diff options
Diffstat (limited to 'Zend/zend_operators.c')
| -rw-r--r-- | Zend/zend_operators.c | 2151 |
1 files changed, 2151 insertions, 0 deletions
diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c new file mode 100644 index 0000000..594f1f1 --- /dev/null +++ b/Zend/zend_operators.c @@ -0,0 +1,2151 @@ +/* + +----------------------------------------------------------------------+ + | Zend Engine | + +----------------------------------------------------------------------+ + | Copyright (c) 1998-2013 Zend Technologies Ltd. (http://www.zend.com) | + +----------------------------------------------------------------------+ + | This source file is subject to version 2.00 of the Zend license, | + | that is bundled with this package in the file LICENSE, and is | + | available through the world-wide-web at the following url: | + | http://www.zend.com/license/2_00.txt. | + | If you did not receive a copy of the Zend license and are unable to | + | obtain it through the world-wide-web, please send a note to | + | license@zend.com so we can mail you a copy immediately. | + +----------------------------------------------------------------------+ + | Authors: Andi Gutmans <andi@zend.com> | + | Zeev Suraski <zeev@zend.com> | + +----------------------------------------------------------------------+ +*/ + +/* $Id$ */ + +#include <ctype.h> + +#include "zend.h" +#include "zend_operators.h" +#include "zend_variables.h" +#include "zend_globals.h" +#include "zend_list.h" +#include "zend_API.h" +#include "zend_strtod.h" +#include "zend_exceptions.h" +#include "zend_closures.h" + +#if ZEND_USE_TOLOWER_L +#include <locale.h> +static _locale_t current_locale = NULL; +/* this is true global! may lead to strange effects on ZTS, but so may setlocale() */ +#define zend_tolower(c) _tolower_l(c, current_locale) +#else +#define zend_tolower(c) tolower(c) +#endif + +#define TYPE_PAIR(t1,t2) (((t1) << 4) | (t2)) + +ZEND_API int zend_atoi(const char *str, int str_len) /* {{{ */ +{ + int retval; + + if (!str_len) { + str_len = strlen(str); + } + retval = strtol(str, NULL, 0); + if (str_len>0) { + switch (str[str_len-1]) { + case 'g': + case 'G': + retval *= 1024; + /* break intentionally missing */ + case 'm': + case 'M': + retval *= 1024; + /* break intentionally missing */ + case 'k': + case 'K': + retval *= 1024; + break; + } + } + return retval; +} +/* }}} */ + +ZEND_API long zend_atol(const char *str, int str_len) /* {{{ */ +{ + long retval; + + if (!str_len) { + str_len = strlen(str); + } + retval = strtol(str, NULL, 0); + if (str_len>0) { + switch (str[str_len-1]) { + case 'g': + case 'G': + retval *= 1024; + /* break intentionally missing */ + case 'm': + case 'M': + retval *= 1024; + /* break intentionally missing */ + case 'k': + case 'K': + retval *= 1024; + break; + } + } + return retval; +} +/* }}} */ + +ZEND_API double zend_string_to_double(const char *number, zend_uint length) /* {{{ */ +{ + double divisor = 10.0; + double result = 0.0; + double exponent; + const char *end = number+length; + const char *digit = number; + + if (!length) { + return result; + } + + while (digit < end) { + if ((*digit <= '9' && *digit >= '0')) { + result *= 10; + result += *digit - '0'; + } else if (*digit == '.') { + digit++; + break; + } else if (toupper(*digit) == 'E') { + exponent = (double) atoi(digit+1); + result *= pow(10.0, exponent); + return result; + } else { + return result; + } + digit++; + } + + while (digit < end) { + if ((*digit <= '9' && *digit >= '0')) { + result += (*digit - '0') / divisor; + divisor *= 10; + } else if (toupper(*digit) == 'E') { + exponent = (double) atoi(digit+1); + result *= pow(10.0, exponent); + return result; + } else { + return result; + } + digit++; + } + return result; +} +/* }}} */ + +ZEND_API void convert_scalar_to_number(zval *op TSRMLS_DC) /* {{{ */ +{ + switch (Z_TYPE_P(op)) { + case IS_STRING: + { + char *strval; + + strval = Z_STRVAL_P(op); + if ((Z_TYPE_P(op)=is_numeric_string(strval, Z_STRLEN_P(op), &Z_LVAL_P(op), &Z_DVAL_P(op), 1)) == 0) { + ZVAL_LONG(op, 0); + } + STR_FREE(strval); + break; + } + case IS_BOOL: + Z_TYPE_P(op) = IS_LONG; + break; + case IS_RESOURCE: + zend_list_delete(Z_LVAL_P(op)); + Z_TYPE_P(op) = IS_LONG; + break; + case IS_OBJECT: + convert_to_long_base(op, 10); + break; + case IS_NULL: + ZVAL_LONG(op, 0); + break; + } +} +/* }}} */ + +/* {{{ zendi_convert_scalar_to_number */ +#define zendi_convert_scalar_to_number(op, holder, result) \ + if (op==result) { \ + if (Z_TYPE_P(op) != IS_LONG) { \ + convert_scalar_to_number(op TSRMLS_CC); \ + } \ + } else { \ + switch (Z_TYPE_P(op)) { \ + case IS_STRING: \ + { \ + if ((Z_TYPE(holder)=is_numeric_string(Z_STRVAL_P(op), Z_STRLEN_P(op), &Z_LVAL(holder), &Z_DVAL(holder), 1)) == 0) { \ + ZVAL_LONG(&(holder), 0); \ + } \ + (op) = &(holder); \ + break; \ + } \ + case IS_BOOL: \ + case IS_RESOURCE: \ + ZVAL_LONG(&(holder), Z_LVAL_P(op)); \ + (op) = &(holder); \ + break; \ + case IS_NULL: \ + ZVAL_LONG(&(holder), 0); \ + (op) = &(holder); \ + break; \ + case IS_OBJECT: \ + (holder) = (*(op)); \ + zval_copy_ctor(&(holder)); \ + convert_to_long_base(&(holder), 10); \ + if (Z_TYPE(holder) == IS_LONG) { \ + (op) = &(holder); \ + } \ + break; \ + } \ + } + +/* }}} */ + +/* {{{ zendi_convert_to_long */ +#define zendi_convert_to_long(op, holder, result) \ + if (op == result) { \ + convert_to_long(op); \ + } else if (Z_TYPE_P(op) != IS_LONG) { \ + switch (Z_TYPE_P(op)) { \ + case IS_NULL: \ + Z_LVAL(holder) = 0; \ + break; \ + case IS_DOUBLE: \ + Z_LVAL(holder) = zend_dval_to_lval(Z_DVAL_P(op)); \ + break; \ + case IS_STRING: \ + Z_LVAL(holder) = strtol(Z_STRVAL_P(op), NULL, 10); \ + break; \ + case IS_ARRAY: \ + Z_LVAL(holder) = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); \ + break; \ + case IS_OBJECT: \ + (holder) = (*(op)); \ + zval_copy_ctor(&(holder)); \ + convert_to_long_base(&(holder), 10); \ + break; \ + case IS_BOOL: \ + case IS_RESOURCE: \ + Z_LVAL(holder) = Z_LVAL_P(op); \ + break; \ + default: \ + zend_error(E_WARNING, "Cannot convert to ordinal value"); \ + Z_LVAL(holder) = 0; \ + break; \ + } \ + Z_TYPE(holder) = IS_LONG; \ + (op) = &(holder); \ + } + +/* }}} */ + +/* {{{ zendi_convert_to_boolean */ +#define zendi_convert_to_boolean(op, holder, result) \ + if (op==result) { \ + convert_to_boolean(op); \ + } else if (Z_TYPE_P(op) != IS_BOOL) { \ + switch (Z_TYPE_P(op)) { \ + case IS_NULL: \ + Z_LVAL(holder) = 0; \ + break; \ + case IS_RESOURCE: \ + case IS_LONG: \ + Z_LVAL(holder) = (Z_LVAL_P(op) ? 1 : 0); \ + break; \ + case IS_DOUBLE: \ + Z_LVAL(holder) = (Z_DVAL_P(op) ? 1 : 0); \ + break; \ + case IS_STRING: \ + if (Z_STRLEN_P(op) == 0 \ + || (Z_STRLEN_P(op)==1 && Z_STRVAL_P(op)[0]=='0')) { \ + Z_LVAL(holder) = 0; \ + } else { \ + Z_LVAL(holder) = 1; \ + } \ + break; \ + case IS_ARRAY: \ + Z_LVAL(holder) = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); \ + break; \ + case IS_OBJECT: \ + (holder) = (*(op)); \ + zval_copy_ctor(&(holder)); \ + convert_to_boolean(&(holder)); \ + break; \ + default: \ + Z_LVAL(holder) = 0; \ + break; \ + } \ + Z_TYPE(holder) = IS_BOOL; \ + (op) = &(holder); \ + } + +/* }}} */ + +/* {{{ convert_object_to_type */ +#define convert_object_to_type(op, ctype, conv_func) \ + if (Z_OBJ_HT_P(op)->cast_object) { \ + zval dst; \ + if (Z_OBJ_HT_P(op)->cast_object(op, &dst, ctype TSRMLS_CC) == FAILURE) { \ + zend_error(E_RECOVERABLE_ERROR, \ + "Object of class %s could not be converted to %s", Z_OBJCE_P(op)->name, \ + zend_get_type_by_const(ctype)); \ + } else { \ + zval_dtor(op); \ + Z_TYPE_P(op) = ctype; \ + op->value = dst.value; \ + } \ + } else { \ + if (Z_OBJ_HT_P(op)->get) { \ + zval *newop = Z_OBJ_HT_P(op)->get(op TSRMLS_CC); \ + if (Z_TYPE_P(newop) != IS_OBJECT) { \ + /* for safety - avoid loop */ \ + zval_dtor(op); \ + *op = *newop; \ + FREE_ZVAL(newop); \ + conv_func(op); \ + } \ + } \ + } + +/* }}} */ + +ZEND_API void convert_to_long(zval *op) /* {{{ */ +{ + if (Z_TYPE_P(op) != IS_LONG) { + convert_to_long_base(op, 10); + } +} +/* }}} */ + +ZEND_API void convert_to_long_base(zval *op, int base) /* {{{ */ +{ + long tmp; + + switch (Z_TYPE_P(op)) { + case IS_NULL: + Z_LVAL_P(op) = 0; + break; + case IS_RESOURCE: { + TSRMLS_FETCH(); + + zend_list_delete(Z_LVAL_P(op)); + } + /* break missing intentionally */ + case IS_BOOL: + case IS_LONG: + break; + case IS_DOUBLE: + Z_LVAL_P(op) = zend_dval_to_lval(Z_DVAL_P(op)); + break; + case IS_STRING: + { + char *strval = Z_STRVAL_P(op); + + Z_LVAL_P(op) = strtol(strval, NULL, base); + STR_FREE(strval); + } + break; + case IS_ARRAY: + tmp = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); + zval_dtor(op); + Z_LVAL_P(op) = tmp; + break; + case IS_OBJECT: + { + int retval = 1; + TSRMLS_FETCH(); + + convert_object_to_type(op, IS_LONG, convert_to_long); + + if (Z_TYPE_P(op) == IS_LONG) { + return; + } + zend_error(E_NOTICE, "Object of class %s could not be converted to int", Z_OBJCE_P(op)->name); + + zval_dtor(op); + ZVAL_LONG(op, retval); + return; + } + default: + zend_error(E_WARNING, "Cannot convert to ordinal value"); + zval_dtor(op); + Z_LVAL_P(op) = 0; + break; + } + + Z_TYPE_P(op) = IS_LONG; +} +/* }}} */ + +ZEND_API void convert_to_double(zval *op) /* {{{ */ +{ + double tmp; + + switch (Z_TYPE_P(op)) { + case IS_NULL: + Z_DVAL_P(op) = 0.0; + break; + case IS_RESOURCE: { + TSRMLS_FETCH(); + + zend_list_delete(Z_LVAL_P(op)); + } + /* break missing intentionally */ + case IS_BOOL: + case IS_LONG: + Z_DVAL_P(op) = (double) Z_LVAL_P(op); + break; + case IS_DOUBLE: + break; + case IS_STRING: + { + char *strval = Z_STRVAL_P(op); + + Z_DVAL_P(op) = zend_strtod(strval, NULL); + STR_FREE(strval); + } + break; + case IS_ARRAY: + tmp = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); + zval_dtor(op); + Z_DVAL_P(op) = tmp; + break; + case IS_OBJECT: + { + double retval = 1.0; + TSRMLS_FETCH(); + + convert_object_to_type(op, IS_DOUBLE, convert_to_double); + + if (Z_TYPE_P(op) == IS_DOUBLE) { + return; + } + zend_error(E_NOTICE, "Object of class %s could not be converted to double", Z_OBJCE_P(op)->name); + + zval_dtor(op); + ZVAL_DOUBLE(op, retval); + break; + } + default: + zend_error(E_WARNING, "Cannot convert to real value (type=%d)", Z_TYPE_P(op)); + zval_dtor(op); + Z_DVAL_P(op) = 0; + break; + } + Z_TYPE_P(op) = IS_DOUBLE; +} +/* }}} */ + +ZEND_API void convert_to_null(zval *op) /* {{{ */ +{ + if (Z_TYPE_P(op) == IS_OBJECT) { + if (Z_OBJ_HT_P(op)->cast_object) { + zval *org; + TSRMLS_FETCH(); + + ALLOC_ZVAL(org); + *org = *op; + if (Z_OBJ_HT_P(op)->cast_object(org, op, IS_NULL TSRMLS_CC) == SUCCESS) { + zval_dtor(org); + return; + } + *op = *org; + FREE_ZVAL(org); + } + } + + zval_dtor(op); + Z_TYPE_P(op) = IS_NULL; +} +/* }}} */ + +ZEND_API void convert_to_boolean(zval *op) /* {{{ */ +{ + int tmp; + + switch (Z_TYPE_P(op)) { + case IS_BOOL: + break; + case IS_NULL: + Z_LVAL_P(op) = 0; + break; + case IS_RESOURCE: { + TSRMLS_FETCH(); + + zend_list_delete(Z_LVAL_P(op)); + } + /* break missing intentionally */ + case IS_LONG: + Z_LVAL_P(op) = (Z_LVAL_P(op) ? 1 : 0); + break; + case IS_DOUBLE: + Z_LVAL_P(op) = (Z_DVAL_P(op) ? 1 : 0); + break; + case IS_STRING: + { + char *strval = Z_STRVAL_P(op); + + if (Z_STRLEN_P(op) == 0 + || (Z_STRLEN_P(op)==1 && Z_STRVAL_P(op)[0]=='0')) { + Z_LVAL_P(op) = 0; + } else { + Z_LVAL_P(op) = 1; + } + STR_FREE(strval); + } + break; + case IS_ARRAY: + tmp = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); + zval_dtor(op); + Z_LVAL_P(op) = tmp; + break; + case IS_OBJECT: + { + zend_bool retval = 1; + TSRMLS_FETCH(); + + convert_object_to_type(op, IS_BOOL, convert_to_boolean); + + if (Z_TYPE_P(op) == IS_BOOL) { + return; + } + + zval_dtor(op); + ZVAL_BOOL(op, retval); + break; + } + default: + zval_dtor(op); + Z_LVAL_P(op) = 0; + break; + } + Z_TYPE_P(op) = IS_BOOL; +} +/* }}} */ + +ZEND_API void _convert_to_string(zval *op ZEND_FILE_LINE_DC) /* {{{ */ +{ + long lval; + double dval; + + switch (Z_TYPE_P(op)) { + case IS_NULL: + Z_STRVAL_P(op) = STR_EMPTY_ALLOC(); + Z_STRLEN_P(op) = 0; + break; + case IS_STRING: + break; + case IS_BOOL: + if (Z_LVAL_P(op)) { + Z_STRVAL_P(op) = estrndup_rel("1", 1); + Z_STRLEN_P(op) = 1; + } else { + Z_STRVAL_P(op) = STR_EMPTY_ALLOC(); + Z_STRLEN_P(op) = 0; + } + break; + case IS_RESOURCE: { + long tmp = Z_LVAL_P(op); + TSRMLS_FETCH(); + + zend_list_delete(Z_LVAL_P(op)); + Z_STRLEN_P(op) = zend_spprintf(&Z_STRVAL_P(op), 0, "Resource id #%ld", tmp); + break; + } + case IS_LONG: + lval = Z_LVAL_P(op); + + Z_STRLEN_P(op) = zend_spprintf(&Z_STRVAL_P(op), 0, "%ld", lval); + break; + case IS_DOUBLE: { + TSRMLS_FETCH(); + dval = Z_DVAL_P(op); + Z_STRLEN_P(op) = zend_spprintf(&Z_STRVAL_P(op), 0, "%.*G", (int) EG(precision), dval); + /* %G already handles removing trailing zeros from the fractional part, yay */ + break; + } + case IS_ARRAY: + zend_error(E_NOTICE, "Array to string conversion"); + zval_dtor(op); + Z_STRVAL_P(op) = estrndup_rel("Array", sizeof("Array")-1); + Z_STRLEN_P(op) = sizeof("Array")-1; + break; + case IS_OBJECT: { + TSRMLS_FETCH(); + + convert_object_to_type(op, IS_STRING, convert_to_string); + + if (Z_TYPE_P(op) == IS_STRING) { + return; + } + + zend_error(E_NOTICE, "Object of class %s to string conversion", Z_OBJCE_P(op)->name); + zval_dtor(op); + Z_STRVAL_P(op) = estrndup_rel("Object", sizeof("Object")-1); + Z_STRLEN_P(op) = sizeof("Object")-1; + break; + } + default: + zval_dtor(op); + ZVAL_BOOL(op, 0); + break; + } + Z_TYPE_P(op) = IS_STRING; +} +/* }}} */ + +static void convert_scalar_to_array(zval *op, int type TSRMLS_DC) /* {{{ */ +{ + zval *entry; + + ALLOC_ZVAL(entry); + *entry = *op; + INIT_PZVAL(entry); + + switch (type) { + case IS_ARRAY: + ALLOC_HASHTABLE(Z_ARRVAL_P(op)); + zend_hash_init(Z_ARRVAL_P(op), 0, NULL, ZVAL_PTR_DTOR, 0); + zend_hash_index_update(Z_ARRVAL_P(op), 0, (void *) &entry, sizeof(zval *), NULL); + Z_TYPE_P(op) = IS_ARRAY; + break; + case IS_OBJECT: + object_init(op); + zend_hash_update(Z_OBJPROP_P(op), "scalar", sizeof("scalar"), (void *) &entry, sizeof(zval *), NULL); + break; + } +} +/* }}} */ + +ZEND_API void convert_to_array(zval *op) /* {{{ */ +{ + TSRMLS_FETCH(); + + switch (Z_TYPE_P(op)) { + case IS_ARRAY: + break; +/* OBJECTS_OPTIMIZE */ + case IS_OBJECT: + { + zval *tmp; + HashTable *ht; + + ALLOC_HASHTABLE(ht); + zend_hash_init(ht, 0, NULL, ZVAL_PTR_DTOR, 0); + if (Z_OBJCE_P(op) == zend_ce_closure) { + convert_scalar_to_array(op, IS_ARRAY TSRMLS_CC); + if (Z_TYPE_P(op) == IS_ARRAY) { + zend_hash_destroy(ht); + FREE_HASHTABLE(ht); + return; + } + } else if (Z_OBJ_HT_P(op)->get_properties) { + HashTable *obj_ht = Z_OBJ_HT_P(op)->get_properties(op TSRMLS_CC); + if (obj_ht) { + zend_hash_copy(ht, obj_ht, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *)); + } + } else { + convert_object_to_type(op, IS_ARRAY, convert_to_array); + + if (Z_TYPE_P(op) == IS_ARRAY) { + zend_hash_destroy(ht); + FREE_HASHTABLE(ht); + return; + } + } + zval_dtor(op); + Z_TYPE_P(op) = IS_ARRAY; + Z_ARRVAL_P(op) = ht; + } + break; + case IS_NULL: + ALLOC_HASHTABLE(Z_ARRVAL_P(op)); + zend_hash_init(Z_ARRVAL_P(op), 0, NULL, ZVAL_PTR_DTOR, 0); + Z_TYPE_P(op) = IS_ARRAY; + break; + default: + convert_scalar_to_array(op, IS_ARRAY TSRMLS_CC); + break; + } +} +/* }}} */ + +ZEND_API void convert_to_object(zval *op) /* {{{ */ +{ + TSRMLS_FETCH(); + + switch (Z_TYPE_P(op)) { + case IS_ARRAY: + { + object_and_properties_init(op, zend_standard_class_def, Z_ARRVAL_P(op)); + break; + } + case IS_OBJECT: + break; + case IS_NULL: + object_init(op); + break; + default: + convert_scalar_to_array(op, IS_OBJECT TSRMLS_CC); + break; + } +} +/* }}} */ + +ZEND_API void multi_convert_to_long_ex(int argc, ...) /* {{{ */ +{ + zval **arg; + va_list ap; + + va_start(ap, argc); + + while (argc--) { + arg = va_arg(ap, zval **); + convert_to_long_ex(arg); + } + + va_end(ap); +} +/* }}} */ + +ZEND_API void multi_convert_to_double_ex(int argc, ...) /* {{{ */ +{ + zval **arg; + va_list ap; + + va_start(ap, argc); + + while (argc--) { + arg = va_arg(ap, zval **); + convert_to_double_ex(arg); + } + + va_end(ap); +} +/* }}} */ + +ZEND_API void multi_convert_to_string_ex(int argc, ...) /* {{{ */ +{ + zval **arg; + va_list ap; + + va_start(ap, argc); + + while (argc--) { + arg = va_arg(ap, zval **); + convert_to_string_ex(arg); + } + + va_end(ap); +} +/* }}} */ + +ZEND_API int add_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + zval op1_copy, op2_copy; + int converted = 0; + + while (1) { + switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) { + case TYPE_PAIR(IS_LONG, IS_LONG): { + long lval = Z_LVAL_P(op1) + Z_LVAL_P(op2); + + /* check for overflow by comparing sign bits */ + if ((Z_LVAL_P(op1) & LONG_SIGN_MASK) == (Z_LVAL_P(op2) & LONG_SIGN_MASK) + && (Z_LVAL_P(op1) & LONG_SIGN_MASK) != (lval & LONG_SIGN_MASK)) { + + ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) + (double) Z_LVAL_P(op2)); + } else { + ZVAL_LONG(result, lval); + } + return SUCCESS; + } + + case TYPE_PAIR(IS_LONG, IS_DOUBLE): + ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2)); + return SUCCESS; + + case TYPE_PAIR(IS_DOUBLE, IS_LONG): + ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2))); + return SUCCESS; + + case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE): + ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2)); + return SUCCESS; + + case TYPE_PAIR(IS_ARRAY, IS_ARRAY): { + zval *tmp; + + if ((result == op1) && (result == op2)) { + /* $a += $a */ + return SUCCESS; + } + if (result != op1) { + *result = *op1; + zval_copy_ctor(result); + } + zend_hash_merge(Z_ARRVAL_P(result), Z_ARRVAL_P(op2), (void (*)(void *pData)) zval_add_ref, (void *) &tmp, sizeof(zval *), 0); + return SUCCESS; + } + + default: + if (!converted) { + zendi_convert_scalar_to_number(op1, op1_copy, result); + zendi_convert_scalar_to_number(op2, op2_copy, result); + converted = 1; + } else { + zend_error(E_ERROR, "Unsupported operand types"); + return FAILURE; /* unknown datatype */ + } + } + } +} +/* }}} */ + +ZEND_API int sub_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + zval op1_copy, op2_copy; + int converted = 0; + + while (1) { + switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) { + case TYPE_PAIR(IS_LONG, IS_LONG): { + long lval = Z_LVAL_P(op1) - Z_LVAL_P(op2); + + /* check for overflow by comparing sign bits */ + if ((Z_LVAL_P(op1) & LONG_SIGN_MASK) != (Z_LVAL_P(op2) & LONG_SIGN_MASK) + && (Z_LVAL_P(op1) & LONG_SIGN_MASK) != (lval & LONG_SIGN_MASK)) { + + ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) - (double) Z_LVAL_P(op2)); + } else { + ZVAL_LONG(result, lval); + } + return SUCCESS; + + } + case TYPE_PAIR(IS_LONG, IS_DOUBLE): + ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) - Z_DVAL_P(op2)); + return SUCCESS; + + case TYPE_PAIR(IS_DOUBLE, IS_LONG): + ZVAL_DOUBLE(result, Z_DVAL_P(op1) - ((double)Z_LVAL_P(op2))); + return SUCCESS; + + case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE): + ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2)); + return SUCCESS; + + default: + if (!converted) { + zendi_convert_scalar_to_number(op1, op1_copy, result); + zendi_convert_scalar_to_number(op2, op2_copy, result); + converted = 1; + } else { + zend_error(E_ERROR, "Unsupported operand types"); + return FAILURE; /* unknown datatype */ + } + } + } +} +/* }}} */ + +ZEND_API int mul_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + zval op1_copy, op2_copy; + int converted = 0; + + while (1) { + switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) { + case TYPE_PAIR(IS_LONG, IS_LONG): { + long overflow; + + ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1),Z_LVAL_P(op2), Z_LVAL_P(result),Z_DVAL_P(result),overflow); + Z_TYPE_P(result) = overflow ? IS_DOUBLE : IS_LONG; + return SUCCESS; + + } + case TYPE_PAIR(IS_LONG, IS_DOUBLE): + ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) * Z_DVAL_P(op2)); + return SUCCESS; + + case TYPE_PAIR(IS_DOUBLE, IS_LONG): + ZVAL_DOUBLE(result, Z_DVAL_P(op1) * ((double)Z_LVAL_P(op2))); + return SUCCESS; + + case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE): + ZVAL_DOUBLE(result, Z_DVAL_P(op1) * Z_DVAL_P(op2)); + return SUCCESS; + + default: + if (!converted) { + zendi_convert_scalar_to_number(op1, op1_copy, result); + zendi_convert_scalar_to_number(op2, op2_copy, result); + converted = 1; + } else { + zend_error(E_ERROR, "Unsupported operand types"); + return FAILURE; /* unknown datatype */ + } + } + } +} +/* }}} */ + +ZEND_API int div_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + zval op1_copy, op2_copy; + int converted = 0; + + while (1) { + switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) { + case TYPE_PAIR(IS_LONG, IS_LONG): + if (Z_LVAL_P(op2) == 0) { + zend_error(E_WARNING, "Division by zero"); + ZVAL_BOOL(result, 0); + return FAILURE; /* division by zero */ + } else if (Z_LVAL_P(op2) == -1 && Z_LVAL_P(op1) == LONG_MIN) { + /* Prevent overflow error/crash */ + ZVAL_DOUBLE(result, (double) LONG_MIN / -1); + return SUCCESS; + } + if (Z_LVAL_P(op1) % Z_LVAL_P(op2) == 0) { /* integer */ + ZVAL_LONG(result, Z_LVAL_P(op1) / Z_LVAL_P(op2)); + } else { + ZVAL_DOUBLE(result, ((double) Z_LVAL_P(op1)) / Z_LVAL_P(op2)); + } + return SUCCESS; + + case TYPE_PAIR(IS_DOUBLE, IS_LONG): + if (Z_LVAL_P(op2) == 0) { + zend_error(E_WARNING, "Division by zero"); + ZVAL_BOOL(result, 0); + return FAILURE; /* division by zero */ + } + ZVAL_DOUBLE(result, Z_DVAL_P(op1) / (double)Z_LVAL_P(op2)); + return SUCCESS; + + case TYPE_PAIR(IS_LONG, IS_DOUBLE): + if (Z_DVAL_P(op2) == 0) { + zend_error(E_WARNING, "Division by zero"); + ZVAL_BOOL(result, 0); + return FAILURE; /* division by zero */ + } + ZVAL_DOUBLE(result, (double)Z_LVAL_P(op1) / Z_DVAL_P(op2)); + return SUCCESS; + + case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE): + if (Z_DVAL_P(op2) == 0) { + zend_error(E_WARNING, "Division by zero"); + ZVAL_BOOL(result, 0); + return FAILURE; /* division by zero */ + } + ZVAL_DOUBLE(result, Z_DVAL_P(op1) / Z_DVAL_P(op2)); + return SUCCESS; + + default: + if (!converted) { + zendi_convert_scalar_to_number(op1, op1_copy, result); + zendi_convert_scalar_to_number(op2, op2_copy, result); + converted = 1; + } else { + zend_error(E_ERROR, "Unsupported operand types"); + return FAILURE; /* unknown datatype */ + } + } + } +} +/* }}} */ + +ZEND_API int mod_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + zval op1_copy, op2_copy; + long op1_lval; + + zendi_convert_to_long(op1, op1_copy, result); + op1_lval = Z_LVAL_P(op1); + zendi_convert_to_long(op2, op2_copy, result); + + if (Z_LVAL_P(op2) == 0) { + zend_error(E_WARNING, "Division by zero"); + ZVAL_BOOL(result, 0); + return FAILURE; /* modulus by zero */ + } + + if (Z_LVAL_P(op2) == -1) { + /* Prevent overflow error/crash if op1==LONG_MIN */ + ZVAL_LONG(result, 0); + return SUCCESS; + } + + ZVAL_LONG(result, op1_lval % Z_LVAL_P(op2)); + return SUCCESS; +} +/* }}} */ + +ZEND_API int boolean_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + zval op1_copy, op2_copy; + long op1_lval; + + zendi_convert_to_boolean(op1, op1_copy, result); + op1_lval = Z_LVAL_P(op1); + zendi_convert_to_boolean(op2, op2_copy, result); + ZVAL_BOOL(result, op1_lval ^ Z_LVAL_P(op2)); + return SUCCESS; +} +/* }}} */ + +ZEND_API int boolean_not_function(zval *result, zval *op1 TSRMLS_DC) /* {{{ */ +{ + zval op1_copy; + + zendi_convert_to_boolean(op1, op1_copy, result); + ZVAL_BOOL(result, !Z_LVAL_P(op1)); + return SUCCESS; +} +/* }}} */ + +ZEND_API int bitwise_not_function(zval *result, zval *op1 TSRMLS_DC) /* {{{ */ +{ + zval op1_copy = *op1; + + op1 = &op1_copy; + + if (Z_TYPE_P(op1) == IS_LONG) { + ZVAL_LONG(result, ~Z_LVAL_P(op1)); + return SUCCESS; + } else if (Z_TYPE_P(op1) == IS_DOUBLE) { + ZVAL_LONG(result, ~zend_dval_to_lval(Z_DVAL_P(op1))); + return SUCCESS; + } else if (Z_TYPE_P(op1) == IS_STRING) { + int i; + + Z_TYPE_P(result) = IS_STRING; + Z_STRVAL_P(result) = estrndup(Z_STRVAL_P(op1), Z_STRLEN_P(op1)); + Z_STRLEN_P(result) = Z_STRLEN_P(op1); + for (i = 0; i < Z_STRLEN_P(op1); i++) { + Z_STRVAL_P(result)[i] = ~Z_STRVAL_P(op1)[i]; + } + return SUCCESS; + } + zend_error(E_ERROR, "Unsupported operand types"); + return FAILURE; /* unknown datatype */ +} +/* }}} */ + +ZEND_API int bitwise_or_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + zval op1_copy, op2_copy; + long op1_lval; + + if (Z_TYPE_P(op1) == IS_STRING && Z_TYPE_P(op2) == IS_STRING) { + zval *longer, *shorter; + char *result_str; + int i, result_len; + + if (Z_STRLEN_P(op1) >= Z_STRLEN_P(op2)) { + longer = op1; + shorter = op2; + } else { + longer = op2; + shorter = op1; + } + + Z_TYPE_P(result) = IS_STRING; + result_len = Z_STRLEN_P(longer); + result_str = estrndup(Z_STRVAL_P(longer), Z_STRLEN_P(longer)); + for (i = 0; i < Z_STRLEN_P(shorter); i++) { + result_str[i] |= Z_STRVAL_P(shorter)[i]; + } + if (result==op1) { + STR_FREE(Z_STRVAL_P(result)); + } + Z_STRVAL_P(result) = result_str; + Z_STRLEN_P(result) = result_len; + return SUCCESS; + } + zendi_convert_to_long(op1, op1_copy, result); + op1_lval = Z_LVAL_P(op1); + zendi_convert_to_long(op2, op2_copy, result); + + ZVAL_LONG(result, op1_lval | Z_LVAL_P(op2)); + return SUCCESS; +} +/* }}} */ + +ZEND_API int bitwise_and_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + zval op1_copy, op2_copy; + long op1_lval; + + if (Z_TYPE_P(op1) == IS_STRING && Z_TYPE_P(op2) == IS_STRING) { + zval *longer, *shorter; + char *result_str; + int i, result_len; + + if (Z_STRLEN_P(op1) >= Z_STRLEN_P(op2)) { + longer = op1; + shorter = op2; + } else { + longer = op2; + shorter = op1; + } + + Z_TYPE_P(result) = IS_STRING; + result_len = Z_STRLEN_P(shorter); + result_str = estrndup(Z_STRVAL_P(shorter), Z_STRLEN_P(shorter)); + for (i = 0; i < Z_STRLEN_P(shorter); i++) { + result_str[i] &= Z_STRVAL_P(longer)[i]; + } + if (result==op1) { + STR_FREE(Z_STRVAL_P(result)); + } + Z_STRVAL_P(result) = result_str; + Z_STRLEN_P(result) = result_len; + return SUCCESS; + } + + + zendi_convert_to_long(op1, op1_copy, result); + op1_lval = Z_LVAL_P(op1); + zendi_convert_to_long(op2, op2_copy, result); + + ZVAL_LONG(result, op1_lval & Z_LVAL_P(op2)); + return SUCCESS; +} +/* }}} */ + +ZEND_API int bitwise_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + zval op1_copy, op2_copy; + long op1_lval; + + if (Z_TYPE_P(op1) == IS_STRING && Z_TYPE_P(op2) == IS_STRING) { + zval *longer, *shorter; + char *result_str; + int i, result_len; + + if (Z_STRLEN_P(op1) >= Z_STRLEN_P(op2)) { + longer = op1; + shorter = op2; + } else { + longer = op2; + shorter = op1; + } + + Z_TYPE_P(result) = IS_STRING; + result_len = Z_STRLEN_P(shorter); + result_str = estrndup(Z_STRVAL_P(shorter), Z_STRLEN_P(shorter)); + for (i = 0; i < Z_STRLEN_P(shorter); i++) { + result_str[i] ^= Z_STRVAL_P(longer)[i]; + } + if (result==op1) { + STR_FREE(Z_STRVAL_P(result)); + } + Z_STRVAL_P(result) = result_str; + Z_STRLEN_P(result) = result_len; + return SUCCESS; + } + + zendi_convert_to_long(op1, op1_copy, result); + op1_lval = Z_LVAL_P(op1); + zendi_convert_to_long(op2, op2_copy, result); + + ZVAL_LONG(result, op1_lval ^ Z_LVAL_P(op2)); + return SUCCESS; +} +/* }}} */ + +ZEND_API int shift_left_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + zval op1_copy, op2_copy; + long op1_lval; + + zendi_convert_to_long(op1, op1_copy, result); + op1_lval = Z_LVAL_P(op1); + zendi_convert_to_long(op2, op2_copy, result); + ZVAL_LONG(result, op1_lval << Z_LVAL_P(op2)); + return SUCCESS; +} +/* }}} */ + +ZEND_API int shift_right_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + zval op1_copy, op2_copy; + long op1_lval; + + zendi_convert_to_long(op1, op1_copy, result); + op1_lval = Z_LVAL_P(op1); + zendi_convert_to_long(op2, op2_copy, result); + ZVAL_LONG(result, op1_lval >> Z_LVAL_P(op2)); + return SUCCESS; +} +/* }}} */ + +/* must support result==op1 */ +ZEND_API int add_char_to_string(zval *result, const zval *op1, const zval *op2) /* {{{ */ +{ + int length = Z_STRLEN_P(op1) + 1; + char *buf; + + if (IS_INTERNED(Z_STRVAL_P(op1))) { + buf = (char *) emalloc(length + 1); + memcpy(buf, Z_STRVAL_P(op1), Z_STRLEN_P(op1)); + } else { + buf = (char *) erealloc(Z_STRVAL_P(op1), length + 1); + } + buf[length - 1] = (char) Z_LVAL_P(op2); + buf[length] = 0; + ZVAL_STRINGL(result, buf, length, 0); + return SUCCESS; +} +/* }}} */ + +/* must support result==op1 */ +ZEND_API int add_string_to_string(zval *result, const zval *op1, const zval *op2) /* {{{ */ +{ + int length = Z_STRLEN_P(op1) + Z_STRLEN_P(op2); + char *buf; + + if (IS_INTERNED(Z_STRVAL_P(op1))) { + buf = (char *) emalloc(length+1); + memcpy(buf, Z_STRVAL_P(op1), Z_STRLEN_P(op1)); + } else { + buf = (char *) erealloc(Z_STRVAL_P(op1), length+1); + } + memcpy(buf + Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2)); + buf[length] = 0; + ZVAL_STRINGL(result, buf, length, 0); + return SUCCESS; +} +/* }}} */ + +ZEND_API int concat_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + zval op1_copy, op2_copy; + int use_copy1 = 0, use_copy2 = 0; + + if (Z_TYPE_P(op1) != IS_STRING) { + zend_make_printable_zval(op1, &op1_copy, &use_copy1); + } + if (Z_TYPE_P(op2) != IS_STRING) { + zend_make_printable_zval(op2, &op2_copy, &use_copy2); + } + + if (use_copy1) { + /* We have created a converted copy of op1. Therefore, op1 won't become the result so + * we have to free it. + */ + if (result == op1) { + zval_dtor(op1); + } + op1 = &op1_copy; + } + if (use_copy2) { + op2 = &op2_copy; + } + if (result==op1 && !IS_INTERNED(Z_STRVAL_P(op1))) { /* special case, perform operations on result */ + uint res_len = Z_STRLEN_P(op1) + Z_STRLEN_P(op2); + + if (Z_STRLEN_P(result) < 0 || (int) (Z_STRLEN_P(op1) + Z_STRLEN_P(op2)) < 0) { + efree(Z_STRVAL_P(result)); + ZVAL_EMPTY_STRING(result); + zend_error(E_ERROR, "String size overflow"); + } + + Z_STRVAL_P(result) = erealloc(Z_STRVAL_P(result), res_len+1); + + memcpy(Z_STRVAL_P(result)+Z_STRLEN_P(result), Z_STRVAL_P(op2), Z_STRLEN_P(op2)); + Z_STRVAL_P(result)[res_len]=0; + Z_STRLEN_P(result) = res_len; + } else { + int length = Z_STRLEN_P(op1) + Z_STRLEN_P(op2); + char *buf = (char *) emalloc(length + 1); + + memcpy(buf, Z_STRVAL_P(op1), Z_STRLEN_P(op1)); + memcpy(buf + Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2)); + buf[length] = 0; + ZVAL_STRINGL(result, buf, length, 0); + } + if (use_copy1) { + zval_dtor(op1); + } + if (use_copy2) { + zval_dtor(op2); + } + return SUCCESS; +} +/* }}} */ + +ZEND_API int string_compare_function_ex(zval *result, zval *op1, zval *op2, zend_bool case_insensitive TSRMLS_DC) /* {{{ */ +{ + zval op1_copy, op2_copy; + int use_copy1 = 0, use_copy2 = 0; + + if (Z_TYPE_P(op1) != IS_STRING) { + zend_make_printable_zval(op1, &op1_copy, &use_copy1); + } + if (Z_TYPE_P(op2) != IS_STRING) { + zend_make_printable_zval(op2, &op2_copy, &use_copy2); + } + + if (use_copy1) { + op1 = &op1_copy; + } + if (use_copy2) { + op2 = &op2_copy; + } + + if (case_insensitive) { + ZVAL_LONG(result, zend_binary_zval_strcasecmp(op1, op2)); + } else { + ZVAL_LONG(result, zend_binary_zval_strcmp(op1, op2)); + } + + if (use_copy1) { + zval_dtor(op1); + } + if (use_copy2) { + zval_dtor(op2); + } + return SUCCESS; +} +/* }}} */ + +ZEND_API int string_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + return string_compare_function_ex(result, op1, op2, 0 TSRMLS_CC); +} +/* }}} */ + +ZEND_API int string_case_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + return string_compare_function_ex(result, op1, op2, 1 TSRMLS_CC); +} +/* }}} */ + +#if HAVE_STRCOLL +ZEND_API int string_locale_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + zval op1_copy, op2_copy; + int use_copy1 = 0, use_copy2 = 0; + + if (Z_TYPE_P(op1) != IS_STRING) { + zend_make_printable_zval(op1, &op1_copy, &use_copy1); + } + if (Z_TYPE_P(op2) != IS_STRING) { + zend_make_printable_zval(op2, &op2_copy, &use_copy2); + } + + if (use_copy1) { + op1 = &op1_copy; + } + if (use_copy2) { + op2 = &op2_copy; + } + + ZVAL_LONG(result, strcoll(Z_STRVAL_P(op1), Z_STRVAL_P(op2))); + + if (use_copy1) { + zval_dtor(op1); + } + if (use_copy2) { + zval_dtor(op2); + } + return SUCCESS; +} +/* }}} */ +#endif + +ZEND_API int numeric_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + zval op1_copy, op2_copy; + + op1_copy = *op1; + zval_copy_ctor(&op1_copy); + + op2_copy = *op2; + zval_copy_ctor(&op2_copy); + + convert_to_double(&op1_copy); + convert_to_double(&op2_copy); + + ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL(op1_copy)-Z_DVAL(op2_copy))); + + return SUCCESS; +} +/* }}} */ + +static inline void zend_free_obj_get_result(zval *op TSRMLS_DC) /* {{{ */ +{ + if (Z_REFCOUNT_P(op) == 0) { + GC_REMOVE_ZVAL_FROM_BUFFER(op); + zval_dtor(op); + FREE_ZVAL(op); + } else { + zval_ptr_dtor(&op); + } +} +/* }}} */ + +ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + int ret; + int converted = 0; + zval op1_copy, op2_copy; + zval *op_free; + + while (1) { + switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) { + case TYPE_PAIR(IS_LONG, IS_LONG): + ZVAL_LONG(result, Z_LVAL_P(op1)>Z_LVAL_P(op2)?1:(Z_LVAL_P(op1)<Z_LVAL_P(op2)?-1:0)); + return SUCCESS; + + case TYPE_PAIR(IS_DOUBLE, IS_LONG): + Z_DVAL_P(result) = Z_DVAL_P(op1) - (double)Z_LVAL_P(op2); + ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result))); + return SUCCESS; + + case TYPE_PAIR(IS_LONG, IS_DOUBLE): + Z_DVAL_P(result) = (double)Z_LVAL_P(op1) - Z_DVAL_P(op2); + ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result))); + return SUCCESS; + + case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE): + if (Z_DVAL_P(op1) == Z_DVAL_P(op2)) { + ZVAL_LONG(result, 0); + } else { + Z_DVAL_P(result) = Z_DVAL_P(op1) - Z_DVAL_P(op2); + ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result))); + } + return SUCCESS; + + case TYPE_PAIR(IS_ARRAY, IS_ARRAY): + zend_compare_arrays(result, op1, op2 TSRMLS_CC); + return SUCCESS; + + case TYPE_PAIR(IS_NULL, IS_NULL): + ZVAL_LONG(result, 0); + return SUCCESS; + + case TYPE_PAIR(IS_NULL, IS_BOOL): + ZVAL_LONG(result, Z_LVAL_P(op2) ? -1 : 0); + return SUCCESS; + + case TYPE_PAIR(IS_BOOL, IS_NULL): + ZVAL_LONG(result, Z_LVAL_P(op1) ? 1 : 0); + return SUCCESS; + + case TYPE_PAIR(IS_BOOL, IS_BOOL): + ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(op1) - Z_LVAL_P(op2))); + return SUCCESS; + + case TYPE_PAIR(IS_STRING, IS_STRING): + zendi_smart_strcmp(result, op1, op2); + return SUCCESS; + + case TYPE_PAIR(IS_NULL, IS_STRING): + ZVAL_LONG(result, zend_binary_strcmp("", 0, Z_STRVAL_P(op2), Z_STRLEN_P(op2))); + return SUCCESS; + + case TYPE_PAIR(IS_STRING, IS_NULL): + ZVAL_LONG(result, zend_binary_strcmp(Z_STRVAL_P(op1), Z_STRLEN_P(op1), "", 0)); + return SUCCESS; + + case TYPE_PAIR(IS_OBJECT, IS_NULL): + ZVAL_LONG(result, 1); + return SUCCESS; + + case TYPE_PAIR(IS_NULL, IS_OBJECT): + ZVAL_LONG(result, -1); + return SUCCESS; + + case TYPE_PAIR(IS_OBJECT, IS_OBJECT): + /* If both are objects sharing the same comparision handler then use is */ + if (Z_OBJ_HANDLER_P(op1,compare_objects) == Z_OBJ_HANDLER_P(op2,compare_objects)) { + if (Z_OBJ_HANDLE_P(op1) == Z_OBJ_HANDLE_P(op2)) { + /* object handles are identical, apprently this is the same object */ + ZVAL_LONG(result, 0); + return SUCCESS; + } + ZVAL_LONG(result, Z_OBJ_HT_P(op1)->compare_objects(op1, op2 TSRMLS_CC)); + return SUCCESS; + } + /* break missing intentionally */ + + default: + if (Z_TYPE_P(op1) == IS_OBJECT) { + if (Z_OBJ_HT_P(op1)->get) { + op_free = Z_OBJ_HT_P(op1)->get(op1 TSRMLS_CC); + ret = compare_function(result, op_free, op2 TSRMLS_CC); + zend_free_obj_get_result(op_free TSRMLS_CC); + return ret; + } else if (Z_TYPE_P(op2) != IS_OBJECT && Z_OBJ_HT_P(op1)->cast_object) { + ALLOC_INIT_ZVAL(op_free); + if (Z_OBJ_HT_P(op1)->cast_object(op1, op_free, Z_TYPE_P(op2) TSRMLS_CC) == FAILURE) { + ZVAL_LONG(result, 1); + zend_free_obj_get_result(op_free TSRMLS_CC); + return SUCCESS; + } + ret = compare_function(result, op_free, op2 TSRMLS_CC); + zend_free_obj_get_result(op_free TSRMLS_CC); + return ret; + } + } + if (Z_TYPE_P(op2) == IS_OBJECT) { + if (Z_OBJ_HT_P(op2)->get) { + op_free = Z_OBJ_HT_P(op2)->get(op2 TSRMLS_CC); + ret = compare_function(result, op1, op_free TSRMLS_CC); + zend_free_obj_get_result(op_free TSRMLS_CC); + return ret; + } else if (Z_TYPE_P(op1) != IS_OBJECT && Z_OBJ_HT_P(op2)->cast_object) { + ALLOC_INIT_ZVAL(op_free); + if (Z_OBJ_HT_P(op2)->cast_object(op2, op_free, Z_TYPE_P(op1) TSRMLS_CC) == FAILURE) { + ZVAL_LONG(result, -1); + zend_free_obj_get_result(op_free TSRMLS_CC); + return SUCCESS; + } + ret = compare_function(result, op1, op_free TSRMLS_CC); + zend_free_obj_get_result(op_free TSRMLS_CC); + return ret; + } else if (Z_TYPE_P(op1) == IS_OBJECT) { + ZVAL_LONG(result, 1); + return SUCCESS; + } + } + if (!converted) { + if (Z_TYPE_P(op1) == IS_NULL) { + zendi_convert_to_boolean(op2, op2_copy, result); + ZVAL_LONG(result, Z_LVAL_P(op2) ? -1 : 0); + return SUCCESS; + } else if (Z_TYPE_P(op2) == IS_NULL) { + zendi_convert_to_boolean(op1, op1_copy, result); + ZVAL_LONG(result, Z_LVAL_P(op1) ? 1 : 0); + return SUCCESS; + } else if (Z_TYPE_P(op1) == IS_BOOL) { + zendi_convert_to_boolean(op2, op2_copy, result); + ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(op1) - Z_LVAL_P(op2))); + return SUCCESS; + } else if (Z_TYPE_P(op2) == IS_BOOL) { + zendi_convert_to_boolean(op1, op1_copy, result); + ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(op1) - Z_LVAL_P(op2))); + return SUCCESS; + } else { + zendi_convert_scalar_to_number(op1, op1_copy, result); + zendi_convert_scalar_to_number(op2, op2_copy, result); + converted = 1; + } + } else if (Z_TYPE_P(op1)==IS_ARRAY) { + ZVAL_LONG(result, 1); + return SUCCESS; + } else if (Z_TYPE_P(op2)==IS_ARRAY) { + ZVAL_LONG(result, -1); + return SUCCESS; + } else if (Z_TYPE_P(op1)==IS_OBJECT) { + ZVAL_LONG(result, 1); + return SUCCESS; + } else if (Z_TYPE_P(op2)==IS_OBJECT) { + ZVAL_LONG(result, -1); + return SUCCESS; + } else { + ZVAL_LONG(result, 0); + return FAILURE; + } + } + } +} +/* }}} */ + +static int hash_zval_identical_function(const zval **z1, const zval **z2) /* {{{ */ +{ + zval result; + TSRMLS_FETCH(); + + /* is_identical_function() returns 1 in case of identity and 0 in case + * of a difference; + * whereas this comparison function is expected to return 0 on identity, + * and non zero otherwise. + */ + if (is_identical_function(&result, (zval *) *z1, (zval *) *z2 TSRMLS_CC)==FAILURE) { + return 1; + } + return !Z_LVAL(result); +} +/* }}} */ + +ZEND_API int is_identical_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + Z_TYPE_P(result) = IS_BOOL; + if (Z_TYPE_P(op1) != Z_TYPE_P(op2)) { + Z_LVAL_P(result) = 0; + return SUCCESS; + } + switch (Z_TYPE_P(op1)) { + case IS_NULL: + Z_LVAL_P(result) = 1; + break; + case IS_BOOL: + case IS_LONG: + case IS_RESOURCE: + Z_LVAL_P(result) = (Z_LVAL_P(op1) == Z_LVAL_P(op2)); + break; + case IS_DOUBLE: + Z_LVAL_P(result) = (Z_DVAL_P(op1) == Z_DVAL_P(op2)); + break; + case IS_STRING: + Z_LVAL_P(result) = ((Z_STRLEN_P(op1) == Z_STRLEN_P(op2)) + && (!memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op1)))); + break; + case IS_ARRAY: + Z_LVAL_P(result) = (Z_ARRVAL_P(op1) == Z_ARRVAL_P(op2) || + zend_hash_compare(Z_ARRVAL_P(op1), Z_ARRVAL_P(op2), (compare_func_t) hash_zval_identical_function, 1 TSRMLS_CC)==0); + break; + case IS_OBJECT: + if (Z_OBJ_HT_P(op1) == Z_OBJ_HT_P(op2)) { + Z_LVAL_P(result) = (Z_OBJ_HANDLE_P(op1) == Z_OBJ_HANDLE_P(op2)); + } else { + Z_LVAL_P(result) = 0; + } + break; + default: + Z_LVAL_P(result) = 0; + return FAILURE; + } + return SUCCESS; +} +/* }}} */ + +ZEND_API int is_not_identical_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + if (is_identical_function(result, op1, op2 TSRMLS_CC) == FAILURE) { + return FAILURE; + } + Z_LVAL_P(result) = !Z_LVAL_P(result); + return SUCCESS; +} +/* }}} */ + +ZEND_API int is_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + if (compare_function(result, op1, op2 TSRMLS_CC) == FAILURE) { + return FAILURE; + } + ZVAL_BOOL(result, (Z_LVAL_P(result) == 0)); + return SUCCESS; +} +/* }}} */ + +ZEND_API int is_not_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + if (compare_function(result, op1, op2 TSRMLS_CC) == FAILURE) { + return FAILURE; + } + ZVAL_BOOL(result, (Z_LVAL_P(result) != 0)); + return SUCCESS; +} +/* }}} */ + +ZEND_API int is_smaller_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + if (compare_function(result, op1, op2 TSRMLS_CC) == FAILURE) { + return FAILURE; + } + ZVAL_BOOL(result, (Z_LVAL_P(result) < 0)); + return SUCCESS; +} +/* }}} */ + +ZEND_API int is_smaller_or_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ +{ + if (compare_function(result, op1, op2 TSRMLS_CC) == FAILURE) { + return FAILURE; + } + ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0)); + return SUCCESS; +} +/* }}} */ + +ZEND_API zend_bool instanceof_function_ex(const zend_class_entry *instance_ce, const zend_class_entry *ce, zend_bool interfaces_only TSRMLS_DC) /* {{{ */ +{ + zend_uint i; + + for (i=0; i<instance_ce->num_interfaces; i++) { + if (instanceof_function(instance_ce->interfaces[i], ce TSRMLS_CC)) { + return 1; + } + } + if (!interfaces_only) { + while (instance_ce) { + if (instance_ce == ce) { + return 1; + } + instance_ce = instance_ce->parent; + } + } + + return 0; +} +/* }}} */ + +ZEND_API zend_bool instanceof_function(const zend_class_entry *instance_ce, const zend_class_entry *ce TSRMLS_DC) /* {{{ */ +{ + return instanceof_function_ex(instance_ce, ce, 0 TSRMLS_CC); +} +/* }}} */ + +#define LOWER_CASE 1 +#define UPPER_CASE 2 +#define NUMERIC 3 + +static void increment_string(zval *str) /* {{{ */ +{ + int carry=0; + int pos=Z_STRLEN_P(str)-1; + char *s=Z_STRVAL_P(str); + char *t; + int last=0; /* Shut up the compiler warning */ + int ch; + + if (Z_STRLEN_P(str) == 0) { + STR_FREE(Z_STRVAL_P(str)); + Z_STRVAL_P(str) = estrndup("1", sizeof("1")-1); + Z_STRLEN_P(str) = 1; + return; + } + + if (IS_INTERNED(s)) { + s = (char*) emalloc(Z_STRLEN_P(str) + 1); + memcpy(s, Z_STRVAL_P(str), Z_STRLEN_P(str) + 1); + Z_STRVAL_P(str) = s; + } + + while (pos >= 0) { + ch = s[pos]; + if (ch >= 'a' && ch <= 'z') { + if (ch == 'z') { + s[pos] = 'a'; + carry=1; + } else { + s[pos]++; + carry=0; + } + last=LOWER_CASE; + } else if (ch >= 'A' && ch <= 'Z') { + if (ch == 'Z') { + s[pos] = 'A'; + carry=1; + } else { + s[pos]++; + carry=0; + } + last=UPPER_CASE; + } else if (ch >= '0' && ch <= '9') { + if (ch == '9') { + s[pos] = '0'; + carry=1; + } else { + s[pos]++; + carry=0; + } + last = NUMERIC; + } else { + carry=0; + break; + } + if (carry == 0) { + break; + } + pos--; + } + + if (carry) { + t = (char *) emalloc(Z_STRLEN_P(str)+1+1); + memcpy(t+1, Z_STRVAL_P(str), Z_STRLEN_P(str)); + Z_STRLEN_P(str)++; + t[Z_STRLEN_P(str)] = '\0'; + switch (last) { + case NUMERIC: + t[0] = '1'; + break; + case UPPER_CASE: + t[0] = 'A'; + break; + case LOWER_CASE: + t[0] = 'a'; + break; + } + STR_FREE(Z_STRVAL_P(str)); + Z_STRVAL_P(str) = t; + } +} +/* }}} */ + +ZEND_API int increment_function(zval *op1) /* {{{ */ +{ + switch (Z_TYPE_P(op1)) { + case IS_LONG: + if (Z_LVAL_P(op1) == LONG_MAX) { + /* switch to double */ + double d = (double)Z_LVAL_P(op1); + ZVAL_DOUBLE(op1, d+1); + } else { + Z_LVAL_P(op1)++; + } + break; + case IS_DOUBLE: + Z_DVAL_P(op1) = Z_DVAL_P(op1) + 1; + break; + case IS_NULL: + ZVAL_LONG(op1, 1); + break; + case IS_STRING: { + long lval; + double dval; + + switch (is_numeric_string(Z_STRVAL_P(op1), Z_STRLEN_P(op1), &lval, &dval, 0)) { + case IS_LONG: + str_efree(Z_STRVAL_P(op1)); + if (lval == LONG_MAX) { + /* switch to double */ + double d = (double)lval; + ZVAL_DOUBLE(op1, d+1); + } else { + ZVAL_LONG(op1, lval+1); + } + break; + case IS_DOUBLE: + str_efree(Z_STRVAL_P(op1)); + ZVAL_DOUBLE(op1, dval+1); + break; + default: + /* Perl style string increment */ + increment_string(op1); + break; + } + } + break; + default: + return FAILURE; + } + return SUCCESS; +} +/* }}} */ + +ZEND_API int decrement_function(zval *op1) /* {{{ */ +{ + long lval; + double dval; + + switch (Z_TYPE_P(op1)) { + case IS_LONG: + if (Z_LVAL_P(op1) == LONG_MIN) { + double d = (double)Z_LVAL_P(op1); + ZVAL_DOUBLE(op1, d-1); + } else { + Z_LVAL_P(op1)--; + } + break; + case IS_DOUBLE: + Z_DVAL_P(op1) = Z_DVAL_P(op1) - 1; + break; + case IS_STRING: /* Like perl we only support string increment */ + if (Z_STRLEN_P(op1) == 0) { /* consider as 0 */ + STR_FREE(Z_STRVAL_P(op1)); + ZVAL_LONG(op1, -1); + break; + } + switch (is_numeric_string(Z_STRVAL_P(op1), Z_STRLEN_P(op1), &lval, &dval, 0)) { + case IS_LONG: + STR_FREE(Z_STRVAL_P(op1)); + if (lval == LONG_MIN) { + double d = (double)lval; + ZVAL_DOUBLE(op1, d-1); + } else { + ZVAL_LONG(op1, lval-1); + } + break; + case IS_DOUBLE: + STR_FREE(Z_STRVAL_P(op1)); + ZVAL_DOUBLE(op1, dval - 1); + break; + } + break; + default: + return FAILURE; + } + + return SUCCESS; +} +/* }}} */ + +ZEND_API int zval_is_true(zval *op) /* {{{ */ +{ + convert_to_boolean(op); + return (Z_LVAL_P(op) ? 1 : 0); +} +/* }}} */ + +#ifdef ZEND_USE_TOLOWER_L +ZEND_API void zend_update_current_locale(void) /* {{{ */ +{ + current_locale = _get_current_locale(); +} +/* }}} */ +#endif + +ZEND_API char *zend_str_tolower_copy(char *dest, const char *source, unsigned int length) /* {{{ */ +{ + register unsigned char *str = (unsigned char*)source; + register unsigned char *result = (unsigned char*)dest; + register unsigned char *end = str + length; + + while (str < end) { + *result++ = zend_tolower((int)*str++); + } + *result = '\0'; + + return dest; +} +/* }}} */ + +ZEND_API char *zend_str_tolower_dup(const char *source, unsigned int length) /* {{{ */ +{ + return zend_str_tolower_copy((char *)emalloc(length+1), source, length); +} +/* }}} */ + +ZEND_API void zend_str_tolower(char *str, unsigned int length) /* {{{ */ +{ + register unsigned char *p = (unsigned char*)str; + register unsigned char *end = p + length; + + while (p < end) { + *p = zend_tolower((int)*p); + p++; + } +} +/* }}} */ + +ZEND_API int zend_binary_strcmp(const char *s1, uint len1, const char *s2, uint len2) /* {{{ */ +{ + int retval; + + if (s1 == s2) { + return 0; + } + retval = memcmp(s1, s2, MIN(len1, len2)); + if (!retval) { + return (len1 - len2); + } else { + return retval; + } +} +/* }}} */ + +ZEND_API int zend_binary_strncmp(const char *s1, uint len1, const char *s2, uint len2, uint length) /* {{{ */ +{ + int retval; + + if (s1 == s2) { + return 0; + } + retval = memcmp(s1, s2, MIN(length, MIN(len1, len2))); + if (!retval) { + return (MIN(length, len1) - MIN(length, len2)); + } else { + return retval; + } +} +/* }}} */ + +ZEND_API int zend_binary_strcasecmp(const char *s1, uint len1, const char *s2, uint len2) /* {{{ */ +{ + int len; + int c1, c2; + + if (s1 == s2) { + return 0; + } + + len = MIN(len1, len2); + while (len--) { + c1 = zend_tolower((int)*(unsigned char *)s1++); + c2 = zend_tolower((int)*(unsigned char *)s2++); + if (c1 != c2) { + return c1 - c2; + } + } + + return len1 - len2; +} +/* }}} */ + +ZEND_API int zend_binary_strncasecmp(const char *s1, uint len1, const char *s2, uint len2, uint length) /* {{{ */ +{ + int len; + int c1, c2; + + if (s1 == s2) { + return 0; + } + len = MIN(length, MIN(len1, len2)); + while (len--) { + c1 = zend_tolower((int)*(unsigned char *)s1++); + c2 = zend_tolower((int)*(unsigned char *)s2++); + if (c1 != c2) { + return c1 - c2; + } + } + + return MIN(length, len1) - MIN(length, len2); +} +/* }}} */ + +ZEND_API int zend_binary_zval_strcmp(zval *s1, zval *s2) /* {{{ */ +{ + return zend_binary_strcmp(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2)); +} +/* }}} */ + +ZEND_API int zend_binary_zval_strncmp(zval *s1, zval *s2, zval *s3) /* {{{ */ +{ + return zend_binary_strncmp(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2), Z_LVAL_P(s3)); +} +/* }}} */ + +ZEND_API int zend_binary_zval_strcasecmp(zval *s1, zval *s2) /* {{{ */ +{ + return zend_binary_strcasecmp(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2)); +} +/* }}} */ + +ZEND_API int zend_binary_zval_strncasecmp(zval *s1, zval *s2, zval *s3) /* {{{ */ +{ + return zend_binary_strncasecmp(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2), Z_LVAL_P(s3)); +} +/* }}} */ + +ZEND_API void zendi_smart_strcmp(zval *result, zval *s1, zval *s2) /* {{{ */ +{ + int ret1, ret2; + int oflow1, oflow2; + long lval1, lval2; + double dval1, dval2; + + if ((ret1=is_numeric_string_ex(Z_STRVAL_P(s1), Z_STRLEN_P(s1), &lval1, &dval1, 0, &oflow1)) && + (ret2=is_numeric_string_ex(Z_STRVAL_P(s2), Z_STRLEN_P(s2), &lval2, &dval2, 0, &oflow2))) { +#if ULONG_MAX == 0xFFFFFFFF + if (oflow1 != 0 && oflow1 == oflow2 && dval1 - dval2 == 0. && + ((oflow1 == 1 && dval1 > 9007199254740991. /*0x1FFFFFFFFFFFFF*/) + || (oflow1 == -1 && dval1 < -9007199254740991.))) { +#else + if (oflow1 != 0 && oflow1 == oflow2 && dval1 - dval2 == 0.) { +#endif + /* both values are integers overflown to the same side, and the + * double comparison may have resulted in crucial accuracy lost */ + goto string_cmp; + } + if ((ret1==IS_DOUBLE) || (ret2==IS_DOUBLE)) { + if (ret1!=IS_DOUBLE) { + if (oflow2) { + /* 2nd operand is integer > LONG_MAX (oflow2==1) or < LONG_MIN (-1) */ + ZVAL_LONG(result, -1 * oflow2); + return; + } + dval1 = (double) lval1; + } else if (ret2!=IS_DOUBLE) { + if (oflow1) { + ZVAL_LONG(result, oflow1); + return; + } + dval2 = (double) lval2; + } else if (dval1 == dval2 && !zend_finite(dval1)) { + /* Both values overflowed and have the same sign, + * so a numeric comparison would be inaccurate */ + goto string_cmp; + } + Z_DVAL_P(result) = dval1 - dval2; + ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result))); + } else { /* they both have to be long's */ + ZVAL_LONG(result, lval1 > lval2 ? 1 : (lval1 < lval2 ? -1 : 0)); + } + } else { +string_cmp: + Z_LVAL_P(result) = zend_binary_zval_strcmp(s1, s2); + ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(result))); + } +} +/* }}} */ + +static int hash_zval_compare_function(const zval **z1, const zval **z2 TSRMLS_DC) /* {{{ */ +{ + zval result; + + if (compare_function(&result, (zval *) *z1, (zval *) *z2 TSRMLS_CC)==FAILURE) { + return 1; + } + return Z_LVAL(result); +} +/* }}} */ + +ZEND_API int zend_compare_symbol_tables_i(HashTable *ht1, HashTable *ht2 TSRMLS_DC) /* {{{ */ +{ + return ht1 == ht2 ? 0 : zend_hash_compare(ht1, ht2, (compare_func_t) hash_zval_compare_function, 0 TSRMLS_CC); +} +/* }}} */ + +ZEND_API void zend_compare_symbol_tables(zval *result, HashTable *ht1, HashTable *ht2 TSRMLS_DC) /* {{{ */ +{ + ZVAL_LONG(result, ht1 == ht2 ? 0 : zend_hash_compare(ht1, ht2, (compare_func_t) hash_zval_compare_function, 0 TSRMLS_CC)); +} +/* }}} */ + +ZEND_API void zend_compare_arrays(zval *result, zval *a1, zval *a2 TSRMLS_DC) /* {{{ */ +{ + zend_compare_symbol_tables(result, Z_ARRVAL_P(a1), Z_ARRVAL_P(a2) TSRMLS_CC); +} +/* }}} */ + +ZEND_API void zend_compare_objects(zval *result, zval *o1, zval *o2 TSRMLS_DC) /* {{{ */ +{ + Z_TYPE_P(result) = IS_LONG; + + if (Z_OBJ_HANDLE_P(o1) == Z_OBJ_HANDLE_P(o2)) { + Z_LVAL_P(result) = 0; + return; + } + + if (Z_OBJ_HT_P(o1)->compare_objects == NULL) { + Z_LVAL_P(result) = 1; + } else { + Z_LVAL_P(result) = Z_OBJ_HT_P(o1)->compare_objects(o1, o2 TSRMLS_CC); + } +} +/* }}} */ + +ZEND_API void zend_locale_sprintf_double(zval *op ZEND_FILE_LINE_DC) /* {{{ */ +{ + TSRMLS_FETCH(); + + Z_STRLEN_P(op) = zend_spprintf(&Z_STRVAL_P(op), 0, "%.*G", (int) EG(precision), (double)Z_DVAL_P(op)); +} +/* }}} */ + +/* + * Local variables: + * tab-width: 4 + * c-basic-offset: 4 + * indent-tabs-mode: t + * End: + */ |