Mirrors
/
php
mirror of https://github.com/php/php-src
3
0
Fork 0
Code Releases Activity
Browse Source

Unicode stuff is changed according to decision maden on PDM. 

Now IS_BINRAY data type is removed and IS_STRING starts behave as IS_BINARY in unicode mode. IS_STRING is incompatible with IS_UNICODE, so ALL functions should be improved to support unicode mode.
migration/RELEASE_1_0_0
Dmitry Stogov 20 years ago
parent
465b131c2f
commit
227295a4f1
71 changed files with 596 additions and 1002 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      Zend/tests/bug26166.phpt
  2. 2
      Zend/tests/bug28444.phpt
  3. 29
      Zend/zend.c
  4. 1
      Zend/zend.h
  5. 226
      Zend/zend_API.c
  6. 39
      Zend/zend_API.h
  7. 10
      Zend/zend_builtin_functions.c
  8. 1
      Zend/zend_compile.c
  9. 37
      Zend/zend_exceptions.c
  10. 15
      Zend/zend_execute.c
  11. 1
      Zend/zend_execute.h
  12. 9
      Zend/zend_execute_API.c
  13. 20
      Zend/zend_hash.c
  14. 9
      Zend/zend_hash.h
  15. 2
      Zend/zend_highlight.c
  16. 9
      Zend/zend_interfaces.c
  17. 9
      Zend/zend_language_parser.y
  18. 20
      Zend/zend_language_scanner.l
  19. 86
      Zend/zend_operators.c
  20. 12
      Zend/zend_operators.h
  21. 13
      Zend/zend_unicode.c
  22. 1
      Zend/zend_unicode.h
  23. 3
      Zend/zend_variables.c
  24. 15
      Zend/zend_vm_def.h
  25. 98
      Zend/zend_vm_execute.h
  26. 1
      ext/ctype/ctype.c
  27. 19
      ext/date/php_date.c
  28. 12
      ext/date/tests/bug35143.phpt
  29. 2
      ext/dom/document.c
  30. 6
      ext/dom/node.c
  31. 25
      ext/dom/tests/dom002.phpt
  32. 6
      ext/dom/tests/dom_set_attr_node.phpt
  33. 6
      ext/reflection/php_reflection.c
  34. 13
      ext/simplexml/simplexml.c
  35. 3
      ext/simplexml/tests/013.phpt
  36. 4
      ext/simplexml/tests/profile11.phpt
  37. 3
      ext/spl/php_spl.c
  38. 7
      ext/spl/spl_array.c
  39. 20
      ext/spl/spl_iterators.c
  40. 6
      ext/sqlite/sqlite.c
  41. 65
      ext/standard/array.c
  42. 5
      ext/standard/basic_functions.c
  43. 5
      ext/standard/file.c
  44. 25
      ext/standard/math.c
  45. 4
      ext/standard/md5.c
  46. 4
      ext/standard/sha1.c
  47. 256
      ext/standard/string.c
  48. 33
      ext/standard/tests/general_functions/008.phpt
  49. 3
      ext/standard/tests/math/bug21523.phpt
  50. 3
      ext/standard/tests/strings/bug22187.phpt
  51. 9
      ext/standard/tests/strings/strval.phpt
  52. 21
      ext/standard/type.c
  53. 17
      ext/standard/user_filters.c
  54. 40
      ext/standard/var.c
  55. 3
      ext/standard/var_unserializer.re
  56. 186
      ext/tokenizer/tests/002.phpt
  57. 4
      ext/tokenizer/tests/003.phpt
  58. 30
      ext/tokenizer/tests/bug26463.phpt
  59. 4
      ext/xml/xml.c
  60. 6
      main/main.c
  61. 4
      main/output.c
  62. 4
      main/php_variables.c
  63. 3
      main/streams/plain_wrapper.c
  64. 4
      run-tests.php
  65. 6
      tests/basic/bug29971.phpt
  66. 3
      tests/func/006.phpt
  67. 15
      tests/lang/catchable_error_002.phpt
  68. 4
      tests/run-test/test004.phpt
  69. 8
      tests/run-test/test005.phpt
  70. 9
      tests/run-test/test008.phpt
  71. 8
      tests/run-test/test008a.phpt

7
Zend/tests/bug26166.phpt
View File

@ -72,3 +72,10 @@ string(52) "Method None::__toString() must return a string value"
===THROW===
Fatal error: Object of class Error could not be converted to string in %sbug26166.php on line %d
--UEXPECTF--
Hello World!
===NONE===
unicode(52) "Method None::__toString() must return a string value"
===THROW===
Fatal error: Object of class Error could not be converted to string in %sbug26166.php on line %d

2
Zend/tests/bug28444.phpt
View File

@ -90,7 +90,7 @@ Overloaded::__set(y,3)
int(3)
Overloaded::__get(y)
int(3)
string(55) "Object of class Object could not be converted to string"
unicode(55) "Object of class Object could not be converted to string"
Overloaded::__set(z,)
object(Object)#%d (1) {
[u"x"]=>

29
Zend/zend.c
View File

@ -263,9 +263,6 @@ static void print_hash(HashTable *ht, int indent, zend_bool is_object TSRMLS_DC)
goto str_type;
case HASH_KEY_IS_UNICODE:
ztype = IS_UNICODE;
goto str_type;
case HASH_KEY_IS_BINARY:
ztype = IS_BINARY;
str_type:
if (is_object) {
char *prop_name, *class_name;
@ -320,9 +317,6 @@ static void print_flat_hash(HashTable *ht TSRMLS_DC)
case HASH_KEY_IS_STRING:
ZEND_PUTS(string_key);
break;
case HASH_KEY_IS_BINARY:
zend_printf("b\"%s\"", string_key);
break;
case HASH_KEY_IS_UNICODE:
zend_printf("%r", string_key);
break;
@ -377,7 +371,7 @@ ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_cop
UErrorCode temp = U_ZERO_ERROR;
TSRMLS_FETCH();
if (expr->type == IS_BINARY ||
if (
/* UTODO: clean this up */
(expr->type == IS_STRING &&
(!strcmp(ucnv_getName(ZEND_U_CONVERTER(UG(output_encoding_conv)), &temp),
@ -466,6 +460,10 @@ ZEND_API void zend_make_unicode_zval(zval *expr, zval *expr_copy, int *use_copy)
zend_error(EG(exception) ? E_ERROR : E_RECOVERABLE_ERROR, "Object of class %v could not be converted to string", Z_OBJCE_P(expr)->name);
ZVAL_EMPTY_UNICODE(expr_copy);
break;
case IS_ARRAY:
expr_copy->value.ustr.len = sizeof("Array")-1;
expr_copy->value.ustr.val = zend_ascii_to_unicode("Array", sizeof("Array") ZEND_FILE_LINE_CC);
break;
default:
*expr_copy = *expr;
zval_copy_ctor(expr_copy);
@ -650,9 +648,7 @@ static void zend_set_default_compile_time_values(TSRMLS_D)
static void zval_copy_persistent(zval *zv)
{
if (Z_TYPE_P(zv) == IS_BINARY) {
Z_BINVAL_P(zv) = zend_strndup(Z_BINVAL_P(zv), Z_BINLEN_P(zv));
} else if (Z_TYPE_P(zv) == IS_UNICODE) {
if (Z_TYPE_P(zv) == IS_UNICODE) {
Z_USTRVAL_P(zv) = zend_ustrndup(Z_USTRVAL_P(zv), Z_USTRLEN_P(zv));
} else if (Z_TYPE_P(zv) == IS_STRING || Z_TYPE_P(zv) == IS_CONSTANT) {
UChar *ustr;
@ -1684,18 +1680,23 @@ ZEND_API void zend_error(int type, const char *format, ...)
#endif
va_copy(usr_copy, args);
z_error_message->value.str.len = zend_vspprintf(&z_error_message->value.str.val, 0, format, usr_copy);
z_error_message->type = IS_STRING;
if (UG(unicode)) {
char *str = z_error_message->value.str.val;
int len = z_error_message->value.str.len;
ZVAL_RT_STRINGL(z_error_message, str, len, 1);
efree(str);
}
#ifdef va_copy
va_end(usr_copy);
#endif
z_error_message->type = IS_STRING;
z_error_type->value.lval = type;
z_error_type->type = IS_LONG;
if (error_filename) {
z_error_filename->value.str.len = strlen(error_filename);
z_error_filename->value.str.val = estrndup(error_filename, z_error_filename->value.str.len);
z_error_filename->type = IS_STRING;
ZVAL_RT_STRING(z_error_filename, error_filename, 1);
}
z_error_lineno->value.lval = error_lineno;

1
Zend/zend.h
View File

@ -434,7 +434,6 @@ typedef int (*zend_write_func_t)(const char *str, uint str_length);
#define IS_CONSTANT 8
#define IS_CONSTANT_ARRAY 9
#define IS_UNICODE 10
#define IS_BINARY 11
/* Ugly hack to support constants as static array indices */
#define IS_CONSTANT_INDEX 0x80

226
Zend/zend_API.c
View File

@ -244,9 +244,6 @@ ZEND_API char *zend_zval_type_name(zval *arg)
case IS_UNICODE:
return "Unicode string";
case IS_BINARY:
return "binary data";
default:
return "unknown";
}
@ -281,11 +278,6 @@ ZEND_API int zend_get_object_classname(zval *object, char **class_name, zend_uin
*pl = Z_STRLEN_PP(arg); \
*type = IS_STRING;
#define RETURN_AS_BINARY(arg, p, pl, type) \
*(char**)p = Z_BINVAL_PP(arg); \
*pl = Z_BINLEN_PP(arg); \
*type = IS_BINARY;
#define RETURN_AS_UNICODE(arg, p, pl, type) \
*(UChar**)p = Z_USTRVAL_PP(arg); \
*pl = Z_USTRLEN_PP(arg); \
@ -424,11 +416,6 @@ static char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, char **sp
*pl = Z_STRLEN_PP(arg);
break;
case IS_BINARY:
*p = Z_BINVAL_PP(arg);
*pl = Z_BINLEN_PP(arg);
break;
case IS_OBJECT: {
if (Z_OBJ_HANDLER_PP(arg, cast_object)) {
SEPARATE_ZVAL_IF_NOT_REF(arg);
@ -450,55 +437,6 @@ static char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, char **sp
}
break;
case 'y':
{
char **p = va_arg(*va, char **);
int *pl = va_arg(*va, int *);
switch (Z_TYPE_PP(arg)) {
case IS_NULL:
if (return_null) {
*p = NULL;
*pl = 0;
break;
}
/* break omitted intentionally */
case IS_STRING:
case IS_LONG:
case IS_DOUBLE:
case IS_BOOL:
case IS_UNICODE:
convert_to_binary_ex(arg);
*p = Z_BINVAL_PP(arg);
*pl = Z_BINLEN_PP(arg);
break;
case IS_BINARY:
*p = Z_BINVAL_PP(arg);
*pl = Z_BINLEN_PP(arg);
break;
case IS_OBJECT: {
if (Z_OBJ_HANDLER_PP(arg, cast_object)) {
SEPARATE_ZVAL_IF_NOT_REF(arg);
if (Z_OBJ_HANDLER_PP(arg, cast_object)(*arg, *arg, IS_BINARY TSRMLS_CC) == SUCCESS) {
*pl = Z_BINLEN_PP(arg);
*p = Z_BINVAL_PP(arg);
break;
} else {
return "binary data";
}
}
}
case IS_ARRAY:
case IS_RESOURCE:
default:
return "binary data";
}
}
break;
case 'u':
{
UChar **p = va_arg(*va, UChar **);
@ -564,7 +502,6 @@ static char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, char **sp
case IS_BOOL:
case IS_STRING:
case IS_UNICODE:
case IS_BINARY:
if (T_arg_type == IS_UNICODE) {
convert_to_unicode_ex(arg);
RETURN_AS_UNICODE(arg, p, pl, type);
@ -578,9 +515,6 @@ static char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, char **sp
zend_error(E_WARNING, "%v%s%v() does not allow mixing binary and Unicode parameters",
class_name, space, get_active_function_name(TSRMLS_C));
return "";
} else {
convert_to_binary_ex(arg);
RETURN_AS_BINARY(arg, p, pl, type);
}
}
break;
@ -639,10 +573,6 @@ static char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, char **sp
RETURN_AS_STRING(arg, p, pl, type);
break;
case IS_BINARY:
RETURN_AS_BINARY(arg, p, pl, type);
break;
case IS_UNICODE:
RETURN_AS_UNICODE(arg, p, pl, type);
break;
@ -926,10 +856,7 @@ static int zend_parse_va_args(int num_args, char *type_spec, va_list *va, int fl
switch (*spec_walk) {
case 'T':
arg = (zval **) p - (arg_count-i);
if (Z_TYPE_PP(arg) == IS_BINARY) {
/* we can always convert to binary */
T_arg_type = IS_BINARY;
} else if (Z_TYPE_PP(arg) == IS_UNICODE && (T_arg_type == -1 || T_arg_type == IS_STRING)) {
if (Z_TYPE_PP(arg) == IS_UNICODE && (T_arg_type == -1 || T_arg_type == IS_STRING)) {
/* we can upgrade from strings to Unicode */
T_arg_type = IS_UNICODE;
} else if (Z_TYPE_PP(arg) == IS_STRING && T_arg_type == -1) {
@ -1082,8 +1009,6 @@ static int zend_merge_property(zval **value, int num_args, va_list args, zend_ha
MAKE_STD_ZVAL(member);
if (hash_key->type == IS_STRING) {
ZVAL_STRINGL(member, hash_key->u.string, hash_key->nKeyLength-1, 1);
} else if (hash_key->type == IS_BINARY) {
ZVAL_BINARYL(member, hash_key->u.string, hash_key->nKeyLength-1, 1);
} else if (hash_key->type == IS_UNICODE) {
ZVAL_UNICODEL(member, hash_key->u.unicode, hash_key->nKeyLength-1, 1);
}
@ -1148,9 +1073,6 @@ ZEND_API void zend_update_class_constants(zend_class_entry *class_type TSRMLS_DC
case HASH_KEY_IS_UNICODE:
utype = IS_UNICODE;
break;
case HASH_KEY_IS_BINARY:
utype = IS_BINARY;
break;
case HASH_KEY_IS_STRING:
default:
utype = IS_STRING;
@ -1414,28 +1336,6 @@ ZEND_API int add_index_stringl(zval *arg, ulong index, char *str, uint length, i
}
ZEND_API int add_index_binary(zval *arg, ulong index, char *str, int duplicate TSRMLS_DC)
{
zval *tmp;
MAKE_STD_ZVAL(tmp);
ZVAL_BINARY(tmp, str, duplicate);
return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL);
}
ZEND_API int add_index_binaryl(zval *arg, ulong index, char *str, uint length, int duplicate TSRMLS_DC)
{
zval *tmp;
MAKE_STD_ZVAL(tmp);
ZVAL_BINARYL(tmp, str, length, duplicate);
return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL);
}
ZEND_API int add_index_unicode(zval *arg, ulong index, UChar *str, int duplicate)
{
zval *tmp;
@ -1541,29 +1441,6 @@ ZEND_API int add_next_index_stringl(zval *arg, char *str, uint length, int dupli
}
ZEND_API int add_next_index_binary(zval *arg, char *str, int duplicate)
{
zval *tmp;
TSRMLS_FETCH();
MAKE_STD_ZVAL(tmp);
ZVAL_BINARY(tmp, str, duplicate);
return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL);
}
ZEND_API int add_next_index_binaryl(zval *arg, char *str, uint length, int duplicate)
{
zval *tmp;
TSRMLS_FETCH();
MAKE_STD_ZVAL(tmp);
ZVAL_BINARYL(tmp, str, length, duplicate);
return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL);
}
ZEND_API int add_next_index_unicode(zval *arg, UChar *str, int duplicate)
{
zval *tmp;
@ -1657,30 +1534,6 @@ ZEND_API int add_get_index_stringl(zval *arg, ulong index, char *str, uint lengt
return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), dest);
}
ZEND_API int add_get_index_binary(zval *arg, ulong index, char *str, void **dest, int duplicate)
{
zval *tmp;
TSRMLS_FETCH();
MAKE_STD_ZVAL(tmp);
ZVAL_BINARY(tmp, str, duplicate);
return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), dest);
}
ZEND_API int add_get_index_binaryl(zval *arg, ulong index, char *str, uint length, void **dest, int duplicate)
{
zval *tmp;
TSRMLS_FETCH();
MAKE_STD_ZVAL(tmp);
ZVAL_BINARYL(tmp, str, length, duplicate);
return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), dest);
}
ZEND_API int add_get_index_unicode(zval *arg, ulong index, UChar *str, void **dest, int duplicate)
{
zval *tmp;
@ -1711,7 +1564,7 @@ ZEND_API int add_property_long_ex(zval *arg, char *key, uint key_len, long n TSR
ZVAL_LONG(tmp, n);
MAKE_STD_ZVAL(z_key);
ZVAL_STRINGL(z_key, key, key_len-1, 1);
ZVAL_ASCII_STRINGL(z_key, key, key_len-1, 1);
Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp TSRMLS_CC);
zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
@ -1728,7 +1581,7 @@ ZEND_API int add_property_bool_ex(zval *arg, char *key, uint key_len, int b TSRM
ZVAL_BOOL(tmp, b);
MAKE_STD_ZVAL(z_key);
ZVAL_STRINGL(z_key, key, key_len-1, 1);
ZVAL_ASCII_STRINGL(z_key, key, key_len-1, 1);
Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp TSRMLS_CC);
zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
@ -1745,7 +1598,7 @@ ZEND_API int add_property_null_ex(zval *arg, char *key, uint key_len TSRMLS_DC)
ZVAL_NULL(tmp);
MAKE_STD_ZVAL(z_key);
ZVAL_STRINGL(z_key, key, key_len-1, 1);
ZVAL_ASCII_STRINGL(z_key, key, key_len-1, 1);
Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp TSRMLS_CC);
zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
@ -1762,7 +1615,7 @@ ZEND_API int add_property_resource_ex(zval *arg, char *key, uint key_len, long n
ZVAL_RESOURCE(tmp, n);
MAKE_STD_ZVAL(z_key);
ZVAL_STRINGL(z_key, key, key_len-1, 1);
ZVAL_ASCII_STRINGL(z_key, key, key_len-1, 1);
Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp TSRMLS_CC);
zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
@ -1780,7 +1633,7 @@ ZEND_API int add_property_double_ex(zval *arg, char *key, uint key_len, double d
ZVAL_DOUBLE(tmp, d);
MAKE_STD_ZVAL(z_key);
ZVAL_STRINGL(z_key, key, key_len-1, 1);
ZVAL_ASCII_STRINGL(z_key, key, key_len-1, 1);
Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp TSRMLS_CC);
zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
@ -1798,7 +1651,7 @@ ZEND_API int add_property_string_ex(zval *arg, char *key, uint key_len, char *st
ZVAL_STRING(tmp, str, duplicate);
MAKE_STD_ZVAL(z_key);
ZVAL_STRINGL(z_key, key, key_len-1, 1);
ZVAL_ASCII_STRINGL(z_key, key, key_len-1, 1);
Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp TSRMLS_CC);
zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
@ -1815,7 +1668,7 @@ ZEND_API int add_property_stringl_ex(zval *arg, char *key, uint key_len, char *s
ZVAL_STRINGL(tmp, str, length, duplicate);
MAKE_STD_ZVAL(z_key);
ZVAL_STRINGL(z_key, key, key_len-1, 1);
ZVAL_ASCII_STRINGL(z_key, key, key_len-1, 1);
Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp TSRMLS_CC);
zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
@ -1832,7 +1685,7 @@ ZEND_API int add_property_ascii_string_ex(zval *arg, char *key, uint key_len, ch
ZVAL_ASCII_STRING(tmp, str, duplicate);
MAKE_STD_ZVAL(z_key);
ZVAL_STRINGL(z_key, key, key_len-1, 1);
ZVAL_ASCII_STRINGL(z_key, key, key_len-1, 1);
Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp TSRMLS_CC);
zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
@ -1849,7 +1702,7 @@ ZEND_API int add_property_ascii_stringl_ex(zval *arg, char *key, uint key_len, c
ZVAL_ASCII_STRINGL(tmp, str, length, duplicate);
MAKE_STD_ZVAL(z_key);
ZVAL_STRINGL(z_key, key, key_len-1, 1);
ZVAL_ASCII_STRINGL(z_key, key, key_len-1, 1);
Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp TSRMLS_CC);
zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
@ -1866,7 +1719,7 @@ ZEND_API int add_property_rt_string_ex(zval *arg, char *key, uint key_len, char
ZVAL_RT_STRING(tmp, str, duplicate);
MAKE_STD_ZVAL(z_key);
ZVAL_STRINGL(z_key, key, key_len-1, 1);
ZVAL_ASCII_STRINGL(z_key, key, key_len-1, 1);
Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp TSRMLS_CC);
zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
@ -1883,7 +1736,41 @@ ZEND_API int add_property_rt_stringl_ex(zval *arg, char *key, uint key_len, char
ZVAL_RT_STRINGL(tmp, str, length, duplicate);
MAKE_STD_ZVAL(z_key);
ZVAL_STRINGL(z_key, key, key_len-1, 1);
ZVAL_ASCII_STRINGL(z_key, key, key_len-1, 1);
Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp TSRMLS_CC);
zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
zval_ptr_dtor(&z_key);
return SUCCESS;
}
ZEND_API int add_property_unicode_ex(zval *arg, char *key, uint key_len, UChar *str, int duplicate TSRMLS_DC)
{
zval *tmp;
zval *z_key;
MAKE_STD_ZVAL(tmp);
ZVAL_UNICODE(tmp, str, duplicate);
MAKE_STD_ZVAL(z_key);
ZVAL_ASCII_STRINGL(z_key, key, key_len-1, 1);
Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp TSRMLS_CC);
zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
zval_ptr_dtor(&z_key);
return SUCCESS;
}
ZEND_API int add_property_unicodel_ex(zval *arg, char *key, uint key_len, UChar *str, uint length, int duplicate TSRMLS_DC)
{
zval *tmp;
zval *z_key;
MAKE_STD_ZVAL(tmp);
ZVAL_UNICODEL(tmp, str, length, duplicate);
MAKE_STD_ZVAL(z_key);
ZVAL_ASCII_STRINGL(z_key, key, key_len-1, 1);
Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp TSRMLS_CC);
zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
@ -1896,7 +1783,7 @@ ZEND_API int add_property_zval_ex(zval *arg, char *key, uint key_len, zval *valu
zval *z_key;
MAKE_STD_ZVAL(z_key);
ZVAL_STRINGL(z_key, key, key_len-1, 1);
ZVAL_ASCII_STRINGL(z_key, key, key_len-1, 1);
Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, value TSRMLS_CC);
zval_ptr_dtor(&z_key);
@ -3197,7 +3084,7 @@ ZEND_API void zend_update_property(zend_class_entry *scope, zval *object, char *
zend_error(E_CORE_ERROR, "Property %s of class %v cannot be updated", name, class_name);
}
MAKE_STD_ZVAL(property);
ZVAL_STRINGL(property, name, name_length, 1);
ZVAL_ASCII_STRINGL(property, name, name_length, 1);
Z_OBJ_HT_P(object)->write_property(object, property, value TSRMLS_CC);
zval_ptr_dtor(&property);
@ -3518,7 +3405,7 @@ ZEND_API zval *zend_read_property(zend_class_entry *scope, zval *object, char *n
}
MAKE_STD_ZVAL(property);
ZVAL_STRINGL(property, name, name_length, 1);
ZVAL_ASCII_STRINGL(property, name, name_length, 1);
value = Z_OBJ_HT_P(object)->read_property(object, property, silent TSRMLS_CC);
zval_ptr_dtor(&property);
@ -3550,6 +3437,7 @@ ZEND_API zend_uchar zend_get_unified_string_type(int num_args TSRMLS_DC, ...)
va_list ap;
int best_type = UG(unicode) ? IS_UNICODE : IS_STRING;
zend_bool seen_unicode = 0;
zend_bool seen_string = 0;
int type;
if (num_args <= 0) return (zend_uchar)-1;
@ -3560,22 +3448,20 @@ ZEND_API zend_uchar zend_get_unified_string_type(int num_args TSRMLS_DC, ...)
va_start(ap, num_args);
#endif
while (num_args--) {
type = va_arg(ap, int);
if (type == IS_BINARY) {
best_type = IS_BINARY;
} else if (type == IS_UNICODE) {
type = va_arg(ap, int);
if (type == IS_UNICODE) {
seen_unicode = 1;
if (best_type == IS_STRING) {
best_type = IS_UNICODE;
}
best_type = IS_UNICODE;
} else if (type == IS_STRING) {
seen_string = 1;
best_type = IS_STRING;
}
}
va_end(ap);
/* We do not allow mixing binary and Unicode types */
if (best_type == IS_BINARY && seen_unicode) {
if (seen_string && seen_unicode) {
zend_error(E_WARNING, "Cannot mix binary and Unicode parameters");
return (zend_uchar)-1;
}

39
Zend/zend_API.h
View File

@ -426,8 +426,6 @@ ZEND_API int add_index_resource(zval *arg, ulong idx, int r);
ZEND_API int add_index_double(zval *arg, ulong idx, double d);
ZEND_API int add_index_string(zval *arg, ulong idx, char *str, int duplicate);
ZEND_API int add_index_stringl(zval *arg, ulong idx, char *str, uint length, int duplicate);
ZEND_API int add_index_binary(zval *arg, ulong idx, char *str, int duplicate TSRMLS_DC);
ZEND_API int add_index_binaryl(zval *arg, ulong idx, char *str, uint length, int duplicate TSRMLS_DC);
ZEND_API int add_index_unicode(zval *arg, ulong idx, UChar *str, int duplicate);
ZEND_API int add_index_unicodel(zval *arg, ulong idx, UChar *str, uint length, int duplicate);
ZEND_API int add_index_zval(zval *arg, ulong index, zval *value);
@ -470,8 +468,6 @@ ZEND_API int add_next_index_resource(zval *arg, int r);
ZEND_API int add_next_index_double(zval *arg, double d);
ZEND_API int add_next_index_string(zval *arg, char *str, int duplicate);
ZEND_API int add_next_index_stringl(zval *arg, char *str, uint length, int duplicate);
ZEND_API int add_next_index_binary(zval *arg, char *str, int duplicate);
ZEND_API int add_next_index_binaryl(zval *arg, char *str, uint length, int duplicate);
ZEND_API int add_next_index_unicode(zval *arg, UChar *str, int duplicate);
ZEND_API int add_next_index_unicodel(zval *arg, UChar *str, uint length, int duplicate);
ZEND_API int add_next_index_zval(zval *arg, zval *value);
@ -540,8 +536,6 @@ ZEND_API int add_get_index_long(zval *arg, ulong idx, long l, void **dest);
ZEND_API int add_get_index_double(zval *arg, ulong idx, double d, void **dest);
ZEND_API int add_get_index_string(zval *arg, ulong idx, char *str, void **dest, int duplicate);
ZEND_API int add_get_index_stringl(zval *arg, ulong idx, char *str, uint length, void **dest, int duplicate);
ZEND_API int add_get_index_binary(zval *arg, ulong idx, char *str, void **dest, int duplicate);
ZEND_API int add_get_index_binaryl(zval *arg, ulong idx, char *str, uint length, void **dest, int duplicate);
ZEND_API int add_get_index_unicode(zval *arg, ulong idx, UChar *str, void **dest, int duplicate);
ZEND_API int add_get_index_unicodel(zval *arg, ulong idx, UChar *str, uint length, void **dest, int duplicate);
@ -557,6 +551,8 @@ ZEND_API int add_property_ascii_string_ex(zval *arg, char *key, uint key_len, ch
ZEND_API int add_property_ascii_stringl_ex(zval *arg, char *key, uint key_len, char *str, uint length, int duplicate TSRMLS_DC);
ZEND_API int add_property_rt_string_ex(zval *arg, char *key, uint key_len, char *str, int duplicate TSRMLS_DC);
ZEND_API int add_property_rt_stringl_ex(zval *arg, char *key, uint key_len, char *str, uint length, int duplicate TSRMLS_DC);
ZEND_API int add_property_unicode_ex(zval *arg, char *key, uint key_len, UChar *str, int duplicate TSRMLS_DC);
ZEND_API int add_property_unicodel_ex(zval *arg, char *key, uint key_len, UChar *str, uint length, int duplicate TSRMLS_DC);
#define add_property_long(__arg, __key, __n) add_property_long_ex(__arg, __key, strlen(__key)+1, __n TSRMLS_CC)
#define add_property_null(__arg, __key) add_property_null_ex(__arg, __key, strlen(__key) + 1 TSRMLS_CC)
@ -570,6 +566,8 @@ ZEND_API int add_property_rt_stringl_ex(zval *arg, char *key, uint key_len, char
#define add_property_rt_string(__arg, __key, __str, __duplicate) add_property_ascii_string_ex(__arg, __key, strlen(__key)+1, __str, __duplicate TSRMLS_CC)
#define add_property_rt_stringl(__arg, __key, __str, __length, __duplicate) add_property_rt_stringl_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate TSRMLS_CC)
#define add_property_zval(__arg, __key, __value) add_property_zval_ex(__arg, __key, strlen(__key)+1, __value TSRMLS_CC)
#define add_property_unicode(__arg, __key, __str, __duplicate) add_property_unicode_ex(__arg, __key, strlen(__key)+1, __str, __duplicate TSRMLS_CC)
#define add_property_unicodel(__arg, __key, __str, __length, __duplicate) add_property_unicodel_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate TSRMLS_CC)
ZEND_API int call_user_function(HashTable *function_table, zval **object_pp, zval *function_name, zval *retval_ptr, zend_uint param_count, zval *params[] TSRMLS_DC);
@ -616,9 +614,6 @@ ZEND_API ZEND_FUNCTION(display_disabled_class);
END_EXTERN_C()
#define BINARY_TYPE (UG(unicode) ? IS_BINARY : IS_STRING)
#if ZEND_DEBUG
#define CHECK_ZVAL_STRING(z) \
if ((z)->value.str.val[ (z)->value.str.len ] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s)", (z)->value.str.val); }
@ -745,20 +740,6 @@ END_EXTERN_C()
(z)->type = IS_UNICODE; \
}
#define ZVAL_BINARY(z, s, duplicate) { \
char *__s=(s); \
(z)->value.str.len = strlen(__s); \
(z)->value.str.val = (duplicate?estrndup(__s, (z)->value.str.len):__s); \
(z)->type = BINARY_TYPE; \
}
#define ZVAL_BINARYL(z, s, l, duplicate) { \
char *__s=(s); int __l=l; \
(z)->value.str.len = __l; \
(z)->value.str.val = (duplicate?estrndup(__s, __l):__s); \
(z)->type = BINARY_TYPE; \
}
#define ZVAL_EMPTY_STRING(z) { \
(z)->value.str.len = 0; \
(z)->value.str.val = STR_EMPTY_ALLOC(); \
@ -771,12 +752,6 @@ END_EXTERN_C()
(z)->type = IS_UNICODE; \
}
#define ZVAL_EMPTY_BINARY(z) { \
(z)->value.str.len = 0; \
(z)->value.str.val = STR_EMPTY_ALLOC(); \
(z)->type = BINARY_TYPE; \
}
#define ZVAL_ZVAL(z, zv, copy, dtor) { \
int is_ref, refcount; \
is_ref = (z)->is_ref; \
@ -840,9 +815,6 @@ END_EXTERN_C()
#define RETVAL_UNICODE(u, duplicate) ZVAL_UNICODE(return_value, u, duplicate)
#define RETVAL_UNICODEL(u, l, duplicate) ZVAL_UNICODEL(return_value, u, l, duplicate)
#define RETVAL_EMPTY_UNICODE() ZVAL_EMPTY_UNICODE(return_value)
#define RETVAL_BINARY(s, duplicate) ZVAL_BINARY(return_value, s, duplicate)
#define RETVAL_BINARYL(s, l, duplicate) ZVAL_BINARYL(return_value, s, l, duplicate)
#define RETVAL_EMPTY_BINARY() ZVAL_EMPTY_BINARY(return_value)
#define RETVAL_ZVAL(zv, copy, dtor) ZVAL_ZVAL(return_value, zv, copy, dtor)
#define RETVAL_FALSE ZVAL_BOOL(return_value, 0)
#define RETVAL_TRUE ZVAL_BOOL(return_value, 1)
@ -860,9 +832,6 @@ END_EXTERN_C()
#define RETURN_UNICODE(u, duplicate) { RETVAL_UNICODE(u, duplicate); return; }
#define RETURN_UNICODEL(u, l, duplicate) { RETVAL_UNICODEL(u, l, duplicate); return; }
#define RETURN_EMPTY_UNICODE() { RETVAL_EMPTY_UNICODE(); return; }
#define RETURN_BINARY(s, duplicate) { RETVAL_BINARY(s, duplicate); return; }
#define RETURN_BINARYL(s, l, duplicate) { RETVAL_BINARYL(s, l, duplicate); return; }
#define RETURN_EMPTY_BINARY() { RETVAL_EMPTY_BINARY(); return; }
#define RETURN_ZVAL(zv, copy, dtor) { RETVAL_ZVAL(zv, copy, dtor); return; }
#define RETURN_FALSE { RETVAL_FALSE; return; }
#define RETURN_TRUE { RETVAL_TRUE; return; }

10
Zend/zend_builtin_functions.c
View File

@ -287,7 +287,6 @@ ZEND_NAMED_FUNCTION(zend_if_strlen)
break;
case IS_STRING:
case IS_BINARY:
RETVAL_LONG(Z_STRLEN_PP(str));
break;
@ -431,9 +430,6 @@ ZEND_FUNCTION(each)
case HASH_KEY_IS_STRING:
add_get_index_stringl(return_value, 0, string_key, string_key_len-1, (void **) &inserted_pointer, 0);
break;
case HASH_KEY_IS_BINARY:
add_get_index_binaryl(return_value, 0, string_key, string_key_len-1, (void **) &inserted_pointer, 0);
break;
case HASH_KEY_IS_UNICODE:
add_get_index_unicodel(return_value, 0, (UChar*)string_key, string_key_len-1, (void **) &inserted_pointer, 0);
break;
@ -511,7 +507,6 @@ ZEND_FUNCTION(define)
case IS_LONG:
case IS_DOUBLE:
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
case IS_BOOL:
case IS_RESOURCE:
@ -1398,7 +1393,6 @@ static int copy_function_name(zend_function *func, int num_args, va_list args, z
*user_ar = va_arg(args, zval *);
if (hash_key->nKeyLength == 0 ||
hash_key->type == IS_BINARY ||
(hash_key->type == IS_UNICODE && hash_key->u.unicode[0] == 0) ||
(hash_key->type == IS_STRING && hash_key->u.unicode[0] == 0)) {
return 0;
@ -1407,16 +1401,12 @@ static int copy_function_name(zend_function *func, int num_args, va_list args, z
if (func->type == ZEND_INTERNAL_FUNCTION) {
if (hash_key->type == IS_STRING) {
add_next_index_stringl(internal_ar, hash_key->u.string, hash_key->nKeyLength-1, 1);
} else if (hash_key->type == IS_BINARY) {
add_next_index_binaryl(internal_ar, hash_key->u.string, hash_key->nKeyLength-1, 1);
} else {
add_next_index_unicodel(internal_ar, hash_key->u.unicode, hash_key->nKeyLength-1, 1);
}
} else if (func->type == ZEND_USER_FUNCTION) {
if (hash_key->type == IS_STRING) {
add_next_index_stringl(user_ar, hash_key->u.string, hash_key->nKeyLength-1, 1);
} else if (hash_key->type == IS_BINARY) {
add_next_index_binaryl(user_ar, hash_key->u.string, hash_key->nKeyLength-1, 1);
} else {
add_next_index_unicodel(user_ar, hash_key->u.unicode, hash_key->nKeyLength-1, 1);
}

1
Zend/zend_compile.c
View File

@ -3378,7 +3378,6 @@ void zend_do_add_static_array_element(znode *result, znode *offset, znode *expr)
/* break missing intentionally */
utype = UG(unicode)?IS_UNICODE:IS_STRING;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(result->u.constant.value.ht, utype, Z_UNIVAL(offset->u.constant), Z_UNILEN(offset->u.constant)+1, &element, sizeof(zval *), NULL);
zval_dtor(&offset->u.constant);

37
Zend/zend_exceptions.c
View File

@ -307,13 +307,23 @@ ZEND_METHOD(error_exception, getSeverity)
*len += l; \
}
#define TRACE_APPEND_USTRL(val, vallen) \
{ \
zval tmp, copy; \
int use_copy; \
ZVAL_UNICODEL(&tmp, val, vallen, 0); \
zend_make_printable_zval(&tmp, &copy, &use_copy); \
TRACE_APPEND_STRL(Z_STRVAL(copy), Z_STRLEN(copy)); \
zval_dtor(&copy); \
}
#define TRACE_APPEND_ZVAL(zv) \
if (Z_TYPE_P((zv)) == IS_UNICODE) { \
zval copy; \
int use_copy; \
zend_make_printable_zval((zv), &copy, &use_copy); \
TRACE_APPEND_STRL(Z_STRVAL(copy), Z_STRLEN(copy)); \
zval_dtor(&copy); \
TRACE_APPEND_STRL(Z_STRVAL(copy), Z_STRLEN(copy)); \
zval_dtor(&copy); \
} else { \
TRACE_APPEND_STRL(Z_STRVAL_P((zv)), Z_STRLEN_P((zv))); \
}
@ -372,6 +382,26 @@ static int _build_trace_args(zval **arg, int num_args, va_list args, zend_hash_k
}
break;
}
case IS_UNICODE: {
int l_added;
TRACE_APPEND_CHR('\'');
if (Z_USTRLEN_PP(arg) > 15) {
TRACE_APPEND_USTRL(Z_USTRVAL_PP(arg), 15);
TRACE_APPEND_STR("...', ");
l_added = 15 + 6 + 1; /* +1 because of while (--l_added) */
} else {
l_added = Z_USTRLEN_PP(arg);
TRACE_APPEND_USTRL(Z_USTRVAL_PP(arg), l_added);
TRACE_APPEND_STR("', ");
l_added += 3 + 1;
}
while (--l_added) {
if ((*str)[*len - l_added] < 32) {
(*str)[*len - l_added] = '?';
}
}
break;
}
case IS_BOOL:
if (Z_LVAL_PP(arg)) {
TRACE_APPEND_STR("true, ");
@ -535,7 +565,7 @@ ZEND_METHOD(exception, __toString)
convert_to_long(&line);
ZVAL_STRINGL(&fname, "gettraceasstring", sizeof("gettraceasstring")-1, 0);
ZVAL_ASCII_STRINGL(&fname, "gettraceasstring", sizeof("gettraceasstring")-1, 1);
fci.size = sizeof(fci);
fci.function_table = &Z_OBJCE_P(getThis())->function_table;
@ -548,6 +578,7 @@ ZEND_METHOD(exception, __toString)
fci.no_separation = 1;
zend_call_function(&fci, NULL TSRMLS_CC);
zval_dtor(&fname);
if (Z_TYPE_P(trace) != IS_STRING && Z_TYPE_P(trace) != IS_UNICODE) {
trace = NULL;

15
Zend/zend_execute.c
View File

@ -178,7 +178,7 @@ static inline zval *_get_zval_ptr_var(znode *node, temp_variable *Ts, zend_free_
should_free->var = ptr;
/* T->str_offset.str here is always IS_STRING or IS_UNICODE */
if (T->str_offset.str->type == IS_STRING || T->str_offset.str->type == IS_BINARY) {
if (T->str_offset.str->type == IS_STRING) {
if (((int)T->str_offset.offset<0)
|| (T->str_offset.str->value.str.len <= T->str_offset.offset)) {
zend_error(E_NOTICE, "Uninitialized string offset: %d", T->str_offset.offset);
@ -458,7 +458,7 @@ static inline void make_real_object(zval **object_ptr TSRMLS_DC)
/* this should modify object only if it's empty */
if ((*object_ptr)->type == IS_NULL
|| ((*object_ptr)->type == IS_BOOL && (*object_ptr)->value.lval==0)
|| (((*object_ptr)->type == IS_STRING || (*object_ptr)->type == IS_BINARY) && (*object_ptr)->value.str.len == 0)
|| ((*object_ptr)->type == IS_STRING && (*object_ptr)->value.str.len == 0)
|| ((*object_ptr)->type == IS_UNICODE && (*object_ptr)->value.ustr.len == 0)) {
if (!PZVAL_IS_REF(*object_ptr)) {
SEPARATE_ZVAL(object_ptr);
@ -668,8 +668,7 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
convert_to_unicode(T->str_offset.str);
}
if (Z_TYPE_P(T->str_offset.str) == IS_STRING ||
Z_TYPE_P(T->str_offset.str) == IS_BINARY)
if (Z_TYPE_P(T->str_offset.str) == IS_STRING)
do {
zval tmp;
zval *final_value = value;
@ -694,7 +693,7 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
T->str_offset.str->value.str.len = T->str_offset.offset+1;
}
if (value->type!=IS_STRING && value->type!=IS_BINARY) {
if (value->type!=IS_STRING) {
tmp = *value;
if (op2->op_type & (IS_VAR|IS_CV|IS_CONST)) {
zval_copy_ctor(&tmp);
@ -1031,7 +1030,6 @@ static inline zval **zend_fetch_dimension_address_inner(HashTable *ht, zval *dim
offset_key_length = 1;
goto fetch_string_dim;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
offset_key = Z_UNIVAL_P(dim);
@ -1152,7 +1150,7 @@ static void zend_fetch_dimension_address(temp_variable *result, zval **container
if (container->type==IS_NULL
|| (container->type==IS_BOOL && container->value.lval==0)
|| ((container->type==IS_STRING || container->type==IS_BINARY) && container->value.str.len==0)
|| (container->type==IS_STRING && container->value.str.len==0)
|| (container->type==IS_UNICODE && container->value.ustr.len==0)) {
switch (type) {
case BP_VAR_RW:
@ -1204,7 +1202,6 @@ static void zend_fetch_dimension_address(temp_variable *result, zval **container
break;
}
case IS_UNICODE:
case IS_BINARY:
case IS_STRING: {
zval tmp;
@ -1327,7 +1324,7 @@ static void zend_fetch_property_address(temp_variable *result, zval **container_
/* this should modify object only if it's empty */
if (container->type == IS_NULL
|| (container->type == IS_BOOL && container->value.lval==0)
|| ((container->type==IS_STRING || container->type==IS_BINARY) && container->value.str.len==0)
|| (container->type==IS_STRING && container->value.str.len==0)
|| (container->type==IS_UNICODE && container->value.ustr.len==0)) {
switch (type) {
case BP_VAR_RW:

1
Zend/zend_execute.h
View File

@ -89,7 +89,6 @@ static inline int i_zend_is_true(zval *op)
result = (op->value.dval ? 1 : 0);
break;
case IS_STRING:
case IS_BINARY:
if (op->value.str.len == 0
|| (op->value.str.len==1 && op->value.str.val[0]=='0')) {
result = 0;

9
Zend/zend_execute_API.c
View File

@ -528,9 +528,6 @@ ZEND_API int zval_update_constant(zval **pp, void *arg TSRMLS_DC)
case IS_UNICODE:
zend_u_symtable_update_current_key(p->value.ht, Z_TYPE(const_value), Z_UNIVAL(const_value), Z_UNILEN(const_value)+1);
break;
case IS_BINARY:
zend_hash_update_current_key(p->value.ht, HASH_KEY_IS_BINARY, Z_STRVAL(const_value), Z_STRLEN(const_value)+1, 0);
break;
case IS_BOOL:
case IS_LONG:
zend_hash_update_current_key(p->value.ht, HASH_KEY_IS_LONG, NULL, 0, const_value.value.lval);
@ -1054,7 +1051,7 @@ ZEND_API int zend_u_lookup_class_ex(zend_uchar type, void *name, int name_length
return FAILURE;
}
ZVAL_STRINGL(&autoload_function, ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME)-1, 0);
ZVAL_ASCII_STRINGL(&autoload_function, ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME)-1, 0);
ALLOC_ZVAL(class_name_ptr);
INIT_PZVAL(class_name_ptr);
@ -1086,6 +1083,10 @@ ZEND_API int zend_u_lookup_class_ex(zend_uchar type, void *name, int name_length
retval = zend_call_function(&fcall_info, &fcall_cache TSRMLS_CC);
EG(autoload_func) = fcall_cache.function_handler;
if (UG(unicode)) {
zval_dtor(&autoload_function);
}
zval_ptr_dtor(&class_name_ptr);
zend_u_hash_del(EG(in_autoload), type, lc_name, lc_name_len+1);

20
Zend/zend_hash.c
View File

@ -1216,7 +1216,7 @@ ZEND_API int zend_hash_get_current_key_ex(HashTable *ht, char **str_index, uint
if (p) {
if (p->nKeyLength) {
if (p->key.type == IS_STRING || p->key.type == IS_BINARY) {
if (p->key.type == IS_STRING) {
if (duplicate) {
*str_index = estrndup(p->key.u.string, p->nKeyLength-1);
} else {
@ -1225,11 +1225,7 @@ ZEND_API int zend_hash_get_current_key_ex(HashTable *ht, char **str_index, uint
if (str_length) {
*str_length = p->nKeyLength;
}
if (p->key.type == IS_BINARY) {
return HASH_KEY_IS_BINARY;
} else {
return HASH_KEY_IS_STRING;
}
return HASH_KEY_IS_STRING;
} else if (p->key.type == IS_UNICODE) {
if (duplicate) {
*str_index = (char*)eustrndup(p->key.u.unicode, p->nKeyLength-1);
@ -1262,8 +1258,6 @@ ZEND_API int zend_hash_get_current_key_type_ex(HashTable *ht, HashPosition *pos)
if (p->nKeyLength) {
if (p->key.type == IS_UNICODE) {
return HASH_KEY_IS_UNICODE;
} else if (p->key.type == IS_BINARY) {
return HASH_KEY_IS_BINARY;
} else {
return HASH_KEY_IS_STRING;
}
@ -1310,14 +1304,14 @@ ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, char *
return SUCCESS;
}
zend_hash_index_del(ht, num_index);
} else if (key_type == HASH_KEY_IS_STRING || key_type == HASH_KEY_IS_BINARY) {
} else if (key_type == HASH_KEY_IS_STRING) {
real_length = str_length;
if (p->nKeyLength == str_length &&
p->key.type == ((key_type == HASH_KEY_IS_STRING)?IS_STRING:IS_BINARY) &&
p->key.type == IS_STRING &&
memcmp(p->key.u.string, str_index, str_length) == 0) {
return SUCCESS;
}
zend_u_hash_del(ht, (key_type == HASH_KEY_IS_STRING)?IS_STRING:IS_BINARY, str_index, str_length);
zend_u_hash_del(ht, IS_STRING, str_index, str_length);
} else if (key_type == HASH_KEY_IS_UNICODE) {
real_length = str_length * sizeof(UChar);
if (p->nKeyLength == str_length &&
@ -1381,7 +1375,7 @@ ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, char *
p->h = zend_u_inline_hash_func(IS_UNICODE, str_index, str_length);
} else {
memcpy(p->key.u.string, str_index, real_length);
p->key.type = (key_type == HASH_KEY_IS_STRING)?IS_STRING:IS_BINARY;
p->key.type = IS_STRING;
p->h = zend_u_inline_hash_func(p->key.type, str_index, str_length);
}
@ -1705,8 +1699,6 @@ ZEND_API int zend_u_symtable_update_current_key(HashTable *ht, zend_uchar type,
} else if (type == IS_UNICODE) {
key_type = HASH_KEY_IS_UNICODE;
HANDLE_U_NUMERIC((UChar*)arKey, nKeyLength, zend_hash_update_current_key(ht, HASH_KEY_IS_LONG, NULL, 0, idx));
} else {
key_type = HASH_KEY_IS_BINARY;
}
return zend_hash_update_current_key(ht, key_type, arKey, nKeyLength, 0);
}

9
Zend/zend_hash.h
View File

@ -25,11 +25,10 @@
#include <sys/types.h>
#include "zend.h"
#define HASH_KEY_IS_STRING 1
#define HASH_KEY_IS_LONG 2
#define HASH_KEY_NON_EXISTANT 3
#define HASH_KEY_IS_BINARY 4
#define HASH_KEY_IS_UNICODE 5
#define HASH_KEY_NON_EXISTANT IS_NULL
#define HASH_KEY_IS_LONG IS_LONG
#define HASH_KEY_IS_STRING IS_STRING
#define HASH_KEY_IS_UNICODE IS_UNICODE
#define HASH_UPDATE (1<<0)
#define HASH_ADD (1<<1)

2
Zend/zend_highlight.c
View File

@ -143,7 +143,6 @@ ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini
}
if (token.type == IS_STRING ||
token.type == IS_BINARY ||
token.type == IS_UNICODE) {
switch (token_type) {
case T_OPEN_TAG:
@ -213,7 +212,6 @@ ZEND_API void zend_strip(TSRMLS_D)
}
if (token.type == IS_STRING ||
token.type == IS_BINARY ||
token.type == IS_UNICODE) {
switch (token_type) {
case T_OPEN_TAG:

9
Zend/zend_interfaces.c
View File

@ -57,9 +57,10 @@ ZEND_API zval* zend_call_method(zval **object_pp, zend_class_entry *obj_ce, zend
if (!fn_proxy && !obj_ce) {
/* no interest in caching and no information already present that is
* needed later inside zend_call_function. */
ZVAL_STRINGL(&z_fname, function_name, function_name_len, 0);
ZVAL_ASCII_STRINGL(&z_fname, function_name, function_name_len, 1);
fci.function_table = !object_pp ? EG(function_table) : NULL;
result = zend_call_function(&fci, NULL TSRMLS_CC);
zval_dtor(&z_fname);
} else {
zend_fcall_info_cache fcic;
@ -214,12 +215,6 @@ static int zend_user_it_get_current_key(zend_object_iterator *_iter, char **str_
zval_ptr_dtor(&retval);
return HASH_KEY_IS_STRING;
case IS_BINARY:
*str_key = estrndup(Z_STRVAL_P(retval), Z_STRLEN_P(retval));
*str_key_len = retval->value.str.len+1;
zval_ptr_dtor(&retval);
return HASH_KEY_IS_BINARY;
case IS_UNICODE:
*str_key = (char*)eustrndup(Z_USTRVAL_P(retval), Z_USTRLEN_P(retval));
*str_key_len = retval->value.str.len+1;

9
Zend/zend_language_parser.y
View File

@ -71,7 +71,7 @@
%left '*' '/' '%'
%right '!'
%nonassoc T_INSTANCEOF
%right '~' T_INC T_DEC T_INT_CAST T_DOUBLE_CAST T_STRING_CAST T_UNICODE_CAST T_BINARY_CAST T_ARRAY_CAST T_OBJECT_CAST T_BOOL_CAST T_UNSET_CAST '@'
%right '~' T_INC T_DEC T_INT_CAST T_DOUBLE_CAST T_STRING_CAST T_UNICODE_CAST T_ARRAY_CAST T_OBJECT_CAST T_BOOL_CAST T_UNSET_CAST '@'
%right '['
%nonassoc T_NEW T_CLONE
%token T_EXIT
@ -611,9 +611,8 @@ expr_without_variable:
| internal_functions_in_yacc { $$ = $1; }
| T_INT_CAST expr { zend_do_cast(&$$, &$2, IS_LONG TSRMLS_CC); }
| T_DOUBLE_CAST expr { zend_do_cast(&$$, &$2, IS_DOUBLE TSRMLS_CC); }
| T_STRING_CAST expr { zend_do_cast(&$$, &$2, IS_STRING TSRMLS_CC); }
| T_STRING_CAST expr { zend_do_cast(&$$, &$2, UG(unicode)?IS_UNICODE:IS_STRING TSRMLS_CC); }
| T_UNICODE_CAST expr { zend_do_cast(&$$, &$2, IS_UNICODE TSRMLS_CC); }
| T_BINARY_CAST expr { zend_do_cast(&$$, &$2, UG(unicode)?IS_BINARY:IS_STRING TSRMLS_CC); }
| T_ARRAY_CAST expr { zend_do_cast(&$$, &$2, IS_ARRAY TSRMLS_CC); }
| T_OBJECT_CAST expr { zend_do_cast(&$$, &$2, IS_OBJECT TSRMLS_CC); }
| T_BOOL_CAST expr { zend_do_cast(&$$, &$2, IS_BOOL TSRMLS_CC); }
@ -714,8 +713,8 @@ scalar:
| common_scalar { $$ = $1; }
| '"' { CG(literal_type) = UG(unicode)?IS_UNICODE:IS_STRING; } encaps_list '"' { $$ = $3; }
| T_START_HEREDOC { CG(literal_type) = UG(unicode)?IS_UNICODE:IS_STRING; } encaps_list T_END_HEREDOC { $$ = $3; zend_do_end_heredoc(TSRMLS_C); }
| T_BINARY_DOUBLE { CG(literal_type) = UG(unicode)?IS_BINARY:IS_STRING; } encaps_list '"' { $$ = $3; }
| T_BINARY_HEREDOC { CG(literal_type) = UG(unicode)?IS_BINARY:IS_STRING; } encaps_list T_END_HEREDOC { $$ = $3; zend_do_end_heredoc(TSRMLS_C); }
| T_BINARY_DOUBLE { CG(literal_type) = IS_STRING; } encaps_list '"' { $$ = $3; }
| T_BINARY_HEREDOC { CG(literal_type) = IS_STRING; } encaps_list T_END_HEREDOC { $$ = $3; zend_do_end_heredoc(TSRMLS_C); }
;

20
Zend/zend_language_scanner.l
View File

@ -1270,7 +1270,7 @@ int zend_scan_binary_double_string(zval *zendlval TSRMLS_DC)
zendlval->value.str.val = estrndup(yytext+1, yyleng-2);
zendlval->value.str.len = yyleng-2;
zendlval->type = UG(unicode) ? IS_BINARY : IS_STRING;
zendlval->type = IS_STRING;
HANDLE_NEWLINES(yytext, yyleng);
/* convert escape sequences */
@ -1352,7 +1352,7 @@ int zend_scan_binary_single_string(zval *zendlval TSRMLS_DC)
zendlval->value.str.val = estrndup(yytext+1, yyleng-2);
zendlval->value.str.len = yyleng-2;
zendlval->type = UG(unicode) ? IS_BINARY : IS_STRING;
zendlval->type = IS_STRING;
HANDLE_NEWLINES(yytext, yyleng);
/* convert escape sequences */
@ -1597,10 +1597,6 @@ NEWLINE ("\r"|"\n"|"\r\n")
return T_UNICODE_CAST;
}
<ST_IN_SCRIPTING>"("{TABS_AND_SPACES}"binary"{TABS_AND_SPACES}")" {
return T_BINARY_CAST;
}
<ST_IN_SCRIPTING>"("{TABS_AND_SPACES}"array"{TABS_AND_SPACES}")" {
return T_ARRAY_CAST;
}
@ -1988,16 +1984,14 @@ NEWLINE ("\r"|"\n"|"\r\n")
if (!filename) {
filename = "";
}
zendlval->value.str.len = strlen(filename);
zendlval->value.str.val = estrndup(filename, zendlval->value.str.len);
zendlval->type = IS_STRING;
ZVAL_RT_STRING(zendlval, filename, 1);
return T_FILE;
}
<INITIAL>(([^<]|"<"[^?%s<]){1,400})|"<s"|"<" {
zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_BINARY;
zendlval->type = IS_STRING;
HANDLE_NEWLINES(yytext, yyleng);
return T_INLINE_HTML;
}
@ -2013,7 +2007,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
} else {
zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_BINARY;
zendlval->type = IS_STRING;
return T_INLINE_HTML;
}
}
@ -2029,7 +2023,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
} else {
zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_BINARY;
zendlval->type = IS_STRING;
return T_INLINE_HTML;
}
}
@ -2045,7 +2039,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
} else {
zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_BINARY;
zendlval->type = IS_STRING;
return T_INLINE_HTML;
}
}

86
Zend/zend_operators.c
View File

@ -114,7 +114,6 @@ ZEND_API void convert_scalar_to_number(zval *op TSRMLS_DC)
{
switch (op->type) {
case IS_STRING:
case IS_BINARY:
{
char *strval;
@ -174,7 +173,6 @@ ZEND_API void convert_scalar_to_number(zval *op TSRMLS_DC)
} else { \
switch ((op)->type) { \
case IS_STRING: \
case IS_BINARY: \
{ \
switch (((holder).type=is_numeric_string((op)->value.str.val, (op)->value.str.len, &(holder).value.lval, &(holder).value.dval, 1))) { \
case IS_DOUBLE: \
@ -239,7 +237,6 @@ ZEND_API void convert_scalar_to_number(zval *op TSRMLS_DC)
DVAL_TO_LVAL((op)->value.dval, (holder).value.lval); \
break; \
case IS_STRING: \
case IS_BINARY: \
(holder).value.lval = strtol((op)->value.str.val, NULL, 10); \
break; \
case IS_UNICODE: \
@ -283,7 +280,6 @@ ZEND_API void convert_scalar_to_number(zval *op TSRMLS_DC)
(holder).value.lval = ((op)->value.dval ? 1 : 0); \
break; \
case IS_STRING: \
case IS_BINARY: \
if ((op)->value.str.len == 0 \
|| ((op)->value.str.len==1 && (op)->value.str.val[0]=='0')) { \
(holder).value.lval = 0; \
@ -369,7 +365,6 @@ ZEND_API void convert_to_long_base(zval *op, int base)
DVAL_TO_LVAL(op->value.dval, op->value.lval);
break;
case IS_STRING:
case IS_BINARY:
{
char *strval = op->value.str.val;
op->value.lval = strtol(strval, NULL, base);
@ -443,7 +438,6 @@ ZEND_API void convert_to_double(zval *op)
case IS_DOUBLE:
break;
case IS_STRING:
case IS_BINARY:
{
char *strval = op->value.str.val;
@ -543,7 +537,6 @@ ZEND_API void convert_to_boolean(zval *op)
op->value.lval = (op->value.dval ? 1 : 0);
break;
case IS_STRING:
case IS_BINARY:
{
char *strval = op->value.str.val;
@ -615,9 +608,6 @@ ZEND_API void _convert_to_unicode(zval *op TSRMLS_DC ZEND_FILE_LINE_DC)
case IS_UNICODE:
break;
case IS_STRING:
zval_string_to_unicode(op TSRMLS_CC);
break;
case IS_BINARY:
zend_error(E_ERROR, "Cannot convert binary type to Unicode type");
return;
case IS_BOOL:
@ -703,23 +693,6 @@ ZEND_API void _convert_to_string_with_converter(zval *op, UConverter *conv TSRML
op->value.str.len = 0;
break;
case IS_STRING:
if (conv == ZEND_U_CONVERTER(UG(runtime_encoding_conv))) {
break;
} else {
char *s;
int32_t s_len;
UErrorCode status = U_ZERO_ERROR;
s = op->value.str.val;
s_len = op->value.str.len;
zend_convert_encodings(conv, ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &op->value.str.val, &op->value.str.len, s, s_len, &status);
efree(s);
if (U_FAILURE(status)) {
zend_error(E_WARNING, "Error converting string for printing");
}
}
break;
case IS_BINARY:
zend_error(E_ERROR, "Cannot convert binary type to string type");
return;
case IS_UNICODE:
zval_unicode_to_string(op, conv TSRMLS_CC);
@ -785,38 +758,6 @@ ZEND_API void _convert_to_string_with_converter(zval *op, UConverter *conv TSRML
op->type = IS_STRING;
}
ZEND_API void _convert_to_binary(zval *op TSRMLS_DC ZEND_FILE_LINE_DC)
{
if (!UG(unicode)) {
convert_to_string(op);
return;
}
switch (op->type) {
case IS_BINARY:
break;
case IS_OBJECT: {
TSRMLS_FETCH();
convert_object_to_type(op, IS_BINARY, convert_to_binary);
if (op->type == IS_BINARY) {
return;
}
zend_error(E_NOTICE, "Object of class %v to binary conversion", Z_OBJCE_P(op)->name);
zval_dtor(op);
op->value.str.val = estrndup("Object", sizeof("Object")-1);
op->value.str.len = sizeof("Object")-1;
break;
}
default:
convert_to_string(op);
break;
}
op->type = IS_BINARY;
}
static void convert_scalar_to_array(zval *op, int type TSRMLS_DC)
{
@ -1192,7 +1133,7 @@ ZEND_API int bitwise_not_function(zval *result, zval *op1 TSRMLS_DC)
result->type = IS_LONG;
return SUCCESS;
}
if (op1->type == IS_STRING || op1->type == IS_BINARY) {
if (op1->type == IS_STRING) {
int i;
result->type = op1->type;
@ -1212,8 +1153,7 @@ ZEND_API int bitwise_or_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
{
zval op1_copy, op2_copy;
if ((op1->type == IS_STRING && op2->type == IS_STRING) ||
(op1->type == IS_BINARY && op2->type == IS_BINARY)) {
if (op1->type == IS_STRING && op2->type == IS_STRING) {
zval *longer, *shorter;
char *result_str;
int i, result_len;
@ -1256,8 +1196,7 @@ ZEND_API int bitwise_and_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
{
zval op1_copy, op2_copy;
if ((op1->type == IS_STRING && op2->type == IS_STRING) ||
(op1->type == IS_BINARY && op2->type == IS_BINARY)) {
if (op1->type == IS_STRING && op2->type == IS_STRING) {
zval *longer, *shorter;
char *result_str;
int i, result_len;
@ -1302,8 +1241,7 @@ ZEND_API int bitwise_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
{
zval op1_copy, op2_copy;
if ((op1->type == IS_STRING && op2->type == IS_STRING) ||
(op1->type == IS_BINARY && op2->type == IS_BINARY)) {
if (op1->type == IS_STRING && op2->type == IS_STRING) {
zval *longer, *shorter;
char *result_str;
int i, result_len;
@ -1443,10 +1381,6 @@ ZEND_API int concat_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
zend_make_unicode_zval(op1, &op1_copy, &use_copy1);
zend_make_unicode_zval(op2, &op2_copy, &use_copy2);
result_type = IS_UNICODE;
} else if (op1->type == IS_BINARY && op2->type == IS_BINARY) {
result_type = IS_BINARY;
/* no conversion necessary */
use_copy1 = use_copy2 = 0;
} else {
result_type = IS_STRING;
zend_make_string_zval(op1, &op1_copy, &use_copy1);
@ -1622,8 +1556,8 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
}
}
if ((op1->type == IS_UNICODE || op1->type == IS_STRING || op1->type == IS_BINARY) &&
(op2->type == IS_UNICODE || op2->type == IS_STRING || op2->type == IS_BINARY)) {
if ((op1->type == IS_UNICODE || op1->type == IS_STRING) &&
(op2->type == IS_UNICODE || op2->type == IS_STRING)) {
if (op1->type == IS_UNICODE || op2->type == IS_UNICODE) {
zendi_u_smart_strcmp(result, op1, op2);
@ -1739,7 +1673,6 @@ ZEND_API int is_identical_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
result->value.lval = (op1->value.dval == op2->value.dval);
break;
case IS_STRING:
case IS_BINARY:
if ((op1->value.str.len == op2->value.str.len)
&& (!memcmp(op1->value.str.val, op2->value.str.val, op1->value.str.len))) {
result->value.lval = 1;
@ -2009,7 +1942,6 @@ ZEND_API int increment_function(zval *op1)
op1->value.lval = 1;
op1->type = IS_LONG;
break;
case IS_BINARY:
case IS_STRING: {
long lval;
double dval;
@ -2066,7 +1998,6 @@ ZEND_API int decrement_function(zval *op1)
case IS_DOUBLE:
op1->value.dval = op1->value.dval - 1;
break;
case IS_BINARY:
case IS_STRING: /* Like perl we only support string increment */
if (op1->value.str.len == 0) { /* consider as 0 */
STR_FREE(op1->value.str.val);
@ -2358,11 +2289,6 @@ ZEND_API void zendi_smart_strcmp(zval *result, zval *s1, zval *s2)
long lval1, lval2;
double dval1, dval2;
if (s1->type == IS_BINARY || s2->type == IS_BINARY) {
zend_error(E_ERROR, "Cannot convert binary type to string type");
return;
}
if ((ret1=is_numeric_string(s1->value.str.val, s1->value.str.len, &lval1, &dval1, 0)) &&
(ret2=is_numeric_string(s2->value.str.val, s2->value.str.len, &lval2, &dval2, 0))) {
if ((ret1==IS_DOUBLE) || (ret2==IS_DOUBLE)) {

12
Zend/zend_operators.h
View File

@ -243,7 +243,6 @@ ZEND_API void _convert_to_string(zval *op ZEND_FILE_LINE_DC);
ZEND_API void _convert_to_string_with_converter(zval *op, UConverter *conv TSRMLS_DC ZEND_FILE_LINE_DC);
ZEND_API void _convert_to_unicode(zval *op TSRMLS_DC ZEND_FILE_LINE_DC);
ZEND_API void _convert_to_unicode_with_converter(zval *op, UConverter *conv TSRMLS_DC ZEND_FILE_LINE_DC);
ZEND_API void _convert_to_binary(zval *op TSRMLS_DC ZEND_FILE_LINE_DC);
ZEND_API void convert_to_long(zval *op);
ZEND_API void convert_to_double(zval *op);
ZEND_API void convert_to_long_base(zval *op, int base);
@ -260,7 +259,6 @@ ZEND_API int add_string_to_string(zval *result, zval *op1, zval *op2);
#define convert_to_string_with_converter(op, conv) _convert_to_string_with_converter((op), (conv) TSRMLS_CC ZEND_FILE_LINE_CC)
#define convert_to_unicode(op) _convert_to_unicode((op) TSRMLS_CC ZEND_FILE_LINE_CC)
#define convert_to_unicode_with_converter(op, conv) _convert_to_unicode_with_converter((op), (conv) TSRMLS_CC ZEND_FILE_LINE_CC)
#define convert_to_binary(op) _convert_to_binary((op) TSRMLS_CC ZEND_FILE_LINE_CC)
#define convert_to_text(op) (UG(unicode)?convert_to_unicode(op):convert_to_string(op))
ZEND_API double zend_string_to_double(const char *number, zend_uint length);
@ -343,9 +341,6 @@ END_EXTERN_C()
case IS_UNICODE: \
convert_to_unicode(pzv); \
break; \
case IS_BINARY: \
convert_to_binary(pzv); \
break; \
default: \
assert(0); \
break; \
@ -363,7 +358,6 @@ END_EXTERN_C()
#define convert_to_double_ex(ppzv) convert_to_ex_master(ppzv, double, DOUBLE)
#define convert_to_string_ex(ppzv) convert_to_ex_master(ppzv, string, STRING)
#define convert_to_unicode_ex(ppzv) convert_to_ex_master(ppzv, unicode, UNICODE)
#define convert_to_binary_ex(ppzv) convert_to_ex_master(ppzv, binary, BINARY)
#define convert_to_array_ex(ppzv) convert_to_ex_master(ppzv, array, ARRAY)
#define convert_to_object_ex(ppzv) convert_to_ex_master(ppzv, object, OBJECT)
#define convert_to_null_ex(ppzv) convert_to_ex_master(ppzv, null, NULL)
@ -386,8 +380,6 @@ END_EXTERN_C()
#define Z_USTRVAL(zval) (zval).value.ustr.val
#define Z_USTRLEN(zval) (zval).value.ustr.len
#define Z_USTRCPLEN(zval) (u_countChar32((zval).value.ustr.val, (zval).value.ustr.len))
#define Z_BINVAL(zval) Z_STRVAL(zval)
#define Z_BINLEN(zval) Z_STRLEN(zval)
#define Z_ARRVAL(zval) (zval).value.ht
#define Z_OBJVAL(zval) (zval).value.obj
#define Z_OBJ_HANDLE(zval) (zval).value.obj.handle
@ -407,8 +399,6 @@ END_EXTERN_C()
#define Z_USTRVAL_P(zval_p) Z_USTRVAL(*zval_p)
#define Z_USTRLEN_P(zval_p) Z_USTRLEN(*zval_p)
#define Z_USTRCPLEN_P(zval_p) Z_USTRCPLEN(*zval_p)
#define Z_BINVAL_P(zval) Z_STRVAL_P(zval)
#define Z_BINLEN_P(zval) Z_STRLEN_P(zval)
#define Z_ARRVAL_P(zval_p) Z_ARRVAL(*zval_p)
#define Z_OBJPROP_P(zval_p) Z_OBJPROP(*zval_p)
#define Z_OBJCE_P(zval_p) Z_OBJCE(*zval_p)
@ -428,8 +418,6 @@ END_EXTERN_C()
#define Z_USTRVAL_PP(zval_pp) Z_USTRVAL(**zval_pp)
#define Z_USTRLEN_PP(zval_pp) Z_USTRLEN(**zval_pp)
#define Z_USTRCPLEN_PP(zval_pp) Z_USTRCPLEN(**zval_pp)
#define Z_BINVAL_PP(zval) Z_STRVAL_PP(zval)
#define Z_BINLEN_PP(zval) Z_STRLEN_PP(zval)
#define Z_ARRVAL_PP(zval_pp) Z_ARRVAL(**zval_pp)
#define Z_OBJPROP_PP(zval_pp) Z_OBJPROP(**zval_pp)
#define Z_OBJCE_PP(zval_pp) Z_OBJCE(**zval_pp)

13
Zend/zend_unicode.c
View File

@ -410,8 +410,8 @@ ZEND_API int zval_unicode_to_string(zval *string, UConverter *conv TSRMLS_DC)
}
/* }}} */
/* {{{ zval_string_to_unicode */
ZEND_API int zval_string_to_unicode(zval *string TSRMLS_DC)
/* {{{ zval_string_to_unicode_ex */
ZEND_API int zval_string_to_unicode_ex(zval *string, UConverter *conv)
{
UErrorCode status = U_ZERO_ERROR;
int retval = TRUE;
@ -422,7 +422,7 @@ ZEND_API int zval_string_to_unicode(zval *string TSRMLS_DC)
int s_len = Z_STRLEN_P(string);
Z_TYPE_P(string) = IS_UNICODE;
zend_convert_to_unicode(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &u, &u_len, s, s_len, &status);
zend_convert_to_unicode(conv, &u, &u_len, s, s_len, &status);
ZVAL_UNICODEL(string, u, u_len, 0);
if (U_FAILURE(status)) {
@ -434,6 +434,13 @@ ZEND_API int zval_string_to_unicode(zval *string TSRMLS_DC)
}
/* }}} */
/* {{{ zval_string_to_unicode */
ZEND_API int zval_string_to_unicode(zval *string TSRMLS_DC)
{
return zval_string_to_unicode(string, ZEND_U_CONVERTER(UG(runtime_encoding_conv)));
}
/* }}} */
/* {{{ zend_cmp_unicode_and_string */
ZEND_API int zend_cmp_unicode_and_string(UChar *ustr, char* str, uint len)
{

1
Zend/zend_unicode.h
View File

@ -45,6 +45,7 @@ void zend_set_converter_error_mode(UConverter *conv, uint8_t error_mode);
ZEND_API void zend_convert_to_unicode(UConverter *conv, UChar **target, int32_t *target_len, const char *source, int32_t source_len, UErrorCode *status);
ZEND_API void zend_convert_from_unicode(UConverter *conv, char **target, int32_t *target_len, const UChar *source, int32_t source_len, UErrorCode *status);
ZEND_API void zend_convert_encodings(UConverter *target_conv, UConverter *source_conv, char **target, int32_t *target_len, const char *source, int32_t source_len, UErrorCode *status);
ZEND_API int zval_string_to_unicode_ex(zval *string, UConverter *conv);
ZEND_API int zval_string_to_unicode(zval *string TSRMLS_DC);
ZEND_API int zval_unicode_to_string(zval *string, UConverter *conv TSRMLS_DC);

3
Zend/zend_variables.c
View File

@ -36,7 +36,6 @@ ZEND_API void _zval_dtor_func(zval *zvalue ZEND_FILE_LINE_DC)
if (UG(unicode)) goto dtor_unicode;
}
case IS_STRING:
case IS_BINARY:
CHECK_ZVAL_STRING_REL(zvalue);
STR_FREE_REL(zvalue->value.str.val);
break;
@ -90,7 +89,6 @@ ZEND_API void _zval_internal_dtor(zval *zvalue ZEND_FILE_LINE_DC)
if (UG(unicode)) goto dtor_unicode;
}
case IS_STRING:
case IS_BINARY:
CHECK_ZVAL_STRING_REL(zvalue);
free(zvalue->value.str.val);
break;
@ -140,7 +138,6 @@ ZEND_API void _zval_copy_ctor_func(zval *zvalue ZEND_FILE_LINE_DC)
if (UG(unicode)) goto copy_unicode;
}
case IS_STRING:
case IS_BINARY:
CHECK_ZVAL_STRING_REL(zvalue);
zvalue->value.str.val = (char *) estrndup_rel(zvalue->value.str.val, zvalue->value.str.len);
break;

15
Zend/zend_vm_def.h
View File

@ -898,7 +898,7 @@ ZEND_VM_HANDLER(40, ZEND_ECHO, CONST|TMP|VAR|CV, ANY)
zend_error(E_ERROR, "Unsupported encoding [%d]", EX(op_array)->script_encoding);
}
zend_convert_encodings(ZEND_U_CONVERTER(UG(output_encoding_conv)), script_enc_conv, &z_conv.value.str.val, &z_conv.value.str.len, z->value.str.val, z->value.str.len, &status);
z_conv.type = IS_BINARY;
z_conv.type = IS_STRING;
if (U_SUCCESS(status)) {
zend_print_variable(&z_conv);
} else {
@ -2623,7 +2623,6 @@ ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|V
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -2699,9 +2698,6 @@ ZEND_VM_HANDLER(21, ZEND_CAST, CONST|TMP|VAR|CV, ANY)
}
break;
}
case IS_BINARY:
convert_to_binary(result);
break;
case IS_ARRAY:
convert_to_array(result);
break;
@ -2918,7 +2914,6 @@ ZEND_VM_HANDLER(75, ZEND_UNSET_DIM, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
zend_hash_index_del(ht, index);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
void *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -2989,7 +2984,6 @@ ZEND_VM_HANDLER(75, ZEND_UNSET_DIM, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
@ -3289,11 +3283,6 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
key->value.str.len = str_key_len-1;
key->type = IS_STRING;
break;
case HASH_KEY_IS_BINARY:
key->value.str.val = str_key;
key->value.str.len = str_key_len-1;
key->type = IS_BINARY;
break;
case HASH_KEY_IS_UNICODE:
key->value.ustr.val = (UChar*)str_key;
key->value.ustr.len = str_key_len-1;
@ -3400,7 +3389,6 @@ ZEND_VM_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, VAR|UNUSED|CV, CONST|
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
char *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -3471,7 +3459,6 @@ ZEND_VM_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, VAR|UNUSED|CV, CONST|
FREE_OP2();
}
} else if (((*container)->type == IS_STRING ||
(*container)->type == IS_BINARY ||
(*container)->type == IS_UNICODE) && !prop_dim) { /* string offsets */
zval tmp;

98
Zend/zend_vm_execute.h
View File

@ -1284,7 +1284,7 @@ static int ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_error(E_ERROR, "Unsupported encoding [%d]", EX(op_array)->script_encoding);
}
zend_convert_encodings(ZEND_U_CONVERTER(UG(output_encoding_conv)), script_enc_conv, &z_conv.value.str.val, &z_conv.value.str.len, z->value.str.val, z->value.str.len, &status);
z_conv.type = IS_BINARY;
z_conv.type = IS_STRING;
if (U_SUCCESS(status)) {
zend_print_variable(&z_conv);
} else {
@ -1784,9 +1784,6 @@ static int ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
}
break;
}
case IS_BINARY:
convert_to_binary(result);
break;
case IS_ARRAY:
convert_to_array(result);
break;
@ -2589,7 +2586,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -2938,7 +2934,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -3287,7 +3282,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -3370,7 +3364,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -3718,7 +3711,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -3788,7 +3780,7 @@ static int ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_error(E_ERROR, "Unsupported encoding [%d]", EX(op_array)->script_encoding);
}
zend_convert_encodings(ZEND_U_CONVERTER(UG(output_encoding_conv)), script_enc_conv, &z_conv.value.str.val, &z_conv.value.str.len, z->value.str.val, z->value.str.len, &status);
z_conv.type = IS_BINARY;
z_conv.type = IS_STRING;
if (U_SUCCESS(status)) {
zend_print_variable(&z_conv);
} else {
@ -4290,9 +4282,6 @@ static int ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
}
break;
}
case IS_BINARY:
convert_to_binary(result);
break;
case IS_ARRAY:
convert_to_array(result);
break;
@ -5177,7 +5166,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -5614,7 +5602,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -6051,7 +6038,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -6134,7 +6120,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_AR
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -6568,7 +6553,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -6800,7 +6784,7 @@ static int ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_error(E_ERROR, "Unsupported encoding [%d]", EX(op_array)->script_encoding);
}
zend_convert_encodings(ZEND_U_CONVERTER(UG(output_encoding_conv)), script_enc_conv, &z_conv.value.str.val, &z_conv.value.str.len, z->value.str.val, z->value.str.len, &status);
z_conv.type = IS_BINARY;
z_conv.type = IS_STRING;
if (U_SUCCESS(status)) {
zend_print_variable(&z_conv);
} else {
@ -7393,9 +7377,6 @@ static int ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
}
break;
}
case IS_BINARY:
convert_to_binary(result);
break;
case IS_ARRAY:
convert_to_array(result);
break;
@ -7834,11 +7815,6 @@ static int ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
key->value.str.len = str_key_len-1;
key->type = IS_STRING;
break;
case HASH_KEY_IS_BINARY:
key->value.str.val = str_key;
key->value.str.len = str_key_len-1;
key->type = IS_BINARY;
break;
case HASH_KEY_IS_UNICODE:
key->value.ustr.val = (UChar*)str_key;
key->value.ustr.len = str_key_len-1;
@ -9135,7 +9111,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -9195,7 +9170,6 @@ static int ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_del(ht, index);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
void *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -9266,7 +9240,6 @@ static int ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
@ -9348,7 +9321,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(int prop_dim,
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
char *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -9419,7 +9391,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(int prop_dim,
}
} else if (((*container)->type == IS_STRING ||
(*container)->type == IS_BINARY ||
(*container)->type == IS_UNICODE) && !prop_dim) { /* string offsets */
zval tmp;
@ -10624,7 +10595,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -10684,7 +10654,6 @@ static int ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_del(ht, index);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
void *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -10755,7 +10724,6 @@ static int ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
@ -10837,7 +10805,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(int prop_dim, ZE
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
char *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -10908,7 +10875,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(int prop_dim, ZE
zval_dtor(free_op2.var);
}
} else if (((*container)->type == IS_STRING ||
(*container)->type == IS_BINARY ||
(*container)->type == IS_UNICODE) && !prop_dim) { /* string offsets */
zval tmp;
@ -12151,7 +12117,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -12211,7 +12176,6 @@ static int ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_del(ht, index);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
void *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -12282,7 +12246,6 @@ static int ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
@ -12364,7 +12327,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(int prop_dim, ZE
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
char *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -12435,7 +12397,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(int prop_dim, ZE
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
}
} else if (((*container)->type == IS_STRING ||
(*container)->type == IS_BINARY ||
(*container)->type == IS_UNICODE) && !prop_dim) { /* string offsets */
zval tmp;
@ -12876,7 +12837,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_AR
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -14082,7 +14042,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -14142,7 +14101,6 @@ static int ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_del(ht, index);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
void *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -14213,7 +14171,6 @@ static int ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
@ -14295,7 +14252,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(int prop_dim, ZEN
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
char *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -14366,7 +14322,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(int prop_dim, ZEN
}
} else if (((*container)->type == IS_STRING ||
(*container)->type == IS_BINARY ||
(*container)->type == IS_UNICODE) && !prop_dim) { /* string offsets */
zval tmp;
@ -15300,7 +15255,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -15360,7 +15314,6 @@ static int ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_del(ht, index);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
void *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -15431,7 +15384,6 @@ static int ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
@ -15511,7 +15463,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(int prop_di
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
char *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -15582,7 +15533,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(int prop_di
}
} else if (((*container)->type == IS_STRING ||
(*container)->type == IS_BINARY ||
(*container)->type == IS_UNICODE) && !prop_dim) { /* string offsets */
zval tmp;
@ -16400,7 +16350,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -16460,7 +16409,6 @@ static int ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_del(ht, index);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
void *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -16531,7 +16479,6 @@ static int ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
@ -16611,7 +16558,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(int prop_dim,
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
char *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -16682,7 +16628,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(int prop_dim,
zval_dtor(free_op2.var);
}
} else if (((*container)->type == IS_STRING ||
(*container)->type == IS_BINARY ||
(*container)->type == IS_UNICODE) && !prop_dim) { /* string offsets */
zval tmp;
@ -17500,7 +17445,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -17560,7 +17504,6 @@ static int ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_del(ht, index);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
void *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -17631,7 +17574,6 @@ static int ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
@ -17711,7 +17653,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(int prop_dim,
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
char *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -17782,7 +17723,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(int prop_dim,
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
}
} else if (((*container)->type == IS_STRING ||
(*container)->type == IS_BINARY ||
(*container)->type == IS_UNICODE) && !prop_dim) { /* string offsets */
zval tmp;
@ -18179,7 +18119,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -18965,7 +18904,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -19025,7 +18963,6 @@ static int ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_del(ht, index);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
void *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -19096,7 +19033,6 @@ static int ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
@ -19176,7 +19112,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(int prop_dim,
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
char *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -19247,7 +19182,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(int prop_dim,
}
} else if (((*container)->type == IS_STRING ||
(*container)->type == IS_BINARY ||
(*container)->type == IS_UNICODE) && !prop_dim) { /* string offsets */
zval tmp;
@ -19504,7 +19438,7 @@ static int ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_error(E_ERROR, "Unsupported encoding [%d]", EX(op_array)->script_encoding);
}
zend_convert_encodings(ZEND_U_CONVERTER(UG(output_encoding_conv)), script_enc_conv, &z_conv.value.str.val, &z_conv.value.str.len, z->value.str.val, z->value.str.len, &status);
z_conv.type = IS_BINARY;
z_conv.type = IS_STRING;
if (U_SUCCESS(status)) {
zend_print_variable(&z_conv);
} else {
@ -20083,9 +20017,6 @@ static int ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
}
break;
}
case IS_BINARY:
convert_to_binary(result);
break;
case IS_ARRAY:
convert_to_array(result);
break;
@ -21667,7 +21598,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -21727,7 +21657,6 @@ static int ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_del(ht, index);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
void *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -21798,7 +21727,6 @@ static int ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
@ -21878,7 +21806,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(int prop_dim, Z
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
char *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -21949,7 +21876,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(int prop_dim, Z
}
} else if (((*container)->type == IS_STRING ||
(*container)->type == IS_BINARY ||
(*container)->type == IS_UNICODE) && !prop_dim) { /* string offsets */
zval tmp;
@ -23148,7 +23074,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -23208,7 +23133,6 @@ static int ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_del(ht, index);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
void *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -23279,7 +23203,6 @@ static int ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
@ -23359,7 +23282,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(int prop_dim, ZEN
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
char *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -23430,7 +23352,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(int prop_dim, ZEN
zval_dtor(free_op2.var);
}
} else if (((*container)->type == IS_STRING ||
(*container)->type == IS_BINARY ||
(*container)->type == IS_UNICODE) && !prop_dim) { /* string offsets */
zval tmp;
@ -24666,7 +24587,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -24726,7 +24646,6 @@ static int ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_del(ht, index);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
void *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -24797,7 +24716,6 @@ static int ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
@ -24877,7 +24795,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(int prop_dim, ZEN
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
char *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -24948,7 +24865,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(int prop_dim, ZEN
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
}
} else if (((*container)->type == IS_STRING ||
(*container)->type == IS_BINARY ||
(*container)->type == IS_UNICODE) && !prop_dim) { /* string offsets */
zval tmp;
@ -25386,7 +25302,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARG
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -26587,7 +26502,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
break;
@ -26647,7 +26561,6 @@ static int ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_hash_index_del(ht, index);
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
void *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -26718,7 +26631,6 @@ static int ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
@ -26798,7 +26710,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int prop_dim, ZEND
}
break;
case IS_STRING:
case IS_BINARY:
case IS_UNICODE: {
char *offset_key = Z_UNIVAL_P(offset);
int offset_len = Z_UNILEN_P(offset);
@ -26869,7 +26780,6 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int prop_dim, ZEND
}
} else if (((*container)->type == IS_STRING ||
(*container)->type == IS_BINARY ||
(*container)->type == IS_UNICODE) && !prop_dim) { /* string offsets */
zval tmp;

1
ext/ctype/ctype.c
View File

@ -107,7 +107,6 @@ PHP_MINFO_FUNCTION(ctype)
convert_to_string(&tmp); \
c = &tmp; \
case IS_STRING: \
case IS_BINARY: \
string:\
{ \
char *p = Z_STRVAL_P(c), *e = Z_STRVAL_P(c) + Z_STRLEN_P(c); \

19
ext/date/php_date.c
View File

@ -563,7 +563,11 @@ static char *date_format(char *format, int format_len, int *return_len, timelib_
php_locale_data *loc_dat;
if (!format_len) {
return estrdup("");
if (UG(unicode)) {
return eustrdup(EMPTY_STR);
} else {
return estrdup("");
}
}
loc_dat = date_get_locale_data(UG(default_locale));
@ -1187,7 +1191,14 @@ PHPAPI void php_strftime(INTERNAL_FUNCTION_PARAMETERS, int gmt)
if (real_len && real_len != buf_len) {
buf = (char *) erealloc(buf, real_len + 1);
RETURN_STRINGL(buf, real_len, 0);
if (UG(unicode)) {
RETVAL_RT_STRINGL(buf, real_len, 1);
efree(buf);
return;
} else {
RETURN_STRINGL(buf, real_len, 0);
}
}
efree(buf);
RETURN_FALSE;
@ -1820,7 +1831,7 @@ PHP_FUNCTION(date_default_timezone_get)
timelib_tzinfo *default_tz;
default_tz = get_timezone_info(TSRMLS_C);
RETVAL_STRING(default_tz->name, 1);
RETVAL_ASCII_STRING(default_tz->name, 1);
}
/* }}} */
@ -1902,7 +1913,7 @@ static void php_do_date_sunrise_sunset(INTERNAL_FUNCTION_PARAMETERS, int calc_su
switch (retformat) {
case SUNFUNCS_RET_STRING:
sprintf(retstr, "%02d:%02d", (int) N, (int) (60 * (N - (int) N)));
RETURN_STRINGL(retstr, 5, 1);
RETURN_RT_STRINGL(retstr, 5, 1);
break;
case SUNFUNCS_RET_DOUBLE:
RETURN_DOUBLE(N);

12
ext/date/tests/bug35143.phpt
View File

@ -19,3 +19,15 @@ array(4) {
["dsttime"]=>
int(0)
}
--UEXPECTF--
unicode(3) "UTC"
array(4) {
[u"sec"]=>
int(%d)
[u"usec"]=>
int(%d)
[u"minuteswest"]=>
int(0)
[u"dsttime"]=>
int(0)
}

2
ext/dom/document.c
View File

@ -1708,7 +1708,7 @@ PHP_FUNCTION(dom_document_savexml)
if (!size) {
RETURN_FALSE;
}
RETVAL_STRINGL(mem, size, 1);
RETVAL_RT_STRINGL(mem, size, 1);
xmlFree(mem);
}
}

6
ext/dom/node.c
View File

@ -147,9 +147,9 @@ int dom_node_node_name_read(dom_object *obj, zval **retval TSRMLS_DC)
ALLOC_ZVAL(*retval);
if(str != NULL) {
ZVAL_STRING(*retval, str, 1);
ZVAL_RT_STRING(*retval, str, 1);
} else {
ZVAL_EMPTY_STRING(*retval);
ZVAL_EMPTY_TEXT(*retval);
}
if (qname != NULL) {
@ -202,7 +202,7 @@ int dom_node_node_value_read(dom_object *obj, zval **retval TSRMLS_DC)
ALLOC_ZVAL(*retval);
if(str != NULL) {
ZVAL_STRING(*retval, str, 1);
ZVAL_RT_STRING(*retval, str, 1);
xmlFree(str);
} else {
ZVAL_NULL(*retval);

25
ext/dom/tests/dom002.phpt
View File

@ -55,3 +55,28 @@ string(9) "fubar:bar"
string(5) "test3"
string(9) "fubar:bar"
string(5) "test4"
--UEXPECT--
unicode(3) "bar"
unicode(5) "test1"
unicode(3) "bar"
unicode(5) "test2"
unicode(9) "fubar:bar"
unicode(5) "test3"
unicode(9) "fubar:bar"
unicode(5) "test4"
unicode(3) "bar"
unicode(5) "test1"
unicode(3) "bar"
unicode(5) "test2"
unicode(9) "fubar:bar"
unicode(5) "test3"
unicode(9) "fubar:bar"
unicode(5) "test4"
unicode(9) "fubar:bar"
unicode(5) "test3"
unicode(9) "fubar:bar"
unicode(5) "test4"
unicode(9) "fubar:bar"
unicode(5) "test3"
unicode(9) "fubar:bar"
unicode(5) "test4"

6
ext/dom/tests/dom_set_attr_node.phpt
View File

@ -74,7 +74,7 @@ object(DOMException)#%d (6) {
[u"file":protected]=>
unicode(%d) "%sdom_set_attr_node.php"
[u"line":protected]=>
int(22)
int(%d)
[u"trace":u"Exception":private]=>
array(1) {
[0]=>
@ -82,7 +82,7 @@ object(DOMException)#%d (6) {
[u"file"]=>
unicode(%d) "%sdom_set_attr_node.php"
[u"line"]=>
int(22)
int(%d)
[u"function"]=>
unicode(16) "setAttributeNode"
[u"class"]=>
@ -97,6 +97,6 @@ object(DOMException)#%d (6) {
}
}
}
["code"]=>
[u"code"]=>
int(4)
}

6
ext/reflection/php_reflection.c
View File

@ -604,8 +604,8 @@ static void _parameter_string(string *str, zend_function *fptr, struct _zend_arg
}
} else if (Z_TYPE_P(zv) == IS_NULL) {
string_write(str, "NULL", sizeof("NULL")-1);
} else if (Z_TYPE_P(zv) == IS_STRING || Z_TYPE_P(zv) == IS_BINARY) {
if (Z_TYPE_P(zv) == IS_BINARY) {
} else if (Z_TYPE_P(zv) == IS_STRING) {
if (UG(unicode)) {
string_write(str, "b'", sizeof("b")-1);
}
string_write(str, "'", sizeof("'")-1);
@ -1227,7 +1227,7 @@ ZEND_METHOD(reflection, export)
}
/* Invoke the __toString() method */
ZVAL_STRINGL(&fname, "__tostring", sizeof("__tostring") - 1, 1);
ZVAL_ASCII_STRINGL(&fname, "__tostring", sizeof("__tostring") - 1, 1);
result= call_user_function_ex(NULL, &object, &fname, &retval_ptr, 0, NULL, 0, NULL TSRMLS_CC);
zval_dtor(&fname);

13
ext/simplexml/simplexml.c
View File

@ -370,7 +370,6 @@ static void change_node_zval(xmlNodePtr node, zval *value TSRMLS_DC)
convert_to_string(value);
/* break missing intentionally */
case IS_STRING:
case IS_BINARY:
xmlNodeSetContentLen(node, Z_STRVAL_P(value), Z_STRLEN_P(value));
if (value == &value_copy) {
zval_dtor(value);
@ -521,7 +520,6 @@ next_iter:
case IS_UNICODE:
convert_to_string(value);
case IS_STRING:
case IS_BINARY:
newnode = (xmlNodePtr)xmlNewProp(node, name, Z_STRVAL_P(value));
break;
default:
@ -1276,7 +1274,11 @@ SXE_METHOD(attributes)
static int cast_object(zval *object, int type, char *contents TSRMLS_DC)
{
if (contents) {
ZVAL_STRINGL(object, contents, strlen(contents), 1);
if (UG(unicode)) {
ZVAL_U_STRING(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), object, contents, 1);
} else {
ZVAL_STRINGL(object, contents, strlen(contents), 1);
}
} else {
ZVAL_NULL(object);
}
@ -1287,9 +1289,6 @@ static int cast_object(zval *object, int type, char *contents TSRMLS_DC)
case IS_STRING:
convert_to_string(object);
break;
case IS_BINARY:
convert_to_binary(object);
break;
case IS_UNICODE:
convert_to_unicode(object);
break;
@ -1381,7 +1380,7 @@ static zval *sxe_get_value(zval *z TSRMLS_DC)
MAKE_STD_ZVAL(retval);
if (sxe_object_cast(z, retval, IS_STRING TSRMLS_CC)==FAILURE) {
if (sxe_object_cast(z, retval, UG(unicode)?IS_UNICODE:IS_STRING TSRMLS_CC)==FAILURE) {
zend_error(E_ERROR, "Unable to cast node to string");
/* FIXME: Should not be fatal */
}

3
ext/simplexml/tests/013.phpt
View File

@ -21,3 +21,6 @@ var_dump((string)$sxe);
--EXPECT--
string(6) "barbar"
===DONE===
--UEXPECT--
unicode(6) "barbar"
===DONE===

4
ext/simplexml/tests/profile11.phpt
View File

@ -42,8 +42,8 @@ object(SimpleXMLElement)#%d (1) {
[0]=>
unicode(5) "World"
}
string(5) "Hello"
string(5) "World"
unicode(5) "Hello"
unicode(5) "World"
object(SimpleXMLElement)#%d (0) {
}
===DONE===

3
ext/spl/php_spl.c
View File

@ -403,8 +403,7 @@ PHP_FUNCTION(spl_autoload_register)
}
}
} else if (Z_TYPE_P(zcallable) == IS_UNICODE) {
ZVAL_STRINGL(&ztmp, "spl_autoload_call", sizeof("spl_autoload_call"), 1);
convert_to_unicode(&ztmp);
ZVAL_ASCII_STRINGL(&ztmp, "spl_autoload_call", sizeof("spl_autoload_call")-1, 1);
if (zend_u_binary_zval_strcmp(&ztmp, zcallable)) {
if (!zend_binary_strcasecmp(Z_STRVAL_P(zcallable), sizeof("spl_autoload_call"), "spl_autoload_call", sizeof("spl_autoload_call"))) {
if (do_throw) {

7
ext/spl/spl_array.c
View File

@ -225,7 +225,6 @@ static zval **spl_array_get_dimension_ptr_ptr(int check_inherited, zval *object,
switch(Z_TYPE_P(offset)) {
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
if (zend_u_symtable_find(spl_array_get_hash_table(intern, 0 TSRMLS_CC), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, (void **) &retval) == FAILURE) {
zend_error(E_NOTICE, "Undefined index: %R", Z_TYPE_P(offset), Z_STRVAL_P(offset));
@ -303,7 +302,6 @@ static void spl_array_write_dimension_ex(int check_inherited, zval *object, zval
}
switch(Z_TYPE_P(offset)) {
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
if (*(char*)Z_UNIVAL_P(offset) == '\0') {
zend_throw_exception(U_CLASS_ENTRY(spl_ce_InvalidArgumentException), "An offset must not begin with \\0 or be empty", 0 TSRMLS_CC);
@ -351,7 +349,6 @@ static void spl_array_unset_dimension_ex(int check_inherited, zval *object, zval
switch(Z_TYPE_P(offset)) {
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
if (spl_array_get_hash_table(intern, 0 TSRMLS_CC) == &EG(symbol_table)) {
if (zend_u_delete_global_variable(Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset) TSRMLS_CC)) {
@ -406,7 +403,6 @@ static int spl_array_has_dimension_ex(int check_inherited, zval *object, zval *o
switch(Z_TYPE_P(offset)) {
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
return zend_u_symtable_exists(spl_array_get_hash_table(intern, 0 TSRMLS_CC), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1);
case IS_DOUBLE:
@ -1176,9 +1172,6 @@ void spl_array_iterator_key(zval *object, zval *return_value TSRMLS_DC) /* {{{ *
case HASH_KEY_IS_STRING:
RETVAL_STRINGL(string_key, string_length - 1, 0);
break;
case HASH_KEY_IS_BINARY:
RETVAL_BINARYL(string_key, string_length - 1, 0);
break;
case HASH_KEY_IS_UNICODE:
RETVAL_UNICODEL((UChar*)string_key, string_length - 1, 0);
break;

20
ext/spl/spl_iterators.c
View File

@ -481,9 +481,6 @@ SPL_METHOD(RecursiveIteratorIterator, key)
case HASH_KEY_IS_UNICODE:
RETURN_UNICODEL((void*)str_key, str_key_len-1, 0);
break;
case HASH_KEY_IS_BINARY:
RETURN_BINARYL(str_key, str_key_len-1, 0);
break;
default:
RETURN_NULL();
}
@ -1110,8 +1107,6 @@ SPL_METHOD(dual_it, key)
if (intern->current.data) {
if (intern->current.key_type == HASH_KEY_IS_STRING) {
RETURN_STRINGL(intern->current.str_key, intern->current.str_key_len-1, 1);
} else if (intern->current.key_type == HASH_KEY_IS_BINARY) {
RETURN_BINARYL(intern->current.str_key, intern->current.str_key_len-1, 1);
} else if (intern->current.key_type == HASH_KEY_IS_UNICODE) {
RETURN_UNICODEL((UChar *)intern->current.str_key, intern->current.str_key_len-1, 1);
} else {
@ -1659,7 +1654,11 @@ static inline void spl_caching_it_next(spl_dual_it_object *intern TSRMLS_DC)
zval expr_copy;
ALLOC_ZVAL(intern->u.caching.zstr);
*intern->u.caching.zstr = *intern->current.data;
zend_make_printable_zval(intern->u.caching.zstr, &expr_copy, &use_copy);
if (UG(unicode)) {
zend_make_unicode_zval(intern->u.caching.zstr, &expr_copy, &use_copy);
} else {
zend_make_printable_zval(intern->u.caching.zstr, &expr_copy, &use_copy);
}
if (use_copy) {
*intern->u.caching.zstr = expr_copy;
INIT_PZVAL(intern->u.caching.zstr);
@ -1750,8 +1749,6 @@ SPL_METHOD(CachingIterator, __toString)
RETURN_STRINGL(intern->current.str_key, intern->current.str_key_len, 1);
} else if (intern->current.key_type == HASH_KEY_IS_UNICODE) {
RETURN_UNICODEL((void*)intern->current.str_key, intern->current.str_key_len, 1);
} else if (intern->current.key_type == HASH_KEY_IS_BINARY) {
RETURN_BINARYL(intern->current.str_key, intern->current.str_key_len, 1);
} else {
RETVAL_LONG(intern->current.int_key);
convert_to_string(return_value);
@ -2070,9 +2067,6 @@ SPL_METHOD(NoRewindIterator, key)
case HASH_KEY_IS_UNICODE:
RETURN_UNICODEL((void*)str_key, str_key_len-1, 0);
break;
case HASH_KEY_IS_BINARY:
RETURN_BINARYL(str_key, str_key_len-1, 0);
break;
default:
RETURN_NULL();
}
@ -2383,10 +2377,6 @@ PHP_FUNCTION(iterator_to_array)
add_assoc_zval_ex(return_value, str_key, str_key_len, *data);
efree(str_key);
break;
case HASH_KEY_IS_BINARY:
add_u_assoc_zval_ex(return_value, IS_BINARY, str_key, str_key_len, *data);
efree(str_key);
break;
case HASH_KEY_IS_UNICODE:
add_u_assoc_zval_ex(return_value, IS_UNICODE, str_key, str_key_len, *data);
efree(str_key);

6
ext/sqlite/sqlite.c
View File

@ -442,7 +442,7 @@ static void php_sqlite_generic_function_callback(sqlite_func *func, int argc, co
return;
}
ZVAL_STRING(&funcname, (char*)argv[0], 1);
ZVAL_ASCII_STRING(&funcname, (char*)argv[0], 1);
if (!zend_make_callable(&funcname, &callable TSRMLS_CC)) {
spprintf(&errbuf, 0, "function `%R' is not a function name", Z_TYPE(callable), Z_UNIVAL(callable));
@ -1862,7 +1862,7 @@ static void php_sqlite_fetch_array(struct php_sqlite_result *res, int mode, zend
Z_STRVAL_P(decoded) = emalloc(strlen(rowdata[j]));
Z_STRLEN_P(decoded) = php_sqlite_decode_binary(rowdata[j]+1, Z_STRVAL_P(decoded));
Z_STRVAL_P(decoded)[Z_STRLEN_P(decoded)] = '\0';
Z_TYPE_P(decoded) = UG(unicode)?IS_BINARY:IS_STRING;
Z_TYPE_P(decoded) = IS_STRING;
if (!buffered) {
efree((char*)rowdata[j]);
rowdata[j] = NULL;
@ -1951,7 +1951,7 @@ static void php_sqlite_fetch_column(struct php_sqlite_result *res, zval *which,
char *decoded = emalloc(l);
l = php_sqlite_decode_binary(rowdata[j]+1, decoded);
decoded[l] = '\0';
RETVAL_BINARYL(decoded, l, 0);
RETVAL_STRINGL(decoded, l, 0);
if (!res->buffered) {
efree((char*)rowdata[j]);
rowdata[j] = NULL;

65
ext/standard/array.c
View File

@ -956,9 +956,6 @@ PHP_FUNCTION(key)
case HASH_KEY_IS_STRING:
RETVAL_STRINGL(string_key, string_length - 1, 1);
break;
case HASH_KEY_IS_BINARY:
RETVAL_BINARYL(string_key, string_length - 1, 1);
break;
case HASH_KEY_IS_UNICODE:
RETVAL_UNICODEL((UChar*)string_key, string_length - 1, 1);
break;
@ -1114,9 +1111,6 @@ static int php_array_walk(HashTable *target_hash, zval **userdata, int recursive
case HASH_KEY_IS_STRING:
ZVAL_STRINGL(key, string_key, string_key_len-1, 1);
break;
case HASH_KEY_IS_BINARY:
ZVAL_BINARYL(key, string_key, string_key_len-1, 1);
break;
case HASH_KEY_IS_UNICODE:
ZVAL_UNICODEL(key, (UChar*)string_key, string_key_len-1, 1);
break;
@ -1287,9 +1281,6 @@ static void php_search_array(INTERNAL_FUNCTION_PARAMETERS, int behavior)
case HASH_KEY_IS_STRING:
RETURN_STRINGL(string_key, str_key_len-1, 1);
break;
case HASH_KEY_IS_BINARY:
RETURN_BINARYL(string_key, str_key_len-1, 1);
break;
case HASH_KEY_IS_UNICODE:
RETURN_UNICODEL((UChar*)string_key, str_key_len-1, 1);
break;
@ -1588,7 +1579,6 @@ static void php_compact_var(HashTable *eg_active_symbol_table, zval *return_valu
zval **value_ptr, *value, *data;
if (Z_TYPE_P(entry) == IS_STRING ||
Z_TYPE_P(entry) == IS_BINARY ||
Z_TYPE_P(entry) == IS_UNICODE) {
if (zend_u_hash_find(eg_active_symbol_table, Z_TYPE_P(entry), Z_UNIVAL_P(entry),
Z_UNILEN_P(entry)+1, (void **)&value_ptr) != FAILURE) {
@ -1721,7 +1711,6 @@ PHP_FUNCTION(range)
/* Unify types */
str_type = zend_get_unified_string_type(2 TSRMLS_CC, Z_TYPE_P(zlow), Z_TYPE_P(zhigh));
if (str_type == (zend_uchar)-1) {
zend_error(E_WARNING, "Cannot mix binary and Unicode parameters");
return;
}
convert_to_explicit_type(zlow, str_type);
@ -1731,7 +1720,7 @@ PHP_FUNCTION(range)
array_init(return_value);
/* If the range is given as strings, generate an array of characters. */
if ((Z_TYPE_P(zlow) == IS_STRING || Z_TYPE_P(zlow) == IS_BINARY) &&
if ((Z_TYPE_P(zlow) == IS_STRING) &&
Z_STRLEN_P(zlow) >= 1 && Z_STRLEN_P(zhigh) >= 1) {
zend_uchar type1, type2;
unsigned char *low, *high;
@ -1758,11 +1747,7 @@ PHP_FUNCTION(range)
goto err;
}
for (; *low >= *high; (*low) -= (unsigned int)lstep) {
if (Z_TYPE_P(zlow) == IS_STRING) {
add_next_index_stringl(return_value, low, 1, 1);
} else {
add_next_index_binaryl(return_value, low, 1, 1);
}
add_next_index_stringl(return_value, low, 1, 1);
if (((signed int)*low - lstep) < 0) {
break;
}
@ -1773,21 +1758,13 @@ PHP_FUNCTION(range)
goto err;
}
for (; *low <= *high; (*low) += (unsigned int)lstep) {
if (Z_TYPE_P(zlow) == IS_STRING) {
add_next_index_stringl(return_value, low, 1, 1);
} else {
add_next_index_binaryl(return_value, low, 1, 1);
}
add_next_index_stringl(return_value, low, 1, 1);
if (((signed int)*low + lstep) > 255) {
break;
}
}
} else {
if (Z_TYPE_P(zlow) == IS_STRING) {
add_next_index_stringl(return_value, low, 1, 1);
} else {
add_next_index_binaryl(return_value, low, 1, 1);
}
add_next_index_stringl(return_value, low, 1, 1);
}
} else if (Z_TYPE_P(zlow) == IS_UNICODE &&
Z_USTRLEN_P(zlow) >= 1 && Z_USTRLEN_P(zhigh) >= 1) {
@ -2157,8 +2134,7 @@ static void _phpi_pop(INTERNAL_FUNCTION_PARAMETERS, int off_the_end)
key_type = zend_hash_get_current_key_ex(Z_ARRVAL_PP(stack), &key, &key_len, &index, 0, NULL);
if (key && Z_ARRVAL_PP(stack) == &EG(symbol_table)) {
if (key_type == HASH_KEY_IS_UNICODE) key_type = IS_UNICODE;
else if (key_type == HASH_KEY_IS_STRING) key_type = IS_STRING;
else key_type = IS_BINARY;
else key_type = IS_STRING;
zend_u_delete_global_variable(key_type, key, key_len-1 TSRMLS_CC);
} else {
zend_hash_del_key_or_index(Z_ARRVAL_PP(stack), key, key_len, index, (key) ? HASH_DEL_KEY : HASH_DEL_INDEX);
@ -2428,9 +2404,6 @@ PHP_FUNCTION(array_slice)
case HASH_KEY_IS_STRING:
utype = IS_STRING;
goto ukey;
case HASH_KEY_IS_BINARY:
utype = IS_BINARY;
goto ukey;
case HASH_KEY_IS_UNICODE:
utype = IS_UNICODE;
ukey:
@ -2470,9 +2443,6 @@ PHPAPI int php_array_merge(HashTable *dest, HashTable *src, int recursive TSRMLS
case HASH_KEY_IS_STRING:
utype = IS_STRING;
goto ukey;
case HASH_KEY_IS_BINARY:
utype = IS_BINARY;
goto ukey;
case HASH_KEY_IS_UNICODE:
utype = IS_UNICODE;
ukey:
@ -2625,9 +2595,6 @@ PHP_FUNCTION(array_keys)
case HASH_KEY_IS_STRING:
ZVAL_STRINGL(new_val, string_key, string_key_len-1, 0);
goto ukey;
case HASH_KEY_IS_BINARY:
ZVAL_BINARYL(new_val, string_key, string_key_len-1, 0);
goto ukey;
case HASH_KEY_IS_UNICODE:
ZVAL_UNICODEL(new_val, (UChar*)string_key, string_key_len-1, 0);
ukey:
@ -2725,7 +2692,6 @@ PHP_FUNCTION(array_count_values)
Z_LVAL_PP(tmp)++;
}
} else if (Z_TYPE_PP(entry) == IS_STRING ||
Z_TYPE_PP(entry) == IS_BINARY ||
Z_TYPE_PP(entry) == IS_UNICODE) {
/* make sure our array does not end up with numeric string keys
* but don't touch those strings that start with 0 */
@ -2815,9 +2781,6 @@ PHP_FUNCTION(array_reverse)
case HASH_KEY_IS_STRING:
utype = IS_STRING;
goto ukey;
case HASH_KEY_IS_BINARY:
utype = IS_BINARY;
goto ukey;
case HASH_KEY_IS_UNICODE:
utype = IS_UNICODE;
ukey:
@ -2940,9 +2903,6 @@ PHP_FUNCTION(array_flip)
case HASH_KEY_IS_STRING:
ZVAL_STRINGL(data, string_key, str_key_len-1, 0);
break;
case HASH_KEY_IS_BINARY:
ZVAL_BINARYL(data, string_key, str_key_len-1, 0);
break;
case HASH_KEY_IS_UNICODE:
ZVAL_UNICODEL(data, (UChar *)string_key, str_key_len-1, 0);
break;
@ -2955,7 +2915,6 @@ PHP_FUNCTION(array_flip)
if (Z_TYPE_PP(entry) == IS_LONG) {
zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_PP(entry), &data, sizeof(data), NULL);
} else if (Z_TYPE_PP(entry) == IS_STRING ||
Z_TYPE_PP(entry) == IS_BINARY ||
Z_TYPE_PP(entry) == IS_UNICODE) {
zend_u_symtable_update(Z_ARRVAL_P(return_value), Z_TYPE_PP(entry), Z_UNIVAL_PP(entry), Z_UNILEN_PP(entry) + 1, &data, sizeof(data), NULL);
} else {
@ -4147,8 +4106,6 @@ PHP_FUNCTION(array_rand)
if (Z_TYPE_P(return_value) != IS_ARRAY) {
if (key_type == HASH_KEY_IS_STRING) {
RETURN_STRINGL(string_key, string_key_len-1, 1);
} else if (key_type == HASH_KEY_IS_BINARY) {
RETURN_BINARYL(string_key, string_key_len-1, 1);
} else if (key_type == HASH_KEY_IS_UNICODE) {
RETURN_UNICODEL((UChar *)string_key, string_key_len-1, 1);
} else {
@ -4158,8 +4115,6 @@ PHP_FUNCTION(array_rand)
/* Append the result to the return value. */
if (key_type == HASH_KEY_IS_STRING)
add_next_index_stringl(return_value, string_key, string_key_len-1, 1);
else if (key_type == HASH_KEY_IS_BINARY)
add_next_index_binaryl(return_value, string_key, string_key_len-1, 1);
else if (key_type == HASH_KEY_IS_UNICODE)
add_next_index_unicodel(return_value, (UChar *)string_key, string_key_len-1, 1);
else
@ -4452,9 +4407,6 @@ PHP_FUNCTION(array_filter)
case HASH_KEY_IS_STRING:
utype = IS_STRING;
goto ukey;
case HASH_KEY_IS_BINARY:
utype = IS_BINARY;
goto ukey;
case HASH_KEY_IS_UNICODE:
utype = IS_UNICODE;
ukey:
@ -4622,9 +4574,6 @@ PHP_FUNCTION(array_map)
case HASH_KEY_IS_STRING:
utype = IS_STRING;
goto ukey;
case HASH_KEY_IS_BINARY:
utype = IS_BINARY;
goto ukey;
case HASH_KEY_IS_UNICODE:
utype = IS_UNICODE;
ukey:
@ -4665,7 +4614,6 @@ PHP_FUNCTION(array_key_exists)
switch (Z_TYPE_PP(key)) {
case IS_STRING:
case IS_UNICODE:
case IS_BINARY:
if (zend_u_symtable_exists(HASH_OF(*array), Z_TYPE_PP(key), Z_UNIVAL_PP(key), Z_UNILEN_PP(key)+1)) {
RETURN_TRUE;
}
@ -4736,9 +4684,6 @@ PHP_FUNCTION(array_chunk)
case HASH_KEY_IS_STRING:
utype = IS_STRING;
goto ukey;
case HASH_KEY_IS_BINARY:
utype = IS_BINARY;
goto ukey;
case HASH_KEY_IS_UNICODE:
utype = IS_UNICODE;
ukey:

5
ext/standard/basic_functions.c
View File

@ -534,7 +534,6 @@ zend_function_entry basic_functions[] = {
PHP_FE(is_numeric, NULL)
PHP_FE(is_string, NULL)
PHP_FE(is_unicode, NULL)
PHP_FE(is_binary, NULL)
PHP_FE(is_buffer, NULL)
PHP_FE(is_array, NULL)
PHP_FE(is_object, NULL)
@ -1425,7 +1424,7 @@ PHP_FUNCTION(getenv)
ptr = getenv(str);
}
if (ptr) {
RETURN_STRING(ptr, 1);
RETURN_RT_STRING(ptr, 1);
}
RETURN_FALSE;
}
@ -2572,7 +2571,7 @@ PHP_FUNCTION(ini_get)
RETURN_FALSE;
}
RETURN_STRING(str, 1);
RETURN_RT_STRING(str, 1);
}
/* }}} */

5
ext/standard/file.c
View File

@ -844,7 +844,10 @@ PHP_FUNCTION(tempnam)
if ((fd = php_open_temporary_fd(d, p, &opened_path TSRMLS_CC)) >= 0) {
close(fd);
RETVAL_STRING(opened_path, 0);
RETVAL_RT_STRING(opened_path, 0);
if (UG(unicode)) {
efree(opened_path);
}
} else {
RETVAL_FALSE;
}

25
ext/standard/math.c
View File

@ -1073,6 +1073,7 @@ PHP_FUNCTION(number_format)
{
zval **num, **dec, **t_s, **d_p;
char thousand_sep=',', dec_point='.';
char *tmp;
switch(ZEND_NUM_ARGS()) {
case 1:
@ -1080,16 +1081,24 @@ PHP_FUNCTION(number_format)
RETURN_FALSE;
}
convert_to_double_ex(num);
RETURN_STRING(_php_math_number_format(Z_DVAL_PP(num), 0, dec_point, thousand_sep), 0);
break;
tmp = _php_math_number_format(Z_DVAL_PP(num), 0, dec_point, thousand_sep);
RETVAL_RT_STRING(tmp, 0);
if (UG(unicode)) {
efree(tmp);
}
return;
case 2:
if (zend_get_parameters_ex(2, &num, &dec)==FAILURE) {
RETURN_FALSE;
}
convert_to_double_ex(num);
convert_to_long_ex(dec);
RETURN_STRING(_php_math_number_format(Z_DVAL_PP(num), Z_LVAL_PP(dec), dec_point, thousand_sep), 0);
break;
tmp = _php_math_number_format(Z_DVAL_PP(num), Z_LVAL_PP(dec), dec_point, thousand_sep);
RETVAL_RT_STRING(tmp, 0);
if (UG(unicode)) {
efree(tmp);
}
return;
case 4:
if (zend_get_parameters_ex(4, &num, &dec, &d_p, &t_s)==FAILURE) {
RETURN_FALSE;
@ -1113,8 +1122,12 @@ PHP_FUNCTION(number_format)
thousand_sep=0;
}
}
RETURN_STRING(_php_math_number_format(Z_DVAL_PP(num), Z_LVAL_PP(dec), dec_point, thousand_sep), 0);
break;
tmp = _php_math_number_format(Z_DVAL_PP(num), Z_LVAL_PP(dec), dec_point, thousand_sep);
RETVAL_RT_STRING(tmp, 0);
if (UG(unicode)) {
efree(tmp);
}
return;
default:
WRONG_PARAM_COUNT;
break;

4
ext/standard/md5.c
View File

@ -58,7 +58,7 @@ PHP_NAMED_FUNCTION(php_if_md5)
PHP_MD5Update(&context, arg, arg_len);
PHP_MD5Final(digest, &context);
if (raw_output) {
RETURN_BINARYL(digest, 16, 1);
RETURN_STRINGL(digest, 16, 1);
} else {
make_digest(md5str, digest);
RETVAL_ASCII_STRING(md5str, 1);
@ -105,7 +105,7 @@ PHP_NAMED_FUNCTION(php_if_md5_file)
}
if (raw_output) {
RETURN_BINARYL(digest, 16, 1);
RETURN_STRINGL(digest, 16, 1);
} else {
make_digest(md5str, digest);
RETVAL_ASCII_STRING(md5str, 1);

4
ext/standard/sha1.c
View File

@ -59,7 +59,7 @@ PHP_FUNCTION(sha1)
RETURN_STRINGL(digest, 20, 1);
} else {
make_sha1_digest(sha1str, digest);
RETVAL_STRING(sha1str, 1);
RETVAL_ASCII_STRING(sha1str, 1);
}
}
@ -108,7 +108,7 @@ PHP_FUNCTION(sha1_file)
RETURN_STRINGL(digest, 20, 1);
} else {
make_sha1_digest(sha1str, digest);
RETVAL_STRING(sha1str, 1);
RETVAL_ASCII_STRING(sha1str, 1);
}
}
/* }}} */

256
ext/standard/string.c
View File

@ -190,7 +190,7 @@ PHP_FUNCTION(bin2hex)
char *result;
size_t newlen;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "y", &data, &data_len) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &data, &data_len) == FAILURE) {
return;
}
@ -599,11 +599,7 @@ PHPAPI char *php_trim(char *c, int len, char *what, int what_len, zend_uchar str
}
if (return_value) {
if ( str_type == IS_BINARY ) {
RETVAL_BINARYL(c, len, 1);
} else {
RETVAL_STRINGL(c, len, 1);
}
RETVAL_STRINGL(c, len, 1);
} else {
return estrndup(c, len);
}
@ -963,28 +959,16 @@ PHPAPI void php_explode(char *delim, uint delim_len, char *str, uint str_len, ze
p2 = php_memnstr(str, delim, delim_len, endp);
if ( p2 == NULL ) {
if ( str_type == IS_BINARY ) {
add_next_index_binaryl(return_value, p1, str_len, 1);
} else {
add_next_index_stringl(return_value, p1, str_len, 1);
}
add_next_index_stringl(return_value, p1, str_len, 1);
} else {
do {
if ( str_type == IS_BINARY ) {
add_next_index_binaryl(return_value, p1, p2-p1, 1);
} else {
add_next_index_stringl(return_value, p1, p2-p1, 1);
}
add_next_index_stringl(return_value, p1, p2-p1, 1);
p1 = p2 + delim_len;
} while ( (p2 = php_memnstr(p1, delim, delim_len, endp)) != NULL &&
(limit == -1 || --limit > 1) );
if ( p1 <= endp ) {
if ( str_type == IS_BINARY ) {
add_next_index_binaryl(return_value, p1, endp-p1, 1);
} else {
add_next_index_stringl(return_value, p1, endp-p1, 1);
}
add_next_index_stringl(return_value, p1, endp-p1, 1);
}
}
}
@ -1021,13 +1005,8 @@ PHPAPI void php_explode_negative_limit(char *delim, uint delim_len, char *str, u
to_return = limit + found;
/* limit is at least -1 therefore no need of bounds checking : i will be always less than found */
for ( i = 0 ; i < to_return ; i++ ) { /* this checks also for to_return > 0 */
if ( str_type == IS_BINARY ) {
add_next_index_binaryl(return_value, positions[i],
(positions[i+1]-delim_len) - positions[i], 1);
} else {
add_next_index_stringl(return_value, positions[i],
add_next_index_stringl(return_value, positions[i],
(positions[i+1]-delim_len) - positions[i], 1);
}
}
}
efree(positions);
@ -1132,8 +1111,6 @@ PHP_FUNCTION(explode)
if ( str_len == 0 ) {
if ( str_type == IS_UNICODE ) {
add_next_index_unicodel(return_value, USTR_MAKE(""), sizeof("")-1, 0);
} else if ( str_type == IS_BINARY ) {
add_next_index_binaryl(return_value, "", sizeof("")-1, 1);
} else {
add_next_index_stringl(return_value, "", sizeof("")-1, 1);
}
@ -1144,8 +1121,6 @@ PHP_FUNCTION(explode)
if (limit == 0 || limit == 1) {
if ( str_type == IS_UNICODE ) {
add_index_unicodel(return_value, 0, (UChar *)str, str_len, 1);
} else if ( str_type == IS_BINARY ) {
add_index_binaryl(return_value, 0, (char *)str, str_len, 1 TSRMLS_CC);
} else {
add_index_stringl(return_value, 0, (char *)str, str_len, 1);
}
@ -1184,8 +1159,6 @@ PHPAPI void php_implode(zval *delim, zval *arr, zval *retval)
/* Setup return value */
if (return_type == IS_UNICODE) {
ZVAL_EMPTY_UNICODE(retval);
} else if (return_type == IS_BINARY) {
ZVAL_EMPTY_BINARY(retval);
} else {
ZVAL_EMPTY_STRING(retval);
}
@ -1198,9 +1171,8 @@ PHPAPI void php_implode(zval *delim, zval *arr, zval *retval)
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(arr), &pos);
while (zend_hash_get_current_data_ex(Z_ARRVAL_P(arr), (void **)&tmp, &pos) == SUCCESS) {
if (Z_TYPE_PP(tmp) != return_type) {
/* Convert to common type, if possible */
if (return_type == IS_UNICODE) {
if (Z_TYPE_PP(tmp) == IS_BINARY) {
if (Z_TYPE_PP(tmp) == IS_STRING) {
/* ERROR */
php_error_docref(NULL TSRMLS_CC, E_WARNING,
"Cannot mix binary strings with other string types");
@ -1211,17 +1183,17 @@ PHPAPI void php_implode(zval *delim, zval *arr, zval *retval)
SEPARATE_ZVAL(tmp);
convert_to_unicode_ex(tmp);
}
} else if (return_type == IS_BINARY) {
if (Z_TYPE_PP(tmp) == IS_UNICODE || Z_TYPE_PP(tmp) == IS_STRING) {
} else if (return_type == IS_STRING) {
if (Z_TYPE_PP(tmp) == IS_UNICODE) {
/* ERROR */
php_error_docref(NULL TSRMLS_CC, E_WARNING,
"Cannot mix binary strings with other string types");
efree(Z_BINVAL_P(retval));
efree(Z_STRVAL_P(retval));
ZVAL_FALSE(retval);
return;
} else {
SEPARATE_ZVAL(tmp);
convert_to_binary_ex(tmp);
convert_to_string_ex(tmp);
}
} else {
if (Z_TYPE_PP(tmp) == IS_UNICODE) {
@ -1229,13 +1201,6 @@ PHPAPI void php_implode(zval *delim, zval *arr, zval *retval)
convert_to_unicode_ex(&retval);
convert_to_unicode_ex(&delim);
Z_TYPE_P(retval) = return_type = IS_UNICODE;
} else if (Z_TYPE_PP(tmp) == IS_BINARY) {
/* ERROR */
php_error_docref(NULL TSRMLS_CC, E_WARNING,
"Cannot mix binary strings with other string types");
efree(Z_STRVAL_P(retval));
ZVAL_FALSE(retval);
return;
} else {
SEPARATE_ZVAL(tmp);
convert_to_string_ex(tmp);
@ -1308,14 +1273,14 @@ PHP_FUNCTION(implode)
if (Z_TYPE_PP(arg1) == IS_ARRAY) {
SEPARATE_ZVAL(arg1);
arr = *arg1;
if (Z_TYPE_PP(arg2) != IS_UNICODE && Z_TYPE_PP(arg2) != IS_BINARY && Z_TYPE_PP(arg2) != IS_STRING) {
if (Z_TYPE_PP(arg2) != IS_UNICODE && Z_TYPE_PP(arg2) != IS_STRING) {
convert_to_text_ex(arg2);
}
delim = *arg2;
} else if (Z_TYPE_PP(arg2) == IS_ARRAY) {
SEPARATE_ZVAL(arg2);
arr = *arg2;
if (Z_TYPE_PP(arg1) != IS_UNICODE && Z_TYPE_PP(arg1) != IS_BINARY && Z_TYPE_PP(arg1) != IS_STRING) {
if (Z_TYPE_PP(arg1) != IS_UNICODE && Z_TYPE_PP(arg1) != IS_STRING) {
convert_to_text_ex(arg1);
}
delim = *arg1;
@ -1375,8 +1340,6 @@ PHP_FUNCTION(strtok)
MAKE_STD_ZVAL(zv);
if (str_type == IS_UNICODE) {
ZVAL_UNICODEL(zv, (UChar *)str, str_len, 1);
} else if (str_type == IS_BINARY) {
ZVAL_BINARYL(zv, (char *)str, str_len, 1);
} else {
ZVAL_STRINGL(zv, (char *)str, str_len, 1);
}
@ -1484,11 +1447,7 @@ PHP_FUNCTION(strtok)
if (p - (char *)BG(strtok_last)) {
return_token:
if (tok_type == IS_BINARY) {
RETVAL_BINARYL((char *)BG(strtok_last) + skipped, (p - (char *)BG(strtok_last)) - skipped, 1);
} else {
RETVAL_STRINGL((char *)BG(strtok_last) + skipped, (p - (char *)BG(strtok_last)) - skipped, 1);
}
RETVAL_STRINGL((char *)BG(strtok_last) + skipped, (p - (char *)BG(strtok_last)) - skipped, 1);
BG(strtok_last) = p + 1;
} else {
RETVAL_FALSE;
@ -1839,8 +1798,11 @@ PHP_FUNCTION(dirname)
ret = estrndup(Z_STRVAL_PP(str), Z_STRLEN_PP(str));
ret_len = php_dirname(ret, Z_STRLEN_PP(str));
RETURN_STRINGL(ret, ret_len, 0);
RETVAL_RT_STRINGL(ret, ret_len, 0);
if (UG(unicode)) {
efree(ret);
}
}
/* }}} */
@ -2070,11 +2032,11 @@ PHP_FUNCTION(stristr)
return;
}
if (Z_TYPE_P(haystack) != IS_UNICODE && Z_TYPE_P(haystack) != IS_BINARY && Z_TYPE_P(haystack) != IS_STRING) {
if (Z_TYPE_P(haystack) != IS_UNICODE && Z_TYPE_P(haystack) != IS_STRING) {
convert_to_text(haystack);
}
if (Z_TYPE_P(needle) == IS_UNICODE || Z_TYPE_P(needle) == IS_BINARY || Z_TYPE_P(needle) == IS_STRING) {
if (Z_TYPE_P(needle) == IS_UNICODE || Z_TYPE_P(needle) == IS_STRING) {
if (!Z_UNILEN_P(needle)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty delimiter.");
RETURN_FALSE;
@ -2082,12 +2044,10 @@ PHP_FUNCTION(stristr)
if (Z_TYPE_P(haystack) != Z_TYPE_P(needle)) {
str_type = zend_get_unified_string_type(2 TSRMLS_CC, Z_TYPE_P(haystack), Z_TYPE_P(needle));
if (str_type == (zend_uchar)-1) {
convert_to_explicit_type(haystack, IS_BINARY);
convert_to_explicit_type(needle, IS_BINARY);
} else {
convert_to_explicit_type(haystack, str_type);
convert_to_explicit_type(needle, str_type);
return;
}
convert_to_explicit_type(haystack, str_type);
convert_to_explicit_type(needle, str_type);
}
target = Z_UNIVAL_P(needle);
needle_len = Z_UNILEN_P(needle);
@ -2137,11 +2097,7 @@ PHP_FUNCTION(stristr)
found_offset = (char *)found - Z_STRVAL_P(haystack);
start = part ? haystack_copy : haystack_copy + found_offset;
end = part ? haystack_copy + found_offset : (haystack_copy + Z_STRLEN_P(haystack));
if (Z_TYPE_P(haystack) == IS_BINARY) {
RETVAL_BINARYL((char *)start, (char *)end-(char *)start, 1);
} else {
RETVAL_STRINGL((char *)start, (char *)end-(char *)start, 1);
}
RETVAL_STRINGL((char *)start, (char *)end-(char *)start, 1);
}
} else {
RETVAL_FALSE;
@ -2172,7 +2128,7 @@ PHP_FUNCTION(strstr)
return;
}
if (Z_TYPE_PP(needle) == IS_STRING || Z_TYPE_PP(needle) == IS_UNICODE || Z_TYPE_PP(needle) == IS_BINARY) {
if (Z_TYPE_PP(needle) == IS_STRING || Z_TYPE_PP(needle) == IS_UNICODE) {
if (!Z_STRLEN_PP(needle)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty delimiter.");
RETURN_FALSE;
@ -2251,19 +2207,6 @@ PHP_FUNCTION(strstr)
RETURN_STRINGL(found, haystack_len - found_offset, 1);
}
break;
case IS_BINARY:
found_offset = (char *)found - (char *)haystack;
if (part) {
char *ret;
ret = emalloc(found_offset + 1);
strncpy(ret, haystack, found_offset);
ret[found_offset] = '\0';
RETURN_BINARYL(ret , found_offset, 0);
} else {
RETURN_BINARYL(found, haystack_len - found_offset, 1);
}
break;
}
} else {
RETURN_FALSE;
@ -2304,7 +2247,7 @@ PHP_FUNCTION(strpos)
RETURN_FALSE;
}
if (Z_TYPE_PP(needle) == IS_STRING || Z_TYPE_PP(needle) == IS_UNICODE || Z_TYPE_PP(needle) == IS_BINARY) {
if (Z_TYPE_PP(needle) == IS_STRING || Z_TYPE_PP(needle) == IS_UNICODE) {
if (!Z_STRLEN_PP(needle)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty delimiter.");
RETURN_FALSE;
@ -2395,7 +2338,7 @@ PHP_FUNCTION(stripos)
return;
}
if (Z_TYPE_P(haystack) != IS_UNICODE && Z_TYPE_P(haystack) != IS_BINARY && Z_TYPE_P(haystack) != IS_STRING) {
if (Z_TYPE_P(haystack) != IS_UNICODE && Z_TYPE_P(haystack) != IS_STRING) {
convert_to_text(haystack);
}
if (offset < 0 || offset > Z_UNILEN_P(haystack)) {
@ -2404,19 +2347,17 @@ PHP_FUNCTION(stripos)
}
haystack_len = Z_UNILEN_P(haystack);
if (Z_TYPE_P(needle) == IS_UNICODE || Z_TYPE_P(needle) == IS_BINARY || Z_TYPE_P(needle) == IS_STRING) {
if (Z_TYPE_P(needle) == IS_UNICODE || Z_TYPE_P(needle) == IS_STRING) {
if (!Z_UNILEN_P(needle)) {
RETURN_FALSE;
}
if (Z_TYPE_P(haystack) != Z_TYPE_P(needle)) {
str_type = zend_get_unified_string_type(2 TSRMLS_CC, Z_TYPE_P(haystack), Z_TYPE_P(needle));
if (str_type == (zend_uchar)-1) {
convert_to_explicit_type(haystack, IS_BINARY);
convert_to_explicit_type(needle, IS_BINARY);
} else {
convert_to_explicit_type(haystack, str_type);
convert_to_explicit_type(needle, str_type);
return;
}
convert_to_explicit_type(haystack, str_type);
convert_to_explicit_type(needle, str_type);
}
needle_len = Z_UNILEN_P(needle);
if (Z_TYPE_P(haystack) == IS_UNICODE) {
@ -2519,19 +2460,17 @@ PHP_FUNCTION(strrpos)
RETURN_FALSE;
}
if (Z_TYPE_P(zhaystack) != IS_UNICODE && Z_TYPE_P(zhaystack) != IS_BINARY && Z_TYPE_P(zhaystack) != IS_STRING) {
if (Z_TYPE_P(zhaystack) != IS_UNICODE && Z_TYPE_P(zhaystack) != IS_STRING) {
convert_to_text(zhaystack);
}
if (Z_TYPE_P(zneedle) == IS_UNICODE || Z_TYPE_P(zneedle) == IS_BINARY || Z_TYPE_P(zneedle) == IS_STRING) {
if (Z_TYPE_P(zneedle) == IS_UNICODE || Z_TYPE_P(zneedle) == IS_STRING) {
if (Z_TYPE_P(zneedle) != Z_TYPE_P(zhaystack)) {
str_type = zend_get_unified_string_type(2 TSRMLS_CC, Z_TYPE_P(zhaystack), Z_TYPE_P(zneedle));
if (str_type == (zend_uchar)-1) {
convert_to_explicit_type(zhaystack, IS_BINARY);
convert_to_explicit_type(zneedle, IS_BINARY);
} else {
convert_to_explicit_type(zhaystack, str_type);
convert_to_explicit_type(zneedle, str_type);
return;
}
convert_to_explicit_type(zhaystack, str_type);
convert_to_explicit_type(zneedle, str_type);
}
needle = Z_UNIVAL_P(zneedle);
needle_len = Z_UNILEN_P(zneedle);
@ -2743,20 +2682,18 @@ PHP_FUNCTION(strrchr)
if (ZEND_NUM_ARGS() != 2 || zend_parse_parameters(2 TSRMLS_CC, "zz", &haystack, &needle) == FAILURE) {
WRONG_PARAM_COUNT;
}
if (Z_TYPE_P(haystack) != IS_UNICODE || Z_TYPE_P(haystack) != IS_BINARY || Z_TYPE_P(haystack) != IS_STRING) {
if (Z_TYPE_P(haystack) != IS_UNICODE || Z_TYPE_P(haystack) != IS_STRING) {
convert_to_string(haystack);
}
if (Z_TYPE_P(needle) == IS_UNICODE || Z_TYPE_P(needle) == IS_BINARY || Z_TYPE_P(needle) == IS_STRING) {
if (Z_TYPE_P(needle) == IS_UNICODE || Z_TYPE_P(needle) == IS_STRING) {
if (Z_TYPE_P(needle) != Z_TYPE_P(haystack)) {
str_type = zend_get_unified_string_type(2 TSRMLS_CC, Z_TYPE_P(haystack), Z_TYPE_P(needle));
if (str_type == (zend_uchar)-1) {
convert_to_explicit_type(haystack, IS_BINARY);
convert_to_explicit_type(needle, IS_BINARY);
} else {
convert_to_explicit_type(haystack, str_type);
convert_to_explicit_type(needle, str_type);
return;
}
convert_to_explicit_type(haystack, str_type);
convert_to_explicit_type(needle, str_type);
}
if (Z_TYPE_P(haystack) == IS_UNICODE) {
U16_GET(Z_USTRVAL_P(needle), 0, 0, Z_USTRLEN_P(needle), ch);
@ -2783,11 +2720,7 @@ PHP_FUNCTION(strrchr)
RETURN_UNICODEL((UChar *)found, Z_USTRLEN_P(haystack) - found_offset, 1);
} else {
found_offset = (char *)found - Z_STRVAL_P(haystack);
if (Z_TYPE_P(haystack) == IS_BINARY) {
RETURN_BINARYL((char *)found, Z_BINLEN_P(haystack) - found_offset, 1);
} else {
RETURN_STRINGL((char *)found, Z_STRLEN_P(haystack) - found_offset, 1);
}
RETURN_STRINGL((char *)found, Z_STRLEN_P(haystack) - found_offset, 1);
}
} else {
RETURN_FALSE;
@ -3069,11 +3002,11 @@ PHP_FUNCTION(substr_replace)
}
if (Z_TYPE_PP(str) != IS_ARRAY && Z_TYPE_PP(str) != IS_UNICODE &&
Z_TYPE_PP(str) != IS_BINARY && Z_TYPE_PP(str) != IS_STRING) {
Z_TYPE_PP(str) != IS_STRING) {
convert_to_text_ex(str);
}
if (Z_TYPE_PP(repl) != IS_ARRAY && Z_TYPE_PP(repl) != IS_UNICODE &&
Z_TYPE_PP(repl) != IS_BINARY && Z_TYPE_PP(repl) != IS_STRING) {
Z_TYPE_PP(repl) != IS_STRING) {
convert_to_text_ex(repl);
}
if (Z_TYPE_PP(from) != IS_ARRAY) {
@ -3111,7 +3044,7 @@ PHP_FUNCTION(substr_replace)
if (Z_TYPE_PP(repl) == IS_ARRAY) {
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(repl), &pos_repl);
if (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(repl), (void **) &tmp_repl, &pos_repl)) {
if (Z_TYPE_PP(repl) != IS_UNICODE && Z_TYPE_PP(repl) != IS_BINARY && Z_TYPE_PP(repl) != IS_STRING) {
if (Z_TYPE_PP(repl) != IS_UNICODE && Z_TYPE_PP(repl) != IS_STRING) {
convert_to_text_ex(tmp_repl);
}
} else {
@ -3124,20 +3057,16 @@ PHP_FUNCTION(substr_replace)
if (tmp_repl && Z_TYPE_PP(str) != Z_TYPE_PP(tmp_repl)) {
str_type = zend_get_unified_string_type(2 TSRMLS_CC, Z_TYPE_PP(str), Z_TYPE_PP(tmp_repl));
if (str_type == (zend_uchar)-1) {
convert_to_explicit_type_ex(str, IS_BINARY);
convert_to_explicit_type_ex(tmp_repl, IS_BINARY);
} else {
convert_to_explicit_type_ex(str, str_type);
convert_to_explicit_type_ex(tmp_repl, str_type);
return;
}
convert_to_explicit_type_ex(str, str_type);
convert_to_explicit_type_ex(tmp_repl, str_type);
}
php_adjust_limits(str, &f, &l);
result_len = php_do_substr_replace(&result, str, tmp_repl, f, l TSRMLS_CC);
if (Z_TYPE_PP(str) == IS_UNICODE) {
RETURN_UNICODEL((UChar *)result, result_len, 0);
} else if (Z_TYPE_PP(str) == IS_BINARY) {
RETURN_BINARYL((char *)result, result_len, 0);
} else {
RETURN_STRINGL((char *)result, result_len, 0);
}
@ -3160,7 +3089,7 @@ PHP_FUNCTION(substr_replace)
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(str), &pos_str);
while (zend_hash_get_current_data_ex(Z_ARRVAL_PP(str), (void **) &tmp_str, &pos_str) == SUCCESS) {
if (Z_TYPE_PP(tmp_str) != IS_UNICODE && Z_TYPE_PP(tmp_str) != IS_BINARY && Z_TYPE_PP(tmp_str) != IS_STRING) {
if (Z_TYPE_PP(tmp_str) != IS_UNICODE && Z_TYPE_PP(tmp_str) != IS_STRING && Z_TYPE_PP(tmp_str) != IS_STRING) {
convert_to_text_ex(tmp_str);
}
@ -3191,7 +3120,7 @@ PHP_FUNCTION(substr_replace)
if (Z_TYPE_PP(repl) == IS_ARRAY) {
if (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(repl), (void **) &tmp_repl, &pos_repl)) {
if (Z_TYPE_PP(repl) != IS_UNICODE && Z_TYPE_PP(repl) != IS_BINARY && Z_TYPE_PP(repl) != IS_STRING) {
if (Z_TYPE_PP(repl) != IS_UNICODE && Z_TYPE_PP(repl) != IS_STRING && Z_TYPE_PP(repl) != IS_STRING) {
convert_to_text_ex(tmp_repl);
}
zend_hash_move_forward_ex(Z_ARRVAL_PP(repl), &pos_repl);
@ -3205,20 +3134,16 @@ PHP_FUNCTION(substr_replace)
if (tmp_repl && Z_TYPE_PP(tmp_str) != Z_TYPE_PP(tmp_repl)) {
str_type = zend_get_unified_string_type(2 TSRMLS_CC, Z_TYPE_PP(tmp_str), Z_TYPE_PP(tmp_repl));
if (str_type == (zend_uchar)-1) {
convert_to_explicit_type_ex(tmp_str, IS_BINARY);
convert_to_explicit_type_ex(tmp_repl, IS_BINARY);
} else {
convert_to_explicit_type_ex(tmp_str, str_type);
convert_to_explicit_type_ex(tmp_repl, str_type);
return;
}
convert_to_explicit_type_ex(tmp_str, str_type);
convert_to_explicit_type_ex(tmp_repl, str_type);
}
php_adjust_limits(tmp_str, &f, &l);
result_len = php_do_substr_replace(&result, tmp_str, tmp_repl, f, l TSRMLS_CC);
if (Z_TYPE_PP(tmp_str) == IS_UNICODE) {
add_next_index_unicodel(return_value, (UChar *)result, result_len, 0);
} else if (Z_TYPE_PP(tmp_str) == IS_BINARY) {
add_next_index_binaryl(return_value, (char *)result, result_len, 0);
} else {
add_next_index_stringl(return_value, (char *)result, result_len, 0);
}
@ -3293,10 +3218,6 @@ PHP_FUNCTION(ord)
WRONG_PARAM_COUNT;
}
if (Z_TYPE_PP(str) == IS_BINARY) {
RETURN_LONG((unsigned char) Z_STRVAL_PP(str)[0]);
}
convert_to_text_ex(str);
if (Z_TYPE_PP(str) == IS_UNICODE) {
RETURN_LONG(zend_get_codepoint_at(Z_USTRVAL_PP(str), Z_USTRLEN_PP(str), 0));
@ -3380,14 +3301,12 @@ PHP_FUNCTION(ucfirst)
WRONG_PARAM_COUNT;
}
if (Z_TYPE_PP(str) != IS_UNICODE && Z_TYPE_PP(str) != IS_BINARY && Z_TYPE_PP(str) != IS_STRING) {
if (Z_TYPE_PP(str) != IS_UNICODE && Z_TYPE_PP(str) != IS_STRING) {
convert_to_text_ex(str);
}
if (Z_TYPE_PP(str) == IS_UNICODE && !Z_USTRLEN_PP(str)) {
RETURN_EMPTY_UNICODE();
} else if (Z_TYPE_PP(str) == IS_BINARY && !Z_BINLEN_PP(str)) {
RETURN_EMPTY_BINARY();
} else if (!Z_STRLEN_PP(str)) {
RETURN_EMPTY_STRING();
}
@ -3395,9 +3314,6 @@ PHP_FUNCTION(ucfirst)
if (Z_TYPE_PP(str) == IS_UNICODE) {
Z_TYPE_P(return_value) = IS_UNICODE;
php_u_ucfirst(*str, return_value);
} else if (Z_TYPE_PP(str) == IS_BINARY) {
ZVAL_BINARYL(return_value, Z_BINVAL_PP(str), Z_BINLEN_PP(str), 1);
*Z_BINVAL_P(return_value) = toupper((unsigned char) *Z_BINVAL_P(return_value));
} else {
ZVAL_STRINGL(return_value, Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);
*Z_STRVAL_P(return_value) = toupper((unsigned char) *Z_STRVAL_P(return_value));
@ -3463,14 +3379,12 @@ PHP_FUNCTION(ucwords)
WRONG_PARAM_COUNT;
}
if (Z_TYPE_PP(str) != IS_UNICODE && Z_TYPE_PP(str) != IS_BINARY && Z_TYPE_PP(str) != IS_STRING) {
if (Z_TYPE_PP(str) != IS_UNICODE && Z_TYPE_PP(str) != IS_STRING) {
convert_to_text_ex(str);
}
if (Z_TYPE_PP(str) == IS_UNICODE && !Z_USTRLEN_PP(str)) {
RETURN_EMPTY_UNICODE();
} else if (Z_TYPE_PP(str) == IS_BINARY && !Z_BINLEN_PP(str)) {
RETURN_EMPTY_BINARY();
} else if (!Z_STRLEN_PP(str)) {
RETURN_EMPTY_STRING();
}
@ -3479,11 +3393,7 @@ PHP_FUNCTION(ucwords)
Z_TYPE_P(return_value) = IS_UNICODE;
php_u_ucwords(*str, return_value);
} else {
if (Z_TYPE_PP(str) == IS_BINARY) {
ZVAL_BINARYL(return_value, Z_BINVAL_PP(str), Z_BINLEN_PP(str), 1);
} else {
ZVAL_STRINGL(return_value, Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);
}
ZVAL_STRINGL(return_value, Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);
r = Z_STRVAL_P(return_value);
*r = toupper((unsigned char) *r);
@ -3685,7 +3595,7 @@ PHP_FUNCTION(strrev)
WRONG_PARAM_COUNT;
}
if (Z_TYPE_PP(str) != IS_UNICODE && Z_TYPE_PP(str) != IS_BINARY && Z_TYPE_PP(str) != IS_STRING) {
if (Z_TYPE_PP(str) != IS_UNICODE && Z_TYPE_PP(str) != IS_STRING) {
convert_to_text_ex(str);
}
@ -3726,8 +3636,6 @@ PHP_FUNCTION(strrev)
if (Z_TYPE_PP(str) == IS_UNICODE) {
RETVAL_UNICODEL(u_n, Z_USTRLEN_PP(str), 0);
} else if (Z_TYPE_PP(str) == IS_BINARY) {
RETVAL_BINARYL(n, Z_BINLEN_PP(str), 0);
} else {
RETVAL_STRINGL(n, Z_STRLEN_PP(str), 0);
}
@ -3849,20 +3757,18 @@ PHP_FUNCTION(similar_text)
if (ac < 2 || ac > 3 || zend_get_parameters_ex(ac, &t1, &t2, &percent) == FAILURE) {
WRONG_PARAM_COUNT;
}
if (Z_TYPE_PP(t1) != IS_UNICODE && Z_TYPE_PP(t1) != IS_BINARY && Z_TYPE_PP(t1) != IS_STRING) {
if (Z_TYPE_PP(t1) != IS_UNICODE && Z_TYPE_PP(t1) != IS_STRING) {
convert_to_text_ex(t1);
}
if (Z_TYPE_PP(t2) != IS_UNICODE && Z_TYPE_PP(t2) != IS_BINARY && Z_TYPE_PP(t2) != IS_STRING) {
if (Z_TYPE_PP(t2) != IS_UNICODE && Z_TYPE_PP(t2) != IS_STRING) {
convert_to_text_ex(t2);
}
str_type = zend_get_unified_string_type(2 TSRMLS_CC, Z_TYPE_PP(t1), Z_TYPE_PP(t2));
if (str_type == (zend_uchar)-1) {
convert_to_binary_ex(t1);
convert_to_binary_ex(t2);
} else {
convert_to_explicit_type_ex(t1, str_type);
convert_to_explicit_type_ex(t2, str_type);
return;
}
convert_to_explicit_type_ex(t1, str_type);
convert_to_explicit_type_ex(t2, str_type);
if (ac > 2) {
convert_to_double_ex(percent);
}
@ -4067,8 +3973,6 @@ PHP_FUNCTION(addslashes)
if (Z_TYPE_PP(str) == IS_UNICODE && Z_USTRLEN_PP(str) == 0) {
RETURN_EMPTY_UNICODE();
} else if (Z_TYPE_PP(str) == IS_BINARY && Z_BINLEN_PP(str) == 0) {
RETURN_EMPTY_BINARY();
} else if (Z_TYPE_PP(str) == IS_STRING && Z_STRLEN_PP(str) == 0) {
RETURN_EMPTY_STRING();
}
@ -4080,11 +3984,7 @@ PHP_FUNCTION(addslashes)
} else {
tmp = (char *)php_addslashes(Z_STRVAL_PP(str), Z_STRLEN_PP(str),
&tmp_len, 0 TSRMLS_CC);
if (Z_TYPE_PP(str) == IS_BINARY) {
RETURN_BINARYL((char *)tmp, tmp_len, 0);
} else {
RETURN_STRINGL((char *)tmp, tmp_len, 0);
}
RETURN_STRINGL((char *)tmp, tmp_len, 0);
}
}
/* }}} */
@ -4120,11 +4020,7 @@ PHP_FUNCTION(stripslashes)
ZVAL_UNICODEL(return_value, Z_USTRVAL_PP(str), Z_USTRLEN_PP(str), 1);
php_u_stripslashes(Z_USTRVAL_P(return_value), &Z_USTRLEN_P(return_value) TSRMLS_CC);
} else {
if (Z_TYPE_PP(str) == IS_BINARY) {
ZVAL_BINARYL(return_value, Z_BINVAL_PP(str), Z_BINLEN_PP(str), 1);
} else {
ZVAL_STRINGL(return_value, Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);
}
ZVAL_STRINGL(return_value, Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);
php_stripslashes(Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value) TSRMLS_CC);
}
}
@ -5146,11 +5042,7 @@ PHP_FUNCTION(strip_tags)
} else {
buf = estrndup(str, str_len);
retval_len = php_strip_tags((char *)buf, str_len, NULL, (char *)allow, allow_len);
if (str_type == IS_BINARY) {
RETURN_BINARYL((char *)buf, retval_len, 0);
} else {
RETURN_STRINGL((char *)buf, retval_len, 0);
}
RETURN_STRINGL((char *)buf, retval_len, 0);
}
}
/* }}} */
@ -5905,10 +5797,8 @@ PHP_FUNCTION(str_repeat)
if ( input_str_chars == 0 || mult == 0 ) {
if ( input_str_type == IS_UNICODE ) {
RETURN_UNICODEL(USTR_MAKE(""), 0, 0);
} else if ( input_str_type == IS_STRING ) {
RETURN_STRINGL("", 0, 1);
} else {
RETURN_BINARYL("", 0, 1);
RETURN_STRINGL("", 0, 1);
}
}
@ -5958,11 +5848,7 @@ PHP_FUNCTION(str_repeat)
RETURN_UNICODEL((UChar *)result, result_chars-1, 0);
} else {
*(((char *)result)+result_chars-1) = '\0';
if ( input_str_type == IS_BINARY ) {
RETURN_BINARYL((char *)result, result_chars-1, 0);
} else {
RETURN_STRINGL((char *)result, result_chars-1, 0);
}
RETURN_STRINGL((char *)result, result_chars-1, 0);
}
}
/* }}} */
@ -6306,8 +6192,6 @@ PHP_FUNCTION(str_pad)
if (num_pad_chars < 0) {
if (input_type == IS_UNICODE) {
RETURN_UNICODEL((UChar *)input, input_len, 1);
} else if (input_type == IS_BINARY) {
RETURN_BINARYL((char *)input, input_len, 1);
} else {
RETURN_STRINGL((char *)input, input_len, 1);
}
@ -6396,8 +6280,6 @@ PHP_FUNCTION(str_pad)
efree(padstr);
}
RETURN_UNICODEL((UChar *)result, result_len, 0);
} else if (input_type == IS_BINARY) {
RETURN_BINARYL((char *)result, result_len, 0);
} else {
RETURN_STRINGL((char *)result, result_len, 0);
}
@ -6683,8 +6565,6 @@ PHP_FUNCTION(strpbrk)
if (p) {
if (haystack_type == IS_UNICODE) {
RETURN_UNICODEL((UChar *)p, ((UChar *)haystack + haystack_len - (UChar *)p), 1);
} else if (haystack_type == IS_BINARY) {
RETURN_BINARYL((char *)p, ((char *)haystack + haystack_len - (char *)p), 1);
} else {
RETURN_STRINGL((char *)p, ((char *)haystack + haystack_len - (char *)p), 1);
}

33
ext/standard/tests/general_functions/008.phpt
View File

@ -37,4 +37,35 @@ array(14) {
float(1234567890120)
[13]=>
float(1.23456789012E+19)
}
}
--UEXPECT--
array(14) {
[0]=>
unicode(2) "12"
[1]=>
float(0.012)
[2]=>
float(-0.012)
[3]=>
float(0.12)
[4]=>
float(-0.12)
[5]=>
float(1.2)
[6]=>
float(-1.2)
[7]=>
float(12)
[8]=>
float(-12)
[9]=>
float(0.000123)
[10]=>
float(1.23E-5)
[11]=>
float(123456789012)
[12]=>
float(1234567890120)
[13]=>
float(1.23456789012E+19)
}

3
ext/standard/tests/math/bug21523.phpt
View File

@ -9,3 +9,6 @@ echo "OK";
--EXPECT--
string(2775) "-2,000.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
OK
--UEXPECT--
unicode(2775) "-2,000.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
OK

3
ext/standard/tests/strings/bug22187.phpt
View File

@ -8,3 +8,6 @@ Bug #22187 (possible crash in number_format() function)
--EXPECT--
string(3) "0.0"
string(1) "0"
--UEXPECT--
unicode(3) "0.0"
unicode(1) "0"

9
ext/standard/tests/strings/strval.phpt
View File

@ -22,3 +22,12 @@ string(3) "1.1"
string(1) "1"
string(0) ""
string(5) "Array"
--UEXPECT--
unicode(3) "bar"
unicode(3) "BAR"
unicode(6) "foobar"
unicode(1) "1"
unicode(3) "1.1"
unicode(1) "1"
unicode(0) ""
unicode(5) "Array"

21
ext/standard/type.c
View File

@ -52,10 +52,6 @@ PHP_FUNCTION(gettype)
RETVAL_ASCII_STRING("string", 1);
break;
case IS_BINARY:
RETVAL_ASCII_STRING("binary", 1);
break;
case IS_UNICODE:
RETVAL_ASCII_STRING("unicode", 1);
break;
@ -199,7 +195,11 @@ PHP_FUNCTION(strval)
WRONG_PARAM_COUNT;
}
zend_make_printable_zval(*num, &expr_copy, &use_copy);
if (UG(unicode)) {
zend_make_unicode_zval(*num, &expr_copy, &use_copy);
} else {
zend_make_printable_zval(*num, &expr_copy, &use_copy);
}
if (use_copy) {
tmp = &expr_copy;
RETVAL_ZVAL(tmp, 0, 0);
@ -300,14 +300,6 @@ PHP_FUNCTION(is_unicode)
}
/* }}} */
/* {{{ proto bool is_binary(mixed var)
Returns true if variable is a binary string */
PHP_FUNCTION(is_binary)
{
php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_BINARY);
}
/* }}} */
/* {{{ proto bool is_buffer(mixed var)
Returns true if variable is a native, unicode or binary string */
PHP_FUNCTION(is_buffer)
@ -319,7 +311,7 @@ PHP_FUNCTION(is_buffer)
RETURN_FALSE;
}
if (Z_TYPE_PP(arg) == IS_STRING || Z_TYPE_PP(arg) == IS_UNICODE || Z_TYPE_PP(arg) == IS_BINARY) {
if (Z_TYPE_PP(arg) == IS_STRING || Z_TYPE_PP(arg) == IS_UNICODE) {
RETURN_TRUE;
}
RETURN_FALSE;
@ -399,7 +391,6 @@ PHP_FUNCTION(is_scalar)
case IS_DOUBLE:
case IS_LONG:
case IS_STRING:
case IS_BINARY:
case IS_UNICODE:
RETURN_TRUE;
break;

17
ext/standard/user_filters.c
View File

@ -122,7 +122,7 @@ static void userfilter_dtor(php_stream_filter *thisfilter TSRMLS_DC)
return;
}
ZVAL_STRINGL(&func_name, "onclose", sizeof("onclose")-1, 0);
ZVAL_ASCII_STRINGL(&func_name, "onclose", sizeof("onclose")-1, 1);
call_user_function_ex(NULL,
&obj,
@ -130,6 +130,7 @@ static void userfilter_dtor(php_stream_filter *thisfilter TSRMLS_DC)
&retval,
0, NULL,
0, NULL TSRMLS_CC);
zval_dtor(&func_name);
if (retval)
zval_ptr_dtor(&retval);
@ -164,7 +165,7 @@ php_stream_filter_status_t userfilter_filter(
zval_ptr_dtor(&zstream);
}
ZVAL_STRINGL(&func_name, "filter", sizeof("filter")-1, 0);
ZVAL_ASCII_STRINGL(&func_name, "filter", sizeof("filter")-1, 1);
/* Setup calling arguments */
ALLOC_INIT_ZVAL(zin);
@ -189,6 +190,7 @@ php_stream_filter_status_t userfilter_filter(
&retval,
4, args,
0, NULL TSRMLS_CC);
zval_dtor(&func_name);
if (call_result == SUCCESS && retval != NULL) {
convert_to_long(retval);
@ -304,7 +306,7 @@ static php_stream_filter *user_filter_factory_create(const char *filtername,
}
/* invoke the constructor */
ZVAL_STRINGL(&func_name, "oncreate", sizeof("oncreate")-1, 0);
ZVAL_ASCII_STRINGL(&func_name, "oncreate", sizeof("oncreate")-1, 1);
call_user_function_ex(NULL,
&obj,
@ -312,6 +314,7 @@ static php_stream_filter *user_filter_factory_create(const char *filtername,
&retval,
0, NULL,
0, NULL TSRMLS_CC);
zval_dtor(&func_name);
if (retval) {
if (Z_TYPE_P(retval) == IS_BOOL && Z_LVAL_P(retval) == 0) {
@ -374,12 +377,8 @@ PHP_FUNCTION(stream_bucket_make_writeable)
/* add_property_zval increments the refcount which is unwanted here */
zval_ptr_dtor(&zbucket);
if (bucket->is_unicode) {
zval *unicode_data;
ALLOC_INIT_ZVAL(unicode_data);
ZVAL_UNICODEL(unicode_data, bucket->buf.ustr.val, bucket->buf.ustr.len, 1);
add_property_zval(return_value, "data", unicode_data);
add_property_long(return_value, "datalen", bucket->buf.str.len);
add_property_unicodel(return_value, "data", bucket->buf.ustr.val, bucket->buf.ustr.len, 1);
add_property_long(return_value, "datalen", bucket->buf.ustr.len);
} else {
add_property_stringl(return_value, "data", bucket->buf.str.val, bucket->buf.str.len, 1);
add_property_long(return_value, "datalen", bucket->buf.str.len);

40
ext/standard/var.c
View File

@ -132,10 +132,6 @@ static int php_array_element_dump(zval **zv, int num_args, va_list args, zend_ha
php_printf("\"");
PHPWRITE(hash_key->u.string, hash_key->nKeyLength - 1);
php_printf("\"");
} else if (hash_key->type == IS_BINARY) {
php_printf("b\"");
PHPWRITE(hash_key->u.string, hash_key->nKeyLength - 1);
php_printf("\"");
} else if (hash_key->type == IS_UNICODE) {
php_printf("u");
php_var_dump_unicode(hash_key->u.unicode, hash_key->nKeyLength-1, verbose, "\"", 0 TSRMLS_CC);
@ -209,11 +205,6 @@ PHPAPI void php_var_dump(zval **struc, int level, int verbose TSRMLS_DC)
PHPWRITE(Z_STRVAL_PP(struc), Z_STRLEN_PP(struc));
PUTS("\"\n");
break;
case IS_BINARY:
php_printf("%sbinary(%d) \"", COMMON, Z_STRLEN_PP(struc));
PHPWRITE(Z_STRVAL_PP(struc), Z_STRLEN_PP(struc));
PUTS("\"\n");
break;
case IS_UNICODE:
php_printf("%sunicode(%d) ", COMMON, u_countChar32((*struc)->value.ustr.val, (*struc)->value.ustr.len));
php_var_dump_unicode((*struc)->value.ustr.val, (*struc)->value.ustr.len, verbose, "\"", 0 TSRMLS_CC);
@ -337,10 +328,6 @@ static int zval_array_element_dump(zval **zv, int num_args, va_list args, zend_h
php_printf("\"");
PHPWRITE(hash_key->u.string, hash_key->nKeyLength - 1);
php_printf("\"");
} else if (hash_key->type == IS_BINARY) {
php_printf("b\"");
PHPWRITE(hash_key->u.string, hash_key->nKeyLength - 1);
php_printf("\"");
} else if (hash_key->type == IS_UNICODE) {
php_printf("u");
php_var_dump_unicode(hash_key->u.unicode, hash_key->nKeyLength-1, 1, "\"", 0 TSRMLS_CC);
@ -380,11 +367,6 @@ PHPAPI void php_debug_zval_dump(zval **struc, int level, int verbose TSRMLS_DC)
PHPWRITE(Z_STRVAL_PP(struc), Z_STRLEN_PP(struc));
php_printf("\" refcount(%u)\n", Z_REFCOUNT_PP(struc));
break;
case IS_BINARY:
php_printf("%sbinary(%d) \"", COMMON, Z_STRLEN_PP(struc));
PHPWRITE(Z_STRVAL_PP(struc), Z_STRLEN_PP(struc));
php_printf("\" refcount(%u)\n", Z_REFCOUNT_PP(struc));
break;
case IS_UNICODE:
php_printf("%sunicode(%d) ", COMMON, u_countChar32((*struc)->value.ustr.val, (*struc)->value.ustr.len));
php_var_dump_unicode((*struc)->value.ustr.val, (*struc)->value.ustr.len, verbose, "\"", 0 TSRMLS_CC);
@ -525,8 +507,6 @@ PHPAPI void php_var_export(zval **struc, int level TSRMLS_DC)
case IS_DOUBLE:
php_printf("%.*G", (int) EG(precision), Z_DVAL_PP(struc));
break;
case IS_BINARY:
PUTS ("b");
case IS_STRING:
tmp_str = php_addcslashes(Z_STRVAL_PP(struc), Z_STRLEN_PP(struc), &tmp_len, 0, "'\\", 2 TSRMLS_CC);
PUTS ("'");
@ -657,15 +637,6 @@ static inline void php_var_serialize_string(smart_str *buf, char *str, int len)
smart_str_appendl(buf, "\";", 2);
}
static inline void php_var_serialize_binary(smart_str *buf, char *str, int len)
{
smart_str_appendl(buf, "B:", 2);
smart_str_append_long(buf, len);
smart_str_appendl(buf, ":\"", 2);
smart_str_appendl(buf, str, len);
smart_str_appendl(buf, "\";", 2);
}
static inline void php_var_serialize_ustr(smart_str *buf, UChar *ustr, int len)
{
static const char hex[] = "0123456789abcdef";
@ -874,10 +845,6 @@ static void php_var_serialize_intern(smart_str *buf, zval **struc, HashTable *va
php_var_serialize_string(buf, Z_STRVAL_PP(struc), Z_STRLEN_PP(struc));
return;
case IS_BINARY:
php_var_serialize_binary(buf, Z_STRVAL_PP(struc), Z_STRLEN_PP(struc));
return;
case IS_UNICODE:
php_var_serialize_unicode(buf, Z_USTRVAL_PP(struc), Z_USTRLEN_PP(struc));
return;
@ -920,10 +887,10 @@ static void php_var_serialize_intern(smart_str *buf, zval **struc, HashTable *va
if (ce && ce != PHP_IC_ENTRY &&
zend_hash_exists(&ce->function_table, "__sleep", sizeof("__sleep"))) {
INIT_PZVAL(&fname);
ZVAL_STRINGL(&fname, "__sleep", sizeof("__sleep") - 1, 0);
ZVAL_ASCII_STRINGL(&fname, "__sleep", sizeof("__sleep") - 1, 1);
res = call_user_function_ex(CG(function_table), struc, &fname,
&retval_ptr, 0, 0, 1, NULL TSRMLS_CC);
zval_dtor(&fname);
if (res == SUCCESS && !EG(exception)) {
if (retval_ptr) {
if (HASH_OF(retval_ptr)) {
@ -990,9 +957,6 @@ static void php_var_serialize_intern(smart_str *buf, zval **struc, HashTable *va
case HASH_KEY_IS_STRING:
php_var_serialize_string(buf, key, key_len - 1);
break;
case HASH_KEY_IS_BINARY:
php_var_serialize_binary(buf, key, key_len - 1);
break;
case HASH_KEY_IS_UNICODE:
php_var_serialize_unicode(buf, (UChar*)key, key_len - 1);
break;

3
ext/standard/var_unserializer.re
View File

@ -332,8 +332,9 @@ static inline int object_common2(UNSERIALIZE_PARAMETER, long elements)
if (Z_OBJCE_PP(rval) != PHP_IC_ENTRY &&
zend_hash_exists(&Z_OBJCE_PP(rval)->function_table, "__wakeup", sizeof("__wakeup"))) {
INIT_PZVAL(&fname);
ZVAL_STRINGL(&fname, "__wakeup", sizeof("__wakeup") - 1, 0);
ZVAL_ASCII_STRINGL(&fname, "__wakeup", sizeof("__wakeup") - 1, 1);
call_user_function_ex(CG(function_table), rval, &fname, &retval_ptr, 0, 0, 1, NULL TSRMLS_CC);
zval_dtor(&fname);
}
if (retval_ptr)

186
ext/tokenizer/tests/002.phpt
View File

@ -24,35 +24,35 @@ array(49) {
[0]=>
array(2) {
[0]=>
int(369)
int(368)
[1]=>
string(2) "<?"
}
[1]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[2]=>
array(2) {
[0]=>
int(318)
int(317)
[1]=>
string(4) "echo"
}
[3]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[4]=>
array(2) {
[0]=>
int(307)
int(306)
[1]=>
string(1) "1"
}
@ -61,21 +61,21 @@ array(49) {
[6]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[7]=>
array(2) {
[0]=>
int(303)
int(302)
[1]=>
string(2) "if"
}
[8]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
@ -84,7 +84,7 @@ array(49) {
[10]=>
array(2) {
[0]=>
int(351)
int(350)
[1]=>
string(5) "isset"
}
@ -93,7 +93,7 @@ array(49) {
[12]=>
array(2) {
[0]=>
int(311)
int(310)
[1]=>
string(2) "$a"
}
@ -104,7 +104,7 @@ array(49) {
[15]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
@ -118,14 +118,14 @@ array(49) {
[17]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[18]=>
array(2) {
[0]=>
int(311)
int(310)
[1]=>
string(2) "$a"
}
@ -134,7 +134,7 @@ array(49) {
[20]=>
array(2) {
[0]=>
int(307)
int(306)
[1]=>
string(1) "1"
}
@ -143,21 +143,21 @@ array(49) {
[22]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[23]=>
array(2) {
[0]=>
int(311)
int(310)
[1]=>
string(2) "$a"
}
[24]=>
array(2) {
[0]=>
int(299)
int(298)
[1]=>
string(2) "++"
}
@ -166,21 +166,21 @@ array(49) {
[26]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[27]=>
array(2) {
[0]=>
int(311)
int(310)
[1]=>
string(2) "$a"
}
[28]=>
array(2) {
[0]=>
int(298)
int(297)
[1]=>
string(2) "--"
}
@ -189,21 +189,21 @@ array(49) {
[30]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[31]=>
array(2) {
[0]=>
int(311)
int(310)
[1]=>
string(2) "$a"
}
[32]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
@ -217,14 +217,14 @@ array(49) {
[34]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[35]=>
array(2) {
[0]=>
int(307)
int(306)
[1]=>
string(1) "2"
}
@ -233,21 +233,21 @@ array(49) {
[37]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[38]=>
array(2) {
[0]=>
int(311)
int(310)
[1]=>
string(2) "$a"
}
[39]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
@ -261,14 +261,14 @@ array(49) {
[41]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[42]=>
array(2) {
[0]=>
int(307)
int(306)
[1]=>
string(1) "2"
}
@ -277,14 +277,14 @@ array(49) {
[44]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[45]=>
array(2) {
[0]=>
int(306)
int(305)
[1]=>
string(5) "endif"
}
@ -293,14 +293,14 @@ array(49) {
[47]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[48]=>
array(2) {
[0]=>
int(371)
int(370)
[1]=>
string(2) "?>"
}
@ -309,14 +309,14 @@ array(37) {
[0]=>
array(2) {
[0]=>
int(369)
int(368)
[1]=>
string(6) "<?php "
}
[1]=>
array(2) {
[0]=>
int(329)
int(328)
[1]=>
string(6) "switch"
}
@ -325,7 +325,7 @@ array(37) {
[3]=>
array(2) {
[0]=>
int(311)
int(310)
[1]=>
string(2) "$a"
}
@ -334,7 +334,7 @@ array(37) {
[5]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
@ -343,28 +343,28 @@ array(37) {
[7]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[8]=>
array(2) {
[0]=>
int(331)
int(330)
[1]=>
string(4) "case"
}
[9]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[10]=>
array(2) {
[0]=>
int(307)
int(306)
[1]=>
string(1) "1"
}
@ -373,14 +373,14 @@ array(37) {
[12]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[13]=>
array(2) {
[0]=>
int(333)
int(332)
[1]=>
string(5) "break"
}
@ -389,14 +389,14 @@ array(37) {
[15]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[16]=>
array(2) {
[0]=>
int(332)
int(331)
[1]=>
string(7) "default"
}
@ -405,14 +405,14 @@ array(37) {
[18]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[19]=>
array(2) {
[0]=>
int(333)
int(332)
[1]=>
string(5) "break"
}
@ -421,7 +421,7 @@ array(37) {
[21]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
@ -430,14 +430,14 @@ array(37) {
[23]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[24]=>
array(2) {
[0]=>
int(320)
int(319)
[1]=>
string(5) "while"
}
@ -446,7 +446,7 @@ array(37) {
[26]=>
array(2) {
[0]=>
int(311)
int(310)
[1]=>
string(2) "$a"
}
@ -455,7 +455,7 @@ array(37) {
[28]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
@ -464,14 +464,14 @@ array(37) {
[30]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[31]=>
array(2) {
[0]=>
int(302)
int(301)
[1]=>
string(4) "exit"
}
@ -480,7 +480,7 @@ array(37) {
[33]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
@ -489,14 +489,14 @@ array(37) {
[35]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[36]=>
array(2) {
[0]=>
int(371)
int(370)
[1]=>
string(2) "?>"
}
@ -505,42 +505,42 @@ array(48) {
[0]=>
array(2) {
[0]=>
int(369)
int(368)
[1]=>
string(2) "<?"
}
[1]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[2]=>
array(2) {
[0]=>
int(367)
int(366)
[1]=>
string(13) "/* comment */"
}
[3]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[4]=>
array(2) {
[0]=>
int(303)
int(302)
[1]=>
string(2) "if"
}
[5]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
@ -549,14 +549,14 @@ array(48) {
[7]=>
array(2) {
[0]=>
int(307)
int(306)
[1]=>
string(1) "1"
}
[8]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
@ -570,14 +570,14 @@ array(48) {
[10]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[11]=>
array(2) {
[0]=>
int(307)
int(306)
[1]=>
string(1) "2"
}
@ -586,7 +586,7 @@ array(48) {
[13]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
@ -595,7 +595,7 @@ array(48) {
[15]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
@ -604,21 +604,21 @@ array(48) {
[17]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[18]=>
array(2) {
[0]=>
int(311)
int(310)
[1]=>
string(2) "$a"
}
[19]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
@ -627,21 +627,21 @@ array(48) {
[21]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[22]=>
array(2) {
[0]=>
int(307)
int(306)
[1]=>
string(1) "2"
}
[23]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
@ -650,14 +650,14 @@ array(48) {
[25]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[26]=>
array(2) {
[0]=>
int(307)
int(306)
[1]=>
string(1) "1"
}
@ -666,21 +666,21 @@ array(48) {
[28]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[29]=>
array(2) {
[0]=>
int(311)
int(310)
[1]=>
string(2) "$b"
}
[30]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
@ -689,14 +689,14 @@ array(48) {
[32]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[33]=>
array(2) {
[0]=>
int(307)
int(306)
[1]=>
string(1) "3"
}
@ -705,7 +705,7 @@ array(48) {
[35]=>
array(2) {
[0]=>
int(307)
int(306)
[1]=>
string(1) "2"
}
@ -714,21 +714,21 @@ array(48) {
[37]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[38]=>
array(2) {
[0]=>
int(311)
int(310)
[1]=>
string(2) "$c"
}
[39]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
@ -737,14 +737,14 @@ array(48) {
[41]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[42]=>
array(2) {
[0]=>
int(307)
int(306)
[1]=>
string(1) "4"
}
@ -753,7 +753,7 @@ array(48) {
[44]=>
array(2) {
[0]=>
int(307)
int(306)
[1]=>
string(1) "2"
}
@ -762,14 +762,14 @@ array(48) {
[46]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) " "
}
[47]=>
array(2) {
[0]=>
int(371)
int(370)
[1]=>
string(2) "?>"
}
@ -778,7 +778,7 @@ array(1) {
[0]=>
array(2) {
[0]=>
int(313)
int(312)
[1]=>
string(17) "wrong syntax here"
}

4
ext/tokenizer/tests/003.phpt
View File

@ -25,7 +25,7 @@ array(1) {
[0]=>
array(2) {
[0]=>
int(313)
int(312)
[1]=>
string(1) "0"
}
@ -34,7 +34,7 @@ array(1) {
[0]=>
array(2) {
[0]=>
int(313)
int(312)
[1]=>
string(2) "-1"
}

30
ext/tokenizer/tests/bug26463.phpt
View File

@ -15,12 +15,12 @@ DDDD;
?>';
var_dump(token_get_all($str));
?>
--EXPECTF--
--EXPECT--
array(19) {
[0]=>
array(2) {
[0]=>
int(369)
int(368)
[1]=>
string(6) "<?php
"
@ -28,7 +28,7 @@ array(19) {
[1]=>
array(2) {
[0]=>
int(311)
int(310)
[1]=>
string(2) "$x"
}
@ -37,7 +37,7 @@ array(19) {
[3]=>
array(2) {
[0]=>
int(373)
int(372)
[1]=>
string(6) "<<<DD
"
@ -45,7 +45,7 @@ array(19) {
[4]=>
array(2) {
[0]=>
int(309)
int(308)
[1]=>
string(13) "jhdsjkfhjdsh
"
@ -53,14 +53,14 @@ array(19) {
[5]=>
array(2) {
[0]=>
int(374)
int(373)
[1]=>
string(2) "DD"
}
[6]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) "
"
@ -70,7 +70,7 @@ array(19) {
[8]=>
array(2) {
[0]=>
int(317)
int(316)
[1]=>
string(2) """"
}
@ -79,7 +79,7 @@ array(19) {
[10]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) "
"
@ -87,7 +87,7 @@ array(19) {
[11]=>
array(2) {
[0]=>
int(311)
int(310)
[1]=>
string(2) "$a"
}
@ -96,7 +96,7 @@ array(19) {
[13]=>
array(2) {
[0]=>
int(373)
int(372)
[1]=>
string(8) "<<<DDDD
"
@ -104,7 +104,7 @@ array(19) {
[14]=>
array(2) {
[0]=>
int(309)
int(308)
[1]=>
string(13) "jhdsjkfhjdsh
"
@ -112,7 +112,7 @@ array(19) {
[15]=>
array(2) {
[0]=>
int(374)
int(373)
[1]=>
string(4) "DDDD"
}
@ -121,7 +121,7 @@ array(19) {
[17]=>
array(2) {
[0]=>
int(372)
int(371)
[1]=>
string(1) "
"
@ -129,7 +129,7 @@ array(19) {
[18]=>
array(2) {
[0]=>
int(371)
int(370)
[1]=>
string(2) "?>"
}

4
ext/xml/xml.c
View File

@ -388,7 +388,9 @@ static void xml_set_handler(zval **handler, zval **data)
/* IS_ARRAY might indicate that we're using array($obj, 'method') syntax */
if (Z_TYPE_PP(data) != IS_ARRAY) {
convert_to_string_ex(data);
TSRMLS_FETCH();
convert_to_text_ex(data);
}
zval_add_ref(data);

6
main/main.c
View File

@ -694,7 +694,7 @@ PHPAPI void php_verror(const char *docref, const char *params, int type, const c
if (PG(track_errors) && module_initialized && EG(active_symbol_table)) {
zval *tmp;
ALLOC_INIT_ZVAL(tmp);
ZVAL_STRINGL(tmp, buffer, buffer_len, 1);
ZVAL_RT_STRINGL(tmp, buffer, buffer_len, 1);
zend_hash_update(EG(active_symbol_table), "php_errormsg", sizeof("php_errormsg"), (void **) &tmp, sizeof(zval *), NULL);
}
efree(buffer);
@ -963,9 +963,7 @@ static void php_error_cb(int type, const char *error_filename, const uint error_
ALLOC_ZVAL(tmp);
INIT_PZVAL(tmp);
Z_STRVAL_P(tmp) = (char *) estrndup(buffer, buffer_len);
Z_STRLEN_P(tmp) = buffer_len;
Z_TYPE_P(tmp) = IS_STRING;
ZVAL_RT_STRINGL(tmp, buffer, buffer_len, 1);
zend_hash_update(EG(active_symbol_table), "php_errormsg", sizeof("php_errormsg"), (void **) & tmp, sizeof(zval *), NULL);
}
efree(buffer);

4
main/output.c
View File

@ -226,7 +226,7 @@ PHPAPI void php_end_ob_buffer(zend_bool send_buffer, zend_bool just_flush TSRMLS
zval *z_status;
ALLOC_INIT_ZVAL(orig_buffer);
ZVAL_STRINGL(orig_buffer, OG(active_ob_buffer).buffer, OG(active_ob_buffer).text_length, 1);
ZVAL_U_STRINGL(ZEND_U_CONVERTER(UG(output_encoding_conv)), orig_buffer, OG(active_ob_buffer).buffer, OG(active_ob_buffer).text_length, 1);
orig_buffer->refcount=2; /* don't let call_user_function() destroy our buffer */
orig_buffer->is_ref=1;
@ -704,7 +704,7 @@ PHPAPI int php_ob_get_buffer(zval *p TSRMLS_DC)
if (OG(ob_nesting_level)==0) {
return FAILURE;
}
ZVAL_STRINGL(p, OG(active_ob_buffer).buffer, OG(active_ob_buffer).text_length, 1);
ZVAL_U_STRINGL(ZEND_U_CONVERTER(UG(output_encoding_conv)), p, OG(active_ob_buffer).buffer, OG(active_ob_buffer).text_length, 1);
return SUCCESS;
}
/* }}} */

4
main/php_variables.c
View File

@ -679,9 +679,7 @@ static void php_build_argv(char *s, zval *track_vars_array TSRMLS_DC)
int i;
for (i = 0; i < SG(request_info).argc; i++) {
ALLOC_ZVAL(tmp);
Z_TYPE_P(tmp) = IS_STRING;
Z_STRLEN_P(tmp) = strlen(SG(request_info).argv[i]);
Z_STRVAL_P(tmp) = estrndup(SG(request_info).argv[i], Z_STRLEN_P(tmp));
ZVAL_RT_STRING(tmp, SG(request_info).argv[i], 1);
INIT_PZVAL(tmp);
if (zend_hash_next_index_insert(Z_ARRVAL_P(arr), &tmp, sizeof(zval *), NULL) == FAILURE) {
if (Z_TYPE_P(tmp) == IS_STRING) {

3
main/streams/plain_wrapper.c
View File

@ -993,8 +993,9 @@ static int php_plain_files_unlink(php_stream_wrapper *wrapper, char *url, int op
return 0;
}
/* Clear stat cache */
ZVAL_STRINGL(&funcname, "clearstatcache", sizeof("clearstatcache")-1, 0);
ZVAL_ASCII_STRINGL(&funcname, "clearstatcache", sizeof("clearstatcache")-1, 1);
call_user_function_ex(CG(function_table), NULL, &funcname, &retval, 0, NULL, 0, NULL TSRMLS_CC);
zval_dtor(&funcname);
if (retval) {
zval_ptr_dtor(&retval);
}

4
run-tests.php
View File

@ -1077,8 +1077,8 @@ TEST $file
$exp_filename = $temp_dir . DIRECTORY_SEPARATOR . basename($file,'phpt').$pu.'exp';
$output_filename = $temp_dir . DIRECTORY_SEPARATOR . basename($file,'phpt').$pu.'out';
$memcheck_filename = $temp_dir . DIRECTORY_SEPARATOR . basename($file,'phpt').$pu.'mem';
$temp_file = $temp_dir . DIRECTORY_SEPARATOR . basename($file,'phpt').$pu.'php';
$test_file = $test_dir . DIRECTORY_SEPARATOR . basename($file,'phpt').$pu.'php';
$temp_file = $temp_dir . DIRECTORY_SEPARATOR . basename($file,'phpt')/*.$pu*/.'php';
$test_file = $test_dir . DIRECTORY_SEPARATOR . basename($file,'phpt')/*.$pu*/.'php';
$temp_skipif = $temp_dir . DIRECTORY_SEPARATOR . basename($file,'phpt').$pu.'skip.php';
$test_skipif = $test_dir . DIRECTORY_SEPARATOR . basename($file,'phpt').$pu.'skip.php';
$temp_clean = $temp_dir . DIRECTORY_SEPARATOR . basename($file,'phpt').$pu.'clean.php';

6
tests/basic/bug29971.phpt
View File

@ -13,3 +13,9 @@ array(0) {
array(0) {
}
string(3) "GPC"
--UEXPECT--
array(0) {
}
array(0) {
}
unicode(3) "GPC"

3
tests/func/006.phpt
View File

@ -24,3 +24,6 @@ var_dump( $a ); // 1A
--EXPECT--
string(2) "2B"
string(2) "1A"
--UEXPECT--
unicode(2) "2B"
unicode(2) "1A"

15
tests/lang/catchable_error_002.phpt
View File

@ -35,3 +35,18 @@ array(5) {
}
}
ALIVE!
--UEXPECTF--
array(5) {
[0]=>
int(4096)
[1]=>
unicode(%d) "Argument 1 passed to blah() must be an instance of Foo, called in %scatchable_error_002.php on line 17 and defined"
[2]=>
unicode(%d) "%scatchable_error_002.php"
[3]=>
int(5)
[4]=>
array(0) {
}
}
ALIVE!

4
tests/run-test/test004.phpt
View File

@ -7,4 +7,6 @@ arg_separator.input==
var_dump(ini_get('arg_separator.input'));
?>
--EXPECT--
string(1) "="
string(1) "="
--UEXPECT--
unicode(1) "="

8
tests/run-test/test005.phpt
View File

@ -30,3 +30,11 @@ string(1) "1"
string(1) "0"
NULL
string(%d) "%sivision by zer%s"
--UEXPECTF--
unicode(1) "1"
unicode(4) "8191"
unicode(1) "0"
unicode(1) "1"
unicode(1) "0"
NULL
unicode(%d) "%sivision by zer%s"

9
tests/run-test/test008.phpt
View File

@ -31,3 +31,12 @@ string(1) "1"
string(1) "0"
string(%d) "%sivision by zer%s"
string(%d) "%sivision by zer%s"
--UEXPECTF--
%s: %sivision by zero in %s on line %d
unicode(1) "1"
unicode(4) "4095"
unicode(1) "0"
unicode(1) "1"
unicode(1) "0"
unicode(%d) "%sivision by zer%s"
unicode(%d) "%sivision by zer%s"

8
tests/run-test/test008a.phpt
View File

@ -30,3 +30,11 @@ string(1) "1"
string(1) "0"
NULL
string(%d) "%sivision by zer%s"
--UEXPECTF--
unicode(1) "1"
unicode(4) "8191"
unicode(1) "0"
unicode(1) "1"
unicode(1) "0"
NULL
unicode(%d) "%sivision by zer%s"
Write Preview
Loading…
Cancel
Save