09 Jul 2015, PHP 7.0.0 Beta 1
- Core:
+ . Improved zend_string API (Francois Laupretre)
. Fixed bug #69768 (escapeshell*() doesn't cater to !). (cmb)
. Fixed bug #69955 (Segfault when trying to combine [] and assign-op on
ArrayAccess object). (Laruence)
result = zend_symtable_update(ht, Z_STR_P(key), value);
break;
case IS_NULL:
- result = zend_symtable_update(ht, STR_EMPTY_ALLOC(), value);
+ result = zend_symtable_update(ht, ZSTR_EMPTY_ALLOC(), value);
break;
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_string *lcname;
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);
*strict_class = 0;
} else {
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;
}
/* }}} */
/* Skip leading \ */
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 {
lmname = Z_STR_P(callable);
}
* 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 (lmname != Z_STR_P(callable)) {
- STR_ALLOCA_FREE(lmname, use_heap);
+ ZSTR_ALLOCA_FREE(lmname, use_heap);
}
return 1;
} else {
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 {
zend_string_forget_hash_val(lmname);
}
zend_str_tolower(lmname->val, lmname->len);
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;
}
}
if (lmname != Z_STR_P(callable)) {
- STR_ALLOCA_FREE(lmname, use_heap);
+ ZSTR_ALLOCA_FREE(lmname, use_heap);
}
}
} while (0)
#define ZVAL_EMPTY_STRING(z) do { \
- ZVAL_INTERNED_STR(z, STR_EMPTY_ALLOC()); \
+ ZVAL_INTERNED_STR(z, ZSTR_EMPTY_ALLOC()); \
} while (0)
#define ZVAL_PSTRINGL(z, s, l) do { \
*dest = NULL;
*dest_len = 0;
} else {
- *dest = str->val;
- *dest_len = str->len;
+ *dest = ZSTR_VAL(str);
+ *dest_len = ZSTR_LEN(str);
}
return 1;
}
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) ||
- (*dest && UNEXPECTED(CHECK_NULL_PATH((*dest)->val, (*dest)->len)))) {
+ (*dest && UNEXPECTED(CHECK_NULL_PATH(ZSTR_VAL(*dest), ZSTR_LEN(*dest))))) {
return 0;
}
return 1;
*dest = NULL;
*dest_len = 0;
} else {
- *dest = str->val;
- *dest_len = str->len;
+ *dest = ZSTR_VAL(str);
+ *dest_len = ZSTR_LEN(str);
}
return 1;
}
zval_dtor(offset);
break;
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;
case IS_LONG:
zend_hash_index_update(Z_ARRVAL_P(result), Z_LVAL_P(offset), expr);
if (Z_TYPE_P(zv) == IS_STRING || Z_TYPE_P(zv) == IS_CONSTANT) {
zend_string_hash_val(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);
}
}
zend_string *lcname;
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);
result = zend_hash_find_ptr(ht, lcname);
- STR_ALLOCA_FREE(lcname, use_heap);
+ ZSTR_ALLOCA_FREE(lcname, use_heap);
return result;
}
zend_hash_index_update(Z_ARRVAL_P(result), 1, value);
break;
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;
default:
zend_error_noreturn(E_COMPILE_ERROR, "Illegal offset type");
DEFAULT_0_PARAMS;
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
exception = getThis();
ZVAL_STRINGL(&fname, "gettraceasstring", sizeof("gettraceasstring")-1);
zend_string *key;
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));
- STR_ALLOCA_FREE(key, use_heap);
+ ZSTR_ALLOCA_FREE(key, use_heap);
*class_name = (*pce) ? (*pce)->name->val : (char*)cur_arg_info->class_name;
if (*pce && (*pce)->ce_flags & ZEND_ACC_INTERFACE) {
} else {
switch (Z_TYPE_P(dim)) {
case IS_NULL:
- offset_key = STR_EMPTY_ALLOC();
+ offset_key = ZSTR_EMPTY_ALLOC();
goto str_index;
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(dim));
zend_hash_iterators_update(ht, HT_INVALID_IDX, idx);
p = ht->arData + idx;
p->key = key;
- if (!IS_INTERNED(key)) {
+ if (!ZSTR_IS_INTERNED(key)) {
zend_string_addref(key);
ht->u.flags &= ~HASH_FLAG_STATIC_KEYS;
zend_string_hash_val(key);
Bucket *p = ht->arData + idx;
ZVAL_COPY_VALUE(&p->val, zv);
- if (!IS_INTERNED(key)) {
+ if (!ZSTR_IS_INTERNED(key)) {
ht->u.flags &= ~HASH_FLAG_STATIC_KEYS;
zend_string_addref(key);
zend_string_hash_val(key);
Bucket *p = ht->arData + idx;
ZVAL_PTR(&p->val, ptr);
- if (!IS_INTERNED(key)) {
+ if (!ZSTR_IS_INTERNED(key)) {
ht->u.flags &= ~HASH_FLAG_STATIC_KEYS;
zend_string_addref(key);
zend_string_hash_val(key);
Bucket *p = ht->arData + idx;
ZVAL_INDIRECT(&p->val, ptr);
- if (!IS_INTERNED(key)) {
+ if (!ZSTR_IS_INTERNED(key)) {
ht->u.flags &= ~HASH_FLAG_STATIC_KEYS;
zend_string_addref(key);
zend_string_hash_val(key);
backticks_expr:
/* empty */
- { $$ = zend_ast_create_zval_from_str(STR_EMPTY_ALLOC()); }
+ { $$ = zend_ast_create_zval_from_str(ZSTR_EMPTY_ALLOC()); }
| T_ENCAPSED_AND_WHITESPACE { $$ = $1; }
| encaps_list { $$ = $1; }
;
| 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_END_HEREDOC
- { $$ = zend_ast_create_zval_from_str(STR_EMPTY_ALLOC()); }
+ { $$ = zend_ast_create_zval_from_str(ZSTR_EMPTY_ALLOC()); }
| '"' encaps_list '"' { $$ = $2; }
| T_START_HEREDOC encaps_list T_END_HEREDOC { $$ = $2; }
| dereferencable_scalar { $$ = $1; }
func->prototype = fbc;
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_end = (fbc->type == ZEND_USER_FUNCTION)? fbc->op_array.line_end : 0;
use_heap = 0;
#endif
} 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);
}
if (UNEXPECTED((func = zend_hash_find(&zobj->ce->function_table, lc_method_name)) == NULL)) {
if (UNEXPECTED(!key)) {
- STR_ALLOCA_FREE(lc_method_name, use_heap);
+ ZSTR_ALLOCA_FREE(lc_method_name, use_heap);
}
if (zobj->ce->__call) {
return zend_get_user_call_function(zobj->ce, method_name);
}
if (UNEXPECTED(!key)) {
- STR_ALLOCA_FREE(lc_method_name, use_heap);
+ ZSTR_ALLOCA_FREE(lc_method_name, use_heap);
}
return fbc;
}
case IS_UNDEF:
case IS_NULL:
case IS_FALSE:
- return STR_EMPTY_ALLOC();
+ return ZSTR_EMPTY_ALLOC();
case IS_TRUE:
return zend_string_init("1", 1, 0);
case IS_RESOURCE: {
zval_ptr_dtor(z);
}
zend_error(EG(exception) ? E_ERROR : E_RECOVERABLE_ERROR, "Object of class %s could not be converted to string", Z_OBJCE_P(op)->name->val);
- return STR_EMPTY_ALLOC();
+ return ZSTR_EMPTY_ALLOC();
}
case IS_REFERENCE:
op = Z_REFVAL_P(op);
#include <zend.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
# define SMART_STR_PAGE 4096
str->s->len = 0;
} else {
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);
}
}
str->s->len = 0;
} else {
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);
}
}
uint idx;
Bucket *p;
- if (IS_INTERNED(str)) {
+ if (ZSTR_IS_INTERNED(str)) {
return str;
}
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 { \
- (str) = (zend_string *)do_alloca(ZEND_MM_ALIGNED_SIZE(_STR_HEADER_SIZE + (_len) + 1), (use_heap)); \
+#define IS_INTERNED(s) ZSTR_IS_INTERNED(s)
+#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_TYPE_INFO(str) = IS_STRING; \
- (str)->h = 0; \
- (str)->len = (_len); \
+ zend_string_forget_hash_val(str); \
+ 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'; \
+
+#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 STR_ALLOCA_FREE(str, use_heap) free_alloca(str, use_heap)
+#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)
{
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;
}
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 1;
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 1;
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 1;
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;
#if 1
GC_FLAGS(ret) = (persistent ? IS_STR_PERSISTENT : 0);
GC_INFO(ret) = 0;
#endif
- ret->h = 0;
- ret->len = len;
+ zend_string_forget_hash_val(ret);
+ zend_string_set_len(ret, len);
return ret;
}
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;
#if 1
GC_FLAGS(ret) = (persistent ? IS_STR_PERSISTENT : 0);
GC_INFO(ret) = 0;
#endif
- ret->h = 0;
- ret->len = (n * m) + l;
+ zend_string_forget_hash_val(ret);
+ zend_string_set_len(ret, (n * m) + l);
return ret;
}
{
zend_string *ret = zend_string_alloc(len, persistent);
- memcpy(ret->val, str, len);
- ret->val[len] = '\0';
+ memcpy(ZSTR_VAL(ret), str, len);
+ ZSTR_VAL(ret)[len] = '\0';
return ret;
}
static zend_always_inline zend_string *zend_string_copy(zend_string *s)
{
- if (!IS_INTERNED(s)) {
+ if (!ZSTR_IS_INTERNED(s)) {
GC_REFCOUNT(s)++;
}
return s;
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;
} else {
- return zend_string_init(s->val, s->len, persistent);
+ return zend_string_init(ZSTR_VAL(s), ZSTR_LEN(s), persistent);
}
}
{
zend_string *ret;
- if (!IS_INTERNED(s)) {
+ if (!ZSTR_IS_INTERNED(s)) {
if (EXPECTED(GC_REFCOUNT(s) == 1)) {
- ret = (zend_string *)perealloc(s, ZEND_MM_ALIGNED_SIZE(_STR_HEADER_SIZE + len + 1), persistent);
- ret->len = len;
+ ret = (zend_string *)perealloc(s, ZEND_MM_ALIGNED_SIZE(_ZSTR_STRUCT_SIZE(len)), persistent);
+ zend_string_set_len(ret, len);
zend_string_forget_hash_val(ret);
return ret;
} else {
}
}
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;
}
{
zend_string *ret;
- ZEND_ASSERT(len >= s->len);
- if (!IS_INTERNED(s)) {
+ ZEND_ASSERT(len >= ZSTR_LEN(s));
+ if (!ZSTR_IS_INTERNED(s)) {
if (EXPECTED(GC_REFCOUNT(s) == 1)) {
- ret = (zend_string *)perealloc(s, ZEND_MM_ALIGNED_SIZE(_STR_HEADER_SIZE + len + 1), persistent);
- ret->len = len;
+ ret = (zend_string *)perealloc(s, ZEND_MM_ALIGNED_SIZE(_ZSTR_STRUCT_SIZE(len)), persistent);
+ zend_string_set_len(ret, len);
zend_string_forget_hash_val(ret);
return ret;
} else {
}
}
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;
}
{
zend_string *ret;
- ZEND_ASSERT(len <= s->len);
- if (!IS_INTERNED(s)) {
+ ZEND_ASSERT(len <= ZSTR_LEN(s));
+ if (!ZSTR_IS_INTERNED(s)) {
if (EXPECTED(GC_REFCOUNT(s) == 1)) {
- ret = (zend_string *)perealloc(s, ZEND_MM_ALIGNED_SIZE(_STR_HEADER_SIZE + len + 1), persistent);
- ret->len = len;
+ ret = (zend_string *)perealloc(s, ZEND_MM_ALIGNED_SIZE(_ZSTR_STRUCT_SIZE(len)), persistent);
+ zend_string_set_len(ret, len);
zend_string_forget_hash_val(ret);
return ret;
} else {
}
}
ret = zend_string_alloc(len, persistent);
- memcpy(ret->val, s->val, len + 1);
+ memcpy(ZSTR_VAL(ret), ZSTR_VAL(s), len + 1);
return ret;
}
{
zend_string *ret;
- if (!IS_INTERNED(s)) {
+ if (!ZSTR_IS_INTERNED(s)) {
if (GC_REFCOUNT(s) == 1) {
- ret = (zend_string *)safe_perealloc(s, n, m, ZEND_MM_ALIGNED_SIZE(_STR_HEADER_SIZE + l + 1), persistent);
- ret->len = (n * m) + l;
+ ret = (zend_string *)safe_perealloc(s, n, m, ZEND_MM_ALIGNED_SIZE(_ZSTR_STRUCT_SIZE(l)), persistent);
+ zend_string_set_len(ret, (n * m) + l);
zend_string_forget_hash_val(ret);
return ret;
} else {
}
}
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;
}
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);
pefree(s, GC_FLAGS(s) & IS_STR_PERSISTENT);
}
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) {
pefree(s, GC_FLAGS(s) & IS_STR_PERSISTENT);
}
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) \
- ((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) \
- ((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) \
- ((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)
zend_string *str;
str = zend_string_alloc(sizeof("")-1, 1);
- str->val[0] = '\000';
+ ZSTR_VAL(str)[0] = '\000';
#ifndef ZTS
*s = zend_new_interned_string(str);
#else
zend_string_hash_val(str);
- str->gc.u.v.flags |= IS_STR_INTERNED;
+ GC_FLAGS(str) |= IS_STR_INTERNED;
*s = str;
#endif
}
#define Z_STR(zval) (zval).value.str
#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_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_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_ARR(zval) (zval).value.arr
zend_string *__s = (s); \
Z_STR_P(__z) = __s; \
/* 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_STRING_EX; \
} while (0)
zend_string *__s = (s); \
Z_STR_P(__z) = __s; \
/* interned strings support */ \
- if (IS_INTERNED(__s)) { \
+ if (ZSTR_IS_INTERNED(__s)) { \
Z_TYPE_INFO_P(__z) = IS_INTERNED_STRING_EX; \
} else { \
GC_REFCOUNT(__s)++; \
}
}
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;
str = zend_string_realloc(op1_str, len + op2_str->len, 0);
offset = Z_REFVAL_P(offset);
ZEND_VM_C_GOTO(add_again);
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
ZEND_VM_C_GOTO(str_index);
} else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset));
ZEND_VM_C_GOTO(num_index);
} else if (OP2_TYPE == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
ZEND_VM_C_GOTO(str_index);
} else {
zend_error(E_WARNING, "Illegal offset type");
hval = zend_dval_to_lval(Z_DVAL_P(offset));
ZEND_VM_C_GOTO(num_index_dim);
} else if (Z_TYPE_P(offset) == IS_NULL) {
- key = STR_EMPTY_ALLOC();
+ key = ZSTR_EMPTY_ALLOC();
ZEND_VM_C_GOTO(str_index_dim);
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
ZEND_VM_C_GOTO(num_index_dim);
} else if (OP2_TYPE == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- key = STR_EMPTY_ALLOC();
+ key = ZSTR_EMPTY_ALLOC();
ZEND_VM_C_GOTO(str_index_dim);
} else {
zend_error(E_WARNING, "Illegal offset type in unset");
hval = zend_dval_to_lval(Z_DVAL_P(offset));
ZEND_VM_C_GOTO(num_index_prop);
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
ZEND_VM_C_GOTO(str_index_prop);
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
ZEND_VM_C_GOTO(num_index_prop);
} else if (OP2_TYPE == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
ZEND_VM_C_GOTO(str_index_prop);
} else {
zend_error(E_WARNING, "Illegal offset type in isset or empty");
}
}
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;
str = zend_string_realloc(op1_str, len + op2_str->len, 0);
offset = Z_REFVAL_P(offset);
goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else {
zend_error(E_WARNING, "Illegal offset type");
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_prop;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else {
zend_error(E_WARNING, "Illegal offset type in isset or empty");
offset = Z_REFVAL_P(offset);
goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index;
} else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else {
zend_error(E_WARNING, "Illegal offset type");
}
}
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;
str = zend_string_realloc(op1_str, len + op2_str->len, 0);
offset = Z_REFVAL_P(offset);
goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else {
zend_error(E_WARNING, "Illegal offset type");
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_prop;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else {
zend_error(E_WARNING, "Illegal offset type in isset or empty");
}
}
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;
str = zend_string_realloc(op1_str, len + op2_str->len, 0);
offset = Z_REFVAL_P(offset);
goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else {
zend_error(E_WARNING, "Illegal offset type");
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_prop;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else {
zend_error(E_WARNING, "Illegal offset type in isset or empty");
offset = Z_REFVAL_P(offset);
goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else {
zend_error(E_WARNING, "Illegal offset type");
offset = Z_REFVAL_P(offset);
goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index;
} else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else {
zend_error(E_WARNING, "Illegal offset type");
offset = Z_REFVAL_P(offset);
goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else {
zend_error(E_WARNING, "Illegal offset type");
offset = Z_REFVAL_P(offset);
goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else {
zend_error(E_WARNING, "Illegal offset type");
offset = Z_REFVAL_P(offset);
goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else {
zend_error(E_WARNING, "Illegal offset type");
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_dim;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- key = STR_EMPTY_ALLOC();
+ key = ZSTR_EMPTY_ALLOC();
goto str_index_dim;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_dim;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- key = STR_EMPTY_ALLOC();
+ key = ZSTR_EMPTY_ALLOC();
goto str_index_dim;
} else {
zend_error(E_WARNING, "Illegal offset type in unset");
offset = Z_REFVAL_P(offset);
goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index;
} else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else {
zend_error(E_WARNING, "Illegal offset type");
offset = Z_REFVAL_P(offset);
goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else {
zend_error(E_WARNING, "Illegal offset type");
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_dim;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- key = STR_EMPTY_ALLOC();
+ key = ZSTR_EMPTY_ALLOC();
goto str_index_dim;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_dim;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- key = STR_EMPTY_ALLOC();
+ key = ZSTR_EMPTY_ALLOC();
goto str_index_dim;
} else {
zend_error(E_WARNING, "Illegal offset type in unset");
offset = Z_REFVAL_P(offset);
goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else {
zend_error(E_WARNING, "Illegal offset type");
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_dim;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- key = STR_EMPTY_ALLOC();
+ key = ZSTR_EMPTY_ALLOC();
goto str_index_dim;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_dim;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- key = STR_EMPTY_ALLOC();
+ key = ZSTR_EMPTY_ALLOC();
goto str_index_dim;
} else {
zend_error(E_WARNING, "Illegal offset type in unset");
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_dim;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- key = STR_EMPTY_ALLOC();
+ key = ZSTR_EMPTY_ALLOC();
goto str_index_dim;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_dim;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- key = STR_EMPTY_ALLOC();
+ key = ZSTR_EMPTY_ALLOC();
goto str_index_dim;
} else {
zend_error(E_WARNING, "Illegal offset type in unset");
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_prop;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else {
zend_error(E_WARNING, "Illegal offset type in isset or empty");
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_dim;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- key = STR_EMPTY_ALLOC();
+ key = ZSTR_EMPTY_ALLOC();
goto str_index_dim;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_dim;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- key = STR_EMPTY_ALLOC();
+ key = ZSTR_EMPTY_ALLOC();
goto str_index_dim;
} else {
zend_error(E_WARNING, "Illegal offset type in unset");
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_prop;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else {
zend_error(E_WARNING, "Illegal offset type in isset or empty");
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_dim;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- key = STR_EMPTY_ALLOC();
+ key = ZSTR_EMPTY_ALLOC();
goto str_index_dim;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_dim;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- key = STR_EMPTY_ALLOC();
+ key = ZSTR_EMPTY_ALLOC();
goto str_index_dim;
} else {
zend_error(E_WARNING, "Illegal offset type in unset");
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_prop;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else {
zend_error(E_WARNING, "Illegal offset type in isset or empty");
}
}
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;
str = zend_string_realloc(op1_str, len + op2_str->len, 0);
offset = Z_REFVAL_P(offset);
goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else {
zend_error(E_WARNING, "Illegal offset type");
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_dim;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- key = STR_EMPTY_ALLOC();
+ key = ZSTR_EMPTY_ALLOC();
goto str_index_dim;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_dim;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- key = STR_EMPTY_ALLOC();
+ key = ZSTR_EMPTY_ALLOC();
goto str_index_dim;
} else {
zend_error(E_WARNING, "Illegal offset type in unset");
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_prop;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else {
zend_error(E_WARNING, "Illegal offset type in isset or empty");
offset = Z_REFVAL_P(offset);
goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index;
} else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else {
zend_error(E_WARNING, "Illegal offset type");
}
}
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;
str = zend_string_realloc(op1_str, len + op2_str->len, 0);
offset = Z_REFVAL_P(offset);
goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else {
zend_error(E_WARNING, "Illegal offset type");
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_dim;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- key = STR_EMPTY_ALLOC();
+ key = ZSTR_EMPTY_ALLOC();
goto str_index_dim;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_dim;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- key = STR_EMPTY_ALLOC();
+ key = ZSTR_EMPTY_ALLOC();
goto str_index_dim;
} else {
zend_error(E_WARNING, "Illegal offset type in unset");
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_prop;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else {
zend_error(E_WARNING, "Illegal offset type in isset or empty");
}
}
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;
str = zend_string_realloc(op1_str, len + op2_str->len, 0);
offset = Z_REFVAL_P(offset);
goto add_again;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else if (Z_TYPE_P(offset) == IS_DOUBLE) {
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index;
} else {
zend_error(E_WARNING, "Illegal offset type");
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_dim;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- key = STR_EMPTY_ALLOC();
+ key = ZSTR_EMPTY_ALLOC();
goto str_index_dim;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_dim;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- key = STR_EMPTY_ALLOC();
+ key = ZSTR_EMPTY_ALLOC();
goto str_index_dim;
} else {
zend_error(E_WARNING, "Illegal offset type in unset");
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_prop;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else {
zend_error(E_WARNING, "Illegal offset type in isset or empty");
}
}
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;
str = zend_string_realloc(op1_str, len + op2_str->len, 0);
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_prop;
} else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else {
zend_error(E_WARNING, "Illegal offset type in isset or empty");
}
}
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;
str = zend_string_realloc(op1_str, len + op2_str->len, 0);
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_prop;
} else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else {
zend_error(E_WARNING, "Illegal offset type in isset or empty");
}
}
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;
str = zend_string_realloc(op1_str, len + op2_str->len, 0);
hval = zend_dval_to_lval(Z_DVAL_P(offset));
goto num_index_prop;
} else if (Z_TYPE_P(offset) == IS_NULL) {
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else if (Z_TYPE_P(offset) == IS_FALSE) {
hval = 0;
goto num_index_prop;
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
GET_OP2_UNDEF_CV(offset, BP_VAR_R);
- str = STR_EMPTY_ALLOC();
+ str = ZSTR_EMPTY_ALLOC();
goto str_index_prop;
} else {
zend_error(E_WARNING, "Illegal offset type in isset or empty");
#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 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);
#if defined(PHP_WIN32) || defined(__GNUC__)
int weekYearSet = 0;
if (!format_len) {
- return STR_EMPTY_ALLOC();
+ return ZSTR_EMPTY_ALLOC();
}
if (localtime) {
char buffer[33];
if (!format_len) {
- return STR_EMPTY_ALLOC();
+ return ZSTR_EMPTY_ALLOC();
}
for (i = 0; i < format_len; i++) {
ALLOCA_FLAG(use_heap);
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);
} else {
lc_method_name = Z_STR_P(key);
end:
if (key == NULL) {
- STR_ALLOCA_FREE(lc_method_name, use_heap);
+ ZSTR_ALLOCA_FREE(lc_method_name, use_heap);
}
return ret;
zend_string *errMessage = 0;
if( !err && !( err = intl_g_error_get( ) ) )
- return STR_EMPTY_ALLOC();
+ return ZSTR_EMPTY_ALLOC();
uErrorName = u_errorName( err->code );
if (meta->name != mysqlnd_empty_string) {
meta->sname = zend_string_init(meta->name, meta->name_length, packet->persistent_alloc);
} else {
- meta->sname = STR_EMPTY_ALLOC();
+ meta->sname = ZSTR_EMPTY_ALLOC();
}
meta->name = meta->sname->val;
meta->name_length = meta->sname->len;
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)) {
/* no memory, return the same non-interned string */
zend_accel_error(ACCEL_LOG_WARNING, "Interned string buffer overflow");
ZCSG(interned_strings).nNumOfElements++;
p = ZCSG(interned_strings).arData + idx;
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;
GC_REFCOUNT(p->key) = 1;
#if 1
ZEND_HASH_FOREACH_BUCKET(&PCRE_G(pcre_cache), p) {
/* Remove PCRE cache entries with inconsistent keys */
- if (IS_INTERNED(p->key)) {
+ if (ZSTR_IS_INTERNED(p->key)) {
p->key = NULL;
zend_hash_del_bucket(&PCRE_G(pcre_cache), p);
}
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));
zend_shared_alloc_register_xlat_entry(str, ret);
if (info->str_size + len > ((zend_string*)ZCG(mem))->len) {
size_t new_len = info->str_size + len;
ZCG(mem) = (void*)zend_string_realloc(
(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);
}
memcpy(((zend_string*)ZCG(mem))->val + info->str_size, str, len);
mem = buf = emalloc(script->size);
#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();
if (!in_shm) {
zend_string_release(str); \
str = new_str; \
} 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); \
str = new_str; \
zend_string_hash_val(str); \
} \
} while (0)
#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); \
GC_FLAGS(str) = IS_STR_INTERNED | IS_STR_PERMANENT; \
} while (0)
#define ADD_ARENA_SIZE(m) ZCG(current_persistent_script)->arena_size += ZEND_ALIGNED_SIZE(m)
-# define ADD_STRING(str) \
- ADD_DUP_SIZE((str), _STR_HEADER_SIZE + (str)->len + 1)
+# define ADD_STRING(str) ADD_DUP_SIZE((str), _ZSTR_STRUCT_SIZE(ZSTR_LEN(str)))
+
# define ADD_INTERNED_STRING(str, do_free) do { \
if (!IS_ACCEL_INTERNED(str)) { \
zend_string *tmp = accel_new_interned_string(str); \
* as hash keys especually for this table.
* 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);
GC_REFCOUNT(str) = 0; /* will be incremented by zend_hash_update_mem() */
str->h = regex->h;
uint32_t replace_idx;
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);
/* If regex is an array */
data->st_size = sbuf.st_size;
if (sbuf.st_size == 0) {
- *val = STR_EMPTY_ALLOC();
+ *val = ZSTR_EMPTY_ALLOC();
return SUCCESS;
}
php_error_docref(NULL, E_WARNING, "read returned less bytes than requested");
}
zend_string_release(*val);
- *val = STR_EMPTY_ALLOC();
+ *val = ZSTR_EMPTY_ALLOC();
return FAILURE;
}
}
zend_string_release(val);
} 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));
}
}
res = zend_string_init((char*)tmp, strlen((char *)tmp), 0);
xmlFree(tmp);
} else {
- res = STR_EMPTY_ALLOC();
+ res = ZSTR_EMPTY_ALLOC();
}
return res;
switch (Z_TYPE_P(offset)) {
case IS_NULL:
- offset_key = STR_EMPTY_ALLOC();
+ offset_key = ZSTR_EMPTY_ALLOC();
goto fetch_dim_string;
case IS_STRING:
offset_key = Z_STR_P(offset);
}
RETURN_FALSE;
case IS_NULL:
- if (zend_hash_exists(array, STR_EMPTY_ALLOC())) {
+ if (zend_hash_exists(array, ZSTR_EMPTY_ALLOC())) {
RETURN_TRUE;
}
RETURN_FALSE;
(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))
) {
- // TODO: USE STR_EMPTY_ALLOC()?
+ // TODO: USE ZSTR_EMPTY_ALLOC()?
ZVAL_NEW_STR(&new_property, zend_string_init("", sizeof("")-1, persistent));
} else { /* Other than true/false setting */
ZVAL_STR(&new_property, zend_string_dup(Z_STR_P(arg2), persistent));
if (allowed != NULL) {
// TODO: reimplement to avoid reallocation ???
- if (IS_INTERNED(allowed)) {
+ if (ZSTR_IS_INTERNED(allowed)) {
allowed_tags = estrndup(allowed->val, allowed->len);
allowed_tags_len = allowed->len;
} else {
retval_len = php_strip_tags(retval, actual_len, &stream->fgetss_state, allowed_tags, allowed_tags_len);
// TODO: reimplement to avoid reallocation ???
- if (allowed && IS_INTERNED(allowed)) {
+ if (allowed && ZSTR_IS_INTERNED(allowed)) {
efree(allowed_tags);
}
continue;
} else {
zend_string_free(replaced);
- return STR_EMPTY_ALLOC();
+ return ZSTR_EMPTY_ALLOC();
}
} else { /* SUCCESS */
mbsequence = &old[cursor_before];
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);
} else if (GC_REFCOUNT(tmp) > 1) {
GC_REFCOUNT(tmp)--;
zend_ulong value;
if (Z_TYPE_P(arg) != IS_LONG || base < 2 || base > 36) {
- return STR_EMPTY_ALLOC();
+ return ZSTR_EMPTY_ALLOC();
}
value = Z_LVAL_P(arg);
static char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz";
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) {
/* Don't try to convert +/- infinity */
if (fvalue == HUGE_VAL || fvalue == -HUGE_VAL) {
php_error_docref(NULL, E_WARNING, "Number too large");
- return STR_EMPTY_ALLOC();
+ return ZSTR_EMPTY_ALLOC();
}
end = ptr = buf + sizeof(buf) - 1;
return;
}
- delim = STR_EMPTY_ALLOC();
+ delim = ZSTR_EMPTY_ALLOC();
arr = arg1;
} else {
if (Z_TYPE_P(arg1) == IS_ARRAY) {
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) {
needle = Z_STR_P(zneedle);
} else {
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;
}
ord_needle->val[1] = '\0';
}
if ((haystack->len == 0) || (needle->len == 0)) {
- STR_ALLOCA_FREE(ord_needle, use_heap);
+ ZSTR_ALLOCA_FREE(ord_needle, use_heap);
RETURN_FALSE;
}
Can also avoid tolower emallocs */
if (offset >= 0) {
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");
RETURN_FALSE;
}
} else {
p = haystack->val;
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");
RETURN_FALSE;
}
*ord_needle->val = tolower(*needle->val);
while (e >= p) {
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));
}
e--;
}
- STR_ALLOCA_FREE(ord_needle, use_heap);
+ ZSTR_ALLOCA_FREE(ord_needle, use_heap);
RETURN_FALSE;
}
if (offset >= 0) {
if ((size_t)offset > haystack->len) {
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");
RETURN_FALSE;
}
} else {
if (offset < -INT_MAX || (size_t)(-offset) > haystack->len) {
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");
RETURN_FALSE;
}
RETVAL_LONG(found - haystack_dup->val);
zend_string_release(needle_dup);
zend_string_release(haystack_dup);
- STR_ALLOCA_FREE(ord_needle, use_heap);
+ ZSTR_ALLOCA_FREE(ord_needle, use_heap);
} else {
zend_string_release(needle_dup);
zend_string_release(haystack_dup);
- STR_ALLOCA_FREE(ord_needle, use_heap);
+ ZSTR_ALLOCA_FREE(ord_needle, use_heap);
RETURN_FALSE;
}
}
zend_string *new_str;
if (!str) {
- return STR_EMPTY_ALLOC();
+ return ZSTR_EMPTY_ALLOC();
}
source = str->val;
rp = rbuf;
br = 0;
if (allow) {
-//??? if (IS_INTERNED(allow)) {
+//??? if (ZSTR_IS_INTERNED(allow)) {
//??? allow_free = allow = zend_str_tolower_dup(allow, allow_len);
//??? } else {
allow_free = NULL;
-/* Generated by re2c 0.13.7.5 */
+/* Generated by re2c 0.13.5 */
#line 1 "ext/standard/var_unserializer.re"
/*
+----------------------------------------------------------------------+
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);
res = zend_hash_exists(classes, lcname);
- STR_ALLOCA_FREE(lcname, use_heap);
+ ZSTR_ALLOCA_FREE(lcname, use_heap);
return res;
}
if (yybm[0+yych] & 128) {
goto yy20;
}
- if (yych <= '/') goto yy18;
- if (yych >= ';') goto yy18;
+ if (yych != ':') goto yy18;
yych = *++YYCURSOR;
if (yych != '"') goto yy18;
++YYCURSOR;
return object_common2(UNSERIALIZE_PASSTHRU, elements);
}
-#line 815 "ext/standard/var_unserializer.c"
+#line 814 "ext/standard/var_unserializer.c"
yy25:
yych = *++YYCURSOR;
if (yych <= ',') {
return object_common2(UNSERIALIZE_PASSTHRU,
object_common1(UNSERIALIZE_PASSTHRU, ZEND_STANDARD_CLASS_DEF_PTR));
}
-#line 848 "ext/standard/var_unserializer.c"
+#line 847 "ext/standard/var_unserializer.c"
yy32:
yych = *++YYCURSOR;
if (yych == '+') goto yy33;
return finish_nested_data(UNSERIALIZE_PASSTHRU);
}
-#line 890 "ext/standard/var_unserializer.c"
+#line 889 "ext/standard/var_unserializer.c"
yy39:
yych = *++YYCURSOR;
if (yych == '+') goto yy40;
ZVAL_STR(rval, str);
return 1;
}
-#line 939 "ext/standard/var_unserializer.c"
+#line 938 "ext/standard/var_unserializer.c"
yy46:
yych = *++YYCURSOR;
if (yych == '+') goto yy47;
ZVAL_STRINGL(rval, str, len);
return 1;
}
-#line 987 "ext/standard/var_unserializer.c"
+#line 986 "ext/standard/var_unserializer.c"
yy53:
yych = *++YYCURSOR;
if (yych <= '/') {
ZVAL_DOUBLE(rval, zend_strtod((const char *)start + 2, NULL));
return 1;
}
-#line 1084 "ext/standard/var_unserializer.c"
+#line 1083 "ext/standard/var_unserializer.c"
yy65:
yych = *++YYCURSOR;
if (yych <= ',') {
return 1;
}
-#line 1159 "ext/standard/var_unserializer.c"
+#line 1158 "ext/standard/var_unserializer.c"
yy76:
yych = *++YYCURSOR;
if (yych == 'N') goto yy73;
ZVAL_LONG(rval, parse_iv(start + 2));
return 1;
}
-#line 1212 "ext/standard/var_unserializer.c"
+#line 1211 "ext/standard/var_unserializer.c"
yy83:
yych = *++YYCURSOR;
if (yych <= '/') goto yy18;
ZVAL_BOOL(rval, parse_iv(start + 2));
return 1;
}
-#line 1226 "ext/standard/var_unserializer.c"
+#line 1225 "ext/standard/var_unserializer.c"
yy87:
++YYCURSOR;
#line 577 "ext/standard/var_unserializer.re"
ZVAL_NULL(rval);
return 1;
}
-#line 1235 "ext/standard/var_unserializer.c"
+#line 1234 "ext/standard/var_unserializer.c"
yy89:
yych = *++YYCURSOR;
if (yych <= ',') {
return 1;
}
-#line 1281 "ext/standard/var_unserializer.c"
+#line 1280 "ext/standard/var_unserializer.c"
yy95:
yych = *++YYCURSOR;
if (yych <= ',') {
return 1;
}
-#line 1326 "ext/standard/var_unserializer.c"
+#line 1325 "ext/standard/var_unserializer.c"
}
#line 877 "ext/standard/var_unserializer.re"
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);
res = zend_hash_exists(classes, lcname);
- STR_ALLOCA_FREE(lcname, use_heap);
+ ZSTR_ALLOCA_FREE(lcname, use_heap);
return res;
}
return 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);
if (val) {
return (void *) zend_string_init(val, strlen(val), 0);
} else {
- return (void *) STR_EMPTY_ALLOC();
+ return (void *) ZSTR_EMPTY_ALLOC();
}
}
break;
ent.type = ST_STRING;
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));
} else if (!strcmp((char *)name, EL_BINARY)) {
ent.type = ST_BINARY;
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));
} else if (!strcmp((char *)name, EL_CHAR)) {
int i;
zend_string *result;
if (maxlen == 0) {
- return STR_EMPTY_ALLOC();
+ return ZSTR_EMPTY_ALLOC();
}
if (maxlen == PHP_STREAM_COPY_ALL) {
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);
if (!data_cln) {
- data_cln = STR_EMPTY_ALLOC();
+ data_cln = ZSTR_EMPTY_ALLOC();
}
/* send message contents in 1024 chunks */
projects / php / commitdiff