Z_ADDREF_P(z);
if (Z_TYPE_P(z) != IS_OBJECT) {
- zval_ptr_dtor_nogc(arg);
+ zval_dtor(arg);
ZVAL_NULL(arg);
if (!zend_make_printable_zval(z, arg)) {
ZVAL_COPY_VALUE(arg, z);
if (zend_is_callable_ex(callable, NULL, IS_CALLABLE_STRICT, callable_name, &fcc, NULL)) {
if (Z_TYPE_P(callable) == IS_STRING && fcc.calling_scope) {
- zval_ptr_dtor_nogc(callable);
+ zval_dtor(callable);
array_init(callable);
add_next_index_str(callable, zend_string_copy(fcc.calling_scope->name));
add_next_index_str(callable, zend_string_copy(fcc.function_handler->common.function_name));
} else {
if (property != value) {
if (Z_ISREF_P(property)) {
- zval_ptr_dtor_nogc(property);
+ zval_dtor(property);
ZVAL_COPY_VALUE(property, value);
if (Z_REFCOUNTED_P(value) && Z_REFCOUNT_P(value) > 0) {
zval_opt_copy_ctor(property);
break;
case IS_STRING:
zend_symtable_update(Z_ARRVAL_P(result), Z_STR_P(offset), expr);
- zval_ptr_dtor_nogc(offset);
+ zval_dtor(offset);
break;
case IS_NULL:
zend_symtable_update(Z_ARRVAL_P(result), ZSTR_EMPTY_ALLOC(), expr);
if (UNEXPECTED(zend_ast_evaluate(&op1, ast->child[0], scope) != SUCCESS)) {
ret = FAILURE;
} else if (UNEXPECTED(zend_ast_evaluate(&op2, ast->child[1], scope) != SUCCESS)) {
- zval_ptr_dtor_nogc(&op1);
+ zval_dtor(&op1);
ret = FAILURE;
} else {
binary_op_type op = get_binary_op(ast->attr);
ret = op(result, &op1, &op2);
- zval_ptr_dtor_nogc(&op1);
- zval_ptr_dtor_nogc(&op2);
+ zval_dtor(&op1);
+ zval_dtor(&op2);
}
break;
case ZEND_AST_GREATER:
if (UNEXPECTED(zend_ast_evaluate(&op1, ast->child[0], scope) != SUCCESS)) {
ret = FAILURE;
} else if (UNEXPECTED(zend_ast_evaluate(&op2, ast->child[1], scope) != SUCCESS)) {
- zval_ptr_dtor_nogc(&op1);
+ zval_dtor(&op1);
ret = FAILURE;
} else {
/* op1 > op2 is the same as op2 < op1 */
binary_op_type op = ast->kind == ZEND_AST_GREATER
? is_smaller_function : is_smaller_or_equal_function;
ret = op(result, &op2, &op1);
- zval_ptr_dtor_nogc(&op1);
- zval_ptr_dtor_nogc(&op2);
+ zval_dtor(&op1);
+ zval_dtor(&op2);
}
break;
case ZEND_AST_UNARY_OP:
} else {
unary_op_type op = get_unary_op(ast->attr);
ret = op(result, &op1);
- zval_ptr_dtor_nogc(&op1);
+ zval_dtor(&op1);
}
break;
case ZEND_AST_ZVAL:
}
if (zend_is_true(&op1)) {
if (UNEXPECTED(zend_ast_evaluate(&op2, ast->child[1], scope) != SUCCESS)) {
- zval_ptr_dtor_nogc(&op1);
+ zval_dtor(&op1);
ret = FAILURE;
break;
}
ZVAL_BOOL(result, zend_is_true(&op2));
- zval_ptr_dtor_nogc(&op2);
+ zval_dtor(&op2);
} else {
ZVAL_FALSE(result);
}
- zval_ptr_dtor_nogc(&op1);
+ zval_dtor(&op1);
break;
case ZEND_AST_OR:
if (UNEXPECTED(zend_ast_evaluate(&op1, ast->child[0], scope) != SUCCESS)) {
ZVAL_TRUE(result);
} else {
if (UNEXPECTED(zend_ast_evaluate(&op2, ast->child[1], scope) != SUCCESS)) {
- zval_ptr_dtor_nogc(&op1);
+ zval_dtor(&op1);
ret = FAILURE;
break;
}
ZVAL_BOOL(result, zend_is_true(&op2));
- zval_ptr_dtor_nogc(&op2);
+ zval_dtor(&op2);
}
- zval_ptr_dtor_nogc(&op1);
+ zval_dtor(&op1);
break;
case ZEND_AST_CONDITIONAL:
if (UNEXPECTED(zend_ast_evaluate(&op1, ast->child[0], scope) != SUCCESS)) {
*result = op1;
} else {
if (UNEXPECTED(zend_ast_evaluate(result, ast->child[1], scope) != SUCCESS)) {
- zval_ptr_dtor_nogc(&op1);
+ zval_dtor(&op1);
ret = FAILURE;
break;
}
- zval_ptr_dtor_nogc(&op1);
+ zval_dtor(&op1);
}
} else {
if (UNEXPECTED(zend_ast_evaluate(result, ast->child[2], scope) != SUCCESS)) {
- zval_ptr_dtor_nogc(&op1);
+ zval_dtor(&op1);
ret = FAILURE;
break;
}
- zval_ptr_dtor_nogc(&op1);
+ zval_dtor(&op1);
}
break;
case ZEND_AST_COALESCE:
*result = op1;
} else {
if (UNEXPECTED(zend_ast_evaluate(result, ast->child[1], scope) != SUCCESS)) {
- zval_ptr_dtor_nogc(&op1);
+ zval_dtor(&op1);
ret = FAILURE;
break;
}
- zval_ptr_dtor_nogc(&op1);
+ zval_dtor(&op1);
}
break;
case ZEND_AST_UNARY_PLUS:
} else {
ZVAL_LONG(&op1, 0);
ret = add_function(result, &op1, &op2);
- zval_ptr_dtor_nogc(&op2);
+ zval_dtor(&op2);
}
break;
case ZEND_AST_UNARY_MINUS:
} else {
ZVAL_LONG(&op1, 0);
ret = sub_function(result, &op1, &op2);
- zval_ptr_dtor_nogc(&op2);
+ zval_dtor(&op2);
}
break;
case ZEND_AST_ARRAY:
zend_ast *elem = list->child[i];
if (elem->child[1]) {
if (UNEXPECTED(zend_ast_evaluate(&op1, elem->child[1], scope) != SUCCESS)) {
- zval_ptr_dtor_nogc(result);
+ zval_dtor(result);
return FAILURE;
}
} else {
ZVAL_UNDEF(&op1);
}
if (UNEXPECTED(zend_ast_evaluate(&op2, elem->child[0], scope) != SUCCESS)) {
- zval_ptr_dtor_nogc(&op1);
- zval_ptr_dtor_nogc(result);
+ zval_dtor(&op1);
+ zval_dtor(result);
return FAILURE;
}
if (UNEXPECTED(zend_ast_add_array_element(result, &op1, &op2) != SUCCESS)) {
- zval_ptr_dtor_nogc(&op1);
- zval_ptr_dtor_nogc(&op2);
- zval_ptr_dtor_nogc(result);
+ zval_dtor(&op1);
+ zval_dtor(&op2);
+ zval_dtor(result);
return FAILURE;
}
}
if (UNEXPECTED(zend_ast_evaluate(&op1, ast->child[0], scope) != SUCCESS)) {
ret = FAILURE;
} else if (UNEXPECTED(zend_ast_evaluate(&op2, ast->child[1], scope) != SUCCESS)) {
- zval_ptr_dtor_nogc(&op1);
+ zval_dtor(&op1);
ret = FAILURE;
} else {
zval tmp;
ZVAL_DUP(result, &tmp);
}
zval_ptr_dtor(&tmp);
- zval_ptr_dtor_nogc(&op1);
- zval_ptr_dtor_nogc(&op2);
+ zval_dtor(&op1);
+ zval_dtor(&op2);
}
break;
default:
void zend_del_literal(zend_op_array *op_array, int n) /* {{{ */
{
- zval_ptr_dtor_nogc(CT_CONSTANT_EX(op_array, n));
+ zval_dtor(CT_CONSTANT_EX(op_array, n));
if (n + 1 == op_array->last_literal) {
op_array->last_literal--;
} else {
if (arg_node.op_type == IS_CONST && Z_TYPE(arg_node.u.constant) == IS_STRING) {
result->op_type = IS_CONST;
ZVAL_LONG(&result->u.constant, Z_STRLEN(arg_node.u.constant));
- zval_ptr_dtor_nogc(&arg_node.u.constant);
+ zval_dtor(&arg_node.u.constant);
} else {
zend_emit_op_tmp(result, ZEND_STRLEN, &arg_node, NULL);
}
zend_error_noreturn(E_COMPILE_ERROR, "'goto' to undefined label '%s'", Z_STRVAL_P(label));
}
- zval_ptr_dtor_nogc(label);
+ zval_dtor(label);
ZVAL_NULL(label);
current = opline->extended_value;
SET_NODE(opline->op1, &expr_node);
SET_UNUSED(opline->op2);
} else if (expr_node.op_type == IS_CONST) {
- zval_ptr_dtor_nogc(&expr_node.u.constant);
+ zval_dtor(&expr_node.u.constant);
}
efree(jmpnz_opnums);
zval value_zv;
zend_const_expr_to_zval(&value_zv, value_ast);
FC(declarables).ticks = zval_get_long(&value_zv);
- zval_ptr_dtor_nogc(&value_zv);
+ zval_dtor(&value_zv);
} else if (zend_string_equals_literal_ci(name, "encoding")) {
if (FAILURE == zend_declare_is_first_statement(ast)) {
zend_error(E_NOTICE,"Constant %s already defined", ZSTR_VAL(name));
zend_string_release(c->name);
if (!(c->flags & CONST_PERSISTENT)) {
- zval_ptr_dtor_nogc(&c->value);
+ zval_dtor(&c->value);
}
ret = FAILURE;
}
if (!Z_DELREF_P(cv)) {
zend_refcounted *r = Z_COUNTED_P(cv);
ZVAL_NULL(cv);
- zval_dtor_func(r);
+ zval_dtor_func_for_ptr(r);
} else {
GC_ZVAL_CHECK_POSSIBLE_ROOT(cv);
}
Z_ADDREF_P(variable_ptr);
}
}
- zval_dtor_func(garbage);
+ zval_dtor_func_for_ptr(garbage);
return variable_ptr;
} else { /* we need to split */
/* optimized version of GC_ZVAL_CHECK_POSSIBLE_ROOT(variable_ptr) */
if (!Z_DELREF_P(p)) {
zend_refcounted *r = Z_COUNTED_P(p);
ZVAL_NULL(p);
- zval_dtor_func(r);
+ zval_dtor_func_for_ptr(r);
} else {
GC_ZVAL_CHECK_POSSIBLE_ROOT(p);
}
if (!Z_DELREF_P(p)) {
zend_refcounted *r = Z_COUNTED_P(p);
ZVAL_NULL(p);
- zval_dtor_func(r);
+ zval_dtor_func_for_ptr(r);
}
}
} while (p != end);
zend_exception_restore();
zval_ptr_dtor(&args[0]);
- zval_ptr_dtor_nogc(&fcall_info.function_name);
+ zval_dtor(&fcall_info.function_name);
zend_hash_del(EG(in_autoload), lc_name);
} else {
retval = FAILURE;
}
- zval_ptr_dtor_nogc(&pv);
+ zval_dtor(&pv);
return retval;
}
/* }}} */
gc_collect_cycles();
GC_REFCOUNT(ref)--;
if (UNEXPECTED(GC_REFCOUNT(ref)) == 0) {
- zval_dtor_func(ref);
+ zval_dtor_func_for_ptr(ref);
return;
}
if (UNEXPECTED(GC_INFO(ref))) {
int parent_num = OBJ_PROP_TO_NUM(parent_info->offset);
int child_num = OBJ_PROP_TO_NUM(child_info->offset);
- /* Don't keep default properties in GC (they may be freed by opcache) */
+ /* Don't keep default properties in GC (thry may be freed by opcache) */
zval_ptr_dtor_nogc(&(ce->default_properties_table[parent_num]));
ce->default_properties_table[parent_num] = ce->default_properties_table[child_num];
ZVAL_UNDEF(&ce->default_properties_table[child_num]);
if (Z_TYPE($2) == IS_STRING) {
zend_string_release(Z_STR($2));
} else {
- zval_ptr_dtor_nogc(&$2);
+ zval_dtor(&$2);
}
zval_ptr_dtor(&$5);
}
-/* Generated by re2c 0.14.3 */
+/* Generated by re2c 0.15.3 */
#line 1 "Zend/zend_language_scanner.l"
/*
+----------------------------------------------------------------------+
zend_destroy_file_handle(&file_handle);
if (filename==&tmp) {
- zval_ptr_dtor_nogc(&tmp);
+ zval_dtor(&tmp);
}
return retval;
}
}
zend_restore_lexical_state(&original_lex_state);
- zval_ptr_dtor_nogc(&tmp);
+ zval_dtor(&tmp);
return op_array;
}
SCNG(script_filtered) = NULL;
}
zend_restore_lexical_state(&original_lex_state);
- zval_ptr_dtor_nogc(str);
+ zval_dtor(str);
return SUCCESS;
}
goto yy4;
yy6:
YYDEBUG(6, *YYCURSOR);
- yyaccept = 0;
yych = *(YYMARKER = ++YYCURSOR);
if (yych <= 'O') {
if (yych == '=') goto yy8;
goto inline_char_handler;
}
}
-#line 1222 "Zend/zend_language_scanner.c"
+#line 1221 "Zend/zend_language_scanner.c"
yy8:
YYDEBUG(8, *YYCURSOR);
++YYCURSOR;
BEGIN(ST_IN_SCRIPTING);
RETURN_TOKEN(T_OPEN_TAG_WITH_ECHO);
}
-#line 1233 "Zend/zend_language_scanner.c"
+#line 1232 "Zend/zend_language_scanner.c"
yy10:
YYDEBUG(10, *YYCURSOR);
yych = *++YYCURSOR;
BEGIN(ST_IN_SCRIPTING);
RETURN_TOKEN(T_OPEN_TAG);
}
-#line 1270 "Zend/zend_language_scanner.c"
+#line 1269 "Zend/zend_language_scanner.c"
yy16:
YYDEBUG(16, *YYCURSOR);
++YYCURSOR;
zend_scan_escape_string(zendlval, yytext, yyleng, '`');
RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE);
}
-#line 1381 "Zend/zend_language_scanner.c"
+#line 1380 "Zend/zend_language_scanner.c"
yy21:
YYDEBUG(21, *YYCURSOR);
yych = *++YYCURSOR;
BEGIN(ST_IN_SCRIPTING);
RETURN_TOKEN('`');
}
-#line 1397 "Zend/zend_language_scanner.c"
+#line 1396 "Zend/zend_language_scanner.c"
yy24:
YYDEBUG(24, *YYCURSOR);
yych = *++YYCURSOR;
yyless(1);
RETURN_TOKEN(T_CURLY_OPEN);
}
-#line 1414 "Zend/zend_language_scanner.c"
+#line 1413 "Zend/zend_language_scanner.c"
yy27:
YYDEBUG(27, *YYCURSOR);
- yyaccept = 0;
YYMARKER = ++YYCURSOR;
YYFILL(3);
yych = *YYCURSOR;
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
RETURN_TOKEN(T_VARIABLE);
}
-#line 1436 "Zend/zend_language_scanner.c"
+#line 1434 "Zend/zend_language_scanner.c"
yy30:
YYDEBUG(30, *YYCURSOR);
++YYCURSOR;
yy_push_state(ST_LOOKING_FOR_VARNAME);
RETURN_TOKEN(T_DOLLAR_OPEN_CURLY_BRACES);
}
-#line 1447 "Zend/zend_language_scanner.c"
+#line 1445 "Zend/zend_language_scanner.c"
yy32:
YYDEBUG(32, *YYCURSOR);
yych = *++YYCURSOR;
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
RETURN_TOKEN(T_VARIABLE);
}
-#line 1468 "Zend/zend_language_scanner.c"
+#line 1466 "Zend/zend_language_scanner.c"
yy36:
YYDEBUG(36, *YYCURSOR);
yych = *++YYCURSOR;
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
RETURN_TOKEN(T_VARIABLE);
}
-#line 1493 "Zend/zend_language_scanner.c"
+#line 1491 "Zend/zend_language_scanner.c"
}
/* *********************************** */
yyc_ST_DOUBLE_QUOTES:
zend_scan_escape_string(zendlval, yytext, yyleng, '"');
RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE);
}
-#line 1610 "Zend/zend_language_scanner.c"
+#line 1608 "Zend/zend_language_scanner.c"
yy43:
YYDEBUG(43, *YYCURSOR);
yych = *++YYCURSOR;
BEGIN(ST_IN_SCRIPTING);
RETURN_TOKEN('"');
}
-#line 1626 "Zend/zend_language_scanner.c"
+#line 1624 "Zend/zend_language_scanner.c"
yy46:
YYDEBUG(46, *YYCURSOR);
yych = *++YYCURSOR;
yyless(1);
RETURN_TOKEN(T_CURLY_OPEN);
}
-#line 1643 "Zend/zend_language_scanner.c"
+#line 1641 "Zend/zend_language_scanner.c"
yy49:
YYDEBUG(49, *YYCURSOR);
- yyaccept = 0;
YYMARKER = ++YYCURSOR;
YYFILL(3);
yych = *YYCURSOR;
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
RETURN_TOKEN(T_VARIABLE);
}
-#line 1665 "Zend/zend_language_scanner.c"
+#line 1662 "Zend/zend_language_scanner.c"
yy52:
YYDEBUG(52, *YYCURSOR);
++YYCURSOR;
yy_push_state(ST_LOOKING_FOR_VARNAME);
RETURN_TOKEN(T_DOLLAR_OPEN_CURLY_BRACES);
}
-#line 1676 "Zend/zend_language_scanner.c"
+#line 1673 "Zend/zend_language_scanner.c"
yy54:
YYDEBUG(54, *YYCURSOR);
yych = *++YYCURSOR;
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
RETURN_TOKEN(T_VARIABLE);
}
-#line 1697 "Zend/zend_language_scanner.c"
+#line 1694 "Zend/zend_language_scanner.c"
yy58:
YYDEBUG(58, *YYCURSOR);
yych = *++YYCURSOR;
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
RETURN_TOKEN(T_VARIABLE);
}
-#line 1722 "Zend/zend_language_scanner.c"
+#line 1719 "Zend/zend_language_scanner.c"
}
/* *********************************** */
yyc_ST_END_HEREDOC:
BEGIN(ST_IN_SCRIPTING);
RETURN_TOKEN(T_END_HEREDOC);
}
-#line 1746 "Zend/zend_language_scanner.c"
+#line 1743 "Zend/zend_language_scanner.c"
/* *********************************** */
yyc_ST_HEREDOC:
{
zend_scan_escape_string(zendlval, yytext, yyleng - newline, 0);
RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE);
}
-#line 1881 "Zend/zend_language_scanner.c"
+#line 1878 "Zend/zend_language_scanner.c"
yy69:
YYDEBUG(69, *YYCURSOR);
yych = *++YYCURSOR;
yyless(1);
RETURN_TOKEN(T_CURLY_OPEN);
}
-#line 1903 "Zend/zend_language_scanner.c"
+#line 1900 "Zend/zend_language_scanner.c"
yy73:
YYDEBUG(73, *YYCURSOR);
- yyaccept = 0;
YYMARKER = ++YYCURSOR;
YYFILL(3);
yych = *YYCURSOR;
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
RETURN_TOKEN(T_VARIABLE);
}
-#line 1925 "Zend/zend_language_scanner.c"
+#line 1921 "Zend/zend_language_scanner.c"
yy76:
YYDEBUG(76, *YYCURSOR);
++YYCURSOR;
yy_push_state(ST_LOOKING_FOR_VARNAME);
RETURN_TOKEN(T_DOLLAR_OPEN_CURLY_BRACES);
}
-#line 1936 "Zend/zend_language_scanner.c"
+#line 1932 "Zend/zend_language_scanner.c"
yy78:
YYDEBUG(78, *YYCURSOR);
yych = *++YYCURSOR;
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
RETURN_TOKEN(T_VARIABLE);
}
-#line 1957 "Zend/zend_language_scanner.c"
+#line 1953 "Zend/zend_language_scanner.c"
yy82:
YYDEBUG(82, *YYCURSOR);
yych = *++YYCURSOR;
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
RETURN_TOKEN(T_VARIABLE);
}
-#line 1982 "Zend/zend_language_scanner.c"
+#line 1978 "Zend/zend_language_scanner.c"
}
/* *********************************** */
yyc_ST_IN_SCRIPTING:
YYDEBUG(85, *YYCURSOR);
YYFILL(16);
yych = *YYCURSOR;
- YYDEBUG(-1, yych);
switch (yych) {
case 0x00:
case 0x01:
yy87:
YYDEBUG(87, *YYCURSOR);
++YYCURSOR;
- YYDEBUG(-1, yych);
switch ((yych = *YYCURSOR)) {
case 'C':
case 'c': goto yy705;
zend_copy_value(zendlval, yytext, yyleng);
RETURN_TOKEN(T_STRING);
}
-#line 2171 "Zend/zend_language_scanner.c"
+#line 2165 "Zend/zend_language_scanner.c"
yy89:
YYDEBUG(89, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(yytext[0]);
}
-#line 2407 "Zend/zend_language_scanner.c"
+#line 2401 "Zend/zend_language_scanner.c"
yy104:
YYDEBUG(104, *YYCURSOR);
++YYCURSOR;
HANDLE_NEWLINES(yytext, yyleng);
RETURN_TOKEN(T_WHITESPACE);
}
-#line 2421 "Zend/zend_language_scanner.c"
+#line 2415 "Zend/zend_language_scanner.c"
yy106:
YYDEBUG(106, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_NS_SEPARATOR);
}
-#line 2436 "Zend/zend_language_scanner.c"
+#line 2430 "Zend/zend_language_scanner.c"
yy109:
YYDEBUG(109, *YYCURSOR);
yyaccept = 1;
yy_push_state(ST_IN_SCRIPTING);
RETURN_TOKEN('{');
}
-#line 2670 "Zend/zend_language_scanner.c"
+#line 2664 "Zend/zend_language_scanner.c"
yy134:
YYDEBUG(134, *YYCURSOR);
++YYCURSOR;
}
RETURN_TOKEN('}');
}
-#line 2684 "Zend/zend_language_scanner.c"
+#line 2678 "Zend/zend_language_scanner.c"
yy136:
YYDEBUG(136, *YYCURSOR);
yyaccept = 2;
ZEND_ASSERT(!errno);
RETURN_TOKEN(T_LNUMBER);
}
-#line 2757 "Zend/zend_language_scanner.c"
+#line 2751 "Zend/zend_language_scanner.c"
yy138:
YYDEBUG(138, *YYCURSOR);
yyaccept = 2;
RETURN_TOKEN(T_COMMENT);
}
-#line 2814 "Zend/zend_language_scanner.c"
+#line 2808 "Zend/zend_language_scanner.c"
yy142:
YYDEBUG(142, *YYCURSOR);
++YYCURSOR;
}
RETURN_TOKEN(T_CONSTANT_ENCAPSED_STRING);
}
-#line 2889 "Zend/zend_language_scanner.c"
+#line 2883 "Zend/zend_language_scanner.c"
yy144:
YYDEBUG(144, *YYCURSOR);
++YYCURSOR;
BEGIN(ST_DOUBLE_QUOTES);
RETURN_TOKEN('"');
}
-#line 2937 "Zend/zend_language_scanner.c"
+#line 2931 "Zend/zend_language_scanner.c"
yy146:
YYDEBUG(146, *YYCURSOR);
++YYCURSOR;
BEGIN(ST_BACKQUOTE);
RETURN_TOKEN('`');
}
-#line 2948 "Zend/zend_language_scanner.c"
+#line 2942 "Zend/zend_language_scanner.c"
yy148:
YYDEBUG(148, *YYCURSOR);
++YYCURSOR;
zend_error(E_COMPILE_WARNING,"Unexpected character in input: '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE);
goto restart;
}
-#line 2963 "Zend/zend_language_scanner.c"
+#line 2957 "Zend/zend_language_scanner.c"
yy150:
YYDEBUG(150, *YYCURSOR);
++YYCURSOR;
ZEND_ASSERT(end == yytext + yyleng);
RETURN_TOKEN(T_DNUMBER);
}
-#line 2999 "Zend/zend_language_scanner.c"
+#line 2993 "Zend/zend_language_scanner.c"
yy155:
YYDEBUG(155, *YYCURSOR);
yyaccept = 2;
RETURN_TOKEN(T_DNUMBER);
}
}
-#line 3123 "Zend/zend_language_scanner.c"
+#line 3117 "Zend/zend_language_scanner.c"
yy167:
YYDEBUG(167, *YYCURSOR);
++YYCURSOR;
RETURN_TOKEN(T_DNUMBER);
}
}
-#line 3163 "Zend/zend_language_scanner.c"
+#line 3157 "Zend/zend_language_scanner.c"
yy170:
YYDEBUG(170, *YYCURSOR);
++YYCURSOR;
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
RETURN_TOKEN(T_VARIABLE);
}
-#line 3193 "Zend/zend_language_scanner.c"
+#line 3187 "Zend/zend_language_scanner.c"
yy173:
YYDEBUG(173, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_LOGICAL_XOR);
}
-#line 3211 "Zend/zend_language_scanner.c"
+#line 3205 "Zend/zend_language_scanner.c"
yy176:
YYDEBUG(176, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_LOGICAL_OR);
}
-#line 3224 "Zend/zend_language_scanner.c"
+#line 3218 "Zend/zend_language_scanner.c"
yy178:
YYDEBUG(178, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_XOR_EQUAL);
}
-#line 3234 "Zend/zend_language_scanner.c"
+#line 3228 "Zend/zend_language_scanner.c"
yy180:
YYDEBUG(180, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_BOOLEAN_OR);
}
-#line 3244 "Zend/zend_language_scanner.c"
+#line 3238 "Zend/zend_language_scanner.c"
yy182:
YYDEBUG(182, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_OR_EQUAL);
}
-#line 3254 "Zend/zend_language_scanner.c"
+#line 3248 "Zend/zend_language_scanner.c"
yy184:
YYDEBUG(184, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_BOOLEAN_AND);
}
-#line 3264 "Zend/zend_language_scanner.c"
+#line 3258 "Zend/zend_language_scanner.c"
yy186:
YYDEBUG(186, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_AND_EQUAL);
}
-#line 3274 "Zend/zend_language_scanner.c"
+#line 3268 "Zend/zend_language_scanner.c"
yy188:
YYDEBUG(188, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_MOD_EQUAL);
}
-#line 3284 "Zend/zend_language_scanner.c"
+#line 3278 "Zend/zend_language_scanner.c"
yy190:
YYDEBUG(190, *YYCURSOR);
yyaccept = 4;
RETURN_TOKEN(T_COMMENT);
}
-#line 3326 "Zend/zend_language_scanner.c"
+#line 3320 "Zend/zend_language_scanner.c"
yy192:
YYDEBUG(192, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_DIV_EQUAL);
}
-#line 3340 "Zend/zend_language_scanner.c"
+#line 3334 "Zend/zend_language_scanner.c"
yy195:
YYDEBUG(195, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_POW);
}
-#line 3368 "Zend/zend_language_scanner.c"
+#line 3362 "Zend/zend_language_scanner.c"
yy200:
YYDEBUG(200, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_MUL_EQUAL);
}
-#line 3378 "Zend/zend_language_scanner.c"
+#line 3372 "Zend/zend_language_scanner.c"
yy202:
YYDEBUG(202, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_POW_EQUAL);
}
-#line 3388 "Zend/zend_language_scanner.c"
+#line 3382 "Zend/zend_language_scanner.c"
yy204:
YYDEBUG(204, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_SR);
}
-#line 3399 "Zend/zend_language_scanner.c"
+#line 3393 "Zend/zend_language_scanner.c"
yy206:
YYDEBUG(206, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_IS_GREATER_OR_EQUAL);
}
-#line 3409 "Zend/zend_language_scanner.c"
+#line 3403 "Zend/zend_language_scanner.c"
yy208:
YYDEBUG(208, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_SR_EQUAL);
}
-#line 3419 "Zend/zend_language_scanner.c"
+#line 3413 "Zend/zend_language_scanner.c"
yy210:
YYDEBUG(210, *YYCURSOR);
yyaccept = 5;
{
RETURN_TOKEN(T_SL);
}
-#line 3434 "Zend/zend_language_scanner.c"
+#line 3428 "Zend/zend_language_scanner.c"
yy212:
YYDEBUG(212, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_IS_SMALLER_OR_EQUAL);
}
-#line 3445 "Zend/zend_language_scanner.c"
+#line 3439 "Zend/zend_language_scanner.c"
yy214:
YYDEBUG(214, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_IS_NOT_EQUAL);
}
-#line 3456 "Zend/zend_language_scanner.c"
+#line 3450 "Zend/zend_language_scanner.c"
yy216:
YYDEBUG(216, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_SPACESHIP);
}
-#line 3466 "Zend/zend_language_scanner.c"
+#line 3460 "Zend/zend_language_scanner.c"
yy218:
YYDEBUG(218, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_SL_EQUAL);
}
-#line 3476 "Zend/zend_language_scanner.c"
+#line 3470 "Zend/zend_language_scanner.c"
yy220:
YYDEBUG(220, *YYCURSOR);
++YYCURSOR;
RETURN_TOKEN(T_START_HEREDOC);
}
-#line 3628 "Zend/zend_language_scanner.c"
+#line 3622 "Zend/zend_language_scanner.c"
yy231:
YYDEBUG(231, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_IS_NOT_IDENTICAL);
}
-#line 3672 "Zend/zend_language_scanner.c"
+#line 3666 "Zend/zend_language_scanner.c"
yy237:
YYDEBUG(237, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_PLUS_EQUAL);
}
-#line 3682 "Zend/zend_language_scanner.c"
+#line 3676 "Zend/zend_language_scanner.c"
yy239:
YYDEBUG(239, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_INC);
}
-#line 3692 "Zend/zend_language_scanner.c"
+#line 3686 "Zend/zend_language_scanner.c"
yy241:
YYDEBUG(241, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_LIST);
}
-#line 3715 "Zend/zend_language_scanner.c"
+#line 3709 "Zend/zend_language_scanner.c"
yy245:
YYDEBUG(245, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_IS_EQUAL);
}
-#line 3726 "Zend/zend_language_scanner.c"
+#line 3720 "Zend/zend_language_scanner.c"
yy247:
YYDEBUG(247, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_DOUBLE_ARROW);
}
-#line 3736 "Zend/zend_language_scanner.c"
+#line 3730 "Zend/zend_language_scanner.c"
yy249:
YYDEBUG(249, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_IS_IDENTICAL);
}
-#line 3746 "Zend/zend_language_scanner.c"
+#line 3740 "Zend/zend_language_scanner.c"
yy251:
YYDEBUG(251, *YYCURSOR);
yych = *++YYCURSOR;
- YYDEBUG(-1, yych);
switch (yych) {
case 'C':
case 'c': goto yy253;
{
RETURN_TOKEN(T_NS_C);
}
-#line 3880 "Zend/zend_language_scanner.c"
+#line 3873 "Zend/zend_language_scanner.c"
yy271:
YYDEBUG(271, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_DIR);
}
-#line 3904 "Zend/zend_language_scanner.c"
+#line 3897 "Zend/zend_language_scanner.c"
yy276:
YYDEBUG(276, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_LINE);
}
-#line 3933 "Zend/zend_language_scanner.c"
+#line 3926 "Zend/zend_language_scanner.c"
yy282:
YYDEBUG(282, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_METHOD_C);
}
-#line 3972 "Zend/zend_language_scanner.c"
+#line 3965 "Zend/zend_language_scanner.c"
yy290:
YYDEBUG(290, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_FUNC_C);
}
-#line 4027 "Zend/zend_language_scanner.c"
+#line 4020 "Zend/zend_language_scanner.c"
yy301:
YYDEBUG(301, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_FILE);
}
-#line 4051 "Zend/zend_language_scanner.c"
+#line 4044 "Zend/zend_language_scanner.c"
yy306:
YYDEBUG(306, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_TRAIT_C);
}
-#line 4085 "Zend/zend_language_scanner.c"
+#line 4078 "Zend/zend_language_scanner.c"
yy313:
YYDEBUG(313, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_CLASS_C);
}
-#line 4119 "Zend/zend_language_scanner.c"
+#line 4112 "Zend/zend_language_scanner.c"
yy320:
YYDEBUG(320, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_HALT_COMPILER);
}
-#line 4185 "Zend/zend_language_scanner.c"
+#line 4178 "Zend/zend_language_scanner.c"
yy333:
YYDEBUG(333, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_USE);
}
-#line 4209 "Zend/zend_language_scanner.c"
+#line 4202 "Zend/zend_language_scanner.c"
yy337:
YYDEBUG(337, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_UNSET);
}
-#line 4232 "Zend/zend_language_scanner.c"
+#line 4225 "Zend/zend_language_scanner.c"
yy341:
YYDEBUG(341, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_INT_CAST);
}
-#line 4408 "Zend/zend_language_scanner.c"
+#line 4401 "Zend/zend_language_scanner.c"
yy359:
YYDEBUG(359, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_DOUBLE_CAST);
}
-#line 4456 "Zend/zend_language_scanner.c"
+#line 4449 "Zend/zend_language_scanner.c"
yy368:
YYDEBUG(368, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_STRING_CAST);
}
-#line 4530 "Zend/zend_language_scanner.c"
+#line 4523 "Zend/zend_language_scanner.c"
yy382:
YYDEBUG(382, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_ARRAY_CAST);
}
-#line 4567 "Zend/zend_language_scanner.c"
+#line 4560 "Zend/zend_language_scanner.c"
yy389:
YYDEBUG(389, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_OBJECT_CAST);
}
-#line 4609 "Zend/zend_language_scanner.c"
+#line 4602 "Zend/zend_language_scanner.c"
yy397:
YYDEBUG(397, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_BOOL_CAST);
}
-#line 4654 "Zend/zend_language_scanner.c"
+#line 4647 "Zend/zend_language_scanner.c"
yy405:
YYDEBUG(405, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_UNSET_CAST);
}
-#line 4718 "Zend/zend_language_scanner.c"
+#line 4711 "Zend/zend_language_scanner.c"
yy417:
YYDEBUG(417, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_VAR);
}
-#line 4736 "Zend/zend_language_scanner.c"
+#line 4729 "Zend/zend_language_scanner.c"
yy420:
YYDEBUG(420, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_NEW);
}
-#line 4760 "Zend/zend_language_scanner.c"
+#line 4753 "Zend/zend_language_scanner.c"
yy424:
YYDEBUG(424, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_NAMESPACE);
}
-#line 4803 "Zend/zend_language_scanner.c"
+#line 4796 "Zend/zend_language_scanner.c"
yy432:
YYDEBUG(432, *YYCURSOR);
++YYCURSOR;
BEGIN(INITIAL);
RETURN_TOKEN(T_CLOSE_TAG); /* implicit ';' at php-end tag */
}
-#line 4817 "Zend/zend_language_scanner.c"
+#line 4810 "Zend/zend_language_scanner.c"
yy434:
YYDEBUG(434, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_COALESCE);
}
-#line 4827 "Zend/zend_language_scanner.c"
+#line 4820 "Zend/zend_language_scanner.c"
yy436:
YYDEBUG(436, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_CONCAT_EQUAL);
}
-#line 4862 "Zend/zend_language_scanner.c"
+#line 4855 "Zend/zend_language_scanner.c"
yy442:
YYDEBUG(442, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_ELLIPSIS);
}
-#line 4875 "Zend/zend_language_scanner.c"
+#line 4868 "Zend/zend_language_scanner.c"
yy445:
YYDEBUG(445, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_PAAMAYIM_NEKUDOTAYIM);
}
-#line 4885 "Zend/zend_language_scanner.c"
+#line 4878 "Zend/zend_language_scanner.c"
yy447:
YYDEBUG(447, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_MINUS_EQUAL);
}
-#line 4911 "Zend/zend_language_scanner.c"
+#line 4904 "Zend/zend_language_scanner.c"
yy451:
YYDEBUG(451, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_DEC);
}
-#line 4921 "Zend/zend_language_scanner.c"
+#line 4914 "Zend/zend_language_scanner.c"
yy453:
YYDEBUG(453, *YYCURSOR);
++YYCURSOR;
yy_push_state(ST_LOOKING_FOR_PROPERTY);
RETURN_TOKEN(T_OBJECT_OPERATOR);
}
-#line 4932 "Zend/zend_language_scanner.c"
+#line 4925 "Zend/zend_language_scanner.c"
yy455:
YYDEBUG(455, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_PUBLIC);
}
-#line 4981 "Zend/zend_language_scanner.c"
+#line 4974 "Zend/zend_language_scanner.c"
yy462:
YYDEBUG(462, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_PROTECTED);
}
-#line 5040 "Zend/zend_language_scanner.c"
+#line 5033 "Zend/zend_language_scanner.c"
yy471:
YYDEBUG(471, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_PRIVATE);
}
-#line 5074 "Zend/zend_language_scanner.c"
+#line 5067 "Zend/zend_language_scanner.c"
yy477:
YYDEBUG(477, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_PRINT);
}
-#line 5087 "Zend/zend_language_scanner.c"
+#line 5080 "Zend/zend_language_scanner.c"
yy479:
YYDEBUG(479, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_GOTO);
}
-#line 5116 "Zend/zend_language_scanner.c"
+#line 5109 "Zend/zend_language_scanner.c"
yy484:
YYDEBUG(484, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_GLOBAL);
}
-#line 5144 "Zend/zend_language_scanner.c"
+#line 5137 "Zend/zend_language_scanner.c"
yy489:
YYDEBUG(489, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_BREAK);
}
-#line 5185 "Zend/zend_language_scanner.c"
+#line 5178 "Zend/zend_language_scanner.c"
yy497:
YYDEBUG(497, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_SWITCH);
}
-#line 5229 "Zend/zend_language_scanner.c"
+#line 5222 "Zend/zend_language_scanner.c"
yy505:
YYDEBUG(505, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_STATIC);
}
-#line 5257 "Zend/zend_language_scanner.c"
+#line 5250 "Zend/zend_language_scanner.c"
yy510:
YYDEBUG(510, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_AS);
}
-#line 5288 "Zend/zend_language_scanner.c"
+#line 5281 "Zend/zend_language_scanner.c"
yy515:
YYDEBUG(515, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_ARRAY);
}
-#line 5311 "Zend/zend_language_scanner.c"
+#line 5304 "Zend/zend_language_scanner.c"
yy519:
YYDEBUG(519, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_LOGICAL_AND);
}
-#line 5324 "Zend/zend_language_scanner.c"
+#line 5317 "Zend/zend_language_scanner.c"
yy521:
YYDEBUG(521, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_ABSTRACT);
}
-#line 5362 "Zend/zend_language_scanner.c"
+#line 5355 "Zend/zend_language_scanner.c"
yy528:
YYDEBUG(528, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_WHILE);
}
-#line 5390 "Zend/zend_language_scanner.c"
+#line 5383 "Zend/zend_language_scanner.c"
yy533:
YYDEBUG(533, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_IF);
}
-#line 5403 "Zend/zend_language_scanner.c"
+#line 5396 "Zend/zend_language_scanner.c"
yy535:
YYDEBUG(535, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_ISSET);
}
-#line 5459 "Zend/zend_language_scanner.c"
+#line 5452 "Zend/zend_language_scanner.c"
yy542:
YYDEBUG(542, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_INCLUDE);
}
-#line 5517 "Zend/zend_language_scanner.c"
+#line 5510 "Zend/zend_language_scanner.c"
yy550:
YYDEBUG(550, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_INCLUDE_ONCE);
}
-#line 5550 "Zend/zend_language_scanner.c"
+#line 5543 "Zend/zend_language_scanner.c"
yy556:
YYDEBUG(556, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_INTERFACE);
}
-#line 5588 "Zend/zend_language_scanner.c"
+#line 5581 "Zend/zend_language_scanner.c"
yy563:
YYDEBUG(563, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_INSTEADOF);
}
-#line 5642 "Zend/zend_language_scanner.c"
+#line 5635 "Zend/zend_language_scanner.c"
yy571:
YYDEBUG(571, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_INSTANCEOF);
}
-#line 5675 "Zend/zend_language_scanner.c"
+#line 5668 "Zend/zend_language_scanner.c"
yy577:
YYDEBUG(577, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_IMPLEMENTS);
}
-#line 5723 "Zend/zend_language_scanner.c"
+#line 5716 "Zend/zend_language_scanner.c"
yy586:
YYDEBUG(586, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_TRY);
}
-#line 5755 "Zend/zend_language_scanner.c"
+#line 5748 "Zend/zend_language_scanner.c"
yy590:
YYDEBUG(590, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_TRAIT);
}
-#line 5778 "Zend/zend_language_scanner.c"
+#line 5771 "Zend/zend_language_scanner.c"
yy594:
YYDEBUG(594, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_THROW);
}
-#line 5801 "Zend/zend_language_scanner.c"
+#line 5794 "Zend/zend_language_scanner.c"
yy598:
YYDEBUG(598, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_YIELD);
}
-#line 5838 "Zend/zend_language_scanner.c"
+#line 5831 "Zend/zend_language_scanner.c"
yy603:
YYDEBUG(603, *YYCURSOR);
++YYCURSOR;
HANDLE_NEWLINES(yytext, yyleng);
RETURN_TOKEN(T_YIELD_FROM);
}
-#line 5885 "Zend/zend_language_scanner.c"
+#line 5878 "Zend/zend_language_scanner.c"
yy610:
YYDEBUG(610, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_REQUIRE);
}
-#line 5950 "Zend/zend_language_scanner.c"
+#line 5943 "Zend/zend_language_scanner.c"
yy618:
YYDEBUG(618, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_REQUIRE_ONCE);
}
-#line 5983 "Zend/zend_language_scanner.c"
+#line 5976 "Zend/zend_language_scanner.c"
yy624:
YYDEBUG(624, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_RETURN);
}
-#line 6006 "Zend/zend_language_scanner.c"
+#line 5999 "Zend/zend_language_scanner.c"
yy628:
YYDEBUG(628, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_CONTINUE);
}
-#line 6100 "Zend/zend_language_scanner.c"
+#line 6093 "Zend/zend_language_scanner.c"
yy639:
YYDEBUG(639, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_CONST);
}
-#line 6113 "Zend/zend_language_scanner.c"
+#line 6106 "Zend/zend_language_scanner.c"
yy641:
YYDEBUG(641, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_CLONE);
}
-#line 6142 "Zend/zend_language_scanner.c"
+#line 6135 "Zend/zend_language_scanner.c"
yy646:
YYDEBUG(646, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_CLASS);
}
-#line 6160 "Zend/zend_language_scanner.c"
+#line 6153 "Zend/zend_language_scanner.c"
yy649:
YYDEBUG(649, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_CALLABLE);
}
-#line 6210 "Zend/zend_language_scanner.c"
+#line 6203 "Zend/zend_language_scanner.c"
yy658:
YYDEBUG(658, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_CASE);
}
-#line 6223 "Zend/zend_language_scanner.c"
+#line 6216 "Zend/zend_language_scanner.c"
yy660:
YYDEBUG(660, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_CATCH);
}
-#line 6241 "Zend/zend_language_scanner.c"
+#line 6234 "Zend/zend_language_scanner.c"
yy663:
YYDEBUG(663, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_FUNCTION);
}
-#line 6296 "Zend/zend_language_scanner.c"
+#line 6289 "Zend/zend_language_scanner.c"
yy673:
YYDEBUG(673, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_FOR);
}
-#line 6324 "Zend/zend_language_scanner.c"
+#line 6317 "Zend/zend_language_scanner.c"
yy675:
YYDEBUG(675, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_FOREACH);
}
-#line 6352 "Zend/zend_language_scanner.c"
+#line 6345 "Zend/zend_language_scanner.c"
yy680:
YYDEBUG(680, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_FINAL);
}
-#line 6390 "Zend/zend_language_scanner.c"
+#line 6383 "Zend/zend_language_scanner.c"
yy684:
YYDEBUG(684, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_FINALLY);
}
-#line 6408 "Zend/zend_language_scanner.c"
+#line 6401 "Zend/zend_language_scanner.c"
yy687:
YYDEBUG(687, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_DO);
}
-#line 6443 "Zend/zend_language_scanner.c"
+#line 6436 "Zend/zend_language_scanner.c"
yy691:
YYDEBUG(691, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_EXIT);
}
-#line 6456 "Zend/zend_language_scanner.c"
+#line 6449 "Zend/zend_language_scanner.c"
yy693:
YYDEBUG(693, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_DEFAULT);
}
-#line 6495 "Zend/zend_language_scanner.c"
+#line 6488 "Zend/zend_language_scanner.c"
yy700:
YYDEBUG(700, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_DECLARE);
}
-#line 6523 "Zend/zend_language_scanner.c"
+#line 6516 "Zend/zend_language_scanner.c"
yy705:
YYDEBUG(705, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_EXTENDS);
}
-#line 6607 "Zend/zend_language_scanner.c"
+#line 6600 "Zend/zend_language_scanner.c"
yy718:
YYDEBUG(718, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_EXIT);
}
-#line 6620 "Zend/zend_language_scanner.c"
+#line 6613 "Zend/zend_language_scanner.c"
yy720:
YYDEBUG(720, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_EVAL);
}
-#line 6638 "Zend/zend_language_scanner.c"
+#line 6631 "Zend/zend_language_scanner.c"
yy723:
YYDEBUG(723, *YYCURSOR);
yych = *++YYCURSOR;
- YYDEBUG(-1, yych);
switch (yych) {
case 'D':
case 'd': goto yy724;
{
RETURN_TOKEN(T_ENDWHILE);
}
-#line 6712 "Zend/zend_language_scanner.c"
+#line 6704 "Zend/zend_language_scanner.c"
yy734:
YYDEBUG(734, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_ENDSWITCH);
}
-#line 6745 "Zend/zend_language_scanner.c"
+#line 6737 "Zend/zend_language_scanner.c"
yy740:
YYDEBUG(740, *YYCURSOR);
++YYCURSOR;
{
RETURN_TOKEN(T_ENDIF);
}
-#line 6758 "Zend/zend_language_scanner.c"
+#line 6750 "Zend/zend_language_scanner.c"
yy742:
YYDEBUG(742, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_ENDFOR);
}
-#line 6791 "Zend/zend_language_scanner.c"
+#line 6783 "Zend/zend_language_scanner.c"
yy745:
YYDEBUG(745, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_ENDFOREACH);
}
-#line 6819 "Zend/zend_language_scanner.c"
+#line 6811 "Zend/zend_language_scanner.c"
yy750:
YYDEBUG(750, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_ENDDECLARE);
}
-#line 6857 "Zend/zend_language_scanner.c"
+#line 6849 "Zend/zend_language_scanner.c"
yy757:
YYDEBUG(757, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_EMPTY);
}
-#line 6880 "Zend/zend_language_scanner.c"
+#line 6872 "Zend/zend_language_scanner.c"
yy761:
YYDEBUG(761, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_ELSE);
}
-#line 6913 "Zend/zend_language_scanner.c"
+#line 6905 "Zend/zend_language_scanner.c"
yy764:
YYDEBUG(764, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_ELSEIF);
}
-#line 6931 "Zend/zend_language_scanner.c"
+#line 6923 "Zend/zend_language_scanner.c"
yy767:
YYDEBUG(767, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_ECHO);
}
-#line 6949 "Zend/zend_language_scanner.c"
+#line 6941 "Zend/zend_language_scanner.c"
}
/* *********************************** */
yyc_ST_LOOKING_FOR_PROPERTY:
HANDLE_NEWLINES(yytext, yyleng);
RETURN_TOKEN(T_WHITESPACE);
}
-#line 7027 "Zend/zend_language_scanner.c"
+#line 7019 "Zend/zend_language_scanner.c"
yy774:
YYDEBUG(774, *YYCURSOR);
++YYCURSOR;
yy_pop_state();
goto restart;
}
-#line 7041 "Zend/zend_language_scanner.c"
+#line 7033 "Zend/zend_language_scanner.c"
yy776:
YYDEBUG(776, *YYCURSOR);
++YYCURSOR;
zend_copy_value(zendlval, yytext, yyleng);
RETURN_TOKEN(T_STRING);
}
-#line 7056 "Zend/zend_language_scanner.c"
+#line 7048 "Zend/zend_language_scanner.c"
yy778:
YYDEBUG(778, *YYCURSOR);
yych = *++YYCURSOR;
{
RETURN_TOKEN(T_OBJECT_OPERATOR);
}
-#line 7081 "Zend/zend_language_scanner.c"
+#line 7073 "Zend/zend_language_scanner.c"
yy783:
YYDEBUG(783, *YYCURSOR);
++YYCURSOR;
}
yy787:
YYDEBUG(787, *YYCURSOR);
- yyaccept = 0;
yych = *(YYMARKER = ++YYCURSOR);
if (yych <= '_') {
if (yych <= '@') {
yy_push_state(ST_IN_SCRIPTING);
goto restart;
}
-#line 7174 "Zend/zend_language_scanner.c"
+#line 7165 "Zend/zend_language_scanner.c"
yy789:
YYDEBUG(789, *YYCURSOR);
yych = *++YYCURSOR;
yy_push_state(ST_IN_SCRIPTING);
RETURN_TOKEN(T_STRING_VARNAME);
}
-#line 7209 "Zend/zend_language_scanner.c"
+#line 7200 "Zend/zend_language_scanner.c"
}
/* *********************************** */
yyc_ST_NOWDOC:
HANDLE_NEWLINES(yytext, yyleng - newline);
RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE);
}
-#line 7276 "Zend/zend_language_scanner.c"
+#line 7267 "Zend/zend_language_scanner.c"
/* *********************************** */
yyc_ST_VAR_OFFSET:
{
}
}
YYDEBUG(801, *YYCURSOR);
- yyaccept = 0;
yych = *(YYMARKER = ++YYCURSOR);
if (yych <= 'W') {
if (yych <= '9') {
}
RETURN_TOKEN(T_NUM_STRING);
}
-#line 7397 "Zend/zend_language_scanner.c"
+#line 7387 "Zend/zend_language_scanner.c"
yy803:
YYDEBUG(803, *YYCURSOR);
yych = *++YYCURSOR;
/* Only '[' can be valid, but returning other tokens will allow a more explicit parse error */
RETURN_TOKEN(yytext[0]);
}
-#line 7422 "Zend/zend_language_scanner.c"
+#line 7412 "Zend/zend_language_scanner.c"
yy806:
YYDEBUG(806, *YYCURSOR);
++YYCURSOR;
yy_pop_state();
RETURN_TOKEN(']');
}
-#line 7433 "Zend/zend_language_scanner.c"
+#line 7423 "Zend/zend_language_scanner.c"
yy808:
YYDEBUG(808, *YYCURSOR);
yych = *++YYCURSOR;
ZVAL_NULL(zendlval);
RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE);
}
-#line 7451 "Zend/zend_language_scanner.c"
+#line 7441 "Zend/zend_language_scanner.c"
yy811:
YYDEBUG(811, *YYCURSOR);
++YYCURSOR;
zend_copy_value(zendlval, yytext, yyleng);
RETURN_TOKEN(T_STRING);
}
-#line 7465 "Zend/zend_language_scanner.c"
+#line 7455 "Zend/zend_language_scanner.c"
yy813:
YYDEBUG(813, *YYCURSOR);
++YYCURSOR;
zend_error(E_COMPILE_WARNING,"Unexpected character in input: '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE);
goto restart;
}
-#line 7480 "Zend/zend_language_scanner.c"
+#line 7470 "Zend/zend_language_scanner.c"
yy815:
YYDEBUG(815, *YYCURSOR);
++YYCURSOR;
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
RETURN_TOKEN(T_VARIABLE);
}
-#line 7521 "Zend/zend_language_scanner.c"
+#line 7511 "Zend/zend_language_scanner.c"
yy820:
YYDEBUG(820, *YYCURSOR);
++YYCURSOR;
ZVAL_STRINGL(zendlval, yytext, yyleng);
RETURN_TOKEN(T_NUM_STRING);
}
-#line 7566 "Zend/zend_language_scanner.c"
+#line 7556 "Zend/zend_language_scanner.c"
yy828:
YYDEBUG(828, *YYCURSOR);
++YYCURSOR;
zend_destroy_file_handle(&file_handle);
if (filename==&tmp) {
- zval_ptr_dtor_nogc(&tmp);
+ zval_dtor(&tmp);
}
return retval;
}
}
zend_restore_lexical_state(&original_lex_state);
- zval_ptr_dtor_nogc(&tmp);
+ zval_dtor(&tmp);
return op_array;
}
SCNG(script_filtered) = NULL;
}
zend_restore_lexical_state(&original_lex_state);
- zval_ptr_dtor_nogc(str);
+ zval_dtor(str);
return SUCCESS;
}
-/* Generated by re2c 0.14.3 */
+/* Generated by re2c 0.15.3 */
#line 3 "Zend/zend_language_scanner_defs.h"
enum YYCONDTYPE {
ce = Z_OBJCE_P(readobj);
zend_error(E_NOTICE, "Object of class %s could not be converted to int", ZSTR_VAL(ce->name));
if (readobj == writeobj) {
- zval_ptr_dtor_nogc(readobj);
+ zval_dtor(readobj);
}
ZVAL_LONG(writeobj, 1);
return SUCCESS;
ce = Z_OBJCE_P(readobj);
zend_error(E_NOTICE, "Object of class %s could not be converted to float", ZSTR_VAL(ce->name));
if (readobj == writeobj) {
- zval_ptr_dtor_nogc(readobj);
+ zval_dtor(readobj);
}
ZVAL_DOUBLE(writeobj, 1);
return SUCCESS;
zval dst;
convert_object_to_type(op, &dst, IS_LONG, convert_to_long);
- zval_ptr_dtor_nogc(op);
+ zval_dtor(op);
if (Z_TYPE(dst) == IS_LONG) {
ZVAL_COPY_VALUE(op, &dst);
zval dst;
convert_object_to_type(op, &dst, IS_DOUBLE, convert_to_double);
- zval_ptr_dtor_nogc(op);
+ zval_dtor(op);
if (Z_TYPE(dst) == IS_DOUBLE) {
ZVAL_COPY_VALUE(op, &dst);
ZVAL_COPY_VALUE(&org, op);
if (Z_OBJ_HT_P(op)->cast_object(&org, op, IS_NULL) == SUCCESS) {
- zval_ptr_dtor_nogc(&org);
+ zval_dtor(&org);
return;
}
ZVAL_COPY_VALUE(op, &org);
zval dst;
convert_object_to_type(op, &dst, _IS_BOOL, convert_to_boolean);
- zval_ptr_dtor_nogc(op);
+ zval_dtor(op);
if (Z_TYPE(dst) == IS_FALSE || Z_TYPE(dst) == IS_TRUE) {
ZVAL_COPY_VALUE(op, &dst);
zval dst;
convert_object_to_type(op, &dst, IS_STRING, convert_to_string);
- zval_ptr_dtor_nogc(op);
+ zval_dtor(op);
if (Z_TYPE(dst) == IS_STRING) {
ZVAL_COPY_VALUE(op, &dst);
} else {
arr = zend_array_dup(obj_ht);
}
- zval_ptr_dtor_nogc(op);
+ zval_dtor(op);
ZVAL_ARR(op, arr);
} else {
arr = zend_array_dup(obj_ht);
- zval_ptr_dtor_nogc(op);
+ zval_dtor(op);
ZVAL_ARR(op, arr);
}
return;
convert_object_to_type(op, &dst, IS_ARRAY, convert_to_array);
if (Z_TYPE(dst) == IS_ARRAY) {
- zval_ptr_dtor_nogc(op);
+ zval_dtor(op);
ZVAL_COPY_VALUE(op, &dst);
return;
}
}
- zval_ptr_dtor_nogc(op);
+ zval_dtor(op);
array_init(op);
}
break;
convert_op1_op2_long(op1, op1_lval, op2, op2_lval, ZEND_MOD, mod_function);
if (op1 == result) {
- zval_ptr_dtor_nogc(result);
+ zval_dtor(result);
}
if (op2_lval == 0) {
}
if (op1 == result) {
- zval_ptr_dtor_nogc(result);
+ zval_dtor(result);
}
ZVAL_LONG(result, op1_lval | op2_lval);
return SUCCESS;
}
if (op1 == result) {
- zval_ptr_dtor_nogc(result);
+ zval_dtor(result);
}
ZVAL_LONG(result, op1_lval & op2_lval);
return SUCCESS;
}
if (op1 == result) {
- zval_ptr_dtor_nogc(result);
+ zval_dtor(result);
}
ZVAL_LONG(result, op1_lval ^ op2_lval);
return SUCCESS;
convert_op1_op2_long(op1, op1_lval, op2, op2_lval, ZEND_SL, shift_left_function);
if (op1 == result) {
- zval_ptr_dtor_nogc(result);
+ zval_dtor(result);
}
/* prevent wrapping quirkiness on some processors where << 64 + x == << x */
convert_op1_op2_long(op1, op1_lval, op2, op2_lval, ZEND_SR, shift_right_function);
if (op1 == result) {
- zval_ptr_dtor_nogc(result);
+ zval_dtor(result);
}
/* prevent wrapping quirkiness on some processors where >> 64 + x == >> x */
* we have to free it.
*/
if (result == op1) {
- zval_ptr_dtor_nogc(op1);
+ zval_dtor(op1);
if (UNEXPECTED(op1 == op2)) {
op2 = &op1_copy;
}
}
if (UNEXPECTED(use_copy1)) {
- zval_ptr_dtor_nogc(op1);
+ zval_dtor(op1);
}
if (UNEXPECTED(use_copy2)) {
- zval_ptr_dtor_nogc(op2);
+ zval_dtor(op2);
}
return SUCCESS;
}
{
if (Z_REFCOUNTED_P(op)) {
if (Z_REFCOUNT_P(op) == 0) {
- zval_ptr_dtor_nogc(op);
+ zval_dtor(op);
} else {
zval_ptr_dtor(op);
}
ZEND_API void ZEND_FASTCALL _zval_dtor_func(zend_refcounted *p ZEND_FILE_LINE_DC)
{
+ if (--GC_REFCOUNT(p)) {
+ return;
+ }
+
switch (GC_TYPE(p)) {
case IS_STRING:
case IS_CONSTANT: {
}
}
-ZEND_API void _zval_internal_dtor(zval *zval_ptr ZEND_FILE_LINE_DC)
+ZEND_API void ZEND_FASTCALL _zval_dtor_func_for_ptr(zend_refcounted *p ZEND_FILE_LINE_DC)
+{
+ switch (GC_TYPE(p)) {
+ case IS_STRING:
+ case IS_CONSTANT: {
+ zend_string *str = (zend_string*)p;
+ CHECK_ZVAL_STRING_REL(str);
+ zend_string_free(str);
+ break;
+ }
+ case IS_ARRAY: {
+ zend_array *arr = (zend_array*)p;
+
+ zend_array_destroy(arr);
+ break;
+ }
+ case IS_CONSTANT_AST: {
+ zend_ast_ref *ast = (zend_ast_ref*)p;
+
+ zend_ast_destroy_and_free(ast->ast);
+ efree_size(ast, sizeof(zend_ast_ref));
+ break;
+ }
+ case IS_OBJECT: {
+ zend_object *obj = (zend_object*)p;
+
+ zend_objects_store_del(obj);
+ break;
+ }
+ case IS_RESOURCE: {
+ zend_resource *res = (zend_resource*)p;
+
+ /* destroy resource */
+ zend_list_free(res);
+ break;
+ }
+ case IS_REFERENCE: {
+ zend_reference *ref = (zend_reference*)p;
+
+ i_zval_ptr_dtor(&ref->val ZEND_FILE_LINE_RELAY_CC);
+ efree_size(ref, sizeof(zend_reference));
+ break;
+ }
+ default:
+ break;
+ }
+}
+
+ZEND_API void _zval_internal_dtor(zval *zvalue ZEND_FILE_LINE_DC)
{
- switch (Z_TYPE_P(zval_ptr)) {
+ switch (Z_TYPE_P(zvalue)) {
case IS_STRING:
case IS_CONSTANT:
- CHECK_ZVAL_STRING_REL(Z_STR_P(zval_ptr));
- zend_string_release(Z_STR_P(zval_ptr));
+ CHECK_ZVAL_STRING_REL(Z_STR_P(zvalue));
+ zend_string_release(Z_STR_P(zvalue));
break;
case IS_ARRAY:
case IS_CONSTANT_AST:
zend_error_noreturn(E_CORE_ERROR, "Internal zval's can't be arrays, objects or resources");
break;
case IS_REFERENCE: {
- zend_reference *ref = (zend_reference*)Z_REF_P(zval_ptr);
+ zend_reference *ref = (zend_reference*)Z_REF_P(zvalue);
zval_internal_ptr_dtor(&ref->val);
free(ref);
}
}
-ZEND_API void _zval_internal_dtor_for_ptr(zval *zval_ptr ZEND_FILE_LINE_DC)
+ZEND_API void _zval_internal_dtor_for_ptr(zval *zvalue ZEND_FILE_LINE_DC)
{
- switch (Z_TYPE_P(zval_ptr)) {
+ switch (Z_TYPE_P(zvalue)) {
case IS_STRING:
case IS_CONSTANT:
- CHECK_ZVAL_STRING_REL(Z_STR_P(zval_ptr));
- zend_string_free(Z_STR_P(zval_ptr));
+ CHECK_ZVAL_STRING_REL(Z_STR_P(zvalue));
+ zend_string_free(Z_STR_P(zvalue));
break;
case IS_ARRAY:
case IS_CONSTANT_AST:
zend_error_noreturn(E_CORE_ERROR, "Internal zval's can't be arrays, objects or resources");
break;
case IS_REFERENCE: {
- zend_reference *ref = (zend_reference*)Z_REF_P(zval_ptr);
+ zend_reference *ref = (zend_reference*)Z_REF_P(zvalue);
zval_internal_ptr_dtor(&ref->val);
free(ref);
}
}
-ZEND_API void ZEND_FASTCALL _zval_copy_ctor_func(zval *zval_ptr ZEND_FILE_LINE_DC)
+ZEND_API void ZEND_FASTCALL _zval_copy_ctor_func(zval *zvalue ZEND_FILE_LINE_DC)
{
- if (EXPECTED(Z_TYPE_P(zval_ptr) == IS_ARRAY)) {
- ZVAL_ARR(zval_ptr, zend_array_dup(Z_ARRVAL_P(zval_ptr)));
- } else if (EXPECTED(Z_TYPE_P(zval_ptr) == IS_STRING) ||
- EXPECTED(Z_TYPE_P(zval_ptr) == IS_CONSTANT)) {
- CHECK_ZVAL_STRING_REL(Z_STR_P(zval_ptr));
- Z_STR_P(zval_ptr) = zend_string_dup(Z_STR_P(zval_ptr), 0);
- } else if (EXPECTED(Z_TYPE_P(zval_ptr) == IS_CONSTANT_AST)) {
- zend_ast *copy = zend_ast_copy(Z_ASTVAL_P(zval_ptr));
- ZVAL_NEW_AST(zval_ptr, copy);
+ if (EXPECTED(Z_TYPE_P(zvalue) == IS_ARRAY)) {
+ ZVAL_ARR(zvalue, zend_array_dup(Z_ARRVAL_P(zvalue)));
+ } else if (EXPECTED(Z_TYPE_P(zvalue) == IS_STRING) ||
+ EXPECTED(Z_TYPE_P(zvalue) == IS_CONSTANT)) {
+ CHECK_ZVAL_STRING_REL(Z_STR_P(zvalue));
+ Z_STR_P(zvalue) = zend_string_dup(Z_STR_P(zvalue), 0);
+ } else if (EXPECTED(Z_TYPE_P(zvalue) == IS_CONSTANT_AST)) {
+ zend_ast *copy = zend_ast_copy(Z_ASTVAL_P(zvalue));
+ ZVAL_NEW_AST(zvalue, copy);
}
}
}
-ZEND_API void _zval_dtor_wrapper(zval *zval_ptr)
+ZEND_API void _zval_dtor_wrapper(zval *zvalue)
{
- zval_dtor(zval_ptr);
+ zval_dtor(zvalue);
}
#if ZEND_DEBUG
-ZEND_API void _zval_internal_dtor_wrapper(zval *zval_ptr)
+ZEND_API void _zval_internal_dtor_wrapper(zval *zvalue)
{
- zval_internal_dtor(zval_ptr);
+ zval_internal_dtor(zvalue);
}
BEGIN_EXTERN_C()
ZEND_API void ZEND_FASTCALL _zval_dtor_func(zend_refcounted *p ZEND_FILE_LINE_DC);
-ZEND_API void ZEND_FASTCALL _zval_copy_ctor_func(zval *zval_ptr ZEND_FILE_LINE_DC);
+ZEND_API void ZEND_FASTCALL _zval_dtor_func_for_ptr(zend_refcounted *p ZEND_FILE_LINE_DC);
+ZEND_API void ZEND_FASTCALL _zval_copy_ctor_func(zval *zvalue ZEND_FILE_LINE_DC);
-#define zval_dtor_func(zval_ptr) _zval_dtor_func(zval_ptr ZEND_FILE_LINE_CC)
-#define zval_copy_ctor_func(zval_ptr) _zval_copy_ctor_func(zval_ptr ZEND_FILE_LINE_CC)
+#define zval_dtor_func(zv) _zval_dtor_func(zv ZEND_FILE_LINE_CC)
+#define zval_dtor_func_for_ptr(zv) _zval_dtor_func_for_ptr(zv ZEND_FILE_LINE_CC)
+#define zval_copy_ctor_func(zv) _zval_copy_ctor_func(zv ZEND_FILE_LINE_CC)
+
+static zend_always_inline void _zval_dtor(zval *zvalue ZEND_FILE_LINE_DC)
+{
+ if (!Z_REFCOUNTED_P(zvalue)) {
+ return;
+ }
+ _zval_dtor_func(Z_COUNTED_P(zvalue) ZEND_FILE_LINE_RELAY_CC);
+}
static zend_always_inline void _zval_ptr_dtor_nogc(zval *zval_ptr ZEND_FILE_LINE_DC)
{
if (Z_REFCOUNTED_P(zval_ptr) && !Z_DELREF_P(zval_ptr)) {
- _zval_dtor_func(Z_COUNTED_P(zval_ptr) ZEND_FILE_LINE_RELAY_CC);
+ _zval_dtor_func_for_ptr(Z_COUNTED_P(zval_ptr) ZEND_FILE_LINE_RELAY_CC);
}
}
{
if (Z_REFCOUNTED_P(zval_ptr)) {
if (!Z_DELREF_P(zval_ptr)) {
- _zval_dtor_func(Z_COUNTED_P(zval_ptr) ZEND_FILE_LINE_RELAY_CC);
+ _zval_dtor_func_for_ptr(Z_COUNTED_P(zval_ptr) ZEND_FILE_LINE_RELAY_CC);
} else {
GC_ZVAL_CHECK_POSSIBLE_ROOT(zval_ptr);
}
}
}
-static zend_always_inline void _zval_copy_ctor(zval *zval_ptr ZEND_FILE_LINE_DC)
+static zend_always_inline void _zval_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC)
{
- if (Z_REFCOUNTED_P(zval_ptr) || Z_IMMUTABLE_P(zval_ptr)) {
- if (Z_COPYABLE_P(zval_ptr) || Z_IMMUTABLE_P(zval_ptr)) {
- _zval_copy_ctor_func(zval_ptr ZEND_FILE_LINE_RELAY_CC);
+ if (Z_REFCOUNTED_P(zvalue) || Z_IMMUTABLE_P(zvalue)) {
+ if (Z_COPYABLE_P(zvalue) || Z_IMMUTABLE_P(zvalue)) {
+ _zval_copy_ctor_func(zvalue ZEND_FILE_LINE_RELAY_CC);
} else {
- Z_ADDREF_P(zval_ptr);
+ Z_ADDREF_P(zvalue);
}
}
}
-static zend_always_inline void _zval_opt_copy_ctor(zval *zval_ptr ZEND_FILE_LINE_DC)
+static zend_always_inline void _zval_opt_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC)
{
- if (Z_OPT_REFCOUNTED_P(zval_ptr) || Z_OPT_IMMUTABLE_P(zval_ptr)) {
- if (Z_OPT_COPYABLE_P(zval_ptr) || Z_OPT_IMMUTABLE_P(zval_ptr)) {
- _zval_copy_ctor_func(zval_ptr ZEND_FILE_LINE_RELAY_CC);
+ if (Z_OPT_REFCOUNTED_P(zvalue) || Z_OPT_IMMUTABLE_P(zvalue)) {
+ if (Z_OPT_COPYABLE_P(zvalue) || Z_OPT_IMMUTABLE_P(zvalue)) {
+ _zval_copy_ctor_func(zvalue ZEND_FILE_LINE_RELAY_CC);
} else {
- Z_ADDREF_P(zval_ptr);
+ Z_ADDREF_P(zvalue);
}
}
}
-static zend_always_inline void _zval_copy_ctor_no_imm(zval *zval_ptr ZEND_FILE_LINE_DC)
+static zend_always_inline void _zval_copy_ctor_no_imm(zval *zvalue ZEND_FILE_LINE_DC)
{
- if (Z_REFCOUNTED_P(zval_ptr)) {
- if (Z_COPYABLE_P(zval_ptr)) {
- _zval_copy_ctor_func(zval_ptr ZEND_FILE_LINE_RELAY_CC);
+ if (Z_REFCOUNTED_P(zvalue)) {
+ if (Z_COPYABLE_P(zvalue)) {
+ _zval_copy_ctor_func(zvalue ZEND_FILE_LINE_RELAY_CC);
} else {
- Z_ADDREF_P(zval_ptr);
+ Z_ADDREF_P(zvalue);
}
}
}
-static zend_always_inline void _zval_opt_copy_ctor_no_imm(zval *zval_ptr ZEND_FILE_LINE_DC)
+static zend_always_inline void _zval_opt_copy_ctor_no_imm(zval *zvalue ZEND_FILE_LINE_DC)
{
- if (Z_OPT_REFCOUNTED_P(zval_ptr)) {
- if (Z_OPT_COPYABLE_P(zval_ptr)) {
- _zval_copy_ctor_func(zval_ptr ZEND_FILE_LINE_RELAY_CC);
+ if (Z_OPT_REFCOUNTED_P(zvalue)) {
+ if (Z_OPT_COPYABLE_P(zvalue)) {
+ _zval_copy_ctor_func(zvalue ZEND_FILE_LINE_RELAY_CC);
} else {
- Z_ADDREF_P(zval_ptr);
+ Z_ADDREF_P(zvalue);
}
}
}
ZEND_API size_t zend_print_variable(zval *var);
ZEND_API void _zval_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC);
-ZEND_API void _zval_internal_dtor_for_ptr(zval *zval_ptr ZEND_FILE_LINE_DC);
-ZEND_API void _zval_internal_dtor(zval *zval_ptr ZEND_FILE_LINE_DC);
-ZEND_API void _zval_internal_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC);
-ZEND_API void _zval_dtor_wrapper(zval *zval_ptr);
-#define zval_copy_ctor(zval_ptr) _zval_copy_ctor((zval_ptr) ZEND_FILE_LINE_CC)
-#define zval_opt_copy_ctor(zval_ptr) _zval_opt_copy_ctor((zval_ptr) ZEND_FILE_LINE_CC)
-#define zval_copy_ctor_no_imm(zval_ptr) _zval_copy_ctor_no_imm((zval_ptr) ZEND_FILE_LINE_CC)
-#define zval_opt_copy_ctor_no_imm(zval_ptr) _zval_opt_copy_ctor_no_imm((zval_ptr) ZEND_FILE_LINE_CC)
-#define zval_ptr_dtor_nogc(zval_ptr) _zval_ptr_dtor_nogc((zval_ptr) ZEND_FILE_LINE_CC)
+ZEND_API void _zval_internal_dtor_for_ptr(zval *zvalue ZEND_FILE_LINE_DC);
+ZEND_API void _zval_internal_dtor(zval *zvalue ZEND_FILE_LINE_DC);
+ZEND_API void _zval_internal_ptr_dtor(zval *zvalue ZEND_FILE_LINE_DC);
+ZEND_API void _zval_dtor_wrapper(zval *zvalue);
+#define zval_copy_ctor(zvalue) _zval_copy_ctor((zvalue) ZEND_FILE_LINE_CC)
+#define zval_opt_copy_ctor(zvalue) _zval_opt_copy_ctor((zvalue) ZEND_FILE_LINE_CC)
+#define zval_copy_ctor_no_imm(zvalue) _zval_copy_ctor_no_imm((zvalue) ZEND_FILE_LINE_CC)
+#define zval_opt_copy_ctor_no_imm(zvalue) _zval_opt_copy_ctor_no_imm((zvalue) ZEND_FILE_LINE_CC)
+#define zval_dtor(zvalue) _zval_dtor((zvalue) ZEND_FILE_LINE_CC)
#define zval_ptr_dtor(zval_ptr) _zval_ptr_dtor((zval_ptr) ZEND_FILE_LINE_CC)
-#define zval_internal_dtor(zval_ptr) _zval_internal_dtor((zval_ptr) ZEND_FILE_LINE_CC)
-#define zval_internal_ptr_dtor(zval_ptr) _zval_internal_ptr_dtor((zval_ptr) ZEND_FILE_LINE_CC)
+#define zval_ptr_dtor_nogc(zval_ptr) _zval_ptr_dtor_nogc((zval_ptr) ZEND_FILE_LINE_CC)
+#define zval_internal_dtor(zvalue) _zval_internal_dtor((zvalue) ZEND_FILE_LINE_CC)
+#define zval_internal_ptr_dtor(zvalue) _zval_internal_ptr_dtor((zvalue) ZEND_FILE_LINE_CC)
#define zval_dtor_wrapper _zval_dtor_wrapper
-/* deprecated in favor of zval_ptr_dtor_nogc(); kept for avoiding too many changes */
-#define zval_dtor(zval_ptr) zval_ptr_dtor_nogc(zval_ptr)
-
#if ZEND_DEBUG
ZEND_API void _zval_ptr_dtor_wrapper(zval *zval_ptr);
-ZEND_API void _zval_internal_dtor_wrapper(zval *zval_ptr);
-ZEND_API void _zval_internal_ptr_dtor_wrapper(zval *zval_ptr);
+ZEND_API void _zval_internal_dtor_wrapper(zval *zvalue);
+ZEND_API void _zval_internal_ptr_dtor_wrapper(zval *zvalue);
#define zval_ptr_dtor_wrapper _zval_ptr_dtor_wrapper
#define zval_internal_dtor_wrapper _zval_internal_dtor_wrapper
#define zval_internal_ptr_dtor_wrapper _zval_internal_ptr_dtor_wrapper
if (OP1_TYPE & (IS_VAR|IS_TMP_VAR)) {
if (Z_REFCOUNTED_P(free_op1) && !Z_DELREF_P(free_op1)) {
SAVE_OPLINE();
- zval_dtor_func(Z_COUNTED_P(free_op1));
+ zval_dtor_func_for_ptr(Z_COUNTED_P(free_op1));
}
}
} else {
ZEND_VM_C_GOTO(unpack_iter_dtor);
}
- zval_ptr_dtor_nogc(&key);
+ zval_dtor(&key);
}
if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
if (!--GC_REFCOUNT(garbage)) {
ZVAL_UNDEF(var);
- zval_dtor_func(garbage);
+ zval_dtor_func_for_ptr(garbage);
} else {
zval *z = var;
ZVAL_DEREF(z);
}
if (refcnt == 0) {
SAVE_OPLINE();
- zval_dtor_func(Z_COUNTED_P(variable_ptr));
+ zval_dtor_func_for_ptr(Z_COUNTED_P(variable_ptr));
if (UNEXPECTED(EG(exception))) {
ZVAL_NULL(variable_ptr);
HANDLE_EXCEPTION();
goto unpack_iter_dtor;
}
- zval_ptr_dtor_nogc(&key);
+ zval_dtor(&key);
}
if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
if (IS_CONST & (IS_VAR|IS_TMP_VAR)) {
if (Z_REFCOUNTED_P(free_op1) && !Z_DELREF_P(free_op1)) {
SAVE_OPLINE();
- zval_dtor_func(Z_COUNTED_P(free_op1));
+ zval_dtor_func_for_ptr(Z_COUNTED_P(free_op1));
}
}
} else {
if (!--GC_REFCOUNT(garbage)) {
ZVAL_UNDEF(var);
- zval_dtor_func(garbage);
+ zval_dtor_func_for_ptr(garbage);
} else {
zval *z = var;
ZVAL_DEREF(z);
if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) {
if (Z_REFCOUNTED_P(free_op1) && !Z_DELREF_P(free_op1)) {
SAVE_OPLINE();
- zval_dtor_func(Z_COUNTED_P(free_op1));
+ zval_dtor_func_for_ptr(Z_COUNTED_P(free_op1));
}
}
} else {
ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
increment_function(var_ptr);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
decrement_function(var_ptr);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
if (IS_VAR & (IS_VAR|IS_TMP_VAR)) {
if (Z_REFCOUNTED_P(free_op1) && !Z_DELREF_P(free_op1)) {
SAVE_OPLINE();
- zval_dtor_func(Z_COUNTED_P(free_op1));
+ zval_dtor_func_for_ptr(Z_COUNTED_P(free_op1));
}
}
} else {
if (EX(return_value)) {
ZVAL_NEW_REF(EX(return_value), retval_ptr);
} else {
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
}
break;
}
ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
} while (0);
ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
ZVAL_REF(varptr, Z_REF_P(arg));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE();
}
p = fe_ht->arData;
while (1) {
if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
}
}
Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(fe_ht, pos);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
} else if (IS_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
if (!Z_OBJCE_P(array_ptr)->get_iterator) {
p = fe_ht->arData;
while (1) {
if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
}
}
Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(fe_ht, pos);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
} else {
zend_class_entry *ce = Z_OBJCE_P(array_ptr);
if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
if (IS_VAR == IS_VAR) {
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
} else {
zval_ptr_dtor_nogc(free_op1);
}
if (UNEXPECTED(EG(exception) != NULL)) {
OBJ_RELEASE(&iter->std);
if (IS_VAR == IS_VAR) {
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
} else {
zval_ptr_dtor_nogc(free_op1);
}
if (UNEXPECTED(EG(exception) != NULL)) {
OBJ_RELEASE(&iter->std);
if (IS_VAR == IS_VAR) {
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
} else {
zval_ptr_dtor_nogc(free_op1);
}
Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
if (IS_VAR == IS_VAR) {
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
} else {
zval_ptr_dtor_nogc(free_op1);
}
ZVAL_UNDEF(EX_VAR(opline->result.var));
Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
if (IS_VAR == IS_VAR) {
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
} else {
zval_ptr_dtor_nogc(free_op1);
}
FREE_OP(free_op_data1);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_obj has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
}
FREE_OP(free_op_data1);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
}
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
}
} while (0);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
}
} while (0);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
} else {
if (IS_CONST == IS_UNUSED) {
zend_throw_error(NULL, "Cannot use [] for reading");
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
zend_throw_error(NULL, "Cannot use temporary expression in write context");
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
HANDLE_EXCEPTION();
}
zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
} else {
ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
}
exit_assign_obj:
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_obj has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
}
exit_assign_obj:
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_obj has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
}
exit_assign_obj:
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_obj has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
}
exit_assign_obj:
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_obj has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
if (IS_CONST == IS_UNUSED) {
zend_throw_error(NULL, "[] operator not supported for strings");
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
HANDLE_EXCEPTION();
} else {
dim = EX_CONSTANT(opline->op2);
if (IS_CONST != IS_UNUSED) {
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_dim has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
if (IS_CONST == IS_UNUSED) {
zend_throw_error(NULL, "[] operator not supported for strings");
zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
HANDLE_EXCEPTION();
} else {
dim = EX_CONSTANT(opline->op2);
if (IS_CONST != IS_UNUSED) {
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_dim has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
if (IS_CONST == IS_UNUSED) {
zend_throw_error(NULL, "[] operator not supported for strings");
zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
HANDLE_EXCEPTION();
} else {
dim = EX_CONSTANT(opline->op2);
if (IS_CONST != IS_UNUSED) {
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_dim has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
if (IS_CONST == IS_UNUSED) {
zend_throw_error(NULL, "[] operator not supported for strings");
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
HANDLE_EXCEPTION();
} else {
dim = EX_CONSTANT(opline->op2);
if (IS_CONST != IS_UNUSED) {
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_dim has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
if (UNEXPECTED(0)) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* zend_assign_to_variable() always takes care of op2, never free it! */
}
if (UNEXPECTED(1)) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* zend_assign_to_variable() always takes care of op2, never free it! */
}
expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
} else {
expr_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
if (IS_VAR == IS_TMP_VAR) {
}
} while (0);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
}
} while (0);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
}
ZVAL_COPY(&generator->value, value_ptr);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
}
} else {
zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
if (UNEXPECTED(0)) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* zend_assign_to_variable() always takes care of op2, never free it! */
}
if (UNEXPECTED(1)) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* zend_assign_to_variable() always takes care of op2, never free it! */
}
}
ZVAL_COPY(&generator->value, value_ptr);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
}
} else {
zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
if (UNEXPECTED(0)) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* zend_assign_to_variable() always takes care of op2, never free it! */
}
if (UNEXPECTED(1)) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* zend_assign_to_variable() always takes care of op2, never free it! */
}
UNEXPECTED(!Z_ISERROR_P(EX_VAR(opline->op1.var)))) {
zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
- if (UNEXPECTED(free_op2)) { zval_ptr_dtor_nogc(free_op2); };
+ if (UNEXPECTED(free_op2)) {zval_ptr_dtor_nogc(free_op2);};
HANDLE_EXCEPTION();
} else if (IS_VAR == IS_VAR &&
UNEXPECTED(!Z_ISREF_P(value_ptr))) {
zend_error(E_NOTICE, "Only variables should be assigned by reference");
if (UNEXPECTED(EG(exception) != NULL)) {
- if (UNEXPECTED(free_op2)) { zval_ptr_dtor_nogc(free_op2); };
+ if (UNEXPECTED(free_op2)) {zval_ptr_dtor_nogc(free_op2);};
HANDLE_EXCEPTION();
}
ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
}
- if (UNEXPECTED(free_op2)) { zval_ptr_dtor_nogc(free_op2); };
+ if (UNEXPECTED(free_op2)) {zval_ptr_dtor_nogc(free_op2);};
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
}
ZVAL_COPY(&generator->value, value_ptr);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
}
} else {
zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
}
FREE_OP(free_op_data1);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
} else {
if (IS_UNUSED == IS_UNUSED) {
zend_throw_error(NULL, "Cannot use [] for reading");
if (IS_UNUSED == IS_UNUSED) {
zend_throw_error(NULL, "[] operator not supported for strings");
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
HANDLE_EXCEPTION();
} else {
dim = NULL;
if (IS_UNUSED != IS_UNUSED) {
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_dim has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
if (IS_UNUSED == IS_UNUSED) {
zend_throw_error(NULL, "[] operator not supported for strings");
zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
HANDLE_EXCEPTION();
} else {
dim = NULL;
if (IS_UNUSED != IS_UNUSED) {
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_dim has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
if (IS_UNUSED == IS_UNUSED) {
zend_throw_error(NULL, "[] operator not supported for strings");
zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
HANDLE_EXCEPTION();
} else {
dim = NULL;
if (IS_UNUSED != IS_UNUSED) {
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_dim has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
if (IS_UNUSED == IS_UNUSED) {
zend_throw_error(NULL, "[] operator not supported for strings");
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
HANDLE_EXCEPTION();
} else {
dim = NULL;
if (IS_UNUSED != IS_UNUSED) {
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_dim has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
} else {
expr_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
if (IS_VAR == IS_TMP_VAR) {
}
ZVAL_COPY(&generator->value, value_ptr);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
}
} else {
zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
FREE_OP(free_op_data1);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_obj has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
}
FREE_OP(free_op_data1);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
}
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
}
} while (0);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
}
} while (0);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
} else {
if (IS_CV == IS_UNUSED) {
zend_throw_error(NULL, "Cannot use [] for reading");
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
zend_throw_error(NULL, "Cannot use temporary expression in write context");
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
HANDLE_EXCEPTION();
}
zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
} else {
ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
}
exit_assign_obj:
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_obj has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
}
exit_assign_obj:
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_obj has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
}
exit_assign_obj:
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_obj has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
}
exit_assign_obj:
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_obj has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
if (IS_CV == IS_UNUSED) {
zend_throw_error(NULL, "[] operator not supported for strings");
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
HANDLE_EXCEPTION();
} else {
dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
if (IS_CV != IS_UNUSED) {
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_dim has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
if (IS_CV == IS_UNUSED) {
zend_throw_error(NULL, "[] operator not supported for strings");
zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
HANDLE_EXCEPTION();
} else {
dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
if (IS_CV != IS_UNUSED) {
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_dim has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
if (IS_CV == IS_UNUSED) {
zend_throw_error(NULL, "[] operator not supported for strings");
zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
HANDLE_EXCEPTION();
} else {
dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
if (IS_CV != IS_UNUSED) {
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_dim has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
if (IS_CV == IS_UNUSED) {
zend_throw_error(NULL, "[] operator not supported for strings");
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
HANDLE_EXCEPTION();
} else {
dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
if (IS_CV != IS_UNUSED) {
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_dim has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
if (UNEXPECTED(0)) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* zend_assign_to_variable() always takes care of op2, never free it! */
}
if (UNEXPECTED(1)) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* zend_assign_to_variable() always takes care of op2, never free it! */
}
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
} else {
expr_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
if (IS_VAR == IS_TMP_VAR) {
}
} while (0);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
}
} while (0);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
}
ZVAL_COPY(&generator->value, value_ptr);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
}
} else {
zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
FREE_OP(free_op_data1);
zval_ptr_dtor_nogc(free_op2);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_obj has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
zval_ptr_dtor_nogc(free_op2);
FREE_OP(free_op_data1);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
}
zval_ptr_dtor_nogc(free_op2);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
} while (0);
zval_ptr_dtor_nogc(free_op2);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
} while (0);
zval_ptr_dtor_nogc(free_op2);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
zval_ptr_dtor_nogc(free_op2);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
} else {
if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
zend_throw_error(NULL, "Cannot use [] for reading");
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
zend_throw_error(NULL, "Cannot use temporary expression in write context");
zval_ptr_dtor_nogc(free_op2);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
HANDLE_EXCEPTION();
}
zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
} else {
ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
}
exit_assign_obj:
zval_ptr_dtor_nogc(free_op2);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_obj has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
}
exit_assign_obj:
zval_ptr_dtor_nogc(free_op2);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_obj has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
}
exit_assign_obj:
zval_ptr_dtor_nogc(free_op2);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_obj has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
}
exit_assign_obj:
zval_ptr_dtor_nogc(free_op2);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_obj has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
zend_throw_error(NULL, "[] operator not supported for strings");
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
HANDLE_EXCEPTION();
} else {
dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
zval_ptr_dtor_nogc(free_op2);
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_dim has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
zend_throw_error(NULL, "[] operator not supported for strings");
zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
HANDLE_EXCEPTION();
} else {
dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
zval_ptr_dtor_nogc(free_op2);
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_dim has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
zend_throw_error(NULL, "[] operator not supported for strings");
zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
HANDLE_EXCEPTION();
} else {
dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
zval_ptr_dtor_nogc(free_op2);
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_dim has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
zend_throw_error(NULL, "[] operator not supported for strings");
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
HANDLE_EXCEPTION();
} else {
dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
zval_ptr_dtor_nogc(free_op2);
}
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
/* assign_dim has two opcodes! */
ZEND_VM_NEXT_OPCODE_EX(1, 2);
}
expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
} else {
expr_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
if (IS_VAR == IS_TMP_VAR) {
} while (0);
zval_ptr_dtor_nogc(free_op2);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
} while (0);
zval_ptr_dtor_nogc(free_op2);
- if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); };
+ if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
if (IS_CV & (IS_VAR|IS_TMP_VAR)) {
if (Z_REFCOUNTED_P(free_op1) && !Z_DELREF_P(free_op1)) {
SAVE_OPLINE();
- zval_dtor_func(Z_COUNTED_P(free_op1));
+ zval_dtor_func_for_ptr(Z_COUNTED_P(free_op1));
}
}
} else {
}
if (refcnt == 0) {
SAVE_OPLINE();
- zval_dtor_func(Z_COUNTED_P(variable_ptr));
+ zval_dtor_func_for_ptr(Z_COUNTED_P(variable_ptr));
if (UNEXPECTED(EG(exception))) {
ZVAL_NULL(variable_ptr);
HANDLE_EXCEPTION();
UNEXPECTED(!Z_ISERROR_P(EX_VAR(opline->op1.var)))) {
zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
- if (UNEXPECTED(free_op2)) { zval_ptr_dtor_nogc(free_op2); };
+ if (UNEXPECTED(free_op2)) {zval_ptr_dtor_nogc(free_op2);};
HANDLE_EXCEPTION();
} else if (IS_VAR == IS_VAR &&
UNEXPECTED(!Z_ISREF_P(value_ptr))) {
zend_error(E_NOTICE, "Only variables should be assigned by reference");
if (UNEXPECTED(EG(exception) != NULL)) {
- if (UNEXPECTED(free_op2)) { zval_ptr_dtor_nogc(free_op2); };
+ if (UNEXPECTED(free_op2)) {zval_ptr_dtor_nogc(free_op2);};
HANDLE_EXCEPTION();
}
ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
}
- if (UNEXPECTED(free_op2)) { zval_ptr_dtor_nogc(free_op2); };
+ if (UNEXPECTED(free_op2)) {zval_ptr_dtor_nogc(free_op2);};
}
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
if (!--GC_REFCOUNT(garbage)) {
ZVAL_UNDEF(var);
- zval_dtor_func(garbage);
+ zval_dtor_func_for_ptr(garbage);
} else {
zval *z = var;
ZVAL_DEREF(z);
if (!--GC_REFCOUNT(garbage)) {
ZVAL_UNDEF(var);
- zval_dtor_func(garbage);
+ zval_dtor_func_for_ptr(garbage);
} else {
zval *z = var;
ZVAL_DEREF(z);
);
$op1_free_op_if_var = array(
- "ANY" => "if (opline->op1_type == IS_VAR) { zval_ptr_dtor_nogc(free_op1); }",
+ "ANY" => "if (opline->op1_type == IS_VAR) {zval_ptr_dtor_nogc(free_op1);}",
"TMP" => "",
"VAR" => "zval_ptr_dtor_nogc(free_op1)",
"CONST" => "",
);
$op2_free_op_if_var = array(
- "ANY" => "if (opline->op2_type == IS_VAR) { zval_ptr_dtor_nogc(free_op2); }",
+ "ANY" => "if (opline->op2_type == IS_VAR) {zval_ptr_dtor_nogc(free_op2);}",
"TMP" => "",
"VAR" => "zval_ptr_dtor_nogc(free_op2)",
"CONST" => "",
);
$op1_free_op_var_ptr = array(
- "ANY" => "if (free_op1) { zval_ptr_dtor_nogc(free_op1); }",
+ "ANY" => "if (free_op1) {zval_ptr_dtor_nogc(free_op1);}",
"TMP" => "",
- "VAR" => "if (UNEXPECTED(free_op1)) { zval_ptr_dtor_nogc(free_op1); }",
+ "VAR" => "if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}",
"CONST" => "",
"UNUSED" => "",
"CV" => "",
);
$op2_free_op_var_ptr = array(
- "ANY" => "if (free_op2) { zval_ptr_dtor_nogc(free_op2); }",
+ "ANY" => "if (free_op2) {zval_ptr_dtor_nogc(free_op2);}",
"TMP" => "",
- "VAR" => "if (UNEXPECTED(free_op2)) { zval_ptr_dtor_nogc(free_op2); }",
+ "VAR" => "if (UNEXPECTED(free_op2)) {zval_ptr_dtor_nogc(free_op2);}",
"CONST" => "",
"UNUSED" => "",
"CV" => "",
} else {
zend_refcounted *garbage = Z_COUNTED_P(return_value);
ZVAL_COPY(return_value, tmp);
- zval_dtor_func(garbage);
+ _zval_dtor_func(garbage ZEND_FILE_LINE_CC);
}
}
}
projects / php / commitdiff