archive/php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2025-08-15 21:48:51 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Improved zend_string API (Francois Laupretre)

Browse source 
Squashed commit of the following:

commit d96eab8d79
Author: Francois Laupretre <francois@tekwire.net>
Date:   Fri Jun 26 01:23:31 2015 +0200

    Use the new 'ZSTR' macros in the rest of the code.

    Does not change anything to the generated code (thanks to compat macros) but cleaner.

commit b352643910
Author: Francois Laupretre <francois@tekwire.net>
Date:   Thu Jun 25 13:45:06 2015 +0200

    Improve zend_string API

    Add missing methods
This commit is contained in:
Dmitry Stogov 2015-06-29 16:44:54 +03:00
parent 667e9bd417
commit 4bd22cf1c1
45 changed files with 293 additions and 261 deletions
Download patch file Download diff file Expand all files Collapse all files

1
NEWS
View file

@ -3,6 +3,7 @@ PHP NEWS
09 Jul 2015, PHP 7.0.0 Beta 1 09 Jul 2015, PHP 7.0.0 Beta 1
- Core: - Core:
. Improved zend_string API (Francois Laupretre)
. Fixed bug #69768 (escapeshell*() doesn't cater to !). (cmb) . Fixed bug #69768 (escapeshell*() doesn't cater to !). (cmb)
. Fixed bug #69955 (Segfault when trying to combine [] and assign-op on . Fixed bug #69955 (Segfault when trying to combine [] and assign-op on
ArrayAccess object). (Laruence) ArrayAccess object). (Laruence)

16
Zend/zend_API.c
View file

@ -1644,7 +1644,7 @@ ZEND_API int array_set_zval_key(HashTable *ht, zval *key, zval *value) /* {{{ */
result = zend_symtable_update(ht, Z_STR_P(key), value); result = zend_symtable_update(ht, Z_STR_P(key), value);
break; break;
case IS_NULL: case IS_NULL:
result = zend_symtable_update(ht, STR_EMPTY_ALLOC(), value); result = zend_symtable_update(ht, ZSTR_EMPTY_ALLOC(), value);
break; break;
case IS_RESOURCE: case IS_RESOURCE:
zend_error(E_NOTICE, "Resource ID#" ZEND_LONG_FMT " used as offset, casting to integer (%pd)", Z_RES_HANDLE_P(key), Z_RES_HANDLE_P(key)); zend_error(E_NOTICE, "Resource ID#" ZEND_LONG_FMT " used as offset, casting to integer (%pd)", Z_RES_HANDLE_P(key), Z_RES_HANDLE_P(key));
@ -2833,7 +2833,7 @@ static int zend_is_callable_check_class(zend_string *name, zend_fcall_info_cache
zend_string *lcname; zend_string *lcname;
ALLOCA_FLAG(use_heap); ALLOCA_FLAG(use_heap);
STR_ALLOCA_ALLOC(lcname, name_len, use_heap); ZSTR_ALLOCA_ALLOC(lcname, name_len, use_heap);
zend_str_tolower_copy(lcname->val, name->val, name_len); zend_str_tolower_copy(lcname->val, name->val, name_len);
*strict_class = 0; *strict_class = 0;
@ -2904,7 +2904,7 @@ static int zend_is_callable_check_class(zend_string *name, zend_fcall_info_cache
} else { } else {
if (error) zend_spprintf(error, 0, "class '%.*s' not found", name_len, name->val); if (error) zend_spprintf(error, 0, "class '%.*s' not found", name_len, name->val);
} }
STR_ALLOCA_FREE(lcname, use_heap); ZSTR_ALLOCA_FREE(lcname, use_heap);
return ret; return ret;
} }
/* }}} */ /* }}} */
@ -2934,7 +2934,7 @@ static int zend_is_callable_check_func(int check_flags, zval *callable, zend_fca
/* Skip leading \ */ /* Skip leading \ */
if (UNEXPECTED(Z_STRVAL_P(callable)[0] == '\\')) { if (UNEXPECTED(Z_STRVAL_P(callable)[0] == '\\')) {
STR_ALLOCA_INIT(lmname, Z_STRVAL_P(callable) + 1, Z_STRLEN_P(callable) - 1, use_heap); ZSTR_ALLOCA_INIT(lmname, Z_STRVAL_P(callable) + 1, Z_STRLEN_P(callable) - 1, use_heap);
} else { } else {
lmname = Z_STR_P(callable); lmname = Z_STR_P(callable);
} }
@ -2942,23 +2942,23 @@ static int zend_is_callable_check_func(int check_flags, zval *callable, zend_fca
* This may be a compound name that includes namespace name */ * This may be a compound name that includes namespace name */
if (EXPECTED((fcc->function_handler = zend_hash_find_ptr(EG(function_table), lmname)) != NULL)) { if (EXPECTED((fcc->function_handler = zend_hash_find_ptr(EG(function_table), lmname)) != NULL)) {
if (lmname != Z_STR_P(callable)) { if (lmname != Z_STR_P(callable)) {
STR_ALLOCA_FREE(lmname, use_heap); ZSTR_ALLOCA_FREE(lmname, use_heap);
} }
return 1; return 1;
} else { } else {
if (lmname == Z_STR_P(callable)) { if (lmname == Z_STR_P(callable)) {
STR_ALLOCA_INIT(lmname, Z_STRVAL_P(callable), Z_STRLEN_P(callable), use_heap); ZSTR_ALLOCA_INIT(lmname, Z_STRVAL_P(callable), Z_STRLEN_P(callable), use_heap);
} else { } else {
zend_string_forget_hash_val(lmname); zend_string_forget_hash_val(lmname);
} }
zend_str_tolower(lmname->val, lmname->len); zend_str_tolower(lmname->val, lmname->len);
if ((fcc->function_handler = zend_hash_find_ptr(EG(function_table), lmname)) != NULL) { if ((fcc->function_handler = zend_hash_find_ptr(EG(function_table), lmname)) != NULL) {
STR_ALLOCA_FREE(lmname, use_heap); ZSTR_ALLOCA_FREE(lmname, use_heap);
return 1; return 1;
} }
} }
if (lmname != Z_STR_P(callable)) { if (lmname != Z_STR_P(callable)) {
STR_ALLOCA_FREE(lmname, use_heap); ZSTR_ALLOCA_FREE(lmname, use_heap);
} }
} }

12
Zend/zend_API.h
View file

@ -573,7 +573,7 @@ END_EXTERN_C()
} while (0) } while (0)
#define ZVAL_EMPTY_STRING(z) do { \ #define ZVAL_EMPTY_STRING(z) do { \
ZVAL_INTERNED_STR(z, STR_EMPTY_ALLOC()); \ ZVAL_INTERNED_STR(z, ZSTR_EMPTY_ALLOC()); \
} while (0) } while (0)
#define ZVAL_PSTRINGL(z, s, l) do { \ #define ZVAL_PSTRINGL(z, s, l) do { \
@ -1126,8 +1126,8 @@ static zend_always_inline int zend_parse_arg_string(zval *arg, char **dest, size
*dest = NULL; *dest = NULL;
*dest_len = 0; *dest_len = 0;
} else { } else {
*dest = str->val; *dest = ZSTR_VAL(str);
*dest_len = str->len; *dest_len = ZSTR_LEN(str);
} }
return 1; return 1;
} }
@ -1135,7 +1135,7 @@ static zend_always_inline int zend_parse_arg_string(zval *arg, char **dest, size
static zend_always_inline int zend_parse_arg_path_str(zval *arg, zend_string **dest, int check_null) static zend_always_inline int zend_parse_arg_path_str(zval *arg, zend_string **dest, int check_null)
{ {
if (!zend_parse_arg_str(arg, dest, check_null) || if (!zend_parse_arg_str(arg, dest, check_null) ||
(*dest && UNEXPECTED(CHECK_NULL_PATH((*dest)->val, (*dest)->len)))) { (*dest && UNEXPECTED(CHECK_NULL_PATH(ZSTR_VAL(*dest), ZSTR_LEN(*dest))))) {
return 0; return 0;
} }
return 1; return 1;
@ -1152,8 +1152,8 @@ static zend_always_inline int zend_parse_arg_path(zval *arg, char **dest, size_t
*dest = NULL; *dest = NULL;
*dest_len = 0; *dest_len = 0;
} else { } else {
*dest = str->val; *dest = ZSTR_VAL(str);
*dest_len = str->len; *dest_len = ZSTR_LEN(str);
} }
return 1; return 1;
} }

2
Zend/zend_ast.c
View file

@ -188,7 +188,7 @@ static int zend_ast_add_array_element(zval *result, zval *offset, zval *expr)
zval_dtor(offset); zval_dtor(offset);
break; break;
case IS_NULL: case IS_NULL:
zend_symtable_update(Z_ARRVAL_P(result), STR_EMPTY_ALLOC(), expr); zend_symtable_update(Z_ARRVAL_P(result), ZSTR_EMPTY_ALLOC(), expr);
break; break;
case IS_LONG: case IS_LONG:
zend_hash_index_update(Z_ARRVAL_P(result), Z_LVAL_P(offset), expr); zend_hash_index_update(Z_ARRVAL_P(result), Z_LVAL_P(offset), expr);

8
Zend/zend_compile.c
View file

@ -413,7 +413,7 @@ static inline void zend_insert_literal(zend_op_array *op_array, zval *zv, int li
if (Z_TYPE_P(zv) == IS_STRING || Z_TYPE_P(zv) == IS_CONSTANT) { if (Z_TYPE_P(zv) == IS_STRING || Z_TYPE_P(zv) == IS_CONSTANT) {
zend_string_hash_val(Z_STR_P(zv)); zend_string_hash_val(Z_STR_P(zv));
Z_STR_P(zv) = zend_new_interned_string(Z_STR_P(zv)); Z_STR_P(zv) = zend_new_interned_string(Z_STR_P(zv));
if (IS_INTERNED(Z_STR_P(zv))) { if (ZSTR_IS_INTERNED(Z_STR_P(zv))) {
Z_TYPE_FLAGS_P(zv) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE); Z_TYPE_FLAGS_P(zv) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
} }
} }
@ -725,10 +725,10 @@ void *zend_hash_find_ptr_lc(HashTable *ht, const char *str, size_t len) {
zend_string *lcname; zend_string *lcname;
ALLOCA_FLAG(use_heap); ALLOCA_FLAG(use_heap);
STR_ALLOCA_ALLOC(lcname, len, use_heap); ZSTR_ALLOCA_ALLOC(lcname, len, use_heap);
zend_str_tolower_copy(lcname->val, str, len); zend_str_tolower_copy(lcname->val, str, len);
result = zend_hash_find_ptr(ht, lcname); result = zend_hash_find_ptr(ht, lcname);
STR_ALLOCA_FREE(lcname, use_heap); ZSTR_ALLOCA_FREE(lcname, use_heap);
return result; return result;
} }
@ -5717,7 +5717,7 @@ static zend_bool zend_try_ct_eval_array(zval *result, zend_ast *ast) /* {{{ */
zend_hash_index_update(Z_ARRVAL_P(result), 1, value); zend_hash_index_update(Z_ARRVAL_P(result), 1, value);
break; break;
case IS_NULL: case IS_NULL:
zend_hash_update(Z_ARRVAL_P(result), STR_EMPTY_ALLOC(), value); zend_hash_update(Z_ARRVAL_P(result), ZSTR_EMPTY_ALLOC(), value);
break; break;
default: default:
zend_error_noreturn(E_COMPILE_ERROR, "Illegal offset type"); zend_error_noreturn(E_COMPILE_ERROR, "Illegal offset type");

2
Zend/zend_exceptions.c
View file

@ -678,7 +678,7 @@ ZEND_METHOD(exception, __toString)
DEFAULT_0_PARAMS; DEFAULT_0_PARAMS;
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
exception = getThis(); exception = getThis();
ZVAL_STRINGL(&fname, "gettraceasstring", sizeof("gettraceasstring")-1); ZVAL_STRINGL(&fname, "gettraceasstring", sizeof("gettraceasstring")-1);

6
Zend/zend_execute.c
View file

@ -573,9 +573,9 @@ ZEND_API char * zend_verify_internal_arg_class_kind(const zend_internal_arg_info
zend_string *key; zend_string *key;
ALLOCA_FLAG(use_heap); ALLOCA_FLAG(use_heap);
STR_ALLOCA_INIT(key, cur_arg_info->class_name, strlen(cur_arg_info->class_name), use_heap); ZSTR_ALLOCA_INIT(key, cur_arg_info->class_name, strlen(cur_arg_info->class_name), use_heap);
*pce = zend_fetch_class(key, (ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_NO_AUTOLOAD)); *pce = zend_fetch_class(key, (ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_NO_AUTOLOAD));
STR_ALLOCA_FREE(key, use_heap); ZSTR_ALLOCA_FREE(key, use_heap);
*class_name = (*pce) ? (*pce)->name->val : (char*)cur_arg_info->class_name; *class_name = (*pce) ? (*pce)->name->val : (char*)cur_arg_info->class_name;
if (*pce && (*pce)->ce_flags & ZEND_ACC_INTERFACE) { if (*pce && (*pce)->ce_flags & ZEND_ACC_INTERFACE) {
@ -1568,7 +1568,7 @@ str_index:
} else { } else {
switch (Z_TYPE_P(dim)) { switch (Z_TYPE_P(dim)) {
case IS_NULL: case IS_NULL:
offset_key = STR_EMPTY_ALLOC(); offset_key = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
case IS_DOUBLE: case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(dim)); hval = zend_dval_to_lval(Z_DVAL_P(dim));

2
Zend/zend_hash.c
View file

@ -524,7 +524,7 @@ add_to_hash:
zend_hash_iterators_update(ht, HT_INVALID_IDX, idx); zend_hash_iterators_update(ht, HT_INVALID_IDX, idx);
p = ht->arData + idx; p = ht->arData + idx;
p->key = key; p->key = key;
if (!IS_INTERNED(key)) { if (!ZSTR_IS_INTERNED(key)) {
zend_string_addref(key); zend_string_addref(key);
ht->u.flags &= ~HASH_FLAG_STATIC_KEYS; ht->u.flags &= ~HASH_FLAG_STATIC_KEYS;
zend_string_hash_val(key); zend_string_hash_val(key);

6
Zend/zend_hash.h
View file

@ -894,7 +894,7 @@ static zend_always_inline zval *_zend_hash_append(HashTable *ht, zend_string *ke
Bucket *p = ht->arData + idx; Bucket *p = ht->arData + idx;
ZVAL_COPY_VALUE(&p->val, zv); ZVAL_COPY_VALUE(&p->val, zv);
if (!IS_INTERNED(key)) { if (!ZSTR_IS_INTERNED(key)) {
ht->u.flags &= ~HASH_FLAG_STATIC_KEYS; ht->u.flags &= ~HASH_FLAG_STATIC_KEYS;
zend_string_addref(key); zend_string_addref(key);
zend_string_hash_val(key); zend_string_hash_val(key);
@ -916,7 +916,7 @@ static zend_always_inline zval *_zend_hash_append_ptr(HashTable *ht, zend_string
Bucket *p = ht->arData + idx; Bucket *p = ht->arData + idx;
ZVAL_PTR(&p->val, ptr); ZVAL_PTR(&p->val, ptr);
if (!IS_INTERNED(key)) { if (!ZSTR_IS_INTERNED(key)) {
ht->u.flags &= ~HASH_FLAG_STATIC_KEYS; ht->u.flags &= ~HASH_FLAG_STATIC_KEYS;
zend_string_addref(key); zend_string_addref(key);
zend_string_hash_val(key); zend_string_hash_val(key);
@ -938,7 +938,7 @@ static zend_always_inline void _zend_hash_append_ind(HashTable *ht, zend_string
Bucket *p = ht->arData + idx; Bucket *p = ht->arData + idx;
ZVAL_INDIRECT(&p->val, ptr); ZVAL_INDIRECT(&p->val, ptr);
if (!IS_INTERNED(key)) { if (!ZSTR_IS_INTERNED(key)) {
ht->u.flags &= ~HASH_FLAG_STATIC_KEYS; ht->u.flags &= ~HASH_FLAG_STATIC_KEYS;
zend_string_addref(key); zend_string_addref(key);
zend_string_hash_val(key); zend_string_hash_val(key);

4
Zend/zend_language_parser.y
View file

@ -1014,7 +1014,7 @@ exit_expr:
backticks_expr: backticks_expr:
/* empty */ /* empty */
{ $$ = zend_ast_create_zval_from_str(STR_EMPTY_ALLOC()); } { $$ = zend_ast_create_zval_from_str(ZSTR_EMPTY_ALLOC()); }
| T_ENCAPSED_AND_WHITESPACE { $$ = $1; } | T_ENCAPSED_AND_WHITESPACE { $$ = $1; }
| encaps_list { $$ = $1; } | encaps_list { $$ = $1; }
; ;
@ -1045,7 +1045,7 @@ scalar:
| T_CLASS_C { $$ = zend_ast_create_ex(ZEND_AST_MAGIC_CONST, T_CLASS_C); } | T_CLASS_C { $$ = zend_ast_create_ex(ZEND_AST_MAGIC_CONST, T_CLASS_C); }
| T_START_HEREDOC T_ENCAPSED_AND_WHITESPACE T_END_HEREDOC { $$ = $2; } | T_START_HEREDOC T_ENCAPSED_AND_WHITESPACE T_END_HEREDOC { $$ = $2; }
| T_START_HEREDOC T_END_HEREDOC | T_START_HEREDOC T_END_HEREDOC
{ $$ = zend_ast_create_zval_from_str(STR_EMPTY_ALLOC()); } { $$ = zend_ast_create_zval_from_str(ZSTR_EMPTY_ALLOC()); }
| '"' encaps_list '"' { $$ = $2; } | '"' encaps_list '"' { $$ = $2; }
| T_START_HEREDOC encaps_list T_END_HEREDOC { $$ = $2; } | T_START_HEREDOC encaps_list T_END_HEREDOC { $$ = $2; }
| dereferencable_scalar { $$ = $1; } | dereferencable_scalar { $$ = $1; }

8
Zend/zend_object_handlers.c
View file

@ -1048,7 +1048,7 @@ ZEND_API zend_function *zend_get_call_trampoline_func(zend_class_entry *ce, zend
func->prototype = fbc; func->prototype = fbc;
func->scope = fbc->common.scope; func->scope = fbc->common.scope;
func->filename = (fbc->type == ZEND_USER_FUNCTION)? fbc->op_array.filename : STR_EMPTY_ALLOC(); func->filename = (fbc->type == ZEND_USER_FUNCTION)? fbc->op_array.filename : ZSTR_EMPTY_ALLOC();
func->line_start = (fbc->type == ZEND_USER_FUNCTION)? fbc->op_array.line_start : 0; func->line_start = (fbc->type == ZEND_USER_FUNCTION)? fbc->op_array.line_start : 0;
func->line_end = (fbc->type == ZEND_USER_FUNCTION)? fbc->op_array.line_end : 0; func->line_end = (fbc->type == ZEND_USER_FUNCTION)? fbc->op_array.line_end : 0;
@ -1084,13 +1084,13 @@ static union _zend_function *zend_std_get_method(zend_object **obj_ptr, zend_str
use_heap = 0; use_heap = 0;
#endif #endif
} else { } else {
STR_ALLOCA_ALLOC(lc_method_name, method_name->len, use_heap); ZSTR_ALLOCA_ALLOC(lc_method_name, method_name->len, use_heap);
zend_str_tolower_copy(lc_method_name->val, method_name->val, method_name->len); zend_str_tolower_copy(lc_method_name->val, method_name->val, method_name->len);
} }
if (UNEXPECTED((func = zend_hash_find(&zobj->ce->function_table, lc_method_name)) == NULL)) { if (UNEXPECTED((func = zend_hash_find(&zobj->ce->function_table, lc_method_name)) == NULL)) {
if (UNEXPECTED(!key)) { if (UNEXPECTED(!key)) {
STR_ALLOCA_FREE(lc_method_name, use_heap); ZSTR_ALLOCA_FREE(lc_method_name, use_heap);
} }
if (zobj->ce->__call) { if (zobj->ce->__call) {
return zend_get_user_call_function(zobj->ce, method_name); return zend_get_user_call_function(zobj->ce, method_name);
@ -1149,7 +1149,7 @@ static union _zend_function *zend_std_get_method(zend_object **obj_ptr, zend_str
} }
if (UNEXPECTED(!key)) { if (UNEXPECTED(!key)) {
STR_ALLOCA_FREE(lc_method_name, use_heap); ZSTR_ALLOCA_FREE(lc_method_name, use_heap);
} }
return fbc; return fbc;
} }

4
Zend/zend_operators.c
View file

@ -795,7 +795,7 @@ try_again:
case IS_UNDEF: case IS_UNDEF:
case IS_NULL: case IS_NULL:
case IS_FALSE: case IS_FALSE:
return STR_EMPTY_ALLOC(); return ZSTR_EMPTY_ALLOC();
case IS_TRUE: case IS_TRUE:
return zend_string_init("1", 1, 0); return zend_string_init("1", 1, 0);
case IS_RESOURCE: { case IS_RESOURCE: {
@ -830,7 +830,7 @@ try_again:
zval_ptr_dtor(z); zval_ptr_dtor(z);
} }
zend_error(EG(exception) ? E_ERROR : E_RECOVERABLE_ERROR, "Object of class %s could not be converted to string", Z_OBJCE_P(op)->name->val); zend_error(EG(exception) ? E_ERROR : E_RECOVERABLE_ERROR, "Object of class %s could not be converted to string", Z_OBJCE_P(op)->name->val);
return STR_EMPTY_ALLOC(); return ZSTR_EMPTY_ALLOC();
} }
case IS_REFERENCE: case IS_REFERENCE:
op = Z_REFVAL_P(op); op = Z_REFVAL_P(op);

6
Zend/zend_smart_str.c
View file

@ -19,7 +19,7 @@
#include <zend.h> #include <zend.h>
#include "zend_smart_str_public.h" #include "zend_smart_str_public.h"
#define SMART_STR_OVERHEAD (ZEND_MM_OVERHEAD + _STR_HEADER_SIZE) #define SMART_STR_OVERHEAD (ZEND_MM_OVERHEAD + _ZSTR_HEADER_SIZE)
#ifndef SMART_STR_PAGE #ifndef SMART_STR_PAGE
# define SMART_STR_PAGE 4096 # define SMART_STR_PAGE 4096
@ -42,7 +42,7 @@ ZEND_API void ZEND_FASTCALL smart_str_erealloc(smart_str *str, size_t len)
str->s->len = 0; str->s->len = 0;
} else { } else {
str->a = SMART_STR_NEW_SIZE(len); str->a = SMART_STR_NEW_SIZE(len);
str->s = (zend_string *) erealloc2(str->s, _STR_HEADER_SIZE + str->a + 1, _STR_HEADER_SIZE + str->s->len + 1); str->s = (zend_string *) erealloc2(str->s, _ZSTR_HEADER_SIZE + str->a + 1, _ZSTR_HEADER_SIZE + str->s->len + 1);
} }
} }
@ -56,6 +56,6 @@ ZEND_API void ZEND_FASTCALL smart_str_realloc(smart_str *str, size_t len)
str->s->len = 0; str->s->len = 0;
} else { } else {
str->a = SMART_STR_NEW_SIZE(len); str->a = SMART_STR_NEW_SIZE(len);
str->s = (zend_string *) realloc(str->s, _STR_HEADER_SIZE + str->a + 1); str->s = (zend_string *) realloc(str->s, _ZSTR_HEADER_SIZE + str->a + 1);
} }
} }

2
Zend/zend_string.c
View file

@ -83,7 +83,7 @@ static zend_string *zend_new_interned_string_int(zend_string *str)
uint idx; uint idx;
Bucket *p; Bucket *p;
if (IS_INTERNED(str)) { if (ZSTR_IS_INTERNED(str)) {
return str; return str;
} }

142
Zend/zend_string.h
View file

@ -35,31 +35,63 @@ void zend_interned_strings_dtor(void);
END_EXTERN_C() END_EXTERN_C()
#define IS_INTERNED(s) (GC_FLAGS(s) & IS_STR_INTERNED) /* Shortcuts */
#define STR_EMPTY_ALLOC() CG(empty_string) #define ZSTR_VAL(zstr) zend_string_get_val(zstr)
#define ZSTR_LEN(zstr) (zstr)->len
#define ZSTR_HASH(zstr) zend_string_hash_val(zstr)
#define _STR_HEADER_SIZE XtOffsetOf(zend_string, val) /* Compatibility macros */
#define STR_ALLOCA_ALLOC(str, _len, use_heap) do { \ #define IS_INTERNED(s) ZSTR_IS_INTERNED(s)
(str) = (zend_string *)do_alloca(ZEND_MM_ALIGNED_SIZE(_STR_HEADER_SIZE + (_len) + 1), (use_heap)); \ #define STR_EMPTY_ALLOC() ZSTR_EMPTY_ALLOC()
#define _STR_HEADER_SIZE _ZSTR_HEADER_SIZE
#define STR_ALLOCA_ALLOC(str, _len, use_heap) ZSTR_ALLOCA_ALLOC(str, _len, use_heap)
#define STR_ALLOCA_INIT(str, s, len, use_heap) ZSTR_ALLOCA_INIT(str, s, len, use_heap)
#define STR_ALLOCA_FREE(str, use_heap) ZSTR_ALLOCA_FREE(str, use_heap)
/*---*/
#define ZSTR_IS_INTERNED(s) (GC_FLAGS(s) & IS_STR_INTERNED)
#define ZSTR_EMPTY_ALLOC() CG(empty_string)
#define _ZSTR_HEADER_SIZE XtOffsetOf(zend_string, val)
#define _ZSTR_STRUCT_SIZE(len) (_ZSTR_HEADER_SIZE + len + 1)
#define ZSTR_ALLOCA_ALLOC(str, _len, use_heap) do { \
(str) = (zend_string *)do_alloca(ZEND_MM_ALIGNED_SIZE(_ZSTR_STRUCT_SIZE(_len)), (use_heap)); \
GC_REFCOUNT(str) = 1; \ GC_REFCOUNT(str) = 1; \
GC_TYPE_INFO(str) = IS_STRING; \ GC_TYPE_INFO(str) = IS_STRING; \
(str)->h = 0; \ zend_string_forget_hash_val(str); \
(str)->len = (_len); \ zend_string_set_len(str, _len); \
} while (0)
#define STR_ALLOCA_INIT(str, s, len, use_heap) do { \
STR_ALLOCA_ALLOC(str, len, use_heap); \
memcpy((str)->val, (s), (len)); \
(str)->val[(len)] = '\0'; \
} while (0) } while (0)
#define STR_ALLOCA_FREE(str, use_heap) free_alloca(str, use_heap) #define ZSTR_ALLOCA_INIT(str, s, len, use_heap) do { \
ZSTR_ALLOCA_ALLOC(str, len, use_heap); \
memcpy(ZSTR_VAL(str), (s), (len)); \
ZSTR_VAL(str)[(len)] = '\0'; \
} while (0)
#define ZSTR_ALLOCA_FREE(str, use_heap) free_alloca(str, use_heap)
/*---*/
static zend_always_inline char * zend_string_get_val(zend_string *s)
{
return s->val;
}
static zend_always_inline void zend_string_set_len(zend_string *s, size_t len)
{
s->len = len;
}
static zend_always_inline zend_ulong zend_string_hash_val(zend_string *s) static zend_always_inline zend_ulong zend_string_hash_val(zend_string *s)
{ {
if (!s->h) { if (!s->h) {
s->h = zend_hash_func(s->val, s->len); s->h = zend_hash_func(ZSTR_VAL(s), ZSTR_LEN(s));
} }
return s->h; return s->h;
} }
@ -69,9 +101,9 @@ static zend_always_inline void zend_string_forget_hash_val(zend_string *s)
s->h = 0; s->h = 0;
} }
static zend_always_inline uint32_t zend_string_refcount(zend_string *s) static zend_always_inline uint32_t zend_string_refcount(const zend_string *s)
{ {
if (!IS_INTERNED(s)) { if (!ZSTR_IS_INTERNED(s)) {
return GC_REFCOUNT(s); return GC_REFCOUNT(s);
} }
return 1; return 1;
@ -79,7 +111,7 @@ static zend_always_inline uint32_t zend_string_refcount(zend_string *s)
static zend_always_inline uint32_t zend_string_addref(zend_string *s) static zend_always_inline uint32_t zend_string_addref(zend_string *s)
{ {
if (!IS_INTERNED(s)) { if (!ZSTR_IS_INTERNED(s)) {
return ++GC_REFCOUNT(s); return ++GC_REFCOUNT(s);
} }
return 1; return 1;
@ -87,7 +119,7 @@ static zend_always_inline uint32_t zend_string_addref(zend_string *s)
static zend_always_inline uint32_t zend_string_delref(zend_string *s) static zend_always_inline uint32_t zend_string_delref(zend_string *s)
{ {
if (!IS_INTERNED(s)) { if (!ZSTR_IS_INTERNED(s)) {
return --GC_REFCOUNT(s); return --GC_REFCOUNT(s);
} }
return 1; return 1;
@ -95,7 +127,7 @@ static zend_always_inline uint32_t zend_string_delref(zend_string *s)
static zend_always_inline zend_string *zend_string_alloc(size_t len, int persistent) static zend_always_inline zend_string *zend_string_alloc(size_t len, int persistent)
{ {
zend_string *ret = (zend_string *)pemalloc(ZEND_MM_ALIGNED_SIZE(_STR_HEADER_SIZE + len + 1), persistent); zend_string *ret = (zend_string *)pemalloc(ZEND_MM_ALIGNED_SIZE(_ZSTR_STRUCT_SIZE(len)), persistent);
GC_REFCOUNT(ret) = 1; GC_REFCOUNT(ret) = 1;
#if 1 #if 1
@ -106,14 +138,14 @@ static zend_always_inline zend_string *zend_string_alloc(size_t len, int persist
GC_FLAGS(ret) = (persistent ? IS_STR_PERSISTENT : 0); GC_FLAGS(ret) = (persistent ? IS_STR_PERSISTENT : 0);
GC_INFO(ret) = 0; GC_INFO(ret) = 0;
#endif #endif
ret->h = 0; zend_string_forget_hash_val(ret);
ret->len = len; zend_string_set_len(ret, len);
return ret; return ret;
} }
static zend_always_inline zend_string *zend_string_safe_alloc(size_t n, size_t m, size_t l, int persistent) static zend_always_inline zend_string *zend_string_safe_alloc(size_t n, size_t m, size_t l, int persistent)
{ {
zend_string *ret = (zend_string *)safe_pemalloc(n, m, ZEND_MM_ALIGNED_SIZE(_STR_HEADER_SIZE + l + 1), persistent); zend_string *ret = (zend_string *)safe_pemalloc(n, m, ZEND_MM_ALIGNED_SIZE(_ZSTR_STRUCT_SIZE(l)), persistent);
GC_REFCOUNT(ret) = 1; GC_REFCOUNT(ret) = 1;
#if 1 #if 1
@ -124,8 +156,8 @@ static zend_always_inline zend_string *zend_string_safe_alloc(size_t n, size_t m
GC_FLAGS(ret) = (persistent ? IS_STR_PERSISTENT : 0); GC_FLAGS(ret) = (persistent ? IS_STR_PERSISTENT : 0);
GC_INFO(ret) = 0; GC_INFO(ret) = 0;
#endif #endif
ret->h = 0; zend_string_forget_hash_val(ret);
ret->len = (n * m) + l; zend_string_set_len(ret, (n * m) + l);
return ret; return ret;
} }
@ -133,14 +165,14 @@ static zend_always_inline zend_string *zend_string_init(const char *str, size_t
{ {
zend_string *ret = zend_string_alloc(len, persistent); zend_string *ret = zend_string_alloc(len, persistent);
memcpy(ret->val, str, len); memcpy(ZSTR_VAL(ret), str, len);
ret->val[len] = '\0'; ZSTR_VAL(ret)[len] = '\0';
return ret; return ret;
} }
static zend_always_inline zend_string *zend_string_copy(zend_string *s) static zend_always_inline zend_string *zend_string_copy(zend_string *s)
{ {
if (!IS_INTERNED(s)) { if (!ZSTR_IS_INTERNED(s)) {
GC_REFCOUNT(s)++; GC_REFCOUNT(s)++;
} }
return s; return s;
@ -148,10 +180,10 @@ static zend_always_inline zend_string *zend_string_copy(zend_string *s)
static zend_always_inline zend_string *zend_string_dup(zend_string *s, int persistent) static zend_always_inline zend_string *zend_string_dup(zend_string *s, int persistent)
{ {
if (IS_INTERNED(s)) { if (ZSTR_IS_INTERNED(s)) {
return s; return s;
} else { } else {
return zend_string_init(s->val, s->len, persistent); return zend_string_init(ZSTR_VAL(s), ZSTR_LEN(s), persistent);
} }
} }
@ -159,10 +191,10 @@ static zend_always_inline zend_string *zend_string_realloc(zend_string *s, size_
{ {
zend_string *ret; zend_string *ret;
if (!IS_INTERNED(s)) { if (!ZSTR_IS_INTERNED(s)) {
if (EXPECTED(GC_REFCOUNT(s) == 1)) { if (EXPECTED(GC_REFCOUNT(s) == 1)) {
ret = (zend_string *)perealloc(s, ZEND_MM_ALIGNED_SIZE(_STR_HEADER_SIZE + len + 1), persistent); ret = (zend_string *)perealloc(s, ZEND_MM_ALIGNED_SIZE(_ZSTR_STRUCT_SIZE(len)), persistent);
ret->len = len; zend_string_set_len(ret, len);
zend_string_forget_hash_val(ret); zend_string_forget_hash_val(ret);
return ret; return ret;
} else { } else {
@ -170,7 +202,7 @@ static zend_always_inline zend_string *zend_string_realloc(zend_string *s, size_
} }
} }
ret = zend_string_alloc(len, persistent); ret = zend_string_alloc(len, persistent);
memcpy(ret->val, s->val, (len > s->len ? s->len : len) + 1); memcpy(ZSTR_VAL(ret), ZSTR_VAL(s), MIN(len, ZSTR_LEN(s)) + 1);
return ret; return ret;
} }
@ -178,11 +210,11 @@ static zend_always_inline zend_string *zend_string_extend(zend_string *s, size_t
{ {
zend_string *ret; zend_string *ret;
ZEND_ASSERT(len >= s->len); ZEND_ASSERT(len >= ZSTR_LEN(s));
if (!IS_INTERNED(s)) { if (!ZSTR_IS_INTERNED(s)) {
if (EXPECTED(GC_REFCOUNT(s) == 1)) { if (EXPECTED(GC_REFCOUNT(s) == 1)) {
ret = (zend_string *)perealloc(s, ZEND_MM_ALIGNED_SIZE(_STR_HEADER_SIZE + len + 1), persistent); ret = (zend_string *)perealloc(s, ZEND_MM_ALIGNED_SIZE(_ZSTR_STRUCT_SIZE(len)), persistent);
ret->len = len; zend_string_set_len(ret, len);
zend_string_forget_hash_val(ret); zend_string_forget_hash_val(ret);
return ret; return ret;
} else { } else {
@ -190,7 +222,7 @@ static zend_always_inline zend_string *zend_string_extend(zend_string *s, size_t
} }
} }
ret = zend_string_alloc(len, persistent); ret = zend_string_alloc(len, persistent);
memcpy(ret->val, s->val, s->len + 1); memcpy(ZSTR_VAL(ret), ZSTR_VAL(s), ZSTR_LEN(s) + 1);
return ret; return ret;
} }
@ -198,11 +230,11 @@ static zend_always_inline zend_string *zend_string_truncate(zend_string *s, size
{ {
zend_string *ret; zend_string *ret;
ZEND_ASSERT(len <= s->len); ZEND_ASSERT(len <= ZSTR_LEN(s));
if (!IS_INTERNED(s)) { if (!ZSTR_IS_INTERNED(s)) {
if (EXPECTED(GC_REFCOUNT(s) == 1)) { if (EXPECTED(GC_REFCOUNT(s) == 1)) {
ret = (zend_string *)perealloc(s, ZEND_MM_ALIGNED_SIZE(_STR_HEADER_SIZE + len + 1), persistent); ret = (zend_string *)perealloc(s, ZEND_MM_ALIGNED_SIZE(_ZSTR_STRUCT_SIZE(len)), persistent);
ret->len = len; zend_string_set_len(ret, len);
zend_string_forget_hash_val(ret); zend_string_forget_hash_val(ret);
return ret; return ret;
} else { } else {
@ -210,7 +242,7 @@ static zend_always_inline zend_string *zend_string_truncate(zend_string *s, size
} }
} }
ret = zend_string_alloc(len, persistent); ret = zend_string_alloc(len, persistent);
memcpy(ret->val, s->val, len + 1); memcpy(ZSTR_VAL(ret), ZSTR_VAL(s), len + 1);
return ret; return ret;
} }
@ -218,10 +250,10 @@ static zend_always_inline zend_string *zend_string_safe_realloc(zend_string *s,
{ {
zend_string *ret; zend_string *ret;
if (!IS_INTERNED(s)) { if (!ZSTR_IS_INTERNED(s)) {
if (GC_REFCOUNT(s) == 1) { if (GC_REFCOUNT(s) == 1) {
ret = (zend_string *)safe_perealloc(s, n, m, ZEND_MM_ALIGNED_SIZE(_STR_HEADER_SIZE + l + 1), persistent); ret = (zend_string *)safe_perealloc(s, n, m, ZEND_MM_ALIGNED_SIZE(_ZSTR_STRUCT_SIZE(l)), persistent);
ret->len = (n * m) + l; zend_string_set_len(ret, (n * m) + l);
zend_string_forget_hash_val(ret); zend_string_forget_hash_val(ret);
return ret; return ret;
} else { } else {
@ -229,13 +261,13 @@ static zend_always_inline zend_string *zend_string_safe_realloc(zend_string *s,
} }
} }
ret = zend_string_safe_alloc(n, m, l, persistent); ret = zend_string_safe_alloc(n, m, l, persistent);
memcpy(ret->val, s->val, ((n * m) + l > s->len ? s->len : ((n * m) + l)) + 1); memcpy(ZSTR_VAL(ret), ZSTR_VAL(s), MIN((n * m) + l, ZSTR_LEN(s)) + 1);
return ret; return ret;
} }
static zend_always_inline void zend_string_free(zend_string *s) static zend_always_inline void zend_string_free(zend_string *s)
{ {
if (!IS_INTERNED(s)) { if (!ZSTR_IS_INTERNED(s)) {
ZEND_ASSERT(GC_REFCOUNT(s) <= 1); ZEND_ASSERT(GC_REFCOUNT(s) <= 1);
pefree(s, GC_FLAGS(s) & IS_STR_PERSISTENT); pefree(s, GC_FLAGS(s) & IS_STR_PERSISTENT);
} }
@ -243,7 +275,7 @@ static zend_always_inline void zend_string_free(zend_string *s)
static zend_always_inline void zend_string_release(zend_string *s) static zend_always_inline void zend_string_release(zend_string *s)
{ {
if (!IS_INTERNED(s)) { if (!ZSTR_IS_INTERNED(s)) {
if (--GC_REFCOUNT(s) == 0) { if (--GC_REFCOUNT(s) == 0) {
pefree(s, GC_FLAGS(s) & IS_STR_PERSISTENT); pefree(s, GC_FLAGS(s) & IS_STR_PERSISTENT);
} }
@ -253,17 +285,17 @@ static zend_always_inline void zend_string_release(zend_string *s)
static zend_always_inline zend_bool zend_string_equals(zend_string *s1, zend_string *s2) static zend_always_inline zend_bool zend_string_equals(zend_string *s1, zend_string *s2)
{ {
return s1 == s2 || (s1->len == s2->len && !memcmp(s1->val, s2->val, s1->len)); return s1 == s2 || (ZSTR_LEN(s1) == ZSTR_LEN(s2) && !memcmp(ZSTR_VAL(s1), ZSTR_VAL(s2), ZSTR_LEN(s1)));
} }
#define zend_string_equals_ci(s1, s2) \ #define zend_string_equals_ci(s1, s2) \
((s1)->len == (s2)->len && !zend_binary_strcasecmp((s1)->val, (s1)->len, (s2)->val, (s2)->len)) (ZSTR_LEN(s1) == ZSTR_LEN(s2) && !zend_binary_strcasecmp(ZSTR_VAL(s1), ZSTR_LEN(s1), ZSTR_VAL(s2), ZSTR_LEN(s2)))
#define zend_string_equals_literal_ci(str, c) \ #define zend_string_equals_literal_ci(str, c) \
((str)->len == sizeof(c) - 1 && !zend_binary_strcasecmp((str)->val, (str)->len, (c), sizeof(c) - 1)) (ZSTR_LEN(str) == sizeof(c) - 1 && !zend_binary_strcasecmp(ZSTR_VAL(str), ZSTR_LEN(str), (c), sizeof(c) - 1))
#define zend_string_equals_literal(str, literal) \ #define zend_string_equals_literal(str, literal) \
((str)->len == sizeof(literal)-1 && !memcmp((str)->val, literal, sizeof(literal) - 1)) (ZSTR_LEN(str) == sizeof(literal)-1 && !memcmp(ZSTR_VAL(str), literal, sizeof(literal) - 1))
/* /*
* DJBX33A (Daniel J. Bernstein, Times 33 with Addition) * DJBX33A (Daniel J. Bernstein, Times 33 with Addition)
@ -340,13 +372,13 @@ static zend_always_inline void zend_interned_empty_string_init(zend_string **s)
zend_string *str; zend_string *str;
str = zend_string_alloc(sizeof("")-1, 1); str = zend_string_alloc(sizeof("")-1, 1);
str->val[0] = '\000'; ZSTR_VAL(str)[0] = '\000';
#ifndef ZTS #ifndef ZTS
*s = zend_new_interned_string(str); *s = zend_new_interned_string(str);
#else #else
zend_string_hash_val(str); zend_string_hash_val(str);
str->gc.u.v.flags |= IS_STR_INTERNED; GC_FLAGS(str) |= IS_STR_INTERNED;
*s = str; *s = str;
#endif #endif
} }

10
Zend/zend_types.h
View file

@ -495,13 +495,13 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) {
#define Z_STR(zval) (zval).value.str #define Z_STR(zval) (zval).value.str
#define Z_STR_P(zval_p) Z_STR(*(zval_p)) #define Z_STR_P(zval_p) Z_STR(*(zval_p))
#define Z_STRVAL(zval) Z_STR(zval)->val #define Z_STRVAL(zval) ZSTR_VAL(Z_STR(zval))
#define Z_STRVAL_P(zval_p) Z_STRVAL(*(zval_p)) #define Z_STRVAL_P(zval_p) Z_STRVAL(*(zval_p))
#define Z_STRLEN(zval) Z_STR(zval)->len #define Z_STRLEN(zval) ZSTR_LEN(Z_STR(zval))
#define Z_STRLEN_P(zval_p) Z_STRLEN(*(zval_p)) #define Z_STRLEN_P(zval_p) Z_STRLEN(*(zval_p))
#define Z_STRHASH(zval) Z_STR(zval)->h #define Z_STRHASH(zval) ZSTR_HASH(Z_STR(zval))
#define Z_STRHASH_P(zval_p) Z_STRHASH(*(zval_p)) #define Z_STRHASH_P(zval_p) Z_STRHASH(*(zval_p))
#define Z_ARR(zval) (zval).value.arr #define Z_ARR(zval) (zval).value.arr
@ -605,7 +605,7 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) {
zend_string *__s = (s); \ zend_string *__s = (s); \
Z_STR_P(__z) = __s; \ Z_STR_P(__z) = __s; \
/* interned strings support */ \ /* interned strings support */ \
Z_TYPE_INFO_P(__z) = IS_INTERNED(__s) ? \ Z_TYPE_INFO_P(__z) = ZSTR_IS_INTERNED(__s) ? \
IS_INTERNED_STRING_EX : \ IS_INTERNED_STRING_EX : \
IS_STRING_EX; \ IS_STRING_EX; \
} while (0) } while (0)
@ -629,7 +629,7 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) {
zend_string *__s = (s); \ zend_string *__s = (s); \
Z_STR_P(__z) = __s; \ Z_STR_P(__z) = __s; \
/* interned strings support */ \ /* interned strings support */ \
if (IS_INTERNED(__s)) { \ if (ZSTR_IS_INTERNED(__s)) { \
Z_TYPE_INFO_P(__z) = IS_INTERNED_STRING_EX; \ Z_TYPE_INFO_P(__z) = IS_INTERNED_STRING_EX; \
} else { \ } else { \
GC_REFCOUNT(__s)++; \ GC_REFCOUNT(__s)++; \

14
Zend/zend_vm_def.h
View file

@ -279,7 +279,7 @@ ZEND_VM_HANDLER(8, ZEND_CONCAT, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
} }
} }
if (OP1_TYPE != IS_CONST && OP1_TYPE != IS_CV && if (OP1_TYPE != IS_CONST && OP1_TYPE != IS_CV &&
!IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
size_t len = op1_str->len; size_t len = op1_str->len;
str = zend_string_realloc(op1_str, len + op2_str->len, 0); str = zend_string_realloc(op1_str, len + op2_str->len, 0);
@ -5271,7 +5271,7 @@ ZEND_VM_C_LABEL(num_index):
offset = Z_REFVAL_P(offset); offset = Z_REFVAL_P(offset);
ZEND_VM_C_GOTO(add_again); ZEND_VM_C_GOTO(add_again);
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
ZEND_VM_C_GOTO(str_index); ZEND_VM_C_GOTO(str_index);
} else if (Z_TYPE_P(offset) == IS_DOUBLE) { } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
@ -5284,7 +5284,7 @@ ZEND_VM_C_LABEL(num_index):
ZEND_VM_C_GOTO(num_index); ZEND_VM_C_GOTO(num_index);
} else if (OP2_TYPE == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (OP2_TYPE == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
ZEND_VM_C_GOTO(str_index); ZEND_VM_C_GOTO(str_index);
} else { } else {
zend_error(E_WARNING, "Illegal offset type"); zend_error(E_WARNING, "Illegal offset type");
@ -5699,7 +5699,7 @@ ZEND_VM_C_LABEL(num_index_dim):
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
ZEND_VM_C_GOTO(num_index_dim); ZEND_VM_C_GOTO(num_index_dim);
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
key = STR_EMPTY_ALLOC(); key = ZSTR_EMPTY_ALLOC();
ZEND_VM_C_GOTO(str_index_dim); ZEND_VM_C_GOTO(str_index_dim);
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -5712,7 +5712,7 @@ ZEND_VM_C_LABEL(num_index_dim):
ZEND_VM_C_GOTO(num_index_dim); ZEND_VM_C_GOTO(num_index_dim);
} else if (OP2_TYPE == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (OP2_TYPE == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
key = STR_EMPTY_ALLOC(); key = ZSTR_EMPTY_ALLOC();
ZEND_VM_C_GOTO(str_index_dim); ZEND_VM_C_GOTO(str_index_dim);
} else { } else {
zend_error(E_WARNING, "Illegal offset type in unset"); zend_error(E_WARNING, "Illegal offset type in unset");
@ -6594,7 +6594,7 @@ ZEND_VM_C_LABEL(num_index_prop):
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
ZEND_VM_C_GOTO(num_index_prop); ZEND_VM_C_GOTO(num_index_prop);
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
ZEND_VM_C_GOTO(str_index_prop); ZEND_VM_C_GOTO(str_index_prop);
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -6607,7 +6607,7 @@ ZEND_VM_C_LABEL(num_index_prop):
ZEND_VM_C_GOTO(num_index_prop); ZEND_VM_C_GOTO(num_index_prop);
} else if (OP2_TYPE == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (OP2_TYPE == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
ZEND_VM_C_GOTO(str_index_prop); ZEND_VM_C_GOTO(str_index_prop);
} else { } else {
zend_error(E_WARNING, "Illegal offset type in isset or empty"); zend_error(E_WARNING, "Illegal offset type in isset or empty");

166
Zend/zend_vm_execute.h
View file

@ -4580,7 +4580,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CONST_HANDLE
} }
} }
if (IS_CONST != IS_CONST && IS_CONST != IS_CV && if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
!IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
size_t len = op1_str->len; size_t len = op1_str->len;
str = zend_string_realloc(op1_str, len + op2_str->len, 0); str = zend_string_realloc(op1_str, len + op2_str->len, 0);
@ -6091,7 +6091,7 @@ num_index:
offset = Z_REFVAL_P(offset); offset = Z_REFVAL_P(offset);
goto add_again; goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) { } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
@ -6104,7 +6104,7 @@ num_index:
goto num_index; goto num_index;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else { } else {
zend_error(E_WARNING, "Illegal offset type"); zend_error(E_WARNING, "Illegal offset type");
@ -6384,7 +6384,7 @@ num_index_prop:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop; goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -6397,7 +6397,7 @@ num_index_prop:
goto num_index_prop; goto num_index_prop;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in isset or empty"); zend_error(E_WARNING, "Illegal offset type in isset or empty");
@ -7940,7 +7940,7 @@ num_index:
offset = Z_REFVAL_P(offset); offset = Z_REFVAL_P(offset);
goto add_again; goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) { } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
@ -7953,7 +7953,7 @@ num_index:
goto num_index; goto num_index;
} else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else { } else {
zend_error(E_WARNING, "Illegal offset type"); zend_error(E_WARNING, "Illegal offset type");
@ -8603,7 +8603,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CV_HANDLER(Z
} }
} }
if (IS_CONST != IS_CONST && IS_CONST != IS_CV && if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
!IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
size_t len = op1_str->len; size_t len = op1_str->len;
str = zend_string_realloc(op1_str, len + op2_str->len, 0); str = zend_string_realloc(op1_str, len + op2_str->len, 0);
@ -9824,7 +9824,7 @@ num_index:
offset = Z_REFVAL_P(offset); offset = Z_REFVAL_P(offset);
goto add_again; goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) { } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
@ -9837,7 +9837,7 @@ num_index:
goto num_index; goto num_index;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else { } else {
zend_error(E_WARNING, "Illegal offset type"); zend_error(E_WARNING, "Illegal offset type");
@ -9930,7 +9930,7 @@ num_index_prop:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop; goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -9943,7 +9943,7 @@ num_index_prop:
goto num_index_prop; goto num_index_prop;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in isset or empty"); zend_error(E_WARNING, "Illegal offset type in isset or empty");
@ -10478,7 +10478,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDL
} }
} }
if (IS_CONST != IS_CONST && IS_CONST != IS_CV && if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
!IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
size_t len = op1_str->len; size_t len = op1_str->len;
str = zend_string_realloc(op1_str, len + op2_str->len, 0); str = zend_string_realloc(op1_str, len + op2_str->len, 0);
@ -11610,7 +11610,7 @@ num_index:
offset = Z_REFVAL_P(offset); offset = Z_REFVAL_P(offset);
goto add_again; goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) { } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
@ -11623,7 +11623,7 @@ num_index:
goto num_index; goto num_index;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else { } else {
zend_error(E_WARNING, "Illegal offset type"); zend_error(E_WARNING, "Illegal offset type");
@ -11716,7 +11716,7 @@ num_index_prop:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop; goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -11729,7 +11729,7 @@ num_index_prop:
goto num_index_prop; goto num_index_prop;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in isset or empty"); zend_error(E_WARNING, "Illegal offset type in isset or empty");
@ -13087,7 +13087,7 @@ num_index:
offset = Z_REFVAL_P(offset); offset = Z_REFVAL_P(offset);
goto add_again; goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) { } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
@ -13100,7 +13100,7 @@ num_index:
goto num_index; goto num_index;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else { } else {
zend_error(E_WARNING, "Illegal offset type"); zend_error(E_WARNING, "Illegal offset type");
@ -13817,7 +13817,7 @@ num_index:
offset = Z_REFVAL_P(offset); offset = Z_REFVAL_P(offset);
goto add_again; goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) { } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
@ -13830,7 +13830,7 @@ num_index:
goto num_index; goto num_index;
} else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else { } else {
zend_error(E_WARNING, "Illegal offset type"); zend_error(E_WARNING, "Illegal offset type");
@ -14371,7 +14371,7 @@ num_index:
offset = Z_REFVAL_P(offset); offset = Z_REFVAL_P(offset);
goto add_again; goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) { } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
@ -14384,7 +14384,7 @@ num_index:
goto num_index; goto num_index;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else { } else {
zend_error(E_WARNING, "Illegal offset type"); zend_error(E_WARNING, "Illegal offset type");
@ -14884,7 +14884,7 @@ num_index:
offset = Z_REFVAL_P(offset); offset = Z_REFVAL_P(offset);
goto add_again; goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) { } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
@ -14897,7 +14897,7 @@ num_index:
goto num_index; goto num_index;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else { } else {
zend_error(E_WARNING, "Illegal offset type"); zend_error(E_WARNING, "Illegal offset type");
@ -17980,7 +17980,7 @@ num_index:
offset = Z_REFVAL_P(offset); offset = Z_REFVAL_P(offset);
goto add_again; goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) { } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
@ -17993,7 +17993,7 @@ num_index:
goto num_index; goto num_index;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else { } else {
zend_error(E_WARNING, "Illegal offset type"); zend_error(E_WARNING, "Illegal offset type");
@ -18093,7 +18093,7 @@ num_index_dim:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_dim; goto num_index_dim;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
key = STR_EMPTY_ALLOC(); key = ZSTR_EMPTY_ALLOC();
goto str_index_dim; goto str_index_dim;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -18106,7 +18106,7 @@ num_index_dim:
goto num_index_dim; goto num_index_dim;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
key = STR_EMPTY_ALLOC(); key = ZSTR_EMPTY_ALLOC();
goto str_index_dim; goto str_index_dim;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in unset"); zend_error(E_WARNING, "Illegal offset type in unset");
@ -19560,7 +19560,7 @@ num_index:
offset = Z_REFVAL_P(offset); offset = Z_REFVAL_P(offset);
goto add_again; goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) { } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
@ -19573,7 +19573,7 @@ num_index:
goto num_index; goto num_index;
} else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else { } else {
zend_error(E_WARNING, "Illegal offset type"); zend_error(E_WARNING, "Illegal offset type");
@ -21133,7 +21133,7 @@ num_index:
offset = Z_REFVAL_P(offset); offset = Z_REFVAL_P(offset);
goto add_again; goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) { } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
@ -21146,7 +21146,7 @@ num_index:
goto num_index; goto num_index;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else { } else {
zend_error(E_WARNING, "Illegal offset type"); zend_error(E_WARNING, "Illegal offset type");
@ -21246,7 +21246,7 @@ num_index_dim:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_dim; goto num_index_dim;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
key = STR_EMPTY_ALLOC(); key = ZSTR_EMPTY_ALLOC();
goto str_index_dim; goto str_index_dim;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -21259,7 +21259,7 @@ num_index_dim:
goto num_index_dim; goto num_index_dim;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
key = STR_EMPTY_ALLOC(); key = ZSTR_EMPTY_ALLOC();
goto str_index_dim; goto str_index_dim;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in unset"); zend_error(E_WARNING, "Illegal offset type in unset");
@ -22710,7 +22710,7 @@ num_index:
offset = Z_REFVAL_P(offset); offset = Z_REFVAL_P(offset);
goto add_again; goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) { } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
@ -22723,7 +22723,7 @@ num_index:
goto num_index; goto num_index;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else { } else {
zend_error(E_WARNING, "Illegal offset type"); zend_error(E_WARNING, "Illegal offset type");
@ -22823,7 +22823,7 @@ num_index_dim:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_dim; goto num_index_dim;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
key = STR_EMPTY_ALLOC(); key = ZSTR_EMPTY_ALLOC();
goto str_index_dim; goto str_index_dim;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -22836,7 +22836,7 @@ num_index_dim:
goto num_index_dim; goto num_index_dim;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
key = STR_EMPTY_ALLOC(); key = ZSTR_EMPTY_ALLOC();
goto str_index_dim; goto str_index_dim;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in unset"); zend_error(E_WARNING, "Illegal offset type in unset");
@ -24212,7 +24212,7 @@ num_index_dim:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_dim; goto num_index_dim;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
key = STR_EMPTY_ALLOC(); key = ZSTR_EMPTY_ALLOC();
goto str_index_dim; goto str_index_dim;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -24225,7 +24225,7 @@ num_index_dim:
goto num_index_dim; goto num_index_dim;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
key = STR_EMPTY_ALLOC(); key = ZSTR_EMPTY_ALLOC();
goto str_index_dim; goto str_index_dim;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in unset"); zend_error(E_WARNING, "Illegal offset type in unset");
@ -24348,7 +24348,7 @@ num_index_prop:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop; goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -24361,7 +24361,7 @@ num_index_prop:
goto num_index_prop; goto num_index_prop;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in isset or empty"); zend_error(E_WARNING, "Illegal offset type in isset or empty");
@ -26493,7 +26493,7 @@ num_index_dim:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_dim; goto num_index_dim;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
key = STR_EMPTY_ALLOC(); key = ZSTR_EMPTY_ALLOC();
goto str_index_dim; goto str_index_dim;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -26506,7 +26506,7 @@ num_index_dim:
goto num_index_dim; goto num_index_dim;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
key = STR_EMPTY_ALLOC(); key = ZSTR_EMPTY_ALLOC();
goto str_index_dim; goto str_index_dim;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in unset"); zend_error(E_WARNING, "Illegal offset type in unset");
@ -26629,7 +26629,7 @@ num_index_prop:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop; goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -26642,7 +26642,7 @@ num_index_prop:
goto num_index_prop; goto num_index_prop;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in isset or empty"); zend_error(E_WARNING, "Illegal offset type in isset or empty");
@ -27985,7 +27985,7 @@ num_index_dim:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_dim; goto num_index_dim;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
key = STR_EMPTY_ALLOC(); key = ZSTR_EMPTY_ALLOC();
goto str_index_dim; goto str_index_dim;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -27998,7 +27998,7 @@ num_index_dim:
goto num_index_dim; goto num_index_dim;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
key = STR_EMPTY_ALLOC(); key = ZSTR_EMPTY_ALLOC();
goto str_index_dim; goto str_index_dim;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in unset"); zend_error(E_WARNING, "Illegal offset type in unset");
@ -28123,7 +28123,7 @@ num_index_prop:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop; goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -28136,7 +28136,7 @@ num_index_prop:
goto num_index_prop; goto num_index_prop;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in isset or empty"); zend_error(E_WARNING, "Illegal offset type in isset or empty");
@ -30276,7 +30276,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CONST_HANDLER(Z
} }
} }
if (IS_CV != IS_CONST && IS_CV != IS_CV && if (IS_CV != IS_CONST && IS_CV != IS_CV &&
!IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
size_t len = op1_str->len; size_t len = op1_str->len;
str = zend_string_realloc(op1_str, len + op2_str->len, 0); str = zend_string_realloc(op1_str, len + op2_str->len, 0);
@ -32377,7 +32377,7 @@ num_index:
offset = Z_REFVAL_P(offset); offset = Z_REFVAL_P(offset);
goto add_again; goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) { } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
@ -32390,7 +32390,7 @@ num_index:
goto num_index; goto num_index;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else { } else {
zend_error(E_WARNING, "Illegal offset type"); zend_error(E_WARNING, "Illegal offset type");
@ -32572,7 +32572,7 @@ num_index_dim:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_dim; goto num_index_dim;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
key = STR_EMPTY_ALLOC(); key = ZSTR_EMPTY_ALLOC();
goto str_index_dim; goto str_index_dim;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -32585,7 +32585,7 @@ num_index_dim:
goto num_index_dim; goto num_index_dim;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
key = STR_EMPTY_ALLOC(); key = ZSTR_EMPTY_ALLOC();
goto str_index_dim; goto str_index_dim;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in unset"); zend_error(E_WARNING, "Illegal offset type in unset");
@ -32813,7 +32813,7 @@ num_index_prop:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop; goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -32826,7 +32826,7 @@ num_index_prop:
goto num_index_prop; goto num_index_prop;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in isset or empty"); zend_error(E_WARNING, "Illegal offset type in isset or empty");
@ -34944,7 +34944,7 @@ num_index:
offset = Z_REFVAL_P(offset); offset = Z_REFVAL_P(offset);
goto add_again; goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) { } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
@ -34957,7 +34957,7 @@ num_index:
goto num_index; goto num_index;
} else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else { } else {
zend_error(E_WARNING, "Illegal offset type"); zend_error(E_WARNING, "Illegal offset type");
@ -35584,7 +35584,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND
} }
} }
if (IS_CV != IS_CONST && IS_CV != IS_CV && if (IS_CV != IS_CONST && IS_CV != IS_CV &&
!IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
size_t len = op1_str->len; size_t len = op1_str->len;
str = zend_string_realloc(op1_str, len + op2_str->len, 0); str = zend_string_realloc(op1_str, len + op2_str->len, 0);
@ -37513,7 +37513,7 @@ num_index:
offset = Z_REFVAL_P(offset); offset = Z_REFVAL_P(offset);
goto add_again; goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) { } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
@ -37526,7 +37526,7 @@ num_index:
goto num_index; goto num_index;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else { } else {
zend_error(E_WARNING, "Illegal offset type"); zend_error(E_WARNING, "Illegal offset type");
@ -37626,7 +37626,7 @@ num_index_dim:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_dim; goto num_index_dim;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
key = STR_EMPTY_ALLOC(); key = ZSTR_EMPTY_ALLOC();
goto str_index_dim; goto str_index_dim;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -37639,7 +37639,7 @@ num_index_dim:
goto num_index_dim; goto num_index_dim;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
key = STR_EMPTY_ALLOC(); key = ZSTR_EMPTY_ALLOC();
goto str_index_dim; goto str_index_dim;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in unset"); zend_error(E_WARNING, "Illegal offset type in unset");
@ -37762,7 +37762,7 @@ num_index_prop:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop; goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -37775,7 +37775,7 @@ num_index_prop:
goto num_index_prop; goto num_index_prop;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in isset or empty"); zend_error(E_WARNING, "Illegal offset type in isset or empty");
@ -38315,7 +38315,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(
} }
} }
if (IS_CV != IS_CONST && IS_CV != IS_CV && if (IS_CV != IS_CONST && IS_CV != IS_CV &&
!IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
size_t len = op1_str->len; size_t len = op1_str->len;
str = zend_string_realloc(op1_str, len + op2_str->len, 0); str = zend_string_realloc(op1_str, len + op2_str->len, 0);
@ -40120,7 +40120,7 @@ num_index:
offset = Z_REFVAL_P(offset); offset = Z_REFVAL_P(offset);
goto add_again; goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) { } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
@ -40133,7 +40133,7 @@ num_index:
goto num_index; goto num_index;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index; goto str_index;
} else { } else {
zend_error(E_WARNING, "Illegal offset type"); zend_error(E_WARNING, "Illegal offset type");
@ -40233,7 +40233,7 @@ num_index_dim:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_dim; goto num_index_dim;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
key = STR_EMPTY_ALLOC(); key = ZSTR_EMPTY_ALLOC();
goto str_index_dim; goto str_index_dim;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -40246,7 +40246,7 @@ num_index_dim:
goto num_index_dim; goto num_index_dim;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
key = STR_EMPTY_ALLOC(); key = ZSTR_EMPTY_ALLOC();
goto str_index_dim; goto str_index_dim;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in unset"); zend_error(E_WARNING, "Illegal offset type in unset");
@ -40371,7 +40371,7 @@ num_index_prop:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop; goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -40384,7 +40384,7 @@ num_index_prop:
goto num_index_prop; goto num_index_prop;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in isset or empty"); zend_error(E_WARNING, "Illegal offset type in isset or empty");
@ -41388,7 +41388,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDL
} }
} }
if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV && if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
!IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
size_t len = op1_str->len; size_t len = op1_str->len;
str = zend_string_realloc(op1_str, len + op2_str->len, 0); str = zend_string_realloc(op1_str, len + op2_str->len, 0);
@ -42565,7 +42565,7 @@ num_index_prop:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop; goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -42578,7 +42578,7 @@ num_index_prop:
goto num_index_prop; goto num_index_prop;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in isset or empty"); zend_error(E_WARNING, "Illegal offset type in isset or empty");
@ -43818,7 +43818,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(
} }
} }
if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV && if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
!IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
size_t len = op1_str->len; size_t len = op1_str->len;
str = zend_string_realloc(op1_str, len + op2_str->len, 0); str = zend_string_realloc(op1_str, len + op2_str->len, 0);
@ -44574,7 +44574,7 @@ num_index_prop:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop; goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -44587,7 +44587,7 @@ num_index_prop:
goto num_index_prop; goto num_index_prop;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in isset or empty"); zend_error(E_WARNING, "Illegal offset type in isset or empty");
@ -44981,7 +44981,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HAND
} }
} }
if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV && if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
!IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
size_t len = op1_str->len; size_t len = op1_str->len;
str = zend_string_realloc(op1_str, len + op2_str->len, 0); str = zend_string_realloc(op1_str, len + op2_str->len, 0);
@ -45739,7 +45739,7 @@ num_index_prop:
hval = zend_dval_to_lval(Z_DVAL_P(offset)); hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop; goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) { } else if (Z_TYPE_P(offset) == IS_NULL) {
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) { } else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0; hval = 0;
@ -45752,7 +45752,7 @@ num_index_prop:
goto num_index_prop; goto num_index_prop;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R); GET_OP2_UNDEF_CV(offset, BP_VAR_R);
str = STR_EMPTY_ALLOC(); str = ZSTR_EMPTY_ALLOC();
goto str_index_prop; goto str_index_prop;
} else { } else {
zend_error(E_WARNING, "Illegal offset type in isset or empty"); zend_error(E_WARNING, "Illegal offset type in isset or empty");

2
ext/curl/interface.c
View file

@ -157,7 +157,7 @@ static void _php_curl_close(zend_resource *rsrc);
#define CAAL(s, v) add_assoc_long_ex(return_value, s, sizeof(s) - 1, (zend_long) v); #define CAAL(s, v) add_assoc_long_ex(return_value, s, sizeof(s) - 1, (zend_long) v);
#define CAAD(s, v) add_assoc_double_ex(return_value, s, sizeof(s) - 1, (double) v); #define CAAD(s, v) add_assoc_double_ex(return_value, s, sizeof(s) - 1, (double) v);
#define CAAS(s, v) add_assoc_string_ex(return_value, s, sizeof(s) - 1, (char *) (v ? v : "")); #define CAAS(s, v) add_assoc_string_ex(return_value, s, sizeof(s) - 1, (char *) (v ? v : ""));
#define CAASTR(s, v) add_assoc_str_ex(return_value, s, sizeof(s) - 1, v ? v : STR_EMPTY_ALLOC()); #define CAASTR(s, v) add_assoc_str_ex(return_value, s, sizeof(s) - 1, v ? v : ZSTR_EMPTY_ALLOC());
#define CAAZ(s, v) add_assoc_zval_ex(return_value, s, sizeof(s) -1 , (zval *) v); #define CAAZ(s, v) add_assoc_zval_ex(return_value, s, sizeof(s) -1 , (zval *) v);
#if defined(PHP_WIN32) || defined(__GNUC__) #if defined(PHP_WIN32) || defined(__GNUC__)

4
ext/date/php_date.c
View file

@ -1079,7 +1079,7 @@ static zend_string *date_format(char *format, size_t format_len, timelib_time *t
int weekYearSet = 0; int weekYearSet = 0;
if (!format_len) { if (!format_len) {
return STR_EMPTY_ALLOC(); return ZSTR_EMPTY_ALLOC();
} }
if (localtime) { if (localtime) {
@ -4212,7 +4212,7 @@ static zend_string *date_interval_format(char *format, size_t format_len, timeli
char buffer[33]; char buffer[33];
if (!format_len) { if (!format_len) {
return STR_EMPTY_ALLOC(); return ZSTR_EMPTY_ALLOC();
} }
for (i = 0; i < format_len; i++) { for (i = 0; i < format_len; i++) {

4
ext/intl/breakiterator/breakiterator_iterators.cpp
View file

@ -249,7 +249,7 @@ U_CFUNC zend_function *IntlPartsIterator_get_method(zend_object **object_ptr, ze
ALLOCA_FLAG(use_heap); ALLOCA_FLAG(use_heap);
if (key == NULL) { if (key == NULL) {
STR_ALLOCA_ALLOC(lc_method_name, method->len, use_heap); ZSTR_ALLOCA_ALLOC(lc_method_name, method->len, use_heap);
zend_str_tolower_copy(lc_method_name->val, method->val, method->len); zend_str_tolower_copy(lc_method_name->val, method->val, method->len);
} else { } else {
lc_method_name = Z_STR_P(key); lc_method_name = Z_STR_P(key);
@ -270,7 +270,7 @@ U_CFUNC zend_function *IntlPartsIterator_get_method(zend_object **object_ptr, ze
end: end:
if (key == NULL) { if (key == NULL) {
STR_ALLOCA_FREE(lc_method_name, use_heap); ZSTR_ALLOCA_FREE(lc_method_name, use_heap);
} }
return ret; return ret;

2
ext/intl/intl_error.c
View file

@ -135,7 +135,7 @@ zend_string * intl_error_get_message( intl_error* err )
zend_string *errMessage = 0; zend_string *errMessage = 0;
if( !err && !( err = intl_g_error_get( ) ) ) if( !err && !( err = intl_g_error_get( ) ) )
return STR_EMPTY_ALLOC(); return ZSTR_EMPTY_ALLOC();
uErrorName = u_errorName( err->code ); uErrorName = u_errorName( err->code );

2
ext/mysqlnd/mysqlnd_wireprotocol.c
View file

@ -1358,7 +1358,7 @@ php_mysqlnd_rset_field_read(void * _packet, MYSQLND_CONN_DATA * conn)
if (meta->name != mysqlnd_empty_string) { if (meta->name != mysqlnd_empty_string) {
meta->sname = zend_string_init(meta->name, meta->name_length, packet->persistent_alloc); meta->sname = zend_string_init(meta->name, meta->name_length, packet->persistent_alloc);
} else { } else {
meta->sname = STR_EMPTY_ALLOC(); meta->sname = ZSTR_EMPTY_ALLOC();
} }
meta->name = meta->sname->val; meta->name = meta->sname->val;
meta->name_length = meta->sname->len; meta->name_length = meta->sname->len;

6
ext/opcache/ZendAccelerator.c
View file

@ -343,7 +343,7 @@ zend_string *accel_new_interned_string(zend_string *str)
idx = Z_NEXT(p->val); idx = Z_NEXT(p->val);
} }
if (ZCSG(interned_strings_top) + ZEND_MM_ALIGNED_SIZE(_STR_HEADER_SIZE + str->len + 1) >= if (ZCSG(interned_strings_top) + ZEND_MM_ALIGNED_SIZE(_ZSTR_STRUCT_SIZE(ZSTR_LEN(str))) >=
ZCSG(interned_strings_end)) { ZCSG(interned_strings_end)) {
/* no memory, return the same non-interned string */ /* no memory, return the same non-interned string */
zend_accel_error(ACCEL_LOG_WARNING, "Interned string buffer overflow"); zend_accel_error(ACCEL_LOG_WARNING, "Interned string buffer overflow");
@ -356,7 +356,7 @@ zend_string *accel_new_interned_string(zend_string *str)
ZCSG(interned_strings).nNumOfElements++; ZCSG(interned_strings).nNumOfElements++;
p = ZCSG(interned_strings).arData + idx; p = ZCSG(interned_strings).arData + idx;
p->key = (zend_string*) ZCSG(interned_strings_top); p->key = (zend_string*) ZCSG(interned_strings_top);
ZCSG(interned_strings_top) += ZEND_MM_ALIGNED_SIZE(_STR_HEADER_SIZE + str->len + 1); ZCSG(interned_strings_top) += ZEND_MM_ALIGNED_SIZE(_ZSTR_STRUCT_SIZE(ZSTR_LEN(str)));
p->h = h; p->h = h;
GC_REFCOUNT(p->key) = 1; GC_REFCOUNT(p->key) = 1;
#if 1 #if 1
@ -1973,7 +1973,7 @@ static void accel_reset_pcre_cache(void)
ZEND_HASH_FOREACH_BUCKET(&PCRE_G(pcre_cache), p) { ZEND_HASH_FOREACH_BUCKET(&PCRE_G(pcre_cache), p) {
/* Remove PCRE cache entries with inconsistent keys */ /* Remove PCRE cache entries with inconsistent keys */
if (IS_INTERNED(p->key)) { if (ZSTR_IS_INTERNED(p->key)) {
p->key = NULL; p->key = NULL;
zend_hash_del_bucket(&PCRE_G(pcre_cache), p); zend_hash_del_bucket(&PCRE_G(pcre_cache), p);
} }

6
ext/opcache/zend_file_cache.c
View file

@ -199,14 +199,14 @@ static void *zend_file_cache_serialize_interned(zend_string *str,
return ret; return ret;
} }
len = ZEND_MM_ALIGNED_SIZE(_STR_HEADER_SIZE + str->len + 1); len = ZEND_MM_ALIGNED_SIZE(_ZSTR_STRUCT_SIZE(ZSTR_LEN(str)));
ret = (void*)(info->str_size | Z_UL(1)); ret = (void*)(info->str_size | Z_UL(1));
zend_shared_alloc_register_xlat_entry(str, ret); zend_shared_alloc_register_xlat_entry(str, ret);
if (info->str_size + len > ((zend_string*)ZCG(mem))->len) { if (info->str_size + len > ((zend_string*)ZCG(mem))->len) {
size_t new_len = info->str_size + len; size_t new_len = info->str_size + len;
ZCG(mem) = (void*)zend_string_realloc( ZCG(mem) = (void*)zend_string_realloc(
(zend_string*)ZCG(mem), (zend_string*)ZCG(mem),
((_STR_HEADER_SIZE + 1 + new_len + 4095) & ~0xfff) - (_STR_HEADER_SIZE + 1), ((_ZSTR_HEADER_SIZE + 1 + new_len + 4095) & ~0xfff) - (_ZSTR_HEADER_SIZE + 1),
0); 0);
} }
memcpy(((zend_string*)ZCG(mem))->val + info->str_size, str, len); memcpy(((zend_string*)ZCG(mem))->val + info->str_size, str, len);
@ -717,7 +717,7 @@ int zend_file_cache_script_store(zend_persistent_script *script, int in_shm)
mem = buf = emalloc(script->size); mem = buf = emalloc(script->size);
#endif #endif
ZCG(mem) = zend_string_alloc(4096 - (_STR_HEADER_SIZE + 1), 0); ZCG(mem) = zend_string_alloc(4096 - (_ZSTR_HEADER_SIZE + 1), 0);
zend_shared_alloc_init_xlat_table(); zend_shared_alloc_init_xlat_table();
if (!in_shm) { if (!in_shm) {

4
ext/opcache/zend_persist.c
View file

@ -39,7 +39,7 @@
zend_string_release(str); \ zend_string_release(str); \
str = new_str; \ str = new_str; \
} else { \ } else { \
new_str = zend_accel_memdup((void*)str, _STR_HEADER_SIZE + (str)->len + 1); \ new_str = zend_accel_memdup((void*)str, _ZSTR_STRUCT_SIZE(ZSTR_LEN(str))); \
zend_string_release(str); \ zend_string_release(str); \
str = new_str; \ str = new_str; \
zend_string_hash_val(str); \ zend_string_hash_val(str); \
@ -47,7 +47,7 @@
} \ } \
} while (0) } while (0)
#define zend_accel_memdup_string(str) do { \ #define zend_accel_memdup_string(str) do { \
str = zend_accel_memdup(str, _STR_HEADER_SIZE + (str)->len + 1); \ str = zend_accel_memdup(str, _ZSTR_STRUCT_SIZE(ZSTR_LEN(str))); \
zend_string_hash_val(str); \ zend_string_hash_val(str); \
GC_FLAGS(str) = IS_STR_INTERNED | IS_STR_PERMANENT; \ GC_FLAGS(str) = IS_STR_INTERNED | IS_STR_PERMANENT; \
} while (0) } while (0)

4
ext/opcache/zend_persist_calc.c
View file

@ -31,8 +31,8 @@
#define ADD_ARENA_SIZE(m) ZCG(current_persistent_script)->arena_size += ZEND_ALIGNED_SIZE(m) #define ADD_ARENA_SIZE(m) ZCG(current_persistent_script)->arena_size += ZEND_ALIGNED_SIZE(m)
# define ADD_STRING(str) \ # define ADD_STRING(str) ADD_DUP_SIZE((str), _ZSTR_STRUCT_SIZE(ZSTR_LEN(str)))
ADD_DUP_SIZE((str), _STR_HEADER_SIZE + (str)->len + 1)
# define ADD_INTERNED_STRING(str, do_free) do { \ # define ADD_INTERNED_STRING(str, do_free) do { \
if (!IS_ACCEL_INTERNED(str)) { \ if (!IS_ACCEL_INTERNED(str)) { \
zend_string *tmp = accel_new_interned_string(str); \ zend_string *tmp = accel_new_interned_string(str); \

4
ext/pcre/php_pcre.c
View file

@ -503,7 +503,7 @@ PHPAPI pcre_cache_entry* pcre_get_compiled_regex_cache(zend_string *regex)
* as hash keys especually for this table. * as hash keys especually for this table.
* See bug #63180 * See bug #63180
*/ */
if (!IS_INTERNED(regex) || !(GC_FLAGS(regex) & IS_STR_PERMANENT)) { if (!ZSTR_IS_INTERNED(regex) || !(GC_FLAGS(regex) & IS_STR_PERMANENT)) {
zend_string *str = zend_string_init(regex->val, regex->len, 1); zend_string *str = zend_string_init(regex->val, regex->len, 1);
GC_REFCOUNT(str) = 0; /* will be incremented by zend_hash_update_mem() */ GC_REFCOUNT(str) = 0; /* will be incremented by zend_hash_update_mem() */
str->h = regex->h; str->h = regex->h;
@ -1339,7 +1339,7 @@ static zend_string *php_replace_in_subject(zval *regex, zval *replace, zval *sub
uint32_t replace_idx; uint32_t replace_idx;
zend_string *subject_str = zval_get_string(subject); zend_string *subject_str = zval_get_string(subject);
/* FIXME: This might need to be changed to STR_EMPTY_ALLOC(). Check if this zval could be dtor()'ed somehow */ /* FIXME: This might need to be changed to ZSTR_EMPTY_ALLOC(). Check if this zval could be dtor()'ed somehow */
ZVAL_EMPTY_STRING(&empty_replace); ZVAL_EMPTY_STRING(&empty_replace);
/* If regex is an array */ /* If regex is an array */

4
ext/session/mod_files.c
View file

@ -477,7 +477,7 @@ PS_READ_FUNC(files)
data->st_size = sbuf.st_size; data->st_size = sbuf.st_size;
if (sbuf.st_size == 0) { if (sbuf.st_size == 0) {
*val = STR_EMPTY_ALLOC(); *val = ZSTR_EMPTY_ALLOC();
return SUCCESS; return SUCCESS;
} }
@ -515,7 +515,7 @@ PS_READ_FUNC(files)
php_error_docref(NULL, E_WARNING, "read returned less bytes than requested"); php_error_docref(NULL, E_WARNING, "read returned less bytes than requested");
} }
zend_string_release(*val); zend_string_release(*val);
*val = STR_EMPTY_ALLOC(); *val = ZSTR_EMPTY_ALLOC();
return FAILURE; return FAILURE;
} }

2
ext/session/session.c
View file

@ -565,7 +565,7 @@ static void php_session_save_current_state(int write) /* {{{ */
} }
zend_string_release(val); zend_string_release(val);
} else { } else {
ret = PS(mod)->s_write(&PS(mod_data), PS(id), STR_EMPTY_ALLOC(), PS(gc_maxlifetime)); ret = PS(mod)->s_write(&PS(mod_data), PS(id), ZSTR_EMPTY_ALLOC(), PS(gc_maxlifetime));
} }
} }

2
ext/simplexml/simplexml.c
View file

@ -969,7 +969,7 @@ static inline zend_string *sxe_xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr li
res = zend_string_init((char*)tmp, strlen((char *)tmp), 0); res = zend_string_init((char*)tmp, strlen((char *)tmp), 0);
xmlFree(tmp); xmlFree(tmp);
} else { } else {
res = STR_EMPTY_ALLOC(); res = ZSTR_EMPTY_ALLOC();
} }
return res; return res;

2
ext/spl/spl_array.c
View file

@ -278,7 +278,7 @@ static zval *spl_array_get_dimension_ptr(int check_inherited, zval *object, zval
switch (Z_TYPE_P(offset)) { switch (Z_TYPE_P(offset)) {
case IS_NULL: case IS_NULL:
offset_key = STR_EMPTY_ALLOC(); offset_key = ZSTR_EMPTY_ALLOC();
goto fetch_dim_string; goto fetch_dim_string;
case IS_STRING: case IS_STRING:
offset_key = Z_STR_P(offset); offset_key = Z_STR_P(offset);

2
ext/standard/array.c
View file

@ -5051,7 +5051,7 @@ PHP_FUNCTION(array_key_exists)
} }
RETURN_FALSE; RETURN_FALSE;
case IS_NULL: case IS_NULL:
if (zend_hash_exists(array, STR_EMPTY_ALLOC())) { if (zend_hash_exists(array, ZSTR_EMPTY_ALLOC())) {
RETURN_TRUE; RETURN_TRUE;
} }
RETURN_FALSE; RETURN_FALSE;

2
ext/standard/browscap.c
View file

@ -174,7 +174,7 @@ static void php_browscap_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callb
(Z_STRLEN_P(arg2) == 4 && !strncasecmp(Z_STRVAL_P(arg2), "none", sizeof("none") - 1)) || (Z_STRLEN_P(arg2) == 4 && !strncasecmp(Z_STRVAL_P(arg2), "none", sizeof("none") - 1)) ||
(Z_STRLEN_P(arg2) == 5 && !strncasecmp(Z_STRVAL_P(arg2), "false", sizeof("false") - 1)) (Z_STRLEN_P(arg2) == 5 && !strncasecmp(Z_STRVAL_P(arg2), "false", sizeof("false") - 1))
) { ) {
// TODO: USE STR_EMPTY_ALLOC()? // TODO: USE ZSTR_EMPTY_ALLOC()?
ZVAL_NEW_STR(&new_property, zend_string_init("", sizeof("")-1, persistent)); ZVAL_NEW_STR(&new_property, zend_string_init("", sizeof("")-1, persistent));
} else { /* Other than true/false setting */ } else { /* Other than true/false setting */
ZVAL_STR(&new_property, zend_string_dup(Z_STR_P(arg2), persistent)); ZVAL_STR(&new_property, zend_string_dup(Z_STR_P(arg2), persistent));

4
ext/standard/file.c
View file

@ -1115,7 +1115,7 @@ PHPAPI PHP_FUNCTION(fgetss)
if (allowed != NULL) { if (allowed != NULL) {
// TODO: reimplement to avoid reallocation ??? // TODO: reimplement to avoid reallocation ???
if (IS_INTERNED(allowed)) { if (ZSTR_IS_INTERNED(allowed)) {
allowed_tags = estrndup(allowed->val, allowed->len); allowed_tags = estrndup(allowed->val, allowed->len);
allowed_tags_len = allowed->len; allowed_tags_len = allowed->len;
} else { } else {
@ -1127,7 +1127,7 @@ PHPAPI PHP_FUNCTION(fgetss)
retval_len = php_strip_tags(retval, actual_len, &stream->fgetss_state, allowed_tags, allowed_tags_len); retval_len = php_strip_tags(retval, actual_len, &stream->fgetss_state, allowed_tags, allowed_tags_len);
// TODO: reimplement to avoid reallocation ??? // TODO: reimplement to avoid reallocation ???
if (allowed && IS_INTERNED(allowed)) { if (allowed && ZSTR_IS_INTERNED(allowed)) {
efree(allowed_tags); efree(allowed_tags);
} }

2
ext/standard/html.c
View file

@ -1303,7 +1303,7 @@ PHPAPI zend_string *php_escape_html_entities_ex(unsigned char *old, size_t oldle
continue; continue;
} else { } else {
zend_string_free(replaced); zend_string_free(replaced);
return STR_EMPTY_ALLOC(); return ZSTR_EMPTY_ALLOC();
} }
} else { /* SUCCESS */ } else { /* SUCCESS */
mbsequence = &old[cursor_before]; mbsequence = &old[cursor_before];

2
ext/standard/http_fopen_wrapper.c
View file

@ -454,7 +454,7 @@ finish:
user_headers = estrndup(tmp->val, tmp->len); user_headers = estrndup(tmp->val, tmp->len);
if (IS_INTERNED(tmp)) { if (ZSTR_IS_INTERNED(tmp)) {
tmp = zend_string_init(tmp->val, tmp->len, 0); tmp = zend_string_init(tmp->val, tmp->len, 0);
} else if (GC_REFCOUNT(tmp) > 1) { } else if (GC_REFCOUNT(tmp) > 1) {
GC_REFCOUNT(tmp)--; GC_REFCOUNT(tmp)--;

6
ext/standard/math.c
View file

@ -1081,7 +1081,7 @@ PHPAPI zend_string * _php_math_longtobase(zval *arg, int base)
zend_ulong value; zend_ulong value;
if (Z_TYPE_P(arg) != IS_LONG || base < 2 || base > 36) { if (Z_TYPE_P(arg) != IS_LONG || base < 2 || base > 36) {
return STR_EMPTY_ALLOC(); return ZSTR_EMPTY_ALLOC();
} }
value = Z_LVAL_P(arg); value = Z_LVAL_P(arg);
@ -1108,7 +1108,7 @@ PHPAPI zend_string * _php_math_zvaltobase(zval *arg, int base)
static char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz"; static char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz";
if ((Z_TYPE_P(arg) != IS_LONG && Z_TYPE_P(arg) != IS_DOUBLE) || base < 2 || base > 36) { if ((Z_TYPE_P(arg) != IS_LONG && Z_TYPE_P(arg) != IS_DOUBLE) || base < 2 || base > 36) {
return STR_EMPTY_ALLOC(); return ZSTR_EMPTY_ALLOC();
} }
if (Z_TYPE_P(arg) == IS_DOUBLE) { if (Z_TYPE_P(arg) == IS_DOUBLE) {
@ -1119,7 +1119,7 @@ PHPAPI zend_string * _php_math_zvaltobase(zval *arg, int base)
/* Don't try to convert +/- infinity */ /* Don't try to convert +/- infinity */
if (fvalue == HUGE_VAL || fvalue == -HUGE_VAL) { if (fvalue == HUGE_VAL || fvalue == -HUGE_VAL) {
php_error_docref(NULL, E_WARNING, "Number too large"); php_error_docref(NULL, E_WARNING, "Number too large");
return STR_EMPTY_ALLOC(); return ZSTR_EMPTY_ALLOC();
} }
end = ptr = buf + sizeof(buf) - 1; end = ptr = buf + sizeof(buf) - 1;

28
ext/standard/string.c
View file

@ -1302,7 +1302,7 @@ PHP_FUNCTION(implode)
return; return;
} }
delim = STR_EMPTY_ALLOC(); delim = ZSTR_EMPTY_ALLOC();
arr = arg1; arr = arg1;
} else { } else {
if (Z_TYPE_P(arg1) == IS_ARRAY) { if (Z_TYPE_P(arg1) == IS_ARRAY) {
@ -2131,12 +2131,12 @@ PHP_FUNCTION(strripos)
RETURN_FALSE; RETURN_FALSE;
} }
STR_ALLOCA_ALLOC(ord_needle, 1, use_heap); ZSTR_ALLOCA_ALLOC(ord_needle, 1, use_heap);
if (Z_TYPE_P(zneedle) == IS_STRING) { if (Z_TYPE_P(zneedle) == IS_STRING) {
needle = Z_STR_P(zneedle); needle = Z_STR_P(zneedle);
} else { } else {
if (php_needle_char(zneedle, ord_needle->val) != SUCCESS) { if (php_needle_char(zneedle, ord_needle->val) != SUCCESS) {
STR_ALLOCA_FREE(ord_needle, use_heap); ZSTR_ALLOCA_FREE(ord_needle, use_heap);
RETURN_FALSE; RETURN_FALSE;
} }
ord_needle->val[1] = '\0'; ord_needle->val[1] = '\0';
@ -2144,7 +2144,7 @@ PHP_FUNCTION(strripos)
} }
if ((haystack->len == 0) || (needle->len == 0)) { if ((haystack->len == 0) || (needle->len == 0)) {
STR_ALLOCA_FREE(ord_needle, use_heap); ZSTR_ALLOCA_FREE(ord_needle, use_heap);
RETURN_FALSE; RETURN_FALSE;
} }
@ -2153,7 +2153,7 @@ PHP_FUNCTION(strripos)
Can also avoid tolower emallocs */ Can also avoid tolower emallocs */
if (offset >= 0) { if (offset >= 0) {
if ((size_t)offset > haystack->len) { if ((size_t)offset > haystack->len) {
STR_ALLOCA_FREE(ord_needle, use_heap); ZSTR_ALLOCA_FREE(ord_needle, use_heap);
php_error_docref(NULL, E_WARNING, "Offset is greater than the length of haystack string"); php_error_docref(NULL, E_WARNING, "Offset is greater than the length of haystack string");
RETURN_FALSE; RETURN_FALSE;
} }
@ -2162,7 +2162,7 @@ PHP_FUNCTION(strripos)
} else { } else {
p = haystack->val; p = haystack->val;
if (offset < -INT_MAX || (size_t)(-offset) > haystack->len) { if (offset < -INT_MAX || (size_t)(-offset) > haystack->len) {
STR_ALLOCA_FREE(ord_needle, use_heap); ZSTR_ALLOCA_FREE(ord_needle, use_heap);
php_error_docref(NULL, E_WARNING, "Offset is greater than the length of haystack string"); php_error_docref(NULL, E_WARNING, "Offset is greater than the length of haystack string");
RETURN_FALSE; RETURN_FALSE;
} }
@ -2172,12 +2172,12 @@ PHP_FUNCTION(strripos)
*ord_needle->val = tolower(*needle->val); *ord_needle->val = tolower(*needle->val);
while (e >= p) { while (e >= p) {
if (tolower(*e) == *ord_needle->val) { if (tolower(*e) == *ord_needle->val) {
STR_ALLOCA_FREE(ord_needle, use_heap); ZSTR_ALLOCA_FREE(ord_needle, use_heap);
RETURN_LONG(e - p + (offset > 0 ? offset : 0)); RETURN_LONG(e - p + (offset > 0 ? offset : 0));
} }
e--; e--;
} }
STR_ALLOCA_FREE(ord_needle, use_heap); ZSTR_ALLOCA_FREE(ord_needle, use_heap);
RETURN_FALSE; RETURN_FALSE;
} }
@ -2185,7 +2185,7 @@ PHP_FUNCTION(strripos)
if (offset >= 0) { if (offset >= 0) {
if ((size_t)offset > haystack->len) { if ((size_t)offset > haystack->len) {
zend_string_release(haystack_dup); zend_string_release(haystack_dup);
STR_ALLOCA_FREE(ord_needle, use_heap); ZSTR_ALLOCA_FREE(ord_needle, use_heap);
php_error_docref(NULL, E_WARNING, "Offset is greater than the length of haystack string"); php_error_docref(NULL, E_WARNING, "Offset is greater than the length of haystack string");
RETURN_FALSE; RETURN_FALSE;
} }
@ -2194,7 +2194,7 @@ PHP_FUNCTION(strripos)
} else { } else {
if (offset < -INT_MAX || (size_t)(-offset) > haystack->len) { if (offset < -INT_MAX || (size_t)(-offset) > haystack->len) {
zend_string_release(haystack_dup); zend_string_release(haystack_dup);
STR_ALLOCA_FREE(ord_needle, use_heap); ZSTR_ALLOCA_FREE(ord_needle, use_heap);
php_error_docref(NULL, E_WARNING, "Offset is greater than the length of haystack string"); php_error_docref(NULL, E_WARNING, "Offset is greater than the length of haystack string");
RETURN_FALSE; RETURN_FALSE;
} }
@ -2211,11 +2211,11 @@ PHP_FUNCTION(strripos)
RETVAL_LONG(found - haystack_dup->val); RETVAL_LONG(found - haystack_dup->val);
zend_string_release(needle_dup); zend_string_release(needle_dup);
zend_string_release(haystack_dup); zend_string_release(haystack_dup);
STR_ALLOCA_FREE(ord_needle, use_heap); ZSTR_ALLOCA_FREE(ord_needle, use_heap);
} else { } else {
zend_string_release(needle_dup); zend_string_release(needle_dup);
zend_string_release(haystack_dup); zend_string_release(haystack_dup);
STR_ALLOCA_FREE(ord_needle, use_heap); ZSTR_ALLOCA_FREE(ord_needle, use_heap);
RETURN_FALSE; RETURN_FALSE;
} }
} }
@ -3855,7 +3855,7 @@ PHPAPI zend_string *php_addslashes(zend_string *str, int should_free)
zend_string *new_str; zend_string *new_str;
if (!str) { if (!str) {
return STR_EMPTY_ALLOC(); return ZSTR_EMPTY_ALLOC();
} }
source = str->val; source = str->val;
@ -4710,7 +4710,7 @@ PHPAPI size_t php_strip_tags_ex(char *rbuf, size_t len, int *stateptr, char *all
rp = rbuf; rp = rbuf;
br = 0; br = 0;
if (allow) { if (allow) {
//??? if (IS_INTERNED(allow)) { //??? if (ZSTR_IS_INTERNED(allow)) {
//??? allow_free = allow = zend_str_tolower_dup(allow, allow_len); //??? allow_free = allow = zend_str_tolower_dup(allow, allow_len);
//??? } else { //??? } else {
allow_free = NULL; allow_free = NULL;

33
ext/standard/var_unserializer.c
View file

@ -1,4 +1,4 @@
/* Generated by re2c 0.13.7.5 */ /* Generated by re2c 0.13.5 */
#line 1 "ext/standard/var_unserializer.re" #line 1 "ext/standard/var_unserializer.re"
/* /*
+----------------------------------------------------------------------+ +----------------------------------------------------------------------+
@ -245,10 +245,10 @@ static inline int unserialize_allowed_class(zend_string *class_name, HashTable *
return 0; return 0;
} }
STR_ALLOCA_ALLOC(lcname, class_name->len, use_heap); ZSTR_ALLOCA_ALLOC(lcname, class_name->len, use_heap);
zend_str_tolower_copy(lcname->val, class_name->val, class_name->len); zend_str_tolower_copy(lcname->val, class_name->val, class_name->len);
res = zend_hash_exists(classes, lcname); res = zend_hash_exists(classes, lcname);
STR_ALLOCA_FREE(lcname, use_heap); ZSTR_ALLOCA_FREE(lcname, use_heap);
return res; return res;
} }
@ -661,8 +661,7 @@ yy20:
if (yybm[0+yych] & 128) { if (yybm[0+yych] & 128) {
goto yy20; goto yy20;
} }
if (yych <= '/') goto yy18; if (yych != ':') goto yy18;
if (yych >= ';') goto yy18;
yych = *++YYCURSOR; yych = *++YYCURSOR;
if (yych != '"') goto yy18; if (yych != '"') goto yy18;
++YYCURSOR; ++YYCURSOR;
@ -811,7 +810,7 @@ yy20:
return object_common2(UNSERIALIZE_PASSTHRU, elements); return object_common2(UNSERIALIZE_PASSTHRU, elements);
} }
#line 815 "ext/standard/var_unserializer.c" #line 814 "ext/standard/var_unserializer.c"
yy25: yy25:
yych = *++YYCURSOR; yych = *++YYCURSOR;
if (yych <= ',') { if (yych <= ',') {
@ -844,7 +843,7 @@ yy27:
return object_common2(UNSERIALIZE_PASSTHRU, return object_common2(UNSERIALIZE_PASSTHRU,
object_common1(UNSERIALIZE_PASSTHRU, ZEND_STANDARD_CLASS_DEF_PTR)); object_common1(UNSERIALIZE_PASSTHRU, ZEND_STANDARD_CLASS_DEF_PTR));
} }
#line 848 "ext/standard/var_unserializer.c" #line 847 "ext/standard/var_unserializer.c"
yy32: yy32:
yych = *++YYCURSOR; yych = *++YYCURSOR;
if (yych == '+') goto yy33; if (yych == '+') goto yy33;
@ -886,7 +885,7 @@ yy34:
return finish_nested_data(UNSERIALIZE_PASSTHRU); return finish_nested_data(UNSERIALIZE_PASSTHRU);
} }
#line 890 "ext/standard/var_unserializer.c" #line 889 "ext/standard/var_unserializer.c"
yy39: yy39:
yych = *++YYCURSOR; yych = *++YYCURSOR;
if (yych == '+') goto yy40; if (yych == '+') goto yy40;
@ -935,7 +934,7 @@ yy41:
ZVAL_STR(rval, str); ZVAL_STR(rval, str);
return 1; return 1;
} }
#line 939 "ext/standard/var_unserializer.c" #line 938 "ext/standard/var_unserializer.c"
yy46: yy46:
yych = *++YYCURSOR; yych = *++YYCURSOR;
if (yych == '+') goto yy47; if (yych == '+') goto yy47;
@ -983,7 +982,7 @@ yy48:
ZVAL_STRINGL(rval, str, len); ZVAL_STRINGL(rval, str, len);
return 1; return 1;
} }
#line 987 "ext/standard/var_unserializer.c" #line 986 "ext/standard/var_unserializer.c"
yy53: yy53:
yych = *++YYCURSOR; yych = *++YYCURSOR;
if (yych <= '/') { if (yych <= '/') {
@ -1080,7 +1079,7 @@ use_double:
ZVAL_DOUBLE(rval, zend_strtod((const char *)start + 2, NULL)); ZVAL_DOUBLE(rval, zend_strtod((const char *)start + 2, NULL));
return 1; return 1;
} }
#line 1084 "ext/standard/var_unserializer.c" #line 1083 "ext/standard/var_unserializer.c"
yy65: yy65:
yych = *++YYCURSOR; yych = *++YYCURSOR;
if (yych <= ',') { if (yych <= ',') {
@ -1155,7 +1154,7 @@ yy73:
return 1; return 1;
} }
#line 1159 "ext/standard/var_unserializer.c" #line 1158 "ext/standard/var_unserializer.c"
yy76: yy76:
yych = *++YYCURSOR; yych = *++YYCURSOR;
if (yych == 'N') goto yy73; if (yych == 'N') goto yy73;
@ -1208,7 +1207,7 @@ yy79:
ZVAL_LONG(rval, parse_iv(start + 2)); ZVAL_LONG(rval, parse_iv(start + 2));
return 1; return 1;
} }
#line 1212 "ext/standard/var_unserializer.c" #line 1211 "ext/standard/var_unserializer.c"
yy83: yy83:
yych = *++YYCURSOR; yych = *++YYCURSOR;
if (yych <= '/') goto yy18; if (yych <= '/') goto yy18;
@ -1222,7 +1221,7 @@ yy83:
ZVAL_BOOL(rval, parse_iv(start + 2)); ZVAL_BOOL(rval, parse_iv(start + 2));
return 1; return 1;
} }
#line 1226 "ext/standard/var_unserializer.c" #line 1225 "ext/standard/var_unserializer.c"
yy87: yy87:
++YYCURSOR; ++YYCURSOR;
#line 577 "ext/standard/var_unserializer.re" #line 577 "ext/standard/var_unserializer.re"
@ -1231,7 +1230,7 @@ yy87:
ZVAL_NULL(rval); ZVAL_NULL(rval);
return 1; return 1;
} }
#line 1235 "ext/standard/var_unserializer.c" #line 1234 "ext/standard/var_unserializer.c"
yy89: yy89:
yych = *++YYCURSOR; yych = *++YYCURSOR;
if (yych <= ',') { if (yych <= ',') {
@ -1277,7 +1276,7 @@ yy91:
return 1; return 1;
} }
#line 1281 "ext/standard/var_unserializer.c" #line 1280 "ext/standard/var_unserializer.c"
yy95: yy95:
yych = *++YYCURSOR; yych = *++YYCURSOR;
if (yych <= ',') { if (yych <= ',') {
@ -1322,7 +1321,7 @@ yy97:
return 1; return 1;
} }
#line 1326 "ext/standard/var_unserializer.c" #line 1325 "ext/standard/var_unserializer.c"
} }
#line 877 "ext/standard/var_unserializer.re" #line 877 "ext/standard/var_unserializer.re"

4
ext/standard/var_unserializer.re
View file

@ -243,10 +243,10 @@ static inline int unserialize_allowed_class(zend_string *class_name, HashTable *
return 0; return 0;
} }
STR_ALLOCA_ALLOC(lcname, class_name->len, use_heap); ZSTR_ALLOCA_ALLOC(lcname, class_name->len, use_heap);
zend_str_tolower_copy(lcname->val, class_name->val, class_name->len); zend_str_tolower_copy(lcname->val, class_name->val, class_name->len);
res = zend_hash_exists(classes, lcname); res = zend_hash_exists(classes, lcname);
STR_ALLOCA_FREE(lcname, use_heap); ZSTR_ALLOCA_FREE(lcname, use_heap);
return res; return res;
} }

4
ext/tidy/tidy.c
View file

@ -646,7 +646,7 @@ static zend_string *php_tidy_file_to_mem(char *filename, zend_bool use_include_p
return NULL; return NULL;
} }
if ((data = php_stream_copy_to_mem(stream, PHP_STREAM_COPY_ALL, 0)) == NULL) { if ((data = php_stream_copy_to_mem(stream, PHP_STREAM_COPY_ALL, 0)) == NULL) {
data = STR_EMPTY_ALLOC(); data = ZSTR_EMPTY_ALLOC();
} }
php_stream_close(stream); php_stream_close(stream);
@ -928,7 +928,7 @@ static void *php_tidy_get_opt_val(PHPTidyDoc *ptdoc, TidyOption opt, TidyOptionT
if (val) { if (val) {
return (void *) zend_string_init(val, strlen(val), 0); return (void *) zend_string_init(val, strlen(val), 0);
} else { } else {
return (void *) STR_EMPTY_ALLOC(); return (void *) ZSTR_EMPTY_ALLOC();
} }
} }
break; break;

4
ext/wddx/wddx.c
View file

@ -720,13 +720,13 @@ static void php_wddx_push_element(void *user_data, const XML_Char *name, const X
ent.type = ST_STRING; ent.type = ST_STRING;
SET_STACK_VARNAME; SET_STACK_VARNAME;
ZVAL_STR(&ent.data, STR_EMPTY_ALLOC()); ZVAL_STR(&ent.data, ZSTR_EMPTY_ALLOC());
wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry)); wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
} else if (!strcmp((char *)name, EL_BINARY)) { } else if (!strcmp((char *)name, EL_BINARY)) {
ent.type = ST_BINARY; ent.type = ST_BINARY;
SET_STACK_VARNAME; SET_STACK_VARNAME;
ZVAL_STR(&ent.data, STR_EMPTY_ALLOC()); ZVAL_STR(&ent.data, ZSTR_EMPTY_ALLOC());
wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry)); wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
} else if (!strcmp((char *)name, EL_CHAR)) { } else if (!strcmp((char *)name, EL_CHAR)) {
int i; int i;

2
main/streams/streams.c
View file

@ -1414,7 +1414,7 @@ PHPAPI zend_string *_php_stream_copy_to_mem(php_stream *src, size_t maxlen, int
zend_string *result; zend_string *result;
if (maxlen == 0) { if (maxlen == 0) {
return STR_EMPTY_ALLOC(); return ZSTR_EMPTY_ALLOC();
} }
if (maxlen == PHP_STREAM_COPY_ALL) { if (maxlen == PHP_STREAM_COPY_ALL) {

2
win32/sendmail.c
View file

@ -607,7 +607,7 @@ static int SendText(char *RPath, char *Subject, char *mailTo, char *mailCc, char
data_cln = php_str_to_str(data, strlen(data), PHP_WIN32_MAIL_DOT_PATTERN, sizeof(PHP_WIN32_MAIL_DOT_PATTERN) - 1, data_cln = php_str_to_str(data, strlen(data), PHP_WIN32_MAIL_DOT_PATTERN, sizeof(PHP_WIN32_MAIL_DOT_PATTERN) - 1,
PHP_WIN32_MAIL_DOT_REPLACE, sizeof(PHP_WIN32_MAIL_DOT_REPLACE) - 1); PHP_WIN32_MAIL_DOT_REPLACE, sizeof(PHP_WIN32_MAIL_DOT_REPLACE) - 1);
if (!data_cln) { if (!data_cln) {
data_cln = STR_EMPTY_ALLOC(); data_cln = ZSTR_EMPTY_ALLOC();
} }
/* send message contents in 1024 chunks */ /* send message contents in 1024 chunks */