clones/php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2024-09-21 09:57:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use better data structures (incomplete)

Browse Source
This commit is contained in:
Dmitry Stogov 2014-02-18 01:41:23 +04:00
parent 4d6ff31cb3
commit a0fe8e5a91
14 changed files with 387 additions and 431 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Zend/zend_API.c
View File

@ -763,7 +763,7 @@ static int zend_parse_va_args(int num_args, const char *type_spec, va_list *va,
int arg_count;
int quiet = flags & ZEND_PARSE_PARAMS_QUIET;
zend_bool have_varargs = 0;
zval ***varargs = NULL;
zval **varargs = NULL;
int *n_varargs = NULL;
for (spec_walk = type_spec; *spec_walk; spec_walk++) {
@ -869,7 +869,7 @@ static int zend_parse_va_args(int num_args, const char *type_spec, va_list *va,
int num_varargs = num_args + 1 - post_varargs;
/* eat up the passed in storage even if it won't be filled in with varargs */
varargs = va_arg(*va, zval ***);
varargs = va_arg(*va, zval **);
n_varargs = va_arg(*va, int *);
type_spec++;
@ -880,9 +880,11 @@ static int zend_parse_va_args(int num_args, const char *type_spec, va_list *va,
*n_varargs = num_varargs;
/* allocate space for array and store args */
*varargs = safe_emalloc(num_varargs, sizeof(zval *), 0);
*varargs = (zval*)safe_emalloc(num_varargs, sizeof(zval), 0);
while (num_varargs-- > 0) {
(*varargs)[iv++] = p++;
ZVAL_COPY_VALUE(&(*varargs)[iv], p);
iv++;
p++;
}
/* adjust how many args we have left and restart loop */

16
Zend/zend_API.h
View File

@ -545,16 +545,12 @@ END_EXTERN_C()
#define CHECK_NULL_PATH(p, l) (strlen(p) != l)
#define ZVAL_STRINGL(z, s, l) do { \
zval *_z = (z); \
int __l = l; \
ZVAL_STR(_z, STR_ALLOC(__l, 0)); \
memcpy(Z_STRVAL_P(_z), (s), __l + 1); \
ZVAL_STR(z, STR_INIT(s, l, 0)); \
} while (0)
#define ZVAL_STRING(z, s) do { \
const char *_s = (s); \
int _l = strlen(_s); \
ZVAL_STRINGL(z, _s, _l); \
ZVAL_STRINGL(z, _s, strlen(_s)); \
} while (0)
#define ZVAL_EMPTY_STRING(z) do { \
@ -562,16 +558,12 @@ END_EXTERN_C()
} while (0)
#define ZVAL_PSTRINGL(z, s, l) do { \
zval *_z = (z); \
int __l = l; \
ZVAL_STR(_z, STR_ALLOC(__l, 1)); \
memcpy(Z_STRVAL_P(_z), (s), __l + 1); \
ZVAL_STR(z, STR_INIT(s, l, 1)); \
} while (0)
#define ZVAL_PSTRING(z, s) do { \
const char *_s = (s); \
int _l = strlen(_s); \
ZVAL_PSTRINGL(z, _s, _l); \
ZVAL_PSTRINGL(z, _s, strlen(_s)); \
} while (0)
#define ZVAL_EMPTY_PSTRING(z) do { \

10
Zend/zend_compile.c
View File

@ -168,6 +168,7 @@ static void build_runtime_defined_function_key(zval *result, const char *name, i
ZVAL_STR(result, STR_ALLOC(1+name_length+strlen(filename)+char_pos_len, 0));
/* must be binary safe */
Z_STRVAL_P(result)[0] = '\0';
sprintf(Z_STRVAL_P(result)+1, "%s%s%s", name, filename, char_pos_buf);
}
/* }}} */
@ -298,7 +299,8 @@ ZEND_API zend_bool zend_is_compiling(TSRMLS_D) /* {{{ */
static zend_uint get_temporary_variable(zend_op_array *op_array) /* {{{ */
{
return (zend_uint)(zend_uintptr_t)EX_VAR_NUM_2(0, (op_array->T)++);
//??? return (zend_uint)(zend_uintptr_t)EX_VAR_NUM_2(0, (op_array->T)++);
return (zend_uint)op_array->T++;
}
/* }}} */
@ -340,11 +342,11 @@ void zend_del_literal(zend_op_array *op_array, int n) /* {{{ */
/* }}} */
/* Common part of zend_add_literal and zend_append_individual_literal */
static inline void zend_insert_literal(zend_op_array *op_array, const zval *zv, int literal_position TSRMLS_DC) /* {{{ */
static inline void zend_insert_literal(zend_op_array *op_array, zval *zv, int literal_position TSRMLS_DC) /* {{{ */
{
if (Z_TYPE_P(zv) == IS_STRING || Z_TYPE_P(zv) == IS_CONSTANT) {
STR_HASH_VAL(Z_STR_P(zv));
zend_new_interned_string(Z_STR_P(zv) TSRMLS_CC);
Z_STR_P(zv) = zend_new_interned_string(Z_STR_P(zv) TSRMLS_CC);
}
ZVAL_COPY_VALUE(&CONSTANT_EX(op_array, literal_position), zv);
//??? Z_SET_REFCOUNT(CONSTANT_EX(op_array, literal_position), 2);
@ -1715,7 +1717,7 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n
char *tmp = zend_str_tolower_dup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name));
if (Z_STRLEN_P(ns_name) != Z_STRLEN(function_name->u.constant) ||
memcmp(tmp, lcname, Z_STRLEN(function_name->u.constant))) {
memcmp(tmp, lcname->val, Z_STRLEN(function_name->u.constant))) {
zend_error(E_COMPILE_ERROR, "Cannot declare function %s because the name is already in use", Z_STRVAL(function_name->u.constant));
}
efree(tmp);

2
Zend/zend_compile.h
View File

@ -396,7 +396,7 @@ struct _zend_execute_data {
#define EX(element) execute_data.element
#define EX_VAR_2(ex, n) ((zval*)(((char*)(ex)) + ((int)(n))))
#define EX_VAR_NUM_2(ex, n) (EX_VAR_2(ex, 0) - (1 + (n)))
#define EX_VAR_NUM_2(ex, n) (((zval*)(((char*)(ex))+ZEND_MM_ALIGNED_SIZE(sizeof(zend_execute_data))))+(n))
#define EX_VAR(n) EX_VAR_2(execute_data, n)
#define EX_VAR_NUM(n) EX_VAR_NUM_2(execute_data, n)

8
Zend/zend_execute.c
View File

@ -212,7 +212,7 @@ static zend_never_inline zval *_get_zval_cv_lookup(zend_uint var, int type TSRML
zend_error(E_NOTICE, "Undefined variable: %s", cv->val);
/* break missing intentionally */
case BP_VAR_W:
ret = EX_VAR_2(EG(current_execute_data), var);
ret = EX_VAR_NUM_2(EG(current_execute_data), var);
ZVAL_NULL(ret);
if (EG(active_symbol_table)) {
ret = zend_hash_update(EG(active_symbol_table), cv, ret);
@ -267,7 +267,7 @@ static zend_never_inline zval *_get_zval_cv_lookup_BP_VAR_RW(zend_uint var TSRML
zval *ret;
if (!EG(active_symbol_table)) {
ret = EX_VAR_2(EG(current_execute_data), var);
ret = EX_VAR_NUM_2(EG(current_execute_data), var);
ZVAL_NULL(ret);
zend_error(E_NOTICE, "Undefined variable: %s", cv->val);
} else if ((ret = zend_hash_find(EG(active_symbol_table), cv)) == NULL) {
@ -283,7 +283,7 @@ static zend_never_inline zval *_get_zval_cv_lookup_BP_VAR_W(zend_uint var TSRMLS
zval *ret;
if (!EG(active_symbol_table)) {
ret = EX_VAR_2(EG(current_execute_data), var);
ret = EX_VAR_NUM_2(EG(current_execute_data), var);
ZVAL_NULL(ret);
} else if ((ret = zend_hash_find(EG(active_symbol_table), cv)) == NULL) {
ret = zend_hash_update(EG(active_symbol_table), cv, &EG(uninitialized_zval));
@ -1365,7 +1365,7 @@ void zend_free_compiled_variables(zend_execute_data *execute_data TSRMLS_DC) /*
* | VAR[op_array->last_var-1] |
* | VAR[op_array->last_var] |
* | ... |
* | VAR[op_array->T-1] |
* | VAR[op_array->last_var+op_array->T-1] |
* +----------------------------------------+
* EX(call_slots) -> | CALL_SLOT[0] |
* | ... |

3
Zend/zend_execute.h
View File

@ -226,7 +226,8 @@ static zend_always_inline zval *zend_vm_stack_top(TSRMLS_D)
static zend_always_inline void zend_vm_stack_push(zval *ptr TSRMLS_DC)
{
*(EG(argument_stack)->top++) = *ptr;
ZVAL_COPY_VALUE(EG(argument_stack)->top, ptr);
EG(argument_stack)->top++;
}
static zend_always_inline zval *zend_vm_stack_pop(TSRMLS_D)

13
Zend/zend_execute_API.c
View File

@ -129,6 +129,7 @@ static int clean_non_persistent_class_full(zend_class_entry **ce TSRMLS_DC) /* {
void init_executor(TSRMLS_D) /* {{{ */
{
zval tmp;
zend_init_fpu(TSRMLS_C);
ZVAL_NULL(&EG(uninitialized_zval));
@ -152,7 +153,8 @@ void init_executor(TSRMLS_D) /* {{{ */
EG(error_handling) = EH_NORMAL;
zend_vm_stack_init(TSRMLS_C);
//??? zend_vm_stack_push((void *) NULL TSRMLS_CC);
ZVAL_LONG(&tmp, 0);
zend_vm_stack_push(&tmp TSRMLS_CC);
zend_hash_init(&EG(symbol_table).ht, 50, NULL, ZVAL_PTR_DTOR, 0);
EG(active_symbol_table) = &EG(symbol_table).ht;
@ -734,6 +736,7 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
zval current_this;
zend_execute_data execute_data;
zend_fcall_info_cache fci_cache_local;
zval tmp;
fci->retval = NULL;
@ -821,7 +824,7 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
ZEND_VM_STACK_GROW_IF_NEEDED(fci->param_count + 1);
for (i=0; i<fci->param_count; i++) {
zval *param, tmp;
zval *param;
if (ARG_SHOULD_BE_SENT_BY_REF(EX(function_state).function, i + 1)) {
if (!Z_ISREF(fci->params[i]) && Z_REFCOUNT(fci->params[i]) > 1) {
@ -831,7 +834,8 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
!ARG_MAY_BE_SENT_BY_REF(EX(function_state).function, i + 1)) {
if (i || UNEXPECTED(ZEND_VM_STACK_ELEMETS(EG(argument_stack)) == (EG(argument_stack)->top))) {
/* hack to clean up the stack */
zend_vm_stack_push((void *) (zend_uintptr_t)i TSRMLS_CC);
ZVAL_LONG(&tmp, i);
zend_vm_stack_push(&tmp TSRMLS_CC);
zend_vm_stack_clear_multiple(0 TSRMLS_CC);
}
@ -866,7 +870,8 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
}
EX(function_state).arguments = zend_vm_stack_top(TSRMLS_C);
zend_vm_stack_push((void*)(zend_uintptr_t)fci->param_count TSRMLS_CC);
ZVAL_LONG(&tmp, fci->param_count);
zend_vm_stack_push(&tmp TSRMLS_CC);
current_scope = EG(scope);
EG(scope) = calling_scope;

16
Zend/zend_ini.h
View File

@ -115,7 +115,7 @@ END_EXTERN_C()
#define ZEND_INI_END() { 0, 0, NULL, 0, NULL, NULL, NULL, NULL, NULL, 0, NULL, 0, 0, 0, NULL } };
#define ZEND_INI_ENTRY3_EX(name, default_value, modifiable, on_modify, arg1, arg2, arg3, displayer) \
{ 0, modifiable, name, sizeof(name), on_modify, arg1, arg2, arg3, default_value, sizeof(default_value)-1, NULL, 0, 0, 0, displayer },
{ 0, modifiable, name, sizeof(name)-1, on_modify, arg1, arg2, arg3, default_value, sizeof(default_value)-1, NULL, 0, 0, 0, displayer },
#define ZEND_INI_ENTRY3(name, default_value, modifiable, on_modify, arg1, arg2, arg3) \
ZEND_INI_ENTRY3_EX(name, default_value, modifiable, on_modify, arg1, arg2, arg3, NULL)
@ -154,21 +154,21 @@ END_EXTERN_C()
ZEND_INI_ENTRY3_EX(name, default_value, modifiable, on_modify, (void *) XtOffsetOf(struct_type, property_name), (void *) &struct_ptr, NULL, zend_ini_boolean_displayer_cb)
#endif
#define INI_INT(name) zend_ini_long((name), sizeof(name), 0)
#define INI_FLT(name) zend_ini_double((name), sizeof(name), 0)
#define INI_STR(name) zend_ini_string_ex((name), sizeof(name), 0, NULL)
#define INI_INT(name) zend_ini_long((name), sizeof(name)-1, 0)
#define INI_FLT(name) zend_ini_double((name), sizeof(name)-1, 0)
#define INI_STR(name) zend_ini_string_ex((name), sizeof(name)-1, 0, NULL)
#define INI_BOOL(name) ((zend_bool) INI_INT(name))
#define INI_ORIG_INT(name) zend_ini_long((name), sizeof(name), 1)
#define INI_ORIG_FLT(name) zend_ini_double((name), sizeof(name), 1)
#define INI_ORIG_STR(name) zend_ini_string((name), sizeof(name), 1)
#define INI_ORIG_INT(name) zend_ini_long((name), sizeof(name)-1, 1)
#define INI_ORIG_FLT(name) zend_ini_double((name), sizeof(name)-1, 1)
#define INI_ORIG_STR(name) zend_ini_string((name), sizeof(name)-1, 1)
#define INI_ORIG_BOOL(name) ((zend_bool) INI_ORIG_INT(name))
#define REGISTER_INI_ENTRIES() zend_register_ini_entries(ini_entries, module_number TSRMLS_CC)
#define UNREGISTER_INI_ENTRIES() zend_unregister_ini_entries(module_number TSRMLS_CC)
#define DISPLAY_INI_ENTRIES() display_ini_entries(zend_module)
#define REGISTER_INI_DISPLAYER(name, displayer) zend_ini_register_displayer((name), sizeof(name), displayer)
#define REGISTER_INI_DISPLAYER(name, displayer) zend_ini_register_displayer((name), sizeof(name)-1, displayer)
#define REGISTER_INI_BOOLEAN(name) REGISTER_INI_DISPLAYER(name, zend_ini_boolean_displayer_cb)
/* Standard message handlers */

598
Zend/zend_language_scanner.c
View File

File diff suppressed because it is too large Load Diff

7
Zend/zend_language_scanner.l
View File

@ -1193,7 +1193,6 @@ NEWLINE ("\r"|"\n"|"\r\n")
<ST_LOOKING_FOR_PROPERTY>{LABEL} {
yy_pop_state(TSRMLS_C);
zend_copy_value(zendlval, yytext, yyleng);
zendlval->type = IS_STRING;
return T_STRING;
}
@ -1480,7 +1479,6 @@ NEWLINE ("\r"|"\n"|"\r\n")
<ST_LOOKING_FOR_VARNAME>{LABEL}[[}] {
yyless(yyleng - 1);
zend_copy_value(zendlval, yytext, yyleng);
zendlval->type = IS_STRING;
yy_pop_state(TSRMLS_C);
yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
return T_STRING_VARNAME;
@ -1819,7 +1817,6 @@ inline_html:
yyless(yyleng - 3);
yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
zendlval->type = IS_STRING;
return T_VARIABLE;
}
@ -1829,13 +1826,11 @@ inline_html:
yyless(yyleng - 1);
yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
zendlval->type = IS_STRING;
return T_VARIABLE;
}
<ST_IN_SCRIPTING,ST_DOUBLE_QUOTES,ST_HEREDOC,ST_BACKQUOTE,ST_VAR_OFFSET>"$"{LABEL} {
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
zendlval->type = IS_STRING;
return T_VARIABLE;
}
@ -1858,7 +1853,6 @@ inline_html:
<ST_IN_SCRIPTING,ST_VAR_OFFSET>{LABEL} {
zend_copy_value(zendlval, yytext, yyleng);
zendlval->type = IS_STRING;
return T_STRING;
}
@ -2363,7 +2357,6 @@ nowdoc_scan_done:
yyleng = YYCURSOR - SCNG(yy_text);
zend_copy_value(zendlval, yytext, yyleng - newline);
zendlval->type = IS_STRING;
HANDLE_NEWLINES(yytext, yyleng - newline);
return T_ENCAPSED_AND_WHITESPACE;
}

7
Zend/zend_opcode.c
View File

@ -695,9 +695,16 @@ ZEND_API int pass_two(zend_op_array *op_array TSRMLS_DC)
while (opline < end) {
if (opline->op1_type == IS_CONST) {
opline->op1.zv = &op_array->literals[opline->op1.constant].constant;
} else if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
opline->op1.var = (zend_uint)EX_VAR_NUM_2(NULL, op_array->last_var + opline->op1.var);
}
if (opline->op2_type == IS_CONST) {
opline->op2.zv = &op_array->literals[opline->op2.constant].constant;
} else if (opline->op2_type & (IS_VAR|IS_TMP_VAR)) {
opline->op2.var = (zend_uint)EX_VAR_NUM_2(NULL, op_array->last_var + opline->op2.var);
}
if (opline->result_type & (IS_VAR|IS_TMP_VAR)) {
opline->result.var = (zend_uint)EX_VAR_NUM_2(NULL, op_array->last_var + opline->result.var);
}
switch (opline->opcode) {
case ZEND_GOTO:

3
Zend/zend_string.h
View File

@ -110,7 +110,8 @@ static zend_always_inline zend_string *zend_str_init(const char *str, int len, i
{
zend_string *ret = STR_ALLOC(len, persistent);
memcpy(ret->val, str, len + 1);
memcpy(ret->val, str, len);
ret->val[len] = '\0';
return ret;
}

16
Zend/zend_vm_def.h
View File

@ -1027,7 +1027,6 @@ ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMP|VAR|CV, UNUSED|CONST|
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
/* break missing intentionally */
case BP_VAR_W:
Z_ADDREF_P(&EG(uninitialized_zval));
retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
break;
EMPTY_SWITCH_DEFAULT_CASE()
@ -1602,7 +1601,7 @@ ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
if (zend_assign_to_string_offset(EX_VAR((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
if (RETURN_VALUE_USED(opline)) {
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str->val + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
}
} else if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
@ -1650,7 +1649,7 @@ ZEND_VM_HANDLER(38, ZEND_ASSIGN, VAR|CV, CONST|TMP|VAR|CV)
if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
if (zend_assign_to_string_offset(EX_VAR(opline->op1.var), value, OP2_TYPE TSRMLS_CC)) {
if (RETURN_VALUE_USED(opline)) {
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->str + Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->offset, 1);
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->str->val + Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->offset, 1);
}
} else if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
@ -1748,7 +1747,7 @@ ZEND_VM_HELPER(zend_leave_helper, ANY, ANY)
i_free_compiled_variables(execute_data TSRMLS_CC);
}
zend_vm_stack_free((char*)execute_data - (ZEND_MM_ALIGNED_SIZE(sizeof(zval)) * op_array->T) TSRMLS_CC);
zend_vm_stack_free((char*)execute_data TSRMLS_CC);
if ((op_array->fn_flags & ZEND_ACC_CLOSURE) && op_array->prototype) {
zval_ptr_dtor((zval*)op_array->prototype);
@ -1877,8 +1876,11 @@ ZEND_VM_HELPER(zend_do_fcall_common_helper, ANY, ANY)
if (EX(call)->num_additional_args) {
EX(function_state).arguments = zend_vm_stack_push_args(num_args TSRMLS_CC);
} else {
zval tmp;
ZVAL_LONG(&tmp, num_args);
EX(function_state).arguments = zend_vm_stack_top(TSRMLS_C);
zend_vm_stack_push((void*)(zend_uintptr_t) num_args TSRMLS_CC);
zend_vm_stack_push(&tmp TSRMLS_CC);
}
LOAD_OPLINE();
@ -2955,7 +2957,7 @@ ZEND_VM_HELPER(zend_send_by_var_helper, VAR|CV, ANY)
varptr = Z_REFVAL_P(varptr);
}
} else if (OP1_TYPE == IS_CV) {
Z_ADDREF_P(varptr);
if (IS_REFCOUNTED(Z_TYPE_P(varptr))) Z_ADDREF_P(varptr);
}
zend_vm_stack_push(varptr TSRMLS_CC);
@ -3240,7 +3242,7 @@ ZEND_VM_HANDLER(63, ZEND_RECV, ANY, ANY)
zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, param, opline->extended_value TSRMLS_CC);
var_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
Z_DELREF_P(var_ptr);
if (IS_REFCOUNTED(Z_TYPE_P(var_ptr))) Z_DELREF_P(var_ptr);
ZVAL_COPY(var_ptr, param);
}

109
Zend/zend_vm_execute.h
View File

@ -392,7 +392,7 @@ static int ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
i_free_compiled_variables(execute_data TSRMLS_CC);
}
zend_vm_stack_free((char*)execute_data - (ZEND_MM_ALIGNED_SIZE(sizeof(zval)) * op_array->T) TSRMLS_CC);
zend_vm_stack_free((char*)execute_data TSRMLS_CC);
if ((op_array->fn_flags & ZEND_ACC_CLOSURE) && op_array->prototype) {
zval_ptr_dtor((zval*)op_array->prototype);
@ -521,8 +521,11 @@ static int ZEND_FASTCALL zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_AR
if (EX(call)->num_additional_args) {
EX(function_state).arguments = zend_vm_stack_push_args(num_args TSRMLS_CC);
} else {
zval tmp;
ZVAL_LONG(&tmp, num_args);
EX(function_state).arguments = zend_vm_stack_top(TSRMLS_C);
zend_vm_stack_push((void*)(zend_uintptr_t) num_args TSRMLS_CC);
zend_vm_stack_push(&tmp TSRMLS_CC);
}
LOAD_OPLINE();
@ -868,7 +871,7 @@ static int ZEND_FASTCALL ZEND_RECV_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, param, opline->extended_value TSRMLS_CC);
var_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
Z_DELREF_P(var_ptr);
if (IS_REFCOUNTED(Z_TYPE_P(var_ptr))) Z_DELREF_P(var_ptr);
ZVAL_COPY(var_ptr, param);
}
@ -3499,9 +3502,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type
varname = opline->op1.zv;
if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
ZVAL_DUP(&tmp_varname, varname);
//??? Z_SET_REFCOUNT(tmp_varname, 1);
//??? Z_UNSET_ISREF(tmp_varname);
ZVAL_DUP_DEREF(&tmp_varname, varname);
convert_to_string(&tmp_varname);
varname = &tmp_varname;
}
@ -3550,7 +3551,6 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
/* break missing intentionally */
case BP_VAR_W:
Z_ADDREF_P(&EG(uninitialized_zval));
retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
break;
EMPTY_SWITCH_DEFAULT_CASE()
@ -5248,9 +5248,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_VAR(int type,
varname = opline->op1.zv;
if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
ZVAL_DUP(&tmp_varname, varname);
//??? Z_SET_REFCOUNT(tmp_varname, 1);
//??? Z_UNSET_ISREF(tmp_varname);
ZVAL_DUP_DEREF(&tmp_varname, varname);
convert_to_string(&tmp_varname);
varname = &tmp_varname;
}
@ -5299,7 +5297,6 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_VAR(int type,
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
/* break missing intentionally */
case BP_VAR_W:
Z_ADDREF_P(&EG(uninitialized_zval));
retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
break;
EMPTY_SWITCH_DEFAULT_CASE()
@ -5930,9 +5927,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int typ
varname = opline->op1.zv;
if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
ZVAL_DUP(&tmp_varname, varname);
//??? Z_SET_REFCOUNT(tmp_varname, 1);
//??? Z_UNSET_ISREF(tmp_varname);
ZVAL_DUP_DEREF(&tmp_varname, varname);
convert_to_string(&tmp_varname);
varname = &tmp_varname;
}
@ -5981,7 +5976,6 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int typ
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
/* break missing intentionally */
case BP_VAR_W:
Z_ADDREF_P(&EG(uninitialized_zval));
retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
break;
EMPTY_SWITCH_DEFAULT_CASE()
@ -8524,9 +8518,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_CONST(int type,
varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
ZVAL_DUP(&tmp_varname, varname);
//??? Z_SET_REFCOUNT(tmp_varname, 1);
//??? Z_UNSET_ISREF(tmp_varname);
ZVAL_DUP_DEREF(&tmp_varname, varname);
convert_to_string(&tmp_varname);
varname = &tmp_varname;
}
@ -8575,7 +8567,6 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_CONST(int type,
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
/* break missing intentionally */
case BP_VAR_W:
Z_ADDREF_P(&EG(uninitialized_zval));
retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
break;
EMPTY_SWITCH_DEFAULT_CASE()
@ -10149,9 +10140,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_VAR(int type, ZE
varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
ZVAL_DUP(&tmp_varname, varname);
//??? Z_SET_REFCOUNT(tmp_varname, 1);
//??? Z_UNSET_ISREF(tmp_varname);
ZVAL_DUP_DEREF(&tmp_varname, varname);
convert_to_string(&tmp_varname);
varname = &tmp_varname;
}
@ -10200,7 +10189,6 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_VAR(int type, ZE
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
/* break missing intentionally */
case BP_VAR_W:
Z_ADDREF_P(&EG(uninitialized_zval));
retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
break;
EMPTY_SWITCH_DEFAULT_CASE()
@ -10834,9 +10822,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_UNUSED(int type,
varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
ZVAL_DUP(&tmp_varname, varname);
//??? Z_SET_REFCOUNT(tmp_varname, 1);
//??? Z_UNSET_ISREF(tmp_varname);
ZVAL_DUP_DEREF(&tmp_varname, varname);
convert_to_string(&tmp_varname);
varname = &tmp_varname;
}
@ -10885,7 +10871,6 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_UNUSED(int type,
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
/* break missing intentionally */
case BP_VAR_W:
Z_ADDREF_P(&EG(uninitialized_zval));
retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
break;
EMPTY_SWITCH_DEFAULT_CASE()
@ -12534,7 +12519,7 @@ static int ZEND_FASTCALL zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_AR
varptr = Z_REFVAL_P(varptr);
}
} else if (IS_VAR == IS_CV) {
Z_ADDREF_P(varptr);
if (IS_REFCOUNTED(Z_TYPE_P(varptr))) Z_ADDREF_P(varptr);
}
zend_vm_stack_push(varptr TSRMLS_CC);
@ -14055,9 +14040,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_CONST(int type,
varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
ZVAL_DUP(&tmp_varname, varname);
//??? Z_SET_REFCOUNT(tmp_varname, 1);
//??? Z_UNSET_ISREF(tmp_varname);
ZVAL_DUP_DEREF(&tmp_varname, varname);
convert_to_string(&tmp_varname);
varname = &tmp_varname;
}
@ -14106,7 +14089,6 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_CONST(int type,
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
/* break missing intentionally */
case BP_VAR_W:
Z_ADDREF_P(&EG(uninitialized_zval));
retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
break;
EMPTY_SWITCH_DEFAULT_CASE()
@ -14657,7 +14639,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN
if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
if (zend_assign_to_string_offset(EX_VAR((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
if (RETURN_VALUE_USED(opline)) {
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str->val + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
}
} else if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
@ -14705,7 +14687,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER
if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
if (zend_assign_to_string_offset(EX_VAR(opline->op1.var), value, IS_CONST TSRMLS_CC)) {
if (RETURN_VALUE_USED(opline)) {
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->str + Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->offset, 1);
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->str->val + Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->offset, 1);
}
} else if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
@ -16868,7 +16850,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDL
if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
if (zend_assign_to_string_offset(EX_VAR((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
if (RETURN_VALUE_USED(opline)) {
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str->val + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
}
} else if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
@ -16916,7 +16898,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_A
if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
if (zend_assign_to_string_offset(EX_VAR(opline->op1.var), value, IS_TMP_VAR TSRMLS_CC)) {
if (RETURN_VALUE_USED(opline)) {
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->str + Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->offset, 1);
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->str->val + Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->offset, 1);
}
} else if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
@ -18379,9 +18361,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_VAR(int type, ZE
varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
ZVAL_DUP(&tmp_varname, varname);
//??? Z_SET_REFCOUNT(tmp_varname, 1);
//??? Z_UNSET_ISREF(tmp_varname);
ZVAL_DUP_DEREF(&tmp_varname, varname);
convert_to_string(&tmp_varname);
varname = &tmp_varname;
}
@ -18430,7 +18410,6 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_VAR(int type, ZE
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
/* break missing intentionally */
case BP_VAR_W:
Z_ADDREF_P(&EG(uninitialized_zval));
retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
break;
EMPTY_SWITCH_DEFAULT_CASE()
@ -18982,7 +18961,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDL
if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
if (zend_assign_to_string_offset(EX_VAR((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
if (RETURN_VALUE_USED(opline)) {
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str->val + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
}
} else if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
@ -19030,7 +19009,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_A
if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
if (zend_assign_to_string_offset(EX_VAR(opline->op1.var), value, IS_VAR TSRMLS_CC)) {
if (RETURN_VALUE_USED(opline)) {
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->str + Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->offset, 1);
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->str->val + Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->offset, 1);
}
} else if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
@ -20237,9 +20216,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type,
varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
ZVAL_DUP(&tmp_varname, varname);
//??? Z_SET_REFCOUNT(tmp_varname, 1);
//??? Z_UNSET_ISREF(tmp_varname);
ZVAL_DUP_DEREF(&tmp_varname, varname);
convert_to_string(&tmp_varname);
varname = &tmp_varname;
}
@ -20288,7 +20265,6 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type,
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
/* break missing intentionally */
case BP_VAR_W:
Z_ADDREF_P(&EG(uninitialized_zval));
retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
break;
EMPTY_SWITCH_DEFAULT_CASE()
@ -20501,7 +20477,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HA
if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
if (zend_assign_to_string_offset(EX_VAR((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
if (RETURN_VALUE_USED(opline)) {
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str->val + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
}
} else if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
@ -22224,7 +22200,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE
if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
if (zend_assign_to_string_offset(EX_VAR((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
if (RETURN_VALUE_USED(opline)) {
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str->val + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
}
} else if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
@ -22272,7 +22248,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
if (zend_assign_to_string_offset(EX_VAR(opline->op1.var), value, IS_CV TSRMLS_CC)) {
if (RETURN_VALUE_USED(opline)) {
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->str + Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->offset, 1);
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->str->val + Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->offset, 1);
}
} else if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
@ -29091,7 +29067,7 @@ static int ZEND_FASTCALL zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARG
varptr = Z_REFVAL_P(varptr);
}
} else if (IS_CV == IS_CV) {
Z_ADDREF_P(varptr);
if (IS_REFCOUNTED(Z_TYPE_P(varptr))) Z_ADDREF_P(varptr);
}
zend_vm_stack_push(varptr TSRMLS_CC);
@ -30468,9 +30444,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_CONST(int type, Z
varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
ZVAL_DUP(&tmp_varname, varname);
//??? Z_SET_REFCOUNT(tmp_varname, 1);
//??? Z_UNSET_ISREF(tmp_varname);
ZVAL_DUP_DEREF(&tmp_varname, varname);
convert_to_string(&tmp_varname);
varname = &tmp_varname;
}
@ -30519,7 +30493,6 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_CONST(int type, Z
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
/* break missing intentionally */
case BP_VAR_W:
Z_ADDREF_P(&EG(uninitialized_zval));
retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
break;
EMPTY_SWITCH_DEFAULT_CASE()
@ -31065,7 +31038,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
if (zend_assign_to_string_offset(EX_VAR((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
if (RETURN_VALUE_USED(opline)) {
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str->val + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
}
} else if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
@ -31113,7 +31086,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_
if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
if (zend_assign_to_string_offset(EX_VAR(opline->op1.var), value, IS_CONST TSRMLS_CC)) {
if (RETURN_VALUE_USED(opline)) {
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->str + Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->offset, 1);
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->str->val + Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->offset, 1);
}
} else if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
@ -33057,7 +33030,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLE
if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
if (zend_assign_to_string_offset(EX_VAR((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
if (RETURN_VALUE_USED(opline)) {
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str->val + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
}
} else if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
@ -33105,7 +33078,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
if (zend_assign_to_string_offset(EX_VAR(opline->op1.var), value, IS_TMP_VAR TSRMLS_CC)) {
if (RETURN_VALUE_USED(opline)) {
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->str + Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->offset, 1);
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->str->val + Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->offset, 1);
}
} else if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
@ -34447,9 +34420,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_VAR(int type, ZEN
varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
ZVAL_DUP(&tmp_varname, varname);
//??? Z_SET_REFCOUNT(tmp_varname, 1);
//??? Z_UNSET_ISREF(tmp_varname);
ZVAL_DUP_DEREF(&tmp_varname, varname);
convert_to_string(&tmp_varname);
varname = &tmp_varname;
}
@ -34498,7 +34469,6 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_VAR(int type, ZEN
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
/* break missing intentionally */
case BP_VAR_W:
Z_ADDREF_P(&EG(uninitialized_zval));
retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
break;
EMPTY_SWITCH_DEFAULT_CASE()
@ -35045,7 +35015,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE
if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
if (zend_assign_to_string_offset(EX_VAR((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
if (RETURN_VALUE_USED(opline)) {
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str->val + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
}
} else if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
@ -35093,7 +35063,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
if (zend_assign_to_string_offset(EX_VAR(opline->op1.var), value, IS_VAR TSRMLS_CC)) {
if (RETURN_VALUE_USED(opline)) {
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->str + Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->offset, 1);
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->str->val + Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->offset, 1);
}
} else if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
@ -36178,9 +36148,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type,
varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
ZVAL_DUP(&tmp_varname, varname);
//??? Z_SET_REFCOUNT(tmp_varname, 1);
//??? Z_UNSET_ISREF(tmp_varname);
ZVAL_DUP_DEREF(&tmp_varname, varname);
convert_to_string(&tmp_varname);
varname = &tmp_varname;
}
@ -36229,7 +36197,6 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type,
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
/* break missing intentionally */
case BP_VAR_W:
Z_ADDREF_P(&EG(uninitialized_zval));
retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
break;
EMPTY_SWITCH_DEFAULT_CASE()
@ -36441,7 +36408,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAN
if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
if (zend_assign_to_string_offset(EX_VAR((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
if (RETURN_VALUE_USED(opline)) {
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str->val + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
}
} else if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
@ -38028,7 +37995,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
if (zend_assign_to_string_offset(EX_VAR((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
if (RETURN_VALUE_USED(opline)) {
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->str->val + Z_STR_OFFSET_P(EX_VAR((opline+1)->op2.var))->offset, 1);
}
} else if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
@ -38076,7 +38043,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
if (zend_assign_to_string_offset(EX_VAR(opline->op1.var), value, IS_CV TSRMLS_CC)) {
if (RETURN_VALUE_USED(opline)) {
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->str + Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->offset, 1);
ZVAL_STRINGL(EX_VAR(opline->result.var), Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->str->val + Z_STR_OFFSET_P(EX_VAR(opline->op1.var))->offset, 1);
}
} else if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));