PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - Zend - zend_operators.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 1160 1354 85.7 %
Date: 2015-07-31 Functions: 75 85 88.2 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | Zend Engine                                                          |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1998-2015 Zend Technologies Ltd. (http://www.zend.com) |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 2.00 of the Zend license,     |
       8             :    | that is bundled with this package in the file LICENSE, and is        |
       9             :    | available through the world-wide-web at the following url:           |
      10             :    | http://www.zend.com/license/2_00.txt.                                |
      11             :    | If you did not receive a copy of the Zend license and are unable to  |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@zend.com so we can mail you a copy immediately.              |
      14             :    +----------------------------------------------------------------------+
      15             :    | Authors: Andi Gutmans <andi@zend.com>                                |
      16             :    |          Zeev Suraski <zeev@zend.com>                                |
      17             :    +----------------------------------------------------------------------+
      18             : */
      19             : 
      20             : /* $Id$ */
      21             : 
      22             : #include <ctype.h>
      23             : 
      24             : #include "zend.h"
      25             : #include "zend_operators.h"
      26             : #include "zend_variables.h"
      27             : #include "zend_globals.h"
      28             : #include "zend_list.h"
      29             : #include "zend_API.h"
      30             : #include "zend_strtod.h"
      31             : #include "zend_exceptions.h"
      32             : #include "zend_closures.h"
      33             : 
      34             : #if ZEND_USE_TOLOWER_L
      35             : #include <locale.h>
      36             : static _locale_t current_locale = NULL;
      37             : /* this is true global! may lead to strange effects on ZTS, but so may setlocale() */
      38             : #define zend_tolower(c) _tolower_l(c, current_locale)
      39             : #else
      40             : #define zend_tolower(c) tolower(c)
      41             : #endif
      42             : 
      43             : #define TYPE_PAIR(t1,t2) (((t1) << 4) | (t2))
      44             : 
      45             : static const unsigned char tolower_map[256] = {
      46             : 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,
      47             : 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,
      48             : 0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,
      49             : 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,
      50             : 0x40,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f,
      51             : 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x5b,0x5c,0x5d,0x5e,0x5f,
      52             : 0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f,
      53             : 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x7b,0x7c,0x7d,0x7e,0x7f,
      54             : 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,
      55             : 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0x9b,0x9c,0x9d,0x9e,0x9f,
      56             : 0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,
      57             : 0xb0,0xb1,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xbb,0xbc,0xbd,0xbe,0xbf,
      58             : 0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,
      59             : 0xd0,0xd1,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xdb,0xdc,0xdd,0xde,0xdf,
      60             : 0xe0,0xe1,0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xeb,0xec,0xed,0xee,0xef,
      61             : 0xf0,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa,0xfb,0xfc,0xfd,0xfe,0xff
      62             : };
      63             : 
      64             : #define zend_tolower_ascii(c) (tolower_map[(unsigned char)(c)])
      65             : 
      66             : /**
      67             :  * Functions using locale lowercase:
      68             :                 zend_binary_strncasecmp_l
      69             :                 zend_binary_strcasecmp_l
      70             :                 zend_binary_zval_strcasecmp
      71             :                 zend_binary_zval_strncasecmp
      72             :                 string_compare_function_ex
      73             :                 string_case_compare_function
      74             :  * Functions using ascii lowercase:
      75             :                 zend_str_tolower_copy
      76             :                 zend_str_tolower_dup
      77             :                 zend_str_tolower
      78             :                 zend_binary_strcasecmp
      79             :                 zend_binary_strncasecmp
      80             :  */
      81             : 
      82       63646 : ZEND_API int ZEND_FASTCALL zend_atoi(const char *str, int str_len) /* {{{ */
      83             : {
      84             :         int retval;
      85             : 
      86       63646 :         if (!str_len) {
      87       42078 :                 str_len = (int)strlen(str);
      88             :         }
      89       63646 :         retval = ZEND_STRTOL(str, NULL, 0);
      90       63646 :         if (str_len>0) {
      91       42607 :                 switch (str[str_len-1]) {
      92             :                         case 'g':
      93             :                         case 'G':
      94           0 :                                 retval *= 1024;
      95             :                                 /* break intentionally missing */
      96             :                         case 'm':
      97             :                         case 'M':
      98           0 :                                 retval *= 1024;
      99             :                                 /* break intentionally missing */
     100             :                         case 'k':
     101             :                         case 'K':
     102           0 :                                 retval *= 1024;
     103             :                                 break;
     104             :                 }
     105             :         }
     106       63646 :         return retval;
     107             : }
     108             : /* }}} */
     109             : 
     110     1262230 : ZEND_API zend_long ZEND_FASTCALL zend_atol(const char *str, int str_len) /* {{{ */
     111             : {
     112             :         zend_long retval;
     113             : 
     114     1262230 :         if (!str_len) {
     115       20903 :                 str_len = (int)strlen(str);
     116             :         }
     117     1262230 :         retval = ZEND_STRTOL(str, NULL, 0);
     118     1262230 :         if (str_len>0) {
     119     1241327 :                 switch (str[str_len-1]) {
     120             :                         case 'g':
     121             :                         case 'G':
     122           4 :                                 retval *= 1024;
     123             :                                 /* break intentionally missing */
     124             :                         case 'm':
     125             :                         case 'M':
     126       63105 :                                 retval *= 1024;
     127             :                                 /* break intentionally missing */
     128             :                         case 'k':
     129             :                         case 'K':
     130       84155 :                                 retval *= 1024;
     131             :                                 break;
     132             :                 }
     133             :         }
     134     1262230 :         return retval;
     135             : }
     136             : /* }}} */
     137             : 
     138             : static zend_always_inline void zend_unwrap_reference(zval *op) /* {{{ */
     139             : {
     140           7 :         if (Z_REFCOUNT_P(op) == 1) {
     141           0 :                 ZVAL_UNREF(op);
     142             :         } else {
     143             :                 Z_DELREF_P(op);
     144           7 :                 ZVAL_COPY(op, Z_REFVAL_P(op));
     145             :         }
     146             : }
     147             : /* }}} */
     148             : 
     149      203368 : ZEND_API void ZEND_FASTCALL convert_scalar_to_number(zval *op) /* {{{ */
     150             : {
     151             : try_again:
     152      203368 :         switch (Z_TYPE_P(op)) {
     153             :                 case IS_REFERENCE:
     154             :                         zend_unwrap_reference(op);
     155           4 :                         goto try_again;
     156             :                 case IS_STRING:
     157             :                         {
     158             :                                 zend_string *str;
     159             : 
     160      101112 :                                 str = Z_STR_P(op);
     161      202224 :                                 if ((Z_TYPE_INFO_P(op)=is_numeric_string(str->val, str->len, &Z_LVAL_P(op), &Z_DVAL_P(op), 1)) == 0) {
     162          48 :                                         ZVAL_LONG(op, 0);
     163             :                                 }
     164             :                                 zend_string_release(str);
     165      101112 :                                 break;
     166             :                         }
     167             :                 case IS_NULL:
     168             :                 case IS_FALSE:
     169          60 :                         ZVAL_LONG(op, 0);
     170          60 :                         break;
     171             :                 case IS_TRUE:
     172          16 :                         ZVAL_LONG(op, 1);
     173          16 :                         break;
     174             :                 case IS_RESOURCE:
     175             :                         {
     176           5 :                                 zend_long l = Z_RES_HANDLE_P(op);
     177           5 :                                 zval_ptr_dtor(op);
     178           5 :                                 ZVAL_LONG(op, l);
     179             :                         }
     180           5 :                         break;
     181             :                 case IS_OBJECT:
     182           5 :                         convert_to_long_base(op, 10);
     183             :                         break;
     184             :         }
     185      203364 : }
     186             : /* }}} */
     187             : 
     188             : /* {{{ zendi_convert_scalar_to_number */
     189             : #define zendi_convert_scalar_to_number(op, holder, result)                      \
     190             :         if (op==result) {                                                                                               \
     191             :                 if (Z_TYPE_P(op) != IS_LONG) {                                                          \
     192             :                         convert_scalar_to_number(op);                                   \
     193             :                 }                                                                                                                       \
     194             :         } else {                                                                                                                \
     195             :                 switch (Z_TYPE_P(op)) {                                                                         \
     196             :                         case IS_STRING:                                                                                 \
     197             :                                 {                                                                                                       \
     198             :                                         if ((Z_TYPE_INFO(holder)=is_numeric_string(Z_STRVAL_P(op), Z_STRLEN_P(op), &Z_LVAL(holder), &Z_DVAL(holder), 1)) == 0) {        \
     199             :                                                 ZVAL_LONG(&(holder), 0);                                                    \
     200             :                                         }                                                                                                               \
     201             :                                         (op) = &(holder);                                                                           \
     202             :                                         break;                                                                                                  \
     203             :                                 }                                                                                                                       \
     204             :                         case IS_NULL:                                                                                                   \
     205             :                         case IS_FALSE:                                                                                                  \
     206             :                                 ZVAL_LONG(&(holder), 0);                                                                    \
     207             :                                 (op) = &(holder);                                                                                   \
     208             :                                 break;                                                                                                          \
     209             :                         case IS_TRUE:                                                                                                   \
     210             :                                 ZVAL_LONG(&(holder), 1);                                                                    \
     211             :                                 (op) = &(holder);                                                                                   \
     212             :                                 break;                                                                                                          \
     213             :                         case IS_RESOURCE:                                                                                               \
     214             :                                 ZVAL_LONG(&(holder), Z_RES_HANDLE_P(op));                                   \
     215             :                                 (op) = &(holder);                                                                                   \
     216             :                                 break;                                                                                                          \
     217             :                         case IS_OBJECT:                                                                                                 \
     218             :                                 ZVAL_COPY(&(holder), op);                                                                           \
     219             :                                 convert_to_long_base(&(holder), 10);                                                \
     220             :                                 if (Z_TYPE(holder) == IS_LONG) {                                                        \
     221             :                                         (op) = &(holder);                                                                           \
     222             :                                 }                                                                                                                       \
     223             :                                 break;                                                                                                          \
     224             :                 }                                                                                                                                       \
     225             :         }
     226             : 
     227             : /* }}} */
     228             : 
     229             : /* {{{ convert_object_to_type: dst will be either ctype or UNDEF */
     230             : #define convert_object_to_type(op, dst, ctype, conv_func)                                                                       \
     231             :         ZVAL_UNDEF(dst);                                                                                                                                                \
     232             :         if (Z_OBJ_HT_P(op)->cast_object) {                                                                                                           \
     233             :                 if (Z_OBJ_HT_P(op)->cast_object(op, dst, ctype) == FAILURE) {                                \
     234             :                         zend_error(E_RECOVERABLE_ERROR,                                                                                                 \
     235             :                                 "Object of class %s could not be converted to %s", Z_OBJCE_P(op)->name->val,\
     236             :                         zend_get_type_by_const(ctype));                                                                                                 \
     237             :                 }                                                                                                                                                                       \
     238             :         } else if (Z_OBJ_HT_P(op)->get) {                                                                                                            \
     239             :                 zval *newop = Z_OBJ_HT_P(op)->get(op, dst);                                                          \
     240             :                 if (Z_TYPE_P(newop) != IS_OBJECT) {                                                                                                     \
     241             :                         /* for safety - avoid loop */                                                                                                   \
     242             :                         ZVAL_COPY_VALUE(dst, newop);                                                                                                    \
     243             :                         conv_func(dst);                                                                                                                                 \
     244             :                 }                                                                                                                                                                       \
     245             :         }
     246             : 
     247             : /* }}} */
     248             : 
     249             : #define convert_op1_op2_long(op1, op1_lval, op2, op2_lval, op, op_func) \
     250             :         do {                                                                                                                            \
     251             :                 if (UNEXPECTED(Z_TYPE_P(op1) != IS_LONG)) {                                             \
     252             :                         if (Z_ISREF_P(op1)) {                                                                           \
     253             :                                 op1 = Z_REFVAL_P(op1);                                                                  \
     254             :                                 if (Z_TYPE_P(op1) == IS_LONG) {                                                 \
     255             :                                         op1_lval = Z_LVAL_P(op1);                                                       \
     256             :                                         break;                                                                                          \
     257             :                                 }                                                                                                               \
     258             :                         }                                                                                                                       \
     259             :                         ZEND_TRY_BINARY_OP1_OBJECT_OPERATION(op, op_func);                      \
     260             :                         op1_lval = _zval_get_long_func(op1);                                            \
     261             :                 } else {                                                                                                                \
     262             :                         op1_lval = Z_LVAL_P(op1);                                                                       \
     263             :                 }                                                                                                                               \
     264             :         } while (0);                                                                                                            \
     265             :         do {                                                                                                                            \
     266             :                 if (UNEXPECTED(Z_TYPE_P(op2) != IS_LONG)) {                                             \
     267             :                         if (Z_ISREF_P(op2)) {                                                                           \
     268             :                                 op2 = Z_REFVAL_P(op2);                                                                  \
     269             :                                 if (Z_TYPE_P(op2) == IS_LONG) {                                                 \
     270             :                                         op2_lval = Z_LVAL_P(op2);                                                       \
     271             :                                         break;                                                                                          \
     272             :                                 }                                                                                                               \
     273             :                         }                                                                                                                       \
     274             :                         ZEND_TRY_BINARY_OP2_OBJECT_OPERATION(op);                                       \
     275             :                         op2_lval = _zval_get_long_func(op2);                                            \
     276             :                 } else {                                                                                                                \
     277             :                         op2_lval = Z_LVAL_P(op2);                                                                       \
     278             :                 }                                                                                                                               \
     279             :         } while (0);
     280             : 
     281       22059 : ZEND_API void ZEND_FASTCALL convert_to_long(zval *op) /* {{{ */
     282             : {
     283       22059 :         if (Z_TYPE_P(op) != IS_LONG) {
     284        1432 :                 convert_to_long_base(op, 10);
     285             :         }
     286       22059 : }
     287             : /* }}} */
     288             : 
     289        5947 : ZEND_API void ZEND_FASTCALL convert_to_long_base(zval *op, int base) /* {{{ */
     290             : {
     291             :         zend_long tmp;
     292             : 
     293             : try_again:
     294        5947 :         switch (Z_TYPE_P(op)) {
     295             :                 case IS_NULL:
     296             :                 case IS_FALSE:
     297         250 :                         ZVAL_LONG(op, 0);
     298         250 :                         break;
     299             :                 case IS_TRUE:
     300         910 :                         ZVAL_LONG(op, 1);
     301         910 :                         break;
     302             :                 case IS_RESOURCE:
     303          11 :                         tmp = Z_RES_HANDLE_P(op);
     304          11 :                         zval_ptr_dtor(op);
     305          11 :                         ZVAL_LONG(op, tmp);
     306          11 :                         break;
     307             :                 case IS_LONG:
     308        2630 :                         break;
     309             :                 case IS_DOUBLE:
     310        3828 :                         ZVAL_LONG(op, zend_dval_to_lval(Z_DVAL_P(op)));
     311        1914 :                         break;
     312             :                 case IS_STRING:
     313             :                         {
     314         176 :                                 zend_string *str = Z_STR_P(op);
     315             : 
     316         176 :                                 ZVAL_LONG(op, ZEND_STRTOL(str->val, NULL, base));
     317             :                                 zend_string_release(str);
     318             :                         }
     319         176 :                         break;
     320             :                 case IS_ARRAY:
     321          29 :                         tmp = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);
     322          29 :                         zval_ptr_dtor(op);
     323          29 :                         ZVAL_LONG(op, tmp);
     324          29 :                         break;
     325             :                 case IS_OBJECT:
     326             :                         {
     327             :                                 zval dst;
     328             : 
     329          27 :                                 convert_object_to_type(op, &dst, IS_LONG, convert_to_long);
     330             :                                 zval_dtor(op);
     331             : 
     332          27 :                                 if (Z_TYPE(dst) == IS_LONG) {
     333          27 :                                         ZVAL_COPY_VALUE(op, &dst);
     334             :                                 } else {
     335             : 
     336           0 :                                         ZVAL_LONG(op, 1);
     337             :                                 }
     338          27 :                                 return;
     339             :                         }
     340             :                 case IS_REFERENCE:
     341             :                         zend_unwrap_reference(op);
     342           0 :                         goto try_again;
     343             :                 EMPTY_SWITCH_DEFAULT_CASE()
     344             :         }
     345             : }
     346             : /* }}} */
     347             : 
     348        3038 : ZEND_API void ZEND_FASTCALL convert_to_double(zval *op) /* {{{ */
     349             : {
     350             :         double tmp;
     351             : 
     352             : try_again:
     353        3038 :         switch (Z_TYPE_P(op)) {
     354             :                 case IS_NULL:
     355             :                 case IS_FALSE:
     356           9 :                         ZVAL_DOUBLE(op, 0.0);
     357           9 :                         break;
     358             :                 case IS_TRUE:
     359           1 :                         ZVAL_DOUBLE(op, 1.0);
     360           1 :                         break;
     361             :                 case IS_RESOURCE: {
     362           7 :                                 double d = (double) Z_RES_HANDLE_P(op);
     363           7 :                                 zval_ptr_dtor(op);
     364           7 :                                 ZVAL_DOUBLE(op, d);
     365             :                         }
     366           7 :                         break;
     367             :                 case IS_LONG:
     368        1948 :                         ZVAL_DOUBLE(op, (double) Z_LVAL_P(op));
     369        1948 :                         break;
     370             :                 case IS_DOUBLE:
     371        1013 :                         break;
     372             :                 case IS_STRING:
     373             :                         {
     374          48 :                                 zend_string *str = Z_STR_P(op);
     375             : 
     376          48 :                                 ZVAL_DOUBLE(op, zend_strtod(str->val, NULL));
     377             :                                 zend_string_release(str);
     378             :                         }
     379          48 :                         break;
     380             :                 case IS_ARRAY:
     381           8 :                         tmp = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);
     382           8 :                         zval_ptr_dtor(op);
     383           8 :                         ZVAL_DOUBLE(op, tmp);
     384           8 :                         break;
     385             :                 case IS_OBJECT:
     386             :                         {
     387             :                                 zval dst;
     388             : 
     389           4 :                                 convert_object_to_type(op, &dst, IS_DOUBLE, convert_to_double);
     390             :                                 zval_dtor(op);
     391             : 
     392           4 :                                 if (Z_TYPE(dst) == IS_DOUBLE) {
     393           4 :                                         ZVAL_COPY_VALUE(op, &dst);
     394             :                                 } else {
     395           0 :                                         ZVAL_DOUBLE(op, 1.0);
     396             :                                 }
     397           4 :                                 break;
     398             :                         }
     399             :                 case IS_REFERENCE:
     400             :                         zend_unwrap_reference(op);
     401           0 :                         goto try_again;
     402             :                 EMPTY_SWITCH_DEFAULT_CASE()
     403             :         }
     404        3038 : }
     405             : /* }}} */
     406             : 
     407         914 : ZEND_API void ZEND_FASTCALL convert_to_null(zval *op) /* {{{ */
     408             : {
     409         914 :         if (Z_TYPE_P(op) == IS_OBJECT) {
     410           3 :                 if (Z_OBJ_HT_P(op)->cast_object) {
     411             :                         zval org;
     412             : 
     413           3 :                         ZVAL_COPY_VALUE(&org, op);
     414           3 :                         if (Z_OBJ_HT_P(op)->cast_object(&org, op, IS_NULL) == SUCCESS) {
     415             :                                 zval_dtor(&org);
     416           0 :                                 return;
     417             :                         }
     418           3 :                         ZVAL_COPY_VALUE(op, &org);
     419             :                 }
     420             :         }
     421             : 
     422         914 :         zval_ptr_dtor(op);
     423         914 :         ZVAL_NULL(op);
     424             : }
     425             : /* }}} */
     426             : 
     427         591 : ZEND_API void ZEND_FASTCALL convert_to_boolean(zval *op) /* {{{ */
     428             : {
     429             :         int tmp;
     430             : 
     431             : try_again:
     432         591 :         switch (Z_TYPE_P(op)) {
     433             :                 case IS_FALSE:
     434             :                 case IS_TRUE:
     435         210 :                         break;
     436             :                 case IS_NULL:
     437           5 :                         ZVAL_FALSE(op);
     438           5 :                         break;
     439             :                 case IS_RESOURCE: {
     440           7 :                                 zend_long l = (Z_RES_HANDLE_P(op) ? 1 : 0);
     441             : 
     442           7 :                                 zval_ptr_dtor(op);
     443           7 :                                 ZVAL_BOOL(op, l);
     444             :                         }
     445           7 :                         break;
     446             :                 case IS_LONG:
     447         332 :                         ZVAL_BOOL(op, Z_LVAL_P(op) ? 1 : 0);
     448         332 :                         break;
     449             :                 case IS_DOUBLE:
     450           6 :                         ZVAL_BOOL(op, Z_DVAL_P(op) ? 1 : 0);
     451           6 :                         break;
     452             :                 case IS_STRING:
     453             :                         {
     454          19 :                                 zend_string *str = Z_STR_P(op);
     455             : 
     456          43 :                                 if (str->len == 0
     457          41 :                                         || (str->len == 1 && str->val[0] == '0')) {
     458           2 :                                         ZVAL_FALSE(op);
     459             :                                 } else {
     460          17 :                                         ZVAL_TRUE(op);
     461             :                                 }
     462             :                                 zend_string_release(str);
     463             :                         }
     464          19 :                         break;
     465             :                 case IS_ARRAY:
     466           8 :                         tmp = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);
     467           8 :                         zval_ptr_dtor(op);
     468           8 :                         ZVAL_BOOL(op, tmp);
     469           8 :                         break;
     470             :                 case IS_OBJECT:
     471             :                         {
     472             :                                 zval dst;
     473             : 
     474           4 :                                 convert_object_to_type(op, &dst, _IS_BOOL, convert_to_boolean);
     475             :                                 zval_dtor(op);
     476             : 
     477          12 :                                 if (Z_TYPE(dst) == IS_FALSE || Z_TYPE(dst) == IS_TRUE) {
     478           4 :                                         ZVAL_COPY_VALUE(op, &dst);
     479             :                                 } else {
     480           0 :                                         ZVAL_TRUE(op);
     481             :                                 }
     482           4 :                                 break;
     483             :                         }
     484             :                 case IS_REFERENCE:
     485             :                         zend_unwrap_reference(op);
     486           0 :                         goto try_again;
     487             :                 EMPTY_SWITCH_DEFAULT_CASE()
     488             :         }
     489         591 : }
     490             : /* }}} */
     491             : 
     492          13 : ZEND_API void ZEND_FASTCALL _convert_to_cstring(zval *op ZEND_FILE_LINE_DC) /* {{{ */
     493             : {
     494          13 :         _convert_to_string(op ZEND_FILE_LINE_CC);
     495          13 : }
     496             : /* }}} */
     497             : 
     498       60332 : ZEND_API void ZEND_FASTCALL _convert_to_string(zval *op ZEND_FILE_LINE_DC) /* {{{ */
     499             : {
     500             : try_again:
     501       60332 :         switch (Z_TYPE_P(op)) {
     502             :                 case IS_UNDEF:
     503             :                 case IS_NULL:
     504             :                 case IS_FALSE: {
     505        4161 :                         ZVAL_EMPTY_STRING(op);
     506        4161 :                         break;
     507             :                 }
     508             :                 case IS_TRUE:
     509        1564 :                         ZVAL_NEW_STR(op, zend_string_init("1", 1, 0));
     510         782 :                         break;
     511             :                 case IS_STRING:
     512           3 :                         break;
     513             :                 case IS_RESOURCE: {
     514             :                         char buf[sizeof("Resource id #") + MAX_LENGTH_OF_LONG];
     515          43 :                         int len = snprintf(buf, sizeof(buf), "Resource id #" ZEND_LONG_FMT, (zend_long)Z_RES_HANDLE_P(op));
     516          43 :                         zval_ptr_dtor(op);
     517          86 :                         ZVAL_NEW_STR(op, zend_string_init(buf, len, 0));
     518          43 :                         break;
     519             :                 }
     520             :                 case IS_LONG: {
     521       53202 :                         ZVAL_NEW_STR(op, zend_long_to_str(Z_LVAL_P(op)));
     522       53202 :                         break;
     523             :                 }
     524             :                 case IS_DOUBLE: {
     525             :                         zend_string *str;
     526        1928 :                         double dval = Z_DVAL_P(op);
     527             : 
     528        1928 :                         str = zend_strpprintf(0, "%.*G", (int) EG(precision), dval);
     529             :                         /* %G already handles removing trailing zeros from the fractional part, yay */
     530        1928 :                         ZVAL_NEW_STR(op, str);
     531        1928 :                         break;
     532             :                 }
     533             :                 case IS_ARRAY:
     534         168 :                         zend_error(E_NOTICE, "Array to string conversion");
     535         168 :                         zval_ptr_dtor(op);
     536         336 :                         ZVAL_NEW_STR(op, zend_string_init("Array", sizeof("Array")-1, 0));
     537         168 :                         break;
     538             :                 case IS_OBJECT: {
     539             :                         zval dst;
     540             : 
     541          42 :                         convert_object_to_type(op, &dst, IS_STRING, convert_to_string);
     542             :                         zval_dtor(op);
     543             : 
     544          34 :                         if (Z_TYPE(dst) == IS_STRING) {
     545          29 :                                 ZVAL_COPY_VALUE(op, &dst);
     546             :                         } else {
     547          10 :                                 ZVAL_NEW_STR(op, zend_string_init("Object", sizeof("Object")-1, 0));
     548             :                         }
     549          34 :                         break;
     550             :                 }
     551             :                 case IS_REFERENCE:
     552             :                         zend_unwrap_reference(op);
     553           3 :                         goto try_again;
     554             :                 EMPTY_SWITCH_DEFAULT_CASE()
     555             :         }
     556       60321 : }
     557             : /* }}} */
     558             : 
     559         119 : static void convert_scalar_to_array(zval *op) /* {{{ */
     560             : {
     561             :         zval entry;
     562             : 
     563         119 :         ZVAL_COPY_VALUE(&entry, op);
     564             : 
     565         119 :         ZVAL_NEW_ARR(op);
     566         119 :         zend_hash_init(Z_ARRVAL_P(op), 8, NULL, ZVAL_PTR_DTOR, 0);
     567         119 :         zend_hash_index_add_new(Z_ARRVAL_P(op), 0, &entry);
     568         119 : }
     569             : /* }}} */
     570             : 
     571         174 : ZEND_API void ZEND_FASTCALL convert_to_array(zval *op) /* {{{ */
     572             : {
     573             : try_again:
     574         174 :         switch (Z_TYPE_P(op)) {
     575             :                 case IS_ARRAY:
     576          21 :                         break;
     577             : /* OBJECTS_OPTIMIZE */
     578             :                 case IS_OBJECT:
     579          19 :                         if (Z_OBJCE_P(op) == zend_ce_closure) {
     580           3 :                                 convert_scalar_to_array(op);
     581             :                         } else {
     582          16 :                                 if (Z_OBJ_HT_P(op)->get_properties) {
     583          16 :                                         HashTable *obj_ht = Z_OBJ_HT_P(op)->get_properties(op);
     584          16 :                                         if (obj_ht) {
     585             :                                                 zval arr;
     586             : 
     587          23 :                                                 if (!Z_OBJCE_P(op)->default_properties_count && obj_ht == Z_OBJ_P(op)->properties) {
     588             :                                                         /* fast copy */
     589           7 :                                                         if (EXPECTED(Z_OBJ_P(op)->handlers == &std_object_handlers)) {
     590           6 :                                                                 ZVAL_ARR(&arr, obj_ht);
     591           6 :                                                                 if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(op)->properties) & IS_ARRAY_IMMUTABLE))) {
     592           6 :                                                                         GC_REFCOUNT(Z_OBJ_P(op)->properties)++;
     593             :                                                                 }
     594             :                                                         } else {
     595           1 :                                                                 ZVAL_ARR(&arr, zend_array_dup(obj_ht));
     596             :                                                         }
     597             :                                                         zval_dtor(op);
     598           7 :                                                         ZVAL_COPY_VALUE(op, &arr);
     599             :                                                 } else {
     600           9 :                                                         ZVAL_ARR(&arr, zend_array_dup(obj_ht));
     601             :                                                         zval_dtor(op);
     602           9 :                                                         ZVAL_COPY_VALUE(op, &arr);
     603             :                                                 }
     604          16 :                                                 return;
     605             :                                         }
     606             :                                 } else {
     607             :                                         zval dst;
     608           0 :                                         convert_object_to_type(op, &dst, IS_ARRAY, convert_to_array);
     609             : 
     610           0 :                                         if (Z_TYPE(dst) == IS_ARRAY) {
     611             :                                                 zval_dtor(op);
     612           0 :                                                 ZVAL_COPY_VALUE(op, &dst);
     613           0 :                                                 return;
     614             :                                         }
     615             :                                 }
     616             : 
     617             :                                 zval_dtor(op);
     618           0 :                                 array_init(op);
     619             :                         }
     620           3 :                         break;
     621             :                 case IS_NULL:
     622          18 :                         ZVAL_NEW_ARR(op);
     623          18 :                         zend_hash_init(Z_ARRVAL_P(op), 8, NULL, ZVAL_PTR_DTOR, 0);
     624          18 :                         break;
     625             :                 case IS_REFERENCE:
     626             :                         zend_unwrap_reference(op);
     627           0 :                         goto try_again;
     628             :                 default:
     629         116 :                         convert_scalar_to_array(op);
     630             :                         break;
     631             :         }
     632             : }
     633             : /* }}} */
     634             : 
     635         126 : ZEND_API void ZEND_FASTCALL convert_to_object(zval *op) /* {{{ */
     636             : {
     637             : try_again:
     638         126 :         switch (Z_TYPE_P(op)) {
     639             :                 case IS_ARRAY:
     640             :                         {
     641             :                                 zval tmp;
     642          83 :                                 ZVAL_COPY_VALUE(&tmp, op);
     643          83 :                                 SEPARATE_ARRAY(&tmp);
     644          83 :                                 object_and_properties_init(op, zend_standard_class_def, Z_ARR(tmp));
     645          83 :                                 break;
     646             :                         }
     647             :                 case IS_OBJECT:
     648           3 :                         break;
     649             :                 case IS_NULL:
     650           3 :                         object_init(op);
     651           3 :                         break;
     652             :                 case IS_REFERENCE:
     653             :                         zend_unwrap_reference(op);
     654           0 :                         goto try_again;
     655             :                 default: {
     656             :                         zval tmp;
     657          37 :                         ZVAL_COPY_VALUE(&tmp, op);
     658          37 :                         object_init(op);
     659          37 :                         zend_hash_str_add_new(Z_OBJPROP_P(op), "scalar", sizeof("scalar")-1, &tmp);
     660             :                         break;
     661             :                 }
     662             :         }
     663         126 : }
     664             : /* }}} */
     665             : 
     666           0 : ZEND_API void multi_convert_to_long_ex(int argc, ...) /* {{{ */
     667             : {
     668             :         zval *arg;
     669             :         va_list ap;
     670             : 
     671           0 :         va_start(ap, argc);
     672             : 
     673           0 :         while (argc--) {
     674           0 :                 arg = va_arg(ap, zval *);
     675           0 :                 convert_to_long_ex(arg);
     676             :         }
     677             : 
     678           0 :         va_end(ap);
     679           0 : }
     680             : /* }}} */
     681             : 
     682           0 : ZEND_API void multi_convert_to_double_ex(int argc, ...) /* {{{ */
     683             : {
     684             :         zval *arg;
     685             :         va_list ap;
     686             : 
     687           0 :         va_start(ap, argc);
     688             : 
     689           0 :         while (argc--) {
     690           0 :                 arg = va_arg(ap, zval *);
     691           0 :                 convert_to_double_ex(arg);
     692             :         }
     693             : 
     694           0 :         va_end(ap);
     695           0 : }
     696             : /* }}} */
     697             : 
     698           0 : ZEND_API void multi_convert_to_string_ex(int argc, ...) /* {{{ */
     699             : {
     700             :         zval *arg;
     701             :         va_list ap;
     702             : 
     703           0 :         va_start(ap, argc);
     704             : 
     705           0 :         while (argc--) {
     706           0 :                 arg = va_arg(ap, zval *);
     707           0 :                 convert_to_string_ex(arg);
     708             :         }
     709             : 
     710           0 :         va_end(ap);
     711           0 : }
     712             : /* }}} */
     713             : 
     714       33819 : ZEND_API zend_long ZEND_FASTCALL _zval_get_long_func(zval *op) /* {{{ */
     715             : {
     716             : try_again:
     717       33819 :         switch (Z_TYPE_P(op)) {
     718             :                 case IS_NULL:
     719             :                 case IS_FALSE:
     720         774 :                         return 0;
     721             :                 case IS_TRUE:
     722        1998 :                         return 1;
     723             :                 case IS_RESOURCE:
     724          87 :                         return Z_RES_HANDLE_P(op);
     725             :                 case IS_LONG:
     726           1 :                         return Z_LVAL_P(op);
     727             :                 case IS_DOUBLE:
     728        3700 :                         return zend_dval_to_lval(Z_DVAL_P(op));
     729             :                 case IS_STRING:
     730       28248 :                         return ZEND_STRTOL(Z_STRVAL_P(op), NULL, 10);
     731             :                 case IS_ARRAY:
     732         832 :                         return zend_hash_num_elements(Z_ARRVAL_P(op)) ? 1 : 0;
     733             :                 case IS_OBJECT:
     734             :                         {
     735             :                                 zval dst;
     736          24 :                                 convert_object_to_type(op, &dst, IS_LONG, convert_to_long);
     737          24 :                                 if (Z_TYPE(dst) == IS_LONG) {
     738          24 :                                         return Z_LVAL(dst);
     739             :                                 } else {
     740           0 :                                         return 1;
     741             :                                 }
     742             :                         }
     743             :                 case IS_REFERENCE:
     744           5 :                         op = Z_REFVAL_P(op);
     745           5 :                         goto try_again;
     746             :                 EMPTY_SWITCH_DEFAULT_CASE()
     747             :         }
     748           0 :         return 0;
     749             : }
     750             : /* }}} */
     751             : 
     752      205838 : ZEND_API double ZEND_FASTCALL _zval_get_double_func(zval *op) /* {{{ */
     753             : {
     754             : try_again:
     755      205838 :         switch (Z_TYPE_P(op)) {
     756             :                 case IS_NULL:
     757             :                 case IS_FALSE:
     758         135 :                         return 0.0;
     759             :                 case IS_TRUE:
     760         129 :                         return 1.0;
     761             :                 case IS_RESOURCE:
     762          41 :                         return (double) Z_RES_HANDLE_P(op);
     763             :                 case IS_LONG:
     764      204525 :                         return (double) Z_LVAL_P(op);
     765             :                 case IS_DOUBLE:
     766           0 :                         return Z_DVAL_P(op);
     767             :                 case IS_STRING:
     768         614 :                         return zend_strtod(Z_STRVAL_P(op), NULL);
     769             :                 case IS_ARRAY:
     770         371 :                         return zend_hash_num_elements(Z_ARRVAL_P(op)) ? 1.0 : 0.0;
     771             :                 case IS_OBJECT:
     772             :                         {
     773             :                                 zval dst;
     774          11 :                                 convert_object_to_type(op, &dst, IS_DOUBLE, convert_to_double);
     775             : 
     776          11 :                                 if (Z_TYPE(dst) == IS_DOUBLE) {
     777          11 :                                         return Z_DVAL(dst);
     778             :                                 } else {
     779           0 :                                         return 1.0;
     780             :                                 }
     781             :                         }
     782             :                 case IS_REFERENCE:
     783          12 :                         op = Z_REFVAL_P(op);
     784          12 :                         goto try_again;
     785             :                 EMPTY_SWITCH_DEFAULT_CASE()
     786             :         }
     787           0 :         return 0.0;
     788             : }
     789             : /* }}} */
     790             : 
     791     2727458 : ZEND_API zend_string* ZEND_FASTCALL _zval_get_string_func(zval *op) /* {{{ */
     792             : {
     793             : try_again:
     794     2727458 :         switch (Z_TYPE_P(op)) {
     795             :                 case IS_UNDEF:
     796             :                 case IS_NULL:
     797             :                 case IS_FALSE:
     798     1374444 :                         return STR_EMPTY_ALLOC();
     799             :                 case IS_TRUE:
     800        1371 :                         return zend_string_init("1", 1, 0);
     801             :                 case IS_RESOURCE: {
     802             :                         char buf[sizeof("Resource id #") + MAX_LENGTH_OF_LONG];
     803             :                         int len;
     804             : 
     805         637 :                         len = snprintf(buf, sizeof(buf), "Resource id #" ZEND_LONG_FMT, (zend_long)Z_RES_HANDLE_P(op));
     806        1274 :                         return zend_string_init(buf, len, 0);
     807             :                 }
     808             :                 case IS_LONG: {
     809      335589 :                         return zend_long_to_str(Z_LVAL_P(op));
     810             :                 }
     811             :                 case IS_DOUBLE: {
     812        5990 :                         return zend_strpprintf(0, "%.*G", (int) EG(precision), Z_DVAL_P(op));
     813             :                 }
     814             :                 case IS_ARRAY:
     815         762 :                         zend_error(E_NOTICE, "Array to string conversion");
     816         762 :                         return zend_string_init("Array", sizeof("Array")-1, 0);
     817             :                 case IS_OBJECT: {
     818             :                         zval tmp;
     819      103528 :                         if (Z_OBJ_HT_P(op)->cast_object) {
     820      103528 :                                 if (Z_OBJ_HT_P(op)->cast_object(op, &tmp, IS_STRING) == SUCCESS) {
     821      103493 :                                         return Z_STR(tmp);
     822             :                                 }
     823           0 :                         } else if (Z_OBJ_HT_P(op)->get) {
     824           0 :                                 zval *z = Z_OBJ_HT_P(op)->get(op, &tmp);
     825           0 :                                 if (Z_TYPE_P(z) != IS_OBJECT) {
     826           0 :                                         zend_string *str = zval_get_string(z);
     827           0 :                                         zval_ptr_dtor(z);
     828           0 :                                         return str;
     829             :                                 }
     830           0 :                                 zval_ptr_dtor(z);
     831             :                         }
     832          31 :                         zend_error(EG(exception) ? E_ERROR : E_RECOVERABLE_ERROR, "Object of class %s could not be converted to string", Z_OBJCE_P(op)->name->val);
     833          27 :                         return STR_EMPTY_ALLOC();
     834             :                 }
     835             :                 case IS_REFERENCE:
     836      459938 :                         op = Z_REFVAL_P(op);
     837      459938 :                         goto try_again;
     838             :                 case IS_STRING:
     839      890398 :                         return zend_string_copy(Z_STR_P(op));
     840             :                 EMPTY_SWITCH_DEFAULT_CASE()
     841             :         }
     842           0 :         return NULL;
     843             : }
     844             : /* }}} */
     845             : 
     846      822902 : ZEND_API int ZEND_FASTCALL add_function(zval *result, zval *op1, zval *op2) /* {{{ */
     847             : {
     848             :         zval op1_copy, op2_copy;
     849      822902 :         int converted = 0;
     850             : 
     851             :         while (1) {
     852     1646812 :                 switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) {
     853             :                         case TYPE_PAIR(IS_LONG, IS_LONG): {
     854      822566 :                                 zend_long lval = Z_LVAL_P(op1) + Z_LVAL_P(op2);
     855             : 
     856             :                                 /* check for overflow by comparing sign bits */
     857     1645027 :                                 if ((Z_LVAL_P(op1) & LONG_SIGN_MASK) == (Z_LVAL_P(op2) & LONG_SIGN_MASK)
     858     1645016 :                                         && (Z_LVAL_P(op1) & LONG_SIGN_MASK) != (lval & LONG_SIGN_MASK)) {
     859             : 
     860          11 :                                         ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) + (double) Z_LVAL_P(op2));
     861             :                                 } else {
     862      822555 :                                         ZVAL_LONG(result, lval);
     863             :                                 }
     864      822566 :                                 return SUCCESS;
     865             :                         }
     866             : 
     867             :                         case TYPE_PAIR(IS_LONG, IS_DOUBLE):
     868         184 :                                 ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2));
     869         184 :                                 return SUCCESS;
     870             : 
     871             :                         case TYPE_PAIR(IS_DOUBLE, IS_LONG):
     872          62 :                                 ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2)));
     873          62 :                                 return SUCCESS;
     874             : 
     875             :                         case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE):
     876          64 :                                 ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
     877          64 :                                 return SUCCESS;
     878             : 
     879             :                         case TYPE_PAIR(IS_ARRAY, IS_ARRAY):
     880          13 :                                 if ((result == op1) && (result == op2)) {
     881             :                                         /* $a += $a */
     882           1 :                                         return SUCCESS;
     883             :                                 }
     884          12 :                                 if (result != op1) {
     885          11 :                                         ZVAL_DUP(result, op1);
     886             :                                 }
     887          12 :                                 zend_hash_merge(Z_ARRVAL_P(result), Z_ARRVAL_P(op2), zval_add_ref, 0);
     888          12 :                                 return SUCCESS;
     889             : 
     890             :                         default:
     891         517 :                                 if (Z_ISREF_P(op1)) {
     892          23 :                                         op1 = Z_REFVAL_P(op1);
     893         494 :                                 } else if (Z_ISREF_P(op2)) {
     894          18 :                                         op2 = Z_REFVAL_P(op2);
     895         476 :                                 } else if (!converted) {
     896        1401 :                                         ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_ADD, add_function);
     897             : 
     898        1256 :                                         zendi_convert_scalar_to_number(op1, op1_copy, result);
     899        1164 :                                         zendi_convert_scalar_to_number(op2, op2_copy, result);
     900         463 :                                         converted = 1;
     901             :                                 } else {
     902           8 :                                         zend_error(E_EXCEPTION | E_ERROR, "Unsupported operand types");
     903           8 :                                         return FAILURE; /* unknown datatype */
     904             :                                 }
     905             :                 }
     906         504 :         }
     907             : }
     908             : /* }}} */
     909             : 
     910       62754 : ZEND_API int ZEND_FASTCALL sub_function(zval *result, zval *op1, zval *op2) /* {{{ */
     911             : {
     912             :         zval op1_copy, op2_copy;
     913       62754 :         int converted = 0;
     914             : 
     915             :         while (1) {
     916      126002 :                 switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) {
     917             :                         case TYPE_PAIR(IS_LONG, IS_LONG): {
     918       61017 :                                 zend_long lval = Z_LVAL_P(op1) - Z_LVAL_P(op2);
     919             : 
     920             :                                 /* check for overflow by comparing sign bits */
     921       61194 :                                 if ((Z_LVAL_P(op1) & LONG_SIGN_MASK) != (Z_LVAL_P(op2) & LONG_SIGN_MASK)
     922       61187 :                                         && (Z_LVAL_P(op1) & LONG_SIGN_MASK) != (lval & LONG_SIGN_MASK)) {
     923             : 
     924           7 :                                         ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) - (double) Z_LVAL_P(op2));
     925             :                                 } else {
     926       61010 :                                         ZVAL_LONG(result, lval);
     927             :                                 }
     928       61017 :                                 return SUCCESS;
     929             : 
     930             :                         }
     931             :                         case TYPE_PAIR(IS_LONG, IS_DOUBLE):
     932        1644 :                                 ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) - Z_DVAL_P(op2));
     933        1644 :                                 return SUCCESS;
     934             : 
     935             :                         case TYPE_PAIR(IS_DOUBLE, IS_LONG):
     936          45 :                                 ZVAL_DOUBLE(result, Z_DVAL_P(op1) - ((double)Z_LVAL_P(op2)));
     937          45 :                                 return SUCCESS;
     938             : 
     939             :                         case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE):
     940          38 :                                 ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
     941          38 :                                 return SUCCESS;
     942             : 
     943             :                         default:
     944         257 :                                 if (Z_ISREF_P(op1)) {
     945           8 :                                         op1 = Z_REFVAL_P(op1);
     946         249 :                                 } else if (Z_ISREF_P(op2)) {
     947           7 :                                         op2 = Z_REFVAL_P(op2);
     948         242 :                                 } else if (!converted) {
     949         711 :                                         ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_SUB, sub_function);
     950             : 
     951         677 :                                         zendi_convert_scalar_to_number(op1, op1_copy, result);
     952         678 :                                         zendi_convert_scalar_to_number(op2, op2_copy, result);
     953         232 :                                         converted = 1;
     954             :                                 } else {
     955           4 :                                         zend_error(E_EXCEPTION | E_ERROR, "Unsupported operand types");
     956           2 :                                         return FAILURE; /* unknown datatype */
     957             :                                 }
     958             :                 }
     959         247 :         }
     960             : }
     961             : /* }}} */
     962             : 
     963         373 : ZEND_API int ZEND_FASTCALL mul_function(zval *result, zval *op1, zval *op2) /* {{{ */
     964             : {
     965             :         zval op1_copy, op2_copy;
     966         373 :         int converted = 0;
     967             : 
     968             :         while (1) {
     969        1208 :                 switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) {
     970             :                         case TYPE_PAIR(IS_LONG, IS_LONG): {
     971             :                                 zend_long overflow;
     972             : 
     973         222 :                                 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1),Z_LVAL_P(op2), Z_LVAL_P(result),Z_DVAL_P(result),overflow);
     974         222 :                                 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
     975         222 :                                 return SUCCESS;
     976             : 
     977             :                         }
     978             :                         case TYPE_PAIR(IS_LONG, IS_DOUBLE):
     979          45 :                                 ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) * Z_DVAL_P(op2));
     980          45 :                                 return SUCCESS;
     981             : 
     982             :                         case TYPE_PAIR(IS_DOUBLE, IS_LONG):
     983          61 :                                 ZVAL_DOUBLE(result, Z_DVAL_P(op1) * ((double)Z_LVAL_P(op2)));
     984          61 :                                 return SUCCESS;
     985             : 
     986             :                         case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE):
     987          39 :                                 ZVAL_DOUBLE(result, Z_DVAL_P(op1) * Z_DVAL_P(op2));
     988          39 :                                 return SUCCESS;
     989             : 
     990             :                         default:
     991         237 :                                 if (Z_ISREF_P(op1)) {
     992           4 :                                         op1 = Z_REFVAL_P(op1);
     993         233 :                                 } else if (Z_ISREF_P(op2)) {
     994           4 :                                         op2 = Z_REFVAL_P(op2);
     995         229 :                                 } else if (!converted) {
     996         678 :                                         ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_MUL, mul_function);
     997             : 
     998         665 :                                         zendi_convert_scalar_to_number(op1, op1_copy, result);
     999         644 :                                         zendi_convert_scalar_to_number(op2, op2_copy, result);
    1000         223 :                                         converted = 1;
    1001             :                                 } else {
    1002           2 :                                         zend_error(E_EXCEPTION | E_ERROR, "Unsupported operand types");
    1003           2 :                                         return FAILURE; /* unknown datatype */
    1004             :                                 }
    1005             :                 }
    1006         231 :         }
    1007             : }
    1008             : /* }}} */
    1009             : 
    1010        2229 : ZEND_API int ZEND_FASTCALL pow_function(zval *result, zval *op1, zval *op2) /* {{{ */
    1011             : {
    1012             :         zval op1_copy, op2_copy;
    1013        2229 :         int converted = 0;
    1014             : 
    1015             :         while (1) {
    1016        4598 :                 switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) {
    1017             :                         case TYPE_PAIR(IS_LONG, IS_LONG):
    1018        1514 :                                 if (Z_LVAL_P(op2) >= 0) {
    1019         831 :                                         zend_long l1 = 1, l2 = Z_LVAL_P(op1), i = Z_LVAL_P(op2);
    1020             : 
    1021         831 :                                         if (i == 0) {
    1022          26 :                                                 ZVAL_LONG(result, 1L);
    1023          26 :                                                 return SUCCESS;
    1024         805 :                                         } else if (l2 == 0) {
    1025          14 :                                                 ZVAL_LONG(result, 0);
    1026          14 :                                                 return SUCCESS;
    1027             :                                         }
    1028             : 
    1029        6653 :                                         while (i >= 1) {
    1030             :                                                 zend_long overflow;
    1031        5161 :                                                 double dval = 0.0;
    1032             : 
    1033        5161 :                                                 if (i % 2) {
    1034        2004 :                                                         --i;
    1035        2004 :                                                         ZEND_SIGNED_MULTIPLY_LONG(l1, l2, l1, dval, overflow);
    1036        2004 :                                                         if (overflow) {
    1037          17 :                                                                 ZVAL_DOUBLE(result, dval * pow(l2, i));
    1038          17 :                                                                 return SUCCESS;
    1039             :                                                         }
    1040             :                                                 } else {
    1041        3157 :                                                         i /= 2;
    1042        3157 :                                                         ZEND_SIGNED_MULTIPLY_LONG(l2, l2, l2, dval, overflow);
    1043        3157 :                                                         if (overflow) {
    1044          73 :                                                                 ZVAL_DOUBLE(result, (double)l1 * pow(dval, i));
    1045          73 :                                                                 return SUCCESS;
    1046             :                                                         }
    1047             :                                                 }
    1048             :                                         }
    1049             :                                         /* i == 0 */
    1050         701 :                                         ZVAL_LONG(result, l1);
    1051             :                                 } else {
    1052         683 :                                         ZVAL_DOUBLE(result, pow((double)Z_LVAL_P(op1), (double)Z_LVAL_P(op2)));
    1053             :                                 }
    1054        1384 :                                 return SUCCESS;
    1055             : 
    1056             :                         case TYPE_PAIR(IS_LONG, IS_DOUBLE):
    1057         501 :                                 ZVAL_DOUBLE(result, pow((double)Z_LVAL_P(op1), Z_DVAL_P(op2)));
    1058         501 :                                 return SUCCESS;
    1059             : 
    1060             :                         case TYPE_PAIR(IS_DOUBLE, IS_LONG):
    1061         144 :                                 ZVAL_DOUBLE(result, pow(Z_DVAL_P(op1), (double)Z_LVAL_P(op2)));
    1062         144 :                                 return SUCCESS;
    1063             : 
    1064             :                         case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE):
    1065          65 :                                 ZVAL_DOUBLE(result, pow(Z_DVAL_P(op1), Z_DVAL_P(op2)));
    1066          65 :                                 return SUCCESS;
    1067             : 
    1068             :                         default:
    1069          75 :                                 if (Z_ISREF_P(op1)) {
    1070           0 :                                         op1 = Z_REFVAL_P(op1);
    1071          75 :                                 } else if (Z_ISREF_P(op2)) {
    1072           1 :                                         op2 = Z_REFVAL_P(op2);
    1073          74 :                                 } else if (!converted) {
    1074         220 :                                         ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_POW, pow_function);
    1075             : 
    1076          71 :                                         if (Z_TYPE_P(op1) == IS_ARRAY) {
    1077           1 :                                                 ZVAL_LONG(result, 0);
    1078           1 :                                                 return SUCCESS;
    1079             :                                         } else {
    1080         185 :                                                 zendi_convert_scalar_to_number(op1, op1_copy, result);
    1081             :                                         }
    1082          70 :                                         if (Z_TYPE_P(op2) == IS_ARRAY) {
    1083           1 :                                                 ZVAL_LONG(result, 1L);
    1084           1 :                                                 return SUCCESS;
    1085             :                                         } else {
    1086         144 :                                                 zendi_convert_scalar_to_number(op2, op2_copy, result);
    1087             :                                         }
    1088          69 :                                         converted = 1;
    1089             :                                 } else {
    1090           0 :                                         zend_error(E_EXCEPTION | E_ERROR, "Unsupported operand types");
    1091           0 :                                         return FAILURE;
    1092             :                                 }
    1093             :                 }
    1094          70 :         }
    1095             : }
    1096             : /* }}} */
    1097             : 
    1098      124847 : ZEND_API int ZEND_FASTCALL div_function(zval *result, zval *op1, zval *op2) /* {{{ */
    1099             : {
    1100             :         zval op1_copy, op2_copy;
    1101      124847 :         int converted = 0;
    1102             : 
    1103             :         while (1) {
    1104      250114 :                 switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) {
    1105             :                         case TYPE_PAIR(IS_LONG, IS_LONG):
    1106      116878 :                                 if (Z_LVAL_P(op2) == 0) {
    1107          43 :                                         zend_error(E_WARNING, "Division by zero");
    1108          43 :                                         ZVAL_DOUBLE(result, ((double) Z_LVAL_P(op1) / (double) Z_LVAL_P(op2)));
    1109          43 :                                         return SUCCESS;
    1110      116835 :                                 } else if (Z_LVAL_P(op2) == -1 && Z_LVAL_P(op1) == ZEND_LONG_MIN) {
    1111             :                                         /* Prevent overflow error/crash */
    1112           1 :                                         ZVAL_DOUBLE(result, (double) ZEND_LONG_MIN / -1);
    1113           1 :                                         return SUCCESS;
    1114             :                                 }
    1115      116834 :                                 if (Z_LVAL_P(op1) % Z_LVAL_P(op2) == 0) { /* integer */
    1116       78025 :                                         ZVAL_LONG(result, Z_LVAL_P(op1) / Z_LVAL_P(op2));
    1117             :                                 } else {
    1118       38809 :                                         ZVAL_DOUBLE(result, ((double) Z_LVAL_P(op1)) / Z_LVAL_P(op2));
    1119             :                                 }
    1120      116834 :                                 return SUCCESS;
    1121             : 
    1122             :                         case TYPE_PAIR(IS_DOUBLE, IS_LONG):
    1123        7836 :                                 if (Z_LVAL_P(op2) == 0) {
    1124          17 :                                         zend_error(E_WARNING, "Division by zero");
    1125             :                                 }
    1126        7836 :                                 ZVAL_DOUBLE(result, Z_DVAL_P(op1) / (double)Z_LVAL_P(op2));
    1127        7836 :                                 return SUCCESS;
    1128             : 
    1129             :                         case TYPE_PAIR(IS_LONG, IS_DOUBLE):
    1130          66 :                                 if (Z_DVAL_P(op2) == 0) {
    1131           0 :                                         zend_error(E_WARNING, "Division by zero");
    1132             :                                 }
    1133          66 :                                 ZVAL_DOUBLE(result, (double)Z_LVAL_P(op1) / Z_DVAL_P(op2));
    1134          66 :                                 return SUCCESS;
    1135             : 
    1136             :                         case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE):
    1137          61 :                                 if (Z_DVAL_P(op2) == 0) {
    1138           0 :                                         zend_error(E_WARNING, "Division by zero");
    1139             :                                 }
    1140          61 :                                 ZVAL_DOUBLE(result, Z_DVAL_P(op1) / Z_DVAL_P(op2));
    1141          61 :                                 return SUCCESS;
    1142             : 
    1143             :                         default:
    1144         216 :                                 if (Z_ISREF_P(op1)) {
    1145           0 :                                         op1 = Z_REFVAL_P(op1);
    1146         216 :                                 } else if (Z_ISREF_P(op2)) {
    1147           7 :                                         op2 = Z_REFVAL_P(op2);
    1148         209 :                                 } else if (!converted) {
    1149         618 :                                         ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_DIV, div_function);
    1150             : 
    1151         605 :                                         zendi_convert_scalar_to_number(op1, op1_copy, result);
    1152         603 :                                         zendi_convert_scalar_to_number(op2, op2_copy, result);
    1153         203 :                                         converted = 1;
    1154             :                                 } else {
    1155           2 :                                         zend_error(E_EXCEPTION | E_ERROR, "Unsupported operand types");
    1156           2 :                                         return FAILURE; /* unknown datatype */
    1157             :                                 }
    1158             :                 }
    1159         210 :         }
    1160             : }
    1161             : /* }}} */
    1162             : 
    1163         349 : ZEND_API int ZEND_FASTCALL mod_function(zval *result, zval *op1, zval *op2) /* {{{ */
    1164             : {
    1165             :         zend_long op1_lval, op2_lval;
    1166             : 
    1167        2313 :         convert_op1_op2_long(op1, op1_lval, op2, op2_lval, ZEND_MOD, mod_function);
    1168             : 
    1169         345 :         if (op1 == result) {
    1170             :                 zval_dtor(result);
    1171             :         }
    1172             : 
    1173         345 :         if (op2_lval == 0) {
    1174             :                 /* modulus by zero */
    1175          92 :                 if (EG(current_execute_data) && !CG(in_compilation)) {
    1176          46 :                         zend_throw_exception_ex(NULL, 0, "Division by zero");
    1177             :                 } else {
    1178           0 :                         zend_error_noreturn(E_ERROR, "Division by zero");
    1179             :                 }
    1180          46 :                 ZVAL_UNDEF(result);
    1181          46 :                 return FAILURE;
    1182             :         }
    1183             : 
    1184         299 :         if (op2_lval == -1) {
    1185             :                 /* Prevent overflow error/crash if op1==LONG_MIN */
    1186           6 :                 ZVAL_LONG(result, 0);
    1187           6 :                 return SUCCESS;
    1188             :         }
    1189             : 
    1190         293 :         ZVAL_LONG(result, op1_lval % op2_lval);
    1191         293 :         return SUCCESS;
    1192             : }
    1193             : /* }}} */
    1194             : 
    1195           2 : ZEND_API int ZEND_FASTCALL boolean_xor_function(zval *result, zval *op1, zval *op2) /* {{{ */
    1196             : {
    1197             :         int op1_val, op2_val;
    1198             : 
    1199             :         do {
    1200           2 :                 if (Z_TYPE_P(op1) == IS_FALSE) {
    1201           0 :                         op1_val = 0;
    1202           2 :                 } else if (EXPECTED(Z_TYPE_P(op1) == IS_TRUE)) {
    1203           0 :                         op1_val = 1;
    1204             :                 } else {
    1205           2 :                         if (Z_ISREF_P(op1)) {
    1206           0 :                                 op1 = Z_REFVAL_P(op1);
    1207           0 :                                 if (Z_TYPE_P(op1) == IS_FALSE) {
    1208           0 :                                         op1_val = 0;
    1209           0 :                                         break;
    1210           0 :                                 } else if (EXPECTED(Z_TYPE_P(op1) == IS_TRUE)) {
    1211           0 :                                         op1_val = 1;
    1212           0 :                                         break;
    1213             :                                 }
    1214             :                         }
    1215           4 :                         ZEND_TRY_BINARY_OP1_OBJECT_OPERATION(ZEND_BOOL_XOR, boolean_xor_function);
    1216           2 :                         op1_val = zval_is_true(op1);
    1217             :                 }
    1218             :         } while (0);
    1219             :         do {
    1220           2 :                 if (Z_TYPE_P(op2) == IS_FALSE) {
    1221           0 :                         op2_val = 0;
    1222           2 :                 } else if (EXPECTED(Z_TYPE_P(op2) == IS_TRUE)) {
    1223           0 :                         op2_val = 1;
    1224             :                 } else {
    1225           2 :                         if (Z_ISREF_P(op2)) {
    1226           0 :                                 op2 = Z_REFVAL_P(op2);
    1227           0 :                                 if (Z_TYPE_P(op2) == IS_FALSE) {
    1228           0 :                                         op2_val = 0;
    1229           0 :                                         break;
    1230           0 :                                 } else if (EXPECTED(Z_TYPE_P(op2) == IS_TRUE)) {
    1231           0 :                                         op2_val = 1;
    1232           0 :                                         break;
    1233             :                                 }
    1234             :                         }
    1235           2 :                         ZEND_TRY_BINARY_OP2_OBJECT_OPERATION(ZEND_BOOL_XOR);
    1236           2 :                         op2_val = zval_is_true(op2);
    1237             :                 }
    1238             :         } while (0);
    1239             : 
    1240           2 :         ZVAL_BOOL(result, op1_val ^ op2_val);
    1241           2 :         return SUCCESS;
    1242             : }
    1243             : /* }}} */
    1244             : 
    1245         220 : ZEND_API int ZEND_FASTCALL boolean_not_function(zval *result, zval *op1) /* {{{ */
    1246             : {
    1247         220 :         if (Z_TYPE_P(op1) < IS_TRUE) {
    1248           9 :                 ZVAL_TRUE(result);
    1249         211 :         } else if (EXPECTED(Z_TYPE_P(op1) == IS_TRUE)) {
    1250         177 :                 ZVAL_FALSE(result);
    1251             :         } else {
    1252          34 :                 if (Z_ISREF_P(op1)) {
    1253           0 :                         op1 = Z_REFVAL_P(op1);
    1254           0 :                         if (Z_TYPE_P(op1) < IS_TRUE) {
    1255           0 :                                 ZVAL_TRUE(result);
    1256           0 :                                 return SUCCESS;
    1257           0 :                         } else if (EXPECTED(Z_TYPE_P(op1) == IS_TRUE)) {
    1258           0 :                                 ZVAL_FALSE(result);
    1259           0 :                                 return SUCCESS;
    1260             :                         }
    1261             :                 }
    1262          34 :                 ZEND_TRY_UNARY_OBJECT_OPERATION(ZEND_BOOL_NOT);
    1263             : 
    1264          34 :                 ZVAL_BOOL(result, !zval_is_true(op1));
    1265             :         }
    1266         220 :         return SUCCESS;
    1267             : }
    1268             : /* }}} */
    1269             : 
    1270         118 : ZEND_API int ZEND_FASTCALL bitwise_not_function(zval *result, zval *op1) /* {{{ */
    1271             : {
    1272             : try_again:
    1273         118 :         switch (Z_TYPE_P(op1)) {
    1274             :                 case IS_LONG:
    1275          97 :                         ZVAL_LONG(result, ~Z_LVAL_P(op1));
    1276          97 :                         return SUCCESS;
    1277             :                 case IS_DOUBLE:
    1278           6 :                         ZVAL_LONG(result, ~zend_dval_to_lval(Z_DVAL_P(op1)));
    1279           3 :                         return SUCCESS;
    1280             :                 case IS_STRING: {
    1281             :                         size_t i;
    1282             : 
    1283          15 :                         if (Z_STRLEN_P(op1) == 1) {
    1284           1 :                                 zend_uchar not = (zend_uchar) ~*Z_STRVAL_P(op1);
    1285           1 :                                 if (CG(one_char_string)[not]) {
    1286           0 :                                         ZVAL_INTERNED_STR(result, CG(one_char_string)[not]);
    1287             :                                 } else {
    1288           2 :                                         ZVAL_NEW_STR(result, zend_string_init((char *) &not, 1, 0));
    1289             :                                 }
    1290             :                         } else {
    1291          28 :                                 ZVAL_NEW_STR(result, zend_string_alloc(Z_STRLEN_P(op1), 0));
    1292          81 :                                 for (i = 0; i < Z_STRLEN_P(op1); i++) {
    1293          67 :                                         Z_STRVAL_P(result)[i] = ~Z_STRVAL_P(op1)[i];
    1294             :                                 }
    1295          14 :                                 Z_STRVAL_P(result)[i] = 0;
    1296             :                         }
    1297          15 :                         return SUCCESS;
    1298             :                 }
    1299             :                 case IS_REFERENCE:
    1300           0 :                         op1 = Z_REFVAL_P(op1);
    1301           0 :                         goto try_again;
    1302             :                 default:
    1303           3 :                         ZEND_TRY_UNARY_OBJECT_OPERATION(ZEND_BW_NOT);
    1304             : 
    1305           2 :                         zend_error(E_EXCEPTION | E_ERROR, "Unsupported operand types");
    1306           2 :                         return FAILURE;
    1307             :         }
    1308             : }
    1309             : /* }}} */
    1310             : 
    1311      454346 : ZEND_API int ZEND_FASTCALL bitwise_or_function(zval *result, zval *op1, zval *op2) /* {{{ */
    1312             : {
    1313             :         zend_long op1_lval, op2_lval;
    1314             : 
    1315      908469 :         if (EXPECTED(Z_TYPE_P(op1) == IS_LONG) && EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
    1316      454103 :                 ZVAL_LONG(result, Z_LVAL_P(op1) | Z_LVAL_P(op2));
    1317      454103 :                 return SUCCESS;
    1318             :         }
    1319             : 
    1320         243 :         ZVAL_DEREF(op1);
    1321         243 :         ZVAL_DEREF(op2);
    1322             : 
    1323         446 :         if (Z_TYPE_P(op1) == IS_STRING && EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
    1324             :                 zval *longer, *shorter;
    1325             :                 zend_string *str;
    1326             :                 size_t i;
    1327             : 
    1328         200 :                 if (EXPECTED(Z_STRLEN_P(op1) >= Z_STRLEN_P(op2))) {
    1329         117 :                         if (EXPECTED(Z_STRLEN_P(op1) == Z_STRLEN_P(op2)) && Z_STRLEN_P(op1) == 1) {
    1330           1 :                                 zend_uchar or = (zend_uchar) (*Z_STRVAL_P(op1) | *Z_STRVAL_P(op2));
    1331           1 :                                 if (CG(one_char_string)[or]) {
    1332           0 :                                         ZVAL_INTERNED_STR(result, CG(one_char_string)[or]);
    1333             :                                 } else {
    1334           2 :                                         ZVAL_NEW_STR(result, zend_string_init((char *) &or, 1, 0));
    1335             :                                 }
    1336           1 :                                 return SUCCESS;
    1337             :                         }
    1338         116 :                         longer = op1;
    1339         116 :                         shorter = op2;
    1340             :                 } else {
    1341          83 :                         longer = op2;
    1342          83 :                         shorter = op1;
    1343             :                 }
    1344             : 
    1345         398 :                 str = zend_string_alloc(Z_STRLEN_P(longer), 0);
    1346         886 :                 for (i = 0; i < Z_STRLEN_P(shorter); i++) {
    1347         687 :                         str->val[i] = Z_STRVAL_P(longer)[i] | Z_STRVAL_P(shorter)[i];
    1348             :                 }
    1349         199 :                 memcpy(str->val + i, Z_STRVAL_P(longer) + i, Z_STRLEN_P(longer) - i + 1);
    1350         199 :                 if (result==op1) {
    1351           1 :                         zend_string_release(Z_STR_P(result));
    1352             :                 }
    1353         199 :                 ZVAL_NEW_STR(result, str);
    1354         199 :                 return SUCCESS;
    1355             :         }
    1356             : 
    1357          43 :         if (UNEXPECTED(Z_TYPE_P(op1) != IS_LONG)) {
    1358          46 :                 ZEND_TRY_BINARY_OP1_OBJECT_OPERATION(ZEND_BW_OR, bitwise_or_function);
    1359          21 :                 op1_lval = _zval_get_long_func(op1);
    1360             :         } else {
    1361          20 :                 op1_lval = Z_LVAL_P(op1);
    1362             :         }
    1363          41 :         if (UNEXPECTED(Z_TYPE_P(op2) != IS_LONG)) {
    1364          20 :                 ZEND_TRY_BINARY_OP2_OBJECT_OPERATION(ZEND_BW_OR);
    1365          19 :                 op2_lval = _zval_get_long_func(op2);
    1366             :         } else {
    1367          21 :                 op2_lval = Z_LVAL_P(op2);
    1368             :         }
    1369             : 
    1370          40 :         if (op1 == result) {
    1371             :                 zval_dtor(result);
    1372             :         }
    1373          40 :         ZVAL_LONG(result, op1_lval | op2_lval);
    1374          40 :         return SUCCESS;
    1375             : }
    1376             : /* }}} */
    1377             : 
    1378      359317 : ZEND_API int ZEND_FASTCALL bitwise_and_function(zval *result, zval *op1, zval *op2) /* {{{ */
    1379             : {
    1380             :         zend_long op1_lval, op2_lval;
    1381             : 
    1382      718398 :         if (EXPECTED(Z_TYPE_P(op1) == IS_LONG) && EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
    1383      359002 :                 ZVAL_LONG(result, Z_LVAL_P(op1) & Z_LVAL_P(op2));
    1384      359002 :                 return SUCCESS;
    1385             :         }
    1386             : 
    1387         315 :         ZVAL_DEREF(op1);
    1388         315 :         ZVAL_DEREF(op2);
    1389             : 
    1390         519 :         if (Z_TYPE_P(op1) == IS_STRING && Z_TYPE_P(op2) == IS_STRING) {
    1391             :                 zval *longer, *shorter;
    1392             :                 zend_string *str;
    1393             :                 size_t i;
    1394             : 
    1395         201 :                 if (EXPECTED(Z_STRLEN_P(op1) >= Z_STRLEN_P(op2))) {
    1396         117 :                         if (EXPECTED(Z_STRLEN_P(op1) == Z_STRLEN_P(op2)) && Z_STRLEN_P(op1) == 1) {
    1397           1 :                                 zend_uchar and = (zend_uchar) (*Z_STRVAL_P(op1) & *Z_STRVAL_P(op2));
    1398           1 :                                 if (CG(one_char_string)[and]) {
    1399           0 :                                         ZVAL_INTERNED_STR(result, CG(one_char_string)[and]);
    1400             :                                 } else {
    1401           2 :                                         ZVAL_NEW_STR(result, zend_string_init((char *) &and, 1, 0));
    1402             :                                 }
    1403           1 :                                 return SUCCESS;
    1404             :                         }
    1405         116 :                         longer = op1;
    1406         116 :                         shorter = op2;
    1407             :                 } else {
    1408          84 :                         longer = op2;
    1409          84 :                         shorter = op1;
    1410             :                 }
    1411             : 
    1412         400 :                 str = zend_string_alloc(Z_STRLEN_P(shorter), 0);
    1413         886 :                 for (i = 0; i < Z_STRLEN_P(shorter); i++) {
    1414         686 :                         str->val[i] = Z_STRVAL_P(shorter)[i] & Z_STRVAL_P(longer)[i];
    1415             :                 }
    1416         200 :                 str->val[i] = 0;
    1417         200 :                 if (result==op1) {
    1418           1 :                         zend_string_release(Z_STR_P(result));
    1419             :                 }
    1420         200 :                 ZVAL_NEW_STR(result, str);
    1421         200 :                 return SUCCESS;
    1422             :         }
    1423             : 
    1424         114 :         if (UNEXPECTED(Z_TYPE_P(op1) != IS_LONG)) {
    1425          70 :                 ZEND_TRY_BINARY_OP1_OBJECT_OPERATION(ZEND_BW_AND, bitwise_and_function);
    1426          33 :                 op1_lval = _zval_get_long_func(op1);
    1427             :         } else {
    1428          79 :                 op1_lval = Z_LVAL_P(op1);
    1429             :         }
    1430         112 :         if (UNEXPECTED(Z_TYPE_P(op2) != IS_LONG)) {
    1431          25 :                 ZEND_TRY_BINARY_OP2_OBJECT_OPERATION(ZEND_BW_AND);
    1432          24 :                 op2_lval = _zval_get_long_func(op2);
    1433             :         } else {
    1434          87 :                 op2_lval = Z_LVAL_P(op2);
    1435             :         }
    1436             : 
    1437         111 :         if (op1 == result) {
    1438             :                 zval_dtor(result);
    1439             :         }
    1440         111 :         ZVAL_LONG(result, op1_lval & op2_lval);
    1441         111 :         return SUCCESS;
    1442             : }
    1443             : /* }}} */
    1444             : 
    1445         491 : ZEND_API int ZEND_FASTCALL bitwise_xor_function(zval *result, zval *op1, zval *op2) /* {{{ */
    1446             : {
    1447             :         zend_long op1_lval, op2_lval;
    1448             : 
    1449         753 :         if (EXPECTED(Z_TYPE_P(op1) == IS_LONG) && EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
    1450         243 :                 ZVAL_LONG(result, Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
    1451         243 :                 return SUCCESS;
    1452             :         }
    1453             : 
    1454         248 :         ZVAL_DEREF(op1);
    1455         248 :         ZVAL_DEREF(op2);
    1456             : 
    1457         453 :         if (Z_TYPE_P(op1) == IS_STRING && Z_TYPE_P(op2) == IS_STRING) {
    1458             :                 zval *longer, *shorter;
    1459             :                 zend_string *str;
    1460             :                 size_t i;
    1461             : 
    1462         202 :                 if (EXPECTED(Z_STRLEN_P(op1) >= Z_STRLEN_P(op2))) {
    1463         118 :                         if (EXPECTED(Z_STRLEN_P(op1) == Z_STRLEN_P(op2)) && Z_STRLEN_P(op1) == 1) {
    1464           1 :                                 zend_uchar xor = (zend_uchar) (*Z_STRVAL_P(op1) ^ *Z_STRVAL_P(op2));
    1465           1 :                                 if (CG(one_char_string)[xor]) {
    1466           0 :                                         ZVAL_INTERNED_STR(result, CG(one_char_string)[xor]);
    1467             :                                 } else {
    1468           2 :                                         ZVAL_NEW_STR(result, zend_string_init((char *) &xor, 1, 0));
    1469             :                                 }
    1470           1 :                                 return SUCCESS;
    1471             :                         }
    1472         117 :                         longer = op1;
    1473         117 :                         shorter = op2;
    1474             :                 } else {
    1475          84 :                         longer = op2;
    1476          84 :                         shorter = op1;
    1477             :                 }
    1478             : 
    1479         402 :                 str = zend_string_alloc(Z_STRLEN_P(shorter), 0);
    1480         890 :                 for (i = 0; i < Z_STRLEN_P(shorter); i++) {
    1481         689 :                         str->val[i] = Z_STRVAL_P(shorter)[i] ^ Z_STRVAL_P(longer)[i];
    1482             :                 }
    1483         201 :                 str->val[i] = 0;
    1484         201 :                 if (result==op1) {
    1485           1 :                         zend_string_release(Z_STR_P(result));
    1486             :                 }
    1487         201 :                 ZVAL_NEW_STR(result, str);
    1488         201 :                 return SUCCESS;
    1489             :         }
    1490             : 
    1491          46 :         if (UNEXPECTED(Z_TYPE_P(op1) != IS_LONG)) {
    1492          54 :                 ZEND_TRY_BINARY_OP1_OBJECT_OPERATION(ZEND_BW_XOR, bitwise_xor_function);
    1493          25 :                 op1_lval = _zval_get_long_func(op1);
    1494             :         } else {
    1495          19 :                 op1_lval = Z_LVAL_P(op1);
    1496             :         }
    1497          44 :         if (UNEXPECTED(Z_TYPE_P(op2) != IS_LONG)) {
    1498          23 :                 ZEND_TRY_BINARY_OP2_OBJECT_OPERATION(ZEND_BW_XOR);
    1499          22 :                 op2_lval = _zval_get_long_func(op2);
    1500             :         } else {
    1501          21 :                 op2_lval = Z_LVAL_P(op2);
    1502             :         }
    1503             : 
    1504          43 :         if (op1 == result) {
    1505             :                 zval_dtor(result);
    1506             :         }
    1507          43 :         ZVAL_LONG(result, op1_lval ^ op2_lval);
    1508          43 :         return SUCCESS;
    1509             : }
    1510             : /* }}} */
    1511             : 
    1512        4623 : ZEND_API int ZEND_FASTCALL shift_left_function(zval *result, zval *op1, zval *op2) /* {{{ */
    1513             : {
    1514             :         zend_long op1_lval, op2_lval;
    1515             : 
    1516       12360 :         convert_op1_op2_long(op1, op1_lval, op2, op2_lval, ZEND_SL, shift_left_function);
    1517             : 
    1518        3618 :         if (op1 == result) {
    1519             :                 zval_dtor(result);
    1520             :         }
    1521             : 
    1522             :         /* prevent wrapping quirkiness on some processors where << 64 + x == << x */
    1523        3618 :         if (UNEXPECTED((zend_ulong)op2_lval >= SIZEOF_ZEND_LONG * 8)) {
    1524         338 :                 if (EXPECTED(op2_lval > 0)) {
    1525         216 :                         ZVAL_LONG(result, 0);
    1526         216 :                         return SUCCESS;
    1527             :                 } else {
    1528         244 :                         if (EG(current_execute_data) && !CG(in_compilation)) {
    1529         122 :                                 zend_throw_exception_ex(NULL, 0, "Bit shift by negative number");
    1530             :                         } else {
    1531           0 :                                 zend_error_noreturn(E_ERROR, "Bit shift by negative number");
    1532             :                         }
    1533         122 :                         ZVAL_UNDEF(result);
    1534         122 :                         return FAILURE;
    1535             :                 }
    1536             :         }
    1537             : 
    1538        3280 :         ZVAL_LONG(result, op1_lval << op2_lval);
    1539        3280 :         return SUCCESS;
    1540             : }
    1541             : /* }}} */
    1542             : 
    1543      350392 : ZEND_API int ZEND_FASTCALL shift_right_function(zval *result, zval *op1, zval *op2) /* {{{ */
    1544             : {
    1545             :         zend_long op1_lval, op2_lval;
    1546             : 
    1547      701894 :         convert_op1_op2_long(op1, op1_lval, op2, op2_lval, ZEND_SR, shift_right_function);
    1548             : 
    1549      350389 :         if (op1 == result) {
    1550             :                 zval_dtor(result);
    1551             :         }
    1552             : 
    1553             :         /* prevent wrapping quirkiness on some processors where >> 64 + x == >> x */
    1554      350389 :         if (UNEXPECTED((zend_ulong)op2_lval >= SIZEOF_ZEND_LONG * 8)) {
    1555         338 :                 if (EXPECTED(op2_lval > 0)) {
    1556         216 :                         ZVAL_LONG(result, (op1_lval < 0) ? -1 : 0);
    1557         216 :                         return SUCCESS;
    1558             :                 } else {
    1559         244 :                         if (EG(current_execute_data) && !CG(in_compilation)) {
    1560         122 :                                 zend_throw_exception_ex(NULL, 0, "Bit shift by negative number");
    1561             :                         } else {
    1562           0 :                                 zend_error_noreturn(E_ERROR, "Bit shift by negative number");
    1563             :                         }
    1564         122 :                         ZVAL_UNDEF(result);
    1565         122 :                         return FAILURE;
    1566             :                 }
    1567             :         }
    1568             : 
    1569      350051 :         ZVAL_LONG(result, op1_lval >> op2_lval);
    1570      350051 :         return SUCCESS;
    1571             : }
    1572             : /* }}} */
    1573             : 
    1574     7929741 : ZEND_API int ZEND_FASTCALL concat_function(zval *result, zval *op1, zval *op2) /* {{{ */
    1575             : {
    1576             :         zval op1_copy, op2_copy;
    1577     7929741 :         int use_copy1 = 0, use_copy2 = 0;
    1578             : 
    1579             :         do {
    1580     7929741 :                 if (UNEXPECTED(Z_TYPE_P(op1) != IS_STRING)) {
    1581       48677 :                         if (Z_ISREF_P(op1)) {
    1582       17214 :                                 op1 = Z_REFVAL_P(op1);
    1583       17214 :                                 if (Z_TYPE_P(op1) == IS_STRING) break;
    1584             :                         }
    1585       94399 :                         ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_CONCAT, concat_function);
    1586       31470 :                         use_copy1 = zend_make_printable_zval(op1, &op1_copy);
    1587       31470 :                         if (use_copy1) {
    1588             :                                 /* We have created a converted copy of op1. Therefore, op1 won't become the result so
    1589             :                                  * we have to free it.
    1590             :                                  */
    1591       31470 :                                 if (result == op1) {
    1592             :                                         zval_dtor(op1);
    1593           8 :                                         if (UNEXPECTED(op1 == op2)) {
    1594           0 :                                                 op2 = &op1_copy;
    1595             :                                         }
    1596             :                                 }
    1597       31470 :                                 op1 = &op1_copy;
    1598             :                         }
    1599             :                 }
    1600             :         } while (0);
    1601             :         do {
    1602     7929741 :                 if (UNEXPECTED(Z_TYPE_P(op2) != IS_STRING)) {
    1603     1396021 :                         if (Z_ISREF_P(op2)) {
    1604         127 :                                 op2 = Z_REFVAL_P(op2);
    1605         127 :                                 if (Z_TYPE_P(op2) == IS_STRING) break;
    1606             :                         }
    1607     1395912 :                         ZEND_TRY_BINARY_OP2_OBJECT_OPERATION(ZEND_CONCAT);
    1608     1395912 :                         use_copy2 = zend_make_printable_zval(op2, &op2_copy);
    1609     1395912 :                         if (use_copy2) {
    1610     1395912 :                                 op2 = &op2_copy;
    1611             :                         }
    1612             :                 }
    1613             :         } while (0);
    1614             : 
    1615             :         {
    1616     7929741 :                 size_t op1_len = Z_STRLEN_P(op1);
    1617     7929741 :                 size_t op2_len = Z_STRLEN_P(op2);
    1618     7929741 :                 size_t result_len = op1_len + op2_len;
    1619             :                 zend_string *result_str;
    1620             : 
    1621     7929741 :                 if (UNEXPECTED(op1_len > SIZE_MAX - op2_len)) {
    1622           0 :                         zend_error(E_EXCEPTION | E_ERROR, "String size overflow");
    1623           0 :                         ZVAL_FALSE(result);
    1624           0 :                         return FAILURE;
    1625             :                 }
    1626             : 
    1627    14735294 :                 if (result == op1 && Z_REFCOUNTED_P(result)) {
    1628             :                         /* special case, perform operations on result */
    1629    13611106 :                         result_str = zend_string_extend(Z_STR_P(result), result_len, 0);
    1630             :                 } else {
    1631     1124188 :                         result_str = zend_string_alloc(result_len, 0);
    1632     1124188 :                         memcpy(result_str->val, Z_STRVAL_P(op1), op1_len);
    1633             :                 }
    1634             : 
    1635             :                 /* This has to happen first to account for the cases where result == op1 == op2 and
    1636             :                  * the realloc is done. In this case this line will also update Z_STRVAL_P(op2) to
    1637             :                  * point to the new string. The first op2_len bytes of result will still be the same. */
    1638     7929741 :                 ZVAL_NEW_STR(result, result_str);
    1639             : 
    1640     7929741 :                 memcpy(result_str->val + op1_len, Z_STRVAL_P(op2), op2_len);
    1641     7929741 :                 result_str->val[result_len] = '\0';
    1642             :         }
    1643             : 
    1644     7929741 :         if (UNEXPECTED(use_copy1)) {
    1645             :                 zval_dtor(op1);
    1646             :         }
    1647     7929741 :         if (UNEXPECTED(use_copy2)) {
    1648             :                 zval_dtor(op2);
    1649             :         }
    1650     7929741 :         return SUCCESS;
    1651             : }
    1652             : /* }}} */
    1653             : 
    1654           0 : ZEND_API int string_compare_function_ex(zval *result, zval *op1, zval *op2, zend_bool case_insensitive) /* {{{ */
    1655             : {
    1656           0 :         zend_string *str1 = zval_get_string(op1);
    1657           0 :         zend_string *str2 = zval_get_string(op2);
    1658             : 
    1659           0 :         if (case_insensitive) {
    1660           0 :                 ZVAL_LONG(result, zend_binary_strcasecmp_l(str1->val, str1->len, str2->val, str1->len));
    1661             :         } else {
    1662           0 :                 ZVAL_LONG(result, zend_binary_strcmp(str1->val, str1->len, str2->val, str2->len));
    1663             :         }
    1664             : 
    1665             :         zend_string_release(str1);
    1666             :         zend_string_release(str2);
    1667           0 :         return SUCCESS;
    1668             : }
    1669             : /* }}} */
    1670             : 
    1671      212450 : ZEND_API int string_compare_function(zval *result, zval *op1, zval *op2) /* {{{ */
    1672             : {
    1673      622819 :         if (EXPECTED(Z_TYPE_P(op1) == IS_STRING) &&
    1674      206266 :             EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
    1675      204103 :                 if (Z_STR_P(op1) == Z_STR_P(op2)) {
    1676         228 :                         ZVAL_LONG(result, 0);
    1677             :                 } else {
    1678      203875 :                         ZVAL_LONG(result, zend_binary_strcmp(Z_STRVAL_P(op1), Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2)));
    1679             :                 }
    1680             :         } else {
    1681        8347 :                 zend_string *str1 = zval_get_string(op1);
    1682        8347 :                 zend_string *str2 = zval_get_string(op2);
    1683             : 
    1684        8347 :                 ZVAL_LONG(result, zend_binary_strcmp(str1->val, str1->len, str2->val, str2->len));
    1685             : 
    1686             :                 zend_string_release(str1);
    1687             :                 zend_string_release(str2);
    1688             :         }
    1689      212450 :         return SUCCESS;
    1690             : }
    1691             : /* }}} */
    1692             : 
    1693         125 : ZEND_API int string_case_compare_function(zval *result, zval *op1, zval *op2) /* {{{ */
    1694             : {
    1695         341 :         if (EXPECTED(Z_TYPE_P(op1) == IS_STRING) &&
    1696         108 :             EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
    1697         108 :                 if (Z_STR_P(op1) == Z_STR_P(op2)) {
    1698           0 :                         ZVAL_LONG(result, 0);
    1699             :                 } else {
    1700         108 :                         ZVAL_LONG(result, zend_binary_strcasecmp_l(Z_STRVAL_P(op1), Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2)));
    1701             :                 }
    1702             :         } else {
    1703          17 :                 zend_string *str1 = zval_get_string(op1);
    1704          17 :                 zend_string *str2 = zval_get_string(op2);
    1705             : 
    1706          17 :                 ZVAL_LONG(result, zend_binary_strcasecmp_l(str1->val, str1->len, str2->val, str1->len));
    1707             : 
    1708             :                 zend_string_release(str1);
    1709             :                 zend_string_release(str2);
    1710             :         }
    1711         125 :         return SUCCESS;
    1712             : }
    1713             : /* }}} */
    1714             : 
    1715             : #if HAVE_STRCOLL
    1716          29 : ZEND_API int string_locale_compare_function(zval *result, zval *op1, zval *op2) /* {{{ */
    1717             : {
    1718          29 :         zend_string *str1 = zval_get_string(op1);
    1719          29 :         zend_string *str2 = zval_get_string(op2);
    1720             : 
    1721          29 :         ZVAL_LONG(result, strcoll(str1->val, str2->val));
    1722             : 
    1723             :         zend_string_release(str1);
    1724             :         zend_string_release(str2);
    1725          29 :         return SUCCESS;
    1726             : }
    1727             : /* }}} */
    1728             : #endif
    1729             : 
    1730         804 : ZEND_API int numeric_compare_function(zval *result, zval *op1, zval *op2) /* {{{ */
    1731             : {
    1732             :         double d1, d2;
    1733             : 
    1734         804 :         d1 = zval_get_double(op1);
    1735         804 :         d2 = zval_get_double(op2);
    1736             : 
    1737         804 :         ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(d1 - d2));
    1738             : 
    1739         804 :         return SUCCESS;
    1740             : }
    1741             : /* }}} */
    1742             : 
    1743         409 : static inline void zend_free_obj_get_result(zval *op) /* {{{ */
    1744             : {
    1745         409 :         if (Z_REFCOUNTED_P(op)) {
    1746           1 :                 if (Z_REFCOUNT_P(op) == 0) {
    1747             :                         zval_dtor(op);
    1748             :                 } else {
    1749           1 :                         zval_ptr_dtor(op);
    1750             :                 }
    1751             :         }
    1752         409 : }
    1753             : /* }}} */
    1754             : 
    1755             : static zend_always_inline int i_compare_function(zval *result, zval *op1, zval *op2) /* {{{ */
    1756             : {
    1757             :         int ret;
    1758      825960 :         int converted = 0;
    1759             :         zval op1_copy, op2_copy;
    1760             :         zval *op_free, tmp_free;
    1761             : 
    1762             :         while (1) {
    1763     1985950 :                 switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) {
    1764             :                         case TYPE_PAIR(IS_LONG, IS_LONG):
    1765       65076 :                                 ZVAL_LONG(result, Z_LVAL_P(op1)>Z_LVAL_P(op2)?1:(Z_LVAL_P(op1)<Z_LVAL_P(op2)?-1:0));
    1766       65076 :                                 return SUCCESS;
    1767             : 
    1768             :                         case TYPE_PAIR(IS_DOUBLE, IS_LONG):
    1769         421 :                                 Z_DVAL_P(result) = Z_DVAL_P(op1) - (double)Z_LVAL_P(op2);
    1770         421 :                                 ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
    1771         421 :                                 return SUCCESS;
    1772             : 
    1773             :                         case TYPE_PAIR(IS_LONG, IS_DOUBLE):
    1774         345 :                                 Z_DVAL_P(result) = (double)Z_LVAL_P(op1) - Z_DVAL_P(op2);
    1775         345 :                                 ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
    1776         345 :                                 return SUCCESS;
    1777             : 
    1778             :                         case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE):
    1779         371 :                                 if (Z_DVAL_P(op1) == Z_DVAL_P(op2)) {
    1780          95 :                                         ZVAL_LONG(result, 0);
    1781             :                                 } else {
    1782         276 :                                         Z_DVAL_P(result) = Z_DVAL_P(op1) - Z_DVAL_P(op2);
    1783         276 :                                         ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
    1784             :                                 }
    1785         371 :                                 return SUCCESS;
    1786             : 
    1787             :                         case TYPE_PAIR(IS_ARRAY, IS_ARRAY):
    1788         528 :                                 ZVAL_LONG(result, zend_compare_arrays(op1, op2));
    1789         528 :                                 return SUCCESS;
    1790             : 
    1791             :                         case TYPE_PAIR(IS_NULL, IS_NULL):
    1792             :                         case TYPE_PAIR(IS_NULL, IS_FALSE):
    1793             :                         case TYPE_PAIR(IS_FALSE, IS_NULL):
    1794             :                         case TYPE_PAIR(IS_FALSE, IS_FALSE):
    1795             :                         case TYPE_PAIR(IS_TRUE, IS_TRUE):
    1796        3195 :                                 ZVAL_LONG(result, 0);
    1797        3195 :                                 return SUCCESS;
    1798             : 
    1799             :                         case TYPE_PAIR(IS_NULL, IS_TRUE):
    1800          13 :                                 ZVAL_LONG(result, -1);
    1801          13 :                                 return SUCCESS;
    1802             : 
    1803             :                         case TYPE_PAIR(IS_TRUE, IS_NULL):
    1804          12 :                                 ZVAL_LONG(result, 1);
    1805          12 :                                 return SUCCESS;
    1806             : 
    1807             :                         case TYPE_PAIR(IS_STRING, IS_STRING):
    1808      342071 :                                 if (Z_STR_P(op1) == Z_STR_P(op2)) {
    1809         216 :                                         ZVAL_LONG(result, 0);
    1810         216 :                                         return SUCCESS;
    1811             :                                 }
    1812      341855 :                                 ZVAL_LONG(result, zendi_smart_strcmp(op1, op2));
    1813      341855 :                                 return SUCCESS;
    1814             : 
    1815             :                         case TYPE_PAIR(IS_NULL, IS_STRING):
    1816       12925 :                                 ZVAL_LONG(result, Z_STRLEN_P(op2) == 0 ? 0 : -1);
    1817       12925 :                                 return SUCCESS;
    1818             : 
    1819             :                         case TYPE_PAIR(IS_STRING, IS_NULL):
    1820         115 :                                 ZVAL_LONG(result, Z_STRLEN_P(op1) == 0 ? 0 : 1);
    1821         115 :                                 return SUCCESS;
    1822             : 
    1823             :                         case TYPE_PAIR(IS_OBJECT, IS_NULL):
    1824          49 :                                 ZVAL_LONG(result, 1);
    1825          49 :                                 return SUCCESS;
    1826             : 
    1827             :                         case TYPE_PAIR(IS_NULL, IS_OBJECT):
    1828          15 :                                 ZVAL_LONG(result, -1);
    1829          15 :                                 return SUCCESS;
    1830             : 
    1831             :                         default:
    1832      567839 :                                 if (Z_ISREF_P(op1)) {
    1833      110282 :                                         op1 = Z_REFVAL_P(op1);
    1834      110282 :                                         continue;
    1835      457557 :                                 } else if (Z_ISREF_P(op2)) {
    1836       24886 :                                         op2 = Z_REFVAL_P(op2);
    1837       24886 :                                         continue;
    1838             :                                 }
    1839             : 
    1840      432671 :                                 if (Z_TYPE_P(op1) == IS_OBJECT && Z_OBJ_HANDLER_P(op1, compare)) {
    1841       25018 :                                         return Z_OBJ_HANDLER_P(op1, compare)(result, op1, op2);
    1842      407653 :                                 } else if (Z_TYPE_P(op2) == IS_OBJECT && Z_OBJ_HANDLER_P(op2, compare)) {
    1843       25004 :                                         return Z_OBJ_HANDLER_P(op2, compare)(result, op1, op2);
    1844             :                                 }
    1845             : 
    1846      729066 :                                 if (Z_TYPE_P(op1) == IS_OBJECT && Z_TYPE_P(op2) == IS_OBJECT) {
    1847      346205 :                                         if (Z_OBJ_P(op1) == Z_OBJ_P(op2)) {
    1848             :                                                 /* object handles are identical, apparently this is the same object */
    1849          25 :                                                 ZVAL_LONG(result, 0);
    1850          25 :                                                 return SUCCESS;
    1851             :                                         }
    1852      346180 :                                         if (Z_OBJ_HANDLER_P(op1, compare_objects) == Z_OBJ_HANDLER_P(op2, compare_objects)) {
    1853      346179 :                                                 ZVAL_LONG(result, Z_OBJ_HANDLER_P(op1, compare_objects)(op1, op2));
    1854      346175 :                                                 return SUCCESS;
    1855             :                                         }
    1856             :                                 }
    1857       36445 :                                 if (Z_TYPE_P(op1) == IS_OBJECT) {
    1858         213 :                                         if (Z_OBJ_HT_P(op1)->get) {
    1859             :                                                 zval rv;
    1860           1 :                                                 op_free = Z_OBJ_HT_P(op1)->get(op1, &rv);
    1861           1 :                                                 ret = compare_function(result, op_free, op2);
    1862           1 :                                                 zend_free_obj_get_result(op_free);
    1863           1 :                                                 return ret;
    1864         212 :                                         } else if (Z_TYPE_P(op2) != IS_OBJECT && Z_OBJ_HT_P(op1)->cast_object) {
    1865         211 :                                                 ZVAL_UNDEF(&tmp_free);
    1866         797 :                                                 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))) == FAILURE) {
    1867         112 :                                                         ZVAL_LONG(result, 1);
    1868         112 :                                                         zend_free_obj_get_result(&tmp_free);
    1869         112 :                                                         return SUCCESS;
    1870             :                                                 }
    1871          99 :                                                 ret = compare_function(result, &tmp_free, op2);
    1872          99 :                                                 zend_free_obj_get_result(&tmp_free);
    1873          99 :                                                 return ret;
    1874             :                                         }
    1875             :                                 }
    1876       36233 :                                 if (Z_TYPE_P(op2) == IS_OBJECT) {
    1877         198 :                                         if (Z_OBJ_HT_P(op2)->get) {
    1878             :                                                 zval rv;
    1879           0 :                                                 op_free = Z_OBJ_HT_P(op2)->get(op2, &rv);
    1880           0 :                                                 ret = compare_function(result, op1, op_free);
    1881           0 :                                                 zend_free_obj_get_result(op_free);
    1882           0 :                                                 return ret;
    1883         198 :                                         } else if (Z_TYPE_P(op1) != IS_OBJECT && Z_OBJ_HT_P(op2)->cast_object) {
    1884         197 :                                                 ZVAL_UNDEF(&tmp_free);
    1885         743 :                                                 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))) == FAILURE) {
    1886         107 :                                                         ZVAL_LONG(result, -1);
    1887         107 :                                                         zend_free_obj_get_result(&tmp_free);
    1888         107 :                                                         return SUCCESS;
    1889             :                                                 }
    1890          90 :                                                 ret = compare_function(result, op1, &tmp_free);
    1891          90 :                                                 zend_free_obj_get_result(&tmp_free);
    1892          90 :                                                 return ret;
    1893           1 :                                         } else if (Z_TYPE_P(op1) == IS_OBJECT) {
    1894           1 :                                                 ZVAL_LONG(result, 1);
    1895           1 :                                                 return SUCCESS;
    1896             :                                         }
    1897             :                                 }
    1898       36035 :                                 if (!converted) {
    1899       70815 :                                         if (Z_TYPE_P(op1) == IS_NULL || Z_TYPE_P(op1) == IS_FALSE) {
    1900        2125 :                                                 ZVAL_LONG(result, zval_is_true(op2) ? -1 : 0);
    1901        2125 :                                                 return SUCCESS;
    1902       66655 :                                         } else if (Z_TYPE_P(op2) == IS_NULL || Z_TYPE_P(op2) == IS_FALSE) {
    1903        1158 :                                                 ZVAL_LONG(result, zval_is_true(op1) ? 1 : 0);
    1904        1158 :                                                 return SUCCESS;
    1905       32213 :                                         } else if (Z_TYPE_P(op1) == IS_TRUE) {
    1906         184 :                                                 ZVAL_LONG(result, zval_is_true(op2) ? 0 : 1);
    1907         184 :                                                 return SUCCESS;
    1908       32029 :                                         } else if (Z_TYPE_P(op2) == IS_TRUE) {
    1909         182 :                                                 ZVAL_LONG(result, zval_is_true(op1) ? 0 : -1);
    1910         182 :                                                 return SUCCESS;
    1911             :                                         } else {
    1912       79971 :                                                 zendi_convert_scalar_to_number(op1, op1_copy, result);
    1913       78987 :                                                 zendi_convert_scalar_to_number(op2, op2_copy, result);
    1914       31847 :                                                 converted = 1;
    1915             :                                         }
    1916         539 :                                 } else if (Z_TYPE_P(op1)==IS_ARRAY) {
    1917         281 :                                         ZVAL_LONG(result, 1);
    1918         281 :                                         return SUCCESS;
    1919         258 :                                 } else if (Z_TYPE_P(op2)==IS_ARRAY) {
    1920         258 :                                         ZVAL_LONG(result, -1);
    1921         258 :                                         return SUCCESS;
    1922           0 :                                 } else if (Z_TYPE_P(op1)==IS_OBJECT) {
    1923           0 :                                         ZVAL_LONG(result, 1);
    1924           0 :                                         return SUCCESS;
    1925           0 :                                 } else if (Z_TYPE_P(op2)==IS_OBJECT) {
    1926           0 :                                         ZVAL_LONG(result, -1);
    1927           0 :                                         return SUCCESS;
    1928             :                                 } else {
    1929           0 :                                         ZVAL_LONG(result, 0);
    1930           0 :                                         return FAILURE;
    1931             :                                 }
    1932             :                 }
    1933             :         }
    1934             : }
    1935             : /* }}} */
    1936             : 
    1937      792560 : ZEND_API int ZEND_FASTCALL compare_function(zval *result, zval *op1, zval *op2) /* {{{ */
    1938             : {
    1939      792556 :         return i_compare_function(result, op1, op2);
    1940             : }
    1941             : /* }}} */
    1942             : 
    1943       33400 : ZEND_API int zval_compare_function(zval *result, zval *op1, zval *op2) /* {{{ */
    1944             : {
    1945       33400 :         return i_compare_function(result, op1, op2);
    1946             : }
    1947             : /* }}} */
    1948             : 
    1949        1129 : static int hash_zval_identical_function(zval *z1, zval *z2) /* {{{ */
    1950             : {
    1951             :         zval result;
    1952             : 
    1953             :         /* is_identical_function() returns 1 in case of identity and 0 in case
    1954             :          * of a difference;
    1955             :          * whereas this comparison function is expected to return 0 on identity,
    1956             :          * and non zero otherwise.
    1957             :          */
    1958        1129 :         ZVAL_DEREF(z1);
    1959        1129 :         ZVAL_DEREF(z2);
    1960        1129 :         if (is_identical_function(&result, z1, z2)==FAILURE) {
    1961           0 :                 return 1;
    1962             :         }
    1963        1129 :         return Z_TYPE(result) != IS_TRUE;
    1964             : }
    1965             : /* }}} */
    1966             : 
    1967     1022307 : ZEND_API int ZEND_FASTCALL zend_is_identical(zval *op1, zval *op2) /* {{{ */
    1968             : {
    1969     1022307 :         if (Z_TYPE_P(op1) != Z_TYPE_P(op2)) {
    1970           0 :                 return 0;
    1971             :         }
    1972     1022307 :         switch (Z_TYPE_P(op1)) {
    1973             :                 case IS_NULL:
    1974             :                 case IS_FALSE:
    1975             :                 case IS_TRUE:
    1976           3 :                         return 1;
    1977             :                 case IS_LONG:
    1978      911650 :                         return (Z_LVAL_P(op1) == Z_LVAL_P(op2));
    1979             :                 case IS_RESOURCE:
    1980          12 :                         return (Z_RES_P(op1) == Z_RES_P(op2));
    1981             :                 case IS_DOUBLE:
    1982         179 :                         return (Z_DVAL_P(op1) == Z_DVAL_P(op2));
    1983             :                 case IS_STRING:
    1984       77355 :                         return (Z_STR_P(op1) == Z_STR_P(op2) ||
    1985       18259 :                                 (Z_STRLEN_P(op1) == Z_STRLEN_P(op2) &&
    1986       14790 :                                  memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op1)) == 0));
    1987             :                 case IS_ARRAY:
    1988         138 :                         return (Z_ARRVAL_P(op1) == Z_ARRVAL_P(op2) ||
    1989          68 :                                 zend_hash_compare(Z_ARRVAL_P(op1), Z_ARRVAL_P(op2), (compare_func_t) hash_zval_identical_function, 1) == 0);
    1990             :                 case IS_OBJECT:
    1991       66087 :                         return (Z_OBJ_P(op1) == Z_OBJ_P(op2) && Z_OBJ_HT_P(op1) == Z_OBJ_HT_P(op2));
    1992             :                 default:
    1993           0 :                         return 0;
    1994             :         }
    1995             : }
    1996             : /* }}} */
    1997             : 
    1998        1132 : ZEND_API int ZEND_FASTCALL is_identical_function(zval *result, zval *op1, zval *op2) /* {{{ */
    1999             : {
    2000        1132 :         ZVAL_BOOL(result, zend_is_identical(op1, op2));
    2001        1132 :         return SUCCESS;
    2002             : }
    2003             : /* }}} */
    2004             : 
    2005          19 : ZEND_API int ZEND_FASTCALL is_not_identical_function(zval *result, zval *op1, zval *op2) /* {{{ */
    2006             : {
    2007          19 :         ZVAL_BOOL(result, !zend_is_identical(op1, op2));
    2008          19 :         return SUCCESS;
    2009             : }
    2010             : /* }}} */
    2011             : 
    2012          79 : ZEND_API int ZEND_FASTCALL is_equal_function(zval *result, zval *op1, zval *op2) /* {{{ */
    2013             : {
    2014          79 :         if (compare_function(result, op1, op2) == FAILURE) {
    2015           0 :                 return FAILURE;
    2016             :         }
    2017          79 :         ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
    2018          79 :         return SUCCESS;
    2019             : }
    2020             : /* }}} */
    2021             : 
    2022         399 : ZEND_API int ZEND_FASTCALL is_not_equal_function(zval *result, zval *op1, zval *op2) /* {{{ */
    2023             : {
    2024         399 :         if (compare_function(result, op1, op2) == FAILURE) {
    2025           0 :                 return FAILURE;
    2026             :         }
    2027         399 :         ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
    2028         399 :         return SUCCESS;
    2029             : }
    2030             : /* }}} */
    2031             : 
    2032        1954 : ZEND_API int ZEND_FASTCALL is_smaller_function(zval *result, zval *op1, zval *op2) /* {{{ */
    2033             : {
    2034        1954 :         if (compare_function(result, op1, op2) == FAILURE) {
    2035           0 :                 return FAILURE;
    2036             :         }
    2037        1954 :         ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
    2038        1954 :         return SUCCESS;
    2039             : }
    2040             : /* }}} */
    2041             : 
    2042        1289 : ZEND_API int ZEND_FASTCALL is_smaller_or_equal_function(zval *result, zval *op1, zval *op2) /* {{{ */
    2043             : {
    2044        1289 :         if (compare_function(result, op1, op2) == FAILURE) {
    2045           0 :                 return FAILURE;
    2046             :         }
    2047        1289 :         ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
    2048        1289 :         return SUCCESS;
    2049             : }
    2050             : /* }}} */
    2051             : 
    2052           0 : static zend_bool ZEND_FASTCALL instanceof_interface_only(const zend_class_entry *instance_ce, const zend_class_entry *ce) /* {{{ */
    2053             : {
    2054             :         uint32_t i;
    2055             : 
    2056           0 :         for (i = 0; i < instance_ce->num_interfaces; i++) {
    2057           0 :                 if (instanceof_interface_only(instance_ce->interfaces[i], ce)) {
    2058           0 :                         return 1;
    2059             :                 }
    2060             :         }
    2061           0 :         return 0;
    2062             : }
    2063             : /* }}} */
    2064             : 
    2065             : static zend_always_inline zend_bool instanceof_class(const zend_class_entry *instance_ce, const zend_class_entry *ce) /* {{{ */
    2066             : {
    2067     3819680 :         while (instance_ce) {
    2068     3311787 :                 if (instance_ce == ce) {
    2069     1863212 :                         return 1;
    2070             :                 }
    2071     1448575 :                 instance_ce = instance_ce->parent;
    2072             :         }
    2073      507893 :         return 0;
    2074             : }
    2075             : /* }}} */
    2076             : 
    2077     1252743 : static zend_bool ZEND_FASTCALL instanceof_interface(const zend_class_entry *instance_ce, const zend_class_entry *ce) /* {{{ */
    2078             : {
    2079             :         uint32_t i;
    2080             : 
    2081     1659179 :         for (i = 0; i < instance_ce->num_interfaces; i++) {
    2082      829730 :                 if (instanceof_interface(instance_ce->interfaces[i], ce)) {
    2083      423294 :                         return 1;
    2084             :                 }
    2085             :         }
    2086      829449 :         return instanceof_class(instance_ce, ce);
    2087             : }
    2088             : /* }}} */
    2089             : 
    2090       66168 : ZEND_API zend_bool ZEND_FASTCALL instanceof_function_ex(const zend_class_entry *instance_ce, const zend_class_entry *ce, zend_bool interfaces_only) /* {{{ */
    2091             : {
    2092       66168 :         if (ce->ce_flags & ZEND_ACC_INTERFACE) {
    2093       66161 :                 if (!interfaces_only) {
    2094           0 :                         if (instanceof_interface_only(instance_ce, ce)) {
    2095           0 :                                 return 1;
    2096             :                         }
    2097             :                 } else {
    2098       66161 :                         return instanceof_interface(instance_ce, ce);
    2099             :                 }
    2100             :         }
    2101           7 :         if (!interfaces_only) {
    2102           7 :                 return instanceof_class(instance_ce, ce);
    2103             :         }
    2104           0 :         return 0;
    2105             : }
    2106             : /* }}} */
    2107             : 
    2108     1898501 : ZEND_API zend_bool ZEND_FASTCALL instanceof_function(const zend_class_entry *instance_ce, const zend_class_entry *ce) /* {{{ */
    2109             : {
    2110     1898501 :         if (ce->ce_flags & ZEND_ACC_INTERFACE) {
    2111      356852 :                 return instanceof_interface(instance_ce, ce);
    2112             :         } else {
    2113     1541649 :                 return instanceof_class(instance_ce, ce);
    2114             :         }
    2115             : }
    2116             : /* }}} */
    2117             : 
    2118             : #define LOWER_CASE 1
    2119             : #define UPPER_CASE 2
    2120             : #define NUMERIC 3
    2121             : 
    2122          55 : static void ZEND_FASTCALL increment_string(zval *str) /* {{{ */
    2123             : {
    2124          55 :         int carry=0;
    2125          55 :         size_t pos=Z_STRLEN_P(str)-1;
    2126             :         char *s;
    2127             :         zend_string *t;
    2128          55 :         int last=0; /* Shut up the compiler warning */
    2129             :         int ch;
    2130             : 
    2131          55 :         if (Z_STRLEN_P(str) == 0) {
    2132           0 :                 zend_string_release(Z_STR_P(str));
    2133           0 :                 Z_STR_P(str) = zend_string_init("1", sizeof("1")-1, 0);
    2134           0 :                 Z_TYPE_INFO_P(str) = IS_STRING_EX;
    2135           0 :                 return;
    2136             :         }
    2137             : 
    2138          55 :         if (!Z_REFCOUNTED_P(str)) {
    2139          10 :                 Z_STR_P(str) = zend_string_init(Z_STRVAL_P(str), Z_STRLEN_P(str), 0);
    2140           5 :                 Z_TYPE_INFO_P(str) = IS_STRING_EX;
    2141          50 :         } else if (Z_REFCOUNT_P(str) > 1) {
    2142             :                 Z_DELREF_P(str);
    2143           0 :                 Z_STR_P(str) = zend_string_init(Z_STRVAL_P(str), Z_STRLEN_P(str), 0);
    2144             :         } else {
    2145          50 :                 zend_string_forget_hash_val(Z_STR_P(str));
    2146             :         }
    2147          55 :         s = Z_STRVAL_P(str);
    2148             : 
    2149             :         do {
    2150          68 :                 ch = s[pos];
    2151         107 :                 if (ch >= 'a' && ch <= 'z') {
    2152          39 :                         if (ch == 'z') {
    2153           9 :                                 s[pos] = 'a';
    2154           9 :                                 carry=1;
    2155             :                         } else {
    2156          30 :                                 s[pos]++;
    2157          30 :                                 carry=0;
    2158             :                         }
    2159          39 :                         last=LOWER_CASE;
    2160          40 :                 } else if (ch >= 'A' && ch <= 'Z') {
    2161          11 :                         if (ch == 'Z') {
    2162           4 :                                 s[pos] = 'A';
    2163           4 :                                 carry=1;
    2164             :                         } else {
    2165           7 :                                 s[pos]++;
    2166           7 :                                 carry=0;
    2167             :                         }
    2168          11 :                         last=UPPER_CASE;
    2169          32 :                 } else if (ch >= '0' && ch <= '9') {
    2170          14 :                         if (ch == '9') {
    2171           6 :                                 s[pos] = '0';
    2172           6 :                                 carry=1;
    2173             :                         } else {
    2174           8 :                                 s[pos]++;
    2175           8 :                                 carry=0;
    2176             :                         }
    2177          14 :                         last = NUMERIC;
    2178             :                 } else {
    2179           4 :                         carry=0;
    2180           4 :                         break;
    2181             :                 }
    2182          64 :                 if (carry == 0) {
    2183          45 :                         break;
    2184             :                 }
    2185          19 :         } while (pos-- > 0);
    2186             : 
    2187          55 :         if (carry) {
    2188          12 :                 t = zend_string_alloc(Z_STRLEN_P(str)+1, 0);
    2189           6 :                 memcpy(t->val + 1, Z_STRVAL_P(str), Z_STRLEN_P(str));
    2190           6 :                 t->val[Z_STRLEN_P(str) + 1] = '\0';
    2191           6 :                 switch (last) {
    2192             :                         case NUMERIC:
    2193           2 :                                 t->val[0] = '1';
    2194           2 :                                 break;
    2195             :                         case UPPER_CASE:
    2196           2 :                                 t->val[0] = 'A';
    2197           2 :                                 break;
    2198             :                         case LOWER_CASE:
    2199           2 :                                 t->val[0] = 'a';
    2200             :                                 break;
    2201             :                 }
    2202           6 :                 zend_string_free(Z_STR_P(str));
    2203           6 :                 ZVAL_NEW_STR(str, t);
    2204             :         }
    2205             : }
    2206             : /* }}} */
    2207             : 
    2208       15467 : ZEND_API int ZEND_FASTCALL increment_function(zval *op1) /* {{{ */
    2209             : {
    2210             : try_again:
    2211       15467 :         switch (Z_TYPE_P(op1)) {
    2212             :                 case IS_LONG:
    2213             :                         fast_long_increment_function(op1);
    2214       15364 :                         break;
    2215             :                 case IS_DOUBLE:
    2216           4 :                         Z_DVAL_P(op1) = Z_DVAL_P(op1) + 1;
    2217           4 :                         break;
    2218             :                 case IS_NULL:
    2219          27 :                         ZVAL_LONG(op1, 1);
    2220          27 :                         break;
    2221             :                 case IS_STRING: {
    2222             :                                 zend_long lval;
    2223             :                                 double dval;
    2224             : 
    2225         138 :                                 switch (is_numeric_string(Z_STRVAL_P(op1), Z_STRLEN_P(op1), &lval, &dval, 0)) {
    2226             :                                         case IS_LONG:
    2227           8 :                                                 zend_string_release(Z_STR_P(op1));
    2228           8 :                                                 if (lval == ZEND_LONG_MAX) {
    2229             :                                                         /* switch to double */
    2230           0 :                                                         double d = (double)lval;
    2231           0 :                                                         ZVAL_DOUBLE(op1, d+1);
    2232             :                                                 } else {
    2233           8 :                                                         ZVAL_LONG(op1, lval+1);
    2234             :                                                 }
    2235           8 :                                                 break;
    2236             :                                         case IS_DOUBLE:
    2237           6 :                                                 zend_string_release(Z_STR_P(op1));
    2238           6 :                                                 ZVAL_DOUBLE(op1, dval+1);
    2239           6 :                                                 break;
    2240             :                                         default:
    2241             :                                                 /* Perl style string increment */
    2242          55 :                                                 increment_string(op1);
    2243             :                                                 break;
    2244             :                                 }
    2245             :                         }
    2246          69 :                         break;
    2247             :                 case IS_OBJECT:
    2248           6 :                         if (Z_OBJ_HANDLER_P(op1, get)
    2249           3 :                            && Z_OBJ_HANDLER_P(op1, set)) {
    2250             :                                 /* proxy object */
    2251             :                                 zval rv;
    2252             :                                 zval *val;
    2253             : 
    2254           0 :                                 val = Z_OBJ_HANDLER_P(op1, get)(op1, &rv);
    2255             :                                 Z_ADDREF_P(val);
    2256           0 :                                 increment_function(val);
    2257           0 :                                 Z_OBJ_HANDLER_P(op1, set)(op1, val);
    2258           0 :                                 zval_ptr_dtor(val);
    2259           3 :                         } else if (Z_OBJ_HANDLER_P(op1, do_operation)) {
    2260             :                                 zval op2;
    2261             :                                 int res;
    2262             : 
    2263           2 :                                 ZVAL_LONG(&op2, 1);
    2264           2 :                                 res = Z_OBJ_HANDLER_P(op1, do_operation)(ZEND_ADD, op1, op1, &op2);
    2265           2 :                                 zval_ptr_dtor(&op2);
    2266             : 
    2267           2 :                                 return res;
    2268             :                         }
    2269           1 :                         return FAILURE;
    2270             :                 case IS_REFERENCE:
    2271           0 :                         op1 = Z_REFVAL_P(op1);
    2272           0 :                         goto try_again;
    2273             :                 default:
    2274           0 :                         return FAILURE;
    2275             :         }
    2276       15464 :         return SUCCESS;
    2277             : }
    2278             : /* }}} */
    2279             : 
    2280      151001 : ZEND_API int ZEND_FASTCALL decrement_function(zval *op1) /* {{{ */
    2281             : {
    2282             :         zend_long lval;
    2283             :         double dval;
    2284             : 
    2285             : try_again:
    2286      151001 :         switch (Z_TYPE_P(op1)) {
    2287             :                 case IS_LONG:
    2288             :                         fast_long_decrement_function(op1);
    2289          16 :                         break;
    2290             :                 case IS_DOUBLE:
    2291      150944 :                         Z_DVAL_P(op1) = Z_DVAL_P(op1) - 1;
    2292      150944 :                         break;
    2293             :                 case IS_STRING:         /* Like perl we only support string increment */
    2294          33 :                         if (Z_STRLEN_P(op1) == 0) { /* consider as 0 */
    2295           1 :                                 zend_string_release(Z_STR_P(op1));
    2296           1 :                                 ZVAL_LONG(op1, -1);
    2297           1 :                                 break;
    2298             :                         }
    2299          64 :                         switch (is_numeric_string(Z_STRVAL_P(op1), Z_STRLEN_P(op1), &lval, &dval, 0)) {
    2300             :                                 case IS_LONG:
    2301           8 :                                         zend_string_release(Z_STR_P(op1));
    2302           8 :                                         if (lval == ZEND_LONG_MIN) {
    2303           1 :                                                 double d = (double)lval;
    2304           1 :                                                 ZVAL_DOUBLE(op1, d-1);
    2305             :                                         } else {
    2306           7 :                                                 ZVAL_LONG(op1, lval-1);
    2307             :                                         }
    2308           8 :                                         break;
    2309             :                                 case IS_DOUBLE:
    2310           7 :                                         zend_string_release(Z_STR_P(op1));
    2311           7 :                                         ZVAL_DOUBLE(op1, dval - 1);
    2312             :                                         break;
    2313             :                         }
    2314          32 :                         break;
    2315             :                 case IS_OBJECT:
    2316           6 :                         if (Z_OBJ_HANDLER_P(op1, get)
    2317           3 :                            && Z_OBJ_HANDLER_P(op1, set)) {
    2318             :                                 /* proxy object */
    2319             :                                 zval rv;
    2320             :                                 zval *val;
    2321             : 
    2322           0 :                                 val = Z_OBJ_HANDLER_P(op1, get)(op1, &rv);
    2323             :                                 Z_ADDREF_P(val);
    2324           0 :                                 decrement_function(val);
    2325           0 :                                 Z_OBJ_HANDLER_P(op1, set)(op1, val);
    2326           0 :                                 zval_ptr_dtor(val);
    2327           3 :                         } else if (Z_OBJ_HANDLER_P(op1, do_operation)) {
    2328             :                                 zval op2;
    2329             :                                 int res;
    2330             : 
    2331           2 :                                 ZVAL_LONG(&op2, 1);
    2332           2 :                                 res = Z_OBJ_HANDLER_P(op1, do_operation)(ZEND_SUB, op1, op1, &op2);
    2333           2 :                                 zval_ptr_dtor(&op2);
    2334             : 
    2335           2 :                                 return res;
    2336             :                         }
    2337           1 :                         return FAILURE;
    2338             :                 case IS_REFERENCE:
    2339           0 :                         op1 = Z_REFVAL_P(op1);
    2340           0 :                         goto try_again;
    2341             :                 default:
    2342           5 :                         return FAILURE;
    2343             :         }
    2344             : 
    2345      150993 :         return SUCCESS;
    2346             : }
    2347             : /* }}} */
    2348             : 
    2349      119104 : ZEND_API int ZEND_FASTCALL zend_is_true(zval *op) /* {{{ */
    2350             : {
    2351      119103 :         return i_zend_is_true(op);
    2352             : }
    2353             : /* }}} */
    2354             : 
    2355       92362 : ZEND_API int ZEND_FASTCALL zend_object_is_true(zval *op) /* {{{ */
    2356             : {
    2357       92362 :         if (Z_OBJ_HT_P(op)->cast_object) {
    2358             :                 zval tmp;
    2359       92362 :                 if (Z_OBJ_HT_P(op)->cast_object(op, &tmp, _IS_BOOL) == SUCCESS) {
    2360       92361 :                         return Z_TYPE(tmp) == IS_TRUE;
    2361             :                 }
    2362           1 :                 zend_error(E_RECOVERABLE_ERROR, "Object of class %s could not be converted to boolean", Z_OBJ_P(op)->ce->name->val);
    2363           0 :         } else if (Z_OBJ_HT_P(op)->get) {
    2364             :                 int result;
    2365             :                 zval rv;
    2366           0 :                 zval *tmp = Z_OBJ_HT_P(op)->get(op, &rv);
    2367             : 
    2368           0 :                 if (Z_TYPE_P(tmp) != IS_OBJECT) {
    2369             :                         /* for safety - avoid loop */
    2370           0 :                         result = i_zend_is_true(tmp);
    2371           0 :                         zval_ptr_dtor(tmp);
    2372           0 :                         return result;
    2373             :                 }
    2374             :         }
    2375           0 :         return 1;
    2376             : }
    2377             : /* }}} */
    2378             : 
    2379             : #ifdef ZEND_USE_TOLOWER_L
    2380             : ZEND_API void zend_update_current_locale(void) /* {{{ */
    2381             : {
    2382             :         current_locale = _get_current_locale();
    2383             : }
    2384             : /* }}} */
    2385             : #endif
    2386             : 
    2387   134544745 : ZEND_API char* ZEND_FASTCALL zend_str_tolower_copy(char *dest, const char *source, size_t length) /* {{{ */
    2388             : {
    2389   134544745 :         register unsigned char *str = (unsigned char*)source;
    2390   134544745 :         register unsigned char *result = (unsigned char*)dest;
    2391   134544745 :         register unsigned char *end = str + length;
    2392             : 
    2393  2046525950 :         while (str < end) {
    2394  1777436460 :                 *result++ = zend_tolower_ascii(*str++);
    2395             :         }
    2396   134544745 :         *result = '\0';
    2397             : 
    2398   134544745 :         return dest;
    2399             : }
    2400             : /* }}} */
    2401             : 
    2402     4378216 : ZEND_API char* ZEND_FASTCALL zend_str_tolower_dup(const char *source, size_t length) /* {{{ */
    2403             : {
    2404     4378216 :         return zend_str_tolower_copy((char *)emalloc(length+1), source, length);
    2405             : }
    2406             : /* }}} */
    2407             : 
    2408       61266 : ZEND_API void ZEND_FASTCALL zend_str_tolower(char *str, size_t length) /* {{{ */
    2409             : {
    2410       61266 :         register unsigned char *p = (unsigned char*)str;
    2411       61266 :         register unsigned char *end = p + length;
    2412             : 
    2413      548215 :         while (p < end) {
    2414      425683 :                 *p = zend_tolower_ascii(*p);
    2415      425683 :                 p++;
    2416             :         }
    2417       61266 : }
    2418             : /* }}} */
    2419             : 
    2420      558900 : ZEND_API zend_string* ZEND_FASTCALL zend_string_tolower(zend_string *str) /* {{{ */
    2421             : {
    2422      558900 :         register unsigned char *p = (unsigned char*)str->val;
    2423      558900 :         register unsigned char *end = p + str->len;
    2424             : 
    2425    36115797 :         while (p < end) {
    2426    35203142 :                 if (*p != zend_tolower_ascii(*p)) {
    2427      410290 :                         zend_string *res = zend_string_alloc(str->len, 0);
    2428             :                         register unsigned char *r;
    2429             : 
    2430      205145 :                         if (p != (unsigned char*)str->val) {
    2431       44001 :                                 memcpy(res->val, str->val, p - (unsigned char*)str->val);
    2432             :                         }
    2433      205145 :                         r = p + (res->val - str->val);
    2434     1120585 :                         while (p < end) {
    2435      710295 :                                 *r = zend_tolower_ascii(*p);
    2436      710295 :                                 p++;
    2437      710295 :                                 r++;
    2438             :                         }
    2439      205145 :                         *r = '\0';
    2440      205145 :                         return res;
    2441             :                 }
    2442    34997997 :                 p++;
    2443             :         }
    2444      353755 :         return zend_string_copy(str);
    2445             : }
    2446             : /* }}} */
    2447             : 
    2448      821417 : ZEND_API int ZEND_FASTCALL zend_binary_strcmp(const char *s1, size_t len1, const char *s2, size_t len2) /* {{{ */
    2449             : {
    2450             :         int retval;
    2451             : 
    2452      821417 :         if (s1 == s2) {
    2453         313 :                 return 0;
    2454             :         }
    2455      821104 :         retval = memcmp(s1, s2, MIN(len1, len2));
    2456      821104 :         if (!retval) {
    2457      225373 :                 return (int)(len1 - len2);
    2458             :         } else {
    2459      595731 :                 return retval;
    2460             :         }
    2461             : }
    2462             : /* }}} */
    2463             : 
    2464       14633 : ZEND_API int ZEND_FASTCALL zend_binary_strncmp(const char *s1, size_t len1, const char *s2, size_t len2, size_t length) /* {{{ */
    2465             : {
    2466             :         int retval;
    2467             : 
    2468       14633 :         if (s1 == s2) {
    2469          44 :                 return 0;
    2470             :         }
    2471       14589 :         retval = memcmp(s1, s2, MIN(length, MIN(len1, len2)));
    2472       14589 :         if (!retval) {
    2473       14313 :                 return (int)(MIN(length, len1) - MIN(length, len2));
    2474             :         } else {
    2475         276 :                 return retval;
    2476             :         }
    2477             : }
    2478             : /* }}} */
    2479             : 
    2480      406172 : ZEND_API int ZEND_FASTCALL zend_binary_strcasecmp(const char *s1, size_t len1, const char *s2, size_t len2) /* {{{ */
    2481             : {
    2482             :         size_t len;
    2483             :         int c1, c2;
    2484             : 
    2485      406172 :         if (s1 == s2) {
    2486          50 :                 return 0;
    2487             :         }
    2488             : 
    2489      406122 :         len = MIN(len1, len2);
    2490     2163566 :         while (len--) {
    2491     1603279 :                 c1 = zend_tolower_ascii(*(unsigned char *)s1++);
    2492     1603279 :                 c2 = zend_tolower_ascii(*(unsigned char *)s2++);
    2493     1603279 :                 if (c1 != c2) {
    2494      251957 :                         return c1 - c2;
    2495             :                 }
    2496             :         }
    2497             : 
    2498      154165 :         return (int)(len1 - len2);
    2499             : }
    2500             : /* }}} */
    2501             : 
    2502       20303 : ZEND_API int ZEND_FASTCALL zend_binary_strncasecmp(const char *s1, size_t len1, const char *s2, size_t len2, size_t length) /* {{{ */
    2503             : {
    2504             :         size_t len;
    2505             :         int c1, c2;
    2506             : 
    2507       20303 :         if (s1 == s2) {
    2508          45 :                 return 0;
    2509             :         }
    2510       20258 :         len = MIN(length, MIN(len1, len2));
    2511       47727 :         while (len--) {
    2512        7674 :                 c1 = zend_tolower_ascii(*(unsigned char *)s1++);
    2513        7674 :                 c2 = zend_tolower_ascii(*(unsigned char *)s2++);
    2514        7674 :                 if (c1 != c2) {
    2515         463 :                         return c1 - c2;
    2516             :                 }
    2517             :         }
    2518             : 
    2519       19795 :         return (int)(MIN(length, len1) - MIN(length, len2));
    2520             : }
    2521             : /* }}} */
    2522             : 
    2523         125 : ZEND_API int ZEND_FASTCALL zend_binary_strcasecmp_l(const char *s1, size_t len1, const char *s2, size_t len2) /* {{{ */
    2524             : {
    2525             :         size_t len;
    2526             :         int c1, c2;
    2527             : 
    2528         125 :         if (s1 == s2) {
    2529           0 :                 return 0;
    2530             :         }
    2531             : 
    2532         125 :         len = MIN(len1, len2);
    2533         569 :         while (len--) {
    2534         407 :                 c1 = zend_tolower((int)*(unsigned char *)s1++);
    2535         407 :                 c2 = zend_tolower((int)*(unsigned char *)s2++);
    2536         407 :                 if (c1 != c2) {
    2537          88 :                         return c1 - c2;
    2538             :                 }
    2539             :         }
    2540             : 
    2541          37 :         return (int)(len1 - len2);
    2542             : }
    2543             : /* }}} */
    2544             : 
    2545           1 : ZEND_API int ZEND_FASTCALL zend_binary_strncasecmp_l(const char *s1, size_t len1, const char *s2, size_t len2, size_t length) /* {{{ */
    2546             : {
    2547             :         size_t len;
    2548             :         int c1, c2;
    2549             : 
    2550           1 :         if (s1 == s2) {
    2551           0 :                 return 0;
    2552             :         }
    2553           1 :         len = MIN(length, MIN(len1, len2));
    2554           4 :         while (len--) {
    2555           2 :                 c1 = zend_tolower((int)*(unsigned char *)s1++);
    2556           2 :                 c2 = zend_tolower((int)*(unsigned char *)s2++);
    2557           2 :                 if (c1 != c2) {
    2558           0 :                         return c1 - c2;
    2559             :                 }
    2560             :         }
    2561             : 
    2562           1 :         return (int)(MIN(length, len1) - MIN(length, len2));
    2563             : }
    2564             : /* }}} */
    2565             : 
    2566           2 : ZEND_API int ZEND_FASTCALL zend_binary_zval_strcmp(zval *s1, zval *s2) /* {{{ */
    2567             : {
    2568           2 :         return zend_binary_strcmp(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2));
    2569             : }
    2570             : /* }}} */
    2571             : 
    2572           0 : ZEND_API int ZEND_FASTCALL zend_binary_zval_strncmp(zval *s1, zval *s2, zval *s3) /* {{{ */
    2573             : {
    2574           0 :         return zend_binary_strncmp(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2), Z_LVAL_P(s3));
    2575             : }
    2576             : /* }}} */
    2577             : 
    2578           0 : ZEND_API int ZEND_FASTCALL zend_binary_zval_strcasecmp(zval *s1, zval *s2) /* {{{ */
    2579             : {
    2580           0 :         return zend_binary_strcasecmp_l(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2));
    2581             : }
    2582             : /* }}} */
    2583             : 
    2584           0 : ZEND_API int ZEND_FASTCALL zend_binary_zval_strncasecmp(zval *s1, zval *s2, zval *s3) /* {{{ */
    2585             : {
    2586           0 :         return zend_binary_strncasecmp_l(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2), Z_LVAL_P(s3));
    2587             : }
    2588             : /* }}} */
    2589             : 
    2590      632972 : ZEND_API zend_long ZEND_FASTCALL zendi_smart_strcmp(zval *s1, zval *s2) /* {{{ */
    2591             : {
    2592             :         int ret1, ret2;
    2593             :         int oflow1, oflow2;
    2594      632972 :         zend_long lval1 = 0, lval2 = 0;
    2595      632972 :         double dval1 = 0.0, dval2 = 0.0;
    2596             : 
    2597     1572700 :         if ((ret1 = is_numeric_string_ex(Z_STRVAL_P(s1), Z_STRLEN_P(s1), &lval1, &dval1, 0, &oflow1)) &&
    2598      306756 :                 (ret2 = is_numeric_string_ex(Z_STRVAL_P(s2), Z_STRLEN_P(s2), &lval2, &dval2, 0, &oflow2))) {
    2599             : #if ZEND_ULONG_MAX == 0xFFFFFFFF
    2600             :                 if (oflow1 != 0 && oflow1 == oflow2 && dval1 - dval2 == 0. &&
    2601             :                         ((oflow1 == 1 && dval1 > 9007199254740991. /*0x1FFFFFFFFFFFFF*/)
    2602             :                         || (oflow1 == -1 && dval1 < -9007199254740991.))) {
    2603             : #else
    2604      306602 :                 if (oflow1 != 0 && oflow1 == oflow2 && dval1 - dval2 == 0.) {
    2605             : #endif
    2606             :                         /* both values are integers overflown to the same side, and the
    2607             :                          * double comparison may have resulted in crucial accuracy lost */
    2608        1124 :                         goto string_cmp;
    2609             :                 }
    2610      305478 :                 if ((ret1 == IS_DOUBLE) || (ret2 == IS_DOUBLE)) {
    2611      100103 :                         if (ret1 != IS_DOUBLE) {
    2612          34 :                                 if (oflow2) {
    2613             :                                         /* 2nd operand is integer > LONG_MAX (oflow2==1) or < LONG_MIN (-1) */
    2614           2 :                                         return -1 * oflow2;
    2615             :                                 }
    2616          32 :                                 dval1 = (double) lval1;
    2617      100069 :                         } else if (ret2 != IS_DOUBLE) {
    2618          13 :                                 if (oflow1) {
    2619           0 :                                         return oflow1;
    2620             :                                 }
    2621          13 :                                 dval2 = (double) lval2;
    2622      100056 :                         } else if (dval1 == dval2 && !zend_finite(dval1)) {
    2623             :                                 /* Both values overflowed and have the same sign,
    2624             :                                  * so a numeric comparison would be inaccurate */
    2625           4 :                                 goto string_cmp;
    2626             :                         }
    2627      100097 :                         dval1 = dval1 - dval2;
    2628      100097 :                         return ZEND_NORMALIZE_BOOL(dval1);
    2629             :                 } else { /* they both have to be long's */
    2630      205375 :                         return lval1 > lval2 ? 1 : (lval1 < lval2 ? -1 : 0);
    2631             :                 }
    2632             :         } else {
    2633             :                 int strcmp_ret;
    2634             : string_cmp:
    2635      327498 :                 strcmp_ret = zend_binary_strcmp(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2));
    2636      327498 :                 return ZEND_NORMALIZE_BOOL(strcmp_ret);
    2637             :         }
    2638             : }
    2639             : /* }}} */
    2640             : 
    2641        2795 : static int hash_zval_compare_function(zval *z1, zval *z2) /* {{{ */
    2642             : {
    2643             :         zval result;
    2644             : 
    2645        2795 :         if (compare_function(&result, z1, z2)==FAILURE) {
    2646           0 :                 return 1;
    2647             :         }
    2648        2795 :         return Z_LVAL(result);
    2649             : }
    2650             : /* }}} */
    2651             : 
    2652         839 : ZEND_API int ZEND_FASTCALL zend_compare_symbol_tables(HashTable *ht1, HashTable *ht2) /* {{{ */
    2653             : {
    2654         839 :         return ht1 == ht2 ? 0 : zend_hash_compare(ht1, ht2, (compare_func_t) hash_zval_compare_function, 0);
    2655             : }
    2656             : /* }}} */
    2657             : 
    2658         528 : ZEND_API int ZEND_FASTCALL zend_compare_arrays(zval *a1, zval *a2) /* {{{ */
    2659             : {
    2660         528 :         return zend_compare_symbol_tables(Z_ARRVAL_P(a1), Z_ARRVAL_P(a2));
    2661             : }
    2662             : /* }}} */
    2663             : 
    2664           1 : ZEND_API int ZEND_FASTCALL zend_compare_objects(zval *o1, zval *o2) /* {{{ */
    2665             : {
    2666           1 :         if (Z_OBJ_P(o1) == Z_OBJ_P(o2)) {
    2667           1 :                 return 0;
    2668             :         }
    2669             : 
    2670           0 :         if (Z_OBJ_HT_P(o1)->compare_objects == NULL) {
    2671           0 :                 return 1;
    2672             :         } else {
    2673           0 :                 return Z_OBJ_HT_P(o1)->compare_objects(o1, o2);
    2674             :         }
    2675             : }
    2676             : /* }}} */
    2677             : 
    2678           0 : ZEND_API void ZEND_FASTCALL zend_locale_sprintf_double(zval *op ZEND_FILE_LINE_DC) /* {{{ */
    2679             : {
    2680             :         zend_string *str;
    2681             : 
    2682           0 :         str = zend_strpprintf(0, "%.*G", (int) EG(precision), (double)Z_DVAL_P(op));
    2683           0 :         ZVAL_NEW_STR(op, str);
    2684           0 : }
    2685             : /* }}} */
    2686             : 
    2687      389470 : ZEND_API zend_string* ZEND_FASTCALL zend_long_to_str(zend_long num) /* {{{ */
    2688             : {
    2689             :         char buf[MAX_LENGTH_OF_LONG + 1];
    2690      389470 :         char *res = zend_print_long_to_buf(buf + sizeof(buf) - 1, num);
    2691      778940 :         return zend_string_init(res, buf + sizeof(buf) - 1 - res, 0);
    2692             : }
    2693             : /* }}} */
    2694             : 
    2695        2342 : ZEND_API zend_uchar ZEND_FASTCALL is_numeric_str_function(const zend_string *str, zend_long *lval, double *dval) /* {{{ */ {
    2696        4684 :     return is_numeric_string_ex(str->val, str->len, lval, dval, -1, NULL);
    2697             : }
    2698             : /* }}} */
    2699             : 
    2700      962784 : ZEND_API zend_uchar ZEND_FASTCALL _is_numeric_string_ex(const char *str, size_t length, zend_long *lval, double *dval, int allow_errors, int *oflow_info) /* {{{ */
    2701             : {
    2702             :         const char *ptr;
    2703      962784 :         int digits = 0, dp_or_e = 0;
    2704      962784 :         double local_dval = 0.0;
    2705             :         zend_uchar type;
    2706      962784 :         zend_long tmp_lval = 0;
    2707      962784 :         int neg = 0;
    2708             : 
    2709      962784 :         if (!length) {
    2710        1401 :                 return 0;
    2711             :         }
    2712             : 
    2713      961383 :         if (oflow_info != NULL) {
    2714      826185 :                 *oflow_info = 0;
    2715             :         }
    2716             : 
    2717             :         /* Skip any whitespace
    2718             :          * This is much faster than the isspace() function */
    2719     1924625 :         while (*str == ' ' || *str == '\t' || *str == '\n' || *str == '\r' || *str == '\v' || *str == '\f') {
    2720        1859 :                 str++;
    2721        1859 :                 length--;
    2722             :         }
    2723      961383 :         ptr = str;
    2724             : 
    2725      961383 :         if (*ptr == '-') {
    2726        1691 :                 neg = 1;
    2727        1691 :                 ptr++;
    2728      959692 :         } else if (*ptr == '+') {
    2729         712 :                 ptr++;
    2730             :         }
    2731             : 
    2732     1518480 :         if (ZEND_IS_DIGIT(*ptr)) {
    2733             :                 /* Skip any leading 0s */
    2734     1790890 :                 while (*ptr == '0') {
    2735      266030 :                         ptr++;
    2736             :                 }
    2737             : 
    2738             :                 /* Count the number of digits. If a decimal point/exponent is found,
    2739             :                  * it's a double. Otherwise, if there's a dval or no need to check for
    2740             :                  * a full match, stop when there are too many digits for a long */
    2741    10895576 :                 for (type = IS_LONG; !(digits >= MAX_LENGTH_OF_LONG && (dval || allow_errors == 1)); digits++, ptr++) {
    2742             : check_digits:
    2743     5445554 :                         if (ZEND_IS_DIGIT(*ptr)) {
    2744     4685358 :                                 tmp_lval = tmp_lval * 10 + (*ptr) - '0';
    2745     4685358 :                                 continue;
    2746      760196 :                         } else if (*ptr == '.' && dp_or_e < 1) {
    2747             :                                 goto process_double;
    2748      557416 :                         } else if ((*ptr == 'e' || *ptr == 'E') && dp_or_e < 2) {
    2749         360 :                                 const char *e = ptr + 1;
    2750             : 
    2751         360 :                                 if (*e == '-' || *e == '+') {
    2752           9 :                                         ptr = e++;
    2753             :                                 }
    2754         360 :                                 if (ZEND_IS_DIGIT(*e)) {
    2755         317 :                                         goto process_double;
    2756             :                                 }
    2757             :                         }
    2758             : 
    2759      557099 :                         break;
    2760             :                 }
    2761             : 
    2762      559353 :                 if (digits >= MAX_LENGTH_OF_LONG) {
    2763        2256 :                         if (oflow_info != NULL) {
    2764        2251 :                                 *oflow_info = *str == '-' ? -1 : 1;
    2765             :                         }
    2766        2256 :                         dp_or_e = -1;
    2767        2256 :                         goto process_double;
    2768             :                 }
    2769      404448 :         } else if (*ptr == '.' && ZEND_IS_DIGIT(ptr[1])) {
    2770             : process_double:
    2771      205515 :                 type = IS_DOUBLE;
    2772             : 
    2773             :                 /* If there's a dval, do the conversion; else continue checking
    2774             :                  * the digits if we need to check for a full match */
    2775      205515 :                 if (dval) {
    2776      205493 :                         local_dval = zend_strtod(str, &ptr);
    2777          22 :                 } else if (allow_errors != 1 && dp_or_e != -1) {
    2778          20 :                         dp_or_e = (*ptr++ == '.') ? 1 : 2;
    2779          20 :                         goto check_digits;
    2780             :                 }
    2781             :         } else {
    2782      198791 :                 return 0;
    2783             :         }
    2784             : 
    2785      762592 :         if (ptr != str + length) {
    2786       14974 :                 if (!allow_errors) {
    2787       14118 :                         return 0;
    2788             :                 }
    2789         856 :                 if (allow_errors == -1) {
    2790          70 :                         zend_error(E_NOTICE, "A non well formed numeric value encountered");
    2791             :                 }
    2792             :         }
    2793             : 
    2794      748474 :         if (type == IS_LONG) {
    2795      543853 :                 if (digits == MAX_LENGTH_OF_LONG - 1) {
    2796         158 :                         int cmp = strcmp(&ptr[-digits], long_min_digits);
    2797             : 
    2798         158 :                         if (!(cmp < 0 || (cmp == 0 && *str == '-'))) {
    2799           2 :                                 if (dval) {
    2800           2 :                                         *dval = zend_strtod(str, NULL);
    2801             :                                 }
    2802           2 :                                 if (oflow_info != NULL) {
    2803           2 :                                         *oflow_info = *str == '-' ? -1 : 1;
    2804             :                                 }
    2805             : 
    2806           2 :                                 return IS_DOUBLE;
    2807             :                         }
    2808             :                 }
    2809             : 
    2810      543851 :                 if (lval) {
    2811      543792 :                         if (neg) {
    2812         499 :                                 tmp_lval = -tmp_lval;
    2813             :                         }
    2814      543792 :                         *lval = tmp_lval;
    2815             :                 }
    2816             : 
    2817      543851 :                 return IS_LONG;
    2818             :         } else {
    2819      204621 :                 if (dval) {
    2820      204603 :                         *dval = local_dval;
    2821             :                 }
    2822             : 
    2823      204621 :                 return IS_DOUBLE;
    2824             :         }
    2825             : }
    2826             : /* }}} */
    2827             : 
    2828             : /* 
    2829             :  * String matching - Sunday algorithm
    2830             :  * http://www.iti.fh-flensburg.de/lang/algorithmen/pattern/sundayen.htm
    2831             :  */
    2832             : static zend_always_inline void zend_memnstr_ex_pre(unsigned int td[], const char *needle, size_t needle_len, int reverse) /* {{{ */ {
    2833             :         int i;
    2834             : 
    2835     3838295 :         for (i = 0; i < 256; i++) {
    2836     3823360 :                 td[i] = needle_len + 1;
    2837             :         }
    2838             : 
    2839       14935 :         if (reverse) {
    2840           0 :                 for (i = needle_len - 1; i >= 0; i--) {
    2841           0 :                         td[(unsigned char)needle[i]] = i + 1;
    2842             :                 }
    2843             :         } else {
    2844      237535 :                 for (i = 0; i < needle_len; i++) {
    2845      222600 :                         td[(unsigned char)needle[i]] = (int)needle_len - i;
    2846             :                 }
    2847             :         }
    2848             : }
    2849             : /* }}} */
    2850             : 
    2851       14935 : ZEND_API const char* ZEND_FASTCALL zend_memnstr_ex(const char *haystack, const char *needle, size_t needle_len, char *end) /* {{{ */
    2852             : {
    2853             :         unsigned int td[256];
    2854             :         register size_t i;
    2855             :         register const char *p;
    2856             : 
    2857       14935 :         if (needle_len == 0 || (end - haystack) == 0) {
    2858           0 :                 return NULL;
    2859             :         }
    2860             : 
    2861             :         zend_memnstr_ex_pre(td, needle, needle_len, 0);
    2862             : 
    2863       14935 :         p = haystack;
    2864       14935 :         end -= needle_len;
    2865             : 
    2866     3876494 :         while (p <= end) {
    2867     3952481 :                 for (i = 0; i < needle_len; i++) {
    2868     3947984 :                         if (needle[i] != p[i]) {
    2869     3846624 :                                 break;
    2870             :                         }
    2871             :                 }
    2872     3851121 :                 if (i == needle_len) {
    2873        4497 :                         return p;
    2874             :                 }
    2875     3846624 :                 p += td[(unsigned char)(p[needle_len])];
    2876             :         }
    2877             : 
    2878       10438 :         return NULL;
    2879             : }
    2880             : /* }}} */
    2881             : 
    2882           0 : ZEND_API const char* ZEND_FASTCALL zend_memnrstr_ex(const char *haystack, const char *needle, size_t needle_len, char *end) /* {{{ */
    2883             : {
    2884             :         unsigned int td[256];
    2885             :         register size_t i;
    2886             :         register const char *p;
    2887             : 
    2888           0 :         if (needle_len == 0 || (end - haystack) == 0) {
    2889           0 :                 return NULL;
    2890             :         }
    2891             : 
    2892             :         zend_memnstr_ex_pre(td, needle, needle_len, 1);
    2893             : 
    2894           0 :         p = end;
    2895           0 :         p -= needle_len;
    2896             : 
    2897           0 :         while (p >= haystack) {
    2898           0 :                 for (i = 0; i < needle_len; i++) {
    2899           0 :                         if (needle[i] != p[i]) {
    2900           0 :                                 break;
    2901             :                         }
    2902             :                 }
    2903             : 
    2904           0 :                 if (i == needle_len) {
    2905           0 :                         return (const char *)p;
    2906             :                 }
    2907             :                 
    2908           0 :                 if (UNEXPECTED(p == haystack)) {
    2909           0 :                         return NULL;
    2910             :                 }
    2911             : 
    2912           0 :                 p -= td[(unsigned char)(p[-1])];
    2913             :         }
    2914             : 
    2915           0 :         return NULL;
    2916             : }
    2917             : /* }}} */
    2918             : 
    2919             : #if !ZEND_DVAL_TO_LVAL_CAST_OK
    2920             : # if SIZEOF_ZEND_LONG == 4
    2921             : ZEND_API zend_long ZEND_FASTCALL zend_dval_to_lval_slow(double d)
    2922             : {
    2923             :         double  two_pow_32 = pow(2., 32.),
    2924             :                         dmod;
    2925             : 
    2926             :         dmod = fmod(d, two_pow_32);
    2927             :         if (dmod < 0) {
    2928             :                 /* we're going to make this number positive; call ceil()
    2929             :                  * to simulate rounding towards 0 of the negative number */
    2930             :                 dmod = ceil(dmod);// + two_pow_32;
    2931             :         }
    2932             :         return (zend_long)(zend_ulong)dmod;
    2933             : }
    2934             : #else
    2935         140 : ZEND_API zend_long ZEND_FASTCALL zend_dval_to_lval_slow(double d)
    2936             : {
    2937         140 :         double  two_pow_64 = pow(2., 64.),
    2938             :                         dmod;
    2939             : 
    2940         140 :         dmod = fmod(d, two_pow_64);
    2941         140 :         if (dmod < 0) {
    2942             :                 /* no need to call ceil; original double must have had no
    2943             :                  * fractional part, hence dmod does not have one either */
    2944           7 :                 dmod += two_pow_64;
    2945             :         }
    2946         140 :         return (zend_long)(zend_ulong)dmod;
    2947             : }
    2948             : #endif
    2949             : #endif
    2950             : 
    2951             : /*
    2952             :  * Local variables:
    2953             :  * tab-width: 4
    2954             :  * c-basic-offset: 4
    2955             :  * indent-tabs-mode: t
    2956             :  * End:
    2957             :  */

Generated by: LCOV version 1.10

Generated at Fri, 31 Jul 2015 08:58:46 +0000 (2 days ago)

Copyright © 2005-2015 The PHP Group
All rights reserved.