summaryrefslogtreecommitdiff
path: root/Zend/zend_operators.c
diff options
context:
space:
mode:
Diffstat (limited to 'Zend/zend_operators.c')
-rw-r--r--Zend/zend_operators.c1574
1 files changed, 869 insertions, 705 deletions
diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c
index ef21b47a41..6a81999495 100644
--- a/Zend/zend_operators.c
+++ b/Zend/zend_operators.c
@@ -86,7 +86,7 @@ ZEND_API int zend_atoi(const char *str, int str_len) /* {{{ */
if (!str_len) {
str_len = strlen(str);
}
- retval = strtol(str, NULL, 0);
+ retval = ZEND_STRTOI(str, NULL, 0);
if (str_len>0) {
switch (str[str_len-1]) {
case 'g':
@@ -107,14 +107,14 @@ ZEND_API int zend_atoi(const char *str, int str_len) /* {{{ */
}
/* }}} */
-ZEND_API long zend_atol(const char *str, int str_len) /* {{{ */
+ZEND_API zend_int_t zend_atol(const char *str, int str_len) /* {{{ */
{
- long retval;
+ zend_int_t retval;
if (!str_len) {
str_len = strlen(str);
}
- retval = strtol(str, NULL, 0);
+ retval = ZEND_STRTOI(str, NULL, 0);
if (str_len>0) {
switch (str[str_len-1]) {
case 'g':
@@ -183,30 +183,43 @@ ZEND_API double zend_string_to_double(const char *number, zend_uint length) /* {
ZEND_API void convert_scalar_to_number(zval *op TSRMLS_DC) /* {{{ */
{
+try_again:
switch (Z_TYPE_P(op)) {
+ case IS_REFERENCE:
+ if (Z_REFCOUNT_P(op) == 1) {
+ ZVAL_UNREF(op);
+ } else {
+ Z_DELREF_P(op);
+ ZVAL_COPY_VALUE(op, Z_REFVAL_P(op));
+ }
+ goto try_again;
case IS_STRING:
{
- char *strval;
+ zend_string *str;
- 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 = Z_STR_P(op);
+ if ((Z_TYPE_INFO_P(op)=is_numeric_string(str->val, str->len, &Z_IVAL_P(op), &Z_DVAL_P(op), 1)) == 0) {
+ ZVAL_INT(op, 0);
}
- str_efree(strval);
+ STR_RELEASE(str);
break;
}
- case IS_BOOL:
- Z_TYPE_P(op) = IS_LONG;
+ case IS_NULL:
+ case IS_FALSE:
+ ZVAL_INT(op, 0);
+ break;
+ case IS_TRUE:
+ ZVAL_INT(op, 1);
break;
case IS_RESOURCE:
- zend_list_delete(Z_LVAL_P(op));
- Z_TYPE_P(op) = IS_LONG;
+ {
+ zend_int_t l = Z_RES_HANDLE_P(op);
+ zval_ptr_dtor(op);
+ ZVAL_INT(op, l);
+ }
break;
case IS_OBJECT:
- convert_to_long_base(op, 10);
- break;
- case IS_NULL:
- ZVAL_LONG(op, 0);
+ convert_to_int_base(op, 10);
break;
}
}
@@ -215,33 +228,36 @@ ZEND_API void convert_scalar_to_number(zval *op TSRMLS_DC) /* {{{ */
/* {{{ zendi_convert_scalar_to_number */
#define zendi_convert_scalar_to_number(op, holder, result) \
if (op==result) { \
- if (Z_TYPE_P(op) != IS_LONG) { \
+ if (Z_TYPE_P(op) != IS_INT) { \
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); \
+ if ((Z_TYPE_INFO(holder)=is_numeric_string(Z_STRVAL_P(op), Z_STRSIZE_P(op), &Z_IVAL(holder), &Z_DVAL(holder), 1)) == 0) { \
+ ZVAL_INT(&(holder), 0); \
} \
(op) = &(holder); \
break; \
} \
- case IS_BOOL: \
- case IS_RESOURCE: \
- ZVAL_LONG(&(holder), Z_LVAL_P(op)); \
+ case IS_NULL: \
+ case IS_FALSE: \
+ ZVAL_INT(&(holder), 0); \
(op) = &(holder); \
break; \
- case IS_NULL: \
- ZVAL_LONG(&(holder), 0); \
+ case IS_TRUE: \
+ ZVAL_INT(&(holder), 1); \
+ (op) = &(holder); \
+ break; \
+ case IS_RESOURCE: \
+ ZVAL_INT(&(holder), Z_RES_HANDLE_P(op)); \
(op) = &(holder); \
break; \
case IS_OBJECT: \
- (holder) = (*(op)); \
- zval_copy_ctor(&(holder)); \
- convert_to_long_base(&(holder), 10); \
- if (Z_TYPE(holder) == IS_LONG) { \
+ ZVAL_DUP(&(holder), op); \
+ convert_to_int_base(&(holder), 10); \
+ if (Z_TYPE(holder) == IS_INT) { \
(op) = &(holder); \
} \
break; \
@@ -250,39 +266,40 @@ ZEND_API void convert_scalar_to_number(zval *op TSRMLS_DC) /* {{{ */
/* }}} */
-/* {{{ zendi_convert_to_long */
-#define zendi_convert_to_long(op, holder, result) \
+/* {{{ zendi_convert_to_int */
+#define zendi_convert_to_int(op, holder, result) \
if (op == result) { \
- convert_to_long(op); \
- } else if (Z_TYPE_P(op) != IS_LONG) { \
+ convert_to_int(op); \
+ } else if (Z_TYPE_P(op) != IS_INT) { \
switch (Z_TYPE_P(op)) { \
case IS_NULL: \
- Z_LVAL(holder) = 0; \
+ case IS_FALSE: \
+ ZVAL_INT(&(holder), 0); \
+ break; \
+ case IS_TRUE: \
+ ZVAL_INT(&(holder), 1); \
break; \
case IS_DOUBLE: \
- Z_LVAL(holder) = zend_dval_to_lval(Z_DVAL_P(op)); \
+ ZVAL_INT(&holder, zend_dval_to_ival(Z_DVAL_P(op)));\
break; \
case IS_STRING: \
- Z_LVAL(holder) = strtol(Z_STRVAL_P(op), NULL, 10); \
+ ZVAL_INT(&holder, ZEND_STRTOI(Z_STRVAL_P(op), NULL, 10));\
break; \
case IS_ARRAY: \
- Z_LVAL(holder) = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); \
+ ZVAL_INT(&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); \
+ ZVAL_DUP(&(holder), (op)); \
+ convert_to_int_base(&(holder), 10); \
break; \
- case IS_BOOL: \
case IS_RESOURCE: \
- Z_LVAL(holder) = Z_LVAL_P(op); \
+ ZVAL_INT(&holder, Z_RES_HANDLE_P(op)); \
break; \
default: \
zend_error(E_WARNING, "Cannot convert to ordinal value"); \
- Z_LVAL(holder) = 0; \
+ ZVAL_INT(&holder, 0); \
break; \
} \
- Z_TYPE(holder) = IS_LONG; \
(op) = &(holder); \
}
@@ -292,137 +309,130 @@ ZEND_API void convert_scalar_to_number(zval *op TSRMLS_DC) /* {{{ */
#define zendi_convert_to_boolean(op, holder, result) \
if (op==result) { \
convert_to_boolean(op); \
- } else if (Z_TYPE_P(op) != IS_BOOL) { \
+ } else if (Z_TYPE_P(op) != IS_FALSE && \
+ Z_TYPE_P(op) != IS_TRUE) { \
switch (Z_TYPE_P(op)) { \
case IS_NULL: \
- Z_LVAL(holder) = 0; \
+ ZVAL_BOOL(&holder, 0); \
break; \
case IS_RESOURCE: \
- case IS_LONG: \
- Z_LVAL(holder) = (Z_LVAL_P(op) ? 1 : 0); \
+ ZVAL_BOOL(&holder, Z_RES_HANDLE_P(op) ? 1 : 0); \
+ break; \
+ case IS_INT: \
+ ZVAL_BOOL(&holder, Z_IVAL_P(op) ? 1 : 0); \
break; \
case IS_DOUBLE: \
- Z_LVAL(holder) = (Z_DVAL_P(op) ? 1 : 0); \
+ ZVAL_BOOL(&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; \
+ if (Z_STRSIZE_P(op) == 0 \
+ || (Z_STRSIZE_P(op)==1 && Z_STRVAL_P(op)[0]=='0')) { \
+ ZVAL_BOOL(&holder, 0); \
} else { \
- Z_LVAL(holder) = 1; \
+ ZVAL_BOOL(&holder, 1); \
} \
break; \
case IS_ARRAY: \
- Z_LVAL(holder) = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); \
+ ZVAL_BOOL(&holder, zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); \
break; \
case IS_OBJECT: \
- (holder) = (*(op)); \
- zval_copy_ctor(&(holder)); \
+ ZVAL_DUP(&(holder), (op)); \
convert_to_boolean(&(holder)); \
break; \
default: \
- Z_LVAL(holder) = 0; \
+ ZVAL_BOOL(&holder, 0); \
break; \
} \
- Z_TYPE(holder) = IS_BOOL; \
(op) = &(holder); \
}
/* }}} */
/* {{{ convert_object_to_type */
-#define convert_object_to_type(op, ctype, conv_func) \
+#define convert_object_to_type(op, dst, ctype, conv_func) \
+ ZVAL_UNDEF(dst); \
if (Z_OBJ_HT_P(op)->cast_object) { \
- zval dst; \
- if (Z_OBJ_HT_P(op)->cast_object(op, &dst, ctype TSRMLS_CC) == FAILURE) { \
+ 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, \
+ "Object of class %s could not be converted to %s", Z_OBJCE_P(op)->name->val,\
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); \
- } \
+ } \
+ } else if (Z_OBJ_HT_P(op)->get) { \
+ zval *newop = Z_OBJ_HT_P(op)->get(op, dst TSRMLS_CC); \
+ if (Z_TYPE_P(newop) != IS_OBJECT) { \
+ /* for safety - avoid loop */ \
+ ZVAL_COPY_VALUE(dst, newop); \
+ conv_func(dst); \
} \
}
/* }}} */
-ZEND_API void convert_to_long(zval *op) /* {{{ */
+ZEND_API void convert_to_int(zval *op) /* {{{ */
{
- if (Z_TYPE_P(op) != IS_LONG) {
- convert_to_long_base(op, 10);
+ if (Z_TYPE_P(op) != IS_INT) {
+ convert_to_int_base(op, 10);
}
}
/* }}} */
-ZEND_API void convert_to_long_base(zval *op, int base) /* {{{ */
+ZEND_API void convert_to_int_base(zval *op, int base) /* {{{ */
{
- long tmp;
+ zend_int_t tmp;
switch (Z_TYPE_P(op)) {
case IS_NULL:
- Z_LVAL_P(op) = 0;
+ case IS_FALSE:
+ ZVAL_INT(op, 0);
+ break;
+ case IS_TRUE:
+ ZVAL_INT(op, 1);
break;
case IS_RESOURCE: {
- TSRMLS_FETCH();
-
- zend_list_delete(Z_LVAL_P(op));
+ zend_int_t l = Z_RES_HANDLE_P(op);
+ zval_ptr_dtor(op);
+ ZVAL_INT(op, l);
}
/* break missing intentionally */
- case IS_BOOL:
- case IS_LONG:
+ Z_TYPE_INFO_P(op) = IS_INT;
+ break;
+ case IS_INT:
break;
case IS_DOUBLE:
- Z_LVAL_P(op) = zend_dval_to_lval(Z_DVAL_P(op));
+ ZVAL_INT(op, zend_dval_to_ival(Z_DVAL_P(op)));
break;
case IS_STRING:
{
- char *strval = Z_STRVAL_P(op);
+ zend_string *str = Z_STR_P(op);
- Z_LVAL_P(op) = strtol(strval, NULL, base);
- str_efree(strval);
+ ZVAL_INT(op, strtol(str->val, NULL, base));
+ STR_RELEASE(str);
}
break;
case IS_ARRAY:
tmp = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);
zval_dtor(op);
- Z_LVAL_P(op) = tmp;
+ ZVAL_INT(op, tmp);
break;
case IS_OBJECT:
{
- int retval = 1;
+ zval dst;
TSRMLS_FETCH();
- convert_object_to_type(op, IS_LONG, convert_to_long);
+ convert_object_to_type(op, &dst, IS_INT, convert_to_int);
+ zval_dtor(op);
- 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);
+ if (Z_TYPE(dst) == IS_INT) {
+ ZVAL_COPY_VALUE(op, &dst);
+ } else {
+ zend_error(E_NOTICE, "Object of class %s could not be converted to int", Z_OBJCE_P(op)->name->val);
- zval_dtor(op);
- ZVAL_LONG(op, retval);
+ ZVAL_INT(op, 1);
+ }
return;
}
- default:
- zend_error(E_WARNING, "Cannot convert to ordinal value");
- zval_dtor(op);
- Z_LVAL_P(op) = 0;
- break;
+ EMPTY_SWITCH_DEFAULT_CASE()
}
-
- Z_TYPE_P(op) = IS_LONG;
}
/* }}} */
@@ -432,56 +442,55 @@ ZEND_API void convert_to_double(zval *op) /* {{{ */
switch (Z_TYPE_P(op)) {
case IS_NULL:
- Z_DVAL_P(op) = 0.0;
+ case IS_FALSE:
+ ZVAL_DOUBLE(op, 0.0);
+ break;
+ case IS_TRUE:
+ ZVAL_DOUBLE(op, 1.0);
break;
case IS_RESOURCE: {
- TSRMLS_FETCH();
-
- zend_list_delete(Z_LVAL_P(op));
+ double d = (double) Z_RES_HANDLE_P(op);
+ zval_ptr_dtor(op);
+ ZVAL_DOUBLE(op, d);
}
- /* break missing intentionally */
- case IS_BOOL:
- case IS_LONG:
- Z_DVAL_P(op) = (double) Z_LVAL_P(op);
+ break;
+ case IS_INT:
+ ZVAL_DOUBLE(op, (double) Z_IVAL_P(op));
break;
case IS_DOUBLE:
break;
case IS_STRING:
{
- char *strval = Z_STRVAL_P(op);
+ zend_string *str = Z_STR_P(op);
- Z_DVAL_P(op) = zend_strtod(strval, NULL);
- str_efree(strval);
+ ZVAL_DOUBLE(op, zend_strtod(str->val, NULL));
+ STR_RELEASE(str);
}
break;
case IS_ARRAY:
tmp = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);
zval_dtor(op);
- Z_DVAL_P(op) = tmp;
+ ZVAL_DOUBLE(op, tmp);
break;
case IS_OBJECT:
{
- double retval = 1.0;
+ zval dst;
TSRMLS_FETCH();
- convert_object_to_type(op, IS_DOUBLE, convert_to_double);
+ convert_object_to_type(op, &dst, IS_DOUBLE, convert_to_double);
+ zval_dtor(op);
- 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);
+ if (Z_TYPE(dst) == IS_DOUBLE) {
+ ZVAL_COPY_VALUE(op, &dst);
+ } else {
+ zend_error(E_NOTICE, "Object of class %s could not be converted to double", Z_OBJCE_P(op)->name->val);
- zval_dtor(op);
- ZVAL_DOUBLE(op, retval);
+ ZVAL_DOUBLE(op, 1.0);
+ }
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;
+ EMPTY_SWITCH_DEFAULT_CASE()
}
- Z_TYPE_P(op) = IS_DOUBLE;
}
/* }}} */
@@ -489,22 +498,20 @@ 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;
+ 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);
+ ZVAL_COPY_VALUE(&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_COPY_VALUE(op, &org);
}
}
zval_dtor(op);
- Z_TYPE_P(op) = IS_NULL;
+ ZVAL_NULL(op);
}
/* }}} */
@@ -513,174 +520,138 @@ ZEND_API void convert_to_boolean(zval *op) /* {{{ */
int tmp;
switch (Z_TYPE_P(op)) {
- case IS_BOOL:
+ case IS_FALSE:
+ case IS_TRUE:
break;
case IS_NULL:
- Z_LVAL_P(op) = 0;
+ ZVAL_BOOL(op, 0);
break;
case IS_RESOURCE: {
- TSRMLS_FETCH();
+ zend_int_t l = (Z_RES_HANDLE_P(op) ? 1 : 0);
- zend_list_delete(Z_LVAL_P(op));
+ zval_ptr_dtor(op);
+ ZVAL_BOOL(op, l);
}
- /* break missing intentionally */
- case IS_LONG:
- Z_LVAL_P(op) = (Z_LVAL_P(op) ? 1 : 0);
+ break;
+ case IS_INT:
+ ZVAL_BOOL(op, Z_IVAL_P(op) ? 1 : 0);
break;
case IS_DOUBLE:
- Z_LVAL_P(op) = (Z_DVAL_P(op) ? 1 : 0);
+ ZVAL_BOOL(op, Z_DVAL_P(op) ? 1 : 0);
break;
case IS_STRING:
{
- char *strval = Z_STRVAL_P(op);
+ zend_string *str = Z_STR_P(op);
- if (Z_STRLEN_P(op) == 0
- || (Z_STRLEN_P(op)==1 && Z_STRVAL_P(op)[0]=='0')) {
- Z_LVAL_P(op) = 0;
+ if (str->len == 0
+ || (str->len == 1 && str->val[0] == '0')) {
+ ZVAL_BOOL(op, 0);
} else {
- Z_LVAL_P(op) = 1;
+ ZVAL_BOOL(op, 1);
}
- str_efree(strval);
+ STR_RELEASE(str);
}
break;
case IS_ARRAY:
tmp = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);
zval_dtor(op);
- Z_LVAL_P(op) = tmp;
+ ZVAL_BOOL(op, tmp);
break;
case IS_OBJECT:
{
- zend_bool retval = 1;
+ zval dst;
TSRMLS_FETCH();
- convert_object_to_type(op, IS_BOOL, convert_to_boolean);
+ convert_object_to_type(op, &dst, _IS_BOOL, convert_to_boolean);
+ zval_dtor(op);
- if (Z_TYPE_P(op) == IS_BOOL) {
- return;
+ if (Z_TYPE(dst) == IS_FALSE || Z_TYPE(dst) == IS_TRUE) {
+ ZVAL_COPY_VALUE(op, &dst);
+ } else {
+ ZVAL_BOOL(op, 1);
}
-
- zval_dtor(op);
- ZVAL_BOOL(op, retval);
break;
}
- default:
- zval_dtor(op);
- Z_LVAL_P(op) = 0;
- break;
+ EMPTY_SWITCH_DEFAULT_CASE()
}
- Z_TYPE_P(op) = IS_BOOL;
}
/* }}} */
ZEND_API void _convert_to_cstring(zval *op ZEND_FILE_LINE_DC) /* {{{ */
{
- double dval;
- switch (Z_TYPE_P(op)) {
- case IS_DOUBLE: {
- TSRMLS_FETCH();
- dval = Z_DVAL_P(op);
- Z_STRLEN_P(op) = zend_spprintf(&Z_STRVAL_P(op), 0, "%.*H", (int) EG(precision), dval);
- /* %H already handles removing trailing zeros from the fractional part, yay */
- break;
- }
- default:
- _convert_to_string(op ZEND_FILE_LINE_CC);
- }
- Z_TYPE_P(op) = IS_STRING;
+ _convert_to_string(op ZEND_FILE_LINE_CC);
}
/* }}} */
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;
+ case IS_FALSE: {
+ TSRMLS_FETCH();
+ ZVAL_EMPTY_STRING(op);
break;
- case IS_STRING:
+ }
+ case IS_TRUE:
+ ZVAL_NEW_STR(op, STR_INIT("1", 1, 0));
break;
- case IS_BOOL:
- if (Z_LVAL_P(op)) {
- 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;
- }
+ case IS_STRING:
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);
+ char buf[sizeof("Resource id #") + MAX_LENGTH_OF_ZEND_INT];
+ int len = snprintf(buf, sizeof(buf), "Resource id #%ld", Z_RES_HANDLE_P(op));
+ ZVAL_NEW_STR(op, STR_INIT(buf, len, 0));
break;
}
- case IS_LONG:
- lval = Z_LVAL_P(op);
-
- Z_STRLEN_P(op) = zend_spprintf(&Z_STRVAL_P(op), 0, "%ld", lval);
+ case IS_INT: {
+ ZVAL_NEW_STR(op, zend_int_to_str(Z_IVAL_P(op)));
break;
+ }
case IS_DOUBLE: {
+ zend_string *str;
+ double dval = Z_DVAL_P(op);
TSRMLS_FETCH();
- dval = Z_DVAL_P(op);
- Z_STRLEN_P(op) = zend_spprintf(&Z_STRVAL_P(op), 0, "%.*G", (int) EG(precision), dval);
+
+ str = zend_strpprintf(0, "%.*G", (int) EG(precision), dval);
/* %G already handles removing trailing zeros from the fractional part, yay */
+ ZVAL_NEW_STR(op, str);
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;
+ ZVAL_NEW_STR(op, STR_INIT("Array", sizeof("Array")-1, 0));
break;
case IS_OBJECT: {
+ zval dst;
TSRMLS_FETCH();
- convert_object_to_type(op, IS_STRING, convert_to_string);
+ convert_object_to_type(op, &dst, IS_STRING, convert_to_string);
- if (Z_TYPE_P(op) == IS_STRING) {
- return;
+ if (Z_TYPE(dst) == IS_STRING) {
+ zval_dtor(op);
+ ZVAL_COPY_VALUE(op, &dst);
+ } else {
+ zend_error(E_NOTICE, "Object of class %s to string conversion", Z_OBJCE_P(op)->name->val);
+ zval_dtor(op);
+ ZVAL_NEW_STR(op, STR_INIT("Object", sizeof("Object")-1, 0));
}
-
- 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;
+ EMPTY_SWITCH_DEFAULT_CASE()
}
- Z_TYPE_P(op) = IS_STRING;
}
/* }}} */
-static void convert_scalar_to_array(zval *op, int type TSRMLS_DC) /* {{{ */
+static void convert_scalar_to_array(zval *op TSRMLS_DC) /* {{{ */
{
- zval *entry;
+ zval entry;
- ALLOC_ZVAL(entry);
- *entry = *op;
- INIT_PZVAL(entry);
+ ZVAL_COPY_VALUE(&entry, op);
- 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;
- }
+ ZVAL_NEW_ARR(op);
+ zend_hash_init(Z_ARRVAL_P(op), 8, NULL, ZVAL_PTR_DTOR, 0);
+ zend_hash_index_add_new(Z_ARRVAL_P(op), 0, &entry);
}
/* }}} */
@@ -693,45 +664,40 @@ ZEND_API void convert_to_array(zval *op) /* {{{ */
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) {
+ if (Z_OBJCE_P(op) == zend_ce_closure) {
+ convert_scalar_to_array(op TSRMLS_CC);
+ } 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 *));
+ zval arr;
+ ZVAL_NEW_ARR(&arr);
+ zend_array_dup(Z_ARRVAL(arr), obj_ht);
+ zval_dtor(op);
+ ZVAL_COPY_VALUE(op, &arr);
+ return;
}
} else {
- convert_object_to_type(op, IS_ARRAY, convert_to_array);
+ zval dst;
+ convert_object_to_type(op, &dst, IS_ARRAY, convert_to_array);
- if (Z_TYPE_P(op) == IS_ARRAY) {
- zend_hash_destroy(ht);
- FREE_HASHTABLE(ht);
+ if (Z_TYPE(dst) == IS_ARRAY) {
+ zval_dtor(op);
+ ZVAL_COPY_VALUE(op, &dst);
return;
}
}
+
zval_dtor(op);
- Z_TYPE_P(op) = IS_ARRAY;
- Z_ARRVAL_P(op) = ht;
+ array_init(op);
}
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;
+ ZVAL_NEW_ARR(op);
+ zend_hash_init(Z_ARRVAL_P(op), 8, NULL, ZVAL_PTR_DTOR, 0);
break;
default:
- convert_scalar_to_array(op, IS_ARRAY TSRMLS_CC);
+ convert_scalar_to_array(op TSRMLS_CC);
break;
}
}
@@ -744,7 +710,14 @@ ZEND_API void convert_to_object(zval *op) /* {{{ */
switch (Z_TYPE_P(op)) {
case IS_ARRAY:
{
- object_and_properties_init(op, zend_standard_class_def, Z_ARRVAL_P(op));
+ HashTable *properties = emalloc(sizeof(HashTable));
+ zend_array *arr = Z_ARR_P(op);
+
+ memcpy(properties, Z_ARRVAL_P(op), sizeof(HashTable));
+ object_and_properties_init(op, zend_standard_class_def, properties);
+ if (--GC_REFCOUNT(arr) == 0) {
+ efree(arr);
+ }
break;
}
case IS_OBJECT:
@@ -752,23 +725,27 @@ ZEND_API void convert_to_object(zval *op) /* {{{ */
case IS_NULL:
object_init(op);
break;
- default:
- convert_scalar_to_array(op, IS_OBJECT TSRMLS_CC);
+ default: {
+ zval tmp;
+ ZVAL_COPY_VALUE(&tmp, op);
+ object_init(op);
+ zend_hash_str_add_new(Z_OBJPROP_P(op), "scalar", sizeof("scalar")-1, &tmp);
break;
+ }
}
}
/* }}} */
-ZEND_API void multi_convert_to_long_ex(int argc, ...) /* {{{ */
+ZEND_API void multi_convert_to_int_ex(int argc, ...) /* {{{ */
{
- zval **arg;
+ zval *arg;
va_list ap;
va_start(ap, argc);
while (argc--) {
- arg = va_arg(ap, zval **);
- convert_to_long_ex(arg);
+ arg = va_arg(ap, zval *);
+ convert_to_int_ex(arg);
}
va_end(ap);
@@ -777,13 +754,13 @@ ZEND_API void multi_convert_to_long_ex(int argc, ...) /* {{{ */
ZEND_API void multi_convert_to_double_ex(int argc, ...) /* {{{ */
{
- zval **arg;
+ zval *arg;
va_list ap;
va_start(ap, argc);
while (argc--) {
- arg = va_arg(ap, zval **);
+ arg = va_arg(ap, zval *);
convert_to_double_ex(arg);
}
@@ -793,13 +770,13 @@ ZEND_API void multi_convert_to_double_ex(int argc, ...) /* {{{ */
ZEND_API void multi_convert_to_string_ex(int argc, ...) /* {{{ */
{
- zval **arg;
+ zval *arg;
va_list ap;
va_start(ap, argc);
while (argc--) {
- arg = va_arg(ap, zval **);
+ arg = va_arg(ap, zval *);
convert_to_string_ex(arg);
}
@@ -807,6 +784,140 @@ ZEND_API void multi_convert_to_string_ex(int argc, ...) /* {{{ */
}
/* }}} */
+ZEND_API zend_int_t _zval_get_int_func(zval *op TSRMLS_DC) /* {{{ */
+{
+try_again:
+ switch (Z_TYPE_P(op)) {
+ case IS_NULL:
+ case IS_FALSE:
+ return 0;
+ case IS_TRUE:
+ return 1;
+ case IS_RESOURCE:
+ return Z_RES_HANDLE_P(op);
+ case IS_INT:
+ return Z_IVAL_P(op);
+ case IS_DOUBLE:
+ return zend_dval_to_ival(Z_DVAL_P(op));
+ case IS_STRING:
+ return ZEND_STRTOI(Z_STRVAL_P(op), NULL, 10);
+ case IS_ARRAY:
+ return zend_hash_num_elements(Z_ARRVAL_P(op)) ? 1 : 0;
+ case IS_OBJECT:
+ {
+ zval dst;
+ convert_object_to_type(op, &dst, IS_INT, convert_to_int);
+ if (Z_TYPE(dst) == IS_INT) {
+ return Z_IVAL(dst);
+ } else {
+ zend_error(E_NOTICE, "Object of class %s could not be converted to int", Z_OBJCE_P(op)->name->val);
+ return 1;
+ }
+ }
+ case IS_REFERENCE:
+ op = Z_REFVAL_P(op);
+ goto try_again;
+ EMPTY_SWITCH_DEFAULT_CASE()
+ }
+ return 0;
+}
+/* }}} */
+
+ZEND_API double _zval_get_double_func(zval *op TSRMLS_DC) /* {{{ */
+{
+try_again:
+ switch (Z_TYPE_P(op)) {
+ case IS_NULL:
+ case IS_FALSE:
+ return 0.0;
+ case IS_TRUE:
+ return 1.0;
+ case IS_RESOURCE:
+ return (double) Z_RES_HANDLE_P(op);
+ case IS_INT:
+ return (double) Z_IVAL_P(op);
+ case IS_DOUBLE:
+ return Z_DVAL_P(op);
+ case IS_STRING:
+ return zend_strtod(Z_STRVAL_P(op), NULL);
+ case IS_ARRAY:
+ return zend_hash_num_elements(Z_ARRVAL_P(op)) ? 1.0 : 0.0;
+ case IS_OBJECT:
+ {
+ zval dst;
+ convert_object_to_type(op, &dst, IS_DOUBLE, convert_to_double);
+
+ if (Z_TYPE(dst) == IS_DOUBLE) {
+ return Z_DVAL(dst);
+ } else {
+ zend_error(E_NOTICE, "Object of class %s could not be converted to double", Z_OBJCE_P(op)->name->val);
+
+ return 1.0;
+ }
+ }
+ case IS_REFERENCE:
+ op = Z_REFVAL_P(op);
+ goto try_again;
+ EMPTY_SWITCH_DEFAULT_CASE()
+ }
+ return 0.0;
+}
+/* }}} */
+
+ZEND_API zend_string *_zval_get_string_func(zval *op TSRMLS_DC) /* {{{ */
+{
+try_again:
+ switch (Z_TYPE_P(op)) {
+ case IS_NULL:
+ case IS_FALSE:
+ return STR_EMPTY_ALLOC();
+ case IS_STRING:
+ return STR_COPY(Z_STR_P(op));
+ case IS_TRUE:
+ return STR_INIT("1", 1, 0);
+ case IS_RESOURCE: {
+ char buf[sizeof("Resource id #") + MAX_LENGTH_OF_ZEND_INT];
+ int len;
+
+ len = snprintf(buf, sizeof(buf), "Resource id #%ld", Z_RES_HANDLE_P(op));
+ return STR_INIT(buf, len, 0);
+ }
+ case IS_INT: {
+ return zend_int_to_str(Z_IVAL_P(op));
+ }
+ case IS_DOUBLE: {
+ return zend_strpprintf(0, "%.*G", (int) EG(precision), Z_DVAL_P(op));
+ }
+ case IS_ARRAY:
+ zend_error(E_NOTICE, "Array to string conversion");
+ return STR_INIT("Array", sizeof("Array")-1, 0);
+ case IS_OBJECT: {
+ zval tmp;
+ if (Z_OBJ_HT_P(op)->cast_object) {
+ if (Z_OBJ_HT_P(op)->cast_object(op, &tmp, IS_STRING TSRMLS_CC) == SUCCESS) {
+ return Z_STR(tmp);
+ }
+ } else if (Z_OBJ_HT_P(op)->get) {
+ zval *z = Z_OBJ_HT_P(op)->get(op, &tmp TSRMLS_CC);
+ if (Z_TYPE_P(z) != IS_OBJECT) {
+ zend_string *str = zval_get_string(z);
+ zval_ptr_dtor(z);
+ return str;
+ }
+ zval_ptr_dtor(z);
+ }
+ 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);
+ return STR_EMPTY_ALLOC();
+ }
+ case IS_REFERENCE:
+ op = Z_REFVAL_P(op);
+ goto try_again;
+ EMPTY_SWITCH_DEFAULT_CASE()
+ }
+ return NULL;
+}
+/* }}} */
+
ZEND_API int add_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
{
zval op1_copy, op2_copy;
@@ -814,49 +925,49 @@ ZEND_API int add_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ *
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);
+ case TYPE_PAIR(IS_INT, IS_INT): {
+ zend_int_t lval = Z_IVAL_P(op1) + Z_IVAL_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)) {
+ if ((Z_IVAL_P(op1) & LONG_SIGN_MASK) == (Z_IVAL_P(op2) & LONG_SIGN_MASK)
+ && (Z_IVAL_P(op1) & LONG_SIGN_MASK) != (lval & LONG_SIGN_MASK)) {
- ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) + (double) Z_LVAL_P(op2));
+ ZVAL_DOUBLE(result, (double) Z_IVAL_P(op1) + (double) Z_IVAL_P(op2));
} else {
- ZVAL_LONG(result, lval);
+ ZVAL_INT(result, lval);
}
return SUCCESS;
}
- case TYPE_PAIR(IS_LONG, IS_DOUBLE):
- ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2));
+ case TYPE_PAIR(IS_INT, IS_DOUBLE):
+ ZVAL_DOUBLE(result, ((double)Z_IVAL_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)));
+ case TYPE_PAIR(IS_DOUBLE, IS_INT):
+ ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_IVAL_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;
-
+ case TYPE_PAIR(IS_ARRAY, IS_ARRAY):
if ((result == op1) && (result == op2)) {
/* $a += $a */
return SUCCESS;
}
if (result != op1) {
- *result = *op1;
- zval_copy_ctor(result);
+ ZVAL_DUP(result, op1);
}
- zend_hash_merge(Z_ARRVAL_P(result), Z_ARRVAL_P(op2), (void (*)(void *pData)) zval_add_ref, (void *) &tmp, sizeof(zval *), 0);
+ zend_hash_merge(Z_ARRVAL_P(result), Z_ARRVAL_P(op2), zval_add_ref, 0);
return SUCCESS;
- }
default:
- if (!converted) {
+ if (Z_ISREF_P(op1)) {
+ op1 = Z_REFVAL_P(op1);
+ } else if (Z_ISREF_P(op2)) {
+ op2 = Z_REFVAL_P(op2);
+ } else if (!converted) {
ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_ADD);
zendi_convert_scalar_to_number(op1, op1_copy, result);
@@ -878,26 +989,26 @@ ZEND_API int sub_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ *
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);
+ case TYPE_PAIR(IS_INT, IS_INT): {
+ zend_int_t lval = Z_IVAL_P(op1) - Z_IVAL_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)) {
+ if ((Z_IVAL_P(op1) & LONG_SIGN_MASK) != (Z_IVAL_P(op2) & LONG_SIGN_MASK)
+ && (Z_IVAL_P(op1) & LONG_SIGN_MASK) != (lval & LONG_SIGN_MASK)) {
- ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) - (double) Z_LVAL_P(op2));
+ ZVAL_DOUBLE(result, (double) Z_IVAL_P(op1) - (double) Z_IVAL_P(op2));
} else {
- ZVAL_LONG(result, lval);
+ ZVAL_INT(result, lval);
}
return SUCCESS;
}
- case TYPE_PAIR(IS_LONG, IS_DOUBLE):
- ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) - Z_DVAL_P(op2));
+ case TYPE_PAIR(IS_INT, IS_DOUBLE):
+ ZVAL_DOUBLE(result, ((double)Z_IVAL_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)));
+ case TYPE_PAIR(IS_DOUBLE, IS_INT):
+ ZVAL_DOUBLE(result, Z_DVAL_P(op1) - ((double)Z_IVAL_P(op2)));
return SUCCESS;
case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE):
@@ -905,7 +1016,11 @@ ZEND_API int sub_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ *
return SUCCESS;
default:
- if (!converted) {
+ if (Z_ISREF_P(op1)) {
+ op1 = Z_REFVAL_P(op1);
+ } else if (Z_ISREF_P(op2)) {
+ op2 = Z_REFVAL_P(op2);
+ } else if (!converted) {
ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_SUB);
zendi_convert_scalar_to_number(op1, op1_copy, result);
@@ -927,20 +1042,20 @@ ZEND_API int mul_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ *
while (1) {
switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) {
- case TYPE_PAIR(IS_LONG, IS_LONG): {
- long overflow;
+ case TYPE_PAIR(IS_INT, IS_INT): {
+ zend_int_t 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;
+ ZEND_SIGNED_MULTIPLY_INT(Z_IVAL_P(op1),Z_IVAL_P(op2), Z_IVAL_P(result),Z_DVAL_P(result),overflow);
+ Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_INT;
return SUCCESS;
}
- case TYPE_PAIR(IS_LONG, IS_DOUBLE):
- ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) * Z_DVAL_P(op2));
+ case TYPE_PAIR(IS_INT, IS_DOUBLE):
+ ZVAL_DOUBLE(result, ((double)Z_IVAL_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)));
+ case TYPE_PAIR(IS_DOUBLE, IS_INT):
+ ZVAL_DOUBLE(result, Z_DVAL_P(op1) * ((double)Z_IVAL_P(op2)));
return SUCCESS;
case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE):
@@ -948,7 +1063,11 @@ ZEND_API int mul_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ *
return SUCCESS;
default:
- if (!converted) {
+ if (Z_ISREF_P(op1)) {
+ op1 = Z_REFVAL_P(op1);
+ } else if (Z_ISREF_P(op2)) {
+ op2 = Z_REFVAL_P(op2);
+ } else if (!converted) {
ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_MUL);
zendi_convert_scalar_to_number(op1, op1_copy, result);
@@ -970,32 +1089,32 @@ ZEND_API int pow_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ *
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) {
- long l1 = 1, l2 = Z_LVAL_P(op1), i = Z_LVAL_P(op2);
+ case TYPE_PAIR(IS_INT, IS_INT):
+ if (Z_IVAL_P(op2) >= 0) {
+ zend_int_t l1 = 1, l2 = Z_IVAL_P(op1), i = Z_IVAL_P(op2);
if (i == 0) {
- ZVAL_LONG(result, 1L);
+ ZVAL_INT(result, 1L);
return SUCCESS;
} else if (l2 == 0) {
- ZVAL_LONG(result, 0);
+ ZVAL_INT(result, 0);
return SUCCESS;
}
while (i >= 1) {
- long overflow;
+ zend_int_t overflow;
double dval = 0.0;
if (i % 2) {
--i;
- ZEND_SIGNED_MULTIPLY_LONG(l1, l2, l1, dval, overflow);
+ ZEND_SIGNED_MULTIPLY_INT(l1, l2, l1, dval, overflow);
if (overflow) {
ZVAL_DOUBLE(result, dval * pow(l2, i));
return SUCCESS;
}
} else {
i /= 2;
- ZEND_SIGNED_MULTIPLY_LONG(l2, l2, l2, dval, overflow);
+ ZEND_SIGNED_MULTIPLY_INT(l2, l2, l2, dval, overflow);
if (overflow) {
ZVAL_DOUBLE(result, (double)l1 * pow(dval, i));
return SUCCESS;
@@ -1003,18 +1122,18 @@ ZEND_API int pow_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ *
}
}
/* i == 0 */
- ZVAL_LONG(result, l1);
+ ZVAL_INT(result, l1);
} else {
- ZVAL_DOUBLE(result, pow((double)Z_LVAL_P(op1), (double)Z_LVAL_P(op2)));
+ ZVAL_DOUBLE(result, pow((double)Z_IVAL_P(op1), (double)Z_IVAL_P(op2)));
}
return SUCCESS;
- case TYPE_PAIR(IS_LONG, IS_DOUBLE):
- ZVAL_DOUBLE(result, pow((double)Z_LVAL_P(op1), Z_DVAL_P(op2)));
+ case TYPE_PAIR(IS_INT, IS_DOUBLE):
+ ZVAL_DOUBLE(result, pow((double)Z_IVAL_P(op1), Z_DVAL_P(op2)));
return SUCCESS;
- case TYPE_PAIR(IS_DOUBLE, IS_LONG):
- ZVAL_DOUBLE(result, pow(Z_DVAL_P(op1), (double)Z_LVAL_P(op2)));
+ case TYPE_PAIR(IS_DOUBLE, IS_INT):
+ ZVAL_DOUBLE(result, pow(Z_DVAL_P(op1), (double)Z_IVAL_P(op2)));
return SUCCESS;
case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE):
@@ -1022,17 +1141,21 @@ ZEND_API int pow_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ *
return SUCCESS;
default:
- if (!converted) {
+ if (Z_ISREF_P(op1)) {
+ op1 = Z_REFVAL_P(op1);
+ } else if (Z_ISREF_P(op2)) {
+ op2 = Z_REFVAL_P(op2);
+ } else if (!converted) {
ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_POW);
if (Z_TYPE_P(op1) == IS_ARRAY) {
- ZVAL_LONG(result, 0);
+ ZVAL_INT(result, 0);
return SUCCESS;
} else {
zendi_convert_scalar_to_number(op1, op1_copy, result);
}
if (Z_TYPE_P(op2) == IS_ARRAY) {
- ZVAL_LONG(result, 1L);
+ ZVAL_INT(result, 1L);
return SUCCESS;
} else {
zendi_convert_scalar_to_number(op2, op2_copy, result);
@@ -1054,39 +1177,39 @@ ZEND_API int div_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ *
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) {
+ case TYPE_PAIR(IS_INT, IS_INT):
+ if (Z_IVAL_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) {
+ } else if (Z_IVAL_P(op2) == -1 && Z_IVAL_P(op1) == ZEND_INT_MIN) {
/* Prevent overflow error/crash */
- ZVAL_DOUBLE(result, (double) LONG_MIN / -1);
+ ZVAL_DOUBLE(result, (double) ZEND_INT_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));
+ if (Z_IVAL_P(op1) % Z_IVAL_P(op2) == 0) { /* integer */
+ ZVAL_INT(result, Z_IVAL_P(op1) / Z_IVAL_P(op2));
} else {
- ZVAL_DOUBLE(result, ((double) Z_LVAL_P(op1)) / Z_LVAL_P(op2));
+ ZVAL_DOUBLE(result, ((double) Z_IVAL_P(op1)) / Z_IVAL_P(op2));
}
return SUCCESS;
- case TYPE_PAIR(IS_DOUBLE, IS_LONG):
- if (Z_LVAL_P(op2) == 0) {
+ case TYPE_PAIR(IS_DOUBLE, IS_INT):
+ if (Z_IVAL_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));
+ ZVAL_DOUBLE(result, Z_DVAL_P(op1) / (double)Z_IVAL_P(op2));
return SUCCESS;
- case TYPE_PAIR(IS_LONG, IS_DOUBLE):
+ case TYPE_PAIR(IS_INT, 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));
+ ZVAL_DOUBLE(result, (double)Z_IVAL_P(op1) / Z_DVAL_P(op2));
return SUCCESS;
case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE):
@@ -1099,7 +1222,11 @@ ZEND_API int div_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ *
return SUCCESS;
default:
- if (!converted) {
+ if (Z_ISREF_P(op1)) {
+ op1 = Z_REFVAL_P(op1);
+ } else if (Z_ISREF_P(op2)) {
+ op2 = Z_REFVAL_P(op2);
+ } else if (!converted) {
ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_DIV);
zendi_convert_scalar_to_number(op1, op1_copy, result);
@@ -1117,31 +1244,31 @@ ZEND_API int div_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ *
ZEND_API int mod_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
{
zval op1_copy, op2_copy;
- long op1_lval;
+ zend_int_t op1_lval;
- if (Z_TYPE_P(op1) != IS_LONG || Z_TYPE_P(op2) != IS_LONG) {
+ if (Z_TYPE_P(op1) != IS_INT || Z_TYPE_P(op2) != IS_INT) {
ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_MOD);
- zendi_convert_to_long(op1, op1_copy, result);
- op1_lval = Z_LVAL_P(op1);
- zendi_convert_to_long(op2, op2_copy, result);
+ zendi_convert_to_int(op1, op1_copy, result);
+ op1_lval = Z_IVAL_P(op1);
+ zendi_convert_to_int(op2, op2_copy, result);
} else {
- op1_lval = Z_LVAL_P(op1);
+ op1_lval = Z_IVAL_P(op1);
}
- if (Z_LVAL_P(op2) == 0) {
+ if (Z_IVAL_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) {
+ if (Z_IVAL_P(op2) == -1) {
/* Prevent overflow error/crash if op1==LONG_MIN */
- ZVAL_LONG(result, 0);
+ ZVAL_INT(result, 0);
return SUCCESS;
}
- ZVAL_LONG(result, op1_lval % Z_LVAL_P(op2));
+ ZVAL_INT(result, op1_lval % Z_IVAL_P(op2));
return SUCCESS;
}
/* }}} */
@@ -1149,19 +1276,20 @@ ZEND_API int mod_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ *
ZEND_API int boolean_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
{
zval op1_copy, op2_copy;
- long op1_lval;
+ zend_int_t op1_lval;
- if (Z_TYPE_P(op1) != IS_BOOL || Z_TYPE_P(op2) != IS_BOOL) {
+ if ((Z_TYPE_P(op1) != IS_FALSE && Z_TYPE_P(op1) != IS_TRUE) ||
+ (Z_TYPE_P(op2) != IS_FALSE && Z_TYPE_P(op2) != IS_TRUE)) {
ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_BOOL_XOR);
zendi_convert_to_boolean(op1, op1_copy, result);
- op1_lval = Z_LVAL_P(op1);
+ op1_lval = Z_TYPE_P(op1) == IS_TRUE;
zendi_convert_to_boolean(op2, op2_copy, result);
} else {
- op1_lval = Z_LVAL_P(op1);
+ op1_lval = Z_TYPE_P(op1) == IS_TRUE;
}
- ZVAL_BOOL(result, op1_lval ^ Z_LVAL_P(op2));
+ ZVAL_BOOL(result, op1_lval ^ (Z_TYPE_P(op2) == IS_TRUE));
return SUCCESS;
}
/* }}} */
@@ -1170,13 +1298,17 @@ ZEND_API int boolean_not_function(zval *result, zval *op1 TSRMLS_DC) /* {{{ */
{
zval op1_copy;
- if (Z_TYPE_P(op1) != IS_BOOL) {
+ if (Z_TYPE_P(op1) == IS_FALSE) {
+ ZVAL_TRUE(result);
+ } else if (Z_TYPE_P(op1) == IS_TRUE) {
+ ZVAL_FALSE(result);
+ } else {
ZEND_TRY_UNARY_OBJECT_OPERATION(ZEND_BOOL_NOT);
zendi_convert_to_boolean(op1, op1_copy, result);
- }
- ZVAL_BOOL(result, !Z_LVAL_P(op1));
+ ZVAL_BOOL(result, Z_TYPE_P(op1) == IS_FALSE);
+ }
return SUCCESS;
}
/* }}} */
@@ -1185,22 +1317,21 @@ ZEND_API int bitwise_not_function(zval *result, zval *op1 TSRMLS_DC) /* {{{ */
{
switch (Z_TYPE_P(op1)) {
- case IS_LONG:
- ZVAL_LONG(result, ~Z_LVAL_P(op1));
+ case IS_INT:
+ ZVAL_INT(result, ~Z_IVAL_P(op1));
return SUCCESS;
case IS_DOUBLE:
- ZVAL_LONG(result, ~zend_dval_to_lval(Z_DVAL_P(op1)));
+ ZVAL_INT(result, ~zend_dval_to_ival(Z_DVAL_P(op1)));
return SUCCESS;
case IS_STRING: {
- int i;
+ zend_size_t i;
zval op1_copy = *op1;
- Z_TYPE_P(result) = IS_STRING;
- Z_STRVAL_P(result) = estrndup(Z_STRVAL(op1_copy), Z_STRLEN(op1_copy));
- Z_STRLEN_P(result) = Z_STRLEN(op1_copy);
- for (i = 0; i < Z_STRLEN(op1_copy); i++) {
+ ZVAL_NEW_STR(result, STR_ALLOC(Z_STRSIZE(op1_copy), 0));
+ for (i = 0; i < Z_STRSIZE(op1_copy); i++) {
Z_STRVAL_P(result)[i] = ~Z_STRVAL(op1_copy)[i];
}
+ Z_STRVAL_P(result)[i] = 0;
return SUCCESS;
}
default:
@@ -1215,14 +1346,14 @@ ZEND_API int bitwise_not_function(zval *result, zval *op1 TSRMLS_DC) /* {{{ */
ZEND_API int bitwise_or_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
{
zval op1_copy, op2_copy;
- long op1_lval;
+ zend_int_t 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;
+ zend_string *str;
+ zend_size_t i;
- if (Z_STRLEN_P(op1) >= Z_STRLEN_P(op2)) {
+ if (Z_STRSIZE_P(op1) >= Z_STRSIZE_P(op2)) {
longer = op1;
shorter = op2;
} else {
@@ -1230,31 +1361,29 @@ ZEND_API int bitwise_or_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /
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];
+ str = STR_ALLOC(Z_STRSIZE_P(longer), 0);
+ for (i = 0; i < Z_STRSIZE_P(shorter); i++) {
+ str->val[i] = Z_STRVAL_P(longer)[i] | Z_STRVAL_P(shorter)[i];
}
+ memcpy(str->val + i, Z_STRVAL_P(longer) + i, Z_STRSIZE_P(longer) - i + 1);
if (result==op1) {
- str_efree(Z_STRVAL_P(result));
+ STR_RELEASE(Z_STR_P(result));
}
- Z_STRVAL_P(result) = result_str;
- Z_STRLEN_P(result) = result_len;
+ ZVAL_NEW_STR(result, str);
return SUCCESS;
}
- if (Z_TYPE_P(op1) != IS_LONG || Z_TYPE_P(op2) != IS_LONG) {
+ if (Z_TYPE_P(op1) != IS_INT || Z_TYPE_P(op2) != IS_INT) {
ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_BW_OR);
- zendi_convert_to_long(op1, op1_copy, result);
- op1_lval = Z_LVAL_P(op1);
- zendi_convert_to_long(op2, op2_copy, result);
+ zendi_convert_to_int(op1, op1_copy, result);
+ op1_lval = Z_IVAL_P(op1);
+ zendi_convert_to_int(op2, op2_copy, result);
} else {
- op1_lval = Z_LVAL_P(op1);
+ op1_lval = Z_IVAL_P(op1);
}
- ZVAL_LONG(result, op1_lval | Z_LVAL_P(op2));
+ ZVAL_INT(result, op1_lval | Z_IVAL_P(op2));
return SUCCESS;
}
/* }}} */
@@ -1262,14 +1391,14 @@ ZEND_API int bitwise_or_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /
ZEND_API int bitwise_and_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
{
zval op1_copy, op2_copy;
- long op1_lval;
+ zend_int_t 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;
+ zend_string *str;
+ zend_size_t i;
- if (Z_STRLEN_P(op1) >= Z_STRLEN_P(op2)) {
+ if (Z_STRSIZE_P(op1) >= Z_STRSIZE_P(op2)) {
longer = op1;
shorter = op2;
} else {
@@ -1277,31 +1406,29 @@ ZEND_API int bitwise_and_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
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];
+ str = STR_ALLOC(Z_STRSIZE_P(shorter), 0);
+ for (i = 0; i < Z_STRSIZE_P(shorter); i++) {
+ str->val[i] = Z_STRVAL_P(shorter)[i] & Z_STRVAL_P(longer)[i];
}
+ str->val[i] = 0;
if (result==op1) {
- str_efree(Z_STRVAL_P(result));
+ STR_RELEASE(Z_STR_P(result));
}
- Z_STRVAL_P(result) = result_str;
- Z_STRLEN_P(result) = result_len;
+ ZVAL_NEW_STR(result, str);
return SUCCESS;
}
- if (Z_TYPE_P(op1) != IS_LONG || Z_TYPE_P(op2) != IS_LONG) {
+ if (Z_TYPE_P(op1) != IS_INT || Z_TYPE_P(op2) != IS_INT) {
ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_BW_AND);
- zendi_convert_to_long(op1, op1_copy, result);
- op1_lval = Z_LVAL_P(op1);
- zendi_convert_to_long(op2, op2_copy, result);
+ zendi_convert_to_int(op1, op1_copy, result);
+ op1_lval = Z_IVAL_P(op1);
+ zendi_convert_to_int(op2, op2_copy, result);
} else {
- op1_lval = Z_LVAL_P(op1);
+ op1_lval = Z_IVAL_P(op1);
}
- ZVAL_LONG(result, op1_lval & Z_LVAL_P(op2));
+ ZVAL_INT(result, op1_lval & Z_IVAL_P(op2));
return SUCCESS;
}
/* }}} */
@@ -1309,14 +1436,14 @@ ZEND_API int bitwise_and_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
ZEND_API int bitwise_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
{
zval op1_copy, op2_copy;
- long op1_lval;
+ zend_int_t 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;
+ zend_string *str;
+ zend_size_t i;
- if (Z_STRLEN_P(op1) >= Z_STRLEN_P(op2)) {
+ if (Z_STRSIZE_P(op1) >= Z_STRSIZE_P(op2)) {
longer = op1;
shorter = op2;
} else {
@@ -1324,31 +1451,29 @@ ZEND_API int bitwise_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
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];
+ str = STR_ALLOC(Z_STRSIZE_P(shorter), 0);
+ for (i = 0; i < Z_STRSIZE_P(shorter); i++) {
+ str->val[i] = Z_STRVAL_P(shorter)[i] ^ Z_STRVAL_P(longer)[i];
}
+ str->val[i] = 0;
if (result==op1) {
- str_efree(Z_STRVAL_P(result));
+ STR_RELEASE(Z_STR_P(result));
}
- Z_STRVAL_P(result) = result_str;
- Z_STRLEN_P(result) = result_len;
+ ZVAL_NEW_STR(result, str);
return SUCCESS;
}
- if (Z_TYPE_P(op1) != IS_LONG || Z_TYPE_P(op2) != IS_LONG) {
+ if (Z_TYPE_P(op1) != IS_INT || Z_TYPE_P(op2) != IS_INT) {
ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_BW_XOR);
- zendi_convert_to_long(op1, op1_copy, result);
- op1_lval = Z_LVAL_P(op1);
- zendi_convert_to_long(op2, op2_copy, result);
+ zendi_convert_to_int(op1, op1_copy, result);
+ op1_lval = Z_IVAL_P(op1);
+ zendi_convert_to_int(op2, op2_copy, result);
} else {
- op1_lval = Z_LVAL_P(op1);
+ op1_lval = Z_IVAL_P(op1);
}
- ZVAL_LONG(result, op1_lval ^ Z_LVAL_P(op2));
+ ZVAL_INT(result, op1_lval ^ Z_IVAL_P(op2));
return SUCCESS;
}
/* }}} */
@@ -1356,19 +1481,19 @@ ZEND_API int bitwise_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
ZEND_API int shift_left_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
{
zval op1_copy, op2_copy;
- long op1_lval;
+ zend_int_t op1_lval;
- if (Z_TYPE_P(op1) != IS_LONG || Z_TYPE_P(op2) != IS_LONG) {
+ if (Z_TYPE_P(op1) != IS_INT || Z_TYPE_P(op2) != IS_INT) {
ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_SL);
- zendi_convert_to_long(op1, op1_copy, result);
- op1_lval = Z_LVAL_P(op1);
- zendi_convert_to_long(op2, op2_copy, result);
+ zendi_convert_to_int(op1, op1_copy, result);
+ op1_lval = Z_IVAL_P(op1);
+ zendi_convert_to_int(op2, op2_copy, result);
} else {
- op1_lval = Z_LVAL_P(op1);
+ op1_lval = Z_IVAL_P(op1);
}
- ZVAL_LONG(result, op1_lval << Z_LVAL_P(op2));
+ ZVAL_INT(result, op1_lval << Z_IVAL_P(op2));
return SUCCESS;
}
/* }}} */
@@ -1376,19 +1501,19 @@ ZEND_API int shift_left_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /
ZEND_API int shift_right_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
{
zval op1_copy, op2_copy;
- long op1_lval;
+ zend_int_t op1_lval;
- if (Z_TYPE_P(op1) != IS_LONG || Z_TYPE_P(op2) != IS_LONG) {
+ if (Z_TYPE_P(op1) != IS_INT || Z_TYPE_P(op2) != IS_INT) {
ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_SR);
- zendi_convert_to_long(op1, op1_copy, result);
- op1_lval = Z_LVAL_P(op1);
- zendi_convert_to_long(op2, op2_copy, result);
+ zendi_convert_to_int(op1, op1_copy, result);
+ op1_lval = Z_IVAL_P(op1);
+ zendi_convert_to_int(op2, op2_copy, result);
} else {
- op1_lval = Z_LVAL_P(op1);
+ op1_lval = Z_IVAL_P(op1);
}
- ZVAL_LONG(result, op1_lval >> Z_LVAL_P(op2));
+ ZVAL_INT(result, op1_lval >> Z_IVAL_P(op2));
return SUCCESS;
}
/* }}} */
@@ -1396,12 +1521,12 @@ ZEND_API int shift_right_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
/* 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 = str_erealloc(Z_STRVAL_P(op1), length + 1);
+ zend_size_t length = Z_STRSIZE_P(op1) + 1;
+ zend_string *buf = STR_REALLOC(Z_STR_P(op1), length, 0);
- buf[length - 1] = (char) Z_LVAL_P(op2);
- buf[length] = 0;
- ZVAL_STRINGL(result, buf, length, 0);
+ buf->val[length - 1] = (char) Z_IVAL_P(op2);
+ buf->val[length] = 0;
+ ZVAL_NEW_STR(result, buf);
return SUCCESS;
}
/* }}} */
@@ -1409,12 +1534,13 @@ ZEND_API int add_char_to_string(zval *result, const zval *op1, const zval *op2)
/* 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 = str_erealloc(Z_STRVAL_P(op1), length + 1);
+ zend_size_t op1_len = Z_STRSIZE_P(op1);
+ zend_size_t length = op1_len + Z_STRSIZE_P(op2);
+ zend_string *buf = STR_REALLOC(Z_STR_P(op1), length, 0);
- memcpy(buf + Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2));
- buf[length] = 0;
- ZVAL_STRINGL(result, buf, length, 0);
+ memcpy(buf->val + op1_len, Z_STRVAL_P(op2), Z_STRSIZE_P(op2));
+ buf->val[length] = 0;
+ ZVAL_NEW_STR(result, buf);
return SUCCESS;
}
/* }}} */
@@ -1424,14 +1550,15 @@ 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 || Z_TYPE_P(op2) != IS_STRING) {
+ if (UNEXPECTED(Z_TYPE_P(op1) != IS_STRING) ||
+ UNEXPECTED(Z_TYPE_P(op2) != IS_STRING)) {
ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_CONCAT);
if (Z_TYPE_P(op1) != IS_STRING) {
- zend_make_printable_zval(op1, &op1_copy, &use_copy1);
+ use_copy1 = zend_make_printable_zval(op1, &op1_copy TSRMLS_CC);
}
if (Z_TYPE_P(op2) != IS_STRING) {
- zend_make_printable_zval(op2, &op2_copy, &use_copy2);
+ use_copy2 = zend_make_printable_zval(op2, &op2_copy TSRMLS_CC);
}
}
@@ -1447,33 +1574,34 @@ ZEND_API int concat_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{
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));
+ if (result==op1 && !IS_INTERNED(Z_STR_P(op1))) { /* special case, perform operations on result */
+ zend_size_t op1_len = Z_STRSIZE_P(op1);
+ zend_size_t op2_len = Z_STRSIZE_P(op2);
+ zend_size_t res_len = op1_len + op2_len;
+
+ if (Z_STRSIZE_P(result) < 0 || (zend_size_t) (op1_len + op2_len) < 0) {
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_STR_P(result) = STR_REALLOC(Z_STR_P(result), res_len, 0 );
+ Z_TYPE_INFO_P(result) = IS_STRING_EX;
+ memcpy(Z_STRVAL_P(result) + op1_len, Z_STRVAL_P(op2), op2_len);
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);
+ zend_size_t length = Z_STRSIZE_P(op1) + Z_STRSIZE_P(op2);
+ zend_string *buf = STR_ALLOC(length, 0);
- 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);
+ memcpy(buf->val, Z_STRVAL_P(op1), Z_STRSIZE_P(op1));
+ memcpy(buf->val + Z_STRSIZE_P(op1), Z_STRVAL_P(op2), Z_STRSIZE_P(op2));
+ buf->val[length] = 0;
+ ZVAL_NEW_STR(result, buf);
}
- if (use_copy1) {
+ if (UNEXPECTED(use_copy1)) {
zval_dtor(op1);
}
- if (use_copy2) {
+ if (UNEXPECTED(use_copy2)) {
zval_dtor(op2);
}
return SUCCESS;
@@ -1482,79 +1610,75 @@ ZEND_API int concat_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{
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;
- }
+ zend_string *str1 = zval_get_string(op1);
+ zend_string *str2 = zval_get_string(op2);
if (case_insensitive) {
- ZVAL_LONG(result, zend_binary_zval_strcasecmp(op1, op2));
+ ZVAL_INT(result, zend_binary_strcasecmp_l(str1->val, str1->len, str2->val, str1->len));
} else {
- ZVAL_LONG(result, zend_binary_zval_strcmp(op1, op2));
+ ZVAL_INT(result, zend_binary_strcmp(str1->val, str1->len, str2->val, str2->len));
}
- if (use_copy1) {
- zval_dtor(op1);
- }
- if (use_copy2) {
- zval_dtor(op2);
- }
+ STR_RELEASE(str1);
+ STR_RELEASE(str2);
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);
+ if (EXPECTED(Z_TYPE_P(op1) == IS_STRING) &&
+ EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
+ if (Z_STR_P(op1) == Z_STR_P(op2)) {
+ ZVAL_INT(result, 0);
+ } else {
+ ZVAL_INT(result, zend_binary_strcmp(Z_STRVAL_P(op1), Z_STRSIZE_P(op1), Z_STRVAL_P(op2), Z_STRSIZE_P(op2)));
+ }
+ } else {
+ zend_string *str1 = zval_get_string(op1);
+ zend_string *str2 = zval_get_string(op2);
+
+ ZVAL_INT(result, zend_binary_strcmp(str1->val, str1->len, str2->val, str2->len));
+
+ STR_RELEASE(str1);
+ STR_RELEASE(str2);
+ }
+ return SUCCESS;
}
/* }}} */
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 (EXPECTED(Z_TYPE_P(op1) == IS_STRING) &&
+ EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
+ if (Z_STR_P(op1) == Z_STR_P(op2)) {
+ ZVAL_INT(result, 0);
+ } else {
+ ZVAL_INT(result, zend_binary_strcasecmp_l(Z_STRVAL_P(op1), Z_STRSIZE_P(op1), Z_STRVAL_P(op2), Z_STRSIZE_P(op2)));
+ }
+ } else {
+ zend_string *str1 = zval_get_string(op1);
+ zend_string *str2 = zval_get_string(op2);
+
+ ZVAL_INT(result, zend_binary_strcasecmp_l(str1->val, str1->len, str2->val, str1->len));
+
+ STR_RELEASE(str1);
+ STR_RELEASE(str2);
+ }
+ return SUCCESS;
}
/* }}} */
#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;
- }
+ zend_string *str1 = zval_get_string(op1);
+ zend_string *str2 = zval_get_string(op2);
- ZVAL_LONG(result, strcoll(Z_STRVAL_P(op1), Z_STRVAL_P(op2)));
+ ZVAL_INT(result, strcoll(str1->val, str2->val));
- if (use_copy1) {
- zval_dtor(op1);
- }
- if (use_copy2) {
- zval_dtor(op2);
- }
+ STR_RELEASE(str1);
+ STR_RELEASE(str2);
return SUCCESS;
}
/* }}} */
@@ -1562,18 +1686,12 @@ ZEND_API int string_locale_compare_function(zval *result, zval *op1, zval *op2 T
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);
+ double d1, d2;
- op2_copy = *op2;
- zval_copy_ctor(&op2_copy);
+ d1 = zval_get_double(op1);
+ d2 = zval_get_double(op2);
- convert_to_double(&op1_copy);
- convert_to_double(&op2_copy);
-
- ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL(op1_copy)-Z_DVAL(op2_copy)));
+ ZVAL_INT(result, ZEND_NORMALIZE_BOOL(d1 - d2));
return SUCCESS;
}
@@ -1581,12 +1699,12 @@ ZEND_API int numeric_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_
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);
+ if (Z_REFCOUNTED_P(op)) {
+ if (Z_REFCOUNT_P(op) == 0) {
+ zval_dtor(op);
+ } else {
+ zval_ptr_dtor(op);
+ }
}
}
/* }}} */
@@ -1596,30 +1714,30 @@ 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;
+ zval *op_free, tmp_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));
+ case TYPE_PAIR(IS_INT, IS_INT):
+ ZVAL_INT(result, Z_IVAL_P(op1)>Z_IVAL_P(op2)?1:(Z_IVAL_P(op1)<Z_IVAL_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)));
+ case TYPE_PAIR(IS_DOUBLE, IS_INT):
+ Z_DVAL_P(result) = Z_DVAL_P(op1) - (double)Z_IVAL_P(op2);
+ ZVAL_INT(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)));
+ case TYPE_PAIR(IS_INT, IS_DOUBLE):
+ Z_DVAL_P(result) = (double)Z_IVAL_P(op1) - Z_DVAL_P(op2);
+ ZVAL_INT(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);
+ ZVAL_INT(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)));
+ ZVAL_INT(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
}
return SUCCESS;
@@ -1628,42 +1746,54 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {
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);
+ case TYPE_PAIR(IS_NULL, IS_FALSE):
+ case TYPE_PAIR(IS_FALSE, IS_NULL):
+ case TYPE_PAIR(IS_FALSE, IS_FALSE):
+ case TYPE_PAIR(IS_TRUE, IS_TRUE):
+ ZVAL_INT(result, 0);
return SUCCESS;
- case TYPE_PAIR(IS_BOOL, IS_NULL):
- ZVAL_LONG(result, Z_LVAL_P(op1) ? 1 : 0);
+ case TYPE_PAIR(IS_NULL, IS_TRUE):
+ ZVAL_INT(result, -1);
return SUCCESS;
- case TYPE_PAIR(IS_BOOL, IS_BOOL):
- ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(op1) - Z_LVAL_P(op2)));
+ case TYPE_PAIR(IS_TRUE, IS_NULL):
+ ZVAL_INT(result, 1);
return SUCCESS;
case TYPE_PAIR(IS_STRING, IS_STRING):
+ if (Z_STR_P(op1) == Z_STR_P(op2)) {
+ ZVAL_INT(result, 0);
+ return SUCCESS;
+ }
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)));
+ ZVAL_INT(result, Z_STRSIZE_P(op2) == 0 ? 0 : -1);
return SUCCESS;
case TYPE_PAIR(IS_STRING, IS_NULL):
- ZVAL_LONG(result, zend_binary_strcmp(Z_STRVAL_P(op1), Z_STRLEN_P(op1), "", 0));
+ ZVAL_INT(result, Z_STRSIZE_P(op1) == 0 ? 0 : 1);
return SUCCESS;
case TYPE_PAIR(IS_OBJECT, IS_NULL):
- ZVAL_LONG(result, 1);
+ ZVAL_INT(result, 1);
return SUCCESS;
case TYPE_PAIR(IS_NULL, IS_OBJECT):
- ZVAL_LONG(result, -1);
+ ZVAL_INT(result, -1);
return SUCCESS;
default:
+ if (Z_ISREF_P(op1)) {
+ op1 = Z_REFVAL_P(op1);
+ continue;
+ } else if (Z_ISREF_P(op2)) {
+ op2 = Z_REFVAL_P(op2);
+ continue;
+ }
+
if (Z_TYPE_P(op1) == IS_OBJECT && Z_OBJ_HANDLER_P(op1, compare)) {
return Z_OBJ_HANDLER_P(op1, compare)(result, op1, op2 TSRMLS_CC);
} else if (Z_TYPE_P(op2) == IS_OBJECT && Z_OBJ_HANDLER_P(op2, compare)) {
@@ -1671,71 +1801,73 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {
}
if (Z_TYPE_P(op1) == IS_OBJECT && Z_TYPE_P(op2) == IS_OBJECT) {
- if (Z_OBJ_HANDLE_P(op1) == Z_OBJ_HANDLE_P(op2)) {
+ if (Z_OBJ_P(op1) == Z_OBJ_P(op2)) {
/* object handles are identical, apparently this is the same object */
- ZVAL_LONG(result, 0);
+ ZVAL_INT(result, 0);
return SUCCESS;
}
if (Z_OBJ_HANDLER_P(op1, compare_objects) == Z_OBJ_HANDLER_P(op2, compare_objects)) {
- ZVAL_LONG(result, Z_OBJ_HANDLER_P(op1, compare_objects)(op1, op2 TSRMLS_CC));
+ ZVAL_INT(result, Z_OBJ_HANDLER_P(op1, compare_objects)(op1, op2 TSRMLS_CC));
return SUCCESS;
}
}
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);
+ zval rv;
+ op_free = Z_OBJ_HT_P(op1)->get(op1, &rv 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);
+ ZVAL_UNDEF(&tmp_free);
+ if (Z_OBJ_HT_P(op1)->cast_object(op1, &tmp_free, ((Z_TYPE_P(op2) == IS_FALSE || Z_TYPE_P(op2) == IS_TRUE) ? _IS_BOOL : Z_TYPE_P(op2)) TSRMLS_CC) == FAILURE) {
+ ZVAL_INT(result, 1);
+ zend_free_obj_get_result(&tmp_free TSRMLS_CC);
return SUCCESS;
}
- ret = compare_function(result, op_free, op2 TSRMLS_CC);
- zend_free_obj_get_result(op_free TSRMLS_CC);
+ ret = compare_function(result, &tmp_free, op2 TSRMLS_CC);
+ zend_free_obj_get_result(&tmp_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);
+ zval rv;
+ op_free = Z_OBJ_HT_P(op2)->get(op2, &rv 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);
+ ZVAL_UNDEF(&tmp_free);
+ if (Z_OBJ_HT_P(op2)->cast_object(op2, &tmp_free, ((Z_TYPE_P(op1) == IS_FALSE || Z_TYPE_P(op1) == IS_TRUE) ? _IS_BOOL : Z_TYPE_P(op1)) TSRMLS_CC) == FAILURE) {
+ ZVAL_INT(result, -1);
+ zend_free_obj_get_result(&tmp_free TSRMLS_CC);
return SUCCESS;
}
- ret = compare_function(result, op1, op_free TSRMLS_CC);
- zend_free_obj_get_result(op_free TSRMLS_CC);
+ ret = compare_function(result, op1, &tmp_free TSRMLS_CC);
+ zend_free_obj_get_result(&tmp_free TSRMLS_CC);
return ret;
} else if (Z_TYPE_P(op1) == IS_OBJECT) {
- ZVAL_LONG(result, 1);
+ ZVAL_INT(result, 1);
return SUCCESS;
}
}
if (!converted) {
- if (Z_TYPE_P(op1) == IS_NULL) {
+ if (Z_TYPE_P(op1) == IS_NULL || Z_TYPE_P(op1) == IS_FALSE) {
zendi_convert_to_boolean(op2, op2_copy, result);
- ZVAL_LONG(result, Z_LVAL_P(op2) ? -1 : 0);
+ ZVAL_INT(result, (Z_TYPE_P(op2) == IS_TRUE) ? -1 : 0);
return SUCCESS;
- } else if (Z_TYPE_P(op2) == IS_NULL) {
+ } else if (Z_TYPE_P(op2) == IS_NULL || Z_TYPE_P(op2) == IS_FALSE) {
zendi_convert_to_boolean(op1, op1_copy, result);
- ZVAL_LONG(result, Z_LVAL_P(op1) ? 1 : 0);
+ ZVAL_INT(result, (Z_TYPE_P(op1) == IS_TRUE) ? 1 : 0);
return SUCCESS;
- } else if (Z_TYPE_P(op1) == IS_BOOL) {
+ } else if (Z_TYPE_P(op1) == IS_TRUE) {
zendi_convert_to_boolean(op2, op2_copy, result);
- ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(op1) - Z_LVAL_P(op2)));
+ ZVAL_INT(result, (Z_TYPE_P(op2) == IS_TRUE) ? 0 : 1);
return SUCCESS;
- } else if (Z_TYPE_P(op2) == IS_BOOL) {
+ } else if (Z_TYPE_P(op2) == IS_TRUE) {
zendi_convert_to_boolean(op1, op1_copy, result);
- ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(op1) - Z_LVAL_P(op2)));
+ ZVAL_INT(result, (Z_TYPE_P(op1) == IS_TRUE) ? 0 : -1);
return SUCCESS;
} else {
zendi_convert_scalar_to_number(op1, op1_copy, result);
@@ -1743,19 +1875,19 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {
converted = 1;
}
} else if (Z_TYPE_P(op1)==IS_ARRAY) {
- ZVAL_LONG(result, 1);
+ ZVAL_INT(result, 1);
return SUCCESS;
} else if (Z_TYPE_P(op2)==IS_ARRAY) {
- ZVAL_LONG(result, -1);
+ ZVAL_INT(result, -1);
return SUCCESS;
} else if (Z_TYPE_P(op1)==IS_OBJECT) {
- ZVAL_LONG(result, 1);
+ ZVAL_INT(result, 1);
return SUCCESS;
} else if (Z_TYPE_P(op2)==IS_OBJECT) {
- ZVAL_LONG(result, -1);
+ ZVAL_INT(result, -1);
return SUCCESS;
} else {
- ZVAL_LONG(result, 0);
+ ZVAL_INT(result, 0);
return FAILURE;
}
}
@@ -1763,59 +1895,66 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {
}
/* }}} */
-static int hash_zval_identical_function(const zval **z1, const zval **z2) /* {{{ */
+static int hash_zval_identical_function(zval *z1, zval *z2 TSRMLS_DC) /* {{{ */
{
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) {
+ ZVAL_DEREF(z1);
+ ZVAL_DEREF(z2);
+ if (is_identical_function(&result, z1, z2 TSRMLS_CC)==FAILURE) {
return 1;
}
- return !Z_LVAL(result);
+ return Z_TYPE(result) != IS_TRUE;
}
/* }}} */
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;
+ ZVAL_BOOL(result, 0);
return SUCCESS;
}
switch (Z_TYPE_P(op1)) {
case IS_NULL:
- Z_LVAL_P(result) = 1;
+ case IS_FALSE:
+ case IS_TRUE:
+ ZVAL_BOOL(result, 1);
+ break;
+ case IS_INT:
+ ZVAL_BOOL(result, Z_IVAL_P(op1) == Z_IVAL_P(op2));
break;
- case IS_BOOL:
- case IS_LONG:
case IS_RESOURCE:
- Z_LVAL_P(result) = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
+ ZVAL_BOOL(result, Z_RES_P(op1) == Z_RES_P(op2));
break;
case IS_DOUBLE:
- Z_LVAL_P(result) = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
+ ZVAL_BOOL(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))));
+ if (Z_STR_P(op1) == Z_STR_P(op2)) {
+ ZVAL_BOOL(result, 1);
+ } else {
+ ZVAL_BOOL(result, (Z_STRSIZE_P(op1) == Z_STRSIZE_P(op2))
+ && (!memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRSIZE_P(op1))));
+ }
break;
case IS_ARRAY:
- Z_LVAL_P(result) = (Z_ARRVAL_P(op1) == Z_ARRVAL_P(op2) ||
+ ZVAL_BOOL(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));
+ ZVAL_BOOL(result, Z_OBJ_P(op1) == Z_OBJ_P(op2));
} else {
- Z_LVAL_P(result) = 0;
+ ZVAL_BOOL(result, 0);
}
break;
default:
- Z_LVAL_P(result) = 0;
+ ZVAL_BOOL(result, 0);
return FAILURE;
}
return SUCCESS;
@@ -1827,7 +1966,7 @@ ZEND_API int is_not_identical_function(zval *result, zval *op1, zval *op2 TSRMLS
if (is_identical_function(result, op1, op2 TSRMLS_CC) == FAILURE) {
return FAILURE;
}
- Z_LVAL_P(result) = !Z_LVAL_P(result);
+ ZVAL_BOOL(result, Z_TYPE_P(result) != IS_TRUE);
return SUCCESS;
}
/* }}} */
@@ -1837,7 +1976,7 @@ 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));
+ ZVAL_BOOL(result, (Z_IVAL_P(result) == 0));
return SUCCESS;
}
/* }}} */
@@ -1847,7 +1986,7 @@ 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));
+ ZVAL_BOOL(result, (Z_IVAL_P(result) != 0));
return SUCCESS;
}
/* }}} */
@@ -1857,7 +1996,7 @@ 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));
+ ZVAL_BOOL(result, (Z_IVAL_P(result) < 0));
return SUCCESS;
}
/* }}} */
@@ -1867,7 +2006,7 @@ ZEND_API int is_smaller_or_equal_function(zval *result, zval *op1, zval *op2 TSR
if (compare_function(result, op1, op2 TSRMLS_CC) == FAILURE) {
return FAILURE;
}
- ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
+ ZVAL_BOOL(result, (Z_IVAL_P(result) <= 0));
return SUCCESS;
}
/* }}} */
@@ -1907,22 +2046,29 @@ ZEND_API zend_bool instanceof_function(const zend_class_entry *instance_ce, cons
static void increment_string(zval *str) /* {{{ */
{
int carry=0;
- int pos=Z_STRLEN_P(str)-1;
- char *s=Z_STRVAL_P(str);
- char *t;
+ zend_size_t pos=Z_STRSIZE_P(str)-1;
+ char *s;
+ zend_string *t;
int last=0; /* Shut up the compiler warning */
int ch;
- if (Z_STRLEN_P(str) == 0) {
- str_efree(Z_STRVAL_P(str));
- Z_STRVAL_P(str) = estrndup("1", sizeof("1")-1);
- Z_STRLEN_P(str) = 1;
+ if (Z_STRSIZE_P(str) == 0) {
+ STR_RELEASE(Z_STR_P(str));
+ Z_STR_P(str) = STR_INIT("1", sizeof("1")-1, 0);
+ Z_TYPE_INFO_P(str) = IS_STRING_EX;
return;
}
- if (IS_INTERNED(s)) {
- Z_STRVAL_P(str) = s = estrndup(s, Z_STRLEN_P(str));
+ if (IS_INTERNED(Z_STR_P(str))) {
+ Z_STR_P(str) = STR_INIT(Z_STRVAL_P(str), Z_STRSIZE_P(str), 0);
+ Z_TYPE_INFO_P(str) = IS_STRING_EX;
+ } else if (Z_REFCOUNT_P(str) > 1) {
+ Z_DELREF_P(str);
+ Z_STR_P(str) = STR_INIT(Z_STRVAL_P(str), Z_STRSIZE_P(str), 0);
+ } else {
+ STR_FORGET_HASH_VAL(Z_STR_P(str));
}
+ s = Z_STRVAL_P(str);
while (pos >= 0) {
ch = s[pos];
@@ -1964,62 +2110,62 @@ static void increment_string(zval *str) /* {{{ */
}
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';
+ t = STR_ALLOC(Z_STRSIZE_P(str)+1, 0);
+ memcpy(t->val + 1, Z_STRVAL_P(str), Z_STRSIZE_P(str));
+ t->val[Z_STRSIZE_P(str) + 1] = '\0';
switch (last) {
case NUMERIC:
- t[0] = '1';
+ t->val[0] = '1';
break;
case UPPER_CASE:
- t[0] = 'A';
+ t->val[0] = 'A';
break;
case LOWER_CASE:
- t[0] = 'a';
+ t->val[0] = 'a';
break;
}
- str_efree(Z_STRVAL_P(str));
- Z_STRVAL_P(str) = t;
+ STR_FREE(Z_STR_P(str));
+ ZVAL_NEW_STR(str, t);
}
}
/* }}} */
ZEND_API int increment_function(zval *op1) /* {{{ */
{
+try_again:
switch (Z_TYPE_P(op1)) {
- case IS_LONG:
- if (Z_LVAL_P(op1) == LONG_MAX) {
+ case IS_INT:
+ if (Z_IVAL_P(op1) == ZEND_INT_MAX) {
/* switch to double */
- double d = (double)Z_LVAL_P(op1);
+ double d = (double)Z_IVAL_P(op1);
ZVAL_DOUBLE(op1, d+1);
} else {
- Z_LVAL_P(op1)++;
+ Z_IVAL_P(op1)++;
}
break;
case IS_DOUBLE:
Z_DVAL_P(op1) = Z_DVAL_P(op1) + 1;
break;
case IS_NULL:
- ZVAL_LONG(op1, 1);
+ ZVAL_INT(op1, 1);
break;
case IS_STRING: {
- long lval;
+ zend_int_t 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 (is_numeric_string(Z_STRVAL_P(op1), Z_STRSIZE_P(op1), &lval, &dval, 0)) {
+ case IS_INT:
+ STR_RELEASE(Z_STR_P(op1));
+ if (lval == ZEND_INT_MAX) {
/* switch to double */
double d = (double)lval;
ZVAL_DOUBLE(op1, d+1);
} else {
- ZVAL_LONG(op1, lval+1);
+ ZVAL_INT(op1, lval+1);
}
break;
case IS_DOUBLE:
- str_efree(Z_STRVAL_P(op1));
+ STR_RELEASE(Z_STR_P(op1));
ZVAL_DOUBLE(op1, dval+1);
break;
default:
@@ -2031,18 +2177,20 @@ ZEND_API int increment_function(zval *op1) /* {{{ */
break;
case IS_OBJECT:
if (Z_OBJ_HANDLER_P(op1, do_operation)) {
- zval *op2;
+ zval op2;
int res;
TSRMLS_FETCH();
- MAKE_STD_ZVAL(op2);
- ZVAL_LONG(op2, 1);
- res = Z_OBJ_HANDLER_P(op1, do_operation)(ZEND_ADD, op1, op1, op2 TSRMLS_CC);
+ ZVAL_INT(&op2, 1);
+ res = Z_OBJ_HANDLER_P(op1, do_operation)(ZEND_ADD, op1, op1, &op2 TSRMLS_CC);
zval_ptr_dtor(&op2);
return res;
}
return FAILURE;
+ case IS_REFERENCE:
+ op1 = Z_REFVAL_P(op1);
+ goto try_again;
default:
return FAILURE;
}
@@ -2052,57 +2200,60 @@ ZEND_API int increment_function(zval *op1) /* {{{ */
ZEND_API int decrement_function(zval *op1) /* {{{ */
{
- long lval;
+ zend_int_t lval;
double dval;
+try_again:
switch (Z_TYPE_P(op1)) {
- case IS_LONG:
- if (Z_LVAL_P(op1) == LONG_MIN) {
- double d = (double)Z_LVAL_P(op1);
+ case IS_INT:
+ if (Z_IVAL_P(op1) == ZEND_INT_MIN) {
+ double d = (double)Z_IVAL_P(op1);
ZVAL_DOUBLE(op1, d-1);
} else {
- Z_LVAL_P(op1)--;
+ Z_IVAL_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_efree(Z_STRVAL_P(op1));
- ZVAL_LONG(op1, -1);
+ if (Z_STRSIZE_P(op1) == 0) { /* consider as 0 */
+ STR_RELEASE(Z_STR_P(op1));
+ ZVAL_INT(op1, -1);
break;
}
- 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_MIN) {
+ switch (is_numeric_string(Z_STRVAL_P(op1), Z_STRSIZE_P(op1), &lval, &dval, 0)) {
+ case IS_INT:
+ STR_RELEASE(Z_STR_P(op1));
+ if (lval == ZEND_INT_MIN) {
double d = (double)lval;
ZVAL_DOUBLE(op1, d-1);
} else {
- ZVAL_LONG(op1, lval-1);
+ ZVAL_INT(op1, lval-1);
}
break;
case IS_DOUBLE:
- str_efree(Z_STRVAL_P(op1));
+ STR_RELEASE(Z_STR_P(op1));
ZVAL_DOUBLE(op1, dval - 1);
break;
}
break;
case IS_OBJECT:
if (Z_OBJ_HANDLER_P(op1, do_operation)) {
- zval *op2;
+ zval op2;
int res;
TSRMLS_FETCH();
- MAKE_STD_ZVAL(op2);
- ZVAL_LONG(op2, 1);
- res = Z_OBJ_HANDLER_P(op1, do_operation)(ZEND_SUB, op1, op1, op2 TSRMLS_CC);
+ ZVAL_INT(&op2, 1);
+ res = Z_OBJ_HANDLER_P(op1, do_operation)(ZEND_SUB, op1, op1, &op2 TSRMLS_CC);
zval_ptr_dtor(&op2);
return res;
}
return FAILURE;
+ case IS_REFERENCE:
+ op1 = Z_REFVAL_P(op1);
+ goto try_again;
default:
return FAILURE;
}
@@ -2114,7 +2265,7 @@ ZEND_API int decrement_function(zval *op1) /* {{{ */
ZEND_API int zval_is_true(zval *op) /* {{{ */
{
convert_to_boolean(op);
- return (Z_LVAL_P(op) ? 1 : 0);
+ return (Z_TYPE_P(op) == IS_TRUE ? 1 : 0);
}
/* }}} */
@@ -2126,7 +2277,7 @@ ZEND_API void zend_update_current_locale(void) /* {{{ */
/* }}} */
#endif
-ZEND_API char *zend_str_tolower_copy(char *dest, const char *source, unsigned int length) /* {{{ */
+ZEND_API char *zend_str_tolower_copy(char *dest, const char *source, zend_size_t length) /* {{{ */
{
register unsigned char *str = (unsigned char*)source;
register unsigned char *result = (unsigned char*)dest;
@@ -2141,13 +2292,13 @@ ZEND_API char *zend_str_tolower_copy(char *dest, const char *source, unsigned in
}
/* }}} */
-ZEND_API char *zend_str_tolower_dup(const char *source, unsigned int length) /* {{{ */
+ZEND_API char *zend_str_tolower_dup(const char *source, zend_size_t length) /* {{{ */
{
return zend_str_tolower_copy((char *)emalloc(length+1), source, length);
}
/* }}} */
-ZEND_API void zend_str_tolower(char *str, unsigned int length) /* {{{ */
+ZEND_API void zend_str_tolower(char *str, zend_size_t length) /* {{{ */
{
register unsigned char *p = (unsigned char*)str;
register unsigned char *end = p + length;
@@ -2159,7 +2310,7 @@ ZEND_API void zend_str_tolower(char *str, unsigned int length) /* {{{ */
}
/* }}} */
-ZEND_API int zend_binary_strcmp(const char *s1, uint len1, const char *s2, uint len2) /* {{{ */
+ZEND_API int zend_binary_strcmp(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2) /* {{{ */
{
int retval;
@@ -2168,14 +2319,14 @@ ZEND_API int zend_binary_strcmp(const char *s1, uint len1, const char *s2, uint
}
retval = memcmp(s1, s2, MIN(len1, len2));
if (!retval) {
- return (len1 - len2);
+ return (int)(len1 - len2);
} else {
return retval;
}
}
/* }}} */
-ZEND_API int zend_binary_strncmp(const char *s1, uint len1, const char *s2, uint len2, uint length) /* {{{ */
+ZEND_API int zend_binary_strncmp(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2, zend_size_t length) /* {{{ */
{
int retval;
@@ -2184,16 +2335,16 @@ ZEND_API int zend_binary_strncmp(const char *s1, uint len1, const char *s2, uint
}
retval = memcmp(s1, s2, MIN(length, MIN(len1, len2)));
if (!retval) {
- return (MIN(length, len1) - MIN(length, len2));
+ return (int)(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) /* {{{ */
+ZEND_API int zend_binary_strcasecmp(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2) /* {{{ */
{
- int len;
+ zend_size_t len;
int c1, c2;
if (s1 == s2) {
@@ -2209,13 +2360,13 @@ ZEND_API int zend_binary_strcasecmp(const char *s1, uint len1, const char *s2, u
}
}
- return len1 - len2;
+ return (int)(len1 - len2);
}
/* }}} */
-ZEND_API int zend_binary_strncasecmp(const char *s1, uint len1, const char *s2, uint len2, uint length) /* {{{ */
+ZEND_API int zend_binary_strncasecmp(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2, zend_size_t length) /* {{{ */
{
- int len;
+ zend_size_t len;
int c1, c2;
if (s1 == s2) {
@@ -2230,13 +2381,13 @@ ZEND_API int zend_binary_strncasecmp(const char *s1, uint len1, const char *s2,
}
}
- return MIN(length, len1) - MIN(length, len2);
+ return (int)(MIN(length, len1) - MIN(length, len2));
}
/* }}} */
-ZEND_API int zend_binary_strcasecmp_l(const char *s1, uint len1, const char *s2, uint len2) /* {{{ */
+ZEND_API int zend_binary_strcasecmp_l(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2) /* {{{ */
{
- int len;
+ zend_size_t len;
int c1, c2;
if (s1 == s2) {
@@ -2252,13 +2403,13 @@ ZEND_API int zend_binary_strcasecmp_l(const char *s1, uint len1, const char *s2,
}
}
- return len1 - len2;
+ return (int)(len1 - len2);
}
/* }}} */
-ZEND_API int zend_binary_strncasecmp_l(const char *s1, uint len1, const char *s2, uint len2, uint length) /* {{{ */
+ZEND_API int zend_binary_strncasecmp_l(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2, zend_size_t length) /* {{{ */
{
- int len;
+ zend_size_t len;
int c1, c2;
if (s1 == s2) {
@@ -2273,31 +2424,31 @@ ZEND_API int zend_binary_strncasecmp_l(const char *s1, uint len1, const char *s2
}
}
- return MIN(length, len1) - MIN(length, len2);
+ return (int)(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));
+ return zend_binary_strcmp(Z_STRVAL_P(s1), Z_STRSIZE_P(s1), Z_STRVAL_P(s2), Z_STRSIZE_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));
+ return zend_binary_strncmp(Z_STRVAL_P(s1), Z_STRSIZE_P(s1), Z_STRVAL_P(s2), Z_STRSIZE_P(s2), Z_IVAL_P(s3));
}
/* }}} */
ZEND_API int zend_binary_zval_strcasecmp(zval *s1, zval *s2) /* {{{ */
{
- return zend_binary_strcasecmp_l(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2));
+ return zend_binary_strcasecmp_l(Z_STRVAL_P(s1), Z_STRSIZE_P(s1), Z_STRVAL_P(s2), Z_STRSIZE_P(s2));
}
/* }}} */
ZEND_API int zend_binary_zval_strncasecmp(zval *s1, zval *s2, zval *s3) /* {{{ */
{
- 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));
+ return zend_binary_strncasecmp_l(Z_STRVAL_P(s1), Z_STRSIZE_P(s1), Z_STRVAL_P(s2), Z_STRSIZE_P(s2), Z_IVAL_P(s3));
}
/* }}} */
@@ -2305,12 +2456,12 @@ ZEND_API void zendi_smart_strcmp(zval *result, zval *s1, zval *s2) /* {{{ */
{
int ret1, ret2;
int oflow1, oflow2;
- long lval1 = 0, lval2 = 0;
+ zend_int_t lval1 = 0, lval2 = 0;
double dval1 = 0.0, dval2 = 0.0;
- 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 ((ret1=is_numeric_string_ex(Z_STRVAL_P(s1), Z_STRSIZE_P(s1), &lval1, &dval1, 0, &oflow1)) &&
+ (ret2=is_numeric_string_ex(Z_STRVAL_P(s2), Z_STRSIZE_P(s2), &lval2, &dval2, 0, &oflow2))) {
+#if ZEND_UINT_MAX == 0xFFFFFFFF
if (oflow1 != 0 && oflow1 == oflow2 && dval1 - dval2 == 0. &&
((oflow1 == 1 && dval1 > 9007199254740991. /*0x1FFFFFFFFFFFFF*/)
|| (oflow1 == -1 && dval1 < -9007199254740991.))) {
@@ -2325,13 +2476,13 @@ ZEND_API void zendi_smart_strcmp(zval *result, zval *s1, zval *s2) /* {{{ */
if (ret1!=IS_DOUBLE) {
if (oflow2) {
/* 2nd operand is integer > LONG_MAX (oflow2==1) or < LONG_MIN (-1) */
- ZVAL_LONG(result, -1 * oflow2);
+ ZVAL_INT(result, -1 * oflow2);
return;
}
dval1 = (double) lval1;
} else if (ret2!=IS_DOUBLE) {
if (oflow1) {
- ZVAL_LONG(result, oflow1);
+ ZVAL_INT(result, oflow1);
return;
}
dval2 = (double) lval2;
@@ -2341,26 +2492,26 @@ ZEND_API void zendi_smart_strcmp(zval *result, zval *s1, zval *s2) /* {{{ */
goto string_cmp;
}
Z_DVAL_P(result) = dval1 - dval2;
- ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
+ ZVAL_INT(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));
+ ZVAL_INT(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)));
+ Z_IVAL_P(result) = zend_binary_strcmp(Z_STRVAL_P(s1), Z_STRSIZE_P(s1), Z_STRVAL_P(s2), Z_STRSIZE_P(s2));
+ ZVAL_INT(result, ZEND_NORMALIZE_BOOL(Z_IVAL_P(result)));
}
}
/* }}} */
-static int hash_zval_compare_function(const zval **z1, const zval **z2 TSRMLS_DC) /* {{{ */
+static int hash_zval_compare_function(zval *z1, zval *z2 TSRMLS_DC) /* {{{ */
{
zval result;
- if (compare_function(&result, (zval *) *z1, (zval *) *z2 TSRMLS_CC)==FAILURE) {
+ if (compare_function(&result, z1, z2 TSRMLS_CC)==FAILURE) {
return 1;
}
- return Z_LVAL(result);
+ return Z_IVAL(result);
}
/* }}} */
@@ -2372,7 +2523,7 @@ ZEND_API int zend_compare_symbol_tables_i(HashTable *ht1, HashTable *ht2 TSRMLS_
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));
+ ZVAL_INT(result, ht1 == ht2 ? 0 : zend_hash_compare(ht1, ht2, (compare_func_t) hash_zval_compare_function, 0 TSRMLS_CC));
}
/* }}} */
@@ -2384,29 +2535,42 @@ ZEND_API void zend_compare_arrays(zval *result, zval *a1, zval *a2 TSRMLS_DC) /*
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;
+ if (Z_OBJ_P(o1) == Z_OBJ_P(o2)) {
+ ZVAL_INT(result, 0);
return;
}
if (Z_OBJ_HT_P(o1)->compare_objects == NULL) {
- Z_LVAL_P(result) = 1;
+ ZVAL_INT(result, 1);
} else {
- Z_LVAL_P(result) = Z_OBJ_HT_P(o1)->compare_objects(o1, o2 TSRMLS_CC);
+ ZVAL_INT(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) /* {{{ */
{
+ zend_string *str;
TSRMLS_FETCH();
- Z_STRLEN_P(op) = zend_spprintf(&Z_STRVAL_P(op), 0, "%.*G", (int) EG(precision), (double)Z_DVAL_P(op));
+ str = zend_strpprintf(0, "%.*G", (int) EG(precision), (double)Z_DVAL_P(op));
+ ZVAL_NEW_STR(op, str);
+}
+/* }}} */
+
+ZEND_API zend_string *zend_int_to_str(zend_int_t num) /* {{{ */
+{
+ char buf[MAX_LENGTH_OF_ZEND_INT + 1];
+ char *res;
+ _zend_print_signed_to_buf(buf + sizeof(buf) - 1, num, zend_uint_t, res);
+ return STR_INIT(res, buf + sizeof(buf) - 1 - res, 0);
}
/* }}} */
+ZEND_API zend_uchar is_numeric_str_function(const zend_string *str, zend_int_t *lval, double *dval) {
+ return is_numeric_string_ex(str->val, str->len, lval, dval, -1, NULL);
+}
+
/*
* Local variables:
* tab-width: 4
View Lorry Controller Status