2
+----------------------------------------------------------------------+
4
+----------------------------------------------------------------------+
5
| Copyright (c) 1998-2009 Zend Technologies Ltd. (http://www.zend.com) |
6
+----------------------------------------------------------------------+
7
| This source file is subject to version 2.00 of the Zend license, |
8
| that is bundled with this package in the file LICENSE, and is |
9
| available through the world-wide-web at the following url: |
10
| http://www.zend.com/license/2_00.txt. |
11
| If you did not receive a copy of the Zend license and are unable to |
12
| obtain it through the world-wide-web, please send a note to |
13
| license@zend.com so we can mail you a copy immediately. |
14
+----------------------------------------------------------------------+
15
| Authors: Andi Gutmans <andi@zend.com> |
16
| Zeev Suraski <zeev@zend.com> |
17
| Dmitry Stogov <dmitry@zend.com> |
18
+----------------------------------------------------------------------+
21
static user_opcode_handler_t zend_user_opcode_handlers[256] = {(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL};
23
static zend_uchar zend_user_opcodes[256] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255};
25
static opcode_handler_t zend_vm_get_opcode_handler(zend_uchar opcode, zend_op* op);
28
#define ZEND_VM_CONTINUE() return 0
29
#define ZEND_VM_RETURN() return 1
30
#define ZEND_VM_ENTER() return 2
31
#define ZEND_VM_LEAVE() return 3
32
#define ZEND_VM_DISPATCH(opcode, opline) return zend_vm_get_opcode_handler(opcode, opline)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34
#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL execute_data TSRMLS_CC
36
#define EX(element) execute_data->element
39
ZEND_API void execute(zend_op_array *op_array TSRMLS_DC)
41
zend_execute_data *execute_data;
43
zend_bool original_in_execution = EG(in_execution);
53
/* Initialize execute_data */
54
execute_data = (zend_execute_data *)zend_vm_stack_alloc(
55
sizeof(zend_execute_data) +
56
sizeof(zval**) * op_array->last_var * (EG(active_symbol_table) ? 1 : 2) +
57
sizeof(temp_variable) * op_array->T TSRMLS_CC);
59
EX(CVs) = (zval***)((char*)execute_data + sizeof(zend_execute_data));
60
memset(EX(CVs), 0, sizeof(zval**) * op_array->last_var);
61
EX(Ts) = (temp_variable *)(EX(CVs) + op_array->last_var * (EG(active_symbol_table) ? 1 : 2));
63
EX(called_scope) = NULL;
65
EX(old_error_reporting) = NULL;
66
EX(op_array) = op_array;
67
EX(symbol_table) = EG(active_symbol_table);
68
EX(prev_execute_data) = EG(current_execute_data);
69
EG(current_execute_data) = execute_data;
73
if (op_array->start_op) {
74
ZEND_VM_SET_OPCODE(op_array->start_op);
76
ZEND_VM_SET_OPCODE(op_array->opcodes);
79
if (op_array->this_var != -1 && EG(This)) {
80
Z_ADDREF_P(EG(This)); /* For $this pointer */
81
if (!EG(active_symbol_table)) {
82
EX(CVs)[op_array->this_var] = (zval**)EX(CVs) + (op_array->last_var + op_array->this_var);
83
*EX(CVs)[op_array->this_var] = EG(This);
85
if (zend_hash_add(EG(active_symbol_table), "this", sizeof("this"), &EG(This), sizeof(zval *), (void**)&EX(CVs)[op_array->this_var])==FAILURE) {
91
EG(opline_ptr) = &EX(opline);
93
EX(function_state).function = (zend_function *) op_array;
94
EX(function_state).arguments = NULL;
104
if ((ret = EX(opline)->handler(execute_data TSRMLS_CC)) > 0) {
107
EG(in_execution) = original_in_execution;
110
op_array = EG(active_op_array);
113
execute_data = EG(current_execute_data);
120
zend_error_noreturn(E_ERROR, "Arrived at end of main loop which shouldn't happen");
123
static int ZEND_FASTCALL ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
126
printf("Jumping to %d\n", EX(opline)->op1.u.opline_num);
128
ZEND_VM_SET_OPCODE(EX(opline)->op1.u.jmp_addr);
129
ZEND_VM_CONTINUE(); /* CHECK_ME */
132
static int ZEND_FASTCALL ZEND_INIT_STRING_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
134
zval *tmp = &EX_T(EX(opline)->result.u.var).tmp_var;
136
tmp->value.str.val = emalloc(1);
137
tmp->value.str.val[0] = 0;
138
tmp->value.str.len = 0;
139
Z_SET_REFCOUNT_P(tmp, 1);
140
tmp->type = IS_STRING;
141
Z_UNSET_ISREF_P(tmp);
142
ZEND_VM_NEXT_OPCODE();
145
static int ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
148
zend_op_array *op_array = EX(op_array);
150
EG(current_execute_data) = EX(prev_execute_data);
151
EG(opline_ptr) = NULL;
152
if (!EG(active_symbol_table)) {
153
zval ***cv = EX(CVs);
154
zval ***end = cv + EX(op_array)->last_var;
165
zend_vm_stack_free(execute_data TSRMLS_CC);
168
execute_data = EG(current_execute_data);
170
if (EX(call_opline)->opcode == ZEND_INCLUDE_OR_EVAL) {
172
EX(function_state).function = (zend_function *) EX(op_array);
173
EX(function_state).arguments = NULL;
174
EX(object) = EX(current_object);
176
if (RETURN_VALUE_USED(EX(call_opline))) {
177
if (!EX_T(EX(call_opline)->result.u.var).var.ptr) { /* there was no return statement */
178
ALLOC_ZVAL(EX_T(EX(call_opline)->result.u.var).var.ptr);
179
INIT_PZVAL(EX_T(EX(call_opline)->result.u.var).var.ptr);
180
Z_LVAL_P(EX_T(EX(call_opline)->result.u.var).var.ptr) = 1;
181
Z_TYPE_P(EX_T(EX(call_opline)->result.u.var).var.ptr) = IS_BOOL;
185
EG(opline_ptr) = &EX(opline);
186
EG(active_op_array) = EX(op_array);
187
EG(return_value_ptr_ptr) = EX(original_return_value);
188
destroy_op_array(op_array TSRMLS_CC);
191
zend_throw_exception_internal(NULL TSRMLS_CC);
198
EG(opline_ptr) = &EX(opline);
199
EG(active_op_array) = EX(op_array);
200
EG(return_value_ptr_ptr) = EX(original_return_value);
201
if (EG(active_symbol_table)) {
202
if (EG(symtable_cache_ptr)>=EG(symtable_cache_limit)) {
203
zend_hash_destroy(EG(active_symbol_table));
204
FREE_HASHTABLE(EG(active_symbol_table));
206
/* clean before putting into the cache, since clean
207
could call dtors, which could use cached hash */
208
zend_hash_clean(EG(active_symbol_table));
209
*(++EG(symtable_cache_ptr)) = EG(active_symbol_table);
212
EG(active_symbol_table) = EX(symbol_table);
214
EX(function_state).function = (zend_function *) EX(op_array);
215
EX(function_state).arguments = NULL;
218
if (EG(exception) && IS_CTOR_CALL(EX(called_scope))) {
219
if (IS_CTOR_USED(EX(called_scope))) {
220
Z_DELREF_P(EG(This));
222
if (Z_REFCOUNT_P(EG(This)) == 1) {
223
zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
226
zval_ptr_dtor(&EG(This));
228
EG(This) = EX(current_this);
229
EG(scope) = EX(current_scope);
230
EG(called_scope) = EX(current_called_scope);
232
EX(object) = EX(current_object);
233
EX(called_scope) = DECODE_CTOR(EX(called_scope));
235
zend_vm_stack_clear_multiple(TSRMLS_C);
238
zend_throw_exception_internal(NULL TSRMLS_CC);
239
if (RETURN_VALUE_USED(EX(call_opline)) && EX_T(EX(call_opline)->result.u.var).var.ptr) {
240
zval_ptr_dtor(&EX_T(EX(call_opline)->result.u.var).var.ptr);
251
static int ZEND_FASTCALL zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
253
zend_op *opline = EX(opline);
254
zend_bool should_change_scope = 0;
256
if (EX(function_state).function->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) {
257
if (EX(function_state).function->common.fn_flags & ZEND_ACC_ABSTRACT) {
258
zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", EX(function_state).function->common.scope->name, EX(function_state).function->common.function_name);
259
ZEND_VM_NEXT_OPCODE(); /* Never reached */
261
if (EX(function_state).function->common.fn_flags & ZEND_ACC_DEPRECATED) {
262
zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated",
263
EX(function_state).function->common.scope ? EX(function_state).function->common.scope->name : "",
264
EX(function_state).function->common.scope ? "::" : "",
265
EX(function_state).function->common.function_name);
268
if (EX(function_state).function->common.scope &&
269
!(EX(function_state).function->common.fn_flags & ZEND_ACC_STATIC) &&
272
if (EX(function_state).function->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
273
/* FIXME: output identifiers properly */
274
zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically", EX(function_state).function->common.scope->name, EX(function_state).function->common.function_name);
276
/* FIXME: output identifiers properly */
277
/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
278
zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically", EX(function_state).function->common.scope->name, EX(function_state).function->common.function_name);
282
if (EX(function_state).function->type == ZEND_USER_FUNCTION ||
283
EX(function_state).function->common.scope) {
284
should_change_scope = 1;
285
EX(current_this) = EG(This);
286
EX(current_scope) = EG(scope);
287
EX(current_called_scope) = EG(called_scope);
288
EG(This) = EX(object);
289
EG(scope) = (EX(function_state).function->type == ZEND_USER_FUNCTION || !EX(object)) ? EX(function_state).function->common.scope : NULL;
290
EG(called_scope) = EX(called_scope);
293
zend_arg_types_stack_3_pop(&EG(arg_types_stack), &EX(called_scope), &EX(current_object), &EX(fbc));
294
EX(function_state).arguments = zend_vm_stack_push_args(opline->extended_value TSRMLS_CC);
296
if (EX(function_state).function->type == ZEND_INTERNAL_FUNCTION) {
297
ALLOC_INIT_ZVAL(EX_T(opline->result.u.var).var.ptr);
298
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
299
EX_T(opline->result.u.var).var.fcall_returned_reference = EX(function_state).function->common.return_reference;
301
if (EX(function_state).function->common.arg_info) {
303
zval **p = (zval**)EX(function_state).arguments;
304
ulong arg_count = opline->extended_value;
306
while (arg_count>0) {
307
zend_verify_arg_type(EX(function_state).function, ++i, *(p-arg_count), 0 TSRMLS_CC);
311
if (!zend_execute_internal) {
312
/* saves one function call if zend_execute_internal is not used */
313
((zend_internal_function *) EX(function_state).function)->handler(opline->extended_value, EX_T(opline->result.u.var).var.ptr, EX(function_state).function->common.return_reference?&EX_T(opline->result.u.var).var.ptr:NULL, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC);
315
zend_execute_internal(execute_data, RETURN_VALUE_USED(opline) TSRMLS_CC);
318
if (!RETURN_VALUE_USED(opline)) {
319
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
321
} else if (EX(function_state).function->type == ZEND_USER_FUNCTION) {
322
EX(original_return_value) = EG(return_value_ptr_ptr);
323
EG(active_symbol_table) = NULL;
324
EG(active_op_array) = &EX(function_state).function->op_array;
325
EG(return_value_ptr_ptr) = NULL;
326
if (RETURN_VALUE_USED(opline)) {
327
EG(return_value_ptr_ptr) = &EX_T(opline->result.u.var).var.ptr;
328
EX_T(opline->result.u.var).var.ptr = NULL;
329
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
330
EX_T(opline->result.u.var).var.fcall_returned_reference = EX(function_state).function->common.return_reference;
334
if (zend_execute == execute && !EG(exception)) {
335
EX(call_opline) = opline;
338
zend_execute(EG(active_op_array) TSRMLS_CC);
341
zend_execute(EG(active_op_array) TSRMLS_CC);
344
EG(opline_ptr) = &EX(opline);
345
EG(active_op_array) = EX(op_array);
346
EG(return_value_ptr_ptr) = EX(original_return_value);
347
if (EG(active_symbol_table)) {
348
if (EG(symtable_cache_ptr)>=EG(symtable_cache_limit)) {
349
zend_hash_destroy(EG(active_symbol_table));
350
FREE_HASHTABLE(EG(active_symbol_table));
352
/* clean before putting into the cache, since clean
353
could call dtors, which could use cached hash */
354
zend_hash_clean(EG(active_symbol_table));
355
*(++EG(symtable_cache_ptr)) = EG(active_symbol_table);
358
EG(active_symbol_table) = EX(symbol_table);
359
} else { /* ZEND_OVERLOADED_FUNCTION */
360
ALLOC_INIT_ZVAL(EX_T(opline->result.u.var).var.ptr);
362
/* Not sure what should be done here if it's a static method */
364
Z_OBJ_HT_P(EX(object))->call_method(EX(function_state).function->common.function_name, opline->extended_value, EX_T(opline->result.u.var).var.ptr, &EX_T(opline->result.u.var).var.ptr, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC);
366
zend_error_noreturn(E_ERROR, "Cannot call overloaded function for non-object");
369
if (EX(function_state).function->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
370
efree(EX(function_state).function->common.function_name);
372
efree(EX(function_state).function);
374
if (!RETURN_VALUE_USED(opline)) {
375
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
377
Z_UNSET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
378
Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
379
EX_T(opline->result.u.var).var.fcall_returned_reference = 0;
380
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
384
EX(function_state).function = (zend_function *) EX(op_array);
385
EX(function_state).arguments = NULL;
387
if (should_change_scope) {
389
if (EG(exception) && IS_CTOR_CALL(EX(called_scope))) {
390
if (IS_CTOR_USED(EX(called_scope))) {
391
Z_DELREF_P(EG(This));
393
if (Z_REFCOUNT_P(EG(This)) == 1) {
394
zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
397
zval_ptr_dtor(&EG(This));
399
EG(This) = EX(current_this);
400
EG(scope) = EX(current_scope);
401
EG(called_scope) = EX(current_called_scope);
404
EX(object) = EX(current_object);
405
EX(called_scope) = DECODE_CTOR(EX(called_scope));
407
zend_vm_stack_clear_multiple(TSRMLS_C);
410
zend_throw_exception_internal(NULL TSRMLS_CC);
411
if (RETURN_VALUE_USED(opline) && EX_T(opline->result.u.var).var.ptr) {
412
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
416
ZEND_VM_NEXT_OPCODE();
419
static int ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
421
EX(function_state).function = EX(fbc);
422
return zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
425
static int ZEND_FASTCALL ZEND_RECV_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
427
zend_op *opline = EX(opline);
428
zend_uint arg_num = Z_LVAL(opline->op1.u.constant);
429
zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
433
char *class_name = get_active_class_name(&space TSRMLS_CC);
434
zend_execute_data *ptr = EX(prev_execute_data);
436
if (zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, NULL, opline->extended_value TSRMLS_CC)) {
437
if(ptr && ptr->op_array) {
438
zend_error(E_WARNING, "Missing argument %ld for %s%s%s(), called in %s on line %d and defined", opline->op1.u.constant.value.lval, class_name, space, get_active_function_name(TSRMLS_C), ptr->op_array->filename, ptr->opline->lineno);
440
zend_error(E_WARNING, "Missing argument %ld for %s%s%s()", opline->op1.u.constant.value.lval, class_name, space, get_active_function_name(TSRMLS_C));
443
if (opline->result.op_type == IS_VAR) {
444
PZVAL_UNLOCK_FREE(*EX_T(opline->result.u.var).var.ptr_ptr);
447
zend_free_op free_res;
450
zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, *param, opline->extended_value TSRMLS_CC);
451
var_ptr = get_zval_ptr_ptr(&opline->result, EX(Ts), &free_res, BP_VAR_W);
452
Z_DELREF_PP(var_ptr);
454
Z_ADDREF_PP(var_ptr);
457
ZEND_VM_NEXT_OPCODE();
460
static int ZEND_FASTCALL ZEND_NEW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
462
zend_op *opline = EX(opline);
464
zend_function *constructor;
466
if (EX_T(opline->op1.u.var).class_entry->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) {
469
if (EX_T(opline->op1.u.var).class_entry->ce_flags & ZEND_ACC_INTERFACE) {
470
class_type = "interface";
472
class_type = "abstract class";
474
zend_error_noreturn(E_ERROR, "Cannot instantiate %s %s", class_type, EX_T(opline->op1.u.var).class_entry->name);
476
ALLOC_ZVAL(object_zval);
477
object_init_ex(object_zval, EX_T(opline->op1.u.var).class_entry);
478
INIT_PZVAL(object_zval);
480
constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC);
482
if (constructor == NULL) {
483
if (RETURN_VALUE_USED(opline)) {
484
AI_SET_PTR(EX_T(opline->result.u.var).var, object_zval);
486
zval_ptr_dtor(&object_zval);
488
ZEND_VM_JMP(EX(op_array)->opcodes + opline->op2.u.opline_num);
490
if (RETURN_VALUE_USED(opline)) {
491
AI_SET_PTR(EX_T(opline->result.u.var).var, object_zval);
492
PZVAL_LOCK(object_zval);
495
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), ENCODE_CTOR(EX(called_scope), RETURN_VALUE_USED(opline)));
497
/* We are not handling overloaded classes right now */
498
EX(object) = object_zval;
499
EX(fbc) = constructor;
500
EX(called_scope) = EX_T(opline->op1.u.var).class_entry;
502
ZEND_VM_NEXT_OPCODE();
506
static int ZEND_FASTCALL ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
508
zend_op *opline = EX(opline);
510
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = EG(error_reporting);
511
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_LONG; /* shouldn't be necessary */
512
if (EX(old_error_reporting) == NULL) {
513
EX(old_error_reporting) = &EX_T(opline->result.u.var).tmp_var;
516
if (EG(error_reporting)) {
517
zend_alter_ini_entry_ex("error_reporting", sizeof("error_reporting"), "0", 1, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME, 1 TSRMLS_CC);
519
ZEND_VM_NEXT_OPCODE();
522
static int ZEND_FASTCALL ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
524
zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", EG(scope)->name, EX(op_array)->function_name);
525
ZEND_VM_NEXT_OPCODE(); /* Never reached */
528
static int ZEND_FASTCALL ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
530
if (!EG(no_extensions)) {
531
zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_statement_handler, EX(op_array) TSRMLS_CC);
533
ZEND_VM_NEXT_OPCODE();
536
static int ZEND_FASTCALL ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
538
if (!EG(no_extensions)) {
539
zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_begin_handler, EX(op_array) TSRMLS_CC);
541
ZEND_VM_NEXT_OPCODE();
544
static int ZEND_FASTCALL ZEND_EXT_FCALL_END_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
546
if (!EG(no_extensions)) {
547
zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_end_handler, EX(op_array) TSRMLS_CC);
549
ZEND_VM_NEXT_OPCODE();
552
static int ZEND_FASTCALL ZEND_DECLARE_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
554
zend_op *opline = EX(opline);
556
EX_T(opline->result.u.var).class_entry = do_bind_class(opline, EG(class_table), 0 TSRMLS_CC);
557
ZEND_VM_NEXT_OPCODE();
560
static int ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
562
zend_op *opline = EX(opline);
564
EX_T(opline->result.u.var).class_entry = do_bind_inherited_class(opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC);
565
ZEND_VM_NEXT_OPCODE();
568
static int ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
570
zend_op *opline = EX(opline);
571
zend_class_entry **pce, **pce_orig;
573
if (zend_hash_find(EG(class_table), Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant)+1, (void**)&pce) == FAILURE ||
574
(zend_hash_find(EG(class_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), (void**)&pce_orig) == SUCCESS &&
575
*pce != *pce_orig)) {
576
do_bind_inherited_class(opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC);
578
ZEND_VM_NEXT_OPCODE();
581
static int ZEND_FASTCALL ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
583
do_bind_function(EX(opline), EG(function_table), 0);
584
ZEND_VM_NEXT_OPCODE();
587
static int ZEND_FASTCALL ZEND_EXT_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
589
ZEND_VM_NEXT_OPCODE();
592
static int ZEND_FASTCALL ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
594
ZEND_VM_NEXT_OPCODE();
597
static int ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
599
zend_uint op_num = EG(opline_before_exception)-EG(active_op_array)->opcodes;
601
zend_uint catch_op_num;
603
zval restored_error_reporting;
605
void **stack_frame = (void**)EX(Ts) +
606
(sizeof(temp_variable) * EX(op_array)->T) / sizeof(void*);
608
while (zend_vm_stack_top(TSRMLS_C) != stack_frame) {
609
zval *stack_zval_p = zend_vm_stack_pop(TSRMLS_C);
610
zval_ptr_dtor(&stack_zval_p);
613
for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
614
if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
615
/* further blocks will not be relevant... */
618
if (op_num >= EG(active_op_array)->try_catch_array[i].try_op
619
&& op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
620
catch_op_num = EX(op_array)->try_catch_array[i].catch_op;
626
EX(called_scope) = (zend_class_entry*)zend_ptr_stack_pop(&EG(arg_types_stack));
628
if (IS_CTOR_CALL(EX(called_scope))) {
629
if (IS_CTOR_USED(EX(called_scope))) {
630
Z_DELREF_P(EX(object));
632
if (Z_REFCOUNT_P(EX(object)) == 1) {
633
zend_object_store_ctor_failed(EX(object) TSRMLS_CC);
636
zval_ptr_dtor(&EX(object));
638
EX(called_scope) = DECODE_CTOR(EX(called_scope));
639
zend_arg_types_stack_2_pop(&EG(arg_types_stack), &EX(object), &EX(fbc));
642
for (i=0; i<EX(op_array)->last_brk_cont; i++) {
643
if (EX(op_array)->brk_cont_array[i].start < 0) {
645
} else if (EX(op_array)->brk_cont_array[i].start > op_num) {
646
/* further blocks will not be relevant... */
648
} else if (op_num < EX(op_array)->brk_cont_array[i].brk) {
650
catch_op_num >= EX(op_array)->brk_cont_array[i].brk) {
651
zend_op *brk_opline = &EX(op_array)->opcodes[EX(op_array)->brk_cont_array[i].brk];
653
switch (brk_opline->opcode) {
654
case ZEND_SWITCH_FREE:
655
if (brk_opline->op1.u.EA.type != EXT_TYPE_FREE_ON_RETURN) {
656
zend_switch_free(&EX_T(brk_opline->op1.u.var), brk_opline->extended_value TSRMLS_CC);
660
if (brk_opline->op1.u.EA.type != EXT_TYPE_FREE_ON_RETURN) {
661
zendi_zval_dtor(EX_T(brk_opline->op1.u.var).tmp_var);
669
/* restore previous error_reporting value */
670
if (!EG(error_reporting) && EX(old_error_reporting) != NULL && Z_LVAL_P(EX(old_error_reporting)) != 0) {
671
Z_TYPE(restored_error_reporting) = IS_LONG;
672
Z_LVAL(restored_error_reporting) = Z_LVAL_P(EX(old_error_reporting));
673
convert_to_string(&restored_error_reporting);
674
zend_alter_ini_entry_ex("error_reporting", sizeof("error_reporting"), Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME, 1 TSRMLS_CC);
675
zendi_zval_dtor(restored_error_reporting);
677
EX(old_error_reporting) = NULL;
680
return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
682
ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
687
static int ZEND_FASTCALL ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
689
zend_verify_abstract_class(EX_T(EX(opline)->op1.u.var).class_entry TSRMLS_CC);
690
ZEND_VM_NEXT_OPCODE();
693
static int ZEND_FASTCALL ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
695
int ret = zend_user_opcode_handlers[EX(opline)->opcode](ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL);
698
case ZEND_USER_OPCODE_CONTINUE:
700
case ZEND_USER_OPCODE_RETURN:
701
return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
702
case ZEND_USER_OPCODE_DISPATCH:
703
ZEND_VM_DISPATCH(EX(opline)->opcode, EX(opline));
705
ZEND_VM_DISPATCH((zend_uchar)(ret & 0xff), EX(opline));
709
static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
711
zend_op *opline = EX(opline);
714
if (IS_CONST == IS_UNUSED) {
715
EX_T(opline->result.u.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
716
ZEND_VM_NEXT_OPCODE();
719
zval *class_name = &opline->op2.u.constant;
721
if (IS_CONST != IS_CONST && Z_TYPE_P(class_name) == IS_OBJECT) {
722
EX_T(opline->result.u.var).class_entry = Z_OBJCE_P(class_name);
723
} else if (Z_TYPE_P(class_name) == IS_STRING) {
724
EX_T(opline->result.u.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
726
zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
729
ZEND_VM_NEXT_OPCODE();
733
static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
735
zend_op *opline = EX(opline);
737
char *function_name_strval, *lcname;
738
int function_name_strlen;
741
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
743
if (IS_CONST == IS_CONST) {
744
if (zend_hash_quick_find(EG(function_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant)+1, opline->extended_value, (void **) &EX(fbc)) == FAILURE) {
745
zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL(opline->op2.u.constant));
748
function_name = &opline->op2.u.constant;
750
if (IS_CONST != IS_CONST &&
751
Z_TYPE_P(function_name) == IS_OBJECT &&
752
Z_OBJ_HANDLER_P(function_name, get_closure) &&
753
Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &EX(called_scope), &EX(fbc), &EX(object) TSRMLS_CC) == SUCCESS) {
755
Z_ADDREF_P(EX(object));
758
ZEND_VM_NEXT_OPCODE();
761
if (Z_TYPE_P(function_name) != IS_STRING) {
762
zend_error_noreturn(E_ERROR, "Function name must be a string");
764
function_name_strval = Z_STRVAL_P(function_name);
765
function_name_strlen = Z_STRLEN_P(function_name);
766
if (function_name_strval[0] == '\\') {
768
function_name_strlen -= 1;
769
lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
771
lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
773
if (zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &EX(fbc)) == FAILURE) {
774
zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
781
ZEND_VM_NEXT_OPCODE();
785
static int ZEND_FASTCALL ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
787
zend_op *opline = EX(opline);
788
zend_op *op_data = opline + 1;
790
ZEND_VM_INC_OPCODE();
791
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
793
if (zend_hash_quick_find(EG(function_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant)+1, opline->extended_value, (void **) &EX(fbc))==FAILURE) {
794
char *short_name = Z_STRVAL(opline->op1.u.constant)+Z_LVAL(op_data->op1.u.constant);
795
if (zend_hash_quick_find(EG(function_table), short_name, Z_STRLEN(opline->op1.u.constant)-Z_LVAL(op_data->op1.u.constant)+1, op_data->extended_value, (void **) &EX(fbc))==FAILURE) {
796
zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL(opline->op2.u.constant));
801
ZEND_VM_NEXT_OPCODE();
804
static int ZEND_FASTCALL ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
806
zend_op *opline = EX(opline);
807
zval *assignment_value;
808
zend_uint arg_num = Z_LVAL(opline->op1.u.constant);
809
zend_free_op free_res;
810
zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
814
ALLOC_ZVAL(assignment_value);
815
*assignment_value = opline->op2.u.constant;
816
if ((Z_TYPE(opline->op2.u.constant) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT || Z_TYPE(opline->op2.u.constant)==IS_CONSTANT_ARRAY) {
817
Z_SET_REFCOUNT_P(assignment_value, 1);
818
zval_update_constant(&assignment_value, 0 TSRMLS_CC);
820
zval_copy_ctor(assignment_value);
822
INIT_PZVAL(assignment_value);
824
assignment_value = *param;
825
Z_ADDREF_P(assignment_value);
828
zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, assignment_value, opline->extended_value TSRMLS_CC);
829
var_ptr = get_zval_ptr_ptr(&opline->result, EX(Ts), &free_res, BP_VAR_W);
830
Z_DELREF_PP(var_ptr);
831
*var_ptr = assignment_value;
833
ZEND_VM_NEXT_OPCODE();
836
static int ZEND_FASTCALL ZEND_BRK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
838
zend_op *opline = EX(opline);
840
zend_brk_cont_element *el;
842
el = zend_brk_cont(&opline->op2.u.constant, opline->op1.u.opline_num,
843
EX(op_array), EX(Ts) TSRMLS_CC);
845
ZEND_VM_JMP(EX(op_array)->opcodes + el->brk);
848
static int ZEND_FASTCALL ZEND_CONT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
850
zend_op *opline = EX(opline);
852
zend_brk_cont_element *el;
854
el = zend_brk_cont(&opline->op2.u.constant, opline->op1.u.opline_num,
855
EX(op_array), EX(Ts) TSRMLS_CC);
857
ZEND_VM_JMP(EX(op_array)->opcodes + el->cont);
860
static int ZEND_FASTCALL ZEND_GOTO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
863
zend_op *opline = EX(opline);
864
zend_brk_cont_element *el;
866
el = zend_brk_cont(&opline->op2.u.constant, opline->extended_value,
867
EX(op_array), EX(Ts) TSRMLS_CC);
869
brk_opline = EX(op_array)->opcodes + el->brk;
871
switch (brk_opline->opcode) {
872
case ZEND_SWITCH_FREE:
873
if (brk_opline->op1.u.EA.type != EXT_TYPE_FREE_ON_RETURN) {
874
zend_switch_free(&EX_T(brk_opline->op1.u.var), brk_opline->extended_value TSRMLS_CC);
878
if (brk_opline->op1.u.EA.type != EXT_TYPE_FREE_ON_RETURN) {
879
zendi_zval_dtor(EX_T(brk_opline->op1.u.var).tmp_var);
883
ZEND_VM_JMP(opline->op1.u.jmp_addr);
886
static int ZEND_FASTCALL ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
888
zend_op *opline = EX(opline);
889
zend_class_entry *ce = EX_T(opline->op1.u.var).class_entry;
890
zend_class_entry *iface = zend_fetch_class(Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant), opline->extended_value TSRMLS_CC);
892
if (!(iface->ce_flags & ZEND_ACC_INTERFACE)) {
893
zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ce->name, iface->name);
896
zend_do_implement_interface(ce, iface TSRMLS_CC);
898
ZEND_VM_NEXT_OPCODE();
901
static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
903
zend_op *opline = EX(opline);
906
if (IS_TMP_VAR == IS_UNUSED) {
907
EX_T(opline->result.u.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
908
ZEND_VM_NEXT_OPCODE();
910
zend_free_op free_op2;
911
zval *class_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
913
if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(class_name) == IS_OBJECT) {
914
EX_T(opline->result.u.var).class_entry = Z_OBJCE_P(class_name);
915
} else if (Z_TYPE_P(class_name) == IS_STRING) {
916
EX_T(opline->result.u.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
918
zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
921
zval_dtor(free_op2.var);
922
ZEND_VM_NEXT_OPCODE();
926
static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
928
zend_op *opline = EX(opline);
930
char *function_name_strval, *lcname;
931
int function_name_strlen;
932
zend_free_op free_op2;
934
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
936
if (IS_TMP_VAR == IS_CONST) {
937
if (zend_hash_quick_find(EG(function_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant)+1, opline->extended_value, (void **) &EX(fbc)) == FAILURE) {
938
zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL(opline->op2.u.constant));
941
function_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
943
if (IS_TMP_VAR != IS_CONST &&
944
Z_TYPE_P(function_name) == IS_OBJECT &&
945
Z_OBJ_HANDLER_P(function_name, get_closure) &&
946
Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &EX(called_scope), &EX(fbc), &EX(object) TSRMLS_CC) == SUCCESS) {
948
Z_ADDREF_P(EX(object));
950
zval_dtor(free_op2.var);
951
ZEND_VM_NEXT_OPCODE();
954
if (Z_TYPE_P(function_name) != IS_STRING) {
955
zend_error_noreturn(E_ERROR, "Function name must be a string");
957
function_name_strval = Z_STRVAL_P(function_name);
958
function_name_strlen = Z_STRLEN_P(function_name);
959
if (function_name_strval[0] == '\\') {
961
function_name_strlen -= 1;
962
lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
964
lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
966
if (zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &EX(fbc)) == FAILURE) {
967
zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
970
zval_dtor(free_op2.var);
974
ZEND_VM_NEXT_OPCODE();
978
static int ZEND_FASTCALL ZEND_BRK_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
980
zend_op *opline = EX(opline);
981
zend_free_op free_op2;
982
zend_brk_cont_element *el;
984
el = zend_brk_cont(_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), opline->op1.u.opline_num,
985
EX(op_array), EX(Ts) TSRMLS_CC);
986
zval_dtor(free_op2.var);
987
ZEND_VM_JMP(EX(op_array)->opcodes + el->brk);
990
static int ZEND_FASTCALL ZEND_CONT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
992
zend_op *opline = EX(opline);
993
zend_free_op free_op2;
994
zend_brk_cont_element *el;
996
el = zend_brk_cont(_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), opline->op1.u.opline_num,
997
EX(op_array), EX(Ts) TSRMLS_CC);
998
zval_dtor(free_op2.var);
999
ZEND_VM_JMP(EX(op_array)->opcodes + el->cont);
1002
static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1004
zend_op *opline = EX(opline);
1007
if (IS_VAR == IS_UNUSED) {
1008
EX_T(opline->result.u.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
1009
ZEND_VM_NEXT_OPCODE();
1011
zend_free_op free_op2;
1012
zval *class_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
1014
if (IS_VAR != IS_CONST && Z_TYPE_P(class_name) == IS_OBJECT) {
1015
EX_T(opline->result.u.var).class_entry = Z_OBJCE_P(class_name);
1016
} else if (Z_TYPE_P(class_name) == IS_STRING) {
1017
EX_T(opline->result.u.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
1019
zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
1022
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
1023
ZEND_VM_NEXT_OPCODE();
1027
static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1029
zend_op *opline = EX(opline);
1030
zval *function_name;
1031
char *function_name_strval, *lcname;
1032
int function_name_strlen;
1033
zend_free_op free_op2;
1035
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
1037
if (IS_VAR == IS_CONST) {
1038
if (zend_hash_quick_find(EG(function_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant)+1, opline->extended_value, (void **) &EX(fbc)) == FAILURE) {
1039
zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL(opline->op2.u.constant));
1042
function_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
1044
if (IS_VAR != IS_CONST &&
1045
Z_TYPE_P(function_name) == IS_OBJECT &&
1046
Z_OBJ_HANDLER_P(function_name, get_closure) &&
1047
Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &EX(called_scope), &EX(fbc), &EX(object) TSRMLS_CC) == SUCCESS) {
1049
Z_ADDREF_P(EX(object));
1051
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
1052
ZEND_VM_NEXT_OPCODE();
1055
if (Z_TYPE_P(function_name) != IS_STRING) {
1056
zend_error_noreturn(E_ERROR, "Function name must be a string");
1058
function_name_strval = Z_STRVAL_P(function_name);
1059
function_name_strlen = Z_STRLEN_P(function_name);
1060
if (function_name_strval[0] == '\\') {
1062
function_name_strlen -= 1;
1063
lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
1065
lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
1067
if (zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &EX(fbc)) == FAILURE) {
1068
zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
1071
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
1075
ZEND_VM_NEXT_OPCODE();
1079
static int ZEND_FASTCALL ZEND_BRK_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1081
zend_op *opline = EX(opline);
1082
zend_free_op free_op2;
1083
zend_brk_cont_element *el;
1085
el = zend_brk_cont(_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), opline->op1.u.opline_num,
1086
EX(op_array), EX(Ts) TSRMLS_CC);
1087
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
1088
ZEND_VM_JMP(EX(op_array)->opcodes + el->brk);
1091
static int ZEND_FASTCALL ZEND_CONT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1093
zend_op *opline = EX(opline);
1094
zend_free_op free_op2;
1095
zend_brk_cont_element *el;
1097
el = zend_brk_cont(_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), opline->op1.u.opline_num,
1098
EX(op_array), EX(Ts) TSRMLS_CC);
1099
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
1100
ZEND_VM_JMP(EX(op_array)->opcodes + el->cont);
1103
static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1105
zend_op *opline = EX(opline);
1108
if (IS_UNUSED == IS_UNUSED) {
1109
EX_T(opline->result.u.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
1110
ZEND_VM_NEXT_OPCODE();
1113
zval *class_name = NULL;
1115
if (IS_UNUSED != IS_CONST && Z_TYPE_P(class_name) == IS_OBJECT) {
1116
EX_T(opline->result.u.var).class_entry = Z_OBJCE_P(class_name);
1117
} else if (Z_TYPE_P(class_name) == IS_STRING) {
1118
EX_T(opline->result.u.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
1120
zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
1123
ZEND_VM_NEXT_OPCODE();
1127
static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1129
zend_op *opline = EX(opline);
1132
if (IS_CV == IS_UNUSED) {
1133
EX_T(opline->result.u.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
1134
ZEND_VM_NEXT_OPCODE();
1137
zval *class_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
1139
if (IS_CV != IS_CONST && Z_TYPE_P(class_name) == IS_OBJECT) {
1140
EX_T(opline->result.u.var).class_entry = Z_OBJCE_P(class_name);
1141
} else if (Z_TYPE_P(class_name) == IS_STRING) {
1142
EX_T(opline->result.u.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
1144
zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
1147
ZEND_VM_NEXT_OPCODE();
1151
static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1153
zend_op *opline = EX(opline);
1154
zval *function_name;
1155
char *function_name_strval, *lcname;
1156
int function_name_strlen;
1159
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
1161
if (IS_CV == IS_CONST) {
1162
if (zend_hash_quick_find(EG(function_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant)+1, opline->extended_value, (void **) &EX(fbc)) == FAILURE) {
1163
zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL(opline->op2.u.constant));
1166
function_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
1168
if (IS_CV != IS_CONST &&
1169
Z_TYPE_P(function_name) == IS_OBJECT &&
1170
Z_OBJ_HANDLER_P(function_name, get_closure) &&
1171
Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &EX(called_scope), &EX(fbc), &EX(object) TSRMLS_CC) == SUCCESS) {
1173
Z_ADDREF_P(EX(object));
1176
ZEND_VM_NEXT_OPCODE();
1179
if (Z_TYPE_P(function_name) != IS_STRING) {
1180
zend_error_noreturn(E_ERROR, "Function name must be a string");
1182
function_name_strval = Z_STRVAL_P(function_name);
1183
function_name_strlen = Z_STRLEN_P(function_name);
1184
if (function_name_strval[0] == '\\') {
1186
function_name_strlen -= 1;
1187
lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
1189
lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
1191
if (zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &EX(fbc)) == FAILURE) {
1192
zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
1199
ZEND_VM_NEXT_OPCODE();
1203
static int ZEND_FASTCALL ZEND_CATCH_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1205
zend_op *opline = EX(opline);
1206
zend_class_entry *ce;
1208
/* Check whether an exception has been thrown, if not, jump over code */
1209
zend_exception_restore(TSRMLS_C);
1210
if (EG(exception) == NULL) {
1211
ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
1212
ZEND_VM_CONTINUE(); /* CHECK_ME */
1214
ce = Z_OBJCE_P(EG(exception));
1215
if (ce != EX_T(opline->op1.u.var).class_entry) {
1216
if (!instanceof_function(ce, EX_T(opline->op1.u.var).class_entry TSRMLS_CC)) {
1217
if (opline->op1.u.EA.type) {
1218
zend_throw_exception_internal(NULL TSRMLS_CC);
1219
ZEND_VM_NEXT_OPCODE();
1221
ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
1222
ZEND_VM_CONTINUE(); /* CHECK_ME */
1226
if (!EG(active_symbol_table)) {
1227
if (EX(CVs)[opline->op2.u.var]) {
1228
zval_ptr_dtor(EX(CVs)[opline->op2.u.var]);
1230
EX(CVs)[opline->op2.u.var] = (zval**)EX(CVs) + (EX(op_array)->last_var + opline->op2.u.var);
1231
*EX(CVs)[opline->op2.u.var] = EG(exception);
1233
zend_compiled_variable *cv = &CV_DEF_OF(opline->op2.u.var);
1234
zend_hash_quick_update(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value,
1235
&EG(exception), sizeof(zval *), (void**)&EX(CVs)[opline->op2.u.var]);
1237
EG(exception) = NULL;
1238
ZEND_VM_NEXT_OPCODE();
1241
static int ZEND_FASTCALL ZEND_BRK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1243
zend_op *opline = EX(opline);
1245
zend_brk_cont_element *el;
1247
el = zend_brk_cont(_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC), opline->op1.u.opline_num,
1248
EX(op_array), EX(Ts) TSRMLS_CC);
1250
ZEND_VM_JMP(EX(op_array)->opcodes + el->brk);
1253
static int ZEND_FASTCALL ZEND_CONT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1255
zend_op *opline = EX(opline);
1257
zend_brk_cont_element *el;
1259
el = zend_brk_cont(_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC), opline->op1.u.opline_num,
1260
EX(op_array), EX(Ts) TSRMLS_CC);
1262
ZEND_VM_JMP(EX(op_array)->opcodes + el->cont);
1265
static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1267
zend_op *opline = EX(opline);
1270
bitwise_not_function(&EX_T(opline->result.u.var).tmp_var,
1271
&opline->op1.u.constant TSRMLS_CC);
1273
ZEND_VM_NEXT_OPCODE();
1276
static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1278
zend_op *opline = EX(opline);
1281
boolean_not_function(&EX_T(opline->result.u.var).tmp_var,
1282
&opline->op1.u.constant TSRMLS_CC);
1284
ZEND_VM_NEXT_OPCODE();
1287
static int ZEND_FASTCALL ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1289
zend_op *opline = EX(opline);
1292
zval *z = &opline->op1.u.constant;
1294
if (IS_CONST != IS_CONST &&
1295
Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get_method != NULL &&
1296
zend_std_cast_object_tostring(z, &z_copy, IS_STRING TSRMLS_CC) == SUCCESS) {
1297
zend_print_variable(&z_copy);
1300
zend_print_variable(z);
1303
ZEND_VM_NEXT_OPCODE();
1306
static int ZEND_FASTCALL ZEND_PRINT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1308
zend_op *opline = EX(opline);
1310
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
1311
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_LONG;
1313
return ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1316
static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
1318
zend_op *opline = EX(opline);
1319
zend_free_op free_op1;
1320
zval *varname = &opline->op1.u.constant;
1323
HashTable *target_symbol_table;
1325
if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
1326
tmp_varname = *varname;
1327
zval_copy_ctor(&tmp_varname);
1328
convert_to_string(&tmp_varname);
1329
varname = &tmp_varname;
1332
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
1333
retval = zend_std_get_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0 TSRMLS_CC);
1335
target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), type, varname TSRMLS_CC);
1337
if (!target_symbol_table) {
1338
ZEND_VM_NEXT_OPCODE();
1341
if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &retval) == FAILURE) {
1345
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
1346
/* break missing intentionally */
1348
retval = &EG(uninitialized_zval_ptr);
1351
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
1352
/* break missing intentionally */
1354
zval *new_zval = &EG(uninitialized_zval);
1356
Z_ADDREF_P(new_zval);
1357
zend_hash_update(target_symbol_table, varname->value.str.val, varname->value.str.len+1, &new_zval, sizeof(zval *), (void **) &retval);
1360
EMPTY_SWITCH_DEFAULT_CASE()
1363
switch (opline->op2.u.EA.type) {
1364
case ZEND_FETCH_GLOBAL:
1365
if (IS_CONST != IS_TMP_VAR) {
1369
case ZEND_FETCH_LOCAL:
1372
case ZEND_FETCH_STATIC:
1373
zval_update_constant(retval, (void*) 1 TSRMLS_CC);
1375
case ZEND_FETCH_GLOBAL_LOCK:
1376
if (IS_CONST == IS_VAR && !free_op1.var) {
1377
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
1384
if (IS_CONST != IS_CONST && varname == &tmp_varname) {
1387
if (!RETURN_VALUE_UNUSED(&opline->result)) {
1388
if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
1389
SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
1391
PZVAL_LOCK(*retval);
1395
AI_SET_PTR(EX_T(opline->result.u.var).var, *retval);
1397
case BP_VAR_UNSET: {
1398
zend_free_op free_res;
1400
EX_T(opline->result.u.var).var.ptr_ptr = retval;
1401
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
1402
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
1403
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
1405
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
1406
FREE_OP_VAR_PTR(free_res);
1409
EX_T(opline->result.u.var).var.ptr_ptr = retval;
1414
ZEND_VM_NEXT_OPCODE();
1417
static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1419
return zend_fetch_var_address_helper_SPEC_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1422
static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1424
return zend_fetch_var_address_helper_SPEC_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1427
static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1429
return zend_fetch_var_address_helper_SPEC_CONST(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1432
static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1434
return zend_fetch_var_address_helper_SPEC_CONST(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), EX(opline)->extended_value)?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1437
static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1439
return zend_fetch_var_address_helper_SPEC_CONST(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1442
static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1444
return zend_fetch_var_address_helper_SPEC_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1447
static int ZEND_FASTCALL ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1449
zend_op *opline = EX(opline);
1451
zval *val = &opline->op1.u.constant;
1454
if (IS_CONST == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
1455
ret = Z_LVAL_P(val);
1457
ret = i_zend_is_true(val);
1459
if (UNEXPECTED(EG(exception) != NULL)) {
1465
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
1467
ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
1471
ZEND_VM_NEXT_OPCODE();
1474
static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1476
zend_op *opline = EX(opline);
1478
zval *val = &opline->op1.u.constant;
1481
if (IS_CONST == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
1482
ret = Z_LVAL_P(val);
1484
ret = i_zend_is_true(val);
1486
if (UNEXPECTED(EG(exception) != NULL)) {
1492
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
1494
ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
1498
ZEND_VM_NEXT_OPCODE();
1501
static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1503
zend_op *opline = EX(opline);
1505
zval *val = &opline->op1.u.constant;
1508
if (IS_CONST == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
1509
retval = Z_LVAL_P(val);
1511
retval = i_zend_is_true(val);
1513
if (UNEXPECTED(EG(exception) != NULL)) {
1517
if (EXPECTED(retval != 0)) {
1519
printf("Conditional jmp on true to %d\n", opline->extended_value);
1521
ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
1522
ZEND_VM_CONTINUE(); /* CHECK_ME */
1525
printf("Conditional jmp on false to %d\n", opline->op2.u.opline_num);
1527
ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.u.opline_num]);
1528
ZEND_VM_CONTINUE(); /* CHECK_ME */
1532
static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1534
zend_op *opline = EX(opline);
1536
zval *val = &opline->op1.u.constant;
1539
if (IS_CONST == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
1540
retval = Z_LVAL_P(val);
1542
retval = i_zend_is_true(val);
1544
if (UNEXPECTED(EG(exception) != NULL)) {
1548
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
1549
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
1552
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
1554
ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
1557
ZEND_VM_NEXT_OPCODE();
1560
static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1562
zend_op *opline = EX(opline);
1564
zval *val = &opline->op1.u.constant;
1567
if (IS_CONST == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
1568
retval = Z_LVAL_P(val);
1570
retval = i_zend_is_true(val);
1572
if (UNEXPECTED(EG(exception) != NULL)) {
1576
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
1577
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
1580
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
1582
ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
1585
ZEND_VM_NEXT_OPCODE();
1588
static int ZEND_FASTCALL ZEND_DO_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1590
zend_op *opline = EX(opline);
1592
zval *fname = &opline->op1.u.constant;
1594
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
1596
if (zend_hash_quick_find(EG(function_table), fname->value.str.val, fname->value.str.len+1, Z_LVAL(opline->op2.u.constant), (void **) &EX(function_state).function)==FAILURE) {
1597
zend_error_noreturn(E_ERROR, "Call to undefined function %s()", fname->value.str.val);
1601
return zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1604
static int ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1606
zend_op *opline = EX(opline);
1608
zval **retval_ptr_ptr;
1611
if (EG(active_op_array)->return_reference == ZEND_RETURN_REF) {
1613
if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
1614
/* Not supposed to happen, but we'll allow it */
1615
zend_error(E_NOTICE, "Only variable references should be returned by reference");
1616
goto return_by_value;
1619
retval_ptr_ptr = NULL;
1621
if (IS_CONST == IS_VAR && !retval_ptr_ptr) {
1622
zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
1625
if (IS_CONST == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
1626
if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
1627
EX_T(opline->op1.u.var).var.fcall_returned_reference) {
1628
} else if (EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
1629
if (IS_CONST == IS_VAR && !0) {
1630
PZVAL_LOCK(*retval_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
1632
zend_error(E_NOTICE, "Only variable references should be returned by reference");
1633
goto return_by_value;
1637
if (EG(return_value_ptr_ptr)) {
1638
SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
1639
Z_ADDREF_PP(retval_ptr_ptr);
1641
(*EG(return_value_ptr_ptr)) = (*retval_ptr_ptr);
1646
retval_ptr = &opline->op1.u.constant;
1648
if (!EG(return_value_ptr_ptr)) {
1649
if (IS_CONST == IS_TMP_VAR) {
1652
} else if (!0) { /* Not a temp var */
1653
if (IS_CONST == IS_CONST ||
1654
EG(active_op_array)->return_reference == ZEND_RETURN_REF ||
1655
(PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
1659
INIT_PZVAL_COPY(ret, retval_ptr);
1660
zval_copy_ctor(ret);
1661
*EG(return_value_ptr_ptr) = ret;
1663
*EG(return_value_ptr_ptr) = retval_ptr;
1664
Z_ADDREF_P(retval_ptr);
1670
INIT_PZVAL_COPY(ret, retval_ptr);
1671
*EG(return_value_ptr_ptr) = ret;
1675
return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1678
static int ZEND_FASTCALL ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1680
zend_op *opline = EX(opline);
1685
value = &opline->op1.u.constant;
1687
if (IS_CONST == IS_CONST || Z_TYPE_P(value) != IS_OBJECT) {
1688
zend_error_noreturn(E_ERROR, "Can only throw objects");
1690
zend_exception_save(TSRMLS_C);
1691
/* Not sure if a complete copy is what we want here */
1692
ALLOC_ZVAL(exception);
1693
INIT_PZVAL_COPY(exception, value);
1695
zval_copy_ctor(exception);
1698
zend_throw_exception_object(exception TSRMLS_CC);
1699
zend_exception_restore(TSRMLS_C);
1701
ZEND_VM_NEXT_OPCODE();
1704
static int ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1706
zend_op *opline = EX(opline);
1707
if (opline->extended_value==ZEND_DO_FCALL_BY_NAME
1708
&& ARG_MUST_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
1709
zend_error_noreturn(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.u.opline_num);
1716
value = &opline->op1.u.constant;
1719
INIT_PZVAL_COPY(valptr, value);
1721
zval_copy_ctor(valptr);
1723
zend_vm_stack_push(valptr TSRMLS_CC);
1726
ZEND_VM_NEXT_OPCODE();
1729
static int ZEND_FASTCALL ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1731
zend_op *opline = EX(opline);
1734
/* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
1735
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = i_zend_is_true(&opline->op1.u.constant);
1736
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
1738
ZEND_VM_NEXT_OPCODE();
1741
static int ZEND_FASTCALL ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1743
zend_op *opline = EX(opline);
1745
zval *obj = &opline->op1.u.constant;
1746
zend_class_entry *ce;
1747
zend_function *clone;
1748
zend_object_clone_obj_t clone_call;
1750
if (IS_CONST == IS_CONST ||
1751
(IS_CONST == IS_VAR && !obj) ||
1752
Z_TYPE_P(obj) != IS_OBJECT) {
1753
zend_error_noreturn(E_ERROR, "__clone method called on non-object");
1756
ce = Z_OBJCE_P(obj);
1757
clone = ce ? ce->clone : NULL;
1758
clone_call = Z_OBJ_HT_P(obj)->clone_obj;
1761
zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
1763
zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
1768
if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
1769
/* Ensure that if we're calling a private function, we're allowed to do so.
1771
if (ce != EG(scope)) {
1772
zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
1774
} else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
1775
/* Ensure that if we're calling a protected function, we're allowed to do so.
1777
if (!zend_check_protected(clone->common.scope, EG(scope))) {
1778
zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
1783
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
1784
if (!EG(exception)) {
1785
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
1786
Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC);
1787
Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
1788
Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
1789
Z_SET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
1790
if (!RETURN_VALUE_USED(opline) || EG(exception)) {
1791
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
1795
ZEND_VM_NEXT_OPCODE();
1798
static int ZEND_FASTCALL ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1800
zend_op *opline = EX(opline);
1802
zval *expr = &opline->op1.u.constant;
1803
zval *result = &EX_T(opline->result.u.var).tmp_var;
1805
if (opline->extended_value != IS_STRING) {
1808
zendi_zval_copy_ctor(*result);
1811
switch (opline->extended_value) {
1813
convert_to_null(result);
1816
convert_to_boolean(result);
1819
convert_to_long(result);
1822
convert_to_double(result);
1828
zend_make_printable_zval(expr, &var_copy, &use_copy);
1837
zendi_zval_copy_ctor(*result);
1843
convert_to_array(result);
1846
convert_to_object(result);
1850
ZEND_VM_NEXT_OPCODE();
1853
static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1855
zend_op *opline = EX(opline);
1856
zend_op_array *new_op_array=NULL;
1857
int return_value_used;
1859
zval *inc_filename = &opline->op1.u.constant;
1860
zval tmp_inc_filename;
1861
zend_bool failure_retval=0;
1863
if (inc_filename->type!=IS_STRING) {
1864
tmp_inc_filename = *inc_filename;
1865
zval_copy_ctor(&tmp_inc_filename);
1866
convert_to_string(&tmp_inc_filename);
1867
inc_filename = &tmp_inc_filename;
1870
return_value_used = RETURN_VALUE_USED(opline);
1872
switch (Z_LVAL(opline->op2.u.constant)) {
1873
case ZEND_INCLUDE_ONCE:
1874
case ZEND_REQUIRE_ONCE: {
1875
zend_file_handle file_handle;
1876
char *resolved_path;
1878
resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
1879
if (resolved_path) {
1880
failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
1882
resolved_path = Z_STRVAL_P(inc_filename);
1885
if (failure_retval) {
1886
/* do nothing, file already included */
1887
} else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) {
1889
if (!file_handle.opened_path) {
1890
file_handle.opened_path = estrdup(resolved_path);
1893
if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
1894
new_op_array = zend_compile_file(&file_handle, (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
1895
zend_destroy_file_handle(&file_handle TSRMLS_CC);
1897
zend_file_handle_dtor(&file_handle TSRMLS_CC);
1901
if (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE) {
1902
zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
1904
zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
1907
if (resolved_path != Z_STRVAL_P(inc_filename)) {
1908
efree(resolved_path);
1914
new_op_array = compile_filename(Z_LVAL(opline->op2.u.constant), inc_filename TSRMLS_CC);
1917
char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
1919
new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
1923
EMPTY_SWITCH_DEFAULT_CASE()
1925
if (inc_filename==&tmp_inc_filename) {
1926
zval_dtor(&tmp_inc_filename);
1929
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
1930
if (new_op_array && !EG(exception)) {
1931
EX(original_return_value) = EG(return_value_ptr_ptr);
1932
EG(return_value_ptr_ptr) = return_value_used ? EX_T(opline->result.u.var).var.ptr_ptr : NULL;
1933
EG(active_op_array) = new_op_array;
1934
EX_T(opline->result.u.var).var.ptr = NULL;
1936
EX(current_object) = EX(object);
1938
EX(function_state).function = (zend_function *) new_op_array;
1941
if (!EG(active_symbol_table)) {
1942
zend_rebuild_symbol_table(TSRMLS_C);
1945
if (zend_execute == execute) {
1946
EX(call_opline) = opline;
1949
zend_execute(new_op_array TSRMLS_CC);
1952
EX(function_state).function = (zend_function *) EX(op_array);
1953
EX(object) = EX(current_object);
1955
if (return_value_used) {
1956
if (!EX_T(opline->result.u.var).var.ptr) { /* there was no return statement */
1957
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
1958
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
1959
Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = 1;
1960
Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
1964
EG(opline_ptr) = &EX(opline);
1965
EG(active_op_array) = EX(op_array);
1966
EG(return_value_ptr_ptr) = EX(original_return_value);
1967
destroy_op_array(new_op_array TSRMLS_CC);
1968
efree(new_op_array);
1969
if (EG(exception)) {
1970
zend_throw_exception_internal(NULL TSRMLS_CC);
1973
if (return_value_used) {
1974
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
1975
INIT_ZVAL(*EX_T(opline->result.u.var).var.ptr);
1976
Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = failure_retval;
1977
Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
1980
ZEND_VM_NEXT_OPCODE();
1983
static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1985
zend_op *opline = EX(opline);
1987
HashTable *target_symbol_table;
1990
if (IS_CONST == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
1991
if (EG(active_symbol_table)) {
1992
zend_execute_data *ex = EX(prev_execute_data);
1993
zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.u.var);
1995
if (zend_hash_quick_del(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value) == SUCCESS) {
1996
while (ex && ex->symbol_table == EG(active_symbol_table)) {
2000
for (i = 0; i < ex->op_array->last_var; i++) {
2001
if (ex->op_array->vars[i].hash_value == cv->hash_value &&
2002
ex->op_array->vars[i].name_len == cv->name_len &&
2003
!memcmp(ex->op_array->vars[i].name, cv->name, cv->name_len)) {
2009
ex = ex->prev_execute_data;
2012
EX(CVs)[opline->op1.u.var] = NULL;
2013
} else if (EX(CVs)[opline->op1.u.var]) {
2014
zval_ptr_dtor(EX(CVs)[opline->op1.u.var]);
2015
EX(CVs)[opline->op1.u.var] = NULL;
2017
ZEND_VM_NEXT_OPCODE();
2020
varname = &opline->op1.u.constant;
2022
if (Z_TYPE_P(varname) != IS_STRING) {
2024
zval_copy_ctor(&tmp);
2025
convert_to_string(&tmp);
2027
} else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
2028
Z_ADDREF_P(varname);
2031
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
2032
zend_std_unset_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname) TSRMLS_CC);
2034
ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
2036
target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
2037
if (zend_hash_quick_del(target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value) == SUCCESS) {
2038
zend_execute_data *ex = execute_data;
2044
for (i = 0; i < ex->op_array->last_var; i++) {
2045
if (ex->op_array->vars[i].hash_value == hash_value &&
2046
ex->op_array->vars[i].name_len == varname->value.str.len &&
2047
!memcmp(ex->op_array->vars[i].name, varname->value.str.val, varname->value.str.len)) {
2053
ex = ex->prev_execute_data;
2054
} while (ex && ex->symbol_table == target_symbol_table);
2058
if (varname == &tmp) {
2060
} else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
2061
zval_ptr_dtor(&varname);
2064
ZEND_VM_NEXT_OPCODE();
2067
static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2069
zend_op *opline = EX(opline);
2071
zval *array_ptr, **array_ptr_ptr;
2073
zend_object_iterator *iter = NULL;
2074
zend_class_entry *ce = NULL;
2075
zend_bool is_empty = 0;
2077
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
2078
array_ptr_ptr = NULL;
2079
if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
2080
ALLOC_INIT_ZVAL(array_ptr);
2081
} else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
2082
if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
2083
zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class");
2084
ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
2087
ce = Z_OBJCE_PP(array_ptr_ptr);
2088
if (!ce || ce->get_iterator == NULL) {
2089
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
2090
Z_ADDREF_PP(array_ptr_ptr);
2092
array_ptr = *array_ptr_ptr;
2094
if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
2095
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
2096
if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
2097
Z_SET_ISREF_PP(array_ptr_ptr);
2100
array_ptr = *array_ptr_ptr;
2101
Z_ADDREF_P(array_ptr);
2104
array_ptr = &opline->op1.u.constant;
2105
if (0) { /* IS_TMP_VAR */
2109
INIT_PZVAL_COPY(tmp, array_ptr);
2111
} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
2112
ce = Z_OBJCE_P(array_ptr);
2113
if (!ce || !ce->get_iterator) {
2114
Z_ADDREF_P(array_ptr);
2117
if ((IS_CONST == IS_CV || IS_CONST == IS_VAR) &&
2118
!Z_ISREF_P(array_ptr) &&
2119
Z_REFCOUNT_P(array_ptr) > 1) {
2123
INIT_PZVAL_COPY(tmp, array_ptr);
2124
zval_copy_ctor(tmp);
2127
Z_ADDREF_P(array_ptr);
2132
if (IS_CONST != IS_TMP_VAR && ce && ce->get_iterator) {
2133
iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC);
2135
if (iter && !EG(exception)) {
2136
array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
2138
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
2143
if (!EG(exception)) {
2144
zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
2146
zend_throw_exception_internal(NULL TSRMLS_CC);
2147
ZEND_VM_NEXT_OPCODE();
2151
AI_SET_PTR(EX_T(opline->result.u.var).var, array_ptr);
2152
PZVAL_LOCK(array_ptr);
2156
if (iter->funcs->rewind) {
2157
iter->funcs->rewind(iter TSRMLS_CC);
2158
if (EG(exception)) {
2159
Z_DELREF_P(array_ptr);
2160
zval_ptr_dtor(&array_ptr);
2161
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
2166
ZEND_VM_NEXT_OPCODE();
2169
is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
2170
if (EG(exception)) {
2171
Z_DELREF_P(array_ptr);
2172
zval_ptr_dtor(&array_ptr);
2173
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
2178
ZEND_VM_NEXT_OPCODE();
2180
iter->index = -1; /* will be set to 0 before using next handler */
2181
} else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
2182
zend_hash_internal_pointer_reset(fe_ht);
2184
zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
2185
while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
2189
zend_uchar key_type;
2191
key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
2192
if (key_type != HASH_KEY_NON_EXISTANT &&
2193
(key_type == HASH_KEY_IS_LONG ||
2194
zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
2197
zend_hash_move_forward(fe_ht);
2200
is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
2201
zend_hash_get_pointer(fe_ht, &EX_T(opline->result.u.var).fe.fe_pos);
2203
zend_error(E_WARNING, "Invalid argument supplied for foreach()");
2207
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
2213
ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
2215
ZEND_VM_NEXT_OPCODE();
2219
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2221
zend_op *opline = EX(opline);
2223
zend_bool isset = 1;
2225
if (IS_CONST == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
2226
if (EX(CVs)[opline->op1.u.var]) {
2227
value = EX(CVs)[opline->op1.u.var];
2228
} else if (EG(active_symbol_table)) {
2229
zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.u.var);
2231
if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
2238
HashTable *target_symbol_table;
2240
zval tmp, *varname = &opline->op1.u.constant;
2242
if (Z_TYPE_P(varname) != IS_STRING) {
2244
zval_copy_ctor(&tmp);
2245
convert_to_string(&tmp);
2249
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
2250
value = zend_std_get_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1 TSRMLS_CC);
2255
target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
2256
if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
2261
if (varname == &tmp) {
2267
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
2269
switch (opline->extended_value & ZEND_ISSET_ISEMPTY_MASK) {
2271
if (isset && Z_TYPE_PP(value) == IS_NULL) {
2272
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
2274
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = isset;
2278
if (!isset || !i_zend_is_true(*value)) {
2279
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
2281
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
2286
ZEND_VM_NEXT_OPCODE();
2289
static int ZEND_FASTCALL ZEND_EXIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2291
#if 0 || (IS_CONST != IS_UNUSED)
2292
zend_op *opline = EX(opline);
2293
if (IS_CONST != IS_UNUSED) {
2295
zval *ptr = &opline->op1.u.constant;
2297
if (Z_TYPE_P(ptr) == IS_LONG) {
2298
EG(exit_status) = Z_LVAL_P(ptr);
2300
zend_print_variable(ptr);
2306
ZEND_VM_NEXT_OPCODE();
2309
static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2311
zend_op *opline = EX(opline);
2313
zval *value = &opline->op1.u.constant;
2315
if (i_zend_is_true(value)) {
2316
EX_T(opline->result.u.var).tmp_var = *value;
2317
zendi_zval_copy_ctor(EX_T(opline->result.u.var).tmp_var);
2320
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
2322
ZEND_VM_JMP(opline->op2.u.jmp_addr);
2325
ZEND_VM_NEXT_OPCODE();
2328
static int ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2330
zend_op *opline = EX(opline);
2332
zval *value = &opline->op1.u.constant;
2334
EX_T(opline->result.u.var).tmp_var = *value;
2336
zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
2339
ZEND_VM_NEXT_OPCODE();
2342
static int ZEND_FASTCALL ZEND_TICKS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2344
zend_op *opline = EX(opline);
2346
if (++EG(ticks_count)>=Z_LVAL(opline->op1.u.constant)) {
2348
if (zend_ticks_function) {
2349
zend_ticks_function(Z_LVAL(opline->op1.u.constant));
2352
ZEND_VM_NEXT_OPCODE();
2355
static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2357
zend_op *opline = EX(opline);
2360
add_function(&EX_T(opline->result.u.var).tmp_var,
2361
&opline->op1.u.constant,
2362
&opline->op2.u.constant TSRMLS_CC);
2365
ZEND_VM_NEXT_OPCODE();
2368
static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2370
zend_op *opline = EX(opline);
2373
sub_function(&EX_T(opline->result.u.var).tmp_var,
2374
&opline->op1.u.constant,
2375
&opline->op2.u.constant TSRMLS_CC);
2378
ZEND_VM_NEXT_OPCODE();
2381
static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2383
zend_op *opline = EX(opline);
2386
mul_function(&EX_T(opline->result.u.var).tmp_var,
2387
&opline->op1.u.constant,
2388
&opline->op2.u.constant TSRMLS_CC);
2391
ZEND_VM_NEXT_OPCODE();
2394
static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2396
zend_op *opline = EX(opline);
2399
div_function(&EX_T(opline->result.u.var).tmp_var,
2400
&opline->op1.u.constant,
2401
&opline->op2.u.constant TSRMLS_CC);
2404
ZEND_VM_NEXT_OPCODE();
2407
static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2409
zend_op *opline = EX(opline);
2412
mod_function(&EX_T(opline->result.u.var).tmp_var,
2413
&opline->op1.u.constant,
2414
&opline->op2.u.constant TSRMLS_CC);
2417
ZEND_VM_NEXT_OPCODE();
2420
static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2422
zend_op *opline = EX(opline);
2425
shift_left_function(&EX_T(opline->result.u.var).tmp_var,
2426
&opline->op1.u.constant,
2427
&opline->op2.u.constant TSRMLS_CC);
2430
ZEND_VM_NEXT_OPCODE();
2433
static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2435
zend_op *opline = EX(opline);
2438
shift_right_function(&EX_T(opline->result.u.var).tmp_var,
2439
&opline->op1.u.constant,
2440
&opline->op2.u.constant TSRMLS_CC);
2443
ZEND_VM_NEXT_OPCODE();
2446
static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2448
zend_op *opline = EX(opline);
2451
concat_function(&EX_T(opline->result.u.var).tmp_var,
2452
&opline->op1.u.constant,
2453
&opline->op2.u.constant TSRMLS_CC);
2456
ZEND_VM_NEXT_OPCODE();
2459
static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2461
zend_op *opline = EX(opline);
2464
is_identical_function(&EX_T(opline->result.u.var).tmp_var,
2465
&opline->op1.u.constant,
2466
&opline->op2.u.constant TSRMLS_CC);
2469
ZEND_VM_NEXT_OPCODE();
2472
static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2474
zend_op *opline = EX(opline);
2476
zval *result = &EX_T(opline->result.u.var).tmp_var;
2478
is_identical_function(result,
2479
&opline->op1.u.constant,
2480
&opline->op2.u.constant TSRMLS_CC);
2481
Z_LVAL_P(result) = !Z_LVAL_P(result);
2484
ZEND_VM_NEXT_OPCODE();
2487
static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2489
zend_op *opline = EX(opline);
2491
zval *result = &EX_T(opline->result.u.var).tmp_var;
2493
compare_function(result,
2494
&opline->op1.u.constant,
2495
&opline->op2.u.constant TSRMLS_CC);
2496
ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
2499
ZEND_VM_NEXT_OPCODE();
2502
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2504
zend_op *opline = EX(opline);
2506
zval *result = &EX_T(opline->result.u.var).tmp_var;
2508
compare_function(result,
2509
&opline->op1.u.constant,
2510
&opline->op2.u.constant TSRMLS_CC);
2511
ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
2514
ZEND_VM_NEXT_OPCODE();
2517
static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2519
zend_op *opline = EX(opline);
2521
zval *result = &EX_T(opline->result.u.var).tmp_var;
2523
compare_function(result,
2524
&opline->op1.u.constant,
2525
&opline->op2.u.constant TSRMLS_CC);
2526
ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
2529
ZEND_VM_NEXT_OPCODE();
2532
static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2534
zend_op *opline = EX(opline);
2536
zval *result = &EX_T(opline->result.u.var).tmp_var;
2538
compare_function(result,
2539
&opline->op1.u.constant,
2540
&opline->op2.u.constant TSRMLS_CC);
2541
ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
2544
ZEND_VM_NEXT_OPCODE();
2547
static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2549
zend_op *opline = EX(opline);
2552
bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
2553
&opline->op1.u.constant,
2554
&opline->op2.u.constant TSRMLS_CC);
2557
ZEND_VM_NEXT_OPCODE();
2560
static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2562
zend_op *opline = EX(opline);
2565
bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
2566
&opline->op1.u.constant,
2567
&opline->op2.u.constant TSRMLS_CC);
2570
ZEND_VM_NEXT_OPCODE();
2573
static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2575
zend_op *opline = EX(opline);
2578
bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
2579
&opline->op1.u.constant,
2580
&opline->op2.u.constant TSRMLS_CC);
2583
ZEND_VM_NEXT_OPCODE();
2586
static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2588
zend_op *opline = EX(opline);
2591
boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
2592
&opline->op1.u.constant,
2593
&opline->op2.u.constant TSRMLS_CC);
2596
ZEND_VM_NEXT_OPCODE();
2599
static int ZEND_FASTCALL ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2601
zend_op *opline = EX(opline);
2603
zval *container = &opline->op1.u.constant;
2605
if (Z_TYPE_P(container) != IS_ARRAY) {
2606
if (!RETURN_VALUE_UNUSED(&opline->result)) {
2607
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
2608
PZVAL_LOCK(EG(uninitialized_zval_ptr));
2612
zval *dim = &opline->op2.u.constant;
2614
AI_SET_PTR(EX_T(opline->result.u.var).var, *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, BP_VAR_R TSRMLS_CC));
2615
SELECTIVE_PZVAL_LOCK(EX_T(opline->result.u.var).var.ptr, &opline->result);
2618
ZEND_VM_NEXT_OPCODE();
2621
static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2623
zend_op *opline = EX(opline);
2624
zval *function_name;
2625
zend_class_entry *ce;
2627
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
2629
if (IS_CONST == IS_CONST) {
2630
/* no function found. try a static method in class */
2631
ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
2633
zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL(opline->op1.u.constant));
2635
EX(called_scope) = ce;
2637
ce = EX_T(opline->op1.u.var).class_entry;
2639
if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
2640
EX(called_scope) = EG(called_scope);
2642
EX(called_scope) = ce;
2645
if(IS_CONST != IS_UNUSED) {
2646
char *function_name_strval = NULL;
2647
int function_name_strlen = 0;
2650
if (IS_CONST == IS_CONST) {
2651
function_name_strval = Z_STRVAL(opline->op2.u.constant);
2652
function_name_strlen = Z_STRLEN(opline->op2.u.constant);
2654
function_name = &opline->op2.u.constant;
2656
if (Z_TYPE_P(function_name) != IS_STRING) {
2657
zend_error_noreturn(E_ERROR, "Function name must be a string");
2659
function_name_strval = Z_STRVAL_P(function_name);
2660
function_name_strlen = Z_STRLEN_P(function_name);
2664
if (function_name_strval) {
2665
if (ce->get_static_method) {
2666
EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
2668
EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
2671
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
2675
if (IS_CONST != IS_CONST) {
2679
if(!ce->constructor) {
2680
zend_error_noreturn(E_ERROR, "Cannot call constructor");
2682
if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
2683
zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
2685
EX(fbc) = ce->constructor;
2688
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
2692
Z_OBJ_HT_P(EG(This))->get_class_entry &&
2693
!instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
2694
/* We are calling method of the other (incompatible) class,
2695
but passing $this. This is done for compatibility with php-4. */
2698
if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
2699
severity = E_STRICT;
2700
verb = "should not";
2702
/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
2706
zend_error(severity, "Non-static method %s::%s() %s be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name, verb);
2709
if ((EX(object) = EG(This))) {
2710
Z_ADDREF_P(EX(object));
2711
EX(called_scope) = Z_OBJCE_P(EX(object));
2715
ZEND_VM_NEXT_OPCODE();
2718
static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2720
zend_op *opline = EX(opline);
2721
int switch_expr_is_overloaded=0;
2724
if (IS_CONST==IS_VAR) {
2725
if (EX_T(opline->op1.u.var).var.ptr_ptr) {
2726
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
2728
switch_expr_is_overloaded = 1;
2729
Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
2732
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
2733
&opline->op1.u.constant,
2734
&opline->op2.u.constant TSRMLS_CC);
2736
if (switch_expr_is_overloaded) {
2737
/* We only free op1 if this is a string offset,
2738
* Since if it is a TMP_VAR, it'll be reused by
2739
* other CASE opcodes (whereas string offsets
2740
* are allocated at each get_zval_ptr())
2743
EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
2744
EX_T(opline->op1.u.var).var.ptr = NULL;
2746
ZEND_VM_NEXT_OPCODE();
2749
static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2751
zend_op *opline = EX(opline);
2753
if (IS_CONST == IS_UNUSED) {
2754
/* namespaced constant */
2755
if (!zend_get_constant_ex(Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant), &EX_T(opline->result.u.var).tmp_var, NULL, opline->extended_value TSRMLS_CC)) {
2756
if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
2757
char *actual = (char *)zend_memrchr(Z_STRVAL(opline->op2.u.constant), '\\', Z_STRLEN(opline->op2.u.constant));
2759
actual = Z_STRVAL(opline->op2.u.constant);
2763
/* non-qualified constant - allow text substitution */
2764
zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
2765
ZVAL_STRINGL(&EX_T(opline->result.u.var).tmp_var, actual, Z_STRLEN(opline->op2.u.constant)-(actual - Z_STRVAL(opline->op2.u.constant)), 1);
2767
zend_error_noreturn(E_ERROR, "Undefined constant '%s'",
2768
Z_STRVAL(opline->op2.u.constant), Z_STRVAL(opline->op2.u.constant));
2771
ZEND_VM_NEXT_OPCODE();
2773
/* class constant */
2774
zend_class_entry *ce;
2777
if (IS_CONST == IS_CONST) {
2779
ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
2781
zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL(opline->op2.u.constant));
2784
ce = EX_T(opline->op1.u.var).class_entry;
2787
if (zend_hash_find(&ce->constants_table, Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant)+1, (void **) &value) == SUCCESS) {
2788
if (Z_TYPE_PP(value) == IS_CONSTANT_ARRAY ||
2789
(Z_TYPE_PP(value) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) {
2790
zend_class_entry *old_scope = EG(scope);
2793
zval_update_constant(value, (void *) 1 TSRMLS_CC);
2794
EG(scope) = old_scope;
2796
EX_T(opline->result.u.var).tmp_var = **value;
2797
zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
2799
zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL(opline->op2.u.constant));
2802
ZEND_VM_NEXT_OPCODE();
2806
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2808
zend_op *opline = EX(opline);
2810
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
2812
zval *offset=&opline->op2.u.constant;
2814
#if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
2815
zval **expr_ptr_ptr = NULL;
2817
if (opline->extended_value) {
2819
expr_ptr = *expr_ptr_ptr;
2821
expr_ptr=&opline->op1.u.constant;
2824
expr_ptr=&opline->op1.u.constant;
2827
if (0) { /* temporary variable */
2830
ALLOC_ZVAL(new_expr);
2831
INIT_PZVAL_COPY(new_expr, expr_ptr);
2832
expr_ptr = new_expr;
2834
#if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
2835
if (opline->extended_value) {
2836
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
2837
expr_ptr = *expr_ptr_ptr;
2838
Z_ADDREF_P(expr_ptr);
2841
if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
2844
ALLOC_ZVAL(new_expr);
2845
INIT_PZVAL_COPY(new_expr, expr_ptr);
2846
expr_ptr = new_expr;
2847
zendi_zval_copy_ctor(*expr_ptr);
2849
Z_ADDREF_P(expr_ptr);
2853
switch (Z_TYPE_P(offset)) {
2855
zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
2859
zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
2862
zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
2865
zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
2868
zend_error(E_WARNING, "Illegal offset type");
2869
zval_ptr_dtor(&expr_ptr);
2875
zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
2877
if (opline->extended_value) {
2882
ZEND_VM_NEXT_OPCODE();
2885
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2887
zend_op *opline = EX(opline);
2889
array_init(&EX_T(opline->result.u.var).tmp_var);
2890
if (IS_CONST == IS_UNUSED) {
2891
ZEND_VM_NEXT_OPCODE();
2892
#if 0 || IS_CONST != IS_UNUSED
2894
return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
2899
static int ZEND_FASTCALL ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2901
zend_op *opline = EX(opline);
2903
zval *name = &opline->op1.u.constant;
2904
zval *val = &opline->op2.u.constant;
2907
if ((Z_TYPE_P(val) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT || Z_TYPE_P(val) == IS_CONSTANT_ARRAY) {
2909
zval *tmp_ptr = &tmp;
2911
if (Z_TYPE_P(val) == IS_CONSTANT_ARRAY) {
2912
zval_copy_ctor(&tmp);
2915
zval_update_constant(&tmp_ptr, NULL TSRMLS_CC);
2919
zval_copy_ctor(&c.value);
2921
c.flags = CONST_CS; /* non persistent, case sensetive */
2922
c.name = zend_strndup(Z_STRVAL_P(name), Z_STRLEN_P(name));
2923
c.name_len = Z_STRLEN_P(name)+1;
2924
c.module_number = PHP_USER_CONSTANT;
2926
if (zend_register_constant(&c TSRMLS_CC) == FAILURE) {
2930
ZEND_VM_NEXT_OPCODE();
2933
static int ZEND_FASTCALL ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2935
zend_op *opline = EX(opline);
2936
zend_function *op_array;
2938
if (zend_hash_quick_find(EG(function_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), Z_LVAL(opline->op2.u.constant), (void *) &op_array) == FAILURE ||
2939
op_array->type != ZEND_USER_FUNCTION) {
2940
zend_error_noreturn(E_ERROR, "Base lambda function for closure not found");
2943
zend_create_closure(&EX_T(opline->result.u.var).tmp_var, op_array TSRMLS_CC);
2945
ZEND_VM_NEXT_OPCODE();
2948
static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2950
zend_op *opline = EX(opline);
2951
zend_free_op free_op2;
2953
add_function(&EX_T(opline->result.u.var).tmp_var,
2954
&opline->op1.u.constant,
2955
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2957
zval_dtor(free_op2.var);
2958
ZEND_VM_NEXT_OPCODE();
2961
static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2963
zend_op *opline = EX(opline);
2964
zend_free_op free_op2;
2966
sub_function(&EX_T(opline->result.u.var).tmp_var,
2967
&opline->op1.u.constant,
2968
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2970
zval_dtor(free_op2.var);
2971
ZEND_VM_NEXT_OPCODE();
2974
static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2976
zend_op *opline = EX(opline);
2977
zend_free_op free_op2;
2979
mul_function(&EX_T(opline->result.u.var).tmp_var,
2980
&opline->op1.u.constant,
2981
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2983
zval_dtor(free_op2.var);
2984
ZEND_VM_NEXT_OPCODE();
2987
static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2989
zend_op *opline = EX(opline);
2990
zend_free_op free_op2;
2992
div_function(&EX_T(opline->result.u.var).tmp_var,
2993
&opline->op1.u.constant,
2994
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2996
zval_dtor(free_op2.var);
2997
ZEND_VM_NEXT_OPCODE();
3000
static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3002
zend_op *opline = EX(opline);
3003
zend_free_op free_op2;
3005
mod_function(&EX_T(opline->result.u.var).tmp_var,
3006
&opline->op1.u.constant,
3007
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3009
zval_dtor(free_op2.var);
3010
ZEND_VM_NEXT_OPCODE();
3013
static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3015
zend_op *opline = EX(opline);
3016
zend_free_op free_op2;
3018
shift_left_function(&EX_T(opline->result.u.var).tmp_var,
3019
&opline->op1.u.constant,
3020
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3022
zval_dtor(free_op2.var);
3023
ZEND_VM_NEXT_OPCODE();
3026
static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3028
zend_op *opline = EX(opline);
3029
zend_free_op free_op2;
3031
shift_right_function(&EX_T(opline->result.u.var).tmp_var,
3032
&opline->op1.u.constant,
3033
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3035
zval_dtor(free_op2.var);
3036
ZEND_VM_NEXT_OPCODE();
3039
static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3041
zend_op *opline = EX(opline);
3042
zend_free_op free_op2;
3044
concat_function(&EX_T(opline->result.u.var).tmp_var,
3045
&opline->op1.u.constant,
3046
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3048
zval_dtor(free_op2.var);
3049
ZEND_VM_NEXT_OPCODE();
3052
static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3054
zend_op *opline = EX(opline);
3055
zend_free_op free_op2;
3057
is_identical_function(&EX_T(opline->result.u.var).tmp_var,
3058
&opline->op1.u.constant,
3059
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3061
zval_dtor(free_op2.var);
3062
ZEND_VM_NEXT_OPCODE();
3065
static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3067
zend_op *opline = EX(opline);
3068
zend_free_op free_op2;
3069
zval *result = &EX_T(opline->result.u.var).tmp_var;
3071
is_identical_function(result,
3072
&opline->op1.u.constant,
3073
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3074
Z_LVAL_P(result) = !Z_LVAL_P(result);
3076
zval_dtor(free_op2.var);
3077
ZEND_VM_NEXT_OPCODE();
3080
static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3082
zend_op *opline = EX(opline);
3083
zend_free_op free_op2;
3084
zval *result = &EX_T(opline->result.u.var).tmp_var;
3086
compare_function(result,
3087
&opline->op1.u.constant,
3088
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3089
ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
3091
zval_dtor(free_op2.var);
3092
ZEND_VM_NEXT_OPCODE();
3095
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3097
zend_op *opline = EX(opline);
3098
zend_free_op free_op2;
3099
zval *result = &EX_T(opline->result.u.var).tmp_var;
3101
compare_function(result,
3102
&opline->op1.u.constant,
3103
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3104
ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
3106
zval_dtor(free_op2.var);
3107
ZEND_VM_NEXT_OPCODE();
3110
static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3112
zend_op *opline = EX(opline);
3113
zend_free_op free_op2;
3114
zval *result = &EX_T(opline->result.u.var).tmp_var;
3116
compare_function(result,
3117
&opline->op1.u.constant,
3118
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3119
ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
3121
zval_dtor(free_op2.var);
3122
ZEND_VM_NEXT_OPCODE();
3125
static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3127
zend_op *opline = EX(opline);
3128
zend_free_op free_op2;
3129
zval *result = &EX_T(opline->result.u.var).tmp_var;
3131
compare_function(result,
3132
&opline->op1.u.constant,
3133
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3134
ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
3136
zval_dtor(free_op2.var);
3137
ZEND_VM_NEXT_OPCODE();
3140
static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3142
zend_op *opline = EX(opline);
3143
zend_free_op free_op2;
3145
bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
3146
&opline->op1.u.constant,
3147
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3149
zval_dtor(free_op2.var);
3150
ZEND_VM_NEXT_OPCODE();
3153
static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3155
zend_op *opline = EX(opline);
3156
zend_free_op free_op2;
3158
bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
3159
&opline->op1.u.constant,
3160
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3162
zval_dtor(free_op2.var);
3163
ZEND_VM_NEXT_OPCODE();
3166
static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3168
zend_op *opline = EX(opline);
3169
zend_free_op free_op2;
3171
bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
3172
&opline->op1.u.constant,
3173
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3175
zval_dtor(free_op2.var);
3176
ZEND_VM_NEXT_OPCODE();
3179
static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3181
zend_op *opline = EX(opline);
3182
zend_free_op free_op2;
3184
boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
3185
&opline->op1.u.constant,
3186
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3188
zval_dtor(free_op2.var);
3189
ZEND_VM_NEXT_OPCODE();
3192
static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3194
zend_op *opline = EX(opline);
3195
zval *function_name;
3196
zend_class_entry *ce;
3198
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
3200
if (IS_CONST == IS_CONST) {
3201
/* no function found. try a static method in class */
3202
ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
3204
zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL(opline->op1.u.constant));
3206
EX(called_scope) = ce;
3208
ce = EX_T(opline->op1.u.var).class_entry;
3210
if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
3211
EX(called_scope) = EG(called_scope);
3213
EX(called_scope) = ce;
3216
if(IS_TMP_VAR != IS_UNUSED) {
3217
char *function_name_strval = NULL;
3218
int function_name_strlen = 0;
3219
zend_free_op free_op2;
3221
if (IS_TMP_VAR == IS_CONST) {
3222
function_name_strval = Z_STRVAL(opline->op2.u.constant);
3223
function_name_strlen = Z_STRLEN(opline->op2.u.constant);
3225
function_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
3227
if (Z_TYPE_P(function_name) != IS_STRING) {
3228
zend_error_noreturn(E_ERROR, "Function name must be a string");
3230
function_name_strval = Z_STRVAL_P(function_name);
3231
function_name_strlen = Z_STRLEN_P(function_name);
3235
if (function_name_strval) {
3236
if (ce->get_static_method) {
3237
EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
3239
EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
3242
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
3246
if (IS_TMP_VAR != IS_CONST) {
3247
zval_dtor(free_op2.var);
3250
if(!ce->constructor) {
3251
zend_error_noreturn(E_ERROR, "Cannot call constructor");
3253
if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
3254
zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
3256
EX(fbc) = ce->constructor;
3259
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
3263
Z_OBJ_HT_P(EG(This))->get_class_entry &&
3264
!instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
3265
/* We are calling method of the other (incompatible) class,
3266
but passing $this. This is done for compatibility with php-4. */
3269
if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
3270
severity = E_STRICT;
3271
verb = "should not";
3273
/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
3277
zend_error(severity, "Non-static method %s::%s() %s be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name, verb);
3280
if ((EX(object) = EG(This))) {
3281
Z_ADDREF_P(EX(object));
3282
EX(called_scope) = Z_OBJCE_P(EX(object));
3286
ZEND_VM_NEXT_OPCODE();
3289
static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3291
zend_op *opline = EX(opline);
3292
int switch_expr_is_overloaded=0;
3293
zend_free_op free_op2;
3295
if (IS_CONST==IS_VAR) {
3296
if (EX_T(opline->op1.u.var).var.ptr_ptr) {
3297
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
3299
switch_expr_is_overloaded = 1;
3300
Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
3303
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
3304
&opline->op1.u.constant,
3305
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3307
zval_dtor(free_op2.var);
3308
if (switch_expr_is_overloaded) {
3309
/* We only free op1 if this is a string offset,
3310
* Since if it is a TMP_VAR, it'll be reused by
3311
* other CASE opcodes (whereas string offsets
3312
* are allocated at each get_zval_ptr())
3315
EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
3316
EX_T(opline->op1.u.var).var.ptr = NULL;
3318
ZEND_VM_NEXT_OPCODE();
3321
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3323
zend_op *opline = EX(opline);
3324
zend_free_op free_op2;
3325
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
3327
zval *offset=_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
3329
#if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
3330
zval **expr_ptr_ptr = NULL;
3332
if (opline->extended_value) {
3334
expr_ptr = *expr_ptr_ptr;
3336
expr_ptr=&opline->op1.u.constant;
3339
expr_ptr=&opline->op1.u.constant;
3342
if (0) { /* temporary variable */
3345
ALLOC_ZVAL(new_expr);
3346
INIT_PZVAL_COPY(new_expr, expr_ptr);
3347
expr_ptr = new_expr;
3349
#if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
3350
if (opline->extended_value) {
3351
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
3352
expr_ptr = *expr_ptr_ptr;
3353
Z_ADDREF_P(expr_ptr);
3356
if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
3359
ALLOC_ZVAL(new_expr);
3360
INIT_PZVAL_COPY(new_expr, expr_ptr);
3361
expr_ptr = new_expr;
3362
zendi_zval_copy_ctor(*expr_ptr);
3364
Z_ADDREF_P(expr_ptr);
3368
switch (Z_TYPE_P(offset)) {
3370
zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
3374
zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
3377
zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
3380
zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
3383
zend_error(E_WARNING, "Illegal offset type");
3384
zval_ptr_dtor(&expr_ptr);
3388
zval_dtor(free_op2.var);
3390
zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
3392
if (opline->extended_value) {
3397
ZEND_VM_NEXT_OPCODE();
3400
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3402
zend_op *opline = EX(opline);
3404
array_init(&EX_T(opline->result.u.var).tmp_var);
3405
if (IS_CONST == IS_UNUSED) {
3406
ZEND_VM_NEXT_OPCODE();
3407
#if 0 || IS_CONST != IS_UNUSED
3409
return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3414
static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3416
zend_op *opline = EX(opline);
3417
zend_free_op free_op2;
3419
add_function(&EX_T(opline->result.u.var).tmp_var,
3420
&opline->op1.u.constant,
3421
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3423
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3424
ZEND_VM_NEXT_OPCODE();
3427
static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3429
zend_op *opline = EX(opline);
3430
zend_free_op free_op2;
3432
sub_function(&EX_T(opline->result.u.var).tmp_var,
3433
&opline->op1.u.constant,
3434
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3436
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3437
ZEND_VM_NEXT_OPCODE();
3440
static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3442
zend_op *opline = EX(opline);
3443
zend_free_op free_op2;
3445
mul_function(&EX_T(opline->result.u.var).tmp_var,
3446
&opline->op1.u.constant,
3447
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3449
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3450
ZEND_VM_NEXT_OPCODE();
3453
static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3455
zend_op *opline = EX(opline);
3456
zend_free_op free_op2;
3458
div_function(&EX_T(opline->result.u.var).tmp_var,
3459
&opline->op1.u.constant,
3460
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3462
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3463
ZEND_VM_NEXT_OPCODE();
3466
static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3468
zend_op *opline = EX(opline);
3469
zend_free_op free_op2;
3471
mod_function(&EX_T(opline->result.u.var).tmp_var,
3472
&opline->op1.u.constant,
3473
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3475
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3476
ZEND_VM_NEXT_OPCODE();
3479
static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3481
zend_op *opline = EX(opline);
3482
zend_free_op free_op2;
3484
shift_left_function(&EX_T(opline->result.u.var).tmp_var,
3485
&opline->op1.u.constant,
3486
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3488
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3489
ZEND_VM_NEXT_OPCODE();
3492
static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3494
zend_op *opline = EX(opline);
3495
zend_free_op free_op2;
3497
shift_right_function(&EX_T(opline->result.u.var).tmp_var,
3498
&opline->op1.u.constant,
3499
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3501
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3502
ZEND_VM_NEXT_OPCODE();
3505
static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3507
zend_op *opline = EX(opline);
3508
zend_free_op free_op2;
3510
concat_function(&EX_T(opline->result.u.var).tmp_var,
3511
&opline->op1.u.constant,
3512
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3514
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3515
ZEND_VM_NEXT_OPCODE();
3518
static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3520
zend_op *opline = EX(opline);
3521
zend_free_op free_op2;
3523
is_identical_function(&EX_T(opline->result.u.var).tmp_var,
3524
&opline->op1.u.constant,
3525
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3527
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3528
ZEND_VM_NEXT_OPCODE();
3531
static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3533
zend_op *opline = EX(opline);
3534
zend_free_op free_op2;
3535
zval *result = &EX_T(opline->result.u.var).tmp_var;
3537
is_identical_function(result,
3538
&opline->op1.u.constant,
3539
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3540
Z_LVAL_P(result) = !Z_LVAL_P(result);
3542
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3543
ZEND_VM_NEXT_OPCODE();
3546
static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3548
zend_op *opline = EX(opline);
3549
zend_free_op free_op2;
3550
zval *result = &EX_T(opline->result.u.var).tmp_var;
3552
compare_function(result,
3553
&opline->op1.u.constant,
3554
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3555
ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
3557
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3558
ZEND_VM_NEXT_OPCODE();
3561
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3563
zend_op *opline = EX(opline);
3564
zend_free_op free_op2;
3565
zval *result = &EX_T(opline->result.u.var).tmp_var;
3567
compare_function(result,
3568
&opline->op1.u.constant,
3569
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3570
ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
3572
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3573
ZEND_VM_NEXT_OPCODE();
3576
static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3578
zend_op *opline = EX(opline);
3579
zend_free_op free_op2;
3580
zval *result = &EX_T(opline->result.u.var).tmp_var;
3582
compare_function(result,
3583
&opline->op1.u.constant,
3584
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3585
ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
3587
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3588
ZEND_VM_NEXT_OPCODE();
3591
static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3593
zend_op *opline = EX(opline);
3594
zend_free_op free_op2;
3595
zval *result = &EX_T(opline->result.u.var).tmp_var;
3597
compare_function(result,
3598
&opline->op1.u.constant,
3599
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3600
ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
3602
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3603
ZEND_VM_NEXT_OPCODE();
3606
static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3608
zend_op *opline = EX(opline);
3609
zend_free_op free_op2;
3611
bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
3612
&opline->op1.u.constant,
3613
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3615
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3616
ZEND_VM_NEXT_OPCODE();
3619
static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3621
zend_op *opline = EX(opline);
3622
zend_free_op free_op2;
3624
bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
3625
&opline->op1.u.constant,
3626
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3628
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3629
ZEND_VM_NEXT_OPCODE();
3632
static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3634
zend_op *opline = EX(opline);
3635
zend_free_op free_op2;
3637
bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
3638
&opline->op1.u.constant,
3639
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3641
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3642
ZEND_VM_NEXT_OPCODE();
3645
static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3647
zend_op *opline = EX(opline);
3648
zend_free_op free_op2;
3650
boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
3651
&opline->op1.u.constant,
3652
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3654
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3655
ZEND_VM_NEXT_OPCODE();
3658
static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3660
zend_op *opline = EX(opline);
3661
zval *function_name;
3662
zend_class_entry *ce;
3664
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
3666
if (IS_CONST == IS_CONST) {
3667
/* no function found. try a static method in class */
3668
ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
3670
zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL(opline->op1.u.constant));
3672
EX(called_scope) = ce;
3674
ce = EX_T(opline->op1.u.var).class_entry;
3676
if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
3677
EX(called_scope) = EG(called_scope);
3679
EX(called_scope) = ce;
3682
if(IS_VAR != IS_UNUSED) {
3683
char *function_name_strval = NULL;
3684
int function_name_strlen = 0;
3685
zend_free_op free_op2;
3687
if (IS_VAR == IS_CONST) {
3688
function_name_strval = Z_STRVAL(opline->op2.u.constant);
3689
function_name_strlen = Z_STRLEN(opline->op2.u.constant);
3691
function_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
3693
if (Z_TYPE_P(function_name) != IS_STRING) {
3694
zend_error_noreturn(E_ERROR, "Function name must be a string");
3696
function_name_strval = Z_STRVAL_P(function_name);
3697
function_name_strlen = Z_STRLEN_P(function_name);
3701
if (function_name_strval) {
3702
if (ce->get_static_method) {
3703
EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
3705
EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
3708
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
3712
if (IS_VAR != IS_CONST) {
3713
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3716
if(!ce->constructor) {
3717
zend_error_noreturn(E_ERROR, "Cannot call constructor");
3719
if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
3720
zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
3722
EX(fbc) = ce->constructor;
3725
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
3729
Z_OBJ_HT_P(EG(This))->get_class_entry &&
3730
!instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
3731
/* We are calling method of the other (incompatible) class,
3732
but passing $this. This is done for compatibility with php-4. */
3735
if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
3736
severity = E_STRICT;
3737
verb = "should not";
3739
/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
3743
zend_error(severity, "Non-static method %s::%s() %s be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name, verb);
3746
if ((EX(object) = EG(This))) {
3747
Z_ADDREF_P(EX(object));
3748
EX(called_scope) = Z_OBJCE_P(EX(object));
3752
ZEND_VM_NEXT_OPCODE();
3755
static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3757
zend_op *opline = EX(opline);
3758
int switch_expr_is_overloaded=0;
3759
zend_free_op free_op2;
3761
if (IS_CONST==IS_VAR) {
3762
if (EX_T(opline->op1.u.var).var.ptr_ptr) {
3763
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
3765
switch_expr_is_overloaded = 1;
3766
Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
3769
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
3770
&opline->op1.u.constant,
3771
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3773
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3774
if (switch_expr_is_overloaded) {
3775
/* We only free op1 if this is a string offset,
3776
* Since if it is a TMP_VAR, it'll be reused by
3777
* other CASE opcodes (whereas string offsets
3778
* are allocated at each get_zval_ptr())
3781
EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
3782
EX_T(opline->op1.u.var).var.ptr = NULL;
3784
ZEND_VM_NEXT_OPCODE();
3787
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3789
zend_op *opline = EX(opline);
3790
zend_free_op free_op2;
3791
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
3793
zval *offset=_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
3795
#if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
3796
zval **expr_ptr_ptr = NULL;
3798
if (opline->extended_value) {
3800
expr_ptr = *expr_ptr_ptr;
3802
expr_ptr=&opline->op1.u.constant;
3805
expr_ptr=&opline->op1.u.constant;
3808
if (0) { /* temporary variable */
3811
ALLOC_ZVAL(new_expr);
3812
INIT_PZVAL_COPY(new_expr, expr_ptr);
3813
expr_ptr = new_expr;
3815
#if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
3816
if (opline->extended_value) {
3817
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
3818
expr_ptr = *expr_ptr_ptr;
3819
Z_ADDREF_P(expr_ptr);
3822
if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
3825
ALLOC_ZVAL(new_expr);
3826
INIT_PZVAL_COPY(new_expr, expr_ptr);
3827
expr_ptr = new_expr;
3828
zendi_zval_copy_ctor(*expr_ptr);
3830
Z_ADDREF_P(expr_ptr);
3834
switch (Z_TYPE_P(offset)) {
3836
zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
3840
zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
3843
zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
3846
zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
3849
zend_error(E_WARNING, "Illegal offset type");
3850
zval_ptr_dtor(&expr_ptr);
3854
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3856
zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
3858
if (opline->extended_value) {
3863
ZEND_VM_NEXT_OPCODE();
3866
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3868
zend_op *opline = EX(opline);
3870
array_init(&EX_T(opline->result.u.var).tmp_var);
3871
if (IS_CONST == IS_UNUSED) {
3872
ZEND_VM_NEXT_OPCODE();
3873
#if 0 || IS_CONST != IS_UNUSED
3875
return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3880
static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3882
zend_op *opline = EX(opline);
3883
zval *function_name;
3884
zend_class_entry *ce;
3886
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
3888
if (IS_CONST == IS_CONST) {
3889
/* no function found. try a static method in class */
3890
ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
3892
zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL(opline->op1.u.constant));
3894
EX(called_scope) = ce;
3896
ce = EX_T(opline->op1.u.var).class_entry;
3898
if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
3899
EX(called_scope) = EG(called_scope);
3901
EX(called_scope) = ce;
3904
if(IS_UNUSED != IS_UNUSED) {
3905
char *function_name_strval = NULL;
3906
int function_name_strlen = 0;
3909
if (IS_UNUSED == IS_CONST) {
3910
function_name_strval = Z_STRVAL(opline->op2.u.constant);
3911
function_name_strlen = Z_STRLEN(opline->op2.u.constant);
3913
function_name = NULL;
3915
if (Z_TYPE_P(function_name) != IS_STRING) {
3916
zend_error_noreturn(E_ERROR, "Function name must be a string");
3918
function_name_strval = Z_STRVAL_P(function_name);
3919
function_name_strlen = Z_STRLEN_P(function_name);
3923
if (function_name_strval) {
3924
if (ce->get_static_method) {
3925
EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
3927
EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
3930
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
3934
if (IS_UNUSED != IS_CONST) {
3938
if(!ce->constructor) {
3939
zend_error_noreturn(E_ERROR, "Cannot call constructor");
3941
if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
3942
zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
3944
EX(fbc) = ce->constructor;
3947
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
3951
Z_OBJ_HT_P(EG(This))->get_class_entry &&
3952
!instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
3953
/* We are calling method of the other (incompatible) class,
3954
but passing $this. This is done for compatibility with php-4. */
3957
if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
3958
severity = E_STRICT;
3959
verb = "should not";
3961
/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
3965
zend_error(severity, "Non-static method %s::%s() %s be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name, verb);
3968
if ((EX(object) = EG(This))) {
3969
Z_ADDREF_P(EX(object));
3970
EX(called_scope) = Z_OBJCE_P(EX(object));
3974
ZEND_VM_NEXT_OPCODE();
3977
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3979
zend_op *opline = EX(opline);
3981
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
3985
#if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
3986
zval **expr_ptr_ptr = NULL;
3988
if (opline->extended_value) {
3990
expr_ptr = *expr_ptr_ptr;
3992
expr_ptr=&opline->op1.u.constant;
3995
expr_ptr=&opline->op1.u.constant;
3998
if (0) { /* temporary variable */
4001
ALLOC_ZVAL(new_expr);
4002
INIT_PZVAL_COPY(new_expr, expr_ptr);
4003
expr_ptr = new_expr;
4005
#if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
4006
if (opline->extended_value) {
4007
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
4008
expr_ptr = *expr_ptr_ptr;
4009
Z_ADDREF_P(expr_ptr);
4012
if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
4015
ALLOC_ZVAL(new_expr);
4016
INIT_PZVAL_COPY(new_expr, expr_ptr);
4017
expr_ptr = new_expr;
4018
zendi_zval_copy_ctor(*expr_ptr);
4020
Z_ADDREF_P(expr_ptr);
4024
switch (Z_TYPE_P(offset)) {
4026
zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
4030
zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
4033
zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
4036
zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
4039
zend_error(E_WARNING, "Illegal offset type");
4040
zval_ptr_dtor(&expr_ptr);
4046
zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
4048
if (opline->extended_value) {
4053
ZEND_VM_NEXT_OPCODE();
4056
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4058
zend_op *opline = EX(opline);
4060
array_init(&EX_T(opline->result.u.var).tmp_var);
4061
if (IS_CONST == IS_UNUSED) {
4062
ZEND_VM_NEXT_OPCODE();
4063
#if 0 || IS_CONST != IS_UNUSED
4065
return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4070
static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4072
zend_op *opline = EX(opline);
4075
add_function(&EX_T(opline->result.u.var).tmp_var,
4076
&opline->op1.u.constant,
4077
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4080
ZEND_VM_NEXT_OPCODE();
4083
static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4085
zend_op *opline = EX(opline);
4088
sub_function(&EX_T(opline->result.u.var).tmp_var,
4089
&opline->op1.u.constant,
4090
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4093
ZEND_VM_NEXT_OPCODE();
4096
static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4098
zend_op *opline = EX(opline);
4101
mul_function(&EX_T(opline->result.u.var).tmp_var,
4102
&opline->op1.u.constant,
4103
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4106
ZEND_VM_NEXT_OPCODE();
4109
static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4111
zend_op *opline = EX(opline);
4114
div_function(&EX_T(opline->result.u.var).tmp_var,
4115
&opline->op1.u.constant,
4116
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4119
ZEND_VM_NEXT_OPCODE();
4122
static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4124
zend_op *opline = EX(opline);
4127
mod_function(&EX_T(opline->result.u.var).tmp_var,
4128
&opline->op1.u.constant,
4129
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4132
ZEND_VM_NEXT_OPCODE();
4135
static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4137
zend_op *opline = EX(opline);
4140
shift_left_function(&EX_T(opline->result.u.var).tmp_var,
4141
&opline->op1.u.constant,
4142
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4145
ZEND_VM_NEXT_OPCODE();
4148
static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4150
zend_op *opline = EX(opline);
4153
shift_right_function(&EX_T(opline->result.u.var).tmp_var,
4154
&opline->op1.u.constant,
4155
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4158
ZEND_VM_NEXT_OPCODE();
4161
static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4163
zend_op *opline = EX(opline);
4166
concat_function(&EX_T(opline->result.u.var).tmp_var,
4167
&opline->op1.u.constant,
4168
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4171
ZEND_VM_NEXT_OPCODE();
4174
static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4176
zend_op *opline = EX(opline);
4179
is_identical_function(&EX_T(opline->result.u.var).tmp_var,
4180
&opline->op1.u.constant,
4181
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4184
ZEND_VM_NEXT_OPCODE();
4187
static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4189
zend_op *opline = EX(opline);
4191
zval *result = &EX_T(opline->result.u.var).tmp_var;
4193
is_identical_function(result,
4194
&opline->op1.u.constant,
4195
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4196
Z_LVAL_P(result) = !Z_LVAL_P(result);
4199
ZEND_VM_NEXT_OPCODE();
4202
static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4204
zend_op *opline = EX(opline);
4206
zval *result = &EX_T(opline->result.u.var).tmp_var;
4208
compare_function(result,
4209
&opline->op1.u.constant,
4210
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4211
ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
4214
ZEND_VM_NEXT_OPCODE();
4217
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4219
zend_op *opline = EX(opline);
4221
zval *result = &EX_T(opline->result.u.var).tmp_var;
4223
compare_function(result,
4224
&opline->op1.u.constant,
4225
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4226
ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
4229
ZEND_VM_NEXT_OPCODE();
4232
static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4234
zend_op *opline = EX(opline);
4236
zval *result = &EX_T(opline->result.u.var).tmp_var;
4238
compare_function(result,
4239
&opline->op1.u.constant,
4240
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4241
ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
4244
ZEND_VM_NEXT_OPCODE();
4247
static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4249
zend_op *opline = EX(opline);
4251
zval *result = &EX_T(opline->result.u.var).tmp_var;
4253
compare_function(result,
4254
&opline->op1.u.constant,
4255
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4256
ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
4259
ZEND_VM_NEXT_OPCODE();
4262
static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4264
zend_op *opline = EX(opline);
4267
bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
4268
&opline->op1.u.constant,
4269
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4272
ZEND_VM_NEXT_OPCODE();
4275
static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4277
zend_op *opline = EX(opline);
4280
bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
4281
&opline->op1.u.constant,
4282
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4285
ZEND_VM_NEXT_OPCODE();
4288
static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4290
zend_op *opline = EX(opline);
4293
bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
4294
&opline->op1.u.constant,
4295
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4298
ZEND_VM_NEXT_OPCODE();
4301
static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4303
zend_op *opline = EX(opline);
4306
boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
4307
&opline->op1.u.constant,
4308
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4311
ZEND_VM_NEXT_OPCODE();
4314
static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4316
zend_op *opline = EX(opline);
4317
zval *function_name;
4318
zend_class_entry *ce;
4320
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
4322
if (IS_CONST == IS_CONST) {
4323
/* no function found. try a static method in class */
4324
ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
4326
zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL(opline->op1.u.constant));
4328
EX(called_scope) = ce;
4330
ce = EX_T(opline->op1.u.var).class_entry;
4332
if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
4333
EX(called_scope) = EG(called_scope);
4335
EX(called_scope) = ce;
4338
if(IS_CV != IS_UNUSED) {
4339
char *function_name_strval = NULL;
4340
int function_name_strlen = 0;
4343
if (IS_CV == IS_CONST) {
4344
function_name_strval = Z_STRVAL(opline->op2.u.constant);
4345
function_name_strlen = Z_STRLEN(opline->op2.u.constant);
4347
function_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
4349
if (Z_TYPE_P(function_name) != IS_STRING) {
4350
zend_error_noreturn(E_ERROR, "Function name must be a string");
4352
function_name_strval = Z_STRVAL_P(function_name);
4353
function_name_strlen = Z_STRLEN_P(function_name);
4357
if (function_name_strval) {
4358
if (ce->get_static_method) {
4359
EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
4361
EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
4364
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
4368
if (IS_CV != IS_CONST) {
4372
if(!ce->constructor) {
4373
zend_error_noreturn(E_ERROR, "Cannot call constructor");
4375
if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
4376
zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
4378
EX(fbc) = ce->constructor;
4381
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
4385
Z_OBJ_HT_P(EG(This))->get_class_entry &&
4386
!instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
4387
/* We are calling method of the other (incompatible) class,
4388
but passing $this. This is done for compatibility with php-4. */
4391
if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
4392
severity = E_STRICT;
4393
verb = "should not";
4395
/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
4399
zend_error(severity, "Non-static method %s::%s() %s be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name, verb);
4402
if ((EX(object) = EG(This))) {
4403
Z_ADDREF_P(EX(object));
4404
EX(called_scope) = Z_OBJCE_P(EX(object));
4408
ZEND_VM_NEXT_OPCODE();
4411
static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4413
zend_op *opline = EX(opline);
4414
int switch_expr_is_overloaded=0;
4417
if (IS_CONST==IS_VAR) {
4418
if (EX_T(opline->op1.u.var).var.ptr_ptr) {
4419
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
4421
switch_expr_is_overloaded = 1;
4422
Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
4425
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
4426
&opline->op1.u.constant,
4427
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4429
if (switch_expr_is_overloaded) {
4430
/* We only free op1 if this is a string offset,
4431
* Since if it is a TMP_VAR, it'll be reused by
4432
* other CASE opcodes (whereas string offsets
4433
* are allocated at each get_zval_ptr())
4436
EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
4437
EX_T(opline->op1.u.var).var.ptr = NULL;
4439
ZEND_VM_NEXT_OPCODE();
4442
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4444
zend_op *opline = EX(opline);
4446
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
4448
zval *offset=_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
4450
#if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
4451
zval **expr_ptr_ptr = NULL;
4453
if (opline->extended_value) {
4455
expr_ptr = *expr_ptr_ptr;
4457
expr_ptr=&opline->op1.u.constant;
4460
expr_ptr=&opline->op1.u.constant;
4463
if (0) { /* temporary variable */
4466
ALLOC_ZVAL(new_expr);
4467
INIT_PZVAL_COPY(new_expr, expr_ptr);
4468
expr_ptr = new_expr;
4470
#if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
4471
if (opline->extended_value) {
4472
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
4473
expr_ptr = *expr_ptr_ptr;
4474
Z_ADDREF_P(expr_ptr);
4477
if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
4480
ALLOC_ZVAL(new_expr);
4481
INIT_PZVAL_COPY(new_expr, expr_ptr);
4482
expr_ptr = new_expr;
4483
zendi_zval_copy_ctor(*expr_ptr);
4485
Z_ADDREF_P(expr_ptr);
4489
switch (Z_TYPE_P(offset)) {
4491
zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
4495
zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
4498
zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
4501
zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
4504
zend_error(E_WARNING, "Illegal offset type");
4505
zval_ptr_dtor(&expr_ptr);
4511
zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
4513
if (opline->extended_value) {
4518
ZEND_VM_NEXT_OPCODE();
4521
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4523
zend_op *opline = EX(opline);
4525
array_init(&EX_T(opline->result.u.var).tmp_var);
4526
if (IS_CONST == IS_UNUSED) {
4527
ZEND_VM_NEXT_OPCODE();
4528
#if 0 || IS_CONST != IS_UNUSED
4530
return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4535
static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4537
zend_op *opline = EX(opline);
4538
zend_free_op free_op1;
4540
bitwise_not_function(&EX_T(opline->result.u.var).tmp_var,
4541
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) TSRMLS_CC);
4542
zval_dtor(free_op1.var);
4543
ZEND_VM_NEXT_OPCODE();
4546
static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4548
zend_op *opline = EX(opline);
4549
zend_free_op free_op1;
4551
boolean_not_function(&EX_T(opline->result.u.var).tmp_var,
4552
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) TSRMLS_CC);
4553
zval_dtor(free_op1.var);
4554
ZEND_VM_NEXT_OPCODE();
4557
static int ZEND_FASTCALL ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4559
zend_op *opline = EX(opline);
4560
zend_free_op free_op1;
4562
zval *z = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4564
if (IS_TMP_VAR != IS_CONST &&
4565
Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get_method != NULL &&
4566
zend_std_cast_object_tostring(z, &z_copy, IS_STRING TSRMLS_CC) == SUCCESS) {
4567
zend_print_variable(&z_copy);
4570
zend_print_variable(z);
4573
zval_dtor(free_op1.var);
4574
ZEND_VM_NEXT_OPCODE();
4577
static int ZEND_FASTCALL ZEND_PRINT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4579
zend_op *opline = EX(opline);
4581
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
4582
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_LONG;
4584
return ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4587
static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP(int type, ZEND_OPCODE_HANDLER_ARGS)
4589
zend_op *opline = EX(opline);
4590
zend_free_op free_op1;
4591
zval *varname = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4594
HashTable *target_symbol_table;
4596
if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
4597
tmp_varname = *varname;
4598
zval_copy_ctor(&tmp_varname);
4599
convert_to_string(&tmp_varname);
4600
varname = &tmp_varname;
4603
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
4604
retval = zend_std_get_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0 TSRMLS_CC);
4606
target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), type, varname TSRMLS_CC);
4608
if (!target_symbol_table) {
4609
ZEND_VM_NEXT_OPCODE();
4612
if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &retval) == FAILURE) {
4616
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
4617
/* break missing intentionally */
4619
retval = &EG(uninitialized_zval_ptr);
4622
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
4623
/* break missing intentionally */
4625
zval *new_zval = &EG(uninitialized_zval);
4627
Z_ADDREF_P(new_zval);
4628
zend_hash_update(target_symbol_table, varname->value.str.val, varname->value.str.len+1, &new_zval, sizeof(zval *), (void **) &retval);
4631
EMPTY_SWITCH_DEFAULT_CASE()
4634
switch (opline->op2.u.EA.type) {
4635
case ZEND_FETCH_GLOBAL:
4636
if (IS_TMP_VAR != IS_TMP_VAR) {
4637
zval_dtor(free_op1.var);
4640
case ZEND_FETCH_LOCAL:
4641
zval_dtor(free_op1.var);
4643
case ZEND_FETCH_STATIC:
4644
zval_update_constant(retval, (void*) 1 TSRMLS_CC);
4646
case ZEND_FETCH_GLOBAL_LOCK:
4647
if (IS_TMP_VAR == IS_VAR && !free_op1.var) {
4648
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
4655
if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
4658
if (!RETURN_VALUE_UNUSED(&opline->result)) {
4659
if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
4660
SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
4662
PZVAL_LOCK(*retval);
4666
AI_SET_PTR(EX_T(opline->result.u.var).var, *retval);
4668
case BP_VAR_UNSET: {
4669
zend_free_op free_res;
4671
EX_T(opline->result.u.var).var.ptr_ptr = retval;
4672
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
4673
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
4674
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
4676
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
4677
FREE_OP_VAR_PTR(free_res);
4680
EX_T(opline->result.u.var).var.ptr_ptr = retval;
4685
ZEND_VM_NEXT_OPCODE();
4688
static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4690
return zend_fetch_var_address_helper_SPEC_TMP(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4693
static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4695
return zend_fetch_var_address_helper_SPEC_TMP(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4698
static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4700
return zend_fetch_var_address_helper_SPEC_TMP(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4703
static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4705
return zend_fetch_var_address_helper_SPEC_TMP(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), EX(opline)->extended_value)?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4708
static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4710
return zend_fetch_var_address_helper_SPEC_TMP(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4713
static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4715
return zend_fetch_var_address_helper_SPEC_TMP(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4718
static int ZEND_FASTCALL ZEND_JMPZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4720
zend_op *opline = EX(opline);
4721
zend_free_op free_op1;
4722
zval *val = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4725
if (IS_TMP_VAR == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
4726
ret = Z_LVAL_P(val);
4728
ret = i_zend_is_true(val);
4729
zval_dtor(free_op1.var);
4730
if (UNEXPECTED(EG(exception) != NULL)) {
4736
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
4738
ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
4742
ZEND_VM_NEXT_OPCODE();
4745
static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4747
zend_op *opline = EX(opline);
4748
zend_free_op free_op1;
4749
zval *val = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4752
if (IS_TMP_VAR == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
4753
ret = Z_LVAL_P(val);
4755
ret = i_zend_is_true(val);
4756
zval_dtor(free_op1.var);
4757
if (UNEXPECTED(EG(exception) != NULL)) {
4763
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
4765
ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
4769
ZEND_VM_NEXT_OPCODE();
4772
static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4774
zend_op *opline = EX(opline);
4775
zend_free_op free_op1;
4776
zval *val = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4779
if (IS_TMP_VAR == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
4780
retval = Z_LVAL_P(val);
4782
retval = i_zend_is_true(val);
4783
zval_dtor(free_op1.var);
4784
if (UNEXPECTED(EG(exception) != NULL)) {
4788
if (EXPECTED(retval != 0)) {
4790
printf("Conditional jmp on true to %d\n", opline->extended_value);
4792
ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
4793
ZEND_VM_CONTINUE(); /* CHECK_ME */
4796
printf("Conditional jmp on false to %d\n", opline->op2.u.opline_num);
4798
ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.u.opline_num]);
4799
ZEND_VM_CONTINUE(); /* CHECK_ME */
4803
static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4805
zend_op *opline = EX(opline);
4806
zend_free_op free_op1;
4807
zval *val = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4810
if (IS_TMP_VAR == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
4811
retval = Z_LVAL_P(val);
4813
retval = i_zend_is_true(val);
4814
zval_dtor(free_op1.var);
4815
if (UNEXPECTED(EG(exception) != NULL)) {
4819
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
4820
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
4823
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
4825
ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
4828
ZEND_VM_NEXT_OPCODE();
4831
static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4833
zend_op *opline = EX(opline);
4834
zend_free_op free_op1;
4835
zval *val = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4838
if (IS_TMP_VAR == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
4839
retval = Z_LVAL_P(val);
4841
retval = i_zend_is_true(val);
4842
zval_dtor(free_op1.var);
4843
if (UNEXPECTED(EG(exception) != NULL)) {
4847
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
4848
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
4851
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
4853
ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
4856
ZEND_VM_NEXT_OPCODE();
4859
static int ZEND_FASTCALL ZEND_FREE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4861
zendi_zval_dtor(EX_T(EX(opline)->op1.u.var).tmp_var);
4862
ZEND_VM_NEXT_OPCODE();
4865
static int ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4867
zend_op *opline = EX(opline);
4869
zval **retval_ptr_ptr;
4870
zend_free_op free_op1;
4872
if (EG(active_op_array)->return_reference == ZEND_RETURN_REF) {
4874
if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
4875
/* Not supposed to happen, but we'll allow it */
4876
zend_error(E_NOTICE, "Only variable references should be returned by reference");
4877
goto return_by_value;
4880
retval_ptr_ptr = NULL;
4882
if (IS_TMP_VAR == IS_VAR && !retval_ptr_ptr) {
4883
zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
4886
if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
4887
if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
4888
EX_T(opline->op1.u.var).var.fcall_returned_reference) {
4889
} else if (EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
4890
if (IS_TMP_VAR == IS_VAR && !1) {
4891
PZVAL_LOCK(*retval_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
4893
zend_error(E_NOTICE, "Only variable references should be returned by reference");
4894
goto return_by_value;
4898
if (EG(return_value_ptr_ptr)) {
4899
SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
4900
Z_ADDREF_PP(retval_ptr_ptr);
4902
(*EG(return_value_ptr_ptr)) = (*retval_ptr_ptr);
4907
retval_ptr = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4909
if (!EG(return_value_ptr_ptr)) {
4910
if (IS_TMP_VAR == IS_TMP_VAR) {
4911
zval_dtor(free_op1.var);
4913
} else if (!1) { /* Not a temp var */
4914
if (IS_TMP_VAR == IS_CONST ||
4915
EG(active_op_array)->return_reference == ZEND_RETURN_REF ||
4916
(PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
4920
INIT_PZVAL_COPY(ret, retval_ptr);
4921
zval_copy_ctor(ret);
4922
*EG(return_value_ptr_ptr) = ret;
4924
*EG(return_value_ptr_ptr) = retval_ptr;
4925
Z_ADDREF_P(retval_ptr);
4931
INIT_PZVAL_COPY(ret, retval_ptr);
4932
*EG(return_value_ptr_ptr) = ret;
4936
return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4939
static int ZEND_FASTCALL ZEND_THROW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4941
zend_op *opline = EX(opline);
4944
zend_free_op free_op1;
4946
value = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4948
if (IS_TMP_VAR == IS_CONST || Z_TYPE_P(value) != IS_OBJECT) {
4949
zend_error_noreturn(E_ERROR, "Can only throw objects");
4951
zend_exception_save(TSRMLS_C);
4952
/* Not sure if a complete copy is what we want here */
4953
ALLOC_ZVAL(exception);
4954
INIT_PZVAL_COPY(exception, value);
4956
zval_copy_ctor(exception);
4959
zend_throw_exception_object(exception TSRMLS_CC);
4960
zend_exception_restore(TSRMLS_C);
4962
ZEND_VM_NEXT_OPCODE();
4965
static int ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4967
zend_op *opline = EX(opline);
4968
if (opline->extended_value==ZEND_DO_FCALL_BY_NAME
4969
&& ARG_MUST_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
4970
zend_error_noreturn(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.u.opline_num);
4975
zend_free_op free_op1;
4977
value = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4980
INIT_PZVAL_COPY(valptr, value);
4982
zval_copy_ctor(valptr);
4984
zend_vm_stack_push(valptr TSRMLS_CC);
4987
ZEND_VM_NEXT_OPCODE();
4990
static int ZEND_FASTCALL ZEND_BOOL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4992
zend_op *opline = EX(opline);
4993
zend_free_op free_op1;
4995
/* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
4996
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = i_zend_is_true(_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC));
4997
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
4998
zval_dtor(free_op1.var);
5000
ZEND_VM_NEXT_OPCODE();
5003
static int ZEND_FASTCALL ZEND_CLONE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5005
zend_op *opline = EX(opline);
5006
zend_free_op free_op1;
5007
zval *obj = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
5008
zend_class_entry *ce;
5009
zend_function *clone;
5010
zend_object_clone_obj_t clone_call;
5012
if (IS_TMP_VAR == IS_CONST ||
5013
(IS_TMP_VAR == IS_VAR && !obj) ||
5014
Z_TYPE_P(obj) != IS_OBJECT) {
5015
zend_error_noreturn(E_ERROR, "__clone method called on non-object");
5018
ce = Z_OBJCE_P(obj);
5019
clone = ce ? ce->clone : NULL;
5020
clone_call = Z_OBJ_HT_P(obj)->clone_obj;
5023
zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
5025
zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
5030
if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
5031
/* Ensure that if we're calling a private function, we're allowed to do so.
5033
if (ce != EG(scope)) {
5034
zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
5036
} else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
5037
/* Ensure that if we're calling a protected function, we're allowed to do so.
5039
if (!zend_check_protected(clone->common.scope, EG(scope))) {
5040
zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
5045
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
5046
if (!EG(exception)) {
5047
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
5048
Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC);
5049
Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
5050
Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
5051
Z_SET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
5052
if (!RETURN_VALUE_USED(opline) || EG(exception)) {
5053
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
5057
ZEND_VM_NEXT_OPCODE();
5060
static int ZEND_FASTCALL ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5062
zend_op *opline = EX(opline);
5063
zend_free_op free_op1;
5064
zval *expr = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
5065
zval *result = &EX_T(opline->result.u.var).tmp_var;
5067
if (opline->extended_value != IS_STRING) {
5070
zendi_zval_copy_ctor(*result);
5073
switch (opline->extended_value) {
5075
convert_to_null(result);
5078
convert_to_boolean(result);
5081
convert_to_long(result);
5084
convert_to_double(result);
5090
zend_make_printable_zval(expr, &var_copy, &use_copy);
5094
zval_dtor(free_op1.var);
5099
zendi_zval_copy_ctor(*result);
5105
convert_to_array(result);
5108
convert_to_object(result);
5112
ZEND_VM_NEXT_OPCODE();
5115
static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5117
zend_op *opline = EX(opline);
5118
zend_op_array *new_op_array=NULL;
5119
int return_value_used;
5120
zend_free_op free_op1;
5121
zval *inc_filename = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
5122
zval tmp_inc_filename;
5123
zend_bool failure_retval=0;
5125
if (inc_filename->type!=IS_STRING) {
5126
tmp_inc_filename = *inc_filename;
5127
zval_copy_ctor(&tmp_inc_filename);
5128
convert_to_string(&tmp_inc_filename);
5129
inc_filename = &tmp_inc_filename;
5132
return_value_used = RETURN_VALUE_USED(opline);
5134
switch (Z_LVAL(opline->op2.u.constant)) {
5135
case ZEND_INCLUDE_ONCE:
5136
case ZEND_REQUIRE_ONCE: {
5137
zend_file_handle file_handle;
5138
char *resolved_path;
5140
resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
5141
if (resolved_path) {
5142
failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
5144
resolved_path = Z_STRVAL_P(inc_filename);
5147
if (failure_retval) {
5148
/* do nothing, file already included */
5149
} else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) {
5151
if (!file_handle.opened_path) {
5152
file_handle.opened_path = estrdup(resolved_path);
5155
if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
5156
new_op_array = zend_compile_file(&file_handle, (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
5157
zend_destroy_file_handle(&file_handle TSRMLS_CC);
5159
zend_file_handle_dtor(&file_handle TSRMLS_CC);
5163
if (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE) {
5164
zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
5166
zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
5169
if (resolved_path != Z_STRVAL_P(inc_filename)) {
5170
efree(resolved_path);
5176
new_op_array = compile_filename(Z_LVAL(opline->op2.u.constant), inc_filename TSRMLS_CC);
5179
char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
5181
new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
5185
EMPTY_SWITCH_DEFAULT_CASE()
5187
if (inc_filename==&tmp_inc_filename) {
5188
zval_dtor(&tmp_inc_filename);
5190
zval_dtor(free_op1.var);
5191
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
5192
if (new_op_array && !EG(exception)) {
5193
EX(original_return_value) = EG(return_value_ptr_ptr);
5194
EG(return_value_ptr_ptr) = return_value_used ? EX_T(opline->result.u.var).var.ptr_ptr : NULL;
5195
EG(active_op_array) = new_op_array;
5196
EX_T(opline->result.u.var).var.ptr = NULL;
5198
EX(current_object) = EX(object);
5200
EX(function_state).function = (zend_function *) new_op_array;
5203
if (!EG(active_symbol_table)) {
5204
zend_rebuild_symbol_table(TSRMLS_C);
5207
if (zend_execute == execute) {
5208
EX(call_opline) = opline;
5211
zend_execute(new_op_array TSRMLS_CC);
5214
EX(function_state).function = (zend_function *) EX(op_array);
5215
EX(object) = EX(current_object);
5217
if (return_value_used) {
5218
if (!EX_T(opline->result.u.var).var.ptr) { /* there was no return statement */
5219
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
5220
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
5221
Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = 1;
5222
Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
5226
EG(opline_ptr) = &EX(opline);
5227
EG(active_op_array) = EX(op_array);
5228
EG(return_value_ptr_ptr) = EX(original_return_value);
5229
destroy_op_array(new_op_array TSRMLS_CC);
5230
efree(new_op_array);
5231
if (EG(exception)) {
5232
zend_throw_exception_internal(NULL TSRMLS_CC);
5235
if (return_value_used) {
5236
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
5237
INIT_ZVAL(*EX_T(opline->result.u.var).var.ptr);
5238
Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = failure_retval;
5239
Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
5242
ZEND_VM_NEXT_OPCODE();
5245
static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5247
zend_op *opline = EX(opline);
5249
HashTable *target_symbol_table;
5250
zend_free_op free_op1;
5252
if (IS_TMP_VAR == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
5253
if (EG(active_symbol_table)) {
5254
zend_execute_data *ex = EX(prev_execute_data);
5255
zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.u.var);
5257
if (zend_hash_quick_del(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value) == SUCCESS) {
5258
while (ex && ex->symbol_table == EG(active_symbol_table)) {
5262
for (i = 0; i < ex->op_array->last_var; i++) {
5263
if (ex->op_array->vars[i].hash_value == cv->hash_value &&
5264
ex->op_array->vars[i].name_len == cv->name_len &&
5265
!memcmp(ex->op_array->vars[i].name, cv->name, cv->name_len)) {
5271
ex = ex->prev_execute_data;
5274
EX(CVs)[opline->op1.u.var] = NULL;
5275
} else if (EX(CVs)[opline->op1.u.var]) {
5276
zval_ptr_dtor(EX(CVs)[opline->op1.u.var]);
5277
EX(CVs)[opline->op1.u.var] = NULL;
5279
ZEND_VM_NEXT_OPCODE();
5282
varname = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
5284
if (Z_TYPE_P(varname) != IS_STRING) {
5286
zval_copy_ctor(&tmp);
5287
convert_to_string(&tmp);
5289
} else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
5290
Z_ADDREF_P(varname);
5293
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
5294
zend_std_unset_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname) TSRMLS_CC);
5296
ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
5298
target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
5299
if (zend_hash_quick_del(target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value) == SUCCESS) {
5300
zend_execute_data *ex = execute_data;
5306
for (i = 0; i < ex->op_array->last_var; i++) {
5307
if (ex->op_array->vars[i].hash_value == hash_value &&
5308
ex->op_array->vars[i].name_len == varname->value.str.len &&
5309
!memcmp(ex->op_array->vars[i].name, varname->value.str.val, varname->value.str.len)) {
5315
ex = ex->prev_execute_data;
5316
} while (ex && ex->symbol_table == target_symbol_table);
5320
if (varname == &tmp) {
5322
} else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
5323
zval_ptr_dtor(&varname);
5325
zval_dtor(free_op1.var);
5326
ZEND_VM_NEXT_OPCODE();
5329
static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5331
zend_op *opline = EX(opline);
5332
zend_free_op free_op1;
5333
zval *array_ptr, **array_ptr_ptr;
5335
zend_object_iterator *iter = NULL;
5336
zend_class_entry *ce = NULL;
5337
zend_bool is_empty = 0;
5339
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
5340
array_ptr_ptr = NULL;
5341
if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
5342
ALLOC_INIT_ZVAL(array_ptr);
5343
} else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
5344
if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
5345
zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class");
5346
ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
5349
ce = Z_OBJCE_PP(array_ptr_ptr);
5350
if (!ce || ce->get_iterator == NULL) {
5351
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
5352
Z_ADDREF_PP(array_ptr_ptr);
5354
array_ptr = *array_ptr_ptr;
5356
if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
5357
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
5358
if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
5359
Z_SET_ISREF_PP(array_ptr_ptr);
5362
array_ptr = *array_ptr_ptr;
5363
Z_ADDREF_P(array_ptr);
5366
array_ptr = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
5367
if (1) { /* IS_TMP_VAR */
5371
INIT_PZVAL_COPY(tmp, array_ptr);
5373
} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
5374
ce = Z_OBJCE_P(array_ptr);
5375
if (!ce || !ce->get_iterator) {
5376
Z_ADDREF_P(array_ptr);
5379
if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) &&
5380
!Z_ISREF_P(array_ptr) &&
5381
Z_REFCOUNT_P(array_ptr) > 1) {
5385
INIT_PZVAL_COPY(tmp, array_ptr);
5386
zval_copy_ctor(tmp);
5389
Z_ADDREF_P(array_ptr);
5394
if (IS_TMP_VAR != IS_TMP_VAR && ce && ce->get_iterator) {
5395
iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC);
5397
if (iter && !EG(exception)) {
5398
array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
5400
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
5405
if (!EG(exception)) {
5406
zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
5408
zend_throw_exception_internal(NULL TSRMLS_CC);
5409
ZEND_VM_NEXT_OPCODE();
5413
AI_SET_PTR(EX_T(opline->result.u.var).var, array_ptr);
5414
PZVAL_LOCK(array_ptr);
5418
if (iter->funcs->rewind) {
5419
iter->funcs->rewind(iter TSRMLS_CC);
5420
if (EG(exception)) {
5421
Z_DELREF_P(array_ptr);
5422
zval_ptr_dtor(&array_ptr);
5423
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
5428
ZEND_VM_NEXT_OPCODE();
5431
is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
5432
if (EG(exception)) {
5433
Z_DELREF_P(array_ptr);
5434
zval_ptr_dtor(&array_ptr);
5435
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
5440
ZEND_VM_NEXT_OPCODE();
5442
iter->index = -1; /* will be set to 0 before using next handler */
5443
} else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
5444
zend_hash_internal_pointer_reset(fe_ht);
5446
zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
5447
while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
5451
zend_uchar key_type;
5453
key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
5454
if (key_type != HASH_KEY_NON_EXISTANT &&
5455
(key_type == HASH_KEY_IS_LONG ||
5456
zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
5459
zend_hash_move_forward(fe_ht);
5462
is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
5463
zend_hash_get_pointer(fe_ht, &EX_T(opline->result.u.var).fe.fe_pos);
5465
zend_error(E_WARNING, "Invalid argument supplied for foreach()");
5469
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
5475
ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
5477
ZEND_VM_NEXT_OPCODE();
5481
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5483
zend_op *opline = EX(opline);
5485
zend_bool isset = 1;
5487
if (IS_TMP_VAR == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
5488
if (EX(CVs)[opline->op1.u.var]) {
5489
value = EX(CVs)[opline->op1.u.var];
5490
} else if (EG(active_symbol_table)) {
5491
zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.u.var);
5493
if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
5500
HashTable *target_symbol_table;
5501
zend_free_op free_op1;
5502
zval tmp, *varname = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
5504
if (Z_TYPE_P(varname) != IS_STRING) {
5506
zval_copy_ctor(&tmp);
5507
convert_to_string(&tmp);
5511
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
5512
value = zend_std_get_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1 TSRMLS_CC);
5517
target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
5518
if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
5523
if (varname == &tmp) {
5526
zval_dtor(free_op1.var);
5529
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
5531
switch (opline->extended_value & ZEND_ISSET_ISEMPTY_MASK) {
5533
if (isset && Z_TYPE_PP(value) == IS_NULL) {
5534
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
5536
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = isset;
5540
if (!isset || !i_zend_is_true(*value)) {
5541
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
5543
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
5548
ZEND_VM_NEXT_OPCODE();
5551
static int ZEND_FASTCALL ZEND_EXIT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5553
#if 0 || (IS_TMP_VAR != IS_UNUSED)
5554
zend_op *opline = EX(opline);
5555
if (IS_TMP_VAR != IS_UNUSED) {
5556
zend_free_op free_op1;
5557
zval *ptr = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
5559
if (Z_TYPE_P(ptr) == IS_LONG) {
5560
EG(exit_status) = Z_LVAL_P(ptr);
5562
zend_print_variable(ptr);
5564
zval_dtor(free_op1.var);
5568
ZEND_VM_NEXT_OPCODE();
5571
static int ZEND_FASTCALL ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5573
zend_op *opline = EX(opline);
5574
zval restored_error_reporting;
5576
if (!EG(error_reporting) && Z_LVAL(EX_T(opline->op1.u.var).tmp_var) != 0) {
5577
Z_TYPE(restored_error_reporting) = IS_LONG;
5578
Z_LVAL(restored_error_reporting) = Z_LVAL(EX_T(opline->op1.u.var).tmp_var);
5579
convert_to_string(&restored_error_reporting);
5580
zend_alter_ini_entry_ex("error_reporting", sizeof("error_reporting"), Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME, 1 TSRMLS_CC);
5581
zendi_zval_dtor(restored_error_reporting);
5583
if (EX(old_error_reporting) == &EX_T(opline->op1.u.var).tmp_var) {
5584
EX(old_error_reporting) = NULL;
5586
ZEND_VM_NEXT_OPCODE();
5589
static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5591
zend_op *opline = EX(opline);
5592
zend_free_op free_op1;
5593
zval *value = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
5595
if (i_zend_is_true(value)) {
5596
EX_T(opline->result.u.var).tmp_var = *value;
5597
zendi_zval_copy_ctor(EX_T(opline->result.u.var).tmp_var);
5598
zval_dtor(free_op1.var);
5600
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
5602
ZEND_VM_JMP(opline->op2.u.jmp_addr);
5605
zval_dtor(free_op1.var);
5606
ZEND_VM_NEXT_OPCODE();
5609
static int ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5611
zend_op *opline = EX(opline);
5612
zend_free_op free_op1;
5613
zval *value = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
5615
EX_T(opline->result.u.var).tmp_var = *value;
5617
zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
5620
ZEND_VM_NEXT_OPCODE();
5623
static int ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5625
zend_op *opline = EX(opline);
5626
zend_free_op free_op1;
5627
zval *expr = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
5630
if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) {
5631
result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.u.var).class_entry TSRMLS_CC);
5635
ZVAL_BOOL(&EX_T(opline->result.u.var).tmp_var, result);
5636
zval_dtor(free_op1.var);
5637
ZEND_VM_NEXT_OPCODE();
5640
static int ZEND_FASTCALL ZEND_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5642
zend_op *opline = EX(opline);
5643
zend_free_op free_op1;
5645
add_function(&EX_T(opline->result.u.var).tmp_var,
5646
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5647
&opline->op2.u.constant TSRMLS_CC);
5648
zval_dtor(free_op1.var);
5650
ZEND_VM_NEXT_OPCODE();
5653
static int ZEND_FASTCALL ZEND_SUB_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5655
zend_op *opline = EX(opline);
5656
zend_free_op free_op1;
5658
sub_function(&EX_T(opline->result.u.var).tmp_var,
5659
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5660
&opline->op2.u.constant TSRMLS_CC);
5661
zval_dtor(free_op1.var);
5663
ZEND_VM_NEXT_OPCODE();
5666
static int ZEND_FASTCALL ZEND_MUL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5668
zend_op *opline = EX(opline);
5669
zend_free_op free_op1;
5671
mul_function(&EX_T(opline->result.u.var).tmp_var,
5672
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5673
&opline->op2.u.constant TSRMLS_CC);
5674
zval_dtor(free_op1.var);
5676
ZEND_VM_NEXT_OPCODE();
5679
static int ZEND_FASTCALL ZEND_DIV_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5681
zend_op *opline = EX(opline);
5682
zend_free_op free_op1;
5684
div_function(&EX_T(opline->result.u.var).tmp_var,
5685
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5686
&opline->op2.u.constant TSRMLS_CC);
5687
zval_dtor(free_op1.var);
5689
ZEND_VM_NEXT_OPCODE();
5692
static int ZEND_FASTCALL ZEND_MOD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5694
zend_op *opline = EX(opline);
5695
zend_free_op free_op1;
5697
mod_function(&EX_T(opline->result.u.var).tmp_var,
5698
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5699
&opline->op2.u.constant TSRMLS_CC);
5700
zval_dtor(free_op1.var);
5702
ZEND_VM_NEXT_OPCODE();
5705
static int ZEND_FASTCALL ZEND_SL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5707
zend_op *opline = EX(opline);
5708
zend_free_op free_op1;
5710
shift_left_function(&EX_T(opline->result.u.var).tmp_var,
5711
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5712
&opline->op2.u.constant TSRMLS_CC);
5713
zval_dtor(free_op1.var);
5715
ZEND_VM_NEXT_OPCODE();
5718
static int ZEND_FASTCALL ZEND_SR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5720
zend_op *opline = EX(opline);
5721
zend_free_op free_op1;
5723
shift_right_function(&EX_T(opline->result.u.var).tmp_var,
5724
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5725
&opline->op2.u.constant TSRMLS_CC);
5726
zval_dtor(free_op1.var);
5728
ZEND_VM_NEXT_OPCODE();
5731
static int ZEND_FASTCALL ZEND_CONCAT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5733
zend_op *opline = EX(opline);
5734
zend_free_op free_op1;
5736
concat_function(&EX_T(opline->result.u.var).tmp_var,
5737
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5738
&opline->op2.u.constant TSRMLS_CC);
5739
zval_dtor(free_op1.var);
5741
ZEND_VM_NEXT_OPCODE();
5744
static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5746
zend_op *opline = EX(opline);
5747
zend_free_op free_op1;
5749
is_identical_function(&EX_T(opline->result.u.var).tmp_var,
5750
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5751
&opline->op2.u.constant TSRMLS_CC);
5752
zval_dtor(free_op1.var);
5754
ZEND_VM_NEXT_OPCODE();
5757
static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5759
zend_op *opline = EX(opline);
5760
zend_free_op free_op1;
5761
zval *result = &EX_T(opline->result.u.var).tmp_var;
5763
is_identical_function(result,
5764
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5765
&opline->op2.u.constant TSRMLS_CC);
5766
Z_LVAL_P(result) = !Z_LVAL_P(result);
5767
zval_dtor(free_op1.var);
5769
ZEND_VM_NEXT_OPCODE();
5772
static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5774
zend_op *opline = EX(opline);
5775
zend_free_op free_op1;
5776
zval *result = &EX_T(opline->result.u.var).tmp_var;
5778
compare_function(result,
5779
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5780
&opline->op2.u.constant TSRMLS_CC);
5781
ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
5782
zval_dtor(free_op1.var);
5784
ZEND_VM_NEXT_OPCODE();
5787
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5789
zend_op *opline = EX(opline);
5790
zend_free_op free_op1;
5791
zval *result = &EX_T(opline->result.u.var).tmp_var;
5793
compare_function(result,
5794
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5795
&opline->op2.u.constant TSRMLS_CC);
5796
ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
5797
zval_dtor(free_op1.var);
5799
ZEND_VM_NEXT_OPCODE();
5802
static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5804
zend_op *opline = EX(opline);
5805
zend_free_op free_op1;
5806
zval *result = &EX_T(opline->result.u.var).tmp_var;
5808
compare_function(result,
5809
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5810
&opline->op2.u.constant TSRMLS_CC);
5811
ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
5812
zval_dtor(free_op1.var);
5814
ZEND_VM_NEXT_OPCODE();
5817
static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5819
zend_op *opline = EX(opline);
5820
zend_free_op free_op1;
5821
zval *result = &EX_T(opline->result.u.var).tmp_var;
5823
compare_function(result,
5824
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5825
&opline->op2.u.constant TSRMLS_CC);
5826
ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
5827
zval_dtor(free_op1.var);
5829
ZEND_VM_NEXT_OPCODE();
5832
static int ZEND_FASTCALL ZEND_BW_OR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5834
zend_op *opline = EX(opline);
5835
zend_free_op free_op1;
5837
bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
5838
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5839
&opline->op2.u.constant TSRMLS_CC);
5840
zval_dtor(free_op1.var);
5842
ZEND_VM_NEXT_OPCODE();
5845
static int ZEND_FASTCALL ZEND_BW_AND_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5847
zend_op *opline = EX(opline);
5848
zend_free_op free_op1;
5850
bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
5851
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5852
&opline->op2.u.constant TSRMLS_CC);
5853
zval_dtor(free_op1.var);
5855
ZEND_VM_NEXT_OPCODE();
5858
static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5860
zend_op *opline = EX(opline);
5861
zend_free_op free_op1;
5863
bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
5864
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5865
&opline->op2.u.constant TSRMLS_CC);
5866
zval_dtor(free_op1.var);
5868
ZEND_VM_NEXT_OPCODE();
5871
static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5873
zend_op *opline = EX(opline);
5874
zend_free_op free_op1;
5876
boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
5877
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5878
&opline->op2.u.constant TSRMLS_CC);
5879
zval_dtor(free_op1.var);
5881
ZEND_VM_NEXT_OPCODE();
5884
static int ZEND_FASTCALL ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5886
zend_op *opline = EX(opline);
5887
zend_free_op free_op1;
5888
zval *container = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
5890
if (Z_TYPE_P(container) != IS_ARRAY) {
5891
if (!RETURN_VALUE_UNUSED(&opline->result)) {
5892
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
5893
PZVAL_LOCK(EG(uninitialized_zval_ptr));
5897
zval *dim = &opline->op2.u.constant;
5899
AI_SET_PTR(EX_T(opline->result.u.var).var, *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, BP_VAR_R TSRMLS_CC));
5900
SELECTIVE_PZVAL_LOCK(EX_T(opline->result.u.var).var.ptr, &opline->result);
5903
ZEND_VM_NEXT_OPCODE();
5906
static int ZEND_FASTCALL ZEND_ADD_CHAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5908
zend_op *opline = EX(opline);
5909
zval *str = &EX_T(opline->result.u.var).tmp_var;
5911
if (IS_TMP_VAR == IS_UNUSED) {
5912
/* Initialize for erealloc in add_char_to_string */
5913
Z_STRVAL_P(str) = NULL;
5914
Z_STRLEN_P(str) = 0;
5915
Z_TYPE_P(str) = IS_STRING;
5920
add_char_to_string(str, str, &opline->op2.u.constant);
5922
/* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
5923
ZEND_VM_NEXT_OPCODE();
5926
static int ZEND_FASTCALL ZEND_ADD_STRING_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5928
zend_op *opline = EX(opline);
5929
zval *str = &EX_T(opline->result.u.var).tmp_var;
5931
if (IS_TMP_VAR == IS_UNUSED) {
5932
/* Initialize for erealloc in add_string_to_string */
5933
Z_STRVAL_P(str) = NULL;
5934
Z_STRLEN_P(str) = 0;
5935
Z_TYPE_P(str) = IS_STRING;
5940
add_string_to_string(str, str, &opline->op2.u.constant);
5942
/* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
5943
ZEND_VM_NEXT_OPCODE();
5946
static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5948
zend_op *opline = EX(opline);
5949
zval *function_name;
5950
char *function_name_strval;
5951
int function_name_strlen;
5952
zend_free_op free_op1;
5954
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
5956
function_name = &opline->op2.u.constant;
5958
if (Z_TYPE_P(function_name)!=IS_STRING) {
5959
zend_error_noreturn(E_ERROR, "Method name must be a string");
5962
function_name_strval = Z_STRVAL_P(function_name);
5963
function_name_strlen = Z_STRLEN_P(function_name);
5965
EX(object) = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
5967
if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
5968
if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
5969
zend_error_noreturn(E_ERROR, "Object does not support method calls");
5972
/* First, locate the function. */
5973
EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
5975
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
5978
EX(called_scope) = Z_OBJCE_P(EX(object));
5980
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
5983
if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) {
5986
if (!PZVAL_IS_REF(EX(object))) {
5987
Z_ADDREF_P(EX(object)); /* For $this pointer */
5990
ALLOC_ZVAL(this_ptr);
5991
INIT_PZVAL_COPY(this_ptr, EX(object));
5992
zval_copy_ctor(this_ptr);
5993
EX(object) = this_ptr;
5998
ZEND_VM_NEXT_OPCODE();
6001
static int ZEND_FASTCALL ZEND_CASE_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6003
zend_op *opline = EX(opline);
6004
int switch_expr_is_overloaded=0;
6005
zend_free_op free_op1;
6007
if (IS_TMP_VAR==IS_VAR) {
6008
if (EX_T(opline->op1.u.var).var.ptr_ptr) {
6009
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
6011
switch_expr_is_overloaded = 1;
6012
Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
6015
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
6016
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6017
&opline->op2.u.constant TSRMLS_CC);
6019
if (switch_expr_is_overloaded) {
6020
/* We only free op1 if this is a string offset,
6021
* Since if it is a TMP_VAR, it'll be reused by
6022
* other CASE opcodes (whereas string offsets
6023
* are allocated at each get_zval_ptr())
6025
zval_dtor(free_op1.var);
6026
EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
6027
EX_T(opline->op1.u.var).var.ptr = NULL;
6029
ZEND_VM_NEXT_OPCODE();
6032
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6034
zend_op *opline = EX(opline);
6035
zend_free_op free_op1;
6036
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
6038
zval *offset=&opline->op2.u.constant;
6040
#if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
6041
zval **expr_ptr_ptr = NULL;
6043
if (opline->extended_value) {
6045
expr_ptr = *expr_ptr_ptr;
6047
expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
6050
expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
6053
if (1) { /* temporary variable */
6056
ALLOC_ZVAL(new_expr);
6057
INIT_PZVAL_COPY(new_expr, expr_ptr);
6058
expr_ptr = new_expr;
6060
#if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
6061
if (opline->extended_value) {
6062
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
6063
expr_ptr = *expr_ptr_ptr;
6064
Z_ADDREF_P(expr_ptr);
6067
if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
6070
ALLOC_ZVAL(new_expr);
6071
INIT_PZVAL_COPY(new_expr, expr_ptr);
6072
expr_ptr = new_expr;
6073
zendi_zval_copy_ctor(*expr_ptr);
6075
Z_ADDREF_P(expr_ptr);
6079
switch (Z_TYPE_P(offset)) {
6081
zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
6085
zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
6088
zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
6091
zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
6094
zend_error(E_WARNING, "Illegal offset type");
6095
zval_ptr_dtor(&expr_ptr);
6101
zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
6103
if (opline->extended_value) {
6108
ZEND_VM_NEXT_OPCODE();
6111
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6113
zend_op *opline = EX(opline);
6115
array_init(&EX_T(opline->result.u.var).tmp_var);
6116
if (IS_TMP_VAR == IS_UNUSED) {
6117
ZEND_VM_NEXT_OPCODE();
6118
#if 0 || IS_TMP_VAR != IS_UNUSED
6120
return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
6125
static int ZEND_FASTCALL ZEND_ADD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6127
zend_op *opline = EX(opline);
6128
zend_free_op free_op1, free_op2;
6130
add_function(&EX_T(opline->result.u.var).tmp_var,
6131
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6132
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6133
zval_dtor(free_op1.var);
6134
zval_dtor(free_op2.var);
6135
ZEND_VM_NEXT_OPCODE();
6138
static int ZEND_FASTCALL ZEND_SUB_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6140
zend_op *opline = EX(opline);
6141
zend_free_op free_op1, free_op2;
6143
sub_function(&EX_T(opline->result.u.var).tmp_var,
6144
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6145
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6146
zval_dtor(free_op1.var);
6147
zval_dtor(free_op2.var);
6148
ZEND_VM_NEXT_OPCODE();
6151
static int ZEND_FASTCALL ZEND_MUL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6153
zend_op *opline = EX(opline);
6154
zend_free_op free_op1, free_op2;
6156
mul_function(&EX_T(opline->result.u.var).tmp_var,
6157
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6158
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6159
zval_dtor(free_op1.var);
6160
zval_dtor(free_op2.var);
6161
ZEND_VM_NEXT_OPCODE();
6164
static int ZEND_FASTCALL ZEND_DIV_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6166
zend_op *opline = EX(opline);
6167
zend_free_op free_op1, free_op2;
6169
div_function(&EX_T(opline->result.u.var).tmp_var,
6170
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6171
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6172
zval_dtor(free_op1.var);
6173
zval_dtor(free_op2.var);
6174
ZEND_VM_NEXT_OPCODE();
6177
static int ZEND_FASTCALL ZEND_MOD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6179
zend_op *opline = EX(opline);
6180
zend_free_op free_op1, free_op2;
6182
mod_function(&EX_T(opline->result.u.var).tmp_var,
6183
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6184
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6185
zval_dtor(free_op1.var);
6186
zval_dtor(free_op2.var);
6187
ZEND_VM_NEXT_OPCODE();
6190
static int ZEND_FASTCALL ZEND_SL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6192
zend_op *opline = EX(opline);
6193
zend_free_op free_op1, free_op2;
6195
shift_left_function(&EX_T(opline->result.u.var).tmp_var,
6196
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6197
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6198
zval_dtor(free_op1.var);
6199
zval_dtor(free_op2.var);
6200
ZEND_VM_NEXT_OPCODE();
6203
static int ZEND_FASTCALL ZEND_SR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6205
zend_op *opline = EX(opline);
6206
zend_free_op free_op1, free_op2;
6208
shift_right_function(&EX_T(opline->result.u.var).tmp_var,
6209
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6210
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6211
zval_dtor(free_op1.var);
6212
zval_dtor(free_op2.var);
6213
ZEND_VM_NEXT_OPCODE();
6216
static int ZEND_FASTCALL ZEND_CONCAT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6218
zend_op *opline = EX(opline);
6219
zend_free_op free_op1, free_op2;
6221
concat_function(&EX_T(opline->result.u.var).tmp_var,
6222
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6223
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6224
zval_dtor(free_op1.var);
6225
zval_dtor(free_op2.var);
6226
ZEND_VM_NEXT_OPCODE();
6229
static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6231
zend_op *opline = EX(opline);
6232
zend_free_op free_op1, free_op2;
6234
is_identical_function(&EX_T(opline->result.u.var).tmp_var,
6235
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6236
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6237
zval_dtor(free_op1.var);
6238
zval_dtor(free_op2.var);
6239
ZEND_VM_NEXT_OPCODE();
6242
static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6244
zend_op *opline = EX(opline);
6245
zend_free_op free_op1, free_op2;
6246
zval *result = &EX_T(opline->result.u.var).tmp_var;
6248
is_identical_function(result,
6249
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6250
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6251
Z_LVAL_P(result) = !Z_LVAL_P(result);
6252
zval_dtor(free_op1.var);
6253
zval_dtor(free_op2.var);
6254
ZEND_VM_NEXT_OPCODE();
6257
static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6259
zend_op *opline = EX(opline);
6260
zend_free_op free_op1, free_op2;
6261
zval *result = &EX_T(opline->result.u.var).tmp_var;
6263
compare_function(result,
6264
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6265
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6266
ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
6267
zval_dtor(free_op1.var);
6268
zval_dtor(free_op2.var);
6269
ZEND_VM_NEXT_OPCODE();
6272
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6274
zend_op *opline = EX(opline);
6275
zend_free_op free_op1, free_op2;
6276
zval *result = &EX_T(opline->result.u.var).tmp_var;
6278
compare_function(result,
6279
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6280
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6281
ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
6282
zval_dtor(free_op1.var);
6283
zval_dtor(free_op2.var);
6284
ZEND_VM_NEXT_OPCODE();
6287
static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6289
zend_op *opline = EX(opline);
6290
zend_free_op free_op1, free_op2;
6291
zval *result = &EX_T(opline->result.u.var).tmp_var;
6293
compare_function(result,
6294
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6295
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6296
ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
6297
zval_dtor(free_op1.var);
6298
zval_dtor(free_op2.var);
6299
ZEND_VM_NEXT_OPCODE();
6302
static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6304
zend_op *opline = EX(opline);
6305
zend_free_op free_op1, free_op2;
6306
zval *result = &EX_T(opline->result.u.var).tmp_var;
6308
compare_function(result,
6309
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6310
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6311
ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
6312
zval_dtor(free_op1.var);
6313
zval_dtor(free_op2.var);
6314
ZEND_VM_NEXT_OPCODE();
6317
static int ZEND_FASTCALL ZEND_BW_OR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6319
zend_op *opline = EX(opline);
6320
zend_free_op free_op1, free_op2;
6322
bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
6323
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6324
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6325
zval_dtor(free_op1.var);
6326
zval_dtor(free_op2.var);
6327
ZEND_VM_NEXT_OPCODE();
6330
static int ZEND_FASTCALL ZEND_BW_AND_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6332
zend_op *opline = EX(opline);
6333
zend_free_op free_op1, free_op2;
6335
bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
6336
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6337
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6338
zval_dtor(free_op1.var);
6339
zval_dtor(free_op2.var);
6340
ZEND_VM_NEXT_OPCODE();
6343
static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6345
zend_op *opline = EX(opline);
6346
zend_free_op free_op1, free_op2;
6348
bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
6349
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6350
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6351
zval_dtor(free_op1.var);
6352
zval_dtor(free_op2.var);
6353
ZEND_VM_NEXT_OPCODE();
6356
static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6358
zend_op *opline = EX(opline);
6359
zend_free_op free_op1, free_op2;
6361
boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
6362
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6363
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6364
zval_dtor(free_op1.var);
6365
zval_dtor(free_op2.var);
6366
ZEND_VM_NEXT_OPCODE();
6369
static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6371
zend_op *opline = EX(opline);
6372
zend_free_op free_op2;
6373
zval *str = &EX_T(opline->result.u.var).tmp_var;
6374
zval *var = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
6378
if (IS_TMP_VAR == IS_UNUSED) {
6379
/* Initialize for erealloc in add_string_to_string */
6380
Z_STRVAL_P(str) = NULL;
6381
Z_STRLEN_P(str) = 0;
6382
Z_TYPE_P(str) = IS_STRING;
6387
if (Z_TYPE_P(var) != IS_STRING) {
6388
zend_make_printable_zval(var, &var_copy, &use_copy);
6394
add_string_to_string(str, str, var);
6399
/* original comment, possibly problematic:
6400
* FREE_OP is missing intentionally here - we're always working on the same temporary variable
6401
* (Zeev): I don't think it's problematic, we only use variables
6402
* which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
6403
* string offsets or overloaded objects
6405
zval_dtor(free_op2.var);
6407
ZEND_VM_NEXT_OPCODE();
6410
static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6412
zend_op *opline = EX(opline);
6413
zval *function_name;
6414
char *function_name_strval;
6415
int function_name_strlen;
6416
zend_free_op free_op1, free_op2;
6418
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
6420
function_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
6422
if (Z_TYPE_P(function_name)!=IS_STRING) {
6423
zend_error_noreturn(E_ERROR, "Method name must be a string");
6426
function_name_strval = Z_STRVAL_P(function_name);
6427
function_name_strlen = Z_STRLEN_P(function_name);
6429
EX(object) = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
6431
if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
6432
if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
6433
zend_error_noreturn(E_ERROR, "Object does not support method calls");
6436
/* First, locate the function. */
6437
EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
6439
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
6442
EX(called_scope) = Z_OBJCE_P(EX(object));
6444
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
6447
if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) {
6450
if (!PZVAL_IS_REF(EX(object))) {
6451
Z_ADDREF_P(EX(object)); /* For $this pointer */
6454
ALLOC_ZVAL(this_ptr);
6455
INIT_PZVAL_COPY(this_ptr, EX(object));
6456
zval_copy_ctor(this_ptr);
6457
EX(object) = this_ptr;
6461
zval_dtor(free_op2.var);
6463
ZEND_VM_NEXT_OPCODE();
6466
static int ZEND_FASTCALL ZEND_CASE_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6468
zend_op *opline = EX(opline);
6469
int switch_expr_is_overloaded=0;
6470
zend_free_op free_op1, free_op2;
6472
if (IS_TMP_VAR==IS_VAR) {
6473
if (EX_T(opline->op1.u.var).var.ptr_ptr) {
6474
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
6476
switch_expr_is_overloaded = 1;
6477
Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
6480
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
6481
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6482
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6484
zval_dtor(free_op2.var);
6485
if (switch_expr_is_overloaded) {
6486
/* We only free op1 if this is a string offset,
6487
* Since if it is a TMP_VAR, it'll be reused by
6488
* other CASE opcodes (whereas string offsets
6489
* are allocated at each get_zval_ptr())
6491
zval_dtor(free_op1.var);
6492
EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
6493
EX_T(opline->op1.u.var).var.ptr = NULL;
6495
ZEND_VM_NEXT_OPCODE();
6498
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6500
zend_op *opline = EX(opline);
6501
zend_free_op free_op1, free_op2;
6502
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
6504
zval *offset=_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
6506
#if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
6507
zval **expr_ptr_ptr = NULL;
6509
if (opline->extended_value) {
6511
expr_ptr = *expr_ptr_ptr;
6513
expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
6516
expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
6519
if (1) { /* temporary variable */
6522
ALLOC_ZVAL(new_expr);
6523
INIT_PZVAL_COPY(new_expr, expr_ptr);
6524
expr_ptr = new_expr;
6526
#if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
6527
if (opline->extended_value) {
6528
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
6529
expr_ptr = *expr_ptr_ptr;
6530
Z_ADDREF_P(expr_ptr);
6533
if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
6536
ALLOC_ZVAL(new_expr);
6537
INIT_PZVAL_COPY(new_expr, expr_ptr);
6538
expr_ptr = new_expr;
6539
zendi_zval_copy_ctor(*expr_ptr);
6541
Z_ADDREF_P(expr_ptr);
6545
switch (Z_TYPE_P(offset)) {
6547
zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
6551
zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
6554
zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
6557
zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
6560
zend_error(E_WARNING, "Illegal offset type");
6561
zval_ptr_dtor(&expr_ptr);
6565
zval_dtor(free_op2.var);
6567
zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
6569
if (opline->extended_value) {
6574
ZEND_VM_NEXT_OPCODE();
6577
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6579
zend_op *opline = EX(opline);
6581
array_init(&EX_T(opline->result.u.var).tmp_var);
6582
if (IS_TMP_VAR == IS_UNUSED) {
6583
ZEND_VM_NEXT_OPCODE();
6584
#if 0 || IS_TMP_VAR != IS_UNUSED
6586
return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
6591
static int ZEND_FASTCALL ZEND_ADD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6593
zend_op *opline = EX(opline);
6594
zend_free_op free_op1, free_op2;
6596
add_function(&EX_T(opline->result.u.var).tmp_var,
6597
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6598
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6599
zval_dtor(free_op1.var);
6600
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6601
ZEND_VM_NEXT_OPCODE();
6604
static int ZEND_FASTCALL ZEND_SUB_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6606
zend_op *opline = EX(opline);
6607
zend_free_op free_op1, free_op2;
6609
sub_function(&EX_T(opline->result.u.var).tmp_var,
6610
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6611
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6612
zval_dtor(free_op1.var);
6613
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6614
ZEND_VM_NEXT_OPCODE();
6617
static int ZEND_FASTCALL ZEND_MUL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6619
zend_op *opline = EX(opline);
6620
zend_free_op free_op1, free_op2;
6622
mul_function(&EX_T(opline->result.u.var).tmp_var,
6623
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6624
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6625
zval_dtor(free_op1.var);
6626
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6627
ZEND_VM_NEXT_OPCODE();
6630
static int ZEND_FASTCALL ZEND_DIV_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6632
zend_op *opline = EX(opline);
6633
zend_free_op free_op1, free_op2;
6635
div_function(&EX_T(opline->result.u.var).tmp_var,
6636
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6637
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6638
zval_dtor(free_op1.var);
6639
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6640
ZEND_VM_NEXT_OPCODE();
6643
static int ZEND_FASTCALL ZEND_MOD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6645
zend_op *opline = EX(opline);
6646
zend_free_op free_op1, free_op2;
6648
mod_function(&EX_T(opline->result.u.var).tmp_var,
6649
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6650
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6651
zval_dtor(free_op1.var);
6652
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6653
ZEND_VM_NEXT_OPCODE();
6656
static int ZEND_FASTCALL ZEND_SL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6658
zend_op *opline = EX(opline);
6659
zend_free_op free_op1, free_op2;
6661
shift_left_function(&EX_T(opline->result.u.var).tmp_var,
6662
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6663
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6664
zval_dtor(free_op1.var);
6665
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6666
ZEND_VM_NEXT_OPCODE();
6669
static int ZEND_FASTCALL ZEND_SR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6671
zend_op *opline = EX(opline);
6672
zend_free_op free_op1, free_op2;
6674
shift_right_function(&EX_T(opline->result.u.var).tmp_var,
6675
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6676
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6677
zval_dtor(free_op1.var);
6678
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6679
ZEND_VM_NEXT_OPCODE();
6682
static int ZEND_FASTCALL ZEND_CONCAT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6684
zend_op *opline = EX(opline);
6685
zend_free_op free_op1, free_op2;
6687
concat_function(&EX_T(opline->result.u.var).tmp_var,
6688
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6689
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6690
zval_dtor(free_op1.var);
6691
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6692
ZEND_VM_NEXT_OPCODE();
6695
static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6697
zend_op *opline = EX(opline);
6698
zend_free_op free_op1, free_op2;
6700
is_identical_function(&EX_T(opline->result.u.var).tmp_var,
6701
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6702
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6703
zval_dtor(free_op1.var);
6704
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6705
ZEND_VM_NEXT_OPCODE();
6708
static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6710
zend_op *opline = EX(opline);
6711
zend_free_op free_op1, free_op2;
6712
zval *result = &EX_T(opline->result.u.var).tmp_var;
6714
is_identical_function(result,
6715
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6716
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6717
Z_LVAL_P(result) = !Z_LVAL_P(result);
6718
zval_dtor(free_op1.var);
6719
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6720
ZEND_VM_NEXT_OPCODE();
6723
static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6725
zend_op *opline = EX(opline);
6726
zend_free_op free_op1, free_op2;
6727
zval *result = &EX_T(opline->result.u.var).tmp_var;
6729
compare_function(result,
6730
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6731
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6732
ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
6733
zval_dtor(free_op1.var);
6734
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6735
ZEND_VM_NEXT_OPCODE();
6738
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6740
zend_op *opline = EX(opline);
6741
zend_free_op free_op1, free_op2;
6742
zval *result = &EX_T(opline->result.u.var).tmp_var;
6744
compare_function(result,
6745
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6746
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6747
ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
6748
zval_dtor(free_op1.var);
6749
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6750
ZEND_VM_NEXT_OPCODE();
6753
static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6755
zend_op *opline = EX(opline);
6756
zend_free_op free_op1, free_op2;
6757
zval *result = &EX_T(opline->result.u.var).tmp_var;
6759
compare_function(result,
6760
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6761
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6762
ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
6763
zval_dtor(free_op1.var);
6764
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6765
ZEND_VM_NEXT_OPCODE();
6768
static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6770
zend_op *opline = EX(opline);
6771
zend_free_op free_op1, free_op2;
6772
zval *result = &EX_T(opline->result.u.var).tmp_var;
6774
compare_function(result,
6775
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6776
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6777
ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
6778
zval_dtor(free_op1.var);
6779
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6780
ZEND_VM_NEXT_OPCODE();
6783
static int ZEND_FASTCALL ZEND_BW_OR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6785
zend_op *opline = EX(opline);
6786
zend_free_op free_op1, free_op2;
6788
bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
6789
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6790
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6791
zval_dtor(free_op1.var);
6792
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6793
ZEND_VM_NEXT_OPCODE();
6796
static int ZEND_FASTCALL ZEND_BW_AND_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6798
zend_op *opline = EX(opline);
6799
zend_free_op free_op1, free_op2;
6801
bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
6802
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6803
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6804
zval_dtor(free_op1.var);
6805
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6806
ZEND_VM_NEXT_OPCODE();
6809
static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6811
zend_op *opline = EX(opline);
6812
zend_free_op free_op1, free_op2;
6814
bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
6815
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6816
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6817
zval_dtor(free_op1.var);
6818
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6819
ZEND_VM_NEXT_OPCODE();
6822
static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6824
zend_op *opline = EX(opline);
6825
zend_free_op free_op1, free_op2;
6827
boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
6828
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6829
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6830
zval_dtor(free_op1.var);
6831
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6832
ZEND_VM_NEXT_OPCODE();
6835
static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6837
zend_op *opline = EX(opline);
6838
zend_free_op free_op2;
6839
zval *str = &EX_T(opline->result.u.var).tmp_var;
6840
zval *var = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
6844
if (IS_TMP_VAR == IS_UNUSED) {
6845
/* Initialize for erealloc in add_string_to_string */
6846
Z_STRVAL_P(str) = NULL;
6847
Z_STRLEN_P(str) = 0;
6848
Z_TYPE_P(str) = IS_STRING;
6853
if (Z_TYPE_P(var) != IS_STRING) {
6854
zend_make_printable_zval(var, &var_copy, &use_copy);
6860
add_string_to_string(str, str, var);
6865
/* original comment, possibly problematic:
6866
* FREE_OP is missing intentionally here - we're always working on the same temporary variable
6867
* (Zeev): I don't think it's problematic, we only use variables
6868
* which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
6869
* string offsets or overloaded objects
6871
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6873
ZEND_VM_NEXT_OPCODE();
6876
static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6878
zend_op *opline = EX(opline);
6879
zval *function_name;
6880
char *function_name_strval;
6881
int function_name_strlen;
6882
zend_free_op free_op1, free_op2;
6884
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
6886
function_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
6888
if (Z_TYPE_P(function_name)!=IS_STRING) {
6889
zend_error_noreturn(E_ERROR, "Method name must be a string");
6892
function_name_strval = Z_STRVAL_P(function_name);
6893
function_name_strlen = Z_STRLEN_P(function_name);
6895
EX(object) = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
6897
if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
6898
if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
6899
zend_error_noreturn(E_ERROR, "Object does not support method calls");
6902
/* First, locate the function. */
6903
EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
6905
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
6908
EX(called_scope) = Z_OBJCE_P(EX(object));
6910
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
6913
if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) {
6916
if (!PZVAL_IS_REF(EX(object))) {
6917
Z_ADDREF_P(EX(object)); /* For $this pointer */
6920
ALLOC_ZVAL(this_ptr);
6921
INIT_PZVAL_COPY(this_ptr, EX(object));
6922
zval_copy_ctor(this_ptr);
6923
EX(object) = this_ptr;
6927
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6929
ZEND_VM_NEXT_OPCODE();
6932
static int ZEND_FASTCALL ZEND_CASE_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6934
zend_op *opline = EX(opline);
6935
int switch_expr_is_overloaded=0;
6936
zend_free_op free_op1, free_op2;
6938
if (IS_TMP_VAR==IS_VAR) {
6939
if (EX_T(opline->op1.u.var).var.ptr_ptr) {
6940
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
6942
switch_expr_is_overloaded = 1;
6943
Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
6946
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
6947
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6948
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6950
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6951
if (switch_expr_is_overloaded) {
6952
/* We only free op1 if this is a string offset,
6953
* Since if it is a TMP_VAR, it'll be reused by
6954
* other CASE opcodes (whereas string offsets
6955
* are allocated at each get_zval_ptr())
6957
zval_dtor(free_op1.var);
6958
EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
6959
EX_T(opline->op1.u.var).var.ptr = NULL;
6961
ZEND_VM_NEXT_OPCODE();
6964
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6966
zend_op *opline = EX(opline);
6967
zend_free_op free_op1, free_op2;
6968
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
6970
zval *offset=_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
6972
#if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
6973
zval **expr_ptr_ptr = NULL;
6975
if (opline->extended_value) {
6977
expr_ptr = *expr_ptr_ptr;
6979
expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
6982
expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
6985
if (1) { /* temporary variable */
6988
ALLOC_ZVAL(new_expr);
6989
INIT_PZVAL_COPY(new_expr, expr_ptr);
6990
expr_ptr = new_expr;
6992
#if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
6993
if (opline->extended_value) {
6994
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
6995
expr_ptr = *expr_ptr_ptr;
6996
Z_ADDREF_P(expr_ptr);
6999
if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
7002
ALLOC_ZVAL(new_expr);
7003
INIT_PZVAL_COPY(new_expr, expr_ptr);
7004
expr_ptr = new_expr;
7005
zendi_zval_copy_ctor(*expr_ptr);
7007
Z_ADDREF_P(expr_ptr);
7011
switch (Z_TYPE_P(offset)) {
7013
zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
7017
zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
7020
zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
7023
zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
7026
zend_error(E_WARNING, "Illegal offset type");
7027
zval_ptr_dtor(&expr_ptr);
7031
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
7033
zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
7035
if (opline->extended_value) {
7040
ZEND_VM_NEXT_OPCODE();
7043
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7045
zend_op *opline = EX(opline);
7047
array_init(&EX_T(opline->result.u.var).tmp_var);
7048
if (IS_TMP_VAR == IS_UNUSED) {
7049
ZEND_VM_NEXT_OPCODE();
7050
#if 0 || IS_TMP_VAR != IS_UNUSED
7052
return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7057
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7059
zend_op *opline = EX(opline);
7060
zend_free_op free_op1;
7061
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
7065
#if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
7066
zval **expr_ptr_ptr = NULL;
7068
if (opline->extended_value) {
7070
expr_ptr = *expr_ptr_ptr;
7072
expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7075
expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7078
if (1) { /* temporary variable */
7081
ALLOC_ZVAL(new_expr);
7082
INIT_PZVAL_COPY(new_expr, expr_ptr);
7083
expr_ptr = new_expr;
7085
#if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
7086
if (opline->extended_value) {
7087
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
7088
expr_ptr = *expr_ptr_ptr;
7089
Z_ADDREF_P(expr_ptr);
7092
if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
7095
ALLOC_ZVAL(new_expr);
7096
INIT_PZVAL_COPY(new_expr, expr_ptr);
7097
expr_ptr = new_expr;
7098
zendi_zval_copy_ctor(*expr_ptr);
7100
Z_ADDREF_P(expr_ptr);
7104
switch (Z_TYPE_P(offset)) {
7106
zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
7110
zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
7113
zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
7116
zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
7119
zend_error(E_WARNING, "Illegal offset type");
7120
zval_ptr_dtor(&expr_ptr);
7126
zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
7128
if (opline->extended_value) {
7133
ZEND_VM_NEXT_OPCODE();
7136
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7138
zend_op *opline = EX(opline);
7140
array_init(&EX_T(opline->result.u.var).tmp_var);
7141
if (IS_TMP_VAR == IS_UNUSED) {
7142
ZEND_VM_NEXT_OPCODE();
7143
#if 0 || IS_TMP_VAR != IS_UNUSED
7145
return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7150
static int ZEND_FASTCALL ZEND_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7152
zend_op *opline = EX(opline);
7153
zend_free_op free_op1;
7155
add_function(&EX_T(opline->result.u.var).tmp_var,
7156
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
7157
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
7158
zval_dtor(free_op1.var);
7160
ZEND_VM_NEXT_OPCODE();
7163
static int ZEND_FASTCALL ZEND_SUB_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7165
zend_op *opline = EX(opline);
7166
zend_free_op free_op1;
7168
sub_function(&EX_T(opline->result.u.var).tmp_var,
7169
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
7170
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
7171
zval_dtor(free_op1.var);
7173
ZEND_VM_NEXT_OPCODE();
7176
static int ZEND_FASTCALL ZEND_MUL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7178
zend_op *opline = EX(opline);
7179
zend_free_op free_op1;
7181
mul_function(&EX_T(opline->result.u.var).tmp_var,
7182
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
7183
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
7184
zval_dtor(free_op1.var);
7186
ZEND_VM_NEXT_OPCODE();
7189
static int ZEND_FASTCALL ZEND_DIV_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7191
zend_op *opline = EX(opline);
7192
zend_free_op free_op1;
7194
div_function(&EX_T(opline->result.u.var).tmp_var,
7195
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
7196
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
7197
zval_dtor(free_op1.var);
7199
ZEND_VM_NEXT_OPCODE();
7202
static int ZEND_FASTCALL ZEND_MOD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7204
zend_op *opline = EX(opline);
7205
zend_free_op free_op1;
7207
mod_function(&EX_T(opline->result.u.var).tmp_var,
7208
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
7209
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
7210
zval_dtor(free_op1.var);
7212
ZEND_VM_NEXT_OPCODE();
7215
static int ZEND_FASTCALL ZEND_SL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7217
zend_op *opline = EX(opline);
7218
zend_free_op free_op1;
7220
shift_left_function(&EX_T(opline->result.u.var).tmp_var,
7221
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
7222
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
7223
zval_dtor(free_op1.var);
7225
ZEND_VM_NEXT_OPCODE();
7228
static int ZEND_FASTCALL ZEND_SR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7230
zend_op *opline = EX(opline);
7231
zend_free_op free_op1;
7233
shift_right_function(&EX_T(opline->result.u.var).tmp_var,
7234
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
7235
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
7236
zval_dtor(free_op1.var);
7238
ZEND_VM_NEXT_OPCODE();
7241
static int ZEND_FASTCALL ZEND_CONCAT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7243
zend_op *opline = EX(opline);
7244
zend_free_op free_op1;
7246
concat_function(&EX_T(opline->result.u.var).tmp_var,
7247
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
7248
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
7249
zval_dtor(free_op1.var);
7251
ZEND_VM_NEXT_OPCODE();
7254
static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7256
zend_op *opline = EX(opline);
7257
zend_free_op free_op1;
7259
is_identical_function(&EX_T(opline->result.u.var).tmp_var,
7260
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
7261
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
7262
zval_dtor(free_op1.var);
7264
ZEND_VM_NEXT_OPCODE();
7267
static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7269
zend_op *opline = EX(opline);
7270
zend_free_op free_op1;
7271
zval *result = &EX_T(opline->result.u.var).tmp_var;
7273
is_identical_function(result,
7274
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
7275
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
7276
Z_LVAL_P(result) = !Z_LVAL_P(result);
7277
zval_dtor(free_op1.var);
7279
ZEND_VM_NEXT_OPCODE();
7282
static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7284
zend_op *opline = EX(opline);
7285
zend_free_op free_op1;
7286
zval *result = &EX_T(opline->result.u.var).tmp_var;
7288
compare_function(result,
7289
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
7290
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
7291
ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
7292
zval_dtor(free_op1.var);
7294
ZEND_VM_NEXT_OPCODE();
7297
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7299
zend_op *opline = EX(opline);
7300
zend_free_op free_op1;
7301
zval *result = &EX_T(opline->result.u.var).tmp_var;
7303
compare_function(result,
7304
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
7305
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
7306
ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
7307
zval_dtor(free_op1.var);
7309
ZEND_VM_NEXT_OPCODE();
7312
static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7314
zend_op *opline = EX(opline);
7315
zend_free_op free_op1;
7316
zval *result = &EX_T(opline->result.u.var).tmp_var;
7318
compare_function(result,
7319
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
7320
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
7321
ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
7322
zval_dtor(free_op1.var);
7324
ZEND_VM_NEXT_OPCODE();
7327
static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7329
zend_op *opline = EX(opline);
7330
zend_free_op free_op1;
7331
zval *result = &EX_T(opline->result.u.var).tmp_var;
7333
compare_function(result,
7334
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
7335
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
7336
ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
7337
zval_dtor(free_op1.var);
7339
ZEND_VM_NEXT_OPCODE();
7342
static int ZEND_FASTCALL ZEND_BW_OR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7344
zend_op *opline = EX(opline);
7345
zend_free_op free_op1;
7347
bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
7348
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
7349
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
7350
zval_dtor(free_op1.var);
7352
ZEND_VM_NEXT_OPCODE();
7355
static int ZEND_FASTCALL ZEND_BW_AND_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7357
zend_op *opline = EX(opline);
7358
zend_free_op free_op1;
7360
bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
7361
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
7362
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
7363
zval_dtor(free_op1.var);
7365
ZEND_VM_NEXT_OPCODE();
7368
static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7370
zend_op *opline = EX(opline);
7371
zend_free_op free_op1;
7373
bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
7374
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
7375
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
7376
zval_dtor(free_op1.var);
7378
ZEND_VM_NEXT_OPCODE();
7381
static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7383
zend_op *opline = EX(opline);
7384
zend_free_op free_op1;
7386
boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
7387
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
7388
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
7389
zval_dtor(free_op1.var);
7391
ZEND_VM_NEXT_OPCODE();
7394
static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7396
zend_op *opline = EX(opline);
7398
zval *str = &EX_T(opline->result.u.var).tmp_var;
7399
zval *var = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
7403
if (IS_TMP_VAR == IS_UNUSED) {
7404
/* Initialize for erealloc in add_string_to_string */
7405
Z_STRVAL_P(str) = NULL;
7406
Z_STRLEN_P(str) = 0;
7407
Z_TYPE_P(str) = IS_STRING;
7412
if (Z_TYPE_P(var) != IS_STRING) {
7413
zend_make_printable_zval(var, &var_copy, &use_copy);
7419
add_string_to_string(str, str, var);
7424
/* original comment, possibly problematic:
7425
* FREE_OP is missing intentionally here - we're always working on the same temporary variable
7426
* (Zeev): I don't think it's problematic, we only use variables
7427
* which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
7428
* string offsets or overloaded objects
7431
ZEND_VM_NEXT_OPCODE();
7434
static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7436
zend_op *opline = EX(opline);
7437
zval *function_name;
7438
char *function_name_strval;
7439
int function_name_strlen;
7440
zend_free_op free_op1;
7442
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
7444
function_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
7446
if (Z_TYPE_P(function_name)!=IS_STRING) {
7447
zend_error_noreturn(E_ERROR, "Method name must be a string");
7450
function_name_strval = Z_STRVAL_P(function_name);
7451
function_name_strlen = Z_STRLEN_P(function_name);
7453
EX(object) = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7455
if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
7456
if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
7457
zend_error_noreturn(E_ERROR, "Object does not support method calls");
7460
/* First, locate the function. */
7461
EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
7463
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
7466
EX(called_scope) = Z_OBJCE_P(EX(object));
7468
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
7471
if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) {
7474
if (!PZVAL_IS_REF(EX(object))) {
7475
Z_ADDREF_P(EX(object)); /* For $this pointer */
7478
ALLOC_ZVAL(this_ptr);
7479
INIT_PZVAL_COPY(this_ptr, EX(object));
7480
zval_copy_ctor(this_ptr);
7481
EX(object) = this_ptr;
7486
ZEND_VM_NEXT_OPCODE();
7489
static int ZEND_FASTCALL ZEND_CASE_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7491
zend_op *opline = EX(opline);
7492
int switch_expr_is_overloaded=0;
7493
zend_free_op free_op1;
7495
if (IS_TMP_VAR==IS_VAR) {
7496
if (EX_T(opline->op1.u.var).var.ptr_ptr) {
7497
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
7499
switch_expr_is_overloaded = 1;
7500
Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
7503
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
7504
_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
7505
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
7507
if (switch_expr_is_overloaded) {
7508
/* We only free op1 if this is a string offset,
7509
* Since if it is a TMP_VAR, it'll be reused by
7510
* other CASE opcodes (whereas string offsets
7511
* are allocated at each get_zval_ptr())
7513
zval_dtor(free_op1.var);
7514
EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
7515
EX_T(opline->op1.u.var).var.ptr = NULL;
7517
ZEND_VM_NEXT_OPCODE();
7520
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7522
zend_op *opline = EX(opline);
7523
zend_free_op free_op1;
7524
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
7526
zval *offset=_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
7528
#if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
7529
zval **expr_ptr_ptr = NULL;
7531
if (opline->extended_value) {
7533
expr_ptr = *expr_ptr_ptr;
7535
expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7538
expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7541
if (1) { /* temporary variable */
7544
ALLOC_ZVAL(new_expr);
7545
INIT_PZVAL_COPY(new_expr, expr_ptr);
7546
expr_ptr = new_expr;
7548
#if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
7549
if (opline->extended_value) {
7550
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
7551
expr_ptr = *expr_ptr_ptr;
7552
Z_ADDREF_P(expr_ptr);
7555
if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
7558
ALLOC_ZVAL(new_expr);
7559
INIT_PZVAL_COPY(new_expr, expr_ptr);
7560
expr_ptr = new_expr;
7561
zendi_zval_copy_ctor(*expr_ptr);
7563
Z_ADDREF_P(expr_ptr);
7567
switch (Z_TYPE_P(offset)) {
7569
zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
7573
zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
7576
zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
7579
zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
7582
zend_error(E_WARNING, "Illegal offset type");
7583
zval_ptr_dtor(&expr_ptr);
7589
zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
7591
if (opline->extended_value) {
7596
ZEND_VM_NEXT_OPCODE();
7599
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7601
zend_op *opline = EX(opline);
7603
array_init(&EX_T(opline->result.u.var).tmp_var);
7604
if (IS_TMP_VAR == IS_UNUSED) {
7605
ZEND_VM_NEXT_OPCODE();
7606
#if 0 || IS_TMP_VAR != IS_UNUSED
7608
return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7613
static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7615
zend_op *opline = EX(opline);
7616
zend_free_op free_op1;
7618
bitwise_not_function(&EX_T(opline->result.u.var).tmp_var,
7619
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) TSRMLS_CC);
7620
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7621
ZEND_VM_NEXT_OPCODE();
7624
static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7626
zend_op *opline = EX(opline);
7627
zend_free_op free_op1;
7629
boolean_not_function(&EX_T(opline->result.u.var).tmp_var,
7630
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) TSRMLS_CC);
7631
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7632
ZEND_VM_NEXT_OPCODE();
7635
static int ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7637
zend_op *opline = EX(opline);
7638
zend_free_op free_op1;
7639
zval **var_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7641
if (IS_VAR == IS_VAR && !var_ptr) {
7642
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
7644
if (IS_VAR == IS_VAR && *var_ptr == EG(error_zval_ptr)) {
7645
if (!RETURN_VALUE_UNUSED(&opline->result)) {
7646
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
7647
PZVAL_LOCK(EG(uninitialized_zval_ptr));
7649
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7650
ZEND_VM_NEXT_OPCODE();
7653
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
7655
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
7656
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
7658
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
7660
increment_function(val);
7661
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
7662
zval_ptr_dtor(&val);
7664
increment_function(*var_ptr);
7667
if (!RETURN_VALUE_UNUSED(&opline->result)) {
7668
AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
7669
PZVAL_LOCK(*var_ptr);
7672
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7673
ZEND_VM_NEXT_OPCODE();
7676
static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7678
zend_op *opline = EX(opline);
7679
zend_free_op free_op1;
7680
zval **var_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7682
if (IS_VAR == IS_VAR && !var_ptr) {
7683
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
7685
if (IS_VAR == IS_VAR && *var_ptr == EG(error_zval_ptr)) {
7686
if (!RETURN_VALUE_UNUSED(&opline->result)) {
7687
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
7688
PZVAL_LOCK(EG(uninitialized_zval_ptr));
7690
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7691
ZEND_VM_NEXT_OPCODE();
7694
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
7696
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
7697
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
7699
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
7701
decrement_function(val);
7702
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
7703
zval_ptr_dtor(&val);
7705
decrement_function(*var_ptr);
7708
if (!RETURN_VALUE_UNUSED(&opline->result)) {
7709
AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
7710
PZVAL_LOCK(*var_ptr);
7713
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7714
ZEND_VM_NEXT_OPCODE();
7717
static int ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7719
zend_op *opline = EX(opline);
7720
zend_free_op free_op1;
7721
zval **var_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7723
if (IS_VAR == IS_VAR && !var_ptr) {
7724
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
7726
if (IS_VAR == IS_VAR && *var_ptr == EG(error_zval_ptr)) {
7727
if (!RETURN_VALUE_UNUSED(&opline->result)) {
7728
EX_T(opline->result.u.var).tmp_var = *EG(uninitialized_zval_ptr);
7730
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7731
ZEND_VM_NEXT_OPCODE();
7734
EX_T(opline->result.u.var).tmp_var = **var_ptr;
7735
zendi_zval_copy_ctor(EX_T(opline->result.u.var).tmp_var);
7737
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
7739
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
7740
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
7742
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
7744
increment_function(val);
7745
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
7746
zval_ptr_dtor(&val);
7748
increment_function(*var_ptr);
7751
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7752
ZEND_VM_NEXT_OPCODE();
7755
static int ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7757
zend_op *opline = EX(opline);
7758
zend_free_op free_op1;
7759
zval **var_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7761
if (IS_VAR == IS_VAR && !var_ptr) {
7762
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
7764
if (IS_VAR == IS_VAR && *var_ptr == EG(error_zval_ptr)) {
7765
if (!RETURN_VALUE_UNUSED(&opline->result)) {
7766
EX_T(opline->result.u.var).tmp_var = *EG(uninitialized_zval_ptr);
7768
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7769
ZEND_VM_NEXT_OPCODE();
7772
EX_T(opline->result.u.var).tmp_var = **var_ptr;
7773
zendi_zval_copy_ctor(EX_T(opline->result.u.var).tmp_var);
7775
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
7777
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
7778
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
7780
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
7782
decrement_function(val);
7783
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
7784
zval_ptr_dtor(&val);
7786
decrement_function(*var_ptr);
7789
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7790
ZEND_VM_NEXT_OPCODE();
7793
static int ZEND_FASTCALL ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7795
zend_op *opline = EX(opline);
7796
zend_free_op free_op1;
7798
zval *z = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7800
if (IS_VAR != IS_CONST &&
7801
Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get_method != NULL &&
7802
zend_std_cast_object_tostring(z, &z_copy, IS_STRING TSRMLS_CC) == SUCCESS) {
7803
zend_print_variable(&z_copy);
7806
zend_print_variable(z);
7809
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7810
ZEND_VM_NEXT_OPCODE();
7813
static int ZEND_FASTCALL ZEND_PRINT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7815
zend_op *opline = EX(opline);
7817
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
7818
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_LONG;
7820
return ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7823
static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
7825
zend_op *opline = EX(opline);
7826
zend_free_op free_op1;
7827
zval *varname = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7830
HashTable *target_symbol_table;
7832
if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
7833
tmp_varname = *varname;
7834
zval_copy_ctor(&tmp_varname);
7835
convert_to_string(&tmp_varname);
7836
varname = &tmp_varname;
7839
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
7840
retval = zend_std_get_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0 TSRMLS_CC);
7842
target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), type, varname TSRMLS_CC);
7844
if (!target_symbol_table) {
7845
ZEND_VM_NEXT_OPCODE();
7848
if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &retval) == FAILURE) {
7852
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
7853
/* break missing intentionally */
7855
retval = &EG(uninitialized_zval_ptr);
7858
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
7859
/* break missing intentionally */
7861
zval *new_zval = &EG(uninitialized_zval);
7863
Z_ADDREF_P(new_zval);
7864
zend_hash_update(target_symbol_table, varname->value.str.val, varname->value.str.len+1, &new_zval, sizeof(zval *), (void **) &retval);
7867
EMPTY_SWITCH_DEFAULT_CASE()
7870
switch (opline->op2.u.EA.type) {
7871
case ZEND_FETCH_GLOBAL:
7872
if (IS_VAR != IS_TMP_VAR) {
7873
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7876
case ZEND_FETCH_LOCAL:
7877
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7879
case ZEND_FETCH_STATIC:
7880
zval_update_constant(retval, (void*) 1 TSRMLS_CC);
7882
case ZEND_FETCH_GLOBAL_LOCK:
7883
if (IS_VAR == IS_VAR && !free_op1.var) {
7884
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
7891
if (IS_VAR != IS_CONST && varname == &tmp_varname) {
7894
if (!RETURN_VALUE_UNUSED(&opline->result)) {
7895
if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
7896
SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
7898
PZVAL_LOCK(*retval);
7902
AI_SET_PTR(EX_T(opline->result.u.var).var, *retval);
7904
case BP_VAR_UNSET: {
7905
zend_free_op free_res;
7907
EX_T(opline->result.u.var).var.ptr_ptr = retval;
7908
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
7909
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
7910
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
7912
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
7913
FREE_OP_VAR_PTR(free_res);
7916
EX_T(opline->result.u.var).var.ptr_ptr = retval;
7921
ZEND_VM_NEXT_OPCODE();
7924
static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7926
return zend_fetch_var_address_helper_SPEC_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7929
static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7931
return zend_fetch_var_address_helper_SPEC_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7934
static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7936
return zend_fetch_var_address_helper_SPEC_VAR(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7939
static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7941
return zend_fetch_var_address_helper_SPEC_VAR(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), EX(opline)->extended_value)?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7944
static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7946
return zend_fetch_var_address_helper_SPEC_VAR(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7949
static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7951
return zend_fetch_var_address_helper_SPEC_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7954
static int ZEND_FASTCALL ZEND_JMPZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7956
zend_op *opline = EX(opline);
7957
zend_free_op free_op1;
7958
zval *val = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7961
if (IS_VAR == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
7962
ret = Z_LVAL_P(val);
7964
ret = i_zend_is_true(val);
7965
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7966
if (UNEXPECTED(EG(exception) != NULL)) {
7972
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
7974
ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
7978
ZEND_VM_NEXT_OPCODE();
7981
static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7983
zend_op *opline = EX(opline);
7984
zend_free_op free_op1;
7985
zval *val = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7988
if (IS_VAR == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
7989
ret = Z_LVAL_P(val);
7991
ret = i_zend_is_true(val);
7992
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7993
if (UNEXPECTED(EG(exception) != NULL)) {
7999
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
8001
ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
8005
ZEND_VM_NEXT_OPCODE();
8008
static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8010
zend_op *opline = EX(opline);
8011
zend_free_op free_op1;
8012
zval *val = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8015
if (IS_VAR == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
8016
retval = Z_LVAL_P(val);
8018
retval = i_zend_is_true(val);
8019
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8020
if (UNEXPECTED(EG(exception) != NULL)) {
8024
if (EXPECTED(retval != 0)) {
8026
printf("Conditional jmp on true to %d\n", opline->extended_value);
8028
ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
8029
ZEND_VM_CONTINUE(); /* CHECK_ME */
8032
printf("Conditional jmp on false to %d\n", opline->op2.u.opline_num);
8034
ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.u.opline_num]);
8035
ZEND_VM_CONTINUE(); /* CHECK_ME */
8039
static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8041
zend_op *opline = EX(opline);
8042
zend_free_op free_op1;
8043
zval *val = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8046
if (IS_VAR == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
8047
retval = Z_LVAL_P(val);
8049
retval = i_zend_is_true(val);
8050
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8051
if (UNEXPECTED(EG(exception) != NULL)) {
8055
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
8056
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
8059
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
8061
ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
8064
ZEND_VM_NEXT_OPCODE();
8067
static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8069
zend_op *opline = EX(opline);
8070
zend_free_op free_op1;
8071
zval *val = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8074
if (IS_VAR == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
8075
retval = Z_LVAL_P(val);
8077
retval = i_zend_is_true(val);
8078
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8079
if (UNEXPECTED(EG(exception) != NULL)) {
8083
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
8084
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
8087
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
8089
ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
8092
ZEND_VM_NEXT_OPCODE();
8095
static int ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8097
zend_op *opline = EX(opline);
8099
zval **retval_ptr_ptr;
8100
zend_free_op free_op1;
8102
if (EG(active_op_array)->return_reference == ZEND_RETURN_REF) {
8104
if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
8105
/* Not supposed to happen, but we'll allow it */
8106
zend_error(E_NOTICE, "Only variable references should be returned by reference");
8107
goto return_by_value;
8110
retval_ptr_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8112
if (IS_VAR == IS_VAR && !retval_ptr_ptr) {
8113
zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
8116
if (IS_VAR == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
8117
if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
8118
EX_T(opline->op1.u.var).var.fcall_returned_reference) {
8119
} else if (EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
8120
if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
8121
PZVAL_LOCK(*retval_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
8123
zend_error(E_NOTICE, "Only variable references should be returned by reference");
8124
goto return_by_value;
8128
if (EG(return_value_ptr_ptr)) {
8129
SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
8130
Z_ADDREF_PP(retval_ptr_ptr);
8132
(*EG(return_value_ptr_ptr)) = (*retval_ptr_ptr);
8137
retval_ptr = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8139
if (!EG(return_value_ptr_ptr)) {
8140
if (IS_VAR == IS_TMP_VAR) {
8141
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8143
} else if (!0) { /* Not a temp var */
8144
if (IS_VAR == IS_CONST ||
8145
EG(active_op_array)->return_reference == ZEND_RETURN_REF ||
8146
(PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
8150
INIT_PZVAL_COPY(ret, retval_ptr);
8151
zval_copy_ctor(ret);
8152
*EG(return_value_ptr_ptr) = ret;
8154
*EG(return_value_ptr_ptr) = retval_ptr;
8155
Z_ADDREF_P(retval_ptr);
8161
INIT_PZVAL_COPY(ret, retval_ptr);
8162
*EG(return_value_ptr_ptr) = ret;
8165
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8166
return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8169
static int ZEND_FASTCALL ZEND_THROW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8171
zend_op *opline = EX(opline);
8174
zend_free_op free_op1;
8176
value = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8178
if (IS_VAR == IS_CONST || Z_TYPE_P(value) != IS_OBJECT) {
8179
zend_error_noreturn(E_ERROR, "Can only throw objects");
8181
zend_exception_save(TSRMLS_C);
8182
/* Not sure if a complete copy is what we want here */
8183
ALLOC_ZVAL(exception);
8184
INIT_PZVAL_COPY(exception, value);
8186
zval_copy_ctor(exception);
8189
zend_throw_exception_object(exception TSRMLS_CC);
8190
zend_exception_restore(TSRMLS_C);
8191
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8192
ZEND_VM_NEXT_OPCODE();
8195
static int ZEND_FASTCALL ZEND_SEND_VAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8197
zend_op *opline = EX(opline);
8198
if (opline->extended_value==ZEND_DO_FCALL_BY_NAME
8199
&& ARG_MUST_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
8200
zend_error_noreturn(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.u.opline_num);
8205
zend_free_op free_op1;
8207
value = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8210
INIT_PZVAL_COPY(valptr, value);
8212
zval_copy_ctor(valptr);
8214
zend_vm_stack_push(valptr TSRMLS_CC);
8215
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8217
ZEND_VM_NEXT_OPCODE();
8220
static int ZEND_FASTCALL zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
8222
zend_op *opline = EX(opline);
8224
zend_free_op free_op1;
8225
varptr = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8227
if (varptr == &EG(uninitialized_zval)) {
8230
Z_SET_REFCOUNT_P(varptr, 0);
8231
} else if (PZVAL_IS_REF(varptr)) {
8232
zval *original_var = varptr;
8235
*varptr = *original_var;
8236
Z_UNSET_ISREF_P(varptr);
8237
Z_SET_REFCOUNT_P(varptr, 0);
8238
zval_copy_ctor(varptr);
8241
zend_vm_stack_push(varptr TSRMLS_CC);
8242
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; /* for string offsets */
8244
ZEND_VM_NEXT_OPCODE();
8247
static int ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8249
zend_op *opline = EX(opline);
8250
zend_free_op free_op1;
8253
if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */
8254
if (!(opline->extended_value & ZEND_ARG_SEND_BY_REF)) {
8255
return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8257
} else if (!ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
8258
return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8261
if (IS_VAR == IS_VAR &&
8262
(opline->extended_value & ZEND_ARG_SEND_FUNCTION) &&
8263
EX_T(opline->op1.u.var).var.fcall_returned_reference &&
8264
EX_T(opline->op1.u.var).var.ptr) {
8265
varptr = EX_T(opline->op1.u.var).var.ptr;
8266
PZVAL_UNLOCK_EX(varptr, &free_op1, 0);
8268
varptr = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8270
if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
8271
EX_T(opline->op1.u.var).var.fcall_returned_reference) &&
8272
varptr != &EG(uninitialized_zval) &&
8273
(PZVAL_IS_REF(varptr) ||
8274
(Z_REFCOUNT_P(varptr) == 1 && (IS_VAR == IS_CV || free_op1.var)))) {
8275
Z_SET_ISREF_P(varptr);
8277
zend_vm_stack_push(varptr TSRMLS_CC);
8281
if (!(opline->extended_value & ZEND_ARG_SEND_SILENT)) {
8282
zend_error(E_STRICT, "Only variables should be passed by reference");
8285
INIT_PZVAL_COPY(valptr, varptr);
8287
zval_copy_ctor(valptr);
8289
zend_vm_stack_push(valptr TSRMLS_CC);
8291
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8292
ZEND_VM_NEXT_OPCODE();
8295
static int ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8297
zend_op *opline = EX(opline);
8298
zend_free_op free_op1;
8301
varptr_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8303
if (IS_VAR == IS_VAR && !varptr_ptr) {
8304
zend_error_noreturn(E_ERROR, "Only variables can be passed by reference");
8307
SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr);
8308
varptr = *varptr_ptr;
8310
zend_vm_stack_push(varptr TSRMLS_CC);
8312
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8313
ZEND_VM_NEXT_OPCODE();
8316
static int ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8318
zend_op *opline = EX(opline);
8320
if ((opline->extended_value == ZEND_DO_FCALL_BY_NAME)
8321
&& ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
8322
return ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8324
return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8327
static int ZEND_FASTCALL ZEND_BOOL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8329
zend_op *opline = EX(opline);
8330
zend_free_op free_op1;
8332
/* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
8333
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = i_zend_is_true(_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC));
8334
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
8335
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8337
ZEND_VM_NEXT_OPCODE();
8340
static int ZEND_FASTCALL ZEND_SWITCH_FREE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8342
zend_op *opline = EX(opline);
8344
zend_switch_free(&EX_T(opline->op1.u.var), opline->extended_value TSRMLS_CC);
8345
ZEND_VM_NEXT_OPCODE();
8348
static int ZEND_FASTCALL ZEND_CLONE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8350
zend_op *opline = EX(opline);
8351
zend_free_op free_op1;
8352
zval *obj = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8353
zend_class_entry *ce;
8354
zend_function *clone;
8355
zend_object_clone_obj_t clone_call;
8357
if (IS_VAR == IS_CONST ||
8358
(IS_VAR == IS_VAR && !obj) ||
8359
Z_TYPE_P(obj) != IS_OBJECT) {
8360
zend_error_noreturn(E_ERROR, "__clone method called on non-object");
8363
ce = Z_OBJCE_P(obj);
8364
clone = ce ? ce->clone : NULL;
8365
clone_call = Z_OBJ_HT_P(obj)->clone_obj;
8368
zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
8370
zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
8375
if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
8376
/* Ensure that if we're calling a private function, we're allowed to do so.
8378
if (ce != EG(scope)) {
8379
zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
8381
} else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
8382
/* Ensure that if we're calling a protected function, we're allowed to do so.
8384
if (!zend_check_protected(clone->common.scope, EG(scope))) {
8385
zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
8390
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
8391
if (!EG(exception)) {
8392
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
8393
Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC);
8394
Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
8395
Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
8396
Z_SET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
8397
if (!RETURN_VALUE_USED(opline) || EG(exception)) {
8398
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
8401
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8402
ZEND_VM_NEXT_OPCODE();
8405
static int ZEND_FASTCALL ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8407
zend_op *opline = EX(opline);
8408
zend_free_op free_op1;
8409
zval *expr = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8410
zval *result = &EX_T(opline->result.u.var).tmp_var;
8412
if (opline->extended_value != IS_STRING) {
8415
zendi_zval_copy_ctor(*result);
8418
switch (opline->extended_value) {
8420
convert_to_null(result);
8423
convert_to_boolean(result);
8426
convert_to_long(result);
8429
convert_to_double(result);
8435
zend_make_printable_zval(expr, &var_copy, &use_copy);
8439
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8444
zendi_zval_copy_ctor(*result);
8450
convert_to_array(result);
8453
convert_to_object(result);
8456
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8457
ZEND_VM_NEXT_OPCODE();
8460
static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8462
zend_op *opline = EX(opline);
8463
zend_op_array *new_op_array=NULL;
8464
int return_value_used;
8465
zend_free_op free_op1;
8466
zval *inc_filename = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8467
zval tmp_inc_filename;
8468
zend_bool failure_retval=0;
8470
if (inc_filename->type!=IS_STRING) {
8471
tmp_inc_filename = *inc_filename;
8472
zval_copy_ctor(&tmp_inc_filename);
8473
convert_to_string(&tmp_inc_filename);
8474
inc_filename = &tmp_inc_filename;
8477
return_value_used = RETURN_VALUE_USED(opline);
8479
switch (Z_LVAL(opline->op2.u.constant)) {
8480
case ZEND_INCLUDE_ONCE:
8481
case ZEND_REQUIRE_ONCE: {
8482
zend_file_handle file_handle;
8483
char *resolved_path;
8485
resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
8486
if (resolved_path) {
8487
failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
8489
resolved_path = Z_STRVAL_P(inc_filename);
8492
if (failure_retval) {
8493
/* do nothing, file already included */
8494
} else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) {
8496
if (!file_handle.opened_path) {
8497
file_handle.opened_path = estrdup(resolved_path);
8500
if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
8501
new_op_array = zend_compile_file(&file_handle, (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
8502
zend_destroy_file_handle(&file_handle TSRMLS_CC);
8504
zend_file_handle_dtor(&file_handle TSRMLS_CC);
8508
if (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE) {
8509
zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
8511
zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
8514
if (resolved_path != Z_STRVAL_P(inc_filename)) {
8515
efree(resolved_path);
8521
new_op_array = compile_filename(Z_LVAL(opline->op2.u.constant), inc_filename TSRMLS_CC);
8524
char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
8526
new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
8530
EMPTY_SWITCH_DEFAULT_CASE()
8532
if (inc_filename==&tmp_inc_filename) {
8533
zval_dtor(&tmp_inc_filename);
8535
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8536
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
8537
if (new_op_array && !EG(exception)) {
8538
EX(original_return_value) = EG(return_value_ptr_ptr);
8539
EG(return_value_ptr_ptr) = return_value_used ? EX_T(opline->result.u.var).var.ptr_ptr : NULL;
8540
EG(active_op_array) = new_op_array;
8541
EX_T(opline->result.u.var).var.ptr = NULL;
8543
EX(current_object) = EX(object);
8545
EX(function_state).function = (zend_function *) new_op_array;
8548
if (!EG(active_symbol_table)) {
8549
zend_rebuild_symbol_table(TSRMLS_C);
8552
if (zend_execute == execute) {
8553
EX(call_opline) = opline;
8556
zend_execute(new_op_array TSRMLS_CC);
8559
EX(function_state).function = (zend_function *) EX(op_array);
8560
EX(object) = EX(current_object);
8562
if (return_value_used) {
8563
if (!EX_T(opline->result.u.var).var.ptr) { /* there was no return statement */
8564
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
8565
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
8566
Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = 1;
8567
Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
8571
EG(opline_ptr) = &EX(opline);
8572
EG(active_op_array) = EX(op_array);
8573
EG(return_value_ptr_ptr) = EX(original_return_value);
8574
destroy_op_array(new_op_array TSRMLS_CC);
8575
efree(new_op_array);
8576
if (EG(exception)) {
8577
zend_throw_exception_internal(NULL TSRMLS_CC);
8580
if (return_value_used) {
8581
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
8582
INIT_ZVAL(*EX_T(opline->result.u.var).var.ptr);
8583
Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = failure_retval;
8584
Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
8587
ZEND_VM_NEXT_OPCODE();
8590
static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8592
zend_op *opline = EX(opline);
8594
HashTable *target_symbol_table;
8595
zend_free_op free_op1;
8597
if (IS_VAR == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
8598
if (EG(active_symbol_table)) {
8599
zend_execute_data *ex = EX(prev_execute_data);
8600
zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.u.var);
8602
if (zend_hash_quick_del(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value) == SUCCESS) {
8603
while (ex && ex->symbol_table == EG(active_symbol_table)) {
8607
for (i = 0; i < ex->op_array->last_var; i++) {
8608
if (ex->op_array->vars[i].hash_value == cv->hash_value &&
8609
ex->op_array->vars[i].name_len == cv->name_len &&
8610
!memcmp(ex->op_array->vars[i].name, cv->name, cv->name_len)) {
8616
ex = ex->prev_execute_data;
8619
EX(CVs)[opline->op1.u.var] = NULL;
8620
} else if (EX(CVs)[opline->op1.u.var]) {
8621
zval_ptr_dtor(EX(CVs)[opline->op1.u.var]);
8622
EX(CVs)[opline->op1.u.var] = NULL;
8624
ZEND_VM_NEXT_OPCODE();
8627
varname = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8629
if (Z_TYPE_P(varname) != IS_STRING) {
8631
zval_copy_ctor(&tmp);
8632
convert_to_string(&tmp);
8634
} else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
8635
Z_ADDREF_P(varname);
8638
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
8639
zend_std_unset_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname) TSRMLS_CC);
8641
ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
8643
target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
8644
if (zend_hash_quick_del(target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value) == SUCCESS) {
8645
zend_execute_data *ex = execute_data;
8651
for (i = 0; i < ex->op_array->last_var; i++) {
8652
if (ex->op_array->vars[i].hash_value == hash_value &&
8653
ex->op_array->vars[i].name_len == varname->value.str.len &&
8654
!memcmp(ex->op_array->vars[i].name, varname->value.str.val, varname->value.str.len)) {
8660
ex = ex->prev_execute_data;
8661
} while (ex && ex->symbol_table == target_symbol_table);
8665
if (varname == &tmp) {
8667
} else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
8668
zval_ptr_dtor(&varname);
8670
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8671
ZEND_VM_NEXT_OPCODE();
8674
static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8676
zend_op *opline = EX(opline);
8677
zend_free_op free_op1;
8678
zval *array_ptr, **array_ptr_ptr;
8680
zend_object_iterator *iter = NULL;
8681
zend_class_entry *ce = NULL;
8682
zend_bool is_empty = 0;
8684
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
8685
array_ptr_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8686
if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
8687
ALLOC_INIT_ZVAL(array_ptr);
8688
} else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
8689
if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
8690
zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class");
8691
ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
8694
ce = Z_OBJCE_PP(array_ptr_ptr);
8695
if (!ce || ce->get_iterator == NULL) {
8696
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
8697
Z_ADDREF_PP(array_ptr_ptr);
8699
array_ptr = *array_ptr_ptr;
8701
if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
8702
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
8703
if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
8704
Z_SET_ISREF_PP(array_ptr_ptr);
8707
array_ptr = *array_ptr_ptr;
8708
Z_ADDREF_P(array_ptr);
8711
array_ptr = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8712
if (0) { /* IS_TMP_VAR */
8716
INIT_PZVAL_COPY(tmp, array_ptr);
8718
} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
8719
ce = Z_OBJCE_P(array_ptr);
8720
if (!ce || !ce->get_iterator) {
8721
Z_ADDREF_P(array_ptr);
8724
if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) &&
8725
!Z_ISREF_P(array_ptr) &&
8726
Z_REFCOUNT_P(array_ptr) > 1) {
8730
INIT_PZVAL_COPY(tmp, array_ptr);
8731
zval_copy_ctor(tmp);
8734
Z_ADDREF_P(array_ptr);
8739
if (IS_VAR != IS_TMP_VAR && ce && ce->get_iterator) {
8740
iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC);
8742
if (iter && !EG(exception)) {
8743
array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
8745
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
8746
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8748
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8750
if (!EG(exception)) {
8751
zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
8753
zend_throw_exception_internal(NULL TSRMLS_CC);
8754
ZEND_VM_NEXT_OPCODE();
8758
AI_SET_PTR(EX_T(opline->result.u.var).var, array_ptr);
8759
PZVAL_LOCK(array_ptr);
8763
if (iter->funcs->rewind) {
8764
iter->funcs->rewind(iter TSRMLS_CC);
8765
if (EG(exception)) {
8766
Z_DELREF_P(array_ptr);
8767
zval_ptr_dtor(&array_ptr);
8768
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
8769
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8771
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8773
ZEND_VM_NEXT_OPCODE();
8776
is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
8777
if (EG(exception)) {
8778
Z_DELREF_P(array_ptr);
8779
zval_ptr_dtor(&array_ptr);
8780
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
8781
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8783
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8785
ZEND_VM_NEXT_OPCODE();
8787
iter->index = -1; /* will be set to 0 before using next handler */
8788
} else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
8789
zend_hash_internal_pointer_reset(fe_ht);
8791
zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
8792
while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
8796
zend_uchar key_type;
8798
key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
8799
if (key_type != HASH_KEY_NON_EXISTANT &&
8800
(key_type == HASH_KEY_IS_LONG ||
8801
zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
8804
zend_hash_move_forward(fe_ht);
8807
is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
8808
zend_hash_get_pointer(fe_ht, &EX_T(opline->result.u.var).fe.fe_pos);
8810
zend_error(E_WARNING, "Invalid argument supplied for foreach()");
8814
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
8815
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8817
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8820
ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
8822
ZEND_VM_NEXT_OPCODE();
8826
static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8828
zend_op *opline = EX(opline);
8829
zend_free_op free_op1;
8830
zval *array = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8836
zend_object_iterator *iter = NULL;
8838
zend_bool use_key = (zend_bool)(opline->extended_value & ZEND_FE_FETCH_WITH_KEY);
8842
switch (zend_iterator_unwrap(array, &iter TSRMLS_CC)) {
8844
case ZEND_ITER_INVALID:
8845
zend_error(E_WARNING, "Invalid argument supplied for foreach()");
8846
ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
8848
case ZEND_ITER_PLAIN_OBJECT: {
8849
char *class_name, *prop_name;
8850
zend_object *zobj = zend_objects_get_address(array TSRMLS_CC);
8852
fe_ht = HASH_OF(array);
8853
zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.u.var).fe.fe_pos);
8855
if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) {
8856
/* reached end of iteration */
8857
ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
8859
key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
8861
zend_hash_move_forward(fe_ht);
8862
} while (key_type == HASH_KEY_NON_EXISTANT ||
8863
(key_type != HASH_KEY_IS_LONG &&
8864
zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) != SUCCESS));
8865
zend_hash_get_pointer(fe_ht, &EX_T(opline->op1.u.var).fe.fe_pos);
8866
if (use_key && key_type != HASH_KEY_IS_LONG) {
8867
zend_unmangle_property_name(str_key, str_key_len-1, &class_name, &prop_name);
8868
str_key_len = strlen(prop_name);
8869
str_key = estrndup(prop_name, str_key_len);
8875
case ZEND_ITER_PLAIN_ARRAY:
8876
fe_ht = HASH_OF(array);
8877
zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.u.var).fe.fe_pos);
8878
if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) {
8879
/* reached end of iteration */
8880
ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
8883
key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 1, NULL);
8885
zend_hash_move_forward(fe_ht);
8886
zend_hash_get_pointer(fe_ht, &EX_T(opline->op1.u.var).fe.fe_pos);
8889
case ZEND_ITER_OBJECT:
8890
/* !iter happens from exception */
8891
if (iter && ++iter->index > 0) {
8892
/* This could cause an endless loop if index becomes zero again.
8893
* In case that ever happens we need an additional flag. */
8894
iter->funcs->move_forward(iter TSRMLS_CC);
8895
if (EG(exception)) {
8897
zval_ptr_dtor(&array);
8898
ZEND_VM_NEXT_OPCODE();
8901
/* If index is zero we come from FE_RESET and checked valid() already. */
8902
if (!iter || (iter->index > 0 && iter->funcs->valid(iter TSRMLS_CC) == FAILURE)) {
8903
/* reached end of iteration */
8904
if (EG(exception)) {
8906
zval_ptr_dtor(&array);
8907
ZEND_VM_NEXT_OPCODE();
8909
ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
8911
iter->funcs->get_current_data(iter, &value TSRMLS_CC);
8912
if (EG(exception)) {
8914
zval_ptr_dtor(&array);
8915
ZEND_VM_NEXT_OPCODE();
8918
/* failure in get_current_data */
8919
ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
8922
if (iter->funcs->get_current_key) {
8923
key_type = iter->funcs->get_current_key(iter, &str_key, &str_key_len, &int_key TSRMLS_CC);
8924
if (EG(exception)) {
8926
zval_ptr_dtor(&array);
8927
ZEND_VM_NEXT_OPCODE();
8930
key_type = HASH_KEY_IS_LONG;
8931
int_key = iter->index;
8937
if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
8938
SEPARATE_ZVAL_IF_NOT_REF(value);
8939
Z_SET_ISREF_PP(value);
8940
EX_T(opline->result.u.var).var.ptr_ptr = value;
8943
AI_SET_PTR(EX_T(opline->result.u.var).var, *value);
8948
zend_op *op_data = opline+1;
8949
zval *key = &EX_T(op_data->result.u.var).tmp_var;
8952
case HASH_KEY_IS_STRING:
8953
Z_STRVAL_P(key) = str_key;
8954
Z_STRLEN_P(key) = str_key_len-1;
8955
Z_TYPE_P(key) = IS_STRING;
8957
case HASH_KEY_IS_LONG:
8958
Z_LVAL_P(key) = int_key;
8959
Z_TYPE_P(key) = IS_LONG;
8962
case HASH_KEY_NON_EXISTANT:
8968
ZEND_VM_INC_OPCODE();
8969
ZEND_VM_NEXT_OPCODE();
8972
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8974
zend_op *opline = EX(opline);
8976
zend_bool isset = 1;
8978
if (IS_VAR == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
8979
if (EX(CVs)[opline->op1.u.var]) {
8980
value = EX(CVs)[opline->op1.u.var];
8981
} else if (EG(active_symbol_table)) {
8982
zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.u.var);
8984
if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
8991
HashTable *target_symbol_table;
8992
zend_free_op free_op1;
8993
zval tmp, *varname = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8995
if (Z_TYPE_P(varname) != IS_STRING) {
8997
zval_copy_ctor(&tmp);
8998
convert_to_string(&tmp);
9002
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
9003
value = zend_std_get_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1 TSRMLS_CC);
9008
target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
9009
if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
9014
if (varname == &tmp) {
9017
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9020
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
9022
switch (opline->extended_value & ZEND_ISSET_ISEMPTY_MASK) {
9024
if (isset && Z_TYPE_PP(value) == IS_NULL) {
9025
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
9027
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = isset;
9031
if (!isset || !i_zend_is_true(*value)) {
9032
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
9034
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
9039
ZEND_VM_NEXT_OPCODE();
9042
static int ZEND_FASTCALL ZEND_EXIT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9044
#if 0 || (IS_VAR != IS_UNUSED)
9045
zend_op *opline = EX(opline);
9046
if (IS_VAR != IS_UNUSED) {
9047
zend_free_op free_op1;
9048
zval *ptr = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9050
if (Z_TYPE_P(ptr) == IS_LONG) {
9051
EG(exit_status) = Z_LVAL_P(ptr);
9053
zend_print_variable(ptr);
9055
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9059
ZEND_VM_NEXT_OPCODE();
9062
static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9064
zend_op *opline = EX(opline);
9065
zend_free_op free_op1;
9066
zval *value = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9068
if (i_zend_is_true(value)) {
9069
EX_T(opline->result.u.var).tmp_var = *value;
9070
zendi_zval_copy_ctor(EX_T(opline->result.u.var).tmp_var);
9071
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9073
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
9075
ZEND_VM_JMP(opline->op2.u.jmp_addr);
9078
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9079
ZEND_VM_NEXT_OPCODE();
9082
static int ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9084
zend_op *opline = EX(opline);
9085
zend_free_op free_op1;
9086
zval *value = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9088
EX_T(opline->result.u.var).tmp_var = *value;
9090
zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
9092
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9093
ZEND_VM_NEXT_OPCODE();
9096
static int ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9098
zend_op *opline = EX(opline);
9099
zend_free_op free_op1;
9100
zval *expr = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9103
if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) {
9104
result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.u.var).class_entry TSRMLS_CC);
9108
ZVAL_BOOL(&EX_T(opline->result.u.var).tmp_var, result);
9109
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9110
ZEND_VM_NEXT_OPCODE();
9113
static int ZEND_FASTCALL ZEND_ADD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9115
zend_op *opline = EX(opline);
9116
zend_free_op free_op1;
9118
add_function(&EX_T(opline->result.u.var).tmp_var,
9119
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9120
&opline->op2.u.constant TSRMLS_CC);
9121
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9123
ZEND_VM_NEXT_OPCODE();
9126
static int ZEND_FASTCALL ZEND_SUB_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9128
zend_op *opline = EX(opline);
9129
zend_free_op free_op1;
9131
sub_function(&EX_T(opline->result.u.var).tmp_var,
9132
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9133
&opline->op2.u.constant TSRMLS_CC);
9134
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9136
ZEND_VM_NEXT_OPCODE();
9139
static int ZEND_FASTCALL ZEND_MUL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9141
zend_op *opline = EX(opline);
9142
zend_free_op free_op1;
9144
mul_function(&EX_T(opline->result.u.var).tmp_var,
9145
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9146
&opline->op2.u.constant TSRMLS_CC);
9147
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9149
ZEND_VM_NEXT_OPCODE();
9152
static int ZEND_FASTCALL ZEND_DIV_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9154
zend_op *opline = EX(opline);
9155
zend_free_op free_op1;
9157
div_function(&EX_T(opline->result.u.var).tmp_var,
9158
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9159
&opline->op2.u.constant TSRMLS_CC);
9160
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9162
ZEND_VM_NEXT_OPCODE();
9165
static int ZEND_FASTCALL ZEND_MOD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9167
zend_op *opline = EX(opline);
9168
zend_free_op free_op1;
9170
mod_function(&EX_T(opline->result.u.var).tmp_var,
9171
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9172
&opline->op2.u.constant TSRMLS_CC);
9173
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9175
ZEND_VM_NEXT_OPCODE();
9178
static int ZEND_FASTCALL ZEND_SL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9180
zend_op *opline = EX(opline);
9181
zend_free_op free_op1;
9183
shift_left_function(&EX_T(opline->result.u.var).tmp_var,
9184
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9185
&opline->op2.u.constant TSRMLS_CC);
9186
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9188
ZEND_VM_NEXT_OPCODE();
9191
static int ZEND_FASTCALL ZEND_SR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9193
zend_op *opline = EX(opline);
9194
zend_free_op free_op1;
9196
shift_right_function(&EX_T(opline->result.u.var).tmp_var,
9197
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9198
&opline->op2.u.constant TSRMLS_CC);
9199
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9201
ZEND_VM_NEXT_OPCODE();
9204
static int ZEND_FASTCALL ZEND_CONCAT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9206
zend_op *opline = EX(opline);
9207
zend_free_op free_op1;
9209
concat_function(&EX_T(opline->result.u.var).tmp_var,
9210
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9211
&opline->op2.u.constant TSRMLS_CC);
9212
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9214
ZEND_VM_NEXT_OPCODE();
9217
static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9219
zend_op *opline = EX(opline);
9220
zend_free_op free_op1;
9222
is_identical_function(&EX_T(opline->result.u.var).tmp_var,
9223
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9224
&opline->op2.u.constant TSRMLS_CC);
9225
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9227
ZEND_VM_NEXT_OPCODE();
9230
static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9232
zend_op *opline = EX(opline);
9233
zend_free_op free_op1;
9234
zval *result = &EX_T(opline->result.u.var).tmp_var;
9236
is_identical_function(result,
9237
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9238
&opline->op2.u.constant TSRMLS_CC);
9239
Z_LVAL_P(result) = !Z_LVAL_P(result);
9240
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9242
ZEND_VM_NEXT_OPCODE();
9245
static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9247
zend_op *opline = EX(opline);
9248
zend_free_op free_op1;
9249
zval *result = &EX_T(opline->result.u.var).tmp_var;
9251
compare_function(result,
9252
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9253
&opline->op2.u.constant TSRMLS_CC);
9254
ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
9255
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9257
ZEND_VM_NEXT_OPCODE();
9260
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9262
zend_op *opline = EX(opline);
9263
zend_free_op free_op1;
9264
zval *result = &EX_T(opline->result.u.var).tmp_var;
9266
compare_function(result,
9267
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9268
&opline->op2.u.constant TSRMLS_CC);
9269
ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
9270
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9272
ZEND_VM_NEXT_OPCODE();
9275
static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9277
zend_op *opline = EX(opline);
9278
zend_free_op free_op1;
9279
zval *result = &EX_T(opline->result.u.var).tmp_var;
9281
compare_function(result,
9282
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9283
&opline->op2.u.constant TSRMLS_CC);
9284
ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
9285
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9287
ZEND_VM_NEXT_OPCODE();
9290
static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9292
zend_op *opline = EX(opline);
9293
zend_free_op free_op1;
9294
zval *result = &EX_T(opline->result.u.var).tmp_var;
9296
compare_function(result,
9297
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9298
&opline->op2.u.constant TSRMLS_CC);
9299
ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
9300
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9302
ZEND_VM_NEXT_OPCODE();
9305
static int ZEND_FASTCALL ZEND_BW_OR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9307
zend_op *opline = EX(opline);
9308
zend_free_op free_op1;
9310
bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
9311
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9312
&opline->op2.u.constant TSRMLS_CC);
9313
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9315
ZEND_VM_NEXT_OPCODE();
9318
static int ZEND_FASTCALL ZEND_BW_AND_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9320
zend_op *opline = EX(opline);
9321
zend_free_op free_op1;
9323
bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
9324
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9325
&opline->op2.u.constant TSRMLS_CC);
9326
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9328
ZEND_VM_NEXT_OPCODE();
9331
static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9333
zend_op *opline = EX(opline);
9334
zend_free_op free_op1;
9336
bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
9337
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9338
&opline->op2.u.constant TSRMLS_CC);
9339
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9341
ZEND_VM_NEXT_OPCODE();
9344
static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9346
zend_op *opline = EX(opline);
9347
zend_free_op free_op1;
9349
boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
9350
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9351
&opline->op2.u.constant TSRMLS_CC);
9352
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9354
ZEND_VM_NEXT_OPCODE();
9357
static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
9359
zend_op *opline = EX(opline);
9360
zend_op *op_data = opline+1;
9361
zend_free_op free_op1, free_op_data1;
9362
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9364
zval *property = &opline->op2.u.constant;
9365
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
9366
znode *result = &opline->result;
9367
int have_get_ptr = 0;
9369
if (IS_VAR == IS_VAR && !object_ptr) {
9370
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
9373
EX_T(result->u.var).var.ptr_ptr = NULL;
9374
make_real_object(object_ptr TSRMLS_CC);
9375
object = *object_ptr;
9377
if (Z_TYPE_P(object) != IS_OBJECT) {
9378
zend_error(E_WARNING, "Attempt to assign property of non-object");
9380
FREE_OP(free_op_data1);
9382
if (!RETURN_VALUE_UNUSED(result)) {
9383
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
9384
EX_T(result->u.var).var.ptr_ptr = NULL;
9385
PZVAL_LOCK(EG(uninitialized_zval_ptr));
9388
/* here we are sure we are dealing with an object */
9390
MAKE_REAL_ZVAL_PTR(property);
9393
/* here property is a string */
9394
if (opline->extended_value == ZEND_ASSIGN_OBJ
9395
&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
9396
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
9397
if (zptr != NULL) { /* NULL means no success in getting PTR */
9398
SEPARATE_ZVAL_IF_NOT_REF(zptr);
9401
binary_op(*zptr, *zptr, value TSRMLS_CC);
9402
if (!RETURN_VALUE_UNUSED(result)) {
9403
EX_T(result->u.var).var.ptr = *zptr;
9404
EX_T(result->u.var).var.ptr_ptr = NULL;
9410
if (!have_get_ptr) {
9413
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
9414
if (Z_OBJ_HT_P(object)->read_property) {
9415
z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
9417
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
9418
if (Z_OBJ_HT_P(object)->read_dimension) {
9419
z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
9423
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
9424
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
9426
if (Z_REFCOUNT_P(z) == 0) {
9427
GC_REMOVE_ZVAL_FROM_BUFFER(z);
9434
SEPARATE_ZVAL_IF_NOT_REF(&z);
9435
binary_op(z, z, value TSRMLS_CC);
9436
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
9437
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
9438
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
9439
Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
9441
if (!RETURN_VALUE_UNUSED(result)) {
9442
EX_T(result->u.var).var.ptr = z;
9443
EX_T(result->u.var).var.ptr_ptr = NULL;
9448
zend_error(E_WARNING, "Attempt to assign property of non-object");
9449
if (!RETURN_VALUE_UNUSED(result)) {
9450
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
9451
EX_T(result->u.var).var.ptr_ptr = NULL;
9452
PZVAL_LOCK(EG(uninitialized_zval_ptr));
9458
zval_ptr_dtor(&property);
9462
FREE_OP(free_op_data1);
9465
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9466
/* assign_obj has two opcodes! */
9467
ZEND_VM_INC_OPCODE();
9468
ZEND_VM_NEXT_OPCODE();
9471
static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
9473
zend_op *opline = EX(opline);
9474
zend_free_op free_op1, free_op_data2, free_op_data1;
9478
switch (opline->extended_value) {
9479
case ZEND_ASSIGN_OBJ:
9480
return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9482
case ZEND_ASSIGN_DIM: {
9483
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9485
if (IS_VAR == IS_VAR && !container) {
9486
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
9487
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
9488
if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
9489
Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
9491
return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9493
zend_op *op_data = opline+1;
9494
zval *dim = &opline->op2.u.constant;
9496
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), container, dim, 0, BP_VAR_RW TSRMLS_CC);
9497
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
9498
var_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
9499
ZEND_VM_INC_OPCODE();
9504
value = &opline->op2.u.constant;
9505
var_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9511
zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
9514
if (*var_ptr == EG(error_zval_ptr)) {
9515
if (!RETURN_VALUE_UNUSED(&opline->result)) {
9516
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
9517
PZVAL_LOCK(EG(uninitialized_zval_ptr));
9520
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9521
ZEND_VM_NEXT_OPCODE();
9524
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
9526
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
9527
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
9529
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
9531
binary_op(objval, objval, value TSRMLS_CC);
9532
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
9533
zval_ptr_dtor(&objval);
9535
binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
9538
if (!RETURN_VALUE_UNUSED(&opline->result)) {
9539
AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
9540
PZVAL_LOCK(*var_ptr);
9543
if (opline->extended_value == ZEND_ASSIGN_DIM) {
9544
FREE_OP(free_op_data1);
9545
FREE_OP_VAR_PTR(free_op_data2);
9547
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9548
ZEND_VM_NEXT_OPCODE();
9551
static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9553
return zend_binary_assign_op_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9556
static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9558
return zend_binary_assign_op_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9561
static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9563
return zend_binary_assign_op_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9566
static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9568
return zend_binary_assign_op_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9571
static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9573
return zend_binary_assign_op_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9576
static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9578
return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9581
static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9583
return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9586
static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9588
return zend_binary_assign_op_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9591
static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9593
return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9596
static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9598
return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9601
static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9603
return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9606
static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
9608
zend_op *opline = EX(opline);
9609
zend_free_op free_op1;
9610
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9612
zval *property = &opline->op2.u.constant;
9613
zval **retval = &EX_T(opline->result.u.var).var.ptr;
9614
int have_get_ptr = 0;
9616
if (IS_VAR == IS_VAR && !object_ptr) {
9617
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
9620
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
9621
object = *object_ptr;
9623
if (Z_TYPE_P(object) != IS_OBJECT) {
9624
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
9626
if (!RETURN_VALUE_UNUSED(&opline->result)) {
9627
*retval = EG(uninitialized_zval_ptr);
9628
PZVAL_LOCK(*retval);
9630
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9631
ZEND_VM_NEXT_OPCODE();
9634
/* here we are sure we are dealing with an object */
9637
MAKE_REAL_ZVAL_PTR(property);
9640
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
9641
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
9642
if (zptr != NULL) { /* NULL means no success in getting PTR */
9643
SEPARATE_ZVAL_IF_NOT_REF(zptr);
9647
if (!RETURN_VALUE_UNUSED(&opline->result)) {
9649
PZVAL_LOCK(*retval);
9654
if (!have_get_ptr) {
9655
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
9656
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
9658
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
9659
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
9661
if (Z_REFCOUNT_P(z) == 0) {
9662
GC_REMOVE_ZVAL_FROM_BUFFER(z);
9669
SEPARATE_ZVAL_IF_NOT_REF(&z);
9672
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
9673
SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
9676
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
9677
if (!RETURN_VALUE_UNUSED(&opline->result)) {
9678
*retval = EG(uninitialized_zval_ptr);
9679
PZVAL_LOCK(*retval);
9685
zval_ptr_dtor(&property);
9689
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9690
ZEND_VM_NEXT_OPCODE();
9693
static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9695
return zend_pre_incdec_property_helper_SPEC_VAR_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9698
static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9700
return zend_pre_incdec_property_helper_SPEC_VAR_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9703
static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
9705
zend_op *opline = EX(opline);
9706
zend_free_op free_op1;
9707
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9709
zval *property = &opline->op2.u.constant;
9710
zval *retval = &EX_T(opline->result.u.var).tmp_var;
9711
int have_get_ptr = 0;
9713
if (IS_VAR == IS_VAR && !object_ptr) {
9714
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
9717
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
9718
object = *object_ptr;
9720
if (Z_TYPE_P(object) != IS_OBJECT) {
9721
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
9723
*retval = *EG(uninitialized_zval_ptr);
9724
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9725
ZEND_VM_NEXT_OPCODE();
9728
/* here we are sure we are dealing with an object */
9731
MAKE_REAL_ZVAL_PTR(property);
9734
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
9735
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
9736
if (zptr != NULL) { /* NULL means no success in getting PTR */
9738
SEPARATE_ZVAL_IF_NOT_REF(zptr);
9741
zendi_zval_copy_ctor(*retval);
9748
if (!have_get_ptr) {
9749
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
9750
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
9753
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
9754
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
9756
if (Z_REFCOUNT_P(z) == 0) {
9757
GC_REMOVE_ZVAL_FROM_BUFFER(z);
9764
zendi_zval_copy_ctor(*retval);
9767
zendi_zval_copy_ctor(*z_copy);
9771
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
9772
zval_ptr_dtor(&z_copy);
9775
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
9776
*retval = *EG(uninitialized_zval_ptr);
9781
zval_ptr_dtor(&property);
9785
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9786
ZEND_VM_NEXT_OPCODE();
9789
static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9791
return zend_post_incdec_property_helper_SPEC_VAR_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9794
static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9796
return zend_post_incdec_property_helper_SPEC_VAR_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9799
static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9801
zend_op *opline = EX(opline);
9802
zend_free_op free_op1;
9803
zval *dim = &opline->op2.u.constant;
9806
if (opline->extended_value == ZEND_FETCH_ADD_LOCK &&
9808
EX_T(opline->op1.u.var).var.ptr_ptr) {
9809
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
9811
container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9812
if (IS_VAR == IS_VAR && !container) {
9813
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
9815
zend_fetch_dimension_address_read(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_R TSRMLS_CC);
9817
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9818
ZEND_VM_NEXT_OPCODE();
9821
static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9823
zend_op *opline = EX(opline);
9824
zend_free_op free_op1;
9825
zval *dim = &opline->op2.u.constant;
9826
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9828
if (IS_VAR == IS_VAR && !container) {
9829
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
9831
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_W TSRMLS_CC);
9833
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
9834
READY_TO_DESTROY(free_op1.var)) {
9835
AI_USE_PTR(EX_T(opline->result.u.var).var);
9836
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
9837
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
9838
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
9841
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9843
/* We are going to assign the result by reference */
9844
if (opline->extended_value) {
9845
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
9846
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
9847
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
9850
ZEND_VM_NEXT_OPCODE();
9853
static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9855
zend_op *opline = EX(opline);
9856
zend_free_op free_op1;
9857
zval *dim = &opline->op2.u.constant;
9858
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9860
if (IS_VAR == IS_VAR && !container) {
9861
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
9863
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_RW TSRMLS_CC);
9865
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
9866
READY_TO_DESTROY(free_op1.var)) {
9867
AI_USE_PTR(EX_T(opline->result.u.var).var);
9868
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
9869
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
9870
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
9873
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9874
ZEND_VM_NEXT_OPCODE();
9877
static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9879
zend_op *opline = EX(opline);
9880
zend_free_op free_op1;
9881
zval *dim = &opline->op2.u.constant;
9882
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9884
if (IS_VAR == IS_VAR && !container) {
9885
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
9887
zend_fetch_dimension_address_read(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_IS TSRMLS_CC);
9889
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9890
ZEND_VM_NEXT_OPCODE();
9893
static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9895
zend_op *opline = EX(opline);
9896
zend_free_op free_op1;
9897
zval *dim = &opline->op2.u.constant;
9900
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
9901
container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9902
if (IS_VAR == IS_VAR && !container) {
9903
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
9905
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_W TSRMLS_CC);
9906
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
9907
READY_TO_DESTROY(free_op1.var)) {
9908
AI_USE_PTR(EX_T(opline->result.u.var).var);
9909
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
9910
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
9911
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
9915
if (IS_CONST == IS_UNUSED) {
9916
zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
9918
container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9919
if (IS_VAR == IS_VAR && !container) {
9920
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
9922
zend_fetch_dimension_address_read(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_R TSRMLS_CC);
9925
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9926
ZEND_VM_NEXT_OPCODE();
9929
static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9931
zend_op *opline = EX(opline);
9932
zend_free_op free_op1;
9933
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9934
zval *dim = &opline->op2.u.constant;
9936
/* Not needed in DIM_UNSET
9937
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
9938
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
9941
if (IS_VAR == IS_CV) {
9942
if (container != &EG(uninitialized_zval_ptr)) {
9943
SEPARATE_ZVAL_IF_NOT_REF(container);
9946
if (IS_VAR == IS_VAR && !container) {
9947
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
9949
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_UNSET TSRMLS_CC);
9951
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
9952
READY_TO_DESTROY(free_op1.var)) {
9953
AI_USE_PTR(EX_T(opline->result.u.var).var);
9954
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
9955
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
9956
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
9959
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9960
if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
9961
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
9963
zend_free_op free_res;
9965
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
9966
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
9967
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
9969
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
9970
FREE_OP_VAR_PTR(free_res);
9972
ZEND_VM_NEXT_OPCODE();
9975
static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
9977
zend_op *opline = EX(opline);
9978
zend_free_op free_op1;
9979
zval *container = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9981
zval *offset = &opline->op2.u.constant;
9983
if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
9984
if (type != BP_VAR_IS) {
9985
zend_error(E_NOTICE, "Trying to get property of non-object");
9987
if (!RETURN_VALUE_UNUSED(&opline->result)) {
9988
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
9989
PZVAL_LOCK(EG(uninitialized_zval_ptr));
9996
MAKE_REAL_ZVAL_PTR(offset);
9999
/* here we are sure we are dealing with an object */
10000
retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
10002
if (RETURN_VALUE_UNUSED(&opline->result)) {
10003
if (Z_REFCOUNT_P(retval) == 0) {
10004
GC_REMOVE_ZVAL_FROM_BUFFER(retval);
10009
AI_SET_PTR(EX_T(opline->result.u.var).var, retval);
10010
PZVAL_LOCK(retval);
10014
zval_ptr_dtor(&offset);
10020
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10021
ZEND_VM_NEXT_OPCODE();
10024
static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10026
return zend_fetch_property_address_read_helper_SPEC_VAR_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10029
static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10031
zend_op *opline = EX(opline);
10032
zend_free_op free_op1;
10033
zval *property = &opline->op2.u.constant;
10036
if (IS_VAR == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
10037
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
10038
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
10042
MAKE_REAL_ZVAL_PTR(property);
10044
container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10045
if (IS_VAR == IS_VAR && !container) {
10046
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
10048
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
10050
zval_ptr_dtor(&property);
10054
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
10055
READY_TO_DESTROY(free_op1.var)) {
10056
AI_USE_PTR(EX_T(opline->result.u.var).var);
10057
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
10058
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
10059
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
10062
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10064
/* We are going to assign the result by reference */
10065
if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
10066
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
10067
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
10068
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
10071
ZEND_VM_NEXT_OPCODE();
10074
static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10076
zend_op *opline = EX(opline);
10077
zend_free_op free_op1;
10078
zval *property = &opline->op2.u.constant;
10079
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10082
MAKE_REAL_ZVAL_PTR(property);
10084
if (IS_VAR == IS_VAR && !container) {
10085
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
10087
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_RW TSRMLS_CC);
10089
zval_ptr_dtor(&property);
10093
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
10094
READY_TO_DESTROY(free_op1.var)) {
10095
AI_USE_PTR(EX_T(opline->result.u.var).var);
10096
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
10097
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
10098
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
10101
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10102
ZEND_VM_NEXT_OPCODE();
10105
static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10107
return zend_fetch_property_address_read_helper_SPEC_VAR_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10110
static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10112
zend_op *opline = EX(opline);
10114
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
10115
/* Behave like FETCH_OBJ_W */
10116
zend_free_op free_op1;
10117
zval *property = &opline->op2.u.constant;
10118
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10121
MAKE_REAL_ZVAL_PTR(property);
10123
if (IS_VAR == IS_VAR && !container) {
10124
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
10126
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
10128
zval_ptr_dtor(&property);
10132
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
10133
READY_TO_DESTROY(free_op1.var)) {
10134
AI_USE_PTR(EX_T(opline->result.u.var).var);
10135
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
10136
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
10137
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
10140
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10141
ZEND_VM_NEXT_OPCODE();
10143
return zend_fetch_property_address_read_helper_SPEC_VAR_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10147
static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10149
zend_op *opline = EX(opline);
10150
zend_free_op free_op1, free_res;
10151
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10152
zval *property = &opline->op2.u.constant;
10154
if (IS_VAR == IS_CV) {
10155
if (container != &EG(uninitialized_zval_ptr)) {
10156
SEPARATE_ZVAL_IF_NOT_REF(container);
10160
MAKE_REAL_ZVAL_PTR(property);
10162
if (IS_VAR == IS_VAR && !container) {
10163
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
10165
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
10167
zval_ptr_dtor(&property);
10171
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
10172
READY_TO_DESTROY(free_op1.var)) {
10173
AI_USE_PTR(EX_T(opline->result.u.var).var);
10174
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
10175
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
10176
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
10179
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10181
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
10182
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
10183
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
10185
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
10186
FREE_OP_VAR_PTR(free_res);
10187
ZEND_VM_NEXT_OPCODE();
10190
static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10192
zend_op *opline = EX(opline);
10193
zend_op *op_data = opline+1;
10194
zend_free_op free_op1;
10195
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10196
zval *property_name = &opline->op2.u.constant;
10199
MAKE_REAL_ZVAL_PTR(property_name);
10201
if (IS_VAR == IS_VAR && !object_ptr) {
10202
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
10204
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
10206
zval_ptr_dtor(&property_name);
10210
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10211
/* assign_obj has two opcodes! */
10212
ZEND_VM_INC_OPCODE();
10213
ZEND_VM_NEXT_OPCODE();
10216
static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10218
zend_op *opline = EX(opline);
10219
zend_op *op_data = opline+1;
10220
zend_free_op free_op1;
10221
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10223
if (IS_VAR == IS_VAR && !object_ptr) {
10224
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
10226
if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
10228
zval *property_name = &opline->op2.u.constant;
10231
MAKE_REAL_ZVAL_PTR(property_name);
10233
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
10235
zval_ptr_dtor(&property_name);
10240
zend_free_op free_op_data1, free_op_data2;
10242
zval *dim = &opline->op2.u.constant;
10243
zval **variable_ptr_ptr;
10245
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
10247
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
10248
variable_ptr_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
10249
if (!variable_ptr_ptr) {
10250
if (zend_assign_to_string_offset(&EX_T(op_data->op2.u.var), value, op_data->op1.op_type TSRMLS_CC)) {
10251
if (!RETURN_VALUE_UNUSED(&opline->result)) {
10252
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
10253
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
10254
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
10255
ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(op_data->op2.u.var).str_offset.str)+EX_T(op_data->op2.u.var).str_offset.offset, 1, 1);
10257
} else if (!RETURN_VALUE_UNUSED(&opline->result)) {
10258
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
10259
PZVAL_LOCK(EG(uninitialized_zval_ptr));
10262
value = zend_assign_to_variable(variable_ptr_ptr, value, IS_TMP_FREE(free_op_data1) TSRMLS_CC);
10263
if (!RETURN_VALUE_UNUSED(&opline->result)) {
10264
AI_SET_PTR(EX_T(opline->result.u.var).var, value);
10268
FREE_OP_VAR_PTR(free_op_data2);
10269
FREE_OP_IF_VAR(free_op_data1);
10271
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10272
/* assign_dim has two opcodes! */
10273
ZEND_VM_INC_OPCODE();
10274
ZEND_VM_NEXT_OPCODE();
10277
static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10279
zend_op *opline = EX(opline);
10280
zend_free_op free_op1;
10281
zval *value = &opline->op2.u.constant;
10282
zval **variable_ptr_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10284
if (IS_VAR == IS_VAR && !variable_ptr_ptr) {
10285
if (zend_assign_to_string_offset(&EX_T(opline->op1.u.var), value, IS_CONST TSRMLS_CC)) {
10286
if (!RETURN_VALUE_UNUSED(&opline->result)) {
10287
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
10288
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
10289
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
10290
ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(opline->op1.u.var).str_offset.str)+EX_T(opline->op1.u.var).str_offset.offset, 1, 1);
10292
} else if (!RETURN_VALUE_UNUSED(&opline->result)) {
10293
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
10294
PZVAL_LOCK(EG(uninitialized_zval_ptr));
10297
value = zend_assign_to_variable(variable_ptr_ptr, value, 0 TSRMLS_CC);
10298
if (!RETURN_VALUE_UNUSED(&opline->result)) {
10299
AI_SET_PTR(EX_T(opline->result.u.var).var, value);
10304
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10306
/* zend_assign_to_variable() always takes care of op2, never free it! */
10308
ZEND_VM_NEXT_OPCODE();
10311
static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10313
zend_op *opline = EX(opline);
10314
zval *function_name;
10315
char *function_name_strval;
10316
int function_name_strlen;
10317
zend_free_op free_op1;
10319
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
10321
function_name = &opline->op2.u.constant;
10323
if (Z_TYPE_P(function_name)!=IS_STRING) {
10324
zend_error_noreturn(E_ERROR, "Method name must be a string");
10327
function_name_strval = Z_STRVAL_P(function_name);
10328
function_name_strlen = Z_STRLEN_P(function_name);
10330
EX(object) = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10332
if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
10333
if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
10334
zend_error_noreturn(E_ERROR, "Object does not support method calls");
10337
/* First, locate the function. */
10338
EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
10340
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
10343
EX(called_scope) = Z_OBJCE_P(EX(object));
10345
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
10348
if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) {
10351
if (!PZVAL_IS_REF(EX(object))) {
10352
Z_ADDREF_P(EX(object)); /* For $this pointer */
10355
ALLOC_ZVAL(this_ptr);
10356
INIT_PZVAL_COPY(this_ptr, EX(object));
10357
zval_copy_ctor(this_ptr);
10358
EX(object) = this_ptr;
10362
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10364
ZEND_VM_NEXT_OPCODE();
10367
static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10369
zend_op *opline = EX(opline);
10370
zval *function_name;
10371
zend_class_entry *ce;
10373
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
10375
if (IS_VAR == IS_CONST) {
10376
/* no function found. try a static method in class */
10377
ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
10379
zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL(opline->op1.u.constant));
10381
EX(called_scope) = ce;
10383
ce = EX_T(opline->op1.u.var).class_entry;
10385
if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
10386
EX(called_scope) = EG(called_scope);
10388
EX(called_scope) = ce;
10391
if(IS_CONST != IS_UNUSED) {
10392
char *function_name_strval = NULL;
10393
int function_name_strlen = 0;
10396
if (IS_CONST == IS_CONST) {
10397
function_name_strval = Z_STRVAL(opline->op2.u.constant);
10398
function_name_strlen = Z_STRLEN(opline->op2.u.constant);
10400
function_name = &opline->op2.u.constant;
10402
if (Z_TYPE_P(function_name) != IS_STRING) {
10403
zend_error_noreturn(E_ERROR, "Function name must be a string");
10405
function_name_strval = Z_STRVAL_P(function_name);
10406
function_name_strlen = Z_STRLEN_P(function_name);
10410
if (function_name_strval) {
10411
if (ce->get_static_method) {
10412
EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
10414
EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
10417
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
10421
if (IS_CONST != IS_CONST) {
10425
if(!ce->constructor) {
10426
zend_error_noreturn(E_ERROR, "Cannot call constructor");
10428
if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
10429
zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
10431
EX(fbc) = ce->constructor;
10434
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
10438
Z_OBJ_HT_P(EG(This))->get_class_entry &&
10439
!instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
10440
/* We are calling method of the other (incompatible) class,
10441
but passing $this. This is done for compatibility with php-4. */
10444
if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
10445
severity = E_STRICT;
10446
verb = "should not";
10448
/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
10449
severity = E_ERROR;
10452
zend_error(severity, "Non-static method %s::%s() %s be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name, verb);
10455
if ((EX(object) = EG(This))) {
10456
Z_ADDREF_P(EX(object));
10457
EX(called_scope) = Z_OBJCE_P(EX(object));
10461
ZEND_VM_NEXT_OPCODE();
10464
static int ZEND_FASTCALL ZEND_CASE_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10466
zend_op *opline = EX(opline);
10467
int switch_expr_is_overloaded=0;
10468
zend_free_op free_op1;
10470
if (IS_VAR==IS_VAR) {
10471
if (EX_T(opline->op1.u.var).var.ptr_ptr) {
10472
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
10474
switch_expr_is_overloaded = 1;
10475
Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
10478
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
10479
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
10480
&opline->op2.u.constant TSRMLS_CC);
10482
if (switch_expr_is_overloaded) {
10483
/* We only free op1 if this is a string offset,
10484
* Since if it is a TMP_VAR, it'll be reused by
10485
* other CASE opcodes (whereas string offsets
10486
* are allocated at each get_zval_ptr())
10488
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10489
EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
10490
EX_T(opline->op1.u.var).var.ptr = NULL;
10492
ZEND_VM_NEXT_OPCODE();
10495
static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10497
zend_op *opline = EX(opline);
10499
if (IS_VAR == IS_UNUSED) {
10500
/* namespaced constant */
10501
if (!zend_get_constant_ex(Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant), &EX_T(opline->result.u.var).tmp_var, NULL, opline->extended_value TSRMLS_CC)) {
10502
if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
10503
char *actual = (char *)zend_memrchr(Z_STRVAL(opline->op2.u.constant), '\\', Z_STRLEN(opline->op2.u.constant));
10505
actual = Z_STRVAL(opline->op2.u.constant);
10509
/* non-qualified constant - allow text substitution */
10510
zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
10511
ZVAL_STRINGL(&EX_T(opline->result.u.var).tmp_var, actual, Z_STRLEN(opline->op2.u.constant)-(actual - Z_STRVAL(opline->op2.u.constant)), 1);
10513
zend_error_noreturn(E_ERROR, "Undefined constant '%s'",
10514
Z_STRVAL(opline->op2.u.constant), Z_STRVAL(opline->op2.u.constant));
10517
ZEND_VM_NEXT_OPCODE();
10519
/* class constant */
10520
zend_class_entry *ce;
10523
if (IS_VAR == IS_CONST) {
10525
ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
10527
zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL(opline->op2.u.constant));
10530
ce = EX_T(opline->op1.u.var).class_entry;
10533
if (zend_hash_find(&ce->constants_table, Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant)+1, (void **) &value) == SUCCESS) {
10534
if (Z_TYPE_PP(value) == IS_CONSTANT_ARRAY ||
10535
(Z_TYPE_PP(value) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) {
10536
zend_class_entry *old_scope = EG(scope);
10539
zval_update_constant(value, (void *) 1 TSRMLS_CC);
10540
EG(scope) = old_scope;
10542
EX_T(opline->result.u.var).tmp_var = **value;
10543
zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
10545
zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL(opline->op2.u.constant));
10548
ZEND_VM_NEXT_OPCODE();
10552
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10554
zend_op *opline = EX(opline);
10555
zend_free_op free_op1;
10556
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
10558
zval *offset=&opline->op2.u.constant;
10560
#if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
10561
zval **expr_ptr_ptr = NULL;
10563
if (opline->extended_value) {
10564
expr_ptr_ptr=_get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10565
expr_ptr = *expr_ptr_ptr;
10567
expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10570
expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10573
if (0) { /* temporary variable */
10576
ALLOC_ZVAL(new_expr);
10577
INIT_PZVAL_COPY(new_expr, expr_ptr);
10578
expr_ptr = new_expr;
10580
#if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
10581
if (opline->extended_value) {
10582
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
10583
expr_ptr = *expr_ptr_ptr;
10584
Z_ADDREF_P(expr_ptr);
10587
if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
10590
ALLOC_ZVAL(new_expr);
10591
INIT_PZVAL_COPY(new_expr, expr_ptr);
10592
expr_ptr = new_expr;
10593
zendi_zval_copy_ctor(*expr_ptr);
10595
Z_ADDREF_P(expr_ptr);
10599
switch (Z_TYPE_P(offset)) {
10601
zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
10605
zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
10608
zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
10611
zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
10614
zend_error(E_WARNING, "Illegal offset type");
10615
zval_ptr_dtor(&expr_ptr);
10621
zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
10623
if (opline->extended_value) {
10624
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10626
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10628
ZEND_VM_NEXT_OPCODE();
10631
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10633
zend_op *opline = EX(opline);
10635
array_init(&EX_T(opline->result.u.var).tmp_var);
10636
if (IS_VAR == IS_UNUSED) {
10637
ZEND_VM_NEXT_OPCODE();
10638
#if 0 || IS_VAR != IS_UNUSED
10640
return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10645
static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10647
zend_op *opline = EX(opline);
10648
zend_free_op free_op1;
10649
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10650
zval *offset = &opline->op2.u.constant;
10652
if (IS_VAR != IS_VAR || container) {
10653
if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
10654
SEPARATE_ZVAL_IF_NOT_REF(container);
10656
switch (Z_TYPE_PP(container)) {
10658
HashTable *ht = Z_ARRVAL_PP(container);
10660
switch (Z_TYPE_P(offset)) {
10662
zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
10667
zend_hash_index_del(ht, Z_LVAL_P(offset));
10670
if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
10671
Z_ADDREF_P(offset);
10673
if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
10674
ht == &EG(symbol_table)) {
10675
zend_execute_data *ex;
10676
ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
10678
for (ex = execute_data; ex; ex = ex->prev_execute_data) {
10679
if (ex->op_array && ex->symbol_table == ht) {
10682
for (i = 0; i < ex->op_array->last_var; i++) {
10683
if (ex->op_array->vars[i].hash_value == hash_value &&
10684
ex->op_array->vars[i].name_len == offset->value.str.len &&
10685
!memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
10693
if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
10694
zval_ptr_dtor(&offset);
10698
zend_hash_del(ht, "", sizeof(""));
10701
zend_error(E_WARNING, "Illegal offset type in unset");
10708
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
10709
zend_error_noreturn(E_ERROR, "Cannot use object as array");
10712
MAKE_REAL_ZVAL_PTR(offset);
10714
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
10716
zval_ptr_dtor(&offset);
10722
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
10723
ZEND_VM_CONTINUE(); /* bailed out before */
10731
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10733
ZEND_VM_NEXT_OPCODE();
10736
static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10738
zend_op *opline = EX(opline);
10739
zend_free_op free_op1;
10740
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10741
zval *offset = &opline->op2.u.constant;
10743
if (IS_VAR != IS_VAR || container) {
10744
if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
10745
SEPARATE_ZVAL_IF_NOT_REF(container);
10747
if (Z_TYPE_PP(container) == IS_OBJECT) {
10749
MAKE_REAL_ZVAL_PTR(offset);
10751
if (Z_OBJ_HT_P(*container)->unset_property) {
10752
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
10754
zend_error(E_NOTICE, "Trying to unset property of non-object");
10757
zval_ptr_dtor(&offset);
10767
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10769
ZEND_VM_NEXT_OPCODE();
10772
static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
10774
zend_op *opline = EX(opline);
10775
zend_free_op free_op1;
10776
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10777
zval **value = NULL;
10780
if (IS_VAR != IS_VAR || container) {
10782
zval *offset = &opline->op2.u.constant;
10784
if (Z_TYPE_PP(container) == IS_ARRAY) {
10788
ht = Z_ARRVAL_PP(container);
10790
switch (Z_TYPE_P(offset)) {
10792
if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
10799
if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
10804
if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
10809
if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
10814
zend_error(E_WARNING, "Illegal offset type in isset or empty");
10819
switch (opline->extended_value) {
10821
if (isset && Z_TYPE_PP(value) == IS_NULL) {
10828
if (!isset || !i_zend_is_true(*value)) {
10836
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
10838
MAKE_REAL_ZVAL_PTR(offset);
10841
if (Z_OBJ_HT_P(*container)->has_property) {
10842
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
10844
zend_error(E_NOTICE, "Trying to check property of non-object");
10848
if (Z_OBJ_HT_P(*container)->has_dimension) {
10849
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
10851
zend_error(E_NOTICE, "Trying to check element of non-array");
10856
zval_ptr_dtor(&offset);
10860
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
10863
if (Z_TYPE_P(offset) != IS_LONG) {
10865
zval_copy_ctor(&tmp);
10866
convert_to_long(&tmp);
10869
if (Z_TYPE_P(offset) == IS_LONG) {
10870
switch (opline->extended_value) {
10872
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
10877
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
10889
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
10891
switch (opline->extended_value) {
10893
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
10896
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
10900
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10902
ZEND_VM_NEXT_OPCODE();
10905
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10907
return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10910
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10912
return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10915
static int ZEND_FASTCALL ZEND_ADD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10917
zend_op *opline = EX(opline);
10918
zend_free_op free_op1, free_op2;
10920
add_function(&EX_T(opline->result.u.var).tmp_var,
10921
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
10922
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
10923
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10924
zval_dtor(free_op2.var);
10925
ZEND_VM_NEXT_OPCODE();
10928
static int ZEND_FASTCALL ZEND_SUB_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10930
zend_op *opline = EX(opline);
10931
zend_free_op free_op1, free_op2;
10933
sub_function(&EX_T(opline->result.u.var).tmp_var,
10934
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
10935
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
10936
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10937
zval_dtor(free_op2.var);
10938
ZEND_VM_NEXT_OPCODE();
10941
static int ZEND_FASTCALL ZEND_MUL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10943
zend_op *opline = EX(opline);
10944
zend_free_op free_op1, free_op2;
10946
mul_function(&EX_T(opline->result.u.var).tmp_var,
10947
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
10948
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
10949
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10950
zval_dtor(free_op2.var);
10951
ZEND_VM_NEXT_OPCODE();
10954
static int ZEND_FASTCALL ZEND_DIV_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10956
zend_op *opline = EX(opline);
10957
zend_free_op free_op1, free_op2;
10959
div_function(&EX_T(opline->result.u.var).tmp_var,
10960
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
10961
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
10962
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10963
zval_dtor(free_op2.var);
10964
ZEND_VM_NEXT_OPCODE();
10967
static int ZEND_FASTCALL ZEND_MOD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10969
zend_op *opline = EX(opline);
10970
zend_free_op free_op1, free_op2;
10972
mod_function(&EX_T(opline->result.u.var).tmp_var,
10973
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
10974
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
10975
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10976
zval_dtor(free_op2.var);
10977
ZEND_VM_NEXT_OPCODE();
10980
static int ZEND_FASTCALL ZEND_SL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10982
zend_op *opline = EX(opline);
10983
zend_free_op free_op1, free_op2;
10985
shift_left_function(&EX_T(opline->result.u.var).tmp_var,
10986
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
10987
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
10988
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10989
zval_dtor(free_op2.var);
10990
ZEND_VM_NEXT_OPCODE();
10993
static int ZEND_FASTCALL ZEND_SR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10995
zend_op *opline = EX(opline);
10996
zend_free_op free_op1, free_op2;
10998
shift_right_function(&EX_T(opline->result.u.var).tmp_var,
10999
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11000
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11001
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11002
zval_dtor(free_op2.var);
11003
ZEND_VM_NEXT_OPCODE();
11006
static int ZEND_FASTCALL ZEND_CONCAT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11008
zend_op *opline = EX(opline);
11009
zend_free_op free_op1, free_op2;
11011
concat_function(&EX_T(opline->result.u.var).tmp_var,
11012
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11013
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11014
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11015
zval_dtor(free_op2.var);
11016
ZEND_VM_NEXT_OPCODE();
11019
static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11021
zend_op *opline = EX(opline);
11022
zend_free_op free_op1, free_op2;
11024
is_identical_function(&EX_T(opline->result.u.var).tmp_var,
11025
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11026
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11027
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11028
zval_dtor(free_op2.var);
11029
ZEND_VM_NEXT_OPCODE();
11032
static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11034
zend_op *opline = EX(opline);
11035
zend_free_op free_op1, free_op2;
11036
zval *result = &EX_T(opline->result.u.var).tmp_var;
11038
is_identical_function(result,
11039
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11040
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11041
Z_LVAL_P(result) = !Z_LVAL_P(result);
11042
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11043
zval_dtor(free_op2.var);
11044
ZEND_VM_NEXT_OPCODE();
11047
static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11049
zend_op *opline = EX(opline);
11050
zend_free_op free_op1, free_op2;
11051
zval *result = &EX_T(opline->result.u.var).tmp_var;
11053
compare_function(result,
11054
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11055
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11056
ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
11057
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11058
zval_dtor(free_op2.var);
11059
ZEND_VM_NEXT_OPCODE();
11062
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11064
zend_op *opline = EX(opline);
11065
zend_free_op free_op1, free_op2;
11066
zval *result = &EX_T(opline->result.u.var).tmp_var;
11068
compare_function(result,
11069
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11070
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11071
ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
11072
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11073
zval_dtor(free_op2.var);
11074
ZEND_VM_NEXT_OPCODE();
11077
static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11079
zend_op *opline = EX(opline);
11080
zend_free_op free_op1, free_op2;
11081
zval *result = &EX_T(opline->result.u.var).tmp_var;
11083
compare_function(result,
11084
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11085
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11086
ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
11087
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11088
zval_dtor(free_op2.var);
11089
ZEND_VM_NEXT_OPCODE();
11092
static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11094
zend_op *opline = EX(opline);
11095
zend_free_op free_op1, free_op2;
11096
zval *result = &EX_T(opline->result.u.var).tmp_var;
11098
compare_function(result,
11099
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11100
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11101
ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
11102
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11103
zval_dtor(free_op2.var);
11104
ZEND_VM_NEXT_OPCODE();
11107
static int ZEND_FASTCALL ZEND_BW_OR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11109
zend_op *opline = EX(opline);
11110
zend_free_op free_op1, free_op2;
11112
bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
11113
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11114
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11115
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11116
zval_dtor(free_op2.var);
11117
ZEND_VM_NEXT_OPCODE();
11120
static int ZEND_FASTCALL ZEND_BW_AND_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11122
zend_op *opline = EX(opline);
11123
zend_free_op free_op1, free_op2;
11125
bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
11126
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11127
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11128
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11129
zval_dtor(free_op2.var);
11130
ZEND_VM_NEXT_OPCODE();
11133
static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11135
zend_op *opline = EX(opline);
11136
zend_free_op free_op1, free_op2;
11138
bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
11139
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11140
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11141
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11142
zval_dtor(free_op2.var);
11143
ZEND_VM_NEXT_OPCODE();
11146
static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11148
zend_op *opline = EX(opline);
11149
zend_free_op free_op1, free_op2;
11151
boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
11152
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11153
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11154
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11155
zval_dtor(free_op2.var);
11156
ZEND_VM_NEXT_OPCODE();
11159
static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
11161
zend_op *opline = EX(opline);
11162
zend_op *op_data = opline+1;
11163
zend_free_op free_op1, free_op2, free_op_data1;
11164
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11166
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11167
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
11168
znode *result = &opline->result;
11169
int have_get_ptr = 0;
11171
if (IS_VAR == IS_VAR && !object_ptr) {
11172
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
11175
EX_T(result->u.var).var.ptr_ptr = NULL;
11176
make_real_object(object_ptr TSRMLS_CC);
11177
object = *object_ptr;
11179
if (Z_TYPE_P(object) != IS_OBJECT) {
11180
zend_error(E_WARNING, "Attempt to assign property of non-object");
11181
zval_dtor(free_op2.var);
11182
FREE_OP(free_op_data1);
11184
if (!RETURN_VALUE_UNUSED(result)) {
11185
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
11186
EX_T(result->u.var).var.ptr_ptr = NULL;
11187
PZVAL_LOCK(EG(uninitialized_zval_ptr));
11190
/* here we are sure we are dealing with an object */
11192
MAKE_REAL_ZVAL_PTR(property);
11195
/* here property is a string */
11196
if (opline->extended_value == ZEND_ASSIGN_OBJ
11197
&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
11198
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
11199
if (zptr != NULL) { /* NULL means no success in getting PTR */
11200
SEPARATE_ZVAL_IF_NOT_REF(zptr);
11203
binary_op(*zptr, *zptr, value TSRMLS_CC);
11204
if (!RETURN_VALUE_UNUSED(result)) {
11205
EX_T(result->u.var).var.ptr = *zptr;
11206
EX_T(result->u.var).var.ptr_ptr = NULL;
11212
if (!have_get_ptr) {
11215
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
11216
if (Z_OBJ_HT_P(object)->read_property) {
11217
z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
11219
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
11220
if (Z_OBJ_HT_P(object)->read_dimension) {
11221
z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
11225
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
11226
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
11228
if (Z_REFCOUNT_P(z) == 0) {
11229
GC_REMOVE_ZVAL_FROM_BUFFER(z);
11236
SEPARATE_ZVAL_IF_NOT_REF(&z);
11237
binary_op(z, z, value TSRMLS_CC);
11238
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
11239
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
11240
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
11241
Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
11243
if (!RETURN_VALUE_UNUSED(result)) {
11244
EX_T(result->u.var).var.ptr = z;
11245
EX_T(result->u.var).var.ptr_ptr = NULL;
11250
zend_error(E_WARNING, "Attempt to assign property of non-object");
11251
if (!RETURN_VALUE_UNUSED(result)) {
11252
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
11253
EX_T(result->u.var).var.ptr_ptr = NULL;
11254
PZVAL_LOCK(EG(uninitialized_zval_ptr));
11260
zval_ptr_dtor(&property);
11262
zval_dtor(free_op2.var);
11264
FREE_OP(free_op_data1);
11267
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11268
/* assign_obj has two opcodes! */
11269
ZEND_VM_INC_OPCODE();
11270
ZEND_VM_NEXT_OPCODE();
11273
static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
11275
zend_op *opline = EX(opline);
11276
zend_free_op free_op1, free_op2, free_op_data2, free_op_data1;
11280
switch (opline->extended_value) {
11281
case ZEND_ASSIGN_OBJ:
11282
return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11284
case ZEND_ASSIGN_DIM: {
11285
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11287
if (IS_VAR == IS_VAR && !container) {
11288
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
11289
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
11290
if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
11291
Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
11293
return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11295
zend_op *op_data = opline+1;
11296
zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11298
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), container, dim, 1, BP_VAR_RW TSRMLS_CC);
11299
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
11300
var_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
11301
ZEND_VM_INC_OPCODE();
11306
value = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11307
var_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11313
zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
11316
if (*var_ptr == EG(error_zval_ptr)) {
11317
if (!RETURN_VALUE_UNUSED(&opline->result)) {
11318
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
11319
PZVAL_LOCK(EG(uninitialized_zval_ptr));
11321
zval_dtor(free_op2.var);
11322
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11323
ZEND_VM_NEXT_OPCODE();
11326
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
11328
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
11329
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
11331
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
11332
Z_ADDREF_P(objval);
11333
binary_op(objval, objval, value TSRMLS_CC);
11334
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
11335
zval_ptr_dtor(&objval);
11337
binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
11340
if (!RETURN_VALUE_UNUSED(&opline->result)) {
11341
AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
11342
PZVAL_LOCK(*var_ptr);
11344
zval_dtor(free_op2.var);
11346
if (opline->extended_value == ZEND_ASSIGN_DIM) {
11347
FREE_OP(free_op_data1);
11348
FREE_OP_VAR_PTR(free_op_data2);
11350
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11351
ZEND_VM_NEXT_OPCODE();
11354
static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11356
return zend_binary_assign_op_helper_SPEC_VAR_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11359
static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11361
return zend_binary_assign_op_helper_SPEC_VAR_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11364
static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11366
return zend_binary_assign_op_helper_SPEC_VAR_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11369
static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11371
return zend_binary_assign_op_helper_SPEC_VAR_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11374
static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11376
return zend_binary_assign_op_helper_SPEC_VAR_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11379
static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11381
return zend_binary_assign_op_helper_SPEC_VAR_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11384
static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11386
return zend_binary_assign_op_helper_SPEC_VAR_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11389
static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11391
return zend_binary_assign_op_helper_SPEC_VAR_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11394
static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11396
return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11399
static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11401
return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11404
static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11406
return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11409
static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
11411
zend_op *opline = EX(opline);
11412
zend_free_op free_op1, free_op2;
11413
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11415
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11416
zval **retval = &EX_T(opline->result.u.var).var.ptr;
11417
int have_get_ptr = 0;
11419
if (IS_VAR == IS_VAR && !object_ptr) {
11420
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
11423
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
11424
object = *object_ptr;
11426
if (Z_TYPE_P(object) != IS_OBJECT) {
11427
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
11428
zval_dtor(free_op2.var);
11429
if (!RETURN_VALUE_UNUSED(&opline->result)) {
11430
*retval = EG(uninitialized_zval_ptr);
11431
PZVAL_LOCK(*retval);
11433
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11434
ZEND_VM_NEXT_OPCODE();
11437
/* here we are sure we are dealing with an object */
11440
MAKE_REAL_ZVAL_PTR(property);
11443
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
11444
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
11445
if (zptr != NULL) { /* NULL means no success in getting PTR */
11446
SEPARATE_ZVAL_IF_NOT_REF(zptr);
11450
if (!RETURN_VALUE_UNUSED(&opline->result)) {
11452
PZVAL_LOCK(*retval);
11457
if (!have_get_ptr) {
11458
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
11459
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
11461
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
11462
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
11464
if (Z_REFCOUNT_P(z) == 0) {
11465
GC_REMOVE_ZVAL_FROM_BUFFER(z);
11472
SEPARATE_ZVAL_IF_NOT_REF(&z);
11475
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
11476
SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
11479
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
11480
if (!RETURN_VALUE_UNUSED(&opline->result)) {
11481
*retval = EG(uninitialized_zval_ptr);
11482
PZVAL_LOCK(*retval);
11488
zval_ptr_dtor(&property);
11490
zval_dtor(free_op2.var);
11492
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11493
ZEND_VM_NEXT_OPCODE();
11496
static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11498
return zend_pre_incdec_property_helper_SPEC_VAR_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11501
static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11503
return zend_pre_incdec_property_helper_SPEC_VAR_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11506
static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
11508
zend_op *opline = EX(opline);
11509
zend_free_op free_op1, free_op2;
11510
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11512
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11513
zval *retval = &EX_T(opline->result.u.var).tmp_var;
11514
int have_get_ptr = 0;
11516
if (IS_VAR == IS_VAR && !object_ptr) {
11517
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
11520
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
11521
object = *object_ptr;
11523
if (Z_TYPE_P(object) != IS_OBJECT) {
11524
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
11525
zval_dtor(free_op2.var);
11526
*retval = *EG(uninitialized_zval_ptr);
11527
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11528
ZEND_VM_NEXT_OPCODE();
11531
/* here we are sure we are dealing with an object */
11534
MAKE_REAL_ZVAL_PTR(property);
11537
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
11538
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
11539
if (zptr != NULL) { /* NULL means no success in getting PTR */
11541
SEPARATE_ZVAL_IF_NOT_REF(zptr);
11544
zendi_zval_copy_ctor(*retval);
11551
if (!have_get_ptr) {
11552
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
11553
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
11556
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
11557
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
11559
if (Z_REFCOUNT_P(z) == 0) {
11560
GC_REMOVE_ZVAL_FROM_BUFFER(z);
11567
zendi_zval_copy_ctor(*retval);
11568
ALLOC_ZVAL(z_copy);
11570
zendi_zval_copy_ctor(*z_copy);
11571
INIT_PZVAL(z_copy);
11574
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
11575
zval_ptr_dtor(&z_copy);
11578
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
11579
*retval = *EG(uninitialized_zval_ptr);
11584
zval_ptr_dtor(&property);
11586
zval_dtor(free_op2.var);
11588
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11589
ZEND_VM_NEXT_OPCODE();
11592
static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11594
return zend_post_incdec_property_helper_SPEC_VAR_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11597
static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11599
return zend_post_incdec_property_helper_SPEC_VAR_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11602
static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11604
zend_op *opline = EX(opline);
11605
zend_free_op free_op1, free_op2;
11606
zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11609
if (opline->extended_value == ZEND_FETCH_ADD_LOCK &&
11611
EX_T(opline->op1.u.var).var.ptr_ptr) {
11612
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
11614
container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11615
if (IS_VAR == IS_VAR && !container) {
11616
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
11618
zend_fetch_dimension_address_read(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, dim, 1, BP_VAR_R TSRMLS_CC);
11619
zval_dtor(free_op2.var);
11620
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11621
ZEND_VM_NEXT_OPCODE();
11624
static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11626
zend_op *opline = EX(opline);
11627
zend_free_op free_op1, free_op2;
11628
zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11629
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11631
if (IS_VAR == IS_VAR && !container) {
11632
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
11634
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 1, BP_VAR_W TSRMLS_CC);
11635
zval_dtor(free_op2.var);
11636
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
11637
READY_TO_DESTROY(free_op1.var)) {
11638
AI_USE_PTR(EX_T(opline->result.u.var).var);
11639
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
11640
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
11641
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
11644
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11646
/* We are going to assign the result by reference */
11647
if (opline->extended_value) {
11648
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
11649
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
11650
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
11653
ZEND_VM_NEXT_OPCODE();
11656
static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11658
zend_op *opline = EX(opline);
11659
zend_free_op free_op1, free_op2;
11660
zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11661
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11663
if (IS_VAR == IS_VAR && !container) {
11664
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
11666
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 1, BP_VAR_RW TSRMLS_CC);
11667
zval_dtor(free_op2.var);
11668
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
11669
READY_TO_DESTROY(free_op1.var)) {
11670
AI_USE_PTR(EX_T(opline->result.u.var).var);
11671
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
11672
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
11673
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
11676
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11677
ZEND_VM_NEXT_OPCODE();
11680
static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11682
zend_op *opline = EX(opline);
11683
zend_free_op free_op1, free_op2;
11684
zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11685
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11687
if (IS_VAR == IS_VAR && !container) {
11688
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
11690
zend_fetch_dimension_address_read(&EX_T(opline->result.u.var), container, dim, 1, BP_VAR_IS TSRMLS_CC);
11691
zval_dtor(free_op2.var);
11692
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11693
ZEND_VM_NEXT_OPCODE();
11696
static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11698
zend_op *opline = EX(opline);
11699
zend_free_op free_op1, free_op2;
11700
zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11703
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
11704
container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11705
if (IS_VAR == IS_VAR && !container) {
11706
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
11708
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 1, BP_VAR_W TSRMLS_CC);
11709
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
11710
READY_TO_DESTROY(free_op1.var)) {
11711
AI_USE_PTR(EX_T(opline->result.u.var).var);
11712
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
11713
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
11714
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
11718
if (IS_TMP_VAR == IS_UNUSED) {
11719
zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
11721
container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11722
if (IS_VAR == IS_VAR && !container) {
11723
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
11725
zend_fetch_dimension_address_read(&EX_T(opline->result.u.var), container, dim, 1, BP_VAR_R TSRMLS_CC);
11727
zval_dtor(free_op2.var);
11728
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11729
ZEND_VM_NEXT_OPCODE();
11732
static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11734
zend_op *opline = EX(opline);
11735
zend_free_op free_op1, free_op2;
11736
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11737
zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11739
/* Not needed in DIM_UNSET
11740
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
11741
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
11744
if (IS_VAR == IS_CV) {
11745
if (container != &EG(uninitialized_zval_ptr)) {
11746
SEPARATE_ZVAL_IF_NOT_REF(container);
11749
if (IS_VAR == IS_VAR && !container) {
11750
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
11752
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 1, BP_VAR_UNSET TSRMLS_CC);
11753
zval_dtor(free_op2.var);
11754
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
11755
READY_TO_DESTROY(free_op1.var)) {
11756
AI_USE_PTR(EX_T(opline->result.u.var).var);
11757
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
11758
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
11759
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
11762
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11763
if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
11764
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
11766
zend_free_op free_res;
11768
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
11769
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
11770
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
11772
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
11773
FREE_OP_VAR_PTR(free_res);
11775
ZEND_VM_NEXT_OPCODE();
11778
static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_TMP(int type, ZEND_OPCODE_HANDLER_ARGS)
11780
zend_op *opline = EX(opline);
11781
zend_free_op free_op1;
11782
zval *container = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11783
zend_free_op free_op2;
11784
zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11786
if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
11787
if (type != BP_VAR_IS) {
11788
zend_error(E_NOTICE, "Trying to get property of non-object");
11790
if (!RETURN_VALUE_UNUSED(&opline->result)) {
11791
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
11792
PZVAL_LOCK(EG(uninitialized_zval_ptr));
11794
zval_dtor(free_op2.var);
11799
MAKE_REAL_ZVAL_PTR(offset);
11802
/* here we are sure we are dealing with an object */
11803
retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
11805
if (RETURN_VALUE_UNUSED(&opline->result)) {
11806
if (Z_REFCOUNT_P(retval) == 0) {
11807
GC_REMOVE_ZVAL_FROM_BUFFER(retval);
11812
AI_SET_PTR(EX_T(opline->result.u.var).var, retval);
11813
PZVAL_LOCK(retval);
11817
zval_ptr_dtor(&offset);
11819
zval_dtor(free_op2.var);
11823
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11824
ZEND_VM_NEXT_OPCODE();
11827
static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11829
return zend_fetch_property_address_read_helper_SPEC_VAR_TMP(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11832
static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11834
zend_op *opline = EX(opline);
11835
zend_free_op free_op1, free_op2;
11836
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11839
if (IS_VAR == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
11840
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
11841
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
11845
MAKE_REAL_ZVAL_PTR(property);
11847
container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11848
if (IS_VAR == IS_VAR && !container) {
11849
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
11851
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
11853
zval_ptr_dtor(&property);
11855
zval_dtor(free_op2.var);
11857
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
11858
READY_TO_DESTROY(free_op1.var)) {
11859
AI_USE_PTR(EX_T(opline->result.u.var).var);
11860
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
11861
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
11862
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
11865
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11867
/* We are going to assign the result by reference */
11868
if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
11869
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
11870
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
11871
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
11874
ZEND_VM_NEXT_OPCODE();
11877
static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11879
zend_op *opline = EX(opline);
11880
zend_free_op free_op1, free_op2;
11881
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11882
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11885
MAKE_REAL_ZVAL_PTR(property);
11887
if (IS_VAR == IS_VAR && !container) {
11888
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
11890
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_RW TSRMLS_CC);
11892
zval_ptr_dtor(&property);
11894
zval_dtor(free_op2.var);
11896
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
11897
READY_TO_DESTROY(free_op1.var)) {
11898
AI_USE_PTR(EX_T(opline->result.u.var).var);
11899
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
11900
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
11901
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
11904
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11905
ZEND_VM_NEXT_OPCODE();
11908
static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11910
return zend_fetch_property_address_read_helper_SPEC_VAR_TMP(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11913
static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11915
zend_op *opline = EX(opline);
11917
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
11918
/* Behave like FETCH_OBJ_W */
11919
zend_free_op free_op1, free_op2;
11920
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11921
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11924
MAKE_REAL_ZVAL_PTR(property);
11926
if (IS_VAR == IS_VAR && !container) {
11927
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
11929
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
11931
zval_ptr_dtor(&property);
11933
zval_dtor(free_op2.var);
11935
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
11936
READY_TO_DESTROY(free_op1.var)) {
11937
AI_USE_PTR(EX_T(opline->result.u.var).var);
11938
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
11939
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
11940
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
11943
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11944
ZEND_VM_NEXT_OPCODE();
11946
return zend_fetch_property_address_read_helper_SPEC_VAR_TMP(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11950
static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11952
zend_op *opline = EX(opline);
11953
zend_free_op free_op1, free_op2, free_res;
11954
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11955
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11957
if (IS_VAR == IS_CV) {
11958
if (container != &EG(uninitialized_zval_ptr)) {
11959
SEPARATE_ZVAL_IF_NOT_REF(container);
11963
MAKE_REAL_ZVAL_PTR(property);
11965
if (IS_VAR == IS_VAR && !container) {
11966
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
11968
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
11970
zval_ptr_dtor(&property);
11972
zval_dtor(free_op2.var);
11974
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
11975
READY_TO_DESTROY(free_op1.var)) {
11976
AI_USE_PTR(EX_T(opline->result.u.var).var);
11977
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
11978
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
11979
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
11982
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11984
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
11985
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
11986
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
11988
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
11989
FREE_OP_VAR_PTR(free_res);
11990
ZEND_VM_NEXT_OPCODE();
11993
static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11995
zend_op *opline = EX(opline);
11996
zend_op *op_data = opline+1;
11997
zend_free_op free_op1, free_op2;
11998
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11999
zval *property_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12002
MAKE_REAL_ZVAL_PTR(property_name);
12004
if (IS_VAR == IS_VAR && !object_ptr) {
12005
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
12007
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
12009
zval_ptr_dtor(&property_name);
12011
zval_dtor(free_op2.var);
12013
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12014
/* assign_obj has two opcodes! */
12015
ZEND_VM_INC_OPCODE();
12016
ZEND_VM_NEXT_OPCODE();
12019
static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12021
zend_op *opline = EX(opline);
12022
zend_op *op_data = opline+1;
12023
zend_free_op free_op1;
12024
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12026
if (IS_VAR == IS_VAR && !object_ptr) {
12027
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
12029
if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
12030
zend_free_op free_op2;
12031
zval *property_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12034
MAKE_REAL_ZVAL_PTR(property_name);
12036
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
12038
zval_ptr_dtor(&property_name);
12040
zval_dtor(free_op2.var);
12043
zend_free_op free_op2, free_op_data1, free_op_data2;
12045
zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12046
zval **variable_ptr_ptr;
12048
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 1, BP_VAR_W TSRMLS_CC);
12049
zval_dtor(free_op2.var);
12051
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
12052
variable_ptr_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
12053
if (!variable_ptr_ptr) {
12054
if (zend_assign_to_string_offset(&EX_T(op_data->op2.u.var), value, op_data->op1.op_type TSRMLS_CC)) {
12055
if (!RETURN_VALUE_UNUSED(&opline->result)) {
12056
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
12057
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
12058
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
12059
ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(op_data->op2.u.var).str_offset.str)+EX_T(op_data->op2.u.var).str_offset.offset, 1, 1);
12061
} else if (!RETURN_VALUE_UNUSED(&opline->result)) {
12062
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
12063
PZVAL_LOCK(EG(uninitialized_zval_ptr));
12066
value = zend_assign_to_variable(variable_ptr_ptr, value, IS_TMP_FREE(free_op_data1) TSRMLS_CC);
12067
if (!RETURN_VALUE_UNUSED(&opline->result)) {
12068
AI_SET_PTR(EX_T(opline->result.u.var).var, value);
12072
FREE_OP_VAR_PTR(free_op_data2);
12073
FREE_OP_IF_VAR(free_op_data1);
12075
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12076
/* assign_dim has two opcodes! */
12077
ZEND_VM_INC_OPCODE();
12078
ZEND_VM_NEXT_OPCODE();
12081
static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12083
zend_op *opline = EX(opline);
12084
zend_free_op free_op1, free_op2;
12085
zval *value = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12086
zval **variable_ptr_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12088
if (IS_VAR == IS_VAR && !variable_ptr_ptr) {
12089
if (zend_assign_to_string_offset(&EX_T(opline->op1.u.var), value, IS_TMP_VAR TSRMLS_CC)) {
12090
if (!RETURN_VALUE_UNUSED(&opline->result)) {
12091
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
12092
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
12093
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
12094
ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(opline->op1.u.var).str_offset.str)+EX_T(opline->op1.u.var).str_offset.offset, 1, 1);
12096
} else if (!RETURN_VALUE_UNUSED(&opline->result)) {
12097
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
12098
PZVAL_LOCK(EG(uninitialized_zval_ptr));
12101
value = zend_assign_to_variable(variable_ptr_ptr, value, 1 TSRMLS_CC);
12102
if (!RETURN_VALUE_UNUSED(&opline->result)) {
12103
AI_SET_PTR(EX_T(opline->result.u.var).var, value);
12108
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12110
/* zend_assign_to_variable() always takes care of op2, never free it! */
12112
ZEND_VM_NEXT_OPCODE();
12115
static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12117
zend_op *opline = EX(opline);
12118
zval *function_name;
12119
char *function_name_strval;
12120
int function_name_strlen;
12121
zend_free_op free_op1, free_op2;
12123
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
12125
function_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12127
if (Z_TYPE_P(function_name)!=IS_STRING) {
12128
zend_error_noreturn(E_ERROR, "Method name must be a string");
12131
function_name_strval = Z_STRVAL_P(function_name);
12132
function_name_strlen = Z_STRLEN_P(function_name);
12134
EX(object) = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12136
if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
12137
if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
12138
zend_error_noreturn(E_ERROR, "Object does not support method calls");
12141
/* First, locate the function. */
12142
EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
12144
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
12147
EX(called_scope) = Z_OBJCE_P(EX(object));
12149
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
12152
if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) {
12155
if (!PZVAL_IS_REF(EX(object))) {
12156
Z_ADDREF_P(EX(object)); /* For $this pointer */
12159
ALLOC_ZVAL(this_ptr);
12160
INIT_PZVAL_COPY(this_ptr, EX(object));
12161
zval_copy_ctor(this_ptr);
12162
EX(object) = this_ptr;
12166
zval_dtor(free_op2.var);
12167
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12169
ZEND_VM_NEXT_OPCODE();
12172
static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12174
zend_op *opline = EX(opline);
12175
zval *function_name;
12176
zend_class_entry *ce;
12178
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
12180
if (IS_VAR == IS_CONST) {
12181
/* no function found. try a static method in class */
12182
ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
12184
zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL(opline->op1.u.constant));
12186
EX(called_scope) = ce;
12188
ce = EX_T(opline->op1.u.var).class_entry;
12190
if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
12191
EX(called_scope) = EG(called_scope);
12193
EX(called_scope) = ce;
12196
if(IS_TMP_VAR != IS_UNUSED) {
12197
char *function_name_strval = NULL;
12198
int function_name_strlen = 0;
12199
zend_free_op free_op2;
12201
if (IS_TMP_VAR == IS_CONST) {
12202
function_name_strval = Z_STRVAL(opline->op2.u.constant);
12203
function_name_strlen = Z_STRLEN(opline->op2.u.constant);
12205
function_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12207
if (Z_TYPE_P(function_name) != IS_STRING) {
12208
zend_error_noreturn(E_ERROR, "Function name must be a string");
12210
function_name_strval = Z_STRVAL_P(function_name);
12211
function_name_strlen = Z_STRLEN_P(function_name);
12215
if (function_name_strval) {
12216
if (ce->get_static_method) {
12217
EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
12219
EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
12222
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
12226
if (IS_TMP_VAR != IS_CONST) {
12227
zval_dtor(free_op2.var);
12230
if(!ce->constructor) {
12231
zend_error_noreturn(E_ERROR, "Cannot call constructor");
12233
if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
12234
zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
12236
EX(fbc) = ce->constructor;
12239
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
12243
Z_OBJ_HT_P(EG(This))->get_class_entry &&
12244
!instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
12245
/* We are calling method of the other (incompatible) class,
12246
but passing $this. This is done for compatibility with php-4. */
12249
if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
12250
severity = E_STRICT;
12251
verb = "should not";
12253
/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
12254
severity = E_ERROR;
12257
zend_error(severity, "Non-static method %s::%s() %s be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name, verb);
12260
if ((EX(object) = EG(This))) {
12261
Z_ADDREF_P(EX(object));
12262
EX(called_scope) = Z_OBJCE_P(EX(object));
12266
ZEND_VM_NEXT_OPCODE();
12269
static int ZEND_FASTCALL ZEND_CASE_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12271
zend_op *opline = EX(opline);
12272
int switch_expr_is_overloaded=0;
12273
zend_free_op free_op1, free_op2;
12275
if (IS_VAR==IS_VAR) {
12276
if (EX_T(opline->op1.u.var).var.ptr_ptr) {
12277
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
12279
switch_expr_is_overloaded = 1;
12280
Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
12283
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
12284
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
12285
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
12287
zval_dtor(free_op2.var);
12288
if (switch_expr_is_overloaded) {
12289
/* We only free op1 if this is a string offset,
12290
* Since if it is a TMP_VAR, it'll be reused by
12291
* other CASE opcodes (whereas string offsets
12292
* are allocated at each get_zval_ptr())
12294
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12295
EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
12296
EX_T(opline->op1.u.var).var.ptr = NULL;
12298
ZEND_VM_NEXT_OPCODE();
12301
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12303
zend_op *opline = EX(opline);
12304
zend_free_op free_op1, free_op2;
12305
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
12307
zval *offset=_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12309
#if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
12310
zval **expr_ptr_ptr = NULL;
12312
if (opline->extended_value) {
12313
expr_ptr_ptr=_get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12314
expr_ptr = *expr_ptr_ptr;
12316
expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12319
expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12322
if (0) { /* temporary variable */
12325
ALLOC_ZVAL(new_expr);
12326
INIT_PZVAL_COPY(new_expr, expr_ptr);
12327
expr_ptr = new_expr;
12329
#if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
12330
if (opline->extended_value) {
12331
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
12332
expr_ptr = *expr_ptr_ptr;
12333
Z_ADDREF_P(expr_ptr);
12336
if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
12339
ALLOC_ZVAL(new_expr);
12340
INIT_PZVAL_COPY(new_expr, expr_ptr);
12341
expr_ptr = new_expr;
12342
zendi_zval_copy_ctor(*expr_ptr);
12344
Z_ADDREF_P(expr_ptr);
12348
switch (Z_TYPE_P(offset)) {
12350
zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
12354
zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
12357
zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
12360
zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
12363
zend_error(E_WARNING, "Illegal offset type");
12364
zval_ptr_dtor(&expr_ptr);
12368
zval_dtor(free_op2.var);
12370
zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
12372
if (opline->extended_value) {
12373
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12375
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12377
ZEND_VM_NEXT_OPCODE();
12380
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12382
zend_op *opline = EX(opline);
12384
array_init(&EX_T(opline->result.u.var).tmp_var);
12385
if (IS_VAR == IS_UNUSED) {
12386
ZEND_VM_NEXT_OPCODE();
12387
#if 0 || IS_VAR != IS_UNUSED
12389
return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12394
static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12396
zend_op *opline = EX(opline);
12397
zend_free_op free_op1, free_op2;
12398
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12399
zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12401
if (IS_VAR != IS_VAR || container) {
12402
if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
12403
SEPARATE_ZVAL_IF_NOT_REF(container);
12405
switch (Z_TYPE_PP(container)) {
12407
HashTable *ht = Z_ARRVAL_PP(container);
12409
switch (Z_TYPE_P(offset)) {
12411
zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
12416
zend_hash_index_del(ht, Z_LVAL_P(offset));
12419
if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
12420
Z_ADDREF_P(offset);
12422
if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
12423
ht == &EG(symbol_table)) {
12424
zend_execute_data *ex;
12425
ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
12427
for (ex = execute_data; ex; ex = ex->prev_execute_data) {
12428
if (ex->op_array && ex->symbol_table == ht) {
12431
for (i = 0; i < ex->op_array->last_var; i++) {
12432
if (ex->op_array->vars[i].hash_value == hash_value &&
12433
ex->op_array->vars[i].name_len == offset->value.str.len &&
12434
!memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
12442
if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
12443
zval_ptr_dtor(&offset);
12447
zend_hash_del(ht, "", sizeof(""));
12450
zend_error(E_WARNING, "Illegal offset type in unset");
12453
zval_dtor(free_op2.var);
12457
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
12458
zend_error_noreturn(E_ERROR, "Cannot use object as array");
12461
MAKE_REAL_ZVAL_PTR(offset);
12463
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
12465
zval_ptr_dtor(&offset);
12467
zval_dtor(free_op2.var);
12471
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
12472
ZEND_VM_CONTINUE(); /* bailed out before */
12474
zval_dtor(free_op2.var);
12478
zval_dtor(free_op2.var);
12480
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12482
ZEND_VM_NEXT_OPCODE();
12485
static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12487
zend_op *opline = EX(opline);
12488
zend_free_op free_op1, free_op2;
12489
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12490
zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12492
if (IS_VAR != IS_VAR || container) {
12493
if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
12494
SEPARATE_ZVAL_IF_NOT_REF(container);
12496
if (Z_TYPE_PP(container) == IS_OBJECT) {
12498
MAKE_REAL_ZVAL_PTR(offset);
12500
if (Z_OBJ_HT_P(*container)->unset_property) {
12501
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
12503
zend_error(E_NOTICE, "Trying to unset property of non-object");
12506
zval_ptr_dtor(&offset);
12508
zval_dtor(free_op2.var);
12511
zval_dtor(free_op2.var);
12514
zval_dtor(free_op2.var);
12516
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12518
ZEND_VM_NEXT_OPCODE();
12521
static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
12523
zend_op *opline = EX(opline);
12524
zend_free_op free_op1;
12525
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12526
zval **value = NULL;
12529
if (IS_VAR != IS_VAR || container) {
12530
zend_free_op free_op2;
12531
zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12533
if (Z_TYPE_PP(container) == IS_ARRAY) {
12537
ht = Z_ARRVAL_PP(container);
12539
switch (Z_TYPE_P(offset)) {
12541
if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
12548
if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
12553
if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
12558
if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
12563
zend_error(E_WARNING, "Illegal offset type in isset or empty");
12568
switch (opline->extended_value) {
12570
if (isset && Z_TYPE_PP(value) == IS_NULL) {
12577
if (!isset || !i_zend_is_true(*value)) {
12584
zval_dtor(free_op2.var);
12585
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
12587
MAKE_REAL_ZVAL_PTR(offset);
12590
if (Z_OBJ_HT_P(*container)->has_property) {
12591
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
12593
zend_error(E_NOTICE, "Trying to check property of non-object");
12597
if (Z_OBJ_HT_P(*container)->has_dimension) {
12598
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
12600
zend_error(E_NOTICE, "Trying to check element of non-array");
12605
zval_ptr_dtor(&offset);
12607
zval_dtor(free_op2.var);
12609
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
12612
if (Z_TYPE_P(offset) != IS_LONG) {
12614
zval_copy_ctor(&tmp);
12615
convert_to_long(&tmp);
12618
if (Z_TYPE_P(offset) == IS_LONG) {
12619
switch (opline->extended_value) {
12621
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
12626
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
12632
zval_dtor(free_op2.var);
12634
zval_dtor(free_op2.var);
12638
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
12640
switch (opline->extended_value) {
12642
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
12645
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
12649
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12651
ZEND_VM_NEXT_OPCODE();
12654
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12656
return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12659
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12661
return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12664
static int ZEND_FASTCALL ZEND_ADD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12666
zend_op *opline = EX(opline);
12667
zend_free_op free_op1, free_op2;
12669
add_function(&EX_T(opline->result.u.var).tmp_var,
12670
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
12671
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
12672
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12673
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12674
ZEND_VM_NEXT_OPCODE();
12677
static int ZEND_FASTCALL ZEND_SUB_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12679
zend_op *opline = EX(opline);
12680
zend_free_op free_op1, free_op2;
12682
sub_function(&EX_T(opline->result.u.var).tmp_var,
12683
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
12684
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
12685
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12686
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12687
ZEND_VM_NEXT_OPCODE();
12690
static int ZEND_FASTCALL ZEND_MUL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12692
zend_op *opline = EX(opline);
12693
zend_free_op free_op1, free_op2;
12695
mul_function(&EX_T(opline->result.u.var).tmp_var,
12696
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
12697
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
12698
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12699
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12700
ZEND_VM_NEXT_OPCODE();
12703
static int ZEND_FASTCALL ZEND_DIV_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12705
zend_op *opline = EX(opline);
12706
zend_free_op free_op1, free_op2;
12708
div_function(&EX_T(opline->result.u.var).tmp_var,
12709
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
12710
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
12711
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12712
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12713
ZEND_VM_NEXT_OPCODE();
12716
static int ZEND_FASTCALL ZEND_MOD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12718
zend_op *opline = EX(opline);
12719
zend_free_op free_op1, free_op2;
12721
mod_function(&EX_T(opline->result.u.var).tmp_var,
12722
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
12723
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
12724
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12725
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12726
ZEND_VM_NEXT_OPCODE();
12729
static int ZEND_FASTCALL ZEND_SL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12731
zend_op *opline = EX(opline);
12732
zend_free_op free_op1, free_op2;
12734
shift_left_function(&EX_T(opline->result.u.var).tmp_var,
12735
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
12736
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
12737
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12738
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12739
ZEND_VM_NEXT_OPCODE();
12742
static int ZEND_FASTCALL ZEND_SR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12744
zend_op *opline = EX(opline);
12745
zend_free_op free_op1, free_op2;
12747
shift_right_function(&EX_T(opline->result.u.var).tmp_var,
12748
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
12749
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
12750
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12751
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12752
ZEND_VM_NEXT_OPCODE();
12755
static int ZEND_FASTCALL ZEND_CONCAT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12757
zend_op *opline = EX(opline);
12758
zend_free_op free_op1, free_op2;
12760
concat_function(&EX_T(opline->result.u.var).tmp_var,
12761
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
12762
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
12763
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12764
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12765
ZEND_VM_NEXT_OPCODE();
12768
static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12770
zend_op *opline = EX(opline);
12771
zend_free_op free_op1, free_op2;
12773
is_identical_function(&EX_T(opline->result.u.var).tmp_var,
12774
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
12775
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
12776
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12777
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12778
ZEND_VM_NEXT_OPCODE();
12781
static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12783
zend_op *opline = EX(opline);
12784
zend_free_op free_op1, free_op2;
12785
zval *result = &EX_T(opline->result.u.var).tmp_var;
12787
is_identical_function(result,
12788
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
12789
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
12790
Z_LVAL_P(result) = !Z_LVAL_P(result);
12791
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12792
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12793
ZEND_VM_NEXT_OPCODE();
12796
static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12798
zend_op *opline = EX(opline);
12799
zend_free_op free_op1, free_op2;
12800
zval *result = &EX_T(opline->result.u.var).tmp_var;
12802
compare_function(result,
12803
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
12804
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
12805
ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
12806
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12807
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12808
ZEND_VM_NEXT_OPCODE();
12811
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12813
zend_op *opline = EX(opline);
12814
zend_free_op free_op1, free_op2;
12815
zval *result = &EX_T(opline->result.u.var).tmp_var;
12817
compare_function(result,
12818
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
12819
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
12820
ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
12821
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12822
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12823
ZEND_VM_NEXT_OPCODE();
12826
static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12828
zend_op *opline = EX(opline);
12829
zend_free_op free_op1, free_op2;
12830
zval *result = &EX_T(opline->result.u.var).tmp_var;
12832
compare_function(result,
12833
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
12834
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
12835
ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
12836
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12837
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12838
ZEND_VM_NEXT_OPCODE();
12841
static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12843
zend_op *opline = EX(opline);
12844
zend_free_op free_op1, free_op2;
12845
zval *result = &EX_T(opline->result.u.var).tmp_var;
12847
compare_function(result,
12848
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
12849
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
12850
ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
12851
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12852
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12853
ZEND_VM_NEXT_OPCODE();
12856
static int ZEND_FASTCALL ZEND_BW_OR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12858
zend_op *opline = EX(opline);
12859
zend_free_op free_op1, free_op2;
12861
bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
12862
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
12863
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
12864
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12865
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12866
ZEND_VM_NEXT_OPCODE();
12869
static int ZEND_FASTCALL ZEND_BW_AND_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12871
zend_op *opline = EX(opline);
12872
zend_free_op free_op1, free_op2;
12874
bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
12875
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
12876
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
12877
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12878
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12879
ZEND_VM_NEXT_OPCODE();
12882
static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12884
zend_op *opline = EX(opline);
12885
zend_free_op free_op1, free_op2;
12887
bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
12888
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
12889
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
12890
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12891
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12892
ZEND_VM_NEXT_OPCODE();
12895
static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12897
zend_op *opline = EX(opline);
12898
zend_free_op free_op1, free_op2;
12900
boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
12901
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
12902
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
12903
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12904
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12905
ZEND_VM_NEXT_OPCODE();
12908
static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
12910
zend_op *opline = EX(opline);
12911
zend_op *op_data = opline+1;
12912
zend_free_op free_op1, free_op2, free_op_data1;
12913
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12915
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12916
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
12917
znode *result = &opline->result;
12918
int have_get_ptr = 0;
12920
if (IS_VAR == IS_VAR && !object_ptr) {
12921
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
12924
EX_T(result->u.var).var.ptr_ptr = NULL;
12925
make_real_object(object_ptr TSRMLS_CC);
12926
object = *object_ptr;
12928
if (Z_TYPE_P(object) != IS_OBJECT) {
12929
zend_error(E_WARNING, "Attempt to assign property of non-object");
12930
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12931
FREE_OP(free_op_data1);
12933
if (!RETURN_VALUE_UNUSED(result)) {
12934
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
12935
EX_T(result->u.var).var.ptr_ptr = NULL;
12936
PZVAL_LOCK(EG(uninitialized_zval_ptr));
12939
/* here we are sure we are dealing with an object */
12941
MAKE_REAL_ZVAL_PTR(property);
12944
/* here property is a string */
12945
if (opline->extended_value == ZEND_ASSIGN_OBJ
12946
&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
12947
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
12948
if (zptr != NULL) { /* NULL means no success in getting PTR */
12949
SEPARATE_ZVAL_IF_NOT_REF(zptr);
12952
binary_op(*zptr, *zptr, value TSRMLS_CC);
12953
if (!RETURN_VALUE_UNUSED(result)) {
12954
EX_T(result->u.var).var.ptr = *zptr;
12955
EX_T(result->u.var).var.ptr_ptr = NULL;
12961
if (!have_get_ptr) {
12964
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
12965
if (Z_OBJ_HT_P(object)->read_property) {
12966
z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
12968
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
12969
if (Z_OBJ_HT_P(object)->read_dimension) {
12970
z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
12974
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
12975
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
12977
if (Z_REFCOUNT_P(z) == 0) {
12978
GC_REMOVE_ZVAL_FROM_BUFFER(z);
12985
SEPARATE_ZVAL_IF_NOT_REF(&z);
12986
binary_op(z, z, value TSRMLS_CC);
12987
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
12988
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
12989
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
12990
Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
12992
if (!RETURN_VALUE_UNUSED(result)) {
12993
EX_T(result->u.var).var.ptr = z;
12994
EX_T(result->u.var).var.ptr_ptr = NULL;
12999
zend_error(E_WARNING, "Attempt to assign property of non-object");
13000
if (!RETURN_VALUE_UNUSED(result)) {
13001
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
13002
EX_T(result->u.var).var.ptr_ptr = NULL;
13003
PZVAL_LOCK(EG(uninitialized_zval_ptr));
13009
zval_ptr_dtor(&property);
13011
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13013
FREE_OP(free_op_data1);
13016
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13017
/* assign_obj has two opcodes! */
13018
ZEND_VM_INC_OPCODE();
13019
ZEND_VM_NEXT_OPCODE();
13022
static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
13024
zend_op *opline = EX(opline);
13025
zend_free_op free_op1, free_op2, free_op_data2, free_op_data1;
13029
switch (opline->extended_value) {
13030
case ZEND_ASSIGN_OBJ:
13031
return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13033
case ZEND_ASSIGN_DIM: {
13034
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13036
if (IS_VAR == IS_VAR && !container) {
13037
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
13038
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
13039
if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
13040
Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
13042
return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13044
zend_op *op_data = opline+1;
13045
zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13047
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), container, dim, 0, BP_VAR_RW TSRMLS_CC);
13048
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
13049
var_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
13050
ZEND_VM_INC_OPCODE();
13055
value = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13056
var_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13062
zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
13065
if (*var_ptr == EG(error_zval_ptr)) {
13066
if (!RETURN_VALUE_UNUSED(&opline->result)) {
13067
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
13068
PZVAL_LOCK(EG(uninitialized_zval_ptr));
13070
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13071
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13072
ZEND_VM_NEXT_OPCODE();
13075
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
13077
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
13078
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
13080
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
13081
Z_ADDREF_P(objval);
13082
binary_op(objval, objval, value TSRMLS_CC);
13083
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
13084
zval_ptr_dtor(&objval);
13086
binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
13089
if (!RETURN_VALUE_UNUSED(&opline->result)) {
13090
AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
13091
PZVAL_LOCK(*var_ptr);
13093
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13095
if (opline->extended_value == ZEND_ASSIGN_DIM) {
13096
FREE_OP(free_op_data1);
13097
FREE_OP_VAR_PTR(free_op_data2);
13099
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13100
ZEND_VM_NEXT_OPCODE();
13103
static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13105
return zend_binary_assign_op_helper_SPEC_VAR_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13108
static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13110
return zend_binary_assign_op_helper_SPEC_VAR_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13113
static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13115
return zend_binary_assign_op_helper_SPEC_VAR_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13118
static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13120
return zend_binary_assign_op_helper_SPEC_VAR_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13123
static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13125
return zend_binary_assign_op_helper_SPEC_VAR_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13128
static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13130
return zend_binary_assign_op_helper_SPEC_VAR_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13133
static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13135
return zend_binary_assign_op_helper_SPEC_VAR_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13138
static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13140
return zend_binary_assign_op_helper_SPEC_VAR_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13143
static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13145
return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13148
static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13150
return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13153
static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13155
return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13158
static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
13160
zend_op *opline = EX(opline);
13161
zend_free_op free_op1, free_op2;
13162
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13164
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13165
zval **retval = &EX_T(opline->result.u.var).var.ptr;
13166
int have_get_ptr = 0;
13168
if (IS_VAR == IS_VAR && !object_ptr) {
13169
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
13172
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
13173
object = *object_ptr;
13175
if (Z_TYPE_P(object) != IS_OBJECT) {
13176
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
13177
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13178
if (!RETURN_VALUE_UNUSED(&opline->result)) {
13179
*retval = EG(uninitialized_zval_ptr);
13180
PZVAL_LOCK(*retval);
13182
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13183
ZEND_VM_NEXT_OPCODE();
13186
/* here we are sure we are dealing with an object */
13189
MAKE_REAL_ZVAL_PTR(property);
13192
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
13193
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
13194
if (zptr != NULL) { /* NULL means no success in getting PTR */
13195
SEPARATE_ZVAL_IF_NOT_REF(zptr);
13199
if (!RETURN_VALUE_UNUSED(&opline->result)) {
13201
PZVAL_LOCK(*retval);
13206
if (!have_get_ptr) {
13207
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
13208
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
13210
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
13211
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
13213
if (Z_REFCOUNT_P(z) == 0) {
13214
GC_REMOVE_ZVAL_FROM_BUFFER(z);
13221
SEPARATE_ZVAL_IF_NOT_REF(&z);
13224
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
13225
SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
13228
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
13229
if (!RETURN_VALUE_UNUSED(&opline->result)) {
13230
*retval = EG(uninitialized_zval_ptr);
13231
PZVAL_LOCK(*retval);
13237
zval_ptr_dtor(&property);
13239
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13241
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13242
ZEND_VM_NEXT_OPCODE();
13245
static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13247
return zend_pre_incdec_property_helper_SPEC_VAR_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13250
static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13252
return zend_pre_incdec_property_helper_SPEC_VAR_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13255
static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
13257
zend_op *opline = EX(opline);
13258
zend_free_op free_op1, free_op2;
13259
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13261
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13262
zval *retval = &EX_T(opline->result.u.var).tmp_var;
13263
int have_get_ptr = 0;
13265
if (IS_VAR == IS_VAR && !object_ptr) {
13266
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
13269
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
13270
object = *object_ptr;
13272
if (Z_TYPE_P(object) != IS_OBJECT) {
13273
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
13274
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13275
*retval = *EG(uninitialized_zval_ptr);
13276
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13277
ZEND_VM_NEXT_OPCODE();
13280
/* here we are sure we are dealing with an object */
13283
MAKE_REAL_ZVAL_PTR(property);
13286
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
13287
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
13288
if (zptr != NULL) { /* NULL means no success in getting PTR */
13290
SEPARATE_ZVAL_IF_NOT_REF(zptr);
13293
zendi_zval_copy_ctor(*retval);
13300
if (!have_get_ptr) {
13301
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
13302
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
13305
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
13306
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
13308
if (Z_REFCOUNT_P(z) == 0) {
13309
GC_REMOVE_ZVAL_FROM_BUFFER(z);
13316
zendi_zval_copy_ctor(*retval);
13317
ALLOC_ZVAL(z_copy);
13319
zendi_zval_copy_ctor(*z_copy);
13320
INIT_PZVAL(z_copy);
13323
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
13324
zval_ptr_dtor(&z_copy);
13327
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
13328
*retval = *EG(uninitialized_zval_ptr);
13333
zval_ptr_dtor(&property);
13335
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13337
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13338
ZEND_VM_NEXT_OPCODE();
13341
static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13343
return zend_post_incdec_property_helper_SPEC_VAR_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13346
static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13348
return zend_post_incdec_property_helper_SPEC_VAR_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13351
static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13353
zend_op *opline = EX(opline);
13354
zend_free_op free_op1, free_op2;
13355
zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13358
if (opline->extended_value == ZEND_FETCH_ADD_LOCK &&
13360
EX_T(opline->op1.u.var).var.ptr_ptr) {
13361
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
13363
container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13364
if (IS_VAR == IS_VAR && !container) {
13365
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
13367
zend_fetch_dimension_address_read(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_R TSRMLS_CC);
13368
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13369
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13370
ZEND_VM_NEXT_OPCODE();
13373
static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13375
zend_op *opline = EX(opline);
13376
zend_free_op free_op1, free_op2;
13377
zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13378
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13380
if (IS_VAR == IS_VAR && !container) {
13381
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
13383
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_W TSRMLS_CC);
13384
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13385
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
13386
READY_TO_DESTROY(free_op1.var)) {
13387
AI_USE_PTR(EX_T(opline->result.u.var).var);
13388
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
13389
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
13390
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
13393
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13395
/* We are going to assign the result by reference */
13396
if (opline->extended_value) {
13397
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
13398
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
13399
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
13402
ZEND_VM_NEXT_OPCODE();
13405
static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13407
zend_op *opline = EX(opline);
13408
zend_free_op free_op1, free_op2;
13409
zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13410
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13412
if (IS_VAR == IS_VAR && !container) {
13413
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
13415
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_RW TSRMLS_CC);
13416
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13417
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
13418
READY_TO_DESTROY(free_op1.var)) {
13419
AI_USE_PTR(EX_T(opline->result.u.var).var);
13420
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
13421
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
13422
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
13425
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13426
ZEND_VM_NEXT_OPCODE();
13429
static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13431
zend_op *opline = EX(opline);
13432
zend_free_op free_op1, free_op2;
13433
zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13434
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13436
if (IS_VAR == IS_VAR && !container) {
13437
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
13439
zend_fetch_dimension_address_read(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_IS TSRMLS_CC);
13440
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13441
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13442
ZEND_VM_NEXT_OPCODE();
13445
static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13447
zend_op *opline = EX(opline);
13448
zend_free_op free_op1, free_op2;
13449
zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13452
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
13453
container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13454
if (IS_VAR == IS_VAR && !container) {
13455
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
13457
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_W TSRMLS_CC);
13458
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
13459
READY_TO_DESTROY(free_op1.var)) {
13460
AI_USE_PTR(EX_T(opline->result.u.var).var);
13461
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
13462
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
13463
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
13467
if (IS_VAR == IS_UNUSED) {
13468
zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
13470
container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13471
if (IS_VAR == IS_VAR && !container) {
13472
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
13474
zend_fetch_dimension_address_read(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_R TSRMLS_CC);
13476
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13477
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13478
ZEND_VM_NEXT_OPCODE();
13481
static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13483
zend_op *opline = EX(opline);
13484
zend_free_op free_op1, free_op2;
13485
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13486
zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13488
/* Not needed in DIM_UNSET
13489
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
13490
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
13493
if (IS_VAR == IS_CV) {
13494
if (container != &EG(uninitialized_zval_ptr)) {
13495
SEPARATE_ZVAL_IF_NOT_REF(container);
13498
if (IS_VAR == IS_VAR && !container) {
13499
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
13501
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_UNSET TSRMLS_CC);
13502
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13503
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
13504
READY_TO_DESTROY(free_op1.var)) {
13505
AI_USE_PTR(EX_T(opline->result.u.var).var);
13506
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
13507
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
13508
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
13511
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13512
if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
13513
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
13515
zend_free_op free_res;
13517
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
13518
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
13519
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
13521
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
13522
FREE_OP_VAR_PTR(free_res);
13524
ZEND_VM_NEXT_OPCODE();
13527
static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
13529
zend_op *opline = EX(opline);
13530
zend_free_op free_op1;
13531
zval *container = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13532
zend_free_op free_op2;
13533
zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13535
if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
13536
if (type != BP_VAR_IS) {
13537
zend_error(E_NOTICE, "Trying to get property of non-object");
13539
if (!RETURN_VALUE_UNUSED(&opline->result)) {
13540
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
13541
PZVAL_LOCK(EG(uninitialized_zval_ptr));
13543
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13548
MAKE_REAL_ZVAL_PTR(offset);
13551
/* here we are sure we are dealing with an object */
13552
retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
13554
if (RETURN_VALUE_UNUSED(&opline->result)) {
13555
if (Z_REFCOUNT_P(retval) == 0) {
13556
GC_REMOVE_ZVAL_FROM_BUFFER(retval);
13561
AI_SET_PTR(EX_T(opline->result.u.var).var, retval);
13562
PZVAL_LOCK(retval);
13566
zval_ptr_dtor(&offset);
13568
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13572
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13573
ZEND_VM_NEXT_OPCODE();
13576
static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13578
return zend_fetch_property_address_read_helper_SPEC_VAR_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13581
static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13583
zend_op *opline = EX(opline);
13584
zend_free_op free_op1, free_op2;
13585
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13588
if (IS_VAR == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
13589
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
13590
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
13594
MAKE_REAL_ZVAL_PTR(property);
13596
container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13597
if (IS_VAR == IS_VAR && !container) {
13598
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
13600
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
13602
zval_ptr_dtor(&property);
13604
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13606
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
13607
READY_TO_DESTROY(free_op1.var)) {
13608
AI_USE_PTR(EX_T(opline->result.u.var).var);
13609
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
13610
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
13611
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
13614
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13616
/* We are going to assign the result by reference */
13617
if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
13618
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
13619
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
13620
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
13623
ZEND_VM_NEXT_OPCODE();
13626
static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13628
zend_op *opline = EX(opline);
13629
zend_free_op free_op1, free_op2;
13630
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13631
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13634
MAKE_REAL_ZVAL_PTR(property);
13636
if (IS_VAR == IS_VAR && !container) {
13637
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
13639
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_RW TSRMLS_CC);
13641
zval_ptr_dtor(&property);
13643
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13645
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
13646
READY_TO_DESTROY(free_op1.var)) {
13647
AI_USE_PTR(EX_T(opline->result.u.var).var);
13648
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
13649
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
13650
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
13653
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13654
ZEND_VM_NEXT_OPCODE();
13657
static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13659
return zend_fetch_property_address_read_helper_SPEC_VAR_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13662
static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13664
zend_op *opline = EX(opline);
13666
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
13667
/* Behave like FETCH_OBJ_W */
13668
zend_free_op free_op1, free_op2;
13669
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13670
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13673
MAKE_REAL_ZVAL_PTR(property);
13675
if (IS_VAR == IS_VAR && !container) {
13676
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
13678
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
13680
zval_ptr_dtor(&property);
13682
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13684
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
13685
READY_TO_DESTROY(free_op1.var)) {
13686
AI_USE_PTR(EX_T(opline->result.u.var).var);
13687
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
13688
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
13689
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
13692
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13693
ZEND_VM_NEXT_OPCODE();
13695
return zend_fetch_property_address_read_helper_SPEC_VAR_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13699
static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13701
zend_op *opline = EX(opline);
13702
zend_free_op free_op1, free_op2, free_res;
13703
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13704
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13706
if (IS_VAR == IS_CV) {
13707
if (container != &EG(uninitialized_zval_ptr)) {
13708
SEPARATE_ZVAL_IF_NOT_REF(container);
13712
MAKE_REAL_ZVAL_PTR(property);
13714
if (IS_VAR == IS_VAR && !container) {
13715
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
13717
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
13719
zval_ptr_dtor(&property);
13721
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13723
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
13724
READY_TO_DESTROY(free_op1.var)) {
13725
AI_USE_PTR(EX_T(opline->result.u.var).var);
13726
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
13727
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
13728
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
13731
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13733
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
13734
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
13735
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
13737
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
13738
FREE_OP_VAR_PTR(free_res);
13739
ZEND_VM_NEXT_OPCODE();
13742
static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13744
zend_op *opline = EX(opline);
13745
zend_op *op_data = opline+1;
13746
zend_free_op free_op1, free_op2;
13747
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13748
zval *property_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13751
MAKE_REAL_ZVAL_PTR(property_name);
13753
if (IS_VAR == IS_VAR && !object_ptr) {
13754
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
13756
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
13758
zval_ptr_dtor(&property_name);
13760
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13762
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13763
/* assign_obj has two opcodes! */
13764
ZEND_VM_INC_OPCODE();
13765
ZEND_VM_NEXT_OPCODE();
13768
static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13770
zend_op *opline = EX(opline);
13771
zend_op *op_data = opline+1;
13772
zend_free_op free_op1;
13773
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13775
if (IS_VAR == IS_VAR && !object_ptr) {
13776
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
13778
if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
13779
zend_free_op free_op2;
13780
zval *property_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13783
MAKE_REAL_ZVAL_PTR(property_name);
13785
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
13787
zval_ptr_dtor(&property_name);
13789
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13792
zend_free_op free_op2, free_op_data1, free_op_data2;
13794
zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13795
zval **variable_ptr_ptr;
13797
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
13798
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13800
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
13801
variable_ptr_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
13802
if (!variable_ptr_ptr) {
13803
if (zend_assign_to_string_offset(&EX_T(op_data->op2.u.var), value, op_data->op1.op_type TSRMLS_CC)) {
13804
if (!RETURN_VALUE_UNUSED(&opline->result)) {
13805
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
13806
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
13807
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
13808
ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(op_data->op2.u.var).str_offset.str)+EX_T(op_data->op2.u.var).str_offset.offset, 1, 1);
13810
} else if (!RETURN_VALUE_UNUSED(&opline->result)) {
13811
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
13812
PZVAL_LOCK(EG(uninitialized_zval_ptr));
13815
value = zend_assign_to_variable(variable_ptr_ptr, value, IS_TMP_FREE(free_op_data1) TSRMLS_CC);
13816
if (!RETURN_VALUE_UNUSED(&opline->result)) {
13817
AI_SET_PTR(EX_T(opline->result.u.var).var, value);
13821
FREE_OP_VAR_PTR(free_op_data2);
13822
FREE_OP_IF_VAR(free_op_data1);
13824
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13825
/* assign_dim has two opcodes! */
13826
ZEND_VM_INC_OPCODE();
13827
ZEND_VM_NEXT_OPCODE();
13830
static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13832
zend_op *opline = EX(opline);
13833
zend_free_op free_op1, free_op2;
13834
zval *value = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13835
zval **variable_ptr_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13837
if (IS_VAR == IS_VAR && !variable_ptr_ptr) {
13838
if (zend_assign_to_string_offset(&EX_T(opline->op1.u.var), value, IS_VAR TSRMLS_CC)) {
13839
if (!RETURN_VALUE_UNUSED(&opline->result)) {
13840
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
13841
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
13842
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
13843
ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(opline->op1.u.var).str_offset.str)+EX_T(opline->op1.u.var).str_offset.offset, 1, 1);
13845
} else if (!RETURN_VALUE_UNUSED(&opline->result)) {
13846
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
13847
PZVAL_LOCK(EG(uninitialized_zval_ptr));
13850
value = zend_assign_to_variable(variable_ptr_ptr, value, 0 TSRMLS_CC);
13851
if (!RETURN_VALUE_UNUSED(&opline->result)) {
13852
AI_SET_PTR(EX_T(opline->result.u.var).var, value);
13857
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13859
/* zend_assign_to_variable() always takes care of op2, never free it! */
13860
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13862
ZEND_VM_NEXT_OPCODE();
13865
static int ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13867
zend_op *opline = EX(opline);
13868
zend_free_op free_op1, free_op2;
13869
zval **variable_ptr_ptr;
13870
zval **value_ptr_ptr = _get_zval_ptr_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13872
if (IS_VAR == IS_VAR &&
13874
!Z_ISREF_PP(value_ptr_ptr) &&
13875
opline->extended_value == ZEND_RETURNS_FUNCTION &&
13876
!EX_T(opline->op2.u.var).var.fcall_returned_reference) {
13877
if (free_op2.var == NULL) {
13878
PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
13880
zend_error(E_STRICT, "Only variables should be assigned by reference");
13881
if (UNEXPECTED(EG(exception) != NULL)) {
13882
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13883
ZEND_VM_NEXT_OPCODE();
13885
return ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13886
} else if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
13887
PZVAL_LOCK(*value_ptr_ptr);
13889
if (IS_VAR == IS_VAR && EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
13890
zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object");
13893
variable_ptr_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13894
if ((IS_VAR == IS_VAR && !value_ptr_ptr) ||
13895
(IS_VAR == IS_VAR && !variable_ptr_ptr)) {
13896
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
13898
zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
13900
if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
13901
Z_DELREF_PP(variable_ptr_ptr);
13904
if (!RETURN_VALUE_UNUSED(&opline->result)) {
13905
AI_SET_PTR(EX_T(opline->result.u.var).var, *variable_ptr_ptr);
13906
PZVAL_LOCK(*variable_ptr_ptr);
13909
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13910
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13912
ZEND_VM_NEXT_OPCODE();
13915
static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13917
zend_op *opline = EX(opline);
13918
zval *function_name;
13919
char *function_name_strval;
13920
int function_name_strlen;
13921
zend_free_op free_op1, free_op2;
13923
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
13925
function_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
13927
if (Z_TYPE_P(function_name)!=IS_STRING) {
13928
zend_error_noreturn(E_ERROR, "Method name must be a string");
13931
function_name_strval = Z_STRVAL_P(function_name);
13932
function_name_strlen = Z_STRLEN_P(function_name);
13934
EX(object) = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13936
if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
13937
if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
13938
zend_error_noreturn(E_ERROR, "Object does not support method calls");
13941
/* First, locate the function. */
13942
EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
13944
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
13947
EX(called_scope) = Z_OBJCE_P(EX(object));
13949
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
13952
if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) {
13955
if (!PZVAL_IS_REF(EX(object))) {
13956
Z_ADDREF_P(EX(object)); /* For $this pointer */
13959
ALLOC_ZVAL(this_ptr);
13960
INIT_PZVAL_COPY(this_ptr, EX(object));
13961
zval_copy_ctor(this_ptr);
13962
EX(object) = this_ptr;
13966
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
13967
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13969
ZEND_VM_NEXT_OPCODE();
13972
static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13974
zend_op *opline = EX(opline);
13975
zval *function_name;
13976
zend_class_entry *ce;
13978
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
13980
if (IS_VAR == IS_CONST) {
13981
/* no function found. try a static method in class */
13982
ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
13984
zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL(opline->op1.u.constant));
13986
EX(called_scope) = ce;
13988
ce = EX_T(opline->op1.u.var).class_entry;
13990
if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
13991
EX(called_scope) = EG(called_scope);
13993
EX(called_scope) = ce;
13996
if(IS_VAR != IS_UNUSED) {
13997
char *function_name_strval = NULL;
13998
int function_name_strlen = 0;
13999
zend_free_op free_op2;
14001
if (IS_VAR == IS_CONST) {
14002
function_name_strval = Z_STRVAL(opline->op2.u.constant);
14003
function_name_strlen = Z_STRLEN(opline->op2.u.constant);
14005
function_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
14007
if (Z_TYPE_P(function_name) != IS_STRING) {
14008
zend_error_noreturn(E_ERROR, "Function name must be a string");
14010
function_name_strval = Z_STRVAL_P(function_name);
14011
function_name_strlen = Z_STRLEN_P(function_name);
14015
if (function_name_strval) {
14016
if (ce->get_static_method) {
14017
EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
14019
EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
14022
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
14026
if (IS_VAR != IS_CONST) {
14027
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
14030
if(!ce->constructor) {
14031
zend_error_noreturn(E_ERROR, "Cannot call constructor");
14033
if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
14034
zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
14036
EX(fbc) = ce->constructor;
14039
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
14043
Z_OBJ_HT_P(EG(This))->get_class_entry &&
14044
!instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
14045
/* We are calling method of the other (incompatible) class,
14046
but passing $this. This is done for compatibility with php-4. */
14049
if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
14050
severity = E_STRICT;
14051
verb = "should not";
14053
/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
14054
severity = E_ERROR;
14057
zend_error(severity, "Non-static method %s::%s() %s be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name, verb);
14060
if ((EX(object) = EG(This))) {
14061
Z_ADDREF_P(EX(object));
14062
EX(called_scope) = Z_OBJCE_P(EX(object));
14066
ZEND_VM_NEXT_OPCODE();
14069
static int ZEND_FASTCALL ZEND_CASE_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14071
zend_op *opline = EX(opline);
14072
int switch_expr_is_overloaded=0;
14073
zend_free_op free_op1, free_op2;
14075
if (IS_VAR==IS_VAR) {
14076
if (EX_T(opline->op1.u.var).var.ptr_ptr) {
14077
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
14079
switch_expr_is_overloaded = 1;
14080
Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
14083
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
14084
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
14085
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
14087
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
14088
if (switch_expr_is_overloaded) {
14089
/* We only free op1 if this is a string offset,
14090
* Since if it is a TMP_VAR, it'll be reused by
14091
* other CASE opcodes (whereas string offsets
14092
* are allocated at each get_zval_ptr())
14094
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14095
EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
14096
EX_T(opline->op1.u.var).var.ptr = NULL;
14098
ZEND_VM_NEXT_OPCODE();
14101
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14103
zend_op *opline = EX(opline);
14104
zend_free_op free_op1, free_op2;
14105
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
14107
zval *offset=_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
14109
#if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
14110
zval **expr_ptr_ptr = NULL;
14112
if (opline->extended_value) {
14113
expr_ptr_ptr=_get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14114
expr_ptr = *expr_ptr_ptr;
14116
expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14119
expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14122
if (0) { /* temporary variable */
14125
ALLOC_ZVAL(new_expr);
14126
INIT_PZVAL_COPY(new_expr, expr_ptr);
14127
expr_ptr = new_expr;
14129
#if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
14130
if (opline->extended_value) {
14131
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
14132
expr_ptr = *expr_ptr_ptr;
14133
Z_ADDREF_P(expr_ptr);
14136
if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
14139
ALLOC_ZVAL(new_expr);
14140
INIT_PZVAL_COPY(new_expr, expr_ptr);
14141
expr_ptr = new_expr;
14142
zendi_zval_copy_ctor(*expr_ptr);
14144
Z_ADDREF_P(expr_ptr);
14148
switch (Z_TYPE_P(offset)) {
14150
zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
14154
zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
14157
zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
14160
zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
14163
zend_error(E_WARNING, "Illegal offset type");
14164
zval_ptr_dtor(&expr_ptr);
14168
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
14170
zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
14172
if (opline->extended_value) {
14173
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14175
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14177
ZEND_VM_NEXT_OPCODE();
14180
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14182
zend_op *opline = EX(opline);
14184
array_init(&EX_T(opline->result.u.var).tmp_var);
14185
if (IS_VAR == IS_UNUSED) {
14186
ZEND_VM_NEXT_OPCODE();
14187
#if 0 || IS_VAR != IS_UNUSED
14189
return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14194
static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14196
zend_op *opline = EX(opline);
14197
zend_free_op free_op1, free_op2;
14198
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14199
zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
14201
if (IS_VAR != IS_VAR || container) {
14202
if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
14203
SEPARATE_ZVAL_IF_NOT_REF(container);
14205
switch (Z_TYPE_PP(container)) {
14207
HashTable *ht = Z_ARRVAL_PP(container);
14209
switch (Z_TYPE_P(offset)) {
14211
zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
14216
zend_hash_index_del(ht, Z_LVAL_P(offset));
14219
if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
14220
Z_ADDREF_P(offset);
14222
if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
14223
ht == &EG(symbol_table)) {
14224
zend_execute_data *ex;
14225
ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
14227
for (ex = execute_data; ex; ex = ex->prev_execute_data) {
14228
if (ex->op_array && ex->symbol_table == ht) {
14231
for (i = 0; i < ex->op_array->last_var; i++) {
14232
if (ex->op_array->vars[i].hash_value == hash_value &&
14233
ex->op_array->vars[i].name_len == offset->value.str.len &&
14234
!memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
14242
if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
14243
zval_ptr_dtor(&offset);
14247
zend_hash_del(ht, "", sizeof(""));
14250
zend_error(E_WARNING, "Illegal offset type in unset");
14253
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
14257
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
14258
zend_error_noreturn(E_ERROR, "Cannot use object as array");
14261
MAKE_REAL_ZVAL_PTR(offset);
14263
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
14265
zval_ptr_dtor(&offset);
14267
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
14271
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
14272
ZEND_VM_CONTINUE(); /* bailed out before */
14274
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
14278
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
14280
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14282
ZEND_VM_NEXT_OPCODE();
14285
static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14287
zend_op *opline = EX(opline);
14288
zend_free_op free_op1, free_op2;
14289
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14290
zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
14292
if (IS_VAR != IS_VAR || container) {
14293
if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
14294
SEPARATE_ZVAL_IF_NOT_REF(container);
14296
if (Z_TYPE_PP(container) == IS_OBJECT) {
14298
MAKE_REAL_ZVAL_PTR(offset);
14300
if (Z_OBJ_HT_P(*container)->unset_property) {
14301
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
14303
zend_error(E_NOTICE, "Trying to unset property of non-object");
14306
zval_ptr_dtor(&offset);
14308
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
14311
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
14314
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
14316
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14318
ZEND_VM_NEXT_OPCODE();
14321
static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
14323
zend_op *opline = EX(opline);
14324
zend_free_op free_op1;
14325
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14326
zval **value = NULL;
14329
if (IS_VAR != IS_VAR || container) {
14330
zend_free_op free_op2;
14331
zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
14333
if (Z_TYPE_PP(container) == IS_ARRAY) {
14337
ht = Z_ARRVAL_PP(container);
14339
switch (Z_TYPE_P(offset)) {
14341
if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
14348
if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
14353
if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
14358
if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
14363
zend_error(E_WARNING, "Illegal offset type in isset or empty");
14368
switch (opline->extended_value) {
14370
if (isset && Z_TYPE_PP(value) == IS_NULL) {
14377
if (!isset || !i_zend_is_true(*value)) {
14384
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
14385
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
14387
MAKE_REAL_ZVAL_PTR(offset);
14390
if (Z_OBJ_HT_P(*container)->has_property) {
14391
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
14393
zend_error(E_NOTICE, "Trying to check property of non-object");
14397
if (Z_OBJ_HT_P(*container)->has_dimension) {
14398
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
14400
zend_error(E_NOTICE, "Trying to check element of non-array");
14405
zval_ptr_dtor(&offset);
14407
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
14409
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
14412
if (Z_TYPE_P(offset) != IS_LONG) {
14414
zval_copy_ctor(&tmp);
14415
convert_to_long(&tmp);
14418
if (Z_TYPE_P(offset) == IS_LONG) {
14419
switch (opline->extended_value) {
14421
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
14426
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
14432
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
14434
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
14438
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
14440
switch (opline->extended_value) {
14442
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
14445
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
14449
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14451
ZEND_VM_NEXT_OPCODE();
14454
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14456
return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14459
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14461
return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14464
static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
14466
zend_op *opline = EX(opline);
14467
zend_op *op_data = opline+1;
14468
zend_free_op free_op1, free_op_data1;
14469
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14471
zval *property = NULL;
14472
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
14473
znode *result = &opline->result;
14474
int have_get_ptr = 0;
14476
if (IS_VAR == IS_VAR && !object_ptr) {
14477
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
14480
EX_T(result->u.var).var.ptr_ptr = NULL;
14481
make_real_object(object_ptr TSRMLS_CC);
14482
object = *object_ptr;
14484
if (Z_TYPE_P(object) != IS_OBJECT) {
14485
zend_error(E_WARNING, "Attempt to assign property of non-object");
14487
FREE_OP(free_op_data1);
14489
if (!RETURN_VALUE_UNUSED(result)) {
14490
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
14491
EX_T(result->u.var).var.ptr_ptr = NULL;
14492
PZVAL_LOCK(EG(uninitialized_zval_ptr));
14495
/* here we are sure we are dealing with an object */
14497
MAKE_REAL_ZVAL_PTR(property);
14500
/* here property is a string */
14501
if (opline->extended_value == ZEND_ASSIGN_OBJ
14502
&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
14503
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
14504
if (zptr != NULL) { /* NULL means no success in getting PTR */
14505
SEPARATE_ZVAL_IF_NOT_REF(zptr);
14508
binary_op(*zptr, *zptr, value TSRMLS_CC);
14509
if (!RETURN_VALUE_UNUSED(result)) {
14510
EX_T(result->u.var).var.ptr = *zptr;
14511
EX_T(result->u.var).var.ptr_ptr = NULL;
14517
if (!have_get_ptr) {
14520
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
14521
if (Z_OBJ_HT_P(object)->read_property) {
14522
z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
14524
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
14525
if (Z_OBJ_HT_P(object)->read_dimension) {
14526
z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
14530
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
14531
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
14533
if (Z_REFCOUNT_P(z) == 0) {
14534
GC_REMOVE_ZVAL_FROM_BUFFER(z);
14541
SEPARATE_ZVAL_IF_NOT_REF(&z);
14542
binary_op(z, z, value TSRMLS_CC);
14543
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
14544
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
14545
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
14546
Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
14548
if (!RETURN_VALUE_UNUSED(result)) {
14549
EX_T(result->u.var).var.ptr = z;
14550
EX_T(result->u.var).var.ptr_ptr = NULL;
14555
zend_error(E_WARNING, "Attempt to assign property of non-object");
14556
if (!RETURN_VALUE_UNUSED(result)) {
14557
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
14558
EX_T(result->u.var).var.ptr_ptr = NULL;
14559
PZVAL_LOCK(EG(uninitialized_zval_ptr));
14565
zval_ptr_dtor(&property);
14569
FREE_OP(free_op_data1);
14572
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14573
/* assign_obj has two opcodes! */
14574
ZEND_VM_INC_OPCODE();
14575
ZEND_VM_NEXT_OPCODE();
14578
static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
14580
zend_op *opline = EX(opline);
14581
zend_free_op free_op1, free_op_data2, free_op_data1;
14585
switch (opline->extended_value) {
14586
case ZEND_ASSIGN_OBJ:
14587
return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14589
case ZEND_ASSIGN_DIM: {
14590
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14592
if (IS_VAR == IS_VAR && !container) {
14593
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
14594
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
14595
if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
14596
Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
14598
return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14600
zend_op *op_data = opline+1;
14603
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), container, dim, 0, BP_VAR_RW TSRMLS_CC);
14604
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
14605
var_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
14606
ZEND_VM_INC_OPCODE();
14612
var_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14618
zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
14621
if (*var_ptr == EG(error_zval_ptr)) {
14622
if (!RETURN_VALUE_UNUSED(&opline->result)) {
14623
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
14624
PZVAL_LOCK(EG(uninitialized_zval_ptr));
14627
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14628
ZEND_VM_NEXT_OPCODE();
14631
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
14633
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
14634
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
14636
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
14637
Z_ADDREF_P(objval);
14638
binary_op(objval, objval, value TSRMLS_CC);
14639
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
14640
zval_ptr_dtor(&objval);
14642
binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
14645
if (!RETURN_VALUE_UNUSED(&opline->result)) {
14646
AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
14647
PZVAL_LOCK(*var_ptr);
14650
if (opline->extended_value == ZEND_ASSIGN_DIM) {
14651
FREE_OP(free_op_data1);
14652
FREE_OP_VAR_PTR(free_op_data2);
14654
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14655
ZEND_VM_NEXT_OPCODE();
14658
static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14660
return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14663
static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14665
return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14668
static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14670
return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14673
static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14675
return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14678
static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14680
return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14683
static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14685
return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14688
static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14690
return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14693
static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14695
return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14698
static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14700
return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14703
static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14705
return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14708
static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14710
return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14713
static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14715
zend_op *opline = EX(opline);
14716
zend_free_op free_op1;
14718
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14720
if (IS_VAR == IS_VAR && !container) {
14721
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
14723
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_W TSRMLS_CC);
14725
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
14726
READY_TO_DESTROY(free_op1.var)) {
14727
AI_USE_PTR(EX_T(opline->result.u.var).var);
14728
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
14729
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
14730
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
14733
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14735
/* We are going to assign the result by reference */
14736
if (opline->extended_value) {
14737
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
14738
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
14739
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
14742
ZEND_VM_NEXT_OPCODE();
14745
static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14747
zend_op *opline = EX(opline);
14748
zend_free_op free_op1;
14750
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14752
if (IS_VAR == IS_VAR && !container) {
14753
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
14755
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_RW TSRMLS_CC);
14757
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
14758
READY_TO_DESTROY(free_op1.var)) {
14759
AI_USE_PTR(EX_T(opline->result.u.var).var);
14760
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
14761
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
14762
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
14765
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14766
ZEND_VM_NEXT_OPCODE();
14769
static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14771
zend_op *opline = EX(opline);
14772
zend_free_op free_op1;
14776
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
14777
container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14778
if (IS_VAR == IS_VAR && !container) {
14779
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
14781
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_W TSRMLS_CC);
14782
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
14783
READY_TO_DESTROY(free_op1.var)) {
14784
AI_USE_PTR(EX_T(opline->result.u.var).var);
14785
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
14786
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
14787
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
14791
if (IS_UNUSED == IS_UNUSED) {
14792
zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
14794
container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14795
if (IS_VAR == IS_VAR && !container) {
14796
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
14798
zend_fetch_dimension_address_read(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_R TSRMLS_CC);
14801
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14802
ZEND_VM_NEXT_OPCODE();
14805
static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14807
zend_op *opline = EX(opline);
14808
zend_op *op_data = opline+1;
14809
zend_free_op free_op1;
14810
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14812
if (IS_VAR == IS_VAR && !object_ptr) {
14813
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
14815
if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
14817
zval *property_name = NULL;
14820
MAKE_REAL_ZVAL_PTR(property_name);
14822
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
14824
zval_ptr_dtor(&property_name);
14829
zend_free_op free_op_data1, free_op_data2;
14832
zval **variable_ptr_ptr;
14834
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
14836
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
14837
variable_ptr_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
14838
if (!variable_ptr_ptr) {
14839
if (zend_assign_to_string_offset(&EX_T(op_data->op2.u.var), value, op_data->op1.op_type TSRMLS_CC)) {
14840
if (!RETURN_VALUE_UNUSED(&opline->result)) {
14841
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
14842
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
14843
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
14844
ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(op_data->op2.u.var).str_offset.str)+EX_T(op_data->op2.u.var).str_offset.offset, 1, 1);
14846
} else if (!RETURN_VALUE_UNUSED(&opline->result)) {
14847
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
14848
PZVAL_LOCK(EG(uninitialized_zval_ptr));
14851
value = zend_assign_to_variable(variable_ptr_ptr, value, IS_TMP_FREE(free_op_data1) TSRMLS_CC);
14852
if (!RETURN_VALUE_UNUSED(&opline->result)) {
14853
AI_SET_PTR(EX_T(opline->result.u.var).var, value);
14857
FREE_OP_VAR_PTR(free_op_data2);
14858
FREE_OP_IF_VAR(free_op_data1);
14860
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14861
/* assign_dim has two opcodes! */
14862
ZEND_VM_INC_OPCODE();
14863
ZEND_VM_NEXT_OPCODE();
14866
static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14868
zend_op *opline = EX(opline);
14869
zval *function_name;
14870
zend_class_entry *ce;
14872
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
14874
if (IS_VAR == IS_CONST) {
14875
/* no function found. try a static method in class */
14876
ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
14878
zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL(opline->op1.u.constant));
14880
EX(called_scope) = ce;
14882
ce = EX_T(opline->op1.u.var).class_entry;
14884
if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
14885
EX(called_scope) = EG(called_scope);
14887
EX(called_scope) = ce;
14890
if(IS_UNUSED != IS_UNUSED) {
14891
char *function_name_strval = NULL;
14892
int function_name_strlen = 0;
14895
if (IS_UNUSED == IS_CONST) {
14896
function_name_strval = Z_STRVAL(opline->op2.u.constant);
14897
function_name_strlen = Z_STRLEN(opline->op2.u.constant);
14899
function_name = NULL;
14901
if (Z_TYPE_P(function_name) != IS_STRING) {
14902
zend_error_noreturn(E_ERROR, "Function name must be a string");
14904
function_name_strval = Z_STRVAL_P(function_name);
14905
function_name_strlen = Z_STRLEN_P(function_name);
14909
if (function_name_strval) {
14910
if (ce->get_static_method) {
14911
EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
14913
EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
14916
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
14920
if (IS_UNUSED != IS_CONST) {
14924
if(!ce->constructor) {
14925
zend_error_noreturn(E_ERROR, "Cannot call constructor");
14927
if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
14928
zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
14930
EX(fbc) = ce->constructor;
14933
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
14937
Z_OBJ_HT_P(EG(This))->get_class_entry &&
14938
!instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
14939
/* We are calling method of the other (incompatible) class,
14940
but passing $this. This is done for compatibility with php-4. */
14943
if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
14944
severity = E_STRICT;
14945
verb = "should not";
14947
/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
14948
severity = E_ERROR;
14951
zend_error(severity, "Non-static method %s::%s() %s be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name, verb);
14954
if ((EX(object) = EG(This))) {
14955
Z_ADDREF_P(EX(object));
14956
EX(called_scope) = Z_OBJCE_P(EX(object));
14960
ZEND_VM_NEXT_OPCODE();
14963
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14965
zend_op *opline = EX(opline);
14966
zend_free_op free_op1;
14967
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
14971
#if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
14972
zval **expr_ptr_ptr = NULL;
14974
if (opline->extended_value) {
14975
expr_ptr_ptr=_get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14976
expr_ptr = *expr_ptr_ptr;
14978
expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14981
expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14984
if (0) { /* temporary variable */
14987
ALLOC_ZVAL(new_expr);
14988
INIT_PZVAL_COPY(new_expr, expr_ptr);
14989
expr_ptr = new_expr;
14991
#if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
14992
if (opline->extended_value) {
14993
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
14994
expr_ptr = *expr_ptr_ptr;
14995
Z_ADDREF_P(expr_ptr);
14998
if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
15001
ALLOC_ZVAL(new_expr);
15002
INIT_PZVAL_COPY(new_expr, expr_ptr);
15003
expr_ptr = new_expr;
15004
zendi_zval_copy_ctor(*expr_ptr);
15006
Z_ADDREF_P(expr_ptr);
15010
switch (Z_TYPE_P(offset)) {
15012
zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
15016
zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
15019
zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
15022
zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
15025
zend_error(E_WARNING, "Illegal offset type");
15026
zval_ptr_dtor(&expr_ptr);
15032
zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
15034
if (opline->extended_value) {
15035
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15037
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15039
ZEND_VM_NEXT_OPCODE();
15042
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15044
zend_op *opline = EX(opline);
15046
array_init(&EX_T(opline->result.u.var).tmp_var);
15047
if (IS_VAR == IS_UNUSED) {
15048
ZEND_VM_NEXT_OPCODE();
15049
#if 0 || IS_VAR != IS_UNUSED
15051
return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15056
static int ZEND_FASTCALL ZEND_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15058
zend_op *opline = EX(opline);
15059
zend_free_op free_op1;
15061
add_function(&EX_T(opline->result.u.var).tmp_var,
15062
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
15063
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
15064
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15066
ZEND_VM_NEXT_OPCODE();
15069
static int ZEND_FASTCALL ZEND_SUB_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15071
zend_op *opline = EX(opline);
15072
zend_free_op free_op1;
15074
sub_function(&EX_T(opline->result.u.var).tmp_var,
15075
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
15076
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
15077
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15079
ZEND_VM_NEXT_OPCODE();
15082
static int ZEND_FASTCALL ZEND_MUL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15084
zend_op *opline = EX(opline);
15085
zend_free_op free_op1;
15087
mul_function(&EX_T(opline->result.u.var).tmp_var,
15088
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
15089
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
15090
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15092
ZEND_VM_NEXT_OPCODE();
15095
static int ZEND_FASTCALL ZEND_DIV_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15097
zend_op *opline = EX(opline);
15098
zend_free_op free_op1;
15100
div_function(&EX_T(opline->result.u.var).tmp_var,
15101
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
15102
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
15103
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15105
ZEND_VM_NEXT_OPCODE();
15108
static int ZEND_FASTCALL ZEND_MOD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15110
zend_op *opline = EX(opline);
15111
zend_free_op free_op1;
15113
mod_function(&EX_T(opline->result.u.var).tmp_var,
15114
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
15115
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
15116
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15118
ZEND_VM_NEXT_OPCODE();
15121
static int ZEND_FASTCALL ZEND_SL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15123
zend_op *opline = EX(opline);
15124
zend_free_op free_op1;
15126
shift_left_function(&EX_T(opline->result.u.var).tmp_var,
15127
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
15128
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
15129
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15131
ZEND_VM_NEXT_OPCODE();
15134
static int ZEND_FASTCALL ZEND_SR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15136
zend_op *opline = EX(opline);
15137
zend_free_op free_op1;
15139
shift_right_function(&EX_T(opline->result.u.var).tmp_var,
15140
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
15141
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
15142
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15144
ZEND_VM_NEXT_OPCODE();
15147
static int ZEND_FASTCALL ZEND_CONCAT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15149
zend_op *opline = EX(opline);
15150
zend_free_op free_op1;
15152
concat_function(&EX_T(opline->result.u.var).tmp_var,
15153
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
15154
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
15155
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15157
ZEND_VM_NEXT_OPCODE();
15160
static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15162
zend_op *opline = EX(opline);
15163
zend_free_op free_op1;
15165
is_identical_function(&EX_T(opline->result.u.var).tmp_var,
15166
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
15167
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
15168
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15170
ZEND_VM_NEXT_OPCODE();
15173
static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15175
zend_op *opline = EX(opline);
15176
zend_free_op free_op1;
15177
zval *result = &EX_T(opline->result.u.var).tmp_var;
15179
is_identical_function(result,
15180
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
15181
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
15182
Z_LVAL_P(result) = !Z_LVAL_P(result);
15183
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15185
ZEND_VM_NEXT_OPCODE();
15188
static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15190
zend_op *opline = EX(opline);
15191
zend_free_op free_op1;
15192
zval *result = &EX_T(opline->result.u.var).tmp_var;
15194
compare_function(result,
15195
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
15196
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
15197
ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
15198
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15200
ZEND_VM_NEXT_OPCODE();
15203
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15205
zend_op *opline = EX(opline);
15206
zend_free_op free_op1;
15207
zval *result = &EX_T(opline->result.u.var).tmp_var;
15209
compare_function(result,
15210
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
15211
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
15212
ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
15213
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15215
ZEND_VM_NEXT_OPCODE();
15218
static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15220
zend_op *opline = EX(opline);
15221
zend_free_op free_op1;
15222
zval *result = &EX_T(opline->result.u.var).tmp_var;
15224
compare_function(result,
15225
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
15226
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
15227
ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
15228
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15230
ZEND_VM_NEXT_OPCODE();
15233
static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15235
zend_op *opline = EX(opline);
15236
zend_free_op free_op1;
15237
zval *result = &EX_T(opline->result.u.var).tmp_var;
15239
compare_function(result,
15240
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
15241
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
15242
ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
15243
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15245
ZEND_VM_NEXT_OPCODE();
15248
static int ZEND_FASTCALL ZEND_BW_OR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15250
zend_op *opline = EX(opline);
15251
zend_free_op free_op1;
15253
bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
15254
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
15255
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
15256
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15258
ZEND_VM_NEXT_OPCODE();
15261
static int ZEND_FASTCALL ZEND_BW_AND_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15263
zend_op *opline = EX(opline);
15264
zend_free_op free_op1;
15266
bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
15267
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
15268
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
15269
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15271
ZEND_VM_NEXT_OPCODE();
15274
static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15276
zend_op *opline = EX(opline);
15277
zend_free_op free_op1;
15279
bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
15280
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
15281
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
15282
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15284
ZEND_VM_NEXT_OPCODE();
15287
static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15289
zend_op *opline = EX(opline);
15290
zend_free_op free_op1;
15292
boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
15293
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
15294
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
15295
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15297
ZEND_VM_NEXT_OPCODE();
15300
static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
15302
zend_op *opline = EX(opline);
15303
zend_op *op_data = opline+1;
15304
zend_free_op free_op1, free_op_data1;
15305
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
15307
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
15308
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
15309
znode *result = &opline->result;
15310
int have_get_ptr = 0;
15312
if (IS_VAR == IS_VAR && !object_ptr) {
15313
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
15316
EX_T(result->u.var).var.ptr_ptr = NULL;
15317
make_real_object(object_ptr TSRMLS_CC);
15318
object = *object_ptr;
15320
if (Z_TYPE_P(object) != IS_OBJECT) {
15321
zend_error(E_WARNING, "Attempt to assign property of non-object");
15323
FREE_OP(free_op_data1);
15325
if (!RETURN_VALUE_UNUSED(result)) {
15326
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
15327
EX_T(result->u.var).var.ptr_ptr = NULL;
15328
PZVAL_LOCK(EG(uninitialized_zval_ptr));
15331
/* here we are sure we are dealing with an object */
15333
MAKE_REAL_ZVAL_PTR(property);
15336
/* here property is a string */
15337
if (opline->extended_value == ZEND_ASSIGN_OBJ
15338
&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
15339
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
15340
if (zptr != NULL) { /* NULL means no success in getting PTR */
15341
SEPARATE_ZVAL_IF_NOT_REF(zptr);
15344
binary_op(*zptr, *zptr, value TSRMLS_CC);
15345
if (!RETURN_VALUE_UNUSED(result)) {
15346
EX_T(result->u.var).var.ptr = *zptr;
15347
EX_T(result->u.var).var.ptr_ptr = NULL;
15353
if (!have_get_ptr) {
15356
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
15357
if (Z_OBJ_HT_P(object)->read_property) {
15358
z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
15360
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
15361
if (Z_OBJ_HT_P(object)->read_dimension) {
15362
z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
15366
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
15367
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
15369
if (Z_REFCOUNT_P(z) == 0) {
15370
GC_REMOVE_ZVAL_FROM_BUFFER(z);
15377
SEPARATE_ZVAL_IF_NOT_REF(&z);
15378
binary_op(z, z, value TSRMLS_CC);
15379
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
15380
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
15381
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
15382
Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
15384
if (!RETURN_VALUE_UNUSED(result)) {
15385
EX_T(result->u.var).var.ptr = z;
15386
EX_T(result->u.var).var.ptr_ptr = NULL;
15391
zend_error(E_WARNING, "Attempt to assign property of non-object");
15392
if (!RETURN_VALUE_UNUSED(result)) {
15393
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
15394
EX_T(result->u.var).var.ptr_ptr = NULL;
15395
PZVAL_LOCK(EG(uninitialized_zval_ptr));
15401
zval_ptr_dtor(&property);
15405
FREE_OP(free_op_data1);
15408
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15409
/* assign_obj has two opcodes! */
15410
ZEND_VM_INC_OPCODE();
15411
ZEND_VM_NEXT_OPCODE();
15414
static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
15416
zend_op *opline = EX(opline);
15417
zend_free_op free_op1, free_op_data2, free_op_data1;
15421
switch (opline->extended_value) {
15422
case ZEND_ASSIGN_OBJ:
15423
return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15425
case ZEND_ASSIGN_DIM: {
15426
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
15428
if (IS_VAR == IS_VAR && !container) {
15429
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
15430
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
15431
if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
15432
Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
15434
return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15436
zend_op *op_data = opline+1;
15437
zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
15439
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), container, dim, 0, BP_VAR_RW TSRMLS_CC);
15440
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
15441
var_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
15442
ZEND_VM_INC_OPCODE();
15447
value = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
15448
var_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
15454
zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
15457
if (*var_ptr == EG(error_zval_ptr)) {
15458
if (!RETURN_VALUE_UNUSED(&opline->result)) {
15459
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
15460
PZVAL_LOCK(EG(uninitialized_zval_ptr));
15463
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15464
ZEND_VM_NEXT_OPCODE();
15467
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
15469
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
15470
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
15472
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
15473
Z_ADDREF_P(objval);
15474
binary_op(objval, objval, value TSRMLS_CC);
15475
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
15476
zval_ptr_dtor(&objval);
15478
binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
15481
if (!RETURN_VALUE_UNUSED(&opline->result)) {
15482
AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
15483
PZVAL_LOCK(*var_ptr);
15486
if (opline->extended_value == ZEND_ASSIGN_DIM) {
15487
FREE_OP(free_op_data1);
15488
FREE_OP_VAR_PTR(free_op_data2);
15490
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15491
ZEND_VM_NEXT_OPCODE();
15494
static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15496
return zend_binary_assign_op_helper_SPEC_VAR_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15499
static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15501
return zend_binary_assign_op_helper_SPEC_VAR_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15504
static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15506
return zend_binary_assign_op_helper_SPEC_VAR_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15509
static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15511
return zend_binary_assign_op_helper_SPEC_VAR_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15514
static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15516
return zend_binary_assign_op_helper_SPEC_VAR_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15519
static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15521
return zend_binary_assign_op_helper_SPEC_VAR_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15524
static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15526
return zend_binary_assign_op_helper_SPEC_VAR_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15529
static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15531
return zend_binary_assign_op_helper_SPEC_VAR_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15534
static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15536
return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15539
static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15541
return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15544
static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15546
return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15549
static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
15551
zend_op *opline = EX(opline);
15552
zend_free_op free_op1;
15553
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
15555
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
15556
zval **retval = &EX_T(opline->result.u.var).var.ptr;
15557
int have_get_ptr = 0;
15559
if (IS_VAR == IS_VAR && !object_ptr) {
15560
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
15563
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
15564
object = *object_ptr;
15566
if (Z_TYPE_P(object) != IS_OBJECT) {
15567
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
15569
if (!RETURN_VALUE_UNUSED(&opline->result)) {
15570
*retval = EG(uninitialized_zval_ptr);
15571
PZVAL_LOCK(*retval);
15573
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15574
ZEND_VM_NEXT_OPCODE();
15577
/* here we are sure we are dealing with an object */
15580
MAKE_REAL_ZVAL_PTR(property);
15583
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
15584
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
15585
if (zptr != NULL) { /* NULL means no success in getting PTR */
15586
SEPARATE_ZVAL_IF_NOT_REF(zptr);
15590
if (!RETURN_VALUE_UNUSED(&opline->result)) {
15592
PZVAL_LOCK(*retval);
15597
if (!have_get_ptr) {
15598
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
15599
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
15601
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
15602
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
15604
if (Z_REFCOUNT_P(z) == 0) {
15605
GC_REMOVE_ZVAL_FROM_BUFFER(z);
15612
SEPARATE_ZVAL_IF_NOT_REF(&z);
15615
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
15616
SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
15619
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
15620
if (!RETURN_VALUE_UNUSED(&opline->result)) {
15621
*retval = EG(uninitialized_zval_ptr);
15622
PZVAL_LOCK(*retval);
15628
zval_ptr_dtor(&property);
15632
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15633
ZEND_VM_NEXT_OPCODE();
15636
static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15638
return zend_pre_incdec_property_helper_SPEC_VAR_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15641
static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15643
return zend_pre_incdec_property_helper_SPEC_VAR_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15646
static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
15648
zend_op *opline = EX(opline);
15649
zend_free_op free_op1;
15650
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
15652
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
15653
zval *retval = &EX_T(opline->result.u.var).tmp_var;
15654
int have_get_ptr = 0;
15656
if (IS_VAR == IS_VAR && !object_ptr) {
15657
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
15660
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
15661
object = *object_ptr;
15663
if (Z_TYPE_P(object) != IS_OBJECT) {
15664
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
15666
*retval = *EG(uninitialized_zval_ptr);
15667
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15668
ZEND_VM_NEXT_OPCODE();
15671
/* here we are sure we are dealing with an object */
15674
MAKE_REAL_ZVAL_PTR(property);
15677
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
15678
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
15679
if (zptr != NULL) { /* NULL means no success in getting PTR */
15681
SEPARATE_ZVAL_IF_NOT_REF(zptr);
15684
zendi_zval_copy_ctor(*retval);
15691
if (!have_get_ptr) {
15692
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
15693
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
15696
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
15697
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
15699
if (Z_REFCOUNT_P(z) == 0) {
15700
GC_REMOVE_ZVAL_FROM_BUFFER(z);
15707
zendi_zval_copy_ctor(*retval);
15708
ALLOC_ZVAL(z_copy);
15710
zendi_zval_copy_ctor(*z_copy);
15711
INIT_PZVAL(z_copy);
15714
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
15715
zval_ptr_dtor(&z_copy);
15718
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
15719
*retval = *EG(uninitialized_zval_ptr);
15724
zval_ptr_dtor(&property);
15728
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15729
ZEND_VM_NEXT_OPCODE();
15732
static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15734
return zend_post_incdec_property_helper_SPEC_VAR_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15737
static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15739
return zend_post_incdec_property_helper_SPEC_VAR_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15742
static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15744
zend_op *opline = EX(opline);
15745
zend_free_op free_op1;
15746
zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
15749
if (opline->extended_value == ZEND_FETCH_ADD_LOCK &&
15751
EX_T(opline->op1.u.var).var.ptr_ptr) {
15752
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
15754
container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
15755
if (IS_VAR == IS_VAR && !container) {
15756
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
15758
zend_fetch_dimension_address_read(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_R TSRMLS_CC);
15760
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15761
ZEND_VM_NEXT_OPCODE();
15764
static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15766
zend_op *opline = EX(opline);
15767
zend_free_op free_op1;
15768
zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
15769
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
15771
if (IS_VAR == IS_VAR && !container) {
15772
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
15774
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_W TSRMLS_CC);
15776
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
15777
READY_TO_DESTROY(free_op1.var)) {
15778
AI_USE_PTR(EX_T(opline->result.u.var).var);
15779
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
15780
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
15781
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
15784
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15786
/* We are going to assign the result by reference */
15787
if (opline->extended_value) {
15788
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
15789
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
15790
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
15793
ZEND_VM_NEXT_OPCODE();
15796
static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15798
zend_op *opline = EX(opline);
15799
zend_free_op free_op1;
15800
zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
15801
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
15803
if (IS_VAR == IS_VAR && !container) {
15804
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
15806
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_RW TSRMLS_CC);
15808
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
15809
READY_TO_DESTROY(free_op1.var)) {
15810
AI_USE_PTR(EX_T(opline->result.u.var).var);
15811
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
15812
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
15813
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
15816
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15817
ZEND_VM_NEXT_OPCODE();
15820
static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15822
zend_op *opline = EX(opline);
15823
zend_free_op free_op1;
15824
zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
15825
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
15827
if (IS_VAR == IS_VAR && !container) {
15828
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
15830
zend_fetch_dimension_address_read(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_IS TSRMLS_CC);
15832
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15833
ZEND_VM_NEXT_OPCODE();
15836
static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15838
zend_op *opline = EX(opline);
15839
zend_free_op free_op1;
15840
zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
15843
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
15844
container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
15845
if (IS_VAR == IS_VAR && !container) {
15846
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
15848
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_W TSRMLS_CC);
15849
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
15850
READY_TO_DESTROY(free_op1.var)) {
15851
AI_USE_PTR(EX_T(opline->result.u.var).var);
15852
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
15853
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
15854
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
15858
if (IS_CV == IS_UNUSED) {
15859
zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
15861
container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
15862
if (IS_VAR == IS_VAR && !container) {
15863
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
15865
zend_fetch_dimension_address_read(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_R TSRMLS_CC);
15868
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15869
ZEND_VM_NEXT_OPCODE();
15872
static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15874
zend_op *opline = EX(opline);
15875
zend_free_op free_op1;
15876
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
15877
zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
15879
/* Not needed in DIM_UNSET
15880
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
15881
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
15884
if (IS_VAR == IS_CV) {
15885
if (container != &EG(uninitialized_zval_ptr)) {
15886
SEPARATE_ZVAL_IF_NOT_REF(container);
15889
if (IS_VAR == IS_VAR && !container) {
15890
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
15892
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_UNSET TSRMLS_CC);
15894
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
15895
READY_TO_DESTROY(free_op1.var)) {
15896
AI_USE_PTR(EX_T(opline->result.u.var).var);
15897
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
15898
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
15899
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
15902
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15903
if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
15904
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
15906
zend_free_op free_res;
15908
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
15909
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
15910
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
15912
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
15913
FREE_OP_VAR_PTR(free_res);
15915
ZEND_VM_NEXT_OPCODE();
15918
static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CV(int type, ZEND_OPCODE_HANDLER_ARGS)
15920
zend_op *opline = EX(opline);
15921
zend_free_op free_op1;
15922
zval *container = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
15924
zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
15926
if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
15927
if (type != BP_VAR_IS) {
15928
zend_error(E_NOTICE, "Trying to get property of non-object");
15930
if (!RETURN_VALUE_UNUSED(&opline->result)) {
15931
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
15932
PZVAL_LOCK(EG(uninitialized_zval_ptr));
15939
MAKE_REAL_ZVAL_PTR(offset);
15942
/* here we are sure we are dealing with an object */
15943
retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
15945
if (RETURN_VALUE_UNUSED(&opline->result)) {
15946
if (Z_REFCOUNT_P(retval) == 0) {
15947
GC_REMOVE_ZVAL_FROM_BUFFER(retval);
15952
AI_SET_PTR(EX_T(opline->result.u.var).var, retval);
15953
PZVAL_LOCK(retval);
15957
zval_ptr_dtor(&offset);
15963
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
15964
ZEND_VM_NEXT_OPCODE();
15967
static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15969
return zend_fetch_property_address_read_helper_SPEC_VAR_CV(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15972
static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15974
zend_op *opline = EX(opline);
15975
zend_free_op free_op1;
15976
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
15979
if (IS_VAR == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
15980
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
15981
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
15985
MAKE_REAL_ZVAL_PTR(property);
15987
container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
15988
if (IS_VAR == IS_VAR && !container) {
15989
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
15991
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
15993
zval_ptr_dtor(&property);
15997
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
15998
READY_TO_DESTROY(free_op1.var)) {
15999
AI_USE_PTR(EX_T(opline->result.u.var).var);
16000
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
16001
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
16002
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
16005
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
16007
/* We are going to assign the result by reference */
16008
if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
16009
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
16010
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
16011
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
16014
ZEND_VM_NEXT_OPCODE();
16017
static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16019
zend_op *opline = EX(opline);
16020
zend_free_op free_op1;
16021
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
16022
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
16025
MAKE_REAL_ZVAL_PTR(property);
16027
if (IS_VAR == IS_VAR && !container) {
16028
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
16030
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_RW TSRMLS_CC);
16032
zval_ptr_dtor(&property);
16036
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
16037
READY_TO_DESTROY(free_op1.var)) {
16038
AI_USE_PTR(EX_T(opline->result.u.var).var);
16039
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
16040
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
16041
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
16044
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
16045
ZEND_VM_NEXT_OPCODE();
16048
static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16050
return zend_fetch_property_address_read_helper_SPEC_VAR_CV(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16053
static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16055
zend_op *opline = EX(opline);
16057
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
16058
/* Behave like FETCH_OBJ_W */
16059
zend_free_op free_op1;
16060
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
16061
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
16064
MAKE_REAL_ZVAL_PTR(property);
16066
if (IS_VAR == IS_VAR && !container) {
16067
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
16069
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
16071
zval_ptr_dtor(&property);
16075
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
16076
READY_TO_DESTROY(free_op1.var)) {
16077
AI_USE_PTR(EX_T(opline->result.u.var).var);
16078
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
16079
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
16080
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
16083
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
16084
ZEND_VM_NEXT_OPCODE();
16086
return zend_fetch_property_address_read_helper_SPEC_VAR_CV(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16090
static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16092
zend_op *opline = EX(opline);
16093
zend_free_op free_op1, free_res;
16094
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
16095
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
16097
if (IS_VAR == IS_CV) {
16098
if (container != &EG(uninitialized_zval_ptr)) {
16099
SEPARATE_ZVAL_IF_NOT_REF(container);
16103
MAKE_REAL_ZVAL_PTR(property);
16105
if (IS_VAR == IS_VAR && !container) {
16106
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
16108
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
16110
zval_ptr_dtor(&property);
16114
if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
16115
READY_TO_DESTROY(free_op1.var)) {
16116
AI_USE_PTR(EX_T(opline->result.u.var).var);
16117
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
16118
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
16119
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
16122
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
16124
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
16125
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
16126
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
16128
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
16129
FREE_OP_VAR_PTR(free_res);
16130
ZEND_VM_NEXT_OPCODE();
16133
static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16135
zend_op *opline = EX(opline);
16136
zend_op *op_data = opline+1;
16137
zend_free_op free_op1;
16138
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
16139
zval *property_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
16142
MAKE_REAL_ZVAL_PTR(property_name);
16144
if (IS_VAR == IS_VAR && !object_ptr) {
16145
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
16147
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
16149
zval_ptr_dtor(&property_name);
16153
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
16154
/* assign_obj has two opcodes! */
16155
ZEND_VM_INC_OPCODE();
16156
ZEND_VM_NEXT_OPCODE();
16159
static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16161
zend_op *opline = EX(opline);
16162
zend_op *op_data = opline+1;
16163
zend_free_op free_op1;
16164
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
16166
if (IS_VAR == IS_VAR && !object_ptr) {
16167
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
16169
if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
16171
zval *property_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
16174
MAKE_REAL_ZVAL_PTR(property_name);
16176
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
16178
zval_ptr_dtor(&property_name);
16183
zend_free_op free_op_data1, free_op_data2;
16185
zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
16186
zval **variable_ptr_ptr;
16188
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
16190
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
16191
variable_ptr_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
16192
if (!variable_ptr_ptr) {
16193
if (zend_assign_to_string_offset(&EX_T(op_data->op2.u.var), value, op_data->op1.op_type TSRMLS_CC)) {
16194
if (!RETURN_VALUE_UNUSED(&opline->result)) {
16195
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
16196
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
16197
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
16198
ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(op_data->op2.u.var).str_offset.str)+EX_T(op_data->op2.u.var).str_offset.offset, 1, 1);
16200
} else if (!RETURN_VALUE_UNUSED(&opline->result)) {
16201
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
16202
PZVAL_LOCK(EG(uninitialized_zval_ptr));
16205
value = zend_assign_to_variable(variable_ptr_ptr, value, IS_TMP_FREE(free_op_data1) TSRMLS_CC);
16206
if (!RETURN_VALUE_UNUSED(&opline->result)) {
16207
AI_SET_PTR(EX_T(opline->result.u.var).var, value);
16211
FREE_OP_VAR_PTR(free_op_data2);
16212
FREE_OP_IF_VAR(free_op_data1);
16214
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
16215
/* assign_dim has two opcodes! */
16216
ZEND_VM_INC_OPCODE();
16217
ZEND_VM_NEXT_OPCODE();
16220
static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16222
zend_op *opline = EX(opline);
16223
zend_free_op free_op1;
16224
zval *value = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
16225
zval **variable_ptr_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
16227
if (IS_VAR == IS_VAR && !variable_ptr_ptr) {
16228
if (zend_assign_to_string_offset(&EX_T(opline->op1.u.var), value, IS_CV TSRMLS_CC)) {
16229
if (!RETURN_VALUE_UNUSED(&opline->result)) {
16230
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
16231
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
16232
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
16233
ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(opline->op1.u.var).str_offset.str)+EX_T(opline->op1.u.var).str_offset.offset, 1, 1);
16235
} else if (!RETURN_VALUE_UNUSED(&opline->result)) {
16236
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
16237
PZVAL_LOCK(EG(uninitialized_zval_ptr));
16240
value = zend_assign_to_variable(variable_ptr_ptr, value, 0 TSRMLS_CC);
16241
if (!RETURN_VALUE_UNUSED(&opline->result)) {
16242
AI_SET_PTR(EX_T(opline->result.u.var).var, value);
16247
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
16249
/* zend_assign_to_variable() always takes care of op2, never free it! */
16251
ZEND_VM_NEXT_OPCODE();
16254
static int ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16256
zend_op *opline = EX(opline);
16257
zend_free_op free_op1, free_op2;
16258
zval **variable_ptr_ptr;
16259
zval **value_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op2, EX(Ts), BP_VAR_W TSRMLS_CC);
16261
if (IS_CV == IS_VAR &&
16263
!Z_ISREF_PP(value_ptr_ptr) &&
16264
opline->extended_value == ZEND_RETURNS_FUNCTION &&
16265
!EX_T(opline->op2.u.var).var.fcall_returned_reference) {
16266
if (free_op2.var == NULL) {
16267
PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
16269
zend_error(E_STRICT, "Only variables should be assigned by reference");
16270
if (UNEXPECTED(EG(exception) != NULL)) {
16272
ZEND_VM_NEXT_OPCODE();
16274
return ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16275
} else if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
16276
PZVAL_LOCK(*value_ptr_ptr);
16278
if (IS_VAR == IS_VAR && EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
16279
zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object");
16282
variable_ptr_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
16283
if ((IS_CV == IS_VAR && !value_ptr_ptr) ||
16284
(IS_VAR == IS_VAR && !variable_ptr_ptr)) {
16285
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
16287
zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
16289
if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
16290
Z_DELREF_PP(variable_ptr_ptr);
16293
if (!RETURN_VALUE_UNUSED(&opline->result)) {
16294
AI_SET_PTR(EX_T(opline->result.u.var).var, *variable_ptr_ptr);
16295
PZVAL_LOCK(*variable_ptr_ptr);
16298
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
16300
ZEND_VM_NEXT_OPCODE();
16303
static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16305
zend_op *opline = EX(opline);
16306
zval *function_name;
16307
char *function_name_strval;
16308
int function_name_strlen;
16309
zend_free_op free_op1;
16311
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
16313
function_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
16315
if (Z_TYPE_P(function_name)!=IS_STRING) {
16316
zend_error_noreturn(E_ERROR, "Method name must be a string");
16319
function_name_strval = Z_STRVAL_P(function_name);
16320
function_name_strlen = Z_STRLEN_P(function_name);
16322
EX(object) = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
16324
if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
16325
if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
16326
zend_error_noreturn(E_ERROR, "Object does not support method calls");
16329
/* First, locate the function. */
16330
EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
16332
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
16335
EX(called_scope) = Z_OBJCE_P(EX(object));
16337
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
16340
if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) {
16343
if (!PZVAL_IS_REF(EX(object))) {
16344
Z_ADDREF_P(EX(object)); /* For $this pointer */
16347
ALLOC_ZVAL(this_ptr);
16348
INIT_PZVAL_COPY(this_ptr, EX(object));
16349
zval_copy_ctor(this_ptr);
16350
EX(object) = this_ptr;
16354
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
16356
ZEND_VM_NEXT_OPCODE();
16359
static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16361
zend_op *opline = EX(opline);
16362
zval *function_name;
16363
zend_class_entry *ce;
16365
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
16367
if (IS_VAR == IS_CONST) {
16368
/* no function found. try a static method in class */
16369
ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
16371
zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL(opline->op1.u.constant));
16373
EX(called_scope) = ce;
16375
ce = EX_T(opline->op1.u.var).class_entry;
16377
if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
16378
EX(called_scope) = EG(called_scope);
16380
EX(called_scope) = ce;
16383
if(IS_CV != IS_UNUSED) {
16384
char *function_name_strval = NULL;
16385
int function_name_strlen = 0;
16388
if (IS_CV == IS_CONST) {
16389
function_name_strval = Z_STRVAL(opline->op2.u.constant);
16390
function_name_strlen = Z_STRLEN(opline->op2.u.constant);
16392
function_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
16394
if (Z_TYPE_P(function_name) != IS_STRING) {
16395
zend_error_noreturn(E_ERROR, "Function name must be a string");
16397
function_name_strval = Z_STRVAL_P(function_name);
16398
function_name_strlen = Z_STRLEN_P(function_name);
16402
if (function_name_strval) {
16403
if (ce->get_static_method) {
16404
EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
16406
EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
16409
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
16413
if (IS_CV != IS_CONST) {
16417
if(!ce->constructor) {
16418
zend_error_noreturn(E_ERROR, "Cannot call constructor");
16420
if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
16421
zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
16423
EX(fbc) = ce->constructor;
16426
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
16430
Z_OBJ_HT_P(EG(This))->get_class_entry &&
16431
!instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
16432
/* We are calling method of the other (incompatible) class,
16433
but passing $this. This is done for compatibility with php-4. */
16436
if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
16437
severity = E_STRICT;
16438
verb = "should not";
16440
/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
16441
severity = E_ERROR;
16444
zend_error(severity, "Non-static method %s::%s() %s be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name, verb);
16447
if ((EX(object) = EG(This))) {
16448
Z_ADDREF_P(EX(object));
16449
EX(called_scope) = Z_OBJCE_P(EX(object));
16453
ZEND_VM_NEXT_OPCODE();
16456
static int ZEND_FASTCALL ZEND_CASE_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16458
zend_op *opline = EX(opline);
16459
int switch_expr_is_overloaded=0;
16460
zend_free_op free_op1;
16462
if (IS_VAR==IS_VAR) {
16463
if (EX_T(opline->op1.u.var).var.ptr_ptr) {
16464
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
16466
switch_expr_is_overloaded = 1;
16467
Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
16470
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
16471
_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
16472
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
16474
if (switch_expr_is_overloaded) {
16475
/* We only free op1 if this is a string offset,
16476
* Since if it is a TMP_VAR, it'll be reused by
16477
* other CASE opcodes (whereas string offsets
16478
* are allocated at each get_zval_ptr())
16480
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
16481
EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
16482
EX_T(opline->op1.u.var).var.ptr = NULL;
16484
ZEND_VM_NEXT_OPCODE();
16487
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16489
zend_op *opline = EX(opline);
16490
zend_free_op free_op1;
16491
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
16493
zval *offset=_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
16495
#if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
16496
zval **expr_ptr_ptr = NULL;
16498
if (opline->extended_value) {
16499
expr_ptr_ptr=_get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
16500
expr_ptr = *expr_ptr_ptr;
16502
expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
16505
expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
16508
if (0) { /* temporary variable */
16511
ALLOC_ZVAL(new_expr);
16512
INIT_PZVAL_COPY(new_expr, expr_ptr);
16513
expr_ptr = new_expr;
16515
#if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
16516
if (opline->extended_value) {
16517
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
16518
expr_ptr = *expr_ptr_ptr;
16519
Z_ADDREF_P(expr_ptr);
16522
if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
16525
ALLOC_ZVAL(new_expr);
16526
INIT_PZVAL_COPY(new_expr, expr_ptr);
16527
expr_ptr = new_expr;
16528
zendi_zval_copy_ctor(*expr_ptr);
16530
Z_ADDREF_P(expr_ptr);
16534
switch (Z_TYPE_P(offset)) {
16536
zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
16540
zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
16543
zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
16546
zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
16549
zend_error(E_WARNING, "Illegal offset type");
16550
zval_ptr_dtor(&expr_ptr);
16556
zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
16558
if (opline->extended_value) {
16559
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
16561
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
16563
ZEND_VM_NEXT_OPCODE();
16566
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16568
zend_op *opline = EX(opline);
16570
array_init(&EX_T(opline->result.u.var).tmp_var);
16571
if (IS_VAR == IS_UNUSED) {
16572
ZEND_VM_NEXT_OPCODE();
16573
#if 0 || IS_VAR != IS_UNUSED
16575
return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16580
static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16582
zend_op *opline = EX(opline);
16583
zend_free_op free_op1;
16584
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
16585
zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
16587
if (IS_VAR != IS_VAR || container) {
16588
if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
16589
SEPARATE_ZVAL_IF_NOT_REF(container);
16591
switch (Z_TYPE_PP(container)) {
16593
HashTable *ht = Z_ARRVAL_PP(container);
16595
switch (Z_TYPE_P(offset)) {
16597
zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
16602
zend_hash_index_del(ht, Z_LVAL_P(offset));
16605
if (IS_CV == IS_CV || IS_CV == IS_VAR) {
16606
Z_ADDREF_P(offset);
16608
if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
16609
ht == &EG(symbol_table)) {
16610
zend_execute_data *ex;
16611
ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
16613
for (ex = execute_data; ex; ex = ex->prev_execute_data) {
16614
if (ex->op_array && ex->symbol_table == ht) {
16617
for (i = 0; i < ex->op_array->last_var; i++) {
16618
if (ex->op_array->vars[i].hash_value == hash_value &&
16619
ex->op_array->vars[i].name_len == offset->value.str.len &&
16620
!memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
16628
if (IS_CV == IS_CV || IS_CV == IS_VAR) {
16629
zval_ptr_dtor(&offset);
16633
zend_hash_del(ht, "", sizeof(""));
16636
zend_error(E_WARNING, "Illegal offset type in unset");
16643
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
16644
zend_error_noreturn(E_ERROR, "Cannot use object as array");
16647
MAKE_REAL_ZVAL_PTR(offset);
16649
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
16651
zval_ptr_dtor(&offset);
16657
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
16658
ZEND_VM_CONTINUE(); /* bailed out before */
16666
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
16668
ZEND_VM_NEXT_OPCODE();
16671
static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16673
zend_op *opline = EX(opline);
16674
zend_free_op free_op1;
16675
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
16676
zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
16678
if (IS_VAR != IS_VAR || container) {
16679
if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
16680
SEPARATE_ZVAL_IF_NOT_REF(container);
16682
if (Z_TYPE_PP(container) == IS_OBJECT) {
16684
MAKE_REAL_ZVAL_PTR(offset);
16686
if (Z_OBJ_HT_P(*container)->unset_property) {
16687
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
16689
zend_error(E_NOTICE, "Trying to unset property of non-object");
16692
zval_ptr_dtor(&offset);
16702
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
16704
ZEND_VM_NEXT_OPCODE();
16707
static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
16709
zend_op *opline = EX(opline);
16710
zend_free_op free_op1;
16711
zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
16712
zval **value = NULL;
16715
if (IS_VAR != IS_VAR || container) {
16717
zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
16719
if (Z_TYPE_PP(container) == IS_ARRAY) {
16723
ht = Z_ARRVAL_PP(container);
16725
switch (Z_TYPE_P(offset)) {
16727
if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
16734
if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
16739
if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
16744
if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
16749
zend_error(E_WARNING, "Illegal offset type in isset or empty");
16754
switch (opline->extended_value) {
16756
if (isset && Z_TYPE_PP(value) == IS_NULL) {
16763
if (!isset || !i_zend_is_true(*value)) {
16771
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
16773
MAKE_REAL_ZVAL_PTR(offset);
16776
if (Z_OBJ_HT_P(*container)->has_property) {
16777
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
16779
zend_error(E_NOTICE, "Trying to check property of non-object");
16783
if (Z_OBJ_HT_P(*container)->has_dimension) {
16784
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
16786
zend_error(E_NOTICE, "Trying to check element of non-array");
16791
zval_ptr_dtor(&offset);
16795
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
16798
if (Z_TYPE_P(offset) != IS_LONG) {
16800
zval_copy_ctor(&tmp);
16801
convert_to_long(&tmp);
16804
if (Z_TYPE_P(offset) == IS_LONG) {
16805
switch (opline->extended_value) {
16807
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
16812
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
16824
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
16826
switch (opline->extended_value) {
16828
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
16831
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
16835
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
16837
ZEND_VM_NEXT_OPCODE();
16840
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16842
return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16845
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16847
return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16850
static int ZEND_FASTCALL ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16852
zend_op *opline = EX(opline);
16854
zval *obj = _get_obj_zval_ptr_unused(TSRMLS_C);
16855
zend_class_entry *ce;
16856
zend_function *clone;
16857
zend_object_clone_obj_t clone_call;
16859
if (IS_UNUSED == IS_CONST ||
16860
(IS_UNUSED == IS_VAR && !obj) ||
16861
Z_TYPE_P(obj) != IS_OBJECT) {
16862
zend_error_noreturn(E_ERROR, "__clone method called on non-object");
16865
ce = Z_OBJCE_P(obj);
16866
clone = ce ? ce->clone : NULL;
16867
clone_call = Z_OBJ_HT_P(obj)->clone_obj;
16870
zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
16872
zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
16877
if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
16878
/* Ensure that if we're calling a private function, we're allowed to do so.
16880
if (ce != EG(scope)) {
16881
zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
16883
} else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
16884
/* Ensure that if we're calling a protected function, we're allowed to do so.
16886
if (!zend_check_protected(clone->common.scope, EG(scope))) {
16887
zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
16892
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
16893
if (!EG(exception)) {
16894
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
16895
Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC);
16896
Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
16897
Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
16898
Z_SET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
16899
if (!RETURN_VALUE_USED(opline) || EG(exception)) {
16900
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
16904
ZEND_VM_NEXT_OPCODE();
16907
static int ZEND_FASTCALL ZEND_EXIT_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16909
#if 0 || (IS_UNUSED != IS_UNUSED)
16910
zend_op *opline = EX(opline);
16911
if (IS_UNUSED != IS_UNUSED) {
16915
if (Z_TYPE_P(ptr) == IS_LONG) {
16916
EG(exit_status) = Z_LVAL_P(ptr);
16918
zend_print_variable(ptr);
16924
ZEND_VM_NEXT_OPCODE();
16927
static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
16929
zend_op *opline = EX(opline);
16930
zend_op *op_data = opline+1;
16931
zend_free_op free_op_data1;
16932
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
16934
zval *property = &opline->op2.u.constant;
16935
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
16936
znode *result = &opline->result;
16937
int have_get_ptr = 0;
16939
if (IS_UNUSED == IS_VAR && !object_ptr) {
16940
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
16943
EX_T(result->u.var).var.ptr_ptr = NULL;
16944
make_real_object(object_ptr TSRMLS_CC);
16945
object = *object_ptr;
16947
if (Z_TYPE_P(object) != IS_OBJECT) {
16948
zend_error(E_WARNING, "Attempt to assign property of non-object");
16950
FREE_OP(free_op_data1);
16952
if (!RETURN_VALUE_UNUSED(result)) {
16953
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
16954
EX_T(result->u.var).var.ptr_ptr = NULL;
16955
PZVAL_LOCK(EG(uninitialized_zval_ptr));
16958
/* here we are sure we are dealing with an object */
16960
MAKE_REAL_ZVAL_PTR(property);
16963
/* here property is a string */
16964
if (opline->extended_value == ZEND_ASSIGN_OBJ
16965
&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
16966
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
16967
if (zptr != NULL) { /* NULL means no success in getting PTR */
16968
SEPARATE_ZVAL_IF_NOT_REF(zptr);
16971
binary_op(*zptr, *zptr, value TSRMLS_CC);
16972
if (!RETURN_VALUE_UNUSED(result)) {
16973
EX_T(result->u.var).var.ptr = *zptr;
16974
EX_T(result->u.var).var.ptr_ptr = NULL;
16980
if (!have_get_ptr) {
16983
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
16984
if (Z_OBJ_HT_P(object)->read_property) {
16985
z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
16987
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
16988
if (Z_OBJ_HT_P(object)->read_dimension) {
16989
z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
16993
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
16994
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
16996
if (Z_REFCOUNT_P(z) == 0) {
16997
GC_REMOVE_ZVAL_FROM_BUFFER(z);
17004
SEPARATE_ZVAL_IF_NOT_REF(&z);
17005
binary_op(z, z, value TSRMLS_CC);
17006
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
17007
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
17008
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
17009
Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
17011
if (!RETURN_VALUE_UNUSED(result)) {
17012
EX_T(result->u.var).var.ptr = z;
17013
EX_T(result->u.var).var.ptr_ptr = NULL;
17018
zend_error(E_WARNING, "Attempt to assign property of non-object");
17019
if (!RETURN_VALUE_UNUSED(result)) {
17020
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
17021
EX_T(result->u.var).var.ptr_ptr = NULL;
17022
PZVAL_LOCK(EG(uninitialized_zval_ptr));
17028
zval_ptr_dtor(&property);
17032
FREE_OP(free_op_data1);
17035
/* assign_obj has two opcodes! */
17036
ZEND_VM_INC_OPCODE();
17037
ZEND_VM_NEXT_OPCODE();
17040
static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
17042
zend_op *opline = EX(opline);
17043
zend_free_op free_op_data2, free_op_data1;
17047
switch (opline->extended_value) {
17048
case ZEND_ASSIGN_OBJ:
17049
return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17051
case ZEND_ASSIGN_DIM: {
17052
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
17054
if (IS_UNUSED == IS_VAR && !container) {
17055
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
17056
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
17057
if (IS_UNUSED == IS_VAR && !0) {
17058
Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
17060
return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17062
zend_op *op_data = opline+1;
17063
zval *dim = &opline->op2.u.constant;
17065
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), container, dim, 0, BP_VAR_RW TSRMLS_CC);
17066
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
17067
var_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
17068
ZEND_VM_INC_OPCODE();
17073
value = &opline->op2.u.constant;
17080
zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
17083
if (*var_ptr == EG(error_zval_ptr)) {
17084
if (!RETURN_VALUE_UNUSED(&opline->result)) {
17085
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
17086
PZVAL_LOCK(EG(uninitialized_zval_ptr));
17090
ZEND_VM_NEXT_OPCODE();
17093
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
17095
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
17096
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
17098
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
17099
Z_ADDREF_P(objval);
17100
binary_op(objval, objval, value TSRMLS_CC);
17101
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
17102
zval_ptr_dtor(&objval);
17104
binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
17107
if (!RETURN_VALUE_UNUSED(&opline->result)) {
17108
AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
17109
PZVAL_LOCK(*var_ptr);
17112
if (opline->extended_value == ZEND_ASSIGN_DIM) {
17113
FREE_OP(free_op_data1);
17114
FREE_OP_VAR_PTR(free_op_data2);
17117
ZEND_VM_NEXT_OPCODE();
17120
static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17122
return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17125
static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17127
return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17130
static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17132
return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17135
static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17137
return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17140
static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17142
return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17145
static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17147
return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17150
static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17152
return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17155
static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17157
return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17160
static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17162
return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17165
static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17167
return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17170
static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17172
return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17175
static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
17177
zend_op *opline = EX(opline);
17179
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
17181
zval *property = &opline->op2.u.constant;
17182
zval **retval = &EX_T(opline->result.u.var).var.ptr;
17183
int have_get_ptr = 0;
17185
if (IS_UNUSED == IS_VAR && !object_ptr) {
17186
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
17189
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
17190
object = *object_ptr;
17192
if (Z_TYPE_P(object) != IS_OBJECT) {
17193
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
17195
if (!RETURN_VALUE_UNUSED(&opline->result)) {
17196
*retval = EG(uninitialized_zval_ptr);
17197
PZVAL_LOCK(*retval);
17200
ZEND_VM_NEXT_OPCODE();
17203
/* here we are sure we are dealing with an object */
17206
MAKE_REAL_ZVAL_PTR(property);
17209
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
17210
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
17211
if (zptr != NULL) { /* NULL means no success in getting PTR */
17212
SEPARATE_ZVAL_IF_NOT_REF(zptr);
17216
if (!RETURN_VALUE_UNUSED(&opline->result)) {
17218
PZVAL_LOCK(*retval);
17223
if (!have_get_ptr) {
17224
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
17225
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
17227
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
17228
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
17230
if (Z_REFCOUNT_P(z) == 0) {
17231
GC_REMOVE_ZVAL_FROM_BUFFER(z);
17238
SEPARATE_ZVAL_IF_NOT_REF(&z);
17241
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
17242
SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
17245
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
17246
if (!RETURN_VALUE_UNUSED(&opline->result)) {
17247
*retval = EG(uninitialized_zval_ptr);
17248
PZVAL_LOCK(*retval);
17254
zval_ptr_dtor(&property);
17259
ZEND_VM_NEXT_OPCODE();
17262
static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17264
return zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17267
static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17269
return zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17272
static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
17274
zend_op *opline = EX(opline);
17276
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
17278
zval *property = &opline->op2.u.constant;
17279
zval *retval = &EX_T(opline->result.u.var).tmp_var;
17280
int have_get_ptr = 0;
17282
if (IS_UNUSED == IS_VAR && !object_ptr) {
17283
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
17286
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
17287
object = *object_ptr;
17289
if (Z_TYPE_P(object) != IS_OBJECT) {
17290
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
17292
*retval = *EG(uninitialized_zval_ptr);
17294
ZEND_VM_NEXT_OPCODE();
17297
/* here we are sure we are dealing with an object */
17300
MAKE_REAL_ZVAL_PTR(property);
17303
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
17304
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
17305
if (zptr != NULL) { /* NULL means no success in getting PTR */
17307
SEPARATE_ZVAL_IF_NOT_REF(zptr);
17310
zendi_zval_copy_ctor(*retval);
17317
if (!have_get_ptr) {
17318
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
17319
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
17322
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
17323
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
17325
if (Z_REFCOUNT_P(z) == 0) {
17326
GC_REMOVE_ZVAL_FROM_BUFFER(z);
17333
zendi_zval_copy_ctor(*retval);
17334
ALLOC_ZVAL(z_copy);
17336
zendi_zval_copy_ctor(*z_copy);
17337
INIT_PZVAL(z_copy);
17340
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
17341
zval_ptr_dtor(&z_copy);
17344
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
17345
*retval = *EG(uninitialized_zval_ptr);
17350
zval_ptr_dtor(&property);
17355
ZEND_VM_NEXT_OPCODE();
17358
static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17360
return zend_post_incdec_property_helper_SPEC_UNUSED_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17363
static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17365
return zend_post_incdec_property_helper_SPEC_UNUSED_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17368
static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
17370
zend_op *opline = EX(opline);
17372
zval *container = _get_obj_zval_ptr_unused(TSRMLS_C);
17374
zval *offset = &opline->op2.u.constant;
17376
if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
17377
if (type != BP_VAR_IS) {
17378
zend_error(E_NOTICE, "Trying to get property of non-object");
17380
if (!RETURN_VALUE_UNUSED(&opline->result)) {
17381
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
17382
PZVAL_LOCK(EG(uninitialized_zval_ptr));
17389
MAKE_REAL_ZVAL_PTR(offset);
17392
/* here we are sure we are dealing with an object */
17393
retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
17395
if (RETURN_VALUE_UNUSED(&opline->result)) {
17396
if (Z_REFCOUNT_P(retval) == 0) {
17397
GC_REMOVE_ZVAL_FROM_BUFFER(retval);
17402
AI_SET_PTR(EX_T(opline->result.u.var).var, retval);
17403
PZVAL_LOCK(retval);
17407
zval_ptr_dtor(&offset);
17413
ZEND_VM_NEXT_OPCODE();
17416
static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17418
return zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17421
static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17423
zend_op *opline = EX(opline);
17424
zend_free_op free_op1;
17425
zval *property = &opline->op2.u.constant;
17428
if (IS_UNUSED == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
17429
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
17430
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
17434
MAKE_REAL_ZVAL_PTR(property);
17436
container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
17437
if (IS_UNUSED == IS_VAR && !container) {
17438
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
17440
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
17442
zval_ptr_dtor(&property);
17446
if (IS_UNUSED == IS_VAR && 0 &&
17447
READY_TO_DESTROY(free_op1.var)) {
17448
AI_USE_PTR(EX_T(opline->result.u.var).var);
17449
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
17450
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
17451
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
17455
/* We are going to assign the result by reference */
17456
if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
17457
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
17458
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
17459
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
17462
ZEND_VM_NEXT_OPCODE();
17465
static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17467
zend_op *opline = EX(opline);
17468
zend_free_op free_op1;
17469
zval *property = &opline->op2.u.constant;
17470
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
17473
MAKE_REAL_ZVAL_PTR(property);
17475
if (IS_UNUSED == IS_VAR && !container) {
17476
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
17478
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_RW TSRMLS_CC);
17480
zval_ptr_dtor(&property);
17484
if (IS_UNUSED == IS_VAR && 0 &&
17485
READY_TO_DESTROY(free_op1.var)) {
17486
AI_USE_PTR(EX_T(opline->result.u.var).var);
17487
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
17488
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
17489
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
17493
ZEND_VM_NEXT_OPCODE();
17496
static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17498
return zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17501
static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17503
zend_op *opline = EX(opline);
17505
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
17506
/* Behave like FETCH_OBJ_W */
17507
zend_free_op free_op1;
17508
zval *property = &opline->op2.u.constant;
17509
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
17512
MAKE_REAL_ZVAL_PTR(property);
17514
if (IS_UNUSED == IS_VAR && !container) {
17515
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
17517
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
17519
zval_ptr_dtor(&property);
17523
if (IS_UNUSED == IS_VAR && 0 &&
17524
READY_TO_DESTROY(free_op1.var)) {
17525
AI_USE_PTR(EX_T(opline->result.u.var).var);
17526
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
17527
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
17528
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
17532
ZEND_VM_NEXT_OPCODE();
17534
return zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17538
static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17540
zend_op *opline = EX(opline);
17541
zend_free_op free_op1, free_res;
17542
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
17543
zval *property = &opline->op2.u.constant;
17545
if (IS_UNUSED == IS_CV) {
17546
if (container != &EG(uninitialized_zval_ptr)) {
17547
SEPARATE_ZVAL_IF_NOT_REF(container);
17551
MAKE_REAL_ZVAL_PTR(property);
17553
if (IS_UNUSED == IS_VAR && !container) {
17554
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
17556
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
17558
zval_ptr_dtor(&property);
17562
if (IS_UNUSED == IS_VAR && 0 &&
17563
READY_TO_DESTROY(free_op1.var)) {
17564
AI_USE_PTR(EX_T(opline->result.u.var).var);
17565
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
17566
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
17567
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
17571
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
17572
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
17573
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
17575
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
17576
FREE_OP_VAR_PTR(free_res);
17577
ZEND_VM_NEXT_OPCODE();
17580
static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17582
zend_op *opline = EX(opline);
17583
zend_op *op_data = opline+1;
17585
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
17586
zval *property_name = &opline->op2.u.constant;
17589
MAKE_REAL_ZVAL_PTR(property_name);
17591
if (IS_UNUSED == IS_VAR && !object_ptr) {
17592
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
17594
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
17596
zval_ptr_dtor(&property_name);
17601
/* assign_obj has two opcodes! */
17602
ZEND_VM_INC_OPCODE();
17603
ZEND_VM_NEXT_OPCODE();
17606
static int ZEND_FASTCALL ZEND_ADD_CHAR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17608
zend_op *opline = EX(opline);
17609
zval *str = &EX_T(opline->result.u.var).tmp_var;
17611
if (IS_UNUSED == IS_UNUSED) {
17612
/* Initialize for erealloc in add_char_to_string */
17613
Z_STRVAL_P(str) = NULL;
17614
Z_STRLEN_P(str) = 0;
17615
Z_TYPE_P(str) = IS_STRING;
17620
add_char_to_string(str, str, &opline->op2.u.constant);
17622
/* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
17623
ZEND_VM_NEXT_OPCODE();
17626
static int ZEND_FASTCALL ZEND_ADD_STRING_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17628
zend_op *opline = EX(opline);
17629
zval *str = &EX_T(opline->result.u.var).tmp_var;
17631
if (IS_UNUSED == IS_UNUSED) {
17632
/* Initialize for erealloc in add_string_to_string */
17633
Z_STRVAL_P(str) = NULL;
17634
Z_STRLEN_P(str) = 0;
17635
Z_TYPE_P(str) = IS_STRING;
17640
add_string_to_string(str, str, &opline->op2.u.constant);
17642
/* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
17643
ZEND_VM_NEXT_OPCODE();
17646
static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17648
zend_op *opline = EX(opline);
17649
zval *function_name;
17650
char *function_name_strval;
17651
int function_name_strlen;
17654
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
17656
function_name = &opline->op2.u.constant;
17658
if (Z_TYPE_P(function_name)!=IS_STRING) {
17659
zend_error_noreturn(E_ERROR, "Method name must be a string");
17662
function_name_strval = Z_STRVAL_P(function_name);
17663
function_name_strlen = Z_STRLEN_P(function_name);
17665
EX(object) = _get_obj_zval_ptr_unused(TSRMLS_C);
17667
if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
17668
if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
17669
zend_error_noreturn(E_ERROR, "Object does not support method calls");
17672
/* First, locate the function. */
17673
EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
17675
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
17678
EX(called_scope) = Z_OBJCE_P(EX(object));
17680
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
17683
if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) {
17686
if (!PZVAL_IS_REF(EX(object))) {
17687
Z_ADDREF_P(EX(object)); /* For $this pointer */
17690
ALLOC_ZVAL(this_ptr);
17691
INIT_PZVAL_COPY(this_ptr, EX(object));
17692
zval_copy_ctor(this_ptr);
17693
EX(object) = this_ptr;
17698
ZEND_VM_NEXT_OPCODE();
17701
static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17703
zend_op *opline = EX(opline);
17705
if (IS_UNUSED == IS_UNUSED) {
17706
/* namespaced constant */
17707
if (!zend_get_constant_ex(Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant), &EX_T(opline->result.u.var).tmp_var, NULL, opline->extended_value TSRMLS_CC)) {
17708
if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
17709
char *actual = (char *)zend_memrchr(Z_STRVAL(opline->op2.u.constant), '\\', Z_STRLEN(opline->op2.u.constant));
17711
actual = Z_STRVAL(opline->op2.u.constant);
17715
/* non-qualified constant - allow text substitution */
17716
zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
17717
ZVAL_STRINGL(&EX_T(opline->result.u.var).tmp_var, actual, Z_STRLEN(opline->op2.u.constant)-(actual - Z_STRVAL(opline->op2.u.constant)), 1);
17719
zend_error_noreturn(E_ERROR, "Undefined constant '%s'",
17720
Z_STRVAL(opline->op2.u.constant), Z_STRVAL(opline->op2.u.constant));
17723
ZEND_VM_NEXT_OPCODE();
17725
/* class constant */
17726
zend_class_entry *ce;
17729
if (IS_UNUSED == IS_CONST) {
17731
ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
17733
zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL(opline->op2.u.constant));
17736
ce = EX_T(opline->op1.u.var).class_entry;
17739
if (zend_hash_find(&ce->constants_table, Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant)+1, (void **) &value) == SUCCESS) {
17740
if (Z_TYPE_PP(value) == IS_CONSTANT_ARRAY ||
17741
(Z_TYPE_PP(value) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) {
17742
zend_class_entry *old_scope = EG(scope);
17745
zval_update_constant(value, (void *) 1 TSRMLS_CC);
17746
EG(scope) = old_scope;
17748
EX_T(opline->result.u.var).tmp_var = **value;
17749
zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
17751
zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL(opline->op2.u.constant));
17754
ZEND_VM_NEXT_OPCODE();
17758
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17760
zend_op *opline = EX(opline);
17762
array_init(&EX_T(opline->result.u.var).tmp_var);
17763
if (IS_UNUSED == IS_UNUSED) {
17764
ZEND_VM_NEXT_OPCODE();
17765
#if 0 || IS_UNUSED != IS_UNUSED
17767
return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17772
static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17774
zend_op *opline = EX(opline);
17776
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
17777
zval *offset = &opline->op2.u.constant;
17779
if (IS_UNUSED != IS_VAR || container) {
17780
if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
17781
SEPARATE_ZVAL_IF_NOT_REF(container);
17783
switch (Z_TYPE_PP(container)) {
17785
HashTable *ht = Z_ARRVAL_PP(container);
17787
switch (Z_TYPE_P(offset)) {
17789
zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
17794
zend_hash_index_del(ht, Z_LVAL_P(offset));
17797
if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
17798
Z_ADDREF_P(offset);
17800
if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
17801
ht == &EG(symbol_table)) {
17802
zend_execute_data *ex;
17803
ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
17805
for (ex = execute_data; ex; ex = ex->prev_execute_data) {
17806
if (ex->op_array && ex->symbol_table == ht) {
17809
for (i = 0; i < ex->op_array->last_var; i++) {
17810
if (ex->op_array->vars[i].hash_value == hash_value &&
17811
ex->op_array->vars[i].name_len == offset->value.str.len &&
17812
!memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
17820
if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
17821
zval_ptr_dtor(&offset);
17825
zend_hash_del(ht, "", sizeof(""));
17828
zend_error(E_WARNING, "Illegal offset type in unset");
17835
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
17836
zend_error_noreturn(E_ERROR, "Cannot use object as array");
17839
MAKE_REAL_ZVAL_PTR(offset);
17841
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
17843
zval_ptr_dtor(&offset);
17849
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
17850
ZEND_VM_CONTINUE(); /* bailed out before */
17859
ZEND_VM_NEXT_OPCODE();
17862
static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17864
zend_op *opline = EX(opline);
17866
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
17867
zval *offset = &opline->op2.u.constant;
17869
if (IS_UNUSED != IS_VAR || container) {
17870
if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
17871
SEPARATE_ZVAL_IF_NOT_REF(container);
17873
if (Z_TYPE_PP(container) == IS_OBJECT) {
17875
MAKE_REAL_ZVAL_PTR(offset);
17877
if (Z_OBJ_HT_P(*container)->unset_property) {
17878
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
17880
zend_error(E_NOTICE, "Trying to unset property of non-object");
17883
zval_ptr_dtor(&offset);
17894
ZEND_VM_NEXT_OPCODE();
17897
static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
17899
zend_op *opline = EX(opline);
17901
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
17902
zval **value = NULL;
17905
if (IS_UNUSED != IS_VAR || container) {
17907
zval *offset = &opline->op2.u.constant;
17909
if (Z_TYPE_PP(container) == IS_ARRAY) {
17913
ht = Z_ARRVAL_PP(container);
17915
switch (Z_TYPE_P(offset)) {
17917
if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
17924
if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
17929
if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
17934
if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
17939
zend_error(E_WARNING, "Illegal offset type in isset or empty");
17944
switch (opline->extended_value) {
17946
if (isset && Z_TYPE_PP(value) == IS_NULL) {
17953
if (!isset || !i_zend_is_true(*value)) {
17961
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
17963
MAKE_REAL_ZVAL_PTR(offset);
17966
if (Z_OBJ_HT_P(*container)->has_property) {
17967
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
17969
zend_error(E_NOTICE, "Trying to check property of non-object");
17973
if (Z_OBJ_HT_P(*container)->has_dimension) {
17974
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
17976
zend_error(E_NOTICE, "Trying to check element of non-array");
17981
zval_ptr_dtor(&offset);
17985
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
17988
if (Z_TYPE_P(offset) != IS_LONG) {
17990
zval_copy_ctor(&tmp);
17991
convert_to_long(&tmp);
17994
if (Z_TYPE_P(offset) == IS_LONG) {
17995
switch (opline->extended_value) {
17997
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
18002
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
18014
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
18016
switch (opline->extended_value) {
18018
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
18021
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
18025
ZEND_VM_NEXT_OPCODE();
18028
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18030
return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18033
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18035
return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18038
static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
18040
zend_op *opline = EX(opline);
18041
zend_op *op_data = opline+1;
18042
zend_free_op free_op2, free_op_data1;
18043
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
18045
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
18046
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
18047
znode *result = &opline->result;
18048
int have_get_ptr = 0;
18050
if (IS_UNUSED == IS_VAR && !object_ptr) {
18051
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
18054
EX_T(result->u.var).var.ptr_ptr = NULL;
18055
make_real_object(object_ptr TSRMLS_CC);
18056
object = *object_ptr;
18058
if (Z_TYPE_P(object) != IS_OBJECT) {
18059
zend_error(E_WARNING, "Attempt to assign property of non-object");
18060
zval_dtor(free_op2.var);
18061
FREE_OP(free_op_data1);
18063
if (!RETURN_VALUE_UNUSED(result)) {
18064
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
18065
EX_T(result->u.var).var.ptr_ptr = NULL;
18066
PZVAL_LOCK(EG(uninitialized_zval_ptr));
18069
/* here we are sure we are dealing with an object */
18071
MAKE_REAL_ZVAL_PTR(property);
18074
/* here property is a string */
18075
if (opline->extended_value == ZEND_ASSIGN_OBJ
18076
&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
18077
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
18078
if (zptr != NULL) { /* NULL means no success in getting PTR */
18079
SEPARATE_ZVAL_IF_NOT_REF(zptr);
18082
binary_op(*zptr, *zptr, value TSRMLS_CC);
18083
if (!RETURN_VALUE_UNUSED(result)) {
18084
EX_T(result->u.var).var.ptr = *zptr;
18085
EX_T(result->u.var).var.ptr_ptr = NULL;
18091
if (!have_get_ptr) {
18094
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
18095
if (Z_OBJ_HT_P(object)->read_property) {
18096
z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
18098
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
18099
if (Z_OBJ_HT_P(object)->read_dimension) {
18100
z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
18104
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
18105
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
18107
if (Z_REFCOUNT_P(z) == 0) {
18108
GC_REMOVE_ZVAL_FROM_BUFFER(z);
18115
SEPARATE_ZVAL_IF_NOT_REF(&z);
18116
binary_op(z, z, value TSRMLS_CC);
18117
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
18118
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
18119
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
18120
Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
18122
if (!RETURN_VALUE_UNUSED(result)) {
18123
EX_T(result->u.var).var.ptr = z;
18124
EX_T(result->u.var).var.ptr_ptr = NULL;
18129
zend_error(E_WARNING, "Attempt to assign property of non-object");
18130
if (!RETURN_VALUE_UNUSED(result)) {
18131
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
18132
EX_T(result->u.var).var.ptr_ptr = NULL;
18133
PZVAL_LOCK(EG(uninitialized_zval_ptr));
18139
zval_ptr_dtor(&property);
18141
zval_dtor(free_op2.var);
18143
FREE_OP(free_op_data1);
18146
/* assign_obj has two opcodes! */
18147
ZEND_VM_INC_OPCODE();
18148
ZEND_VM_NEXT_OPCODE();
18151
static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
18153
zend_op *opline = EX(opline);
18154
zend_free_op free_op2, free_op_data2, free_op_data1;
18158
switch (opline->extended_value) {
18159
case ZEND_ASSIGN_OBJ:
18160
return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18162
case ZEND_ASSIGN_DIM: {
18163
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
18165
if (IS_UNUSED == IS_VAR && !container) {
18166
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
18167
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
18168
if (IS_UNUSED == IS_VAR && !0) {
18169
Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
18171
return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18173
zend_op *op_data = opline+1;
18174
zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
18176
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), container, dim, 1, BP_VAR_RW TSRMLS_CC);
18177
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
18178
var_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
18179
ZEND_VM_INC_OPCODE();
18184
value = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
18191
zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
18194
if (*var_ptr == EG(error_zval_ptr)) {
18195
if (!RETURN_VALUE_UNUSED(&opline->result)) {
18196
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
18197
PZVAL_LOCK(EG(uninitialized_zval_ptr));
18199
zval_dtor(free_op2.var);
18201
ZEND_VM_NEXT_OPCODE();
18204
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
18206
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
18207
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
18209
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
18210
Z_ADDREF_P(objval);
18211
binary_op(objval, objval, value TSRMLS_CC);
18212
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
18213
zval_ptr_dtor(&objval);
18215
binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
18218
if (!RETURN_VALUE_UNUSED(&opline->result)) {
18219
AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
18220
PZVAL_LOCK(*var_ptr);
18222
zval_dtor(free_op2.var);
18224
if (opline->extended_value == ZEND_ASSIGN_DIM) {
18225
FREE_OP(free_op_data1);
18226
FREE_OP_VAR_PTR(free_op_data2);
18229
ZEND_VM_NEXT_OPCODE();
18232
static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18234
return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18237
static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18239
return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18242
static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18244
return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18247
static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18249
return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18252
static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18254
return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18257
static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18259
return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18262
static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18264
return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18267
static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18269
return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18272
static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18274
return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18277
static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18279
return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18282
static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18284
return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18287
static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
18289
zend_op *opline = EX(opline);
18290
zend_free_op free_op2;
18291
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
18293
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
18294
zval **retval = &EX_T(opline->result.u.var).var.ptr;
18295
int have_get_ptr = 0;
18297
if (IS_UNUSED == IS_VAR && !object_ptr) {
18298
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
18301
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
18302
object = *object_ptr;
18304
if (Z_TYPE_P(object) != IS_OBJECT) {
18305
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
18306
zval_dtor(free_op2.var);
18307
if (!RETURN_VALUE_UNUSED(&opline->result)) {
18308
*retval = EG(uninitialized_zval_ptr);
18309
PZVAL_LOCK(*retval);
18312
ZEND_VM_NEXT_OPCODE();
18315
/* here we are sure we are dealing with an object */
18318
MAKE_REAL_ZVAL_PTR(property);
18321
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
18322
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
18323
if (zptr != NULL) { /* NULL means no success in getting PTR */
18324
SEPARATE_ZVAL_IF_NOT_REF(zptr);
18328
if (!RETURN_VALUE_UNUSED(&opline->result)) {
18330
PZVAL_LOCK(*retval);
18335
if (!have_get_ptr) {
18336
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
18337
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
18339
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
18340
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
18342
if (Z_REFCOUNT_P(z) == 0) {
18343
GC_REMOVE_ZVAL_FROM_BUFFER(z);
18350
SEPARATE_ZVAL_IF_NOT_REF(&z);
18353
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
18354
SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
18357
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
18358
if (!RETURN_VALUE_UNUSED(&opline->result)) {
18359
*retval = EG(uninitialized_zval_ptr);
18360
PZVAL_LOCK(*retval);
18366
zval_ptr_dtor(&property);
18368
zval_dtor(free_op2.var);
18371
ZEND_VM_NEXT_OPCODE();
18374
static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18376
return zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18379
static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18381
return zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18384
static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
18386
zend_op *opline = EX(opline);
18387
zend_free_op free_op2;
18388
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
18390
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
18391
zval *retval = &EX_T(opline->result.u.var).tmp_var;
18392
int have_get_ptr = 0;
18394
if (IS_UNUSED == IS_VAR && !object_ptr) {
18395
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
18398
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
18399
object = *object_ptr;
18401
if (Z_TYPE_P(object) != IS_OBJECT) {
18402
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
18403
zval_dtor(free_op2.var);
18404
*retval = *EG(uninitialized_zval_ptr);
18406
ZEND_VM_NEXT_OPCODE();
18409
/* here we are sure we are dealing with an object */
18412
MAKE_REAL_ZVAL_PTR(property);
18415
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
18416
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
18417
if (zptr != NULL) { /* NULL means no success in getting PTR */
18419
SEPARATE_ZVAL_IF_NOT_REF(zptr);
18422
zendi_zval_copy_ctor(*retval);
18429
if (!have_get_ptr) {
18430
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
18431
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
18434
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
18435
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
18437
if (Z_REFCOUNT_P(z) == 0) {
18438
GC_REMOVE_ZVAL_FROM_BUFFER(z);
18445
zendi_zval_copy_ctor(*retval);
18446
ALLOC_ZVAL(z_copy);
18448
zendi_zval_copy_ctor(*z_copy);
18449
INIT_PZVAL(z_copy);
18452
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
18453
zval_ptr_dtor(&z_copy);
18456
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
18457
*retval = *EG(uninitialized_zval_ptr);
18462
zval_ptr_dtor(&property);
18464
zval_dtor(free_op2.var);
18467
ZEND_VM_NEXT_OPCODE();
18470
static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18472
return zend_post_incdec_property_helper_SPEC_UNUSED_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18475
static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18477
return zend_post_incdec_property_helper_SPEC_UNUSED_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18480
static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(int type, ZEND_OPCODE_HANDLER_ARGS)
18482
zend_op *opline = EX(opline);
18484
zval *container = _get_obj_zval_ptr_unused(TSRMLS_C);
18485
zend_free_op free_op2;
18486
zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
18488
if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
18489
if (type != BP_VAR_IS) {
18490
zend_error(E_NOTICE, "Trying to get property of non-object");
18492
if (!RETURN_VALUE_UNUSED(&opline->result)) {
18493
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
18494
PZVAL_LOCK(EG(uninitialized_zval_ptr));
18496
zval_dtor(free_op2.var);
18501
MAKE_REAL_ZVAL_PTR(offset);
18504
/* here we are sure we are dealing with an object */
18505
retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
18507
if (RETURN_VALUE_UNUSED(&opline->result)) {
18508
if (Z_REFCOUNT_P(retval) == 0) {
18509
GC_REMOVE_ZVAL_FROM_BUFFER(retval);
18514
AI_SET_PTR(EX_T(opline->result.u.var).var, retval);
18515
PZVAL_LOCK(retval);
18519
zval_ptr_dtor(&offset);
18521
zval_dtor(free_op2.var);
18525
ZEND_VM_NEXT_OPCODE();
18528
static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18530
return zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18533
static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18535
zend_op *opline = EX(opline);
18536
zend_free_op free_op1, free_op2;
18537
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
18540
if (IS_UNUSED == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
18541
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
18542
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
18546
MAKE_REAL_ZVAL_PTR(property);
18548
container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
18549
if (IS_UNUSED == IS_VAR && !container) {
18550
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
18552
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
18554
zval_ptr_dtor(&property);
18556
zval_dtor(free_op2.var);
18558
if (IS_UNUSED == IS_VAR && 0 &&
18559
READY_TO_DESTROY(free_op1.var)) {
18560
AI_USE_PTR(EX_T(opline->result.u.var).var);
18561
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
18562
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
18563
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
18567
/* We are going to assign the result by reference */
18568
if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
18569
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
18570
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
18571
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
18574
ZEND_VM_NEXT_OPCODE();
18577
static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18579
zend_op *opline = EX(opline);
18580
zend_free_op free_op1, free_op2;
18581
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
18582
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
18585
MAKE_REAL_ZVAL_PTR(property);
18587
if (IS_UNUSED == IS_VAR && !container) {
18588
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
18590
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_RW TSRMLS_CC);
18592
zval_ptr_dtor(&property);
18594
zval_dtor(free_op2.var);
18596
if (IS_UNUSED == IS_VAR && 0 &&
18597
READY_TO_DESTROY(free_op1.var)) {
18598
AI_USE_PTR(EX_T(opline->result.u.var).var);
18599
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
18600
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
18601
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
18605
ZEND_VM_NEXT_OPCODE();
18608
static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18610
return zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18613
static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18615
zend_op *opline = EX(opline);
18617
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
18618
/* Behave like FETCH_OBJ_W */
18619
zend_free_op free_op1, free_op2;
18620
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
18621
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
18624
MAKE_REAL_ZVAL_PTR(property);
18626
if (IS_UNUSED == IS_VAR && !container) {
18627
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
18629
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
18631
zval_ptr_dtor(&property);
18633
zval_dtor(free_op2.var);
18635
if (IS_UNUSED == IS_VAR && 0 &&
18636
READY_TO_DESTROY(free_op1.var)) {
18637
AI_USE_PTR(EX_T(opline->result.u.var).var);
18638
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
18639
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
18640
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
18644
ZEND_VM_NEXT_OPCODE();
18646
return zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18650
static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18652
zend_op *opline = EX(opline);
18653
zend_free_op free_op1, free_op2, free_res;
18654
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
18655
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
18657
if (IS_UNUSED == IS_CV) {
18658
if (container != &EG(uninitialized_zval_ptr)) {
18659
SEPARATE_ZVAL_IF_NOT_REF(container);
18663
MAKE_REAL_ZVAL_PTR(property);
18665
if (IS_UNUSED == IS_VAR && !container) {
18666
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
18668
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
18670
zval_ptr_dtor(&property);
18672
zval_dtor(free_op2.var);
18674
if (IS_UNUSED == IS_VAR && 0 &&
18675
READY_TO_DESTROY(free_op1.var)) {
18676
AI_USE_PTR(EX_T(opline->result.u.var).var);
18677
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
18678
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
18679
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
18683
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
18684
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
18685
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
18687
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
18688
FREE_OP_VAR_PTR(free_res);
18689
ZEND_VM_NEXT_OPCODE();
18692
static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18694
zend_op *opline = EX(opline);
18695
zend_op *op_data = opline+1;
18696
zend_free_op free_op2;
18697
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
18698
zval *property_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
18701
MAKE_REAL_ZVAL_PTR(property_name);
18703
if (IS_UNUSED == IS_VAR && !object_ptr) {
18704
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
18706
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
18708
zval_ptr_dtor(&property_name);
18710
zval_dtor(free_op2.var);
18713
/* assign_obj has two opcodes! */
18714
ZEND_VM_INC_OPCODE();
18715
ZEND_VM_NEXT_OPCODE();
18718
static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18720
zend_op *opline = EX(opline);
18721
zend_free_op free_op2;
18722
zval *str = &EX_T(opline->result.u.var).tmp_var;
18723
zval *var = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
18727
if (IS_UNUSED == IS_UNUSED) {
18728
/* Initialize for erealloc in add_string_to_string */
18729
Z_STRVAL_P(str) = NULL;
18730
Z_STRLEN_P(str) = 0;
18731
Z_TYPE_P(str) = IS_STRING;
18736
if (Z_TYPE_P(var) != IS_STRING) {
18737
zend_make_printable_zval(var, &var_copy, &use_copy);
18743
add_string_to_string(str, str, var);
18748
/* original comment, possibly problematic:
18749
* FREE_OP is missing intentionally here - we're always working on the same temporary variable
18750
* (Zeev): I don't think it's problematic, we only use variables
18751
* which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
18752
* string offsets or overloaded objects
18754
zval_dtor(free_op2.var);
18756
ZEND_VM_NEXT_OPCODE();
18759
static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18761
zend_op *opline = EX(opline);
18762
zval *function_name;
18763
char *function_name_strval;
18764
int function_name_strlen;
18765
zend_free_op free_op2;
18767
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
18769
function_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
18771
if (Z_TYPE_P(function_name)!=IS_STRING) {
18772
zend_error_noreturn(E_ERROR, "Method name must be a string");
18775
function_name_strval = Z_STRVAL_P(function_name);
18776
function_name_strlen = Z_STRLEN_P(function_name);
18778
EX(object) = _get_obj_zval_ptr_unused(TSRMLS_C);
18780
if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
18781
if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
18782
zend_error_noreturn(E_ERROR, "Object does not support method calls");
18785
/* First, locate the function. */
18786
EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
18788
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
18791
EX(called_scope) = Z_OBJCE_P(EX(object));
18793
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
18796
if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) {
18799
if (!PZVAL_IS_REF(EX(object))) {
18800
Z_ADDREF_P(EX(object)); /* For $this pointer */
18803
ALLOC_ZVAL(this_ptr);
18804
INIT_PZVAL_COPY(this_ptr, EX(object));
18805
zval_copy_ctor(this_ptr);
18806
EX(object) = this_ptr;
18810
zval_dtor(free_op2.var);
18812
ZEND_VM_NEXT_OPCODE();
18815
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18817
zend_op *opline = EX(opline);
18819
array_init(&EX_T(opline->result.u.var).tmp_var);
18820
if (IS_UNUSED == IS_UNUSED) {
18821
ZEND_VM_NEXT_OPCODE();
18822
#if 0 || IS_UNUSED != IS_UNUSED
18824
return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18829
static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18831
zend_op *opline = EX(opline);
18832
zend_free_op free_op2;
18833
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
18834
zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
18836
if (IS_UNUSED != IS_VAR || container) {
18837
if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
18838
SEPARATE_ZVAL_IF_NOT_REF(container);
18840
switch (Z_TYPE_PP(container)) {
18842
HashTable *ht = Z_ARRVAL_PP(container);
18844
switch (Z_TYPE_P(offset)) {
18846
zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
18851
zend_hash_index_del(ht, Z_LVAL_P(offset));
18854
if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
18855
Z_ADDREF_P(offset);
18857
if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
18858
ht == &EG(symbol_table)) {
18859
zend_execute_data *ex;
18860
ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
18862
for (ex = execute_data; ex; ex = ex->prev_execute_data) {
18863
if (ex->op_array && ex->symbol_table == ht) {
18866
for (i = 0; i < ex->op_array->last_var; i++) {
18867
if (ex->op_array->vars[i].hash_value == hash_value &&
18868
ex->op_array->vars[i].name_len == offset->value.str.len &&
18869
!memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
18877
if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
18878
zval_ptr_dtor(&offset);
18882
zend_hash_del(ht, "", sizeof(""));
18885
zend_error(E_WARNING, "Illegal offset type in unset");
18888
zval_dtor(free_op2.var);
18892
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
18893
zend_error_noreturn(E_ERROR, "Cannot use object as array");
18896
MAKE_REAL_ZVAL_PTR(offset);
18898
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
18900
zval_ptr_dtor(&offset);
18902
zval_dtor(free_op2.var);
18906
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
18907
ZEND_VM_CONTINUE(); /* bailed out before */
18909
zval_dtor(free_op2.var);
18913
zval_dtor(free_op2.var);
18916
ZEND_VM_NEXT_OPCODE();
18919
static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18921
zend_op *opline = EX(opline);
18922
zend_free_op free_op2;
18923
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
18924
zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
18926
if (IS_UNUSED != IS_VAR || container) {
18927
if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
18928
SEPARATE_ZVAL_IF_NOT_REF(container);
18930
if (Z_TYPE_PP(container) == IS_OBJECT) {
18932
MAKE_REAL_ZVAL_PTR(offset);
18934
if (Z_OBJ_HT_P(*container)->unset_property) {
18935
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
18937
zend_error(E_NOTICE, "Trying to unset property of non-object");
18940
zval_ptr_dtor(&offset);
18942
zval_dtor(free_op2.var);
18945
zval_dtor(free_op2.var);
18948
zval_dtor(free_op2.var);
18951
ZEND_VM_NEXT_OPCODE();
18954
static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
18956
zend_op *opline = EX(opline);
18958
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
18959
zval **value = NULL;
18962
if (IS_UNUSED != IS_VAR || container) {
18963
zend_free_op free_op2;
18964
zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
18966
if (Z_TYPE_PP(container) == IS_ARRAY) {
18970
ht = Z_ARRVAL_PP(container);
18972
switch (Z_TYPE_P(offset)) {
18974
if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
18981
if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
18986
if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
18991
if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
18996
zend_error(E_WARNING, "Illegal offset type in isset or empty");
19001
switch (opline->extended_value) {
19003
if (isset && Z_TYPE_PP(value) == IS_NULL) {
19010
if (!isset || !i_zend_is_true(*value)) {
19017
zval_dtor(free_op2.var);
19018
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
19020
MAKE_REAL_ZVAL_PTR(offset);
19023
if (Z_OBJ_HT_P(*container)->has_property) {
19024
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
19026
zend_error(E_NOTICE, "Trying to check property of non-object");
19030
if (Z_OBJ_HT_P(*container)->has_dimension) {
19031
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
19033
zend_error(E_NOTICE, "Trying to check element of non-array");
19038
zval_ptr_dtor(&offset);
19040
zval_dtor(free_op2.var);
19042
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
19045
if (Z_TYPE_P(offset) != IS_LONG) {
19047
zval_copy_ctor(&tmp);
19048
convert_to_long(&tmp);
19051
if (Z_TYPE_P(offset) == IS_LONG) {
19052
switch (opline->extended_value) {
19054
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
19059
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
19065
zval_dtor(free_op2.var);
19067
zval_dtor(free_op2.var);
19071
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
19073
switch (opline->extended_value) {
19075
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
19078
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
19082
ZEND_VM_NEXT_OPCODE();
19085
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19087
return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19090
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19092
return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19095
static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
19097
zend_op *opline = EX(opline);
19098
zend_op *op_data = opline+1;
19099
zend_free_op free_op2, free_op_data1;
19100
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
19102
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
19103
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
19104
znode *result = &opline->result;
19105
int have_get_ptr = 0;
19107
if (IS_UNUSED == IS_VAR && !object_ptr) {
19108
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
19111
EX_T(result->u.var).var.ptr_ptr = NULL;
19112
make_real_object(object_ptr TSRMLS_CC);
19113
object = *object_ptr;
19115
if (Z_TYPE_P(object) != IS_OBJECT) {
19116
zend_error(E_WARNING, "Attempt to assign property of non-object");
19117
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19118
FREE_OP(free_op_data1);
19120
if (!RETURN_VALUE_UNUSED(result)) {
19121
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
19122
EX_T(result->u.var).var.ptr_ptr = NULL;
19123
PZVAL_LOCK(EG(uninitialized_zval_ptr));
19126
/* here we are sure we are dealing with an object */
19128
MAKE_REAL_ZVAL_PTR(property);
19131
/* here property is a string */
19132
if (opline->extended_value == ZEND_ASSIGN_OBJ
19133
&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
19134
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
19135
if (zptr != NULL) { /* NULL means no success in getting PTR */
19136
SEPARATE_ZVAL_IF_NOT_REF(zptr);
19139
binary_op(*zptr, *zptr, value TSRMLS_CC);
19140
if (!RETURN_VALUE_UNUSED(result)) {
19141
EX_T(result->u.var).var.ptr = *zptr;
19142
EX_T(result->u.var).var.ptr_ptr = NULL;
19148
if (!have_get_ptr) {
19151
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
19152
if (Z_OBJ_HT_P(object)->read_property) {
19153
z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
19155
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
19156
if (Z_OBJ_HT_P(object)->read_dimension) {
19157
z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
19161
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
19162
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
19164
if (Z_REFCOUNT_P(z) == 0) {
19165
GC_REMOVE_ZVAL_FROM_BUFFER(z);
19172
SEPARATE_ZVAL_IF_NOT_REF(&z);
19173
binary_op(z, z, value TSRMLS_CC);
19174
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
19175
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
19176
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
19177
Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
19179
if (!RETURN_VALUE_UNUSED(result)) {
19180
EX_T(result->u.var).var.ptr = z;
19181
EX_T(result->u.var).var.ptr_ptr = NULL;
19186
zend_error(E_WARNING, "Attempt to assign property of non-object");
19187
if (!RETURN_VALUE_UNUSED(result)) {
19188
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
19189
EX_T(result->u.var).var.ptr_ptr = NULL;
19190
PZVAL_LOCK(EG(uninitialized_zval_ptr));
19196
zval_ptr_dtor(&property);
19198
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19200
FREE_OP(free_op_data1);
19203
/* assign_obj has two opcodes! */
19204
ZEND_VM_INC_OPCODE();
19205
ZEND_VM_NEXT_OPCODE();
19208
static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
19210
zend_op *opline = EX(opline);
19211
zend_free_op free_op2, free_op_data2, free_op_data1;
19215
switch (opline->extended_value) {
19216
case ZEND_ASSIGN_OBJ:
19217
return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19219
case ZEND_ASSIGN_DIM: {
19220
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
19222
if (IS_UNUSED == IS_VAR && !container) {
19223
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
19224
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
19225
if (IS_UNUSED == IS_VAR && !0) {
19226
Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
19228
return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19230
zend_op *op_data = opline+1;
19231
zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
19233
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), container, dim, 0, BP_VAR_RW TSRMLS_CC);
19234
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
19235
var_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
19236
ZEND_VM_INC_OPCODE();
19241
value = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
19248
zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
19251
if (*var_ptr == EG(error_zval_ptr)) {
19252
if (!RETURN_VALUE_UNUSED(&opline->result)) {
19253
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
19254
PZVAL_LOCK(EG(uninitialized_zval_ptr));
19256
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19258
ZEND_VM_NEXT_OPCODE();
19261
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
19263
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
19264
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
19266
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
19267
Z_ADDREF_P(objval);
19268
binary_op(objval, objval, value TSRMLS_CC);
19269
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
19270
zval_ptr_dtor(&objval);
19272
binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
19275
if (!RETURN_VALUE_UNUSED(&opline->result)) {
19276
AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
19277
PZVAL_LOCK(*var_ptr);
19279
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19281
if (opline->extended_value == ZEND_ASSIGN_DIM) {
19282
FREE_OP(free_op_data1);
19283
FREE_OP_VAR_PTR(free_op_data2);
19286
ZEND_VM_NEXT_OPCODE();
19289
static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19291
return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19294
static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19296
return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19299
static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19301
return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19304
static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19306
return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19309
static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19311
return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19314
static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19316
return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19319
static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19321
return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19324
static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19326
return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19329
static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19331
return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19334
static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19336
return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19339
static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19341
return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19344
static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
19346
zend_op *opline = EX(opline);
19347
zend_free_op free_op2;
19348
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
19350
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
19351
zval **retval = &EX_T(opline->result.u.var).var.ptr;
19352
int have_get_ptr = 0;
19354
if (IS_UNUSED == IS_VAR && !object_ptr) {
19355
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
19358
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
19359
object = *object_ptr;
19361
if (Z_TYPE_P(object) != IS_OBJECT) {
19362
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
19363
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19364
if (!RETURN_VALUE_UNUSED(&opline->result)) {
19365
*retval = EG(uninitialized_zval_ptr);
19366
PZVAL_LOCK(*retval);
19369
ZEND_VM_NEXT_OPCODE();
19372
/* here we are sure we are dealing with an object */
19375
MAKE_REAL_ZVAL_PTR(property);
19378
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
19379
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
19380
if (zptr != NULL) { /* NULL means no success in getting PTR */
19381
SEPARATE_ZVAL_IF_NOT_REF(zptr);
19385
if (!RETURN_VALUE_UNUSED(&opline->result)) {
19387
PZVAL_LOCK(*retval);
19392
if (!have_get_ptr) {
19393
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
19394
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
19396
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
19397
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
19399
if (Z_REFCOUNT_P(z) == 0) {
19400
GC_REMOVE_ZVAL_FROM_BUFFER(z);
19407
SEPARATE_ZVAL_IF_NOT_REF(&z);
19410
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
19411
SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
19414
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
19415
if (!RETURN_VALUE_UNUSED(&opline->result)) {
19416
*retval = EG(uninitialized_zval_ptr);
19417
PZVAL_LOCK(*retval);
19423
zval_ptr_dtor(&property);
19425
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19428
ZEND_VM_NEXT_OPCODE();
19431
static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19433
return zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19436
static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19438
return zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19441
static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
19443
zend_op *opline = EX(opline);
19444
zend_free_op free_op2;
19445
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
19447
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
19448
zval *retval = &EX_T(opline->result.u.var).tmp_var;
19449
int have_get_ptr = 0;
19451
if (IS_UNUSED == IS_VAR && !object_ptr) {
19452
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
19455
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
19456
object = *object_ptr;
19458
if (Z_TYPE_P(object) != IS_OBJECT) {
19459
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
19460
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19461
*retval = *EG(uninitialized_zval_ptr);
19463
ZEND_VM_NEXT_OPCODE();
19466
/* here we are sure we are dealing with an object */
19469
MAKE_REAL_ZVAL_PTR(property);
19472
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
19473
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
19474
if (zptr != NULL) { /* NULL means no success in getting PTR */
19476
SEPARATE_ZVAL_IF_NOT_REF(zptr);
19479
zendi_zval_copy_ctor(*retval);
19486
if (!have_get_ptr) {
19487
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
19488
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
19491
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
19492
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
19494
if (Z_REFCOUNT_P(z) == 0) {
19495
GC_REMOVE_ZVAL_FROM_BUFFER(z);
19502
zendi_zval_copy_ctor(*retval);
19503
ALLOC_ZVAL(z_copy);
19505
zendi_zval_copy_ctor(*z_copy);
19506
INIT_PZVAL(z_copy);
19509
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
19510
zval_ptr_dtor(&z_copy);
19513
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
19514
*retval = *EG(uninitialized_zval_ptr);
19519
zval_ptr_dtor(&property);
19521
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19524
ZEND_VM_NEXT_OPCODE();
19527
static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19529
return zend_post_incdec_property_helper_SPEC_UNUSED_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19532
static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19534
return zend_post_incdec_property_helper_SPEC_UNUSED_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19537
static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
19539
zend_op *opline = EX(opline);
19541
zval *container = _get_obj_zval_ptr_unused(TSRMLS_C);
19542
zend_free_op free_op2;
19543
zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
19545
if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
19546
if (type != BP_VAR_IS) {
19547
zend_error(E_NOTICE, "Trying to get property of non-object");
19549
if (!RETURN_VALUE_UNUSED(&opline->result)) {
19550
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
19551
PZVAL_LOCK(EG(uninitialized_zval_ptr));
19553
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19558
MAKE_REAL_ZVAL_PTR(offset);
19561
/* here we are sure we are dealing with an object */
19562
retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
19564
if (RETURN_VALUE_UNUSED(&opline->result)) {
19565
if (Z_REFCOUNT_P(retval) == 0) {
19566
GC_REMOVE_ZVAL_FROM_BUFFER(retval);
19571
AI_SET_PTR(EX_T(opline->result.u.var).var, retval);
19572
PZVAL_LOCK(retval);
19576
zval_ptr_dtor(&offset);
19578
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19582
ZEND_VM_NEXT_OPCODE();
19585
static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19587
return zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19590
static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19592
zend_op *opline = EX(opline);
19593
zend_free_op free_op1, free_op2;
19594
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
19597
if (IS_UNUSED == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
19598
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
19599
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
19603
MAKE_REAL_ZVAL_PTR(property);
19605
container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
19606
if (IS_UNUSED == IS_VAR && !container) {
19607
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
19609
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
19611
zval_ptr_dtor(&property);
19613
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19615
if (IS_UNUSED == IS_VAR && 0 &&
19616
READY_TO_DESTROY(free_op1.var)) {
19617
AI_USE_PTR(EX_T(opline->result.u.var).var);
19618
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
19619
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
19620
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
19624
/* We are going to assign the result by reference */
19625
if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
19626
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
19627
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
19628
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
19631
ZEND_VM_NEXT_OPCODE();
19634
static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19636
zend_op *opline = EX(opline);
19637
zend_free_op free_op1, free_op2;
19638
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
19639
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
19642
MAKE_REAL_ZVAL_PTR(property);
19644
if (IS_UNUSED == IS_VAR && !container) {
19645
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
19647
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_RW TSRMLS_CC);
19649
zval_ptr_dtor(&property);
19651
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19653
if (IS_UNUSED == IS_VAR && 0 &&
19654
READY_TO_DESTROY(free_op1.var)) {
19655
AI_USE_PTR(EX_T(opline->result.u.var).var);
19656
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
19657
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
19658
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
19662
ZEND_VM_NEXT_OPCODE();
19665
static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19667
return zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19670
static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19672
zend_op *opline = EX(opline);
19674
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
19675
/* Behave like FETCH_OBJ_W */
19676
zend_free_op free_op1, free_op2;
19677
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
19678
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
19681
MAKE_REAL_ZVAL_PTR(property);
19683
if (IS_UNUSED == IS_VAR && !container) {
19684
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
19686
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
19688
zval_ptr_dtor(&property);
19690
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19692
if (IS_UNUSED == IS_VAR && 0 &&
19693
READY_TO_DESTROY(free_op1.var)) {
19694
AI_USE_PTR(EX_T(opline->result.u.var).var);
19695
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
19696
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
19697
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
19701
ZEND_VM_NEXT_OPCODE();
19703
return zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19707
static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19709
zend_op *opline = EX(opline);
19710
zend_free_op free_op1, free_op2, free_res;
19711
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
19712
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
19714
if (IS_UNUSED == IS_CV) {
19715
if (container != &EG(uninitialized_zval_ptr)) {
19716
SEPARATE_ZVAL_IF_NOT_REF(container);
19720
MAKE_REAL_ZVAL_PTR(property);
19722
if (IS_UNUSED == IS_VAR && !container) {
19723
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
19725
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
19727
zval_ptr_dtor(&property);
19729
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19731
if (IS_UNUSED == IS_VAR && 0 &&
19732
READY_TO_DESTROY(free_op1.var)) {
19733
AI_USE_PTR(EX_T(opline->result.u.var).var);
19734
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
19735
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
19736
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
19740
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
19741
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
19742
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
19744
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
19745
FREE_OP_VAR_PTR(free_res);
19746
ZEND_VM_NEXT_OPCODE();
19749
static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19751
zend_op *opline = EX(opline);
19752
zend_op *op_data = opline+1;
19753
zend_free_op free_op2;
19754
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
19755
zval *property_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
19758
MAKE_REAL_ZVAL_PTR(property_name);
19760
if (IS_UNUSED == IS_VAR && !object_ptr) {
19761
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
19763
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
19765
zval_ptr_dtor(&property_name);
19767
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19770
/* assign_obj has two opcodes! */
19771
ZEND_VM_INC_OPCODE();
19772
ZEND_VM_NEXT_OPCODE();
19775
static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19777
zend_op *opline = EX(opline);
19778
zend_free_op free_op2;
19779
zval *str = &EX_T(opline->result.u.var).tmp_var;
19780
zval *var = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
19784
if (IS_UNUSED == IS_UNUSED) {
19785
/* Initialize for erealloc in add_string_to_string */
19786
Z_STRVAL_P(str) = NULL;
19787
Z_STRLEN_P(str) = 0;
19788
Z_TYPE_P(str) = IS_STRING;
19793
if (Z_TYPE_P(var) != IS_STRING) {
19794
zend_make_printable_zval(var, &var_copy, &use_copy);
19800
add_string_to_string(str, str, var);
19805
/* original comment, possibly problematic:
19806
* FREE_OP is missing intentionally here - we're always working on the same temporary variable
19807
* (Zeev): I don't think it's problematic, we only use variables
19808
* which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
19809
* string offsets or overloaded objects
19811
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19813
ZEND_VM_NEXT_OPCODE();
19816
static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19818
zend_op *opline = EX(opline);
19819
zval *function_name;
19820
char *function_name_strval;
19821
int function_name_strlen;
19822
zend_free_op free_op2;
19824
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
19826
function_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
19828
if (Z_TYPE_P(function_name)!=IS_STRING) {
19829
zend_error_noreturn(E_ERROR, "Method name must be a string");
19832
function_name_strval = Z_STRVAL_P(function_name);
19833
function_name_strlen = Z_STRLEN_P(function_name);
19835
EX(object) = _get_obj_zval_ptr_unused(TSRMLS_C);
19837
if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
19838
if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
19839
zend_error_noreturn(E_ERROR, "Object does not support method calls");
19842
/* First, locate the function. */
19843
EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
19845
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
19848
EX(called_scope) = Z_OBJCE_P(EX(object));
19850
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
19853
if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) {
19856
if (!PZVAL_IS_REF(EX(object))) {
19857
Z_ADDREF_P(EX(object)); /* For $this pointer */
19860
ALLOC_ZVAL(this_ptr);
19861
INIT_PZVAL_COPY(this_ptr, EX(object));
19862
zval_copy_ctor(this_ptr);
19863
EX(object) = this_ptr;
19867
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19869
ZEND_VM_NEXT_OPCODE();
19872
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19874
zend_op *opline = EX(opline);
19876
array_init(&EX_T(opline->result.u.var).tmp_var);
19877
if (IS_UNUSED == IS_UNUSED) {
19878
ZEND_VM_NEXT_OPCODE();
19879
#if 0 || IS_UNUSED != IS_UNUSED
19881
return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19886
static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19888
zend_op *opline = EX(opline);
19889
zend_free_op free_op2;
19890
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
19891
zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
19893
if (IS_UNUSED != IS_VAR || container) {
19894
if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
19895
SEPARATE_ZVAL_IF_NOT_REF(container);
19897
switch (Z_TYPE_PP(container)) {
19899
HashTable *ht = Z_ARRVAL_PP(container);
19901
switch (Z_TYPE_P(offset)) {
19903
zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
19908
zend_hash_index_del(ht, Z_LVAL_P(offset));
19911
if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
19912
Z_ADDREF_P(offset);
19914
if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
19915
ht == &EG(symbol_table)) {
19916
zend_execute_data *ex;
19917
ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
19919
for (ex = execute_data; ex; ex = ex->prev_execute_data) {
19920
if (ex->op_array && ex->symbol_table == ht) {
19923
for (i = 0; i < ex->op_array->last_var; i++) {
19924
if (ex->op_array->vars[i].hash_value == hash_value &&
19925
ex->op_array->vars[i].name_len == offset->value.str.len &&
19926
!memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
19934
if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
19935
zval_ptr_dtor(&offset);
19939
zend_hash_del(ht, "", sizeof(""));
19942
zend_error(E_WARNING, "Illegal offset type in unset");
19945
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19949
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
19950
zend_error_noreturn(E_ERROR, "Cannot use object as array");
19953
MAKE_REAL_ZVAL_PTR(offset);
19955
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
19957
zval_ptr_dtor(&offset);
19959
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19963
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
19964
ZEND_VM_CONTINUE(); /* bailed out before */
19966
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19970
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
19973
ZEND_VM_NEXT_OPCODE();
19976
static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19978
zend_op *opline = EX(opline);
19979
zend_free_op free_op2;
19980
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
19981
zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
19983
if (IS_UNUSED != IS_VAR || container) {
19984
if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
19985
SEPARATE_ZVAL_IF_NOT_REF(container);
19987
if (Z_TYPE_PP(container) == IS_OBJECT) {
19989
MAKE_REAL_ZVAL_PTR(offset);
19991
if (Z_OBJ_HT_P(*container)->unset_property) {
19992
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
19994
zend_error(E_NOTICE, "Trying to unset property of non-object");
19997
zval_ptr_dtor(&offset);
19999
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
20002
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
20005
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
20008
ZEND_VM_NEXT_OPCODE();
20011
static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
20013
zend_op *opline = EX(opline);
20015
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
20016
zval **value = NULL;
20019
if (IS_UNUSED != IS_VAR || container) {
20020
zend_free_op free_op2;
20021
zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
20023
if (Z_TYPE_PP(container) == IS_ARRAY) {
20027
ht = Z_ARRVAL_PP(container);
20029
switch (Z_TYPE_P(offset)) {
20031
if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
20038
if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
20043
if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
20048
if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
20053
zend_error(E_WARNING, "Illegal offset type in isset or empty");
20058
switch (opline->extended_value) {
20060
if (isset && Z_TYPE_PP(value) == IS_NULL) {
20067
if (!isset || !i_zend_is_true(*value)) {
20074
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
20075
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
20077
MAKE_REAL_ZVAL_PTR(offset);
20080
if (Z_OBJ_HT_P(*container)->has_property) {
20081
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
20083
zend_error(E_NOTICE, "Trying to check property of non-object");
20087
if (Z_OBJ_HT_P(*container)->has_dimension) {
20088
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
20090
zend_error(E_NOTICE, "Trying to check element of non-array");
20095
zval_ptr_dtor(&offset);
20097
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
20099
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
20102
if (Z_TYPE_P(offset) != IS_LONG) {
20104
zval_copy_ctor(&tmp);
20105
convert_to_long(&tmp);
20108
if (Z_TYPE_P(offset) == IS_LONG) {
20109
switch (opline->extended_value) {
20111
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
20116
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
20122
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
20124
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
20128
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
20130
switch (opline->extended_value) {
20132
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
20135
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
20139
ZEND_VM_NEXT_OPCODE();
20142
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20144
return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20147
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20149
return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20152
static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
20154
zend_op *opline = EX(opline);
20155
zend_op *op_data = opline+1;
20156
zend_free_op free_op_data1;
20157
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
20159
zval *property = NULL;
20160
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
20161
znode *result = &opline->result;
20162
int have_get_ptr = 0;
20164
if (IS_UNUSED == IS_VAR && !object_ptr) {
20165
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
20168
EX_T(result->u.var).var.ptr_ptr = NULL;
20169
make_real_object(object_ptr TSRMLS_CC);
20170
object = *object_ptr;
20172
if (Z_TYPE_P(object) != IS_OBJECT) {
20173
zend_error(E_WARNING, "Attempt to assign property of non-object");
20175
FREE_OP(free_op_data1);
20177
if (!RETURN_VALUE_UNUSED(result)) {
20178
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
20179
EX_T(result->u.var).var.ptr_ptr = NULL;
20180
PZVAL_LOCK(EG(uninitialized_zval_ptr));
20183
/* here we are sure we are dealing with an object */
20185
MAKE_REAL_ZVAL_PTR(property);
20188
/* here property is a string */
20189
if (opline->extended_value == ZEND_ASSIGN_OBJ
20190
&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
20191
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
20192
if (zptr != NULL) { /* NULL means no success in getting PTR */
20193
SEPARATE_ZVAL_IF_NOT_REF(zptr);
20196
binary_op(*zptr, *zptr, value TSRMLS_CC);
20197
if (!RETURN_VALUE_UNUSED(result)) {
20198
EX_T(result->u.var).var.ptr = *zptr;
20199
EX_T(result->u.var).var.ptr_ptr = NULL;
20205
if (!have_get_ptr) {
20208
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
20209
if (Z_OBJ_HT_P(object)->read_property) {
20210
z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
20212
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
20213
if (Z_OBJ_HT_P(object)->read_dimension) {
20214
z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
20218
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
20219
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
20221
if (Z_REFCOUNT_P(z) == 0) {
20222
GC_REMOVE_ZVAL_FROM_BUFFER(z);
20229
SEPARATE_ZVAL_IF_NOT_REF(&z);
20230
binary_op(z, z, value TSRMLS_CC);
20231
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
20232
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
20233
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
20234
Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
20236
if (!RETURN_VALUE_UNUSED(result)) {
20237
EX_T(result->u.var).var.ptr = z;
20238
EX_T(result->u.var).var.ptr_ptr = NULL;
20243
zend_error(E_WARNING, "Attempt to assign property of non-object");
20244
if (!RETURN_VALUE_UNUSED(result)) {
20245
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
20246
EX_T(result->u.var).var.ptr_ptr = NULL;
20247
PZVAL_LOCK(EG(uninitialized_zval_ptr));
20253
zval_ptr_dtor(&property);
20257
FREE_OP(free_op_data1);
20260
/* assign_obj has two opcodes! */
20261
ZEND_VM_INC_OPCODE();
20262
ZEND_VM_NEXT_OPCODE();
20265
static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
20267
zend_op *opline = EX(opline);
20268
zend_free_op free_op_data2, free_op_data1;
20272
switch (opline->extended_value) {
20273
case ZEND_ASSIGN_OBJ:
20274
return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20276
case ZEND_ASSIGN_DIM: {
20277
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
20279
if (IS_UNUSED == IS_VAR && !container) {
20280
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
20281
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
20282
if (IS_UNUSED == IS_VAR && !0) {
20283
Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
20285
return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20287
zend_op *op_data = opline+1;
20290
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), container, dim, 0, BP_VAR_RW TSRMLS_CC);
20291
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
20292
var_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
20293
ZEND_VM_INC_OPCODE();
20305
zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
20308
if (*var_ptr == EG(error_zval_ptr)) {
20309
if (!RETURN_VALUE_UNUSED(&opline->result)) {
20310
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
20311
PZVAL_LOCK(EG(uninitialized_zval_ptr));
20315
ZEND_VM_NEXT_OPCODE();
20318
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
20320
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
20321
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
20323
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
20324
Z_ADDREF_P(objval);
20325
binary_op(objval, objval, value TSRMLS_CC);
20326
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
20327
zval_ptr_dtor(&objval);
20329
binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
20332
if (!RETURN_VALUE_UNUSED(&opline->result)) {
20333
AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
20334
PZVAL_LOCK(*var_ptr);
20337
if (opline->extended_value == ZEND_ASSIGN_DIM) {
20338
FREE_OP(free_op_data1);
20339
FREE_OP_VAR_PTR(free_op_data2);
20342
ZEND_VM_NEXT_OPCODE();
20345
static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20347
return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20350
static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20352
return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20355
static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20357
return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20360
static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20362
return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20365
static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20367
return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20370
static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20372
return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20375
static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20377
return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20380
static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20382
return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20385
static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20387
return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20390
static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20392
return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20395
static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20397
return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20400
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20402
zend_op *opline = EX(opline);
20404
array_init(&EX_T(opline->result.u.var).tmp_var);
20405
if (IS_UNUSED == IS_UNUSED) {
20406
ZEND_VM_NEXT_OPCODE();
20407
#if 0 || IS_UNUSED != IS_UNUSED
20409
return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20414
static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
20416
zend_op *opline = EX(opline);
20417
zend_op *op_data = opline+1;
20418
zend_free_op free_op_data1;
20419
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
20421
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
20422
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
20423
znode *result = &opline->result;
20424
int have_get_ptr = 0;
20426
if (IS_UNUSED == IS_VAR && !object_ptr) {
20427
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
20430
EX_T(result->u.var).var.ptr_ptr = NULL;
20431
make_real_object(object_ptr TSRMLS_CC);
20432
object = *object_ptr;
20434
if (Z_TYPE_P(object) != IS_OBJECT) {
20435
zend_error(E_WARNING, "Attempt to assign property of non-object");
20437
FREE_OP(free_op_data1);
20439
if (!RETURN_VALUE_UNUSED(result)) {
20440
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
20441
EX_T(result->u.var).var.ptr_ptr = NULL;
20442
PZVAL_LOCK(EG(uninitialized_zval_ptr));
20445
/* here we are sure we are dealing with an object */
20447
MAKE_REAL_ZVAL_PTR(property);
20450
/* here property is a string */
20451
if (opline->extended_value == ZEND_ASSIGN_OBJ
20452
&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
20453
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
20454
if (zptr != NULL) { /* NULL means no success in getting PTR */
20455
SEPARATE_ZVAL_IF_NOT_REF(zptr);
20458
binary_op(*zptr, *zptr, value TSRMLS_CC);
20459
if (!RETURN_VALUE_UNUSED(result)) {
20460
EX_T(result->u.var).var.ptr = *zptr;
20461
EX_T(result->u.var).var.ptr_ptr = NULL;
20467
if (!have_get_ptr) {
20470
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
20471
if (Z_OBJ_HT_P(object)->read_property) {
20472
z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
20474
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
20475
if (Z_OBJ_HT_P(object)->read_dimension) {
20476
z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
20480
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
20481
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
20483
if (Z_REFCOUNT_P(z) == 0) {
20484
GC_REMOVE_ZVAL_FROM_BUFFER(z);
20491
SEPARATE_ZVAL_IF_NOT_REF(&z);
20492
binary_op(z, z, value TSRMLS_CC);
20493
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
20494
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
20495
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
20496
Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
20498
if (!RETURN_VALUE_UNUSED(result)) {
20499
EX_T(result->u.var).var.ptr = z;
20500
EX_T(result->u.var).var.ptr_ptr = NULL;
20505
zend_error(E_WARNING, "Attempt to assign property of non-object");
20506
if (!RETURN_VALUE_UNUSED(result)) {
20507
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
20508
EX_T(result->u.var).var.ptr_ptr = NULL;
20509
PZVAL_LOCK(EG(uninitialized_zval_ptr));
20515
zval_ptr_dtor(&property);
20519
FREE_OP(free_op_data1);
20522
/* assign_obj has two opcodes! */
20523
ZEND_VM_INC_OPCODE();
20524
ZEND_VM_NEXT_OPCODE();
20527
static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
20529
zend_op *opline = EX(opline);
20530
zend_free_op free_op_data2, free_op_data1;
20534
switch (opline->extended_value) {
20535
case ZEND_ASSIGN_OBJ:
20536
return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20538
case ZEND_ASSIGN_DIM: {
20539
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
20541
if (IS_UNUSED == IS_VAR && !container) {
20542
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
20543
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
20544
if (IS_UNUSED == IS_VAR && !0) {
20545
Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
20547
return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20549
zend_op *op_data = opline+1;
20550
zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
20552
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), container, dim, 0, BP_VAR_RW TSRMLS_CC);
20553
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
20554
var_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
20555
ZEND_VM_INC_OPCODE();
20560
value = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
20567
zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
20570
if (*var_ptr == EG(error_zval_ptr)) {
20571
if (!RETURN_VALUE_UNUSED(&opline->result)) {
20572
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
20573
PZVAL_LOCK(EG(uninitialized_zval_ptr));
20577
ZEND_VM_NEXT_OPCODE();
20580
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
20582
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
20583
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
20585
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
20586
Z_ADDREF_P(objval);
20587
binary_op(objval, objval, value TSRMLS_CC);
20588
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
20589
zval_ptr_dtor(&objval);
20591
binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
20594
if (!RETURN_VALUE_UNUSED(&opline->result)) {
20595
AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
20596
PZVAL_LOCK(*var_ptr);
20599
if (opline->extended_value == ZEND_ASSIGN_DIM) {
20600
FREE_OP(free_op_data1);
20601
FREE_OP_VAR_PTR(free_op_data2);
20604
ZEND_VM_NEXT_OPCODE();
20607
static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20609
return zend_binary_assign_op_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20612
static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20614
return zend_binary_assign_op_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20617
static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20619
return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20622
static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20624
return zend_binary_assign_op_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20627
static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20629
return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20632
static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20634
return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20637
static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20639
return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20642
static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20644
return zend_binary_assign_op_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20647
static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20649
return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20652
static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20654
return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20657
static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20659
return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20662
static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
20664
zend_op *opline = EX(opline);
20666
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
20668
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
20669
zval **retval = &EX_T(opline->result.u.var).var.ptr;
20670
int have_get_ptr = 0;
20672
if (IS_UNUSED == IS_VAR && !object_ptr) {
20673
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
20676
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
20677
object = *object_ptr;
20679
if (Z_TYPE_P(object) != IS_OBJECT) {
20680
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
20682
if (!RETURN_VALUE_UNUSED(&opline->result)) {
20683
*retval = EG(uninitialized_zval_ptr);
20684
PZVAL_LOCK(*retval);
20687
ZEND_VM_NEXT_OPCODE();
20690
/* here we are sure we are dealing with an object */
20693
MAKE_REAL_ZVAL_PTR(property);
20696
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
20697
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
20698
if (zptr != NULL) { /* NULL means no success in getting PTR */
20699
SEPARATE_ZVAL_IF_NOT_REF(zptr);
20703
if (!RETURN_VALUE_UNUSED(&opline->result)) {
20705
PZVAL_LOCK(*retval);
20710
if (!have_get_ptr) {
20711
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
20712
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
20714
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
20715
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
20717
if (Z_REFCOUNT_P(z) == 0) {
20718
GC_REMOVE_ZVAL_FROM_BUFFER(z);
20725
SEPARATE_ZVAL_IF_NOT_REF(&z);
20728
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
20729
SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
20732
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
20733
if (!RETURN_VALUE_UNUSED(&opline->result)) {
20734
*retval = EG(uninitialized_zval_ptr);
20735
PZVAL_LOCK(*retval);
20741
zval_ptr_dtor(&property);
20746
ZEND_VM_NEXT_OPCODE();
20749
static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20751
return zend_pre_incdec_property_helper_SPEC_UNUSED_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20754
static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20756
return zend_pre_incdec_property_helper_SPEC_UNUSED_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20759
static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
20761
zend_op *opline = EX(opline);
20763
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
20765
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
20766
zval *retval = &EX_T(opline->result.u.var).tmp_var;
20767
int have_get_ptr = 0;
20769
if (IS_UNUSED == IS_VAR && !object_ptr) {
20770
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
20773
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
20774
object = *object_ptr;
20776
if (Z_TYPE_P(object) != IS_OBJECT) {
20777
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
20779
*retval = *EG(uninitialized_zval_ptr);
20781
ZEND_VM_NEXT_OPCODE();
20784
/* here we are sure we are dealing with an object */
20787
MAKE_REAL_ZVAL_PTR(property);
20790
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
20791
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
20792
if (zptr != NULL) { /* NULL means no success in getting PTR */
20794
SEPARATE_ZVAL_IF_NOT_REF(zptr);
20797
zendi_zval_copy_ctor(*retval);
20804
if (!have_get_ptr) {
20805
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
20806
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
20809
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
20810
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
20812
if (Z_REFCOUNT_P(z) == 0) {
20813
GC_REMOVE_ZVAL_FROM_BUFFER(z);
20820
zendi_zval_copy_ctor(*retval);
20821
ALLOC_ZVAL(z_copy);
20823
zendi_zval_copy_ctor(*z_copy);
20824
INIT_PZVAL(z_copy);
20827
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
20828
zval_ptr_dtor(&z_copy);
20831
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
20832
*retval = *EG(uninitialized_zval_ptr);
20837
zval_ptr_dtor(&property);
20842
ZEND_VM_NEXT_OPCODE();
20845
static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20847
return zend_post_incdec_property_helper_SPEC_UNUSED_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20850
static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20852
return zend_post_incdec_property_helper_SPEC_UNUSED_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20855
static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(int type, ZEND_OPCODE_HANDLER_ARGS)
20857
zend_op *opline = EX(opline);
20859
zval *container = _get_obj_zval_ptr_unused(TSRMLS_C);
20861
zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
20863
if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
20864
if (type != BP_VAR_IS) {
20865
zend_error(E_NOTICE, "Trying to get property of non-object");
20867
if (!RETURN_VALUE_UNUSED(&opline->result)) {
20868
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
20869
PZVAL_LOCK(EG(uninitialized_zval_ptr));
20876
MAKE_REAL_ZVAL_PTR(offset);
20879
/* here we are sure we are dealing with an object */
20880
retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
20882
if (RETURN_VALUE_UNUSED(&opline->result)) {
20883
if (Z_REFCOUNT_P(retval) == 0) {
20884
GC_REMOVE_ZVAL_FROM_BUFFER(retval);
20889
AI_SET_PTR(EX_T(opline->result.u.var).var, retval);
20890
PZVAL_LOCK(retval);
20894
zval_ptr_dtor(&offset);
20900
ZEND_VM_NEXT_OPCODE();
20903
static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20905
return zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20908
static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20910
zend_op *opline = EX(opline);
20911
zend_free_op free_op1;
20912
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
20915
if (IS_UNUSED == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
20916
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
20917
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
20921
MAKE_REAL_ZVAL_PTR(property);
20923
container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
20924
if (IS_UNUSED == IS_VAR && !container) {
20925
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
20927
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
20929
zval_ptr_dtor(&property);
20933
if (IS_UNUSED == IS_VAR && 0 &&
20934
READY_TO_DESTROY(free_op1.var)) {
20935
AI_USE_PTR(EX_T(opline->result.u.var).var);
20936
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
20937
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
20938
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
20942
/* We are going to assign the result by reference */
20943
if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
20944
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
20945
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
20946
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
20949
ZEND_VM_NEXT_OPCODE();
20952
static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20954
zend_op *opline = EX(opline);
20955
zend_free_op free_op1;
20956
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
20957
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
20960
MAKE_REAL_ZVAL_PTR(property);
20962
if (IS_UNUSED == IS_VAR && !container) {
20963
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
20965
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_RW TSRMLS_CC);
20967
zval_ptr_dtor(&property);
20971
if (IS_UNUSED == IS_VAR && 0 &&
20972
READY_TO_DESTROY(free_op1.var)) {
20973
AI_USE_PTR(EX_T(opline->result.u.var).var);
20974
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
20975
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
20976
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
20980
ZEND_VM_NEXT_OPCODE();
20983
static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20985
return zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20988
static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20990
zend_op *opline = EX(opline);
20992
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
20993
/* Behave like FETCH_OBJ_W */
20994
zend_free_op free_op1;
20995
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
20996
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
20999
MAKE_REAL_ZVAL_PTR(property);
21001
if (IS_UNUSED == IS_VAR && !container) {
21002
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
21004
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
21006
zval_ptr_dtor(&property);
21010
if (IS_UNUSED == IS_VAR && 0 &&
21011
READY_TO_DESTROY(free_op1.var)) {
21012
AI_USE_PTR(EX_T(opline->result.u.var).var);
21013
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
21014
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
21015
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
21019
ZEND_VM_NEXT_OPCODE();
21021
return zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21025
static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21027
zend_op *opline = EX(opline);
21028
zend_free_op free_op1, free_res;
21029
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
21030
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
21032
if (IS_UNUSED == IS_CV) {
21033
if (container != &EG(uninitialized_zval_ptr)) {
21034
SEPARATE_ZVAL_IF_NOT_REF(container);
21038
MAKE_REAL_ZVAL_PTR(property);
21040
if (IS_UNUSED == IS_VAR && !container) {
21041
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
21043
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
21045
zval_ptr_dtor(&property);
21049
if (IS_UNUSED == IS_VAR && 0 &&
21050
READY_TO_DESTROY(free_op1.var)) {
21051
AI_USE_PTR(EX_T(opline->result.u.var).var);
21052
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
21053
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
21054
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
21058
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
21059
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
21060
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
21062
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
21063
FREE_OP_VAR_PTR(free_res);
21064
ZEND_VM_NEXT_OPCODE();
21067
static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21069
zend_op *opline = EX(opline);
21070
zend_op *op_data = opline+1;
21072
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
21073
zval *property_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
21076
MAKE_REAL_ZVAL_PTR(property_name);
21078
if (IS_UNUSED == IS_VAR && !object_ptr) {
21079
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
21081
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
21083
zval_ptr_dtor(&property_name);
21088
/* assign_obj has two opcodes! */
21089
ZEND_VM_INC_OPCODE();
21090
ZEND_VM_NEXT_OPCODE();
21093
static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21095
zend_op *opline = EX(opline);
21097
zval *str = &EX_T(opline->result.u.var).tmp_var;
21098
zval *var = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
21102
if (IS_UNUSED == IS_UNUSED) {
21103
/* Initialize for erealloc in add_string_to_string */
21104
Z_STRVAL_P(str) = NULL;
21105
Z_STRLEN_P(str) = 0;
21106
Z_TYPE_P(str) = IS_STRING;
21111
if (Z_TYPE_P(var) != IS_STRING) {
21112
zend_make_printable_zval(var, &var_copy, &use_copy);
21118
add_string_to_string(str, str, var);
21123
/* original comment, possibly problematic:
21124
* FREE_OP is missing intentionally here - we're always working on the same temporary variable
21125
* (Zeev): I don't think it's problematic, we only use variables
21126
* which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
21127
* string offsets or overloaded objects
21130
ZEND_VM_NEXT_OPCODE();
21133
static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21135
zend_op *opline = EX(opline);
21136
zval *function_name;
21137
char *function_name_strval;
21138
int function_name_strlen;
21141
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
21143
function_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
21145
if (Z_TYPE_P(function_name)!=IS_STRING) {
21146
zend_error_noreturn(E_ERROR, "Method name must be a string");
21149
function_name_strval = Z_STRVAL_P(function_name);
21150
function_name_strlen = Z_STRLEN_P(function_name);
21152
EX(object) = _get_obj_zval_ptr_unused(TSRMLS_C);
21154
if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
21155
if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
21156
zend_error_noreturn(E_ERROR, "Object does not support method calls");
21159
/* First, locate the function. */
21160
EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
21162
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
21165
EX(called_scope) = Z_OBJCE_P(EX(object));
21167
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
21170
if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) {
21173
if (!PZVAL_IS_REF(EX(object))) {
21174
Z_ADDREF_P(EX(object)); /* For $this pointer */
21177
ALLOC_ZVAL(this_ptr);
21178
INIT_PZVAL_COPY(this_ptr, EX(object));
21179
zval_copy_ctor(this_ptr);
21180
EX(object) = this_ptr;
21185
ZEND_VM_NEXT_OPCODE();
21188
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21190
zend_op *opline = EX(opline);
21192
array_init(&EX_T(opline->result.u.var).tmp_var);
21193
if (IS_UNUSED == IS_UNUSED) {
21194
ZEND_VM_NEXT_OPCODE();
21195
#if 0 || IS_UNUSED != IS_UNUSED
21197
return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21202
static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21204
zend_op *opline = EX(opline);
21206
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
21207
zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
21209
if (IS_UNUSED != IS_VAR || container) {
21210
if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
21211
SEPARATE_ZVAL_IF_NOT_REF(container);
21213
switch (Z_TYPE_PP(container)) {
21215
HashTable *ht = Z_ARRVAL_PP(container);
21217
switch (Z_TYPE_P(offset)) {
21219
zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
21224
zend_hash_index_del(ht, Z_LVAL_P(offset));
21227
if (IS_CV == IS_CV || IS_CV == IS_VAR) {
21228
Z_ADDREF_P(offset);
21230
if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
21231
ht == &EG(symbol_table)) {
21232
zend_execute_data *ex;
21233
ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
21235
for (ex = execute_data; ex; ex = ex->prev_execute_data) {
21236
if (ex->op_array && ex->symbol_table == ht) {
21239
for (i = 0; i < ex->op_array->last_var; i++) {
21240
if (ex->op_array->vars[i].hash_value == hash_value &&
21241
ex->op_array->vars[i].name_len == offset->value.str.len &&
21242
!memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
21250
if (IS_CV == IS_CV || IS_CV == IS_VAR) {
21251
zval_ptr_dtor(&offset);
21255
zend_hash_del(ht, "", sizeof(""));
21258
zend_error(E_WARNING, "Illegal offset type in unset");
21265
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
21266
zend_error_noreturn(E_ERROR, "Cannot use object as array");
21269
MAKE_REAL_ZVAL_PTR(offset);
21271
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
21273
zval_ptr_dtor(&offset);
21279
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
21280
ZEND_VM_CONTINUE(); /* bailed out before */
21289
ZEND_VM_NEXT_OPCODE();
21292
static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21294
zend_op *opline = EX(opline);
21296
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
21297
zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
21299
if (IS_UNUSED != IS_VAR || container) {
21300
if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
21301
SEPARATE_ZVAL_IF_NOT_REF(container);
21303
if (Z_TYPE_PP(container) == IS_OBJECT) {
21305
MAKE_REAL_ZVAL_PTR(offset);
21307
if (Z_OBJ_HT_P(*container)->unset_property) {
21308
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
21310
zend_error(E_NOTICE, "Trying to unset property of non-object");
21313
zval_ptr_dtor(&offset);
21324
ZEND_VM_NEXT_OPCODE();
21327
static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
21329
zend_op *opline = EX(opline);
21331
zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
21332
zval **value = NULL;
21335
if (IS_UNUSED != IS_VAR || container) {
21337
zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
21339
if (Z_TYPE_PP(container) == IS_ARRAY) {
21343
ht = Z_ARRVAL_PP(container);
21345
switch (Z_TYPE_P(offset)) {
21347
if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
21354
if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
21359
if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
21364
if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
21369
zend_error(E_WARNING, "Illegal offset type in isset or empty");
21374
switch (opline->extended_value) {
21376
if (isset && Z_TYPE_PP(value) == IS_NULL) {
21383
if (!isset || !i_zend_is_true(*value)) {
21391
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
21393
MAKE_REAL_ZVAL_PTR(offset);
21396
if (Z_OBJ_HT_P(*container)->has_property) {
21397
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
21399
zend_error(E_NOTICE, "Trying to check property of non-object");
21403
if (Z_OBJ_HT_P(*container)->has_dimension) {
21404
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
21406
zend_error(E_NOTICE, "Trying to check element of non-array");
21411
zval_ptr_dtor(&offset);
21415
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
21418
if (Z_TYPE_P(offset) != IS_LONG) {
21420
zval_copy_ctor(&tmp);
21421
convert_to_long(&tmp);
21424
if (Z_TYPE_P(offset) == IS_LONG) {
21425
switch (opline->extended_value) {
21427
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
21432
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
21444
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
21446
switch (opline->extended_value) {
21448
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
21451
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
21455
ZEND_VM_NEXT_OPCODE();
21458
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21460
return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21463
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21465
return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21468
static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21470
zend_op *opline = EX(opline);
21473
bitwise_not_function(&EX_T(opline->result.u.var).tmp_var,
21474
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
21476
ZEND_VM_NEXT_OPCODE();
21479
static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21481
zend_op *opline = EX(opline);
21484
boolean_not_function(&EX_T(opline->result.u.var).tmp_var,
21485
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
21487
ZEND_VM_NEXT_OPCODE();
21490
static int ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21492
zend_op *opline = EX(opline);
21494
zval **var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
21496
if (IS_CV == IS_VAR && !var_ptr) {
21497
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
21499
if (IS_CV == IS_VAR && *var_ptr == EG(error_zval_ptr)) {
21500
if (!RETURN_VALUE_UNUSED(&opline->result)) {
21501
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
21502
PZVAL_LOCK(EG(uninitialized_zval_ptr));
21505
ZEND_VM_NEXT_OPCODE();
21508
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
21510
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
21511
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
21513
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
21515
increment_function(val);
21516
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
21517
zval_ptr_dtor(&val);
21519
increment_function(*var_ptr);
21522
if (!RETURN_VALUE_UNUSED(&opline->result)) {
21523
AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
21524
PZVAL_LOCK(*var_ptr);
21527
ZEND_VM_NEXT_OPCODE();
21530
static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21532
zend_op *opline = EX(opline);
21534
zval **var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
21536
if (IS_CV == IS_VAR && !var_ptr) {
21537
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
21539
if (IS_CV == IS_VAR && *var_ptr == EG(error_zval_ptr)) {
21540
if (!RETURN_VALUE_UNUSED(&opline->result)) {
21541
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
21542
PZVAL_LOCK(EG(uninitialized_zval_ptr));
21545
ZEND_VM_NEXT_OPCODE();
21548
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
21550
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
21551
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
21553
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
21555
decrement_function(val);
21556
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
21557
zval_ptr_dtor(&val);
21559
decrement_function(*var_ptr);
21562
if (!RETURN_VALUE_UNUSED(&opline->result)) {
21563
AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
21564
PZVAL_LOCK(*var_ptr);
21567
ZEND_VM_NEXT_OPCODE();
21570
static int ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21572
zend_op *opline = EX(opline);
21574
zval **var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
21576
if (IS_CV == IS_VAR && !var_ptr) {
21577
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
21579
if (IS_CV == IS_VAR && *var_ptr == EG(error_zval_ptr)) {
21580
if (!RETURN_VALUE_UNUSED(&opline->result)) {
21581
EX_T(opline->result.u.var).tmp_var = *EG(uninitialized_zval_ptr);
21584
ZEND_VM_NEXT_OPCODE();
21587
EX_T(opline->result.u.var).tmp_var = **var_ptr;
21588
zendi_zval_copy_ctor(EX_T(opline->result.u.var).tmp_var);
21590
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
21592
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
21593
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
21595
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
21597
increment_function(val);
21598
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
21599
zval_ptr_dtor(&val);
21601
increment_function(*var_ptr);
21604
ZEND_VM_NEXT_OPCODE();
21607
static int ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21609
zend_op *opline = EX(opline);
21611
zval **var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
21613
if (IS_CV == IS_VAR && !var_ptr) {
21614
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
21616
if (IS_CV == IS_VAR && *var_ptr == EG(error_zval_ptr)) {
21617
if (!RETURN_VALUE_UNUSED(&opline->result)) {
21618
EX_T(opline->result.u.var).tmp_var = *EG(uninitialized_zval_ptr);
21621
ZEND_VM_NEXT_OPCODE();
21624
EX_T(opline->result.u.var).tmp_var = **var_ptr;
21625
zendi_zval_copy_ctor(EX_T(opline->result.u.var).tmp_var);
21627
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
21629
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
21630
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
21632
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
21634
decrement_function(val);
21635
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
21636
zval_ptr_dtor(&val);
21638
decrement_function(*var_ptr);
21641
ZEND_VM_NEXT_OPCODE();
21644
static int ZEND_FASTCALL ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21646
zend_op *opline = EX(opline);
21649
zval *z = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
21651
if (IS_CV != IS_CONST &&
21652
Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get_method != NULL &&
21653
zend_std_cast_object_tostring(z, &z_copy, IS_STRING TSRMLS_CC) == SUCCESS) {
21654
zend_print_variable(&z_copy);
21655
zval_dtor(&z_copy);
21657
zend_print_variable(z);
21660
ZEND_VM_NEXT_OPCODE();
21663
static int ZEND_FASTCALL ZEND_PRINT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21665
zend_op *opline = EX(opline);
21667
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
21668
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_LONG;
21670
return ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21673
static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV(int type, ZEND_OPCODE_HANDLER_ARGS)
21675
zend_op *opline = EX(opline);
21676
zend_free_op free_op1;
21677
zval *varname = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
21680
HashTable *target_symbol_table;
21682
if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
21683
tmp_varname = *varname;
21684
zval_copy_ctor(&tmp_varname);
21685
convert_to_string(&tmp_varname);
21686
varname = &tmp_varname;
21689
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
21690
retval = zend_std_get_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0 TSRMLS_CC);
21692
target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), type, varname TSRMLS_CC);
21694
if (!target_symbol_table) {
21695
ZEND_VM_NEXT_OPCODE();
21698
if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &retval) == FAILURE) {
21702
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
21703
/* break missing intentionally */
21705
retval = &EG(uninitialized_zval_ptr);
21708
zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
21709
/* break missing intentionally */
21711
zval *new_zval = &EG(uninitialized_zval);
21713
Z_ADDREF_P(new_zval);
21714
zend_hash_update(target_symbol_table, varname->value.str.val, varname->value.str.len+1, &new_zval, sizeof(zval *), (void **) &retval);
21717
EMPTY_SWITCH_DEFAULT_CASE()
21720
switch (opline->op2.u.EA.type) {
21721
case ZEND_FETCH_GLOBAL:
21722
if (IS_CV != IS_TMP_VAR) {
21726
case ZEND_FETCH_LOCAL:
21729
case ZEND_FETCH_STATIC:
21730
zval_update_constant(retval, (void*) 1 TSRMLS_CC);
21732
case ZEND_FETCH_GLOBAL_LOCK:
21733
if (IS_CV == IS_VAR && !free_op1.var) {
21734
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
21741
if (IS_CV != IS_CONST && varname == &tmp_varname) {
21742
zval_dtor(varname);
21744
if (!RETURN_VALUE_UNUSED(&opline->result)) {
21745
if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
21746
SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
21748
PZVAL_LOCK(*retval);
21752
AI_SET_PTR(EX_T(opline->result.u.var).var, *retval);
21754
case BP_VAR_UNSET: {
21755
zend_free_op free_res;
21757
EX_T(opline->result.u.var).var.ptr_ptr = retval;
21758
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
21759
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
21760
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
21762
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
21763
FREE_OP_VAR_PTR(free_res);
21766
EX_T(opline->result.u.var).var.ptr_ptr = retval;
21771
ZEND_VM_NEXT_OPCODE();
21774
static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21776
return zend_fetch_var_address_helper_SPEC_CV(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21779
static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21781
return zend_fetch_var_address_helper_SPEC_CV(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21784
static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21786
return zend_fetch_var_address_helper_SPEC_CV(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21789
static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21791
return zend_fetch_var_address_helper_SPEC_CV(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), EX(opline)->extended_value)?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21794
static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21796
return zend_fetch_var_address_helper_SPEC_CV(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21799
static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21801
return zend_fetch_var_address_helper_SPEC_CV(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21804
static int ZEND_FASTCALL ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21806
zend_op *opline = EX(opline);
21808
zval *val = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
21811
if (IS_CV == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
21812
ret = Z_LVAL_P(val);
21814
ret = i_zend_is_true(val);
21816
if (UNEXPECTED(EG(exception) != NULL)) {
21817
ZEND_VM_CONTINUE();
21822
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
21824
ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
21825
ZEND_VM_CONTINUE();
21828
ZEND_VM_NEXT_OPCODE();
21831
static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21833
zend_op *opline = EX(opline);
21835
zval *val = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
21838
if (IS_CV == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
21839
ret = Z_LVAL_P(val);
21841
ret = i_zend_is_true(val);
21843
if (UNEXPECTED(EG(exception) != NULL)) {
21844
ZEND_VM_CONTINUE();
21849
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
21851
ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
21852
ZEND_VM_CONTINUE();
21855
ZEND_VM_NEXT_OPCODE();
21858
static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21860
zend_op *opline = EX(opline);
21862
zval *val = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
21865
if (IS_CV == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
21866
retval = Z_LVAL_P(val);
21868
retval = i_zend_is_true(val);
21870
if (UNEXPECTED(EG(exception) != NULL)) {
21871
ZEND_VM_CONTINUE();
21874
if (EXPECTED(retval != 0)) {
21876
printf("Conditional jmp on true to %d\n", opline->extended_value);
21878
ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
21879
ZEND_VM_CONTINUE(); /* CHECK_ME */
21882
printf("Conditional jmp on false to %d\n", opline->op2.u.opline_num);
21884
ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.u.opline_num]);
21885
ZEND_VM_CONTINUE(); /* CHECK_ME */
21889
static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21891
zend_op *opline = EX(opline);
21893
zval *val = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
21896
if (IS_CV == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
21897
retval = Z_LVAL_P(val);
21899
retval = i_zend_is_true(val);
21901
if (UNEXPECTED(EG(exception) != NULL)) {
21902
ZEND_VM_CONTINUE();
21905
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
21906
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
21909
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
21911
ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
21912
ZEND_VM_CONTINUE();
21914
ZEND_VM_NEXT_OPCODE();
21917
static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21919
zend_op *opline = EX(opline);
21921
zval *val = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
21924
if (IS_CV == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
21925
retval = Z_LVAL_P(val);
21927
retval = i_zend_is_true(val);
21929
if (UNEXPECTED(EG(exception) != NULL)) {
21930
ZEND_VM_CONTINUE();
21933
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
21934
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
21937
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
21939
ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
21940
ZEND_VM_CONTINUE();
21942
ZEND_VM_NEXT_OPCODE();
21945
static int ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21947
zend_op *opline = EX(opline);
21949
zval **retval_ptr_ptr;
21952
if (EG(active_op_array)->return_reference == ZEND_RETURN_REF) {
21954
if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
21955
/* Not supposed to happen, but we'll allow it */
21956
zend_error(E_NOTICE, "Only variable references should be returned by reference");
21957
goto return_by_value;
21960
retval_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
21962
if (IS_CV == IS_VAR && !retval_ptr_ptr) {
21963
zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
21966
if (IS_CV == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
21967
if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
21968
EX_T(opline->op1.u.var).var.fcall_returned_reference) {
21969
} else if (EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
21970
if (IS_CV == IS_VAR && !0) {
21971
PZVAL_LOCK(*retval_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
21973
zend_error(E_NOTICE, "Only variable references should be returned by reference");
21974
goto return_by_value;
21978
if (EG(return_value_ptr_ptr)) {
21979
SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
21980
Z_ADDREF_PP(retval_ptr_ptr);
21982
(*EG(return_value_ptr_ptr)) = (*retval_ptr_ptr);
21987
retval_ptr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
21989
if (!EG(return_value_ptr_ptr)) {
21990
if (IS_CV == IS_TMP_VAR) {
21993
} else if (!0) { /* Not a temp var */
21994
if (IS_CV == IS_CONST ||
21995
EG(active_op_array)->return_reference == ZEND_RETURN_REF ||
21996
(PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
22000
INIT_PZVAL_COPY(ret, retval_ptr);
22001
zval_copy_ctor(ret);
22002
*EG(return_value_ptr_ptr) = ret;
22004
*EG(return_value_ptr_ptr) = retval_ptr;
22005
Z_ADDREF_P(retval_ptr);
22011
INIT_PZVAL_COPY(ret, retval_ptr);
22012
*EG(return_value_ptr_ptr) = ret;
22016
return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22019
static int ZEND_FASTCALL ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22021
zend_op *opline = EX(opline);
22026
value = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
22028
if (IS_CV == IS_CONST || Z_TYPE_P(value) != IS_OBJECT) {
22029
zend_error_noreturn(E_ERROR, "Can only throw objects");
22031
zend_exception_save(TSRMLS_C);
22032
/* Not sure if a complete copy is what we want here */
22033
ALLOC_ZVAL(exception);
22034
INIT_PZVAL_COPY(exception, value);
22036
zval_copy_ctor(exception);
22039
zend_throw_exception_object(exception TSRMLS_CC);
22040
zend_exception_restore(TSRMLS_C);
22042
ZEND_VM_NEXT_OPCODE();
22045
static int ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22047
zend_op *opline = EX(opline);
22048
if (opline->extended_value==ZEND_DO_FCALL_BY_NAME
22049
&& ARG_MUST_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
22050
zend_error_noreturn(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.u.opline_num);
22057
value = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
22059
ALLOC_ZVAL(valptr);
22060
INIT_PZVAL_COPY(valptr, value);
22062
zval_copy_ctor(valptr);
22064
zend_vm_stack_push(valptr TSRMLS_CC);
22067
ZEND_VM_NEXT_OPCODE();
22070
static int ZEND_FASTCALL zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
22072
zend_op *opline = EX(opline);
22075
varptr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
22077
if (varptr == &EG(uninitialized_zval)) {
22078
ALLOC_ZVAL(varptr);
22079
INIT_ZVAL(*varptr);
22080
Z_SET_REFCOUNT_P(varptr, 0);
22081
} else if (PZVAL_IS_REF(varptr)) {
22082
zval *original_var = varptr;
22084
ALLOC_ZVAL(varptr);
22085
*varptr = *original_var;
22086
Z_UNSET_ISREF_P(varptr);
22087
Z_SET_REFCOUNT_P(varptr, 0);
22088
zval_copy_ctor(varptr);
22090
Z_ADDREF_P(varptr);
22091
zend_vm_stack_push(varptr TSRMLS_CC);
22092
; /* for string offsets */
22094
ZEND_VM_NEXT_OPCODE();
22097
static int ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22099
zend_op *opline = EX(opline);
22100
zend_free_op free_op1;
22103
if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */
22104
if (!(opline->extended_value & ZEND_ARG_SEND_BY_REF)) {
22105
return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22107
} else if (!ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
22108
return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22111
if (IS_CV == IS_VAR &&
22112
(opline->extended_value & ZEND_ARG_SEND_FUNCTION) &&
22113
EX_T(opline->op1.u.var).var.fcall_returned_reference &&
22114
EX_T(opline->op1.u.var).var.ptr) {
22115
varptr = EX_T(opline->op1.u.var).var.ptr;
22116
PZVAL_UNLOCK_EX(varptr, &free_op1, 0);
22118
varptr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
22120
if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
22121
EX_T(opline->op1.u.var).var.fcall_returned_reference) &&
22122
varptr != &EG(uninitialized_zval) &&
22123
(PZVAL_IS_REF(varptr) ||
22124
(Z_REFCOUNT_P(varptr) == 1 && (IS_CV == IS_CV || free_op1.var)))) {
22125
Z_SET_ISREF_P(varptr);
22126
Z_ADDREF_P(varptr);
22127
zend_vm_stack_push(varptr TSRMLS_CC);
22131
if (!(opline->extended_value & ZEND_ARG_SEND_SILENT)) {
22132
zend_error(E_STRICT, "Only variables should be passed by reference");
22134
ALLOC_ZVAL(valptr);
22135
INIT_PZVAL_COPY(valptr, varptr);
22137
zval_copy_ctor(valptr);
22139
zend_vm_stack_push(valptr TSRMLS_CC);
22142
ZEND_VM_NEXT_OPCODE();
22145
static int ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22147
zend_op *opline = EX(opline);
22151
varptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
22153
if (IS_CV == IS_VAR && !varptr_ptr) {
22154
zend_error_noreturn(E_ERROR, "Only variables can be passed by reference");
22157
SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr);
22158
varptr = *varptr_ptr;
22159
Z_ADDREF_P(varptr);
22160
zend_vm_stack_push(varptr TSRMLS_CC);
22162
ZEND_VM_NEXT_OPCODE();
22165
static int ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22167
zend_op *opline = EX(opline);
22169
if ((opline->extended_value == ZEND_DO_FCALL_BY_NAME)
22170
&& ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
22171
return ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22173
return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22176
static int ZEND_FASTCALL ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22178
zend_op *opline = EX(opline);
22181
/* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
22182
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = i_zend_is_true(_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC));
22183
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
22185
ZEND_VM_NEXT_OPCODE();
22188
static int ZEND_FASTCALL ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22190
zend_op *opline = EX(opline);
22192
zval *obj = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
22193
zend_class_entry *ce;
22194
zend_function *clone;
22195
zend_object_clone_obj_t clone_call;
22197
if (IS_CV == IS_CONST ||
22198
(IS_CV == IS_VAR && !obj) ||
22199
Z_TYPE_P(obj) != IS_OBJECT) {
22200
zend_error_noreturn(E_ERROR, "__clone method called on non-object");
22203
ce = Z_OBJCE_P(obj);
22204
clone = ce ? ce->clone : NULL;
22205
clone_call = Z_OBJ_HT_P(obj)->clone_obj;
22208
zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
22210
zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
22215
if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
22216
/* Ensure that if we're calling a private function, we're allowed to do so.
22218
if (ce != EG(scope)) {
22219
zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
22221
} else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
22222
/* Ensure that if we're calling a protected function, we're allowed to do so.
22224
if (!zend_check_protected(clone->common.scope, EG(scope))) {
22225
zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
22230
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
22231
if (!EG(exception)) {
22232
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
22233
Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC);
22234
Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
22235
Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
22236
Z_SET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
22237
if (!RETURN_VALUE_USED(opline) || EG(exception)) {
22238
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
22242
ZEND_VM_NEXT_OPCODE();
22245
static int ZEND_FASTCALL ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22247
zend_op *opline = EX(opline);
22249
zval *expr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
22250
zval *result = &EX_T(opline->result.u.var).tmp_var;
22252
if (opline->extended_value != IS_STRING) {
22255
zendi_zval_copy_ctor(*result);
22258
switch (opline->extended_value) {
22260
convert_to_null(result);
22263
convert_to_boolean(result);
22266
convert_to_long(result);
22269
convert_to_double(result);
22275
zend_make_printable_zval(expr, &var_copy, &use_copy);
22277
*result = var_copy;
22284
zendi_zval_copy_ctor(*result);
22290
convert_to_array(result);
22293
convert_to_object(result);
22297
ZEND_VM_NEXT_OPCODE();
22300
static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22302
zend_op *opline = EX(opline);
22303
zend_op_array *new_op_array=NULL;
22304
int return_value_used;
22306
zval *inc_filename = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
22307
zval tmp_inc_filename;
22308
zend_bool failure_retval=0;
22310
if (inc_filename->type!=IS_STRING) {
22311
tmp_inc_filename = *inc_filename;
22312
zval_copy_ctor(&tmp_inc_filename);
22313
convert_to_string(&tmp_inc_filename);
22314
inc_filename = &tmp_inc_filename;
22317
return_value_used = RETURN_VALUE_USED(opline);
22319
switch (Z_LVAL(opline->op2.u.constant)) {
22320
case ZEND_INCLUDE_ONCE:
22321
case ZEND_REQUIRE_ONCE: {
22322
zend_file_handle file_handle;
22323
char *resolved_path;
22325
resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
22326
if (resolved_path) {
22327
failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
22329
resolved_path = Z_STRVAL_P(inc_filename);
22332
if (failure_retval) {
22333
/* do nothing, file already included */
22334
} else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) {
22336
if (!file_handle.opened_path) {
22337
file_handle.opened_path = estrdup(resolved_path);
22340
if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
22341
new_op_array = zend_compile_file(&file_handle, (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
22342
zend_destroy_file_handle(&file_handle TSRMLS_CC);
22344
zend_file_handle_dtor(&file_handle TSRMLS_CC);
22348
if (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE) {
22349
zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
22351
zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
22354
if (resolved_path != Z_STRVAL_P(inc_filename)) {
22355
efree(resolved_path);
22361
new_op_array = compile_filename(Z_LVAL(opline->op2.u.constant), inc_filename TSRMLS_CC);
22364
char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
22366
new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
22370
EMPTY_SWITCH_DEFAULT_CASE()
22372
if (inc_filename==&tmp_inc_filename) {
22373
zval_dtor(&tmp_inc_filename);
22376
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
22377
if (new_op_array && !EG(exception)) {
22378
EX(original_return_value) = EG(return_value_ptr_ptr);
22379
EG(return_value_ptr_ptr) = return_value_used ? EX_T(opline->result.u.var).var.ptr_ptr : NULL;
22380
EG(active_op_array) = new_op_array;
22381
EX_T(opline->result.u.var).var.ptr = NULL;
22383
EX(current_object) = EX(object);
22385
EX(function_state).function = (zend_function *) new_op_array;
22388
if (!EG(active_symbol_table)) {
22389
zend_rebuild_symbol_table(TSRMLS_C);
22392
if (zend_execute == execute) {
22393
EX(call_opline) = opline;
22396
zend_execute(new_op_array TSRMLS_CC);
22399
EX(function_state).function = (zend_function *) EX(op_array);
22400
EX(object) = EX(current_object);
22402
if (return_value_used) {
22403
if (!EX_T(opline->result.u.var).var.ptr) { /* there was no return statement */
22404
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
22405
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
22406
Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = 1;
22407
Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
22411
EG(opline_ptr) = &EX(opline);
22412
EG(active_op_array) = EX(op_array);
22413
EG(return_value_ptr_ptr) = EX(original_return_value);
22414
destroy_op_array(new_op_array TSRMLS_CC);
22415
efree(new_op_array);
22416
if (EG(exception)) {
22417
zend_throw_exception_internal(NULL TSRMLS_CC);
22420
if (return_value_used) {
22421
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
22422
INIT_ZVAL(*EX_T(opline->result.u.var).var.ptr);
22423
Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = failure_retval;
22424
Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
22427
ZEND_VM_NEXT_OPCODE();
22430
static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22432
zend_op *opline = EX(opline);
22433
zval tmp, *varname;
22434
HashTable *target_symbol_table;
22437
if (IS_CV == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
22438
if (EG(active_symbol_table)) {
22439
zend_execute_data *ex = EX(prev_execute_data);
22440
zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.u.var);
22442
if (zend_hash_quick_del(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value) == SUCCESS) {
22443
while (ex && ex->symbol_table == EG(active_symbol_table)) {
22446
if (ex->op_array) {
22447
for (i = 0; i < ex->op_array->last_var; i++) {
22448
if (ex->op_array->vars[i].hash_value == cv->hash_value &&
22449
ex->op_array->vars[i].name_len == cv->name_len &&
22450
!memcmp(ex->op_array->vars[i].name, cv->name, cv->name_len)) {
22456
ex = ex->prev_execute_data;
22459
EX(CVs)[opline->op1.u.var] = NULL;
22460
} else if (EX(CVs)[opline->op1.u.var]) {
22461
zval_ptr_dtor(EX(CVs)[opline->op1.u.var]);
22462
EX(CVs)[opline->op1.u.var] = NULL;
22464
ZEND_VM_NEXT_OPCODE();
22467
varname = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
22469
if (Z_TYPE_P(varname) != IS_STRING) {
22471
zval_copy_ctor(&tmp);
22472
convert_to_string(&tmp);
22474
} else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
22475
Z_ADDREF_P(varname);
22478
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
22479
zend_std_unset_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname) TSRMLS_CC);
22481
ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
22483
target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
22484
if (zend_hash_quick_del(target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value) == SUCCESS) {
22485
zend_execute_data *ex = execute_data;
22490
if (ex->op_array) {
22491
for (i = 0; i < ex->op_array->last_var; i++) {
22492
if (ex->op_array->vars[i].hash_value == hash_value &&
22493
ex->op_array->vars[i].name_len == varname->value.str.len &&
22494
!memcmp(ex->op_array->vars[i].name, varname->value.str.val, varname->value.str.len)) {
22500
ex = ex->prev_execute_data;
22501
} while (ex && ex->symbol_table == target_symbol_table);
22505
if (varname == &tmp) {
22507
} else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
22508
zval_ptr_dtor(&varname);
22511
ZEND_VM_NEXT_OPCODE();
22514
static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22516
zend_op *opline = EX(opline);
22518
zval *array_ptr, **array_ptr_ptr;
22520
zend_object_iterator *iter = NULL;
22521
zend_class_entry *ce = NULL;
22522
zend_bool is_empty = 0;
22524
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
22525
array_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
22526
if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
22527
ALLOC_INIT_ZVAL(array_ptr);
22528
} else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
22529
if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
22530
zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class");
22531
ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
22534
ce = Z_OBJCE_PP(array_ptr_ptr);
22535
if (!ce || ce->get_iterator == NULL) {
22536
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
22537
Z_ADDREF_PP(array_ptr_ptr);
22539
array_ptr = *array_ptr_ptr;
22541
if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
22542
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
22543
if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
22544
Z_SET_ISREF_PP(array_ptr_ptr);
22547
array_ptr = *array_ptr_ptr;
22548
Z_ADDREF_P(array_ptr);
22551
array_ptr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
22552
if (0) { /* IS_TMP_VAR */
22556
INIT_PZVAL_COPY(tmp, array_ptr);
22558
} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
22559
ce = Z_OBJCE_P(array_ptr);
22560
if (!ce || !ce->get_iterator) {
22561
Z_ADDREF_P(array_ptr);
22564
if ((IS_CV == IS_CV || IS_CV == IS_VAR) &&
22565
!Z_ISREF_P(array_ptr) &&
22566
Z_REFCOUNT_P(array_ptr) > 1) {
22570
INIT_PZVAL_COPY(tmp, array_ptr);
22571
zval_copy_ctor(tmp);
22574
Z_ADDREF_P(array_ptr);
22579
if (IS_CV != IS_TMP_VAR && ce && ce->get_iterator) {
22580
iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC);
22582
if (iter && !EG(exception)) {
22583
array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
22585
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
22590
if (!EG(exception)) {
22591
zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
22593
zend_throw_exception_internal(NULL TSRMLS_CC);
22594
ZEND_VM_NEXT_OPCODE();
22598
AI_SET_PTR(EX_T(opline->result.u.var).var, array_ptr);
22599
PZVAL_LOCK(array_ptr);
22603
if (iter->funcs->rewind) {
22604
iter->funcs->rewind(iter TSRMLS_CC);
22605
if (EG(exception)) {
22606
Z_DELREF_P(array_ptr);
22607
zval_ptr_dtor(&array_ptr);
22608
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
22613
ZEND_VM_NEXT_OPCODE();
22616
is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
22617
if (EG(exception)) {
22618
Z_DELREF_P(array_ptr);
22619
zval_ptr_dtor(&array_ptr);
22620
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
22625
ZEND_VM_NEXT_OPCODE();
22627
iter->index = -1; /* will be set to 0 before using next handler */
22628
} else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
22629
zend_hash_internal_pointer_reset(fe_ht);
22631
zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
22632
while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
22636
zend_uchar key_type;
22638
key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
22639
if (key_type != HASH_KEY_NON_EXISTANT &&
22640
(key_type == HASH_KEY_IS_LONG ||
22641
zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
22644
zend_hash_move_forward(fe_ht);
22647
is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
22648
zend_hash_get_pointer(fe_ht, &EX_T(opline->result.u.var).fe.fe_pos);
22650
zend_error(E_WARNING, "Invalid argument supplied for foreach()");
22654
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
22660
ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
22662
ZEND_VM_NEXT_OPCODE();
22666
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22668
zend_op *opline = EX(opline);
22670
zend_bool isset = 1;
22672
if (IS_CV == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
22673
if (EX(CVs)[opline->op1.u.var]) {
22674
value = EX(CVs)[opline->op1.u.var];
22675
} else if (EG(active_symbol_table)) {
22676
zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.u.var);
22678
if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
22685
HashTable *target_symbol_table;
22687
zval tmp, *varname = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
22689
if (Z_TYPE_P(varname) != IS_STRING) {
22691
zval_copy_ctor(&tmp);
22692
convert_to_string(&tmp);
22696
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
22697
value = zend_std_get_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1 TSRMLS_CC);
22702
target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
22703
if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
22708
if (varname == &tmp) {
22714
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
22716
switch (opline->extended_value & ZEND_ISSET_ISEMPTY_MASK) {
22718
if (isset && Z_TYPE_PP(value) == IS_NULL) {
22719
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
22721
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = isset;
22725
if (!isset || !i_zend_is_true(*value)) {
22726
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
22728
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
22733
ZEND_VM_NEXT_OPCODE();
22736
static int ZEND_FASTCALL ZEND_EXIT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22738
#if 0 || (IS_CV != IS_UNUSED)
22739
zend_op *opline = EX(opline);
22740
if (IS_CV != IS_UNUSED) {
22742
zval *ptr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
22744
if (Z_TYPE_P(ptr) == IS_LONG) {
22745
EG(exit_status) = Z_LVAL_P(ptr);
22747
zend_print_variable(ptr);
22753
ZEND_VM_NEXT_OPCODE();
22756
static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22758
zend_op *opline = EX(opline);
22760
zval *value = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
22762
if (i_zend_is_true(value)) {
22763
EX_T(opline->result.u.var).tmp_var = *value;
22764
zendi_zval_copy_ctor(EX_T(opline->result.u.var).tmp_var);
22767
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
22769
ZEND_VM_JMP(opline->op2.u.jmp_addr);
22772
ZEND_VM_NEXT_OPCODE();
22775
static int ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22777
zend_op *opline = EX(opline);
22779
zval *value = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
22781
EX_T(opline->result.u.var).tmp_var = *value;
22783
zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
22786
ZEND_VM_NEXT_OPCODE();
22789
static int ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22791
zend_op *opline = EX(opline);
22793
zval *expr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
22796
if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) {
22797
result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.u.var).class_entry TSRMLS_CC);
22801
ZVAL_BOOL(&EX_T(opline->result.u.var).tmp_var, result);
22803
ZEND_VM_NEXT_OPCODE();
22806
static int ZEND_FASTCALL ZEND_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22808
zend_op *opline = EX(opline);
22811
add_function(&EX_T(opline->result.u.var).tmp_var,
22812
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
22813
&opline->op2.u.constant TSRMLS_CC);
22816
ZEND_VM_NEXT_OPCODE();
22819
static int ZEND_FASTCALL ZEND_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22821
zend_op *opline = EX(opline);
22824
sub_function(&EX_T(opline->result.u.var).tmp_var,
22825
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
22826
&opline->op2.u.constant TSRMLS_CC);
22829
ZEND_VM_NEXT_OPCODE();
22832
static int ZEND_FASTCALL ZEND_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22834
zend_op *opline = EX(opline);
22837
mul_function(&EX_T(opline->result.u.var).tmp_var,
22838
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
22839
&opline->op2.u.constant TSRMLS_CC);
22842
ZEND_VM_NEXT_OPCODE();
22845
static int ZEND_FASTCALL ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22847
zend_op *opline = EX(opline);
22850
div_function(&EX_T(opline->result.u.var).tmp_var,
22851
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
22852
&opline->op2.u.constant TSRMLS_CC);
22855
ZEND_VM_NEXT_OPCODE();
22858
static int ZEND_FASTCALL ZEND_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22860
zend_op *opline = EX(opline);
22863
mod_function(&EX_T(opline->result.u.var).tmp_var,
22864
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
22865
&opline->op2.u.constant TSRMLS_CC);
22868
ZEND_VM_NEXT_OPCODE();
22871
static int ZEND_FASTCALL ZEND_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22873
zend_op *opline = EX(opline);
22876
shift_left_function(&EX_T(opline->result.u.var).tmp_var,
22877
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
22878
&opline->op2.u.constant TSRMLS_CC);
22881
ZEND_VM_NEXT_OPCODE();
22884
static int ZEND_FASTCALL ZEND_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22886
zend_op *opline = EX(opline);
22889
shift_right_function(&EX_T(opline->result.u.var).tmp_var,
22890
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
22891
&opline->op2.u.constant TSRMLS_CC);
22894
ZEND_VM_NEXT_OPCODE();
22897
static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22899
zend_op *opline = EX(opline);
22902
concat_function(&EX_T(opline->result.u.var).tmp_var,
22903
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
22904
&opline->op2.u.constant TSRMLS_CC);
22907
ZEND_VM_NEXT_OPCODE();
22910
static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22912
zend_op *opline = EX(opline);
22915
is_identical_function(&EX_T(opline->result.u.var).tmp_var,
22916
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
22917
&opline->op2.u.constant TSRMLS_CC);
22920
ZEND_VM_NEXT_OPCODE();
22923
static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22925
zend_op *opline = EX(opline);
22927
zval *result = &EX_T(opline->result.u.var).tmp_var;
22929
is_identical_function(result,
22930
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
22931
&opline->op2.u.constant TSRMLS_CC);
22932
Z_LVAL_P(result) = !Z_LVAL_P(result);
22935
ZEND_VM_NEXT_OPCODE();
22938
static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22940
zend_op *opline = EX(opline);
22942
zval *result = &EX_T(opline->result.u.var).tmp_var;
22944
compare_function(result,
22945
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
22946
&opline->op2.u.constant TSRMLS_CC);
22947
ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
22950
ZEND_VM_NEXT_OPCODE();
22953
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22955
zend_op *opline = EX(opline);
22957
zval *result = &EX_T(opline->result.u.var).tmp_var;
22959
compare_function(result,
22960
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
22961
&opline->op2.u.constant TSRMLS_CC);
22962
ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
22965
ZEND_VM_NEXT_OPCODE();
22968
static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22970
zend_op *opline = EX(opline);
22972
zval *result = &EX_T(opline->result.u.var).tmp_var;
22974
compare_function(result,
22975
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
22976
&opline->op2.u.constant TSRMLS_CC);
22977
ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
22980
ZEND_VM_NEXT_OPCODE();
22983
static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22985
zend_op *opline = EX(opline);
22987
zval *result = &EX_T(opline->result.u.var).tmp_var;
22989
compare_function(result,
22990
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
22991
&opline->op2.u.constant TSRMLS_CC);
22992
ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
22995
ZEND_VM_NEXT_OPCODE();
22998
static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23000
zend_op *opline = EX(opline);
23003
bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
23004
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23005
&opline->op2.u.constant TSRMLS_CC);
23008
ZEND_VM_NEXT_OPCODE();
23011
static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23013
zend_op *opline = EX(opline);
23016
bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
23017
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23018
&opline->op2.u.constant TSRMLS_CC);
23021
ZEND_VM_NEXT_OPCODE();
23024
static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23026
zend_op *opline = EX(opline);
23029
bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
23030
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23031
&opline->op2.u.constant TSRMLS_CC);
23034
ZEND_VM_NEXT_OPCODE();
23037
static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23039
zend_op *opline = EX(opline);
23042
boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
23043
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23044
&opline->op2.u.constant TSRMLS_CC);
23047
ZEND_VM_NEXT_OPCODE();
23050
static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
23052
zend_op *opline = EX(opline);
23053
zend_op *op_data = opline+1;
23054
zend_free_op free_op_data1;
23055
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
23057
zval *property = &opline->op2.u.constant;
23058
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
23059
znode *result = &opline->result;
23060
int have_get_ptr = 0;
23062
if (IS_CV == IS_VAR && !object_ptr) {
23063
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
23066
EX_T(result->u.var).var.ptr_ptr = NULL;
23067
make_real_object(object_ptr TSRMLS_CC);
23068
object = *object_ptr;
23070
if (Z_TYPE_P(object) != IS_OBJECT) {
23071
zend_error(E_WARNING, "Attempt to assign property of non-object");
23073
FREE_OP(free_op_data1);
23075
if (!RETURN_VALUE_UNUSED(result)) {
23076
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
23077
EX_T(result->u.var).var.ptr_ptr = NULL;
23078
PZVAL_LOCK(EG(uninitialized_zval_ptr));
23081
/* here we are sure we are dealing with an object */
23083
MAKE_REAL_ZVAL_PTR(property);
23086
/* here property is a string */
23087
if (opline->extended_value == ZEND_ASSIGN_OBJ
23088
&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
23089
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
23090
if (zptr != NULL) { /* NULL means no success in getting PTR */
23091
SEPARATE_ZVAL_IF_NOT_REF(zptr);
23094
binary_op(*zptr, *zptr, value TSRMLS_CC);
23095
if (!RETURN_VALUE_UNUSED(result)) {
23096
EX_T(result->u.var).var.ptr = *zptr;
23097
EX_T(result->u.var).var.ptr_ptr = NULL;
23103
if (!have_get_ptr) {
23106
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
23107
if (Z_OBJ_HT_P(object)->read_property) {
23108
z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
23110
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
23111
if (Z_OBJ_HT_P(object)->read_dimension) {
23112
z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
23116
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
23117
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
23119
if (Z_REFCOUNT_P(z) == 0) {
23120
GC_REMOVE_ZVAL_FROM_BUFFER(z);
23127
SEPARATE_ZVAL_IF_NOT_REF(&z);
23128
binary_op(z, z, value TSRMLS_CC);
23129
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
23130
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
23131
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
23132
Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
23134
if (!RETURN_VALUE_UNUSED(result)) {
23135
EX_T(result->u.var).var.ptr = z;
23136
EX_T(result->u.var).var.ptr_ptr = NULL;
23141
zend_error(E_WARNING, "Attempt to assign property of non-object");
23142
if (!RETURN_VALUE_UNUSED(result)) {
23143
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
23144
EX_T(result->u.var).var.ptr_ptr = NULL;
23145
PZVAL_LOCK(EG(uninitialized_zval_ptr));
23151
zval_ptr_dtor(&property);
23155
FREE_OP(free_op_data1);
23158
/* assign_obj has two opcodes! */
23159
ZEND_VM_INC_OPCODE();
23160
ZEND_VM_NEXT_OPCODE();
23163
static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
23165
zend_op *opline = EX(opline);
23166
zend_free_op free_op_data2, free_op_data1;
23170
switch (opline->extended_value) {
23171
case ZEND_ASSIGN_OBJ:
23172
return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23174
case ZEND_ASSIGN_DIM: {
23175
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
23177
if (IS_CV == IS_VAR && !container) {
23178
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23179
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
23180
if (IS_CV == IS_VAR && !0) {
23181
Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
23183
return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23185
zend_op *op_data = opline+1;
23186
zval *dim = &opline->op2.u.constant;
23188
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), container, dim, 0, BP_VAR_RW TSRMLS_CC);
23189
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
23190
var_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
23191
ZEND_VM_INC_OPCODE();
23196
value = &opline->op2.u.constant;
23197
var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
23203
zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
23206
if (*var_ptr == EG(error_zval_ptr)) {
23207
if (!RETURN_VALUE_UNUSED(&opline->result)) {
23208
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
23209
PZVAL_LOCK(EG(uninitialized_zval_ptr));
23213
ZEND_VM_NEXT_OPCODE();
23216
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
23218
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
23219
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
23221
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
23222
Z_ADDREF_P(objval);
23223
binary_op(objval, objval, value TSRMLS_CC);
23224
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
23225
zval_ptr_dtor(&objval);
23227
binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
23230
if (!RETURN_VALUE_UNUSED(&opline->result)) {
23231
AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
23232
PZVAL_LOCK(*var_ptr);
23235
if (opline->extended_value == ZEND_ASSIGN_DIM) {
23236
FREE_OP(free_op_data1);
23237
FREE_OP_VAR_PTR(free_op_data2);
23240
ZEND_VM_NEXT_OPCODE();
23243
static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23245
return zend_binary_assign_op_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23248
static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23250
return zend_binary_assign_op_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23253
static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23255
return zend_binary_assign_op_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23258
static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23260
return zend_binary_assign_op_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23263
static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23265
return zend_binary_assign_op_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23268
static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23270
return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23273
static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23275
return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23278
static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23280
return zend_binary_assign_op_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23283
static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23285
return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23288
static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23290
return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23293
static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23295
return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23298
static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
23300
zend_op *opline = EX(opline);
23302
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
23304
zval *property = &opline->op2.u.constant;
23305
zval **retval = &EX_T(opline->result.u.var).var.ptr;
23306
int have_get_ptr = 0;
23308
if (IS_CV == IS_VAR && !object_ptr) {
23309
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
23312
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
23313
object = *object_ptr;
23315
if (Z_TYPE_P(object) != IS_OBJECT) {
23316
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
23318
if (!RETURN_VALUE_UNUSED(&opline->result)) {
23319
*retval = EG(uninitialized_zval_ptr);
23320
PZVAL_LOCK(*retval);
23323
ZEND_VM_NEXT_OPCODE();
23326
/* here we are sure we are dealing with an object */
23329
MAKE_REAL_ZVAL_PTR(property);
23332
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
23333
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
23334
if (zptr != NULL) { /* NULL means no success in getting PTR */
23335
SEPARATE_ZVAL_IF_NOT_REF(zptr);
23339
if (!RETURN_VALUE_UNUSED(&opline->result)) {
23341
PZVAL_LOCK(*retval);
23346
if (!have_get_ptr) {
23347
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
23348
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
23350
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
23351
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
23353
if (Z_REFCOUNT_P(z) == 0) {
23354
GC_REMOVE_ZVAL_FROM_BUFFER(z);
23361
SEPARATE_ZVAL_IF_NOT_REF(&z);
23364
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
23365
SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
23368
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
23369
if (!RETURN_VALUE_UNUSED(&opline->result)) {
23370
*retval = EG(uninitialized_zval_ptr);
23371
PZVAL_LOCK(*retval);
23377
zval_ptr_dtor(&property);
23382
ZEND_VM_NEXT_OPCODE();
23385
static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23387
return zend_pre_incdec_property_helper_SPEC_CV_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23390
static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23392
return zend_pre_incdec_property_helper_SPEC_CV_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23395
static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
23397
zend_op *opline = EX(opline);
23399
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
23401
zval *property = &opline->op2.u.constant;
23402
zval *retval = &EX_T(opline->result.u.var).tmp_var;
23403
int have_get_ptr = 0;
23405
if (IS_CV == IS_VAR && !object_ptr) {
23406
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
23409
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
23410
object = *object_ptr;
23412
if (Z_TYPE_P(object) != IS_OBJECT) {
23413
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
23415
*retval = *EG(uninitialized_zval_ptr);
23417
ZEND_VM_NEXT_OPCODE();
23420
/* here we are sure we are dealing with an object */
23423
MAKE_REAL_ZVAL_PTR(property);
23426
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
23427
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
23428
if (zptr != NULL) { /* NULL means no success in getting PTR */
23430
SEPARATE_ZVAL_IF_NOT_REF(zptr);
23433
zendi_zval_copy_ctor(*retval);
23440
if (!have_get_ptr) {
23441
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
23442
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
23445
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
23446
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
23448
if (Z_REFCOUNT_P(z) == 0) {
23449
GC_REMOVE_ZVAL_FROM_BUFFER(z);
23456
zendi_zval_copy_ctor(*retval);
23457
ALLOC_ZVAL(z_copy);
23459
zendi_zval_copy_ctor(*z_copy);
23460
INIT_PZVAL(z_copy);
23463
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
23464
zval_ptr_dtor(&z_copy);
23467
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
23468
*retval = *EG(uninitialized_zval_ptr);
23473
zval_ptr_dtor(&property);
23478
ZEND_VM_NEXT_OPCODE();
23481
static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23483
return zend_post_incdec_property_helper_SPEC_CV_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23486
static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23488
return zend_post_incdec_property_helper_SPEC_CV_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23491
static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23493
zend_op *opline = EX(opline);
23495
zval *dim = &opline->op2.u.constant;
23498
if (opline->extended_value == ZEND_FETCH_ADD_LOCK &&
23500
EX_T(opline->op1.u.var).var.ptr_ptr) {
23501
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
23503
container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
23504
if (IS_CV == IS_VAR && !container) {
23505
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23507
zend_fetch_dimension_address_read(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_R TSRMLS_CC);
23510
ZEND_VM_NEXT_OPCODE();
23513
static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23515
zend_op *opline = EX(opline);
23516
zend_free_op free_op1;
23517
zval *dim = &opline->op2.u.constant;
23518
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
23520
if (IS_CV == IS_VAR && !container) {
23521
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23523
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_W TSRMLS_CC);
23525
if (IS_CV == IS_VAR && 0 &&
23526
READY_TO_DESTROY(free_op1.var)) {
23527
AI_USE_PTR(EX_T(opline->result.u.var).var);
23528
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
23529
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
23530
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
23534
/* We are going to assign the result by reference */
23535
if (opline->extended_value) {
23536
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
23537
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
23538
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
23541
ZEND_VM_NEXT_OPCODE();
23544
static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23546
zend_op *opline = EX(opline);
23547
zend_free_op free_op1;
23548
zval *dim = &opline->op2.u.constant;
23549
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
23551
if (IS_CV == IS_VAR && !container) {
23552
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23554
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_RW TSRMLS_CC);
23556
if (IS_CV == IS_VAR && 0 &&
23557
READY_TO_DESTROY(free_op1.var)) {
23558
AI_USE_PTR(EX_T(opline->result.u.var).var);
23559
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
23560
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
23561
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
23565
ZEND_VM_NEXT_OPCODE();
23568
static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23570
zend_op *opline = EX(opline);
23572
zval *dim = &opline->op2.u.constant;
23573
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
23575
if (IS_CV == IS_VAR && !container) {
23576
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23578
zend_fetch_dimension_address_read(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_IS TSRMLS_CC);
23581
ZEND_VM_NEXT_OPCODE();
23584
static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23586
zend_op *opline = EX(opline);
23587
zend_free_op free_op1;
23588
zval *dim = &opline->op2.u.constant;
23591
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
23592
container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
23593
if (IS_CV == IS_VAR && !container) {
23594
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23596
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_W TSRMLS_CC);
23597
if (IS_CV == IS_VAR && 0 &&
23598
READY_TO_DESTROY(free_op1.var)) {
23599
AI_USE_PTR(EX_T(opline->result.u.var).var);
23600
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
23601
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
23602
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
23606
if (IS_CONST == IS_UNUSED) {
23607
zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
23609
container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
23610
if (IS_CV == IS_VAR && !container) {
23611
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23613
zend_fetch_dimension_address_read(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_R TSRMLS_CC);
23617
ZEND_VM_NEXT_OPCODE();
23620
static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23622
zend_op *opline = EX(opline);
23623
zend_free_op free_op1;
23624
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
23625
zval *dim = &opline->op2.u.constant;
23627
/* Not needed in DIM_UNSET
23628
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
23629
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
23632
if (IS_CV == IS_CV) {
23633
if (container != &EG(uninitialized_zval_ptr)) {
23634
SEPARATE_ZVAL_IF_NOT_REF(container);
23637
if (IS_CV == IS_VAR && !container) {
23638
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23640
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_UNSET TSRMLS_CC);
23642
if (IS_CV == IS_VAR && 0 &&
23643
READY_TO_DESTROY(free_op1.var)) {
23644
AI_USE_PTR(EX_T(opline->result.u.var).var);
23645
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
23646
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
23647
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
23651
if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
23652
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
23654
zend_free_op free_res;
23656
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
23657
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
23658
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
23660
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
23661
FREE_OP_VAR_PTR(free_res);
23663
ZEND_VM_NEXT_OPCODE();
23666
static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
23668
zend_op *opline = EX(opline);
23670
zval *container = _get_zval_ptr_cv(&opline->op1, EX(Ts), type TSRMLS_CC);
23672
zval *offset = &opline->op2.u.constant;
23674
if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
23675
if (type != BP_VAR_IS) {
23676
zend_error(E_NOTICE, "Trying to get property of non-object");
23678
if (!RETURN_VALUE_UNUSED(&opline->result)) {
23679
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
23680
PZVAL_LOCK(EG(uninitialized_zval_ptr));
23687
MAKE_REAL_ZVAL_PTR(offset);
23690
/* here we are sure we are dealing with an object */
23691
retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
23693
if (RETURN_VALUE_UNUSED(&opline->result)) {
23694
if (Z_REFCOUNT_P(retval) == 0) {
23695
GC_REMOVE_ZVAL_FROM_BUFFER(retval);
23700
AI_SET_PTR(EX_T(opline->result.u.var).var, retval);
23701
PZVAL_LOCK(retval);
23705
zval_ptr_dtor(&offset);
23711
ZEND_VM_NEXT_OPCODE();
23714
static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23716
return zend_fetch_property_address_read_helper_SPEC_CV_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23719
static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23721
zend_op *opline = EX(opline);
23722
zend_free_op free_op1;
23723
zval *property = &opline->op2.u.constant;
23726
if (IS_CV == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
23727
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
23728
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
23732
MAKE_REAL_ZVAL_PTR(property);
23734
container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
23735
if (IS_CV == IS_VAR && !container) {
23736
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
23738
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
23740
zval_ptr_dtor(&property);
23744
if (IS_CV == IS_VAR && 0 &&
23745
READY_TO_DESTROY(free_op1.var)) {
23746
AI_USE_PTR(EX_T(opline->result.u.var).var);
23747
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
23748
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
23749
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
23753
/* We are going to assign the result by reference */
23754
if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
23755
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
23756
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
23757
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
23760
ZEND_VM_NEXT_OPCODE();
23763
static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23765
zend_op *opline = EX(opline);
23766
zend_free_op free_op1;
23767
zval *property = &opline->op2.u.constant;
23768
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
23771
MAKE_REAL_ZVAL_PTR(property);
23773
if (IS_CV == IS_VAR && !container) {
23774
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
23776
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_RW TSRMLS_CC);
23778
zval_ptr_dtor(&property);
23782
if (IS_CV == IS_VAR && 0 &&
23783
READY_TO_DESTROY(free_op1.var)) {
23784
AI_USE_PTR(EX_T(opline->result.u.var).var);
23785
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
23786
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
23787
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
23791
ZEND_VM_NEXT_OPCODE();
23794
static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23796
return zend_fetch_property_address_read_helper_SPEC_CV_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23799
static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23801
zend_op *opline = EX(opline);
23803
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
23804
/* Behave like FETCH_OBJ_W */
23805
zend_free_op free_op1;
23806
zval *property = &opline->op2.u.constant;
23807
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
23810
MAKE_REAL_ZVAL_PTR(property);
23812
if (IS_CV == IS_VAR && !container) {
23813
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
23815
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
23817
zval_ptr_dtor(&property);
23821
if (IS_CV == IS_VAR && 0 &&
23822
READY_TO_DESTROY(free_op1.var)) {
23823
AI_USE_PTR(EX_T(opline->result.u.var).var);
23824
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
23825
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
23826
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
23830
ZEND_VM_NEXT_OPCODE();
23832
return zend_fetch_property_address_read_helper_SPEC_CV_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23836
static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23838
zend_op *opline = EX(opline);
23839
zend_free_op free_op1, free_res;
23840
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
23841
zval *property = &opline->op2.u.constant;
23843
if (IS_CV == IS_CV) {
23844
if (container != &EG(uninitialized_zval_ptr)) {
23845
SEPARATE_ZVAL_IF_NOT_REF(container);
23849
MAKE_REAL_ZVAL_PTR(property);
23851
if (IS_CV == IS_VAR && !container) {
23852
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
23854
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
23856
zval_ptr_dtor(&property);
23860
if (IS_CV == IS_VAR && 0 &&
23861
READY_TO_DESTROY(free_op1.var)) {
23862
AI_USE_PTR(EX_T(opline->result.u.var).var);
23863
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
23864
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
23865
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
23869
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
23870
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
23871
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
23873
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
23874
FREE_OP_VAR_PTR(free_res);
23875
ZEND_VM_NEXT_OPCODE();
23878
static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23880
zend_op *opline = EX(opline);
23881
zend_op *op_data = opline+1;
23883
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
23884
zval *property_name = &opline->op2.u.constant;
23887
MAKE_REAL_ZVAL_PTR(property_name);
23889
if (IS_CV == IS_VAR && !object_ptr) {
23890
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23892
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
23894
zval_ptr_dtor(&property_name);
23899
/* assign_obj has two opcodes! */
23900
ZEND_VM_INC_OPCODE();
23901
ZEND_VM_NEXT_OPCODE();
23904
static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23906
zend_op *opline = EX(opline);
23907
zend_op *op_data = opline+1;
23909
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
23911
if (IS_CV == IS_VAR && !object_ptr) {
23912
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23914
if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
23916
zval *property_name = &opline->op2.u.constant;
23919
MAKE_REAL_ZVAL_PTR(property_name);
23921
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
23923
zval_ptr_dtor(&property_name);
23928
zend_free_op free_op_data1, free_op_data2;
23930
zval *dim = &opline->op2.u.constant;
23931
zval **variable_ptr_ptr;
23933
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
23935
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
23936
variable_ptr_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
23937
if (!variable_ptr_ptr) {
23938
if (zend_assign_to_string_offset(&EX_T(op_data->op2.u.var), value, op_data->op1.op_type TSRMLS_CC)) {
23939
if (!RETURN_VALUE_UNUSED(&opline->result)) {
23940
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
23941
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
23942
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
23943
ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(op_data->op2.u.var).str_offset.str)+EX_T(op_data->op2.u.var).str_offset.offset, 1, 1);
23945
} else if (!RETURN_VALUE_UNUSED(&opline->result)) {
23946
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
23947
PZVAL_LOCK(EG(uninitialized_zval_ptr));
23950
value = zend_assign_to_variable(variable_ptr_ptr, value, IS_TMP_FREE(free_op_data1) TSRMLS_CC);
23951
if (!RETURN_VALUE_UNUSED(&opline->result)) {
23952
AI_SET_PTR(EX_T(opline->result.u.var).var, value);
23956
FREE_OP_VAR_PTR(free_op_data2);
23957
FREE_OP_IF_VAR(free_op_data1);
23960
/* assign_dim has two opcodes! */
23961
ZEND_VM_INC_OPCODE();
23962
ZEND_VM_NEXT_OPCODE();
23965
static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23967
zend_op *opline = EX(opline);
23969
zval *value = &opline->op2.u.constant;
23970
zval **variable_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
23972
if (IS_CV == IS_VAR && !variable_ptr_ptr) {
23973
if (zend_assign_to_string_offset(&EX_T(opline->op1.u.var), value, IS_CONST TSRMLS_CC)) {
23974
if (!RETURN_VALUE_UNUSED(&opline->result)) {
23975
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
23976
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
23977
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
23978
ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(opline->op1.u.var).str_offset.str)+EX_T(opline->op1.u.var).str_offset.offset, 1, 1);
23980
} else if (!RETURN_VALUE_UNUSED(&opline->result)) {
23981
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
23982
PZVAL_LOCK(EG(uninitialized_zval_ptr));
23985
value = zend_assign_to_variable(variable_ptr_ptr, value, 0 TSRMLS_CC);
23986
if (!RETURN_VALUE_UNUSED(&opline->result)) {
23987
AI_SET_PTR(EX_T(opline->result.u.var).var, value);
23992
/* zend_assign_to_variable() always takes care of op2, never free it! */
23994
ZEND_VM_NEXT_OPCODE();
23997
static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23999
zend_op *opline = EX(opline);
24000
zval *function_name;
24001
char *function_name_strval;
24002
int function_name_strlen;
24005
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
24007
function_name = &opline->op2.u.constant;
24009
if (Z_TYPE_P(function_name)!=IS_STRING) {
24010
zend_error_noreturn(E_ERROR, "Method name must be a string");
24013
function_name_strval = Z_STRVAL_P(function_name);
24014
function_name_strlen = Z_STRLEN_P(function_name);
24016
EX(object) = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
24018
if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
24019
if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
24020
zend_error_noreturn(E_ERROR, "Object does not support method calls");
24023
/* First, locate the function. */
24024
EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
24026
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
24029
EX(called_scope) = Z_OBJCE_P(EX(object));
24031
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
24034
if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) {
24037
if (!PZVAL_IS_REF(EX(object))) {
24038
Z_ADDREF_P(EX(object)); /* For $this pointer */
24041
ALLOC_ZVAL(this_ptr);
24042
INIT_PZVAL_COPY(this_ptr, EX(object));
24043
zval_copy_ctor(this_ptr);
24044
EX(object) = this_ptr;
24049
ZEND_VM_NEXT_OPCODE();
24052
static int ZEND_FASTCALL ZEND_CASE_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24054
zend_op *opline = EX(opline);
24055
int switch_expr_is_overloaded=0;
24058
if (IS_CV==IS_VAR) {
24059
if (EX_T(opline->op1.u.var).var.ptr_ptr) {
24060
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
24062
switch_expr_is_overloaded = 1;
24063
Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
24066
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
24067
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
24068
&opline->op2.u.constant TSRMLS_CC);
24070
if (switch_expr_is_overloaded) {
24071
/* We only free op1 if this is a string offset,
24072
* Since if it is a TMP_VAR, it'll be reused by
24073
* other CASE opcodes (whereas string offsets
24074
* are allocated at each get_zval_ptr())
24077
EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
24078
EX_T(opline->op1.u.var).var.ptr = NULL;
24080
ZEND_VM_NEXT_OPCODE();
24083
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24085
zend_op *opline = EX(opline);
24087
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
24089
zval *offset=&opline->op2.u.constant;
24091
#if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
24092
zval **expr_ptr_ptr = NULL;
24094
if (opline->extended_value) {
24095
expr_ptr_ptr=_get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
24096
expr_ptr = *expr_ptr_ptr;
24098
expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
24101
expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
24104
if (0) { /* temporary variable */
24107
ALLOC_ZVAL(new_expr);
24108
INIT_PZVAL_COPY(new_expr, expr_ptr);
24109
expr_ptr = new_expr;
24111
#if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
24112
if (opline->extended_value) {
24113
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
24114
expr_ptr = *expr_ptr_ptr;
24115
Z_ADDREF_P(expr_ptr);
24118
if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
24121
ALLOC_ZVAL(new_expr);
24122
INIT_PZVAL_COPY(new_expr, expr_ptr);
24123
expr_ptr = new_expr;
24124
zendi_zval_copy_ctor(*expr_ptr);
24126
Z_ADDREF_P(expr_ptr);
24130
switch (Z_TYPE_P(offset)) {
24132
zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
24136
zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
24139
zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
24142
zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
24145
zend_error(E_WARNING, "Illegal offset type");
24146
zval_ptr_dtor(&expr_ptr);
24152
zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
24154
if (opline->extended_value) {
24159
ZEND_VM_NEXT_OPCODE();
24162
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24164
zend_op *opline = EX(opline);
24166
array_init(&EX_T(opline->result.u.var).tmp_var);
24167
if (IS_CV == IS_UNUSED) {
24168
ZEND_VM_NEXT_OPCODE();
24169
#if 0 || IS_CV != IS_UNUSED
24171
return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24176
static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24178
zend_op *opline = EX(opline);
24180
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
24181
zval *offset = &opline->op2.u.constant;
24183
if (IS_CV != IS_VAR || container) {
24184
if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
24185
SEPARATE_ZVAL_IF_NOT_REF(container);
24187
switch (Z_TYPE_PP(container)) {
24189
HashTable *ht = Z_ARRVAL_PP(container);
24191
switch (Z_TYPE_P(offset)) {
24193
zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
24198
zend_hash_index_del(ht, Z_LVAL_P(offset));
24201
if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
24202
Z_ADDREF_P(offset);
24204
if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
24205
ht == &EG(symbol_table)) {
24206
zend_execute_data *ex;
24207
ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
24209
for (ex = execute_data; ex; ex = ex->prev_execute_data) {
24210
if (ex->op_array && ex->symbol_table == ht) {
24213
for (i = 0; i < ex->op_array->last_var; i++) {
24214
if (ex->op_array->vars[i].hash_value == hash_value &&
24215
ex->op_array->vars[i].name_len == offset->value.str.len &&
24216
!memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
24224
if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
24225
zval_ptr_dtor(&offset);
24229
zend_hash_del(ht, "", sizeof(""));
24232
zend_error(E_WARNING, "Illegal offset type in unset");
24239
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
24240
zend_error_noreturn(E_ERROR, "Cannot use object as array");
24243
MAKE_REAL_ZVAL_PTR(offset);
24245
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
24247
zval_ptr_dtor(&offset);
24253
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
24254
ZEND_VM_CONTINUE(); /* bailed out before */
24263
ZEND_VM_NEXT_OPCODE();
24266
static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24268
zend_op *opline = EX(opline);
24270
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
24271
zval *offset = &opline->op2.u.constant;
24273
if (IS_CV != IS_VAR || container) {
24274
if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
24275
SEPARATE_ZVAL_IF_NOT_REF(container);
24277
if (Z_TYPE_PP(container) == IS_OBJECT) {
24279
MAKE_REAL_ZVAL_PTR(offset);
24281
if (Z_OBJ_HT_P(*container)->unset_property) {
24282
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
24284
zend_error(E_NOTICE, "Trying to unset property of non-object");
24287
zval_ptr_dtor(&offset);
24298
ZEND_VM_NEXT_OPCODE();
24301
static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
24303
zend_op *opline = EX(opline);
24305
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
24306
zval **value = NULL;
24309
if (IS_CV != IS_VAR || container) {
24311
zval *offset = &opline->op2.u.constant;
24313
if (Z_TYPE_PP(container) == IS_ARRAY) {
24317
ht = Z_ARRVAL_PP(container);
24319
switch (Z_TYPE_P(offset)) {
24321
if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
24328
if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
24333
if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
24338
if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
24343
zend_error(E_WARNING, "Illegal offset type in isset or empty");
24348
switch (opline->extended_value) {
24350
if (isset && Z_TYPE_PP(value) == IS_NULL) {
24357
if (!isset || !i_zend_is_true(*value)) {
24365
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
24367
MAKE_REAL_ZVAL_PTR(offset);
24370
if (Z_OBJ_HT_P(*container)->has_property) {
24371
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
24373
zend_error(E_NOTICE, "Trying to check property of non-object");
24377
if (Z_OBJ_HT_P(*container)->has_dimension) {
24378
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
24380
zend_error(E_NOTICE, "Trying to check element of non-array");
24385
zval_ptr_dtor(&offset);
24389
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
24392
if (Z_TYPE_P(offset) != IS_LONG) {
24394
zval_copy_ctor(&tmp);
24395
convert_to_long(&tmp);
24398
if (Z_TYPE_P(offset) == IS_LONG) {
24399
switch (opline->extended_value) {
24401
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
24406
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
24418
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
24420
switch (opline->extended_value) {
24422
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
24425
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
24429
ZEND_VM_NEXT_OPCODE();
24432
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24434
return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24437
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24439
return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24442
static int ZEND_FASTCALL ZEND_ADD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24444
zend_op *opline = EX(opline);
24445
zend_free_op free_op2;
24447
add_function(&EX_T(opline->result.u.var).tmp_var,
24448
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
24449
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
24451
zval_dtor(free_op2.var);
24452
ZEND_VM_NEXT_OPCODE();
24455
static int ZEND_FASTCALL ZEND_SUB_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24457
zend_op *opline = EX(opline);
24458
zend_free_op free_op2;
24460
sub_function(&EX_T(opline->result.u.var).tmp_var,
24461
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
24462
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
24464
zval_dtor(free_op2.var);
24465
ZEND_VM_NEXT_OPCODE();
24468
static int ZEND_FASTCALL ZEND_MUL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24470
zend_op *opline = EX(opline);
24471
zend_free_op free_op2;
24473
mul_function(&EX_T(opline->result.u.var).tmp_var,
24474
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
24475
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
24477
zval_dtor(free_op2.var);
24478
ZEND_VM_NEXT_OPCODE();
24481
static int ZEND_FASTCALL ZEND_DIV_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24483
zend_op *opline = EX(opline);
24484
zend_free_op free_op2;
24486
div_function(&EX_T(opline->result.u.var).tmp_var,
24487
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
24488
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
24490
zval_dtor(free_op2.var);
24491
ZEND_VM_NEXT_OPCODE();
24494
static int ZEND_FASTCALL ZEND_MOD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24496
zend_op *opline = EX(opline);
24497
zend_free_op free_op2;
24499
mod_function(&EX_T(opline->result.u.var).tmp_var,
24500
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
24501
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
24503
zval_dtor(free_op2.var);
24504
ZEND_VM_NEXT_OPCODE();
24507
static int ZEND_FASTCALL ZEND_SL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24509
zend_op *opline = EX(opline);
24510
zend_free_op free_op2;
24512
shift_left_function(&EX_T(opline->result.u.var).tmp_var,
24513
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
24514
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
24516
zval_dtor(free_op2.var);
24517
ZEND_VM_NEXT_OPCODE();
24520
static int ZEND_FASTCALL ZEND_SR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24522
zend_op *opline = EX(opline);
24523
zend_free_op free_op2;
24525
shift_right_function(&EX_T(opline->result.u.var).tmp_var,
24526
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
24527
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
24529
zval_dtor(free_op2.var);
24530
ZEND_VM_NEXT_OPCODE();
24533
static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24535
zend_op *opline = EX(opline);
24536
zend_free_op free_op2;
24538
concat_function(&EX_T(opline->result.u.var).tmp_var,
24539
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
24540
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
24542
zval_dtor(free_op2.var);
24543
ZEND_VM_NEXT_OPCODE();
24546
static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24548
zend_op *opline = EX(opline);
24549
zend_free_op free_op2;
24551
is_identical_function(&EX_T(opline->result.u.var).tmp_var,
24552
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
24553
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
24555
zval_dtor(free_op2.var);
24556
ZEND_VM_NEXT_OPCODE();
24559
static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24561
zend_op *opline = EX(opline);
24562
zend_free_op free_op2;
24563
zval *result = &EX_T(opline->result.u.var).tmp_var;
24565
is_identical_function(result,
24566
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
24567
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
24568
Z_LVAL_P(result) = !Z_LVAL_P(result);
24570
zval_dtor(free_op2.var);
24571
ZEND_VM_NEXT_OPCODE();
24574
static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24576
zend_op *opline = EX(opline);
24577
zend_free_op free_op2;
24578
zval *result = &EX_T(opline->result.u.var).tmp_var;
24580
compare_function(result,
24581
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
24582
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
24583
ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
24585
zval_dtor(free_op2.var);
24586
ZEND_VM_NEXT_OPCODE();
24589
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24591
zend_op *opline = EX(opline);
24592
zend_free_op free_op2;
24593
zval *result = &EX_T(opline->result.u.var).tmp_var;
24595
compare_function(result,
24596
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
24597
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
24598
ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
24600
zval_dtor(free_op2.var);
24601
ZEND_VM_NEXT_OPCODE();
24604
static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24606
zend_op *opline = EX(opline);
24607
zend_free_op free_op2;
24608
zval *result = &EX_T(opline->result.u.var).tmp_var;
24610
compare_function(result,
24611
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
24612
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
24613
ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
24615
zval_dtor(free_op2.var);
24616
ZEND_VM_NEXT_OPCODE();
24619
static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24621
zend_op *opline = EX(opline);
24622
zend_free_op free_op2;
24623
zval *result = &EX_T(opline->result.u.var).tmp_var;
24625
compare_function(result,
24626
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
24627
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
24628
ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
24630
zval_dtor(free_op2.var);
24631
ZEND_VM_NEXT_OPCODE();
24634
static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24636
zend_op *opline = EX(opline);
24637
zend_free_op free_op2;
24639
bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
24640
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
24641
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
24643
zval_dtor(free_op2.var);
24644
ZEND_VM_NEXT_OPCODE();
24647
static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24649
zend_op *opline = EX(opline);
24650
zend_free_op free_op2;
24652
bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
24653
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
24654
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
24656
zval_dtor(free_op2.var);
24657
ZEND_VM_NEXT_OPCODE();
24660
static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24662
zend_op *opline = EX(opline);
24663
zend_free_op free_op2;
24665
bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
24666
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
24667
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
24669
zval_dtor(free_op2.var);
24670
ZEND_VM_NEXT_OPCODE();
24673
static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24675
zend_op *opline = EX(opline);
24676
zend_free_op free_op2;
24678
boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
24679
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
24680
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
24682
zval_dtor(free_op2.var);
24683
ZEND_VM_NEXT_OPCODE();
24686
static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
24688
zend_op *opline = EX(opline);
24689
zend_op *op_data = opline+1;
24690
zend_free_op free_op2, free_op_data1;
24691
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
24693
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
24694
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
24695
znode *result = &opline->result;
24696
int have_get_ptr = 0;
24698
if (IS_CV == IS_VAR && !object_ptr) {
24699
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
24702
EX_T(result->u.var).var.ptr_ptr = NULL;
24703
make_real_object(object_ptr TSRMLS_CC);
24704
object = *object_ptr;
24706
if (Z_TYPE_P(object) != IS_OBJECT) {
24707
zend_error(E_WARNING, "Attempt to assign property of non-object");
24708
zval_dtor(free_op2.var);
24709
FREE_OP(free_op_data1);
24711
if (!RETURN_VALUE_UNUSED(result)) {
24712
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
24713
EX_T(result->u.var).var.ptr_ptr = NULL;
24714
PZVAL_LOCK(EG(uninitialized_zval_ptr));
24717
/* here we are sure we are dealing with an object */
24719
MAKE_REAL_ZVAL_PTR(property);
24722
/* here property is a string */
24723
if (opline->extended_value == ZEND_ASSIGN_OBJ
24724
&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
24725
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
24726
if (zptr != NULL) { /* NULL means no success in getting PTR */
24727
SEPARATE_ZVAL_IF_NOT_REF(zptr);
24730
binary_op(*zptr, *zptr, value TSRMLS_CC);
24731
if (!RETURN_VALUE_UNUSED(result)) {
24732
EX_T(result->u.var).var.ptr = *zptr;
24733
EX_T(result->u.var).var.ptr_ptr = NULL;
24739
if (!have_get_ptr) {
24742
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
24743
if (Z_OBJ_HT_P(object)->read_property) {
24744
z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
24746
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
24747
if (Z_OBJ_HT_P(object)->read_dimension) {
24748
z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
24752
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
24753
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
24755
if (Z_REFCOUNT_P(z) == 0) {
24756
GC_REMOVE_ZVAL_FROM_BUFFER(z);
24763
SEPARATE_ZVAL_IF_NOT_REF(&z);
24764
binary_op(z, z, value TSRMLS_CC);
24765
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
24766
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
24767
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
24768
Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
24770
if (!RETURN_VALUE_UNUSED(result)) {
24771
EX_T(result->u.var).var.ptr = z;
24772
EX_T(result->u.var).var.ptr_ptr = NULL;
24777
zend_error(E_WARNING, "Attempt to assign property of non-object");
24778
if (!RETURN_VALUE_UNUSED(result)) {
24779
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
24780
EX_T(result->u.var).var.ptr_ptr = NULL;
24781
PZVAL_LOCK(EG(uninitialized_zval_ptr));
24787
zval_ptr_dtor(&property);
24789
zval_dtor(free_op2.var);
24791
FREE_OP(free_op_data1);
24794
/* assign_obj has two opcodes! */
24795
ZEND_VM_INC_OPCODE();
24796
ZEND_VM_NEXT_OPCODE();
24799
static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
24801
zend_op *opline = EX(opline);
24802
zend_free_op free_op2, free_op_data2, free_op_data1;
24806
switch (opline->extended_value) {
24807
case ZEND_ASSIGN_OBJ:
24808
return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24810
case ZEND_ASSIGN_DIM: {
24811
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
24813
if (IS_CV == IS_VAR && !container) {
24814
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
24815
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
24816
if (IS_CV == IS_VAR && !0) {
24817
Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
24819
return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24821
zend_op *op_data = opline+1;
24822
zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
24824
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), container, dim, 1, BP_VAR_RW TSRMLS_CC);
24825
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
24826
var_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
24827
ZEND_VM_INC_OPCODE();
24832
value = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
24833
var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
24839
zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
24842
if (*var_ptr == EG(error_zval_ptr)) {
24843
if (!RETURN_VALUE_UNUSED(&opline->result)) {
24844
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
24845
PZVAL_LOCK(EG(uninitialized_zval_ptr));
24847
zval_dtor(free_op2.var);
24849
ZEND_VM_NEXT_OPCODE();
24852
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
24854
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
24855
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
24857
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
24858
Z_ADDREF_P(objval);
24859
binary_op(objval, objval, value TSRMLS_CC);
24860
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
24861
zval_ptr_dtor(&objval);
24863
binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
24866
if (!RETURN_VALUE_UNUSED(&opline->result)) {
24867
AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
24868
PZVAL_LOCK(*var_ptr);
24870
zval_dtor(free_op2.var);
24872
if (opline->extended_value == ZEND_ASSIGN_DIM) {
24873
FREE_OP(free_op_data1);
24874
FREE_OP_VAR_PTR(free_op_data2);
24877
ZEND_VM_NEXT_OPCODE();
24880
static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24882
return zend_binary_assign_op_helper_SPEC_CV_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24885
static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24887
return zend_binary_assign_op_helper_SPEC_CV_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24890
static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24892
return zend_binary_assign_op_helper_SPEC_CV_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24895
static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24897
return zend_binary_assign_op_helper_SPEC_CV_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24900
static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24902
return zend_binary_assign_op_helper_SPEC_CV_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24905
static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24907
return zend_binary_assign_op_helper_SPEC_CV_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24910
static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24912
return zend_binary_assign_op_helper_SPEC_CV_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24915
static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24917
return zend_binary_assign_op_helper_SPEC_CV_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24920
static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24922
return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24925
static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24927
return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24930
static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24932
return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24935
static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
24937
zend_op *opline = EX(opline);
24938
zend_free_op free_op2;
24939
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
24941
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
24942
zval **retval = &EX_T(opline->result.u.var).var.ptr;
24943
int have_get_ptr = 0;
24945
if (IS_CV == IS_VAR && !object_ptr) {
24946
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
24949
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
24950
object = *object_ptr;
24952
if (Z_TYPE_P(object) != IS_OBJECT) {
24953
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
24954
zval_dtor(free_op2.var);
24955
if (!RETURN_VALUE_UNUSED(&opline->result)) {
24956
*retval = EG(uninitialized_zval_ptr);
24957
PZVAL_LOCK(*retval);
24960
ZEND_VM_NEXT_OPCODE();
24963
/* here we are sure we are dealing with an object */
24966
MAKE_REAL_ZVAL_PTR(property);
24969
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
24970
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
24971
if (zptr != NULL) { /* NULL means no success in getting PTR */
24972
SEPARATE_ZVAL_IF_NOT_REF(zptr);
24976
if (!RETURN_VALUE_UNUSED(&opline->result)) {
24978
PZVAL_LOCK(*retval);
24983
if (!have_get_ptr) {
24984
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
24985
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
24987
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
24988
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
24990
if (Z_REFCOUNT_P(z) == 0) {
24991
GC_REMOVE_ZVAL_FROM_BUFFER(z);
24998
SEPARATE_ZVAL_IF_NOT_REF(&z);
25001
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
25002
SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
25005
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
25006
if (!RETURN_VALUE_UNUSED(&opline->result)) {
25007
*retval = EG(uninitialized_zval_ptr);
25008
PZVAL_LOCK(*retval);
25014
zval_ptr_dtor(&property);
25016
zval_dtor(free_op2.var);
25019
ZEND_VM_NEXT_OPCODE();
25022
static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25024
return zend_pre_incdec_property_helper_SPEC_CV_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25027
static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25029
return zend_pre_incdec_property_helper_SPEC_CV_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25032
static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
25034
zend_op *opline = EX(opline);
25035
zend_free_op free_op2;
25036
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
25038
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25039
zval *retval = &EX_T(opline->result.u.var).tmp_var;
25040
int have_get_ptr = 0;
25042
if (IS_CV == IS_VAR && !object_ptr) {
25043
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
25046
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
25047
object = *object_ptr;
25049
if (Z_TYPE_P(object) != IS_OBJECT) {
25050
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
25051
zval_dtor(free_op2.var);
25052
*retval = *EG(uninitialized_zval_ptr);
25054
ZEND_VM_NEXT_OPCODE();
25057
/* here we are sure we are dealing with an object */
25060
MAKE_REAL_ZVAL_PTR(property);
25063
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
25064
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
25065
if (zptr != NULL) { /* NULL means no success in getting PTR */
25067
SEPARATE_ZVAL_IF_NOT_REF(zptr);
25070
zendi_zval_copy_ctor(*retval);
25077
if (!have_get_ptr) {
25078
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
25079
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
25082
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
25083
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
25085
if (Z_REFCOUNT_P(z) == 0) {
25086
GC_REMOVE_ZVAL_FROM_BUFFER(z);
25093
zendi_zval_copy_ctor(*retval);
25094
ALLOC_ZVAL(z_copy);
25096
zendi_zval_copy_ctor(*z_copy);
25097
INIT_PZVAL(z_copy);
25100
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
25101
zval_ptr_dtor(&z_copy);
25104
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
25105
*retval = *EG(uninitialized_zval_ptr);
25110
zval_ptr_dtor(&property);
25112
zval_dtor(free_op2.var);
25115
ZEND_VM_NEXT_OPCODE();
25118
static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25120
return zend_post_incdec_property_helper_SPEC_CV_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25123
static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25125
return zend_post_incdec_property_helper_SPEC_CV_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25128
static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25130
zend_op *opline = EX(opline);
25131
zend_free_op free_op2;
25132
zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25135
if (opline->extended_value == ZEND_FETCH_ADD_LOCK &&
25137
EX_T(opline->op1.u.var).var.ptr_ptr) {
25138
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
25140
container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
25141
if (IS_CV == IS_VAR && !container) {
25142
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
25144
zend_fetch_dimension_address_read(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, dim, 1, BP_VAR_R TSRMLS_CC);
25145
zval_dtor(free_op2.var);
25147
ZEND_VM_NEXT_OPCODE();
25150
static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25152
zend_op *opline = EX(opline);
25153
zend_free_op free_op1, free_op2;
25154
zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25155
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
25157
if (IS_CV == IS_VAR && !container) {
25158
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
25160
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 1, BP_VAR_W TSRMLS_CC);
25161
zval_dtor(free_op2.var);
25162
if (IS_CV == IS_VAR && 0 &&
25163
READY_TO_DESTROY(free_op1.var)) {
25164
AI_USE_PTR(EX_T(opline->result.u.var).var);
25165
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
25166
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
25167
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
25171
/* We are going to assign the result by reference */
25172
if (opline->extended_value) {
25173
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
25174
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
25175
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
25178
ZEND_VM_NEXT_OPCODE();
25181
static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25183
zend_op *opline = EX(opline);
25184
zend_free_op free_op1, free_op2;
25185
zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25186
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
25188
if (IS_CV == IS_VAR && !container) {
25189
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
25191
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 1, BP_VAR_RW TSRMLS_CC);
25192
zval_dtor(free_op2.var);
25193
if (IS_CV == IS_VAR && 0 &&
25194
READY_TO_DESTROY(free_op1.var)) {
25195
AI_USE_PTR(EX_T(opline->result.u.var).var);
25196
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
25197
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
25198
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
25202
ZEND_VM_NEXT_OPCODE();
25205
static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25207
zend_op *opline = EX(opline);
25208
zend_free_op free_op2;
25209
zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25210
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
25212
if (IS_CV == IS_VAR && !container) {
25213
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
25215
zend_fetch_dimension_address_read(&EX_T(opline->result.u.var), container, dim, 1, BP_VAR_IS TSRMLS_CC);
25216
zval_dtor(free_op2.var);
25218
ZEND_VM_NEXT_OPCODE();
25221
static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25223
zend_op *opline = EX(opline);
25224
zend_free_op free_op1, free_op2;
25225
zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25228
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
25229
container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
25230
if (IS_CV == IS_VAR && !container) {
25231
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
25233
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 1, BP_VAR_W TSRMLS_CC);
25234
if (IS_CV == IS_VAR && 0 &&
25235
READY_TO_DESTROY(free_op1.var)) {
25236
AI_USE_PTR(EX_T(opline->result.u.var).var);
25237
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
25238
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
25239
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
25243
if (IS_TMP_VAR == IS_UNUSED) {
25244
zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
25246
container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
25247
if (IS_CV == IS_VAR && !container) {
25248
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
25250
zend_fetch_dimension_address_read(&EX_T(opline->result.u.var), container, dim, 1, BP_VAR_R TSRMLS_CC);
25252
zval_dtor(free_op2.var);
25254
ZEND_VM_NEXT_OPCODE();
25257
static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25259
zend_op *opline = EX(opline);
25260
zend_free_op free_op1, free_op2;
25261
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
25262
zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25264
/* Not needed in DIM_UNSET
25265
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
25266
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
25269
if (IS_CV == IS_CV) {
25270
if (container != &EG(uninitialized_zval_ptr)) {
25271
SEPARATE_ZVAL_IF_NOT_REF(container);
25274
if (IS_CV == IS_VAR && !container) {
25275
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
25277
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 1, BP_VAR_UNSET TSRMLS_CC);
25278
zval_dtor(free_op2.var);
25279
if (IS_CV == IS_VAR && 0 &&
25280
READY_TO_DESTROY(free_op1.var)) {
25281
AI_USE_PTR(EX_T(opline->result.u.var).var);
25282
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
25283
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
25284
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
25288
if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
25289
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
25291
zend_free_op free_res;
25293
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
25294
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
25295
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
25297
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
25298
FREE_OP_VAR_PTR(free_res);
25300
ZEND_VM_NEXT_OPCODE();
25303
static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_TMP(int type, ZEND_OPCODE_HANDLER_ARGS)
25305
zend_op *opline = EX(opline);
25307
zval *container = _get_zval_ptr_cv(&opline->op1, EX(Ts), type TSRMLS_CC);
25308
zend_free_op free_op2;
25309
zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25311
if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
25312
if (type != BP_VAR_IS) {
25313
zend_error(E_NOTICE, "Trying to get property of non-object");
25315
if (!RETURN_VALUE_UNUSED(&opline->result)) {
25316
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
25317
PZVAL_LOCK(EG(uninitialized_zval_ptr));
25319
zval_dtor(free_op2.var);
25324
MAKE_REAL_ZVAL_PTR(offset);
25327
/* here we are sure we are dealing with an object */
25328
retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
25330
if (RETURN_VALUE_UNUSED(&opline->result)) {
25331
if (Z_REFCOUNT_P(retval) == 0) {
25332
GC_REMOVE_ZVAL_FROM_BUFFER(retval);
25337
AI_SET_PTR(EX_T(opline->result.u.var).var, retval);
25338
PZVAL_LOCK(retval);
25342
zval_ptr_dtor(&offset);
25344
zval_dtor(free_op2.var);
25348
ZEND_VM_NEXT_OPCODE();
25351
static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25353
return zend_fetch_property_address_read_helper_SPEC_CV_TMP(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25356
static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25358
zend_op *opline = EX(opline);
25359
zend_free_op free_op1, free_op2;
25360
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25363
if (IS_CV == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
25364
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
25365
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
25369
MAKE_REAL_ZVAL_PTR(property);
25371
container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
25372
if (IS_CV == IS_VAR && !container) {
25373
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
25375
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
25377
zval_ptr_dtor(&property);
25379
zval_dtor(free_op2.var);
25381
if (IS_CV == IS_VAR && 0 &&
25382
READY_TO_DESTROY(free_op1.var)) {
25383
AI_USE_PTR(EX_T(opline->result.u.var).var);
25384
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
25385
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
25386
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
25390
/* We are going to assign the result by reference */
25391
if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
25392
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
25393
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
25394
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
25397
ZEND_VM_NEXT_OPCODE();
25400
static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25402
zend_op *opline = EX(opline);
25403
zend_free_op free_op1, free_op2;
25404
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25405
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
25408
MAKE_REAL_ZVAL_PTR(property);
25410
if (IS_CV == IS_VAR && !container) {
25411
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
25413
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_RW TSRMLS_CC);
25415
zval_ptr_dtor(&property);
25417
zval_dtor(free_op2.var);
25419
if (IS_CV == IS_VAR && 0 &&
25420
READY_TO_DESTROY(free_op1.var)) {
25421
AI_USE_PTR(EX_T(opline->result.u.var).var);
25422
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
25423
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
25424
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
25428
ZEND_VM_NEXT_OPCODE();
25431
static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25433
return zend_fetch_property_address_read_helper_SPEC_CV_TMP(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25436
static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25438
zend_op *opline = EX(opline);
25440
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
25441
/* Behave like FETCH_OBJ_W */
25442
zend_free_op free_op1, free_op2;
25443
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25444
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
25447
MAKE_REAL_ZVAL_PTR(property);
25449
if (IS_CV == IS_VAR && !container) {
25450
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
25452
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
25454
zval_ptr_dtor(&property);
25456
zval_dtor(free_op2.var);
25458
if (IS_CV == IS_VAR && 0 &&
25459
READY_TO_DESTROY(free_op1.var)) {
25460
AI_USE_PTR(EX_T(opline->result.u.var).var);
25461
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
25462
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
25463
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
25467
ZEND_VM_NEXT_OPCODE();
25469
return zend_fetch_property_address_read_helper_SPEC_CV_TMP(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25473
static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25475
zend_op *opline = EX(opline);
25476
zend_free_op free_op1, free_op2, free_res;
25477
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
25478
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25480
if (IS_CV == IS_CV) {
25481
if (container != &EG(uninitialized_zval_ptr)) {
25482
SEPARATE_ZVAL_IF_NOT_REF(container);
25486
MAKE_REAL_ZVAL_PTR(property);
25488
if (IS_CV == IS_VAR && !container) {
25489
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
25491
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
25493
zval_ptr_dtor(&property);
25495
zval_dtor(free_op2.var);
25497
if (IS_CV == IS_VAR && 0 &&
25498
READY_TO_DESTROY(free_op1.var)) {
25499
AI_USE_PTR(EX_T(opline->result.u.var).var);
25500
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
25501
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
25502
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
25506
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
25507
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
25508
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
25510
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
25511
FREE_OP_VAR_PTR(free_res);
25512
ZEND_VM_NEXT_OPCODE();
25515
static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25517
zend_op *opline = EX(opline);
25518
zend_op *op_data = opline+1;
25519
zend_free_op free_op2;
25520
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
25521
zval *property_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25524
MAKE_REAL_ZVAL_PTR(property_name);
25526
if (IS_CV == IS_VAR && !object_ptr) {
25527
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
25529
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
25531
zval_ptr_dtor(&property_name);
25533
zval_dtor(free_op2.var);
25536
/* assign_obj has two opcodes! */
25537
ZEND_VM_INC_OPCODE();
25538
ZEND_VM_NEXT_OPCODE();
25541
static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25543
zend_op *opline = EX(opline);
25544
zend_op *op_data = opline+1;
25546
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
25548
if (IS_CV == IS_VAR && !object_ptr) {
25549
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
25551
if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
25552
zend_free_op free_op2;
25553
zval *property_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25556
MAKE_REAL_ZVAL_PTR(property_name);
25558
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
25560
zval_ptr_dtor(&property_name);
25562
zval_dtor(free_op2.var);
25565
zend_free_op free_op2, free_op_data1, free_op_data2;
25567
zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25568
zval **variable_ptr_ptr;
25570
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 1, BP_VAR_W TSRMLS_CC);
25571
zval_dtor(free_op2.var);
25573
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
25574
variable_ptr_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
25575
if (!variable_ptr_ptr) {
25576
if (zend_assign_to_string_offset(&EX_T(op_data->op2.u.var), value, op_data->op1.op_type TSRMLS_CC)) {
25577
if (!RETURN_VALUE_UNUSED(&opline->result)) {
25578
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
25579
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
25580
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
25581
ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(op_data->op2.u.var).str_offset.str)+EX_T(op_data->op2.u.var).str_offset.offset, 1, 1);
25583
} else if (!RETURN_VALUE_UNUSED(&opline->result)) {
25584
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
25585
PZVAL_LOCK(EG(uninitialized_zval_ptr));
25588
value = zend_assign_to_variable(variable_ptr_ptr, value, IS_TMP_FREE(free_op_data1) TSRMLS_CC);
25589
if (!RETURN_VALUE_UNUSED(&opline->result)) {
25590
AI_SET_PTR(EX_T(opline->result.u.var).var, value);
25594
FREE_OP_VAR_PTR(free_op_data2);
25595
FREE_OP_IF_VAR(free_op_data1);
25598
/* assign_dim has two opcodes! */
25599
ZEND_VM_INC_OPCODE();
25600
ZEND_VM_NEXT_OPCODE();
25603
static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25605
zend_op *opline = EX(opline);
25606
zend_free_op free_op2;
25607
zval *value = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25608
zval **variable_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
25610
if (IS_CV == IS_VAR && !variable_ptr_ptr) {
25611
if (zend_assign_to_string_offset(&EX_T(opline->op1.u.var), value, IS_TMP_VAR TSRMLS_CC)) {
25612
if (!RETURN_VALUE_UNUSED(&opline->result)) {
25613
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
25614
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
25615
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
25616
ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(opline->op1.u.var).str_offset.str)+EX_T(opline->op1.u.var).str_offset.offset, 1, 1);
25618
} else if (!RETURN_VALUE_UNUSED(&opline->result)) {
25619
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
25620
PZVAL_LOCK(EG(uninitialized_zval_ptr));
25623
value = zend_assign_to_variable(variable_ptr_ptr, value, 1 TSRMLS_CC);
25624
if (!RETURN_VALUE_UNUSED(&opline->result)) {
25625
AI_SET_PTR(EX_T(opline->result.u.var).var, value);
25630
/* zend_assign_to_variable() always takes care of op2, never free it! */
25632
ZEND_VM_NEXT_OPCODE();
25635
static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25637
zend_op *opline = EX(opline);
25638
zval *function_name;
25639
char *function_name_strval;
25640
int function_name_strlen;
25641
zend_free_op free_op2;
25643
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
25645
function_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25647
if (Z_TYPE_P(function_name)!=IS_STRING) {
25648
zend_error_noreturn(E_ERROR, "Method name must be a string");
25651
function_name_strval = Z_STRVAL_P(function_name);
25652
function_name_strlen = Z_STRLEN_P(function_name);
25654
EX(object) = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
25656
if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
25657
if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
25658
zend_error_noreturn(E_ERROR, "Object does not support method calls");
25661
/* First, locate the function. */
25662
EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
25664
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
25667
EX(called_scope) = Z_OBJCE_P(EX(object));
25669
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
25672
if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) {
25675
if (!PZVAL_IS_REF(EX(object))) {
25676
Z_ADDREF_P(EX(object)); /* For $this pointer */
25679
ALLOC_ZVAL(this_ptr);
25680
INIT_PZVAL_COPY(this_ptr, EX(object));
25681
zval_copy_ctor(this_ptr);
25682
EX(object) = this_ptr;
25686
zval_dtor(free_op2.var);
25688
ZEND_VM_NEXT_OPCODE();
25691
static int ZEND_FASTCALL ZEND_CASE_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25693
zend_op *opline = EX(opline);
25694
int switch_expr_is_overloaded=0;
25695
zend_free_op free_op2;
25697
if (IS_CV==IS_VAR) {
25698
if (EX_T(opline->op1.u.var).var.ptr_ptr) {
25699
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
25701
switch_expr_is_overloaded = 1;
25702
Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
25705
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
25706
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
25707
_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
25709
zval_dtor(free_op2.var);
25710
if (switch_expr_is_overloaded) {
25711
/* We only free op1 if this is a string offset,
25712
* Since if it is a TMP_VAR, it'll be reused by
25713
* other CASE opcodes (whereas string offsets
25714
* are allocated at each get_zval_ptr())
25717
EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
25718
EX_T(opline->op1.u.var).var.ptr = NULL;
25720
ZEND_VM_NEXT_OPCODE();
25723
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25725
zend_op *opline = EX(opline);
25726
zend_free_op free_op2;
25727
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
25729
zval *offset=_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25731
#if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
25732
zval **expr_ptr_ptr = NULL;
25734
if (opline->extended_value) {
25735
expr_ptr_ptr=_get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
25736
expr_ptr = *expr_ptr_ptr;
25738
expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
25741
expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
25744
if (0) { /* temporary variable */
25747
ALLOC_ZVAL(new_expr);
25748
INIT_PZVAL_COPY(new_expr, expr_ptr);
25749
expr_ptr = new_expr;
25751
#if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
25752
if (opline->extended_value) {
25753
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
25754
expr_ptr = *expr_ptr_ptr;
25755
Z_ADDREF_P(expr_ptr);
25758
if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
25761
ALLOC_ZVAL(new_expr);
25762
INIT_PZVAL_COPY(new_expr, expr_ptr);
25763
expr_ptr = new_expr;
25764
zendi_zval_copy_ctor(*expr_ptr);
25766
Z_ADDREF_P(expr_ptr);
25770
switch (Z_TYPE_P(offset)) {
25772
zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
25776
zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
25779
zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
25782
zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
25785
zend_error(E_WARNING, "Illegal offset type");
25786
zval_ptr_dtor(&expr_ptr);
25790
zval_dtor(free_op2.var);
25792
zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
25794
if (opline->extended_value) {
25799
ZEND_VM_NEXT_OPCODE();
25802
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25804
zend_op *opline = EX(opline);
25806
array_init(&EX_T(opline->result.u.var).tmp_var);
25807
if (IS_CV == IS_UNUSED) {
25808
ZEND_VM_NEXT_OPCODE();
25809
#if 0 || IS_CV != IS_UNUSED
25811
return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25816
static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25818
zend_op *opline = EX(opline);
25819
zend_free_op free_op2;
25820
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
25821
zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25823
if (IS_CV != IS_VAR || container) {
25824
if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
25825
SEPARATE_ZVAL_IF_NOT_REF(container);
25827
switch (Z_TYPE_PP(container)) {
25829
HashTable *ht = Z_ARRVAL_PP(container);
25831
switch (Z_TYPE_P(offset)) {
25833
zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
25838
zend_hash_index_del(ht, Z_LVAL_P(offset));
25841
if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
25842
Z_ADDREF_P(offset);
25844
if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
25845
ht == &EG(symbol_table)) {
25846
zend_execute_data *ex;
25847
ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
25849
for (ex = execute_data; ex; ex = ex->prev_execute_data) {
25850
if (ex->op_array && ex->symbol_table == ht) {
25853
for (i = 0; i < ex->op_array->last_var; i++) {
25854
if (ex->op_array->vars[i].hash_value == hash_value &&
25855
ex->op_array->vars[i].name_len == offset->value.str.len &&
25856
!memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
25864
if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
25865
zval_ptr_dtor(&offset);
25869
zend_hash_del(ht, "", sizeof(""));
25872
zend_error(E_WARNING, "Illegal offset type in unset");
25875
zval_dtor(free_op2.var);
25879
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
25880
zend_error_noreturn(E_ERROR, "Cannot use object as array");
25883
MAKE_REAL_ZVAL_PTR(offset);
25885
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
25887
zval_ptr_dtor(&offset);
25889
zval_dtor(free_op2.var);
25893
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
25894
ZEND_VM_CONTINUE(); /* bailed out before */
25896
zval_dtor(free_op2.var);
25900
zval_dtor(free_op2.var);
25903
ZEND_VM_NEXT_OPCODE();
25906
static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25908
zend_op *opline = EX(opline);
25909
zend_free_op free_op2;
25910
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
25911
zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25913
if (IS_CV != IS_VAR || container) {
25914
if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
25915
SEPARATE_ZVAL_IF_NOT_REF(container);
25917
if (Z_TYPE_PP(container) == IS_OBJECT) {
25919
MAKE_REAL_ZVAL_PTR(offset);
25921
if (Z_OBJ_HT_P(*container)->unset_property) {
25922
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
25924
zend_error(E_NOTICE, "Trying to unset property of non-object");
25927
zval_ptr_dtor(&offset);
25929
zval_dtor(free_op2.var);
25932
zval_dtor(free_op2.var);
25935
zval_dtor(free_op2.var);
25938
ZEND_VM_NEXT_OPCODE();
25941
static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
25943
zend_op *opline = EX(opline);
25945
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
25946
zval **value = NULL;
25949
if (IS_CV != IS_VAR || container) {
25950
zend_free_op free_op2;
25951
zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
25953
if (Z_TYPE_PP(container) == IS_ARRAY) {
25957
ht = Z_ARRVAL_PP(container);
25959
switch (Z_TYPE_P(offset)) {
25961
if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
25968
if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
25973
if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
25978
if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
25983
zend_error(E_WARNING, "Illegal offset type in isset or empty");
25988
switch (opline->extended_value) {
25990
if (isset && Z_TYPE_PP(value) == IS_NULL) {
25997
if (!isset || !i_zend_is_true(*value)) {
26004
zval_dtor(free_op2.var);
26005
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
26007
MAKE_REAL_ZVAL_PTR(offset);
26010
if (Z_OBJ_HT_P(*container)->has_property) {
26011
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
26013
zend_error(E_NOTICE, "Trying to check property of non-object");
26017
if (Z_OBJ_HT_P(*container)->has_dimension) {
26018
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
26020
zend_error(E_NOTICE, "Trying to check element of non-array");
26025
zval_ptr_dtor(&offset);
26027
zval_dtor(free_op2.var);
26029
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
26032
if (Z_TYPE_P(offset) != IS_LONG) {
26034
zval_copy_ctor(&tmp);
26035
convert_to_long(&tmp);
26038
if (Z_TYPE_P(offset) == IS_LONG) {
26039
switch (opline->extended_value) {
26041
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
26046
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
26052
zval_dtor(free_op2.var);
26054
zval_dtor(free_op2.var);
26058
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
26060
switch (opline->extended_value) {
26062
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
26065
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
26069
ZEND_VM_NEXT_OPCODE();
26072
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26074
return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26077
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26079
return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26082
static int ZEND_FASTCALL ZEND_ADD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26084
zend_op *opline = EX(opline);
26085
zend_free_op free_op2;
26087
add_function(&EX_T(opline->result.u.var).tmp_var,
26088
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
26089
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
26091
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26092
ZEND_VM_NEXT_OPCODE();
26095
static int ZEND_FASTCALL ZEND_SUB_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26097
zend_op *opline = EX(opline);
26098
zend_free_op free_op2;
26100
sub_function(&EX_T(opline->result.u.var).tmp_var,
26101
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
26102
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
26104
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26105
ZEND_VM_NEXT_OPCODE();
26108
static int ZEND_FASTCALL ZEND_MUL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26110
zend_op *opline = EX(opline);
26111
zend_free_op free_op2;
26113
mul_function(&EX_T(opline->result.u.var).tmp_var,
26114
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
26115
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
26117
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26118
ZEND_VM_NEXT_OPCODE();
26121
static int ZEND_FASTCALL ZEND_DIV_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26123
zend_op *opline = EX(opline);
26124
zend_free_op free_op2;
26126
div_function(&EX_T(opline->result.u.var).tmp_var,
26127
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
26128
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
26130
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26131
ZEND_VM_NEXT_OPCODE();
26134
static int ZEND_FASTCALL ZEND_MOD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26136
zend_op *opline = EX(opline);
26137
zend_free_op free_op2;
26139
mod_function(&EX_T(opline->result.u.var).tmp_var,
26140
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
26141
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
26143
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26144
ZEND_VM_NEXT_OPCODE();
26147
static int ZEND_FASTCALL ZEND_SL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26149
zend_op *opline = EX(opline);
26150
zend_free_op free_op2;
26152
shift_left_function(&EX_T(opline->result.u.var).tmp_var,
26153
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
26154
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
26156
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26157
ZEND_VM_NEXT_OPCODE();
26160
static int ZEND_FASTCALL ZEND_SR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26162
zend_op *opline = EX(opline);
26163
zend_free_op free_op2;
26165
shift_right_function(&EX_T(opline->result.u.var).tmp_var,
26166
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
26167
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
26169
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26170
ZEND_VM_NEXT_OPCODE();
26173
static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26175
zend_op *opline = EX(opline);
26176
zend_free_op free_op2;
26178
concat_function(&EX_T(opline->result.u.var).tmp_var,
26179
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
26180
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
26182
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26183
ZEND_VM_NEXT_OPCODE();
26186
static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26188
zend_op *opline = EX(opline);
26189
zend_free_op free_op2;
26191
is_identical_function(&EX_T(opline->result.u.var).tmp_var,
26192
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
26193
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
26195
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26196
ZEND_VM_NEXT_OPCODE();
26199
static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26201
zend_op *opline = EX(opline);
26202
zend_free_op free_op2;
26203
zval *result = &EX_T(opline->result.u.var).tmp_var;
26205
is_identical_function(result,
26206
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
26207
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
26208
Z_LVAL_P(result) = !Z_LVAL_P(result);
26210
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26211
ZEND_VM_NEXT_OPCODE();
26214
static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26216
zend_op *opline = EX(opline);
26217
zend_free_op free_op2;
26218
zval *result = &EX_T(opline->result.u.var).tmp_var;
26220
compare_function(result,
26221
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
26222
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
26223
ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
26225
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26226
ZEND_VM_NEXT_OPCODE();
26229
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26231
zend_op *opline = EX(opline);
26232
zend_free_op free_op2;
26233
zval *result = &EX_T(opline->result.u.var).tmp_var;
26235
compare_function(result,
26236
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
26237
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
26238
ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
26240
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26241
ZEND_VM_NEXT_OPCODE();
26244
static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26246
zend_op *opline = EX(opline);
26247
zend_free_op free_op2;
26248
zval *result = &EX_T(opline->result.u.var).tmp_var;
26250
compare_function(result,
26251
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
26252
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
26253
ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
26255
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26256
ZEND_VM_NEXT_OPCODE();
26259
static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26261
zend_op *opline = EX(opline);
26262
zend_free_op free_op2;
26263
zval *result = &EX_T(opline->result.u.var).tmp_var;
26265
compare_function(result,
26266
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
26267
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
26268
ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
26270
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26271
ZEND_VM_NEXT_OPCODE();
26274
static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26276
zend_op *opline = EX(opline);
26277
zend_free_op free_op2;
26279
bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
26280
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
26281
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
26283
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26284
ZEND_VM_NEXT_OPCODE();
26287
static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26289
zend_op *opline = EX(opline);
26290
zend_free_op free_op2;
26292
bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
26293
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
26294
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
26296
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26297
ZEND_VM_NEXT_OPCODE();
26300
static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26302
zend_op *opline = EX(opline);
26303
zend_free_op free_op2;
26305
bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
26306
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
26307
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
26309
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26310
ZEND_VM_NEXT_OPCODE();
26313
static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26315
zend_op *opline = EX(opline);
26316
zend_free_op free_op2;
26318
boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
26319
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
26320
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
26322
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26323
ZEND_VM_NEXT_OPCODE();
26326
static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
26328
zend_op *opline = EX(opline);
26329
zend_op *op_data = opline+1;
26330
zend_free_op free_op2, free_op_data1;
26331
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
26333
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
26334
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
26335
znode *result = &opline->result;
26336
int have_get_ptr = 0;
26338
if (IS_CV == IS_VAR && !object_ptr) {
26339
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
26342
EX_T(result->u.var).var.ptr_ptr = NULL;
26343
make_real_object(object_ptr TSRMLS_CC);
26344
object = *object_ptr;
26346
if (Z_TYPE_P(object) != IS_OBJECT) {
26347
zend_error(E_WARNING, "Attempt to assign property of non-object");
26348
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26349
FREE_OP(free_op_data1);
26351
if (!RETURN_VALUE_UNUSED(result)) {
26352
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
26353
EX_T(result->u.var).var.ptr_ptr = NULL;
26354
PZVAL_LOCK(EG(uninitialized_zval_ptr));
26357
/* here we are sure we are dealing with an object */
26359
MAKE_REAL_ZVAL_PTR(property);
26362
/* here property is a string */
26363
if (opline->extended_value == ZEND_ASSIGN_OBJ
26364
&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
26365
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
26366
if (zptr != NULL) { /* NULL means no success in getting PTR */
26367
SEPARATE_ZVAL_IF_NOT_REF(zptr);
26370
binary_op(*zptr, *zptr, value TSRMLS_CC);
26371
if (!RETURN_VALUE_UNUSED(result)) {
26372
EX_T(result->u.var).var.ptr = *zptr;
26373
EX_T(result->u.var).var.ptr_ptr = NULL;
26379
if (!have_get_ptr) {
26382
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
26383
if (Z_OBJ_HT_P(object)->read_property) {
26384
z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
26386
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
26387
if (Z_OBJ_HT_P(object)->read_dimension) {
26388
z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
26392
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
26393
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
26395
if (Z_REFCOUNT_P(z) == 0) {
26396
GC_REMOVE_ZVAL_FROM_BUFFER(z);
26403
SEPARATE_ZVAL_IF_NOT_REF(&z);
26404
binary_op(z, z, value TSRMLS_CC);
26405
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
26406
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
26407
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
26408
Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
26410
if (!RETURN_VALUE_UNUSED(result)) {
26411
EX_T(result->u.var).var.ptr = z;
26412
EX_T(result->u.var).var.ptr_ptr = NULL;
26417
zend_error(E_WARNING, "Attempt to assign property of non-object");
26418
if (!RETURN_VALUE_UNUSED(result)) {
26419
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
26420
EX_T(result->u.var).var.ptr_ptr = NULL;
26421
PZVAL_LOCK(EG(uninitialized_zval_ptr));
26427
zval_ptr_dtor(&property);
26429
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26431
FREE_OP(free_op_data1);
26434
/* assign_obj has two opcodes! */
26435
ZEND_VM_INC_OPCODE();
26436
ZEND_VM_NEXT_OPCODE();
26439
static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
26441
zend_op *opline = EX(opline);
26442
zend_free_op free_op2, free_op_data2, free_op_data1;
26446
switch (opline->extended_value) {
26447
case ZEND_ASSIGN_OBJ:
26448
return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26450
case ZEND_ASSIGN_DIM: {
26451
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
26453
if (IS_CV == IS_VAR && !container) {
26454
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
26455
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
26456
if (IS_CV == IS_VAR && !0) {
26457
Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
26459
return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26461
zend_op *op_data = opline+1;
26462
zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
26464
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), container, dim, 0, BP_VAR_RW TSRMLS_CC);
26465
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
26466
var_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
26467
ZEND_VM_INC_OPCODE();
26472
value = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
26473
var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
26479
zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
26482
if (*var_ptr == EG(error_zval_ptr)) {
26483
if (!RETURN_VALUE_UNUSED(&opline->result)) {
26484
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
26485
PZVAL_LOCK(EG(uninitialized_zval_ptr));
26487
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26489
ZEND_VM_NEXT_OPCODE();
26492
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
26494
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
26495
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
26497
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
26498
Z_ADDREF_P(objval);
26499
binary_op(objval, objval, value TSRMLS_CC);
26500
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
26501
zval_ptr_dtor(&objval);
26503
binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
26506
if (!RETURN_VALUE_UNUSED(&opline->result)) {
26507
AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
26508
PZVAL_LOCK(*var_ptr);
26510
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26512
if (opline->extended_value == ZEND_ASSIGN_DIM) {
26513
FREE_OP(free_op_data1);
26514
FREE_OP_VAR_PTR(free_op_data2);
26517
ZEND_VM_NEXT_OPCODE();
26520
static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26522
return zend_binary_assign_op_helper_SPEC_CV_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26525
static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26527
return zend_binary_assign_op_helper_SPEC_CV_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26530
static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26532
return zend_binary_assign_op_helper_SPEC_CV_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26535
static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26537
return zend_binary_assign_op_helper_SPEC_CV_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26540
static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26542
return zend_binary_assign_op_helper_SPEC_CV_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26545
static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26547
return zend_binary_assign_op_helper_SPEC_CV_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26550
static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26552
return zend_binary_assign_op_helper_SPEC_CV_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26555
static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26557
return zend_binary_assign_op_helper_SPEC_CV_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26560
static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26562
return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26565
static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26567
return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26570
static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26572
return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26575
static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
26577
zend_op *opline = EX(opline);
26578
zend_free_op free_op2;
26579
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
26581
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
26582
zval **retval = &EX_T(opline->result.u.var).var.ptr;
26583
int have_get_ptr = 0;
26585
if (IS_CV == IS_VAR && !object_ptr) {
26586
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
26589
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
26590
object = *object_ptr;
26592
if (Z_TYPE_P(object) != IS_OBJECT) {
26593
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
26594
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26595
if (!RETURN_VALUE_UNUSED(&opline->result)) {
26596
*retval = EG(uninitialized_zval_ptr);
26597
PZVAL_LOCK(*retval);
26600
ZEND_VM_NEXT_OPCODE();
26603
/* here we are sure we are dealing with an object */
26606
MAKE_REAL_ZVAL_PTR(property);
26609
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
26610
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
26611
if (zptr != NULL) { /* NULL means no success in getting PTR */
26612
SEPARATE_ZVAL_IF_NOT_REF(zptr);
26616
if (!RETURN_VALUE_UNUSED(&opline->result)) {
26618
PZVAL_LOCK(*retval);
26623
if (!have_get_ptr) {
26624
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
26625
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
26627
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
26628
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
26630
if (Z_REFCOUNT_P(z) == 0) {
26631
GC_REMOVE_ZVAL_FROM_BUFFER(z);
26638
SEPARATE_ZVAL_IF_NOT_REF(&z);
26641
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
26642
SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
26645
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
26646
if (!RETURN_VALUE_UNUSED(&opline->result)) {
26647
*retval = EG(uninitialized_zval_ptr);
26648
PZVAL_LOCK(*retval);
26654
zval_ptr_dtor(&property);
26656
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26659
ZEND_VM_NEXT_OPCODE();
26662
static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26664
return zend_pre_incdec_property_helper_SPEC_CV_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26667
static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26669
return zend_pre_incdec_property_helper_SPEC_CV_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26672
static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
26674
zend_op *opline = EX(opline);
26675
zend_free_op free_op2;
26676
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
26678
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
26679
zval *retval = &EX_T(opline->result.u.var).tmp_var;
26680
int have_get_ptr = 0;
26682
if (IS_CV == IS_VAR && !object_ptr) {
26683
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
26686
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
26687
object = *object_ptr;
26689
if (Z_TYPE_P(object) != IS_OBJECT) {
26690
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
26691
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26692
*retval = *EG(uninitialized_zval_ptr);
26694
ZEND_VM_NEXT_OPCODE();
26697
/* here we are sure we are dealing with an object */
26700
MAKE_REAL_ZVAL_PTR(property);
26703
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
26704
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
26705
if (zptr != NULL) { /* NULL means no success in getting PTR */
26707
SEPARATE_ZVAL_IF_NOT_REF(zptr);
26710
zendi_zval_copy_ctor(*retval);
26717
if (!have_get_ptr) {
26718
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
26719
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
26722
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
26723
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
26725
if (Z_REFCOUNT_P(z) == 0) {
26726
GC_REMOVE_ZVAL_FROM_BUFFER(z);
26733
zendi_zval_copy_ctor(*retval);
26734
ALLOC_ZVAL(z_copy);
26736
zendi_zval_copy_ctor(*z_copy);
26737
INIT_PZVAL(z_copy);
26740
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
26741
zval_ptr_dtor(&z_copy);
26744
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
26745
*retval = *EG(uninitialized_zval_ptr);
26750
zval_ptr_dtor(&property);
26752
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26755
ZEND_VM_NEXT_OPCODE();
26758
static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26760
return zend_post_incdec_property_helper_SPEC_CV_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26763
static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26765
return zend_post_incdec_property_helper_SPEC_CV_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26768
static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26770
zend_op *opline = EX(opline);
26771
zend_free_op free_op2;
26772
zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
26775
if (opline->extended_value == ZEND_FETCH_ADD_LOCK &&
26777
EX_T(opline->op1.u.var).var.ptr_ptr) {
26778
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
26780
container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
26781
if (IS_CV == IS_VAR && !container) {
26782
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
26784
zend_fetch_dimension_address_read(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_R TSRMLS_CC);
26785
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26787
ZEND_VM_NEXT_OPCODE();
26790
static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26792
zend_op *opline = EX(opline);
26793
zend_free_op free_op1, free_op2;
26794
zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
26795
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
26797
if (IS_CV == IS_VAR && !container) {
26798
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
26800
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_W TSRMLS_CC);
26801
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26802
if (IS_CV == IS_VAR && 0 &&
26803
READY_TO_DESTROY(free_op1.var)) {
26804
AI_USE_PTR(EX_T(opline->result.u.var).var);
26805
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
26806
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
26807
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
26811
/* We are going to assign the result by reference */
26812
if (opline->extended_value) {
26813
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
26814
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
26815
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
26818
ZEND_VM_NEXT_OPCODE();
26821
static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26823
zend_op *opline = EX(opline);
26824
zend_free_op free_op1, free_op2;
26825
zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
26826
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
26828
if (IS_CV == IS_VAR && !container) {
26829
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
26831
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_RW TSRMLS_CC);
26832
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26833
if (IS_CV == IS_VAR && 0 &&
26834
READY_TO_DESTROY(free_op1.var)) {
26835
AI_USE_PTR(EX_T(opline->result.u.var).var);
26836
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
26837
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
26838
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
26842
ZEND_VM_NEXT_OPCODE();
26845
static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26847
zend_op *opline = EX(opline);
26848
zend_free_op free_op2;
26849
zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
26850
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
26852
if (IS_CV == IS_VAR && !container) {
26853
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
26855
zend_fetch_dimension_address_read(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_IS TSRMLS_CC);
26856
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26858
ZEND_VM_NEXT_OPCODE();
26861
static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26863
zend_op *opline = EX(opline);
26864
zend_free_op free_op1, free_op2;
26865
zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
26868
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
26869
container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
26870
if (IS_CV == IS_VAR && !container) {
26871
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
26873
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_W TSRMLS_CC);
26874
if (IS_CV == IS_VAR && 0 &&
26875
READY_TO_DESTROY(free_op1.var)) {
26876
AI_USE_PTR(EX_T(opline->result.u.var).var);
26877
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
26878
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
26879
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
26883
if (IS_VAR == IS_UNUSED) {
26884
zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
26886
container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
26887
if (IS_CV == IS_VAR && !container) {
26888
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
26890
zend_fetch_dimension_address_read(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_R TSRMLS_CC);
26892
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26894
ZEND_VM_NEXT_OPCODE();
26897
static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26899
zend_op *opline = EX(opline);
26900
zend_free_op free_op1, free_op2;
26901
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
26902
zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
26904
/* Not needed in DIM_UNSET
26905
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
26906
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
26909
if (IS_CV == IS_CV) {
26910
if (container != &EG(uninitialized_zval_ptr)) {
26911
SEPARATE_ZVAL_IF_NOT_REF(container);
26914
if (IS_CV == IS_VAR && !container) {
26915
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
26917
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_UNSET TSRMLS_CC);
26918
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26919
if (IS_CV == IS_VAR && 0 &&
26920
READY_TO_DESTROY(free_op1.var)) {
26921
AI_USE_PTR(EX_T(opline->result.u.var).var);
26922
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
26923
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
26924
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
26928
if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
26929
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
26931
zend_free_op free_res;
26933
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
26934
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
26935
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
26937
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
26938
FREE_OP_VAR_PTR(free_res);
26940
ZEND_VM_NEXT_OPCODE();
26943
static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
26945
zend_op *opline = EX(opline);
26947
zval *container = _get_zval_ptr_cv(&opline->op1, EX(Ts), type TSRMLS_CC);
26948
zend_free_op free_op2;
26949
zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
26951
if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
26952
if (type != BP_VAR_IS) {
26953
zend_error(E_NOTICE, "Trying to get property of non-object");
26955
if (!RETURN_VALUE_UNUSED(&opline->result)) {
26956
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
26957
PZVAL_LOCK(EG(uninitialized_zval_ptr));
26959
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26964
MAKE_REAL_ZVAL_PTR(offset);
26967
/* here we are sure we are dealing with an object */
26968
retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
26970
if (RETURN_VALUE_UNUSED(&opline->result)) {
26971
if (Z_REFCOUNT_P(retval) == 0) {
26972
GC_REMOVE_ZVAL_FROM_BUFFER(retval);
26977
AI_SET_PTR(EX_T(opline->result.u.var).var, retval);
26978
PZVAL_LOCK(retval);
26982
zval_ptr_dtor(&offset);
26984
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
26988
ZEND_VM_NEXT_OPCODE();
26991
static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26993
return zend_fetch_property_address_read_helper_SPEC_CV_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26996
static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26998
zend_op *opline = EX(opline);
26999
zend_free_op free_op1, free_op2;
27000
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
27003
if (IS_CV == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
27004
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
27005
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
27009
MAKE_REAL_ZVAL_PTR(property);
27011
container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
27012
if (IS_CV == IS_VAR && !container) {
27013
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
27015
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
27017
zval_ptr_dtor(&property);
27019
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27021
if (IS_CV == IS_VAR && 0 &&
27022
READY_TO_DESTROY(free_op1.var)) {
27023
AI_USE_PTR(EX_T(opline->result.u.var).var);
27024
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
27025
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
27026
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
27030
/* We are going to assign the result by reference */
27031
if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
27032
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
27033
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
27034
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
27037
ZEND_VM_NEXT_OPCODE();
27040
static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27042
zend_op *opline = EX(opline);
27043
zend_free_op free_op1, free_op2;
27044
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
27045
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
27048
MAKE_REAL_ZVAL_PTR(property);
27050
if (IS_CV == IS_VAR && !container) {
27051
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
27053
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_RW TSRMLS_CC);
27055
zval_ptr_dtor(&property);
27057
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27059
if (IS_CV == IS_VAR && 0 &&
27060
READY_TO_DESTROY(free_op1.var)) {
27061
AI_USE_PTR(EX_T(opline->result.u.var).var);
27062
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
27063
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
27064
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
27068
ZEND_VM_NEXT_OPCODE();
27071
static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27073
return zend_fetch_property_address_read_helper_SPEC_CV_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27076
static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27078
zend_op *opline = EX(opline);
27080
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
27081
/* Behave like FETCH_OBJ_W */
27082
zend_free_op free_op1, free_op2;
27083
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
27084
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
27087
MAKE_REAL_ZVAL_PTR(property);
27089
if (IS_CV == IS_VAR && !container) {
27090
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
27092
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
27094
zval_ptr_dtor(&property);
27096
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27098
if (IS_CV == IS_VAR && 0 &&
27099
READY_TO_DESTROY(free_op1.var)) {
27100
AI_USE_PTR(EX_T(opline->result.u.var).var);
27101
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
27102
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
27103
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
27107
ZEND_VM_NEXT_OPCODE();
27109
return zend_fetch_property_address_read_helper_SPEC_CV_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27113
static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27115
zend_op *opline = EX(opline);
27116
zend_free_op free_op1, free_op2, free_res;
27117
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
27118
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
27120
if (IS_CV == IS_CV) {
27121
if (container != &EG(uninitialized_zval_ptr)) {
27122
SEPARATE_ZVAL_IF_NOT_REF(container);
27126
MAKE_REAL_ZVAL_PTR(property);
27128
if (IS_CV == IS_VAR && !container) {
27129
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
27131
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
27133
zval_ptr_dtor(&property);
27135
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27137
if (IS_CV == IS_VAR && 0 &&
27138
READY_TO_DESTROY(free_op1.var)) {
27139
AI_USE_PTR(EX_T(opline->result.u.var).var);
27140
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
27141
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
27142
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
27146
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
27147
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
27148
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
27150
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
27151
FREE_OP_VAR_PTR(free_res);
27152
ZEND_VM_NEXT_OPCODE();
27155
static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27157
zend_op *opline = EX(opline);
27158
zend_op *op_data = opline+1;
27159
zend_free_op free_op2;
27160
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
27161
zval *property_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
27164
MAKE_REAL_ZVAL_PTR(property_name);
27166
if (IS_CV == IS_VAR && !object_ptr) {
27167
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
27169
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
27171
zval_ptr_dtor(&property_name);
27173
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27176
/* assign_obj has two opcodes! */
27177
ZEND_VM_INC_OPCODE();
27178
ZEND_VM_NEXT_OPCODE();
27181
static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27183
zend_op *opline = EX(opline);
27184
zend_op *op_data = opline+1;
27186
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
27188
if (IS_CV == IS_VAR && !object_ptr) {
27189
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
27191
if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
27192
zend_free_op free_op2;
27193
zval *property_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
27196
MAKE_REAL_ZVAL_PTR(property_name);
27198
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
27200
zval_ptr_dtor(&property_name);
27202
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27205
zend_free_op free_op2, free_op_data1, free_op_data2;
27207
zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
27208
zval **variable_ptr_ptr;
27210
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
27211
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27213
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
27214
variable_ptr_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
27215
if (!variable_ptr_ptr) {
27216
if (zend_assign_to_string_offset(&EX_T(op_data->op2.u.var), value, op_data->op1.op_type TSRMLS_CC)) {
27217
if (!RETURN_VALUE_UNUSED(&opline->result)) {
27218
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
27219
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
27220
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
27221
ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(op_data->op2.u.var).str_offset.str)+EX_T(op_data->op2.u.var).str_offset.offset, 1, 1);
27223
} else if (!RETURN_VALUE_UNUSED(&opline->result)) {
27224
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
27225
PZVAL_LOCK(EG(uninitialized_zval_ptr));
27228
value = zend_assign_to_variable(variable_ptr_ptr, value, IS_TMP_FREE(free_op_data1) TSRMLS_CC);
27229
if (!RETURN_VALUE_UNUSED(&opline->result)) {
27230
AI_SET_PTR(EX_T(opline->result.u.var).var, value);
27234
FREE_OP_VAR_PTR(free_op_data2);
27235
FREE_OP_IF_VAR(free_op_data1);
27238
/* assign_dim has two opcodes! */
27239
ZEND_VM_INC_OPCODE();
27240
ZEND_VM_NEXT_OPCODE();
27243
static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27245
zend_op *opline = EX(opline);
27246
zend_free_op free_op2;
27247
zval *value = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
27248
zval **variable_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
27250
if (IS_CV == IS_VAR && !variable_ptr_ptr) {
27251
if (zend_assign_to_string_offset(&EX_T(opline->op1.u.var), value, IS_VAR TSRMLS_CC)) {
27252
if (!RETURN_VALUE_UNUSED(&opline->result)) {
27253
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
27254
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
27255
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
27256
ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(opline->op1.u.var).str_offset.str)+EX_T(opline->op1.u.var).str_offset.offset, 1, 1);
27258
} else if (!RETURN_VALUE_UNUSED(&opline->result)) {
27259
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
27260
PZVAL_LOCK(EG(uninitialized_zval_ptr));
27263
value = zend_assign_to_variable(variable_ptr_ptr, value, 0 TSRMLS_CC);
27264
if (!RETURN_VALUE_UNUSED(&opline->result)) {
27265
AI_SET_PTR(EX_T(opline->result.u.var).var, value);
27270
/* zend_assign_to_variable() always takes care of op2, never free it! */
27271
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27273
ZEND_VM_NEXT_OPCODE();
27276
static int ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27278
zend_op *opline = EX(opline);
27279
zend_free_op free_op2;
27280
zval **variable_ptr_ptr;
27281
zval **value_ptr_ptr = _get_zval_ptr_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
27283
if (IS_VAR == IS_VAR &&
27285
!Z_ISREF_PP(value_ptr_ptr) &&
27286
opline->extended_value == ZEND_RETURNS_FUNCTION &&
27287
!EX_T(opline->op2.u.var).var.fcall_returned_reference) {
27288
if (free_op2.var == NULL) {
27289
PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
27291
zend_error(E_STRICT, "Only variables should be assigned by reference");
27292
if (UNEXPECTED(EG(exception) != NULL)) {
27293
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27294
ZEND_VM_NEXT_OPCODE();
27296
return ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27297
} else if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
27298
PZVAL_LOCK(*value_ptr_ptr);
27300
if (IS_CV == IS_VAR && EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
27301
zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object");
27304
variable_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
27305
if ((IS_VAR == IS_VAR && !value_ptr_ptr) ||
27306
(IS_CV == IS_VAR && !variable_ptr_ptr)) {
27307
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
27309
zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
27311
if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
27312
Z_DELREF_PP(variable_ptr_ptr);
27315
if (!RETURN_VALUE_UNUSED(&opline->result)) {
27316
AI_SET_PTR(EX_T(opline->result.u.var).var, *variable_ptr_ptr);
27317
PZVAL_LOCK(*variable_ptr_ptr);
27320
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27322
ZEND_VM_NEXT_OPCODE();
27325
static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27327
zend_op *opline = EX(opline);
27328
zval *function_name;
27329
char *function_name_strval;
27330
int function_name_strlen;
27331
zend_free_op free_op2;
27333
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
27335
function_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
27337
if (Z_TYPE_P(function_name)!=IS_STRING) {
27338
zend_error_noreturn(E_ERROR, "Method name must be a string");
27341
function_name_strval = Z_STRVAL_P(function_name);
27342
function_name_strlen = Z_STRLEN_P(function_name);
27344
EX(object) = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
27346
if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
27347
if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
27348
zend_error_noreturn(E_ERROR, "Object does not support method calls");
27351
/* First, locate the function. */
27352
EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
27354
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
27357
EX(called_scope) = Z_OBJCE_P(EX(object));
27359
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
27362
if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) {
27365
if (!PZVAL_IS_REF(EX(object))) {
27366
Z_ADDREF_P(EX(object)); /* For $this pointer */
27369
ALLOC_ZVAL(this_ptr);
27370
INIT_PZVAL_COPY(this_ptr, EX(object));
27371
zval_copy_ctor(this_ptr);
27372
EX(object) = this_ptr;
27376
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27378
ZEND_VM_NEXT_OPCODE();
27381
static int ZEND_FASTCALL ZEND_CASE_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27383
zend_op *opline = EX(opline);
27384
int switch_expr_is_overloaded=0;
27385
zend_free_op free_op2;
27387
if (IS_CV==IS_VAR) {
27388
if (EX_T(opline->op1.u.var).var.ptr_ptr) {
27389
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
27391
switch_expr_is_overloaded = 1;
27392
Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
27395
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
27396
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
27397
_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
27399
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27400
if (switch_expr_is_overloaded) {
27401
/* We only free op1 if this is a string offset,
27402
* Since if it is a TMP_VAR, it'll be reused by
27403
* other CASE opcodes (whereas string offsets
27404
* are allocated at each get_zval_ptr())
27407
EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
27408
EX_T(opline->op1.u.var).var.ptr = NULL;
27410
ZEND_VM_NEXT_OPCODE();
27413
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27415
zend_op *opline = EX(opline);
27416
zend_free_op free_op2;
27417
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
27419
zval *offset=_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
27421
#if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
27422
zval **expr_ptr_ptr = NULL;
27424
if (opline->extended_value) {
27425
expr_ptr_ptr=_get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
27426
expr_ptr = *expr_ptr_ptr;
27428
expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
27431
expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
27434
if (0) { /* temporary variable */
27437
ALLOC_ZVAL(new_expr);
27438
INIT_PZVAL_COPY(new_expr, expr_ptr);
27439
expr_ptr = new_expr;
27441
#if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
27442
if (opline->extended_value) {
27443
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
27444
expr_ptr = *expr_ptr_ptr;
27445
Z_ADDREF_P(expr_ptr);
27448
if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
27451
ALLOC_ZVAL(new_expr);
27452
INIT_PZVAL_COPY(new_expr, expr_ptr);
27453
expr_ptr = new_expr;
27454
zendi_zval_copy_ctor(*expr_ptr);
27456
Z_ADDREF_P(expr_ptr);
27460
switch (Z_TYPE_P(offset)) {
27462
zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
27466
zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
27469
zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
27472
zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
27475
zend_error(E_WARNING, "Illegal offset type");
27476
zval_ptr_dtor(&expr_ptr);
27480
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27482
zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
27484
if (opline->extended_value) {
27489
ZEND_VM_NEXT_OPCODE();
27492
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27494
zend_op *opline = EX(opline);
27496
array_init(&EX_T(opline->result.u.var).tmp_var);
27497
if (IS_CV == IS_UNUSED) {
27498
ZEND_VM_NEXT_OPCODE();
27499
#if 0 || IS_CV != IS_UNUSED
27501
return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27506
static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27508
zend_op *opline = EX(opline);
27509
zend_free_op free_op2;
27510
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
27511
zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
27513
if (IS_CV != IS_VAR || container) {
27514
if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
27515
SEPARATE_ZVAL_IF_NOT_REF(container);
27517
switch (Z_TYPE_PP(container)) {
27519
HashTable *ht = Z_ARRVAL_PP(container);
27521
switch (Z_TYPE_P(offset)) {
27523
zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
27528
zend_hash_index_del(ht, Z_LVAL_P(offset));
27531
if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
27532
Z_ADDREF_P(offset);
27534
if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
27535
ht == &EG(symbol_table)) {
27536
zend_execute_data *ex;
27537
ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
27539
for (ex = execute_data; ex; ex = ex->prev_execute_data) {
27540
if (ex->op_array && ex->symbol_table == ht) {
27543
for (i = 0; i < ex->op_array->last_var; i++) {
27544
if (ex->op_array->vars[i].hash_value == hash_value &&
27545
ex->op_array->vars[i].name_len == offset->value.str.len &&
27546
!memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
27554
if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
27555
zval_ptr_dtor(&offset);
27559
zend_hash_del(ht, "", sizeof(""));
27562
zend_error(E_WARNING, "Illegal offset type in unset");
27565
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27569
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
27570
zend_error_noreturn(E_ERROR, "Cannot use object as array");
27573
MAKE_REAL_ZVAL_PTR(offset);
27575
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
27577
zval_ptr_dtor(&offset);
27579
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27583
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
27584
ZEND_VM_CONTINUE(); /* bailed out before */
27586
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27590
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27593
ZEND_VM_NEXT_OPCODE();
27596
static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27598
zend_op *opline = EX(opline);
27599
zend_free_op free_op2;
27600
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
27601
zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
27603
if (IS_CV != IS_VAR || container) {
27604
if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
27605
SEPARATE_ZVAL_IF_NOT_REF(container);
27607
if (Z_TYPE_PP(container) == IS_OBJECT) {
27609
MAKE_REAL_ZVAL_PTR(offset);
27611
if (Z_OBJ_HT_P(*container)->unset_property) {
27612
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
27614
zend_error(E_NOTICE, "Trying to unset property of non-object");
27617
zval_ptr_dtor(&offset);
27619
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27622
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27625
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27628
ZEND_VM_NEXT_OPCODE();
27631
static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
27633
zend_op *opline = EX(opline);
27635
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
27636
zval **value = NULL;
27639
if (IS_CV != IS_VAR || container) {
27640
zend_free_op free_op2;
27641
zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
27643
if (Z_TYPE_PP(container) == IS_ARRAY) {
27647
ht = Z_ARRVAL_PP(container);
27649
switch (Z_TYPE_P(offset)) {
27651
if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
27658
if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
27663
if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
27668
if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
27673
zend_error(E_WARNING, "Illegal offset type in isset or empty");
27678
switch (opline->extended_value) {
27680
if (isset && Z_TYPE_PP(value) == IS_NULL) {
27687
if (!isset || !i_zend_is_true(*value)) {
27694
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27695
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
27697
MAKE_REAL_ZVAL_PTR(offset);
27700
if (Z_OBJ_HT_P(*container)->has_property) {
27701
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
27703
zend_error(E_NOTICE, "Trying to check property of non-object");
27707
if (Z_OBJ_HT_P(*container)->has_dimension) {
27708
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
27710
zend_error(E_NOTICE, "Trying to check element of non-array");
27715
zval_ptr_dtor(&offset);
27717
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27719
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
27722
if (Z_TYPE_P(offset) != IS_LONG) {
27724
zval_copy_ctor(&tmp);
27725
convert_to_long(&tmp);
27728
if (Z_TYPE_P(offset) == IS_LONG) {
27729
switch (opline->extended_value) {
27731
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
27736
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
27742
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27744
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
27748
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
27750
switch (opline->extended_value) {
27752
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
27755
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
27759
ZEND_VM_NEXT_OPCODE();
27762
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27764
return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27767
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27769
return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27772
static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
27774
zend_op *opline = EX(opline);
27775
zend_op *op_data = opline+1;
27776
zend_free_op free_op_data1;
27777
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
27779
zval *property = NULL;
27780
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
27781
znode *result = &opline->result;
27782
int have_get_ptr = 0;
27784
if (IS_CV == IS_VAR && !object_ptr) {
27785
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
27788
EX_T(result->u.var).var.ptr_ptr = NULL;
27789
make_real_object(object_ptr TSRMLS_CC);
27790
object = *object_ptr;
27792
if (Z_TYPE_P(object) != IS_OBJECT) {
27793
zend_error(E_WARNING, "Attempt to assign property of non-object");
27795
FREE_OP(free_op_data1);
27797
if (!RETURN_VALUE_UNUSED(result)) {
27798
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
27799
EX_T(result->u.var).var.ptr_ptr = NULL;
27800
PZVAL_LOCK(EG(uninitialized_zval_ptr));
27803
/* here we are sure we are dealing with an object */
27805
MAKE_REAL_ZVAL_PTR(property);
27808
/* here property is a string */
27809
if (opline->extended_value == ZEND_ASSIGN_OBJ
27810
&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
27811
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
27812
if (zptr != NULL) { /* NULL means no success in getting PTR */
27813
SEPARATE_ZVAL_IF_NOT_REF(zptr);
27816
binary_op(*zptr, *zptr, value TSRMLS_CC);
27817
if (!RETURN_VALUE_UNUSED(result)) {
27818
EX_T(result->u.var).var.ptr = *zptr;
27819
EX_T(result->u.var).var.ptr_ptr = NULL;
27825
if (!have_get_ptr) {
27828
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
27829
if (Z_OBJ_HT_P(object)->read_property) {
27830
z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
27832
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
27833
if (Z_OBJ_HT_P(object)->read_dimension) {
27834
z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
27838
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
27839
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
27841
if (Z_REFCOUNT_P(z) == 0) {
27842
GC_REMOVE_ZVAL_FROM_BUFFER(z);
27849
SEPARATE_ZVAL_IF_NOT_REF(&z);
27850
binary_op(z, z, value TSRMLS_CC);
27851
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
27852
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
27853
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
27854
Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
27856
if (!RETURN_VALUE_UNUSED(result)) {
27857
EX_T(result->u.var).var.ptr = z;
27858
EX_T(result->u.var).var.ptr_ptr = NULL;
27863
zend_error(E_WARNING, "Attempt to assign property of non-object");
27864
if (!RETURN_VALUE_UNUSED(result)) {
27865
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
27866
EX_T(result->u.var).var.ptr_ptr = NULL;
27867
PZVAL_LOCK(EG(uninitialized_zval_ptr));
27873
zval_ptr_dtor(&property);
27877
FREE_OP(free_op_data1);
27880
/* assign_obj has two opcodes! */
27881
ZEND_VM_INC_OPCODE();
27882
ZEND_VM_NEXT_OPCODE();
27885
static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
27887
zend_op *opline = EX(opline);
27888
zend_free_op free_op_data2, free_op_data1;
27892
switch (opline->extended_value) {
27893
case ZEND_ASSIGN_OBJ:
27894
return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27896
case ZEND_ASSIGN_DIM: {
27897
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
27899
if (IS_CV == IS_VAR && !container) {
27900
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
27901
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
27902
if (IS_CV == IS_VAR && !0) {
27903
Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
27905
return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27907
zend_op *op_data = opline+1;
27910
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), container, dim, 0, BP_VAR_RW TSRMLS_CC);
27911
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
27912
var_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
27913
ZEND_VM_INC_OPCODE();
27919
var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
27925
zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
27928
if (*var_ptr == EG(error_zval_ptr)) {
27929
if (!RETURN_VALUE_UNUSED(&opline->result)) {
27930
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
27931
PZVAL_LOCK(EG(uninitialized_zval_ptr));
27935
ZEND_VM_NEXT_OPCODE();
27938
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
27940
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
27941
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
27943
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
27944
Z_ADDREF_P(objval);
27945
binary_op(objval, objval, value TSRMLS_CC);
27946
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
27947
zval_ptr_dtor(&objval);
27949
binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
27952
if (!RETURN_VALUE_UNUSED(&opline->result)) {
27953
AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
27954
PZVAL_LOCK(*var_ptr);
27957
if (opline->extended_value == ZEND_ASSIGN_DIM) {
27958
FREE_OP(free_op_data1);
27959
FREE_OP_VAR_PTR(free_op_data2);
27962
ZEND_VM_NEXT_OPCODE();
27965
static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27967
return zend_binary_assign_op_helper_SPEC_CV_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27970
static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27972
return zend_binary_assign_op_helper_SPEC_CV_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27975
static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27977
return zend_binary_assign_op_helper_SPEC_CV_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27980
static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27982
return zend_binary_assign_op_helper_SPEC_CV_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27985
static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27987
return zend_binary_assign_op_helper_SPEC_CV_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27990
static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27992
return zend_binary_assign_op_helper_SPEC_CV_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27995
static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27997
return zend_binary_assign_op_helper_SPEC_CV_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28000
static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28002
return zend_binary_assign_op_helper_SPEC_CV_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28005
static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28007
return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28010
static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28012
return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28015
static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28017
return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28020
static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28022
zend_op *opline = EX(opline);
28023
zend_free_op free_op1;
28025
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
28027
if (IS_CV == IS_VAR && !container) {
28028
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
28030
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_W TSRMLS_CC);
28032
if (IS_CV == IS_VAR && 0 &&
28033
READY_TO_DESTROY(free_op1.var)) {
28034
AI_USE_PTR(EX_T(opline->result.u.var).var);
28035
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
28036
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
28037
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
28041
/* We are going to assign the result by reference */
28042
if (opline->extended_value) {
28043
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
28044
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
28045
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
28048
ZEND_VM_NEXT_OPCODE();
28051
static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28053
zend_op *opline = EX(opline);
28054
zend_free_op free_op1;
28056
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
28058
if (IS_CV == IS_VAR && !container) {
28059
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
28061
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_RW TSRMLS_CC);
28063
if (IS_CV == IS_VAR && 0 &&
28064
READY_TO_DESTROY(free_op1.var)) {
28065
AI_USE_PTR(EX_T(opline->result.u.var).var);
28066
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
28067
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
28068
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
28072
ZEND_VM_NEXT_OPCODE();
28075
static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28077
zend_op *opline = EX(opline);
28078
zend_free_op free_op1;
28082
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
28083
container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
28084
if (IS_CV == IS_VAR && !container) {
28085
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
28087
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_W TSRMLS_CC);
28088
if (IS_CV == IS_VAR && 0 &&
28089
READY_TO_DESTROY(free_op1.var)) {
28090
AI_USE_PTR(EX_T(opline->result.u.var).var);
28091
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
28092
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
28093
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
28097
if (IS_UNUSED == IS_UNUSED) {
28098
zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
28100
container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
28101
if (IS_CV == IS_VAR && !container) {
28102
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
28104
zend_fetch_dimension_address_read(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_R TSRMLS_CC);
28108
ZEND_VM_NEXT_OPCODE();
28111
static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28113
zend_op *opline = EX(opline);
28114
zend_op *op_data = opline+1;
28116
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
28118
if (IS_CV == IS_VAR && !object_ptr) {
28119
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
28121
if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
28123
zval *property_name = NULL;
28126
MAKE_REAL_ZVAL_PTR(property_name);
28128
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
28130
zval_ptr_dtor(&property_name);
28135
zend_free_op free_op_data1, free_op_data2;
28138
zval **variable_ptr_ptr;
28140
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
28142
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
28143
variable_ptr_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
28144
if (!variable_ptr_ptr) {
28145
if (zend_assign_to_string_offset(&EX_T(op_data->op2.u.var), value, op_data->op1.op_type TSRMLS_CC)) {
28146
if (!RETURN_VALUE_UNUSED(&opline->result)) {
28147
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
28148
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
28149
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
28150
ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(op_data->op2.u.var).str_offset.str)+EX_T(op_data->op2.u.var).str_offset.offset, 1, 1);
28152
} else if (!RETURN_VALUE_UNUSED(&opline->result)) {
28153
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
28154
PZVAL_LOCK(EG(uninitialized_zval_ptr));
28157
value = zend_assign_to_variable(variable_ptr_ptr, value, IS_TMP_FREE(free_op_data1) TSRMLS_CC);
28158
if (!RETURN_VALUE_UNUSED(&opline->result)) {
28159
AI_SET_PTR(EX_T(opline->result.u.var).var, value);
28163
FREE_OP_VAR_PTR(free_op_data2);
28164
FREE_OP_IF_VAR(free_op_data1);
28167
/* assign_dim has two opcodes! */
28168
ZEND_VM_INC_OPCODE();
28169
ZEND_VM_NEXT_OPCODE();
28172
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28174
zend_op *opline = EX(opline);
28176
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
28180
#if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
28181
zval **expr_ptr_ptr = NULL;
28183
if (opline->extended_value) {
28184
expr_ptr_ptr=_get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
28185
expr_ptr = *expr_ptr_ptr;
28187
expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
28190
expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
28193
if (0) { /* temporary variable */
28196
ALLOC_ZVAL(new_expr);
28197
INIT_PZVAL_COPY(new_expr, expr_ptr);
28198
expr_ptr = new_expr;
28200
#if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
28201
if (opline->extended_value) {
28202
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
28203
expr_ptr = *expr_ptr_ptr;
28204
Z_ADDREF_P(expr_ptr);
28207
if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
28210
ALLOC_ZVAL(new_expr);
28211
INIT_PZVAL_COPY(new_expr, expr_ptr);
28212
expr_ptr = new_expr;
28213
zendi_zval_copy_ctor(*expr_ptr);
28215
Z_ADDREF_P(expr_ptr);
28219
switch (Z_TYPE_P(offset)) {
28221
zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
28225
zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
28228
zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
28231
zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
28234
zend_error(E_WARNING, "Illegal offset type");
28235
zval_ptr_dtor(&expr_ptr);
28241
zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
28243
if (opline->extended_value) {
28248
ZEND_VM_NEXT_OPCODE();
28251
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28253
zend_op *opline = EX(opline);
28255
array_init(&EX_T(opline->result.u.var).tmp_var);
28256
if (IS_CV == IS_UNUSED) {
28257
ZEND_VM_NEXT_OPCODE();
28258
#if 0 || IS_CV != IS_UNUSED
28260
return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28265
static int ZEND_FASTCALL ZEND_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28267
zend_op *opline = EX(opline);
28270
add_function(&EX_T(opline->result.u.var).tmp_var,
28271
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
28272
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
28275
ZEND_VM_NEXT_OPCODE();
28278
static int ZEND_FASTCALL ZEND_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28280
zend_op *opline = EX(opline);
28283
sub_function(&EX_T(opline->result.u.var).tmp_var,
28284
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
28285
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
28288
ZEND_VM_NEXT_OPCODE();
28291
static int ZEND_FASTCALL ZEND_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28293
zend_op *opline = EX(opline);
28296
mul_function(&EX_T(opline->result.u.var).tmp_var,
28297
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
28298
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
28301
ZEND_VM_NEXT_OPCODE();
28304
static int ZEND_FASTCALL ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28306
zend_op *opline = EX(opline);
28309
div_function(&EX_T(opline->result.u.var).tmp_var,
28310
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
28311
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
28314
ZEND_VM_NEXT_OPCODE();
28317
static int ZEND_FASTCALL ZEND_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28319
zend_op *opline = EX(opline);
28322
mod_function(&EX_T(opline->result.u.var).tmp_var,
28323
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
28324
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
28327
ZEND_VM_NEXT_OPCODE();
28330
static int ZEND_FASTCALL ZEND_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28332
zend_op *opline = EX(opline);
28335
shift_left_function(&EX_T(opline->result.u.var).tmp_var,
28336
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
28337
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
28340
ZEND_VM_NEXT_OPCODE();
28343
static int ZEND_FASTCALL ZEND_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28345
zend_op *opline = EX(opline);
28348
shift_right_function(&EX_T(opline->result.u.var).tmp_var,
28349
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
28350
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
28353
ZEND_VM_NEXT_OPCODE();
28356
static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28358
zend_op *opline = EX(opline);
28361
concat_function(&EX_T(opline->result.u.var).tmp_var,
28362
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
28363
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
28366
ZEND_VM_NEXT_OPCODE();
28369
static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28371
zend_op *opline = EX(opline);
28374
is_identical_function(&EX_T(opline->result.u.var).tmp_var,
28375
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
28376
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
28379
ZEND_VM_NEXT_OPCODE();
28382
static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28384
zend_op *opline = EX(opline);
28386
zval *result = &EX_T(opline->result.u.var).tmp_var;
28388
is_identical_function(result,
28389
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
28390
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
28391
Z_LVAL_P(result) = !Z_LVAL_P(result);
28394
ZEND_VM_NEXT_OPCODE();
28397
static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28399
zend_op *opline = EX(opline);
28401
zval *result = &EX_T(opline->result.u.var).tmp_var;
28403
compare_function(result,
28404
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
28405
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
28406
ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
28409
ZEND_VM_NEXT_OPCODE();
28412
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28414
zend_op *opline = EX(opline);
28416
zval *result = &EX_T(opline->result.u.var).tmp_var;
28418
compare_function(result,
28419
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
28420
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
28421
ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
28424
ZEND_VM_NEXT_OPCODE();
28427
static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28429
zend_op *opline = EX(opline);
28431
zval *result = &EX_T(opline->result.u.var).tmp_var;
28433
compare_function(result,
28434
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
28435
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
28436
ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
28439
ZEND_VM_NEXT_OPCODE();
28442
static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28444
zend_op *opline = EX(opline);
28446
zval *result = &EX_T(opline->result.u.var).tmp_var;
28448
compare_function(result,
28449
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
28450
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
28451
ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
28454
ZEND_VM_NEXT_OPCODE();
28457
static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28459
zend_op *opline = EX(opline);
28462
bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
28463
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
28464
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
28467
ZEND_VM_NEXT_OPCODE();
28470
static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28472
zend_op *opline = EX(opline);
28475
bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
28476
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
28477
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
28480
ZEND_VM_NEXT_OPCODE();
28483
static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28485
zend_op *opline = EX(opline);
28488
bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
28489
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
28490
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
28493
ZEND_VM_NEXT_OPCODE();
28496
static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28498
zend_op *opline = EX(opline);
28501
boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
28502
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
28503
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
28506
ZEND_VM_NEXT_OPCODE();
28509
static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
28511
zend_op *opline = EX(opline);
28512
zend_op *op_data = opline+1;
28513
zend_free_op free_op_data1;
28514
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
28516
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
28517
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
28518
znode *result = &opline->result;
28519
int have_get_ptr = 0;
28521
if (IS_CV == IS_VAR && !object_ptr) {
28522
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
28525
EX_T(result->u.var).var.ptr_ptr = NULL;
28526
make_real_object(object_ptr TSRMLS_CC);
28527
object = *object_ptr;
28529
if (Z_TYPE_P(object) != IS_OBJECT) {
28530
zend_error(E_WARNING, "Attempt to assign property of non-object");
28532
FREE_OP(free_op_data1);
28534
if (!RETURN_VALUE_UNUSED(result)) {
28535
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
28536
EX_T(result->u.var).var.ptr_ptr = NULL;
28537
PZVAL_LOCK(EG(uninitialized_zval_ptr));
28540
/* here we are sure we are dealing with an object */
28542
MAKE_REAL_ZVAL_PTR(property);
28545
/* here property is a string */
28546
if (opline->extended_value == ZEND_ASSIGN_OBJ
28547
&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
28548
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
28549
if (zptr != NULL) { /* NULL means no success in getting PTR */
28550
SEPARATE_ZVAL_IF_NOT_REF(zptr);
28553
binary_op(*zptr, *zptr, value TSRMLS_CC);
28554
if (!RETURN_VALUE_UNUSED(result)) {
28555
EX_T(result->u.var).var.ptr = *zptr;
28556
EX_T(result->u.var).var.ptr_ptr = NULL;
28562
if (!have_get_ptr) {
28565
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
28566
if (Z_OBJ_HT_P(object)->read_property) {
28567
z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
28569
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
28570
if (Z_OBJ_HT_P(object)->read_dimension) {
28571
z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
28575
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
28576
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
28578
if (Z_REFCOUNT_P(z) == 0) {
28579
GC_REMOVE_ZVAL_FROM_BUFFER(z);
28586
SEPARATE_ZVAL_IF_NOT_REF(&z);
28587
binary_op(z, z, value TSRMLS_CC);
28588
if (opline->extended_value == ZEND_ASSIGN_OBJ) {
28589
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
28590
} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
28591
Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
28593
if (!RETURN_VALUE_UNUSED(result)) {
28594
EX_T(result->u.var).var.ptr = z;
28595
EX_T(result->u.var).var.ptr_ptr = NULL;
28600
zend_error(E_WARNING, "Attempt to assign property of non-object");
28601
if (!RETURN_VALUE_UNUSED(result)) {
28602
EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
28603
EX_T(result->u.var).var.ptr_ptr = NULL;
28604
PZVAL_LOCK(EG(uninitialized_zval_ptr));
28610
zval_ptr_dtor(&property);
28614
FREE_OP(free_op_data1);
28617
/* assign_obj has two opcodes! */
28618
ZEND_VM_INC_OPCODE();
28619
ZEND_VM_NEXT_OPCODE();
28622
static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
28624
zend_op *opline = EX(opline);
28625
zend_free_op free_op_data2, free_op_data1;
28629
switch (opline->extended_value) {
28630
case ZEND_ASSIGN_OBJ:
28631
return zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28633
case ZEND_ASSIGN_DIM: {
28634
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
28636
if (IS_CV == IS_VAR && !container) {
28637
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
28638
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
28639
if (IS_CV == IS_VAR && !0) {
28640
Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
28642
return zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28644
zend_op *op_data = opline+1;
28645
zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
28647
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), container, dim, 0, BP_VAR_RW TSRMLS_CC);
28648
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
28649
var_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
28650
ZEND_VM_INC_OPCODE();
28655
value = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
28656
var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
28662
zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
28665
if (*var_ptr == EG(error_zval_ptr)) {
28666
if (!RETURN_VALUE_UNUSED(&opline->result)) {
28667
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
28668
PZVAL_LOCK(EG(uninitialized_zval_ptr));
28672
ZEND_VM_NEXT_OPCODE();
28675
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
28677
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
28678
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
28680
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
28681
Z_ADDREF_P(objval);
28682
binary_op(objval, objval, value TSRMLS_CC);
28683
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
28684
zval_ptr_dtor(&objval);
28686
binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
28689
if (!RETURN_VALUE_UNUSED(&opline->result)) {
28690
AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
28691
PZVAL_LOCK(*var_ptr);
28694
if (opline->extended_value == ZEND_ASSIGN_DIM) {
28695
FREE_OP(free_op_data1);
28696
FREE_OP_VAR_PTR(free_op_data2);
28699
ZEND_VM_NEXT_OPCODE();
28702
static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28704
return zend_binary_assign_op_helper_SPEC_CV_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28707
static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28709
return zend_binary_assign_op_helper_SPEC_CV_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28712
static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28714
return zend_binary_assign_op_helper_SPEC_CV_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28717
static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28719
return zend_binary_assign_op_helper_SPEC_CV_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28722
static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28724
return zend_binary_assign_op_helper_SPEC_CV_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28727
static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28729
return zend_binary_assign_op_helper_SPEC_CV_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28732
static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28734
return zend_binary_assign_op_helper_SPEC_CV_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28737
static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28739
return zend_binary_assign_op_helper_SPEC_CV_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28742
static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28744
return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28747
static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28749
return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28752
static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28754
return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28757
static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
28759
zend_op *opline = EX(opline);
28761
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
28763
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
28764
zval **retval = &EX_T(opline->result.u.var).var.ptr;
28765
int have_get_ptr = 0;
28767
if (IS_CV == IS_VAR && !object_ptr) {
28768
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
28771
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
28772
object = *object_ptr;
28774
if (Z_TYPE_P(object) != IS_OBJECT) {
28775
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
28777
if (!RETURN_VALUE_UNUSED(&opline->result)) {
28778
*retval = EG(uninitialized_zval_ptr);
28779
PZVAL_LOCK(*retval);
28782
ZEND_VM_NEXT_OPCODE();
28785
/* here we are sure we are dealing with an object */
28788
MAKE_REAL_ZVAL_PTR(property);
28791
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
28792
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
28793
if (zptr != NULL) { /* NULL means no success in getting PTR */
28794
SEPARATE_ZVAL_IF_NOT_REF(zptr);
28798
if (!RETURN_VALUE_UNUSED(&opline->result)) {
28800
PZVAL_LOCK(*retval);
28805
if (!have_get_ptr) {
28806
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
28807
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
28809
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
28810
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
28812
if (Z_REFCOUNT_P(z) == 0) {
28813
GC_REMOVE_ZVAL_FROM_BUFFER(z);
28820
SEPARATE_ZVAL_IF_NOT_REF(&z);
28823
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
28824
SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
28827
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
28828
if (!RETURN_VALUE_UNUSED(&opline->result)) {
28829
*retval = EG(uninitialized_zval_ptr);
28830
PZVAL_LOCK(*retval);
28836
zval_ptr_dtor(&property);
28841
ZEND_VM_NEXT_OPCODE();
28844
static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28846
return zend_pre_incdec_property_helper_SPEC_CV_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28849
static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28851
return zend_pre_incdec_property_helper_SPEC_CV_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28854
static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
28856
zend_op *opline = EX(opline);
28858
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
28860
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
28861
zval *retval = &EX_T(opline->result.u.var).tmp_var;
28862
int have_get_ptr = 0;
28864
if (IS_CV == IS_VAR && !object_ptr) {
28865
zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
28868
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
28869
object = *object_ptr;
28871
if (Z_TYPE_P(object) != IS_OBJECT) {
28872
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
28874
*retval = *EG(uninitialized_zval_ptr);
28876
ZEND_VM_NEXT_OPCODE();
28879
/* here we are sure we are dealing with an object */
28882
MAKE_REAL_ZVAL_PTR(property);
28885
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
28886
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
28887
if (zptr != NULL) { /* NULL means no success in getting PTR */
28889
SEPARATE_ZVAL_IF_NOT_REF(zptr);
28892
zendi_zval_copy_ctor(*retval);
28899
if (!have_get_ptr) {
28900
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
28901
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
28904
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
28905
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
28907
if (Z_REFCOUNT_P(z) == 0) {
28908
GC_REMOVE_ZVAL_FROM_BUFFER(z);
28915
zendi_zval_copy_ctor(*retval);
28916
ALLOC_ZVAL(z_copy);
28918
zendi_zval_copy_ctor(*z_copy);
28919
INIT_PZVAL(z_copy);
28922
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
28923
zval_ptr_dtor(&z_copy);
28926
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
28927
*retval = *EG(uninitialized_zval_ptr);
28932
zval_ptr_dtor(&property);
28937
ZEND_VM_NEXT_OPCODE();
28940
static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28942
return zend_post_incdec_property_helper_SPEC_CV_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28945
static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28947
return zend_post_incdec_property_helper_SPEC_CV_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28950
static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28952
zend_op *opline = EX(opline);
28954
zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
28957
if (opline->extended_value == ZEND_FETCH_ADD_LOCK &&
28959
EX_T(opline->op1.u.var).var.ptr_ptr) {
28960
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
28962
container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
28963
if (IS_CV == IS_VAR && !container) {
28964
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
28966
zend_fetch_dimension_address_read(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_R TSRMLS_CC);
28969
ZEND_VM_NEXT_OPCODE();
28972
static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28974
zend_op *opline = EX(opline);
28975
zend_free_op free_op1;
28976
zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
28977
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
28979
if (IS_CV == IS_VAR && !container) {
28980
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
28982
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_W TSRMLS_CC);
28984
if (IS_CV == IS_VAR && 0 &&
28985
READY_TO_DESTROY(free_op1.var)) {
28986
AI_USE_PTR(EX_T(opline->result.u.var).var);
28987
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
28988
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
28989
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
28993
/* We are going to assign the result by reference */
28994
if (opline->extended_value) {
28995
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
28996
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
28997
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
29000
ZEND_VM_NEXT_OPCODE();
29003
static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29005
zend_op *opline = EX(opline);
29006
zend_free_op free_op1;
29007
zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
29008
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
29010
if (IS_CV == IS_VAR && !container) {
29011
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
29013
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_RW TSRMLS_CC);
29015
if (IS_CV == IS_VAR && 0 &&
29016
READY_TO_DESTROY(free_op1.var)) {
29017
AI_USE_PTR(EX_T(opline->result.u.var).var);
29018
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
29019
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
29020
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
29024
ZEND_VM_NEXT_OPCODE();
29027
static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29029
zend_op *opline = EX(opline);
29031
zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
29032
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
29034
if (IS_CV == IS_VAR && !container) {
29035
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
29037
zend_fetch_dimension_address_read(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_IS TSRMLS_CC);
29040
ZEND_VM_NEXT_OPCODE();
29043
static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29045
zend_op *opline = EX(opline);
29046
zend_free_op free_op1;
29047
zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
29050
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
29051
container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
29052
if (IS_CV == IS_VAR && !container) {
29053
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
29055
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_W TSRMLS_CC);
29056
if (IS_CV == IS_VAR && 0 &&
29057
READY_TO_DESTROY(free_op1.var)) {
29058
AI_USE_PTR(EX_T(opline->result.u.var).var);
29059
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
29060
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
29061
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
29065
if (IS_CV == IS_UNUSED) {
29066
zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
29068
container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
29069
if (IS_CV == IS_VAR && !container) {
29070
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
29072
zend_fetch_dimension_address_read(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_R TSRMLS_CC);
29076
ZEND_VM_NEXT_OPCODE();
29079
static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29081
zend_op *opline = EX(opline);
29082
zend_free_op free_op1;
29083
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
29084
zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
29086
/* Not needed in DIM_UNSET
29087
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
29088
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
29091
if (IS_CV == IS_CV) {
29092
if (container != &EG(uninitialized_zval_ptr)) {
29093
SEPARATE_ZVAL_IF_NOT_REF(container);
29096
if (IS_CV == IS_VAR && !container) {
29097
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
29099
zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_UNSET TSRMLS_CC);
29101
if (IS_CV == IS_VAR && 0 &&
29102
READY_TO_DESTROY(free_op1.var)) {
29103
AI_USE_PTR(EX_T(opline->result.u.var).var);
29104
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
29105
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
29106
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
29110
if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
29111
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
29113
zend_free_op free_res;
29115
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
29116
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
29117
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
29119
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
29120
FREE_OP_VAR_PTR(free_res);
29122
ZEND_VM_NEXT_OPCODE();
29125
static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CV(int type, ZEND_OPCODE_HANDLER_ARGS)
29127
zend_op *opline = EX(opline);
29129
zval *container = _get_zval_ptr_cv(&opline->op1, EX(Ts), type TSRMLS_CC);
29131
zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
29133
if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
29134
if (type != BP_VAR_IS) {
29135
zend_error(E_NOTICE, "Trying to get property of non-object");
29137
if (!RETURN_VALUE_UNUSED(&opline->result)) {
29138
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
29139
PZVAL_LOCK(EG(uninitialized_zval_ptr));
29146
MAKE_REAL_ZVAL_PTR(offset);
29149
/* here we are sure we are dealing with an object */
29150
retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
29152
if (RETURN_VALUE_UNUSED(&opline->result)) {
29153
if (Z_REFCOUNT_P(retval) == 0) {
29154
GC_REMOVE_ZVAL_FROM_BUFFER(retval);
29159
AI_SET_PTR(EX_T(opline->result.u.var).var, retval);
29160
PZVAL_LOCK(retval);
29164
zval_ptr_dtor(&offset);
29170
ZEND_VM_NEXT_OPCODE();
29173
static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29175
return zend_fetch_property_address_read_helper_SPEC_CV_CV(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29178
static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29180
zend_op *opline = EX(opline);
29181
zend_free_op free_op1;
29182
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
29185
if (IS_CV == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
29186
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
29187
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
29191
MAKE_REAL_ZVAL_PTR(property);
29193
container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
29194
if (IS_CV == IS_VAR && !container) {
29195
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
29197
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
29199
zval_ptr_dtor(&property);
29203
if (IS_CV == IS_VAR && 0 &&
29204
READY_TO_DESTROY(free_op1.var)) {
29205
AI_USE_PTR(EX_T(opline->result.u.var).var);
29206
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
29207
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
29208
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
29212
/* We are going to assign the result by reference */
29213
if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
29214
Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
29215
SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
29216
Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
29219
ZEND_VM_NEXT_OPCODE();
29222
static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29224
zend_op *opline = EX(opline);
29225
zend_free_op free_op1;
29226
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
29227
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
29230
MAKE_REAL_ZVAL_PTR(property);
29232
if (IS_CV == IS_VAR && !container) {
29233
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
29235
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_RW TSRMLS_CC);
29237
zval_ptr_dtor(&property);
29241
if (IS_CV == IS_VAR && 0 &&
29242
READY_TO_DESTROY(free_op1.var)) {
29243
AI_USE_PTR(EX_T(opline->result.u.var).var);
29244
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
29245
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
29246
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
29250
ZEND_VM_NEXT_OPCODE();
29253
static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29255
return zend_fetch_property_address_read_helper_SPEC_CV_CV(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29258
static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29260
zend_op *opline = EX(opline);
29262
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
29263
/* Behave like FETCH_OBJ_W */
29264
zend_free_op free_op1;
29265
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
29266
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
29269
MAKE_REAL_ZVAL_PTR(property);
29271
if (IS_CV == IS_VAR && !container) {
29272
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
29274
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
29276
zval_ptr_dtor(&property);
29280
if (IS_CV == IS_VAR && 0 &&
29281
READY_TO_DESTROY(free_op1.var)) {
29282
AI_USE_PTR(EX_T(opline->result.u.var).var);
29283
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
29284
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
29285
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
29289
ZEND_VM_NEXT_OPCODE();
29291
return zend_fetch_property_address_read_helper_SPEC_CV_CV(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29295
static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29297
zend_op *opline = EX(opline);
29298
zend_free_op free_op1, free_res;
29299
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
29300
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
29302
if (IS_CV == IS_CV) {
29303
if (container != &EG(uninitialized_zval_ptr)) {
29304
SEPARATE_ZVAL_IF_NOT_REF(container);
29308
MAKE_REAL_ZVAL_PTR(property);
29310
if (IS_CV == IS_VAR && !container) {
29311
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
29313
zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
29315
zval_ptr_dtor(&property);
29319
if (IS_CV == IS_VAR && 0 &&
29320
READY_TO_DESTROY(free_op1.var)) {
29321
AI_USE_PTR(EX_T(opline->result.u.var).var);
29322
if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
29323
Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
29324
SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
29328
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
29329
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
29330
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
29332
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
29333
FREE_OP_VAR_PTR(free_res);
29334
ZEND_VM_NEXT_OPCODE();
29337
static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29339
zend_op *opline = EX(opline);
29340
zend_op *op_data = opline+1;
29342
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
29343
zval *property_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
29346
MAKE_REAL_ZVAL_PTR(property_name);
29348
if (IS_CV == IS_VAR && !object_ptr) {
29349
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
29351
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
29353
zval_ptr_dtor(&property_name);
29358
/* assign_obj has two opcodes! */
29359
ZEND_VM_INC_OPCODE();
29360
ZEND_VM_NEXT_OPCODE();
29363
static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29365
zend_op *opline = EX(opline);
29366
zend_op *op_data = opline+1;
29368
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
29370
if (IS_CV == IS_VAR && !object_ptr) {
29371
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
29373
if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
29375
zval *property_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
29378
MAKE_REAL_ZVAL_PTR(property_name);
29380
zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
29382
zval_ptr_dtor(&property_name);
29387
zend_free_op free_op_data1, free_op_data2;
29389
zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
29390
zval **variable_ptr_ptr;
29392
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
29394
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
29395
variable_ptr_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
29396
if (!variable_ptr_ptr) {
29397
if (zend_assign_to_string_offset(&EX_T(op_data->op2.u.var), value, op_data->op1.op_type TSRMLS_CC)) {
29398
if (!RETURN_VALUE_UNUSED(&opline->result)) {
29399
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
29400
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
29401
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
29402
ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(op_data->op2.u.var).str_offset.str)+EX_T(op_data->op2.u.var).str_offset.offset, 1, 1);
29404
} else if (!RETURN_VALUE_UNUSED(&opline->result)) {
29405
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
29406
PZVAL_LOCK(EG(uninitialized_zval_ptr));
29409
value = zend_assign_to_variable(variable_ptr_ptr, value, IS_TMP_FREE(free_op_data1) TSRMLS_CC);
29410
if (!RETURN_VALUE_UNUSED(&opline->result)) {
29411
AI_SET_PTR(EX_T(opline->result.u.var).var, value);
29415
FREE_OP_VAR_PTR(free_op_data2);
29416
FREE_OP_IF_VAR(free_op_data1);
29419
/* assign_dim has two opcodes! */
29420
ZEND_VM_INC_OPCODE();
29421
ZEND_VM_NEXT_OPCODE();
29424
static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29426
zend_op *opline = EX(opline);
29428
zval *value = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
29429
zval **variable_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
29431
if (IS_CV == IS_VAR && !variable_ptr_ptr) {
29432
if (zend_assign_to_string_offset(&EX_T(opline->op1.u.var), value, IS_CV TSRMLS_CC)) {
29433
if (!RETURN_VALUE_UNUSED(&opline->result)) {
29434
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
29435
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
29436
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
29437
ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(opline->op1.u.var).str_offset.str)+EX_T(opline->op1.u.var).str_offset.offset, 1, 1);
29439
} else if (!RETURN_VALUE_UNUSED(&opline->result)) {
29440
AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
29441
PZVAL_LOCK(EG(uninitialized_zval_ptr));
29444
value = zend_assign_to_variable(variable_ptr_ptr, value, 0 TSRMLS_CC);
29445
if (!RETURN_VALUE_UNUSED(&opline->result)) {
29446
AI_SET_PTR(EX_T(opline->result.u.var).var, value);
29451
/* zend_assign_to_variable() always takes care of op2, never free it! */
29453
ZEND_VM_NEXT_OPCODE();
29456
static int ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29458
zend_op *opline = EX(opline);
29459
zend_free_op free_op2;
29460
zval **variable_ptr_ptr;
29461
zval **value_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op2, EX(Ts), BP_VAR_W TSRMLS_CC);
29463
if (IS_CV == IS_VAR &&
29465
!Z_ISREF_PP(value_ptr_ptr) &&
29466
opline->extended_value == ZEND_RETURNS_FUNCTION &&
29467
!EX_T(opline->op2.u.var).var.fcall_returned_reference) {
29468
if (free_op2.var == NULL) {
29469
PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
29471
zend_error(E_STRICT, "Only variables should be assigned by reference");
29472
if (UNEXPECTED(EG(exception) != NULL)) {
29474
ZEND_VM_NEXT_OPCODE();
29476
return ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29477
} else if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
29478
PZVAL_LOCK(*value_ptr_ptr);
29480
if (IS_CV == IS_VAR && EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
29481
zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object");
29484
variable_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
29485
if ((IS_CV == IS_VAR && !value_ptr_ptr) ||
29486
(IS_CV == IS_VAR && !variable_ptr_ptr)) {
29487
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
29489
zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
29491
if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
29492
Z_DELREF_PP(variable_ptr_ptr);
29495
if (!RETURN_VALUE_UNUSED(&opline->result)) {
29496
AI_SET_PTR(EX_T(opline->result.u.var).var, *variable_ptr_ptr);
29497
PZVAL_LOCK(*variable_ptr_ptr);
29501
ZEND_VM_NEXT_OPCODE();
29504
static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29506
zend_op *opline = EX(opline);
29507
zval *function_name;
29508
char *function_name_strval;
29509
int function_name_strlen;
29512
zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
29514
function_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
29516
if (Z_TYPE_P(function_name)!=IS_STRING) {
29517
zend_error_noreturn(E_ERROR, "Method name must be a string");
29520
function_name_strval = Z_STRVAL_P(function_name);
29521
function_name_strlen = Z_STRLEN_P(function_name);
29523
EX(object) = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
29525
if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
29526
if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
29527
zend_error_noreturn(E_ERROR, "Object does not support method calls");
29530
/* First, locate the function. */
29531
EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
29533
zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
29536
EX(called_scope) = Z_OBJCE_P(EX(object));
29538
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
29541
if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) {
29544
if (!PZVAL_IS_REF(EX(object))) {
29545
Z_ADDREF_P(EX(object)); /* For $this pointer */
29548
ALLOC_ZVAL(this_ptr);
29549
INIT_PZVAL_COPY(this_ptr, EX(object));
29550
zval_copy_ctor(this_ptr);
29551
EX(object) = this_ptr;
29556
ZEND_VM_NEXT_OPCODE();
29559
static int ZEND_FASTCALL ZEND_CASE_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29561
zend_op *opline = EX(opline);
29562
int switch_expr_is_overloaded=0;
29565
if (IS_CV==IS_VAR) {
29566
if (EX_T(opline->op1.u.var).var.ptr_ptr) {
29567
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
29569
switch_expr_is_overloaded = 1;
29570
Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
29573
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
29574
_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
29575
_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
29577
if (switch_expr_is_overloaded) {
29578
/* We only free op1 if this is a string offset,
29579
* Since if it is a TMP_VAR, it'll be reused by
29580
* other CASE opcodes (whereas string offsets
29581
* are allocated at each get_zval_ptr())
29584
EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
29585
EX_T(opline->op1.u.var).var.ptr = NULL;
29587
ZEND_VM_NEXT_OPCODE();
29590
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29592
zend_op *opline = EX(opline);
29594
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
29596
zval *offset=_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
29598
#if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
29599
zval **expr_ptr_ptr = NULL;
29601
if (opline->extended_value) {
29602
expr_ptr_ptr=_get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
29603
expr_ptr = *expr_ptr_ptr;
29605
expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
29608
expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
29611
if (0) { /* temporary variable */
29614
ALLOC_ZVAL(new_expr);
29615
INIT_PZVAL_COPY(new_expr, expr_ptr);
29616
expr_ptr = new_expr;
29618
#if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
29619
if (opline->extended_value) {
29620
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
29621
expr_ptr = *expr_ptr_ptr;
29622
Z_ADDREF_P(expr_ptr);
29625
if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
29628
ALLOC_ZVAL(new_expr);
29629
INIT_PZVAL_COPY(new_expr, expr_ptr);
29630
expr_ptr = new_expr;
29631
zendi_zval_copy_ctor(*expr_ptr);
29633
Z_ADDREF_P(expr_ptr);
29637
switch (Z_TYPE_P(offset)) {
29639
zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
29643
zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
29646
zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
29649
zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
29652
zend_error(E_WARNING, "Illegal offset type");
29653
zval_ptr_dtor(&expr_ptr);
29659
zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
29661
if (opline->extended_value) {
29666
ZEND_VM_NEXT_OPCODE();
29669
static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29671
zend_op *opline = EX(opline);
29673
array_init(&EX_T(opline->result.u.var).tmp_var);
29674
if (IS_CV == IS_UNUSED) {
29675
ZEND_VM_NEXT_OPCODE();
29676
#if 0 || IS_CV != IS_UNUSED
29678
return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29683
static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29685
zend_op *opline = EX(opline);
29687
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
29688
zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
29690
if (IS_CV != IS_VAR || container) {
29691
if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
29692
SEPARATE_ZVAL_IF_NOT_REF(container);
29694
switch (Z_TYPE_PP(container)) {
29696
HashTable *ht = Z_ARRVAL_PP(container);
29698
switch (Z_TYPE_P(offset)) {
29700
zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
29705
zend_hash_index_del(ht, Z_LVAL_P(offset));
29708
if (IS_CV == IS_CV || IS_CV == IS_VAR) {
29709
Z_ADDREF_P(offset);
29711
if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
29712
ht == &EG(symbol_table)) {
29713
zend_execute_data *ex;
29714
ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
29716
for (ex = execute_data; ex; ex = ex->prev_execute_data) {
29717
if (ex->op_array && ex->symbol_table == ht) {
29720
for (i = 0; i < ex->op_array->last_var; i++) {
29721
if (ex->op_array->vars[i].hash_value == hash_value &&
29722
ex->op_array->vars[i].name_len == offset->value.str.len &&
29723
!memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
29731
if (IS_CV == IS_CV || IS_CV == IS_VAR) {
29732
zval_ptr_dtor(&offset);
29736
zend_hash_del(ht, "", sizeof(""));
29739
zend_error(E_WARNING, "Illegal offset type in unset");
29746
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
29747
zend_error_noreturn(E_ERROR, "Cannot use object as array");
29750
MAKE_REAL_ZVAL_PTR(offset);
29752
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
29754
zval_ptr_dtor(&offset);
29760
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
29761
ZEND_VM_CONTINUE(); /* bailed out before */
29770
ZEND_VM_NEXT_OPCODE();
29773
static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29775
zend_op *opline = EX(opline);
29777
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
29778
zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
29780
if (IS_CV != IS_VAR || container) {
29781
if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
29782
SEPARATE_ZVAL_IF_NOT_REF(container);
29784
if (Z_TYPE_PP(container) == IS_OBJECT) {
29786
MAKE_REAL_ZVAL_PTR(offset);
29788
if (Z_OBJ_HT_P(*container)->unset_property) {
29789
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
29791
zend_error(E_NOTICE, "Trying to unset property of non-object");
29794
zval_ptr_dtor(&offset);
29805
ZEND_VM_NEXT_OPCODE();
29808
static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
29810
zend_op *opline = EX(opline);
29812
zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
29813
zval **value = NULL;
29816
if (IS_CV != IS_VAR || container) {
29818
zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
29820
if (Z_TYPE_PP(container) == IS_ARRAY) {
29824
ht = Z_ARRVAL_PP(container);
29826
switch (Z_TYPE_P(offset)) {
29828
if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
29835
if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
29840
if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
29845
if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
29850
zend_error(E_WARNING, "Illegal offset type in isset or empty");
29855
switch (opline->extended_value) {
29857
if (isset && Z_TYPE_PP(value) == IS_NULL) {
29864
if (!isset || !i_zend_is_true(*value)) {
29872
} else if (Z_TYPE_PP(container) == IS_OBJECT) {
29874
MAKE_REAL_ZVAL_PTR(offset);
29877
if (Z_OBJ_HT_P(*container)->has_property) {
29878
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
29880
zend_error(E_NOTICE, "Trying to check property of non-object");
29884
if (Z_OBJ_HT_P(*container)->has_dimension) {
29885
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
29887
zend_error(E_NOTICE, "Trying to check element of non-array");
29892
zval_ptr_dtor(&offset);
29896
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
29899
if (Z_TYPE_P(offset) != IS_LONG) {
29901
zval_copy_ctor(&tmp);
29902
convert_to_long(&tmp);
29905
if (Z_TYPE_P(offset) == IS_LONG) {
29906
switch (opline->extended_value) {
29908
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
29913
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
29925
Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
29927
switch (opline->extended_value) {
29929
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
29932
Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
29936
ZEND_VM_NEXT_OPCODE();
29939
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29941
return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29944
static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29946
return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29949
static int ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29951
zend_error_noreturn(E_ERROR, "Invalid opcode %d/%d/%d.", EX(opline)->opcode, EX(opline)->op1.op_type, EX(opline)->op2.op_type);
29955
void zend_init_opcodes_handlers(void)
29957
static const opcode_handler_t labels[] = {
29958
ZEND_NOP_SPEC_HANDLER,
29959
ZEND_NOP_SPEC_HANDLER,
29960
ZEND_NOP_SPEC_HANDLER,
29961
ZEND_NOP_SPEC_HANDLER,
29962
ZEND_NOP_SPEC_HANDLER,
29963
ZEND_NOP_SPEC_HANDLER,
29964
ZEND_NOP_SPEC_HANDLER,
29965
ZEND_NOP_SPEC_HANDLER,
29966
ZEND_NOP_SPEC_HANDLER,
29967
ZEND_NOP_SPEC_HANDLER,
29968
ZEND_NOP_SPEC_HANDLER,
29969
ZEND_NOP_SPEC_HANDLER,
29970
ZEND_NOP_SPEC_HANDLER,
29971
ZEND_NOP_SPEC_HANDLER,
29972
ZEND_NOP_SPEC_HANDLER,
29973
ZEND_NOP_SPEC_HANDLER,
29974
ZEND_NOP_SPEC_HANDLER,
29975
ZEND_NOP_SPEC_HANDLER,
29976
ZEND_NOP_SPEC_HANDLER,
29977
ZEND_NOP_SPEC_HANDLER,
29978
ZEND_NOP_SPEC_HANDLER,
29979
ZEND_NOP_SPEC_HANDLER,
29980
ZEND_NOP_SPEC_HANDLER,
29981
ZEND_NOP_SPEC_HANDLER,
29982
ZEND_NOP_SPEC_HANDLER,
29983
ZEND_ADD_SPEC_CONST_CONST_HANDLER,
29984
ZEND_ADD_SPEC_CONST_TMP_HANDLER,
29985
ZEND_ADD_SPEC_CONST_VAR_HANDLER,
29987
ZEND_ADD_SPEC_CONST_CV_HANDLER,
29988
ZEND_ADD_SPEC_TMP_CONST_HANDLER,
29989
ZEND_ADD_SPEC_TMP_TMP_HANDLER,
29990
ZEND_ADD_SPEC_TMP_VAR_HANDLER,
29992
ZEND_ADD_SPEC_TMP_CV_HANDLER,
29993
ZEND_ADD_SPEC_VAR_CONST_HANDLER,
29994
ZEND_ADD_SPEC_VAR_TMP_HANDLER,
29995
ZEND_ADD_SPEC_VAR_VAR_HANDLER,
29997
ZEND_ADD_SPEC_VAR_CV_HANDLER,
30003
ZEND_ADD_SPEC_CV_CONST_HANDLER,
30004
ZEND_ADD_SPEC_CV_TMP_HANDLER,
30005
ZEND_ADD_SPEC_CV_VAR_HANDLER,
30007
ZEND_ADD_SPEC_CV_CV_HANDLER,
30008
ZEND_SUB_SPEC_CONST_CONST_HANDLER,
30009
ZEND_SUB_SPEC_CONST_TMP_HANDLER,
30010
ZEND_SUB_SPEC_CONST_VAR_HANDLER,
30012
ZEND_SUB_SPEC_CONST_CV_HANDLER,
30013
ZEND_SUB_SPEC_TMP_CONST_HANDLER,
30014
ZEND_SUB_SPEC_TMP_TMP_HANDLER,
30015
ZEND_SUB_SPEC_TMP_VAR_HANDLER,
30017
ZEND_SUB_SPEC_TMP_CV_HANDLER,
30018
ZEND_SUB_SPEC_VAR_CONST_HANDLER,
30019
ZEND_SUB_SPEC_VAR_TMP_HANDLER,
30020
ZEND_SUB_SPEC_VAR_VAR_HANDLER,
30022
ZEND_SUB_SPEC_VAR_CV_HANDLER,
30028
ZEND_SUB_SPEC_CV_CONST_HANDLER,
30029
ZEND_SUB_SPEC_CV_TMP_HANDLER,
30030
ZEND_SUB_SPEC_CV_VAR_HANDLER,
30032
ZEND_SUB_SPEC_CV_CV_HANDLER,
30033
ZEND_MUL_SPEC_CONST_CONST_HANDLER,
30034
ZEND_MUL_SPEC_CONST_TMP_HANDLER,
30035
ZEND_MUL_SPEC_CONST_VAR_HANDLER,
30037
ZEND_MUL_SPEC_CONST_CV_HANDLER,
30038
ZEND_MUL_SPEC_TMP_CONST_HANDLER,
30039
ZEND_MUL_SPEC_TMP_TMP_HANDLER,
30040
ZEND_MUL_SPEC_TMP_VAR_HANDLER,
30042
ZEND_MUL_SPEC_TMP_CV_HANDLER,
30043
ZEND_MUL_SPEC_VAR_CONST_HANDLER,
30044
ZEND_MUL_SPEC_VAR_TMP_HANDLER,
30045
ZEND_MUL_SPEC_VAR_VAR_HANDLER,
30047
ZEND_MUL_SPEC_VAR_CV_HANDLER,
30053
ZEND_MUL_SPEC_CV_CONST_HANDLER,
30054
ZEND_MUL_SPEC_CV_TMP_HANDLER,
30055
ZEND_MUL_SPEC_CV_VAR_HANDLER,
30057
ZEND_MUL_SPEC_CV_CV_HANDLER,
30058
ZEND_DIV_SPEC_CONST_CONST_HANDLER,
30059
ZEND_DIV_SPEC_CONST_TMP_HANDLER,
30060
ZEND_DIV_SPEC_CONST_VAR_HANDLER,
30062
ZEND_DIV_SPEC_CONST_CV_HANDLER,
30063
ZEND_DIV_SPEC_TMP_CONST_HANDLER,
30064
ZEND_DIV_SPEC_TMP_TMP_HANDLER,
30065
ZEND_DIV_SPEC_TMP_VAR_HANDLER,
30067
ZEND_DIV_SPEC_TMP_CV_HANDLER,
30068
ZEND_DIV_SPEC_VAR_CONST_HANDLER,
30069
ZEND_DIV_SPEC_VAR_TMP_HANDLER,
30070
ZEND_DIV_SPEC_VAR_VAR_HANDLER,
30072
ZEND_DIV_SPEC_VAR_CV_HANDLER,
30078
ZEND_DIV_SPEC_CV_CONST_HANDLER,
30079
ZEND_DIV_SPEC_CV_TMP_HANDLER,
30080
ZEND_DIV_SPEC_CV_VAR_HANDLER,
30082
ZEND_DIV_SPEC_CV_CV_HANDLER,
30083
ZEND_MOD_SPEC_CONST_CONST_HANDLER,
30084
ZEND_MOD_SPEC_CONST_TMP_HANDLER,
30085
ZEND_MOD_SPEC_CONST_VAR_HANDLER,
30087
ZEND_MOD_SPEC_CONST_CV_HANDLER,
30088
ZEND_MOD_SPEC_TMP_CONST_HANDLER,
30089
ZEND_MOD_SPEC_TMP_TMP_HANDLER,
30090
ZEND_MOD_SPEC_TMP_VAR_HANDLER,
30092
ZEND_MOD_SPEC_TMP_CV_HANDLER,
30093
ZEND_MOD_SPEC_VAR_CONST_HANDLER,
30094
ZEND_MOD_SPEC_VAR_TMP_HANDLER,
30095
ZEND_MOD_SPEC_VAR_VAR_HANDLER,
30097
ZEND_MOD_SPEC_VAR_CV_HANDLER,
30103
ZEND_MOD_SPEC_CV_CONST_HANDLER,
30104
ZEND_MOD_SPEC_CV_TMP_HANDLER,
30105
ZEND_MOD_SPEC_CV_VAR_HANDLER,
30107
ZEND_MOD_SPEC_CV_CV_HANDLER,
30108
ZEND_SL_SPEC_CONST_CONST_HANDLER,
30109
ZEND_SL_SPEC_CONST_TMP_HANDLER,
30110
ZEND_SL_SPEC_CONST_VAR_HANDLER,
30112
ZEND_SL_SPEC_CONST_CV_HANDLER,
30113
ZEND_SL_SPEC_TMP_CONST_HANDLER,
30114
ZEND_SL_SPEC_TMP_TMP_HANDLER,
30115
ZEND_SL_SPEC_TMP_VAR_HANDLER,
30117
ZEND_SL_SPEC_TMP_CV_HANDLER,
30118
ZEND_SL_SPEC_VAR_CONST_HANDLER,
30119
ZEND_SL_SPEC_VAR_TMP_HANDLER,
30120
ZEND_SL_SPEC_VAR_VAR_HANDLER,
30122
ZEND_SL_SPEC_VAR_CV_HANDLER,
30128
ZEND_SL_SPEC_CV_CONST_HANDLER,
30129
ZEND_SL_SPEC_CV_TMP_HANDLER,
30130
ZEND_SL_SPEC_CV_VAR_HANDLER,
30132
ZEND_SL_SPEC_CV_CV_HANDLER,
30133
ZEND_SR_SPEC_CONST_CONST_HANDLER,
30134
ZEND_SR_SPEC_CONST_TMP_HANDLER,
30135
ZEND_SR_SPEC_CONST_VAR_HANDLER,
30137
ZEND_SR_SPEC_CONST_CV_HANDLER,
30138
ZEND_SR_SPEC_TMP_CONST_HANDLER,
30139
ZEND_SR_SPEC_TMP_TMP_HANDLER,
30140
ZEND_SR_SPEC_TMP_VAR_HANDLER,
30142
ZEND_SR_SPEC_TMP_CV_HANDLER,
30143
ZEND_SR_SPEC_VAR_CONST_HANDLER,
30144
ZEND_SR_SPEC_VAR_TMP_HANDLER,
30145
ZEND_SR_SPEC_VAR_VAR_HANDLER,
30147
ZEND_SR_SPEC_VAR_CV_HANDLER,
30153
ZEND_SR_SPEC_CV_CONST_HANDLER,
30154
ZEND_SR_SPEC_CV_TMP_HANDLER,
30155
ZEND_SR_SPEC_CV_VAR_HANDLER,
30157
ZEND_SR_SPEC_CV_CV_HANDLER,
30158
ZEND_CONCAT_SPEC_CONST_CONST_HANDLER,
30159
ZEND_CONCAT_SPEC_CONST_TMP_HANDLER,
30160
ZEND_CONCAT_SPEC_CONST_VAR_HANDLER,
30162
ZEND_CONCAT_SPEC_CONST_CV_HANDLER,
30163
ZEND_CONCAT_SPEC_TMP_CONST_HANDLER,
30164
ZEND_CONCAT_SPEC_TMP_TMP_HANDLER,
30165
ZEND_CONCAT_SPEC_TMP_VAR_HANDLER,
30167
ZEND_CONCAT_SPEC_TMP_CV_HANDLER,
30168
ZEND_CONCAT_SPEC_VAR_CONST_HANDLER,
30169
ZEND_CONCAT_SPEC_VAR_TMP_HANDLER,
30170
ZEND_CONCAT_SPEC_VAR_VAR_HANDLER,
30172
ZEND_CONCAT_SPEC_VAR_CV_HANDLER,
30178
ZEND_CONCAT_SPEC_CV_CONST_HANDLER,
30179
ZEND_CONCAT_SPEC_CV_TMP_HANDLER,
30180
ZEND_CONCAT_SPEC_CV_VAR_HANDLER,
30182
ZEND_CONCAT_SPEC_CV_CV_HANDLER,
30183
ZEND_BW_OR_SPEC_CONST_CONST_HANDLER,
30184
ZEND_BW_OR_SPEC_CONST_TMP_HANDLER,
30185
ZEND_BW_OR_SPEC_CONST_VAR_HANDLER,
30187
ZEND_BW_OR_SPEC_CONST_CV_HANDLER,
30188
ZEND_BW_OR_SPEC_TMP_CONST_HANDLER,
30189
ZEND_BW_OR_SPEC_TMP_TMP_HANDLER,
30190
ZEND_BW_OR_SPEC_TMP_VAR_HANDLER,
30192
ZEND_BW_OR_SPEC_TMP_CV_HANDLER,
30193
ZEND_BW_OR_SPEC_VAR_CONST_HANDLER,
30194
ZEND_BW_OR_SPEC_VAR_TMP_HANDLER,
30195
ZEND_BW_OR_SPEC_VAR_VAR_HANDLER,
30197
ZEND_BW_OR_SPEC_VAR_CV_HANDLER,
30203
ZEND_BW_OR_SPEC_CV_CONST_HANDLER,
30204
ZEND_BW_OR_SPEC_CV_TMP_HANDLER,
30205
ZEND_BW_OR_SPEC_CV_VAR_HANDLER,
30207
ZEND_BW_OR_SPEC_CV_CV_HANDLER,
30208
ZEND_BW_AND_SPEC_CONST_CONST_HANDLER,
30209
ZEND_BW_AND_SPEC_CONST_TMP_HANDLER,
30210
ZEND_BW_AND_SPEC_CONST_VAR_HANDLER,
30212
ZEND_BW_AND_SPEC_CONST_CV_HANDLER,
30213
ZEND_BW_AND_SPEC_TMP_CONST_HANDLER,
30214
ZEND_BW_AND_SPEC_TMP_TMP_HANDLER,
30215
ZEND_BW_AND_SPEC_TMP_VAR_HANDLER,
30217
ZEND_BW_AND_SPEC_TMP_CV_HANDLER,
30218
ZEND_BW_AND_SPEC_VAR_CONST_HANDLER,
30219
ZEND_BW_AND_SPEC_VAR_TMP_HANDLER,
30220
ZEND_BW_AND_SPEC_VAR_VAR_HANDLER,
30222
ZEND_BW_AND_SPEC_VAR_CV_HANDLER,
30228
ZEND_BW_AND_SPEC_CV_CONST_HANDLER,
30229
ZEND_BW_AND_SPEC_CV_TMP_HANDLER,
30230
ZEND_BW_AND_SPEC_CV_VAR_HANDLER,
30232
ZEND_BW_AND_SPEC_CV_CV_HANDLER,
30233
ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER,
30234
ZEND_BW_XOR_SPEC_CONST_TMP_HANDLER,
30235
ZEND_BW_XOR_SPEC_CONST_VAR_HANDLER,
30237
ZEND_BW_XOR_SPEC_CONST_CV_HANDLER,
30238
ZEND_BW_XOR_SPEC_TMP_CONST_HANDLER,
30239
ZEND_BW_XOR_SPEC_TMP_TMP_HANDLER,
30240
ZEND_BW_XOR_SPEC_TMP_VAR_HANDLER,
30242
ZEND_BW_XOR_SPEC_TMP_CV_HANDLER,
30243
ZEND_BW_XOR_SPEC_VAR_CONST_HANDLER,
30244
ZEND_BW_XOR_SPEC_VAR_TMP_HANDLER,
30245
ZEND_BW_XOR_SPEC_VAR_VAR_HANDLER,
30247
ZEND_BW_XOR_SPEC_VAR_CV_HANDLER,
30253
ZEND_BW_XOR_SPEC_CV_CONST_HANDLER,
30254
ZEND_BW_XOR_SPEC_CV_TMP_HANDLER,
30255
ZEND_BW_XOR_SPEC_CV_VAR_HANDLER,
30257
ZEND_BW_XOR_SPEC_CV_CV_HANDLER,
30258
ZEND_BW_NOT_SPEC_CONST_HANDLER,
30259
ZEND_BW_NOT_SPEC_CONST_HANDLER,
30260
ZEND_BW_NOT_SPEC_CONST_HANDLER,
30261
ZEND_BW_NOT_SPEC_CONST_HANDLER,
30262
ZEND_BW_NOT_SPEC_CONST_HANDLER,
30263
ZEND_BW_NOT_SPEC_TMP_HANDLER,
30264
ZEND_BW_NOT_SPEC_TMP_HANDLER,
30265
ZEND_BW_NOT_SPEC_TMP_HANDLER,
30266
ZEND_BW_NOT_SPEC_TMP_HANDLER,
30267
ZEND_BW_NOT_SPEC_TMP_HANDLER,
30268
ZEND_BW_NOT_SPEC_VAR_HANDLER,
30269
ZEND_BW_NOT_SPEC_VAR_HANDLER,
30270
ZEND_BW_NOT_SPEC_VAR_HANDLER,
30271
ZEND_BW_NOT_SPEC_VAR_HANDLER,
30272
ZEND_BW_NOT_SPEC_VAR_HANDLER,
30278
ZEND_BW_NOT_SPEC_CV_HANDLER,
30279
ZEND_BW_NOT_SPEC_CV_HANDLER,
30280
ZEND_BW_NOT_SPEC_CV_HANDLER,
30281
ZEND_BW_NOT_SPEC_CV_HANDLER,
30282
ZEND_BW_NOT_SPEC_CV_HANDLER,
30283
ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
30284
ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
30285
ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
30286
ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
30287
ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
30288
ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
30289
ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
30290
ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
30291
ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
30292
ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
30293
ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
30294
ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
30295
ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
30296
ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
30297
ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
30303
ZEND_BOOL_NOT_SPEC_CV_HANDLER,
30304
ZEND_BOOL_NOT_SPEC_CV_HANDLER,
30305
ZEND_BOOL_NOT_SPEC_CV_HANDLER,
30306
ZEND_BOOL_NOT_SPEC_CV_HANDLER,
30307
ZEND_BOOL_NOT_SPEC_CV_HANDLER,
30308
ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER,
30309
ZEND_BOOL_XOR_SPEC_CONST_TMP_HANDLER,
30310
ZEND_BOOL_XOR_SPEC_CONST_VAR_HANDLER,
30312
ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER,
30313
ZEND_BOOL_XOR_SPEC_TMP_CONST_HANDLER,
30314
ZEND_BOOL_XOR_SPEC_TMP_TMP_HANDLER,
30315
ZEND_BOOL_XOR_SPEC_TMP_VAR_HANDLER,
30317
ZEND_BOOL_XOR_SPEC_TMP_CV_HANDLER,
30318
ZEND_BOOL_XOR_SPEC_VAR_CONST_HANDLER,
30319
ZEND_BOOL_XOR_SPEC_VAR_TMP_HANDLER,
30320
ZEND_BOOL_XOR_SPEC_VAR_VAR_HANDLER,
30322
ZEND_BOOL_XOR_SPEC_VAR_CV_HANDLER,
30328
ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER,
30329
ZEND_BOOL_XOR_SPEC_CV_TMP_HANDLER,
30330
ZEND_BOOL_XOR_SPEC_CV_VAR_HANDLER,
30332
ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER,
30333
ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER,
30334
ZEND_IS_IDENTICAL_SPEC_CONST_TMP_HANDLER,
30335
ZEND_IS_IDENTICAL_SPEC_CONST_VAR_HANDLER,
30337
ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER,
30338
ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER,
30339
ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER,
30340
ZEND_IS_IDENTICAL_SPEC_TMP_VAR_HANDLER,
30342
ZEND_IS_IDENTICAL_SPEC_TMP_CV_HANDLER,
30343
ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER,
30344
ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER,
30345
ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER,
30347
ZEND_IS_IDENTICAL_SPEC_VAR_CV_HANDLER,
30353
ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER,
30354
ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER,
30355
ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER,
30357
ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER,
30358
ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER,
30359
ZEND_IS_NOT_IDENTICAL_SPEC_CONST_TMP_HANDLER,
30360
ZEND_IS_NOT_IDENTICAL_SPEC_CONST_VAR_HANDLER,
30362
ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER,
30363
ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER,
30364
ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER,
30365
ZEND_IS_NOT_IDENTICAL_SPEC_TMP_VAR_HANDLER,
30367
ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CV_HANDLER,
30368
ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER,
30369
ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER,
30370
ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER,
30372
ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CV_HANDLER,
30378
ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER,
30379
ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER,
30380
ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER,
30382
ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER,
30383
ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
30384
ZEND_IS_EQUAL_SPEC_CONST_TMP_HANDLER,
30385
ZEND_IS_EQUAL_SPEC_CONST_VAR_HANDLER,
30387
ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER,
30388
ZEND_IS_EQUAL_SPEC_TMP_CONST_HANDLER,
30389
ZEND_IS_EQUAL_SPEC_TMP_TMP_HANDLER,
30390
ZEND_IS_EQUAL_SPEC_TMP_VAR_HANDLER,
30392
ZEND_IS_EQUAL_SPEC_TMP_CV_HANDLER,
30393
ZEND_IS_EQUAL_SPEC_VAR_CONST_HANDLER,
30394
ZEND_IS_EQUAL_SPEC_VAR_TMP_HANDLER,
30395
ZEND_IS_EQUAL_SPEC_VAR_VAR_HANDLER,
30397
ZEND_IS_EQUAL_SPEC_VAR_CV_HANDLER,
30403
ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER,
30404
ZEND_IS_EQUAL_SPEC_CV_TMP_HANDLER,
30405
ZEND_IS_EQUAL_SPEC_CV_VAR_HANDLER,
30407
ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER,
30408
ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
30409
ZEND_IS_NOT_EQUAL_SPEC_CONST_TMP_HANDLER,
30410
ZEND_IS_NOT_EQUAL_SPEC_CONST_VAR_HANDLER,
30412
ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER,
30413
ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_HANDLER,
30414
ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_HANDLER,
30415
ZEND_IS_NOT_EQUAL_SPEC_TMP_VAR_HANDLER,
30417
ZEND_IS_NOT_EQUAL_SPEC_TMP_CV_HANDLER,
30418
ZEND_IS_NOT_EQUAL_SPEC_VAR_CONST_HANDLER,
30419
ZEND_IS_NOT_EQUAL_SPEC_VAR_TMP_HANDLER,
30420
ZEND_IS_NOT_EQUAL_SPEC_VAR_VAR_HANDLER,
30422
ZEND_IS_NOT_EQUAL_SPEC_VAR_CV_HANDLER,
30428
ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER,
30429
ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_HANDLER,
30430
ZEND_IS_NOT_EQUAL_SPEC_CV_VAR_HANDLER,
30432
ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER,
30433
ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
30434
ZEND_IS_SMALLER_SPEC_CONST_TMP_HANDLER,
30435
ZEND_IS_SMALLER_SPEC_CONST_VAR_HANDLER,
30437
ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER,
30438
ZEND_IS_SMALLER_SPEC_TMP_CONST_HANDLER,
30439
ZEND_IS_SMALLER_SPEC_TMP_TMP_HANDLER,
30440
ZEND_IS_SMALLER_SPEC_TMP_VAR_HANDLER,
30442
ZEND_IS_SMALLER_SPEC_TMP_CV_HANDLER,
30443
ZEND_IS_SMALLER_SPEC_VAR_CONST_HANDLER,
30444
ZEND_IS_SMALLER_SPEC_VAR_TMP_HANDLER,
30445
ZEND_IS_SMALLER_SPEC_VAR_VAR_HANDLER,
30447
ZEND_IS_SMALLER_SPEC_VAR_CV_HANDLER,
30453
ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER,
30454
ZEND_IS_SMALLER_SPEC_CV_TMP_HANDLER,
30455
ZEND_IS_SMALLER_SPEC_CV_VAR_HANDLER,
30457
ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER,
30458
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
30459
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMP_HANDLER,
30460
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_VAR_HANDLER,
30462
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER,
30463
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CONST_HANDLER,
30464
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_TMP_HANDLER,
30465
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_VAR_HANDLER,
30467
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CV_HANDLER,
30468
ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CONST_HANDLER,
30469
ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_TMP_HANDLER,
30470
ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_VAR_HANDLER,
30472
ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CV_HANDLER,
30478
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER,
30479
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMP_HANDLER,
30480
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_VAR_HANDLER,
30482
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER,
30483
ZEND_CAST_SPEC_CONST_HANDLER,
30484
ZEND_CAST_SPEC_CONST_HANDLER,
30485
ZEND_CAST_SPEC_CONST_HANDLER,
30486
ZEND_CAST_SPEC_CONST_HANDLER,
30487
ZEND_CAST_SPEC_CONST_HANDLER,
30488
ZEND_CAST_SPEC_TMP_HANDLER,
30489
ZEND_CAST_SPEC_TMP_HANDLER,
30490
ZEND_CAST_SPEC_TMP_HANDLER,
30491
ZEND_CAST_SPEC_TMP_HANDLER,
30492
ZEND_CAST_SPEC_TMP_HANDLER,
30493
ZEND_CAST_SPEC_VAR_HANDLER,
30494
ZEND_CAST_SPEC_VAR_HANDLER,
30495
ZEND_CAST_SPEC_VAR_HANDLER,
30496
ZEND_CAST_SPEC_VAR_HANDLER,
30497
ZEND_CAST_SPEC_VAR_HANDLER,
30503
ZEND_CAST_SPEC_CV_HANDLER,
30504
ZEND_CAST_SPEC_CV_HANDLER,
30505
ZEND_CAST_SPEC_CV_HANDLER,
30506
ZEND_CAST_SPEC_CV_HANDLER,
30507
ZEND_CAST_SPEC_CV_HANDLER,
30508
ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
30509
ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
30510
ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
30511
ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
30512
ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
30513
ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
30514
ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
30515
ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
30516
ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
30517
ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
30518
ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
30519
ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
30520
ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
30521
ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
30522
ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
30528
ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
30529
ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
30530
ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
30531
ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
30532
ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
30543
ZEND_ASSIGN_ADD_SPEC_VAR_CONST_HANDLER,
30544
ZEND_ASSIGN_ADD_SPEC_VAR_TMP_HANDLER,
30545
ZEND_ASSIGN_ADD_SPEC_VAR_VAR_HANDLER,
30546
ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_HANDLER,
30547
ZEND_ASSIGN_ADD_SPEC_VAR_CV_HANDLER,
30548
ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_HANDLER,
30549
ZEND_ASSIGN_ADD_SPEC_UNUSED_TMP_HANDLER,
30550
ZEND_ASSIGN_ADD_SPEC_UNUSED_VAR_HANDLER,
30551
ZEND_ASSIGN_ADD_SPEC_UNUSED_UNUSED_HANDLER,
30552
ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_HANDLER,
30553
ZEND_ASSIGN_ADD_SPEC_CV_CONST_HANDLER,
30554
ZEND_ASSIGN_ADD_SPEC_CV_TMP_HANDLER,
30555
ZEND_ASSIGN_ADD_SPEC_CV_VAR_HANDLER,
30556
ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_HANDLER,
30557
ZEND_ASSIGN_ADD_SPEC_CV_CV_HANDLER,
30568
ZEND_ASSIGN_SUB_SPEC_VAR_CONST_HANDLER,
30569
ZEND_ASSIGN_SUB_SPEC_VAR_TMP_HANDLER,
30570
ZEND_ASSIGN_SUB_SPEC_VAR_VAR_HANDLER,
30571
ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_HANDLER,
30572
ZEND_ASSIGN_SUB_SPEC_VAR_CV_HANDLER,
30573
ZEND_ASSIGN_SUB_SPEC_UNUSED_CONST_HANDLER,
30574
ZEND_ASSIGN_SUB_SPEC_UNUSED_TMP_HANDLER,
30575
ZEND_ASSIGN_SUB_SPEC_UNUSED_VAR_HANDLER,
30576
ZEND_ASSIGN_SUB_SPEC_UNUSED_UNUSED_HANDLER,
30577
ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_HANDLER,
30578
ZEND_ASSIGN_SUB_SPEC_CV_CONST_HANDLER,
30579
ZEND_ASSIGN_SUB_SPEC_CV_TMP_HANDLER,
30580
ZEND_ASSIGN_SUB_SPEC_CV_VAR_HANDLER,
30581
ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_HANDLER,
30582
ZEND_ASSIGN_SUB_SPEC_CV_CV_HANDLER,
30593
ZEND_ASSIGN_MUL_SPEC_VAR_CONST_HANDLER,
30594
ZEND_ASSIGN_MUL_SPEC_VAR_TMP_HANDLER,
30595
ZEND_ASSIGN_MUL_SPEC_VAR_VAR_HANDLER,
30596
ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_HANDLER,
30597
ZEND_ASSIGN_MUL_SPEC_VAR_CV_HANDLER,
30598
ZEND_ASSIGN_MUL_SPEC_UNUSED_CONST_HANDLER,
30599
ZEND_ASSIGN_MUL_SPEC_UNUSED_TMP_HANDLER,
30600
ZEND_ASSIGN_MUL_SPEC_UNUSED_VAR_HANDLER,
30601
ZEND_ASSIGN_MUL_SPEC_UNUSED_UNUSED_HANDLER,
30602
ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_HANDLER,
30603
ZEND_ASSIGN_MUL_SPEC_CV_CONST_HANDLER,
30604
ZEND_ASSIGN_MUL_SPEC_CV_TMP_HANDLER,
30605
ZEND_ASSIGN_MUL_SPEC_CV_VAR_HANDLER,
30606
ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_HANDLER,
30607
ZEND_ASSIGN_MUL_SPEC_CV_CV_HANDLER,
30618
ZEND_ASSIGN_DIV_SPEC_VAR_CONST_HANDLER,
30619
ZEND_ASSIGN_DIV_SPEC_VAR_TMP_HANDLER,
30620
ZEND_ASSIGN_DIV_SPEC_VAR_VAR_HANDLER,
30621
ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_HANDLER,
30622
ZEND_ASSIGN_DIV_SPEC_VAR_CV_HANDLER,
30623
ZEND_ASSIGN_DIV_SPEC_UNUSED_CONST_HANDLER,
30624
ZEND_ASSIGN_DIV_SPEC_UNUSED_TMP_HANDLER,
30625
ZEND_ASSIGN_DIV_SPEC_UNUSED_VAR_HANDLER,
30626
ZEND_ASSIGN_DIV_SPEC_UNUSED_UNUSED_HANDLER,
30627
ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_HANDLER,
30628
ZEND_ASSIGN_DIV_SPEC_CV_CONST_HANDLER,
30629
ZEND_ASSIGN_DIV_SPEC_CV_TMP_HANDLER,
30630
ZEND_ASSIGN_DIV_SPEC_CV_VAR_HANDLER,
30631
ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_HANDLER,
30632
ZEND_ASSIGN_DIV_SPEC_CV_CV_HANDLER,
30643
ZEND_ASSIGN_MOD_SPEC_VAR_CONST_HANDLER,
30644
ZEND_ASSIGN_MOD_SPEC_VAR_TMP_HANDLER,
30645
ZEND_ASSIGN_MOD_SPEC_VAR_VAR_HANDLER,
30646
ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_HANDLER,
30647
ZEND_ASSIGN_MOD_SPEC_VAR_CV_HANDLER,
30648
ZEND_ASSIGN_MOD_SPEC_UNUSED_CONST_HANDLER,
30649
ZEND_ASSIGN_MOD_SPEC_UNUSED_TMP_HANDLER,
30650
ZEND_ASSIGN_MOD_SPEC_UNUSED_VAR_HANDLER,
30651
ZEND_ASSIGN_MOD_SPEC_UNUSED_UNUSED_HANDLER,
30652
ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_HANDLER,
30653
ZEND_ASSIGN_MOD_SPEC_CV_CONST_HANDLER,
30654
ZEND_ASSIGN_MOD_SPEC_CV_TMP_HANDLER,
30655
ZEND_ASSIGN_MOD_SPEC_CV_VAR_HANDLER,
30656
ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_HANDLER,
30657
ZEND_ASSIGN_MOD_SPEC_CV_CV_HANDLER,
30668
ZEND_ASSIGN_SL_SPEC_VAR_CONST_HANDLER,
30669
ZEND_ASSIGN_SL_SPEC_VAR_TMP_HANDLER,
30670
ZEND_ASSIGN_SL_SPEC_VAR_VAR_HANDLER,
30671
ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_HANDLER,
30672
ZEND_ASSIGN_SL_SPEC_VAR_CV_HANDLER,
30673
ZEND_ASSIGN_SL_SPEC_UNUSED_CONST_HANDLER,
30674
ZEND_ASSIGN_SL_SPEC_UNUSED_TMP_HANDLER,
30675
ZEND_ASSIGN_SL_SPEC_UNUSED_VAR_HANDLER,
30676
ZEND_ASSIGN_SL_SPEC_UNUSED_UNUSED_HANDLER,
30677
ZEND_ASSIGN_SL_SPEC_UNUSED_CV_HANDLER,
30678
ZEND_ASSIGN_SL_SPEC_CV_CONST_HANDLER,
30679
ZEND_ASSIGN_SL_SPEC_CV_TMP_HANDLER,
30680
ZEND_ASSIGN_SL_SPEC_CV_VAR_HANDLER,
30681
ZEND_ASSIGN_SL_SPEC_CV_UNUSED_HANDLER,
30682
ZEND_ASSIGN_SL_SPEC_CV_CV_HANDLER,
30693
ZEND_ASSIGN_SR_SPEC_VAR_CONST_HANDLER,
30694
ZEND_ASSIGN_SR_SPEC_VAR_TMP_HANDLER,
30695
ZEND_ASSIGN_SR_SPEC_VAR_VAR_HANDLER,
30696
ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_HANDLER,
30697
ZEND_ASSIGN_SR_SPEC_VAR_CV_HANDLER,
30698
ZEND_ASSIGN_SR_SPEC_UNUSED_CONST_HANDLER,
30699
ZEND_ASSIGN_SR_SPEC_UNUSED_TMP_HANDLER,
30700
ZEND_ASSIGN_SR_SPEC_UNUSED_VAR_HANDLER,
30701
ZEND_ASSIGN_SR_SPEC_UNUSED_UNUSED_HANDLER,
30702
ZEND_ASSIGN_SR_SPEC_UNUSED_CV_HANDLER,
30703
ZEND_ASSIGN_SR_SPEC_CV_CONST_HANDLER,
30704
ZEND_ASSIGN_SR_SPEC_CV_TMP_HANDLER,
30705
ZEND_ASSIGN_SR_SPEC_CV_VAR_HANDLER,
30706
ZEND_ASSIGN_SR_SPEC_CV_UNUSED_HANDLER,
30707
ZEND_ASSIGN_SR_SPEC_CV_CV_HANDLER,
30718
ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_HANDLER,
30719
ZEND_ASSIGN_CONCAT_SPEC_VAR_TMP_HANDLER,
30720
ZEND_ASSIGN_CONCAT_SPEC_VAR_VAR_HANDLER,
30721
ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_HANDLER,
30722
ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_HANDLER,
30723
ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CONST_HANDLER,
30724
ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMP_HANDLER,
30725
ZEND_ASSIGN_CONCAT_SPEC_UNUSED_VAR_HANDLER,
30726
ZEND_ASSIGN_CONCAT_SPEC_UNUSED_UNUSED_HANDLER,
30727
ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_HANDLER,
30728
ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_HANDLER,
30729
ZEND_ASSIGN_CONCAT_SPEC_CV_TMP_HANDLER,
30730
ZEND_ASSIGN_CONCAT_SPEC_CV_VAR_HANDLER,
30731
ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_HANDLER,
30732
ZEND_ASSIGN_CONCAT_SPEC_CV_CV_HANDLER,
30743
ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_HANDLER,
30744
ZEND_ASSIGN_BW_OR_SPEC_VAR_TMP_HANDLER,
30745
ZEND_ASSIGN_BW_OR_SPEC_VAR_VAR_HANDLER,
30746
ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_HANDLER,
30747
ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_HANDLER,
30748
ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CONST_HANDLER,
30749
ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMP_HANDLER,
30750
ZEND_ASSIGN_BW_OR_SPEC_UNUSED_VAR_HANDLER,
30751
ZEND_ASSIGN_BW_OR_SPEC_UNUSED_UNUSED_HANDLER,
30752
ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_HANDLER,
30753
ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_HANDLER,
30754
ZEND_ASSIGN_BW_OR_SPEC_CV_TMP_HANDLER,
30755
ZEND_ASSIGN_BW_OR_SPEC_CV_VAR_HANDLER,
30756
ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_HANDLER,
30757
ZEND_ASSIGN_BW_OR_SPEC_CV_CV_HANDLER,
30768
ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_HANDLER,
30769
ZEND_ASSIGN_BW_AND_SPEC_VAR_TMP_HANDLER,
30770
ZEND_ASSIGN_BW_AND_SPEC_VAR_VAR_HANDLER,
30771
ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_HANDLER,
30772
ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_HANDLER,
30773
ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CONST_HANDLER,
30774
ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMP_HANDLER,
30775
ZEND_ASSIGN_BW_AND_SPEC_UNUSED_VAR_HANDLER,
30776
ZEND_ASSIGN_BW_AND_SPEC_UNUSED_UNUSED_HANDLER,
30777
ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_HANDLER,
30778
ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_HANDLER,
30779
ZEND_ASSIGN_BW_AND_SPEC_CV_TMP_HANDLER,
30780
ZEND_ASSIGN_BW_AND_SPEC_CV_VAR_HANDLER,
30781
ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_HANDLER,
30782
ZEND_ASSIGN_BW_AND_SPEC_CV_CV_HANDLER,
30793
ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_HANDLER,
30794
ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMP_HANDLER,
30795
ZEND_ASSIGN_BW_XOR_SPEC_VAR_VAR_HANDLER,
30796
ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_HANDLER,
30797
ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_HANDLER,
30798
ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_HANDLER,
30799
ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMP_HANDLER,
30800
ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_VAR_HANDLER,
30801
ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_UNUSED_HANDLER,
30802
ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_HANDLER,
30803
ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER,
30804
ZEND_ASSIGN_BW_XOR_SPEC_CV_TMP_HANDLER,
30805
ZEND_ASSIGN_BW_XOR_SPEC_CV_VAR_HANDLER,
30806
ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_HANDLER,
30807
ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_HANDLER,
30818
ZEND_PRE_INC_SPEC_VAR_HANDLER,
30819
ZEND_PRE_INC_SPEC_VAR_HANDLER,
30820
ZEND_PRE_INC_SPEC_VAR_HANDLER,
30821
ZEND_PRE_INC_SPEC_VAR_HANDLER,
30822
ZEND_PRE_INC_SPEC_VAR_HANDLER,
30828
ZEND_PRE_INC_SPEC_CV_HANDLER,
30829
ZEND_PRE_INC_SPEC_CV_HANDLER,
30830
ZEND_PRE_INC_SPEC_CV_HANDLER,
30831
ZEND_PRE_INC_SPEC_CV_HANDLER,
30832
ZEND_PRE_INC_SPEC_CV_HANDLER,
30843
ZEND_PRE_DEC_SPEC_VAR_HANDLER,
30844
ZEND_PRE_DEC_SPEC_VAR_HANDLER,
30845
ZEND_PRE_DEC_SPEC_VAR_HANDLER,
30846
ZEND_PRE_DEC_SPEC_VAR_HANDLER,
30847
ZEND_PRE_DEC_SPEC_VAR_HANDLER,
30853
ZEND_PRE_DEC_SPEC_CV_HANDLER,
30854
ZEND_PRE_DEC_SPEC_CV_HANDLER,
30855
ZEND_PRE_DEC_SPEC_CV_HANDLER,
30856
ZEND_PRE_DEC_SPEC_CV_HANDLER,
30857
ZEND_PRE_DEC_SPEC_CV_HANDLER,
30868
ZEND_POST_INC_SPEC_VAR_HANDLER,
30869
ZEND_POST_INC_SPEC_VAR_HANDLER,
30870
ZEND_POST_INC_SPEC_VAR_HANDLER,
30871
ZEND_POST_INC_SPEC_VAR_HANDLER,
30872
ZEND_POST_INC_SPEC_VAR_HANDLER,
30878
ZEND_POST_INC_SPEC_CV_HANDLER,
30879
ZEND_POST_INC_SPEC_CV_HANDLER,
30880
ZEND_POST_INC_SPEC_CV_HANDLER,
30881
ZEND_POST_INC_SPEC_CV_HANDLER,
30882
ZEND_POST_INC_SPEC_CV_HANDLER,
30893
ZEND_POST_DEC_SPEC_VAR_HANDLER,
30894
ZEND_POST_DEC_SPEC_VAR_HANDLER,
30895
ZEND_POST_DEC_SPEC_VAR_HANDLER,
30896
ZEND_POST_DEC_SPEC_VAR_HANDLER,
30897
ZEND_POST_DEC_SPEC_VAR_HANDLER,
30903
ZEND_POST_DEC_SPEC_CV_HANDLER,
30904
ZEND_POST_DEC_SPEC_CV_HANDLER,
30905
ZEND_POST_DEC_SPEC_CV_HANDLER,
30906
ZEND_POST_DEC_SPEC_CV_HANDLER,
30907
ZEND_POST_DEC_SPEC_CV_HANDLER,
30918
ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER,
30919
ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER,
30920
ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER,
30922
ZEND_ASSIGN_SPEC_VAR_CV_HANDLER,
30928
ZEND_ASSIGN_SPEC_CV_CONST_HANDLER,
30929
ZEND_ASSIGN_SPEC_CV_TMP_HANDLER,
30930
ZEND_ASSIGN_SPEC_CV_VAR_HANDLER,
30932
ZEND_ASSIGN_SPEC_CV_CV_HANDLER,
30945
ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER,
30947
ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER,
30955
ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER,
30957
ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER,
30958
ZEND_ECHO_SPEC_CONST_HANDLER,
30959
ZEND_ECHO_SPEC_CONST_HANDLER,
30960
ZEND_ECHO_SPEC_CONST_HANDLER,
30961
ZEND_ECHO_SPEC_CONST_HANDLER,
30962
ZEND_ECHO_SPEC_CONST_HANDLER,
30963
ZEND_ECHO_SPEC_TMP_HANDLER,
30964
ZEND_ECHO_SPEC_TMP_HANDLER,
30965
ZEND_ECHO_SPEC_TMP_HANDLER,
30966
ZEND_ECHO_SPEC_TMP_HANDLER,
30967
ZEND_ECHO_SPEC_TMP_HANDLER,
30968
ZEND_ECHO_SPEC_VAR_HANDLER,
30969
ZEND_ECHO_SPEC_VAR_HANDLER,
30970
ZEND_ECHO_SPEC_VAR_HANDLER,
30971
ZEND_ECHO_SPEC_VAR_HANDLER,
30972
ZEND_ECHO_SPEC_VAR_HANDLER,
30978
ZEND_ECHO_SPEC_CV_HANDLER,
30979
ZEND_ECHO_SPEC_CV_HANDLER,
30980
ZEND_ECHO_SPEC_CV_HANDLER,
30981
ZEND_ECHO_SPEC_CV_HANDLER,
30982
ZEND_ECHO_SPEC_CV_HANDLER,
30983
ZEND_PRINT_SPEC_CONST_HANDLER,
30984
ZEND_PRINT_SPEC_CONST_HANDLER,
30985
ZEND_PRINT_SPEC_CONST_HANDLER,
30986
ZEND_PRINT_SPEC_CONST_HANDLER,
30987
ZEND_PRINT_SPEC_CONST_HANDLER,
30988
ZEND_PRINT_SPEC_TMP_HANDLER,
30989
ZEND_PRINT_SPEC_TMP_HANDLER,
30990
ZEND_PRINT_SPEC_TMP_HANDLER,
30991
ZEND_PRINT_SPEC_TMP_HANDLER,
30992
ZEND_PRINT_SPEC_TMP_HANDLER,
30993
ZEND_PRINT_SPEC_VAR_HANDLER,
30994
ZEND_PRINT_SPEC_VAR_HANDLER,
30995
ZEND_PRINT_SPEC_VAR_HANDLER,
30996
ZEND_PRINT_SPEC_VAR_HANDLER,
30997
ZEND_PRINT_SPEC_VAR_HANDLER,
31003
ZEND_PRINT_SPEC_CV_HANDLER,
31004
ZEND_PRINT_SPEC_CV_HANDLER,
31005
ZEND_PRINT_SPEC_CV_HANDLER,
31006
ZEND_PRINT_SPEC_CV_HANDLER,
31007
ZEND_PRINT_SPEC_CV_HANDLER,
31008
ZEND_JMP_SPEC_HANDLER,
31009
ZEND_JMP_SPEC_HANDLER,
31010
ZEND_JMP_SPEC_HANDLER,
31011
ZEND_JMP_SPEC_HANDLER,
31012
ZEND_JMP_SPEC_HANDLER,
31013
ZEND_JMP_SPEC_HANDLER,
31014
ZEND_JMP_SPEC_HANDLER,
31015
ZEND_JMP_SPEC_HANDLER,
31016
ZEND_JMP_SPEC_HANDLER,
31017
ZEND_JMP_SPEC_HANDLER,
31018
ZEND_JMP_SPEC_HANDLER,
31019
ZEND_JMP_SPEC_HANDLER,
31020
ZEND_JMP_SPEC_HANDLER,
31021
ZEND_JMP_SPEC_HANDLER,
31022
ZEND_JMP_SPEC_HANDLER,
31023
ZEND_JMP_SPEC_HANDLER,
31024
ZEND_JMP_SPEC_HANDLER,
31025
ZEND_JMP_SPEC_HANDLER,
31026
ZEND_JMP_SPEC_HANDLER,
31027
ZEND_JMP_SPEC_HANDLER,
31028
ZEND_JMP_SPEC_HANDLER,
31029
ZEND_JMP_SPEC_HANDLER,
31030
ZEND_JMP_SPEC_HANDLER,
31031
ZEND_JMP_SPEC_HANDLER,
31032
ZEND_JMP_SPEC_HANDLER,
31033
ZEND_JMPZ_SPEC_CONST_HANDLER,
31034
ZEND_JMPZ_SPEC_CONST_HANDLER,
31035
ZEND_JMPZ_SPEC_CONST_HANDLER,
31036
ZEND_JMPZ_SPEC_CONST_HANDLER,
31037
ZEND_JMPZ_SPEC_CONST_HANDLER,
31038
ZEND_JMPZ_SPEC_TMP_HANDLER,
31039
ZEND_JMPZ_SPEC_TMP_HANDLER,
31040
ZEND_JMPZ_SPEC_TMP_HANDLER,
31041
ZEND_JMPZ_SPEC_TMP_HANDLER,
31042
ZEND_JMPZ_SPEC_TMP_HANDLER,
31043
ZEND_JMPZ_SPEC_VAR_HANDLER,
31044
ZEND_JMPZ_SPEC_VAR_HANDLER,
31045
ZEND_JMPZ_SPEC_VAR_HANDLER,
31046
ZEND_JMPZ_SPEC_VAR_HANDLER,
31047
ZEND_JMPZ_SPEC_VAR_HANDLER,
31053
ZEND_JMPZ_SPEC_CV_HANDLER,
31054
ZEND_JMPZ_SPEC_CV_HANDLER,
31055
ZEND_JMPZ_SPEC_CV_HANDLER,
31056
ZEND_JMPZ_SPEC_CV_HANDLER,
31057
ZEND_JMPZ_SPEC_CV_HANDLER,
31058
ZEND_JMPNZ_SPEC_CONST_HANDLER,
31059
ZEND_JMPNZ_SPEC_CONST_HANDLER,
31060
ZEND_JMPNZ_SPEC_CONST_HANDLER,
31061
ZEND_JMPNZ_SPEC_CONST_HANDLER,
31062
ZEND_JMPNZ_SPEC_CONST_HANDLER,
31063
ZEND_JMPNZ_SPEC_TMP_HANDLER,
31064
ZEND_JMPNZ_SPEC_TMP_HANDLER,
31065
ZEND_JMPNZ_SPEC_TMP_HANDLER,
31066
ZEND_JMPNZ_SPEC_TMP_HANDLER,
31067
ZEND_JMPNZ_SPEC_TMP_HANDLER,
31068
ZEND_JMPNZ_SPEC_VAR_HANDLER,
31069
ZEND_JMPNZ_SPEC_VAR_HANDLER,
31070
ZEND_JMPNZ_SPEC_VAR_HANDLER,
31071
ZEND_JMPNZ_SPEC_VAR_HANDLER,
31072
ZEND_JMPNZ_SPEC_VAR_HANDLER,
31078
ZEND_JMPNZ_SPEC_CV_HANDLER,
31079
ZEND_JMPNZ_SPEC_CV_HANDLER,
31080
ZEND_JMPNZ_SPEC_CV_HANDLER,
31081
ZEND_JMPNZ_SPEC_CV_HANDLER,
31082
ZEND_JMPNZ_SPEC_CV_HANDLER,
31083
ZEND_JMPZNZ_SPEC_CONST_HANDLER,
31084
ZEND_JMPZNZ_SPEC_CONST_HANDLER,
31085
ZEND_JMPZNZ_SPEC_CONST_HANDLER,
31086
ZEND_JMPZNZ_SPEC_CONST_HANDLER,
31087
ZEND_JMPZNZ_SPEC_CONST_HANDLER,
31088
ZEND_JMPZNZ_SPEC_TMP_HANDLER,
31089
ZEND_JMPZNZ_SPEC_TMP_HANDLER,
31090
ZEND_JMPZNZ_SPEC_TMP_HANDLER,
31091
ZEND_JMPZNZ_SPEC_TMP_HANDLER,
31092
ZEND_JMPZNZ_SPEC_TMP_HANDLER,
31093
ZEND_JMPZNZ_SPEC_VAR_HANDLER,
31094
ZEND_JMPZNZ_SPEC_VAR_HANDLER,
31095
ZEND_JMPZNZ_SPEC_VAR_HANDLER,
31096
ZEND_JMPZNZ_SPEC_VAR_HANDLER,
31097
ZEND_JMPZNZ_SPEC_VAR_HANDLER,
31103
ZEND_JMPZNZ_SPEC_CV_HANDLER,
31104
ZEND_JMPZNZ_SPEC_CV_HANDLER,
31105
ZEND_JMPZNZ_SPEC_CV_HANDLER,
31106
ZEND_JMPZNZ_SPEC_CV_HANDLER,
31107
ZEND_JMPZNZ_SPEC_CV_HANDLER,
31108
ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
31109
ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
31110
ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
31111
ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
31112
ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
31113
ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
31114
ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
31115
ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
31116
ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
31117
ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
31118
ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
31119
ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
31120
ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
31121
ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
31122
ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
31128
ZEND_JMPZ_EX_SPEC_CV_HANDLER,
31129
ZEND_JMPZ_EX_SPEC_CV_HANDLER,
31130
ZEND_JMPZ_EX_SPEC_CV_HANDLER,
31131
ZEND_JMPZ_EX_SPEC_CV_HANDLER,
31132
ZEND_JMPZ_EX_SPEC_CV_HANDLER,
31133
ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
31134
ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
31135
ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
31136
ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
31137
ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
31138
ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
31139
ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
31140
ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
31141
ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
31142
ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
31143
ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
31144
ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
31145
ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
31146
ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
31147
ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
31153
ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
31154
ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
31155
ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
31156
ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
31157
ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
31158
ZEND_CASE_SPEC_CONST_CONST_HANDLER,
31159
ZEND_CASE_SPEC_CONST_TMP_HANDLER,
31160
ZEND_CASE_SPEC_CONST_VAR_HANDLER,
31162
ZEND_CASE_SPEC_CONST_CV_HANDLER,
31163
ZEND_CASE_SPEC_TMP_CONST_HANDLER,
31164
ZEND_CASE_SPEC_TMP_TMP_HANDLER,
31165
ZEND_CASE_SPEC_TMP_VAR_HANDLER,
31167
ZEND_CASE_SPEC_TMP_CV_HANDLER,
31168
ZEND_CASE_SPEC_VAR_CONST_HANDLER,
31169
ZEND_CASE_SPEC_VAR_TMP_HANDLER,
31170
ZEND_CASE_SPEC_VAR_VAR_HANDLER,
31172
ZEND_CASE_SPEC_VAR_CV_HANDLER,
31178
ZEND_CASE_SPEC_CV_CONST_HANDLER,
31179
ZEND_CASE_SPEC_CV_TMP_HANDLER,
31180
ZEND_CASE_SPEC_CV_VAR_HANDLER,
31182
ZEND_CASE_SPEC_CV_CV_HANDLER,
31193
ZEND_SWITCH_FREE_SPEC_VAR_HANDLER,
31194
ZEND_SWITCH_FREE_SPEC_VAR_HANDLER,
31195
ZEND_SWITCH_FREE_SPEC_VAR_HANDLER,
31196
ZEND_SWITCH_FREE_SPEC_VAR_HANDLER,
31197
ZEND_SWITCH_FREE_SPEC_VAR_HANDLER,
31208
ZEND_BRK_SPEC_CONST_HANDLER,
31209
ZEND_BRK_SPEC_TMP_HANDLER,
31210
ZEND_BRK_SPEC_VAR_HANDLER,
31212
ZEND_BRK_SPEC_CV_HANDLER,
31213
ZEND_BRK_SPEC_CONST_HANDLER,
31214
ZEND_BRK_SPEC_TMP_HANDLER,
31215
ZEND_BRK_SPEC_VAR_HANDLER,
31217
ZEND_BRK_SPEC_CV_HANDLER,
31218
ZEND_BRK_SPEC_CONST_HANDLER,
31219
ZEND_BRK_SPEC_TMP_HANDLER,
31220
ZEND_BRK_SPEC_VAR_HANDLER,
31222
ZEND_BRK_SPEC_CV_HANDLER,
31223
ZEND_BRK_SPEC_CONST_HANDLER,
31224
ZEND_BRK_SPEC_TMP_HANDLER,
31225
ZEND_BRK_SPEC_VAR_HANDLER,
31227
ZEND_BRK_SPEC_CV_HANDLER,
31228
ZEND_BRK_SPEC_CONST_HANDLER,
31229
ZEND_BRK_SPEC_TMP_HANDLER,
31230
ZEND_BRK_SPEC_VAR_HANDLER,
31232
ZEND_BRK_SPEC_CV_HANDLER,
31233
ZEND_CONT_SPEC_CONST_HANDLER,
31234
ZEND_CONT_SPEC_TMP_HANDLER,
31235
ZEND_CONT_SPEC_VAR_HANDLER,
31237
ZEND_CONT_SPEC_CV_HANDLER,
31238
ZEND_CONT_SPEC_CONST_HANDLER,
31239
ZEND_CONT_SPEC_TMP_HANDLER,
31240
ZEND_CONT_SPEC_VAR_HANDLER,
31242
ZEND_CONT_SPEC_CV_HANDLER,
31243
ZEND_CONT_SPEC_CONST_HANDLER,
31244
ZEND_CONT_SPEC_TMP_HANDLER,
31245
ZEND_CONT_SPEC_VAR_HANDLER,
31247
ZEND_CONT_SPEC_CV_HANDLER,
31248
ZEND_CONT_SPEC_CONST_HANDLER,
31249
ZEND_CONT_SPEC_TMP_HANDLER,
31250
ZEND_CONT_SPEC_VAR_HANDLER,
31252
ZEND_CONT_SPEC_CV_HANDLER,
31253
ZEND_CONT_SPEC_CONST_HANDLER,
31254
ZEND_CONT_SPEC_TMP_HANDLER,
31255
ZEND_CONT_SPEC_VAR_HANDLER,
31257
ZEND_CONT_SPEC_CV_HANDLER,
31258
ZEND_BOOL_SPEC_CONST_HANDLER,
31259
ZEND_BOOL_SPEC_CONST_HANDLER,
31260
ZEND_BOOL_SPEC_CONST_HANDLER,
31261
ZEND_BOOL_SPEC_CONST_HANDLER,
31262
ZEND_BOOL_SPEC_CONST_HANDLER,
31263
ZEND_BOOL_SPEC_TMP_HANDLER,
31264
ZEND_BOOL_SPEC_TMP_HANDLER,
31265
ZEND_BOOL_SPEC_TMP_HANDLER,
31266
ZEND_BOOL_SPEC_TMP_HANDLER,
31267
ZEND_BOOL_SPEC_TMP_HANDLER,
31268
ZEND_BOOL_SPEC_VAR_HANDLER,
31269
ZEND_BOOL_SPEC_VAR_HANDLER,
31270
ZEND_BOOL_SPEC_VAR_HANDLER,
31271
ZEND_BOOL_SPEC_VAR_HANDLER,
31272
ZEND_BOOL_SPEC_VAR_HANDLER,
31278
ZEND_BOOL_SPEC_CV_HANDLER,
31279
ZEND_BOOL_SPEC_CV_HANDLER,
31280
ZEND_BOOL_SPEC_CV_HANDLER,
31281
ZEND_BOOL_SPEC_CV_HANDLER,
31282
ZEND_BOOL_SPEC_CV_HANDLER,
31283
ZEND_INIT_STRING_SPEC_HANDLER,
31284
ZEND_INIT_STRING_SPEC_HANDLER,
31285
ZEND_INIT_STRING_SPEC_HANDLER,
31286
ZEND_INIT_STRING_SPEC_HANDLER,
31287
ZEND_INIT_STRING_SPEC_HANDLER,
31288
ZEND_INIT_STRING_SPEC_HANDLER,
31289
ZEND_INIT_STRING_SPEC_HANDLER,
31290
ZEND_INIT_STRING_SPEC_HANDLER,
31291
ZEND_INIT_STRING_SPEC_HANDLER,
31292
ZEND_INIT_STRING_SPEC_HANDLER,
31293
ZEND_INIT_STRING_SPEC_HANDLER,
31294
ZEND_INIT_STRING_SPEC_HANDLER,
31295
ZEND_INIT_STRING_SPEC_HANDLER,
31296
ZEND_INIT_STRING_SPEC_HANDLER,
31297
ZEND_INIT_STRING_SPEC_HANDLER,
31298
ZEND_INIT_STRING_SPEC_HANDLER,
31299
ZEND_INIT_STRING_SPEC_HANDLER,
31300
ZEND_INIT_STRING_SPEC_HANDLER,
31301
ZEND_INIT_STRING_SPEC_HANDLER,
31302
ZEND_INIT_STRING_SPEC_HANDLER,
31303
ZEND_INIT_STRING_SPEC_HANDLER,
31304
ZEND_INIT_STRING_SPEC_HANDLER,
31305
ZEND_INIT_STRING_SPEC_HANDLER,
31306
ZEND_INIT_STRING_SPEC_HANDLER,
31307
ZEND_INIT_STRING_SPEC_HANDLER,
31313
ZEND_ADD_CHAR_SPEC_TMP_CONST_HANDLER,
31323
ZEND_ADD_CHAR_SPEC_UNUSED_CONST_HANDLER,
31338
ZEND_ADD_STRING_SPEC_TMP_CONST_HANDLER,
31348
ZEND_ADD_STRING_SPEC_UNUSED_CONST_HANDLER,
31364
ZEND_ADD_VAR_SPEC_TMP_TMP_HANDLER,
31365
ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER,
31367
ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER,
31374
ZEND_ADD_VAR_SPEC_UNUSED_TMP_HANDLER,
31375
ZEND_ADD_VAR_SPEC_UNUSED_VAR_HANDLER,
31377
ZEND_ADD_VAR_SPEC_UNUSED_CV_HANDLER,
31383
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31384
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31385
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31386
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31387
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31388
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31389
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31390
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31391
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31392
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31393
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31394
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31395
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31396
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31397
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31398
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31399
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31400
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31401
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31402
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31403
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31404
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31405
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31406
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31407
ZEND_BEGIN_SILENCE_SPEC_HANDLER,
31413
ZEND_END_SILENCE_SPEC_TMP_HANDLER,
31414
ZEND_END_SILENCE_SPEC_TMP_HANDLER,
31415
ZEND_END_SILENCE_SPEC_TMP_HANDLER,
31416
ZEND_END_SILENCE_SPEC_TMP_HANDLER,
31417
ZEND_END_SILENCE_SPEC_TMP_HANDLER,
31433
ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
31434
ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER,
31435
ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER,
31437
ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER,
31438
ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
31439
ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER,
31440
ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER,
31442
ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER,
31443
ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
31444
ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER,
31445
ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER,
31447
ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER,
31448
ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
31449
ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER,
31450
ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER,
31452
ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER,
31453
ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
31454
ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER,
31455
ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER,
31457
ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER,
31458
ZEND_DO_FCALL_SPEC_CONST_HANDLER,
31459
ZEND_DO_FCALL_SPEC_CONST_HANDLER,
31460
ZEND_DO_FCALL_SPEC_CONST_HANDLER,
31461
ZEND_DO_FCALL_SPEC_CONST_HANDLER,
31462
ZEND_DO_FCALL_SPEC_CONST_HANDLER,
31483
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31484
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31485
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31486
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31487
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31488
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31489
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31490
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31491
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31492
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31493
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31494
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31495
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31496
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31497
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31498
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31499
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31500
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31501
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31502
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31503
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31504
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31505
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31506
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31507
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
31508
ZEND_RETURN_SPEC_CONST_HANDLER,
31509
ZEND_RETURN_SPEC_CONST_HANDLER,
31510
ZEND_RETURN_SPEC_CONST_HANDLER,
31511
ZEND_RETURN_SPEC_CONST_HANDLER,
31512
ZEND_RETURN_SPEC_CONST_HANDLER,
31513
ZEND_RETURN_SPEC_TMP_HANDLER,
31514
ZEND_RETURN_SPEC_TMP_HANDLER,
31515
ZEND_RETURN_SPEC_TMP_HANDLER,
31516
ZEND_RETURN_SPEC_TMP_HANDLER,
31517
ZEND_RETURN_SPEC_TMP_HANDLER,
31518
ZEND_RETURN_SPEC_VAR_HANDLER,
31519
ZEND_RETURN_SPEC_VAR_HANDLER,
31520
ZEND_RETURN_SPEC_VAR_HANDLER,
31521
ZEND_RETURN_SPEC_VAR_HANDLER,
31522
ZEND_RETURN_SPEC_VAR_HANDLER,
31528
ZEND_RETURN_SPEC_CV_HANDLER,
31529
ZEND_RETURN_SPEC_CV_HANDLER,
31530
ZEND_RETURN_SPEC_CV_HANDLER,
31531
ZEND_RETURN_SPEC_CV_HANDLER,
31532
ZEND_RETURN_SPEC_CV_HANDLER,
31533
ZEND_RECV_SPEC_HANDLER,
31534
ZEND_RECV_SPEC_HANDLER,
31535
ZEND_RECV_SPEC_HANDLER,
31536
ZEND_RECV_SPEC_HANDLER,
31537
ZEND_RECV_SPEC_HANDLER,
31538
ZEND_RECV_SPEC_HANDLER,
31539
ZEND_RECV_SPEC_HANDLER,
31540
ZEND_RECV_SPEC_HANDLER,
31541
ZEND_RECV_SPEC_HANDLER,
31542
ZEND_RECV_SPEC_HANDLER,
31543
ZEND_RECV_SPEC_HANDLER,
31544
ZEND_RECV_SPEC_HANDLER,
31545
ZEND_RECV_SPEC_HANDLER,
31546
ZEND_RECV_SPEC_HANDLER,
31547
ZEND_RECV_SPEC_HANDLER,
31548
ZEND_RECV_SPEC_HANDLER,
31549
ZEND_RECV_SPEC_HANDLER,
31550
ZEND_RECV_SPEC_HANDLER,
31551
ZEND_RECV_SPEC_HANDLER,
31552
ZEND_RECV_SPEC_HANDLER,
31553
ZEND_RECV_SPEC_HANDLER,
31554
ZEND_RECV_SPEC_HANDLER,
31555
ZEND_RECV_SPEC_HANDLER,
31556
ZEND_RECV_SPEC_HANDLER,
31557
ZEND_RECV_SPEC_HANDLER,
31558
ZEND_RECV_INIT_SPEC_CONST_HANDLER,
31563
ZEND_RECV_INIT_SPEC_CONST_HANDLER,
31568
ZEND_RECV_INIT_SPEC_CONST_HANDLER,
31573
ZEND_RECV_INIT_SPEC_CONST_HANDLER,
31578
ZEND_RECV_INIT_SPEC_CONST_HANDLER,
31583
ZEND_SEND_VAL_SPEC_CONST_HANDLER,
31584
ZEND_SEND_VAL_SPEC_CONST_HANDLER,
31585
ZEND_SEND_VAL_SPEC_CONST_HANDLER,
31586
ZEND_SEND_VAL_SPEC_CONST_HANDLER,
31587
ZEND_SEND_VAL_SPEC_CONST_HANDLER,
31588
ZEND_SEND_VAL_SPEC_TMP_HANDLER,
31589
ZEND_SEND_VAL_SPEC_TMP_HANDLER,
31590
ZEND_SEND_VAL_SPEC_TMP_HANDLER,
31591
ZEND_SEND_VAL_SPEC_TMP_HANDLER,
31592
ZEND_SEND_VAL_SPEC_TMP_HANDLER,
31593
ZEND_SEND_VAL_SPEC_VAR_HANDLER,
31594
ZEND_SEND_VAL_SPEC_VAR_HANDLER,
31595
ZEND_SEND_VAL_SPEC_VAR_HANDLER,
31596
ZEND_SEND_VAL_SPEC_VAR_HANDLER,
31597
ZEND_SEND_VAL_SPEC_VAR_HANDLER,
31603
ZEND_SEND_VAL_SPEC_CV_HANDLER,
31604
ZEND_SEND_VAL_SPEC_CV_HANDLER,
31605
ZEND_SEND_VAL_SPEC_CV_HANDLER,
31606
ZEND_SEND_VAL_SPEC_CV_HANDLER,
31607
ZEND_SEND_VAL_SPEC_CV_HANDLER,
31618
ZEND_SEND_VAR_SPEC_VAR_HANDLER,
31619
ZEND_SEND_VAR_SPEC_VAR_HANDLER,
31620
ZEND_SEND_VAR_SPEC_VAR_HANDLER,
31621
ZEND_SEND_VAR_SPEC_VAR_HANDLER,
31622
ZEND_SEND_VAR_SPEC_VAR_HANDLER,
31628
ZEND_SEND_VAR_SPEC_CV_HANDLER,
31629
ZEND_SEND_VAR_SPEC_CV_HANDLER,
31630
ZEND_SEND_VAR_SPEC_CV_HANDLER,
31631
ZEND_SEND_VAR_SPEC_CV_HANDLER,
31632
ZEND_SEND_VAR_SPEC_CV_HANDLER,
31643
ZEND_SEND_REF_SPEC_VAR_HANDLER,
31644
ZEND_SEND_REF_SPEC_VAR_HANDLER,
31645
ZEND_SEND_REF_SPEC_VAR_HANDLER,
31646
ZEND_SEND_REF_SPEC_VAR_HANDLER,
31647
ZEND_SEND_REF_SPEC_VAR_HANDLER,
31653
ZEND_SEND_REF_SPEC_CV_HANDLER,
31654
ZEND_SEND_REF_SPEC_CV_HANDLER,
31655
ZEND_SEND_REF_SPEC_CV_HANDLER,
31656
ZEND_SEND_REF_SPEC_CV_HANDLER,
31657
ZEND_SEND_REF_SPEC_CV_HANDLER,
31658
ZEND_NEW_SPEC_HANDLER,
31659
ZEND_NEW_SPEC_HANDLER,
31660
ZEND_NEW_SPEC_HANDLER,
31661
ZEND_NEW_SPEC_HANDLER,
31662
ZEND_NEW_SPEC_HANDLER,
31663
ZEND_NEW_SPEC_HANDLER,
31664
ZEND_NEW_SPEC_HANDLER,
31665
ZEND_NEW_SPEC_HANDLER,
31666
ZEND_NEW_SPEC_HANDLER,
31667
ZEND_NEW_SPEC_HANDLER,
31668
ZEND_NEW_SPEC_HANDLER,
31669
ZEND_NEW_SPEC_HANDLER,
31670
ZEND_NEW_SPEC_HANDLER,
31671
ZEND_NEW_SPEC_HANDLER,
31672
ZEND_NEW_SPEC_HANDLER,
31673
ZEND_NEW_SPEC_HANDLER,
31674
ZEND_NEW_SPEC_HANDLER,
31675
ZEND_NEW_SPEC_HANDLER,
31676
ZEND_NEW_SPEC_HANDLER,
31677
ZEND_NEW_SPEC_HANDLER,
31678
ZEND_NEW_SPEC_HANDLER,
31679
ZEND_NEW_SPEC_HANDLER,
31680
ZEND_NEW_SPEC_HANDLER,
31681
ZEND_NEW_SPEC_HANDLER,
31682
ZEND_NEW_SPEC_HANDLER,
31683
ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
31688
ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
31693
ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
31698
ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
31703
ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
31713
ZEND_FREE_SPEC_TMP_HANDLER,
31714
ZEND_FREE_SPEC_TMP_HANDLER,
31715
ZEND_FREE_SPEC_TMP_HANDLER,
31716
ZEND_FREE_SPEC_TMP_HANDLER,
31717
ZEND_FREE_SPEC_TMP_HANDLER,
31733
ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER,
31734
ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER,
31735
ZEND_INIT_ARRAY_SPEC_CONST_VAR_HANDLER,
31736
ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER,
31737
ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER,
31738
ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER,
31739
ZEND_INIT_ARRAY_SPEC_TMP_TMP_HANDLER,
31740
ZEND_INIT_ARRAY_SPEC_TMP_VAR_HANDLER,
31741
ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER,
31742
ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER,
31743
ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER,
31744
ZEND_INIT_ARRAY_SPEC_VAR_TMP_HANDLER,
31745
ZEND_INIT_ARRAY_SPEC_VAR_VAR_HANDLER,
31746
ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER,
31747
ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER,
31748
ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER,
31749
ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER,
31750
ZEND_INIT_ARRAY_SPEC_UNUSED_VAR_HANDLER,
31751
ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER,
31752
ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER,
31753
ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER,
31754
ZEND_INIT_ARRAY_SPEC_CV_TMP_HANDLER,
31755
ZEND_INIT_ARRAY_SPEC_CV_VAR_HANDLER,
31756
ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER,
31757
ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER,
31758
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER,
31759
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER,
31760
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER,
31761
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER,
31762
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER,
31763
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER,
31764
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER,
31765
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER,
31766
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER,
31767
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER,
31768
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER,
31769
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER,
31770
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER,
31771
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER,
31772
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER,
31778
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER,
31779
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER,
31780
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER,
31781
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER,
31782
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER,
31783
ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
31784
ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
31785
ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
31786
ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
31787
ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
31788
ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER,
31789
ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER,
31790
ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER,
31791
ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER,
31792
ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER,
31793
ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER,
31794
ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER,
31795
ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER,
31796
ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER,
31797
ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER,
31803
ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
31804
ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
31805
ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
31806
ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
31807
ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
31808
ZEND_UNSET_VAR_SPEC_CONST_HANDLER,
31809
ZEND_UNSET_VAR_SPEC_CONST_HANDLER,
31810
ZEND_UNSET_VAR_SPEC_CONST_HANDLER,
31811
ZEND_UNSET_VAR_SPEC_CONST_HANDLER,
31812
ZEND_UNSET_VAR_SPEC_CONST_HANDLER,
31813
ZEND_UNSET_VAR_SPEC_TMP_HANDLER,
31814
ZEND_UNSET_VAR_SPEC_TMP_HANDLER,
31815
ZEND_UNSET_VAR_SPEC_TMP_HANDLER,
31816
ZEND_UNSET_VAR_SPEC_TMP_HANDLER,
31817
ZEND_UNSET_VAR_SPEC_TMP_HANDLER,
31818
ZEND_UNSET_VAR_SPEC_VAR_HANDLER,
31819
ZEND_UNSET_VAR_SPEC_VAR_HANDLER,
31820
ZEND_UNSET_VAR_SPEC_VAR_HANDLER,
31821
ZEND_UNSET_VAR_SPEC_VAR_HANDLER,
31822
ZEND_UNSET_VAR_SPEC_VAR_HANDLER,
31828
ZEND_UNSET_VAR_SPEC_CV_HANDLER,
31829
ZEND_UNSET_VAR_SPEC_CV_HANDLER,
31830
ZEND_UNSET_VAR_SPEC_CV_HANDLER,
31831
ZEND_UNSET_VAR_SPEC_CV_HANDLER,
31832
ZEND_UNSET_VAR_SPEC_CV_HANDLER,
31843
ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER,
31844
ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER,
31845
ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER,
31847
ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER,
31848
ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER,
31849
ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER,
31850
ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER,
31852
ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER,
31853
ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER,
31854
ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER,
31855
ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER,
31857
ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER,
31868
ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER,
31869
ZEND_UNSET_OBJ_SPEC_VAR_TMP_HANDLER,
31870
ZEND_UNSET_OBJ_SPEC_VAR_VAR_HANDLER,
31872
ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER,
31873
ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER,
31874
ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER,
31875
ZEND_UNSET_OBJ_SPEC_UNUSED_VAR_HANDLER,
31877
ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER,
31878
ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER,
31879
ZEND_UNSET_OBJ_SPEC_CV_TMP_HANDLER,
31880
ZEND_UNSET_OBJ_SPEC_CV_VAR_HANDLER,
31882
ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER,
31883
ZEND_FE_RESET_SPEC_CONST_HANDLER,
31884
ZEND_FE_RESET_SPEC_CONST_HANDLER,
31885
ZEND_FE_RESET_SPEC_CONST_HANDLER,
31886
ZEND_FE_RESET_SPEC_CONST_HANDLER,
31887
ZEND_FE_RESET_SPEC_CONST_HANDLER,
31888
ZEND_FE_RESET_SPEC_TMP_HANDLER,
31889
ZEND_FE_RESET_SPEC_TMP_HANDLER,
31890
ZEND_FE_RESET_SPEC_TMP_HANDLER,
31891
ZEND_FE_RESET_SPEC_TMP_HANDLER,
31892
ZEND_FE_RESET_SPEC_TMP_HANDLER,
31893
ZEND_FE_RESET_SPEC_VAR_HANDLER,
31894
ZEND_FE_RESET_SPEC_VAR_HANDLER,
31895
ZEND_FE_RESET_SPEC_VAR_HANDLER,
31896
ZEND_FE_RESET_SPEC_VAR_HANDLER,
31897
ZEND_FE_RESET_SPEC_VAR_HANDLER,
31903
ZEND_FE_RESET_SPEC_CV_HANDLER,
31904
ZEND_FE_RESET_SPEC_CV_HANDLER,
31905
ZEND_FE_RESET_SPEC_CV_HANDLER,
31906
ZEND_FE_RESET_SPEC_CV_HANDLER,
31907
ZEND_FE_RESET_SPEC_CV_HANDLER,
31918
ZEND_FE_FETCH_SPEC_VAR_HANDLER,
31919
ZEND_FE_FETCH_SPEC_VAR_HANDLER,
31920
ZEND_FE_FETCH_SPEC_VAR_HANDLER,
31921
ZEND_FE_FETCH_SPEC_VAR_HANDLER,
31922
ZEND_FE_FETCH_SPEC_VAR_HANDLER,
31933
ZEND_EXIT_SPEC_CONST_HANDLER,
31934
ZEND_EXIT_SPEC_CONST_HANDLER,
31935
ZEND_EXIT_SPEC_CONST_HANDLER,
31936
ZEND_EXIT_SPEC_CONST_HANDLER,
31937
ZEND_EXIT_SPEC_CONST_HANDLER,
31938
ZEND_EXIT_SPEC_TMP_HANDLER,
31939
ZEND_EXIT_SPEC_TMP_HANDLER,
31940
ZEND_EXIT_SPEC_TMP_HANDLER,
31941
ZEND_EXIT_SPEC_TMP_HANDLER,
31942
ZEND_EXIT_SPEC_TMP_HANDLER,
31943
ZEND_EXIT_SPEC_VAR_HANDLER,
31944
ZEND_EXIT_SPEC_VAR_HANDLER,
31945
ZEND_EXIT_SPEC_VAR_HANDLER,
31946
ZEND_EXIT_SPEC_VAR_HANDLER,
31947
ZEND_EXIT_SPEC_VAR_HANDLER,
31948
ZEND_EXIT_SPEC_UNUSED_HANDLER,
31949
ZEND_EXIT_SPEC_UNUSED_HANDLER,
31950
ZEND_EXIT_SPEC_UNUSED_HANDLER,
31951
ZEND_EXIT_SPEC_UNUSED_HANDLER,
31952
ZEND_EXIT_SPEC_UNUSED_HANDLER,
31953
ZEND_EXIT_SPEC_CV_HANDLER,
31954
ZEND_EXIT_SPEC_CV_HANDLER,
31955
ZEND_EXIT_SPEC_CV_HANDLER,
31956
ZEND_EXIT_SPEC_CV_HANDLER,
31957
ZEND_EXIT_SPEC_CV_HANDLER,
31958
ZEND_FETCH_R_SPEC_CONST_HANDLER,
31959
ZEND_FETCH_R_SPEC_CONST_HANDLER,
31960
ZEND_FETCH_R_SPEC_CONST_HANDLER,
31961
ZEND_FETCH_R_SPEC_CONST_HANDLER,
31962
ZEND_FETCH_R_SPEC_CONST_HANDLER,
31963
ZEND_FETCH_R_SPEC_TMP_HANDLER,
31964
ZEND_FETCH_R_SPEC_TMP_HANDLER,
31965
ZEND_FETCH_R_SPEC_TMP_HANDLER,
31966
ZEND_FETCH_R_SPEC_TMP_HANDLER,
31967
ZEND_FETCH_R_SPEC_TMP_HANDLER,
31968
ZEND_FETCH_R_SPEC_VAR_HANDLER,
31969
ZEND_FETCH_R_SPEC_VAR_HANDLER,
31970
ZEND_FETCH_R_SPEC_VAR_HANDLER,
31971
ZEND_FETCH_R_SPEC_VAR_HANDLER,
31972
ZEND_FETCH_R_SPEC_VAR_HANDLER,
31978
ZEND_FETCH_R_SPEC_CV_HANDLER,
31979
ZEND_FETCH_R_SPEC_CV_HANDLER,
31980
ZEND_FETCH_R_SPEC_CV_HANDLER,
31981
ZEND_FETCH_R_SPEC_CV_HANDLER,
31982
ZEND_FETCH_R_SPEC_CV_HANDLER,
31993
ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER,
31994
ZEND_FETCH_DIM_R_SPEC_VAR_TMP_HANDLER,
31995
ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER,
31997
ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER,
32003
ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER,
32004
ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER,
32005
ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER,
32007
ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER,
32018
ZEND_FETCH_OBJ_R_SPEC_VAR_CONST_HANDLER,
32019
ZEND_FETCH_OBJ_R_SPEC_VAR_TMP_HANDLER,
32020
ZEND_FETCH_OBJ_R_SPEC_VAR_VAR_HANDLER,
32022
ZEND_FETCH_OBJ_R_SPEC_VAR_CV_HANDLER,
32023
ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER,
32024
ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_HANDLER,
32025
ZEND_FETCH_OBJ_R_SPEC_UNUSED_VAR_HANDLER,
32027
ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER,
32028
ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER,
32029
ZEND_FETCH_OBJ_R_SPEC_CV_TMP_HANDLER,
32030
ZEND_FETCH_OBJ_R_SPEC_CV_VAR_HANDLER,
32032
ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER,
32033
ZEND_FETCH_W_SPEC_CONST_HANDLER,
32034
ZEND_FETCH_W_SPEC_CONST_HANDLER,
32035
ZEND_FETCH_W_SPEC_CONST_HANDLER,
32036
ZEND_FETCH_W_SPEC_CONST_HANDLER,
32037
ZEND_FETCH_W_SPEC_CONST_HANDLER,
32038
ZEND_FETCH_W_SPEC_TMP_HANDLER,
32039
ZEND_FETCH_W_SPEC_TMP_HANDLER,
32040
ZEND_FETCH_W_SPEC_TMP_HANDLER,
32041
ZEND_FETCH_W_SPEC_TMP_HANDLER,
32042
ZEND_FETCH_W_SPEC_TMP_HANDLER,
32043
ZEND_FETCH_W_SPEC_VAR_HANDLER,
32044
ZEND_FETCH_W_SPEC_VAR_HANDLER,
32045
ZEND_FETCH_W_SPEC_VAR_HANDLER,
32046
ZEND_FETCH_W_SPEC_VAR_HANDLER,
32047
ZEND_FETCH_W_SPEC_VAR_HANDLER,
32053
ZEND_FETCH_W_SPEC_CV_HANDLER,
32054
ZEND_FETCH_W_SPEC_CV_HANDLER,
32055
ZEND_FETCH_W_SPEC_CV_HANDLER,
32056
ZEND_FETCH_W_SPEC_CV_HANDLER,
32057
ZEND_FETCH_W_SPEC_CV_HANDLER,
32068
ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER,
32069
ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER,
32070
ZEND_FETCH_DIM_W_SPEC_VAR_VAR_HANDLER,
32071
ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER,
32072
ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER,
32078
ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER,
32079
ZEND_FETCH_DIM_W_SPEC_CV_TMP_HANDLER,
32080
ZEND_FETCH_DIM_W_SPEC_CV_VAR_HANDLER,
32081
ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER,
32082
ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER,
32093
ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER,
32094
ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_HANDLER,
32095
ZEND_FETCH_OBJ_W_SPEC_VAR_VAR_HANDLER,
32097
ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER,
32098
ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER,
32099
ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER,
32100
ZEND_FETCH_OBJ_W_SPEC_UNUSED_VAR_HANDLER,
32102
ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER,
32103
ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER,
32104
ZEND_FETCH_OBJ_W_SPEC_CV_TMP_HANDLER,
32105
ZEND_FETCH_OBJ_W_SPEC_CV_VAR_HANDLER,
32107
ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER,
32108
ZEND_FETCH_RW_SPEC_CONST_HANDLER,
32109
ZEND_FETCH_RW_SPEC_CONST_HANDLER,
32110
ZEND_FETCH_RW_SPEC_CONST_HANDLER,
32111
ZEND_FETCH_RW_SPEC_CONST_HANDLER,
32112
ZEND_FETCH_RW_SPEC_CONST_HANDLER,
32113
ZEND_FETCH_RW_SPEC_TMP_HANDLER,
32114
ZEND_FETCH_RW_SPEC_TMP_HANDLER,
32115
ZEND_FETCH_RW_SPEC_TMP_HANDLER,
32116
ZEND_FETCH_RW_SPEC_TMP_HANDLER,
32117
ZEND_FETCH_RW_SPEC_TMP_HANDLER,
32118
ZEND_FETCH_RW_SPEC_VAR_HANDLER,
32119
ZEND_FETCH_RW_SPEC_VAR_HANDLER,
32120
ZEND_FETCH_RW_SPEC_VAR_HANDLER,
32121
ZEND_FETCH_RW_SPEC_VAR_HANDLER,
32122
ZEND_FETCH_RW_SPEC_VAR_HANDLER,
32128
ZEND_FETCH_RW_SPEC_CV_HANDLER,
32129
ZEND_FETCH_RW_SPEC_CV_HANDLER,
32130
ZEND_FETCH_RW_SPEC_CV_HANDLER,
32131
ZEND_FETCH_RW_SPEC_CV_HANDLER,
32132
ZEND_FETCH_RW_SPEC_CV_HANDLER,
32143
ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER,
32144
ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_HANDLER,
32145
ZEND_FETCH_DIM_RW_SPEC_VAR_VAR_HANDLER,
32146
ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER,
32147
ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER,
32153
ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER,
32154
ZEND_FETCH_DIM_RW_SPEC_CV_TMP_HANDLER,
32155
ZEND_FETCH_DIM_RW_SPEC_CV_VAR_HANDLER,
32156
ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER,
32157
ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER,
32168
ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER,
32169
ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_HANDLER,
32170
ZEND_FETCH_OBJ_RW_SPEC_VAR_VAR_HANDLER,
32172
ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER,
32173
ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER,
32174
ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER,
32175
ZEND_FETCH_OBJ_RW_SPEC_UNUSED_VAR_HANDLER,
32177
ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER,
32178
ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER,
32179
ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_HANDLER,
32180
ZEND_FETCH_OBJ_RW_SPEC_CV_VAR_HANDLER,
32182
ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER,
32183
ZEND_FETCH_IS_SPEC_CONST_HANDLER,
32184
ZEND_FETCH_IS_SPEC_CONST_HANDLER,
32185
ZEND_FETCH_IS_SPEC_CONST_HANDLER,
32186
ZEND_FETCH_IS_SPEC_CONST_HANDLER,
32187
ZEND_FETCH_IS_SPEC_CONST_HANDLER,
32188
ZEND_FETCH_IS_SPEC_TMP_HANDLER,
32189
ZEND_FETCH_IS_SPEC_TMP_HANDLER,
32190
ZEND_FETCH_IS_SPEC_TMP_HANDLER,
32191
ZEND_FETCH_IS_SPEC_TMP_HANDLER,
32192
ZEND_FETCH_IS_SPEC_TMP_HANDLER,
32193
ZEND_FETCH_IS_SPEC_VAR_HANDLER,
32194
ZEND_FETCH_IS_SPEC_VAR_HANDLER,
32195
ZEND_FETCH_IS_SPEC_VAR_HANDLER,
32196
ZEND_FETCH_IS_SPEC_VAR_HANDLER,
32197
ZEND_FETCH_IS_SPEC_VAR_HANDLER,
32203
ZEND_FETCH_IS_SPEC_CV_HANDLER,
32204
ZEND_FETCH_IS_SPEC_CV_HANDLER,
32205
ZEND_FETCH_IS_SPEC_CV_HANDLER,
32206
ZEND_FETCH_IS_SPEC_CV_HANDLER,
32207
ZEND_FETCH_IS_SPEC_CV_HANDLER,
32218
ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER,
32219
ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER,
32220
ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER,
32222
ZEND_FETCH_DIM_IS_SPEC_VAR_CV_HANDLER,
32228
ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER,
32229
ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER,
32230
ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER,
32232
ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER,
32243
ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER,
32244
ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER,
32245
ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER,
32247
ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER,
32248
ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER,
32249
ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER,
32250
ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER,
32252
ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER,
32253
ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER,
32254
ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER,
32255
ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER,
32257
ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER,
32258
ZEND_FETCH_FUNC_ARG_SPEC_CONST_HANDLER,
32259
ZEND_FETCH_FUNC_ARG_SPEC_CONST_HANDLER,
32260
ZEND_FETCH_FUNC_ARG_SPEC_CONST_HANDLER,
32261
ZEND_FETCH_FUNC_ARG_SPEC_CONST_HANDLER,
32262
ZEND_FETCH_FUNC_ARG_SPEC_CONST_HANDLER,
32263
ZEND_FETCH_FUNC_ARG_SPEC_TMP_HANDLER,
32264
ZEND_FETCH_FUNC_ARG_SPEC_TMP_HANDLER,
32265
ZEND_FETCH_FUNC_ARG_SPEC_TMP_HANDLER,
32266
ZEND_FETCH_FUNC_ARG_SPEC_TMP_HANDLER,
32267
ZEND_FETCH_FUNC_ARG_SPEC_TMP_HANDLER,
32268
ZEND_FETCH_FUNC_ARG_SPEC_VAR_HANDLER,
32269
ZEND_FETCH_FUNC_ARG_SPEC_VAR_HANDLER,
32270
ZEND_FETCH_FUNC_ARG_SPEC_VAR_HANDLER,
32271
ZEND_FETCH_FUNC_ARG_SPEC_VAR_HANDLER,
32272
ZEND_FETCH_FUNC_ARG_SPEC_VAR_HANDLER,
32278
ZEND_FETCH_FUNC_ARG_SPEC_CV_HANDLER,
32279
ZEND_FETCH_FUNC_ARG_SPEC_CV_HANDLER,
32280
ZEND_FETCH_FUNC_ARG_SPEC_CV_HANDLER,
32281
ZEND_FETCH_FUNC_ARG_SPEC_CV_HANDLER,
32282
ZEND_FETCH_FUNC_ARG_SPEC_CV_HANDLER,
32293
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
32294
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER,
32295
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER,
32296
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER,
32297
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER,
32303
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER,
32304
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER,
32305
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER,
32306
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
32307
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER,
32318
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
32319
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER,
32320
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER,
32322
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER,
32323
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
32324
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER,
32325
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_VAR_HANDLER,
32327
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER,
32328
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER,
32329
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER,
32330
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_VAR_HANDLER,
32332
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER,
32333
ZEND_FETCH_UNSET_SPEC_CONST_HANDLER,
32334
ZEND_FETCH_UNSET_SPEC_CONST_HANDLER,
32335
ZEND_FETCH_UNSET_SPEC_CONST_HANDLER,
32336
ZEND_FETCH_UNSET_SPEC_CONST_HANDLER,
32337
ZEND_FETCH_UNSET_SPEC_CONST_HANDLER,
32338
ZEND_FETCH_UNSET_SPEC_TMP_HANDLER,
32339
ZEND_FETCH_UNSET_SPEC_TMP_HANDLER,
32340
ZEND_FETCH_UNSET_SPEC_TMP_HANDLER,
32341
ZEND_FETCH_UNSET_SPEC_TMP_HANDLER,
32342
ZEND_FETCH_UNSET_SPEC_TMP_HANDLER,
32343
ZEND_FETCH_UNSET_SPEC_VAR_HANDLER,
32344
ZEND_FETCH_UNSET_SPEC_VAR_HANDLER,
32345
ZEND_FETCH_UNSET_SPEC_VAR_HANDLER,
32346
ZEND_FETCH_UNSET_SPEC_VAR_HANDLER,
32347
ZEND_FETCH_UNSET_SPEC_VAR_HANDLER,
32353
ZEND_FETCH_UNSET_SPEC_CV_HANDLER,
32354
ZEND_FETCH_UNSET_SPEC_CV_HANDLER,
32355
ZEND_FETCH_UNSET_SPEC_CV_HANDLER,
32356
ZEND_FETCH_UNSET_SPEC_CV_HANDLER,
32357
ZEND_FETCH_UNSET_SPEC_CV_HANDLER,
32368
ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER,
32369
ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_HANDLER,
32370
ZEND_FETCH_DIM_UNSET_SPEC_VAR_VAR_HANDLER,
32372
ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER,
32378
ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER,
32379
ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER,
32380
ZEND_FETCH_DIM_UNSET_SPEC_CV_VAR_HANDLER,
32382
ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER,
32393
ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER,
32394
ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_HANDLER,
32395
ZEND_FETCH_OBJ_UNSET_SPEC_VAR_VAR_HANDLER,
32397
ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER,
32398
ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER,
32399
ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER,
32400
ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_VAR_HANDLER,
32402
ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER,
32403
ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER,
32404
ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_HANDLER,
32405
ZEND_FETCH_OBJ_UNSET_SPEC_CV_VAR_HANDLER,
32407
ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER,
32408
ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER,
32413
ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER,
32433
ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER,
32443
ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER,
32448
ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER,
32458
ZEND_GOTO_SPEC_CONST_HANDLER,
32463
ZEND_GOTO_SPEC_CONST_HANDLER,
32468
ZEND_GOTO_SPEC_CONST_HANDLER,
32473
ZEND_GOTO_SPEC_CONST_HANDLER,
32478
ZEND_GOTO_SPEC_CONST_HANDLER,
32483
ZEND_EXT_STMT_SPEC_HANDLER,
32484
ZEND_EXT_STMT_SPEC_HANDLER,
32485
ZEND_EXT_STMT_SPEC_HANDLER,
32486
ZEND_EXT_STMT_SPEC_HANDLER,
32487
ZEND_EXT_STMT_SPEC_HANDLER,
32488
ZEND_EXT_STMT_SPEC_HANDLER,
32489
ZEND_EXT_STMT_SPEC_HANDLER,
32490
ZEND_EXT_STMT_SPEC_HANDLER,
32491
ZEND_EXT_STMT_SPEC_HANDLER,
32492
ZEND_EXT_STMT_SPEC_HANDLER,
32493
ZEND_EXT_STMT_SPEC_HANDLER,
32494
ZEND_EXT_STMT_SPEC_HANDLER,
32495
ZEND_EXT_STMT_SPEC_HANDLER,
32496
ZEND_EXT_STMT_SPEC_HANDLER,
32497
ZEND_EXT_STMT_SPEC_HANDLER,
32498
ZEND_EXT_STMT_SPEC_HANDLER,
32499
ZEND_EXT_STMT_SPEC_HANDLER,
32500
ZEND_EXT_STMT_SPEC_HANDLER,
32501
ZEND_EXT_STMT_SPEC_HANDLER,
32502
ZEND_EXT_STMT_SPEC_HANDLER,
32503
ZEND_EXT_STMT_SPEC_HANDLER,
32504
ZEND_EXT_STMT_SPEC_HANDLER,
32505
ZEND_EXT_STMT_SPEC_HANDLER,
32506
ZEND_EXT_STMT_SPEC_HANDLER,
32507
ZEND_EXT_STMT_SPEC_HANDLER,
32508
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32509
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32510
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32511
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32512
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32513
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32514
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32515
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32516
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32517
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32518
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32519
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32520
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32521
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32522
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32523
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32524
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32525
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32526
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32527
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32528
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32529
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32530
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32531
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32532
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
32533
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32534
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32535
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32536
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32537
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32538
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32539
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32540
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32541
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32542
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32543
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32544
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32545
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32546
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32547
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32548
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32549
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32550
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32551
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32552
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32553
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32554
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32555
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32556
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32557
ZEND_EXT_FCALL_END_SPEC_HANDLER,
32558
ZEND_EXT_NOP_SPEC_HANDLER,
32559
ZEND_EXT_NOP_SPEC_HANDLER,
32560
ZEND_EXT_NOP_SPEC_HANDLER,
32561
ZEND_EXT_NOP_SPEC_HANDLER,
32562
ZEND_EXT_NOP_SPEC_HANDLER,
32563
ZEND_EXT_NOP_SPEC_HANDLER,
32564
ZEND_EXT_NOP_SPEC_HANDLER,
32565
ZEND_EXT_NOP_SPEC_HANDLER,
32566
ZEND_EXT_NOP_SPEC_HANDLER,
32567
ZEND_EXT_NOP_SPEC_HANDLER,
32568
ZEND_EXT_NOP_SPEC_HANDLER,
32569
ZEND_EXT_NOP_SPEC_HANDLER,
32570
ZEND_EXT_NOP_SPEC_HANDLER,
32571
ZEND_EXT_NOP_SPEC_HANDLER,
32572
ZEND_EXT_NOP_SPEC_HANDLER,
32573
ZEND_EXT_NOP_SPEC_HANDLER,
32574
ZEND_EXT_NOP_SPEC_HANDLER,
32575
ZEND_EXT_NOP_SPEC_HANDLER,
32576
ZEND_EXT_NOP_SPEC_HANDLER,
32577
ZEND_EXT_NOP_SPEC_HANDLER,
32578
ZEND_EXT_NOP_SPEC_HANDLER,
32579
ZEND_EXT_NOP_SPEC_HANDLER,
32580
ZEND_EXT_NOP_SPEC_HANDLER,
32581
ZEND_EXT_NOP_SPEC_HANDLER,
32582
ZEND_EXT_NOP_SPEC_HANDLER,
32583
ZEND_TICKS_SPEC_CONST_HANDLER,
32584
ZEND_TICKS_SPEC_CONST_HANDLER,
32585
ZEND_TICKS_SPEC_CONST_HANDLER,
32586
ZEND_TICKS_SPEC_CONST_HANDLER,
32587
ZEND_TICKS_SPEC_CONST_HANDLER,
32618
ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER,
32619
ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER,
32620
ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER,
32621
ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER,
32622
ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER,
32628
ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER,
32629
ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER,
32630
ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER,
32631
ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER,
32632
ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER,
32637
ZEND_CATCH_SPEC_CV_HANDLER,
32642
ZEND_CATCH_SPEC_CV_HANDLER,
32647
ZEND_CATCH_SPEC_CV_HANDLER,
32652
ZEND_CATCH_SPEC_CV_HANDLER,
32657
ZEND_CATCH_SPEC_CV_HANDLER,
32658
ZEND_THROW_SPEC_CONST_HANDLER,
32659
ZEND_THROW_SPEC_CONST_HANDLER,
32660
ZEND_THROW_SPEC_CONST_HANDLER,
32661
ZEND_THROW_SPEC_CONST_HANDLER,
32662
ZEND_THROW_SPEC_CONST_HANDLER,
32663
ZEND_THROW_SPEC_TMP_HANDLER,
32664
ZEND_THROW_SPEC_TMP_HANDLER,
32665
ZEND_THROW_SPEC_TMP_HANDLER,
32666
ZEND_THROW_SPEC_TMP_HANDLER,
32667
ZEND_THROW_SPEC_TMP_HANDLER,
32668
ZEND_THROW_SPEC_VAR_HANDLER,
32669
ZEND_THROW_SPEC_VAR_HANDLER,
32670
ZEND_THROW_SPEC_VAR_HANDLER,
32671
ZEND_THROW_SPEC_VAR_HANDLER,
32672
ZEND_THROW_SPEC_VAR_HANDLER,
32678
ZEND_THROW_SPEC_CV_HANDLER,
32679
ZEND_THROW_SPEC_CV_HANDLER,
32680
ZEND_THROW_SPEC_CV_HANDLER,
32681
ZEND_THROW_SPEC_CV_HANDLER,
32682
ZEND_THROW_SPEC_CV_HANDLER,
32683
ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
32684
ZEND_FETCH_CLASS_SPEC_TMP_HANDLER,
32685
ZEND_FETCH_CLASS_SPEC_VAR_HANDLER,
32686
ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
32687
ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
32688
ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
32689
ZEND_FETCH_CLASS_SPEC_TMP_HANDLER,
32690
ZEND_FETCH_CLASS_SPEC_VAR_HANDLER,
32691
ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
32692
ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
32693
ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
32694
ZEND_FETCH_CLASS_SPEC_TMP_HANDLER,
32695
ZEND_FETCH_CLASS_SPEC_VAR_HANDLER,
32696
ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
32697
ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
32698
ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
32699
ZEND_FETCH_CLASS_SPEC_TMP_HANDLER,
32700
ZEND_FETCH_CLASS_SPEC_VAR_HANDLER,
32701
ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
32702
ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
32703
ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
32704
ZEND_FETCH_CLASS_SPEC_TMP_HANDLER,
32705
ZEND_FETCH_CLASS_SPEC_VAR_HANDLER,
32706
ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
32707
ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
32708
ZEND_CLONE_SPEC_CONST_HANDLER,
32709
ZEND_CLONE_SPEC_CONST_HANDLER,
32710
ZEND_CLONE_SPEC_CONST_HANDLER,
32711
ZEND_CLONE_SPEC_CONST_HANDLER,
32712
ZEND_CLONE_SPEC_CONST_HANDLER,
32713
ZEND_CLONE_SPEC_TMP_HANDLER,
32714
ZEND_CLONE_SPEC_TMP_HANDLER,
32715
ZEND_CLONE_SPEC_TMP_HANDLER,
32716
ZEND_CLONE_SPEC_TMP_HANDLER,
32717
ZEND_CLONE_SPEC_TMP_HANDLER,
32718
ZEND_CLONE_SPEC_VAR_HANDLER,
32719
ZEND_CLONE_SPEC_VAR_HANDLER,
32720
ZEND_CLONE_SPEC_VAR_HANDLER,
32721
ZEND_CLONE_SPEC_VAR_HANDLER,
32722
ZEND_CLONE_SPEC_VAR_HANDLER,
32723
ZEND_CLONE_SPEC_UNUSED_HANDLER,
32724
ZEND_CLONE_SPEC_UNUSED_HANDLER,
32725
ZEND_CLONE_SPEC_UNUSED_HANDLER,
32726
ZEND_CLONE_SPEC_UNUSED_HANDLER,
32727
ZEND_CLONE_SPEC_UNUSED_HANDLER,
32728
ZEND_CLONE_SPEC_CV_HANDLER,
32729
ZEND_CLONE_SPEC_CV_HANDLER,
32730
ZEND_CLONE_SPEC_CV_HANDLER,
32731
ZEND_CLONE_SPEC_CV_HANDLER,
32732
ZEND_CLONE_SPEC_CV_HANDLER,
32763
ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER,
32764
ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER,
32765
ZEND_INIT_METHOD_CALL_SPEC_TMP_VAR_HANDLER,
32767
ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER,
32768
ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER,
32769
ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER,
32770
ZEND_INIT_METHOD_CALL_SPEC_VAR_VAR_HANDLER,
32772
ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER,
32773
ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER,
32774
ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER,
32775
ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER,
32777
ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER,
32778
ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER,
32779
ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER,
32780
ZEND_INIT_METHOD_CALL_SPEC_CV_VAR_HANDLER,
32782
ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER,
32783
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER,
32784
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER,
32785
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER,
32786
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER,
32787
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER,
32793
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER,
32794
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER,
32795
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER,
32796
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER,
32797
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER,
32808
ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER,
32809
ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER,
32810
ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER,
32811
ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER,
32812
ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER,
32813
ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER,
32814
ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER,
32815
ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER,
32816
ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER,
32817
ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER,
32818
ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER,
32819
ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER,
32820
ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER,
32821
ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER,
32822
ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER,
32828
ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER,
32829
ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER,
32830
ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER,
32831
ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER,
32832
ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER,
32843
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER,
32844
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER,
32845
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER,
32847
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CV_HANDLER,
32848
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CONST_HANDLER,
32849
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_TMP_HANDLER,
32850
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_VAR_HANDLER,
32852
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CV_HANDLER,
32853
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER,
32854
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER,
32855
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_VAR_HANDLER,
32857
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER,
33268
ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER,
33269
ZEND_PRE_INC_OBJ_SPEC_VAR_TMP_HANDLER,
33270
ZEND_PRE_INC_OBJ_SPEC_VAR_VAR_HANDLER,
33272
ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER,
33273
ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER,
33274
ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP_HANDLER,
33275
ZEND_PRE_INC_OBJ_SPEC_UNUSED_VAR_HANDLER,
33277
ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER,
33278
ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER,
33279
ZEND_PRE_INC_OBJ_SPEC_CV_TMP_HANDLER,
33280
ZEND_PRE_INC_OBJ_SPEC_CV_VAR_HANDLER,
33282
ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER,
33293
ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST_HANDLER,
33294
ZEND_PRE_DEC_OBJ_SPEC_VAR_TMP_HANDLER,
33295
ZEND_PRE_DEC_OBJ_SPEC_VAR_VAR_HANDLER,
33297
ZEND_PRE_DEC_OBJ_SPEC_VAR_CV_HANDLER,
33298
ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER,
33299
ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER,
33300
ZEND_PRE_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER,
33302
ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV_HANDLER,
33303
ZEND_PRE_DEC_OBJ_SPEC_CV_CONST_HANDLER,
33304
ZEND_PRE_DEC_OBJ_SPEC_CV_TMP_HANDLER,
33305
ZEND_PRE_DEC_OBJ_SPEC_CV_VAR_HANDLER,
33307
ZEND_PRE_DEC_OBJ_SPEC_CV_CV_HANDLER,
33318
ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER,
33319
ZEND_POST_INC_OBJ_SPEC_VAR_TMP_HANDLER,
33320
ZEND_POST_INC_OBJ_SPEC_VAR_VAR_HANDLER,
33322
ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER,
33323
ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER,
33324
ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP_HANDLER,
33325
ZEND_POST_INC_OBJ_SPEC_UNUSED_VAR_HANDLER,
33327
ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER,
33328
ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER,
33329
ZEND_POST_INC_OBJ_SPEC_CV_TMP_HANDLER,
33330
ZEND_POST_INC_OBJ_SPEC_CV_VAR_HANDLER,
33332
ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER,
33343
ZEND_POST_DEC_OBJ_SPEC_VAR_CONST_HANDLER,
33344
ZEND_POST_DEC_OBJ_SPEC_VAR_TMP_HANDLER,
33345
ZEND_POST_DEC_OBJ_SPEC_VAR_VAR_HANDLER,
33347
ZEND_POST_DEC_OBJ_SPEC_VAR_CV_HANDLER,
33348
ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER,
33349
ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER,
33350
ZEND_POST_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER,
33352
ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV_HANDLER,
33353
ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER,
33354
ZEND_POST_DEC_OBJ_SPEC_CV_TMP_HANDLER,
33355
ZEND_POST_DEC_OBJ_SPEC_CV_VAR_HANDLER,
33357
ZEND_POST_DEC_OBJ_SPEC_CV_CV_HANDLER,
33368
ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_HANDLER,
33369
ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_HANDLER,
33370
ZEND_ASSIGN_OBJ_SPEC_VAR_VAR_HANDLER,
33372
ZEND_ASSIGN_OBJ_SPEC_VAR_CV_HANDLER,
33373
ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER,
33374
ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_HANDLER,
33375
ZEND_ASSIGN_OBJ_SPEC_UNUSED_VAR_HANDLER,
33377
ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER,
33378
ZEND_ASSIGN_OBJ_SPEC_CV_CONST_HANDLER,
33379
ZEND_ASSIGN_OBJ_SPEC_CV_TMP_HANDLER,
33380
ZEND_ASSIGN_OBJ_SPEC_CV_VAR_HANDLER,
33382
ZEND_ASSIGN_OBJ_SPEC_CV_CV_HANDLER,
33413
ZEND_INSTANCEOF_SPEC_TMP_HANDLER,
33414
ZEND_INSTANCEOF_SPEC_TMP_HANDLER,
33415
ZEND_INSTANCEOF_SPEC_TMP_HANDLER,
33416
ZEND_INSTANCEOF_SPEC_TMP_HANDLER,
33417
ZEND_INSTANCEOF_SPEC_TMP_HANDLER,
33418
ZEND_INSTANCEOF_SPEC_VAR_HANDLER,
33419
ZEND_INSTANCEOF_SPEC_VAR_HANDLER,
33420
ZEND_INSTANCEOF_SPEC_VAR_HANDLER,
33421
ZEND_INSTANCEOF_SPEC_VAR_HANDLER,
33422
ZEND_INSTANCEOF_SPEC_VAR_HANDLER,
33428
ZEND_INSTANCEOF_SPEC_CV_HANDLER,
33429
ZEND_INSTANCEOF_SPEC_CV_HANDLER,
33430
ZEND_INSTANCEOF_SPEC_CV_HANDLER,
33431
ZEND_INSTANCEOF_SPEC_CV_HANDLER,
33432
ZEND_INSTANCEOF_SPEC_CV_HANDLER,
33433
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33434
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33435
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33436
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33437
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33438
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33439
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33440
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33441
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33442
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33443
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33444
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33445
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33446
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33447
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33448
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33449
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33450
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33451
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33452
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33453
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33454
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33455
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33456
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33457
ZEND_DECLARE_CLASS_SPEC_HANDLER,
33458
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33459
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33460
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33461
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33462
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33463
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33464
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33465
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33466
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33467
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33468
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33469
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33470
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33471
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33472
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33473
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33474
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33475
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33476
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33477
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33478
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33479
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33480
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33481
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33482
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
33483
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33484
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33485
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33486
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33487
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33488
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33489
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33490
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33491
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33492
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33493
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33494
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33495
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33496
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33497
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33498
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33499
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33500
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33501
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33502
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33503
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33504
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33505
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33506
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33507
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
33508
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33509
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33510
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33511
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33512
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33513
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33514
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33515
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33516
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33517
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33518
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33519
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33520
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33521
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33522
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33523
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33524
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33525
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33526
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33527
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33528
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33529
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33530
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33531
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33532
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
33533
ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER,
33558
ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER,
33563
ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER,
33568
ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER,
33573
ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER,
33578
ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER,
33583
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33584
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33585
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33586
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33587
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33588
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33589
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33590
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33591
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33592
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33593
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33594
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33595
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33596
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33597
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33598
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33599
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33600
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33601
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33602
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33603
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33604
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33605
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33606
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33607
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
33608
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33609
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33610
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33611
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33612
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33613
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33614
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33615
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33616
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33617
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33618
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33619
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33620
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33621
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33622
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33623
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33624
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33625
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33626
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33627
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33628
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33629
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33630
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33631
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33632
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
33643
ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER,
33644
ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER,
33645
ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER,
33646
ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER,
33647
ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER,
33653
ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER,
33654
ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER,
33655
ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER,
33656
ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER,
33657
ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER,
33668
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CONST_HANDLER,
33669
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_TMP_HANDLER,
33670
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_VAR_HANDLER,
33672
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CV_HANDLER,
33673
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER,
33674
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_HANDLER,
33675
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_VAR_HANDLER,
33677
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER,
33678
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER,
33679
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_HANDLER,
33680
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_VAR_HANDLER,
33682
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER,
33683
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33684
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33685
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33686
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33687
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33688
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33689
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33690
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33691
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33692
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33693
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33694
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33695
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33696
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33697
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33698
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33699
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33700
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33701
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33702
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33703
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33704
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33705
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33706
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33707
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
33708
ZEND_USER_OPCODE_SPEC_HANDLER,
33709
ZEND_USER_OPCODE_SPEC_HANDLER,
33710
ZEND_USER_OPCODE_SPEC_HANDLER,
33711
ZEND_USER_OPCODE_SPEC_HANDLER,
33712
ZEND_USER_OPCODE_SPEC_HANDLER,
33713
ZEND_USER_OPCODE_SPEC_HANDLER,
33714
ZEND_USER_OPCODE_SPEC_HANDLER,
33715
ZEND_USER_OPCODE_SPEC_HANDLER,
33716
ZEND_USER_OPCODE_SPEC_HANDLER,
33717
ZEND_USER_OPCODE_SPEC_HANDLER,
33718
ZEND_USER_OPCODE_SPEC_HANDLER,
33719
ZEND_USER_OPCODE_SPEC_HANDLER,
33720
ZEND_USER_OPCODE_SPEC_HANDLER,
33721
ZEND_USER_OPCODE_SPEC_HANDLER,
33722
ZEND_USER_OPCODE_SPEC_HANDLER,
33723
ZEND_USER_OPCODE_SPEC_HANDLER,
33724
ZEND_USER_OPCODE_SPEC_HANDLER,
33725
ZEND_USER_OPCODE_SPEC_HANDLER,
33726
ZEND_USER_OPCODE_SPEC_HANDLER,
33727
ZEND_USER_OPCODE_SPEC_HANDLER,
33728
ZEND_USER_OPCODE_SPEC_HANDLER,
33729
ZEND_USER_OPCODE_SPEC_HANDLER,
33730
ZEND_USER_OPCODE_SPEC_HANDLER,
33731
ZEND_USER_OPCODE_SPEC_HANDLER,
33732
ZEND_USER_OPCODE_SPEC_HANDLER,
33758
ZEND_JMP_SET_SPEC_CONST_HANDLER,
33759
ZEND_JMP_SET_SPEC_CONST_HANDLER,
33760
ZEND_JMP_SET_SPEC_CONST_HANDLER,
33761
ZEND_JMP_SET_SPEC_CONST_HANDLER,
33762
ZEND_JMP_SET_SPEC_CONST_HANDLER,
33763
ZEND_JMP_SET_SPEC_TMP_HANDLER,
33764
ZEND_JMP_SET_SPEC_TMP_HANDLER,
33765
ZEND_JMP_SET_SPEC_TMP_HANDLER,
33766
ZEND_JMP_SET_SPEC_TMP_HANDLER,
33767
ZEND_JMP_SET_SPEC_TMP_HANDLER,
33768
ZEND_JMP_SET_SPEC_VAR_HANDLER,
33769
ZEND_JMP_SET_SPEC_VAR_HANDLER,
33770
ZEND_JMP_SET_SPEC_VAR_HANDLER,
33771
ZEND_JMP_SET_SPEC_VAR_HANDLER,
33772
ZEND_JMP_SET_SPEC_VAR_HANDLER,
33778
ZEND_JMP_SET_SPEC_CV_HANDLER,
33779
ZEND_JMP_SET_SPEC_CV_HANDLER,
33780
ZEND_JMP_SET_SPEC_CV_HANDLER,
33781
ZEND_JMP_SET_SPEC_CV_HANDLER,
33782
ZEND_JMP_SET_SPEC_CV_HANDLER,
33783
ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_CONST_HANDLER,
33810
zend_opcode_handlers = (opcode_handler_t*)labels;
33812
static opcode_handler_t zend_vm_get_opcode_handler(zend_uchar opcode, zend_op* op)
33814
static const int zend_vm_decode[] = {
33815
_UNUSED_CODE, /* 0 */
33816
_CONST_CODE, /* 1 = IS_CONST */
33817
_TMP_CODE, /* 2 = IS_TMP_VAR */
33818
_UNUSED_CODE, /* 3 */
33819
_VAR_CODE, /* 4 = IS_VAR */
33820
_UNUSED_CODE, /* 5 */
33821
_UNUSED_CODE, /* 6 */
33822
_UNUSED_CODE, /* 7 */
33823
_UNUSED_CODE, /* 8 = IS_UNUSED */
33824
_UNUSED_CODE, /* 9 */
33825
_UNUSED_CODE, /* 10 */
33826
_UNUSED_CODE, /* 11 */
33827
_UNUSED_CODE, /* 12 */
33828
_UNUSED_CODE, /* 13 */
33829
_UNUSED_CODE, /* 14 */
33830
_UNUSED_CODE, /* 15 */
33831
_CV_CODE /* 16 = IS_CV */
33833
return zend_opcode_handlers[opcode * 25 + zend_vm_decode[op->op1.op_type] * 5 + zend_vm_decode[op->op2.op_type]];
33836
ZEND_API void zend_vm_set_opcode_handler(zend_op* op)
33838
op->handler = zend_vm_get_opcode_handler(zend_user_opcodes[op->opcode], op);
33841
ZEND_API int zend_do_fcall(ZEND_OPCODE_HANDLER_ARGS)
33843
return zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);