1 : /*
2 : +----------------------------------------------------------------------+
3 : | Zend Engine |
4 : +----------------------------------------------------------------------+
5 : | Copyright (c) 1998-2007 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 : +----------------------------------------------------------------------+
19 : */
20 :
21 : static opcode_handler_t zend_user_opcode_handlers[256] = {(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL,(opcode_handler_t)NULL};
22 :
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};
24 :
25 : static opcode_handler_t zend_vm_get_opcode_handler(zend_uchar opcode, zend_op* op);
26 :
27 :
28 : #define ZEND_VM_CONTINUE() return 0
29 : #define ZEND_VM_RETURN() return 1
30 : #define ZEND_VM_DISPATCH(opcode, opline) return zend_vm_get_opcode_handler(opcode, opline)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
31 :
32 : #define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL execute_data TSRMLS_CC
33 :
34 : ZEND_API void execute(zend_op_array *op_array TSRMLS_DC)
35 30301 : {
36 : zend_execute_data execute_data;
37 :
38 :
39 30301 : if (EG(exception)) {
40 0 : return;
41 : }
42 :
43 : /* Initialize execute_data */
44 30301 : EX(fbc) = NULL;
45 30301 : EX(object) = NULL;
46 30301 : EX(old_error_reporting) = NULL;
47 30301 : if (op_array->T < TEMP_VAR_STACK_LIMIT) {
48 30301 : EX(Ts) = (temp_variable *) do_alloca(sizeof(temp_variable) * op_array->T);
49 : } else {
50 0 : EX(Ts) = (temp_variable *) safe_emalloc(sizeof(temp_variable), op_array->T, 0);
51 : }
52 30301 : EX(CVs) = (zval***)do_alloca(sizeof(zval**) * op_array->last_var);
53 30301 : memset(EX(CVs), 0, sizeof(zval**) * op_array->last_var);
54 30301 : EX(op_array) = op_array;
55 30301 : EX(original_in_execution) = EG(in_execution);
56 30301 : EX(symbol_table) = EG(active_symbol_table);
57 30301 : EX(prev_execute_data) = EG(current_execute_data);
58 30301 : EG(current_execute_data) = &execute_data;
59 :
60 30301 : EG(in_execution) = 1;
61 30301 : if (op_array->start_op) {
62 0 : ZEND_VM_SET_OPCODE(op_array->start_op);
63 : } else {
64 30301 : ZEND_VM_SET_OPCODE(op_array->opcodes);
65 : }
66 :
67 30301 : if (op_array->uses_this && EG(This)) {
68 9 : EG(This)->refcount++; /* For $this pointer */
69 9 : if (zend_hash_add(EG(active_symbol_table), "this", sizeof("this"), &EG(This), sizeof(zval *), NULL)==FAILURE) {
70 0 : EG(This)->refcount--;
71 : }
72 : }
73 :
74 30301 : EG(opline_ptr) = &EX(opline);
75 :
76 30301 : EX(function_state).function = (zend_function *) op_array;
77 30301 : EG(function_state_ptr) = &EX(function_state);
78 : #if ZEND_DEBUG
79 : /* function_state.function_symbol_table is saved as-is to a stack,
80 : * which is an intentional UMR. Shut it up if we're in DEBUG.
81 : */
82 : EX(function_state).function_symbol_table = NULL;
83 : #endif
84 :
85 : while (1) {
86 : #ifdef ZEND_WIN32
87 : if (EG(timed_out)) {
88 : zend_timeout(0);
89 : }
90 : #endif
91 :
92 1356964 : if (EX(opline)->handler(&execute_data TSRMLS_CC) > 0) {
93 30289 : return;
94 : }
95 :
96 1326663 : }
97 : zend_error_noreturn(E_ERROR, "Arrived at end of main loop which shouldn't happen");
98 : }
99 :
100 : #undef EX
101 : #define EX(element) execute_data->element
102 :
103 : static int ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
104 61774 : {
105 : #if DEBUG_ZEND>=2
106 : printf("Jumping to %d\n", EX(opline)->op1.u.opline_num);
107 : #endif
108 61774 : ZEND_VM_SET_OPCODE(EX(opline)->op1.u.jmp_addr);
109 61774 : ZEND_VM_CONTINUE(); /* CHECK_ME */
110 : }
111 :
112 : static int ZEND_INIT_STRING_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
113 5292 : {
114 5292 : zval *tmp = &EX_T(EX(opline)->result.u.var).tmp_var;
115 :
116 5292 : tmp->value.str.val = emalloc(1);
117 5292 : tmp->value.str.val[0] = 0;
118 5292 : tmp->value.str.len = 0;
119 5292 : tmp->refcount = 1;
120 5292 : tmp->type = IS_STRING;
121 5292 : tmp->is_ref = 0;
122 5292 : ZEND_VM_NEXT_OPCODE();
123 : }
124 :
125 : static int zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
126 110714 : {
127 110714 : zend_op *opline = EX(opline);
128 : zval **original_return_value;
129 110714 : zend_class_entry *current_scope = NULL;
130 110714 : zval *current_this = NULL;
131 110714 : int return_value_used = RETURN_VALUE_USED(opline);
132 : zend_bool should_change_scope;
133 : zend_op *ctor_opline;
134 :
135 110714 : if (EX(function_state).function->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) {
136 1 : if (EX(function_state).function->common.fn_flags & ZEND_ACC_ABSTRACT) {
137 0 : 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);
138 : ZEND_VM_NEXT_OPCODE(); /* Never reached */
139 : }
140 1 : if (EX(function_state).function->common.fn_flags & ZEND_ACC_DEPRECATED) {
141 1 : zend_error(E_STRICT, "Function %s%s%s() is deprecated",
142 : EX(function_state).function->common.scope ? EX(function_state).function->common.scope->name : "",
143 : EX(function_state).function->common.scope ? "::" : "",
144 : EX(function_state).function->common.function_name);
145 : }
146 : }
147 :
148 110714 : zend_ptr_stack_2_push(&EG(argument_stack), (void *) opline->extended_value, NULL);
149 :
150 110714 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
151 :
152 141542 : if (EX(function_state).function->type == ZEND_USER_FUNCTION
153 : || EX(function_state).function->common.scope) {
154 30828 : should_change_scope = 1;
155 30828 : current_this = EG(This);
156 30828 : EG(This) = EX(object);
157 30828 : current_scope = EG(scope);
158 30828 : EG(scope) = (EX(function_state).function->type == ZEND_USER_FUNCTION || !EX(object)) ? EX(function_state).function->common.scope : NULL;
159 : } else {
160 79886 : should_change_scope = 0;
161 : }
162 :
163 110714 : EX_T(opline->result.u.var).var.fcall_returned_reference = 0;
164 :
165 110714 : if (EX(function_state).function->common.scope) {
166 1886 : if (!EG(This) && !(EX(function_state).function->common.fn_flags & ZEND_ACC_STATIC)) {
167 : int severity;
168 : char *severity_word;
169 0 : if (EX(function_state).function->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
170 0 : severity = E_STRICT;
171 0 : severity_word = "should not";
172 : } else {
173 0 : severity = E_ERROR;
174 0 : severity_word = "cannot";
175 : }
176 0 : zend_error(severity, "Non-static method %s::%s() %s be called statically", EX(function_state).function->common.scope->name, EX(function_state).function->common.function_name, severity_word);
177 : }
178 : }
179 110714 : if (EX(function_state).function->type == ZEND_INTERNAL_FUNCTION) {
180 81518 : unsigned char return_reference = EX(function_state).function->common.return_reference;
181 :
182 81518 : ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
183 81518 : INIT_ZVAL(*(EX_T(opline->result.u.var).var.ptr));
184 :
185 81518 : if (EX(function_state).function->common.arg_info) {
186 77570 : zend_uint i=0;
187 : zval **p;
188 : ulong arg_count;
189 :
190 77570 : p = (zval **) EG(argument_stack).top_element-2;
191 77570 : arg_count = (ulong) *p;
192 :
193 285263 : while (arg_count>0) {
194 130123 : zend_verify_arg_type(EX(function_state).function, ++i, *(p-arg_count) TSRMLS_CC);
195 130123 : arg_count--;
196 : }
197 : }
198 81518 : if (!zend_execute_internal) {
199 : /* saves one function call if zend_execute_internal is not used */
200 81518 : ((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 TSRMLS_CC);
201 : } else {
202 0 : zend_execute_internal(execute_data, return_value_used TSRMLS_CC);
203 : }
204 :
205 81512 : EG(current_execute_data) = execute_data;
206 :
207 : /* We shouldn't fix bad extensions here,
208 : because it can break proper ones (Bug #34045)
209 : if (!EX(function_state).function->common.return_reference) {
210 : EX_T(opline->result.u.var).var.ptr->is_ref = 0;
211 : EX_T(opline->result.u.var).var.ptr->refcount = 1;
212 : }
213 : */
214 81512 : if (!return_value_used) {
215 2972 : zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
216 : } else {
217 78540 : EX_T(opline->result.u.var).var.fcall_returned_reference = return_reference;
218 : }
219 29196 : } else if (EX(function_state).function->type == ZEND_USER_FUNCTION) {
220 29196 : EX_T(opline->result.u.var).var.ptr = NULL;
221 29196 : if (EG(symtable_cache_ptr)>=EG(symtable_cache)) {
222 : /*printf("Cache hit! Reusing %x\n", symtable_cache[symtable_cache_ptr]);*/
223 28947 : EX(function_state).function_symbol_table = *(EG(symtable_cache_ptr)--);
224 : } else {
225 249 : ALLOC_HASHTABLE(EX(function_state).function_symbol_table);
226 249 : zend_hash_init(EX(function_state).function_symbol_table, 0, NULL, ZVAL_PTR_DTOR, 0);
227 : /*printf("Cache miss! Initialized %x\n", function_state.function_symbol_table);*/
228 : }
229 29196 : EG(active_symbol_table) = EX(function_state).function_symbol_table;
230 29196 : original_return_value = EG(return_value_ptr_ptr);
231 29196 : EG(return_value_ptr_ptr) = EX_T(opline->result.u.var).var.ptr_ptr;
232 29196 : EG(active_op_array) = (zend_op_array *) EX(function_state).function;
233 :
234 29196 : zend_execute(EG(active_op_array) TSRMLS_CC);
235 29193 : EX_T(opline->result.u.var).var.fcall_returned_reference = EG(active_op_array)->return_reference;
236 :
237 29193 : if (return_value_used && !EX_T(opline->result.u.var).var.ptr) {
238 0 : if (!EG(exception)) {
239 0 : ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
240 0 : INIT_ZVAL(*EX_T(opline->result.u.var).var.ptr);
241 : }
242 29193 : } else if (!return_value_used && EX_T(opline->result.u.var).var.ptr) {
243 1198 : zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
244 : }
245 :
246 29193 : EG(opline_ptr) = &EX(opline);
247 29193 : EG(active_op_array) = EX(op_array);
248 29193 : EG(return_value_ptr_ptr)=original_return_value;
249 29193 : if (EG(symtable_cache_ptr)>=EG(symtable_cache_limit)) {
250 0 : zend_hash_destroy(EX(function_state).function_symbol_table);
251 0 : FREE_HASHTABLE(EX(function_state).function_symbol_table);
252 : } else {
253 : /* clean before putting into the cache, since clean
254 : could call dtors, which could use cached hash */
255 29193 : zend_hash_clean(EX(function_state).function_symbol_table);
256 29193 : *(++EG(symtable_cache_ptr)) = EX(function_state).function_symbol_table;
257 : }
258 29193 : EG(active_symbol_table) = EX(symbol_table);
259 : } else { /* ZEND_OVERLOADED_FUNCTION */
260 0 : ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
261 0 : INIT_ZVAL(*(EX_T(opline->result.u.var).var.ptr));
262 :
263 : /* Not sure what should be done here if it's a static method */
264 0 : if (EX(object)) {
265 0 : Z_OBJ_HT_P(EX(object))->call_method(EX(fbc)->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 TSRMLS_CC);
266 : } else {
267 0 : zend_error_noreturn(E_ERROR, "Cannot call overloaded function for non-object");
268 : }
269 :
270 0 : if (EX(function_state).function->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
271 0 : efree(EX(function_state).function->common.function_name);
272 : }
273 0 : efree(EX(fbc));
274 :
275 0 : if (!return_value_used) {
276 0 : zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
277 : } else {
278 0 : EX_T(opline->result.u.var).var.ptr->is_ref = 0;
279 0 : EX_T(opline->result.u.var).var.ptr->refcount = 1;
280 : }
281 : }
282 :
283 110705 : ctor_opline = (zend_op*)zend_ptr_stack_pop(&EG(arg_types_stack));
284 :
285 110705 : if (EG(This)) {
286 2182 : if (EG(exception) && ctor_opline) {
287 0 : if (RETURN_VALUE_USED(ctor_opline)) {
288 0 : EG(This)->refcount--;
289 : }
290 0 : if (EG(This)->refcount == 1) {
291 0 : zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
292 : }
293 : }
294 2182 : if (should_change_scope) {
295 1841 : zval_ptr_dtor(&EG(This));
296 : }
297 : }
298 :
299 110705 : if (should_change_scope) {
300 30823 : EG(This) = current_this;
301 30823 : EG(scope) = current_scope;
302 : }
303 110705 : zend_ptr_stack_2_pop(&EG(arg_types_stack), (void**)&EX(object), (void**)&EX(fbc));
304 :
305 110705 : EX(function_state).function = (zend_function *) EX(op_array);
306 110705 : EG(function_state_ptr) = &EX(function_state);
307 110705 : zend_ptr_stack_clear_multiple(TSRMLS_C);
308 :
309 110705 : if (EG(exception)) {
310 12 : zend_throw_exception_internal(NULL TSRMLS_CC);
311 12 : if (return_value_used && EX_T(opline->result.u.var).var.ptr) {
312 4 : zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
313 : }
314 : }
315 :
316 110705 : ZEND_VM_NEXT_OPCODE();
317 : }
318 :
319 : static int ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
320 13369 : {
321 13369 : EX(function_state).function = EX(fbc);
322 13369 : return zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
323 : }
324 :
325 : static int ZEND_CATCH_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
326 24 : {
327 24 : zend_op *opline = EX(opline);
328 : zend_class_entry *ce;
329 :
330 : /* Check whether an exception has been thrown, if not, jump over code */
331 24 : if (EG(exception) == NULL) {
332 0 : ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
333 0 : ZEND_VM_CONTINUE(); /* CHECK_ME */
334 : }
335 24 : ce = Z_OBJCE_P(EG(exception));
336 24 : if (ce != EX_T(opline->op1.u.var).class_entry) {
337 18 : if (!instanceof_function(ce, EX_T(opline->op1.u.var).class_entry TSRMLS_CC)) {
338 0 : if (opline->op1.u.EA.type) {
339 0 : zend_throw_exception_internal(NULL TSRMLS_CC);
340 0 : ZEND_VM_NEXT_OPCODE();
341 : }
342 0 : ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
343 0 : ZEND_VM_CONTINUE(); /* CHECK_ME */
344 : }
345 : }
346 :
347 24 : zend_hash_update(EG(active_symbol_table), opline->op2.u.constant.value.str.val,
348 : opline->op2.u.constant.value.str.len+1, &EG(exception), sizeof(zval *), (void **) NULL);
349 24 : EG(exception) = NULL;
350 24 : ZEND_VM_NEXT_OPCODE();
351 : }
352 :
353 : static int ZEND_RECV_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
354 148464 : {
355 148464 : zend_op *opline = EX(opline);
356 : zval **param;
357 148464 : zend_uint arg_num = Z_LVAL(opline->op1.u.constant);
358 :
359 148464 : if (zend_ptr_stack_get_arg(arg_num, (void **) ¶m TSRMLS_CC)==FAILURE) {
360 : char *space;
361 0 : char *class_name = get_active_class_name(&space TSRMLS_CC);
362 0 : zend_execute_data *ptr = EX(prev_execute_data);
363 :
364 0 : zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, NULL TSRMLS_CC);
365 0 : if(ptr && ptr->op_array) {
366 0 : 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);
367 : } else {
368 0 : 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));
369 : }
370 0 : if (opline->result.op_type == IS_VAR) {
371 0 : PZVAL_UNLOCK_FREE(*EX_T(opline->result.u.var).var.ptr_ptr);
372 : }
373 : } else {
374 : zend_free_op free_res;
375 : zval **var_ptr;
376 :
377 148464 : zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, *param TSRMLS_CC);
378 148464 : var_ptr = get_zval_ptr_ptr(&opline->result, EX(Ts), &free_res, BP_VAR_W);
379 148464 : if (PZVAL_IS_REF(*param)) {
380 221 : zend_assign_to_variable_reference(var_ptr, param TSRMLS_CC);
381 : } else {
382 148243 : zend_receive(var_ptr, *param TSRMLS_CC);
383 : }
384 : }
385 :
386 148464 : ZEND_VM_NEXT_OPCODE();
387 : }
388 :
389 : static int ZEND_NEW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
390 118 : {
391 118 : zend_op *opline = EX(opline);
392 : zval *object_zval;
393 : zend_function *constructor;
394 :
395 118 : if (EX_T(opline->op1.u.var).class_entry->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) {
396 : char *class_type;
397 :
398 0 : if (EX_T(opline->op1.u.var).class_entry->ce_flags & ZEND_ACC_INTERFACE) {
399 0 : class_type = "interface";
400 : } else {
401 0 : class_type = "abstract class";
402 : }
403 0 : zend_error_noreturn(E_ERROR, "Cannot instantiate %s %s", class_type, EX_T(opline->op1.u.var).class_entry->name);
404 : }
405 118 : ALLOC_ZVAL(object_zval);
406 118 : object_init_ex(object_zval, EX_T(opline->op1.u.var).class_entry);
407 118 : INIT_PZVAL(object_zval);
408 :
409 118 : constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC);
410 :
411 118 : if (constructor == NULL) {
412 1 : if (RETURN_VALUE_USED(opline)) {
413 1 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
414 1 : EX_T(opline->result.u.var).var.ptr = object_zval;
415 : } else {
416 0 : zval_ptr_dtor(&object_zval);
417 : }
418 1 : ZEND_VM_JMP(EX(op_array)->opcodes + opline->op2.u.opline_num);
419 : } else {
420 117 : SELECTIVE_PZVAL_LOCK(object_zval, &opline->result);
421 117 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
422 117 : EX_T(opline->result.u.var).var.ptr = object_zval;
423 :
424 117 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), opline);
425 :
426 : /* We are not handling overloaded classes right now */
427 117 : EX(object) = object_zval;
428 117 : EX(fbc) = constructor;
429 :
430 117 : ZEND_VM_NEXT_OPCODE();
431 : }
432 : }
433 :
434 : static int ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
435 4660 : {
436 4660 : zend_op *opline = EX(opline);
437 :
438 4660 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = EG(error_reporting);
439 4660 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_LONG; /* shouldn't be necessary */
440 4660 : if (EX(old_error_reporting) == NULL) {
441 4660 : EX(old_error_reporting) = &EX_T(opline->result.u.var).tmp_var;
442 : }
443 :
444 4660 : if (EG(error_reporting)) {
445 4660 : zend_alter_ini_entry("error_reporting", sizeof("error_reporting"), "0", 1, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
446 : }
447 4660 : ZEND_VM_NEXT_OPCODE();
448 : }
449 :
450 : static int ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
451 0 : {
452 0 : zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", EG(scope)->name, EX(op_array)->function_name);
453 : ZEND_VM_NEXT_OPCODE(); /* Never reached */
454 : }
455 :
456 : static int ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
457 0 : {
458 0 : if (!EG(no_extensions)) {
459 0 : zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_statement_handler, EX(op_array) TSRMLS_CC);
460 : }
461 0 : ZEND_VM_NEXT_OPCODE();
462 : }
463 :
464 : static int ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
465 0 : {
466 0 : if (!EG(no_extensions)) {
467 0 : zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_begin_handler, EX(op_array) TSRMLS_CC);
468 : }
469 0 : ZEND_VM_NEXT_OPCODE();
470 : }
471 :
472 : static int ZEND_EXT_FCALL_END_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
473 0 : {
474 0 : if (!EG(no_extensions)) {
475 0 : zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_end_handler, EX(op_array) TSRMLS_CC);
476 : }
477 0 : ZEND_VM_NEXT_OPCODE();
478 : }
479 :
480 : static int ZEND_DECLARE_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
481 0 : {
482 0 : zend_op *opline = EX(opline);
483 :
484 0 : EX_T(opline->result.u.var).class_entry = do_bind_class(opline, EG(class_table), 0 TSRMLS_CC);
485 0 : ZEND_VM_NEXT_OPCODE();
486 : }
487 :
488 : static int ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
489 0 : {
490 0 : zend_op *opline = EX(opline);
491 :
492 0 : 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);
493 0 : ZEND_VM_NEXT_OPCODE();
494 : }
495 :
496 : static int ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
497 0 : {
498 0 : do_bind_function(EX(opline), EG(function_table), 0);
499 0 : ZEND_VM_NEXT_OPCODE();
500 : }
501 :
502 : static int ZEND_EXT_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
503 0 : {
504 0 : ZEND_VM_NEXT_OPCODE();
505 : }
506 :
507 : static int ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
508 891 : {
509 891 : ZEND_VM_NEXT_OPCODE();
510 : }
511 :
512 : static int ZEND_ADD_INTERFACE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
513 0 : {
514 0 : zend_op *opline = EX(opline);
515 0 : zend_class_entry *ce = EX_T(opline->op1.u.var).class_entry;
516 0 : zend_class_entry *iface = EX_T(opline->op2.u.var).class_entry;
517 :
518 0 : if (!(iface->ce_flags & ZEND_ACC_INTERFACE)) {
519 0 : zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ce->name, iface->name);
520 : }
521 :
522 0 : zend_do_implement_interface(ce, iface TSRMLS_CC);
523 :
524 0 : ZEND_VM_NEXT_OPCODE();
525 : }
526 :
527 : static int ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
528 24 : {
529 24 : zend_uint op_num = EG(opline_before_exception)-EG(active_op_array)->opcodes;
530 : int i;
531 : zend_uint catch_op_num;
532 24 : int catched = 0;
533 : zval **stack_zval_pp;
534 : zval restored_error_reporting;
535 :
536 24 : stack_zval_pp = (zval **) EG(argument_stack).top_element - 1;
537 48 : while (*stack_zval_pp != NULL) {
538 0 : zval_ptr_dtor(stack_zval_pp);
539 0 : EG(argument_stack).top_element--;
540 0 : EG(argument_stack).top--;
541 0 : stack_zval_pp--;
542 : }
543 :
544 49 : for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
545 26 : if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
546 : /* further blocks will not be relevant... */
547 1 : break;
548 : }
549 25 : if (op_num >= EG(active_op_array)->try_catch_array[i].try_op
550 : && op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
551 24 : catch_op_num = EX(op_array)->try_catch_array[i].catch_op;
552 24 : catched = 1;
553 : }
554 : }
555 :
556 48 : while (EX(fbc)) {
557 0 : zend_op *ctor_opline = (zend_op*)zend_ptr_stack_pop(&EG(arg_types_stack));
558 :
559 0 : if (EX(object)) {
560 0 : if (ctor_opline && RETURN_VALUE_USED(ctor_opline)) {
561 0 : EX(object)->refcount--;
562 : }
563 0 : zval_ptr_dtor(&EX(object));
564 : }
565 0 : zend_ptr_stack_2_pop(&EG(arg_types_stack), (void**)&EX(object), (void**)&EX(fbc));
566 : }
567 :
568 49 : for (i=0; i<EX(op_array)->last_brk_cont; i++) {
569 31 : if (EX(op_array)->brk_cont_array[i].start > op_num) {
570 : /* further blocks will not be relevant... */
571 6 : break;
572 : }
573 25 : if (op_num < EX(op_array)->brk_cont_array[i].brk) {
574 20 : if (!catched ||
575 : catch_op_num >= EX(op_array)->brk_cont_array[i].brk) {
576 1 : zend_op *brk_opline = &EX(op_array)->opcodes[EX(op_array)->brk_cont_array[i].brk];
577 :
578 1 : switch (brk_opline->opcode) {
579 : case ZEND_SWITCH_FREE:
580 0 : zend_switch_free(brk_opline, EX(Ts) TSRMLS_CC);
581 0 : break;
582 : case ZEND_FREE:
583 0 : zendi_zval_dtor(EX_T(brk_opline->op1.u.var).tmp_var);
584 : break;
585 : }
586 : }
587 : }
588 : }
589 :
590 : /* restore previous error_reporting value */
591 24 : if (!EG(error_reporting) && EX(old_error_reporting) != NULL && Z_LVAL_P(EX(old_error_reporting)) != 0) {
592 0 : Z_TYPE(restored_error_reporting) = IS_LONG;
593 0 : Z_LVAL(restored_error_reporting) = Z_LVAL_P(EX(old_error_reporting));
594 0 : convert_to_string(&restored_error_reporting);
595 0 : zend_alter_ini_entry("error_reporting", sizeof("error_reporting"), Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
596 0 : zendi_zval_dtor(restored_error_reporting);
597 : }
598 24 : EX(old_error_reporting) = NULL;
599 :
600 24 : if (!catched) {
601 0 : ZEND_VM_RETURN_FROM_EXECUTE_LOOP();
602 : } else {
603 24 : ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
604 24 : ZEND_VM_CONTINUE();
605 : }
606 : }
607 :
608 : static int ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
609 0 : {
610 0 : zend_verify_abstract_class(EX_T(EX(opline)->op1.u.var).class_entry TSRMLS_CC);
611 0 : ZEND_VM_NEXT_OPCODE();
612 : }
613 :
614 : static int ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
615 0 : {
616 0 : int ret = zend_user_opcode_handlers[EX(opline)->opcode](ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL);
617 :
618 0 : switch (ret) {
619 : case ZEND_USER_OPCODE_CONTINUE:
620 0 : ZEND_VM_CONTINUE();
621 : case ZEND_USER_OPCODE_RETURN:
622 0 : ZEND_VM_RETURN();
623 : case ZEND_USER_OPCODE_DISPATCH:
624 0 : ZEND_VM_DISPATCH(EX(opline)->opcode, EX(opline));
625 : default:
626 0 : ZEND_VM_DISPATCH(ret & 0xff, EX(opline));
627 : }
628 : }
629 :
630 : static int ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
631 236 : {
632 236 : zend_op *opline = EX(opline);
633 : zval *class_name;
634 :
635 :
636 :
637 : if (IS_CONST == IS_UNUSED) {
638 : EX_T(opline->result.u.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
639 : ZEND_VM_NEXT_OPCODE();
640 : }
641 :
642 236 : class_name = &opline->op2.u.constant;
643 :
644 236 : switch (Z_TYPE_P(class_name)) {
645 : case IS_OBJECT:
646 0 : EX_T(opline->result.u.var).class_entry = Z_OBJCE_P(class_name);
647 0 : break;
648 : case IS_STRING:
649 236 : 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);
650 236 : break;
651 : default:
652 0 : zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
653 : break;
654 : }
655 :
656 236 : ZEND_VM_NEXT_OPCODE();
657 : }
658 :
659 : static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
660 294 : {
661 294 : zend_op *opline = EX(opline);
662 : zval *function_name;
663 : zend_class_entry *ce;
664 :
665 294 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
666 :
667 294 : ce = EX_T(opline->op1.u.var).class_entry;
668 : if(IS_CONST != IS_UNUSED) {
669 : char *function_name_strval;
670 : int function_name_strlen;
671 294 : zend_bool is_const = (IS_CONST == IS_CONST);
672 :
673 :
674 294 : if (is_const) {
675 294 : function_name_strval = Z_STRVAL(opline->op2.u.constant);
676 294 : function_name_strlen = Z_STRLEN(opline->op2.u.constant);
677 : } else {
678 0 : function_name = &opline->op2.u.constant;
679 :
680 0 : if (Z_TYPE_P(function_name) != IS_STRING) {
681 0 : zend_error_noreturn(E_ERROR, "Function name must be a string");
682 : }
683 0 : function_name_strval = zend_str_tolower_dup(function_name->value.str.val, function_name->value.str.len);
684 0 : function_name_strlen = function_name->value.str.len;
685 : }
686 :
687 294 : EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
688 :
689 294 : if (!is_const) {
690 0 : efree(function_name_strval);
691 :
692 : }
693 : } else {
694 : if(!ce->constructor) {
695 : zend_error_noreturn(E_ERROR, "Can not call constructor");
696 : }
697 : if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
698 : zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
699 : }
700 : EX(fbc) = ce->constructor;
701 : }
702 :
703 294 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
704 44 : EX(object) = NULL;
705 : } else {
706 250 : if (IS_CONST != IS_UNUSED &&
707 : EG(This) &&
708 : Z_OBJ_HT_P(EG(This))->get_class_entry &&
709 : !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
710 : /* We are calling method of the other (incompatible) class,
711 : but passing $this. This is done for compatibility with php-4. */
712 0 : zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name);
713 :
714 : }
715 250 : if ((EX(object) = EG(This))) {
716 250 : EX(object)->refcount++;
717 : }
718 : }
719 :
720 294 : ZEND_VM_NEXT_OPCODE();
721 : }
722 :
723 : static int ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
724 11483 : {
725 11483 : zend_op *opline = EX(opline);
726 : zval *function_name;
727 : zend_function *function;
728 : char *function_name_strval, *lcname;
729 : int function_name_strlen;
730 :
731 :
732 11483 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
733 :
734 : if (IS_CONST == IS_CONST) {
735 11483 : function_name_strval = opline->op2.u.constant.value.str.val;
736 11483 : function_name_strlen = opline->op2.u.constant.value.str.len;
737 : } else {
738 : function_name = &opline->op2.u.constant;
739 :
740 : if (Z_TYPE_P(function_name) != IS_STRING) {
741 : zend_error_noreturn(E_ERROR, "Function name must be a string");
742 : }
743 : function_name_strval = function_name->value.str.val;
744 : function_name_strlen = function_name->value.str.len;
745 : }
746 :
747 11483 : lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
748 11483 : if (zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &function)==FAILURE) {
749 0 : efree(lcname);
750 0 : zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
751 : }
752 :
753 11483 : efree(lcname);
754 : if (IS_CONST != IS_CONST) {
755 :
756 : }
757 :
758 11483 : EX(object) = NULL;
759 :
760 11483 : EX(fbc) = function;
761 :
762 11483 : ZEND_VM_NEXT_OPCODE();
763 : }
764 :
765 :
766 : static int ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
767 901 : {
768 901 : zend_op *opline = EX(opline);
769 : zval **param, *assignment_value;
770 901 : zend_uint arg_num = Z_LVAL(opline->op1.u.constant);
771 : zend_free_op free_res;
772 :
773 901 : if (zend_ptr_stack_get_arg(arg_num, (void **) ¶m TSRMLS_CC)==FAILURE) {
774 116 : if (Z_TYPE(opline->op2.u.constant) == IS_CONSTANT || Z_TYPE(opline->op2.u.constant)==IS_CONSTANT_ARRAY) {
775 : zval *default_value;
776 :
777 0 : ALLOC_ZVAL(default_value);
778 0 : *default_value = opline->op2.u.constant;
779 0 : if (Z_TYPE(opline->op2.u.constant)==IS_CONSTANT_ARRAY) {
780 0 : zval_copy_ctor(default_value);
781 : }
782 0 : default_value->refcount=1;
783 0 : zval_update_constant(&default_value, 0 TSRMLS_CC);
784 0 : default_value->refcount=0;
785 0 : default_value->is_ref=0;
786 0 : param = &default_value;
787 0 : assignment_value = default_value;
788 : } else {
789 116 : param = NULL;
790 116 : assignment_value = &opline->op2.u.constant;
791 : }
792 116 : zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, assignment_value TSRMLS_CC);
793 116 : zend_assign_to_variable(NULL, &opline->result, NULL, assignment_value, IS_VAR, EX(Ts) TSRMLS_CC);
794 : } else {
795 785 : zval **var_ptr = get_zval_ptr_ptr(&opline->result, EX(Ts), &free_res, BP_VAR_W);
796 :
797 785 : assignment_value = *param;
798 785 : zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, assignment_value TSRMLS_CC);
799 785 : if (PZVAL_IS_REF(assignment_value)) {
800 0 : zend_assign_to_variable_reference(var_ptr, param TSRMLS_CC);
801 : } else {
802 785 : zend_receive(var_ptr, assignment_value TSRMLS_CC);
803 : }
804 : }
805 :
806 901 : ZEND_VM_NEXT_OPCODE();
807 : }
808 :
809 : static int ZEND_BRK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
810 220 : {
811 220 : zend_op *opline = EX(opline);
812 :
813 : zend_brk_cont_element *el;
814 :
815 220 : el = zend_brk_cont(&opline->op2.u.constant, opline->op1.u.opline_num,
816 : EX(op_array), EX(Ts) TSRMLS_CC);
817 :
818 220 : ZEND_VM_JMP(EX(op_array)->opcodes + el->brk);
819 : }
820 :
821 : static int ZEND_CONT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
822 467 : {
823 467 : zend_op *opline = EX(opline);
824 :
825 : zend_brk_cont_element *el;
826 :
827 467 : el = zend_brk_cont(&opline->op2.u.constant, opline->op1.u.opline_num,
828 : EX(op_array), EX(Ts) TSRMLS_CC);
829 :
830 467 : ZEND_VM_JMP(EX(op_array)->opcodes + el->cont);
831 : }
832 :
833 : static int ZEND_FETCH_CLASS_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
834 0 : {
835 0 : zend_op *opline = EX(opline);
836 : zval *class_name;
837 : zend_free_op free_op2;
838 :
839 :
840 : if (IS_TMP_VAR == IS_UNUSED) {
841 : EX_T(opline->result.u.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
842 : ZEND_VM_NEXT_OPCODE();
843 : }
844 :
845 0 : class_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
846 :
847 0 : switch (Z_TYPE_P(class_name)) {
848 : case IS_OBJECT:
849 0 : EX_T(opline->result.u.var).class_entry = Z_OBJCE_P(class_name);
850 0 : break;
851 : case IS_STRING:
852 0 : 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);
853 0 : break;
854 : default:
855 0 : zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
856 : break;
857 : }
858 :
859 0 : zval_dtor(free_op2.var);
860 0 : ZEND_VM_NEXT_OPCODE();
861 : }
862 :
863 : static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
864 0 : {
865 0 : zend_op *opline = EX(opline);
866 : zval *function_name;
867 : zend_class_entry *ce;
868 :
869 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
870 :
871 0 : ce = EX_T(opline->op1.u.var).class_entry;
872 : if(IS_TMP_VAR != IS_UNUSED) {
873 : char *function_name_strval;
874 : int function_name_strlen;
875 0 : zend_bool is_const = (IS_TMP_VAR == IS_CONST);
876 : zend_free_op free_op2;
877 :
878 0 : if (is_const) {
879 0 : function_name_strval = Z_STRVAL(opline->op2.u.constant);
880 0 : function_name_strlen = Z_STRLEN(opline->op2.u.constant);
881 : } else {
882 0 : function_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
883 :
884 0 : if (Z_TYPE_P(function_name) != IS_STRING) {
885 0 : zend_error_noreturn(E_ERROR, "Function name must be a string");
886 : }
887 0 : function_name_strval = zend_str_tolower_dup(function_name->value.str.val, function_name->value.str.len);
888 0 : function_name_strlen = function_name->value.str.len;
889 : }
890 :
891 0 : EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
892 :
893 0 : if (!is_const) {
894 0 : efree(function_name_strval);
895 0 : zval_dtor(free_op2.var);
896 : }
897 : } else {
898 : if(!ce->constructor) {
899 : zend_error_noreturn(E_ERROR, "Can not call constructor");
900 : }
901 : if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
902 : zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
903 : }
904 : EX(fbc) = ce->constructor;
905 : }
906 :
907 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
908 0 : EX(object) = NULL;
909 : } else {
910 0 : if (IS_TMP_VAR != IS_UNUSED &&
911 : EG(This) &&
912 : Z_OBJ_HT_P(EG(This))->get_class_entry &&
913 : !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
914 : /* We are calling method of the other (incompatible) class,
915 : but passing $this. This is done for compatibility with php-4. */
916 0 : zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name);
917 :
918 : }
919 0 : if ((EX(object) = EG(This))) {
920 0 : EX(object)->refcount++;
921 : }
922 : }
923 :
924 0 : ZEND_VM_NEXT_OPCODE();
925 : }
926 :
927 : static int ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
928 0 : {
929 0 : zend_op *opline = EX(opline);
930 : zval *function_name;
931 : zend_function *function;
932 : char *function_name_strval, *lcname;
933 : int function_name_strlen;
934 : zend_free_op free_op2;
935 :
936 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
937 :
938 : if (IS_TMP_VAR == IS_CONST) {
939 : function_name_strval = opline->op2.u.constant.value.str.val;
940 : function_name_strlen = opline->op2.u.constant.value.str.len;
941 : } else {
942 0 : function_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
943 :
944 0 : if (Z_TYPE_P(function_name) != IS_STRING) {
945 0 : zend_error_noreturn(E_ERROR, "Function name must be a string");
946 : }
947 0 : function_name_strval = function_name->value.str.val;
948 0 : function_name_strlen = function_name->value.str.len;
949 : }
950 :
951 0 : lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
952 0 : if (zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &function)==FAILURE) {
953 0 : efree(lcname);
954 0 : zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
955 : }
956 :
957 0 : efree(lcname);
958 : if (IS_TMP_VAR != IS_CONST) {
959 0 : zval_dtor(free_op2.var);
960 : }
961 :
962 0 : EX(object) = NULL;
963 :
964 0 : EX(fbc) = function;
965 :
966 0 : ZEND_VM_NEXT_OPCODE();
967 : }
968 :
969 :
970 : static int ZEND_BRK_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
971 0 : {
972 0 : zend_op *opline = EX(opline);
973 : zend_free_op free_op2;
974 : zend_brk_cont_element *el;
975 :
976 0 : el = zend_brk_cont(_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), opline->op1.u.opline_num,
977 : EX(op_array), EX(Ts) TSRMLS_CC);
978 0 : zval_dtor(free_op2.var);
979 0 : ZEND_VM_JMP(EX(op_array)->opcodes + el->brk);
980 : }
981 :
982 : static int ZEND_CONT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
983 0 : {
984 0 : zend_op *opline = EX(opline);
985 : zend_free_op free_op2;
986 : zend_brk_cont_element *el;
987 :
988 0 : el = zend_brk_cont(_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), opline->op1.u.opline_num,
989 : EX(op_array), EX(Ts) TSRMLS_CC);
990 0 : zval_dtor(free_op2.var);
991 0 : ZEND_VM_JMP(EX(op_array)->opcodes + el->cont);
992 : }
993 :
994 : static int ZEND_FETCH_CLASS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
995 0 : {
996 0 : zend_op *opline = EX(opline);
997 : zval *class_name;
998 : zend_free_op free_op2;
999 :
1000 :
1001 : if (IS_VAR == IS_UNUSED) {
1002 : EX_T(opline->result.u.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
1003 : ZEND_VM_NEXT_OPCODE();
1004 : }
1005 :
1006 0 : class_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
1007 :
1008 0 : switch (Z_TYPE_P(class_name)) {
1009 : case IS_OBJECT:
1010 0 : EX_T(opline->result.u.var).class_entry = Z_OBJCE_P(class_name);
1011 0 : break;
1012 : case IS_STRING:
1013 0 : 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);
1014 0 : break;
1015 : default:
1016 0 : zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
1017 : break;
1018 : }
1019 :
1020 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
1021 0 : ZEND_VM_NEXT_OPCODE();
1022 : }
1023 :
1024 : static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1025 0 : {
1026 0 : zend_op *opline = EX(opline);
1027 : zval *function_name;
1028 : zend_class_entry *ce;
1029 :
1030 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
1031 :
1032 0 : ce = EX_T(opline->op1.u.var).class_entry;
1033 : if(IS_VAR != IS_UNUSED) {
1034 : char *function_name_strval;
1035 : int function_name_strlen;
1036 0 : zend_bool is_const = (IS_VAR == IS_CONST);
1037 : zend_free_op free_op2;
1038 :
1039 0 : if (is_const) {
1040 0 : function_name_strval = Z_STRVAL(opline->op2.u.constant);
1041 0 : function_name_strlen = Z_STRLEN(opline->op2.u.constant);
1042 : } else {
1043 0 : function_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
1044 :
1045 0 : if (Z_TYPE_P(function_name) != IS_STRING) {
1046 0 : zend_error_noreturn(E_ERROR, "Function name must be a string");
1047 : }
1048 0 : function_name_strval = zend_str_tolower_dup(function_name->value.str.val, function_name->value.str.len);
1049 0 : function_name_strlen = function_name->value.str.len;
1050 : }
1051 :
1052 0 : EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
1053 :
1054 0 : if (!is_const) {
1055 0 : efree(function_name_strval);
1056 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
1057 : }
1058 : } else {
1059 : if(!ce->constructor) {
1060 : zend_error_noreturn(E_ERROR, "Can not call constructor");
1061 : }
1062 : if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
1063 : zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
1064 : }
1065 : EX(fbc) = ce->constructor;
1066 : }
1067 :
1068 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
1069 0 : EX(object) = NULL;
1070 : } else {
1071 0 : if (IS_VAR != IS_UNUSED &&
1072 : EG(This) &&
1073 : Z_OBJ_HT_P(EG(This))->get_class_entry &&
1074 : !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
1075 : /* We are calling method of the other (incompatible) class,
1076 : but passing $this. This is done for compatibility with php-4. */
1077 0 : zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name);
1078 :
1079 : }
1080 0 : if ((EX(object) = EG(This))) {
1081 0 : EX(object)->refcount++;
1082 : }
1083 : }
1084 :
1085 0 : ZEND_VM_NEXT_OPCODE();
1086 : }
1087 :
1088 : static int ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1089 0 : {
1090 0 : zend_op *opline = EX(opline);
1091 : zval *function_name;
1092 : zend_function *function;
1093 : char *function_name_strval, *lcname;
1094 : int function_name_strlen;
1095 : zend_free_op free_op2;
1096 :
1097 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
1098 :
1099 : if (IS_VAR == IS_CONST) {
1100 : function_name_strval = opline->op2.u.constant.value.str.val;
1101 : function_name_strlen = opline->op2.u.constant.value.str.len;
1102 : } else {
1103 0 : function_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
1104 :
1105 0 : if (Z_TYPE_P(function_name) != IS_STRING) {
1106 0 : zend_error_noreturn(E_ERROR, "Function name must be a string");
1107 : }
1108 0 : function_name_strval = function_name->value.str.val;
1109 0 : function_name_strlen = function_name->value.str.len;
1110 : }
1111 :
1112 0 : lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
1113 0 : if (zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &function)==FAILURE) {
1114 0 : efree(lcname);
1115 0 : zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
1116 : }
1117 :
1118 0 : efree(lcname);
1119 : if (IS_VAR != IS_CONST) {
1120 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
1121 : }
1122 :
1123 0 : EX(object) = NULL;
1124 :
1125 0 : EX(fbc) = function;
1126 :
1127 0 : ZEND_VM_NEXT_OPCODE();
1128 : }
1129 :
1130 :
1131 : static int ZEND_BRK_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1132 0 : {
1133 0 : zend_op *opline = EX(opline);
1134 : zend_free_op free_op2;
1135 : zend_brk_cont_element *el;
1136 :
1137 0 : el = zend_brk_cont(_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), opline->op1.u.opline_num,
1138 : EX(op_array), EX(Ts) TSRMLS_CC);
1139 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
1140 0 : ZEND_VM_JMP(EX(op_array)->opcodes + el->brk);
1141 : }
1142 :
1143 : static int ZEND_CONT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1144 0 : {
1145 0 : zend_op *opline = EX(opline);
1146 : zend_free_op free_op2;
1147 : zend_brk_cont_element *el;
1148 :
1149 0 : el = zend_brk_cont(_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), opline->op1.u.opline_num,
1150 : EX(op_array), EX(Ts) TSRMLS_CC);
1151 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
1152 0 : ZEND_VM_JMP(EX(op_array)->opcodes + el->cont);
1153 : }
1154 :
1155 : static int ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1156 250 : {
1157 250 : zend_op *opline = EX(opline);
1158 : zval *class_name;
1159 :
1160 :
1161 :
1162 : if (IS_UNUSED == IS_UNUSED) {
1163 250 : EX_T(opline->result.u.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
1164 250 : ZEND_VM_NEXT_OPCODE();
1165 : }
1166 :
1167 : class_name = NULL;
1168 :
1169 : switch (Z_TYPE_P(class_name)) {
1170 : case IS_OBJECT:
1171 : EX_T(opline->result.u.var).class_entry = Z_OBJCE_P(class_name);
1172 : break;
1173 : case IS_STRING:
1174 : 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);
1175 : break;
1176 : default:
1177 : zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
1178 : break;
1179 : }
1180 :
1181 : ZEND_VM_NEXT_OPCODE();
1182 : }
1183 :
1184 : static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1185 0 : {
1186 0 : zend_op *opline = EX(opline);
1187 : zval *function_name;
1188 : zend_class_entry *ce;
1189 :
1190 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
1191 :
1192 0 : ce = EX_T(opline->op1.u.var).class_entry;
1193 : if(IS_UNUSED != IS_UNUSED) {
1194 : char *function_name_strval;
1195 : int function_name_strlen;
1196 : zend_bool is_const = (IS_UNUSED == IS_CONST);
1197 :
1198 :
1199 : if (is_const) {
1200 : function_name_strval = Z_STRVAL(opline->op2.u.constant);
1201 : function_name_strlen = Z_STRLEN(opline->op2.u.constant);
1202 : } else {
1203 : function_name = NULL;
1204 :
1205 : if (Z_TYPE_P(function_name) != IS_STRING) {
1206 : zend_error_noreturn(E_ERROR, "Function name must be a string");
1207 : }
1208 : function_name_strval = zend_str_tolower_dup(function_name->value.str.val, function_name->value.str.len);
1209 : function_name_strlen = function_name->value.str.len;
1210 : }
1211 :
1212 : EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
1213 :
1214 : if (!is_const) {
1215 : efree(function_name_strval);
1216 :
1217 : }
1218 : } else {
1219 0 : if(!ce->constructor) {
1220 0 : zend_error_noreturn(E_ERROR, "Can not call constructor");
1221 : }
1222 0 : if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
1223 0 : zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
1224 : }
1225 0 : EX(fbc) = ce->constructor;
1226 : }
1227 :
1228 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
1229 0 : EX(object) = NULL;
1230 : } else {
1231 : if (IS_UNUSED != IS_UNUSED &&
1232 : EG(This) &&
1233 : Z_OBJ_HT_P(EG(This))->get_class_entry &&
1234 : !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
1235 : /* We are calling method of the other (incompatible) class,
1236 : but passing $this. This is done for compatibility with php-4. */
1237 : zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name);
1238 :
1239 : }
1240 0 : if ((EX(object) = EG(This))) {
1241 0 : EX(object)->refcount++;
1242 : }
1243 : }
1244 :
1245 0 : ZEND_VM_NEXT_OPCODE();
1246 : }
1247 :
1248 : static int ZEND_FETCH_CLASS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1249 12 : {
1250 12 : zend_op *opline = EX(opline);
1251 : zval *class_name;
1252 :
1253 :
1254 :
1255 : if (IS_CV == IS_UNUSED) {
1256 : EX_T(opline->result.u.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
1257 : ZEND_VM_NEXT_OPCODE();
1258 : }
1259 :
1260 12 : class_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
1261 :
1262 12 : switch (Z_TYPE_P(class_name)) {
1263 : case IS_OBJECT:
1264 0 : EX_T(opline->result.u.var).class_entry = Z_OBJCE_P(class_name);
1265 0 : break;
1266 : case IS_STRING:
1267 12 : 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);
1268 12 : break;
1269 : default:
1270 0 : zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
1271 : break;
1272 : }
1273 :
1274 12 : ZEND_VM_NEXT_OPCODE();
1275 : }
1276 :
1277 : static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1278 0 : {
1279 0 : zend_op *opline = EX(opline);
1280 : zval *function_name;
1281 : zend_class_entry *ce;
1282 :
1283 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
1284 :
1285 0 : ce = EX_T(opline->op1.u.var).class_entry;
1286 : if(IS_CV != IS_UNUSED) {
1287 : char *function_name_strval;
1288 : int function_name_strlen;
1289 0 : zend_bool is_const = (IS_CV == IS_CONST);
1290 :
1291 :
1292 0 : if (is_const) {
1293 0 : function_name_strval = Z_STRVAL(opline->op2.u.constant);
1294 0 : function_name_strlen = Z_STRLEN(opline->op2.u.constant);
1295 : } else {
1296 0 : function_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
1297 :
1298 0 : if (Z_TYPE_P(function_name) != IS_STRING) {
1299 0 : zend_error_noreturn(E_ERROR, "Function name must be a string");
1300 : }
1301 0 : function_name_strval = zend_str_tolower_dup(function_name->value.str.val, function_name->value.str.len);
1302 0 : function_name_strlen = function_name->value.str.len;
1303 : }
1304 :
1305 0 : EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
1306 :
1307 0 : if (!is_const) {
1308 0 : efree(function_name_strval);
1309 :
1310 : }
1311 : } else {
1312 : if(!ce->constructor) {
1313 : zend_error_noreturn(E_ERROR, "Can not call constructor");
1314 : }
1315 : if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
1316 : zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
1317 : }
1318 : EX(fbc) = ce->constructor;
1319 : }
1320 :
1321 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
1322 0 : EX(object) = NULL;
1323 : } else {
1324 0 : if (IS_CV != IS_UNUSED &&
1325 : EG(This) &&
1326 : Z_OBJ_HT_P(EG(This))->get_class_entry &&
1327 : !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
1328 : /* We are calling method of the other (incompatible) class,
1329 : but passing $this. This is done for compatibility with php-4. */
1330 0 : zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name);
1331 :
1332 : }
1333 0 : if ((EX(object) = EG(This))) {
1334 0 : EX(object)->refcount++;
1335 : }
1336 : }
1337 :
1338 0 : ZEND_VM_NEXT_OPCODE();
1339 : }
1340 :
1341 : static int ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1342 0 : {
1343 0 : zend_op *opline = EX(opline);
1344 : zval *function_name;
1345 : zend_function *function;
1346 : char *function_name_strval, *lcname;
1347 : int function_name_strlen;
1348 :
1349 :
1350 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
1351 :
1352 : if (IS_CV == IS_CONST) {
1353 : function_name_strval = opline->op2.u.constant.value.str.val;
1354 : function_name_strlen = opline->op2.u.constant.value.str.len;
1355 : } else {
1356 0 : function_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
1357 :
1358 0 : if (Z_TYPE_P(function_name) != IS_STRING) {
1359 0 : zend_error_noreturn(E_ERROR, "Function name must be a string");
1360 : }
1361 0 : function_name_strval = function_name->value.str.val;
1362 0 : function_name_strlen = function_name->value.str.len;
1363 : }
1364 :
1365 0 : lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
1366 0 : if (zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &function)==FAILURE) {
1367 0 : efree(lcname);
1368 0 : zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
1369 : }
1370 :
1371 0 : efree(lcname);
1372 : if (IS_CV != IS_CONST) {
1373 :
1374 : }
1375 :
1376 0 : EX(object) = NULL;
1377 :
1378 0 : EX(fbc) = function;
1379 :
1380 0 : ZEND_VM_NEXT_OPCODE();
1381 : }
1382 :
1383 :
1384 : static int ZEND_BRK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1385 0 : {
1386 0 : zend_op *opline = EX(opline);
1387 :
1388 : zend_brk_cont_element *el;
1389 :
1390 0 : el = zend_brk_cont(_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC), opline->op1.u.opline_num,
1391 : EX(op_array), EX(Ts) TSRMLS_CC);
1392 :
1393 0 : ZEND_VM_JMP(EX(op_array)->opcodes + el->brk);
1394 : }
1395 :
1396 : static int ZEND_CONT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1397 0 : {
1398 0 : zend_op *opline = EX(opline);
1399 :
1400 : zend_brk_cont_element *el;
1401 :
1402 0 : el = zend_brk_cont(_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC), opline->op1.u.opline_num,
1403 : EX(op_array), EX(Ts) TSRMLS_CC);
1404 :
1405 0 : ZEND_VM_JMP(EX(op_array)->opcodes + el->cont);
1406 : }
1407 :
1408 : static int ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1409 0 : {
1410 0 : zend_op *opline = EX(opline);
1411 :
1412 :
1413 0 : bitwise_not_function(&EX_T(opline->result.u.var).tmp_var,
1414 : &opline->op1.u.constant TSRMLS_CC);
1415 :
1416 0 : ZEND_VM_NEXT_OPCODE();
1417 : }
1418 :
1419 : static int ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1420 0 : {
1421 0 : zend_op *opline = EX(opline);
1422 :
1423 :
1424 0 : boolean_not_function(&EX_T(opline->result.u.var).tmp_var,
1425 : &opline->op1.u.constant TSRMLS_CC);
1426 :
1427 0 : ZEND_VM_NEXT_OPCODE();
1428 : }
1429 :
1430 : static int ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1431 218 : {
1432 218 : zend_op *opline = EX(opline);
1433 :
1434 : zval z_copy;
1435 218 : zval *z = &opline->op1.u.constant;
1436 :
1437 218 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get_method != NULL &&
1438 : zend_std_cast_object_tostring(z, &z_copy, IS_STRING TSRMLS_CC) == SUCCESS) {
1439 0 : zend_print_variable(&z_copy);
1440 0 : zval_dtor(&z_copy);
1441 : } else {
1442 218 : zend_print_variable(z);
1443 : }
1444 :
1445 218 : ZEND_VM_NEXT_OPCODE();
1446 : }
1447 :
1448 : static int ZEND_PRINT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1449 4 : {
1450 4 : zend_op *opline = EX(opline);
1451 :
1452 4 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
1453 4 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_LONG;
1454 :
1455 4 : return ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1456 : }
1457 :
1458 : static int zend_fetch_var_address_helper_SPEC_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
1459 8275 : {
1460 8275 : zend_op *opline = EX(opline);
1461 : zend_free_op free_op1;
1462 8275 : zval *varname = &opline->op1.u.constant;
1463 : zval **retval;
1464 : zval tmp_varname;
1465 : HashTable *target_symbol_table;
1466 :
1467 8275 : if (Z_TYPE_P(varname) != IS_STRING) {
1468 0 : tmp_varname = *varname;
1469 0 : zval_copy_ctor(&tmp_varname);
1470 0 : convert_to_string(&tmp_varname);
1471 0 : varname = &tmp_varname;
1472 : }
1473 :
1474 8275 : if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
1475 0 : 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);
1476 : } else {
1477 8275 : target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), type, varname TSRMLS_CC);
1478 : /*
1479 : if (!target_symbol_table) {
1480 : ZEND_VM_NEXT_OPCODE();
1481 : }
1482 : */
1483 8275 : if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &retval) == FAILURE) {
1484 10 : switch (type) {
1485 : case BP_VAR_R:
1486 : case BP_VAR_UNSET:
1487 0 : zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
1488 : /* break missing intentionally */
1489 : case BP_VAR_IS:
1490 0 : retval = &EG(uninitialized_zval_ptr);
1491 0 : break;
1492 : case BP_VAR_RW:
1493 0 : zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
1494 : /* break missing intentionally */
1495 : case BP_VAR_W: {
1496 10 : zval *new_zval = &EG(uninitialized_zval);
1497 :
1498 10 : new_zval->refcount++;
1499 10 : zend_hash_update(target_symbol_table, varname->value.str.val, varname->value.str.len+1, &new_zval, sizeof(zval *), (void **) &retval);
1500 : }
1501 : break;
1502 : EMPTY_SWITCH_DEFAULT_CASE()
1503 : }
1504 : }
1505 8275 : switch (opline->op2.u.EA.type) {
1506 : case ZEND_FETCH_GLOBAL:
1507 : if (IS_CONST != IS_TMP_VAR) {
1508 :
1509 : }
1510 9 : break;
1511 : case ZEND_FETCH_LOCAL:
1512 :
1513 4661 : break;
1514 : case ZEND_FETCH_STATIC:
1515 7 : zval_update_constant(retval, (void*) 1 TSRMLS_CC);
1516 : break;
1517 : case ZEND_FETCH_GLOBAL_LOCK:
1518 : if (IS_CONST == IS_VAR && !free_op1.var) {
1519 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
1520 : }
1521 : break;
1522 : }
1523 : }
1524 :
1525 :
1526 8275 : if (varname == &tmp_varname) {
1527 0 : zval_dtor(varname);
1528 : }
1529 8275 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
1530 8275 : EX_T(opline->result.u.var).var.ptr_ptr = retval;
1531 8275 : PZVAL_LOCK(*retval);
1532 8275 : switch (type) {
1533 : case BP_VAR_R:
1534 : case BP_VAR_IS:
1535 2870 : AI_USE_PTR(EX_T(opline->result.u.var).var);
1536 2870 : break;
1537 : case BP_VAR_UNSET: {
1538 : zend_free_op free_res;
1539 :
1540 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
1541 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
1542 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
1543 : }
1544 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
1545 0 : FREE_OP_VAR_PTR(free_res);
1546 : break;
1547 : }
1548 : }
1549 : }
1550 8275 : ZEND_VM_NEXT_OPCODE();
1551 : }
1552 :
1553 : static int ZEND_FETCH_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1554 2866 : {
1555 2866 : return zend_fetch_var_address_helper_SPEC_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1556 : }
1557 :
1558 : static int ZEND_FETCH_W_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1559 5405 : {
1560 5405 : return zend_fetch_var_address_helper_SPEC_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1561 : }
1562 :
1563 : static int ZEND_FETCH_RW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1564 0 : {
1565 0 : return zend_fetch_var_address_helper_SPEC_CONST(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1566 : }
1567 :
1568 : static int ZEND_FETCH_FUNC_ARG_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1569 4 : {
1570 4 : 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);
1571 : }
1572 :
1573 : static int ZEND_FETCH_UNSET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1574 0 : {
1575 0 : return zend_fetch_var_address_helper_SPEC_CONST(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1576 : }
1577 :
1578 : static int ZEND_FETCH_IS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1579 0 : {
1580 0 : return zend_fetch_var_address_helper_SPEC_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1581 : }
1582 :
1583 : static int ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1584 1798 : {
1585 1798 : zend_op *opline = EX(opline);
1586 :
1587 1798 : int ret = i_zend_is_true(&opline->op1.u.constant);
1588 :
1589 1798 : if (!ret) {
1590 : #if DEBUG_ZEND>=2
1591 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
1592 : #endif
1593 0 : ZEND_VM_JMP(opline->op2.u.jmp_addr);
1594 : }
1595 :
1596 1798 : ZEND_VM_NEXT_OPCODE();
1597 : }
1598 :
1599 : static int ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1600 0 : {
1601 0 : zend_op *opline = EX(opline);
1602 :
1603 0 : int ret = i_zend_is_true(&opline->op1.u.constant);
1604 :
1605 0 : if (ret) {
1606 : #if DEBUG_ZEND>=2
1607 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
1608 : #endif
1609 0 : ZEND_VM_JMP(opline->op2.u.jmp_addr);
1610 : }
1611 :
1612 0 : ZEND_VM_NEXT_OPCODE();
1613 : }
1614 :
1615 : static int ZEND_JMPZNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1616 0 : {
1617 0 : zend_op *opline = EX(opline);
1618 :
1619 0 : int retval = i_zend_is_true(&opline->op1.u.constant);
1620 :
1621 0 : if (retval) {
1622 : #if DEBUG_ZEND>=2
1623 : printf("Conditional jmp on true to %d\n", opline->extended_value);
1624 : #endif
1625 0 : ZEND_VM_JMP(&EX(op_array)->opcodes[opline->extended_value]);
1626 : } else {
1627 : #if DEBUG_ZEND>=2
1628 : printf("Conditional jmp on false to %d\n", opline->op2.u.opline_num);
1629 : #endif
1630 0 : ZEND_VM_JMP(&EX(op_array)->opcodes[opline->op2.u.opline_num]);
1631 : }
1632 : }
1633 :
1634 : static int ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1635 0 : {
1636 0 : zend_op *opline = EX(opline);
1637 :
1638 0 : int retval = i_zend_is_true(&opline->op1.u.constant);
1639 :
1640 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
1641 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
1642 0 : if (!retval) {
1643 : #if DEBUG_ZEND>=2
1644 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
1645 : #endif
1646 0 : ZEND_VM_JMP(opline->op2.u.jmp_addr);
1647 : }
1648 0 : ZEND_VM_NEXT_OPCODE();
1649 : }
1650 :
1651 : static int ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1652 0 : {
1653 0 : zend_op *opline = EX(opline);
1654 :
1655 0 : int retval = i_zend_is_true(&opline->op1.u.constant);
1656 :
1657 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
1658 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
1659 0 : if (retval) {
1660 : #if DEBUG_ZEND>=2
1661 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
1662 : #endif
1663 0 : ZEND_VM_JMP(opline->op2.u.jmp_addr);
1664 : }
1665 0 : ZEND_VM_NEXT_OPCODE();
1666 : }
1667 :
1668 : static int ZEND_DO_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1669 97345 : {
1670 97345 : zend_op *opline = EX(opline);
1671 :
1672 97345 : zval *fname = &opline->op1.u.constant;
1673 :
1674 97345 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
1675 :
1676 97345 : if (zend_hash_find(EG(function_table), fname->value.str.val, fname->value.str.len+1, (void **) &EX(function_state).function)==FAILURE) {
1677 0 : zend_error_noreturn(E_ERROR, "Call to undefined function %s()", fname->value.str.val);
1678 : }
1679 97345 : EX(object) = NULL;
1680 :
1681 97345 : return zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1682 : }
1683 :
1684 : static int ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1685 1642 : {
1686 1642 : zend_op *opline = EX(opline);
1687 : zval *retval_ptr;
1688 : zval **retval_ptr_ptr;
1689 :
1690 :
1691 1642 : if (EG(active_op_array)->return_reference == ZEND_RETURN_REF) {
1692 :
1693 : if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
1694 : /* Not supposed to happen, but we'll allow it */
1695 0 : zend_error(E_NOTICE, "Only variable references should be returned by reference");
1696 0 : goto return_by_value;
1697 : }
1698 :
1699 : retval_ptr_ptr = NULL;
1700 :
1701 : if (!retval_ptr_ptr) {
1702 : zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
1703 : }
1704 :
1705 : if (IS_CONST == IS_VAR && !(*retval_ptr_ptr)->is_ref) {
1706 : if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
1707 : EX_T(opline->op1.u.var).var.fcall_returned_reference) {
1708 : } else if (EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
1709 : if (IS_CONST == IS_VAR && !0) {
1710 : PZVAL_LOCK(*retval_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
1711 : }
1712 : zend_error(E_NOTICE, "Only variable references should be returned by reference");
1713 : goto return_by_value;
1714 : }
1715 : }
1716 :
1717 : SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
1718 : (*retval_ptr_ptr)->refcount++;
1719 :
1720 : (*EG(return_value_ptr_ptr)) = (*retval_ptr_ptr);
1721 : } else {
1722 1642 : return_by_value:
1723 :
1724 1642 : retval_ptr = &opline->op1.u.constant;
1725 :
1726 1642 : if (EG(ze1_compatibility_mode) && Z_TYPE_P(retval_ptr) == IS_OBJECT) {
1727 : zval *ret;
1728 : char *class_name;
1729 : zend_uint class_name_len;
1730 : int dup;
1731 :
1732 0 : ALLOC_ZVAL(ret);
1733 0 : INIT_PZVAL_COPY(ret, retval_ptr);
1734 0 : dup = zend_get_object_classname(retval_ptr, &class_name, &class_name_len TSRMLS_CC);
1735 0 : if (Z_OBJ_HT_P(retval_ptr)->clone_obj == NULL) {
1736 0 : zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", class_name);
1737 : }
1738 0 : zend_error(E_STRICT, "Implicit cloning object of class '%s' because of 'zend.ze1_compatibility_mode'", class_name);
1739 0 : ret->value.obj = Z_OBJ_HT_P(retval_ptr)->clone_obj(retval_ptr TSRMLS_CC);
1740 0 : *EG(return_value_ptr_ptr) = ret;
1741 0 : if (!dup) {
1742 0 : efree(class_name);
1743 : }
1744 : } else if (!0) { /* Not a temp var */
1745 3284 : if (EG(active_op_array)->return_reference == ZEND_RETURN_REF ||
1746 : (PZVAL_IS_REF(retval_ptr) && retval_ptr->refcount > 0)) {
1747 : zval *ret;
1748 :
1749 1642 : ALLOC_ZVAL(ret);
1750 1642 : INIT_PZVAL_COPY(ret, retval_ptr);
1751 1642 : zval_copy_ctor(ret);
1752 1642 : *EG(return_value_ptr_ptr) = ret;
1753 : } else {
1754 0 : *EG(return_value_ptr_ptr) = retval_ptr;
1755 0 : retval_ptr->refcount++;
1756 : }
1757 : } else {
1758 : zval *ret;
1759 :
1760 : ALLOC_ZVAL(ret);
1761 : INIT_PZVAL_COPY(ret, retval_ptr);
1762 : *EG(return_value_ptr_ptr) = ret;
1763 : }
1764 : }
1765 :
1766 1642 : ZEND_VM_RETURN_FROM_EXECUTE_LOOP();
1767 : }
1768 :
1769 : static int ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1770 0 : {
1771 0 : zend_op *opline = EX(opline);
1772 : zval *value;
1773 : zval *exception;
1774 :
1775 :
1776 0 : value = &opline->op1.u.constant;
1777 :
1778 0 : if (Z_TYPE_P(value) != IS_OBJECT) {
1779 0 : zend_error_noreturn(E_ERROR, "Can only throw objects");
1780 : }
1781 : /* Not sure if a complete copy is what we want here */
1782 0 : ALLOC_ZVAL(exception);
1783 0 : INIT_PZVAL_COPY(exception, value);
1784 : if (!0) {
1785 0 : zval_copy_ctor(exception);
1786 : }
1787 :
1788 0 : zend_throw_exception_object(exception TSRMLS_CC);
1789 :
1790 0 : ZEND_VM_NEXT_OPCODE();
1791 : }
1792 :
1793 : static int ZEND_SEND_VAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1794 31506 : {
1795 31506 : zend_op *opline = EX(opline);
1796 31506 : if (opline->extended_value==ZEND_DO_FCALL_BY_NAME
1797 : && ARG_MUST_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
1798 0 : zend_error_noreturn(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.u.opline_num);
1799 : }
1800 : {
1801 : zval *valptr;
1802 : zval *value;
1803 :
1804 :
1805 31506 : value = &opline->op1.u.constant;
1806 :
1807 31506 : ALLOC_ZVAL(valptr);
1808 31506 : INIT_PZVAL_COPY(valptr, value);
1809 : if (!0) {
1810 31506 : zval_copy_ctor(valptr);
1811 : }
1812 31506 : zend_ptr_stack_push(&EG(argument_stack), valptr);
1813 :
1814 : }
1815 31506 : ZEND_VM_NEXT_OPCODE();
1816 : }
1817 :
1818 : static int ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1819 0 : {
1820 0 : zend_op *opline = EX(opline);
1821 :
1822 :
1823 : /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
1824 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = i_zend_is_true(&opline->op1.u.constant);
1825 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
1826 :
1827 0 : ZEND_VM_NEXT_OPCODE();
1828 : }
1829 :
1830 : static int ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1831 0 : {
1832 0 : zend_op *opline = EX(opline);
1833 :
1834 0 : zval *obj = &opline->op1.u.constant;
1835 : zend_class_entry *ce;
1836 : zend_function *clone;
1837 : zend_object_clone_obj_t clone_call;
1838 :
1839 0 : if (!obj || Z_TYPE_P(obj) != IS_OBJECT) {
1840 0 : zend_error(E_WARNING, "__clone method called on non-object");
1841 0 : EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
1842 0 : EX_T(opline->result.u.var).var.ptr->refcount++;
1843 :
1844 0 : ZEND_VM_NEXT_OPCODE();
1845 : }
1846 :
1847 0 : ce = Z_OBJCE_P(obj);
1848 0 : clone = ce ? ce->clone : NULL;
1849 0 : clone_call = Z_OBJ_HT_P(obj)->clone_obj;
1850 0 : if (!clone_call) {
1851 0 : if (ce) {
1852 0 : zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
1853 : } else {
1854 0 : zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
1855 : }
1856 : EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
1857 : EX_T(opline->result.u.var).var.ptr->refcount++;
1858 : }
1859 :
1860 0 : if (ce && clone) {
1861 0 : if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
1862 : /* Ensure that if we're calling a private function, we're allowed to do so.
1863 : */
1864 0 : if (ce != EG(scope)) {
1865 0 : zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
1866 : }
1867 0 : } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
1868 : /* Ensure that if we're calling a protected function, we're allowed to do so.
1869 : */
1870 0 : if (!zend_check_protected(clone->common.scope, EG(scope))) {
1871 0 : zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
1872 : }
1873 : }
1874 : }
1875 :
1876 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
1877 0 : if (!EG(exception)) {
1878 0 : ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
1879 0 : Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC);
1880 0 : Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
1881 0 : EX_T(opline->result.u.var).var.ptr->refcount=1;
1882 0 : EX_T(opline->result.u.var).var.ptr->is_ref=1;
1883 0 : if (!RETURN_VALUE_USED(opline) || EG(exception)) {
1884 0 : zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
1885 : }
1886 : }
1887 :
1888 0 : ZEND_VM_NEXT_OPCODE();
1889 : }
1890 :
1891 : static int ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1892 0 : {
1893 0 : zend_op *opline = EX(opline);
1894 :
1895 0 : zval *expr = &opline->op1.u.constant;
1896 0 : zval *result = &EX_T(opline->result.u.var).tmp_var;
1897 :
1898 0 : *result = *expr;
1899 : if (!0) {
1900 0 : zendi_zval_copy_ctor(*result);
1901 : }
1902 0 : switch (opline->extended_value) {
1903 : case IS_NULL:
1904 0 : convert_to_null(result);
1905 0 : break;
1906 : case IS_BOOL:
1907 0 : convert_to_boolean(result);
1908 0 : break;
1909 : case IS_LONG:
1910 0 : convert_to_long(result);
1911 0 : break;
1912 : case IS_DOUBLE:
1913 0 : convert_to_double(result);
1914 0 : break;
1915 : case IS_STRING: {
1916 : zval var_copy;
1917 : int use_copy;
1918 :
1919 0 : zend_make_printable_zval(result, &var_copy, &use_copy);
1920 0 : if (use_copy) {
1921 0 : zval_dtor(result);
1922 0 : *result = var_copy;
1923 : }
1924 0 : break;
1925 : }
1926 : case IS_ARRAY:
1927 0 : convert_to_array(result);
1928 0 : break;
1929 : case IS_OBJECT:
1930 0 : convert_to_object(result);
1931 : break;
1932 : }
1933 :
1934 0 : ZEND_VM_NEXT_OPCODE();
1935 : }
1936 :
1937 : static int ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1938 116 : {
1939 116 : zend_op *opline = EX(opline);
1940 116 : zend_op_array *new_op_array=NULL;
1941 116 : zval **original_return_value = EG(return_value_ptr_ptr);
1942 : int return_value_used;
1943 :
1944 116 : zval *inc_filename = &opline->op1.u.constant;
1945 : zval tmp_inc_filename;
1946 116 : zend_bool failure_retval=0;
1947 :
1948 116 : if (inc_filename->type!=IS_STRING) {
1949 0 : tmp_inc_filename = *inc_filename;
1950 0 : zval_copy_ctor(&tmp_inc_filename);
1951 0 : convert_to_string(&tmp_inc_filename);
1952 0 : inc_filename = &tmp_inc_filename;
1953 : }
1954 :
1955 116 : return_value_used = RETURN_VALUE_USED(opline);
1956 :
1957 116 : switch (Z_LVAL(opline->op2.u.constant)) {
1958 : case ZEND_INCLUDE_ONCE:
1959 : case ZEND_REQUIRE_ONCE: {
1960 : zend_file_handle file_handle;
1961 : char cwd[MAXPATHLEN];
1962 : cwd_state state;
1963 :
1964 0 : if (IS_ABSOLUTE_PATH(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename))) {
1965 0 : cwd[0] = '\0';
1966 0 : } else if (!VCWD_GETCWD(cwd, MAXPATHLEN)) {
1967 0 : cwd[0] = '\0';
1968 : }
1969 :
1970 0 : state.cwd_length = strlen(cwd);
1971 0 : state.cwd = zend_strndup(cwd, state.cwd_length);
1972 :
1973 0 : failure_retval = (!virtual_file_ex(&state, Z_STRVAL_P(inc_filename), NULL, 1) &&
1974 : zend_hash_exists(&EG(included_files), state.cwd, state.cwd_length+1));
1975 :
1976 0 : free(state.cwd);
1977 :
1978 0 : if (failure_retval) {
1979 : /* do nothing */
1980 0 : } else if (SUCCESS == zend_stream_open(Z_STRVAL_P(inc_filename), &file_handle TSRMLS_CC)) {
1981 :
1982 0 : if (!file_handle.opened_path) {
1983 0 : file_handle.opened_path = estrndup(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename));
1984 : }
1985 :
1986 0 : if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
1987 0 : new_op_array = zend_compile_file(&file_handle, (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
1988 0 : zend_destroy_file_handle(&file_handle TSRMLS_CC);
1989 : } else {
1990 0 : zend_file_handle_dtor(&file_handle);
1991 0 : failure_retval=1;
1992 : }
1993 : } else {
1994 0 : if (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE) {
1995 0 : zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename));
1996 : } else {
1997 0 : zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename));
1998 : }
1999 : }
2000 : }
2001 0 : break;
2002 : case ZEND_INCLUDE:
2003 : case ZEND_REQUIRE:
2004 116 : new_op_array = compile_filename(Z_LVAL(opline->op2.u.constant), inc_filename TSRMLS_CC);
2005 116 : break;
2006 : case ZEND_EVAL: {
2007 0 : char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
2008 :
2009 0 : new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
2010 0 : efree(eval_desc);
2011 : }
2012 : break;
2013 : EMPTY_SWITCH_DEFAULT_CASE()
2014 : }
2015 116 : if (inc_filename==&tmp_inc_filename) {
2016 0 : zval_dtor(&tmp_inc_filename);
2017 : }
2018 116 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
2019 116 : if (new_op_array) {
2020 : zval *saved_object;
2021 : zend_function *saved_function;
2022 :
2023 116 : EG(return_value_ptr_ptr) = EX_T(opline->result.u.var).var.ptr_ptr;
2024 116 : EG(active_op_array) = new_op_array;
2025 116 : EX_T(opline->result.u.var).var.ptr = NULL;
2026 :
2027 116 : saved_object = EX(object);
2028 116 : saved_function = EX(function_state).function;
2029 :
2030 116 : EX(function_state).function = (zend_function *) new_op_array;
2031 116 : EX(object) = NULL;
2032 :
2033 116 : zend_execute(new_op_array TSRMLS_CC);
2034 :
2035 116 : EX(function_state).function = saved_function;
2036 116 : EX(object) = saved_object;
2037 :
2038 116 : if (!return_value_used) {
2039 116 : if (EX_T(opline->result.u.var).var.ptr) {
2040 116 : zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
2041 : }
2042 : } else { /* return value is used */
2043 0 : if (!EX_T(opline->result.u.var).var.ptr) { /* there was no return statement */
2044 0 : ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
2045 0 : INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
2046 0 : Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = 1;
2047 0 : Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
2048 : }
2049 : }
2050 :
2051 116 : EG(opline_ptr) = &EX(opline);
2052 116 : EG(active_op_array) = EX(op_array);
2053 116 : EG(function_state_ptr) = &EX(function_state);
2054 116 : destroy_op_array(new_op_array TSRMLS_CC);
2055 116 : efree(new_op_array);
2056 116 : if (EG(exception)) {
2057 0 : zend_throw_exception_internal(NULL TSRMLS_CC);
2058 : }
2059 : } else {
2060 0 : if (return_value_used) {
2061 0 : ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
2062 0 : INIT_ZVAL(*EX_T(opline->result.u.var).var.ptr);
2063 0 : Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = failure_retval;
2064 0 : Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
2065 : }
2066 : }
2067 :
2068 116 : EG(return_value_ptr_ptr) = original_return_value;
2069 116 : ZEND_VM_NEXT_OPCODE();
2070 : }
2071 :
2072 : static int ZEND_UNSET_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2073 1 : {
2074 1 : zend_op *opline = EX(opline);
2075 : zval tmp, *varname;
2076 : HashTable *target_symbol_table;
2077 :
2078 :
2079 1 : varname = &opline->op1.u.constant;
2080 :
2081 1 : if (Z_TYPE_P(varname) != IS_STRING) {
2082 0 : tmp = *varname;
2083 0 : zval_copy_ctor(&tmp);
2084 0 : convert_to_string(&tmp);
2085 0 : varname = &tmp;
2086 : } else if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
2087 : varname->refcount++;
2088 : }
2089 :
2090 1 : if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
2091 0 : zend_std_unset_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname) TSRMLS_CC);
2092 : } else {
2093 1 : target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
2094 1 : if (zend_hash_del(target_symbol_table, varname->value.str.val, varname->value.str.len+1) == SUCCESS) {
2095 1 : zend_execute_data *ex = execute_data;
2096 1 : ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
2097 :
2098 : do {
2099 : int i;
2100 :
2101 1 : if (ex->op_array) {
2102 2 : for (i = 0; i < ex->op_array->last_var; i++) {
2103 2 : if (ex->op_array->vars[i].hash_value == hash_value &&
2104 : ex->op_array->vars[i].name_len == varname->value.str.len &&
2105 : !memcmp(ex->op_array->vars[i].name, varname->value.str.val, varname->value.str.len)) {
2106 1 : ex->CVs[i] = NULL;
2107 1 : break;
2108 : }
2109 : }
2110 : }
2111 1 : ex = ex->prev_execute_data;
2112 1 : } while (ex && ex->symbol_table == target_symbol_table);
2113 : }
2114 : }
2115 :
2116 1 : if (varname == &tmp) {
2117 0 : zval_dtor(&tmp);
2118 : } else if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
2119 : zval_ptr_dtor(&varname);
2120 : }
2121 :
2122 1 : ZEND_VM_NEXT_OPCODE();
2123 : }
2124 :
2125 : static int ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2126 0 : {
2127 0 : zend_op *opline = EX(opline);
2128 : zend_free_op free_op1;
2129 : zval *array_ptr, **array_ptr_ptr;
2130 : HashTable *fe_ht;
2131 0 : zend_object_iterator *iter = NULL;
2132 0 : zend_class_entry *ce = NULL;
2133 0 : zend_bool is_empty = 0;
2134 :
2135 0 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
2136 0 : array_ptr_ptr = NULL;
2137 0 : if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
2138 0 : ALLOC_INIT_ZVAL(array_ptr);
2139 0 : } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
2140 0 : if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
2141 0 : zend_error(E_WARNING, "foreach() can not iterate over objects without PHP class");
2142 0 : ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
2143 : }
2144 :
2145 0 : ce = Z_OBJCE_PP(array_ptr_ptr);
2146 0 : if (!ce || ce->get_iterator == NULL) {
2147 0 : SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
2148 0 : (*array_ptr_ptr)->refcount++;
2149 : }
2150 0 : array_ptr = *array_ptr_ptr;
2151 : } else {
2152 0 : if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
2153 0 : SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
2154 0 : if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
2155 0 : (*array_ptr_ptr)->is_ref = 1;
2156 : }
2157 : }
2158 0 : array_ptr = *array_ptr_ptr;
2159 0 : array_ptr->refcount++;
2160 : }
2161 : } else {
2162 0 : array_ptr = &opline->op1.u.constant;
2163 : if (0) { /* IS_TMP_VAR */
2164 : zval *tmp;
2165 :
2166 : ALLOC_ZVAL(tmp);
2167 : INIT_PZVAL_COPY(tmp, array_ptr);
2168 : array_ptr = tmp;
2169 0 : } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
2170 0 : ce = Z_OBJCE_P(array_ptr);
2171 0 : if (!ce || !ce->get_iterator) {
2172 0 : array_ptr->refcount++;
2173 : }
2174 : } else {
2175 : if (IS_CONST == IS_VAR &&
2176 : free_op1.var == NULL &&
2177 : !array_ptr->is_ref &&
2178 : array_ptr->refcount > 1) {
2179 : /* non-separated return value from function */
2180 : zval *tmp;
2181 :
2182 : ALLOC_ZVAL(tmp);
2183 : INIT_PZVAL_COPY(tmp, array_ptr);
2184 : zval_copy_ctor(tmp);
2185 : array_ptr = tmp;
2186 : } else {
2187 0 : array_ptr->refcount++;
2188 : }
2189 : }
2190 : }
2191 :
2192 0 : if (IS_CONST != IS_TMP_VAR && ce && ce->get_iterator) {
2193 0 : iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC);
2194 :
2195 0 : if (iter && !EG(exception)) {
2196 0 : array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
2197 : } else {
2198 0 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
2199 :
2200 : } else {
2201 :
2202 : }
2203 0 : if (!EG(exception)) {
2204 0 : zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
2205 : }
2206 0 : zend_throw_exception_internal(NULL TSRMLS_CC);
2207 0 : ZEND_VM_NEXT_OPCODE();
2208 : }
2209 : }
2210 :
2211 0 : PZVAL_LOCK(array_ptr);
2212 0 : EX_T(opline->result.u.var).var.ptr = array_ptr;
2213 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
2214 :
2215 0 : if (iter) {
2216 0 : iter->index = 0;
2217 0 : if (iter->funcs->rewind) {
2218 0 : iter->funcs->rewind(iter TSRMLS_CC);
2219 0 : if (EG(exception)) {
2220 0 : array_ptr->refcount--;
2221 0 : zval_ptr_dtor(&array_ptr);
2222 0 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
2223 :
2224 : } else {
2225 :
2226 : }
2227 0 : ZEND_VM_NEXT_OPCODE();
2228 : }
2229 : }
2230 0 : is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
2231 0 : if (EG(exception)) {
2232 0 : array_ptr->refcount--;
2233 0 : zval_ptr_dtor(&array_ptr);
2234 0 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
2235 :
2236 : } else {
2237 :
2238 : }
2239 0 : ZEND_VM_NEXT_OPCODE();
2240 : }
2241 0 : iter->index = -1; /* will be set to 0 before using next handler */
2242 0 : } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
2243 0 : zend_hash_internal_pointer_reset(fe_ht);
2244 0 : if (ce) {
2245 0 : zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
2246 0 : while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
2247 : char *str_key;
2248 : uint str_key_len;
2249 : ulong int_key;
2250 : zend_uchar key_type;
2251 :
2252 0 : key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
2253 0 : if (key_type != HASH_KEY_NON_EXISTANT &&
2254 : (key_type == HASH_KEY_IS_LONG ||
2255 : zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
2256 : break;
2257 : }
2258 0 : zend_hash_move_forward(fe_ht);
2259 : }
2260 : }
2261 0 : is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
2262 0 : zend_hash_get_pointer(fe_ht, &EX_T(opline->result.u.var).fe.fe_pos);
2263 : } else {
2264 0 : zend_error(E_WARNING, "Invalid argument supplied for foreach()");
2265 0 : is_empty = 1;
2266 : }
2267 :
2268 0 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
2269 :
2270 : } else {
2271 :
2272 : }
2273 0 : if (is_empty) {
2274 0 : ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
2275 : } else {
2276 0 : ZEND_VM_NEXT_OPCODE();
2277 : }
2278 : }
2279 :
2280 : static int ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2281 221 : {
2282 221 : zend_op *opline = EX(opline);
2283 :
2284 221 : zval tmp, *varname = &opline->op1.u.constant;
2285 : zval **value;
2286 221 : zend_bool isset = 1;
2287 : HashTable *target_symbol_table;
2288 :
2289 221 : if (Z_TYPE_P(varname) != IS_STRING) {
2290 0 : tmp = *varname;
2291 0 : zval_copy_ctor(&tmp);
2292 0 : convert_to_string(&tmp);
2293 0 : varname = &tmp;
2294 : }
2295 :
2296 221 : if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
2297 0 : 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);
2298 0 : if (!value) {
2299 0 : isset = 0;
2300 : }
2301 : } else {
2302 221 : target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
2303 221 : if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
2304 218 : isset = 0;
2305 : }
2306 : }
2307 :
2308 221 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
2309 :
2310 221 : switch (opline->extended_value) {
2311 : case ZEND_ISSET:
2312 220 : if (isset && Z_TYPE_PP(value) == IS_NULL) {
2313 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
2314 : } else {
2315 220 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = isset;
2316 : }
2317 220 : break;
2318 : case ZEND_ISEMPTY:
2319 1 : if (!isset || !i_zend_is_true(*value)) {
2320 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
2321 : } else {
2322 1 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
2323 : }
2324 : break;
2325 : }
2326 :
2327 221 : if (varname == &tmp) {
2328 0 : zval_dtor(&tmp);
2329 : }
2330 :
2331 221 : ZEND_VM_NEXT_OPCODE();
2332 : }
2333 :
2334 : static int ZEND_EXIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2335 1 : {
2336 : #if 0 || (IS_CONST != IS_UNUSED)
2337 1 : zend_op *opline = EX(opline);
2338 : if (IS_CONST != IS_UNUSED) {
2339 :
2340 1 : zval *ptr = &opline->op1.u.constant;
2341 :
2342 1 : if (Z_TYPE_P(ptr) == IS_LONG) {
2343 1 : EG(exit_status) = Z_LVAL_P(ptr);
2344 : } else {
2345 0 : zend_print_variable(ptr);
2346 : }
2347 :
2348 : }
2349 : #endif
2350 1 : zend_bailout();
2351 0 : ZEND_VM_NEXT_OPCODE();
2352 : }
2353 :
2354 : static int ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2355 3652 : {
2356 3652 : zend_op *opline = EX(opline);
2357 :
2358 3652 : zval *value = &opline->op1.u.constant;
2359 :
2360 3652 : EX_T(opline->result.u.var).tmp_var = *value;
2361 : if (!0) {
2362 3652 : zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
2363 : }
2364 :
2365 3652 : ZEND_VM_NEXT_OPCODE();
2366 : }
2367 :
2368 : static int ZEND_TICKS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2369 0 : {
2370 0 : zend_op *opline = EX(opline);
2371 :
2372 0 : if (++EG(ticks_count)>=Z_LVAL(opline->op1.u.constant)) {
2373 0 : EG(ticks_count)=0;
2374 0 : if (zend_ticks_function) {
2375 0 : zend_ticks_function(Z_LVAL(opline->op1.u.constant));
2376 : }
2377 : }
2378 0 : ZEND_VM_NEXT_OPCODE();
2379 : }
2380 :
2381 : static int ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2382 0 : {
2383 0 : zend_op *opline = EX(opline);
2384 :
2385 :
2386 0 : add_function(&EX_T(opline->result.u.var).tmp_var,
2387 : &opline->op1.u.constant,
2388 : &opline->op2.u.constant TSRMLS_CC);
2389 :
2390 :
2391 0 : ZEND_VM_NEXT_OPCODE();
2392 : }
2393 :
2394 : static int ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2395 1441 : {
2396 1441 : zend_op *opline = EX(opline);
2397 :
2398 :
2399 1441 : sub_function(&EX_T(opline->result.u.var).tmp_var,
2400 : &opline->op1.u.constant,
2401 : &opline->op2.u.constant TSRMLS_CC);
2402 :
2403 :
2404 1441 : ZEND_VM_NEXT_OPCODE();
2405 : }
2406 :
2407 : static int ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2408 0 : {
2409 0 : zend_op *opline = EX(opline);
2410 :
2411 :
2412 0 : mul_function(&EX_T(opline->result.u.var).tmp_var,
2413 : &opline->op1.u.constant,
2414 : &opline->op2.u.constant TSRMLS_CC);
2415 :
2416 :
2417 0 : ZEND_VM_NEXT_OPCODE();
2418 : }
2419 :
2420 : static int ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2421 0 : {
2422 0 : zend_op *opline = EX(opline);
2423 :
2424 :
2425 0 : div_function(&EX_T(opline->result.u.var).tmp_var,
2426 : &opline->op1.u.constant,
2427 : &opline->op2.u.constant TSRMLS_CC);
2428 :
2429 :
2430 0 : ZEND_VM_NEXT_OPCODE();
2431 : }
2432 :
2433 : static int ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2434 0 : {
2435 0 : zend_op *opline = EX(opline);
2436 :
2437 :
2438 0 : mod_function(&EX_T(opline->result.u.var).tmp_var,
2439 : &opline->op1.u.constant,
2440 : &opline->op2.u.constant TSRMLS_CC);
2441 :
2442 :
2443 0 : ZEND_VM_NEXT_OPCODE();
2444 : }
2445 :
2446 : static int ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2447 0 : {
2448 0 : zend_op *opline = EX(opline);
2449 :
2450 :
2451 0 : shift_left_function(&EX_T(opline->result.u.var).tmp_var,
2452 : &opline->op1.u.constant,
2453 : &opline->op2.u.constant TSRMLS_CC);
2454 :
2455 :
2456 0 : ZEND_VM_NEXT_OPCODE();
2457 : }
2458 :
2459 : static int ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2460 0 : {
2461 0 : zend_op *opline = EX(opline);
2462 :
2463 :
2464 0 : shift_right_function(&EX_T(opline->result.u.var).tmp_var,
2465 : &opline->op1.u.constant,
2466 : &opline->op2.u.constant TSRMLS_CC);
2467 :
2468 :
2469 0 : ZEND_VM_NEXT_OPCODE();
2470 : }
2471 :
2472 : static int ZEND_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2473 10 : {
2474 10 : zend_op *opline = EX(opline);
2475 :
2476 :
2477 10 : concat_function(&EX_T(opline->result.u.var).tmp_var,
2478 : &opline->op1.u.constant,
2479 : &opline->op2.u.constant TSRMLS_CC);
2480 :
2481 :
2482 10 : ZEND_VM_NEXT_OPCODE();
2483 : }
2484 :
2485 : static int ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2486 0 : {
2487 0 : zend_op *opline = EX(opline);
2488 :
2489 :
2490 0 : is_identical_function(&EX_T(opline->result.u.var).tmp_var,
2491 : &opline->op1.u.constant,
2492 : &opline->op2.u.constant TSRMLS_CC);
2493 :
2494 :
2495 0 : ZEND_VM_NEXT_OPCODE();
2496 : }
2497 :
2498 : static int ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2499 0 : {
2500 0 : zend_op *opline = EX(opline);
2501 :
2502 :
2503 0 : is_not_identical_function(&EX_T(opline->result.u.var).tmp_var,
2504 : &opline->op1.u.constant,
2505 : &opline->op2.u.constant TSRMLS_CC);
2506 :
2507 :
2508 0 : ZEND_VM_NEXT_OPCODE();
2509 : }
2510 :
2511 : static int ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2512 0 : {
2513 0 : zend_op *opline = EX(opline);
2514 :
2515 :
2516 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
2517 : &opline->op1.u.constant,
2518 : &opline->op2.u.constant TSRMLS_CC);
2519 :
2520 :
2521 0 : ZEND_VM_NEXT_OPCODE();
2522 : }
2523 :
2524 : static int ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2525 0 : {
2526 0 : zend_op *opline = EX(opline);
2527 :
2528 :
2529 0 : is_not_equal_function(&EX_T(opline->result.u.var).tmp_var,
2530 : &opline->op1.u.constant,
2531 : &opline->op2.u.constant TSRMLS_CC);
2532 :
2533 :
2534 0 : ZEND_VM_NEXT_OPCODE();
2535 : }
2536 :
2537 : static int ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2538 0 : {
2539 0 : zend_op *opline = EX(opline);
2540 :
2541 :
2542 0 : is_smaller_function(&EX_T(opline->result.u.var).tmp_var,
2543 : &opline->op1.u.constant,
2544 : &opline->op2.u.constant TSRMLS_CC);
2545 :
2546 :
2547 0 : ZEND_VM_NEXT_OPCODE();
2548 : }
2549 :
2550 : static int ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2551 0 : {
2552 0 : zend_op *opline = EX(opline);
2553 :
2554 :
2555 0 : is_smaller_or_equal_function(&EX_T(opline->result.u.var).tmp_var,
2556 : &opline->op1.u.constant,
2557 : &opline->op2.u.constant TSRMLS_CC);
2558 :
2559 :
2560 0 : ZEND_VM_NEXT_OPCODE();
2561 : }
2562 :
2563 : static int ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2564 0 : {
2565 0 : zend_op *opline = EX(opline);
2566 :
2567 :
2568 0 : bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
2569 : &opline->op1.u.constant,
2570 : &opline->op2.u.constant TSRMLS_CC);
2571 :
2572 :
2573 0 : ZEND_VM_NEXT_OPCODE();
2574 : }
2575 :
2576 : static int ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2577 0 : {
2578 0 : zend_op *opline = EX(opline);
2579 :
2580 :
2581 0 : bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
2582 : &opline->op1.u.constant,
2583 : &opline->op2.u.constant TSRMLS_CC);
2584 :
2585 :
2586 0 : ZEND_VM_NEXT_OPCODE();
2587 : }
2588 :
2589 : static int ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2590 0 : {
2591 0 : zend_op *opline = EX(opline);
2592 :
2593 :
2594 0 : bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
2595 : &opline->op1.u.constant,
2596 : &opline->op2.u.constant TSRMLS_CC);
2597 :
2598 :
2599 0 : ZEND_VM_NEXT_OPCODE();
2600 : }
2601 :
2602 : static int ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2603 0 : {
2604 0 : zend_op *opline = EX(opline);
2605 :
2606 :
2607 0 : boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
2608 : &opline->op1.u.constant,
2609 : &opline->op2.u.constant TSRMLS_CC);
2610 :
2611 :
2612 0 : ZEND_VM_NEXT_OPCODE();
2613 : }
2614 :
2615 : static int ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2616 0 : {
2617 0 : zend_op *opline = EX(opline);
2618 :
2619 0 : zval *container = &opline->op1.u.constant;
2620 :
2621 0 : if (Z_TYPE_P(container) != IS_ARRAY) {
2622 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
2623 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
2624 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
2625 : }
2626 : } else {
2627 :
2628 0 : zval *dim = &opline->op2.u.constant;
2629 :
2630 0 : EX_T(opline->result.u.var).var.ptr_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, BP_VAR_R TSRMLS_CC);
2631 0 : SELECTIVE_PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &opline->result);
2632 :
2633 : }
2634 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
2635 0 : ZEND_VM_NEXT_OPCODE();
2636 : }
2637 :
2638 : static int ZEND_CASE_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2639 0 : {
2640 0 : zend_op *opline = EX(opline);
2641 0 : int switch_expr_is_overloaded=0;
2642 :
2643 :
2644 : if (IS_CONST==IS_VAR) {
2645 : if (EX_T(opline->op1.u.var).var.ptr_ptr) {
2646 : PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
2647 : } else {
2648 : switch_expr_is_overloaded = 1;
2649 : EX_T(opline->op1.u.var).str_offset.str->refcount++;
2650 : }
2651 : }
2652 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
2653 : &opline->op1.u.constant,
2654 : &opline->op2.u.constant TSRMLS_CC);
2655 :
2656 0 : if (switch_expr_is_overloaded) {
2657 : /* We only free op1 if this is a string offset,
2658 : * Since if it is a TMP_VAR, it'll be reused by
2659 : * other CASE opcodes (whereas string offsets
2660 : * are allocated at each get_zval_ptr())
2661 : */
2662 :
2663 0 : EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
2664 0 : AI_USE_PTR(EX_T(opline->op1.u.var).var);
2665 : }
2666 0 : ZEND_VM_NEXT_OPCODE();
2667 : }
2668 :
2669 : static int ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2670 62 : {
2671 62 : zend_op *opline = EX(opline);
2672 62 : zend_class_entry *ce = NULL;
2673 : zval **value;
2674 :
2675 : if (IS_CONST == IS_UNUSED) {
2676 : /* This seems to be a reminant of namespaces
2677 : if (EG(scope)) {
2678 : ce = EG(scope);
2679 : if (zend_hash_find(&ce->constants_table, Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant)+1, (void **) &value) == SUCCESS) {
2680 : zval_update_constant(value, (void *) 1 TSRMLS_CC);
2681 : EX_T(opline->result.u.var).tmp_var = **value;
2682 : zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
2683 : ZEND_VM_NEXT_OPCODE();
2684 : }
2685 : }
2686 : */
2687 : if (!zend_get_constant(opline->op2.u.constant.value.str.val, opline->op2.u.constant.value.str.len, &EX_T(opline->result.u.var).tmp_var TSRMLS_CC)) {
2688 : zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",
2689 : opline->op2.u.constant.value.str.val,
2690 : opline->op2.u.constant.value.str.val);
2691 : EX_T(opline->result.u.var).tmp_var = opline->op2.u.constant;
2692 : zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
2693 : }
2694 : ZEND_VM_NEXT_OPCODE();
2695 : }
2696 :
2697 62 : ce = EX_T(opline->op1.u.var).class_entry;
2698 :
2699 62 : if (zend_hash_find(&ce->constants_table, opline->op2.u.constant.value.str.val, opline->op2.u.constant.value.str.len+1, (void **) &value) == SUCCESS) {
2700 62 : zval_update_constant(value, (void *) 1 TSRMLS_CC);
2701 62 : EX_T(opline->result.u.var).tmp_var = **value;
2702 62 : zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
2703 : } else {
2704 0 : zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", opline->op2.u.constant.value.str.val);
2705 : }
2706 :
2707 62 : ZEND_VM_NEXT_OPCODE();
2708 : }
2709 :
2710 : static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2711 1197 : {
2712 1197 : zend_op *opline = EX(opline);
2713 :
2714 1197 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
2715 : zval *expr_ptr;
2716 1197 : zval *offset=&opline->op2.u.constant;
2717 :
2718 : #if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
2719 : zval **expr_ptr_ptr = NULL;
2720 :
2721 : if (opline->extended_value) {
2722 : expr_ptr_ptr=NULL;
2723 : expr_ptr = *expr_ptr_ptr;
2724 : } else {
2725 : expr_ptr=&opline->op1.u.constant;
2726 : }
2727 : #else
2728 1197 : expr_ptr=&opline->op1.u.constant;
2729 : #endif
2730 :
2731 : if (0) { /* temporary variable */
2732 : zval *new_expr;
2733 :
2734 : ALLOC_ZVAL(new_expr);
2735 : INIT_PZVAL_COPY(new_expr, expr_ptr);
2736 : expr_ptr = new_expr;
2737 : } else {
2738 : #if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
2739 : if (opline->extended_value) {
2740 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
2741 : expr_ptr = *expr_ptr_ptr;
2742 : expr_ptr->refcount++;
2743 : } else
2744 : #endif
2745 1197 : if (PZVAL_IS_REF(expr_ptr)) {
2746 : zval *new_expr;
2747 :
2748 1197 : ALLOC_ZVAL(new_expr);
2749 1197 : INIT_PZVAL_COPY(new_expr, expr_ptr);
2750 1197 : expr_ptr = new_expr;
2751 1197 : zendi_zval_copy_ctor(*expr_ptr);
2752 : } else {
2753 0 : expr_ptr->refcount++;
2754 : }
2755 : }
2756 1197 : if (offset) {
2757 1197 : switch (Z_TYPE_P(offset)) {
2758 : case IS_DOUBLE:
2759 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
2760 0 : break;
2761 : case IS_LONG:
2762 : case IS_BOOL:
2763 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
2764 0 : break;
2765 : case IS_STRING:
2766 1197 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
2767 1197 : break;
2768 : case IS_NULL:
2769 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
2770 0 : break;
2771 : default:
2772 0 : zend_error(E_WARNING, "Illegal offset type");
2773 0 : zval_ptr_dtor(&expr_ptr);
2774 : /* do nothing */
2775 : break;
2776 : }
2777 :
2778 : } else {
2779 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
2780 : }
2781 1197 : if (opline->extended_value) {
2782 :
2783 : } else {
2784 :
2785 : }
2786 1197 : ZEND_VM_NEXT_OPCODE();
2787 : }
2788 :
2789 : static int ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2790 408 : {
2791 408 : zend_op *opline = EX(opline);
2792 :
2793 408 : array_init(&EX_T(opline->result.u.var).tmp_var);
2794 : if (IS_CONST == IS_UNUSED) {
2795 : ZEND_VM_NEXT_OPCODE();
2796 : #if 0 || IS_CONST != IS_UNUSED
2797 : } else {
2798 408 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
2799 : #endif
2800 : }
2801 : }
2802 :
2803 : static int ZEND_ADD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2804 0 : {
2805 0 : zend_op *opline = EX(opline);
2806 : zend_free_op free_op2;
2807 :
2808 0 : add_function(&EX_T(opline->result.u.var).tmp_var,
2809 : &opline->op1.u.constant,
2810 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2811 :
2812 0 : zval_dtor(free_op2.var);
2813 0 : ZEND_VM_NEXT_OPCODE();
2814 : }
2815 :
2816 : static int ZEND_SUB_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2817 0 : {
2818 0 : zend_op *opline = EX(opline);
2819 : zend_free_op free_op2;
2820 :
2821 0 : sub_function(&EX_T(opline->result.u.var).tmp_var,
2822 : &opline->op1.u.constant,
2823 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2824 :
2825 0 : zval_dtor(free_op2.var);
2826 0 : ZEND_VM_NEXT_OPCODE();
2827 : }
2828 :
2829 : static int ZEND_MUL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2830 0 : {
2831 0 : zend_op *opline = EX(opline);
2832 : zend_free_op free_op2;
2833 :
2834 0 : mul_function(&EX_T(opline->result.u.var).tmp_var,
2835 : &opline->op1.u.constant,
2836 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2837 :
2838 0 : zval_dtor(free_op2.var);
2839 0 : ZEND_VM_NEXT_OPCODE();
2840 : }
2841 :
2842 : static int ZEND_DIV_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2843 0 : {
2844 0 : zend_op *opline = EX(opline);
2845 : zend_free_op free_op2;
2846 :
2847 0 : div_function(&EX_T(opline->result.u.var).tmp_var,
2848 : &opline->op1.u.constant,
2849 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2850 :
2851 0 : zval_dtor(free_op2.var);
2852 0 : ZEND_VM_NEXT_OPCODE();
2853 : }
2854 :
2855 : static int ZEND_MOD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2856 0 : {
2857 0 : zend_op *opline = EX(opline);
2858 : zend_free_op free_op2;
2859 :
2860 0 : mod_function(&EX_T(opline->result.u.var).tmp_var,
2861 : &opline->op1.u.constant,
2862 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2863 :
2864 0 : zval_dtor(free_op2.var);
2865 0 : ZEND_VM_NEXT_OPCODE();
2866 : }
2867 :
2868 : static int ZEND_SL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2869 0 : {
2870 0 : zend_op *opline = EX(opline);
2871 : zend_free_op free_op2;
2872 :
2873 0 : shift_left_function(&EX_T(opline->result.u.var).tmp_var,
2874 : &opline->op1.u.constant,
2875 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2876 :
2877 0 : zval_dtor(free_op2.var);
2878 0 : ZEND_VM_NEXT_OPCODE();
2879 : }
2880 :
2881 : static int ZEND_SR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2882 0 : {
2883 0 : zend_op *opline = EX(opline);
2884 : zend_free_op free_op2;
2885 :
2886 0 : shift_right_function(&EX_T(opline->result.u.var).tmp_var,
2887 : &opline->op1.u.constant,
2888 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2889 :
2890 0 : zval_dtor(free_op2.var);
2891 0 : ZEND_VM_NEXT_OPCODE();
2892 : }
2893 :
2894 : static int ZEND_CONCAT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2895 108 : {
2896 108 : zend_op *opline = EX(opline);
2897 : zend_free_op free_op2;
2898 :
2899 108 : concat_function(&EX_T(opline->result.u.var).tmp_var,
2900 : &opline->op1.u.constant,
2901 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2902 :
2903 108 : zval_dtor(free_op2.var);
2904 108 : ZEND_VM_NEXT_OPCODE();
2905 : }
2906 :
2907 : static int ZEND_IS_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2908 0 : {
2909 0 : zend_op *opline = EX(opline);
2910 : zend_free_op free_op2;
2911 :
2912 0 : is_identical_function(&EX_T(opline->result.u.var).tmp_var,
2913 : &opline->op1.u.constant,
2914 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2915 :
2916 0 : zval_dtor(free_op2.var);
2917 0 : ZEND_VM_NEXT_OPCODE();
2918 : }
2919 :
2920 : static int ZEND_IS_NOT_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2921 0 : {
2922 0 : zend_op *opline = EX(opline);
2923 : zend_free_op free_op2;
2924 :
2925 0 : is_not_identical_function(&EX_T(opline->result.u.var).tmp_var,
2926 : &opline->op1.u.constant,
2927 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2928 :
2929 0 : zval_dtor(free_op2.var);
2930 0 : ZEND_VM_NEXT_OPCODE();
2931 : }
2932 :
2933 : static int ZEND_IS_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2934 0 : {
2935 0 : zend_op *opline = EX(opline);
2936 : zend_free_op free_op2;
2937 :
2938 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
2939 : &opline->op1.u.constant,
2940 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2941 :
2942 0 : zval_dtor(free_op2.var);
2943 0 : ZEND_VM_NEXT_OPCODE();
2944 : }
2945 :
2946 : static int ZEND_IS_NOT_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2947 0 : {
2948 0 : zend_op *opline = EX(opline);
2949 : zend_free_op free_op2;
2950 :
2951 0 : is_not_equal_function(&EX_T(opline->result.u.var).tmp_var,
2952 : &opline->op1.u.constant,
2953 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2954 :
2955 0 : zval_dtor(free_op2.var);
2956 0 : ZEND_VM_NEXT_OPCODE();
2957 : }
2958 :
2959 : static int ZEND_IS_SMALLER_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2960 15952 : {
2961 15952 : zend_op *opline = EX(opline);
2962 : zend_free_op free_op2;
2963 :
2964 15952 : is_smaller_function(&EX_T(opline->result.u.var).tmp_var,
2965 : &opline->op1.u.constant,
2966 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2967 :
2968 15952 : zval_dtor(free_op2.var);
2969 15952 : ZEND_VM_NEXT_OPCODE();
2970 : }
2971 :
2972 : static int ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2973 0 : {
2974 0 : zend_op *opline = EX(opline);
2975 : zend_free_op free_op2;
2976 :
2977 0 : is_smaller_or_equal_function(&EX_T(opline->result.u.var).tmp_var,
2978 : &opline->op1.u.constant,
2979 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2980 :
2981 0 : zval_dtor(free_op2.var);
2982 0 : ZEND_VM_NEXT_OPCODE();
2983 : }
2984 :
2985 : static int ZEND_BW_OR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2986 0 : {
2987 0 : zend_op *opline = EX(opline);
2988 : zend_free_op free_op2;
2989 :
2990 0 : bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
2991 : &opline->op1.u.constant,
2992 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2993 :
2994 0 : zval_dtor(free_op2.var);
2995 0 : ZEND_VM_NEXT_OPCODE();
2996 : }
2997 :
2998 : static int ZEND_BW_AND_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2999 0 : {
3000 0 : zend_op *opline = EX(opline);
3001 : zend_free_op free_op2;
3002 :
3003 0 : bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
3004 : &opline->op1.u.constant,
3005 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3006 :
3007 0 : zval_dtor(free_op2.var);
3008 0 : ZEND_VM_NEXT_OPCODE();
3009 : }
3010 :
3011 : static int ZEND_BW_XOR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3012 0 : {
3013 0 : zend_op *opline = EX(opline);
3014 : zend_free_op free_op2;
3015 :
3016 0 : bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
3017 : &opline->op1.u.constant,
3018 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3019 :
3020 0 : zval_dtor(free_op2.var);
3021 0 : ZEND_VM_NEXT_OPCODE();
3022 : }
3023 :
3024 : static int ZEND_BOOL_XOR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3025 0 : {
3026 0 : zend_op *opline = EX(opline);
3027 : zend_free_op free_op2;
3028 :
3029 0 : boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
3030 : &opline->op1.u.constant,
3031 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3032 :
3033 0 : zval_dtor(free_op2.var);
3034 0 : ZEND_VM_NEXT_OPCODE();
3035 : }
3036 :
3037 : static int ZEND_CASE_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3038 0 : {
3039 0 : zend_op *opline = EX(opline);
3040 0 : int switch_expr_is_overloaded=0;
3041 : zend_free_op free_op2;
3042 :
3043 : if (IS_CONST==IS_VAR) {
3044 : if (EX_T(opline->op1.u.var).var.ptr_ptr) {
3045 : PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
3046 : } else {
3047 : switch_expr_is_overloaded = 1;
3048 : EX_T(opline->op1.u.var).str_offset.str->refcount++;
3049 : }
3050 : }
3051 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
3052 : &opline->op1.u.constant,
3053 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3054 :
3055 0 : zval_dtor(free_op2.var);
3056 0 : if (switch_expr_is_overloaded) {
3057 : /* We only free op1 if this is a string offset,
3058 : * Since if it is a TMP_VAR, it'll be reused by
3059 : * other CASE opcodes (whereas string offsets
3060 : * are allocated at each get_zval_ptr())
3061 : */
3062 :
3063 0 : EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
3064 0 : AI_USE_PTR(EX_T(opline->op1.u.var).var);
3065 : }
3066 0 : ZEND_VM_NEXT_OPCODE();
3067 : }
3068 :
3069 : static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3070 12 : {
3071 12 : zend_op *opline = EX(opline);
3072 : zend_free_op free_op2;
3073 12 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
3074 : zval *expr_ptr;
3075 12 : zval *offset=_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
3076 :
3077 : #if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
3078 : zval **expr_ptr_ptr = NULL;
3079 :
3080 : if (opline->extended_value) {
3081 : expr_ptr_ptr=NULL;
3082 : expr_ptr = *expr_ptr_ptr;
3083 : } else {
3084 : expr_ptr=&opline->op1.u.constant;
3085 : }
3086 : #else
3087 12 : expr_ptr=&opline->op1.u.constant;
3088 : #endif
3089 :
3090 : if (0) { /* temporary variable */
3091 : zval *new_expr;
3092 :
3093 : ALLOC_ZVAL(new_expr);
3094 : INIT_PZVAL_COPY(new_expr, expr_ptr);
3095 : expr_ptr = new_expr;
3096 : } else {
3097 : #if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
3098 : if (opline->extended_value) {
3099 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
3100 : expr_ptr = *expr_ptr_ptr;
3101 : expr_ptr->refcount++;
3102 : } else
3103 : #endif
3104 12 : if (PZVAL_IS_REF(expr_ptr)) {
3105 : zval *new_expr;
3106 :
3107 12 : ALLOC_ZVAL(new_expr);
3108 12 : INIT_PZVAL_COPY(new_expr, expr_ptr);
3109 12 : expr_ptr = new_expr;
3110 12 : zendi_zval_copy_ctor(*expr_ptr);
3111 : } else {
3112 0 : expr_ptr->refcount++;
3113 : }
3114 : }
3115 12 : if (offset) {
3116 12 : switch (Z_TYPE_P(offset)) {
3117 : case IS_DOUBLE:
3118 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
3119 0 : break;
3120 : case IS_LONG:
3121 : case IS_BOOL:
3122 12 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
3123 12 : break;
3124 : case IS_STRING:
3125 0 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
3126 0 : break;
3127 : case IS_NULL:
3128 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
3129 0 : break;
3130 : default:
3131 0 : zend_error(E_WARNING, "Illegal offset type");
3132 0 : zval_ptr_dtor(&expr_ptr);
3133 : /* do nothing */
3134 : break;
3135 : }
3136 12 : zval_dtor(free_op2.var);
3137 : } else {
3138 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
3139 : }
3140 12 : if (opline->extended_value) {
3141 :
3142 : } else {
3143 :
3144 : }
3145 12 : ZEND_VM_NEXT_OPCODE();
3146 : }
3147 :
3148 : static int ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3149 1 : {
3150 1 : zend_op *opline = EX(opline);
3151 :
3152 1 : array_init(&EX_T(opline->result.u.var).tmp_var);
3153 : if (IS_CONST == IS_UNUSED) {
3154 : ZEND_VM_NEXT_OPCODE();
3155 : #if 0 || IS_CONST != IS_UNUSED
3156 : } else {
3157 1 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3158 : #endif
3159 : }
3160 : }
3161 :
3162 : static int ZEND_ADD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3163 0 : {
3164 0 : zend_op *opline = EX(opline);
3165 : zend_free_op free_op2;
3166 :
3167 0 : add_function(&EX_T(opline->result.u.var).tmp_var,
3168 : &opline->op1.u.constant,
3169 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3170 :
3171 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3172 0 : ZEND_VM_NEXT_OPCODE();
3173 : }
3174 :
3175 : static int ZEND_SUB_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3176 0 : {
3177 0 : zend_op *opline = EX(opline);
3178 : zend_free_op free_op2;
3179 :
3180 0 : sub_function(&EX_T(opline->result.u.var).tmp_var,
3181 : &opline->op1.u.constant,
3182 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3183 :
3184 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3185 0 : ZEND_VM_NEXT_OPCODE();
3186 : }
3187 :
3188 : static int ZEND_MUL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3189 5 : {
3190 5 : zend_op *opline = EX(opline);
3191 : zend_free_op free_op2;
3192 :
3193 5 : mul_function(&EX_T(opline->result.u.var).tmp_var,
3194 : &opline->op1.u.constant,
3195 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3196 :
3197 5 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3198 5 : ZEND_VM_NEXT_OPCODE();
3199 : }
3200 :
3201 : static int ZEND_DIV_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3202 0 : {
3203 0 : zend_op *opline = EX(opline);
3204 : zend_free_op free_op2;
3205 :
3206 0 : div_function(&EX_T(opline->result.u.var).tmp_var,
3207 : &opline->op1.u.constant,
3208 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3209 :
3210 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3211 0 : ZEND_VM_NEXT_OPCODE();
3212 : }
3213 :
3214 : static int ZEND_MOD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3215 0 : {
3216 0 : zend_op *opline = EX(opline);
3217 : zend_free_op free_op2;
3218 :
3219 0 : mod_function(&EX_T(opline->result.u.var).tmp_var,
3220 : &opline->op1.u.constant,
3221 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3222 :
3223 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3224 0 : ZEND_VM_NEXT_OPCODE();
3225 : }
3226 :
3227 : static int ZEND_SL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3228 0 : {
3229 0 : zend_op *opline = EX(opline);
3230 : zend_free_op free_op2;
3231 :
3232 0 : shift_left_function(&EX_T(opline->result.u.var).tmp_var,
3233 : &opline->op1.u.constant,
3234 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3235 :
3236 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3237 0 : ZEND_VM_NEXT_OPCODE();
3238 : }
3239 :
3240 : static int ZEND_SR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3241 0 : {
3242 0 : zend_op *opline = EX(opline);
3243 : zend_free_op free_op2;
3244 :
3245 0 : shift_right_function(&EX_T(opline->result.u.var).tmp_var,
3246 : &opline->op1.u.constant,
3247 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3248 :
3249 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3250 0 : ZEND_VM_NEXT_OPCODE();
3251 : }
3252 :
3253 : static int ZEND_CONCAT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3254 4 : {
3255 4 : zend_op *opline = EX(opline);
3256 : zend_free_op free_op2;
3257 :
3258 4 : concat_function(&EX_T(opline->result.u.var).tmp_var,
3259 : &opline->op1.u.constant,
3260 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3261 :
3262 4 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3263 4 : ZEND_VM_NEXT_OPCODE();
3264 : }
3265 :
3266 : static int ZEND_IS_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3267 0 : {
3268 0 : zend_op *opline = EX(opline);
3269 : zend_free_op free_op2;
3270 :
3271 0 : is_identical_function(&EX_T(opline->result.u.var).tmp_var,
3272 : &opline->op1.u.constant,
3273 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3274 :
3275 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3276 0 : ZEND_VM_NEXT_OPCODE();
3277 : }
3278 :
3279 : static int ZEND_IS_NOT_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3280 0 : {
3281 0 : zend_op *opline = EX(opline);
3282 : zend_free_op free_op2;
3283 :
3284 0 : is_not_identical_function(&EX_T(opline->result.u.var).tmp_var,
3285 : &opline->op1.u.constant,
3286 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3287 :
3288 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3289 0 : ZEND_VM_NEXT_OPCODE();
3290 : }
3291 :
3292 : static int ZEND_IS_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3293 0 : {
3294 0 : zend_op *opline = EX(opline);
3295 : zend_free_op free_op2;
3296 :
3297 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
3298 : &opline->op1.u.constant,
3299 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3300 :
3301 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3302 0 : ZEND_VM_NEXT_OPCODE();
3303 : }
3304 :
3305 : static int ZEND_IS_NOT_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3306 0 : {
3307 0 : zend_op *opline = EX(opline);
3308 : zend_free_op free_op2;
3309 :
3310 0 : is_not_equal_function(&EX_T(opline->result.u.var).tmp_var,
3311 : &opline->op1.u.constant,
3312 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3313 :
3314 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3315 0 : ZEND_VM_NEXT_OPCODE();
3316 : }
3317 :
3318 : static int ZEND_IS_SMALLER_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3319 10916 : {
3320 10916 : zend_op *opline = EX(opline);
3321 : zend_free_op free_op2;
3322 :
3323 10916 : is_smaller_function(&EX_T(opline->result.u.var).tmp_var,
3324 : &opline->op1.u.constant,
3325 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3326 :
3327 10916 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3328 10916 : ZEND_VM_NEXT_OPCODE();
3329 : }
3330 :
3331 : static int ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3332 0 : {
3333 0 : zend_op *opline = EX(opline);
3334 : zend_free_op free_op2;
3335 :
3336 0 : is_smaller_or_equal_function(&EX_T(opline->result.u.var).tmp_var,
3337 : &opline->op1.u.constant,
3338 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3339 :
3340 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3341 0 : ZEND_VM_NEXT_OPCODE();
3342 : }
3343 :
3344 : static int ZEND_BW_OR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3345 0 : {
3346 0 : zend_op *opline = EX(opline);
3347 : zend_free_op free_op2;
3348 :
3349 0 : bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
3350 : &opline->op1.u.constant,
3351 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3352 :
3353 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3354 0 : ZEND_VM_NEXT_OPCODE();
3355 : }
3356 :
3357 : static int ZEND_BW_AND_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3358 0 : {
3359 0 : zend_op *opline = EX(opline);
3360 : zend_free_op free_op2;
3361 :
3362 0 : bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
3363 : &opline->op1.u.constant,
3364 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3365 :
3366 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3367 0 : ZEND_VM_NEXT_OPCODE();
3368 : }
3369 :
3370 : static int ZEND_BW_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3371 0 : {
3372 0 : zend_op *opline = EX(opline);
3373 : zend_free_op free_op2;
3374 :
3375 0 : bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
3376 : &opline->op1.u.constant,
3377 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3378 :
3379 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3380 0 : ZEND_VM_NEXT_OPCODE();
3381 : }
3382 :
3383 : static int ZEND_BOOL_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3384 0 : {
3385 0 : zend_op *opline = EX(opline);
3386 : zend_free_op free_op2;
3387 :
3388 0 : boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
3389 : &opline->op1.u.constant,
3390 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3391 :
3392 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3393 0 : ZEND_VM_NEXT_OPCODE();
3394 : }
3395 :
3396 : static int ZEND_CASE_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3397 0 : {
3398 0 : zend_op *opline = EX(opline);
3399 0 : int switch_expr_is_overloaded=0;
3400 : zend_free_op free_op2;
3401 :
3402 : if (IS_CONST==IS_VAR) {
3403 : if (EX_T(opline->op1.u.var).var.ptr_ptr) {
3404 : PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
3405 : } else {
3406 : switch_expr_is_overloaded = 1;
3407 : EX_T(opline->op1.u.var).str_offset.str->refcount++;
3408 : }
3409 : }
3410 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
3411 : &opline->op1.u.constant,
3412 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3413 :
3414 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3415 0 : if (switch_expr_is_overloaded) {
3416 : /* We only free op1 if this is a string offset,
3417 : * Since if it is a TMP_VAR, it'll be reused by
3418 : * other CASE opcodes (whereas string offsets
3419 : * are allocated at each get_zval_ptr())
3420 : */
3421 :
3422 0 : EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
3423 0 : AI_USE_PTR(EX_T(opline->op1.u.var).var);
3424 : }
3425 0 : ZEND_VM_NEXT_OPCODE();
3426 : }
3427 :
3428 : static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3429 0 : {
3430 0 : zend_op *opline = EX(opline);
3431 : zend_free_op free_op2;
3432 0 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
3433 : zval *expr_ptr;
3434 0 : zval *offset=_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
3435 :
3436 : #if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
3437 : zval **expr_ptr_ptr = NULL;
3438 :
3439 : if (opline->extended_value) {
3440 : expr_ptr_ptr=NULL;
3441 : expr_ptr = *expr_ptr_ptr;
3442 : } else {
3443 : expr_ptr=&opline->op1.u.constant;
3444 : }
3445 : #else
3446 0 : expr_ptr=&opline->op1.u.constant;
3447 : #endif
3448 :
3449 : if (0) { /* temporary variable */
3450 : zval *new_expr;
3451 :
3452 : ALLOC_ZVAL(new_expr);
3453 : INIT_PZVAL_COPY(new_expr, expr_ptr);
3454 : expr_ptr = new_expr;
3455 : } else {
3456 : #if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
3457 : if (opline->extended_value) {
3458 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
3459 : expr_ptr = *expr_ptr_ptr;
3460 : expr_ptr->refcount++;
3461 : } else
3462 : #endif
3463 0 : if (PZVAL_IS_REF(expr_ptr)) {
3464 : zval *new_expr;
3465 :
3466 0 : ALLOC_ZVAL(new_expr);
3467 0 : INIT_PZVAL_COPY(new_expr, expr_ptr);
3468 0 : expr_ptr = new_expr;
3469 0 : zendi_zval_copy_ctor(*expr_ptr);
3470 : } else {
3471 0 : expr_ptr->refcount++;
3472 : }
3473 : }
3474 0 : if (offset) {
3475 0 : switch (Z_TYPE_P(offset)) {
3476 : case IS_DOUBLE:
3477 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
3478 0 : break;
3479 : case IS_LONG:
3480 : case IS_BOOL:
3481 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
3482 0 : break;
3483 : case IS_STRING:
3484 0 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
3485 0 : break;
3486 : case IS_NULL:
3487 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
3488 0 : break;
3489 : default:
3490 0 : zend_error(E_WARNING, "Illegal offset type");
3491 0 : zval_ptr_dtor(&expr_ptr);
3492 : /* do nothing */
3493 : break;
3494 : }
3495 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3496 : } else {
3497 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
3498 : }
3499 0 : if (opline->extended_value) {
3500 :
3501 : } else {
3502 :
3503 : }
3504 0 : ZEND_VM_NEXT_OPCODE();
3505 : }
3506 :
3507 : static int ZEND_INIT_ARRAY_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3508 0 : {
3509 0 : zend_op *opline = EX(opline);
3510 :
3511 0 : array_init(&EX_T(opline->result.u.var).tmp_var);
3512 : if (IS_CONST == IS_UNUSED) {
3513 : ZEND_VM_NEXT_OPCODE();
3514 : #if 0 || IS_CONST != IS_UNUSED
3515 : } else {
3516 0 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3517 : #endif
3518 : }
3519 : }
3520 :
3521 : static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3522 1486 : {
3523 1486 : zend_op *opline = EX(opline);
3524 :
3525 1486 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
3526 : zval *expr_ptr;
3527 1486 : zval *offset=NULL;
3528 :
3529 : #if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
3530 : zval **expr_ptr_ptr = NULL;
3531 :
3532 : if (opline->extended_value) {
3533 : expr_ptr_ptr=NULL;
3534 : expr_ptr = *expr_ptr_ptr;
3535 : } else {
3536 : expr_ptr=&opline->op1.u.constant;
3537 : }
3538 : #else
3539 1486 : expr_ptr=&opline->op1.u.constant;
3540 : #endif
3541 :
3542 : if (0) { /* temporary variable */
3543 : zval *new_expr;
3544 :
3545 : ALLOC_ZVAL(new_expr);
3546 : INIT_PZVAL_COPY(new_expr, expr_ptr);
3547 : expr_ptr = new_expr;
3548 : } else {
3549 : #if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
3550 : if (opline->extended_value) {
3551 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
3552 : expr_ptr = *expr_ptr_ptr;
3553 : expr_ptr->refcount++;
3554 : } else
3555 : #endif
3556 1486 : if (PZVAL_IS_REF(expr_ptr)) {
3557 : zval *new_expr;
3558 :
3559 1486 : ALLOC_ZVAL(new_expr);
3560 1486 : INIT_PZVAL_COPY(new_expr, expr_ptr);
3561 1486 : expr_ptr = new_expr;
3562 1486 : zendi_zval_copy_ctor(*expr_ptr);
3563 : } else {
3564 0 : expr_ptr->refcount++;
3565 : }
3566 : }
3567 1486 : if (offset) {
3568 0 : switch (Z_TYPE_P(offset)) {
3569 : case IS_DOUBLE:
3570 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
3571 0 : break;
3572 : case IS_LONG:
3573 : case IS_BOOL:
3574 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
3575 0 : break;
3576 : case IS_STRING:
3577 0 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
3578 0 : break;
3579 : case IS_NULL:
3580 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
3581 0 : break;
3582 : default:
3583 0 : zend_error(E_WARNING, "Illegal offset type");
3584 0 : zval_ptr_dtor(&expr_ptr);
3585 : /* do nothing */
3586 : break;
3587 : }
3588 :
3589 : } else {
3590 1486 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
3591 : }
3592 1486 : if (opline->extended_value) {
3593 :
3594 : } else {
3595 :
3596 : }
3597 1486 : ZEND_VM_NEXT_OPCODE();
3598 : }
3599 :
3600 : static int ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3601 711 : {
3602 711 : zend_op *opline = EX(opline);
3603 :
3604 711 : array_init(&EX_T(opline->result.u.var).tmp_var);
3605 : if (IS_CONST == IS_UNUSED) {
3606 : ZEND_VM_NEXT_OPCODE();
3607 : #if 0 || IS_CONST != IS_UNUSED
3608 : } else {
3609 711 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3610 : #endif
3611 : }
3612 : }
3613 :
3614 : static int ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3615 0 : {
3616 0 : zend_op *opline = EX(opline);
3617 :
3618 :
3619 0 : add_function(&EX_T(opline->result.u.var).tmp_var,
3620 : &opline->op1.u.constant,
3621 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
3622 :
3623 :
3624 0 : ZEND_VM_NEXT_OPCODE();
3625 : }
3626 :
3627 : static int ZEND_SUB_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3628 0 : {
3629 0 : zend_op *opline = EX(opline);
3630 :
3631 :
3632 0 : sub_function(&EX_T(opline->result.u.var).tmp_var,
3633 : &opline->op1.u.constant,
3634 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
3635 :
3636 :
3637 0 : ZEND_VM_NEXT_OPCODE();
3638 : }
3639 :
3640 : static int ZEND_MUL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3641 6 : {
3642 6 : zend_op *opline = EX(opline);
3643 :
3644 :
3645 6 : mul_function(&EX_T(opline->result.u.var).tmp_var,
3646 : &opline->op1.u.constant,
3647 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
3648 :
3649 :
3650 6 : ZEND_VM_NEXT_OPCODE();
3651 : }
3652 :
3653 : static int ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3654 0 : {
3655 0 : zend_op *opline = EX(opline);
3656 :
3657 :
3658 0 : div_function(&EX_T(opline->result.u.var).tmp_var,
3659 : &opline->op1.u.constant,
3660 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
3661 :
3662 :
3663 0 : ZEND_VM_NEXT_OPCODE();
3664 : }
3665 :
3666 : static int ZEND_MOD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3667 0 : {
3668 0 : zend_op *opline = EX(opline);
3669 :
3670 :
3671 0 : mod_function(&EX_T(opline->result.u.var).tmp_var,
3672 : &opline->op1.u.constant,
3673 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
3674 :
3675 :
3676 0 : ZEND_VM_NEXT_OPCODE();
3677 : }
3678 :
3679 : static int ZEND_SL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3680 0 : {
3681 0 : zend_op *opline = EX(opline);
3682 :
3683 :
3684 0 : shift_left_function(&EX_T(opline->result.u.var).tmp_var,
3685 : &opline->op1.u.constant,
3686 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
3687 :
3688 :
3689 0 : ZEND_VM_NEXT_OPCODE();
3690 : }
3691 :
3692 : static int ZEND_SR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3693 0 : {
3694 0 : zend_op *opline = EX(opline);
3695 :
3696 :
3697 0 : shift_right_function(&EX_T(opline->result.u.var).tmp_var,
3698 : &opline->op1.u.constant,
3699 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
3700 :
3701 :
3702 0 : ZEND_VM_NEXT_OPCODE();
3703 : }
3704 :
3705 : static int ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3706 15044 : {
3707 15044 : zend_op *opline = EX(opline);
3708 :
3709 :
3710 15044 : concat_function(&EX_T(opline->result.u.var).tmp_var,
3711 : &opline->op1.u.constant,
3712 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
3713 :
3714 :
3715 15044 : ZEND_VM_NEXT_OPCODE();
3716 : }
3717 :
3718 : static int ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3719 0 : {
3720 0 : zend_op *opline = EX(opline);
3721 :
3722 :
3723 0 : is_identical_function(&EX_T(opline->result.u.var).tmp_var,
3724 : &opline->op1.u.constant,
3725 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
3726 :
3727 :
3728 0 : ZEND_VM_NEXT_OPCODE();
3729 : }
3730 :
3731 : static int ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3732 0 : {
3733 0 : zend_op *opline = EX(opline);
3734 :
3735 :
3736 0 : is_not_identical_function(&EX_T(opline->result.u.var).tmp_var,
3737 : &opline->op1.u.constant,
3738 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
3739 :
3740 :
3741 0 : ZEND_VM_NEXT_OPCODE();
3742 : }
3743 :
3744 : static int ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3745 0 : {
3746 0 : zend_op *opline = EX(opline);
3747 :
3748 :
3749 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
3750 : &opline->op1.u.constant,
3751 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
3752 :
3753 :
3754 0 : ZEND_VM_NEXT_OPCODE();
3755 : }
3756 :
3757 : static int ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3758 0 : {
3759 0 : zend_op *opline = EX(opline);
3760 :
3761 :
3762 0 : is_not_equal_function(&EX_T(opline->result.u.var).tmp_var,
3763 : &opline->op1.u.constant,
3764 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
3765 :
3766 :
3767 0 : ZEND_VM_NEXT_OPCODE();
3768 : }
3769 :
3770 : static int ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3771 4652 : {
3772 4652 : zend_op *opline = EX(opline);
3773 :
3774 :
3775 4652 : is_smaller_function(&EX_T(opline->result.u.var).tmp_var,
3776 : &opline->op1.u.constant,
3777 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
3778 :
3779 :
3780 4652 : ZEND_VM_NEXT_OPCODE();
3781 : }
3782 :
3783 : static int ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3784 0 : {
3785 0 : zend_op *opline = EX(opline);
3786 :
3787 :
3788 0 : is_smaller_or_equal_function(&EX_T(opline->result.u.var).tmp_var,
3789 : &opline->op1.u.constant,
3790 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
3791 :
3792 :
3793 0 : ZEND_VM_NEXT_OPCODE();
3794 : }
3795 :
3796 : static int ZEND_BW_OR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3797 0 : {
3798 0 : zend_op *opline = EX(opline);
3799 :
3800 :
3801 0 : bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
3802 : &opline->op1.u.constant,
3803 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
3804 :
3805 :
3806 0 : ZEND_VM_NEXT_OPCODE();
3807 : }
3808 :
3809 : static int ZEND_BW_AND_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3810 0 : {
3811 0 : zend_op *opline = EX(opline);
3812 :
3813 :
3814 0 : bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
3815 : &opline->op1.u.constant,
3816 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
3817 :
3818 :
3819 0 : ZEND_VM_NEXT_OPCODE();
3820 : }
3821 :
3822 : static int ZEND_BW_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3823 0 : {
3824 0 : zend_op *opline = EX(opline);
3825 :
3826 :
3827 0 : bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
3828 : &opline->op1.u.constant,
3829 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
3830 :
3831 :
3832 0 : ZEND_VM_NEXT_OPCODE();
3833 : }
3834 :
3835 : static int ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3836 0 : {
3837 0 : zend_op *opline = EX(opline);
3838 :
3839 :
3840 0 : boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
3841 : &opline->op1.u.constant,
3842 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
3843 :
3844 :
3845 0 : ZEND_VM_NEXT_OPCODE();
3846 : }
3847 :
3848 : static int ZEND_CASE_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3849 0 : {
3850 0 : zend_op *opline = EX(opline);
3851 0 : int switch_expr_is_overloaded=0;
3852 :
3853 :
3854 : if (IS_CONST==IS_VAR) {
3855 : if (EX_T(opline->op1.u.var).var.ptr_ptr) {
3856 : PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
3857 : } else {
3858 : switch_expr_is_overloaded = 1;
3859 : EX_T(opline->op1.u.var).str_offset.str->refcount++;
3860 : }
3861 : }
3862 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
3863 : &opline->op1.u.constant,
3864 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
3865 :
3866 0 : if (switch_expr_is_overloaded) {
3867 : /* We only free op1 if this is a string offset,
3868 : * Since if it is a TMP_VAR, it'll be reused by
3869 : * other CASE opcodes (whereas string offsets
3870 : * are allocated at each get_zval_ptr())
3871 : */
3872 :
3873 0 : EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
3874 0 : AI_USE_PTR(EX_T(opline->op1.u.var).var);
3875 : }
3876 0 : ZEND_VM_NEXT_OPCODE();
3877 : }
3878 :
3879 : static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3880 0 : {
3881 0 : zend_op *opline = EX(opline);
3882 :
3883 0 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
3884 : zval *expr_ptr;
3885 0 : zval *offset=_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
3886 :
3887 : #if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
3888 : zval **expr_ptr_ptr = NULL;
3889 :
3890 : if (opline->extended_value) {
3891 : expr_ptr_ptr=NULL;
3892 : expr_ptr = *expr_ptr_ptr;
3893 : } else {
3894 : expr_ptr=&opline->op1.u.constant;
3895 : }
3896 : #else
3897 0 : expr_ptr=&opline->op1.u.constant;
3898 : #endif
3899 :
3900 : if (0) { /* temporary variable */
3901 : zval *new_expr;
3902 :
3903 : ALLOC_ZVAL(new_expr);
3904 : INIT_PZVAL_COPY(new_expr, expr_ptr);
3905 : expr_ptr = new_expr;
3906 : } else {
3907 : #if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
3908 : if (opline->extended_value) {
3909 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
3910 : expr_ptr = *expr_ptr_ptr;
3911 : expr_ptr->refcount++;
3912 : } else
3913 : #endif
3914 0 : if (PZVAL_IS_REF(expr_ptr)) {
3915 : zval *new_expr;
3916 :
3917 0 : ALLOC_ZVAL(new_expr);
3918 0 : INIT_PZVAL_COPY(new_expr, expr_ptr);
3919 0 : expr_ptr = new_expr;
3920 0 : zendi_zval_copy_ctor(*expr_ptr);
3921 : } else {
3922 0 : expr_ptr->refcount++;
3923 : }
3924 : }
3925 0 : if (offset) {
3926 0 : switch (Z_TYPE_P(offset)) {
3927 : case IS_DOUBLE:
3928 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
3929 0 : break;
3930 : case IS_LONG:
3931 : case IS_BOOL:
3932 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
3933 0 : break;
3934 : case IS_STRING:
3935 0 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
3936 0 : break;
3937 : case IS_NULL:
3938 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
3939 0 : break;
3940 : default:
3941 0 : zend_error(E_WARNING, "Illegal offset type");
3942 0 : zval_ptr_dtor(&expr_ptr);
3943 : /* do nothing */
3944 : break;
3945 : }
3946 :
3947 : } else {
3948 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
3949 : }
3950 0 : if (opline->extended_value) {
3951 :
3952 : } else {
3953 :
3954 : }
3955 0 : ZEND_VM_NEXT_OPCODE();
3956 : }
3957 :
3958 : static int ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3959 0 : {
3960 0 : zend_op *opline = EX(opline);
3961 :
3962 0 : array_init(&EX_T(opline->result.u.var).tmp_var);
3963 : if (IS_CONST == IS_UNUSED) {
3964 : ZEND_VM_NEXT_OPCODE();
3965 : #if 0 || IS_CONST != IS_UNUSED
3966 : } else {
3967 0 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3968 : #endif
3969 : }
3970 : }
3971 :
3972 : static int ZEND_BW_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3973 0 : {
3974 0 : zend_op *opline = EX(opline);
3975 : zend_free_op free_op1;
3976 :
3977 0 : bitwise_not_function(&EX_T(opline->result.u.var).tmp_var,
3978 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) TSRMLS_CC);
3979 0 : zval_dtor(free_op1.var);
3980 0 : ZEND_VM_NEXT_OPCODE();
3981 : }
3982 :
3983 : static int ZEND_BOOL_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3984 804 : {
3985 804 : zend_op *opline = EX(opline);
3986 : zend_free_op free_op1;
3987 :
3988 804 : boolean_not_function(&EX_T(opline->result.u.var).tmp_var,
3989 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) TSRMLS_CC);
3990 804 : zval_dtor(free_op1.var);
3991 804 : ZEND_VM_NEXT_OPCODE();
3992 : }
3993 :
3994 : static int ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3995 222 : {
3996 222 : zend_op *opline = EX(opline);
3997 : zend_free_op free_op1;
3998 : zval z_copy;
3999 222 : zval *z = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4000 :
4001 222 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get_method != NULL &&
4002 : zend_std_cast_object_tostring(z, &z_copy, IS_STRING TSRMLS_CC) == SUCCESS) {
4003 0 : zend_print_variable(&z_copy);
4004 0 : zval_dtor(&z_copy);
4005 : } else {
4006 222 : zend_print_variable(z);
4007 : }
4008 :
4009 222 : zval_dtor(free_op1.var);
4010 222 : ZEND_VM_NEXT_OPCODE();
4011 : }
4012 :
4013 : static int ZEND_PRINT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4014 0 : {
4015 0 : zend_op *opline = EX(opline);
4016 :
4017 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
4018 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_LONG;
4019 :
4020 0 : return ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4021 : }
4022 :
4023 : static int zend_fetch_var_address_helper_SPEC_TMP(int type, ZEND_OPCODE_HANDLER_ARGS)
4024 0 : {
4025 0 : zend_op *opline = EX(opline);
4026 : zend_free_op free_op1;
4027 0 : zval *varname = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4028 : zval **retval;
4029 : zval tmp_varname;
4030 : HashTable *target_symbol_table;
4031 :
4032 0 : if (Z_TYPE_P(varname) != IS_STRING) {
4033 0 : tmp_varname = *varname;
4034 0 : zval_copy_ctor(&tmp_varname);
4035 0 : convert_to_string(&tmp_varname);
4036 0 : varname = &tmp_varname;
4037 : }
4038 :
4039 0 : if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
4040 0 : 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);
4041 : } else {
4042 0 : target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), type, varname TSRMLS_CC);
4043 : /*
4044 : if (!target_symbol_table) {
4045 : ZEND_VM_NEXT_OPCODE();
4046 : }
4047 : */
4048 0 : if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &retval) == FAILURE) {
4049 0 : switch (type) {
4050 : case BP_VAR_R:
4051 : case BP_VAR_UNSET:
4052 0 : zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
4053 : /* break missing intentionally */
4054 : case BP_VAR_IS:
4055 0 : retval = &EG(uninitialized_zval_ptr);
4056 0 : break;
4057 : case BP_VAR_RW:
4058 0 : zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
4059 : /* break missing intentionally */
4060 : case BP_VAR_W: {
4061 0 : zval *new_zval = &EG(uninitialized_zval);
4062 :
4063 0 : new_zval->refcount++;
4064 0 : zend_hash_update(target_symbol_table, varname->value.str.val, varname->value.str.len+1, &new_zval, sizeof(zval *), (void **) &retval);
4065 : }
4066 : break;
4067 : EMPTY_SWITCH_DEFAULT_CASE()
4068 : }
4069 : }
4070 0 : switch (opline->op2.u.EA.type) {
4071 : case ZEND_FETCH_GLOBAL:
4072 : if (IS_TMP_VAR != IS_TMP_VAR) {
4073 : zval_dtor(free_op1.var);
4074 : }
4075 0 : break;
4076 : case ZEND_FETCH_LOCAL:
4077 0 : zval_dtor(free_op1.var);
4078 0 : break;
4079 : case ZEND_FETCH_STATIC:
4080 0 : zval_update_constant(retval, (void*) 1 TSRMLS_CC);
4081 : break;
4082 : case ZEND_FETCH_GLOBAL_LOCK:
4083 : if (IS_TMP_VAR == IS_VAR && !free_op1.var) {
4084 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
4085 : }
4086 : break;
4087 : }
4088 : }
4089 :
4090 :
4091 0 : if (varname == &tmp_varname) {
4092 0 : zval_dtor(varname);
4093 : }
4094 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
4095 0 : EX_T(opline->result.u.var).var.ptr_ptr = retval;
4096 0 : PZVAL_LOCK(*retval);
4097 0 : switch (type) {
4098 : case BP_VAR_R:
4099 : case BP_VAR_IS:
4100 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
4101 0 : break;
4102 : case BP_VAR_UNSET: {
4103 : zend_free_op free_res;
4104 :
4105 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
4106 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
4107 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
4108 : }
4109 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
4110 0 : FREE_OP_VAR_PTR(free_res);
4111 : break;
4112 : }
4113 : }
4114 : }
4115 0 : ZEND_VM_NEXT_OPCODE();
4116 : }
4117 :
4118 : static int ZEND_FETCH_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4119 0 : {
4120 0 : return zend_fetch_var_address_helper_SPEC_TMP(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4121 : }
4122 :
4123 : static int ZEND_FETCH_W_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4124 0 : {
4125 0 : return zend_fetch_var_address_helper_SPEC_TMP(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4126 : }
4127 :
4128 : static int ZEND_FETCH_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4129 0 : {
4130 0 : return zend_fetch_var_address_helper_SPEC_TMP(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4131 : }
4132 :
4133 : static int ZEND_FETCH_FUNC_ARG_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4134 0 : {
4135 0 : 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);
4136 : }
4137 :
4138 : static int ZEND_FETCH_UNSET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4139 0 : {
4140 0 : return zend_fetch_var_address_helper_SPEC_TMP(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4141 : }
4142 :
4143 : static int ZEND_FETCH_IS_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4144 0 : {
4145 0 : return zend_fetch_var_address_helper_SPEC_TMP(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4146 : }
4147 :
4148 : static int ZEND_JMPZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4149 75125 : {
4150 75125 : zend_op *opline = EX(opline);
4151 : zend_free_op free_op1;
4152 75125 : int ret = i_zend_is_true(_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC));
4153 :
4154 75125 : zval_dtor(free_op1.var);
4155 75125 : if (!ret) {
4156 : #if DEBUG_ZEND>=2
4157 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
4158 : #endif
4159 50896 : ZEND_VM_JMP(opline->op2.u.jmp_addr);
4160 : }
4161 :
4162 24229 : ZEND_VM_NEXT_OPCODE();
4163 : }
4164 :
4165 : static int ZEND_JMPNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4166 0 : {
4167 0 : zend_op *opline = EX(opline);
4168 : zend_free_op free_op1;
4169 0 : int ret = i_zend_is_true(_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC));
4170 :
4171 0 : zval_dtor(free_op1.var);
4172 0 : if (ret) {
4173 : #if DEBUG_ZEND>=2
4174 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
4175 : #endif
4176 0 : ZEND_VM_JMP(opline->op2.u.jmp_addr);
4177 : }
4178 :
4179 0 : ZEND_VM_NEXT_OPCODE();
4180 : }
4181 :
4182 : static int ZEND_JMPZNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4183 21569 : {
4184 21569 : zend_op *opline = EX(opline);
4185 : zend_free_op free_op1;
4186 21569 : int retval = i_zend_is_true(_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC));
4187 :
4188 21569 : zval_dtor(free_op1.var);
4189 21569 : if (retval) {
4190 : #if DEBUG_ZEND>=2
4191 : printf("Conditional jmp on true to %d\n", opline->extended_value);
4192 : #endif
4193 15788 : ZEND_VM_JMP(&EX(op_array)->opcodes[opline->extended_value]);
4194 : } else {
4195 : #if DEBUG_ZEND>=2
4196 : printf("Conditional jmp on false to %d\n", opline->op2.u.opline_num);
4197 : #endif
4198 5781 : ZEND_VM_JMP(&EX(op_array)->opcodes[opline->op2.u.opline_num]);
4199 : }
4200 : }
4201 :
4202 : static int ZEND_JMPZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4203 47302 : {
4204 47302 : zend_op *opline = EX(opline);
4205 : zend_free_op free_op1;
4206 47302 : int retval = i_zend_is_true(_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC));
4207 :
4208 47302 : zval_dtor(free_op1.var);
4209 47302 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
4210 47302 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
4211 47302 : if (!retval) {
4212 : #if DEBUG_ZEND>=2
4213 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
4214 : #endif
4215 1027 : ZEND_VM_JMP(opline->op2.u.jmp_addr);
4216 : }
4217 46275 : ZEND_VM_NEXT_OPCODE();
4218 : }
4219 :
4220 : static int ZEND_JMPNZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4221 982 : {
4222 982 : zend_op *opline = EX(opline);
4223 : zend_free_op free_op1;
4224 982 : int retval = i_zend_is_true(_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC));
4225 :
4226 982 : zval_dtor(free_op1.var);
4227 982 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
4228 982 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
4229 982 : if (retval) {
4230 : #if DEBUG_ZEND>=2
4231 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
4232 : #endif
4233 304 : ZEND_VM_JMP(opline->op2.u.jmp_addr);
4234 : }
4235 678 : ZEND_VM_NEXT_OPCODE();
4236 : }
4237 :
4238 : static int ZEND_FREE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4239 28261 : {
4240 28261 : zendi_zval_dtor(EX_T(EX(opline)->op1.u.var).tmp_var);
4241 28261 : ZEND_VM_NEXT_OPCODE();
4242 : }
4243 :
4244 : static int ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4245 4 : {
4246 4 : zend_op *opline = EX(opline);
4247 : zval *retval_ptr;
4248 : zval **retval_ptr_ptr;
4249 : zend_free_op free_op1;
4250 :
4251 4 : if (EG(active_op_array)->return_reference == ZEND_RETURN_REF) {
4252 :
4253 : if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
4254 : /* Not supposed to happen, but we'll allow it */
4255 0 : zend_error(E_NOTICE, "Only variable references should be returned by reference");
4256 0 : goto return_by_value;
4257 : }
4258 :
4259 : retval_ptr_ptr = NULL;
4260 :
4261 : if (!retval_ptr_ptr) {
4262 : zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
4263 : }
4264 :
4265 : if (IS_TMP_VAR == IS_VAR && !(*retval_ptr_ptr)->is_ref) {
4266 : if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
4267 : EX_T(opline->op1.u.var).var.fcall_returned_reference) {
4268 : } else if (EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
4269 : if (IS_TMP_VAR == IS_VAR && !1) {
4270 : PZVAL_LOCK(*retval_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
4271 : }
4272 : zend_error(E_NOTICE, "Only variable references should be returned by reference");
4273 : goto return_by_value;
4274 : }
4275 : }
4276 :
4277 : SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
4278 : (*retval_ptr_ptr)->refcount++;
4279 :
4280 : (*EG(return_value_ptr_ptr)) = (*retval_ptr_ptr);
4281 : } else {
4282 4 : return_by_value:
4283 :
4284 4 : retval_ptr = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4285 :
4286 4 : if (EG(ze1_compatibility_mode) && Z_TYPE_P(retval_ptr) == IS_OBJECT) {
4287 : zval *ret;
4288 : char *class_name;
4289 : zend_uint class_name_len;
4290 : int dup;
4291 :
4292 0 : ALLOC_ZVAL(ret);
4293 0 : INIT_PZVAL_COPY(ret, retval_ptr);
4294 0 : dup = zend_get_object_classname(retval_ptr, &class_name, &class_name_len TSRMLS_CC);
4295 0 : if (Z_OBJ_HT_P(retval_ptr)->clone_obj == NULL) {
4296 0 : zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", class_name);
4297 : }
4298 0 : zend_error(E_STRICT, "Implicit cloning object of class '%s' because of 'zend.ze1_compatibility_mode'", class_name);
4299 0 : ret->value.obj = Z_OBJ_HT_P(retval_ptr)->clone_obj(retval_ptr TSRMLS_CC);
4300 0 : *EG(return_value_ptr_ptr) = ret;
4301 0 : if (!dup) {
4302 0 : efree(class_name);
4303 : }
4304 : } else if (!1) { /* Not a temp var */
4305 : if (EG(active_op_array)->return_reference == ZEND_RETURN_REF ||
4306 : (PZVAL_IS_REF(retval_ptr) && retval_ptr->refcount > 0)) {
4307 : zval *ret;
4308 :
4309 : ALLOC_ZVAL(ret);
4310 : INIT_PZVAL_COPY(ret, retval_ptr);
4311 : zval_copy_ctor(ret);
4312 : *EG(return_value_ptr_ptr) = ret;
4313 : } else {
4314 : *EG(return_value_ptr_ptr) = retval_ptr;
4315 : retval_ptr->refcount++;
4316 : }
4317 : } else {
4318 : zval *ret;
4319 :
4320 4 : ALLOC_ZVAL(ret);
4321 4 : INIT_PZVAL_COPY(ret, retval_ptr);
4322 4 : *EG(return_value_ptr_ptr) = ret;
4323 : }
4324 : }
4325 :
4326 4 : ZEND_VM_RETURN_FROM_EXECUTE_LOOP();
4327 : }
4328 :
4329 : static int ZEND_THROW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4330 0 : {
4331 0 : zend_op *opline = EX(opline);
4332 : zval *value;
4333 : zval *exception;
4334 : zend_free_op free_op1;
4335 :
4336 0 : value = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4337 :
4338 0 : if (Z_TYPE_P(value) != IS_OBJECT) {
4339 0 : zend_error_noreturn(E_ERROR, "Can only throw objects");
4340 : }
4341 : /* Not sure if a complete copy is what we want here */
4342 0 : ALLOC_ZVAL(exception);
4343 0 : INIT_PZVAL_COPY(exception, value);
4344 : if (!1) {
4345 : zval_copy_ctor(exception);
4346 : }
4347 :
4348 0 : zend_throw_exception_object(exception TSRMLS_CC);
4349 :
4350 0 : ZEND_VM_NEXT_OPCODE();
4351 : }
4352 :
4353 : static int ZEND_SEND_VAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4354 22880 : {
4355 22880 : zend_op *opline = EX(opline);
4356 22880 : if (opline->extended_value==ZEND_DO_FCALL_BY_NAME
4357 : && ARG_MUST_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
4358 0 : zend_error_noreturn(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.u.opline_num);
4359 : }
4360 : {
4361 : zval *valptr;
4362 : zval *value;
4363 : zend_free_op free_op1;
4364 :
4365 22880 : value = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4366 :
4367 22880 : ALLOC_ZVAL(valptr);
4368 22880 : INIT_PZVAL_COPY(valptr, value);
4369 : if (!1) {
4370 : zval_copy_ctor(valptr);
4371 : }
4372 22880 : zend_ptr_stack_push(&EG(argument_stack), valptr);
4373 :
4374 : }
4375 22880 : ZEND_VM_NEXT_OPCODE();
4376 : }
4377 :
4378 : static int ZEND_BOOL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4379 32614 : {
4380 32614 : zend_op *opline = EX(opline);
4381 : zend_free_op free_op1;
4382 :
4383 : /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
4384 32614 : 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));
4385 32614 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
4386 32614 : zval_dtor(free_op1.var);
4387 :
4388 32614 : ZEND_VM_NEXT_OPCODE();
4389 : }
4390 :
4391 : static int ZEND_SWITCH_FREE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4392 0 : {
4393 0 : zend_switch_free(EX(opline), EX(Ts) TSRMLS_CC);
4394 0 : ZEND_VM_NEXT_OPCODE();
4395 : }
4396 :
4397 : static int ZEND_CLONE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4398 0 : {
4399 0 : zend_op *opline = EX(opline);
4400 : zend_free_op free_op1;
4401 0 : zval *obj = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4402 : zend_class_entry *ce;
4403 : zend_function *clone;
4404 : zend_object_clone_obj_t clone_call;
4405 :
4406 0 : if (!obj || Z_TYPE_P(obj) != IS_OBJECT) {
4407 0 : zend_error(E_WARNING, "__clone method called on non-object");
4408 0 : EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
4409 0 : EX_T(opline->result.u.var).var.ptr->refcount++;
4410 :
4411 0 : ZEND_VM_NEXT_OPCODE();
4412 : }
4413 :
4414 0 : ce = Z_OBJCE_P(obj);
4415 0 : clone = ce ? ce->clone : NULL;
4416 0 : clone_call = Z_OBJ_HT_P(obj)->clone_obj;
4417 0 : if (!clone_call) {
4418 0 : if (ce) {
4419 0 : zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
4420 : } else {
4421 0 : zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
4422 : }
4423 : EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
4424 : EX_T(opline->result.u.var).var.ptr->refcount++;
4425 : }
4426 :
4427 0 : if (ce && clone) {
4428 0 : if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
4429 : /* Ensure that if we're calling a private function, we're allowed to do so.
4430 : */
4431 0 : if (ce != EG(scope)) {
4432 0 : zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
4433 : }
4434 0 : } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
4435 : /* Ensure that if we're calling a protected function, we're allowed to do so.
4436 : */
4437 0 : if (!zend_check_protected(clone->common.scope, EG(scope))) {
4438 0 : zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
4439 : }
4440 : }
4441 : }
4442 :
4443 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
4444 0 : if (!EG(exception)) {
4445 0 : ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
4446 0 : Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC);
4447 0 : Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
4448 0 : EX_T(opline->result.u.var).var.ptr->refcount=1;
4449 0 : EX_T(opline->result.u.var).var.ptr->is_ref=1;
4450 0 : if (!RETURN_VALUE_USED(opline) || EG(exception)) {
4451 0 : zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
4452 : }
4453 : }
4454 :
4455 0 : ZEND_VM_NEXT_OPCODE();
4456 : }
4457 :
4458 : static int ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4459 56 : {
4460 56 : zend_op *opline = EX(opline);
4461 : zend_free_op free_op1;
4462 56 : zval *expr = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4463 56 : zval *result = &EX_T(opline->result.u.var).tmp_var;
4464 :
4465 56 : *result = *expr;
4466 : if (!1) {
4467 : zendi_zval_copy_ctor(*result);
4468 : }
4469 56 : switch (opline->extended_value) {
4470 : case IS_NULL:
4471 0 : convert_to_null(result);
4472 0 : break;
4473 : case IS_BOOL:
4474 0 : convert_to_boolean(result);
4475 0 : break;
4476 : case IS_LONG:
4477 0 : convert_to_long(result);
4478 0 : break;
4479 : case IS_DOUBLE:
4480 54 : convert_to_double(result);
4481 54 : break;
4482 : case IS_STRING: {
4483 : zval var_copy;
4484 : int use_copy;
4485 :
4486 0 : zend_make_printable_zval(result, &var_copy, &use_copy);
4487 0 : if (use_copy) {
4488 0 : zval_dtor(result);
4489 0 : *result = var_copy;
4490 : }
4491 0 : break;
4492 : }
4493 : case IS_ARRAY:
4494 0 : convert_to_array(result);
4495 0 : break;
4496 : case IS_OBJECT:
4497 2 : convert_to_object(result);
4498 : break;
4499 : }
4500 :
4501 56 : ZEND_VM_NEXT_OPCODE();
4502 : }
4503 :
4504 : static int ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4505 0 : {
4506 0 : zend_op *opline = EX(opline);
4507 0 : zend_op_array *new_op_array=NULL;
4508 0 : zval **original_return_value = EG(return_value_ptr_ptr);
4509 : int return_value_used;
4510 : zend_free_op free_op1;
4511 0 : zval *inc_filename = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4512 : zval tmp_inc_filename;
4513 0 : zend_bool failure_retval=0;
4514 :
4515 0 : if (inc_filename->type!=IS_STRING) {
4516 0 : tmp_inc_filename = *inc_filename;
4517 0 : zval_copy_ctor(&tmp_inc_filename);
4518 0 : convert_to_string(&tmp_inc_filename);
4519 0 : inc_filename = &tmp_inc_filename;
4520 : }
4521 :
4522 0 : return_value_used = RETURN_VALUE_USED(opline);
4523 :
4524 0 : switch (Z_LVAL(opline->op2.u.constant)) {
4525 : case ZEND_INCLUDE_ONCE:
4526 : case ZEND_REQUIRE_ONCE: {
4527 : zend_file_handle file_handle;
4528 : char cwd[MAXPATHLEN];
4529 : cwd_state state;
4530 :
4531 0 : if (IS_ABSOLUTE_PATH(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename))) {
4532 0 : cwd[0] = '\0';
4533 0 : } else if (!VCWD_GETCWD(cwd, MAXPATHLEN)) {
4534 0 : cwd[0] = '\0';
4535 : }
4536 :
4537 0 : state.cwd_length = strlen(cwd);
4538 0 : state.cwd = zend_strndup(cwd, state.cwd_length);
4539 :
4540 0 : failure_retval = (!virtual_file_ex(&state, Z_STRVAL_P(inc_filename), NULL, 1) &&
4541 : zend_hash_exists(&EG(included_files), state.cwd, state.cwd_length+1));
4542 :
4543 0 : free(state.cwd);
4544 :
4545 0 : if (failure_retval) {
4546 : /* do nothing */
4547 0 : } else if (SUCCESS == zend_stream_open(Z_STRVAL_P(inc_filename), &file_handle TSRMLS_CC)) {
4548 :
4549 0 : if (!file_handle.opened_path) {
4550 0 : file_handle.opened_path = estrndup(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename));
4551 : }
4552 :
4553 0 : if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
4554 0 : new_op_array = zend_compile_file(&file_handle, (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
4555 0 : zend_destroy_file_handle(&file_handle TSRMLS_CC);
4556 : } else {
4557 0 : zend_file_handle_dtor(&file_handle);
4558 0 : failure_retval=1;
4559 : }
4560 : } else {
4561 0 : if (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE) {
4562 0 : zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename));
4563 : } else {
4564 0 : zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename));
4565 : }
4566 : }
4567 : }
4568 0 : break;
4569 : case ZEND_INCLUDE:
4570 : case ZEND_REQUIRE:
4571 0 : new_op_array = compile_filename(Z_LVAL(opline->op2.u.constant), inc_filename TSRMLS_CC);
4572 0 : break;
4573 : case ZEND_EVAL: {
4574 0 : char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
4575 :
4576 0 : new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
4577 0 : efree(eval_desc);
4578 : }
4579 : break;
4580 : EMPTY_SWITCH_DEFAULT_CASE()
4581 : }
4582 0 : if (inc_filename==&tmp_inc_filename) {
4583 0 : zval_dtor(&tmp_inc_filename);
4584 : }
4585 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
4586 0 : if (new_op_array) {
4587 : zval *saved_object;
4588 : zend_function *saved_function;
4589 :
4590 0 : EG(return_value_ptr_ptr) = EX_T(opline->result.u.var).var.ptr_ptr;
4591 0 : EG(active_op_array) = new_op_array;
4592 0 : EX_T(opline->result.u.var).var.ptr = NULL;
4593 :
4594 0 : saved_object = EX(object);
4595 0 : saved_function = EX(function_state).function;
4596 :
4597 0 : EX(function_state).function = (zend_function *) new_op_array;
4598 0 : EX(object) = NULL;
4599 :
4600 0 : zend_execute(new_op_array TSRMLS_CC);
4601 :
4602 0 : EX(function_state).function = saved_function;
4603 0 : EX(object) = saved_object;
4604 :
4605 0 : if (!return_value_used) {
4606 0 : if (EX_T(opline->result.u.var).var.ptr) {
4607 0 : zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
4608 : }
4609 : } else { /* return value is used */
4610 0 : if (!EX_T(opline->result.u.var).var.ptr) { /* there was no return statement */
4611 0 : ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
4612 0 : INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
4613 0 : Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = 1;
4614 0 : Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
4615 : }
4616 : }
4617 :
4618 0 : EG(opline_ptr) = &EX(opline);
4619 0 : EG(active_op_array) = EX(op_array);
4620 0 : EG(function_state_ptr) = &EX(function_state);
4621 0 : destroy_op_array(new_op_array TSRMLS_CC);
4622 0 : efree(new_op_array);
4623 0 : if (EG(exception)) {
4624 0 : zend_throw_exception_internal(NULL TSRMLS_CC);
4625 : }
4626 : } else {
4627 0 : if (return_value_used) {
4628 0 : ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
4629 0 : INIT_ZVAL(*EX_T(opline->result.u.var).var.ptr);
4630 0 : Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = failure_retval;
4631 0 : Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
4632 : }
4633 : }
4634 0 : zval_dtor(free_op1.var);
4635 0 : EG(return_value_ptr_ptr) = original_return_value;
4636 0 : ZEND_VM_NEXT_OPCODE();
4637 : }
4638 :
4639 : static int ZEND_UNSET_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4640 0 : {
4641 0 : zend_op *opline = EX(opline);
4642 : zval tmp, *varname;
4643 : HashTable *target_symbol_table;
4644 : zend_free_op free_op1;
4645 :
4646 0 : varname = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4647 :
4648 0 : if (Z_TYPE_P(varname) != IS_STRING) {
4649 0 : tmp = *varname;
4650 0 : zval_copy_ctor(&tmp);
4651 0 : convert_to_string(&tmp);
4652 0 : varname = &tmp;
4653 : } else if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
4654 : varname->refcount++;
4655 : }
4656 :
4657 0 : if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
4658 0 : zend_std_unset_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname) TSRMLS_CC);
4659 : } else {
4660 0 : target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
4661 0 : if (zend_hash_del(target_symbol_table, varname->value.str.val, varname->value.str.len+1) == SUCCESS) {
4662 0 : zend_execute_data *ex = execute_data;
4663 0 : ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
4664 :
4665 : do {
4666 : int i;
4667 :
4668 0 : if (ex->op_array) {
4669 0 : for (i = 0; i < ex->op_array->last_var; i++) {
4670 0 : if (ex->op_array->vars[i].hash_value == hash_value &&
4671 : ex->op_array->vars[i].name_len == varname->value.str.len &&
4672 : !memcmp(ex->op_array->vars[i].name, varname->value.str.val, varname->value.str.len)) {
4673 0 : ex->CVs[i] = NULL;
4674 0 : break;
4675 : }
4676 : }
4677 : }
4678 0 : ex = ex->prev_execute_data;
4679 0 : } while (ex && ex->symbol_table == target_symbol_table);
4680 : }
4681 : }
4682 :
4683 0 : if (varname == &tmp) {
4684 0 : zval_dtor(&tmp);
4685 : } else if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
4686 : zval_ptr_dtor(&varname);
4687 : }
4688 0 : zval_dtor(free_op1.var);
4689 0 : ZEND_VM_NEXT_OPCODE();
4690 : }
4691 :
4692 : static int ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4693 3 : {
4694 3 : zend_op *opline = EX(opline);
4695 : zend_free_op free_op1;
4696 : zval *array_ptr, **array_ptr_ptr;
4697 : HashTable *fe_ht;
4698 3 : zend_object_iterator *iter = NULL;
4699 3 : zend_class_entry *ce = NULL;
4700 3 : zend_bool is_empty = 0;
4701 :
4702 3 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
4703 0 : array_ptr_ptr = NULL;
4704 0 : if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
4705 0 : ALLOC_INIT_ZVAL(array_ptr);
4706 0 : } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
4707 0 : if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
4708 0 : zend_error(E_WARNING, "foreach() can not iterate over objects without PHP class");
4709 0 : ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
4710 : }
4711 :
4712 0 : ce = Z_OBJCE_PP(array_ptr_ptr);
4713 0 : if (!ce || ce->get_iterator == NULL) {
4714 0 : SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
4715 0 : (*array_ptr_ptr)->refcount++;
4716 : }
4717 0 : array_ptr = *array_ptr_ptr;
4718 : } else {
4719 0 : if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
4720 0 : SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
4721 0 : if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
4722 0 : (*array_ptr_ptr)->is_ref = 1;
4723 : }
4724 : }
4725 0 : array_ptr = *array_ptr_ptr;
4726 0 : array_ptr->refcount++;
4727 : }
4728 : } else {
4729 3 : array_ptr = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4730 : if (1) { /* IS_TMP_VAR */
4731 : zval *tmp;
4732 :
4733 3 : ALLOC_ZVAL(tmp);
4734 3 : INIT_PZVAL_COPY(tmp, array_ptr);
4735 3 : array_ptr = tmp;
4736 : } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
4737 : ce = Z_OBJCE_P(array_ptr);
4738 : if (!ce || !ce->get_iterator) {
4739 : array_ptr->refcount++;
4740 : }
4741 : } else {
4742 : if (IS_TMP_VAR == IS_VAR &&
4743 : free_op1.var == NULL &&
4744 : !array_ptr->is_ref &&
4745 : array_ptr->refcount > 1) {
4746 : /* non-separated return value from function */
4747 : zval *tmp;
4748 :
4749 : ALLOC_ZVAL(tmp);
4750 : INIT_PZVAL_COPY(tmp, array_ptr);
4751 : zval_copy_ctor(tmp);
4752 : array_ptr = tmp;
4753 : } else {
4754 : array_ptr->refcount++;
4755 : }
4756 : }
4757 : }
4758 :
4759 : if (IS_TMP_VAR != IS_TMP_VAR && ce && ce->get_iterator) {
4760 : iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC);
4761 :
4762 : if (iter && !EG(exception)) {
4763 : array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
4764 : } else {
4765 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
4766 :
4767 : } else {
4768 :
4769 : }
4770 : if (!EG(exception)) {
4771 : zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
4772 : }
4773 : zend_throw_exception_internal(NULL TSRMLS_CC);
4774 : ZEND_VM_NEXT_OPCODE();
4775 : }
4776 : }
4777 :
4778 3 : PZVAL_LOCK(array_ptr);
4779 3 : EX_T(opline->result.u.var).var.ptr = array_ptr;
4780 3 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
4781 :
4782 3 : if (iter) {
4783 0 : iter->index = 0;
4784 0 : if (iter->funcs->rewind) {
4785 0 : iter->funcs->rewind(iter TSRMLS_CC);
4786 0 : if (EG(exception)) {
4787 0 : array_ptr->refcount--;
4788 0 : zval_ptr_dtor(&array_ptr);
4789 0 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
4790 :
4791 : } else {
4792 :
4793 : }
4794 0 : ZEND_VM_NEXT_OPCODE();
4795 : }
4796 : }
4797 0 : is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
4798 0 : if (EG(exception)) {
4799 0 : array_ptr->refcount--;
4800 0 : zval_ptr_dtor(&array_ptr);
4801 0 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
4802 :
4803 : } else {
4804 :
4805 : }
4806 0 : ZEND_VM_NEXT_OPCODE();
4807 : }
4808 0 : iter->index = -1; /* will be set to 0 before using next handler */
4809 3 : } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
4810 3 : zend_hash_internal_pointer_reset(fe_ht);
4811 3 : if (ce) {
4812 0 : zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
4813 0 : while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
4814 : char *str_key;
4815 : uint str_key_len;
4816 : ulong int_key;
4817 : zend_uchar key_type;
4818 :
4819 0 : key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
4820 0 : if (key_type != HASH_KEY_NON_EXISTANT &&
4821 : (key_type == HASH_KEY_IS_LONG ||
4822 : zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
4823 : break;
4824 : }
4825 0 : zend_hash_move_forward(fe_ht);
4826 : }
4827 : }
4828 3 : is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
4829 3 : zend_hash_get_pointer(fe_ht, &EX_T(opline->result.u.var).fe.fe_pos);
4830 : } else {
4831 0 : zend_error(E_WARNING, "Invalid argument supplied for foreach()");
4832 0 : is_empty = 1;
4833 : }
4834 :
4835 3 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
4836 :
4837 : } else {
4838 :
4839 : }
4840 3 : if (is_empty) {
4841 2 : ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
4842 : } else {
4843 1 : ZEND_VM_NEXT_OPCODE();
4844 : }
4845 : }
4846 :
4847 : static int ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4848 0 : {
4849 0 : zend_op *opline = EX(opline);
4850 : zend_free_op free_op1;
4851 0 : zval tmp, *varname = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4852 : zval **value;
4853 0 : zend_bool isset = 1;
4854 : HashTable *target_symbol_table;
4855 :
4856 0 : if (Z_TYPE_P(varname) != IS_STRING) {
4857 0 : tmp = *varname;
4858 0 : zval_copy_ctor(&tmp);
4859 0 : convert_to_string(&tmp);
4860 0 : varname = &tmp;
4861 : }
4862 :
4863 0 : if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
4864 0 : 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);
4865 0 : if (!value) {
4866 0 : isset = 0;
4867 : }
4868 : } else {
4869 0 : target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
4870 0 : if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
4871 0 : isset = 0;
4872 : }
4873 : }
4874 :
4875 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
4876 :
4877 0 : switch (opline->extended_value) {
4878 : case ZEND_ISSET:
4879 0 : if (isset && Z_TYPE_PP(value) == IS_NULL) {
4880 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
4881 : } else {
4882 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = isset;
4883 : }
4884 0 : break;
4885 : case ZEND_ISEMPTY:
4886 0 : if (!isset || !i_zend_is_true(*value)) {
4887 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
4888 : } else {
4889 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
4890 : }
4891 : break;
4892 : }
4893 :
4894 0 : if (varname == &tmp) {
4895 0 : zval_dtor(&tmp);
4896 : }
4897 0 : zval_dtor(free_op1.var);
4898 :
4899 0 : ZEND_VM_NEXT_OPCODE();
4900 : }
4901 :
4902 : static int ZEND_EXIT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4903 0 : {
4904 : #if 0 || (IS_TMP_VAR != IS_UNUSED)
4905 0 : zend_op *opline = EX(opline);
4906 : if (IS_TMP_VAR != IS_UNUSED) {
4907 : zend_free_op free_op1;
4908 0 : zval *ptr = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4909 :
4910 0 : if (Z_TYPE_P(ptr) == IS_LONG) {
4911 0 : EG(exit_status) = Z_LVAL_P(ptr);
4912 : } else {
4913 0 : zend_print_variable(ptr);
4914 : }
4915 0 : zval_dtor(free_op1.var);
4916 : }
4917 : #endif
4918 0 : zend_bailout();
4919 0 : ZEND_VM_NEXT_OPCODE();
4920 : }
4921 :
4922 : static int ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4923 4660 : {
4924 4660 : zend_op *opline = EX(opline);
4925 : zval restored_error_reporting;
4926 :
4927 4660 : if (!EG(error_reporting) && Z_LVAL(EX_T(opline->op1.u.var).tmp_var) != 0) {
4928 4660 : Z_TYPE(restored_error_reporting) = IS_LONG;
4929 4660 : Z_LVAL(restored_error_reporting) = Z_LVAL(EX_T(opline->op1.u.var).tmp_var);
4930 4660 : convert_to_string(&restored_error_reporting);
4931 4660 : zend_alter_ini_entry("error_reporting", sizeof("error_reporting"), Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
4932 4660 : zendi_zval_dtor(restored_error_reporting);
4933 : }
4934 4660 : if (EX(old_error_reporting) == &EX_T(opline->op1.u.var).tmp_var) {
4935 4660 : EX(old_error_reporting) = NULL;
4936 : }
4937 4660 : ZEND_VM_NEXT_OPCODE();
4938 : }
4939 :
4940 : static int ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4941 49 : {
4942 49 : zend_op *opline = EX(opline);
4943 : zend_free_op free_op1;
4944 49 : zval *value = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4945 :
4946 49 : EX_T(opline->result.u.var).tmp_var = *value;
4947 : if (!1) {
4948 : zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
4949 : }
4950 :
4951 49 : ZEND_VM_NEXT_OPCODE();
4952 : }
4953 :
4954 : static int ZEND_INSTANCEOF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4955 0 : {
4956 0 : zend_op *opline = EX(opline);
4957 : zend_free_op free_op1;
4958 0 : zval *expr = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4959 : zend_bool result;
4960 :
4961 0 : if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) {
4962 0 : result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.u.var).class_entry TSRMLS_CC);
4963 : } else {
4964 0 : result = 0;
4965 : }
4966 0 : ZVAL_BOOL(&EX_T(opline->result.u.var).tmp_var, result);
4967 0 : zval_dtor(free_op1.var);
4968 0 : ZEND_VM_NEXT_OPCODE();
4969 : }
4970 :
4971 : static int ZEND_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4972 35 : {
4973 35 : zend_op *opline = EX(opline);
4974 : zend_free_op free_op1;
4975 :
4976 35 : add_function(&EX_T(opline->result.u.var).tmp_var,
4977 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
4978 : &opline->op2.u.constant TSRMLS_CC);
4979 35 : zval_dtor(free_op1.var);
4980 :
4981 35 : ZEND_VM_NEXT_OPCODE();
4982 : }
4983 :
4984 : static int ZEND_SUB_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4985 0 : {
4986 0 : zend_op *opline = EX(opline);
4987 : zend_free_op free_op1;
4988 :
4989 0 : sub_function(&EX_T(opline->result.u.var).tmp_var,
4990 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
4991 : &opline->op2.u.constant TSRMLS_CC);
4992 0 : zval_dtor(free_op1.var);
4993 :
4994 0 : ZEND_VM_NEXT_OPCODE();
4995 : }
4996 :
4997 : static int ZEND_MUL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4998 0 : {
4999 0 : zend_op *opline = EX(opline);
5000 : zend_free_op free_op1;
5001 :
5002 0 : mul_function(&EX_T(opline->result.u.var).tmp_var,
5003 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5004 : &opline->op2.u.constant TSRMLS_CC);
5005 0 : zval_dtor(free_op1.var);
5006 :
5007 0 : ZEND_VM_NEXT_OPCODE();
5008 : }
5009 :
5010 : static int ZEND_DIV_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5011 0 : {
5012 0 : zend_op *opline = EX(opline);
5013 : zend_free_op free_op1;
5014 :
5015 0 : div_function(&EX_T(opline->result.u.var).tmp_var,
5016 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5017 : &opline->op2.u.constant TSRMLS_CC);
5018 0 : zval_dtor(free_op1.var);
5019 :
5020 0 : ZEND_VM_NEXT_OPCODE();
5021 : }
5022 :
5023 : static int ZEND_MOD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5024 0 : {
5025 0 : zend_op *opline = EX(opline);
5026 : zend_free_op free_op1;
5027 :
5028 0 : mod_function(&EX_T(opline->result.u.var).tmp_var,
5029 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5030 : &opline->op2.u.constant TSRMLS_CC);
5031 0 : zval_dtor(free_op1.var);
5032 :
5033 0 : ZEND_VM_NEXT_OPCODE();
5034 : }
5035 :
5036 : static int ZEND_SL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5037 0 : {
5038 0 : zend_op *opline = EX(opline);
5039 : zend_free_op free_op1;
5040 :
5041 0 : shift_left_function(&EX_T(opline->result.u.var).tmp_var,
5042 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5043 : &opline->op2.u.constant TSRMLS_CC);
5044 0 : zval_dtor(free_op1.var);
5045 :
5046 0 : ZEND_VM_NEXT_OPCODE();
5047 : }
5048 :
5049 : static int ZEND_SR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5050 0 : {
5051 0 : zend_op *opline = EX(opline);
5052 : zend_free_op free_op1;
5053 :
5054 0 : shift_right_function(&EX_T(opline->result.u.var).tmp_var,
5055 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5056 : &opline->op2.u.constant TSRMLS_CC);
5057 0 : zval_dtor(free_op1.var);
5058 :
5059 0 : ZEND_VM_NEXT_OPCODE();
5060 : }
5061 :
5062 : static int ZEND_CONCAT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5063 16317 : {
5064 16317 : zend_op *opline = EX(opline);
5065 : zend_free_op free_op1;
5066 :
5067 16317 : concat_function(&EX_T(opline->result.u.var).tmp_var,
5068 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5069 : &opline->op2.u.constant TSRMLS_CC);
5070 16317 : zval_dtor(free_op1.var);
5071 :
5072 16317 : ZEND_VM_NEXT_OPCODE();
5073 : }
5074 :
5075 : static int ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5076 0 : {
5077 0 : zend_op *opline = EX(opline);
5078 : zend_free_op free_op1;
5079 :
5080 0 : is_identical_function(&EX_T(opline->result.u.var).tmp_var,
5081 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5082 : &opline->op2.u.constant TSRMLS_CC);
5083 0 : zval_dtor(free_op1.var);
5084 :
5085 0 : ZEND_VM_NEXT_OPCODE();
5086 : }
5087 :
5088 : static int ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5089 0 : {
5090 0 : zend_op *opline = EX(opline);
5091 : zend_free_op free_op1;
5092 :
5093 0 : is_not_identical_function(&EX_T(opline->result.u.var).tmp_var,
5094 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5095 : &opline->op2.u.constant TSRMLS_CC);
5096 0 : zval_dtor(free_op1.var);
5097 :
5098 0 : ZEND_VM_NEXT_OPCODE();
5099 : }
5100 :
5101 : static int ZEND_IS_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5102 0 : {
5103 0 : zend_op *opline = EX(opline);
5104 : zend_free_op free_op1;
5105 :
5106 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
5107 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5108 : &opline->op2.u.constant TSRMLS_CC);
5109 0 : zval_dtor(free_op1.var);
5110 :
5111 0 : ZEND_VM_NEXT_OPCODE();
5112 : }
5113 :
5114 : static int ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5115 220 : {
5116 220 : zend_op *opline = EX(opline);
5117 : zend_free_op free_op1;
5118 :
5119 220 : is_not_equal_function(&EX_T(opline->result.u.var).tmp_var,
5120 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5121 : &opline->op2.u.constant TSRMLS_CC);
5122 220 : zval_dtor(free_op1.var);
5123 :
5124 220 : ZEND_VM_NEXT_OPCODE();
5125 : }
5126 :
5127 : static int ZEND_IS_SMALLER_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5128 0 : {
5129 0 : zend_op *opline = EX(opline);
5130 : zend_free_op free_op1;
5131 :
5132 0 : is_smaller_function(&EX_T(opline->result.u.var).tmp_var,
5133 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5134 : &opline->op2.u.constant TSRMLS_CC);
5135 0 : zval_dtor(free_op1.var);
5136 :
5137 0 : ZEND_VM_NEXT_OPCODE();
5138 : }
5139 :
5140 : static int ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5141 0 : {
5142 0 : zend_op *opline = EX(opline);
5143 : zend_free_op free_op1;
5144 :
5145 0 : is_smaller_or_equal_function(&EX_T(opline->result.u.var).tmp_var,
5146 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5147 : &opline->op2.u.constant TSRMLS_CC);
5148 0 : zval_dtor(free_op1.var);
5149 :
5150 0 : ZEND_VM_NEXT_OPCODE();
5151 : }
5152 :
5153 : static int ZEND_BW_OR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5154 0 : {
5155 0 : zend_op *opline = EX(opline);
5156 : zend_free_op free_op1;
5157 :
5158 0 : bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
5159 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5160 : &opline->op2.u.constant TSRMLS_CC);
5161 0 : zval_dtor(free_op1.var);
5162 :
5163 0 : ZEND_VM_NEXT_OPCODE();
5164 : }
5165 :
5166 : static int ZEND_BW_AND_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5167 0 : {
5168 0 : zend_op *opline = EX(opline);
5169 : zend_free_op free_op1;
5170 :
5171 0 : bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
5172 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5173 : &opline->op2.u.constant TSRMLS_CC);
5174 0 : zval_dtor(free_op1.var);
5175 :
5176 0 : ZEND_VM_NEXT_OPCODE();
5177 : }
5178 :
5179 : static int ZEND_BW_XOR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5180 0 : {
5181 0 : zend_op *opline = EX(opline);
5182 : zend_free_op free_op1;
5183 :
5184 0 : bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
5185 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5186 : &opline->op2.u.constant TSRMLS_CC);
5187 0 : zval_dtor(free_op1.var);
5188 :
5189 0 : ZEND_VM_NEXT_OPCODE();
5190 : }
5191 :
5192 : static int ZEND_BOOL_XOR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5193 0 : {
5194 0 : zend_op *opline = EX(opline);
5195 : zend_free_op free_op1;
5196 :
5197 0 : boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
5198 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5199 : &opline->op2.u.constant TSRMLS_CC);
5200 0 : zval_dtor(free_op1.var);
5201 :
5202 0 : ZEND_VM_NEXT_OPCODE();
5203 : }
5204 :
5205 : static int ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5206 0 : {
5207 0 : zend_op *opline = EX(opline);
5208 : zend_free_op free_op1;
5209 0 : zval *container = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
5210 :
5211 0 : if (Z_TYPE_P(container) != IS_ARRAY) {
5212 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
5213 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
5214 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
5215 : }
5216 : } else {
5217 :
5218 0 : zval *dim = &opline->op2.u.constant;
5219 :
5220 0 : EX_T(opline->result.u.var).var.ptr_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, BP_VAR_R TSRMLS_CC);
5221 0 : SELECTIVE_PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &opline->result);
5222 :
5223 : }
5224 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
5225 0 : ZEND_VM_NEXT_OPCODE();
5226 : }
5227 :
5228 : static int ZEND_ADD_CHAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5229 5394 : {
5230 5394 : zend_op *opline = EX(opline);
5231 : zend_free_op free_op1;
5232 :
5233 5394 : add_char_to_string(&EX_T(opline->result.u.var).tmp_var,
5234 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5235 : &opline->op2.u.constant);
5236 : /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
5237 5394 : ZEND_VM_NEXT_OPCODE();
5238 : }
5239 :
5240 : static int ZEND_ADD_STRING_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5241 15953 : {
5242 15953 : zend_op *opline = EX(opline);
5243 : zend_free_op free_op1;
5244 :
5245 15953 : add_string_to_string(&EX_T(opline->result.u.var).tmp_var,
5246 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5247 : &opline->op2.u.constant);
5248 : /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
5249 15953 : ZEND_VM_NEXT_OPCODE();
5250 : }
5251 :
5252 : static int ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5253 0 : {
5254 0 : zend_op *opline = EX(opline);
5255 : zval *function_name;
5256 : char *function_name_strval;
5257 : int function_name_strlen;
5258 : zend_free_op free_op1;
5259 :
5260 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
5261 :
5262 0 : function_name = &opline->op2.u.constant;
5263 :
5264 0 : if (Z_TYPE_P(function_name)!=IS_STRING) {
5265 0 : zend_error_noreturn(E_ERROR, "Method name must be a string");
5266 : }
5267 :
5268 0 : function_name_strval = Z_STRVAL_P(function_name);
5269 0 : function_name_strlen = Z_STRLEN_P(function_name);
5270 :
5271 0 : EX(object) = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
5272 :
5273 0 : if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
5274 0 : if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
5275 0 : zend_error_noreturn(E_ERROR, "Object does not support method calls");
5276 : }
5277 :
5278 : /* First, locate the function. */
5279 0 : EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
5280 0 : if (!EX(fbc)) {
5281 0 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
5282 : }
5283 : } else {
5284 0 : zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
5285 : }
5286 :
5287 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
5288 0 : EX(object) = NULL;
5289 : } else {
5290 0 : if (!PZVAL_IS_REF(EX(object))) {
5291 0 : EX(object)->refcount++; /* For $this pointer */
5292 : } else {
5293 : zval *this_ptr;
5294 0 : ALLOC_ZVAL(this_ptr);
5295 0 : INIT_PZVAL_COPY(this_ptr, EX(object));
5296 0 : zval_copy_ctor(this_ptr);
5297 0 : EX(object) = this_ptr;
5298 : }
5299 : }
5300 :
5301 :
5302 0 : ZEND_VM_NEXT_OPCODE();
5303 : }
5304 :
5305 : static int ZEND_CASE_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5306 0 : {
5307 0 : zend_op *opline = EX(opline);
5308 0 : int switch_expr_is_overloaded=0;
5309 : zend_free_op free_op1;
5310 :
5311 : if (IS_TMP_VAR==IS_VAR) {
5312 : if (EX_T(opline->op1.u.var).var.ptr_ptr) {
5313 : PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
5314 : } else {
5315 : switch_expr_is_overloaded = 1;
5316 : EX_T(opline->op1.u.var).str_offset.str->refcount++;
5317 : }
5318 : }
5319 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
5320 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5321 : &opline->op2.u.constant TSRMLS_CC);
5322 :
5323 0 : if (switch_expr_is_overloaded) {
5324 : /* We only free op1 if this is a string offset,
5325 : * Since if it is a TMP_VAR, it'll be reused by
5326 : * other CASE opcodes (whereas string offsets
5327 : * are allocated at each get_zval_ptr())
5328 : */
5329 0 : zval_dtor(free_op1.var);
5330 0 : EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
5331 0 : AI_USE_PTR(EX_T(opline->op1.u.var).var);
5332 : }
5333 0 : ZEND_VM_NEXT_OPCODE();
5334 : }
5335 :
5336 : static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5337 863 : {
5338 863 : zend_op *opline = EX(opline);
5339 : zend_free_op free_op1;
5340 863 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
5341 : zval *expr_ptr;
5342 863 : zval *offset=&opline->op2.u.constant;
5343 :
5344 : #if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
5345 : zval **expr_ptr_ptr = NULL;
5346 :
5347 : if (opline->extended_value) {
5348 : expr_ptr_ptr=NULL;
5349 : expr_ptr = *expr_ptr_ptr;
5350 : } else {
5351 : expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
5352 : }
5353 : #else
5354 863 : expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
5355 : #endif
5356 :
5357 : if (1) { /* temporary variable */
5358 : zval *new_expr;
5359 :
5360 863 : ALLOC_ZVAL(new_expr);
5361 863 : INIT_PZVAL_COPY(new_expr, expr_ptr);
5362 863 : expr_ptr = new_expr;
5363 : } else {
5364 : #if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
5365 : if (opline->extended_value) {
5366 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
5367 : expr_ptr = *expr_ptr_ptr;
5368 : expr_ptr->refcount++;
5369 : } else
5370 : #endif
5371 : if (PZVAL_IS_REF(expr_ptr)) {
5372 : zval *new_expr;
5373 :
5374 : ALLOC_ZVAL(new_expr);
5375 : INIT_PZVAL_COPY(new_expr, expr_ptr);
5376 : expr_ptr = new_expr;
5377 : zendi_zval_copy_ctor(*expr_ptr);
5378 : } else {
5379 : expr_ptr->refcount++;
5380 : }
5381 : }
5382 863 : if (offset) {
5383 863 : switch (Z_TYPE_P(offset)) {
5384 : case IS_DOUBLE:
5385 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
5386 0 : break;
5387 : case IS_LONG:
5388 : case IS_BOOL:
5389 648 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
5390 648 : break;
5391 : case IS_STRING:
5392 215 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
5393 215 : break;
5394 : case IS_NULL:
5395 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
5396 0 : break;
5397 : default:
5398 0 : zend_error(E_WARNING, "Illegal offset type");
5399 0 : zval_ptr_dtor(&expr_ptr);
5400 : /* do nothing */
5401 : break;
5402 : }
5403 :
5404 : } else {
5405 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
5406 : }
5407 863 : if (opline->extended_value) {
5408 :
5409 : } else {
5410 :
5411 : }
5412 863 : ZEND_VM_NEXT_OPCODE();
5413 : }
5414 :
5415 : static int ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5416 219 : {
5417 219 : zend_op *opline = EX(opline);
5418 :
5419 219 : array_init(&EX_T(opline->result.u.var).tmp_var);
5420 : if (IS_TMP_VAR == IS_UNUSED) {
5421 : ZEND_VM_NEXT_OPCODE();
5422 : #if 0 || IS_TMP_VAR != IS_UNUSED
5423 : } else {
5424 219 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
5425 : #endif
5426 : }
5427 : }
5428 :
5429 : static int ZEND_ADD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5430 0 : {
5431 0 : zend_op *opline = EX(opline);
5432 : zend_free_op free_op1, free_op2;
5433 :
5434 0 : add_function(&EX_T(opline->result.u.var).tmp_var,
5435 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5436 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5437 0 : zval_dtor(free_op1.var);
5438 0 : zval_dtor(free_op2.var);
5439 0 : ZEND_VM_NEXT_OPCODE();
5440 : }
5441 :
5442 : static int ZEND_SUB_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5443 0 : {
5444 0 : zend_op *opline = EX(opline);
5445 : zend_free_op free_op1, free_op2;
5446 :
5447 0 : sub_function(&EX_T(opline->result.u.var).tmp_var,
5448 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5449 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5450 0 : zval_dtor(free_op1.var);
5451 0 : zval_dtor(free_op2.var);
5452 0 : ZEND_VM_NEXT_OPCODE();
5453 : }
5454 :
5455 : static int ZEND_MUL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5456 0 : {
5457 0 : zend_op *opline = EX(opline);
5458 : zend_free_op free_op1, free_op2;
5459 :
5460 0 : mul_function(&EX_T(opline->result.u.var).tmp_var,
5461 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5462 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5463 0 : zval_dtor(free_op1.var);
5464 0 : zval_dtor(free_op2.var);
5465 0 : ZEND_VM_NEXT_OPCODE();
5466 : }
5467 :
5468 : static int ZEND_DIV_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5469 0 : {
5470 0 : zend_op *opline = EX(opline);
5471 : zend_free_op free_op1, free_op2;
5472 :
5473 0 : div_function(&EX_T(opline->result.u.var).tmp_var,
5474 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5475 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5476 0 : zval_dtor(free_op1.var);
5477 0 : zval_dtor(free_op2.var);
5478 0 : ZEND_VM_NEXT_OPCODE();
5479 : }
5480 :
5481 : static int ZEND_MOD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5482 0 : {
5483 0 : zend_op *opline = EX(opline);
5484 : zend_free_op free_op1, free_op2;
5485 :
5486 0 : mod_function(&EX_T(opline->result.u.var).tmp_var,
5487 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5488 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5489 0 : zval_dtor(free_op1.var);
5490 0 : zval_dtor(free_op2.var);
5491 0 : ZEND_VM_NEXT_OPCODE();
5492 : }
5493 :
5494 : static int ZEND_SL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5495 0 : {
5496 0 : zend_op *opline = EX(opline);
5497 : zend_free_op free_op1, free_op2;
5498 :
5499 0 : shift_left_function(&EX_T(opline->result.u.var).tmp_var,
5500 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5501 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5502 0 : zval_dtor(free_op1.var);
5503 0 : zval_dtor(free_op2.var);
5504 0 : ZEND_VM_NEXT_OPCODE();
5505 : }
5506 :
5507 : static int ZEND_SR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5508 0 : {
5509 0 : zend_op *opline = EX(opline);
5510 : zend_free_op free_op1, free_op2;
5511 :
5512 0 : shift_right_function(&EX_T(opline->result.u.var).tmp_var,
5513 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5514 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5515 0 : zval_dtor(free_op1.var);
5516 0 : zval_dtor(free_op2.var);
5517 0 : ZEND_VM_NEXT_OPCODE();
5518 : }
5519 :
5520 : static int ZEND_CONCAT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5521 6 : {
5522 6 : zend_op *opline = EX(opline);
5523 : zend_free_op free_op1, free_op2;
5524 :
5525 6 : concat_function(&EX_T(opline->result.u.var).tmp_var,
5526 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5527 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5528 6 : zval_dtor(free_op1.var);
5529 6 : zval_dtor(free_op2.var);
5530 6 : ZEND_VM_NEXT_OPCODE();
5531 : }
5532 :
5533 : static int ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5534 0 : {
5535 0 : zend_op *opline = EX(opline);
5536 : zend_free_op free_op1, free_op2;
5537 :
5538 0 : is_identical_function(&EX_T(opline->result.u.var).tmp_var,
5539 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5540 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5541 0 : zval_dtor(free_op1.var);
5542 0 : zval_dtor(free_op2.var);
5543 0 : ZEND_VM_NEXT_OPCODE();
5544 : }
5545 :
5546 : static int ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5547 0 : {
5548 0 : zend_op *opline = EX(opline);
5549 : zend_free_op free_op1, free_op2;
5550 :
5551 0 : is_not_identical_function(&EX_T(opline->result.u.var).tmp_var,
5552 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5553 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5554 0 : zval_dtor(free_op1.var);
5555 0 : zval_dtor(free_op2.var);
5556 0 : ZEND_VM_NEXT_OPCODE();
5557 : }
5558 :
5559 : static int ZEND_IS_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5560 0 : {
5561 0 : zend_op *opline = EX(opline);
5562 : zend_free_op free_op1, free_op2;
5563 :
5564 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
5565 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5566 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5567 0 : zval_dtor(free_op1.var);
5568 0 : zval_dtor(free_op2.var);
5569 0 : ZEND_VM_NEXT_OPCODE();
5570 : }
5571 :
5572 : static int ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5573 0 : {
5574 0 : zend_op *opline = EX(opline);
5575 : zend_free_op free_op1, free_op2;
5576 :
5577 0 : is_not_equal_function(&EX_T(opline->result.u.var).tmp_var,
5578 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5579 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5580 0 : zval_dtor(free_op1.var);
5581 0 : zval_dtor(free_op2.var);
5582 0 : ZEND_VM_NEXT_OPCODE();
5583 : }
5584 :
5585 : static int ZEND_IS_SMALLER_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5586 0 : {
5587 0 : zend_op *opline = EX(opline);
5588 : zend_free_op free_op1, free_op2;
5589 :
5590 0 : is_smaller_function(&EX_T(opline->result.u.var).tmp_var,
5591 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5592 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5593 0 : zval_dtor(free_op1.var);
5594 0 : zval_dtor(free_op2.var);
5595 0 : ZEND_VM_NEXT_OPCODE();
5596 : }
5597 :
5598 : static int ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5599 0 : {
5600 0 : zend_op *opline = EX(opline);
5601 : zend_free_op free_op1, free_op2;
5602 :
5603 0 : is_smaller_or_equal_function(&EX_T(opline->result.u.var).tmp_var,
5604 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5605 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5606 0 : zval_dtor(free_op1.var);
5607 0 : zval_dtor(free_op2.var);
5608 0 : ZEND_VM_NEXT_OPCODE();
5609 : }
5610 :
5611 : static int ZEND_BW_OR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5612 7 : {
5613 7 : zend_op *opline = EX(opline);
5614 : zend_free_op free_op1, free_op2;
5615 :
5616 7 : bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
5617 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5618 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5619 7 : zval_dtor(free_op1.var);
5620 7 : zval_dtor(free_op2.var);
5621 7 : ZEND_VM_NEXT_OPCODE();
5622 : }
5623 :
5624 : static int ZEND_BW_AND_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5625 0 : {
5626 0 : zend_op *opline = EX(opline);
5627 : zend_free_op free_op1, free_op2;
5628 :
5629 0 : bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
5630 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5631 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5632 0 : zval_dtor(free_op1.var);
5633 0 : zval_dtor(free_op2.var);
5634 0 : ZEND_VM_NEXT_OPCODE();
5635 : }
5636 :
5637 : static int ZEND_BW_XOR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5638 0 : {
5639 0 : zend_op *opline = EX(opline);
5640 : zend_free_op free_op1, free_op2;
5641 :
5642 0 : bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
5643 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5644 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5645 0 : zval_dtor(free_op1.var);
5646 0 : zval_dtor(free_op2.var);
5647 0 : ZEND_VM_NEXT_OPCODE();
5648 : }
5649 :
5650 : static int ZEND_BOOL_XOR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5651 0 : {
5652 0 : zend_op *opline = EX(opline);
5653 : zend_free_op free_op1, free_op2;
5654 :
5655 0 : boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
5656 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5657 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5658 0 : zval_dtor(free_op1.var);
5659 0 : zval_dtor(free_op2.var);
5660 0 : ZEND_VM_NEXT_OPCODE();
5661 : }
5662 :
5663 : static int ZEND_ADD_VAR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5664 0 : {
5665 0 : zend_op *opline = EX(opline);
5666 : zend_free_op free_op1, free_op2;
5667 0 : zval *var = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
5668 : zval var_copy;
5669 : int use_copy;
5670 :
5671 0 : zend_make_printable_zval(var, &var_copy, &use_copy);
5672 0 : if (use_copy) {
5673 0 : var = &var_copy;
5674 : }
5675 0 : add_string_to_string( &EX_T(opline->result.u.var).tmp_var,
5676 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5677 : var);
5678 0 : if (use_copy) {
5679 0 : zval_dtor(var);
5680 : }
5681 : /* original comment, possibly problematic:
5682 : * FREE_OP is missing intentionally here - we're always working on the same temporary variable
5683 : * (Zeev): I don't think it's problematic, we only use variables
5684 : * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
5685 : * string offsets or overloaded objects
5686 : */
5687 0 : zval_dtor(free_op2.var);
5688 :
5689 0 : ZEND_VM_NEXT_OPCODE();
5690 : }
5691 :
5692 : static int ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5693 0 : {
5694 0 : zend_op *opline = EX(opline);
5695 : zval *function_name;
5696 : char *function_name_strval;
5697 : int function_name_strlen;
5698 : zend_free_op free_op1, free_op2;
5699 :
5700 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
5701 :
5702 0 : function_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
5703 :
5704 0 : if (Z_TYPE_P(function_name)!=IS_STRING) {
5705 0 : zend_error_noreturn(E_ERROR, "Method name must be a string");
5706 : }
5707 :
5708 0 : function_name_strval = Z_STRVAL_P(function_name);
5709 0 : function_name_strlen = Z_STRLEN_P(function_name);
5710 :
5711 0 : EX(object) = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
5712 :
5713 0 : if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
5714 0 : if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
5715 0 : zend_error_noreturn(E_ERROR, "Object does not support method calls");
5716 : }
5717 :
5718 : /* First, locate the function. */
5719 0 : EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
5720 0 : if (!EX(fbc)) {
5721 0 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
5722 : }
5723 : } else {
5724 0 : zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
5725 : }
5726 :
5727 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
5728 0 : EX(object) = NULL;
5729 : } else {
5730 0 : if (!PZVAL_IS_REF(EX(object))) {
5731 0 : EX(object)->refcount++; /* For $this pointer */
5732 : } else {
5733 : zval *this_ptr;
5734 0 : ALLOC_ZVAL(this_ptr);
5735 0 : INIT_PZVAL_COPY(this_ptr, EX(object));
5736 0 : zval_copy_ctor(this_ptr);
5737 0 : EX(object) = this_ptr;
5738 : }
5739 : }
5740 :
5741 0 : zval_dtor(free_op2.var);
5742 :
5743 0 : ZEND_VM_NEXT_OPCODE();
5744 : }
5745 :
5746 : static int ZEND_CASE_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5747 0 : {
5748 0 : zend_op *opline = EX(opline);
5749 0 : int switch_expr_is_overloaded=0;
5750 : zend_free_op free_op1, free_op2;
5751 :
5752 : if (IS_TMP_VAR==IS_VAR) {
5753 : if (EX_T(opline->op1.u.var).var.ptr_ptr) {
5754 : PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
5755 : } else {
5756 : switch_expr_is_overloaded = 1;
5757 : EX_T(opline->op1.u.var).str_offset.str->refcount++;
5758 : }
5759 : }
5760 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
5761 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5762 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5763 :
5764 0 : zval_dtor(free_op2.var);
5765 0 : if (switch_expr_is_overloaded) {
5766 : /* We only free op1 if this is a string offset,
5767 : * Since if it is a TMP_VAR, it'll be reused by
5768 : * other CASE opcodes (whereas string offsets
5769 : * are allocated at each get_zval_ptr())
5770 : */
5771 0 : zval_dtor(free_op1.var);
5772 0 : EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
5773 0 : AI_USE_PTR(EX_T(opline->op1.u.var).var);
5774 : }
5775 0 : ZEND_VM_NEXT_OPCODE();
5776 : }
5777 :
5778 : static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5779 0 : {
5780 0 : zend_op *opline = EX(opline);
5781 : zend_free_op free_op1, free_op2;
5782 0 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
5783 : zval *expr_ptr;
5784 0 : zval *offset=_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
5785 :
5786 : #if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
5787 : zval **expr_ptr_ptr = NULL;
5788 :
5789 : if (opline->extended_value) {
5790 : expr_ptr_ptr=NULL;
5791 : expr_ptr = *expr_ptr_ptr;
5792 : } else {
5793 : expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
5794 : }
5795 : #else
5796 0 : expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
5797 : #endif
5798 :
5799 : if (1) { /* temporary variable */
5800 : zval *new_expr;
5801 :
5802 0 : ALLOC_ZVAL(new_expr);
5803 0 : INIT_PZVAL_COPY(new_expr, expr_ptr);
5804 0 : expr_ptr = new_expr;
5805 : } else {
5806 : #if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
5807 : if (opline->extended_value) {
5808 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
5809 : expr_ptr = *expr_ptr_ptr;
5810 : expr_ptr->refcount++;
5811 : } else
5812 : #endif
5813 : if (PZVAL_IS_REF(expr_ptr)) {
5814 : zval *new_expr;
5815 :
5816 : ALLOC_ZVAL(new_expr);
5817 : INIT_PZVAL_COPY(new_expr, expr_ptr);
5818 : expr_ptr = new_expr;
5819 : zendi_zval_copy_ctor(*expr_ptr);
5820 : } else {
5821 : expr_ptr->refcount++;
5822 : }
5823 : }
5824 0 : if (offset) {
5825 0 : switch (Z_TYPE_P(offset)) {
5826 : case IS_DOUBLE:
5827 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
5828 0 : break;
5829 : case IS_LONG:
5830 : case IS_BOOL:
5831 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
5832 0 : break;
5833 : case IS_STRING:
5834 0 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
5835 0 : break;
5836 : case IS_NULL:
5837 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
5838 0 : break;
5839 : default:
5840 0 : zend_error(E_WARNING, "Illegal offset type");
5841 0 : zval_ptr_dtor(&expr_ptr);
5842 : /* do nothing */
5843 : break;
5844 : }
5845 0 : zval_dtor(free_op2.var);
5846 : } else {
5847 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
5848 : }
5849 0 : if (opline->extended_value) {
5850 :
5851 : } else {
5852 :
5853 : }
5854 0 : ZEND_VM_NEXT_OPCODE();
5855 : }
5856 :
5857 : static int ZEND_INIT_ARRAY_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5858 0 : {
5859 0 : zend_op *opline = EX(opline);
5860 :
5861 0 : array_init(&EX_T(opline->result.u.var).tmp_var);
5862 : if (IS_TMP_VAR == IS_UNUSED) {
5863 : ZEND_VM_NEXT_OPCODE();
5864 : #if 0 || IS_TMP_VAR != IS_UNUSED
5865 : } else {
5866 0 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
5867 : #endif
5868 : }
5869 : }
5870 :
5871 : static int ZEND_ADD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5872 110 : {
5873 110 : zend_op *opline = EX(opline);
5874 : zend_free_op free_op1, free_op2;
5875 :
5876 110 : add_function(&EX_T(opline->result.u.var).tmp_var,
5877 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5878 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5879 110 : zval_dtor(free_op1.var);
5880 110 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
5881 110 : ZEND_VM_NEXT_OPCODE();
5882 : }
5883 :
5884 : static int ZEND_SUB_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5885 1 : {
5886 1 : zend_op *opline = EX(opline);
5887 : zend_free_op free_op1, free_op2;
5888 :
5889 1 : sub_function(&EX_T(opline->result.u.var).tmp_var,
5890 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5891 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5892 1 : zval_dtor(free_op1.var);
5893 1 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
5894 1 : ZEND_VM_NEXT_OPCODE();
5895 : }
5896 :
5897 : static int ZEND_MUL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5898 0 : {
5899 0 : zend_op *opline = EX(opline);
5900 : zend_free_op free_op1, free_op2;
5901 :
5902 0 : mul_function(&EX_T(opline->result.u.var).tmp_var,
5903 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5904 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5905 0 : zval_dtor(free_op1.var);
5906 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
5907 0 : ZEND_VM_NEXT_OPCODE();
5908 : }
5909 :
5910 : static int ZEND_DIV_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5911 0 : {
5912 0 : zend_op *opline = EX(opline);
5913 : zend_free_op free_op1, free_op2;
5914 :
5915 0 : div_function(&EX_T(opline->result.u.var).tmp_var,
5916 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5917 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5918 0 : zval_dtor(free_op1.var);
5919 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
5920 0 : ZEND_VM_NEXT_OPCODE();
5921 : }
5922 :
5923 : static int ZEND_MOD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5924 0 : {
5925 0 : zend_op *opline = EX(opline);
5926 : zend_free_op free_op1, free_op2;
5927 :
5928 0 : mod_function(&EX_T(opline->result.u.var).tmp_var,
5929 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5930 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5931 0 : zval_dtor(free_op1.var);
5932 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
5933 0 : ZEND_VM_NEXT_OPCODE();
5934 : }
5935 :
5936 : static int ZEND_SL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5937 0 : {
5938 0 : zend_op *opline = EX(opline);
5939 : zend_free_op free_op1, free_op2;
5940 :
5941 0 : shift_left_function(&EX_T(opline->result.u.var).tmp_var,
5942 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5943 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5944 0 : zval_dtor(free_op1.var);
5945 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
5946 0 : ZEND_VM_NEXT_OPCODE();
5947 : }
5948 :
5949 : static int ZEND_SR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5950 0 : {
5951 0 : zend_op *opline = EX(opline);
5952 : zend_free_op free_op1, free_op2;
5953 :
5954 0 : shift_right_function(&EX_T(opline->result.u.var).tmp_var,
5955 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5956 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5957 0 : zval_dtor(free_op1.var);
5958 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
5959 0 : ZEND_VM_NEXT_OPCODE();
5960 : }
5961 :
5962 : static int ZEND_CONCAT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5963 170 : {
5964 170 : zend_op *opline = EX(opline);
5965 : zend_free_op free_op1, free_op2;
5966 :
5967 170 : concat_function(&EX_T(opline->result.u.var).tmp_var,
5968 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5969 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5970 170 : zval_dtor(free_op1.var);
5971 170 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
5972 170 : ZEND_VM_NEXT_OPCODE();
5973 : }
5974 :
5975 : static int ZEND_IS_IDENTICAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5976 0 : {
5977 0 : zend_op *opline = EX(opline);
5978 : zend_free_op free_op1, free_op2;
5979 :
5980 0 : is_identical_function(&EX_T(opline->result.u.var).tmp_var,
5981 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5982 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5983 0 : zval_dtor(free_op1.var);
5984 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
5985 0 : ZEND_VM_NEXT_OPCODE();
5986 : }
5987 :
5988 : static int ZEND_IS_NOT_IDENTICAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5989 0 : {
5990 0 : zend_op *opline = EX(opline);
5991 : zend_free_op free_op1, free_op2;
5992 :
5993 0 : is_not_identical_function(&EX_T(opline->result.u.var).tmp_var,
5994 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
5995 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
5996 0 : zval_dtor(free_op1.var);
5997 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
5998 0 : ZEND_VM_NEXT_OPCODE();
5999 : }
6000 :
6001 : static int ZEND_IS_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6002 3 : {
6003 3 : zend_op *opline = EX(opline);
6004 : zend_free_op free_op1, free_op2;
6005 :
6006 3 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
6007 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6008 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6009 3 : zval_dtor(free_op1.var);
6010 3 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6011 3 : ZEND_VM_NEXT_OPCODE();
6012 : }
6013 :
6014 : static int ZEND_IS_NOT_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6015 0 : {
6016 0 : zend_op *opline = EX(opline);
6017 : zend_free_op free_op1, free_op2;
6018 :
6019 0 : is_not_equal_function(&EX_T(opline->result.u.var).tmp_var,
6020 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6021 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6022 0 : zval_dtor(free_op1.var);
6023 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6024 0 : ZEND_VM_NEXT_OPCODE();
6025 : }
6026 :
6027 : static int ZEND_IS_SMALLER_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6028 1 : {
6029 1 : zend_op *opline = EX(opline);
6030 : zend_free_op free_op1, free_op2;
6031 :
6032 1 : is_smaller_function(&EX_T(opline->result.u.var).tmp_var,
6033 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6034 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6035 1 : zval_dtor(free_op1.var);
6036 1 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6037 1 : ZEND_VM_NEXT_OPCODE();
6038 : }
6039 :
6040 : static int ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6041 0 : {
6042 0 : zend_op *opline = EX(opline);
6043 : zend_free_op free_op1, free_op2;
6044 :
6045 0 : is_smaller_or_equal_function(&EX_T(opline->result.u.var).tmp_var,
6046 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6047 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6048 0 : zval_dtor(free_op1.var);
6049 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6050 0 : ZEND_VM_NEXT_OPCODE();
6051 : }
6052 :
6053 : static int ZEND_BW_OR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6054 0 : {
6055 0 : zend_op *opline = EX(opline);
6056 : zend_free_op free_op1, free_op2;
6057 :
6058 0 : bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
6059 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6060 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6061 0 : zval_dtor(free_op1.var);
6062 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6063 0 : ZEND_VM_NEXT_OPCODE();
6064 : }
6065 :
6066 : static int ZEND_BW_AND_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6067 0 : {
6068 0 : zend_op *opline = EX(opline);
6069 : zend_free_op free_op1, free_op2;
6070 :
6071 0 : bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
6072 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6073 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6074 0 : zval_dtor(free_op1.var);
6075 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6076 0 : ZEND_VM_NEXT_OPCODE();
6077 : }
6078 :
6079 : static int ZEND_BW_XOR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6080 0 : {
6081 0 : zend_op *opline = EX(opline);
6082 : zend_free_op free_op1, free_op2;
6083 :
6084 0 : bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
6085 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6086 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6087 0 : zval_dtor(free_op1.var);
6088 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6089 0 : ZEND_VM_NEXT_OPCODE();
6090 : }
6091 :
6092 : static int ZEND_BOOL_XOR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6093 0 : {
6094 0 : zend_op *opline = EX(opline);
6095 : zend_free_op free_op1, free_op2;
6096 :
6097 0 : boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
6098 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6099 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6100 0 : zval_dtor(free_op1.var);
6101 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6102 0 : ZEND_VM_NEXT_OPCODE();
6103 : }
6104 :
6105 : static int ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6106 1 : {
6107 1 : zend_op *opline = EX(opline);
6108 : zend_free_op free_op1, free_op2;
6109 1 : zval *var = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
6110 : zval var_copy;
6111 : int use_copy;
6112 :
6113 1 : zend_make_printable_zval(var, &var_copy, &use_copy);
6114 1 : if (use_copy) {
6115 0 : var = &var_copy;
6116 : }
6117 1 : add_string_to_string( &EX_T(opline->result.u.var).tmp_var,
6118 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6119 : var);
6120 1 : if (use_copy) {
6121 0 : zval_dtor(var);
6122 : }
6123 : /* original comment, possibly problematic:
6124 : * FREE_OP is missing intentionally here - we're always working on the same temporary variable
6125 : * (Zeev): I don't think it's problematic, we only use variables
6126 : * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
6127 : * string offsets or overloaded objects
6128 : */
6129 1 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6130 :
6131 1 : ZEND_VM_NEXT_OPCODE();
6132 : }
6133 :
6134 : static int ZEND_INIT_METHOD_CALL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6135 0 : {
6136 0 : zend_op *opline = EX(opline);
6137 : zval *function_name;
6138 : char *function_name_strval;
6139 : int function_name_strlen;
6140 : zend_free_op free_op1, free_op2;
6141 :
6142 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
6143 :
6144 0 : function_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
6145 :
6146 0 : if (Z_TYPE_P(function_name)!=IS_STRING) {
6147 0 : zend_error_noreturn(E_ERROR, "Method name must be a string");
6148 : }
6149 :
6150 0 : function_name_strval = Z_STRVAL_P(function_name);
6151 0 : function_name_strlen = Z_STRLEN_P(function_name);
6152 :
6153 0 : EX(object) = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
6154 :
6155 0 : if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
6156 0 : if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
6157 0 : zend_error_noreturn(E_ERROR, "Object does not support method calls");
6158 : }
6159 :
6160 : /* First, locate the function. */
6161 0 : EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
6162 0 : if (!EX(fbc)) {
6163 0 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
6164 : }
6165 : } else {
6166 0 : zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
6167 : }
6168 :
6169 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
6170 0 : EX(object) = NULL;
6171 : } else {
6172 0 : if (!PZVAL_IS_REF(EX(object))) {
6173 0 : EX(object)->refcount++; /* For $this pointer */
6174 : } else {
6175 : zval *this_ptr;
6176 0 : ALLOC_ZVAL(this_ptr);
6177 0 : INIT_PZVAL_COPY(this_ptr, EX(object));
6178 0 : zval_copy_ctor(this_ptr);
6179 0 : EX(object) = this_ptr;
6180 : }
6181 : }
6182 :
6183 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6184 :
6185 0 : ZEND_VM_NEXT_OPCODE();
6186 : }
6187 :
6188 : static int ZEND_CASE_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6189 0 : {
6190 0 : zend_op *opline = EX(opline);
6191 0 : int switch_expr_is_overloaded=0;
6192 : zend_free_op free_op1, free_op2;
6193 :
6194 : if (IS_TMP_VAR==IS_VAR) {
6195 : if (EX_T(opline->op1.u.var).var.ptr_ptr) {
6196 : PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
6197 : } else {
6198 : switch_expr_is_overloaded = 1;
6199 : EX_T(opline->op1.u.var).str_offset.str->refcount++;
6200 : }
6201 : }
6202 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
6203 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6204 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
6205 :
6206 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6207 0 : if (switch_expr_is_overloaded) {
6208 : /* We only free op1 if this is a string offset,
6209 : * Since if it is a TMP_VAR, it'll be reused by
6210 : * other CASE opcodes (whereas string offsets
6211 : * are allocated at each get_zval_ptr())
6212 : */
6213 0 : zval_dtor(free_op1.var);
6214 0 : EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
6215 0 : AI_USE_PTR(EX_T(opline->op1.u.var).var);
6216 : }
6217 0 : ZEND_VM_NEXT_OPCODE();
6218 : }
6219 :
6220 : static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6221 0 : {
6222 0 : zend_op *opline = EX(opline);
6223 : zend_free_op free_op1, free_op2;
6224 0 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
6225 : zval *expr_ptr;
6226 0 : zval *offset=_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
6227 :
6228 : #if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
6229 : zval **expr_ptr_ptr = NULL;
6230 :
6231 : if (opline->extended_value) {
6232 : expr_ptr_ptr=NULL;
6233 : expr_ptr = *expr_ptr_ptr;
6234 : } else {
6235 : expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
6236 : }
6237 : #else
6238 0 : expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
6239 : #endif
6240 :
6241 : if (1) { /* temporary variable */
6242 : zval *new_expr;
6243 :
6244 0 : ALLOC_ZVAL(new_expr);
6245 0 : INIT_PZVAL_COPY(new_expr, expr_ptr);
6246 0 : expr_ptr = new_expr;
6247 : } else {
6248 : #if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
6249 : if (opline->extended_value) {
6250 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
6251 : expr_ptr = *expr_ptr_ptr;
6252 : expr_ptr->refcount++;
6253 : } else
6254 : #endif
6255 : if (PZVAL_IS_REF(expr_ptr)) {
6256 : zval *new_expr;
6257 :
6258 : ALLOC_ZVAL(new_expr);
6259 : INIT_PZVAL_COPY(new_expr, expr_ptr);
6260 : expr_ptr = new_expr;
6261 : zendi_zval_copy_ctor(*expr_ptr);
6262 : } else {
6263 : expr_ptr->refcount++;
6264 : }
6265 : }
6266 0 : if (offset) {
6267 0 : switch (Z_TYPE_P(offset)) {
6268 : case IS_DOUBLE:
6269 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
6270 0 : break;
6271 : case IS_LONG:
6272 : case IS_BOOL:
6273 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
6274 0 : break;
6275 : case IS_STRING:
6276 0 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
6277 0 : break;
6278 : case IS_NULL:
6279 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
6280 0 : break;
6281 : default:
6282 0 : zend_error(E_WARNING, "Illegal offset type");
6283 0 : zval_ptr_dtor(&expr_ptr);
6284 : /* do nothing */
6285 : break;
6286 : }
6287 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
6288 : } else {
6289 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
6290 : }
6291 0 : if (opline->extended_value) {
6292 :
6293 : } else {
6294 :
6295 : }
6296 0 : ZEND_VM_NEXT_OPCODE();
6297 : }
6298 :
6299 : static int ZEND_INIT_ARRAY_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6300 0 : {
6301 0 : zend_op *opline = EX(opline);
6302 :
6303 0 : array_init(&EX_T(opline->result.u.var).tmp_var);
6304 : if (IS_TMP_VAR == IS_UNUSED) {
6305 : ZEND_VM_NEXT_OPCODE();
6306 : #if 0 || IS_TMP_VAR != IS_UNUSED
6307 : } else {
6308 0 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
6309 : #endif
6310 : }
6311 : }
6312 :
6313 : static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6314 6 : {
6315 6 : zend_op *opline = EX(opline);
6316 : zend_free_op free_op1;
6317 6 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
6318 : zval *expr_ptr;
6319 6 : zval *offset=NULL;
6320 :
6321 : #if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
6322 : zval **expr_ptr_ptr = NULL;
6323 :
6324 : if (opline->extended_value) {
6325 : expr_ptr_ptr=NULL;
6326 : expr_ptr = *expr_ptr_ptr;
6327 : } else {
6328 : expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
6329 : }
6330 : #else
6331 6 : expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
6332 : #endif
6333 :
6334 : if (1) { /* temporary variable */
6335 : zval *new_expr;
6336 :
6337 6 : ALLOC_ZVAL(new_expr);
6338 6 : INIT_PZVAL_COPY(new_expr, expr_ptr);
6339 6 : expr_ptr = new_expr;
6340 : } else {
6341 : #if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
6342 : if (opline->extended_value) {
6343 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
6344 : expr_ptr = *expr_ptr_ptr;
6345 : expr_ptr->refcount++;
6346 : } else
6347 : #endif
6348 : if (PZVAL_IS_REF(expr_ptr)) {
6349 : zval *new_expr;
6350 :
6351 : ALLOC_ZVAL(new_expr);
6352 : INIT_PZVAL_COPY(new_expr, expr_ptr);
6353 : expr_ptr = new_expr;
6354 : zendi_zval_copy_ctor(*expr_ptr);
6355 : } else {
6356 : expr_ptr->refcount++;
6357 : }
6358 : }
6359 6 : if (offset) {
6360 0 : switch (Z_TYPE_P(offset)) {
6361 : case IS_DOUBLE:
6362 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
6363 0 : break;
6364 : case IS_LONG:
6365 : case IS_BOOL:
6366 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
6367 0 : break;
6368 : case IS_STRING:
6369 0 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
6370 0 : break;
6371 : case IS_NULL:
6372 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
6373 0 : break;
6374 : default:
6375 0 : zend_error(E_WARNING, "Illegal offset type");
6376 0 : zval_ptr_dtor(&expr_ptr);
6377 : /* do nothing */
6378 : break;
6379 : }
6380 :
6381 : } else {
6382 6 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
6383 : }
6384 6 : if (opline->extended_value) {
6385 :
6386 : } else {
6387 :
6388 : }
6389 6 : ZEND_VM_NEXT_OPCODE();
6390 : }
6391 :
6392 : static int ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6393 4 : {
6394 4 : zend_op *opline = EX(opline);
6395 :
6396 4 : array_init(&EX_T(opline->result.u.var).tmp_var);
6397 : if (IS_TMP_VAR == IS_UNUSED) {
6398 : ZEND_VM_NEXT_OPCODE();
6399 : #if 0 || IS_TMP_VAR != IS_UNUSED
6400 : } else {
6401 4 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
6402 : #endif
6403 : }
6404 : }
6405 :
6406 : static int ZEND_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6407 0 : {
6408 0 : zend_op *opline = EX(opline);
6409 : zend_free_op free_op1;
6410 :
6411 0 : add_function(&EX_T(opline->result.u.var).tmp_var,
6412 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6413 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
6414 0 : zval_dtor(free_op1.var);
6415 :
6416 0 : ZEND_VM_NEXT_OPCODE();
6417 : }
6418 :
6419 : static int ZEND_SUB_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6420 0 : {
6421 0 : zend_op *opline = EX(opline);
6422 : zend_free_op free_op1;
6423 :
6424 0 : sub_function(&EX_T(opline->result.u.var).tmp_var,
6425 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6426 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
6427 0 : zval_dtor(free_op1.var);
6428 :
6429 0 : ZEND_VM_NEXT_OPCODE();
6430 : }
6431 :
6432 : static int ZEND_MUL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6433 0 : {
6434 0 : zend_op *opline = EX(opline);
6435 : zend_free_op free_op1;
6436 :
6437 0 : mul_function(&EX_T(opline->result.u.var).tmp_var,
6438 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6439 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
6440 0 : zval_dtor(free_op1.var);
6441 :
6442 0 : ZEND_VM_NEXT_OPCODE();
6443 : }
6444 :
6445 : static int ZEND_DIV_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6446 10 : {
6447 10 : zend_op *opline = EX(opline);
6448 : zend_free_op free_op1;
6449 :
6450 10 : div_function(&EX_T(opline->result.u.var).tmp_var,
6451 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6452 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
6453 10 : zval_dtor(free_op1.var);
6454 :
6455 10 : ZEND_VM_NEXT_OPCODE();
6456 : }
6457 :
6458 : static int ZEND_MOD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6459 0 : {
6460 0 : zend_op *opline = EX(opline);
6461 : zend_free_op free_op1;
6462 :
6463 0 : mod_function(&EX_T(opline->result.u.var).tmp_var,
6464 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6465 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
6466 0 : zval_dtor(free_op1.var);
6467 :
6468 0 : ZEND_VM_NEXT_OPCODE();
6469 : }
6470 :
6471 : static int ZEND_SL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6472 0 : {
6473 0 : zend_op *opline = EX(opline);
6474 : zend_free_op free_op1;
6475 :
6476 0 : shift_left_function(&EX_T(opline->result.u.var).tmp_var,
6477 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6478 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
6479 0 : zval_dtor(free_op1.var);
6480 :
6481 0 : ZEND_VM_NEXT_OPCODE();
6482 : }
6483 :
6484 : static int ZEND_SR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6485 0 : {
6486 0 : zend_op *opline = EX(opline);
6487 : zend_free_op free_op1;
6488 :
6489 0 : shift_right_function(&EX_T(opline->result.u.var).tmp_var,
6490 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6491 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
6492 0 : zval_dtor(free_op1.var);
6493 :
6494 0 : ZEND_VM_NEXT_OPCODE();
6495 : }
6496 :
6497 : static int ZEND_CONCAT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6498 1203 : {
6499 1203 : zend_op *opline = EX(opline);
6500 : zend_free_op free_op1;
6501 :
6502 1203 : concat_function(&EX_T(opline->result.u.var).tmp_var,
6503 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6504 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
6505 1203 : zval_dtor(free_op1.var);
6506 :
6507 1203 : ZEND_VM_NEXT_OPCODE();
6508 : }
6509 :
6510 : static int ZEND_IS_IDENTICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6511 0 : {
6512 0 : zend_op *opline = EX(opline);
6513 : zend_free_op free_op1;
6514 :
6515 0 : is_identical_function(&EX_T(opline->result.u.var).tmp_var,
6516 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6517 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
6518 0 : zval_dtor(free_op1.var);
6519 :
6520 0 : ZEND_VM_NEXT_OPCODE();
6521 : }
6522 :
6523 : static int ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6524 0 : {
6525 0 : zend_op *opline = EX(opline);
6526 : zend_free_op free_op1;
6527 :
6528 0 : is_not_identical_function(&EX_T(opline->result.u.var).tmp_var,
6529 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6530 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
6531 0 : zval_dtor(free_op1.var);
6532 :
6533 0 : ZEND_VM_NEXT_OPCODE();
6534 : }
6535 :
6536 : static int ZEND_IS_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6537 0 : {
6538 0 : zend_op *opline = EX(opline);
6539 : zend_free_op free_op1;
6540 :
6541 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
6542 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6543 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
6544 0 : zval_dtor(free_op1.var);
6545 :
6546 0 : ZEND_VM_NEXT_OPCODE();
6547 : }
6548 :
6549 : static int ZEND_IS_NOT_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6550 0 : {
6551 0 : zend_op *opline = EX(opline);
6552 : zend_free_op free_op1;
6553 :
6554 0 : is_not_equal_function(&EX_T(opline->result.u.var).tmp_var,
6555 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6556 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
6557 0 : zval_dtor(free_op1.var);
6558 :
6559 0 : ZEND_VM_NEXT_OPCODE();
6560 : }
6561 :
6562 : static int ZEND_IS_SMALLER_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6563 0 : {
6564 0 : zend_op *opline = EX(opline);
6565 : zend_free_op free_op1;
6566 :
6567 0 : is_smaller_function(&EX_T(opline->result.u.var).tmp_var,
6568 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6569 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
6570 0 : zval_dtor(free_op1.var);
6571 :
6572 0 : ZEND_VM_NEXT_OPCODE();
6573 : }
6574 :
6575 : static int ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6576 0 : {
6577 0 : zend_op *opline = EX(opline);
6578 : zend_free_op free_op1;
6579 :
6580 0 : is_smaller_or_equal_function(&EX_T(opline->result.u.var).tmp_var,
6581 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6582 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
6583 0 : zval_dtor(free_op1.var);
6584 :
6585 0 : ZEND_VM_NEXT_OPCODE();
6586 : }
6587 :
6588 : static int ZEND_BW_OR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6589 0 : {
6590 0 : zend_op *opline = EX(opline);
6591 : zend_free_op free_op1;
6592 :
6593 0 : bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
6594 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6595 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
6596 0 : zval_dtor(free_op1.var);
6597 :
6598 0 : ZEND_VM_NEXT_OPCODE();
6599 : }
6600 :
6601 : static int ZEND_BW_AND_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6602 0 : {
6603 0 : zend_op *opline = EX(opline);
6604 : zend_free_op free_op1;
6605 :
6606 0 : bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
6607 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6608 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
6609 0 : zval_dtor(free_op1.var);
6610 :
6611 0 : ZEND_VM_NEXT_OPCODE();
6612 : }
6613 :
6614 : static int ZEND_BW_XOR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6615 0 : {
6616 0 : zend_op *opline = EX(opline);
6617 : zend_free_op free_op1;
6618 :
6619 0 : bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
6620 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6621 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
6622 0 : zval_dtor(free_op1.var);
6623 :
6624 0 : ZEND_VM_NEXT_OPCODE();
6625 : }
6626 :
6627 : static int ZEND_BOOL_XOR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6628 0 : {
6629 0 : zend_op *opline = EX(opline);
6630 : zend_free_op free_op1;
6631 :
6632 0 : boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
6633 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6634 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
6635 0 : zval_dtor(free_op1.var);
6636 :
6637 0 : ZEND_VM_NEXT_OPCODE();
6638 : }
6639 :
6640 : static int ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6641 9647 : {
6642 9647 : zend_op *opline = EX(opline);
6643 : zend_free_op free_op1;
6644 9647 : zval *var = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
6645 : zval var_copy;
6646 : int use_copy;
6647 :
6648 9647 : zend_make_printable_zval(var, &var_copy, &use_copy);
6649 9647 : if (use_copy) {
6650 239 : var = &var_copy;
6651 : }
6652 9647 : add_string_to_string( &EX_T(opline->result.u.var).tmp_var,
6653 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6654 : var);
6655 9647 : if (use_copy) {
6656 239 : zval_dtor(var);
6657 : }
6658 : /* original comment, possibly problematic:
6659 : * FREE_OP is missing intentionally here - we're always working on the same temporary variable
6660 : * (Zeev): I don't think it's problematic, we only use variables
6661 : * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
6662 : * string offsets or overloaded objects
6663 : */
6664 :
6665 9647 : ZEND_VM_NEXT_OPCODE();
6666 : }
6667 :
6668 : static int ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6669 0 : {
6670 0 : zend_op *opline = EX(opline);
6671 : zval *function_name;
6672 : char *function_name_strval;
6673 : int function_name_strlen;
6674 : zend_free_op free_op1;
6675 :
6676 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
6677 :
6678 0 : function_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
6679 :
6680 0 : if (Z_TYPE_P(function_name)!=IS_STRING) {
6681 0 : zend_error_noreturn(E_ERROR, "Method name must be a string");
6682 : }
6683 :
6684 0 : function_name_strval = Z_STRVAL_P(function_name);
6685 0 : function_name_strlen = Z_STRLEN_P(function_name);
6686 :
6687 0 : EX(object) = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
6688 :
6689 0 : if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
6690 0 : if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
6691 0 : zend_error_noreturn(E_ERROR, "Object does not support method calls");
6692 : }
6693 :
6694 : /* First, locate the function. */
6695 0 : EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
6696 0 : if (!EX(fbc)) {
6697 0 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
6698 : }
6699 : } else {
6700 0 : zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
6701 : }
6702 :
6703 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
6704 0 : EX(object) = NULL;
6705 : } else {
6706 0 : if (!PZVAL_IS_REF(EX(object))) {
6707 0 : EX(object)->refcount++; /* For $this pointer */
6708 : } else {
6709 : zval *this_ptr;
6710 0 : ALLOC_ZVAL(this_ptr);
6711 0 : INIT_PZVAL_COPY(this_ptr, EX(object));
6712 0 : zval_copy_ctor(this_ptr);
6713 0 : EX(object) = this_ptr;
6714 : }
6715 : }
6716 :
6717 :
6718 0 : ZEND_VM_NEXT_OPCODE();
6719 : }
6720 :
6721 : static int ZEND_CASE_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6722 0 : {
6723 0 : zend_op *opline = EX(opline);
6724 0 : int switch_expr_is_overloaded=0;
6725 : zend_free_op free_op1;
6726 :
6727 : if (IS_TMP_VAR==IS_VAR) {
6728 : if (EX_T(opline->op1.u.var).var.ptr_ptr) {
6729 : PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
6730 : } else {
6731 : switch_expr_is_overloaded = 1;
6732 : EX_T(opline->op1.u.var).str_offset.str->refcount++;
6733 : }
6734 : }
6735 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
6736 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
6737 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
6738 :
6739 0 : if (switch_expr_is_overloaded) {
6740 : /* We only free op1 if this is a string offset,
6741 : * Since if it is a TMP_VAR, it'll be reused by
6742 : * other CASE opcodes (whereas string offsets
6743 : * are allocated at each get_zval_ptr())
6744 : */
6745 0 : zval_dtor(free_op1.var);
6746 0 : EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
6747 0 : AI_USE_PTR(EX_T(opline->op1.u.var).var);
6748 : }
6749 0 : ZEND_VM_NEXT_OPCODE();
6750 : }
6751 :
6752 : static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6753 0 : {
6754 0 : zend_op *opline = EX(opline);
6755 : zend_free_op free_op1;
6756 0 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
6757 : zval *expr_ptr;
6758 0 : zval *offset=_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
6759 :
6760 : #if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
6761 : zval **expr_ptr_ptr = NULL;
6762 :
6763 : if (opline->extended_value) {
6764 : expr_ptr_ptr=NULL;
6765 : expr_ptr = *expr_ptr_ptr;
6766 : } else {
6767 : expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
6768 : }
6769 : #else
6770 0 : expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
6771 : #endif
6772 :
6773 : if (1) { /* temporary variable */
6774 : zval *new_expr;
6775 :
6776 0 : ALLOC_ZVAL(new_expr);
6777 0 : INIT_PZVAL_COPY(new_expr, expr_ptr);
6778 0 : expr_ptr = new_expr;
6779 : } else {
6780 : #if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
6781 : if (opline->extended_value) {
6782 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
6783 : expr_ptr = *expr_ptr_ptr;
6784 : expr_ptr->refcount++;
6785 : } else
6786 : #endif
6787 : if (PZVAL_IS_REF(expr_ptr)) {
6788 : zval *new_expr;
6789 :
6790 : ALLOC_ZVAL(new_expr);
6791 : INIT_PZVAL_COPY(new_expr, expr_ptr);
6792 : expr_ptr = new_expr;
6793 : zendi_zval_copy_ctor(*expr_ptr);
6794 : } else {
6795 : expr_ptr->refcount++;
6796 : }
6797 : }
6798 0 : if (offset) {
6799 0 : switch (Z_TYPE_P(offset)) {
6800 : case IS_DOUBLE:
6801 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
6802 0 : break;
6803 : case IS_LONG:
6804 : case IS_BOOL:
6805 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
6806 0 : break;
6807 : case IS_STRING:
6808 0 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
6809 0 : break;
6810 : case IS_NULL:
6811 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
6812 0 : break;
6813 : default:
6814 0 : zend_error(E_WARNING, "Illegal offset type");
6815 0 : zval_ptr_dtor(&expr_ptr);
6816 : /* do nothing */
6817 : break;
6818 : }
6819 :
6820 : } else {
6821 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
6822 : }
6823 0 : if (opline->extended_value) {
6824 :
6825 : } else {
6826 :
6827 : }
6828 0 : ZEND_VM_NEXT_OPCODE();
6829 : }
6830 :
6831 : static int ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6832 0 : {
6833 0 : zend_op *opline = EX(opline);
6834 :
6835 0 : array_init(&EX_T(opline->result.u.var).tmp_var);
6836 : if (IS_TMP_VAR == IS_UNUSED) {
6837 : ZEND_VM_NEXT_OPCODE();
6838 : #if 0 || IS_TMP_VAR != IS_UNUSED
6839 : } else {
6840 0 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
6841 : #endif
6842 : }
6843 : }
6844 :
6845 : static int ZEND_BW_NOT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6846 0 : {
6847 0 : zend_op *opline = EX(opline);
6848 : zend_free_op free_op1;
6849 :
6850 0 : bitwise_not_function(&EX_T(opline->result.u.var).tmp_var,
6851 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) TSRMLS_CC);
6852 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
6853 0 : ZEND_VM_NEXT_OPCODE();
6854 : }
6855 :
6856 : static int ZEND_BOOL_NOT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6857 5879 : {
6858 5879 : zend_op *opline = EX(opline);
6859 : zend_free_op free_op1;
6860 :
6861 5879 : boolean_not_function(&EX_T(opline->result.u.var).tmp_var,
6862 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) TSRMLS_CC);
6863 5879 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
6864 5879 : ZEND_VM_NEXT_OPCODE();
6865 : }
6866 :
6867 : static int ZEND_PRE_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6868 0 : {
6869 0 : zend_op *opline = EX(opline);
6870 : zend_free_op free_op1;
6871 0 : zval **var_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
6872 :
6873 0 : if (!var_ptr) {
6874 0 : zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
6875 : }
6876 0 : if (*var_ptr == EG(error_zval_ptr)) {
6877 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
6878 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
6879 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
6880 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
6881 : }
6882 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
6883 0 : ZEND_VM_NEXT_OPCODE();
6884 : }
6885 :
6886 0 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
6887 :
6888 0 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
6889 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
6890 : /* proxy object */
6891 0 : zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
6892 0 : val->refcount++;
6893 0 : increment_function(val);
6894 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
6895 0 : zval_ptr_dtor(&val);
6896 : } else {
6897 0 : increment_function(*var_ptr);
6898 : }
6899 :
6900 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
6901 0 : EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
6902 0 : PZVAL_LOCK(*var_ptr);
6903 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
6904 : }
6905 :
6906 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
6907 0 : ZEND_VM_NEXT_OPCODE();
6908 : }
6909 :
6910 : static int ZEND_PRE_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6911 0 : {
6912 0 : zend_op *opline = EX(opline);
6913 : zend_free_op free_op1;
6914 0 : zval **var_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
6915 :
6916 0 : if (!var_ptr) {
6917 0 : zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
6918 : }
6919 0 : if (*var_ptr == EG(error_zval_ptr)) {
6920 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
6921 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
6922 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
6923 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
6924 : }
6925 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
6926 0 : ZEND_VM_NEXT_OPCODE();
6927 : }
6928 :
6929 0 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
6930 :
6931 0 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
6932 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
6933 : /* proxy object */
6934 0 : zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
6935 0 : val->refcount++;
6936 0 : decrement_function(val);
6937 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
6938 0 : zval_ptr_dtor(&val);
6939 : } else {
6940 0 : decrement_function(*var_ptr);
6941 : }
6942 :
6943 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
6944 0 : EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
6945 0 : PZVAL_LOCK(*var_ptr);
6946 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
6947 : }
6948 :
6949 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
6950 0 : ZEND_VM_NEXT_OPCODE();
6951 : }
6952 :
6953 : static int ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6954 110 : {
6955 110 : zend_op *opline = EX(opline);
6956 : zend_free_op free_op1;
6957 110 : zval **var_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
6958 :
6959 110 : if (!var_ptr) {
6960 0 : zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
6961 : }
6962 110 : if (*var_ptr == EG(error_zval_ptr)) {
6963 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
6964 0 : EX_T(opline->result.u.var).tmp_var = *EG(uninitialized_zval_ptr);
6965 : }
6966 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
6967 0 : ZEND_VM_NEXT_OPCODE();
6968 : }
6969 :
6970 110 : EX_T(opline->result.u.var).tmp_var = **var_ptr;
6971 110 : zendi_zval_copy_ctor(EX_T(opline->result.u.var).tmp_var);
6972 :
6973 110 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
6974 :
6975 110 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
6976 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
6977 : /* proxy object */
6978 0 : zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
6979 0 : val->refcount++;
6980 0 : increment_function(val);
6981 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
6982 0 : zval_ptr_dtor(&val);
6983 : } else {
6984 110 : increment_function(*var_ptr);
6985 : }
6986 :
6987 110 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
6988 110 : ZEND_VM_NEXT_OPCODE();
6989 : }
6990 :
6991 : static int ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6992 0 : {
6993 0 : zend_op *opline = EX(opline);
6994 : zend_free_op free_op1;
6995 0 : zval **var_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
6996 :
6997 0 : if (!var_ptr) {
6998 0 : zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
6999 : }
7000 0 : if (*var_ptr == EG(error_zval_ptr)) {
7001 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
7002 0 : EX_T(opline->result.u.var).tmp_var = *EG(uninitialized_zval_ptr);
7003 : }
7004 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7005 0 : ZEND_VM_NEXT_OPCODE();
7006 : }
7007 :
7008 0 : EX_T(opline->result.u.var).tmp_var = **var_ptr;
7009 0 : zendi_zval_copy_ctor(EX_T(opline->result.u.var).tmp_var);
7010 :
7011 0 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
7012 :
7013 0 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
7014 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
7015 : /* proxy object */
7016 0 : zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
7017 0 : val->refcount++;
7018 0 : decrement_function(val);
7019 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
7020 0 : zval_ptr_dtor(&val);
7021 : } else {
7022 0 : decrement_function(*var_ptr);
7023 : }
7024 :
7025 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7026 0 : ZEND_VM_NEXT_OPCODE();
7027 : }
7028 :
7029 : static int ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7030 76 : {
7031 76 : zend_op *opline = EX(opline);
7032 : zend_free_op free_op1;
7033 : zval z_copy;
7034 76 : zval *z = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7035 :
7036 76 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get_method != NULL &&
7037 : zend_std_cast_object_tostring(z, &z_copy, IS_STRING TSRMLS_CC) == SUCCESS) {
7038 0 : zend_print_variable(&z_copy);
7039 0 : zval_dtor(&z_copy);
7040 : } else {
7041 76 : zend_print_variable(z);
7042 : }
7043 :
7044 76 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7045 76 : ZEND_VM_NEXT_OPCODE();
7046 : }
7047 :
7048 : static int ZEND_PRINT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7049 0 : {
7050 0 : zend_op *opline = EX(opline);
7051 :
7052 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
7053 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_LONG;
7054 :
7055 0 : return ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7056 : }
7057 :
7058 : static int zend_fetch_var_address_helper_SPEC_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
7059 0 : {
7060 0 : zend_op *opline = EX(opline);
7061 : zend_free_op free_op1;
7062 0 : zval *varname = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7063 : zval **retval;
7064 : zval tmp_varname;
7065 : HashTable *target_symbol_table;
7066 :
7067 0 : if (Z_TYPE_P(varname) != IS_STRING) {
7068 0 : tmp_varname = *varname;
7069 0 : zval_copy_ctor(&tmp_varname);
7070 0 : convert_to_string(&tmp_varname);
7071 0 : varname = &tmp_varname;
7072 : }
7073 :
7074 0 : if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
7075 0 : 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);
7076 : } else {
7077 0 : target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), type, varname TSRMLS_CC);
7078 : /*
7079 : if (!target_symbol_table) {
7080 : ZEND_VM_NEXT_OPCODE();
7081 : }
7082 : */
7083 0 : if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &retval) == FAILURE) {
7084 0 : switch (type) {
7085 : case BP_VAR_R:
7086 : case BP_VAR_UNSET:
7087 0 : zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
7088 : /* break missing intentionally */
7089 : case BP_VAR_IS:
7090 0 : retval = &EG(uninitialized_zval_ptr);
7091 0 : break;
7092 : case BP_VAR_RW:
7093 0 : zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
7094 : /* break missing intentionally */
7095 : case BP_VAR_W: {
7096 0 : zval *new_zval = &EG(uninitialized_zval);
7097 :
7098 0 : new_zval->refcount++;
7099 0 : zend_hash_update(target_symbol_table, varname->value.str.val, varname->value.str.len+1, &new_zval, sizeof(zval *), (void **) &retval);
7100 : }
7101 : break;
7102 : EMPTY_SWITCH_DEFAULT_CASE()
7103 : }
7104 : }
7105 0 : switch (opline->op2.u.EA.type) {
7106 : case ZEND_FETCH_GLOBAL:
7107 : if (IS_VAR != IS_TMP_VAR) {
7108 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7109 : }
7110 0 : break;
7111 : case ZEND_FETCH_LOCAL:
7112 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7113 0 : break;
7114 : case ZEND_FETCH_STATIC:
7115 0 : zval_update_constant(retval, (void*) 1 TSRMLS_CC);
7116 0 : break;
7117 : case ZEND_FETCH_GLOBAL_LOCK:
7118 0 : if (IS_VAR == IS_VAR && !free_op1.var) {
7119 0 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
7120 : }
7121 : break;
7122 : }
7123 : }
7124 :
7125 :
7126 0 : if (varname == &tmp_varname) {
7127 0 : zval_dtor(varname);
7128 : }
7129 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
7130 0 : EX_T(opline->result.u.var).var.ptr_ptr = retval;
7131 0 : PZVAL_LOCK(*retval);
7132 0 : switch (type) {
7133 : case BP_VAR_R:
7134 : case BP_VAR_IS:
7135 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
7136 0 : break;
7137 : case BP_VAR_UNSET: {
7138 : zend_free_op free_res;
7139 :
7140 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
7141 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
7142 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
7143 : }
7144 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
7145 0 : FREE_OP_VAR_PTR(free_res);
7146 : break;
7147 : }
7148 : }
7149 : }
7150 0 : ZEND_VM_NEXT_OPCODE();
7151 : }
7152 :
7153 : static int ZEND_FETCH_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7154 0 : {
7155 0 : return zend_fetch_var_address_helper_SPEC_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7156 : }
7157 :
7158 : static int ZEND_FETCH_W_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7159 0 : {
7160 0 : return zend_fetch_var_address_helper_SPEC_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7161 : }
7162 :
7163 : static int ZEND_FETCH_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7164 0 : {
7165 0 : return zend_fetch_var_address_helper_SPEC_VAR(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7166 : }
7167 :
7168 : static int ZEND_FETCH_FUNC_ARG_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7169 0 : {
7170 0 : 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);
7171 : }
7172 :
7173 : static int ZEND_FETCH_UNSET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7174 0 : {
7175 0 : return zend_fetch_var_address_helper_SPEC_VAR(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7176 : }
7177 :
7178 : static int ZEND_FETCH_IS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7179 0 : {
7180 0 : return zend_fetch_var_address_helper_SPEC_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7181 : }
7182 :
7183 : static int ZEND_JMPZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7184 10857 : {
7185 10857 : zend_op *opline = EX(opline);
7186 : zend_free_op free_op1;
7187 10857 : int ret = i_zend_is_true(_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC));
7188 :
7189 10857 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7190 10857 : if (!ret) {
7191 : #if DEBUG_ZEND>=2
7192 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
7193 : #endif
7194 9383 : ZEND_VM_JMP(opline->op2.u.jmp_addr);
7195 : }
7196 :
7197 1474 : ZEND_VM_NEXT_OPCODE();
7198 : }
7199 :
7200 : static int ZEND_JMPNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7201 2 : {
7202 2 : zend_op *opline = EX(opline);
7203 : zend_free_op free_op1;
7204 2 : int ret = i_zend_is_true(_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC));
7205 :
7206 2 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7207 2 : if (ret) {
7208 : #if DEBUG_ZEND>=2
7209 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
7210 : #endif
7211 2 : ZEND_VM_JMP(opline->op2.u.jmp_addr);
7212 : }
7213 :
7214 0 : ZEND_VM_NEXT_OPCODE();
7215 : }
7216 :
7217 : static int ZEND_JMPZNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7218 0 : {
7219 0 : zend_op *opline = EX(opline);
7220 : zend_free_op free_op1;
7221 0 : int retval = i_zend_is_true(_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC));
7222 :
7223 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7224 0 : if (retval) {
7225 : #if DEBUG_ZEND>=2
7226 : printf("Conditional jmp on true to %d\n", opline->extended_value);
7227 : #endif
7228 0 : ZEND_VM_JMP(&EX(op_array)->opcodes[opline->extended_value]);
7229 : } else {
7230 : #if DEBUG_ZEND>=2
7231 : printf("Conditional jmp on false to %d\n", opline->op2.u.opline_num);
7232 : #endif
7233 0 : ZEND_VM_JMP(&EX(op_array)->opcodes[opline->op2.u.opline_num]);
7234 : }
7235 : }
7236 :
7237 : static int ZEND_JMPZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7238 1045 : {
7239 1045 : zend_op *opline = EX(opline);
7240 : zend_free_op free_op1;
7241 1045 : int retval = i_zend_is_true(_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC));
7242 :
7243 1045 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7244 1045 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
7245 1045 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
7246 1045 : if (!retval) {
7247 : #if DEBUG_ZEND>=2
7248 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
7249 : #endif
7250 780 : ZEND_VM_JMP(opline->op2.u.jmp_addr);
7251 : }
7252 265 : ZEND_VM_NEXT_OPCODE();
7253 : }
7254 :
7255 : static int ZEND_JMPNZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7256 342 : {
7257 342 : zend_op *opline = EX(opline);
7258 : zend_free_op free_op1;
7259 342 : int retval = i_zend_is_true(_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC));
7260 :
7261 342 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7262 342 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
7263 342 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
7264 342 : if (retval) {
7265 : #if DEBUG_ZEND>=2
7266 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
7267 : #endif
7268 126 : ZEND_VM_JMP(opline->op2.u.jmp_addr);
7269 : }
7270 216 : ZEND_VM_NEXT_OPCODE();
7271 : }
7272 :
7273 : static int ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7274 15806 : {
7275 15806 : zend_op *opline = EX(opline);
7276 : zval *retval_ptr;
7277 : zval **retval_ptr_ptr;
7278 : zend_free_op free_op1;
7279 :
7280 15806 : if (EG(active_op_array)->return_reference == ZEND_RETURN_REF) {
7281 :
7282 : if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
7283 : /* Not supposed to happen, but we'll allow it */
7284 : zend_error(E_NOTICE, "Only variable references should be returned by reference");
7285 : goto return_by_value;
7286 : }
7287 :
7288 0 : retval_ptr_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7289 :
7290 0 : if (!retval_ptr_ptr) {
7291 0 : zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
7292 : }
7293 :
7294 0 : if (IS_VAR == IS_VAR && !(*retval_ptr_ptr)->is_ref) {
7295 0 : if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
7296 : EX_T(opline->op1.u.var).var.fcall_returned_reference) {
7297 0 : } else if (EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
7298 0 : if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
7299 0 : PZVAL_LOCK(*retval_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
7300 : }
7301 0 : zend_error(E_NOTICE, "Only variable references should be returned by reference");
7302 0 : goto return_by_value;
7303 : }
7304 : }
7305 :
7306 0 : SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
7307 0 : (*retval_ptr_ptr)->refcount++;
7308 :
7309 0 : (*EG(return_value_ptr_ptr)) = (*retval_ptr_ptr);
7310 : } else {
7311 15806 : return_by_value:
7312 :
7313 15806 : retval_ptr = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7314 :
7315 15806 : if (EG(ze1_compatibility_mode) && Z_TYPE_P(retval_ptr) == IS_OBJECT) {
7316 : zval *ret;
7317 : char *class_name;
7318 : zend_uint class_name_len;
7319 : int dup;
7320 :
7321 0 : ALLOC_ZVAL(ret);
7322 0 : INIT_PZVAL_COPY(ret, retval_ptr);
7323 0 : dup = zend_get_object_classname(retval_ptr, &class_name, &class_name_len TSRMLS_CC);
7324 0 : if (Z_OBJ_HT_P(retval_ptr)->clone_obj == NULL) {
7325 0 : zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", class_name);
7326 : }
7327 0 : zend_error(E_STRICT, "Implicit cloning object of class '%s' because of 'zend.ze1_compatibility_mode'", class_name);
7328 0 : ret->value.obj = Z_OBJ_HT_P(retval_ptr)->clone_obj(retval_ptr TSRMLS_CC);
7329 0 : *EG(return_value_ptr_ptr) = ret;
7330 0 : if (!dup) {
7331 0 : efree(class_name);
7332 : }
7333 : } else if (!0) { /* Not a temp var */
7334 15806 : if (EG(active_op_array)->return_reference == ZEND_RETURN_REF ||
7335 : (PZVAL_IS_REF(retval_ptr) && retval_ptr->refcount > 0)) {
7336 : zval *ret;
7337 :
7338 0 : ALLOC_ZVAL(ret);
7339 0 : INIT_PZVAL_COPY(ret, retval_ptr);
7340 0 : zval_copy_ctor(ret);
7341 0 : *EG(return_value_ptr_ptr) = ret;
7342 : } else {
7343 15806 : *EG(return_value_ptr_ptr) = retval_ptr;
7344 15806 : retval_ptr->refcount++;
7345 : }
7346 : } else {
7347 : zval *ret;
7348 :
7349 : ALLOC_ZVAL(ret);
7350 : INIT_PZVAL_COPY(ret, retval_ptr);
7351 : *EG(return_value_ptr_ptr) = ret;
7352 : }
7353 : }
7354 15806 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7355 15806 : ZEND_VM_RETURN_FROM_EXECUTE_LOOP();
7356 : }
7357 :
7358 : static int ZEND_THROW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7359 12 : {
7360 12 : zend_op *opline = EX(opline);
7361 : zval *value;
7362 : zval *exception;
7363 : zend_free_op free_op1;
7364 :
7365 12 : value = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7366 :
7367 12 : if (Z_TYPE_P(value) != IS_OBJECT) {
7368 0 : zend_error_noreturn(E_ERROR, "Can only throw objects");
7369 : }
7370 : /* Not sure if a complete copy is what we want here */
7371 12 : ALLOC_ZVAL(exception);
7372 12 : INIT_PZVAL_COPY(exception, value);
7373 : if (!0) {
7374 12 : zval_copy_ctor(exception);
7375 : }
7376 :
7377 12 : zend_throw_exception_object(exception TSRMLS_CC);
7378 12 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7379 12 : ZEND_VM_NEXT_OPCODE();
7380 : }
7381 :
7382 : static int ZEND_SEND_VAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7383 0 : {
7384 0 : zend_op *opline = EX(opline);
7385 0 : if (opline->extended_value==ZEND_DO_FCALL_BY_NAME
7386 : && ARG_MUST_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
7387 0 : zend_error_noreturn(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.u.opline_num);
7388 : }
7389 : {
7390 : zval *valptr;
7391 : zval *value;
7392 : zend_free_op free_op1;
7393 :
7394 0 : value = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7395 :
7396 0 : ALLOC_ZVAL(valptr);
7397 0 : INIT_PZVAL_COPY(valptr, value);
7398 : if (!0) {
7399 0 : zval_copy_ctor(valptr);
7400 : }
7401 0 : zend_ptr_stack_push(&EG(argument_stack), valptr);
7402 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7403 : }
7404 0 : ZEND_VM_NEXT_OPCODE();
7405 : }
7406 :
7407 : static int zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
7408 48827 : {
7409 48827 : zend_op *opline = EX(opline);
7410 : zval *varptr;
7411 : zend_free_op free_op1;
7412 48827 : varptr = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7413 :
7414 48827 : if (varptr == &EG(uninitialized_zval)) {
7415 766 : ALLOC_ZVAL(varptr);
7416 766 : INIT_ZVAL(*varptr);
7417 766 : varptr->refcount = 0;
7418 48061 : } else if (PZVAL_IS_REF(varptr)) {
7419 2 : zval *original_var = varptr;
7420 :
7421 2 : ALLOC_ZVAL(varptr);
7422 2 : *varptr = *original_var;
7423 2 : varptr->is_ref = 0;
7424 2 : varptr->refcount = 0;
7425 2 : zval_copy_ctor(varptr);
7426 : }
7427 48827 : varptr->refcount++;
7428 48827 : zend_ptr_stack_push(&EG(argument_stack), varptr);
7429 48827 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; /* for string offsets */
7430 :
7431 48827 : ZEND_VM_NEXT_OPCODE();
7432 : }
7433 :
7434 : static int ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7435 8573 : {
7436 8573 : zend_op *opline = EX(opline);
7437 : zend_free_op free_op1;
7438 : zval *varptr;
7439 :
7440 8573 : if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */
7441 8270 : if (!(opline->extended_value & ZEND_ARG_SEND_BY_REF)) {
7442 8270 : return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7443 : }
7444 303 : } else if (!ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
7445 303 : return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7446 : }
7447 :
7448 0 : if (IS_VAR == IS_VAR &&
7449 : (opline->extended_value & ZEND_ARG_SEND_FUNCTION) &&
7450 : EX_T(opline->op1.u.var).var.fcall_returned_reference &&
7451 : EX_T(opline->op1.u.var).var.ptr) {
7452 0 : varptr = EX_T(opline->op1.u.var).var.ptr;
7453 0 : PZVAL_UNLOCK_EX(varptr, &free_op1, 0);
7454 : } else {
7455 0 : varptr = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7456 : }
7457 0 : if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
7458 : EX_T(opline->op1.u.var).var.fcall_returned_reference) &&
7459 : varptr != &EG(uninitialized_zval) &&
7460 : (PZVAL_IS_REF(varptr) ||
7461 : (varptr->refcount == 1 && (IS_VAR == IS_CV || free_op1.var)))) {
7462 0 : varptr->is_ref = 1;
7463 0 : varptr->refcount++;
7464 0 : zend_ptr_stack_push(&EG(argument_stack), varptr);
7465 : } else {
7466 : zval *valptr;
7467 :
7468 0 : zend_error(E_STRICT, "Only variables should be passed by reference");
7469 0 : ALLOC_ZVAL(valptr);
7470 0 : INIT_PZVAL_COPY(valptr, varptr);
7471 : if (!0) {
7472 0 : zval_copy_ctor(valptr);
7473 : }
7474 0 : zend_ptr_stack_push(&EG(argument_stack), valptr);
7475 : }
7476 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7477 0 : ZEND_VM_NEXT_OPCODE();
7478 : }
7479 :
7480 : static int ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7481 1851 : {
7482 1851 : zend_op *opline = EX(opline);
7483 : zend_free_op free_op1;
7484 : zval **varptr_ptr;
7485 : zval *varptr;
7486 1851 : varptr_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7487 :
7488 1851 : if (!varptr_ptr) {
7489 0 : zend_error_noreturn(E_ERROR, "Only variables can be passed by reference");
7490 : }
7491 :
7492 1851 : SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr);
7493 1851 : varptr = *varptr_ptr;
7494 1851 : varptr->refcount++;
7495 1851 : zend_ptr_stack_push(&EG(argument_stack), varptr);
7496 :
7497 1851 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7498 1851 : ZEND_VM_NEXT_OPCODE();
7499 : }
7500 :
7501 : static int ZEND_SEND_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7502 40254 : {
7503 40254 : zend_op *opline = EX(opline);
7504 :
7505 40254 : if ((opline->extended_value == ZEND_DO_FCALL_BY_NAME)
7506 : && ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
7507 0 : return ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7508 : }
7509 40254 : return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7510 : }
7511 :
7512 : static int ZEND_BOOL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7513 16528 : {
7514 16528 : zend_op *opline = EX(opline);
7515 : zend_free_op free_op1;
7516 :
7517 : /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
7518 16528 : 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));
7519 16528 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
7520 16528 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7521 :
7522 16528 : ZEND_VM_NEXT_OPCODE();
7523 : }
7524 :
7525 : static int ZEND_SWITCH_FREE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7526 530 : {
7527 530 : zend_switch_free(EX(opline), EX(Ts) TSRMLS_CC);
7528 530 : ZEND_VM_NEXT_OPCODE();
7529 : }
7530 :
7531 : static int ZEND_CLONE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7532 0 : {
7533 0 : zend_op *opline = EX(opline);
7534 : zend_free_op free_op1;
7535 0 : zval *obj = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7536 : zend_class_entry *ce;
7537 : zend_function *clone;
7538 : zend_object_clone_obj_t clone_call;
7539 :
7540 0 : if (!obj || Z_TYPE_P(obj) != IS_OBJECT) {
7541 0 : zend_error(E_WARNING, "__clone method called on non-object");
7542 0 : EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
7543 0 : EX_T(opline->result.u.var).var.ptr->refcount++;
7544 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7545 0 : ZEND_VM_NEXT_OPCODE();
7546 : }
7547 :
7548 0 : ce = Z_OBJCE_P(obj);
7549 0 : clone = ce ? ce->clone : NULL;
7550 0 : clone_call = Z_OBJ_HT_P(obj)->clone_obj;
7551 0 : if (!clone_call) {
7552 0 : if (ce) {
7553 0 : zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
7554 : } else {
7555 0 : zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
7556 : }
7557 : EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
7558 : EX_T(opline->result.u.var).var.ptr->refcount++;
7559 : }
7560 :
7561 0 : if (ce && clone) {
7562 0 : if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
7563 : /* Ensure that if we're calling a private function, we're allowed to do so.
7564 : */
7565 0 : if (ce != EG(scope)) {
7566 0 : zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
7567 : }
7568 0 : } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
7569 : /* Ensure that if we're calling a protected function, we're allowed to do so.
7570 : */
7571 0 : if (!zend_check_protected(clone->common.scope, EG(scope))) {
7572 0 : zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
7573 : }
7574 : }
7575 : }
7576 :
7577 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
7578 0 : if (!EG(exception)) {
7579 0 : ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
7580 0 : Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC);
7581 0 : Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
7582 0 : EX_T(opline->result.u.var).var.ptr->refcount=1;
7583 0 : EX_T(opline->result.u.var).var.ptr->is_ref=1;
7584 0 : if (!RETURN_VALUE_USED(opline) || EG(exception)) {
7585 0 : zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
7586 : }
7587 : }
7588 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7589 0 : ZEND_VM_NEXT_OPCODE();
7590 : }
7591 :
7592 : static int ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7593 0 : {
7594 0 : zend_op *opline = EX(opline);
7595 : zend_free_op free_op1;
7596 0 : zval *expr = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7597 0 : zval *result = &EX_T(opline->result.u.var).tmp_var;
7598 :
7599 0 : *result = *expr;
7600 : if (!0) {
7601 0 : zendi_zval_copy_ctor(*result);
7602 : }
7603 0 : switch (opline->extended_value) {
7604 : case IS_NULL:
7605 0 : convert_to_null(result);
7606 0 : break;
7607 : case IS_BOOL:
7608 0 : convert_to_boolean(result);
7609 0 : break;
7610 : case IS_LONG:
7611 0 : convert_to_long(result);
7612 0 : break;
7613 : case IS_DOUBLE:
7614 0 : convert_to_double(result);
7615 0 : break;
7616 : case IS_STRING: {
7617 : zval var_copy;
7618 : int use_copy;
7619 :
7620 0 : zend_make_printable_zval(result, &var_copy, &use_copy);
7621 0 : if (use_copy) {
7622 0 : zval_dtor(result);
7623 0 : *result = var_copy;
7624 : }
7625 0 : break;
7626 : }
7627 : case IS_ARRAY:
7628 0 : convert_to_array(result);
7629 0 : break;
7630 : case IS_OBJECT:
7631 0 : convert_to_object(result);
7632 : break;
7633 : }
7634 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7635 0 : ZEND_VM_NEXT_OPCODE();
7636 : }
7637 :
7638 : static int ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7639 0 : {
7640 0 : zend_op *opline = EX(opline);
7641 0 : zend_op_array *new_op_array=NULL;
7642 0 : zval **original_return_value = EG(return_value_ptr_ptr);
7643 : int return_value_used;
7644 : zend_free_op free_op1;
7645 0 : zval *inc_filename = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7646 : zval tmp_inc_filename;
7647 0 : zend_bool failure_retval=0;
7648 :
7649 0 : if (inc_filename->type!=IS_STRING) {
7650 0 : tmp_inc_filename = *inc_filename;
7651 0 : zval_copy_ctor(&tmp_inc_filename);
7652 0 : convert_to_string(&tmp_inc_filename);
7653 0 : inc_filename = &tmp_inc_filename;
7654 : }
7655 :
7656 0 : return_value_used = RETURN_VALUE_USED(opline);
7657 :
7658 0 : switch (Z_LVAL(opline->op2.u.constant)) {
7659 : case ZEND_INCLUDE_ONCE:
7660 : case ZEND_REQUIRE_ONCE: {
7661 : zend_file_handle file_handle;
7662 : char cwd[MAXPATHLEN];
7663 : cwd_state state;
7664 :
7665 0 : if (IS_ABSOLUTE_PATH(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename))) {
7666 0 : cwd[0] = '\0';
7667 0 : } else if (!VCWD_GETCWD(cwd, MAXPATHLEN)) {
7668 0 : cwd[0] = '\0';
7669 : }
7670 :
7671 0 : state.cwd_length = strlen(cwd);
7672 0 : state.cwd = zend_strndup(cwd, state.cwd_length);
7673 :
7674 0 : failure_retval = (!virtual_file_ex(&state, Z_STRVAL_P(inc_filename), NULL, 1) &&
7675 : zend_hash_exists(&EG(included_files), state.cwd, state.cwd_length+1));
7676 :
7677 0 : free(state.cwd);
7678 :
7679 0 : if (failure_retval) {
7680 : /* do nothing */
7681 0 : } else if (SUCCESS == zend_stream_open(Z_STRVAL_P(inc_filename), &file_handle TSRMLS_CC)) {
7682 :
7683 0 : if (!file_handle.opened_path) {
7684 0 : file_handle.opened_path = estrndup(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename));
7685 : }
7686 :
7687 0 : if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
7688 0 : new_op_array = zend_compile_file(&file_handle, (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
7689 0 : zend_destroy_file_handle(&file_handle TSRMLS_CC);
7690 : } else {
7691 0 : zend_file_handle_dtor(&file_handle);
7692 0 : failure_retval=1;
7693 : }
7694 : } else {
7695 0 : if (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE) {
7696 0 : zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename));
7697 : } else {
7698 0 : zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename));
7699 : }
7700 : }
7701 : }
7702 0 : break;
7703 : case ZEND_INCLUDE:
7704 : case ZEND_REQUIRE:
7705 0 : new_op_array = compile_filename(Z_LVAL(opline->op2.u.constant), inc_filename TSRMLS_CC);
7706 0 : break;
7707 : case ZEND_EVAL: {
7708 0 : char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
7709 :
7710 0 : new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
7711 0 : efree(eval_desc);
7712 : }
7713 : break;
7714 : EMPTY_SWITCH_DEFAULT_CASE()
7715 : }
7716 0 : if (inc_filename==&tmp_inc_filename) {
7717 0 : zval_dtor(&tmp_inc_filename);
7718 : }
7719 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
7720 0 : if (new_op_array) {
7721 : zval *saved_object;
7722 : zend_function *saved_function;
7723 :
7724 0 : EG(return_value_ptr_ptr) = EX_T(opline->result.u.var).var.ptr_ptr;
7725 0 : EG(active_op_array) = new_op_array;
7726 0 : EX_T(opline->result.u.var).var.ptr = NULL;
7727 :
7728 0 : saved_object = EX(object);
7729 0 : saved_function = EX(function_state).function;
7730 :
7731 0 : EX(function_state).function = (zend_function *) new_op_array;
7732 0 : EX(object) = NULL;
7733 :
7734 0 : zend_execute(new_op_array TSRMLS_CC);
7735 :
7736 0 : EX(function_state).function = saved_function;
7737 0 : EX(object) = saved_object;
7738 :
7739 0 : if (!return_value_used) {
7740 0 : if (EX_T(opline->result.u.var).var.ptr) {
7741 0 : zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
7742 : }
7743 : } else { /* return value is used */
7744 0 : if (!EX_T(opline->result.u.var).var.ptr) { /* there was no return statement */
7745 0 : ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
7746 0 : INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
7747 0 : Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = 1;
7748 0 : Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
7749 : }
7750 : }
7751 :
7752 0 : EG(opline_ptr) = &EX(opline);
7753 0 : EG(active_op_array) = EX(op_array);
7754 0 : EG(function_state_ptr) = &EX(function_state);
7755 0 : destroy_op_array(new_op_array TSRMLS_CC);
7756 0 : efree(new_op_array);
7757 0 : if (EG(exception)) {
7758 0 : zend_throw_exception_internal(NULL TSRMLS_CC);
7759 : }
7760 : } else {
7761 0 : if (return_value_used) {
7762 0 : ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
7763 0 : INIT_ZVAL(*EX_T(opline->result.u.var).var.ptr);
7764 0 : Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = failure_retval;
7765 0 : Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
7766 : }
7767 : }
7768 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7769 0 : EG(return_value_ptr_ptr) = original_return_value;
7770 0 : ZEND_VM_NEXT_OPCODE();
7771 : }
7772 :
7773 : static int ZEND_UNSET_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7774 0 : {
7775 0 : zend_op *opline = EX(opline);
7776 : zval tmp, *varname;
7777 : HashTable *target_symbol_table;
7778 : zend_free_op free_op1;
7779 :
7780 0 : varname = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7781 :
7782 0 : if (Z_TYPE_P(varname) != IS_STRING) {
7783 0 : tmp = *varname;
7784 0 : zval_copy_ctor(&tmp);
7785 0 : convert_to_string(&tmp);
7786 0 : varname = &tmp;
7787 : } else if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
7788 0 : varname->refcount++;
7789 : }
7790 :
7791 0 : if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
7792 0 : zend_std_unset_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname) TSRMLS_CC);
7793 : } else {
7794 0 : target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
7795 0 : if (zend_hash_del(target_symbol_table, varname->value.str.val, varname->value.str.len+1) == SUCCESS) {
7796 0 : zend_execute_data *ex = execute_data;
7797 0 : ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
7798 :
7799 : do {
7800 : int i;
7801 :
7802 0 : if (ex->op_array) {
7803 0 : for (i = 0; i < ex->op_array->last_var; i++) {
7804 0 : if (ex->op_array->vars[i].hash_value == hash_value &&
7805 : ex->op_array->vars[i].name_len == varname->value.str.len &&
7806 : !memcmp(ex->op_array->vars[i].name, varname->value.str.val, varname->value.str.len)) {
7807 0 : ex->CVs[i] = NULL;
7808 0 : break;
7809 : }
7810 : }
7811 : }
7812 0 : ex = ex->prev_execute_data;
7813 0 : } while (ex && ex->symbol_table == target_symbol_table);
7814 : }
7815 : }
7816 :
7817 0 : if (varname == &tmp) {
7818 0 : zval_dtor(&tmp);
7819 : } else if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
7820 0 : zval_ptr_dtor(&varname);
7821 : }
7822 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7823 0 : ZEND_VM_NEXT_OPCODE();
7824 : }
7825 :
7826 : static int ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7827 289 : {
7828 289 : zend_op *opline = EX(opline);
7829 : zend_free_op free_op1;
7830 : zval *array_ptr, **array_ptr_ptr;
7831 : HashTable *fe_ht;
7832 289 : zend_object_iterator *iter = NULL;
7833 289 : zend_class_entry *ce = NULL;
7834 289 : zend_bool is_empty = 0;
7835 :
7836 289 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
7837 0 : array_ptr_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7838 0 : if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
7839 0 : ALLOC_INIT_ZVAL(array_ptr);
7840 0 : } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
7841 0 : if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
7842 0 : zend_error(E_WARNING, "foreach() can not iterate over objects without PHP class");
7843 0 : ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
7844 : }
7845 :
7846 0 : ce = Z_OBJCE_PP(array_ptr_ptr);
7847 0 : if (!ce || ce->get_iterator == NULL) {
7848 0 : SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
7849 0 : (*array_ptr_ptr)->refcount++;
7850 : }
7851 0 : array_ptr = *array_ptr_ptr;
7852 : } else {
7853 0 : if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
7854 0 : SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
7855 0 : if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
7856 0 : (*array_ptr_ptr)->is_ref = 1;
7857 : }
7858 : }
7859 0 : array_ptr = *array_ptr_ptr;
7860 0 : array_ptr->refcount++;
7861 : }
7862 : } else {
7863 289 : array_ptr = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7864 : if (0) { /* IS_TMP_VAR */
7865 : zval *tmp;
7866 :
7867 : ALLOC_ZVAL(tmp);
7868 : INIT_PZVAL_COPY(tmp, array_ptr);
7869 : array_ptr = tmp;
7870 289 : } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
7871 1 : ce = Z_OBJCE_P(array_ptr);
7872 1 : if (!ce || !ce->get_iterator) {
7873 1 : array_ptr->refcount++;
7874 : }
7875 : } else {
7876 288 : if (IS_VAR == IS_VAR &&
7877 : free_op1.var == NULL &&
7878 : !array_ptr->is_ref &&
7879 : array_ptr->refcount > 1) {
7880 : /* non-separated return value from function */
7881 : zval *tmp;
7882 :
7883 0 : ALLOC_ZVAL(tmp);
7884 0 : INIT_PZVAL_COPY(tmp, array_ptr);
7885 0 : zval_copy_ctor(tmp);
7886 0 : array_ptr = tmp;
7887 : } else {
7888 288 : array_ptr->refcount++;
7889 : }
7890 : }
7891 : }
7892 :
7893 289 : if (IS_VAR != IS_TMP_VAR && ce && ce->get_iterator) {
7894 0 : iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC);
7895 :
7896 0 : if (iter && !EG(exception)) {
7897 0 : array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
7898 : } else {
7899 0 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
7900 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7901 : } else {
7902 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7903 : }
7904 0 : if (!EG(exception)) {
7905 0 : zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
7906 : }
7907 0 : zend_throw_exception_internal(NULL TSRMLS_CC);
7908 0 : ZEND_VM_NEXT_OPCODE();
7909 : }
7910 : }
7911 :
7912 289 : PZVAL_LOCK(array_ptr);
7913 289 : EX_T(opline->result.u.var).var.ptr = array_ptr;
7914 289 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
7915 :
7916 289 : if (iter) {
7917 0 : iter->index = 0;
7918 0 : if (iter->funcs->rewind) {
7919 0 : iter->funcs->rewind(iter TSRMLS_CC);
7920 0 : if (EG(exception)) {
7921 0 : array_ptr->refcount--;
7922 0 : zval_ptr_dtor(&array_ptr);
7923 0 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
7924 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7925 : } else {
7926 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7927 : }
7928 0 : ZEND_VM_NEXT_OPCODE();
7929 : }
7930 : }
7931 0 : is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
7932 0 : if (EG(exception)) {
7933 0 : array_ptr->refcount--;
7934 0 : zval_ptr_dtor(&array_ptr);
7935 0 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
7936 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7937 : } else {
7938 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7939 : }
7940 0 : ZEND_VM_NEXT_OPCODE();
7941 : }
7942 0 : iter->index = -1; /* will be set to 0 before using next handler */
7943 289 : } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
7944 289 : zend_hash_internal_pointer_reset(fe_ht);
7945 289 : if (ce) {
7946 1 : zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
7947 2 : while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
7948 : char *str_key;
7949 : uint str_key_len;
7950 : ulong int_key;
7951 : zend_uchar key_type;
7952 :
7953 1 : key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
7954 1 : if (key_type != HASH_KEY_NON_EXISTANT &&
7955 : (key_type == HASH_KEY_IS_LONG ||
7956 : zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
7957 : break;
7958 : }
7959 0 : zend_hash_move_forward(fe_ht);
7960 : }
7961 : }
7962 289 : is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
7963 289 : zend_hash_get_pointer(fe_ht, &EX_T(opline->result.u.var).fe.fe_pos);
7964 : } else {
7965 0 : zend_error(E_WARNING, "Invalid argument supplied for foreach()");
7966 0 : is_empty = 1;
7967 : }
7968 :
7969 289 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
7970 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7971 : } else {
7972 289 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
7973 : }
7974 289 : if (is_empty) {
7975 222 : ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
7976 : } else {
7977 67 : ZEND_VM_NEXT_OPCODE();
7978 : }
7979 : }
7980 :
7981 : static int ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7982 5340 : {
7983 5340 : zend_op *opline = EX(opline);
7984 : zend_free_op free_op1;
7985 5340 : zval *array = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
7986 : zval **value;
7987 : char *str_key;
7988 : uint str_key_len;
7989 : ulong int_key;
7990 : HashTable *fe_ht;
7991 5340 : zend_object_iterator *iter = NULL;
7992 5340 : int key_type = 0;
7993 5340 : zend_bool use_key = (zend_bool)(opline->extended_value & ZEND_FE_FETCH_WITH_KEY);
7994 :
7995 5340 : PZVAL_LOCK(array);
7996 :
7997 5340 : switch (zend_iterator_unwrap(array, &iter TSRMLS_CC)) {
7998 : default:
7999 : case ZEND_ITER_INVALID:
8000 0 : zend_error(E_WARNING, "Invalid argument supplied for foreach()");
8001 0 : ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
8002 :
8003 : case ZEND_ITER_PLAIN_OBJECT: {
8004 : char *class_name, *prop_name;
8005 4 : zend_object *zobj = zend_objects_get_address(array TSRMLS_CC);
8006 :
8007 4 : fe_ht = HASH_OF(array);
8008 4 : zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.u.var).fe.fe_pos);
8009 : do {
8010 4 : if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) {
8011 : /* reached end of iteration */
8012 1 : ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
8013 : }
8014 3 : key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
8015 :
8016 3 : zend_hash_move_forward(fe_ht);
8017 : } while (key_type == HASH_KEY_NON_EXISTANT ||
8018 : (key_type != HASH_KEY_IS_LONG &&
8019 3 : zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) != SUCCESS));
8020 3 : zend_hash_get_pointer(fe_ht, &EX_T(opline->op1.u.var).fe.fe_pos);
8021 3 : if (use_key && key_type != HASH_KEY_IS_LONG) {
8022 3 : zend_unmangle_property_name(str_key, str_key_len-1, &class_name, &prop_name);
8023 3 : str_key_len = strlen(prop_name);
8024 3 : str_key = estrndup(prop_name, str_key_len);
8025 3 : str_key_len++;
8026 : }
8027 3 : break;
8028 : }
8029 :
8030 : case ZEND_ITER_PLAIN_ARRAY:
8031 5314 : fe_ht = HASH_OF(array);
8032 5314 : zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.u.var).fe.fe_pos);
8033 5314 : if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) {
8034 : /* reached end of iteration */
8035 300 : ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
8036 : }
8037 5014 : if (use_key) {
8038 2228 : key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 1, NULL);
8039 : }
8040 5014 : zend_hash_move_forward(fe_ht);
8041 5014 : zend_hash_get_pointer(fe_ht, &EX_T(opline->op1.u.var).fe.fe_pos);
8042 5014 : break;
8043 :
8044 : case ZEND_ITER_OBJECT:
8045 : /* !iter happens from exception */
8046 22 : if (iter && ++iter->index > 0) {
8047 : /* This could cause an endless loop if index becomes zero again.
8048 : * In case that ever happens we need an additional flag. */
8049 18 : iter->funcs->move_forward(iter TSRMLS_CC);
8050 18 : if (EG(exception)) {
8051 0 : array->refcount--;
8052 0 : zval_ptr_dtor(&array);
8053 0 : ZEND_VM_NEXT_OPCODE();
8054 : }
8055 : }
8056 : /* If index is zero we come from FE_RESET and checked valid() already. */
8057 22 : if (!iter || (iter->index > 0 && iter->funcs->valid(iter TSRMLS_CC) == FAILURE)) {
8058 : /* reached end of iteration */
8059 4 : if (EG(exception)) {
8060 0 : array->refcount--;
8061 0 : zval_ptr_dtor(&array);
8062 0 : ZEND_VM_NEXT_OPCODE();
8063 : }
8064 4 : ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
8065 : }
8066 18 : iter->funcs->get_current_data(iter, &value TSRMLS_CC);
8067 18 : if (EG(exception)) {
8068 0 : array->refcount--;
8069 0 : zval_ptr_dtor(&array);
8070 0 : ZEND_VM_NEXT_OPCODE();
8071 : }
8072 18 : if (!value) {
8073 : /* failure in get_current_data */
8074 0 : ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
8075 : }
8076 18 : if (use_key) {
8077 0 : if (iter->funcs->get_current_key) {
8078 0 : key_type = iter->funcs->get_current_key(iter, &str_key, &str_key_len, &int_key TSRMLS_CC);
8079 0 : if (EG(exception)) {
8080 0 : array->refcount--;
8081 0 : zval_ptr_dtor(&array);
8082 0 : ZEND_VM_NEXT_OPCODE();
8083 : }
8084 : } else {
8085 0 : key_type = HASH_KEY_IS_LONG;
8086 0 : int_key = iter->index;
8087 : }
8088 : }
8089 : break;
8090 : }
8091 :
8092 5035 : if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
8093 0 : SEPARATE_ZVAL_IF_NOT_REF(value);
8094 0 : (*value)->is_ref = 1;
8095 0 : EX_T(opline->result.u.var).var.ptr_ptr = value;
8096 0 : (*value)->refcount++;
8097 : } else {
8098 5035 : EX_T(opline->result.u.var).var.ptr_ptr = value;
8099 5035 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
8100 5035 : AI_USE_PTR(EX_T(opline->result.u.var).var);
8101 : }
8102 :
8103 5035 : if (use_key) {
8104 2231 : zend_op *op_data = opline+1;
8105 2231 : zval *key = &EX_T(op_data->result.u.var).tmp_var;
8106 :
8107 2231 : switch (key_type) {
8108 : case HASH_KEY_IS_STRING:
8109 2219 : Z_STRVAL_P(key) = str_key;
8110 2219 : Z_STRLEN_P(key) = str_key_len-1;
8111 2219 : Z_TYPE_P(key) = IS_STRING;
8112 2219 : break;
8113 : case HASH_KEY_IS_LONG:
8114 12 : Z_LVAL_P(key) = int_key;
8115 12 : Z_TYPE_P(key) = IS_LONG;
8116 12 : break;
8117 : default:
8118 : case HASH_KEY_NON_EXISTANT:
8119 0 : ZVAL_NULL(key);
8120 : break;
8121 : }
8122 : }
8123 :
8124 5035 : ZEND_VM_INC_OPCODE();
8125 5035 : ZEND_VM_NEXT_OPCODE();
8126 : }
8127 :
8128 : static int ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8129 0 : {
8130 0 : zend_op *opline = EX(opline);
8131 : zend_free_op free_op1;
8132 0 : zval tmp, *varname = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8133 : zval **value;
8134 0 : zend_bool isset = 1;
8135 : HashTable *target_symbol_table;
8136 :
8137 0 : if (Z_TYPE_P(varname) != IS_STRING) {
8138 0 : tmp = *varname;
8139 0 : zval_copy_ctor(&tmp);
8140 0 : convert_to_string(&tmp);
8141 0 : varname = &tmp;
8142 : }
8143 :
8144 0 : if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
8145 0 : 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);
8146 0 : if (!value) {
8147 0 : isset = 0;
8148 : }
8149 : } else {
8150 0 : target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
8151 0 : if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
8152 0 : isset = 0;
8153 : }
8154 : }
8155 :
8156 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
8157 :
8158 0 : switch (opline->extended_value) {
8159 : case ZEND_ISSET:
8160 0 : if (isset && Z_TYPE_PP(value) == IS_NULL) {
8161 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
8162 : } else {
8163 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = isset;
8164 : }
8165 0 : break;
8166 : case ZEND_ISEMPTY:
8167 0 : if (!isset || !i_zend_is_true(*value)) {
8168 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
8169 : } else {
8170 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
8171 : }
8172 : break;
8173 : }
8174 :
8175 0 : if (varname == &tmp) {
8176 0 : zval_dtor(&tmp);
8177 : }
8178 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8179 :
8180 0 : ZEND_VM_NEXT_OPCODE();
8181 : }
8182 :
8183 : static int ZEND_EXIT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8184 0 : {
8185 : #if 0 || (IS_VAR != IS_UNUSED)
8186 0 : zend_op *opline = EX(opline);
8187 : if (IS_VAR != IS_UNUSED) {
8188 : zend_free_op free_op1;
8189 0 : zval *ptr = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8190 :
8191 0 : if (Z_TYPE_P(ptr) == IS_LONG) {
8192 0 : EG(exit_status) = Z_LVAL_P(ptr);
8193 : } else {
8194 0 : zend_print_variable(ptr);
8195 : }
8196 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8197 : }
8198 : #endif
8199 0 : zend_bailout();
8200 0 : ZEND_VM_NEXT_OPCODE();
8201 : }
8202 :
8203 : static int ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8204 109 : {
8205 109 : zend_op *opline = EX(opline);
8206 : zend_free_op free_op1;
8207 109 : zval *value = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8208 :
8209 109 : EX_T(opline->result.u.var).tmp_var = *value;
8210 : if (!0) {
8211 109 : zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
8212 : }
8213 109 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8214 109 : ZEND_VM_NEXT_OPCODE();
8215 : }
8216 :
8217 : static int ZEND_INSTANCEOF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8218 0 : {
8219 0 : zend_op *opline = EX(opline);
8220 : zend_free_op free_op1;
8221 0 : zval *expr = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8222 : zend_bool result;
8223 :
8224 0 : if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) {
8225 0 : result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.u.var).class_entry TSRMLS_CC);
8226 : } else {
8227 0 : result = 0;
8228 : }
8229 0 : ZVAL_BOOL(&EX_T(opline->result.u.var).tmp_var, result);
8230 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8231 0 : ZEND_VM_NEXT_OPCODE();
8232 : }
8233 :
8234 : static int ZEND_ADD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8235 0 : {
8236 0 : zend_op *opline = EX(opline);
8237 : zend_free_op free_op1;
8238 :
8239 0 : add_function(&EX_T(opline->result.u.var).tmp_var,
8240 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
8241 : &opline->op2.u.constant TSRMLS_CC);
8242 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8243 :
8244 0 : ZEND_VM_NEXT_OPCODE();
8245 : }
8246 :
8247 : static int ZEND_SUB_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8248 0 : {
8249 0 : zend_op *opline = EX(opline);
8250 : zend_free_op free_op1;
8251 :
8252 0 : sub_function(&EX_T(opline->result.u.var).tmp_var,
8253 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
8254 : &opline->op2.u.constant TSRMLS_CC);
8255 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8256 :
8257 0 : ZEND_VM_NEXT_OPCODE();
8258 : }
8259 :
8260 : static int ZEND_MUL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8261 0 : {
8262 0 : zend_op *opline = EX(opline);
8263 : zend_free_op free_op1;
8264 :
8265 0 : mul_function(&EX_T(opline->result.u.var).tmp_var,
8266 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
8267 : &opline->op2.u.constant TSRMLS_CC);
8268 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8269 :
8270 0 : ZEND_VM_NEXT_OPCODE();
8271 : }
8272 :
8273 : static int ZEND_DIV_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8274 0 : {
8275 0 : zend_op *opline = EX(opline);
8276 : zend_free_op free_op1;
8277 :
8278 0 : div_function(&EX_T(opline->result.u.var).tmp_var,
8279 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
8280 : &opline->op2.u.constant TSRMLS_CC);
8281 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8282 :
8283 0 : ZEND_VM_NEXT_OPCODE();
8284 : }
8285 :
8286 : static int ZEND_MOD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8287 0 : {
8288 0 : zend_op *opline = EX(opline);
8289 : zend_free_op free_op1;
8290 :
8291 0 : mod_function(&EX_T(opline->result.u.var).tmp_var,
8292 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
8293 : &opline->op2.u.constant TSRMLS_CC);
8294 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8295 :
8296 0 : ZEND_VM_NEXT_OPCODE();
8297 : }
8298 :
8299 : static int ZEND_SL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8300 0 : {
8301 0 : zend_op *opline = EX(opline);
8302 : zend_free_op free_op1;
8303 :
8304 0 : shift_left_function(&EX_T(opline->result.u.var).tmp_var,
8305 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
8306 : &opline->op2.u.constant TSRMLS_CC);
8307 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8308 :
8309 0 : ZEND_VM_NEXT_OPCODE();
8310 : }
8311 :
8312 : static int ZEND_SR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8313 0 : {
8314 0 : zend_op *opline = EX(opline);
8315 : zend_free_op free_op1;
8316 :
8317 0 : shift_right_function(&EX_T(opline->result.u.var).tmp_var,
8318 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
8319 : &opline->op2.u.constant TSRMLS_CC);
8320 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8321 :
8322 0 : ZEND_VM_NEXT_OPCODE();
8323 : }
8324 :
8325 : static int ZEND_CONCAT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8326 164 : {
8327 164 : zend_op *opline = EX(opline);
8328 : zend_free_op free_op1;
8329 :
8330 164 : concat_function(&EX_T(opline->result.u.var).tmp_var,
8331 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
8332 : &opline->op2.u.constant TSRMLS_CC);
8333 164 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8334 :
8335 164 : ZEND_VM_NEXT_OPCODE();
8336 : }
8337 :
8338 : static int ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8339 1750 : {
8340 1750 : zend_op *opline = EX(opline);
8341 : zend_free_op free_op1;
8342 :
8343 1750 : is_identical_function(&EX_T(opline->result.u.var).tmp_var,
8344 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
8345 : &opline->op2.u.constant TSRMLS_CC);
8346 1750 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8347 :
8348 1750 : ZEND_VM_NEXT_OPCODE();
8349 : }
8350 :
8351 : static int ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8352 3057 : {
8353 3057 : zend_op *opline = EX(opline);
8354 : zend_free_op free_op1;
8355 :
8356 3057 : is_not_identical_function(&EX_T(opline->result.u.var).tmp_var,
8357 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
8358 : &opline->op2.u.constant TSRMLS_CC);
8359 3057 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8360 :
8361 3057 : ZEND_VM_NEXT_OPCODE();
8362 : }
8363 :
8364 : static int ZEND_IS_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8365 3733 : {
8366 3733 : zend_op *opline = EX(opline);
8367 : zend_free_op free_op1;
8368 :
8369 3733 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
8370 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
8371 : &opline->op2.u.constant TSRMLS_CC);
8372 3733 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8373 :
8374 3733 : ZEND_VM_NEXT_OPCODE();
8375 : }
8376 :
8377 : static int ZEND_IS_NOT_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8378 2 : {
8379 2 : zend_op *opline = EX(opline);
8380 : zend_free_op free_op1;
8381 :
8382 2 : is_not_equal_function(&EX_T(opline->result.u.var).tmp_var,
8383 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
8384 : &opline->op2.u.constant TSRMLS_CC);
8385 2 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8386 :
8387 2 : ZEND_VM_NEXT_OPCODE();
8388 : }
8389 :
8390 : static int ZEND_IS_SMALLER_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8391 0 : {
8392 0 : zend_op *opline = EX(opline);
8393 : zend_free_op free_op1;
8394 :
8395 0 : is_smaller_function(&EX_T(opline->result.u.var).tmp_var,
8396 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
8397 : &opline->op2.u.constant TSRMLS_CC);
8398 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8399 :
8400 0 : ZEND_VM_NEXT_OPCODE();
8401 : }
8402 :
8403 : static int ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8404 0 : {
8405 0 : zend_op *opline = EX(opline);
8406 : zend_free_op free_op1;
8407 :
8408 0 : is_smaller_or_equal_function(&EX_T(opline->result.u.var).tmp_var,
8409 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
8410 : &opline->op2.u.constant TSRMLS_CC);
8411 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8412 :
8413 0 : ZEND_VM_NEXT_OPCODE();
8414 : }
8415 :
8416 : static int ZEND_BW_OR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8417 0 : {
8418 0 : zend_op *opline = EX(opline);
8419 : zend_free_op free_op1;
8420 :
8421 0 : bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
8422 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
8423 : &opline->op2.u.constant TSRMLS_CC);
8424 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8425 :
8426 0 : ZEND_VM_NEXT_OPCODE();
8427 : }
8428 :
8429 : static int ZEND_BW_AND_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8430 0 : {
8431 0 : zend_op *opline = EX(opline);
8432 : zend_free_op free_op1;
8433 :
8434 0 : bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
8435 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
8436 : &opline->op2.u.constant TSRMLS_CC);
8437 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8438 :
8439 0 : ZEND_VM_NEXT_OPCODE();
8440 : }
8441 :
8442 : static int ZEND_BW_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8443 0 : {
8444 0 : zend_op *opline = EX(opline);
8445 : zend_free_op free_op1;
8446 :
8447 0 : bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
8448 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
8449 : &opline->op2.u.constant TSRMLS_CC);
8450 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8451 :
8452 0 : ZEND_VM_NEXT_OPCODE();
8453 : }
8454 :
8455 : static int ZEND_BOOL_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8456 0 : {
8457 0 : zend_op *opline = EX(opline);
8458 : zend_free_op free_op1;
8459 :
8460 0 : boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
8461 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
8462 : &opline->op2.u.constant TSRMLS_CC);
8463 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8464 :
8465 0 : ZEND_VM_NEXT_OPCODE();
8466 : }
8467 :
8468 : static int zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
8469 0 : {
8470 0 : zend_op *opline = EX(opline);
8471 0 : zend_op *op_data = opline+1;
8472 : zend_free_op free_op1, free_op_data1;
8473 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8474 : zval *object;
8475 0 : zval *property = &opline->op2.u.constant;
8476 0 : zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
8477 0 : znode *result = &opline->result;
8478 0 : zval **retval = &EX_T(result->u.var).var.ptr;
8479 0 : int have_get_ptr = 0;
8480 :
8481 0 : EX_T(result->u.var).var.ptr_ptr = NULL;
8482 0 : make_real_object(object_ptr TSRMLS_CC);
8483 0 : object = *object_ptr;
8484 :
8485 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
8486 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
8487 :
8488 0 : FREE_OP(free_op_data1);
8489 :
8490 0 : if (!RETURN_VALUE_UNUSED(result)) {
8491 0 : *retval = EG(uninitialized_zval_ptr);
8492 0 : PZVAL_LOCK(*retval);
8493 : }
8494 : } else {
8495 : /* here we are sure we are dealing with an object */
8496 : if (0) {
8497 : MAKE_REAL_ZVAL_PTR(property);
8498 : }
8499 :
8500 : /* here property is a string */
8501 0 : if (opline->extended_value == ZEND_ASSIGN_OBJ
8502 : && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
8503 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
8504 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
8505 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
8506 :
8507 0 : have_get_ptr = 1;
8508 0 : binary_op(*zptr, *zptr, value TSRMLS_CC);
8509 0 : if (!RETURN_VALUE_UNUSED(result)) {
8510 0 : *retval = *zptr;
8511 0 : PZVAL_LOCK(*retval);
8512 : }
8513 : }
8514 : }
8515 :
8516 0 : if (!have_get_ptr) {
8517 0 : zval *z = NULL;
8518 :
8519 0 : switch (opline->extended_value) {
8520 : case ZEND_ASSIGN_OBJ:
8521 0 : if (Z_OBJ_HT_P(object)->read_property) {
8522 0 : z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
8523 : }
8524 0 : break;
8525 : case ZEND_ASSIGN_DIM:
8526 0 : if (Z_OBJ_HT_P(object)->read_dimension) {
8527 0 : z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
8528 : }
8529 : break;
8530 : }
8531 0 : if (z) {
8532 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
8533 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
8534 :
8535 0 : if (z->refcount == 0) {
8536 0 : zval_dtor(z);
8537 0 : FREE_ZVAL(z);
8538 : }
8539 0 : z = value;
8540 : }
8541 0 : z->refcount++;
8542 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
8543 0 : binary_op(z, z, value TSRMLS_CC);
8544 0 : switch (opline->extended_value) {
8545 : case ZEND_ASSIGN_OBJ:
8546 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
8547 0 : break;
8548 : case ZEND_ASSIGN_DIM:
8549 0 : Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
8550 : break;
8551 : }
8552 0 : if (!RETURN_VALUE_UNUSED(result)) {
8553 0 : *retval = z;
8554 0 : PZVAL_LOCK(*retval);
8555 : }
8556 0 : zval_ptr_dtor(&z);
8557 : } else {
8558 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
8559 0 : if (!RETURN_VALUE_UNUSED(result)) {
8560 0 : *retval = EG(uninitialized_zval_ptr);
8561 0 : PZVAL_LOCK(*retval);
8562 : }
8563 : }
8564 : }
8565 :
8566 : if (0) {
8567 : zval_ptr_dtor(&property);
8568 : } else {
8569 :
8570 : }
8571 0 : FREE_OP(free_op_data1);
8572 : }
8573 :
8574 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8575 : /* assign_obj has two opcodes! */
8576 0 : ZEND_VM_INC_OPCODE();
8577 0 : ZEND_VM_NEXT_OPCODE();
8578 : }
8579 :
8580 : static int zend_binary_assign_op_helper_SPEC_VAR_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
8581 0 : {
8582 0 : zend_op *opline = EX(opline);
8583 : zend_free_op free_op1, free_op_data2, free_op_data1;
8584 : zval **var_ptr;
8585 : zval *value;
8586 0 : zend_bool increment_opline = 0;
8587 :
8588 0 : switch (opline->extended_value) {
8589 : case ZEND_ASSIGN_OBJ:
8590 0 : return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8591 : break;
8592 : case ZEND_ASSIGN_DIM: {
8593 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8594 :
8595 0 : if (object_ptr && IS_VAR != IS_CV && !(free_op1.var != NULL)) {
8596 0 : (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
8597 : }
8598 :
8599 0 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
8600 0 : return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8601 : } else {
8602 0 : zend_op *op_data = opline+1;
8603 0 : zval *dim = &opline->op2.u.constant;
8604 :
8605 0 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
8606 0 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
8607 0 : var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
8608 0 : increment_opline = 1;
8609 : }
8610 : }
8611 0 : break;
8612 : default:
8613 0 : value = &opline->op2.u.constant;
8614 0 : var_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8615 : /* do nothing */
8616 : break;
8617 : }
8618 :
8619 0 : if (!var_ptr) {
8620 0 : zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
8621 : }
8622 :
8623 0 : if (*var_ptr == EG(error_zval_ptr)) {
8624 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
8625 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
8626 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
8627 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
8628 : }
8629 :
8630 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8631 0 : if (increment_opline) {
8632 0 : ZEND_VM_INC_OPCODE();
8633 : }
8634 0 : ZEND_VM_NEXT_OPCODE();
8635 : }
8636 :
8637 0 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
8638 :
8639 0 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
8640 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
8641 : /* proxy object */
8642 0 : zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
8643 0 : objval->refcount++;
8644 0 : binary_op(objval, objval, value TSRMLS_CC);
8645 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
8646 0 : zval_ptr_dtor(&objval);
8647 : } else {
8648 0 : binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
8649 : }
8650 :
8651 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
8652 0 : EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
8653 0 : PZVAL_LOCK(*var_ptr);
8654 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
8655 : }
8656 :
8657 0 : if (increment_opline) {
8658 0 : ZEND_VM_INC_OPCODE();
8659 0 : FREE_OP(free_op_data1);
8660 0 : FREE_OP_VAR_PTR(free_op_data2);
8661 : }
8662 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8663 0 : ZEND_VM_NEXT_OPCODE();
8664 : }
8665 :
8666 : static int ZEND_ASSIGN_ADD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8667 0 : {
8668 0 : return zend_binary_assign_op_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8669 : }
8670 :
8671 : static int ZEND_ASSIGN_SUB_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8672 0 : {
8673 0 : return zend_binary_assign_op_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8674 : }
8675 :
8676 : static int ZEND_ASSIGN_MUL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8677 0 : {
8678 0 : return zend_binary_assign_op_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8679 : }
8680 :
8681 : static int ZEND_ASSIGN_DIV_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8682 0 : {
8683 0 : return zend_binary_assign_op_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8684 : }
8685 :
8686 : static int ZEND_ASSIGN_MOD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8687 0 : {
8688 0 : return zend_binary_assign_op_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8689 : }
8690 :
8691 : static int ZEND_ASSIGN_SL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8692 0 : {
8693 0 : return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8694 : }
8695 :
8696 : static int ZEND_ASSIGN_SR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8697 0 : {
8698 0 : return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8699 : }
8700 :
8701 : static int ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8702 0 : {
8703 0 : return zend_binary_assign_op_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8704 : }
8705 :
8706 : static int ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8707 0 : {
8708 0 : return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8709 : }
8710 :
8711 : static int ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8712 0 : {
8713 0 : return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8714 : }
8715 :
8716 : static int ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8717 0 : {
8718 0 : return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8719 : }
8720 :
8721 : static int zend_pre_incdec_property_helper_SPEC_VAR_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
8722 0 : {
8723 0 : zend_op *opline = EX(opline);
8724 : zend_free_op free_op1;
8725 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8726 : zval *object;
8727 0 : zval *property = &opline->op2.u.constant;
8728 0 : zval **retval = &EX_T(opline->result.u.var).var.ptr;
8729 0 : int have_get_ptr = 0;
8730 :
8731 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
8732 0 : object = *object_ptr;
8733 :
8734 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
8735 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
8736 :
8737 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
8738 0 : *retval = EG(uninitialized_zval_ptr);
8739 0 : PZVAL_LOCK(*retval);
8740 : }
8741 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8742 0 : ZEND_VM_NEXT_OPCODE();
8743 : }
8744 :
8745 : /* here we are sure we are dealing with an object */
8746 :
8747 : if (0) {
8748 : MAKE_REAL_ZVAL_PTR(property);
8749 : }
8750 :
8751 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
8752 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
8753 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
8754 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
8755 :
8756 0 : have_get_ptr = 1;
8757 0 : incdec_op(*zptr);
8758 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
8759 0 : *retval = *zptr;
8760 0 : PZVAL_LOCK(*retval);
8761 : }
8762 : }
8763 : }
8764 :
8765 0 : if (!have_get_ptr) {
8766 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
8767 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
8768 :
8769 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
8770 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
8771 :
8772 0 : if (z->refcount == 0) {
8773 0 : zval_dtor(z);
8774 0 : FREE_ZVAL(z);
8775 : }
8776 0 : z = value;
8777 : }
8778 0 : z->refcount++;
8779 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
8780 0 : incdec_op(z);
8781 0 : *retval = z;
8782 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
8783 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
8784 0 : zval_ptr_dtor(&z);
8785 : } else {
8786 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
8787 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
8788 0 : *retval = EG(uninitialized_zval_ptr);
8789 0 : PZVAL_LOCK(*retval);
8790 : }
8791 : }
8792 : }
8793 :
8794 : if (0) {
8795 : zval_ptr_dtor(&property);
8796 : } else {
8797 :
8798 : }
8799 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8800 0 : ZEND_VM_NEXT_OPCODE();
8801 : }
8802 :
8803 : static int ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8804 0 : {
8805 0 : return zend_pre_incdec_property_helper_SPEC_VAR_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8806 : }
8807 :
8808 : static int ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8809 0 : {
8810 0 : return zend_pre_incdec_property_helper_SPEC_VAR_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8811 : }
8812 :
8813 : static int zend_post_incdec_property_helper_SPEC_VAR_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
8814 0 : {
8815 0 : zend_op *opline = EX(opline);
8816 : zend_free_op free_op1;
8817 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8818 : zval *object;
8819 0 : zval *property = &opline->op2.u.constant;
8820 0 : zval *retval = &EX_T(opline->result.u.var).tmp_var;
8821 0 : int have_get_ptr = 0;
8822 :
8823 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
8824 0 : object = *object_ptr;
8825 :
8826 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
8827 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
8828 :
8829 0 : *retval = *EG(uninitialized_zval_ptr);
8830 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8831 0 : ZEND_VM_NEXT_OPCODE();
8832 : }
8833 :
8834 : /* here we are sure we are dealing with an object */
8835 :
8836 : if (0) {
8837 : MAKE_REAL_ZVAL_PTR(property);
8838 : }
8839 :
8840 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
8841 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
8842 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
8843 0 : have_get_ptr = 1;
8844 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
8845 :
8846 0 : *retval = **zptr;
8847 0 : zendi_zval_copy_ctor(*retval);
8848 :
8849 0 : incdec_op(*zptr);
8850 :
8851 : }
8852 : }
8853 :
8854 0 : if (!have_get_ptr) {
8855 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
8856 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
8857 : zval *z_copy;
8858 :
8859 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
8860 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
8861 :
8862 0 : if (z->refcount == 0) {
8863 0 : zval_dtor(z);
8864 0 : FREE_ZVAL(z);
8865 : }
8866 0 : z = value;
8867 : }
8868 0 : *retval = *z;
8869 0 : zendi_zval_copy_ctor(*retval);
8870 0 : ALLOC_ZVAL(z_copy);
8871 0 : *z_copy = *z;
8872 0 : zendi_zval_copy_ctor(*z_copy);
8873 0 : INIT_PZVAL(z_copy);
8874 0 : incdec_op(z_copy);
8875 0 : z->refcount++;
8876 0 : Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
8877 0 : zval_ptr_dtor(&z_copy);
8878 0 : zval_ptr_dtor(&z);
8879 : } else {
8880 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
8881 0 : *retval = *EG(uninitialized_zval_ptr);
8882 : }
8883 : }
8884 :
8885 : if (0) {
8886 : zval_ptr_dtor(&property);
8887 : } else {
8888 :
8889 : }
8890 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8891 0 : ZEND_VM_NEXT_OPCODE();
8892 : }
8893 :
8894 : static int ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8895 0 : {
8896 0 : return zend_post_incdec_property_helper_SPEC_VAR_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8897 : }
8898 :
8899 : static int ZEND_POST_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8900 0 : {
8901 0 : return zend_post_incdec_property_helper_SPEC_VAR_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8902 : }
8903 :
8904 : static int ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8905 1476 : {
8906 1476 : zend_op *opline = EX(opline);
8907 : zend_free_op free_op1;
8908 1476 : zval *dim = &opline->op2.u.constant;
8909 :
8910 1476 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK &&
8911 : IS_VAR != IS_CV &&
8912 : EX_T(opline->op1.u.var).var.ptr_ptr) {
8913 14 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
8914 : }
8915 1476 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_R TSRMLS_CC);
8916 :
8917 1476 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8918 1476 : ZEND_VM_NEXT_OPCODE();
8919 : }
8920 :
8921 : static int ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8922 0 : {
8923 0 : zend_op *opline = EX(opline);
8924 : zend_free_op free_op1;
8925 0 : zval *dim = &opline->op2.u.constant;
8926 :
8927 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_W TSRMLS_CC);
8928 :
8929 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
8930 : READY_TO_DESTROY(free_op1.var) &&
8931 : !RETURN_VALUE_UNUSED(&opline->result)) {
8932 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
8933 : }
8934 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8935 0 : ZEND_VM_NEXT_OPCODE();
8936 : }
8937 :
8938 : static int ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8939 0 : {
8940 0 : zend_op *opline = EX(opline);
8941 : zend_free_op free_op1;
8942 0 : zval *dim = &opline->op2.u.constant;
8943 :
8944 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
8945 :
8946 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
8947 : READY_TO_DESTROY(free_op1.var) &&
8948 : !RETURN_VALUE_UNUSED(&opline->result)) {
8949 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
8950 : }
8951 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8952 0 : ZEND_VM_NEXT_OPCODE();
8953 : }
8954 :
8955 : static int ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8956 0 : {
8957 0 : zend_op *opline = EX(opline);
8958 : zend_free_op free_op1;
8959 0 : zval *dim = &opline->op2.u.constant;
8960 :
8961 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_IS TSRMLS_CC);
8962 :
8963 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8964 0 : ZEND_VM_NEXT_OPCODE();
8965 : }
8966 :
8967 : static int ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8968 0 : {
8969 0 : zend_op *opline = EX(opline);
8970 : zend_free_op free_op1;
8971 0 : int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
8972 : zval *dim;
8973 :
8974 : if (IS_CONST == IS_UNUSED && type == BP_VAR_R) {
8975 : zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
8976 : }
8977 0 : dim = &opline->op2.u.constant;
8978 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, type TSRMLS_CC);
8979 :
8980 0 : if (IS_VAR == IS_VAR && type == BP_VAR_W && (free_op1.var != NULL) &&
8981 : READY_TO_DESTROY(free_op1.var) &&
8982 : !RETURN_VALUE_UNUSED(&opline->result)) {
8983 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
8984 : }
8985 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
8986 0 : ZEND_VM_NEXT_OPCODE();
8987 : }
8988 :
8989 : static int ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8990 0 : {
8991 0 : zend_op *opline = EX(opline);
8992 : zend_free_op free_op1;
8993 0 : zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
8994 0 : zval *dim = &opline->op2.u.constant;
8995 :
8996 : /* Not needed in DIM_UNSET
8997 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
8998 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
8999 : }
9000 : */
9001 : if (IS_VAR == IS_CV) {
9002 : if (container != &EG(uninitialized_zval_ptr)) {
9003 : SEPARATE_ZVAL_IF_NOT_REF(container);
9004 : }
9005 : }
9006 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_UNSET TSRMLS_CC);
9007 :
9008 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
9009 : READY_TO_DESTROY(free_op1.var) &&
9010 : !RETURN_VALUE_UNUSED(&opline->result)) {
9011 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
9012 : }
9013 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9014 0 : if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
9015 0 : zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
9016 : } else {
9017 : zend_free_op free_res;
9018 :
9019 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
9020 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
9021 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
9022 : }
9023 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
9024 0 : FREE_OP_VAR_PTR(free_res);
9025 : }
9026 0 : ZEND_VM_NEXT_OPCODE();
9027 : }
9028 :
9029 : static int zend_fetch_property_address_read_helper_SPEC_VAR_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
9030 47 : {
9031 47 : zend_op *opline = EX(opline);
9032 : zval *container;
9033 : zval **retval;
9034 : zend_free_op free_op1;
9035 :
9036 47 : retval = &EX_T(opline->result.u.var).var.ptr;
9037 47 : EX_T(opline->result.u.var).var.ptr_ptr = retval;
9038 :
9039 47 : container = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9040 :
9041 47 : if (container == EG(error_zval_ptr)) {
9042 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
9043 0 : *retval = EG(error_zval_ptr);
9044 0 : PZVAL_LOCK(*retval);
9045 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
9046 : }
9047 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9048 0 : ZEND_VM_NEXT_OPCODE();
9049 : }
9050 :
9051 :
9052 47 : if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
9053 0 : if (type != BP_VAR_IS) {
9054 0 : zend_error(E_NOTICE, "Trying to get property of non-object");
9055 : }
9056 0 : *retval = EG(uninitialized_zval_ptr);
9057 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
9058 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
9059 : } else {
9060 :
9061 47 : zval *offset = &opline->op2.u.constant;
9062 :
9063 : if (0) {
9064 : MAKE_REAL_ZVAL_PTR(offset);
9065 : }
9066 :
9067 : /* here we are sure we are dealing with an object */
9068 47 : *retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
9069 :
9070 47 : if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
9071 0 : zval_dtor(*retval);
9072 0 : FREE_ZVAL(*retval);
9073 : } else {
9074 47 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
9075 47 : AI_USE_PTR(EX_T(opline->result.u.var).var);
9076 : }
9077 :
9078 : if (0) {
9079 : zval_ptr_dtor(&offset);
9080 : } else {
9081 :
9082 : }
9083 : }
9084 :
9085 47 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9086 47 : ZEND_VM_NEXT_OPCODE();
9087 : }
9088 :
9089 : static int ZEND_FETCH_OBJ_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9090 47 : {
9091 47 : return zend_fetch_property_address_read_helper_SPEC_VAR_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9092 : }
9093 :
9094 : static int ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9095 0 : {
9096 0 : zend_op *opline = EX(opline);
9097 : zend_free_op free_op1;
9098 0 : zval *property = &opline->op2.u.constant;
9099 :
9100 0 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_VAR != IS_CV) {
9101 0 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
9102 0 : EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
9103 : }
9104 :
9105 : if (0) {
9106 : MAKE_REAL_ZVAL_PTR(property);
9107 : }
9108 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
9109 : if (0) {
9110 : zval_ptr_dtor(&property);
9111 : } else {
9112 :
9113 : }
9114 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
9115 : READY_TO_DESTROY(free_op1.var) &&
9116 : !RETURN_VALUE_UNUSED(&opline->result)) {
9117 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
9118 : }
9119 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9120 0 : ZEND_VM_NEXT_OPCODE();
9121 : }
9122 :
9123 : static int ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9124 0 : {
9125 0 : zend_op *opline = EX(opline);
9126 : zend_free_op free_op1;
9127 0 : zval *property = &opline->op2.u.constant;
9128 :
9129 : if (0) {
9130 : MAKE_REAL_ZVAL_PTR(property);
9131 : }
9132 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_RW TSRMLS_CC);
9133 : if (0) {
9134 : zval_ptr_dtor(&property);
9135 : } else {
9136 :
9137 : }
9138 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
9139 : READY_TO_DESTROY(free_op1.var) &&
9140 : !RETURN_VALUE_UNUSED(&opline->result)) {
9141 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
9142 : }
9143 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9144 0 : ZEND_VM_NEXT_OPCODE();
9145 : }
9146 :
9147 : static int ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9148 0 : {
9149 0 : return zend_fetch_property_address_read_helper_SPEC_VAR_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9150 : }
9151 :
9152 : static int ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9153 0 : {
9154 0 : zend_op *opline = EX(opline);
9155 :
9156 0 : if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
9157 : /* Behave like FETCH_OBJ_W */
9158 : zend_free_op free_op1;
9159 0 : zval *property = &opline->op2.u.constant;
9160 :
9161 : if (0) {
9162 : MAKE_REAL_ZVAL_PTR(property);
9163 : }
9164 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
9165 : if (0) {
9166 : zval_ptr_dtor(&property);
9167 : } else {
9168 :
9169 : }
9170 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
9171 : READY_TO_DESTROY(free_op1.var) &&
9172 : !RETURN_VALUE_UNUSED(&opline->result)) {
9173 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
9174 : }
9175 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9176 0 : ZEND_VM_NEXT_OPCODE();
9177 : } else {
9178 0 : return zend_fetch_property_address_read_helper_SPEC_VAR_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9179 : }
9180 : }
9181 :
9182 : static int ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9183 0 : {
9184 0 : zend_op *opline = EX(opline);
9185 : zend_free_op free_op1, free_res;
9186 0 : zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9187 0 : zval *property = &opline->op2.u.constant;
9188 :
9189 : if (IS_VAR == IS_CV) {
9190 : if (container != &EG(uninitialized_zval_ptr)) {
9191 : SEPARATE_ZVAL_IF_NOT_REF(container);
9192 : }
9193 : }
9194 : if (0) {
9195 : MAKE_REAL_ZVAL_PTR(property);
9196 : }
9197 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
9198 : if (0) {
9199 : zval_ptr_dtor(&property);
9200 : } else {
9201 :
9202 : }
9203 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
9204 : READY_TO_DESTROY(free_op1.var) &&
9205 : !RETURN_VALUE_UNUSED(&opline->result)) {
9206 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
9207 : }
9208 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9209 :
9210 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
9211 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
9212 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
9213 : }
9214 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
9215 0 : FREE_OP_VAR_PTR(free_res);
9216 0 : ZEND_VM_NEXT_OPCODE();
9217 : }
9218 :
9219 : static int ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9220 2 : {
9221 2 : zend_op *opline = EX(opline);
9222 2 : zend_op *op_data = opline+1;
9223 : zend_free_op free_op1;
9224 2 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9225 :
9226 2 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
9227 2 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9228 : /* assign_obj has two opcodes! */
9229 2 : ZEND_VM_INC_OPCODE();
9230 2 : ZEND_VM_NEXT_OPCODE();
9231 : }
9232 :
9233 : static int ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9234 1 : {
9235 1 : zend_op *opline = EX(opline);
9236 1 : zend_op *op_data = opline+1;
9237 : zend_free_op free_op1;
9238 : zval **object_ptr;
9239 :
9240 1 : if (IS_VAR == IS_CV || EX_T(opline->op1.u.var).var.ptr_ptr) {
9241 : /* not an array offset */
9242 1 : object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9243 : } else {
9244 0 : object_ptr = NULL;
9245 : }
9246 :
9247 1 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
9248 0 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
9249 : } else {
9250 : zend_free_op free_op_data1;
9251 : zval *value;
9252 1 : zval *dim = &opline->op2.u.constant;
9253 :
9254 1 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
9255 :
9256 1 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
9257 1 : zend_assign_to_variable(&opline->result, &op_data->op2, &op_data->op1, value, (IS_TMP_FREE(free_op_data1)?IS_TMP_VAR:op_data->op1.op_type), EX(Ts) TSRMLS_CC);
9258 1 : FREE_OP_IF_VAR(free_op_data1);
9259 : }
9260 1 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9261 : /* assign_dim has two opcodes! */
9262 1 : ZEND_VM_INC_OPCODE();
9263 1 : ZEND_VM_NEXT_OPCODE();
9264 : }
9265 :
9266 : static int ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9267 0 : {
9268 0 : zend_op *opline = EX(opline);
9269 :
9270 0 : zval *value = &opline->op2.u.constant;
9271 :
9272 0 : zend_assign_to_variable(&opline->result, &opline->op1, &opline->op2, value, (0?IS_TMP_VAR:IS_CONST), EX(Ts) TSRMLS_CC);
9273 : /* zend_assign_to_variable() always takes care of op2, never free it! */
9274 :
9275 0 : ZEND_VM_NEXT_OPCODE();
9276 : }
9277 :
9278 : static int ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9279 37 : {
9280 37 : zend_op *opline = EX(opline);
9281 : zval *function_name;
9282 : char *function_name_strval;
9283 : int function_name_strlen;
9284 : zend_free_op free_op1;
9285 :
9286 37 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
9287 :
9288 37 : function_name = &opline->op2.u.constant;
9289 :
9290 37 : if (Z_TYPE_P(function_name)!=IS_STRING) {
9291 0 : zend_error_noreturn(E_ERROR, "Method name must be a string");
9292 : }
9293 :
9294 37 : function_name_strval = Z_STRVAL_P(function_name);
9295 37 : function_name_strlen = Z_STRLEN_P(function_name);
9296 :
9297 37 : EX(object) = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9298 :
9299 37 : if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
9300 37 : if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
9301 0 : zend_error_noreturn(E_ERROR, "Object does not support method calls");
9302 : }
9303 :
9304 : /* First, locate the function. */
9305 37 : EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
9306 37 : if (!EX(fbc)) {
9307 0 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
9308 : }
9309 : } else {
9310 0 : zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
9311 : }
9312 :
9313 37 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
9314 0 : EX(object) = NULL;
9315 : } else {
9316 37 : if (!PZVAL_IS_REF(EX(object))) {
9317 37 : EX(object)->refcount++; /* For $this pointer */
9318 : } else {
9319 : zval *this_ptr;
9320 0 : ALLOC_ZVAL(this_ptr);
9321 0 : INIT_PZVAL_COPY(this_ptr, EX(object));
9322 0 : zval_copy_ctor(this_ptr);
9323 0 : EX(object) = this_ptr;
9324 : }
9325 : }
9326 :
9327 37 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9328 :
9329 37 : ZEND_VM_NEXT_OPCODE();
9330 : }
9331 :
9332 : static int ZEND_CASE_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9333 0 : {
9334 0 : zend_op *opline = EX(opline);
9335 0 : int switch_expr_is_overloaded=0;
9336 : zend_free_op free_op1;
9337 :
9338 : if (IS_VAR==IS_VAR) {
9339 0 : if (EX_T(opline->op1.u.var).var.ptr_ptr) {
9340 0 : PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
9341 : } else {
9342 0 : switch_expr_is_overloaded = 1;
9343 0 : EX_T(opline->op1.u.var).str_offset.str->refcount++;
9344 : }
9345 : }
9346 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
9347 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9348 : &opline->op2.u.constant TSRMLS_CC);
9349 :
9350 0 : if (switch_expr_is_overloaded) {
9351 : /* We only free op1 if this is a string offset,
9352 : * Since if it is a TMP_VAR, it'll be reused by
9353 : * other CASE opcodes (whereas string offsets
9354 : * are allocated at each get_zval_ptr())
9355 : */
9356 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9357 0 : EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
9358 0 : AI_USE_PTR(EX_T(opline->op1.u.var).var);
9359 : }
9360 0 : ZEND_VM_NEXT_OPCODE();
9361 : }
9362 :
9363 : static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9364 0 : {
9365 0 : zend_op *opline = EX(opline);
9366 : zend_free_op free_op1;
9367 0 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
9368 : zval *expr_ptr;
9369 0 : zval *offset=&opline->op2.u.constant;
9370 :
9371 : #if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
9372 0 : zval **expr_ptr_ptr = NULL;
9373 :
9374 0 : if (opline->extended_value) {
9375 0 : expr_ptr_ptr=_get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9376 0 : expr_ptr = *expr_ptr_ptr;
9377 : } else {
9378 0 : expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9379 : }
9380 : #else
9381 : expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9382 : #endif
9383 :
9384 : if (0) { /* temporary variable */
9385 : zval *new_expr;
9386 :
9387 : ALLOC_ZVAL(new_expr);
9388 : INIT_PZVAL_COPY(new_expr, expr_ptr);
9389 : expr_ptr = new_expr;
9390 : } else {
9391 : #if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
9392 0 : if (opline->extended_value) {
9393 0 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
9394 0 : expr_ptr = *expr_ptr_ptr;
9395 0 : expr_ptr->refcount++;
9396 : } else
9397 : #endif
9398 0 : if (PZVAL_IS_REF(expr_ptr)) {
9399 : zval *new_expr;
9400 :
9401 0 : ALLOC_ZVAL(new_expr);
9402 0 : INIT_PZVAL_COPY(new_expr, expr_ptr);
9403 0 : expr_ptr = new_expr;
9404 0 : zendi_zval_copy_ctor(*expr_ptr);
9405 : } else {
9406 0 : expr_ptr->refcount++;
9407 : }
9408 : }
9409 0 : if (offset) {
9410 0 : switch (Z_TYPE_P(offset)) {
9411 : case IS_DOUBLE:
9412 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
9413 0 : break;
9414 : case IS_LONG:
9415 : case IS_BOOL:
9416 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
9417 0 : break;
9418 : case IS_STRING:
9419 0 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
9420 0 : break;
9421 : case IS_NULL:
9422 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
9423 0 : break;
9424 : default:
9425 0 : zend_error(E_WARNING, "Illegal offset type");
9426 0 : zval_ptr_dtor(&expr_ptr);
9427 : /* do nothing */
9428 : break;
9429 : }
9430 :
9431 : } else {
9432 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
9433 : }
9434 0 : if (opline->extended_value) {
9435 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9436 : } else {
9437 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9438 : }
9439 0 : ZEND_VM_NEXT_OPCODE();
9440 : }
9441 :
9442 : static int ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9443 0 : {
9444 0 : zend_op *opline = EX(opline);
9445 :
9446 0 : array_init(&EX_T(opline->result.u.var).tmp_var);
9447 : if (IS_VAR == IS_UNUSED) {
9448 : ZEND_VM_NEXT_OPCODE();
9449 : #if 0 || IS_VAR != IS_UNUSED
9450 : } else {
9451 0 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9452 : #endif
9453 : }
9454 : }
9455 :
9456 : static int ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9457 0 : {
9458 0 : zend_op *opline = EX(opline);
9459 : zend_free_op free_op1;
9460 0 : zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9461 0 : zval *offset = &opline->op2.u.constant;
9462 : long index;
9463 :
9464 0 : if (container) {
9465 : if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
9466 : SEPARATE_ZVAL_IF_NOT_REF(container);
9467 : }
9468 0 : switch (Z_TYPE_PP(container)) {
9469 : case IS_ARRAY: {
9470 0 : HashTable *ht = Z_ARRVAL_PP(container);
9471 :
9472 0 : switch (Z_TYPE_P(offset)) {
9473 : case IS_DOUBLE:
9474 0 : index = (long) Z_DVAL_P(offset);
9475 0 : zend_hash_index_del(ht, index);
9476 0 : break;
9477 : case IS_RESOURCE:
9478 : case IS_BOOL:
9479 : case IS_LONG:
9480 0 : index = Z_LVAL_P(offset);
9481 0 : zend_hash_index_del(ht, index);
9482 0 : break;
9483 : case IS_STRING:
9484 : if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
9485 : offset->refcount++;
9486 : }
9487 0 : if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
9488 : ht == &EG(symbol_table)) {
9489 : zend_execute_data *ex;
9490 0 : ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
9491 :
9492 0 : for (ex = execute_data; ex; ex = ex->prev_execute_data) {
9493 0 : if (ex->op_array && ex->symbol_table == ht) {
9494 : int i;
9495 :
9496 0 : for (i = 0; i < ex->op_array->last_var; i++) {
9497 0 : if (ex->op_array->vars[i].hash_value == hash_value &&
9498 : ex->op_array->vars[i].name_len == offset->value.str.len &&
9499 : !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
9500 0 : ex->CVs[i] = NULL;
9501 0 : break;
9502 : }
9503 : }
9504 : }
9505 : }
9506 : }
9507 : if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
9508 : zval_ptr_dtor(&offset);
9509 : }
9510 0 : break;
9511 : case IS_NULL:
9512 0 : zend_hash_del(ht, "", sizeof(""));
9513 0 : break;
9514 : default:
9515 0 : zend_error(E_WARNING, "Illegal offset type in unset");
9516 : break;
9517 : }
9518 :
9519 0 : break;
9520 : }
9521 : case IS_OBJECT:
9522 0 : if (!Z_OBJ_HT_P(*container)->unset_dimension) {
9523 0 : zend_error_noreturn(E_ERROR, "Cannot use object as array");
9524 : }
9525 : if (0) {
9526 : MAKE_REAL_ZVAL_PTR(offset);
9527 : }
9528 0 : Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
9529 : if (0) {
9530 : zval_ptr_dtor(&offset);
9531 : } else {
9532 :
9533 : }
9534 0 : break;
9535 : case IS_STRING:
9536 0 : zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
9537 : ZEND_VM_CONTINUE(); /* bailed out before */
9538 : default:
9539 :
9540 : break;
9541 : }
9542 : } else {
9543 :
9544 : }
9545 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9546 :
9547 0 : ZEND_VM_NEXT_OPCODE();
9548 : }
9549 :
9550 : static int ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9551 0 : {
9552 0 : zend_op *opline = EX(opline);
9553 : zend_free_op free_op1;
9554 0 : zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9555 0 : zval *offset = &opline->op2.u.constant;
9556 :
9557 0 : if (container) {
9558 : if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
9559 : SEPARATE_ZVAL_IF_NOT_REF(container);
9560 : }
9561 0 : if (Z_TYPE_PP(container) == IS_OBJECT) {
9562 : if (0) {
9563 : MAKE_REAL_ZVAL_PTR(offset);
9564 : }
9565 0 : Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
9566 : if (0) {
9567 : zval_ptr_dtor(&offset);
9568 : } else {
9569 :
9570 : }
9571 : } else {
9572 :
9573 : }
9574 : } else {
9575 :
9576 : }
9577 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9578 :
9579 0 : ZEND_VM_NEXT_OPCODE();
9580 : }
9581 :
9582 : static int zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
9583 0 : {
9584 0 : zend_op *opline = EX(opline);
9585 : zend_free_op free_op1;
9586 0 : zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9587 0 : zval **value = NULL;
9588 0 : int result = 0;
9589 : long index;
9590 :
9591 0 : if (container) {
9592 :
9593 0 : zval *offset = &opline->op2.u.constant;
9594 :
9595 0 : if (Z_TYPE_PP(container) == IS_ARRAY) {
9596 : HashTable *ht;
9597 0 : int isset = 0;
9598 :
9599 0 : ht = Z_ARRVAL_PP(container);
9600 :
9601 0 : switch (Z_TYPE_P(offset)) {
9602 : case IS_DOUBLE:
9603 0 : index = (long) Z_DVAL_P(offset);
9604 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
9605 0 : isset = 1;
9606 : }
9607 0 : break;
9608 : case IS_RESOURCE:
9609 : case IS_BOOL:
9610 : case IS_LONG:
9611 0 : index = Z_LVAL_P(offset);
9612 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
9613 0 : isset = 1;
9614 : }
9615 0 : break;
9616 : case IS_STRING:
9617 0 : if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
9618 0 : isset = 1;
9619 : }
9620 0 : break;
9621 : case IS_NULL:
9622 0 : if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
9623 0 : isset = 1;
9624 : }
9625 0 : break;
9626 : default:
9627 0 : zend_error(E_WARNING, "Illegal offset type in isset or empty");
9628 :
9629 : break;
9630 : }
9631 :
9632 0 : switch (opline->extended_value) {
9633 : case ZEND_ISSET:
9634 0 : if (isset && Z_TYPE_PP(value) == IS_NULL) {
9635 0 : result = 0;
9636 : } else {
9637 0 : result = isset;
9638 : }
9639 0 : break;
9640 : case ZEND_ISEMPTY:
9641 0 : if (!isset || !i_zend_is_true(*value)) {
9642 0 : result = 0;
9643 : } else {
9644 0 : result = 1;
9645 : }
9646 : break;
9647 : }
9648 :
9649 0 : } else if (Z_TYPE_PP(container) == IS_OBJECT) {
9650 : if (0) {
9651 : MAKE_REAL_ZVAL_PTR(offset);
9652 : }
9653 0 : if (prop_dim) {
9654 0 : result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
9655 : } else {
9656 0 : result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
9657 : }
9658 : if (0) {
9659 : zval_ptr_dtor(&offset);
9660 : } else {
9661 :
9662 : }
9663 0 : } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
9664 : zval tmp;
9665 :
9666 0 : if (Z_TYPE_P(offset) != IS_LONG) {
9667 0 : tmp = *offset;
9668 0 : zval_copy_ctor(&tmp);
9669 0 : convert_to_long(&tmp);
9670 0 : offset = &tmp;
9671 : }
9672 0 : if (Z_TYPE_P(offset) == IS_LONG) {
9673 0 : switch (opline->extended_value) {
9674 : case ZEND_ISSET:
9675 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
9676 0 : result = 1;
9677 : }
9678 0 : break;
9679 : case ZEND_ISEMPTY:
9680 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
9681 0 : result = 1;
9682 : }
9683 : break;
9684 : }
9685 : }
9686 :
9687 : } else {
9688 :
9689 : }
9690 : }
9691 :
9692 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
9693 :
9694 0 : switch (opline->extended_value) {
9695 : case ZEND_ISSET:
9696 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
9697 0 : break;
9698 : case ZEND_ISEMPTY:
9699 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
9700 : break;
9701 : }
9702 :
9703 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9704 :
9705 0 : ZEND_VM_NEXT_OPCODE();
9706 : }
9707 :
9708 : static int ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9709 0 : {
9710 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9711 : }
9712 :
9713 : static int ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9714 0 : {
9715 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9716 : }
9717 :
9718 : static int ZEND_ADD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9719 0 : {
9720 0 : zend_op *opline = EX(opline);
9721 : zend_free_op free_op1, free_op2;
9722 :
9723 0 : add_function(&EX_T(opline->result.u.var).tmp_var,
9724 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9725 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
9726 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9727 0 : zval_dtor(free_op2.var);
9728 0 : ZEND_VM_NEXT_OPCODE();
9729 : }
9730 :
9731 : static int ZEND_SUB_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9732 0 : {
9733 0 : zend_op *opline = EX(opline);
9734 : zend_free_op free_op1, free_op2;
9735 :
9736 0 : sub_function(&EX_T(opline->result.u.var).tmp_var,
9737 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9738 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
9739 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9740 0 : zval_dtor(free_op2.var);
9741 0 : ZEND_VM_NEXT_OPCODE();
9742 : }
9743 :
9744 : static int ZEND_MUL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9745 0 : {
9746 0 : zend_op *opline = EX(opline);
9747 : zend_free_op free_op1, free_op2;
9748 :
9749 0 : mul_function(&EX_T(opline->result.u.var).tmp_var,
9750 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9751 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
9752 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9753 0 : zval_dtor(free_op2.var);
9754 0 : ZEND_VM_NEXT_OPCODE();
9755 : }
9756 :
9757 : static int ZEND_DIV_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9758 0 : {
9759 0 : zend_op *opline = EX(opline);
9760 : zend_free_op free_op1, free_op2;
9761 :
9762 0 : div_function(&EX_T(opline->result.u.var).tmp_var,
9763 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9764 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
9765 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9766 0 : zval_dtor(free_op2.var);
9767 0 : ZEND_VM_NEXT_OPCODE();
9768 : }
9769 :
9770 : static int ZEND_MOD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9771 0 : {
9772 0 : zend_op *opline = EX(opline);
9773 : zend_free_op free_op1, free_op2;
9774 :
9775 0 : mod_function(&EX_T(opline->result.u.var).tmp_var,
9776 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9777 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
9778 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9779 0 : zval_dtor(free_op2.var);
9780 0 : ZEND_VM_NEXT_OPCODE();
9781 : }
9782 :
9783 : static int ZEND_SL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9784 0 : {
9785 0 : zend_op *opline = EX(opline);
9786 : zend_free_op free_op1, free_op2;
9787 :
9788 0 : shift_left_function(&EX_T(opline->result.u.var).tmp_var,
9789 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9790 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
9791 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9792 0 : zval_dtor(free_op2.var);
9793 0 : ZEND_VM_NEXT_OPCODE();
9794 : }
9795 :
9796 : static int ZEND_SR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9797 0 : {
9798 0 : zend_op *opline = EX(opline);
9799 : zend_free_op free_op1, free_op2;
9800 :
9801 0 : shift_right_function(&EX_T(opline->result.u.var).tmp_var,
9802 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9803 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
9804 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9805 0 : zval_dtor(free_op2.var);
9806 0 : ZEND_VM_NEXT_OPCODE();
9807 : }
9808 :
9809 : static int ZEND_CONCAT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9810 109 : {
9811 109 : zend_op *opline = EX(opline);
9812 : zend_free_op free_op1, free_op2;
9813 :
9814 109 : concat_function(&EX_T(opline->result.u.var).tmp_var,
9815 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9816 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
9817 109 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9818 109 : zval_dtor(free_op2.var);
9819 109 : ZEND_VM_NEXT_OPCODE();
9820 : }
9821 :
9822 : static int ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9823 0 : {
9824 0 : zend_op *opline = EX(opline);
9825 : zend_free_op free_op1, free_op2;
9826 :
9827 0 : is_identical_function(&EX_T(opline->result.u.var).tmp_var,
9828 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9829 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
9830 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9831 0 : zval_dtor(free_op2.var);
9832 0 : ZEND_VM_NEXT_OPCODE();
9833 : }
9834 :
9835 : static int ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9836 0 : {
9837 0 : zend_op *opline = EX(opline);
9838 : zend_free_op free_op1, free_op2;
9839 :
9840 0 : is_not_identical_function(&EX_T(opline->result.u.var).tmp_var,
9841 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9842 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
9843 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9844 0 : zval_dtor(free_op2.var);
9845 0 : ZEND_VM_NEXT_OPCODE();
9846 : }
9847 :
9848 : static int ZEND_IS_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9849 0 : {
9850 0 : zend_op *opline = EX(opline);
9851 : zend_free_op free_op1, free_op2;
9852 :
9853 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
9854 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9855 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
9856 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9857 0 : zval_dtor(free_op2.var);
9858 0 : ZEND_VM_NEXT_OPCODE();
9859 : }
9860 :
9861 : static int ZEND_IS_NOT_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9862 0 : {
9863 0 : zend_op *opline = EX(opline);
9864 : zend_free_op free_op1, free_op2;
9865 :
9866 0 : is_not_equal_function(&EX_T(opline->result.u.var).tmp_var,
9867 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9868 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
9869 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9870 0 : zval_dtor(free_op2.var);
9871 0 : ZEND_VM_NEXT_OPCODE();
9872 : }
9873 :
9874 : static int ZEND_IS_SMALLER_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9875 0 : {
9876 0 : zend_op *opline = EX(opline);
9877 : zend_free_op free_op1, free_op2;
9878 :
9879 0 : is_smaller_function(&EX_T(opline->result.u.var).tmp_var,
9880 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9881 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
9882 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9883 0 : zval_dtor(free_op2.var);
9884 0 : ZEND_VM_NEXT_OPCODE();
9885 : }
9886 :
9887 : static int ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9888 0 : {
9889 0 : zend_op *opline = EX(opline);
9890 : zend_free_op free_op1, free_op2;
9891 :
9892 0 : is_smaller_or_equal_function(&EX_T(opline->result.u.var).tmp_var,
9893 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9894 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
9895 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9896 0 : zval_dtor(free_op2.var);
9897 0 : ZEND_VM_NEXT_OPCODE();
9898 : }
9899 :
9900 : static int ZEND_BW_OR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9901 0 : {
9902 0 : zend_op *opline = EX(opline);
9903 : zend_free_op free_op1, free_op2;
9904 :
9905 0 : bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
9906 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9907 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
9908 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9909 0 : zval_dtor(free_op2.var);
9910 0 : ZEND_VM_NEXT_OPCODE();
9911 : }
9912 :
9913 : static int ZEND_BW_AND_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9914 0 : {
9915 0 : zend_op *opline = EX(opline);
9916 : zend_free_op free_op1, free_op2;
9917 :
9918 0 : bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
9919 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9920 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
9921 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9922 0 : zval_dtor(free_op2.var);
9923 0 : ZEND_VM_NEXT_OPCODE();
9924 : }
9925 :
9926 : static int ZEND_BW_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9927 0 : {
9928 0 : zend_op *opline = EX(opline);
9929 : zend_free_op free_op1, free_op2;
9930 :
9931 0 : bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
9932 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9933 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
9934 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9935 0 : zval_dtor(free_op2.var);
9936 0 : ZEND_VM_NEXT_OPCODE();
9937 : }
9938 :
9939 : static int ZEND_BOOL_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9940 0 : {
9941 0 : zend_op *opline = EX(opline);
9942 : zend_free_op free_op1, free_op2;
9943 :
9944 0 : boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
9945 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
9946 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
9947 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
9948 0 : zval_dtor(free_op2.var);
9949 0 : ZEND_VM_NEXT_OPCODE();
9950 : }
9951 :
9952 : static int zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
9953 0 : {
9954 0 : zend_op *opline = EX(opline);
9955 0 : zend_op *op_data = opline+1;
9956 : zend_free_op free_op1, free_op2, free_op_data1;
9957 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
9958 : zval *object;
9959 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
9960 0 : zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
9961 0 : znode *result = &opline->result;
9962 0 : zval **retval = &EX_T(result->u.var).var.ptr;
9963 0 : int have_get_ptr = 0;
9964 :
9965 0 : EX_T(result->u.var).var.ptr_ptr = NULL;
9966 0 : make_real_object(object_ptr TSRMLS_CC);
9967 0 : object = *object_ptr;
9968 :
9969 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
9970 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
9971 0 : zval_dtor(free_op2.var);
9972 0 : FREE_OP(free_op_data1);
9973 :
9974 0 : if (!RETURN_VALUE_UNUSED(result)) {
9975 0 : *retval = EG(uninitialized_zval_ptr);
9976 0 : PZVAL_LOCK(*retval);
9977 : }
9978 : } else {
9979 : /* here we are sure we are dealing with an object */
9980 : if (1) {
9981 0 : MAKE_REAL_ZVAL_PTR(property);
9982 : }
9983 :
9984 : /* here property is a string */
9985 0 : if (opline->extended_value == ZEND_ASSIGN_OBJ
9986 : && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
9987 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
9988 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
9989 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
9990 :
9991 0 : have_get_ptr = 1;
9992 0 : binary_op(*zptr, *zptr, value TSRMLS_CC);
9993 0 : if (!RETURN_VALUE_UNUSED(result)) {
9994 0 : *retval = *zptr;
9995 0 : PZVAL_LOCK(*retval);
9996 : }
9997 : }
9998 : }
9999 :
10000 0 : if (!have_get_ptr) {
10001 0 : zval *z = NULL;
10002 :
10003 0 : switch (opline->extended_value) {
10004 : case ZEND_ASSIGN_OBJ:
10005 0 : if (Z_OBJ_HT_P(object)->read_property) {
10006 0 : z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
10007 : }
10008 0 : break;
10009 : case ZEND_ASSIGN_DIM:
10010 0 : if (Z_OBJ_HT_P(object)->read_dimension) {
10011 0 : z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
10012 : }
10013 : break;
10014 : }
10015 0 : if (z) {
10016 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
10017 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
10018 :
10019 0 : if (z->refcount == 0) {
10020 0 : zval_dtor(z);
10021 0 : FREE_ZVAL(z);
10022 : }
10023 0 : z = value;
10024 : }
10025 0 : z->refcount++;
10026 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
10027 0 : binary_op(z, z, value TSRMLS_CC);
10028 0 : switch (opline->extended_value) {
10029 : case ZEND_ASSIGN_OBJ:
10030 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
10031 0 : break;
10032 : case ZEND_ASSIGN_DIM:
10033 0 : Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
10034 : break;
10035 : }
10036 0 : if (!RETURN_VALUE_UNUSED(result)) {
10037 0 : *retval = z;
10038 0 : PZVAL_LOCK(*retval);
10039 : }
10040 0 : zval_ptr_dtor(&z);
10041 : } else {
10042 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
10043 0 : if (!RETURN_VALUE_UNUSED(result)) {
10044 0 : *retval = EG(uninitialized_zval_ptr);
10045 0 : PZVAL_LOCK(*retval);
10046 : }
10047 : }
10048 : }
10049 :
10050 : if (1) {
10051 0 : zval_ptr_dtor(&property);
10052 : } else {
10053 : zval_dtor(free_op2.var);
10054 : }
10055 0 : FREE_OP(free_op_data1);
10056 : }
10057 :
10058 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10059 : /* assign_obj has two opcodes! */
10060 0 : ZEND_VM_INC_OPCODE();
10061 0 : ZEND_VM_NEXT_OPCODE();
10062 : }
10063 :
10064 : static int zend_binary_assign_op_helper_SPEC_VAR_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
10065 0 : {
10066 0 : zend_op *opline = EX(opline);
10067 : zend_free_op free_op1, free_op2, free_op_data2, free_op_data1;
10068 : zval **var_ptr;
10069 : zval *value;
10070 0 : zend_bool increment_opline = 0;
10071 :
10072 0 : switch (opline->extended_value) {
10073 : case ZEND_ASSIGN_OBJ:
10074 0 : return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10075 : break;
10076 : case ZEND_ASSIGN_DIM: {
10077 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10078 :
10079 0 : if (object_ptr && IS_VAR != IS_CV && !(free_op1.var != NULL)) {
10080 0 : (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
10081 : }
10082 :
10083 0 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
10084 0 : return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10085 : } else {
10086 0 : zend_op *op_data = opline+1;
10087 0 : zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
10088 :
10089 0 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 1, BP_VAR_RW TSRMLS_CC);
10090 0 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
10091 0 : var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
10092 0 : increment_opline = 1;
10093 : }
10094 : }
10095 0 : break;
10096 : default:
10097 0 : value = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
10098 0 : var_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10099 : /* do nothing */
10100 : break;
10101 : }
10102 :
10103 0 : if (!var_ptr) {
10104 0 : zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
10105 : }
10106 :
10107 0 : if (*var_ptr == EG(error_zval_ptr)) {
10108 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
10109 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
10110 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
10111 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
10112 : }
10113 0 : zval_dtor(free_op2.var);
10114 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10115 0 : if (increment_opline) {
10116 0 : ZEND_VM_INC_OPCODE();
10117 : }
10118 0 : ZEND_VM_NEXT_OPCODE();
10119 : }
10120 :
10121 0 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
10122 :
10123 0 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
10124 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
10125 : /* proxy object */
10126 0 : zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
10127 0 : objval->refcount++;
10128 0 : binary_op(objval, objval, value TSRMLS_CC);
10129 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
10130 0 : zval_ptr_dtor(&objval);
10131 : } else {
10132 0 : binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
10133 : }
10134 :
10135 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
10136 0 : EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
10137 0 : PZVAL_LOCK(*var_ptr);
10138 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
10139 : }
10140 0 : zval_dtor(free_op2.var);
10141 :
10142 0 : if (increment_opline) {
10143 0 : ZEND_VM_INC_OPCODE();
10144 0 : FREE_OP(free_op_data1);
10145 0 : FREE_OP_VAR_PTR(free_op_data2);
10146 : }
10147 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10148 0 : ZEND_VM_NEXT_OPCODE();
10149 : }
10150 :
10151 : static int ZEND_ASSIGN_ADD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10152 0 : {
10153 0 : return zend_binary_assign_op_helper_SPEC_VAR_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10154 : }
10155 :
10156 : static int ZEND_ASSIGN_SUB_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10157 0 : {
10158 0 : return zend_binary_assign_op_helper_SPEC_VAR_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10159 : }
10160 :
10161 : static int ZEND_ASSIGN_MUL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10162 0 : {
10163 0 : return zend_binary_assign_op_helper_SPEC_VAR_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10164 : }
10165 :
10166 : static int ZEND_ASSIGN_DIV_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10167 0 : {
10168 0 : return zend_binary_assign_op_helper_SPEC_VAR_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10169 : }
10170 :
10171 : static int ZEND_ASSIGN_MOD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10172 0 : {
10173 0 : return zend_binary_assign_op_helper_SPEC_VAR_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10174 : }
10175 :
10176 : static int ZEND_ASSIGN_SL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10177 0 : {
10178 0 : return zend_binary_assign_op_helper_SPEC_VAR_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10179 : }
10180 :
10181 : static int ZEND_ASSIGN_SR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10182 0 : {
10183 0 : return zend_binary_assign_op_helper_SPEC_VAR_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10184 : }
10185 :
10186 : static int ZEND_ASSIGN_CONCAT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10187 0 : {
10188 0 : return zend_binary_assign_op_helper_SPEC_VAR_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10189 : }
10190 :
10191 : static int ZEND_ASSIGN_BW_OR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10192 0 : {
10193 0 : return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10194 : }
10195 :
10196 : static int ZEND_ASSIGN_BW_AND_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10197 0 : {
10198 0 : return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10199 : }
10200 :
10201 : static int ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10202 0 : {
10203 0 : return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10204 : }
10205 :
10206 : static int zend_pre_incdec_property_helper_SPEC_VAR_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
10207 0 : {
10208 0 : zend_op *opline = EX(opline);
10209 : zend_free_op free_op1, free_op2;
10210 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10211 : zval *object;
10212 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
10213 0 : zval **retval = &EX_T(opline->result.u.var).var.ptr;
10214 0 : int have_get_ptr = 0;
10215 :
10216 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
10217 0 : object = *object_ptr;
10218 :
10219 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
10220 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
10221 0 : zval_dtor(free_op2.var);
10222 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
10223 0 : *retval = EG(uninitialized_zval_ptr);
10224 0 : PZVAL_LOCK(*retval);
10225 : }
10226 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10227 0 : ZEND_VM_NEXT_OPCODE();
10228 : }
10229 :
10230 : /* here we are sure we are dealing with an object */
10231 :
10232 : if (1) {
10233 0 : MAKE_REAL_ZVAL_PTR(property);
10234 : }
10235 :
10236 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
10237 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
10238 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
10239 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
10240 :
10241 0 : have_get_ptr = 1;
10242 0 : incdec_op(*zptr);
10243 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
10244 0 : *retval = *zptr;
10245 0 : PZVAL_LOCK(*retval);
10246 : }
10247 : }
10248 : }
10249 :
10250 0 : if (!have_get_ptr) {
10251 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
10252 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
10253 :
10254 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
10255 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
10256 :
10257 0 : if (z->refcount == 0) {
10258 0 : zval_dtor(z);
10259 0 : FREE_ZVAL(z);
10260 : }
10261 0 : z = value;
10262 : }
10263 0 : z->refcount++;
10264 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
10265 0 : incdec_op(z);
10266 0 : *retval = z;
10267 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
10268 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
10269 0 : zval_ptr_dtor(&z);
10270 : } else {
10271 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
10272 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
10273 0 : *retval = EG(uninitialized_zval_ptr);
10274 0 : PZVAL_LOCK(*retval);
10275 : }
10276 : }
10277 : }
10278 :
10279 : if (1) {
10280 0 : zval_ptr_dtor(&property);
10281 : } else {
10282 : zval_dtor(free_op2.var);
10283 : }
10284 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10285 0 : ZEND_VM_NEXT_OPCODE();
10286 : }
10287 :
10288 : static int ZEND_PRE_INC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10289 0 : {
10290 0 : return zend_pre_incdec_property_helper_SPEC_VAR_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10291 : }
10292 :
10293 : static int ZEND_PRE_DEC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10294 0 : {
10295 0 : return zend_pre_incdec_property_helper_SPEC_VAR_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10296 : }
10297 :
10298 : static int zend_post_incdec_property_helper_SPEC_VAR_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
10299 0 : {
10300 0 : zend_op *opline = EX(opline);
10301 : zend_free_op free_op1, free_op2;
10302 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10303 : zval *object;
10304 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
10305 0 : zval *retval = &EX_T(opline->result.u.var).tmp_var;
10306 0 : int have_get_ptr = 0;
10307 :
10308 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
10309 0 : object = *object_ptr;
10310 :
10311 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
10312 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
10313 0 : zval_dtor(free_op2.var);
10314 0 : *retval = *EG(uninitialized_zval_ptr);
10315 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10316 0 : ZEND_VM_NEXT_OPCODE();
10317 : }
10318 :
10319 : /* here we are sure we are dealing with an object */
10320 :
10321 : if (1) {
10322 0 : MAKE_REAL_ZVAL_PTR(property);
10323 : }
10324 :
10325 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
10326 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
10327 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
10328 0 : have_get_ptr = 1;
10329 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
10330 :
10331 0 : *retval = **zptr;
10332 0 : zendi_zval_copy_ctor(*retval);
10333 :
10334 0 : incdec_op(*zptr);
10335 :
10336 : }
10337 : }
10338 :
10339 0 : if (!have_get_ptr) {
10340 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
10341 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
10342 : zval *z_copy;
10343 :
10344 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
10345 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
10346 :
10347 0 : if (z->refcount == 0) {
10348 0 : zval_dtor(z);
10349 0 : FREE_ZVAL(z);
10350 : }
10351 0 : z = value;
10352 : }
10353 0 : *retval = *z;
10354 0 : zendi_zval_copy_ctor(*retval);
10355 0 : ALLOC_ZVAL(z_copy);
10356 0 : *z_copy = *z;
10357 0 : zendi_zval_copy_ctor(*z_copy);
10358 0 : INIT_PZVAL(z_copy);
10359 0 : incdec_op(z_copy);
10360 0 : z->refcount++;
10361 0 : Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
10362 0 : zval_ptr_dtor(&z_copy);
10363 0 : zval_ptr_dtor(&z);
10364 : } else {
10365 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
10366 0 : *retval = *EG(uninitialized_zval_ptr);
10367 : }
10368 : }
10369 :
10370 : if (1) {
10371 0 : zval_ptr_dtor(&property);
10372 : } else {
10373 : zval_dtor(free_op2.var);
10374 : }
10375 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10376 0 : ZEND_VM_NEXT_OPCODE();
10377 : }
10378 :
10379 : static int ZEND_POST_INC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10380 0 : {
10381 0 : return zend_post_incdec_property_helper_SPEC_VAR_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10382 : }
10383 :
10384 : static int ZEND_POST_DEC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10385 0 : {
10386 0 : return zend_post_incdec_property_helper_SPEC_VAR_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10387 : }
10388 :
10389 : static int ZEND_FETCH_DIM_R_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10390 0 : {
10391 0 : zend_op *opline = EX(opline);
10392 : zend_free_op free_op1, free_op2;
10393 0 : zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
10394 :
10395 0 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK &&
10396 : IS_VAR != IS_CV &&
10397 : EX_T(opline->op1.u.var).var.ptr_ptr) {
10398 0 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
10399 : }
10400 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 1, BP_VAR_R TSRMLS_CC);
10401 0 : zval_dtor(free_op2.var);
10402 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10403 0 : ZEND_VM_NEXT_OPCODE();
10404 : }
10405 :
10406 : static int ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10407 0 : {
10408 0 : zend_op *opline = EX(opline);
10409 : zend_free_op free_op1, free_op2;
10410 0 : zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
10411 :
10412 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 1, BP_VAR_W TSRMLS_CC);
10413 0 : zval_dtor(free_op2.var);
10414 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
10415 : READY_TO_DESTROY(free_op1.var) &&
10416 : !RETURN_VALUE_UNUSED(&opline->result)) {
10417 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
10418 : }
10419 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10420 0 : ZEND_VM_NEXT_OPCODE();
10421 : }
10422 :
10423 : static int ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10424 0 : {
10425 0 : zend_op *opline = EX(opline);
10426 : zend_free_op free_op1, free_op2;
10427 0 : zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
10428 :
10429 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 1, BP_VAR_RW TSRMLS_CC);
10430 0 : zval_dtor(free_op2.var);
10431 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
10432 : READY_TO_DESTROY(free_op1.var) &&
10433 : !RETURN_VALUE_UNUSED(&opline->result)) {
10434 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
10435 : }
10436 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10437 0 : ZEND_VM_NEXT_OPCODE();
10438 : }
10439 :
10440 : static int ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10441 0 : {
10442 0 : zend_op *opline = EX(opline);
10443 : zend_free_op free_op1, free_op2;
10444 0 : zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
10445 :
10446 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 1, BP_VAR_IS TSRMLS_CC);
10447 0 : zval_dtor(free_op2.var);
10448 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10449 0 : ZEND_VM_NEXT_OPCODE();
10450 : }
10451 :
10452 : static int ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10453 0 : {
10454 0 : zend_op *opline = EX(opline);
10455 : zend_free_op free_op1, free_op2;
10456 0 : int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
10457 : zval *dim;
10458 :
10459 : if (IS_TMP_VAR == IS_UNUSED && type == BP_VAR_R) {
10460 : zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
10461 : }
10462 0 : dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
10463 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 1, type TSRMLS_CC);
10464 0 : zval_dtor(free_op2.var);
10465 0 : if (IS_VAR == IS_VAR && type == BP_VAR_W && (free_op1.var != NULL) &&
10466 : READY_TO_DESTROY(free_op1.var) &&
10467 : !RETURN_VALUE_UNUSED(&opline->result)) {
10468 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
10469 : }
10470 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10471 0 : ZEND_VM_NEXT_OPCODE();
10472 : }
10473 :
10474 : static int ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10475 0 : {
10476 0 : zend_op *opline = EX(opline);
10477 : zend_free_op free_op1, free_op2;
10478 0 : zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10479 0 : zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
10480 :
10481 : /* Not needed in DIM_UNSET
10482 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
10483 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
10484 : }
10485 : */
10486 : if (IS_VAR == IS_CV) {
10487 : if (container != &EG(uninitialized_zval_ptr)) {
10488 : SEPARATE_ZVAL_IF_NOT_REF(container);
10489 : }
10490 : }
10491 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, dim, 1, BP_VAR_UNSET TSRMLS_CC);
10492 0 : zval_dtor(free_op2.var);
10493 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
10494 : READY_TO_DESTROY(free_op1.var) &&
10495 : !RETURN_VALUE_UNUSED(&opline->result)) {
10496 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
10497 : }
10498 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10499 0 : if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
10500 0 : zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
10501 : } else {
10502 : zend_free_op free_res;
10503 :
10504 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
10505 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
10506 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
10507 : }
10508 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
10509 0 : FREE_OP_VAR_PTR(free_res);
10510 : }
10511 0 : ZEND_VM_NEXT_OPCODE();
10512 : }
10513 :
10514 : static int zend_fetch_property_address_read_helper_SPEC_VAR_TMP(int type, ZEND_OPCODE_HANDLER_ARGS)
10515 0 : {
10516 0 : zend_op *opline = EX(opline);
10517 : zval *container;
10518 : zval **retval;
10519 : zend_free_op free_op1;
10520 :
10521 0 : retval = &EX_T(opline->result.u.var).var.ptr;
10522 0 : EX_T(opline->result.u.var).var.ptr_ptr = retval;
10523 :
10524 0 : container = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10525 :
10526 0 : if (container == EG(error_zval_ptr)) {
10527 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
10528 0 : *retval = EG(error_zval_ptr);
10529 0 : PZVAL_LOCK(*retval);
10530 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
10531 : }
10532 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10533 0 : ZEND_VM_NEXT_OPCODE();
10534 : }
10535 :
10536 :
10537 0 : if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
10538 0 : if (type != BP_VAR_IS) {
10539 0 : zend_error(E_NOTICE, "Trying to get property of non-object");
10540 : }
10541 0 : *retval = EG(uninitialized_zval_ptr);
10542 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
10543 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
10544 : } else {
10545 : zend_free_op free_op2;
10546 0 : zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
10547 :
10548 : if (1) {
10549 0 : MAKE_REAL_ZVAL_PTR(offset);
10550 : }
10551 :
10552 : /* here we are sure we are dealing with an object */
10553 0 : *retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
10554 :
10555 0 : if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
10556 0 : zval_dtor(*retval);
10557 0 : FREE_ZVAL(*retval);
10558 : } else {
10559 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
10560 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
10561 : }
10562 :
10563 : if (1) {
10564 0 : zval_ptr_dtor(&offset);
10565 : } else {
10566 : zval_dtor(free_op2.var);
10567 : }
10568 : }
10569 :
10570 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10571 0 : ZEND_VM_NEXT_OPCODE();
10572 : }
10573 :
10574 : static int ZEND_FETCH_OBJ_R_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10575 0 : {
10576 0 : return zend_fetch_property_address_read_helper_SPEC_VAR_TMP(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10577 : }
10578 :
10579 : static int ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10580 0 : {
10581 0 : zend_op *opline = EX(opline);
10582 : zend_free_op free_op1, free_op2;
10583 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
10584 :
10585 0 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_VAR != IS_CV) {
10586 0 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
10587 0 : EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
10588 : }
10589 :
10590 : if (1) {
10591 0 : MAKE_REAL_ZVAL_PTR(property);
10592 : }
10593 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
10594 : if (1) {
10595 0 : zval_ptr_dtor(&property);
10596 : } else {
10597 : zval_dtor(free_op2.var);
10598 : }
10599 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
10600 : READY_TO_DESTROY(free_op1.var) &&
10601 : !RETURN_VALUE_UNUSED(&opline->result)) {
10602 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
10603 : }
10604 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10605 0 : ZEND_VM_NEXT_OPCODE();
10606 : }
10607 :
10608 : static int ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10609 0 : {
10610 0 : zend_op *opline = EX(opline);
10611 : zend_free_op free_op1, free_op2;
10612 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
10613 :
10614 : if (1) {
10615 0 : MAKE_REAL_ZVAL_PTR(property);
10616 : }
10617 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_RW TSRMLS_CC);
10618 : if (1) {
10619 0 : zval_ptr_dtor(&property);
10620 : } else {
10621 : zval_dtor(free_op2.var);
10622 : }
10623 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
10624 : READY_TO_DESTROY(free_op1.var) &&
10625 : !RETURN_VALUE_UNUSED(&opline->result)) {
10626 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
10627 : }
10628 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10629 0 : ZEND_VM_NEXT_OPCODE();
10630 : }
10631 :
10632 : static int ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10633 0 : {
10634 0 : return zend_fetch_property_address_read_helper_SPEC_VAR_TMP(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10635 : }
10636 :
10637 : static int ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10638 0 : {
10639 0 : zend_op *opline = EX(opline);
10640 :
10641 0 : if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
10642 : /* Behave like FETCH_OBJ_W */
10643 : zend_free_op free_op1, free_op2;
10644 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
10645 :
10646 : if (1) {
10647 0 : MAKE_REAL_ZVAL_PTR(property);
10648 : }
10649 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
10650 : if (1) {
10651 0 : zval_ptr_dtor(&property);
10652 : } else {
10653 : zval_dtor(free_op2.var);
10654 : }
10655 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
10656 : READY_TO_DESTROY(free_op1.var) &&
10657 : !RETURN_VALUE_UNUSED(&opline->result)) {
10658 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
10659 : }
10660 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10661 0 : ZEND_VM_NEXT_OPCODE();
10662 : } else {
10663 0 : return zend_fetch_property_address_read_helper_SPEC_VAR_TMP(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10664 : }
10665 : }
10666 :
10667 : static int ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10668 0 : {
10669 0 : zend_op *opline = EX(opline);
10670 : zend_free_op free_op1, free_op2, free_res;
10671 0 : zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10672 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
10673 :
10674 : if (IS_VAR == IS_CV) {
10675 : if (container != &EG(uninitialized_zval_ptr)) {
10676 : SEPARATE_ZVAL_IF_NOT_REF(container);
10677 : }
10678 : }
10679 : if (1) {
10680 0 : MAKE_REAL_ZVAL_PTR(property);
10681 : }
10682 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
10683 : if (1) {
10684 0 : zval_ptr_dtor(&property);
10685 : } else {
10686 : zval_dtor(free_op2.var);
10687 : }
10688 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
10689 : READY_TO_DESTROY(free_op1.var) &&
10690 : !RETURN_VALUE_UNUSED(&opline->result)) {
10691 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
10692 : }
10693 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10694 :
10695 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
10696 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
10697 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
10698 : }
10699 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
10700 0 : FREE_OP_VAR_PTR(free_res);
10701 0 : ZEND_VM_NEXT_OPCODE();
10702 : }
10703 :
10704 : static int ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10705 0 : {
10706 0 : zend_op *opline = EX(opline);
10707 0 : zend_op *op_data = opline+1;
10708 : zend_free_op free_op1;
10709 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10710 :
10711 0 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
10712 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10713 : /* assign_obj has two opcodes! */
10714 0 : ZEND_VM_INC_OPCODE();
10715 0 : ZEND_VM_NEXT_OPCODE();
10716 : }
10717 :
10718 : static int ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10719 0 : {
10720 0 : zend_op *opline = EX(opline);
10721 0 : zend_op *op_data = opline+1;
10722 : zend_free_op free_op1;
10723 : zval **object_ptr;
10724 :
10725 0 : if (IS_VAR == IS_CV || EX_T(opline->op1.u.var).var.ptr_ptr) {
10726 : /* not an array offset */
10727 0 : object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10728 : } else {
10729 0 : object_ptr = NULL;
10730 : }
10731 :
10732 0 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
10733 0 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
10734 : } else {
10735 : zend_free_op free_op2, free_op_data1;
10736 : zval *value;
10737 0 : zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
10738 :
10739 0 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 1, BP_VAR_W TSRMLS_CC);
10740 0 : zval_dtor(free_op2.var);
10741 :
10742 0 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
10743 0 : zend_assign_to_variable(&opline->result, &op_data->op2, &op_data->op1, value, (IS_TMP_FREE(free_op_data1)?IS_TMP_VAR:op_data->op1.op_type), EX(Ts) TSRMLS_CC);
10744 0 : FREE_OP_IF_VAR(free_op_data1);
10745 : }
10746 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10747 : /* assign_dim has two opcodes! */
10748 0 : ZEND_VM_INC_OPCODE();
10749 0 : ZEND_VM_NEXT_OPCODE();
10750 : }
10751 :
10752 : static int ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10753 1 : {
10754 1 : zend_op *opline = EX(opline);
10755 : zend_free_op free_op2;
10756 1 : zval *value = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
10757 :
10758 1 : zend_assign_to_variable(&opline->result, &opline->op1, &opline->op2, value, (1?IS_TMP_VAR:IS_TMP_VAR), EX(Ts) TSRMLS_CC);
10759 : /* zend_assign_to_variable() always takes care of op2, never free it! */
10760 :
10761 1 : ZEND_VM_NEXT_OPCODE();
10762 : }
10763 :
10764 : static int ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10765 0 : {
10766 0 : zend_op *opline = EX(opline);
10767 : zval *function_name;
10768 : char *function_name_strval;
10769 : int function_name_strlen;
10770 : zend_free_op free_op1, free_op2;
10771 :
10772 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
10773 :
10774 0 : function_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
10775 :
10776 0 : if (Z_TYPE_P(function_name)!=IS_STRING) {
10777 0 : zend_error_noreturn(E_ERROR, "Method name must be a string");
10778 : }
10779 :
10780 0 : function_name_strval = Z_STRVAL_P(function_name);
10781 0 : function_name_strlen = Z_STRLEN_P(function_name);
10782 :
10783 0 : EX(object) = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10784 :
10785 0 : if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
10786 0 : if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
10787 0 : zend_error_noreturn(E_ERROR, "Object does not support method calls");
10788 : }
10789 :
10790 : /* First, locate the function. */
10791 0 : EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
10792 0 : if (!EX(fbc)) {
10793 0 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
10794 : }
10795 : } else {
10796 0 : zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
10797 : }
10798 :
10799 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
10800 0 : EX(object) = NULL;
10801 : } else {
10802 0 : if (!PZVAL_IS_REF(EX(object))) {
10803 0 : EX(object)->refcount++; /* For $this pointer */
10804 : } else {
10805 : zval *this_ptr;
10806 0 : ALLOC_ZVAL(this_ptr);
10807 0 : INIT_PZVAL_COPY(this_ptr, EX(object));
10808 0 : zval_copy_ctor(this_ptr);
10809 0 : EX(object) = this_ptr;
10810 : }
10811 : }
10812 :
10813 0 : zval_dtor(free_op2.var);
10814 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10815 :
10816 0 : ZEND_VM_NEXT_OPCODE();
10817 : }
10818 :
10819 : static int ZEND_CASE_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10820 0 : {
10821 0 : zend_op *opline = EX(opline);
10822 0 : int switch_expr_is_overloaded=0;
10823 : zend_free_op free_op1, free_op2;
10824 :
10825 : if (IS_VAR==IS_VAR) {
10826 0 : if (EX_T(opline->op1.u.var).var.ptr_ptr) {
10827 0 : PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
10828 : } else {
10829 0 : switch_expr_is_overloaded = 1;
10830 0 : EX_T(opline->op1.u.var).str_offset.str->refcount++;
10831 : }
10832 : }
10833 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
10834 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
10835 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
10836 :
10837 0 : zval_dtor(free_op2.var);
10838 0 : if (switch_expr_is_overloaded) {
10839 : /* We only free op1 if this is a string offset,
10840 : * Since if it is a TMP_VAR, it'll be reused by
10841 : * other CASE opcodes (whereas string offsets
10842 : * are allocated at each get_zval_ptr())
10843 : */
10844 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10845 0 : EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
10846 0 : AI_USE_PTR(EX_T(opline->op1.u.var).var);
10847 : }
10848 0 : ZEND_VM_NEXT_OPCODE();
10849 : }
10850 :
10851 : static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10852 0 : {
10853 0 : zend_op *opline = EX(opline);
10854 : zend_free_op free_op1, free_op2;
10855 0 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
10856 : zval *expr_ptr;
10857 0 : zval *offset=_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
10858 :
10859 : #if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
10860 0 : zval **expr_ptr_ptr = NULL;
10861 :
10862 0 : if (opline->extended_value) {
10863 0 : expr_ptr_ptr=_get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10864 0 : expr_ptr = *expr_ptr_ptr;
10865 : } else {
10866 0 : expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10867 : }
10868 : #else
10869 : expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10870 : #endif
10871 :
10872 : if (0) { /* temporary variable */
10873 : zval *new_expr;
10874 :
10875 : ALLOC_ZVAL(new_expr);
10876 : INIT_PZVAL_COPY(new_expr, expr_ptr);
10877 : expr_ptr = new_expr;
10878 : } else {
10879 : #if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
10880 0 : if (opline->extended_value) {
10881 0 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
10882 0 : expr_ptr = *expr_ptr_ptr;
10883 0 : expr_ptr->refcount++;
10884 : } else
10885 : #endif
10886 0 : if (PZVAL_IS_REF(expr_ptr)) {
10887 : zval *new_expr;
10888 :
10889 0 : ALLOC_ZVAL(new_expr);
10890 0 : INIT_PZVAL_COPY(new_expr, expr_ptr);
10891 0 : expr_ptr = new_expr;
10892 0 : zendi_zval_copy_ctor(*expr_ptr);
10893 : } else {
10894 0 : expr_ptr->refcount++;
10895 : }
10896 : }
10897 0 : if (offset) {
10898 0 : switch (Z_TYPE_P(offset)) {
10899 : case IS_DOUBLE:
10900 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
10901 0 : break;
10902 : case IS_LONG:
10903 : case IS_BOOL:
10904 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
10905 0 : break;
10906 : case IS_STRING:
10907 0 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
10908 0 : break;
10909 : case IS_NULL:
10910 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
10911 0 : break;
10912 : default:
10913 0 : zend_error(E_WARNING, "Illegal offset type");
10914 0 : zval_ptr_dtor(&expr_ptr);
10915 : /* do nothing */
10916 : break;
10917 : }
10918 0 : zval_dtor(free_op2.var);
10919 : } else {
10920 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
10921 : }
10922 0 : if (opline->extended_value) {
10923 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10924 : } else {
10925 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
10926 : }
10927 0 : ZEND_VM_NEXT_OPCODE();
10928 : }
10929 :
10930 : static int ZEND_INIT_ARRAY_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10931 0 : {
10932 0 : zend_op *opline = EX(opline);
10933 :
10934 0 : array_init(&EX_T(opline->result.u.var).tmp_var);
10935 : if (IS_VAR == IS_UNUSED) {
10936 : ZEND_VM_NEXT_OPCODE();
10937 : #if 0 || IS_VAR != IS_UNUSED
10938 : } else {
10939 0 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10940 : #endif
10941 : }
10942 : }
10943 :
10944 : static int ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10945 0 : {
10946 0 : zend_op *opline = EX(opline);
10947 : zend_free_op free_op1, free_op2;
10948 0 : zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
10949 0 : zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
10950 : long index;
10951 :
10952 0 : if (container) {
10953 : if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
10954 : SEPARATE_ZVAL_IF_NOT_REF(container);
10955 : }
10956 0 : switch (Z_TYPE_PP(container)) {
10957 : case IS_ARRAY: {
10958 0 : HashTable *ht = Z_ARRVAL_PP(container);
10959 :
10960 0 : switch (Z_TYPE_P(offset)) {
10961 : case IS_DOUBLE:
10962 0 : index = (long) Z_DVAL_P(offset);
10963 0 : zend_hash_index_del(ht, index);
10964 0 : break;
10965 : case IS_RESOURCE:
10966 : case IS_BOOL:
10967 : case IS_LONG:
10968 0 : index = Z_LVAL_P(offset);
10969 0 : zend_hash_index_del(ht, index);
10970 0 : break;
10971 : case IS_STRING:
10972 : if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
10973 : offset->refcount++;
10974 : }
10975 0 : if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
10976 : ht == &EG(symbol_table)) {
10977 : zend_execute_data *ex;
10978 0 : ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
10979 :
10980 0 : for (ex = execute_data; ex; ex = ex->prev_execute_data) {
10981 0 : if (ex->op_array && ex->symbol_table == ht) {
10982 : int i;
10983 :
10984 0 : for (i = 0; i < ex->op_array->last_var; i++) {
10985 0 : if (ex->op_array->vars[i].hash_value == hash_value &&
10986 : ex->op_array->vars[i].name_len == offset->value.str.len &&
10987 : !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
10988 0 : ex->CVs[i] = NULL;
10989 0 : break;
10990 : }
10991 : }
10992 : }
10993 : }
10994 : }
10995 : if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
10996 : zval_ptr_dtor(&offset);
10997 : }
10998 0 : break;
10999 : case IS_NULL:
11000 0 : zend_hash_del(ht, "", sizeof(""));
11001 0 : break;
11002 : default:
11003 0 : zend_error(E_WARNING, "Illegal offset type in unset");
11004 : break;
11005 : }
11006 0 : zval_dtor(free_op2.var);
11007 0 : break;
11008 : }
11009 : case IS_OBJECT:
11010 0 : if (!Z_OBJ_HT_P(*container)->unset_dimension) {
11011 0 : zend_error_noreturn(E_ERROR, "Cannot use object as array");
11012 : }
11013 : if (1) {
11014 0 : MAKE_REAL_ZVAL_PTR(offset);
11015 : }
11016 0 : Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
11017 : if (1) {
11018 0 : zval_ptr_dtor(&offset);
11019 : } else {
11020 : zval_dtor(free_op2.var);
11021 : }
11022 0 : break;
11023 : case IS_STRING:
11024 0 : zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
11025 : ZEND_VM_CONTINUE(); /* bailed out before */
11026 : default:
11027 0 : zval_dtor(free_op2.var);
11028 : break;
11029 : }
11030 : } else {
11031 0 : zval_dtor(free_op2.var);
11032 : }
11033 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11034 :
11035 0 : ZEND_VM_NEXT_OPCODE();
11036 : }
11037 :
11038 : static int ZEND_UNSET_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11039 0 : {
11040 0 : zend_op *opline = EX(opline);
11041 : zend_free_op free_op1, free_op2;
11042 0 : zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11043 0 : zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11044 :
11045 0 : if (container) {
11046 : if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
11047 : SEPARATE_ZVAL_IF_NOT_REF(container);
11048 : }
11049 0 : if (Z_TYPE_PP(container) == IS_OBJECT) {
11050 : if (1) {
11051 0 : MAKE_REAL_ZVAL_PTR(offset);
11052 : }
11053 0 : Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
11054 : if (1) {
11055 0 : zval_ptr_dtor(&offset);
11056 : } else {
11057 : zval_dtor(free_op2.var);
11058 : }
11059 : } else {
11060 0 : zval_dtor(free_op2.var);
11061 : }
11062 : } else {
11063 0 : zval_dtor(free_op2.var);
11064 : }
11065 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11066 :
11067 0 : ZEND_VM_NEXT_OPCODE();
11068 : }
11069 :
11070 : static int zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
11071 0 : {
11072 0 : zend_op *opline = EX(opline);
11073 : zend_free_op free_op1;
11074 0 : zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11075 0 : zval **value = NULL;
11076 0 : int result = 0;
11077 : long index;
11078 :
11079 0 : if (container) {
11080 : zend_free_op free_op2;
11081 0 : zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11082 :
11083 0 : if (Z_TYPE_PP(container) == IS_ARRAY) {
11084 : HashTable *ht;
11085 0 : int isset = 0;
11086 :
11087 0 : ht = Z_ARRVAL_PP(container);
11088 :
11089 0 : switch (Z_TYPE_P(offset)) {
11090 : case IS_DOUBLE:
11091 0 : index = (long) Z_DVAL_P(offset);
11092 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
11093 0 : isset = 1;
11094 : }
11095 0 : break;
11096 : case IS_RESOURCE:
11097 : case IS_BOOL:
11098 : case IS_LONG:
11099 0 : index = Z_LVAL_P(offset);
11100 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
11101 0 : isset = 1;
11102 : }
11103 0 : break;
11104 : case IS_STRING:
11105 0 : if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
11106 0 : isset = 1;
11107 : }
11108 0 : break;
11109 : case IS_NULL:
11110 0 : if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
11111 0 : isset = 1;
11112 : }
11113 0 : break;
11114 : default:
11115 0 : zend_error(E_WARNING, "Illegal offset type in isset or empty");
11116 :
11117 : break;
11118 : }
11119 :
11120 0 : switch (opline->extended_value) {
11121 : case ZEND_ISSET:
11122 0 : if (isset && Z_TYPE_PP(value) == IS_NULL) {
11123 0 : result = 0;
11124 : } else {
11125 0 : result = isset;
11126 : }
11127 0 : break;
11128 : case ZEND_ISEMPTY:
11129 0 : if (!isset || !i_zend_is_true(*value)) {
11130 0 : result = 0;
11131 : } else {
11132 0 : result = 1;
11133 : }
11134 : break;
11135 : }
11136 0 : zval_dtor(free_op2.var);
11137 0 : } else if (Z_TYPE_PP(container) == IS_OBJECT) {
11138 : if (1) {
11139 0 : MAKE_REAL_ZVAL_PTR(offset);
11140 : }
11141 0 : if (prop_dim) {
11142 0 : result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
11143 : } else {
11144 0 : result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
11145 : }
11146 : if (1) {
11147 0 : zval_ptr_dtor(&offset);
11148 : } else {
11149 : zval_dtor(free_op2.var);
11150 : }
11151 0 : } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
11152 : zval tmp;
11153 :
11154 0 : if (Z_TYPE_P(offset) != IS_LONG) {
11155 0 : tmp = *offset;
11156 0 : zval_copy_ctor(&tmp);
11157 0 : convert_to_long(&tmp);
11158 0 : offset = &tmp;
11159 : }
11160 0 : if (Z_TYPE_P(offset) == IS_LONG) {
11161 0 : switch (opline->extended_value) {
11162 : case ZEND_ISSET:
11163 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
11164 0 : result = 1;
11165 : }
11166 0 : break;
11167 : case ZEND_ISEMPTY:
11168 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
11169 0 : result = 1;
11170 : }
11171 : break;
11172 : }
11173 : }
11174 0 : zval_dtor(free_op2.var);
11175 : } else {
11176 0 : zval_dtor(free_op2.var);
11177 : }
11178 : }
11179 :
11180 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
11181 :
11182 0 : switch (opline->extended_value) {
11183 : case ZEND_ISSET:
11184 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
11185 0 : break;
11186 : case ZEND_ISEMPTY:
11187 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
11188 : break;
11189 : }
11190 :
11191 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11192 :
11193 0 : ZEND_VM_NEXT_OPCODE();
11194 : }
11195 :
11196 : static int ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11197 0 : {
11198 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11199 : }
11200 :
11201 : static int ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11202 0 : {
11203 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11204 : }
11205 :
11206 : static int ZEND_ADD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11207 220 : {
11208 220 : zend_op *opline = EX(opline);
11209 : zend_free_op free_op1, free_op2;
11210 :
11211 220 : add_function(&EX_T(opline->result.u.var).tmp_var,
11212 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11213 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11214 220 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11215 220 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11216 220 : ZEND_VM_NEXT_OPCODE();
11217 : }
11218 :
11219 : static int ZEND_SUB_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11220 0 : {
11221 0 : zend_op *opline = EX(opline);
11222 : zend_free_op free_op1, free_op2;
11223 :
11224 0 : sub_function(&EX_T(opline->result.u.var).tmp_var,
11225 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11226 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11227 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11228 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11229 0 : ZEND_VM_NEXT_OPCODE();
11230 : }
11231 :
11232 : static int ZEND_MUL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11233 0 : {
11234 0 : zend_op *opline = EX(opline);
11235 : zend_free_op free_op1, free_op2;
11236 :
11237 0 : mul_function(&EX_T(opline->result.u.var).tmp_var,
11238 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11239 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11240 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11241 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11242 0 : ZEND_VM_NEXT_OPCODE();
11243 : }
11244 :
11245 : static int ZEND_DIV_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11246 0 : {
11247 0 : zend_op *opline = EX(opline);
11248 : zend_free_op free_op1, free_op2;
11249 :
11250 0 : div_function(&EX_T(opline->result.u.var).tmp_var,
11251 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11252 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11253 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11254 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11255 0 : ZEND_VM_NEXT_OPCODE();
11256 : }
11257 :
11258 : static int ZEND_MOD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11259 0 : {
11260 0 : zend_op *opline = EX(opline);
11261 : zend_free_op free_op1, free_op2;
11262 :
11263 0 : mod_function(&EX_T(opline->result.u.var).tmp_var,
11264 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11265 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11266 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11267 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11268 0 : ZEND_VM_NEXT_OPCODE();
11269 : }
11270 :
11271 : static int ZEND_SL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11272 0 : {
11273 0 : zend_op *opline = EX(opline);
11274 : zend_free_op free_op1, free_op2;
11275 :
11276 0 : shift_left_function(&EX_T(opline->result.u.var).tmp_var,
11277 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11278 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11279 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11280 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11281 0 : ZEND_VM_NEXT_OPCODE();
11282 : }
11283 :
11284 : static int ZEND_SR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11285 0 : {
11286 0 : zend_op *opline = EX(opline);
11287 : zend_free_op free_op1, free_op2;
11288 :
11289 0 : shift_right_function(&EX_T(opline->result.u.var).tmp_var,
11290 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11291 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11292 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11293 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11294 0 : ZEND_VM_NEXT_OPCODE();
11295 : }
11296 :
11297 : static int ZEND_CONCAT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11298 76 : {
11299 76 : zend_op *opline = EX(opline);
11300 : zend_free_op free_op1, free_op2;
11301 :
11302 76 : concat_function(&EX_T(opline->result.u.var).tmp_var,
11303 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11304 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11305 76 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11306 76 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11307 76 : ZEND_VM_NEXT_OPCODE();
11308 : }
11309 :
11310 : static int ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11311 4 : {
11312 4 : zend_op *opline = EX(opline);
11313 : zend_free_op free_op1, free_op2;
11314 :
11315 4 : is_identical_function(&EX_T(opline->result.u.var).tmp_var,
11316 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11317 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11318 4 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11319 4 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11320 4 : ZEND_VM_NEXT_OPCODE();
11321 : }
11322 :
11323 : static int ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11324 2 : {
11325 2 : zend_op *opline = EX(opline);
11326 : zend_free_op free_op1, free_op2;
11327 :
11328 2 : is_not_identical_function(&EX_T(opline->result.u.var).tmp_var,
11329 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11330 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11331 2 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11332 2 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11333 2 : ZEND_VM_NEXT_OPCODE();
11334 : }
11335 :
11336 : static int ZEND_IS_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11337 4 : {
11338 4 : zend_op *opline = EX(opline);
11339 : zend_free_op free_op1, free_op2;
11340 :
11341 4 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
11342 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11343 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11344 4 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11345 4 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11346 4 : ZEND_VM_NEXT_OPCODE();
11347 : }
11348 :
11349 : static int ZEND_IS_NOT_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11350 0 : {
11351 0 : zend_op *opline = EX(opline);
11352 : zend_free_op free_op1, free_op2;
11353 :
11354 0 : is_not_equal_function(&EX_T(opline->result.u.var).tmp_var,
11355 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11356 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11357 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11358 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11359 0 : ZEND_VM_NEXT_OPCODE();
11360 : }
11361 :
11362 : static int ZEND_IS_SMALLER_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11363 54 : {
11364 54 : zend_op *opline = EX(opline);
11365 : zend_free_op free_op1, free_op2;
11366 :
11367 54 : is_smaller_function(&EX_T(opline->result.u.var).tmp_var,
11368 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11369 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11370 54 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11371 54 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11372 54 : ZEND_VM_NEXT_OPCODE();
11373 : }
11374 :
11375 : static int ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11376 0 : {
11377 0 : zend_op *opline = EX(opline);
11378 : zend_free_op free_op1, free_op2;
11379 :
11380 0 : is_smaller_or_equal_function(&EX_T(opline->result.u.var).tmp_var,
11381 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11382 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11383 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11384 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11385 0 : ZEND_VM_NEXT_OPCODE();
11386 : }
11387 :
11388 : static int ZEND_BW_OR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11389 0 : {
11390 0 : zend_op *opline = EX(opline);
11391 : zend_free_op free_op1, free_op2;
11392 :
11393 0 : bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
11394 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11395 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11396 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11397 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11398 0 : ZEND_VM_NEXT_OPCODE();
11399 : }
11400 :
11401 : static int ZEND_BW_AND_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11402 0 : {
11403 0 : zend_op *opline = EX(opline);
11404 : zend_free_op free_op1, free_op2;
11405 :
11406 0 : bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
11407 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11408 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11409 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11410 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11411 0 : ZEND_VM_NEXT_OPCODE();
11412 : }
11413 :
11414 : static int ZEND_BW_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11415 0 : {
11416 0 : zend_op *opline = EX(opline);
11417 : zend_free_op free_op1, free_op2;
11418 :
11419 0 : bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
11420 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11421 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11422 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11423 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11424 0 : ZEND_VM_NEXT_OPCODE();
11425 : }
11426 :
11427 : static int ZEND_BOOL_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11428 0 : {
11429 0 : zend_op *opline = EX(opline);
11430 : zend_free_op free_op1, free_op2;
11431 :
11432 0 : boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
11433 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
11434 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
11435 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11436 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11437 0 : ZEND_VM_NEXT_OPCODE();
11438 : }
11439 :
11440 : static int zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
11441 0 : {
11442 0 : zend_op *opline = EX(opline);
11443 0 : zend_op *op_data = opline+1;
11444 : zend_free_op free_op1, free_op2, free_op_data1;
11445 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11446 : zval *object;
11447 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11448 0 : zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
11449 0 : znode *result = &opline->result;
11450 0 : zval **retval = &EX_T(result->u.var).var.ptr;
11451 0 : int have_get_ptr = 0;
11452 :
11453 0 : EX_T(result->u.var).var.ptr_ptr = NULL;
11454 0 : make_real_object(object_ptr TSRMLS_CC);
11455 0 : object = *object_ptr;
11456 :
11457 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
11458 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
11459 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11460 0 : FREE_OP(free_op_data1);
11461 :
11462 0 : if (!RETURN_VALUE_UNUSED(result)) {
11463 0 : *retval = EG(uninitialized_zval_ptr);
11464 0 : PZVAL_LOCK(*retval);
11465 : }
11466 : } else {
11467 : /* here we are sure we are dealing with an object */
11468 : if (0) {
11469 : MAKE_REAL_ZVAL_PTR(property);
11470 : }
11471 :
11472 : /* here property is a string */
11473 0 : if (opline->extended_value == ZEND_ASSIGN_OBJ
11474 : && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
11475 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
11476 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
11477 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
11478 :
11479 0 : have_get_ptr = 1;
11480 0 : binary_op(*zptr, *zptr, value TSRMLS_CC);
11481 0 : if (!RETURN_VALUE_UNUSED(result)) {
11482 0 : *retval = *zptr;
11483 0 : PZVAL_LOCK(*retval);
11484 : }
11485 : }
11486 : }
11487 :
11488 0 : if (!have_get_ptr) {
11489 0 : zval *z = NULL;
11490 :
11491 0 : switch (opline->extended_value) {
11492 : case ZEND_ASSIGN_OBJ:
11493 0 : if (Z_OBJ_HT_P(object)->read_property) {
11494 0 : z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
11495 : }
11496 0 : break;
11497 : case ZEND_ASSIGN_DIM:
11498 0 : if (Z_OBJ_HT_P(object)->read_dimension) {
11499 0 : z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
11500 : }
11501 : break;
11502 : }
11503 0 : if (z) {
11504 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
11505 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
11506 :
11507 0 : if (z->refcount == 0) {
11508 0 : zval_dtor(z);
11509 0 : FREE_ZVAL(z);
11510 : }
11511 0 : z = value;
11512 : }
11513 0 : z->refcount++;
11514 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
11515 0 : binary_op(z, z, value TSRMLS_CC);
11516 0 : switch (opline->extended_value) {
11517 : case ZEND_ASSIGN_OBJ:
11518 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
11519 0 : break;
11520 : case ZEND_ASSIGN_DIM:
11521 0 : Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
11522 : break;
11523 : }
11524 0 : if (!RETURN_VALUE_UNUSED(result)) {
11525 0 : *retval = z;
11526 0 : PZVAL_LOCK(*retval);
11527 : }
11528 0 : zval_ptr_dtor(&z);
11529 : } else {
11530 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
11531 0 : if (!RETURN_VALUE_UNUSED(result)) {
11532 0 : *retval = EG(uninitialized_zval_ptr);
11533 0 : PZVAL_LOCK(*retval);
11534 : }
11535 : }
11536 : }
11537 :
11538 : if (0) {
11539 : zval_ptr_dtor(&property);
11540 : } else {
11541 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11542 : }
11543 0 : FREE_OP(free_op_data1);
11544 : }
11545 :
11546 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11547 : /* assign_obj has two opcodes! */
11548 0 : ZEND_VM_INC_OPCODE();
11549 0 : ZEND_VM_NEXT_OPCODE();
11550 : }
11551 :
11552 : static int zend_binary_assign_op_helper_SPEC_VAR_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
11553 0 : {
11554 0 : zend_op *opline = EX(opline);
11555 : zend_free_op free_op1, free_op2, free_op_data2, free_op_data1;
11556 : zval **var_ptr;
11557 : zval *value;
11558 0 : zend_bool increment_opline = 0;
11559 :
11560 0 : switch (opline->extended_value) {
11561 : case ZEND_ASSIGN_OBJ:
11562 0 : return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11563 : break;
11564 : case ZEND_ASSIGN_DIM: {
11565 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11566 :
11567 0 : if (object_ptr && IS_VAR != IS_CV && !(free_op1.var != NULL)) {
11568 0 : (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
11569 : }
11570 :
11571 0 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
11572 0 : return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11573 : } else {
11574 0 : zend_op *op_data = opline+1;
11575 0 : zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11576 :
11577 0 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
11578 0 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
11579 0 : var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
11580 0 : increment_opline = 1;
11581 : }
11582 : }
11583 0 : break;
11584 : default:
11585 0 : value = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11586 0 : var_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11587 : /* do nothing */
11588 : break;
11589 : }
11590 :
11591 0 : if (!var_ptr) {
11592 0 : zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
11593 : }
11594 :
11595 0 : if (*var_ptr == EG(error_zval_ptr)) {
11596 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
11597 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
11598 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
11599 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
11600 : }
11601 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11602 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11603 0 : if (increment_opline) {
11604 0 : ZEND_VM_INC_OPCODE();
11605 : }
11606 0 : ZEND_VM_NEXT_OPCODE();
11607 : }
11608 :
11609 0 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
11610 :
11611 0 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
11612 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
11613 : /* proxy object */
11614 0 : zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
11615 0 : objval->refcount++;
11616 0 : binary_op(objval, objval, value TSRMLS_CC);
11617 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
11618 0 : zval_ptr_dtor(&objval);
11619 : } else {
11620 0 : binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
11621 : }
11622 :
11623 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
11624 0 : EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
11625 0 : PZVAL_LOCK(*var_ptr);
11626 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
11627 : }
11628 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11629 :
11630 0 : if (increment_opline) {
11631 0 : ZEND_VM_INC_OPCODE();
11632 0 : FREE_OP(free_op_data1);
11633 0 : FREE_OP_VAR_PTR(free_op_data2);
11634 : }
11635 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11636 0 : ZEND_VM_NEXT_OPCODE();
11637 : }
11638 :
11639 : static int ZEND_ASSIGN_ADD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11640 0 : {
11641 0 : return zend_binary_assign_op_helper_SPEC_VAR_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11642 : }
11643 :
11644 : static int ZEND_ASSIGN_SUB_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11645 0 : {
11646 0 : return zend_binary_assign_op_helper_SPEC_VAR_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11647 : }
11648 :
11649 : static int ZEND_ASSIGN_MUL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11650 0 : {
11651 0 : return zend_binary_assign_op_helper_SPEC_VAR_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11652 : }
11653 :
11654 : static int ZEND_ASSIGN_DIV_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11655 0 : {
11656 0 : return zend_binary_assign_op_helper_SPEC_VAR_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11657 : }
11658 :
11659 : static int ZEND_ASSIGN_MOD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11660 0 : {
11661 0 : return zend_binary_assign_op_helper_SPEC_VAR_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11662 : }
11663 :
11664 : static int ZEND_ASSIGN_SL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11665 0 : {
11666 0 : return zend_binary_assign_op_helper_SPEC_VAR_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11667 : }
11668 :
11669 : static int ZEND_ASSIGN_SR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11670 0 : {
11671 0 : return zend_binary_assign_op_helper_SPEC_VAR_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11672 : }
11673 :
11674 : static int ZEND_ASSIGN_CONCAT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11675 0 : {
11676 0 : return zend_binary_assign_op_helper_SPEC_VAR_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11677 : }
11678 :
11679 : static int ZEND_ASSIGN_BW_OR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11680 0 : {
11681 0 : return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11682 : }
11683 :
11684 : static int ZEND_ASSIGN_BW_AND_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11685 0 : {
11686 0 : return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11687 : }
11688 :
11689 : static int ZEND_ASSIGN_BW_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11690 0 : {
11691 0 : return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11692 : }
11693 :
11694 : static int zend_pre_incdec_property_helper_SPEC_VAR_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
11695 0 : {
11696 0 : zend_op *opline = EX(opline);
11697 : zend_free_op free_op1, free_op2;
11698 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11699 : zval *object;
11700 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11701 0 : zval **retval = &EX_T(opline->result.u.var).var.ptr;
11702 0 : int have_get_ptr = 0;
11703 :
11704 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
11705 0 : object = *object_ptr;
11706 :
11707 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
11708 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
11709 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11710 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
11711 0 : *retval = EG(uninitialized_zval_ptr);
11712 0 : PZVAL_LOCK(*retval);
11713 : }
11714 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11715 0 : ZEND_VM_NEXT_OPCODE();
11716 : }
11717 :
11718 : /* here we are sure we are dealing with an object */
11719 :
11720 : if (0) {
11721 : MAKE_REAL_ZVAL_PTR(property);
11722 : }
11723 :
11724 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
11725 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
11726 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
11727 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
11728 :
11729 0 : have_get_ptr = 1;
11730 0 : incdec_op(*zptr);
11731 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
11732 0 : *retval = *zptr;
11733 0 : PZVAL_LOCK(*retval);
11734 : }
11735 : }
11736 : }
11737 :
11738 0 : if (!have_get_ptr) {
11739 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
11740 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
11741 :
11742 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
11743 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
11744 :
11745 0 : if (z->refcount == 0) {
11746 0 : zval_dtor(z);
11747 0 : FREE_ZVAL(z);
11748 : }
11749 0 : z = value;
11750 : }
11751 0 : z->refcount++;
11752 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
11753 0 : incdec_op(z);
11754 0 : *retval = z;
11755 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
11756 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
11757 0 : zval_ptr_dtor(&z);
11758 : } else {
11759 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
11760 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
11761 0 : *retval = EG(uninitialized_zval_ptr);
11762 0 : PZVAL_LOCK(*retval);
11763 : }
11764 : }
11765 : }
11766 :
11767 : if (0) {
11768 : zval_ptr_dtor(&property);
11769 : } else {
11770 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11771 : }
11772 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11773 0 : ZEND_VM_NEXT_OPCODE();
11774 : }
11775 :
11776 : static int ZEND_PRE_INC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11777 0 : {
11778 0 : return zend_pre_incdec_property_helper_SPEC_VAR_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11779 : }
11780 :
11781 : static int ZEND_PRE_DEC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11782 0 : {
11783 0 : return zend_pre_incdec_property_helper_SPEC_VAR_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11784 : }
11785 :
11786 : static int zend_post_incdec_property_helper_SPEC_VAR_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
11787 0 : {
11788 0 : zend_op *opline = EX(opline);
11789 : zend_free_op free_op1, free_op2;
11790 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11791 : zval *object;
11792 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11793 0 : zval *retval = &EX_T(opline->result.u.var).tmp_var;
11794 0 : int have_get_ptr = 0;
11795 :
11796 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
11797 0 : object = *object_ptr;
11798 :
11799 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
11800 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
11801 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11802 0 : *retval = *EG(uninitialized_zval_ptr);
11803 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11804 0 : ZEND_VM_NEXT_OPCODE();
11805 : }
11806 :
11807 : /* here we are sure we are dealing with an object */
11808 :
11809 : if (0) {
11810 : MAKE_REAL_ZVAL_PTR(property);
11811 : }
11812 :
11813 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
11814 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
11815 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
11816 0 : have_get_ptr = 1;
11817 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
11818 :
11819 0 : *retval = **zptr;
11820 0 : zendi_zval_copy_ctor(*retval);
11821 :
11822 0 : incdec_op(*zptr);
11823 :
11824 : }
11825 : }
11826 :
11827 0 : if (!have_get_ptr) {
11828 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
11829 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
11830 : zval *z_copy;
11831 :
11832 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
11833 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
11834 :
11835 0 : if (z->refcount == 0) {
11836 0 : zval_dtor(z);
11837 0 : FREE_ZVAL(z);
11838 : }
11839 0 : z = value;
11840 : }
11841 0 : *retval = *z;
11842 0 : zendi_zval_copy_ctor(*retval);
11843 0 : ALLOC_ZVAL(z_copy);
11844 0 : *z_copy = *z;
11845 0 : zendi_zval_copy_ctor(*z_copy);
11846 0 : INIT_PZVAL(z_copy);
11847 0 : incdec_op(z_copy);
11848 0 : z->refcount++;
11849 0 : Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
11850 0 : zval_ptr_dtor(&z_copy);
11851 0 : zval_ptr_dtor(&z);
11852 : } else {
11853 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
11854 0 : *retval = *EG(uninitialized_zval_ptr);
11855 : }
11856 : }
11857 :
11858 : if (0) {
11859 : zval_ptr_dtor(&property);
11860 : } else {
11861 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11862 : }
11863 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11864 0 : ZEND_VM_NEXT_OPCODE();
11865 : }
11866 :
11867 : static int ZEND_POST_INC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11868 0 : {
11869 0 : return zend_post_incdec_property_helper_SPEC_VAR_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11870 : }
11871 :
11872 : static int ZEND_POST_DEC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11873 0 : {
11874 0 : return zend_post_incdec_property_helper_SPEC_VAR_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11875 : }
11876 :
11877 : static int ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11878 0 : {
11879 0 : zend_op *opline = EX(opline);
11880 : zend_free_op free_op1, free_op2;
11881 0 : zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11882 :
11883 0 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK &&
11884 : IS_VAR != IS_CV &&
11885 : EX_T(opline->op1.u.var).var.ptr_ptr) {
11886 0 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
11887 : }
11888 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_R TSRMLS_CC);
11889 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11890 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11891 0 : ZEND_VM_NEXT_OPCODE();
11892 : }
11893 :
11894 : static int ZEND_FETCH_DIM_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11895 0 : {
11896 0 : zend_op *opline = EX(opline);
11897 : zend_free_op free_op1, free_op2;
11898 0 : zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11899 :
11900 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_W TSRMLS_CC);
11901 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11902 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
11903 : READY_TO_DESTROY(free_op1.var) &&
11904 : !RETURN_VALUE_UNUSED(&opline->result)) {
11905 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
11906 : }
11907 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11908 0 : ZEND_VM_NEXT_OPCODE();
11909 : }
11910 :
11911 : static int ZEND_FETCH_DIM_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11912 0 : {
11913 0 : zend_op *opline = EX(opline);
11914 : zend_free_op free_op1, free_op2;
11915 0 : zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11916 :
11917 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
11918 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11919 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
11920 : READY_TO_DESTROY(free_op1.var) &&
11921 : !RETURN_VALUE_UNUSED(&opline->result)) {
11922 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
11923 : }
11924 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11925 0 : ZEND_VM_NEXT_OPCODE();
11926 : }
11927 :
11928 : static int ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11929 0 : {
11930 0 : zend_op *opline = EX(opline);
11931 : zend_free_op free_op1, free_op2;
11932 0 : zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11933 :
11934 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_IS TSRMLS_CC);
11935 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11936 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11937 0 : ZEND_VM_NEXT_OPCODE();
11938 : }
11939 :
11940 : static int ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11941 0 : {
11942 0 : zend_op *opline = EX(opline);
11943 : zend_free_op free_op1, free_op2;
11944 0 : int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
11945 : zval *dim;
11946 :
11947 : if (IS_VAR == IS_UNUSED && type == BP_VAR_R) {
11948 : zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
11949 : }
11950 0 : dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11951 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, type TSRMLS_CC);
11952 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11953 0 : if (IS_VAR == IS_VAR && type == BP_VAR_W && (free_op1.var != NULL) &&
11954 : READY_TO_DESTROY(free_op1.var) &&
11955 : !RETURN_VALUE_UNUSED(&opline->result)) {
11956 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
11957 : }
11958 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11959 0 : ZEND_VM_NEXT_OPCODE();
11960 : }
11961 :
11962 : static int ZEND_FETCH_DIM_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11963 0 : {
11964 0 : zend_op *opline = EX(opline);
11965 : zend_free_op free_op1, free_op2;
11966 0 : zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
11967 0 : zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
11968 :
11969 : /* Not needed in DIM_UNSET
11970 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
11971 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
11972 : }
11973 : */
11974 : if (IS_VAR == IS_CV) {
11975 : if (container != &EG(uninitialized_zval_ptr)) {
11976 : SEPARATE_ZVAL_IF_NOT_REF(container);
11977 : }
11978 : }
11979 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_UNSET TSRMLS_CC);
11980 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
11981 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
11982 : READY_TO_DESTROY(free_op1.var) &&
11983 : !RETURN_VALUE_UNUSED(&opline->result)) {
11984 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
11985 : }
11986 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
11987 0 : if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
11988 0 : zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
11989 : } else {
11990 : zend_free_op free_res;
11991 :
11992 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
11993 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
11994 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
11995 : }
11996 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
11997 0 : FREE_OP_VAR_PTR(free_res);
11998 : }
11999 0 : ZEND_VM_NEXT_OPCODE();
12000 : }
12001 :
12002 : static int zend_fetch_property_address_read_helper_SPEC_VAR_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
12003 0 : {
12004 0 : zend_op *opline = EX(opline);
12005 : zval *container;
12006 : zval **retval;
12007 : zend_free_op free_op1;
12008 :
12009 0 : retval = &EX_T(opline->result.u.var).var.ptr;
12010 0 : EX_T(opline->result.u.var).var.ptr_ptr = retval;
12011 :
12012 0 : container = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12013 :
12014 0 : if (container == EG(error_zval_ptr)) {
12015 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
12016 0 : *retval = EG(error_zval_ptr);
12017 0 : PZVAL_LOCK(*retval);
12018 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
12019 : }
12020 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12021 0 : ZEND_VM_NEXT_OPCODE();
12022 : }
12023 :
12024 :
12025 0 : if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
12026 0 : if (type != BP_VAR_IS) {
12027 0 : zend_error(E_NOTICE, "Trying to get property of non-object");
12028 : }
12029 0 : *retval = EG(uninitialized_zval_ptr);
12030 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
12031 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
12032 : } else {
12033 : zend_free_op free_op2;
12034 0 : zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12035 :
12036 : if (0) {
12037 : MAKE_REAL_ZVAL_PTR(offset);
12038 : }
12039 :
12040 : /* here we are sure we are dealing with an object */
12041 0 : *retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
12042 :
12043 0 : if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
12044 0 : zval_dtor(*retval);
12045 0 : FREE_ZVAL(*retval);
12046 : } else {
12047 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
12048 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
12049 : }
12050 :
12051 : if (0) {
12052 : zval_ptr_dtor(&offset);
12053 : } else {
12054 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12055 : }
12056 : }
12057 :
12058 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12059 0 : ZEND_VM_NEXT_OPCODE();
12060 : }
12061 :
12062 : static int ZEND_FETCH_OBJ_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12063 0 : {
12064 0 : return zend_fetch_property_address_read_helper_SPEC_VAR_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12065 : }
12066 :
12067 : static int ZEND_FETCH_OBJ_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12068 0 : {
12069 0 : zend_op *opline = EX(opline);
12070 : zend_free_op free_op1, free_op2;
12071 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12072 :
12073 0 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_VAR != IS_CV) {
12074 0 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
12075 0 : EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
12076 : }
12077 :
12078 : if (0) {
12079 : MAKE_REAL_ZVAL_PTR(property);
12080 : }
12081 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
12082 : if (0) {
12083 : zval_ptr_dtor(&property);
12084 : } else {
12085 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12086 : }
12087 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
12088 : READY_TO_DESTROY(free_op1.var) &&
12089 : !RETURN_VALUE_UNUSED(&opline->result)) {
12090 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
12091 : }
12092 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12093 0 : ZEND_VM_NEXT_OPCODE();
12094 : }
12095 :
12096 : static int ZEND_FETCH_OBJ_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12097 0 : {
12098 0 : zend_op *opline = EX(opline);
12099 : zend_free_op free_op1, free_op2;
12100 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12101 :
12102 : if (0) {
12103 : MAKE_REAL_ZVAL_PTR(property);
12104 : }
12105 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_RW TSRMLS_CC);
12106 : if (0) {
12107 : zval_ptr_dtor(&property);
12108 : } else {
12109 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12110 : }
12111 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
12112 : READY_TO_DESTROY(free_op1.var) &&
12113 : !RETURN_VALUE_UNUSED(&opline->result)) {
12114 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
12115 : }
12116 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12117 0 : ZEND_VM_NEXT_OPCODE();
12118 : }
12119 :
12120 : static int ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12121 0 : {
12122 0 : return zend_fetch_property_address_read_helper_SPEC_VAR_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12123 : }
12124 :
12125 : static int ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12126 0 : {
12127 0 : zend_op *opline = EX(opline);
12128 :
12129 0 : if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
12130 : /* Behave like FETCH_OBJ_W */
12131 : zend_free_op free_op1, free_op2;
12132 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12133 :
12134 : if (0) {
12135 : MAKE_REAL_ZVAL_PTR(property);
12136 : }
12137 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
12138 : if (0) {
12139 : zval_ptr_dtor(&property);
12140 : } else {
12141 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12142 : }
12143 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
12144 : READY_TO_DESTROY(free_op1.var) &&
12145 : !RETURN_VALUE_UNUSED(&opline->result)) {
12146 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
12147 : }
12148 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12149 0 : ZEND_VM_NEXT_OPCODE();
12150 : } else {
12151 0 : return zend_fetch_property_address_read_helper_SPEC_VAR_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12152 : }
12153 : }
12154 :
12155 : static int ZEND_FETCH_OBJ_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12156 0 : {
12157 0 : zend_op *opline = EX(opline);
12158 : zend_free_op free_op1, free_op2, free_res;
12159 0 : zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12160 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12161 :
12162 : if (IS_VAR == IS_CV) {
12163 : if (container != &EG(uninitialized_zval_ptr)) {
12164 : SEPARATE_ZVAL_IF_NOT_REF(container);
12165 : }
12166 : }
12167 : if (0) {
12168 : MAKE_REAL_ZVAL_PTR(property);
12169 : }
12170 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
12171 : if (0) {
12172 : zval_ptr_dtor(&property);
12173 : } else {
12174 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12175 : }
12176 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
12177 : READY_TO_DESTROY(free_op1.var) &&
12178 : !RETURN_VALUE_UNUSED(&opline->result)) {
12179 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
12180 : }
12181 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12182 :
12183 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
12184 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
12185 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
12186 : }
12187 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
12188 0 : FREE_OP_VAR_PTR(free_res);
12189 0 : ZEND_VM_NEXT_OPCODE();
12190 : }
12191 :
12192 : static int ZEND_ASSIGN_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12193 0 : {
12194 0 : zend_op *opline = EX(opline);
12195 0 : zend_op *op_data = opline+1;
12196 : zend_free_op free_op1;
12197 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12198 :
12199 0 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
12200 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12201 : /* assign_obj has two opcodes! */
12202 0 : ZEND_VM_INC_OPCODE();
12203 0 : ZEND_VM_NEXT_OPCODE();
12204 : }
12205 :
12206 : static int ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12207 0 : {
12208 0 : zend_op *opline = EX(opline);
12209 0 : zend_op *op_data = opline+1;
12210 : zend_free_op free_op1;
12211 : zval **object_ptr;
12212 :
12213 0 : if (IS_VAR == IS_CV || EX_T(opline->op1.u.var).var.ptr_ptr) {
12214 : /* not an array offset */
12215 0 : object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12216 : } else {
12217 0 : object_ptr = NULL;
12218 : }
12219 :
12220 0 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
12221 0 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
12222 : } else {
12223 : zend_free_op free_op2, free_op_data1;
12224 : zval *value;
12225 0 : zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12226 :
12227 0 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
12228 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12229 :
12230 0 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
12231 0 : zend_assign_to_variable(&opline->result, &op_data->op2, &op_data->op1, value, (IS_TMP_FREE(free_op_data1)?IS_TMP_VAR:op_data->op1.op_type), EX(Ts) TSRMLS_CC);
12232 0 : FREE_OP_IF_VAR(free_op_data1);
12233 : }
12234 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12235 : /* assign_dim has two opcodes! */
12236 0 : ZEND_VM_INC_OPCODE();
12237 0 : ZEND_VM_NEXT_OPCODE();
12238 : }
12239 :
12240 : static int ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12241 0 : {
12242 0 : zend_op *opline = EX(opline);
12243 : zend_free_op free_op2;
12244 0 : zval *value = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12245 :
12246 0 : zend_assign_to_variable(&opline->result, &opline->op1, &opline->op2, value, (0?IS_TMP_VAR:IS_VAR), EX(Ts) TSRMLS_CC);
12247 : /* zend_assign_to_variable() always takes care of op2, never free it! */
12248 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12249 :
12250 0 : ZEND_VM_NEXT_OPCODE();
12251 : }
12252 :
12253 : static int ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12254 0 : {
12255 0 : zend_op *opline = EX(opline);
12256 : zend_free_op free_op1, free_op2;
12257 : zval **variable_ptr_ptr;
12258 0 : zval **value_ptr_ptr = _get_zval_ptr_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12259 :
12260 0 : if (IS_VAR == IS_VAR &&
12261 : value_ptr_ptr &&
12262 : !(*value_ptr_ptr)->is_ref &&
12263 : opline->extended_value == ZEND_RETURNS_FUNCTION &&
12264 : !EX_T(opline->op2.u.var).var.fcall_returned_reference) {
12265 0 : if (free_op2.var == NULL) {
12266 0 : PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
12267 : }
12268 0 : zend_error(E_STRICT, "Only variables should be assigned by reference");
12269 0 : return ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12270 : }
12271 0 : if (IS_VAR == IS_VAR && EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
12272 0 : zend_error(E_ERROR, "Cannot assign by reference to overloaded object");
12273 : }
12274 :
12275 0 : variable_ptr_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12276 0 : zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
12277 :
12278 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
12279 0 : EX_T(opline->result.u.var).var.ptr_ptr = variable_ptr_ptr;
12280 0 : PZVAL_LOCK(*variable_ptr_ptr);
12281 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
12282 : }
12283 :
12284 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12285 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12286 :
12287 0 : ZEND_VM_NEXT_OPCODE();
12288 : }
12289 :
12290 : static int ZEND_INIT_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12291 0 : {
12292 0 : zend_op *opline = EX(opline);
12293 : zval *function_name;
12294 : char *function_name_strval;
12295 : int function_name_strlen;
12296 : zend_free_op free_op1, free_op2;
12297 :
12298 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
12299 :
12300 0 : function_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12301 :
12302 0 : if (Z_TYPE_P(function_name)!=IS_STRING) {
12303 0 : zend_error_noreturn(E_ERROR, "Method name must be a string");
12304 : }
12305 :
12306 0 : function_name_strval = Z_STRVAL_P(function_name);
12307 0 : function_name_strlen = Z_STRLEN_P(function_name);
12308 :
12309 0 : EX(object) = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12310 :
12311 0 : if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
12312 0 : if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
12313 0 : zend_error_noreturn(E_ERROR, "Object does not support method calls");
12314 : }
12315 :
12316 : /* First, locate the function. */
12317 0 : EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
12318 0 : if (!EX(fbc)) {
12319 0 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
12320 : }
12321 : } else {
12322 0 : zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
12323 : }
12324 :
12325 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
12326 0 : EX(object) = NULL;
12327 : } else {
12328 0 : if (!PZVAL_IS_REF(EX(object))) {
12329 0 : EX(object)->refcount++; /* For $this pointer */
12330 : } else {
12331 : zval *this_ptr;
12332 0 : ALLOC_ZVAL(this_ptr);
12333 0 : INIT_PZVAL_COPY(this_ptr, EX(object));
12334 0 : zval_copy_ctor(this_ptr);
12335 0 : EX(object) = this_ptr;
12336 : }
12337 : }
12338 :
12339 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12340 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12341 :
12342 0 : ZEND_VM_NEXT_OPCODE();
12343 : }
12344 :
12345 : static int ZEND_CASE_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12346 0 : {
12347 0 : zend_op *opline = EX(opline);
12348 0 : int switch_expr_is_overloaded=0;
12349 : zend_free_op free_op1, free_op2;
12350 :
12351 : if (IS_VAR==IS_VAR) {
12352 0 : if (EX_T(opline->op1.u.var).var.ptr_ptr) {
12353 0 : PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
12354 : } else {
12355 0 : switch_expr_is_overloaded = 1;
12356 0 : EX_T(opline->op1.u.var).str_offset.str->refcount++;
12357 : }
12358 : }
12359 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
12360 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
12361 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
12362 :
12363 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12364 0 : if (switch_expr_is_overloaded) {
12365 : /* We only free op1 if this is a string offset,
12366 : * Since if it is a TMP_VAR, it'll be reused by
12367 : * other CASE opcodes (whereas string offsets
12368 : * are allocated at each get_zval_ptr())
12369 : */
12370 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12371 0 : EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
12372 0 : AI_USE_PTR(EX_T(opline->op1.u.var).var);
12373 : }
12374 0 : ZEND_VM_NEXT_OPCODE();
12375 : }
12376 :
12377 : static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12378 0 : {
12379 0 : zend_op *opline = EX(opline);
12380 : zend_free_op free_op1, free_op2;
12381 0 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
12382 : zval *expr_ptr;
12383 0 : zval *offset=_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12384 :
12385 : #if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
12386 0 : zval **expr_ptr_ptr = NULL;
12387 :
12388 0 : if (opline->extended_value) {
12389 0 : expr_ptr_ptr=_get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12390 0 : expr_ptr = *expr_ptr_ptr;
12391 : } else {
12392 0 : expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12393 : }
12394 : #else
12395 : expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12396 : #endif
12397 :
12398 : if (0) { /* temporary variable */
12399 : zval *new_expr;
12400 :
12401 : ALLOC_ZVAL(new_expr);
12402 : INIT_PZVAL_COPY(new_expr, expr_ptr);
12403 : expr_ptr = new_expr;
12404 : } else {
12405 : #if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
12406 0 : if (opline->extended_value) {
12407 0 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
12408 0 : expr_ptr = *expr_ptr_ptr;
12409 0 : expr_ptr->refcount++;
12410 : } else
12411 : #endif
12412 0 : if (PZVAL_IS_REF(expr_ptr)) {
12413 : zval *new_expr;
12414 :
12415 0 : ALLOC_ZVAL(new_expr);
12416 0 : INIT_PZVAL_COPY(new_expr, expr_ptr);
12417 0 : expr_ptr = new_expr;
12418 0 : zendi_zval_copy_ctor(*expr_ptr);
12419 : } else {
12420 0 : expr_ptr->refcount++;
12421 : }
12422 : }
12423 0 : if (offset) {
12424 0 : switch (Z_TYPE_P(offset)) {
12425 : case IS_DOUBLE:
12426 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
12427 0 : break;
12428 : case IS_LONG:
12429 : case IS_BOOL:
12430 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
12431 0 : break;
12432 : case IS_STRING:
12433 0 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
12434 0 : break;
12435 : case IS_NULL:
12436 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
12437 0 : break;
12438 : default:
12439 0 : zend_error(E_WARNING, "Illegal offset type");
12440 0 : zval_ptr_dtor(&expr_ptr);
12441 : /* do nothing */
12442 : break;
12443 : }
12444 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12445 : } else {
12446 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
12447 : }
12448 0 : if (opline->extended_value) {
12449 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12450 : } else {
12451 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12452 : }
12453 0 : ZEND_VM_NEXT_OPCODE();
12454 : }
12455 :
12456 : static int ZEND_INIT_ARRAY_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12457 0 : {
12458 0 : zend_op *opline = EX(opline);
12459 :
12460 0 : array_init(&EX_T(opline->result.u.var).tmp_var);
12461 : if (IS_VAR == IS_UNUSED) {
12462 : ZEND_VM_NEXT_OPCODE();
12463 : #if 0 || IS_VAR != IS_UNUSED
12464 : } else {
12465 0 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12466 : #endif
12467 : }
12468 : }
12469 :
12470 : static int ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12471 0 : {
12472 0 : zend_op *opline = EX(opline);
12473 : zend_free_op free_op1, free_op2;
12474 0 : zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12475 0 : zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12476 : long index;
12477 :
12478 0 : if (container) {
12479 : if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
12480 : SEPARATE_ZVAL_IF_NOT_REF(container);
12481 : }
12482 0 : switch (Z_TYPE_PP(container)) {
12483 : case IS_ARRAY: {
12484 0 : HashTable *ht = Z_ARRVAL_PP(container);
12485 :
12486 0 : switch (Z_TYPE_P(offset)) {
12487 : case IS_DOUBLE:
12488 0 : index = (long) Z_DVAL_P(offset);
12489 0 : zend_hash_index_del(ht, index);
12490 0 : break;
12491 : case IS_RESOURCE:
12492 : case IS_BOOL:
12493 : case IS_LONG:
12494 0 : index = Z_LVAL_P(offset);
12495 0 : zend_hash_index_del(ht, index);
12496 0 : break;
12497 : case IS_STRING:
12498 : if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
12499 0 : offset->refcount++;
12500 : }
12501 0 : if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
12502 : ht == &EG(symbol_table)) {
12503 : zend_execute_data *ex;
12504 0 : ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
12505 :
12506 0 : for (ex = execute_data; ex; ex = ex->prev_execute_data) {
12507 0 : if (ex->op_array && ex->symbol_table == ht) {
12508 : int i;
12509 :
12510 0 : for (i = 0; i < ex->op_array->last_var; i++) {
12511 0 : if (ex->op_array->vars[i].hash_value == hash_value &&
12512 : ex->op_array->vars[i].name_len == offset->value.str.len &&
12513 : !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
12514 0 : ex->CVs[i] = NULL;
12515 0 : break;
12516 : }
12517 : }
12518 : }
12519 : }
12520 : }
12521 : if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
12522 0 : zval_ptr_dtor(&offset);
12523 : }
12524 0 : break;
12525 : case IS_NULL:
12526 0 : zend_hash_del(ht, "", sizeof(""));
12527 0 : break;
12528 : default:
12529 0 : zend_error(E_WARNING, "Illegal offset type in unset");
12530 : break;
12531 : }
12532 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12533 0 : break;
12534 : }
12535 : case IS_OBJECT:
12536 0 : if (!Z_OBJ_HT_P(*container)->unset_dimension) {
12537 0 : zend_error_noreturn(E_ERROR, "Cannot use object as array");
12538 : }
12539 : if (0) {
12540 : MAKE_REAL_ZVAL_PTR(offset);
12541 : }
12542 0 : Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
12543 : if (0) {
12544 : zval_ptr_dtor(&offset);
12545 : } else {
12546 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12547 : }
12548 0 : break;
12549 : case IS_STRING:
12550 0 : zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
12551 : ZEND_VM_CONTINUE(); /* bailed out before */
12552 : default:
12553 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12554 : break;
12555 : }
12556 : } else {
12557 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12558 : }
12559 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12560 :
12561 0 : ZEND_VM_NEXT_OPCODE();
12562 : }
12563 :
12564 : static int ZEND_UNSET_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12565 0 : {
12566 0 : zend_op *opline = EX(opline);
12567 : zend_free_op free_op1, free_op2;
12568 0 : zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12569 0 : zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12570 :
12571 0 : if (container) {
12572 : if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
12573 : SEPARATE_ZVAL_IF_NOT_REF(container);
12574 : }
12575 0 : if (Z_TYPE_PP(container) == IS_OBJECT) {
12576 : if (0) {
12577 : MAKE_REAL_ZVAL_PTR(offset);
12578 : }
12579 0 : Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
12580 : if (0) {
12581 : zval_ptr_dtor(&offset);
12582 : } else {
12583 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12584 : }
12585 : } else {
12586 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12587 : }
12588 : } else {
12589 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12590 : }
12591 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12592 :
12593 0 : ZEND_VM_NEXT_OPCODE();
12594 : }
12595 :
12596 : static int zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
12597 0 : {
12598 0 : zend_op *opline = EX(opline);
12599 : zend_free_op free_op1;
12600 0 : zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12601 0 : zval **value = NULL;
12602 0 : int result = 0;
12603 : long index;
12604 :
12605 0 : if (container) {
12606 : zend_free_op free_op2;
12607 0 : zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
12608 :
12609 0 : if (Z_TYPE_PP(container) == IS_ARRAY) {
12610 : HashTable *ht;
12611 0 : int isset = 0;
12612 :
12613 0 : ht = Z_ARRVAL_PP(container);
12614 :
12615 0 : switch (Z_TYPE_P(offset)) {
12616 : case IS_DOUBLE:
12617 0 : index = (long) Z_DVAL_P(offset);
12618 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
12619 0 : isset = 1;
12620 : }
12621 0 : break;
12622 : case IS_RESOURCE:
12623 : case IS_BOOL:
12624 : case IS_LONG:
12625 0 : index = Z_LVAL_P(offset);
12626 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
12627 0 : isset = 1;
12628 : }
12629 0 : break;
12630 : case IS_STRING:
12631 0 : if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
12632 0 : isset = 1;
12633 : }
12634 0 : break;
12635 : case IS_NULL:
12636 0 : if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
12637 0 : isset = 1;
12638 : }
12639 0 : break;
12640 : default:
12641 0 : zend_error(E_WARNING, "Illegal offset type in isset or empty");
12642 :
12643 : break;
12644 : }
12645 :
12646 0 : switch (opline->extended_value) {
12647 : case ZEND_ISSET:
12648 0 : if (isset && Z_TYPE_PP(value) == IS_NULL) {
12649 0 : result = 0;
12650 : } else {
12651 0 : result = isset;
12652 : }
12653 0 : break;
12654 : case ZEND_ISEMPTY:
12655 0 : if (!isset || !i_zend_is_true(*value)) {
12656 0 : result = 0;
12657 : } else {
12658 0 : result = 1;
12659 : }
12660 : break;
12661 : }
12662 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12663 0 : } else if (Z_TYPE_PP(container) == IS_OBJECT) {
12664 : if (0) {
12665 : MAKE_REAL_ZVAL_PTR(offset);
12666 : }
12667 0 : if (prop_dim) {
12668 0 : result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
12669 : } else {
12670 0 : result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
12671 : }
12672 : if (0) {
12673 : zval_ptr_dtor(&offset);
12674 : } else {
12675 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12676 : }
12677 0 : } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
12678 : zval tmp;
12679 :
12680 0 : if (Z_TYPE_P(offset) != IS_LONG) {
12681 0 : tmp = *offset;
12682 0 : zval_copy_ctor(&tmp);
12683 0 : convert_to_long(&tmp);
12684 0 : offset = &tmp;
12685 : }
12686 0 : if (Z_TYPE_P(offset) == IS_LONG) {
12687 0 : switch (opline->extended_value) {
12688 : case ZEND_ISSET:
12689 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
12690 0 : result = 1;
12691 : }
12692 0 : break;
12693 : case ZEND_ISEMPTY:
12694 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
12695 0 : result = 1;
12696 : }
12697 : break;
12698 : }
12699 : }
12700 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12701 : } else {
12702 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
12703 : }
12704 : }
12705 :
12706 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
12707 :
12708 0 : switch (opline->extended_value) {
12709 : case ZEND_ISSET:
12710 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
12711 0 : break;
12712 : case ZEND_ISEMPTY:
12713 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
12714 : break;
12715 : }
12716 :
12717 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12718 :
12719 0 : ZEND_VM_NEXT_OPCODE();
12720 : }
12721 :
12722 : static int ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12723 0 : {
12724 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12725 : }
12726 :
12727 : static int ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12728 0 : {
12729 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12730 : }
12731 :
12732 : static int zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
12733 0 : {
12734 0 : zend_op *opline = EX(opline);
12735 0 : zend_op *op_data = opline+1;
12736 : zend_free_op free_op1, free_op_data1;
12737 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12738 : zval *object;
12739 0 : zval *property = NULL;
12740 0 : zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
12741 0 : znode *result = &opline->result;
12742 0 : zval **retval = &EX_T(result->u.var).var.ptr;
12743 0 : int have_get_ptr = 0;
12744 :
12745 0 : EX_T(result->u.var).var.ptr_ptr = NULL;
12746 0 : make_real_object(object_ptr TSRMLS_CC);
12747 0 : object = *object_ptr;
12748 :
12749 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
12750 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
12751 :
12752 0 : FREE_OP(free_op_data1);
12753 :
12754 0 : if (!RETURN_VALUE_UNUSED(result)) {
12755 0 : *retval = EG(uninitialized_zval_ptr);
12756 0 : PZVAL_LOCK(*retval);
12757 : }
12758 : } else {
12759 : /* here we are sure we are dealing with an object */
12760 : if (0) {
12761 : MAKE_REAL_ZVAL_PTR(property);
12762 : }
12763 :
12764 : /* here property is a string */
12765 0 : if (opline->extended_value == ZEND_ASSIGN_OBJ
12766 : && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
12767 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
12768 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
12769 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
12770 :
12771 0 : have_get_ptr = 1;
12772 0 : binary_op(*zptr, *zptr, value TSRMLS_CC);
12773 0 : if (!RETURN_VALUE_UNUSED(result)) {
12774 0 : *retval = *zptr;
12775 0 : PZVAL_LOCK(*retval);
12776 : }
12777 : }
12778 : }
12779 :
12780 0 : if (!have_get_ptr) {
12781 0 : zval *z = NULL;
12782 :
12783 0 : switch (opline->extended_value) {
12784 : case ZEND_ASSIGN_OBJ:
12785 0 : if (Z_OBJ_HT_P(object)->read_property) {
12786 0 : z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
12787 : }
12788 0 : break;
12789 : case ZEND_ASSIGN_DIM:
12790 0 : if (Z_OBJ_HT_P(object)->read_dimension) {
12791 0 : z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
12792 : }
12793 : break;
12794 : }
12795 0 : if (z) {
12796 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
12797 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
12798 :
12799 0 : if (z->refcount == 0) {
12800 0 : zval_dtor(z);
12801 0 : FREE_ZVAL(z);
12802 : }
12803 0 : z = value;
12804 : }
12805 0 : z->refcount++;
12806 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
12807 0 : binary_op(z, z, value TSRMLS_CC);
12808 0 : switch (opline->extended_value) {
12809 : case ZEND_ASSIGN_OBJ:
12810 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
12811 0 : break;
12812 : case ZEND_ASSIGN_DIM:
12813 0 : Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
12814 : break;
12815 : }
12816 0 : if (!RETURN_VALUE_UNUSED(result)) {
12817 0 : *retval = z;
12818 0 : PZVAL_LOCK(*retval);
12819 : }
12820 0 : zval_ptr_dtor(&z);
12821 : } else {
12822 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
12823 0 : if (!RETURN_VALUE_UNUSED(result)) {
12824 0 : *retval = EG(uninitialized_zval_ptr);
12825 0 : PZVAL_LOCK(*retval);
12826 : }
12827 : }
12828 : }
12829 :
12830 : if (0) {
12831 : zval_ptr_dtor(&property);
12832 : } else {
12833 :
12834 : }
12835 0 : FREE_OP(free_op_data1);
12836 : }
12837 :
12838 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12839 : /* assign_obj has two opcodes! */
12840 0 : ZEND_VM_INC_OPCODE();
12841 0 : ZEND_VM_NEXT_OPCODE();
12842 : }
12843 :
12844 : static int zend_binary_assign_op_helper_SPEC_VAR_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
12845 0 : {
12846 0 : zend_op *opline = EX(opline);
12847 : zend_free_op free_op1, free_op_data2, free_op_data1;
12848 : zval **var_ptr;
12849 : zval *value;
12850 0 : zend_bool increment_opline = 0;
12851 :
12852 0 : switch (opline->extended_value) {
12853 : case ZEND_ASSIGN_OBJ:
12854 0 : return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12855 : break;
12856 : case ZEND_ASSIGN_DIM: {
12857 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12858 :
12859 0 : if (object_ptr && IS_VAR != IS_CV && !(free_op1.var != NULL)) {
12860 0 : (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
12861 : }
12862 :
12863 0 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
12864 0 : return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12865 : } else {
12866 0 : zend_op *op_data = opline+1;
12867 0 : zval *dim = NULL;
12868 :
12869 0 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
12870 0 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
12871 0 : var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
12872 0 : increment_opline = 1;
12873 : }
12874 : }
12875 0 : break;
12876 : default:
12877 0 : value = NULL;
12878 0 : var_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
12879 : /* do nothing */
12880 : break;
12881 : }
12882 :
12883 0 : if (!var_ptr) {
12884 0 : zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
12885 : }
12886 :
12887 0 : if (*var_ptr == EG(error_zval_ptr)) {
12888 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
12889 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
12890 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
12891 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
12892 : }
12893 :
12894 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12895 0 : if (increment_opline) {
12896 0 : ZEND_VM_INC_OPCODE();
12897 : }
12898 0 : ZEND_VM_NEXT_OPCODE();
12899 : }
12900 :
12901 0 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
12902 :
12903 0 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
12904 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
12905 : /* proxy object */
12906 0 : zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
12907 0 : objval->refcount++;
12908 0 : binary_op(objval, objval, value TSRMLS_CC);
12909 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
12910 0 : zval_ptr_dtor(&objval);
12911 : } else {
12912 0 : binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
12913 : }
12914 :
12915 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
12916 0 : EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
12917 0 : PZVAL_LOCK(*var_ptr);
12918 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
12919 : }
12920 :
12921 0 : if (increment_opline) {
12922 0 : ZEND_VM_INC_OPCODE();
12923 0 : FREE_OP(free_op_data1);
12924 0 : FREE_OP_VAR_PTR(free_op_data2);
12925 : }
12926 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12927 0 : ZEND_VM_NEXT_OPCODE();
12928 : }
12929 :
12930 : static int ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12931 0 : {
12932 0 : return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12933 : }
12934 :
12935 : static int ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12936 0 : {
12937 0 : return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12938 : }
12939 :
12940 : static int ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12941 0 : {
12942 0 : return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12943 : }
12944 :
12945 : static int ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12946 0 : {
12947 0 : return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12948 : }
12949 :
12950 : static int ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12951 0 : {
12952 0 : return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12953 : }
12954 :
12955 : static int ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12956 0 : {
12957 0 : return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12958 : }
12959 :
12960 : static int ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12961 0 : {
12962 0 : return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12963 : }
12964 :
12965 : static int ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12966 0 : {
12967 0 : return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12968 : }
12969 :
12970 : static int ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12971 0 : {
12972 0 : return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12973 : }
12974 :
12975 : static int ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12976 0 : {
12977 0 : return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12978 : }
12979 :
12980 : static int ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12981 0 : {
12982 0 : return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12983 : }
12984 :
12985 : static int ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12986 0 : {
12987 0 : zend_op *opline = EX(opline);
12988 : zend_free_op free_op1;
12989 0 : zval *dim = NULL;
12990 :
12991 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_W TSRMLS_CC);
12992 :
12993 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
12994 : READY_TO_DESTROY(free_op1.var) &&
12995 : !RETURN_VALUE_UNUSED(&opline->result)) {
12996 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
12997 : }
12998 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
12999 0 : ZEND_VM_NEXT_OPCODE();
13000 : }
13001 :
13002 : static int ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13003 0 : {
13004 0 : zend_op *opline = EX(opline);
13005 : zend_free_op free_op1;
13006 0 : zval *dim = NULL;
13007 :
13008 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
13009 :
13010 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
13011 : READY_TO_DESTROY(free_op1.var) &&
13012 : !RETURN_VALUE_UNUSED(&opline->result)) {
13013 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
13014 : }
13015 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13016 0 : ZEND_VM_NEXT_OPCODE();
13017 : }
13018 :
13019 : static int ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13020 0 : {
13021 0 : zend_op *opline = EX(opline);
13022 : zend_free_op free_op1;
13023 0 : int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
13024 : zval *dim;
13025 :
13026 0 : if (IS_UNUSED == IS_UNUSED && type == BP_VAR_R) {
13027 0 : zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
13028 : }
13029 0 : dim = NULL;
13030 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, type TSRMLS_CC);
13031 :
13032 0 : if (IS_VAR == IS_VAR && type == BP_VAR_W && (free_op1.var != NULL) &&
13033 : READY_TO_DESTROY(free_op1.var) &&
13034 : !RETURN_VALUE_UNUSED(&opline->result)) {
13035 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
13036 : }
13037 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13038 0 : ZEND_VM_NEXT_OPCODE();
13039 : }
13040 :
13041 : static int ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13042 4 : {
13043 4 : zend_op *opline = EX(opline);
13044 4 : zend_op *op_data = opline+1;
13045 : zend_free_op free_op1;
13046 : zval **object_ptr;
13047 :
13048 4 : if (IS_VAR == IS_CV || EX_T(opline->op1.u.var).var.ptr_ptr) {
13049 : /* not an array offset */
13050 4 : object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13051 : } else {
13052 0 : object_ptr = NULL;
13053 : }
13054 :
13055 4 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
13056 0 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
13057 : } else {
13058 : zend_free_op free_op_data1;
13059 : zval *value;
13060 4 : zval *dim = NULL;
13061 :
13062 4 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
13063 :
13064 4 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
13065 4 : zend_assign_to_variable(&opline->result, &op_data->op2, &op_data->op1, value, (IS_TMP_FREE(free_op_data1)?IS_TMP_VAR:op_data->op1.op_type), EX(Ts) TSRMLS_CC);
13066 4 : FREE_OP_IF_VAR(free_op_data1);
13067 : }
13068 4 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13069 : /* assign_dim has two opcodes! */
13070 4 : ZEND_VM_INC_OPCODE();
13071 4 : ZEND_VM_NEXT_OPCODE();
13072 : }
13073 :
13074 : static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13075 0 : {
13076 0 : zend_op *opline = EX(opline);
13077 : zend_free_op free_op1;
13078 0 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
13079 : zval *expr_ptr;
13080 0 : zval *offset=NULL;
13081 :
13082 : #if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
13083 0 : zval **expr_ptr_ptr = NULL;
13084 :
13085 0 : if (opline->extended_value) {
13086 0 : expr_ptr_ptr=_get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13087 0 : expr_ptr = *expr_ptr_ptr;
13088 : } else {
13089 0 : expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13090 : }
13091 : #else
13092 : expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13093 : #endif
13094 :
13095 : if (0) { /* temporary variable */
13096 : zval *new_expr;
13097 :
13098 : ALLOC_ZVAL(new_expr);
13099 : INIT_PZVAL_COPY(new_expr, expr_ptr);
13100 : expr_ptr = new_expr;
13101 : } else {
13102 : #if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
13103 0 : if (opline->extended_value) {
13104 0 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
13105 0 : expr_ptr = *expr_ptr_ptr;
13106 0 : expr_ptr->refcount++;
13107 : } else
13108 : #endif
13109 0 : if (PZVAL_IS_REF(expr_ptr)) {
13110 : zval *new_expr;
13111 :
13112 0 : ALLOC_ZVAL(new_expr);
13113 0 : INIT_PZVAL_COPY(new_expr, expr_ptr);
13114 0 : expr_ptr = new_expr;
13115 0 : zendi_zval_copy_ctor(*expr_ptr);
13116 : } else {
13117 0 : expr_ptr->refcount++;
13118 : }
13119 : }
13120 0 : if (offset) {
13121 0 : switch (Z_TYPE_P(offset)) {
13122 : case IS_DOUBLE:
13123 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
13124 0 : break;
13125 : case IS_LONG:
13126 : case IS_BOOL:
13127 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
13128 0 : break;
13129 : case IS_STRING:
13130 0 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
13131 0 : break;
13132 : case IS_NULL:
13133 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
13134 0 : break;
13135 : default:
13136 0 : zend_error(E_WARNING, "Illegal offset type");
13137 0 : zval_ptr_dtor(&expr_ptr);
13138 : /* do nothing */
13139 : break;
13140 : }
13141 :
13142 : } else {
13143 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
13144 : }
13145 0 : if (opline->extended_value) {
13146 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13147 : } else {
13148 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13149 : }
13150 0 : ZEND_VM_NEXT_OPCODE();
13151 : }
13152 :
13153 : static int ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13154 0 : {
13155 0 : zend_op *opline = EX(opline);
13156 :
13157 0 : array_init(&EX_T(opline->result.u.var).tmp_var);
13158 : if (IS_VAR == IS_UNUSED) {
13159 : ZEND_VM_NEXT_OPCODE();
13160 : #if 0 || IS_VAR != IS_UNUSED
13161 : } else {
13162 0 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13163 : #endif
13164 : }
13165 : }
13166 :
13167 : static int ZEND_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13168 0 : {
13169 0 : zend_op *opline = EX(opline);
13170 : zend_free_op free_op1;
13171 :
13172 0 : add_function(&EX_T(opline->result.u.var).tmp_var,
13173 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
13174 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
13175 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13176 :
13177 0 : ZEND_VM_NEXT_OPCODE();
13178 : }
13179 :
13180 : static int ZEND_SUB_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13181 1 : {
13182 1 : zend_op *opline = EX(opline);
13183 : zend_free_op free_op1;
13184 :
13185 1 : sub_function(&EX_T(opline->result.u.var).tmp_var,
13186 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
13187 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
13188 1 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13189 :
13190 1 : ZEND_VM_NEXT_OPCODE();
13191 : }
13192 :
13193 : static int ZEND_MUL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13194 0 : {
13195 0 : zend_op *opline = EX(opline);
13196 : zend_free_op free_op1;
13197 :
13198 0 : mul_function(&EX_T(opline->result.u.var).tmp_var,
13199 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
13200 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
13201 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13202 :
13203 0 : ZEND_VM_NEXT_OPCODE();
13204 : }
13205 :
13206 : static int ZEND_DIV_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13207 0 : {
13208 0 : zend_op *opline = EX(opline);
13209 : zend_free_op free_op1;
13210 :
13211 0 : div_function(&EX_T(opline->result.u.var).tmp_var,
13212 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
13213 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
13214 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13215 :
13216 0 : ZEND_VM_NEXT_OPCODE();
13217 : }
13218 :
13219 : static int ZEND_MOD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13220 0 : {
13221 0 : zend_op *opline = EX(opline);
13222 : zend_free_op free_op1;
13223 :
13224 0 : mod_function(&EX_T(opline->result.u.var).tmp_var,
13225 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
13226 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
13227 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13228 :
13229 0 : ZEND_VM_NEXT_OPCODE();
13230 : }
13231 :
13232 : static int ZEND_SL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13233 0 : {
13234 0 : zend_op *opline = EX(opline);
13235 : zend_free_op free_op1;
13236 :
13237 0 : shift_left_function(&EX_T(opline->result.u.var).tmp_var,
13238 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
13239 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
13240 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13241 :
13242 0 : ZEND_VM_NEXT_OPCODE();
13243 : }
13244 :
13245 : static int ZEND_SR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13246 0 : {
13247 0 : zend_op *opline = EX(opline);
13248 : zend_free_op free_op1;
13249 :
13250 0 : shift_right_function(&EX_T(opline->result.u.var).tmp_var,
13251 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
13252 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
13253 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13254 :
13255 0 : ZEND_VM_NEXT_OPCODE();
13256 : }
13257 :
13258 : static int ZEND_CONCAT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13259 0 : {
13260 0 : zend_op *opline = EX(opline);
13261 : zend_free_op free_op1;
13262 :
13263 0 : concat_function(&EX_T(opline->result.u.var).tmp_var,
13264 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
13265 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
13266 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13267 :
13268 0 : ZEND_VM_NEXT_OPCODE();
13269 : }
13270 :
13271 : static int ZEND_IS_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13272 0 : {
13273 0 : zend_op *opline = EX(opline);
13274 : zend_free_op free_op1;
13275 :
13276 0 : is_identical_function(&EX_T(opline->result.u.var).tmp_var,
13277 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
13278 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
13279 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13280 :
13281 0 : ZEND_VM_NEXT_OPCODE();
13282 : }
13283 :
13284 : static int ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13285 0 : {
13286 0 : zend_op *opline = EX(opline);
13287 : zend_free_op free_op1;
13288 :
13289 0 : is_not_identical_function(&EX_T(opline->result.u.var).tmp_var,
13290 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
13291 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
13292 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13293 :
13294 0 : ZEND_VM_NEXT_OPCODE();
13295 : }
13296 :
13297 : static int ZEND_IS_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13298 0 : {
13299 0 : zend_op *opline = EX(opline);
13300 : zend_free_op free_op1;
13301 :
13302 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
13303 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
13304 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
13305 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13306 :
13307 0 : ZEND_VM_NEXT_OPCODE();
13308 : }
13309 :
13310 : static int ZEND_IS_NOT_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13311 0 : {
13312 0 : zend_op *opline = EX(opline);
13313 : zend_free_op free_op1;
13314 :
13315 0 : is_not_equal_function(&EX_T(opline->result.u.var).tmp_var,
13316 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
13317 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
13318 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13319 :
13320 0 : ZEND_VM_NEXT_OPCODE();
13321 : }
13322 :
13323 : static int ZEND_IS_SMALLER_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13324 0 : {
13325 0 : zend_op *opline = EX(opline);
13326 : zend_free_op free_op1;
13327 :
13328 0 : is_smaller_function(&EX_T(opline->result.u.var).tmp_var,
13329 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
13330 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
13331 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13332 :
13333 0 : ZEND_VM_NEXT_OPCODE();
13334 : }
13335 :
13336 : static int ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13337 0 : {
13338 0 : zend_op *opline = EX(opline);
13339 : zend_free_op free_op1;
13340 :
13341 0 : is_smaller_or_equal_function(&EX_T(opline->result.u.var).tmp_var,
13342 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
13343 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
13344 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13345 :
13346 0 : ZEND_VM_NEXT_OPCODE();
13347 : }
13348 :
13349 : static int ZEND_BW_OR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13350 0 : {
13351 0 : zend_op *opline = EX(opline);
13352 : zend_free_op free_op1;
13353 :
13354 0 : bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
13355 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
13356 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
13357 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13358 :
13359 0 : ZEND_VM_NEXT_OPCODE();
13360 : }
13361 :
13362 : static int ZEND_BW_AND_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13363 0 : {
13364 0 : zend_op *opline = EX(opline);
13365 : zend_free_op free_op1;
13366 :
13367 0 : bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
13368 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
13369 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
13370 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13371 :
13372 0 : ZEND_VM_NEXT_OPCODE();
13373 : }
13374 :
13375 : static int ZEND_BW_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13376 0 : {
13377 0 : zend_op *opline = EX(opline);
13378 : zend_free_op free_op1;
13379 :
13380 0 : bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
13381 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
13382 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
13383 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13384 :
13385 0 : ZEND_VM_NEXT_OPCODE();
13386 : }
13387 :
13388 : static int ZEND_BOOL_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13389 0 : {
13390 0 : zend_op *opline = EX(opline);
13391 : zend_free_op free_op1;
13392 :
13393 0 : boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
13394 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
13395 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
13396 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13397 :
13398 0 : ZEND_VM_NEXT_OPCODE();
13399 : }
13400 :
13401 : static int zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
13402 0 : {
13403 0 : zend_op *opline = EX(opline);
13404 0 : zend_op *op_data = opline+1;
13405 : zend_free_op free_op1, free_op_data1;
13406 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13407 : zval *object;
13408 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
13409 0 : zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
13410 0 : znode *result = &opline->result;
13411 0 : zval **retval = &EX_T(result->u.var).var.ptr;
13412 0 : int have_get_ptr = 0;
13413 :
13414 0 : EX_T(result->u.var).var.ptr_ptr = NULL;
13415 0 : make_real_object(object_ptr TSRMLS_CC);
13416 0 : object = *object_ptr;
13417 :
13418 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
13419 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
13420 :
13421 0 : FREE_OP(free_op_data1);
13422 :
13423 0 : if (!RETURN_VALUE_UNUSED(result)) {
13424 0 : *retval = EG(uninitialized_zval_ptr);
13425 0 : PZVAL_LOCK(*retval);
13426 : }
13427 : } else {
13428 : /* here we are sure we are dealing with an object */
13429 : if (0) {
13430 : MAKE_REAL_ZVAL_PTR(property);
13431 : }
13432 :
13433 : /* here property is a string */
13434 0 : if (opline->extended_value == ZEND_ASSIGN_OBJ
13435 : && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
13436 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
13437 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
13438 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
13439 :
13440 0 : have_get_ptr = 1;
13441 0 : binary_op(*zptr, *zptr, value TSRMLS_CC);
13442 0 : if (!RETURN_VALUE_UNUSED(result)) {
13443 0 : *retval = *zptr;
13444 0 : PZVAL_LOCK(*retval);
13445 : }
13446 : }
13447 : }
13448 :
13449 0 : if (!have_get_ptr) {
13450 0 : zval *z = NULL;
13451 :
13452 0 : switch (opline->extended_value) {
13453 : case ZEND_ASSIGN_OBJ:
13454 0 : if (Z_OBJ_HT_P(object)->read_property) {
13455 0 : z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
13456 : }
13457 0 : break;
13458 : case ZEND_ASSIGN_DIM:
13459 0 : if (Z_OBJ_HT_P(object)->read_dimension) {
13460 0 : z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
13461 : }
13462 : break;
13463 : }
13464 0 : if (z) {
13465 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
13466 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
13467 :
13468 0 : if (z->refcount == 0) {
13469 0 : zval_dtor(z);
13470 0 : FREE_ZVAL(z);
13471 : }
13472 0 : z = value;
13473 : }
13474 0 : z->refcount++;
13475 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
13476 0 : binary_op(z, z, value TSRMLS_CC);
13477 0 : switch (opline->extended_value) {
13478 : case ZEND_ASSIGN_OBJ:
13479 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
13480 0 : break;
13481 : case ZEND_ASSIGN_DIM:
13482 0 : Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
13483 : break;
13484 : }
13485 0 : if (!RETURN_VALUE_UNUSED(result)) {
13486 0 : *retval = z;
13487 0 : PZVAL_LOCK(*retval);
13488 : }
13489 0 : zval_ptr_dtor(&z);
13490 : } else {
13491 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
13492 0 : if (!RETURN_VALUE_UNUSED(result)) {
13493 0 : *retval = EG(uninitialized_zval_ptr);
13494 0 : PZVAL_LOCK(*retval);
13495 : }
13496 : }
13497 : }
13498 :
13499 : if (0) {
13500 : zval_ptr_dtor(&property);
13501 : } else {
13502 :
13503 : }
13504 0 : FREE_OP(free_op_data1);
13505 : }
13506 :
13507 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13508 : /* assign_obj has two opcodes! */
13509 0 : ZEND_VM_INC_OPCODE();
13510 0 : ZEND_VM_NEXT_OPCODE();
13511 : }
13512 :
13513 : static int zend_binary_assign_op_helper_SPEC_VAR_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
13514 0 : {
13515 0 : zend_op *opline = EX(opline);
13516 : zend_free_op free_op1, free_op_data2, free_op_data1;
13517 : zval **var_ptr;
13518 : zval *value;
13519 0 : zend_bool increment_opline = 0;
13520 :
13521 0 : switch (opline->extended_value) {
13522 : case ZEND_ASSIGN_OBJ:
13523 0 : return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13524 : break;
13525 : case ZEND_ASSIGN_DIM: {
13526 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13527 :
13528 0 : if (object_ptr && IS_VAR != IS_CV && !(free_op1.var != NULL)) {
13529 0 : (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
13530 : }
13531 :
13532 0 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
13533 0 : return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13534 : } else {
13535 0 : zend_op *op_data = opline+1;
13536 0 : zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
13537 :
13538 0 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
13539 0 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
13540 0 : var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
13541 0 : increment_opline = 1;
13542 : }
13543 : }
13544 0 : break;
13545 : default:
13546 0 : value = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
13547 0 : var_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13548 : /* do nothing */
13549 : break;
13550 : }
13551 :
13552 0 : if (!var_ptr) {
13553 0 : zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
13554 : }
13555 :
13556 0 : if (*var_ptr == EG(error_zval_ptr)) {
13557 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
13558 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
13559 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
13560 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
13561 : }
13562 :
13563 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13564 0 : if (increment_opline) {
13565 0 : ZEND_VM_INC_OPCODE();
13566 : }
13567 0 : ZEND_VM_NEXT_OPCODE();
13568 : }
13569 :
13570 0 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
13571 :
13572 0 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
13573 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
13574 : /* proxy object */
13575 0 : zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
13576 0 : objval->refcount++;
13577 0 : binary_op(objval, objval, value TSRMLS_CC);
13578 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
13579 0 : zval_ptr_dtor(&objval);
13580 : } else {
13581 0 : binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
13582 : }
13583 :
13584 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
13585 0 : EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
13586 0 : PZVAL_LOCK(*var_ptr);
13587 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
13588 : }
13589 :
13590 0 : if (increment_opline) {
13591 0 : ZEND_VM_INC_OPCODE();
13592 0 : FREE_OP(free_op_data1);
13593 0 : FREE_OP_VAR_PTR(free_op_data2);
13594 : }
13595 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13596 0 : ZEND_VM_NEXT_OPCODE();
13597 : }
13598 :
13599 : static int ZEND_ASSIGN_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13600 0 : {
13601 0 : return zend_binary_assign_op_helper_SPEC_VAR_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13602 : }
13603 :
13604 : static int ZEND_ASSIGN_SUB_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13605 0 : {
13606 0 : return zend_binary_assign_op_helper_SPEC_VAR_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13607 : }
13608 :
13609 : static int ZEND_ASSIGN_MUL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13610 0 : {
13611 0 : return zend_binary_assign_op_helper_SPEC_VAR_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13612 : }
13613 :
13614 : static int ZEND_ASSIGN_DIV_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13615 0 : {
13616 0 : return zend_binary_assign_op_helper_SPEC_VAR_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13617 : }
13618 :
13619 : static int ZEND_ASSIGN_MOD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13620 0 : {
13621 0 : return zend_binary_assign_op_helper_SPEC_VAR_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13622 : }
13623 :
13624 : static int ZEND_ASSIGN_SL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13625 0 : {
13626 0 : return zend_binary_assign_op_helper_SPEC_VAR_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13627 : }
13628 :
13629 : static int ZEND_ASSIGN_SR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13630 0 : {
13631 0 : return zend_binary_assign_op_helper_SPEC_VAR_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13632 : }
13633 :
13634 : static int ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13635 0 : {
13636 0 : return zend_binary_assign_op_helper_SPEC_VAR_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13637 : }
13638 :
13639 : static int ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13640 0 : {
13641 0 : return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13642 : }
13643 :
13644 : static int ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13645 0 : {
13646 0 : return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13647 : }
13648 :
13649 : static int ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13650 0 : {
13651 0 : return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13652 : }
13653 :
13654 : static int zend_pre_incdec_property_helper_SPEC_VAR_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
13655 0 : {
13656 0 : zend_op *opline = EX(opline);
13657 : zend_free_op free_op1;
13658 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13659 : zval *object;
13660 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
13661 0 : zval **retval = &EX_T(opline->result.u.var).var.ptr;
13662 0 : int have_get_ptr = 0;
13663 :
13664 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
13665 0 : object = *object_ptr;
13666 :
13667 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
13668 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
13669 :
13670 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
13671 0 : *retval = EG(uninitialized_zval_ptr);
13672 0 : PZVAL_LOCK(*retval);
13673 : }
13674 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13675 0 : ZEND_VM_NEXT_OPCODE();
13676 : }
13677 :
13678 : /* here we are sure we are dealing with an object */
13679 :
13680 : if (0) {
13681 : MAKE_REAL_ZVAL_PTR(property);
13682 : }
13683 :
13684 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
13685 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
13686 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
13687 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
13688 :
13689 0 : have_get_ptr = 1;
13690 0 : incdec_op(*zptr);
13691 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
13692 0 : *retval = *zptr;
13693 0 : PZVAL_LOCK(*retval);
13694 : }
13695 : }
13696 : }
13697 :
13698 0 : if (!have_get_ptr) {
13699 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
13700 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
13701 :
13702 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
13703 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
13704 :
13705 0 : if (z->refcount == 0) {
13706 0 : zval_dtor(z);
13707 0 : FREE_ZVAL(z);
13708 : }
13709 0 : z = value;
13710 : }
13711 0 : z->refcount++;
13712 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
13713 0 : incdec_op(z);
13714 0 : *retval = z;
13715 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
13716 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
13717 0 : zval_ptr_dtor(&z);
13718 : } else {
13719 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
13720 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
13721 0 : *retval = EG(uninitialized_zval_ptr);
13722 0 : PZVAL_LOCK(*retval);
13723 : }
13724 : }
13725 : }
13726 :
13727 : if (0) {
13728 : zval_ptr_dtor(&property);
13729 : } else {
13730 :
13731 : }
13732 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13733 0 : ZEND_VM_NEXT_OPCODE();
13734 : }
13735 :
13736 : static int ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13737 0 : {
13738 0 : return zend_pre_incdec_property_helper_SPEC_VAR_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13739 : }
13740 :
13741 : static int ZEND_PRE_DEC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13742 0 : {
13743 0 : return zend_pre_incdec_property_helper_SPEC_VAR_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13744 : }
13745 :
13746 : static int zend_post_incdec_property_helper_SPEC_VAR_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
13747 0 : {
13748 0 : zend_op *opline = EX(opline);
13749 : zend_free_op free_op1;
13750 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13751 : zval *object;
13752 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
13753 0 : zval *retval = &EX_T(opline->result.u.var).tmp_var;
13754 0 : int have_get_ptr = 0;
13755 :
13756 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
13757 0 : object = *object_ptr;
13758 :
13759 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
13760 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
13761 :
13762 0 : *retval = *EG(uninitialized_zval_ptr);
13763 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13764 0 : ZEND_VM_NEXT_OPCODE();
13765 : }
13766 :
13767 : /* here we are sure we are dealing with an object */
13768 :
13769 : if (0) {
13770 : MAKE_REAL_ZVAL_PTR(property);
13771 : }
13772 :
13773 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
13774 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
13775 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
13776 0 : have_get_ptr = 1;
13777 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
13778 :
13779 0 : *retval = **zptr;
13780 0 : zendi_zval_copy_ctor(*retval);
13781 :
13782 0 : incdec_op(*zptr);
13783 :
13784 : }
13785 : }
13786 :
13787 0 : if (!have_get_ptr) {
13788 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
13789 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
13790 : zval *z_copy;
13791 :
13792 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
13793 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
13794 :
13795 0 : if (z->refcount == 0) {
13796 0 : zval_dtor(z);
13797 0 : FREE_ZVAL(z);
13798 : }
13799 0 : z = value;
13800 : }
13801 0 : *retval = *z;
13802 0 : zendi_zval_copy_ctor(*retval);
13803 0 : ALLOC_ZVAL(z_copy);
13804 0 : *z_copy = *z;
13805 0 : zendi_zval_copy_ctor(*z_copy);
13806 0 : INIT_PZVAL(z_copy);
13807 0 : incdec_op(z_copy);
13808 0 : z->refcount++;
13809 0 : Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
13810 0 : zval_ptr_dtor(&z_copy);
13811 0 : zval_ptr_dtor(&z);
13812 : } else {
13813 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
13814 0 : *retval = *EG(uninitialized_zval_ptr);
13815 : }
13816 : }
13817 :
13818 : if (0) {
13819 : zval_ptr_dtor(&property);
13820 : } else {
13821 :
13822 : }
13823 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13824 0 : ZEND_VM_NEXT_OPCODE();
13825 : }
13826 :
13827 : static int ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13828 0 : {
13829 0 : return zend_post_incdec_property_helper_SPEC_VAR_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13830 : }
13831 :
13832 : static int ZEND_POST_DEC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13833 0 : {
13834 0 : return zend_post_incdec_property_helper_SPEC_VAR_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13835 : }
13836 :
13837 : static int ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13838 38 : {
13839 38 : zend_op *opline = EX(opline);
13840 : zend_free_op free_op1;
13841 38 : zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
13842 :
13843 38 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK &&
13844 : IS_VAR != IS_CV &&
13845 : EX_T(opline->op1.u.var).var.ptr_ptr) {
13846 0 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
13847 : }
13848 38 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_R TSRMLS_CC);
13849 :
13850 38 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13851 38 : ZEND_VM_NEXT_OPCODE();
13852 : }
13853 :
13854 : static int ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13855 0 : {
13856 0 : zend_op *opline = EX(opline);
13857 : zend_free_op free_op1;
13858 0 : zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
13859 :
13860 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_W TSRMLS_CC);
13861 :
13862 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
13863 : READY_TO_DESTROY(free_op1.var) &&
13864 : !RETURN_VALUE_UNUSED(&opline->result)) {
13865 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
13866 : }
13867 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13868 0 : ZEND_VM_NEXT_OPCODE();
13869 : }
13870 :
13871 : static int ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13872 0 : {
13873 0 : zend_op *opline = EX(opline);
13874 : zend_free_op free_op1;
13875 0 : zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
13876 :
13877 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
13878 :
13879 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
13880 : READY_TO_DESTROY(free_op1.var) &&
13881 : !RETURN_VALUE_UNUSED(&opline->result)) {
13882 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
13883 : }
13884 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13885 0 : ZEND_VM_NEXT_OPCODE();
13886 : }
13887 :
13888 : static int ZEND_FETCH_DIM_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13889 0 : {
13890 0 : zend_op *opline = EX(opline);
13891 : zend_free_op free_op1;
13892 0 : zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
13893 :
13894 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_IS TSRMLS_CC);
13895 :
13896 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13897 0 : ZEND_VM_NEXT_OPCODE();
13898 : }
13899 :
13900 : static int ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13901 0 : {
13902 0 : zend_op *opline = EX(opline);
13903 : zend_free_op free_op1;
13904 0 : int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
13905 : zval *dim;
13906 :
13907 : if (IS_CV == IS_UNUSED && type == BP_VAR_R) {
13908 : zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
13909 : }
13910 0 : dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
13911 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, type TSRMLS_CC);
13912 :
13913 0 : if (IS_VAR == IS_VAR && type == BP_VAR_W && (free_op1.var != NULL) &&
13914 : READY_TO_DESTROY(free_op1.var) &&
13915 : !RETURN_VALUE_UNUSED(&opline->result)) {
13916 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
13917 : }
13918 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13919 0 : ZEND_VM_NEXT_OPCODE();
13920 : }
13921 :
13922 : static int ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13923 0 : {
13924 0 : zend_op *opline = EX(opline);
13925 : zend_free_op free_op1;
13926 0 : zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13927 0 : zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
13928 :
13929 : /* Not needed in DIM_UNSET
13930 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
13931 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
13932 : }
13933 : */
13934 : if (IS_VAR == IS_CV) {
13935 : if (container != &EG(uninitialized_zval_ptr)) {
13936 : SEPARATE_ZVAL_IF_NOT_REF(container);
13937 : }
13938 : }
13939 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_UNSET TSRMLS_CC);
13940 :
13941 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
13942 : READY_TO_DESTROY(free_op1.var) &&
13943 : !RETURN_VALUE_UNUSED(&opline->result)) {
13944 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
13945 : }
13946 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13947 0 : if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
13948 0 : zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
13949 : } else {
13950 : zend_free_op free_res;
13951 :
13952 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
13953 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
13954 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
13955 : }
13956 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
13957 0 : FREE_OP_VAR_PTR(free_res);
13958 : }
13959 0 : ZEND_VM_NEXT_OPCODE();
13960 : }
13961 :
13962 : static int zend_fetch_property_address_read_helper_SPEC_VAR_CV(int type, ZEND_OPCODE_HANDLER_ARGS)
13963 0 : {
13964 0 : zend_op *opline = EX(opline);
13965 : zval *container;
13966 : zval **retval;
13967 : zend_free_op free_op1;
13968 :
13969 0 : retval = &EX_T(opline->result.u.var).var.ptr;
13970 0 : EX_T(opline->result.u.var).var.ptr_ptr = retval;
13971 :
13972 0 : container = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
13973 :
13974 0 : if (container == EG(error_zval_ptr)) {
13975 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
13976 0 : *retval = EG(error_zval_ptr);
13977 0 : PZVAL_LOCK(*retval);
13978 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
13979 : }
13980 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
13981 0 : ZEND_VM_NEXT_OPCODE();
13982 : }
13983 :
13984 :
13985 0 : if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
13986 0 : if (type != BP_VAR_IS) {
13987 0 : zend_error(E_NOTICE, "Trying to get property of non-object");
13988 : }
13989 0 : *retval = EG(uninitialized_zval_ptr);
13990 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
13991 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
13992 : } else {
13993 :
13994 0 : zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
13995 :
13996 : if (0) {
13997 : MAKE_REAL_ZVAL_PTR(offset);
13998 : }
13999 :
14000 : /* here we are sure we are dealing with an object */
14001 0 : *retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
14002 :
14003 0 : if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
14004 0 : zval_dtor(*retval);
14005 0 : FREE_ZVAL(*retval);
14006 : } else {
14007 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
14008 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
14009 : }
14010 :
14011 : if (0) {
14012 : zval_ptr_dtor(&offset);
14013 : } else {
14014 :
14015 : }
14016 : }
14017 :
14018 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14019 0 : ZEND_VM_NEXT_OPCODE();
14020 : }
14021 :
14022 : static int ZEND_FETCH_OBJ_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14023 0 : {
14024 0 : return zend_fetch_property_address_read_helper_SPEC_VAR_CV(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14025 : }
14026 :
14027 : static int ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14028 0 : {
14029 0 : zend_op *opline = EX(opline);
14030 : zend_free_op free_op1;
14031 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
14032 :
14033 0 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_VAR != IS_CV) {
14034 0 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
14035 0 : EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
14036 : }
14037 :
14038 : if (0) {
14039 : MAKE_REAL_ZVAL_PTR(property);
14040 : }
14041 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
14042 : if (0) {
14043 : zval_ptr_dtor(&property);
14044 : } else {
14045 :
14046 : }
14047 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
14048 : READY_TO_DESTROY(free_op1.var) &&
14049 : !RETURN_VALUE_UNUSED(&opline->result)) {
14050 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
14051 : }
14052 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14053 0 : ZEND_VM_NEXT_OPCODE();
14054 : }
14055 :
14056 : static int ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14057 0 : {
14058 0 : zend_op *opline = EX(opline);
14059 : zend_free_op free_op1;
14060 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
14061 :
14062 : if (0) {
14063 : MAKE_REAL_ZVAL_PTR(property);
14064 : }
14065 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_RW TSRMLS_CC);
14066 : if (0) {
14067 : zval_ptr_dtor(&property);
14068 : } else {
14069 :
14070 : }
14071 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
14072 : READY_TO_DESTROY(free_op1.var) &&
14073 : !RETURN_VALUE_UNUSED(&opline->result)) {
14074 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
14075 : }
14076 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14077 0 : ZEND_VM_NEXT_OPCODE();
14078 : }
14079 :
14080 : static int ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14081 0 : {
14082 0 : return zend_fetch_property_address_read_helper_SPEC_VAR_CV(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14083 : }
14084 :
14085 : static int ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14086 0 : {
14087 0 : zend_op *opline = EX(opline);
14088 :
14089 0 : if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
14090 : /* Behave like FETCH_OBJ_W */
14091 : zend_free_op free_op1;
14092 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
14093 :
14094 : if (0) {
14095 : MAKE_REAL_ZVAL_PTR(property);
14096 : }
14097 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
14098 : if (0) {
14099 : zval_ptr_dtor(&property);
14100 : } else {
14101 :
14102 : }
14103 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
14104 : READY_TO_DESTROY(free_op1.var) &&
14105 : !RETURN_VALUE_UNUSED(&opline->result)) {
14106 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
14107 : }
14108 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14109 0 : ZEND_VM_NEXT_OPCODE();
14110 : } else {
14111 0 : return zend_fetch_property_address_read_helper_SPEC_VAR_CV(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14112 : }
14113 : }
14114 :
14115 : static int ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14116 0 : {
14117 0 : zend_op *opline = EX(opline);
14118 : zend_free_op free_op1, free_res;
14119 0 : zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14120 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
14121 :
14122 : if (IS_VAR == IS_CV) {
14123 : if (container != &EG(uninitialized_zval_ptr)) {
14124 : SEPARATE_ZVAL_IF_NOT_REF(container);
14125 : }
14126 : }
14127 : if (0) {
14128 : MAKE_REAL_ZVAL_PTR(property);
14129 : }
14130 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
14131 : if (0) {
14132 : zval_ptr_dtor(&property);
14133 : } else {
14134 :
14135 : }
14136 0 : if (IS_VAR == IS_VAR && (free_op1.var != NULL) &&
14137 : READY_TO_DESTROY(free_op1.var) &&
14138 : !RETURN_VALUE_UNUSED(&opline->result)) {
14139 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
14140 : }
14141 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14142 :
14143 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
14144 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
14145 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
14146 : }
14147 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
14148 0 : FREE_OP_VAR_PTR(free_res);
14149 0 : ZEND_VM_NEXT_OPCODE();
14150 : }
14151 :
14152 : static int ZEND_ASSIGN_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14153 0 : {
14154 0 : zend_op *opline = EX(opline);
14155 0 : zend_op *op_data = opline+1;
14156 : zend_free_op free_op1;
14157 0 : zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14158 :
14159 0 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
14160 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14161 : /* assign_obj has two opcodes! */
14162 0 : ZEND_VM_INC_OPCODE();
14163 0 : ZEND_VM_NEXT_OPCODE();
14164 : }
14165 :
14166 : static int ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14167 55 : {
14168 55 : zend_op *opline = EX(opline);
14169 55 : zend_op *op_data = opline+1;
14170 : zend_free_op free_op1;
14171 : zval **object_ptr;
14172 :
14173 55 : if (IS_VAR == IS_CV || EX_T(opline->op1.u.var).var.ptr_ptr) {
14174 : /* not an array offset */
14175 55 : object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14176 : } else {
14177 0 : object_ptr = NULL;
14178 : }
14179 :
14180 55 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
14181 0 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
14182 : } else {
14183 : zend_free_op free_op_data1;
14184 : zval *value;
14185 55 : zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
14186 :
14187 55 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
14188 :
14189 55 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
14190 55 : zend_assign_to_variable(&opline->result, &op_data->op2, &op_data->op1, value, (IS_TMP_FREE(free_op_data1)?IS_TMP_VAR:op_data->op1.op_type), EX(Ts) TSRMLS_CC);
14191 55 : FREE_OP_IF_VAR(free_op_data1);
14192 : }
14193 55 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14194 : /* assign_dim has two opcodes! */
14195 55 : ZEND_VM_INC_OPCODE();
14196 55 : ZEND_VM_NEXT_OPCODE();
14197 : }
14198 :
14199 : static int ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14200 0 : {
14201 0 : zend_op *opline = EX(opline);
14202 :
14203 0 : zval *value = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
14204 :
14205 0 : zend_assign_to_variable(&opline->result, &opline->op1, &opline->op2, value, (0?IS_TMP_VAR:IS_CV), EX(Ts) TSRMLS_CC);
14206 : /* zend_assign_to_variable() always takes care of op2, never free it! */
14207 :
14208 0 : ZEND_VM_NEXT_OPCODE();
14209 : }
14210 :
14211 : static int ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14212 0 : {
14213 0 : zend_op *opline = EX(opline);
14214 : zend_free_op free_op1, free_op2;
14215 : zval **variable_ptr_ptr;
14216 0 : zval **value_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op2, EX(Ts), BP_VAR_W TSRMLS_CC);
14217 :
14218 : if (IS_CV == IS_VAR &&
14219 : value_ptr_ptr &&
14220 : !(*value_ptr_ptr)->is_ref &&
14221 : opline->extended_value == ZEND_RETURNS_FUNCTION &&
14222 : !EX_T(opline->op2.u.var).var.fcall_returned_reference) {
14223 : if (free_op2.var == NULL) {
14224 : PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
14225 : }
14226 : zend_error(E_STRICT, "Only variables should be assigned by reference");
14227 : return ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14228 : }
14229 0 : if (IS_VAR == IS_VAR && EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
14230 0 : zend_error(E_ERROR, "Cannot assign by reference to overloaded object");
14231 : }
14232 :
14233 0 : variable_ptr_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14234 0 : zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
14235 :
14236 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
14237 0 : EX_T(opline->result.u.var).var.ptr_ptr = variable_ptr_ptr;
14238 0 : PZVAL_LOCK(*variable_ptr_ptr);
14239 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
14240 : }
14241 :
14242 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14243 :
14244 0 : ZEND_VM_NEXT_OPCODE();
14245 : }
14246 :
14247 : static int ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14248 0 : {
14249 0 : zend_op *opline = EX(opline);
14250 : zval *function_name;
14251 : char *function_name_strval;
14252 : int function_name_strlen;
14253 : zend_free_op free_op1;
14254 :
14255 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
14256 :
14257 0 : function_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
14258 :
14259 0 : if (Z_TYPE_P(function_name)!=IS_STRING) {
14260 0 : zend_error_noreturn(E_ERROR, "Method name must be a string");
14261 : }
14262 :
14263 0 : function_name_strval = Z_STRVAL_P(function_name);
14264 0 : function_name_strlen = Z_STRLEN_P(function_name);
14265 :
14266 0 : EX(object) = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14267 :
14268 0 : if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
14269 0 : if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
14270 0 : zend_error_noreturn(E_ERROR, "Object does not support method calls");
14271 : }
14272 :
14273 : /* First, locate the function. */
14274 0 : EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
14275 0 : if (!EX(fbc)) {
14276 0 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
14277 : }
14278 : } else {
14279 0 : zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
14280 : }
14281 :
14282 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
14283 0 : EX(object) = NULL;
14284 : } else {
14285 0 : if (!PZVAL_IS_REF(EX(object))) {
14286 0 : EX(object)->refcount++; /* For $this pointer */
14287 : } else {
14288 : zval *this_ptr;
14289 0 : ALLOC_ZVAL(this_ptr);
14290 0 : INIT_PZVAL_COPY(this_ptr, EX(object));
14291 0 : zval_copy_ctor(this_ptr);
14292 0 : EX(object) = this_ptr;
14293 : }
14294 : }
14295 :
14296 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14297 :
14298 0 : ZEND_VM_NEXT_OPCODE();
14299 : }
14300 :
14301 : static int ZEND_CASE_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14302 0 : {
14303 0 : zend_op *opline = EX(opline);
14304 0 : int switch_expr_is_overloaded=0;
14305 : zend_free_op free_op1;
14306 :
14307 : if (IS_VAR==IS_VAR) {
14308 0 : if (EX_T(opline->op1.u.var).var.ptr_ptr) {
14309 0 : PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
14310 : } else {
14311 0 : switch_expr_is_overloaded = 1;
14312 0 : EX_T(opline->op1.u.var).str_offset.str->refcount++;
14313 : }
14314 : }
14315 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
14316 : _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC),
14317 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
14318 :
14319 0 : if (switch_expr_is_overloaded) {
14320 : /* We only free op1 if this is a string offset,
14321 : * Since if it is a TMP_VAR, it'll be reused by
14322 : * other CASE opcodes (whereas string offsets
14323 : * are allocated at each get_zval_ptr())
14324 : */
14325 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14326 0 : EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
14327 0 : AI_USE_PTR(EX_T(opline->op1.u.var).var);
14328 : }
14329 0 : ZEND_VM_NEXT_OPCODE();
14330 : }
14331 :
14332 : static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14333 0 : {
14334 0 : zend_op *opline = EX(opline);
14335 : zend_free_op free_op1;
14336 0 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
14337 : zval *expr_ptr;
14338 0 : zval *offset=_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
14339 :
14340 : #if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
14341 0 : zval **expr_ptr_ptr = NULL;
14342 :
14343 0 : if (opline->extended_value) {
14344 0 : expr_ptr_ptr=_get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14345 0 : expr_ptr = *expr_ptr_ptr;
14346 : } else {
14347 0 : expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14348 : }
14349 : #else
14350 : expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14351 : #endif
14352 :
14353 : if (0) { /* temporary variable */
14354 : zval *new_expr;
14355 :
14356 : ALLOC_ZVAL(new_expr);
14357 : INIT_PZVAL_COPY(new_expr, expr_ptr);
14358 : expr_ptr = new_expr;
14359 : } else {
14360 : #if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
14361 0 : if (opline->extended_value) {
14362 0 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
14363 0 : expr_ptr = *expr_ptr_ptr;
14364 0 : expr_ptr->refcount++;
14365 : } else
14366 : #endif
14367 0 : if (PZVAL_IS_REF(expr_ptr)) {
14368 : zval *new_expr;
14369 :
14370 0 : ALLOC_ZVAL(new_expr);
14371 0 : INIT_PZVAL_COPY(new_expr, expr_ptr);
14372 0 : expr_ptr = new_expr;
14373 0 : zendi_zval_copy_ctor(*expr_ptr);
14374 : } else {
14375 0 : expr_ptr->refcount++;
14376 : }
14377 : }
14378 0 : if (offset) {
14379 0 : switch (Z_TYPE_P(offset)) {
14380 : case IS_DOUBLE:
14381 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
14382 0 : break;
14383 : case IS_LONG:
14384 : case IS_BOOL:
14385 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
14386 0 : break;
14387 : case IS_STRING:
14388 0 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
14389 0 : break;
14390 : case IS_NULL:
14391 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
14392 0 : break;
14393 : default:
14394 0 : zend_error(E_WARNING, "Illegal offset type");
14395 0 : zval_ptr_dtor(&expr_ptr);
14396 : /* do nothing */
14397 : break;
14398 : }
14399 :
14400 : } else {
14401 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
14402 : }
14403 0 : if (opline->extended_value) {
14404 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14405 : } else {
14406 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14407 : }
14408 0 : ZEND_VM_NEXT_OPCODE();
14409 : }
14410 :
14411 : static int ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14412 0 : {
14413 0 : zend_op *opline = EX(opline);
14414 :
14415 0 : array_init(&EX_T(opline->result.u.var).tmp_var);
14416 : if (IS_VAR == IS_UNUSED) {
14417 : ZEND_VM_NEXT_OPCODE();
14418 : #if 0 || IS_VAR != IS_UNUSED
14419 : } else {
14420 0 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14421 : #endif
14422 : }
14423 : }
14424 :
14425 : static int ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14426 0 : {
14427 0 : zend_op *opline = EX(opline);
14428 : zend_free_op free_op1;
14429 0 : zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14430 0 : zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
14431 : long index;
14432 :
14433 0 : if (container) {
14434 : if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
14435 : SEPARATE_ZVAL_IF_NOT_REF(container);
14436 : }
14437 0 : switch (Z_TYPE_PP(container)) {
14438 : case IS_ARRAY: {
14439 0 : HashTable *ht = Z_ARRVAL_PP(container);
14440 :
14441 0 : switch (Z_TYPE_P(offset)) {
14442 : case IS_DOUBLE:
14443 0 : index = (long) Z_DVAL_P(offset);
14444 0 : zend_hash_index_del(ht, index);
14445 0 : break;
14446 : case IS_RESOURCE:
14447 : case IS_BOOL:
14448 : case IS_LONG:
14449 0 : index = Z_LVAL_P(offset);
14450 0 : zend_hash_index_del(ht, index);
14451 0 : break;
14452 : case IS_STRING:
14453 : if (IS_CV == IS_CV || IS_CV == IS_VAR) {
14454 0 : offset->refcount++;
14455 : }
14456 0 : if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
14457 : ht == &EG(symbol_table)) {
14458 : zend_execute_data *ex;
14459 0 : ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
14460 :
14461 0 : for (ex = execute_data; ex; ex = ex->prev_execute_data) {
14462 0 : if (ex->op_array && ex->symbol_table == ht) {
14463 : int i;
14464 :
14465 0 : for (i = 0; i < ex->op_array->last_var; i++) {
14466 0 : if (ex->op_array->vars[i].hash_value == hash_value &&
14467 : ex->op_array->vars[i].name_len == offset->value.str.len &&
14468 : !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
14469 0 : ex->CVs[i] = NULL;
14470 0 : break;
14471 : }
14472 : }
14473 : }
14474 : }
14475 : }
14476 : if (IS_CV == IS_CV || IS_CV == IS_VAR) {
14477 0 : zval_ptr_dtor(&offset);
14478 : }
14479 0 : break;
14480 : case IS_NULL:
14481 0 : zend_hash_del(ht, "", sizeof(""));
14482 0 : break;
14483 : default:
14484 0 : zend_error(E_WARNING, "Illegal offset type in unset");
14485 : break;
14486 : }
14487 :
14488 0 : break;
14489 : }
14490 : case IS_OBJECT:
14491 0 : if (!Z_OBJ_HT_P(*container)->unset_dimension) {
14492 0 : zend_error_noreturn(E_ERROR, "Cannot use object as array");
14493 : }
14494 : if (0) {
14495 : MAKE_REAL_ZVAL_PTR(offset);
14496 : }
14497 0 : Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
14498 : if (0) {
14499 : zval_ptr_dtor(&offset);
14500 : } else {
14501 :
14502 : }
14503 0 : break;
14504 : case IS_STRING:
14505 0 : zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
14506 : ZEND_VM_CONTINUE(); /* bailed out before */
14507 : default:
14508 :
14509 : break;
14510 : }
14511 : } else {
14512 :
14513 : }
14514 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14515 :
14516 0 : ZEND_VM_NEXT_OPCODE();
14517 : }
14518 :
14519 : static int ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14520 0 : {
14521 0 : zend_op *opline = EX(opline);
14522 : zend_free_op free_op1;
14523 0 : zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14524 0 : zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
14525 :
14526 0 : if (container) {
14527 : if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
14528 : SEPARATE_ZVAL_IF_NOT_REF(container);
14529 : }
14530 0 : if (Z_TYPE_PP(container) == IS_OBJECT) {
14531 : if (0) {
14532 : MAKE_REAL_ZVAL_PTR(offset);
14533 : }
14534 0 : Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
14535 : if (0) {
14536 : zval_ptr_dtor(&offset);
14537 : } else {
14538 :
14539 : }
14540 : } else {
14541 :
14542 : }
14543 : } else {
14544 :
14545 : }
14546 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14547 :
14548 0 : ZEND_VM_NEXT_OPCODE();
14549 : }
14550 :
14551 : static int zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
14552 0 : {
14553 0 : zend_op *opline = EX(opline);
14554 : zend_free_op free_op1;
14555 0 : zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
14556 0 : zval **value = NULL;
14557 0 : int result = 0;
14558 : long index;
14559 :
14560 0 : if (container) {
14561 :
14562 0 : zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
14563 :
14564 0 : if (Z_TYPE_PP(container) == IS_ARRAY) {
14565 : HashTable *ht;
14566 0 : int isset = 0;
14567 :
14568 0 : ht = Z_ARRVAL_PP(container);
14569 :
14570 0 : switch (Z_TYPE_P(offset)) {
14571 : case IS_DOUBLE:
14572 0 : index = (long) Z_DVAL_P(offset);
14573 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
14574 0 : isset = 1;
14575 : }
14576 0 : break;
14577 : case IS_RESOURCE:
14578 : case IS_BOOL:
14579 : case IS_LONG:
14580 0 : index = Z_LVAL_P(offset);
14581 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
14582 0 : isset = 1;
14583 : }
14584 0 : break;
14585 : case IS_STRING:
14586 0 : if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
14587 0 : isset = 1;
14588 : }
14589 0 : break;
14590 : case IS_NULL:
14591 0 : if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
14592 0 : isset = 1;
14593 : }
14594 0 : break;
14595 : default:
14596 0 : zend_error(E_WARNING, "Illegal offset type in isset or empty");
14597 :
14598 : break;
14599 : }
14600 :
14601 0 : switch (opline->extended_value) {
14602 : case ZEND_ISSET:
14603 0 : if (isset && Z_TYPE_PP(value) == IS_NULL) {
14604 0 : result = 0;
14605 : } else {
14606 0 : result = isset;
14607 : }
14608 0 : break;
14609 : case ZEND_ISEMPTY:
14610 0 : if (!isset || !i_zend_is_true(*value)) {
14611 0 : result = 0;
14612 : } else {
14613 0 : result = 1;
14614 : }
14615 : break;
14616 : }
14617 :
14618 0 : } else if (Z_TYPE_PP(container) == IS_OBJECT) {
14619 : if (0) {
14620 : MAKE_REAL_ZVAL_PTR(offset);
14621 : }
14622 0 : if (prop_dim) {
14623 0 : result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
14624 : } else {
14625 0 : result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
14626 : }
14627 : if (0) {
14628 : zval_ptr_dtor(&offset);
14629 : } else {
14630 :
14631 : }
14632 0 : } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
14633 : zval tmp;
14634 :
14635 0 : if (Z_TYPE_P(offset) != IS_LONG) {
14636 0 : tmp = *offset;
14637 0 : zval_copy_ctor(&tmp);
14638 0 : convert_to_long(&tmp);
14639 0 : offset = &tmp;
14640 : }
14641 0 : if (Z_TYPE_P(offset) == IS_LONG) {
14642 0 : switch (opline->extended_value) {
14643 : case ZEND_ISSET:
14644 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
14645 0 : result = 1;
14646 : }
14647 0 : break;
14648 : case ZEND_ISEMPTY:
14649 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
14650 0 : result = 1;
14651 : }
14652 : break;
14653 : }
14654 : }
14655 :
14656 : } else {
14657 :
14658 : }
14659 : }
14660 :
14661 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
14662 :
14663 0 : switch (opline->extended_value) {
14664 : case ZEND_ISSET:
14665 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
14666 0 : break;
14667 : case ZEND_ISEMPTY:
14668 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
14669 : break;
14670 : }
14671 :
14672 0 : if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
14673 :
14674 0 : ZEND_VM_NEXT_OPCODE();
14675 : }
14676 :
14677 : static int ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14678 0 : {
14679 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14680 : }
14681 :
14682 : static int ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14683 0 : {
14684 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14685 : }
14686 :
14687 : static int ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14688 0 : {
14689 0 : zend_op *opline = EX(opline);
14690 :
14691 0 : zval *obj = _get_obj_zval_ptr_unused(TSRMLS_C);
14692 : zend_class_entry *ce;
14693 : zend_function *clone;
14694 : zend_object_clone_obj_t clone_call;
14695 :
14696 0 : if (!obj || Z_TYPE_P(obj) != IS_OBJECT) {
14697 0 : zend_error(E_WARNING, "__clone method called on non-object");
14698 0 : EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
14699 0 : EX_T(opline->result.u.var).var.ptr->refcount++;
14700 :
14701 0 : ZEND_VM_NEXT_OPCODE();
14702 : }
14703 :
14704 0 : ce = Z_OBJCE_P(obj);
14705 0 : clone = ce ? ce->clone : NULL;
14706 0 : clone_call = Z_OBJ_HT_P(obj)->clone_obj;
14707 0 : if (!clone_call) {
14708 0 : if (ce) {
14709 0 : zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
14710 : } else {
14711 0 : zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
14712 : }
14713 : EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
14714 : EX_T(opline->result.u.var).var.ptr->refcount++;
14715 : }
14716 :
14717 0 : if (ce && clone) {
14718 0 : if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
14719 : /* Ensure that if we're calling a private function, we're allowed to do so.
14720 : */
14721 0 : if (ce != EG(scope)) {
14722 0 : zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
14723 : }
14724 0 : } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
14725 : /* Ensure that if we're calling a protected function, we're allowed to do so.
14726 : */
14727 0 : if (!zend_check_protected(clone->common.scope, EG(scope))) {
14728 0 : zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
14729 : }
14730 : }
14731 : }
14732 :
14733 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
14734 0 : if (!EG(exception)) {
14735 0 : ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
14736 0 : Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC);
14737 0 : Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
14738 0 : EX_T(opline->result.u.var).var.ptr->refcount=1;
14739 0 : EX_T(opline->result.u.var).var.ptr->is_ref=1;
14740 0 : if (!RETURN_VALUE_USED(opline) || EG(exception)) {
14741 0 : zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
14742 : }
14743 : }
14744 :
14745 0 : ZEND_VM_NEXT_OPCODE();
14746 : }
14747 :
14748 : static int ZEND_EXIT_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14749 1 : {
14750 : #if 0 || (IS_UNUSED != IS_UNUSED)
14751 : zend_op *opline = EX(opline);
14752 : if (IS_UNUSED != IS_UNUSED) {
14753 :
14754 : zval *ptr = NULL;
14755 :
14756 : if (Z_TYPE_P(ptr) == IS_LONG) {
14757 : EG(exit_status) = Z_LVAL_P(ptr);
14758 : } else {
14759 : zend_print_variable(ptr);
14760 : }
14761 :
14762 : }
14763 : #endif
14764 1 : zend_bailout();
14765 0 : ZEND_VM_NEXT_OPCODE();
14766 : }
14767 :
14768 : static int zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
14769 0 : {
14770 0 : zend_op *opline = EX(opline);
14771 0 : zend_op *op_data = opline+1;
14772 : zend_free_op free_op_data1;
14773 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
14774 : zval *object;
14775 0 : zval *property = &opline->op2.u.constant;
14776 0 : zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
14777 0 : znode *result = &opline->result;
14778 0 : zval **retval = &EX_T(result->u.var).var.ptr;
14779 0 : int have_get_ptr = 0;
14780 :
14781 0 : EX_T(result->u.var).var.ptr_ptr = NULL;
14782 0 : make_real_object(object_ptr TSRMLS_CC);
14783 0 : object = *object_ptr;
14784 :
14785 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
14786 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
14787 :
14788 0 : FREE_OP(free_op_data1);
14789 :
14790 0 : if (!RETURN_VALUE_UNUSED(result)) {
14791 0 : *retval = EG(uninitialized_zval_ptr);
14792 0 : PZVAL_LOCK(*retval);
14793 : }
14794 : } else {
14795 : /* here we are sure we are dealing with an object */
14796 : if (0) {
14797 : MAKE_REAL_ZVAL_PTR(property);
14798 : }
14799 :
14800 : /* here property is a string */
14801 0 : if (opline->extended_value == ZEND_ASSIGN_OBJ
14802 : && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
14803 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
14804 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
14805 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
14806 :
14807 0 : have_get_ptr = 1;
14808 0 : binary_op(*zptr, *zptr, value TSRMLS_CC);
14809 0 : if (!RETURN_VALUE_UNUSED(result)) {
14810 0 : *retval = *zptr;
14811 0 : PZVAL_LOCK(*retval);
14812 : }
14813 : }
14814 : }
14815 :
14816 0 : if (!have_get_ptr) {
14817 0 : zval *z = NULL;
14818 :
14819 0 : switch (opline->extended_value) {
14820 : case ZEND_ASSIGN_OBJ:
14821 0 : if (Z_OBJ_HT_P(object)->read_property) {
14822 0 : z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
14823 : }
14824 0 : break;
14825 : case ZEND_ASSIGN_DIM:
14826 0 : if (Z_OBJ_HT_P(object)->read_dimension) {
14827 0 : z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
14828 : }
14829 : break;
14830 : }
14831 0 : if (z) {
14832 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
14833 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
14834 :
14835 0 : if (z->refcount == 0) {
14836 0 : zval_dtor(z);
14837 0 : FREE_ZVAL(z);
14838 : }
14839 0 : z = value;
14840 : }
14841 0 : z->refcount++;
14842 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
14843 0 : binary_op(z, z, value TSRMLS_CC);
14844 0 : switch (opline->extended_value) {
14845 : case ZEND_ASSIGN_OBJ:
14846 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
14847 0 : break;
14848 : case ZEND_ASSIGN_DIM:
14849 0 : Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
14850 : break;
14851 : }
14852 0 : if (!RETURN_VALUE_UNUSED(result)) {
14853 0 : *retval = z;
14854 0 : PZVAL_LOCK(*retval);
14855 : }
14856 0 : zval_ptr_dtor(&z);
14857 : } else {
14858 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
14859 0 : if (!RETURN_VALUE_UNUSED(result)) {
14860 0 : *retval = EG(uninitialized_zval_ptr);
14861 0 : PZVAL_LOCK(*retval);
14862 : }
14863 : }
14864 : }
14865 :
14866 : if (0) {
14867 : zval_ptr_dtor(&property);
14868 : } else {
14869 :
14870 : }
14871 0 : FREE_OP(free_op_data1);
14872 : }
14873 :
14874 : /* assign_obj has two opcodes! */
14875 0 : ZEND_VM_INC_OPCODE();
14876 0 : ZEND_VM_NEXT_OPCODE();
14877 : }
14878 :
14879 : static int zend_binary_assign_op_helper_SPEC_UNUSED_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
14880 0 : {
14881 0 : zend_op *opline = EX(opline);
14882 : zend_free_op free_op_data2, free_op_data1;
14883 : zval **var_ptr;
14884 : zval *value;
14885 0 : zend_bool increment_opline = 0;
14886 :
14887 0 : switch (opline->extended_value) {
14888 : case ZEND_ASSIGN_OBJ:
14889 0 : return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14890 : break;
14891 : case ZEND_ASSIGN_DIM: {
14892 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
14893 :
14894 0 : if (object_ptr && IS_UNUSED != IS_CV && !0) {
14895 0 : (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
14896 : }
14897 :
14898 0 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
14899 0 : return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14900 : } else {
14901 0 : zend_op *op_data = opline+1;
14902 0 : zval *dim = &opline->op2.u.constant;
14903 :
14904 0 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), NULL, dim, 0, BP_VAR_RW TSRMLS_CC);
14905 0 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
14906 0 : var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
14907 0 : increment_opline = 1;
14908 : }
14909 : }
14910 0 : break;
14911 : default:
14912 0 : value = &opline->op2.u.constant;
14913 0 : var_ptr = NULL;
14914 : /* do nothing */
14915 : break;
14916 : }
14917 :
14918 0 : if (!var_ptr) {
14919 0 : zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
14920 : }
14921 :
14922 0 : if (*var_ptr == EG(error_zval_ptr)) {
14923 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
14924 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
14925 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
14926 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
14927 : }
14928 :
14929 :
14930 0 : if (increment_opline) {
14931 0 : ZEND_VM_INC_OPCODE();
14932 : }
14933 0 : ZEND_VM_NEXT_OPCODE();
14934 : }
14935 :
14936 0 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
14937 :
14938 0 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
14939 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
14940 : /* proxy object */
14941 0 : zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
14942 0 : objval->refcount++;
14943 0 : binary_op(objval, objval, value TSRMLS_CC);
14944 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
14945 0 : zval_ptr_dtor(&objval);
14946 : } else {
14947 0 : binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
14948 : }
14949 :
14950 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
14951 0 : EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
14952 0 : PZVAL_LOCK(*var_ptr);
14953 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
14954 : }
14955 :
14956 0 : if (increment_opline) {
14957 0 : ZEND_VM_INC_OPCODE();
14958 0 : FREE_OP(free_op_data1);
14959 0 : FREE_OP_VAR_PTR(free_op_data2);
14960 : }
14961 :
14962 0 : ZEND_VM_NEXT_OPCODE();
14963 : }
14964 :
14965 : static int ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14966 0 : {
14967 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14968 : }
14969 :
14970 : static int ZEND_ASSIGN_SUB_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14971 0 : {
14972 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14973 : }
14974 :
14975 : static int ZEND_ASSIGN_MUL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14976 0 : {
14977 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14978 : }
14979 :
14980 : static int ZEND_ASSIGN_DIV_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14981 0 : {
14982 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14983 : }
14984 :
14985 : static int ZEND_ASSIGN_MOD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14986 0 : {
14987 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14988 : }
14989 :
14990 : static int ZEND_ASSIGN_SL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14991 0 : {
14992 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14993 : }
14994 :
14995 : static int ZEND_ASSIGN_SR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14996 0 : {
14997 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14998 : }
14999 :
15000 : static int ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15001 0 : {
15002 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15003 : }
15004 :
15005 : static int ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15006 0 : {
15007 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15008 : }
15009 :
15010 : static int ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15011 0 : {
15012 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15013 : }
15014 :
15015 : static int ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15016 0 : {
15017 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15018 : }
15019 :
15020 : static int zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
15021 0 : {
15022 0 : zend_op *opline = EX(opline);
15023 :
15024 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
15025 : zval *object;
15026 0 : zval *property = &opline->op2.u.constant;
15027 0 : zval **retval = &EX_T(opline->result.u.var).var.ptr;
15028 0 : int have_get_ptr = 0;
15029 :
15030 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
15031 0 : object = *object_ptr;
15032 :
15033 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
15034 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
15035 :
15036 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
15037 0 : *retval = EG(uninitialized_zval_ptr);
15038 0 : PZVAL_LOCK(*retval);
15039 : }
15040 :
15041 0 : ZEND_VM_NEXT_OPCODE();
15042 : }
15043 :
15044 : /* here we are sure we are dealing with an object */
15045 :
15046 : if (0) {
15047 : MAKE_REAL_ZVAL_PTR(property);
15048 : }
15049 :
15050 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
15051 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
15052 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
15053 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
15054 :
15055 0 : have_get_ptr = 1;
15056 0 : incdec_op(*zptr);
15057 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
15058 0 : *retval = *zptr;
15059 0 : PZVAL_LOCK(*retval);
15060 : }
15061 : }
15062 : }
15063 :
15064 0 : if (!have_get_ptr) {
15065 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
15066 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
15067 :
15068 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
15069 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
15070 :
15071 0 : if (z->refcount == 0) {
15072 0 : zval_dtor(z);
15073 0 : FREE_ZVAL(z);
15074 : }
15075 0 : z = value;
15076 : }
15077 0 : z->refcount++;
15078 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
15079 0 : incdec_op(z);
15080 0 : *retval = z;
15081 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
15082 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
15083 0 : zval_ptr_dtor(&z);
15084 : } else {
15085 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
15086 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
15087 0 : *retval = EG(uninitialized_zval_ptr);
15088 0 : PZVAL_LOCK(*retval);
15089 : }
15090 : }
15091 : }
15092 :
15093 : if (0) {
15094 : zval_ptr_dtor(&property);
15095 : } else {
15096 :
15097 : }
15098 :
15099 0 : ZEND_VM_NEXT_OPCODE();
15100 : }
15101 :
15102 : static int ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15103 0 : {
15104 0 : return zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15105 : }
15106 :
15107 : static int ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15108 0 : {
15109 0 : return zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15110 : }
15111 :
15112 : static int zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
15113 0 : {
15114 0 : zend_op *opline = EX(opline);
15115 :
15116 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
15117 : zval *object;
15118 0 : zval *property = &opline->op2.u.constant;
15119 0 : zval *retval = &EX_T(opline->result.u.var).tmp_var;
15120 0 : int have_get_ptr = 0;
15121 :
15122 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
15123 0 : object = *object_ptr;
15124 :
15125 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
15126 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
15127 :
15128 0 : *retval = *EG(uninitialized_zval_ptr);
15129 :
15130 0 : ZEND_VM_NEXT_OPCODE();
15131 : }
15132 :
15133 : /* here we are sure we are dealing with an object */
15134 :
15135 : if (0) {
15136 : MAKE_REAL_ZVAL_PTR(property);
15137 : }
15138 :
15139 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
15140 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
15141 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
15142 0 : have_get_ptr = 1;
15143 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
15144 :
15145 0 : *retval = **zptr;
15146 0 : zendi_zval_copy_ctor(*retval);
15147 :
15148 0 : incdec_op(*zptr);
15149 :
15150 : }
15151 : }
15152 :
15153 0 : if (!have_get_ptr) {
15154 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
15155 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
15156 : zval *z_copy;
15157 :
15158 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
15159 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
15160 :
15161 0 : if (z->refcount == 0) {
15162 0 : zval_dtor(z);
15163 0 : FREE_ZVAL(z);
15164 : }
15165 0 : z = value;
15166 : }
15167 0 : *retval = *z;
15168 0 : zendi_zval_copy_ctor(*retval);
15169 0 : ALLOC_ZVAL(z_copy);
15170 0 : *z_copy = *z;
15171 0 : zendi_zval_copy_ctor(*z_copy);
15172 0 : INIT_PZVAL(z_copy);
15173 0 : incdec_op(z_copy);
15174 0 : z->refcount++;
15175 0 : Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
15176 0 : zval_ptr_dtor(&z_copy);
15177 0 : zval_ptr_dtor(&z);
15178 : } else {
15179 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
15180 0 : *retval = *EG(uninitialized_zval_ptr);
15181 : }
15182 : }
15183 :
15184 : if (0) {
15185 : zval_ptr_dtor(&property);
15186 : } else {
15187 :
15188 : }
15189 :
15190 0 : ZEND_VM_NEXT_OPCODE();
15191 : }
15192 :
15193 : static int ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15194 0 : {
15195 0 : return zend_post_incdec_property_helper_SPEC_UNUSED_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15196 : }
15197 :
15198 : static int ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15199 0 : {
15200 0 : return zend_post_incdec_property_helper_SPEC_UNUSED_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15201 : }
15202 :
15203 : static int zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
15204 177 : {
15205 177 : zend_op *opline = EX(opline);
15206 : zval *container;
15207 : zval **retval;
15208 :
15209 :
15210 177 : retval = &EX_T(opline->result.u.var).var.ptr;
15211 177 : EX_T(opline->result.u.var).var.ptr_ptr = retval;
15212 :
15213 177 : container = _get_obj_zval_ptr_unused(TSRMLS_C);
15214 :
15215 177 : if (container == EG(error_zval_ptr)) {
15216 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
15217 0 : *retval = EG(error_zval_ptr);
15218 0 : PZVAL_LOCK(*retval);
15219 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
15220 : }
15221 :
15222 0 : ZEND_VM_NEXT_OPCODE();
15223 : }
15224 :
15225 :
15226 177 : if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
15227 0 : if (type != BP_VAR_IS) {
15228 0 : zend_error(E_NOTICE, "Trying to get property of non-object");
15229 : }
15230 0 : *retval = EG(uninitialized_zval_ptr);
15231 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
15232 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
15233 : } else {
15234 :
15235 177 : zval *offset = &opline->op2.u.constant;
15236 :
15237 : if (0) {
15238 : MAKE_REAL_ZVAL_PTR(offset);
15239 : }
15240 :
15241 : /* here we are sure we are dealing with an object */
15242 177 : *retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
15243 :
15244 177 : if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
15245 0 : zval_dtor(*retval);
15246 0 : FREE_ZVAL(*retval);
15247 : } else {
15248 177 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
15249 177 : AI_USE_PTR(EX_T(opline->result.u.var).var);
15250 : }
15251 :
15252 : if (0) {
15253 : zval_ptr_dtor(&offset);
15254 : } else {
15255 :
15256 : }
15257 : }
15258 :
15259 177 : ZEND_VM_NEXT_OPCODE();
15260 : }
15261 :
15262 : static int ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15263 177 : {
15264 177 : return zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15265 : }
15266 :
15267 : static int ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15268 99 : {
15269 99 : zend_op *opline = EX(opline);
15270 : zend_free_op free_op1;
15271 99 : zval *property = &opline->op2.u.constant;
15272 :
15273 99 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_UNUSED != IS_CV) {
15274 0 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
15275 0 : EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
15276 : }
15277 :
15278 : if (0) {
15279 : MAKE_REAL_ZVAL_PTR(property);
15280 : }
15281 99 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(TSRMLS_C), property, BP_VAR_W TSRMLS_CC);
15282 : if (0) {
15283 : zval_ptr_dtor(&property);
15284 : } else {
15285 :
15286 : }
15287 : if (IS_UNUSED == IS_VAR && 0 &&
15288 : READY_TO_DESTROY(free_op1.var) &&
15289 : !RETURN_VALUE_UNUSED(&opline->result)) {
15290 : AI_USE_PTR(EX_T(opline->result.u.var).var);
15291 : }
15292 :
15293 98 : ZEND_VM_NEXT_OPCODE();
15294 : }
15295 :
15296 : static int ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15297 0 : {
15298 0 : zend_op *opline = EX(opline);
15299 : zend_free_op free_op1;
15300 0 : zval *property = &opline->op2.u.constant;
15301 :
15302 : if (0) {
15303 : MAKE_REAL_ZVAL_PTR(property);
15304 : }
15305 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(TSRMLS_C), property, BP_VAR_RW TSRMLS_CC);
15306 : if (0) {
15307 : zval_ptr_dtor(&property);
15308 : } else {
15309 :
15310 : }
15311 : if (IS_UNUSED == IS_VAR && 0 &&
15312 : READY_TO_DESTROY(free_op1.var) &&
15313 : !RETURN_VALUE_UNUSED(&opline->result)) {
15314 : AI_USE_PTR(EX_T(opline->result.u.var).var);
15315 : }
15316 :
15317 0 : ZEND_VM_NEXT_OPCODE();
15318 : }
15319 :
15320 : static int ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15321 0 : {
15322 0 : return zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15323 : }
15324 :
15325 : static int ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15326 0 : {
15327 0 : zend_op *opline = EX(opline);
15328 :
15329 0 : if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
15330 : /* Behave like FETCH_OBJ_W */
15331 : zend_free_op free_op1;
15332 0 : zval *property = &opline->op2.u.constant;
15333 :
15334 : if (0) {
15335 : MAKE_REAL_ZVAL_PTR(property);
15336 : }
15337 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(TSRMLS_C), property, BP_VAR_W TSRMLS_CC);
15338 : if (0) {
15339 : zval_ptr_dtor(&property);
15340 : } else {
15341 :
15342 : }
15343 : if (IS_UNUSED == IS_VAR && 0 &&
15344 : READY_TO_DESTROY(free_op1.var) &&
15345 : !RETURN_VALUE_UNUSED(&opline->result)) {
15346 : AI_USE_PTR(EX_T(opline->result.u.var).var);
15347 : }
15348 :
15349 0 : ZEND_VM_NEXT_OPCODE();
15350 : } else {
15351 0 : return zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15352 : }
15353 : }
15354 :
15355 : static int ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15356 0 : {
15357 0 : zend_op *opline = EX(opline);
15358 : zend_free_op free_op1, free_res;
15359 0 : zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
15360 0 : zval *property = &opline->op2.u.constant;
15361 :
15362 : if (IS_UNUSED == IS_CV) {
15363 : if (container != &EG(uninitialized_zval_ptr)) {
15364 : SEPARATE_ZVAL_IF_NOT_REF(container);
15365 : }
15366 : }
15367 : if (0) {
15368 : MAKE_REAL_ZVAL_PTR(property);
15369 : }
15370 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
15371 : if (0) {
15372 : zval_ptr_dtor(&property);
15373 : } else {
15374 :
15375 : }
15376 : if (IS_UNUSED == IS_VAR && 0 &&
15377 : READY_TO_DESTROY(free_op1.var) &&
15378 : !RETURN_VALUE_UNUSED(&opline->result)) {
15379 : AI_USE_PTR(EX_T(opline->result.u.var).var);
15380 : }
15381 :
15382 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
15383 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
15384 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
15385 : }
15386 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
15387 0 : FREE_OP_VAR_PTR(free_res);
15388 0 : ZEND_VM_NEXT_OPCODE();
15389 : }
15390 :
15391 : static int ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15392 2 : {
15393 2 : zend_op *opline = EX(opline);
15394 2 : zend_op *op_data = opline+1;
15395 :
15396 2 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
15397 :
15398 2 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
15399 :
15400 : /* assign_obj has two opcodes! */
15401 2 : ZEND_VM_INC_OPCODE();
15402 2 : ZEND_VM_NEXT_OPCODE();
15403 : }
15404 :
15405 : static int ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15406 860 : {
15407 860 : zend_op *opline = EX(opline);
15408 : zval *function_name;
15409 : char *function_name_strval;
15410 : int function_name_strlen;
15411 :
15412 :
15413 860 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
15414 :
15415 860 : function_name = &opline->op2.u.constant;
15416 :
15417 860 : if (Z_TYPE_P(function_name)!=IS_STRING) {
15418 0 : zend_error_noreturn(E_ERROR, "Method name must be a string");
15419 : }
15420 :
15421 860 : function_name_strval = Z_STRVAL_P(function_name);
15422 860 : function_name_strlen = Z_STRLEN_P(function_name);
15423 :
15424 860 : EX(object) = _get_obj_zval_ptr_unused(TSRMLS_C);
15425 :
15426 860 : if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
15427 860 : if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
15428 0 : zend_error_noreturn(E_ERROR, "Object does not support method calls");
15429 : }
15430 :
15431 : /* First, locate the function. */
15432 860 : EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
15433 860 : if (!EX(fbc)) {
15434 0 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
15435 : }
15436 : } else {
15437 0 : zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
15438 : }
15439 :
15440 860 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
15441 0 : EX(object) = NULL;
15442 : } else {
15443 860 : if (!PZVAL_IS_REF(EX(object))) {
15444 860 : EX(object)->refcount++; /* For $this pointer */
15445 : } else {
15446 : zval *this_ptr;
15447 0 : ALLOC_ZVAL(this_ptr);
15448 0 : INIT_PZVAL_COPY(this_ptr, EX(object));
15449 0 : zval_copy_ctor(this_ptr);
15450 0 : EX(object) = this_ptr;
15451 : }
15452 : }
15453 :
15454 :
15455 860 : ZEND_VM_NEXT_OPCODE();
15456 : }
15457 :
15458 : static int ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15459 2060 : {
15460 2060 : zend_op *opline = EX(opline);
15461 2060 : zend_class_entry *ce = NULL;
15462 : zval **value;
15463 :
15464 : if (IS_UNUSED == IS_UNUSED) {
15465 : /* This seems to be a reminant of namespaces
15466 : if (EG(scope)) {
15467 : ce = EG(scope);
15468 : if (zend_hash_find(&ce->constants_table, Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant)+1, (void **) &value) == SUCCESS) {
15469 : zval_update_constant(value, (void *) 1 TSRMLS_CC);
15470 : EX_T(opline->result.u.var).tmp_var = **value;
15471 : zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
15472 : ZEND_VM_NEXT_OPCODE();
15473 : }
15474 : }
15475 : */
15476 2060 : if (!zend_get_constant(opline->op2.u.constant.value.str.val, opline->op2.u.constant.value.str.len, &EX_T(opline->result.u.var).tmp_var TSRMLS_CC)) {
15477 0 : zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",
15478 : opline->op2.u.constant.value.str.val,
15479 : opline->op2.u.constant.value.str.val);
15480 0 : EX_T(opline->result.u.var).tmp_var = opline->op2.u.constant;
15481 0 : zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
15482 : }
15483 2060 : ZEND_VM_NEXT_OPCODE();
15484 : }
15485 :
15486 : ce = EX_T(opline->op1.u.var).class_entry;
15487 :
15488 : if (zend_hash_find(&ce->constants_table, opline->op2.u.constant.value.str.val, opline->op2.u.constant.value.str.len+1, (void **) &value) == SUCCESS) {
15489 : zval_update_constant(value, (void *) 1 TSRMLS_CC);
15490 : EX_T(opline->result.u.var).tmp_var = **value;
15491 : zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
15492 : } else {
15493 : zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", opline->op2.u.constant.value.str.val);
15494 : }
15495 :
15496 : ZEND_VM_NEXT_OPCODE();
15497 : }
15498 :
15499 : static int ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15500 0 : {
15501 0 : zend_op *opline = EX(opline);
15502 :
15503 0 : array_init(&EX_T(opline->result.u.var).tmp_var);
15504 : if (IS_UNUSED == IS_UNUSED) {
15505 0 : ZEND_VM_NEXT_OPCODE();
15506 : #if 0 || IS_UNUSED != IS_UNUSED
15507 : } else {
15508 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15509 : #endif
15510 : }
15511 : }
15512 :
15513 : static int ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15514 0 : {
15515 0 : zend_op *opline = EX(opline);
15516 :
15517 0 : zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
15518 0 : zval *offset = &opline->op2.u.constant;
15519 : long index;
15520 :
15521 0 : if (container) {
15522 : if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
15523 : SEPARATE_ZVAL_IF_NOT_REF(container);
15524 : }
15525 0 : switch (Z_TYPE_PP(container)) {
15526 : case IS_ARRAY: {
15527 0 : HashTable *ht = Z_ARRVAL_PP(container);
15528 :
15529 0 : switch (Z_TYPE_P(offset)) {
15530 : case IS_DOUBLE:
15531 0 : index = (long) Z_DVAL_P(offset);
15532 0 : zend_hash_index_del(ht, index);
15533 0 : break;
15534 : case IS_RESOURCE:
15535 : case IS_BOOL:
15536 : case IS_LONG:
15537 0 : index = Z_LVAL_P(offset);
15538 0 : zend_hash_index_del(ht, index);
15539 0 : break;
15540 : case IS_STRING:
15541 : if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
15542 : offset->refcount++;
15543 : }
15544 0 : if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
15545 : ht == &EG(symbol_table)) {
15546 : zend_execute_data *ex;
15547 0 : ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
15548 :
15549 0 : for (ex = execute_data; ex; ex = ex->prev_execute_data) {
15550 0 : if (ex->op_array && ex->symbol_table == ht) {
15551 : int i;
15552 :
15553 0 : for (i = 0; i < ex->op_array->last_var; i++) {
15554 0 : if (ex->op_array->vars[i].hash_value == hash_value &&
15555 : ex->op_array->vars[i].name_len == offset->value.str.len &&
15556 : !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
15557 0 : ex->CVs[i] = NULL;
15558 0 : break;
15559 : }
15560 : }
15561 : }
15562 : }
15563 : }
15564 : if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
15565 : zval_ptr_dtor(&offset);
15566 : }
15567 0 : break;
15568 : case IS_NULL:
15569 0 : zend_hash_del(ht, "", sizeof(""));
15570 0 : break;
15571 : default:
15572 0 : zend_error(E_WARNING, "Illegal offset type in unset");
15573 : break;
15574 : }
15575 :
15576 0 : break;
15577 : }
15578 : case IS_OBJECT:
15579 0 : if (!Z_OBJ_HT_P(*container)->unset_dimension) {
15580 0 : zend_error_noreturn(E_ERROR, "Cannot use object as array");
15581 : }
15582 : if (0) {
15583 : MAKE_REAL_ZVAL_PTR(offset);
15584 : }
15585 0 : Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
15586 : if (0) {
15587 : zval_ptr_dtor(&offset);
15588 : } else {
15589 :
15590 : }
15591 0 : break;
15592 : case IS_STRING:
15593 0 : zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
15594 : ZEND_VM_CONTINUE(); /* bailed out before */
15595 : default:
15596 :
15597 : break;
15598 : }
15599 : } else {
15600 :
15601 : }
15602 :
15603 0 : ZEND_VM_NEXT_OPCODE();
15604 : }
15605 :
15606 : static int ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15607 0 : {
15608 0 : zend_op *opline = EX(opline);
15609 :
15610 0 : zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
15611 0 : zval *offset = &opline->op2.u.constant;
15612 :
15613 0 : if (container) {
15614 : if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
15615 : SEPARATE_ZVAL_IF_NOT_REF(container);
15616 : }
15617 0 : if (Z_TYPE_PP(container) == IS_OBJECT) {
15618 : if (0) {
15619 : MAKE_REAL_ZVAL_PTR(offset);
15620 : }
15621 0 : Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
15622 : if (0) {
15623 : zval_ptr_dtor(&offset);
15624 : } else {
15625 :
15626 : }
15627 : } else {
15628 :
15629 : }
15630 : } else {
15631 :
15632 : }
15633 :
15634 0 : ZEND_VM_NEXT_OPCODE();
15635 : }
15636 :
15637 : static int zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
15638 0 : {
15639 0 : zend_op *opline = EX(opline);
15640 :
15641 0 : zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
15642 0 : zval **value = NULL;
15643 0 : int result = 0;
15644 : long index;
15645 :
15646 0 : if (container) {
15647 :
15648 0 : zval *offset = &opline->op2.u.constant;
15649 :
15650 0 : if (Z_TYPE_PP(container) == IS_ARRAY) {
15651 : HashTable *ht;
15652 0 : int isset = 0;
15653 :
15654 0 : ht = Z_ARRVAL_PP(container);
15655 :
15656 0 : switch (Z_TYPE_P(offset)) {
15657 : case IS_DOUBLE:
15658 0 : index = (long) Z_DVAL_P(offset);
15659 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
15660 0 : isset = 1;
15661 : }
15662 0 : break;
15663 : case IS_RESOURCE:
15664 : case IS_BOOL:
15665 : case IS_LONG:
15666 0 : index = Z_LVAL_P(offset);
15667 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
15668 0 : isset = 1;
15669 : }
15670 0 : break;
15671 : case IS_STRING:
15672 0 : if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
15673 0 : isset = 1;
15674 : }
15675 0 : break;
15676 : case IS_NULL:
15677 0 : if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
15678 0 : isset = 1;
15679 : }
15680 0 : break;
15681 : default:
15682 0 : zend_error(E_WARNING, "Illegal offset type in isset or empty");
15683 :
15684 : break;
15685 : }
15686 :
15687 0 : switch (opline->extended_value) {
15688 : case ZEND_ISSET:
15689 0 : if (isset && Z_TYPE_PP(value) == IS_NULL) {
15690 0 : result = 0;
15691 : } else {
15692 0 : result = isset;
15693 : }
15694 0 : break;
15695 : case ZEND_ISEMPTY:
15696 0 : if (!isset || !i_zend_is_true(*value)) {
15697 0 : result = 0;
15698 : } else {
15699 0 : result = 1;
15700 : }
15701 : break;
15702 : }
15703 :
15704 0 : } else if (Z_TYPE_PP(container) == IS_OBJECT) {
15705 : if (0) {
15706 : MAKE_REAL_ZVAL_PTR(offset);
15707 : }
15708 0 : if (prop_dim) {
15709 0 : result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
15710 : } else {
15711 0 : result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
15712 : }
15713 : if (0) {
15714 : zval_ptr_dtor(&offset);
15715 : } else {
15716 :
15717 : }
15718 0 : } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
15719 : zval tmp;
15720 :
15721 0 : if (Z_TYPE_P(offset) != IS_LONG) {
15722 0 : tmp = *offset;
15723 0 : zval_copy_ctor(&tmp);
15724 0 : convert_to_long(&tmp);
15725 0 : offset = &tmp;
15726 : }
15727 0 : if (Z_TYPE_P(offset) == IS_LONG) {
15728 0 : switch (opline->extended_value) {
15729 : case ZEND_ISSET:
15730 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
15731 0 : result = 1;
15732 : }
15733 0 : break;
15734 : case ZEND_ISEMPTY:
15735 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
15736 0 : result = 1;
15737 : }
15738 : break;
15739 : }
15740 : }
15741 :
15742 : } else {
15743 :
15744 : }
15745 : }
15746 :
15747 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
15748 :
15749 0 : switch (opline->extended_value) {
15750 : case ZEND_ISSET:
15751 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
15752 0 : break;
15753 : case ZEND_ISEMPTY:
15754 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
15755 : break;
15756 : }
15757 :
15758 0 : ZEND_VM_NEXT_OPCODE();
15759 : }
15760 :
15761 : static int ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15762 0 : {
15763 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15764 : }
15765 :
15766 : static int ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15767 0 : {
15768 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15769 : }
15770 :
15771 : static int zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
15772 0 : {
15773 0 : zend_op *opline = EX(opline);
15774 0 : zend_op *op_data = opline+1;
15775 : zend_free_op free_op2, free_op_data1;
15776 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
15777 : zval *object;
15778 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
15779 0 : zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
15780 0 : znode *result = &opline->result;
15781 0 : zval **retval = &EX_T(result->u.var).var.ptr;
15782 0 : int have_get_ptr = 0;
15783 :
15784 0 : EX_T(result->u.var).var.ptr_ptr = NULL;
15785 0 : make_real_object(object_ptr TSRMLS_CC);
15786 0 : object = *object_ptr;
15787 :
15788 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
15789 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
15790 0 : zval_dtor(free_op2.var);
15791 0 : FREE_OP(free_op_data1);
15792 :
15793 0 : if (!RETURN_VALUE_UNUSED(result)) {
15794 0 : *retval = EG(uninitialized_zval_ptr);
15795 0 : PZVAL_LOCK(*retval);
15796 : }
15797 : } else {
15798 : /* here we are sure we are dealing with an object */
15799 : if (1) {
15800 0 : MAKE_REAL_ZVAL_PTR(property);
15801 : }
15802 :
15803 : /* here property is a string */
15804 0 : if (opline->extended_value == ZEND_ASSIGN_OBJ
15805 : && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
15806 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
15807 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
15808 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
15809 :
15810 0 : have_get_ptr = 1;
15811 0 : binary_op(*zptr, *zptr, value TSRMLS_CC);
15812 0 : if (!RETURN_VALUE_UNUSED(result)) {
15813 0 : *retval = *zptr;
15814 0 : PZVAL_LOCK(*retval);
15815 : }
15816 : }
15817 : }
15818 :
15819 0 : if (!have_get_ptr) {
15820 0 : zval *z = NULL;
15821 :
15822 0 : switch (opline->extended_value) {
15823 : case ZEND_ASSIGN_OBJ:
15824 0 : if (Z_OBJ_HT_P(object)->read_property) {
15825 0 : z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
15826 : }
15827 0 : break;
15828 : case ZEND_ASSIGN_DIM:
15829 0 : if (Z_OBJ_HT_P(object)->read_dimension) {
15830 0 : z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
15831 : }
15832 : break;
15833 : }
15834 0 : if (z) {
15835 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
15836 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
15837 :
15838 0 : if (z->refcount == 0) {
15839 0 : zval_dtor(z);
15840 0 : FREE_ZVAL(z);
15841 : }
15842 0 : z = value;
15843 : }
15844 0 : z->refcount++;
15845 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
15846 0 : binary_op(z, z, value TSRMLS_CC);
15847 0 : switch (opline->extended_value) {
15848 : case ZEND_ASSIGN_OBJ:
15849 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
15850 0 : break;
15851 : case ZEND_ASSIGN_DIM:
15852 0 : Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
15853 : break;
15854 : }
15855 0 : if (!RETURN_VALUE_UNUSED(result)) {
15856 0 : *retval = z;
15857 0 : PZVAL_LOCK(*retval);
15858 : }
15859 0 : zval_ptr_dtor(&z);
15860 : } else {
15861 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
15862 0 : if (!RETURN_VALUE_UNUSED(result)) {
15863 0 : *retval = EG(uninitialized_zval_ptr);
15864 0 : PZVAL_LOCK(*retval);
15865 : }
15866 : }
15867 : }
15868 :
15869 : if (1) {
15870 0 : zval_ptr_dtor(&property);
15871 : } else {
15872 : zval_dtor(free_op2.var);
15873 : }
15874 0 : FREE_OP(free_op_data1);
15875 : }
15876 :
15877 : /* assign_obj has two opcodes! */
15878 0 : ZEND_VM_INC_OPCODE();
15879 0 : ZEND_VM_NEXT_OPCODE();
15880 : }
15881 :
15882 : static int zend_binary_assign_op_helper_SPEC_UNUSED_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
15883 0 : {
15884 0 : zend_op *opline = EX(opline);
15885 : zend_free_op free_op2, free_op_data2, free_op_data1;
15886 : zval **var_ptr;
15887 : zval *value;
15888 0 : zend_bool increment_opline = 0;
15889 :
15890 0 : switch (opline->extended_value) {
15891 : case ZEND_ASSIGN_OBJ:
15892 0 : return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15893 : break;
15894 : case ZEND_ASSIGN_DIM: {
15895 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
15896 :
15897 0 : if (object_ptr && IS_UNUSED != IS_CV && !0) {
15898 0 : (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
15899 : }
15900 :
15901 0 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
15902 0 : return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15903 : } else {
15904 0 : zend_op *op_data = opline+1;
15905 0 : zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
15906 :
15907 0 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), NULL, dim, 1, BP_VAR_RW TSRMLS_CC);
15908 0 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
15909 0 : var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
15910 0 : increment_opline = 1;
15911 : }
15912 : }
15913 0 : break;
15914 : default:
15915 0 : value = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
15916 0 : var_ptr = NULL;
15917 : /* do nothing */
15918 : break;
15919 : }
15920 :
15921 0 : if (!var_ptr) {
15922 0 : zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
15923 : }
15924 :
15925 0 : if (*var_ptr == EG(error_zval_ptr)) {
15926 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
15927 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
15928 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
15929 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
15930 : }
15931 0 : zval_dtor(free_op2.var);
15932 :
15933 0 : if (increment_opline) {
15934 0 : ZEND_VM_INC_OPCODE();
15935 : }
15936 0 : ZEND_VM_NEXT_OPCODE();
15937 : }
15938 :
15939 0 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
15940 :
15941 0 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
15942 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
15943 : /* proxy object */
15944 0 : zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
15945 0 : objval->refcount++;
15946 0 : binary_op(objval, objval, value TSRMLS_CC);
15947 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
15948 0 : zval_ptr_dtor(&objval);
15949 : } else {
15950 0 : binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
15951 : }
15952 :
15953 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
15954 0 : EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
15955 0 : PZVAL_LOCK(*var_ptr);
15956 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
15957 : }
15958 0 : zval_dtor(free_op2.var);
15959 :
15960 0 : if (increment_opline) {
15961 0 : ZEND_VM_INC_OPCODE();
15962 0 : FREE_OP(free_op_data1);
15963 0 : FREE_OP_VAR_PTR(free_op_data2);
15964 : }
15965 :
15966 0 : ZEND_VM_NEXT_OPCODE();
15967 : }
15968 :
15969 : static int ZEND_ASSIGN_ADD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15970 0 : {
15971 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15972 : }
15973 :
15974 : static int ZEND_ASSIGN_SUB_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15975 0 : {
15976 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15977 : }
15978 :
15979 : static int ZEND_ASSIGN_MUL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15980 0 : {
15981 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15982 : }
15983 :
15984 : static int ZEND_ASSIGN_DIV_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15985 0 : {
15986 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15987 : }
15988 :
15989 : static int ZEND_ASSIGN_MOD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15990 0 : {
15991 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15992 : }
15993 :
15994 : static int ZEND_ASSIGN_SL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15995 0 : {
15996 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15997 : }
15998 :
15999 : static int ZEND_ASSIGN_SR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16000 0 : {
16001 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16002 : }
16003 :
16004 : static int ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16005 0 : {
16006 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16007 : }
16008 :
16009 : static int ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16010 0 : {
16011 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16012 : }
16013 :
16014 : static int ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16015 0 : {
16016 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16017 : }
16018 :
16019 : static int ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16020 0 : {
16021 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16022 : }
16023 :
16024 : static int zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
16025 0 : {
16026 0 : zend_op *opline = EX(opline);
16027 : zend_free_op free_op2;
16028 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
16029 : zval *object;
16030 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
16031 0 : zval **retval = &EX_T(opline->result.u.var).var.ptr;
16032 0 : int have_get_ptr = 0;
16033 :
16034 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
16035 0 : object = *object_ptr;
16036 :
16037 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
16038 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
16039 0 : zval_dtor(free_op2.var);
16040 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
16041 0 : *retval = EG(uninitialized_zval_ptr);
16042 0 : PZVAL_LOCK(*retval);
16043 : }
16044 :
16045 0 : ZEND_VM_NEXT_OPCODE();
16046 : }
16047 :
16048 : /* here we are sure we are dealing with an object */
16049 :
16050 : if (1) {
16051 0 : MAKE_REAL_ZVAL_PTR(property);
16052 : }
16053 :
16054 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
16055 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
16056 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
16057 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
16058 :
16059 0 : have_get_ptr = 1;
16060 0 : incdec_op(*zptr);
16061 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
16062 0 : *retval = *zptr;
16063 0 : PZVAL_LOCK(*retval);
16064 : }
16065 : }
16066 : }
16067 :
16068 0 : if (!have_get_ptr) {
16069 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
16070 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
16071 :
16072 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
16073 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
16074 :
16075 0 : if (z->refcount == 0) {
16076 0 : zval_dtor(z);
16077 0 : FREE_ZVAL(z);
16078 : }
16079 0 : z = value;
16080 : }
16081 0 : z->refcount++;
16082 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
16083 0 : incdec_op(z);
16084 0 : *retval = z;
16085 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
16086 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
16087 0 : zval_ptr_dtor(&z);
16088 : } else {
16089 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
16090 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
16091 0 : *retval = EG(uninitialized_zval_ptr);
16092 0 : PZVAL_LOCK(*retval);
16093 : }
16094 : }
16095 : }
16096 :
16097 : if (1) {
16098 0 : zval_ptr_dtor(&property);
16099 : } else {
16100 : zval_dtor(free_op2.var);
16101 : }
16102 :
16103 0 : ZEND_VM_NEXT_OPCODE();
16104 : }
16105 :
16106 : static int ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16107 0 : {
16108 0 : return zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16109 : }
16110 :
16111 : static int ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16112 0 : {
16113 0 : return zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16114 : }
16115 :
16116 : static int zend_post_incdec_property_helper_SPEC_UNUSED_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
16117 0 : {
16118 0 : zend_op *opline = EX(opline);
16119 : zend_free_op free_op2;
16120 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
16121 : zval *object;
16122 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
16123 0 : zval *retval = &EX_T(opline->result.u.var).tmp_var;
16124 0 : int have_get_ptr = 0;
16125 :
16126 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
16127 0 : object = *object_ptr;
16128 :
16129 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
16130 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
16131 0 : zval_dtor(free_op2.var);
16132 0 : *retval = *EG(uninitialized_zval_ptr);
16133 :
16134 0 : ZEND_VM_NEXT_OPCODE();
16135 : }
16136 :
16137 : /* here we are sure we are dealing with an object */
16138 :
16139 : if (1) {
16140 0 : MAKE_REAL_ZVAL_PTR(property);
16141 : }
16142 :
16143 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
16144 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
16145 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
16146 0 : have_get_ptr = 1;
16147 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
16148 :
16149 0 : *retval = **zptr;
16150 0 : zendi_zval_copy_ctor(*retval);
16151 :
16152 0 : incdec_op(*zptr);
16153 :
16154 : }
16155 : }
16156 :
16157 0 : if (!have_get_ptr) {
16158 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
16159 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
16160 : zval *z_copy;
16161 :
16162 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
16163 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
16164 :
16165 0 : if (z->refcount == 0) {
16166 0 : zval_dtor(z);
16167 0 : FREE_ZVAL(z);
16168 : }
16169 0 : z = value;
16170 : }
16171 0 : *retval = *z;
16172 0 : zendi_zval_copy_ctor(*retval);
16173 0 : ALLOC_ZVAL(z_copy);
16174 0 : *z_copy = *z;
16175 0 : zendi_zval_copy_ctor(*z_copy);
16176 0 : INIT_PZVAL(z_copy);
16177 0 : incdec_op(z_copy);
16178 0 : z->refcount++;
16179 0 : Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
16180 0 : zval_ptr_dtor(&z_copy);
16181 0 : zval_ptr_dtor(&z);
16182 : } else {
16183 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
16184 0 : *retval = *EG(uninitialized_zval_ptr);
16185 : }
16186 : }
16187 :
16188 : if (1) {
16189 0 : zval_ptr_dtor(&property);
16190 : } else {
16191 : zval_dtor(free_op2.var);
16192 : }
16193 :
16194 0 : ZEND_VM_NEXT_OPCODE();
16195 : }
16196 :
16197 : static int ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16198 0 : {
16199 0 : return zend_post_incdec_property_helper_SPEC_UNUSED_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16200 : }
16201 :
16202 : static int ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16203 0 : {
16204 0 : return zend_post_incdec_property_helper_SPEC_UNUSED_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16205 : }
16206 :
16207 : static int zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(int type, ZEND_OPCODE_HANDLER_ARGS)
16208 0 : {
16209 0 : zend_op *opline = EX(opline);
16210 : zval *container;
16211 : zval **retval;
16212 :
16213 :
16214 0 : retval = &EX_T(opline->result.u.var).var.ptr;
16215 0 : EX_T(opline->result.u.var).var.ptr_ptr = retval;
16216 :
16217 0 : container = _get_obj_zval_ptr_unused(TSRMLS_C);
16218 :
16219 0 : if (container == EG(error_zval_ptr)) {
16220 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
16221 0 : *retval = EG(error_zval_ptr);
16222 0 : PZVAL_LOCK(*retval);
16223 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
16224 : }
16225 :
16226 0 : ZEND_VM_NEXT_OPCODE();
16227 : }
16228 :
16229 :
16230 0 : if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
16231 0 : if (type != BP_VAR_IS) {
16232 0 : zend_error(E_NOTICE, "Trying to get property of non-object");
16233 : }
16234 0 : *retval = EG(uninitialized_zval_ptr);
16235 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
16236 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
16237 : } else {
16238 : zend_free_op free_op2;
16239 0 : zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
16240 :
16241 : if (1) {
16242 0 : MAKE_REAL_ZVAL_PTR(offset);
16243 : }
16244 :
16245 : /* here we are sure we are dealing with an object */
16246 0 : *retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
16247 :
16248 0 : if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
16249 0 : zval_dtor(*retval);
16250 0 : FREE_ZVAL(*retval);
16251 : } else {
16252 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
16253 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
16254 : }
16255 :
16256 : if (1) {
16257 0 : zval_ptr_dtor(&offset);
16258 : } else {
16259 : zval_dtor(free_op2.var);
16260 : }
16261 : }
16262 :
16263 0 : ZEND_VM_NEXT_OPCODE();
16264 : }
16265 :
16266 : static int ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16267 0 : {
16268 0 : return zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16269 : }
16270 :
16271 : static int ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16272 0 : {
16273 0 : zend_op *opline = EX(opline);
16274 : zend_free_op free_op1, free_op2;
16275 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
16276 :
16277 0 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_UNUSED != IS_CV) {
16278 0 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
16279 0 : EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
16280 : }
16281 :
16282 : if (1) {
16283 0 : MAKE_REAL_ZVAL_PTR(property);
16284 : }
16285 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(TSRMLS_C), property, BP_VAR_W TSRMLS_CC);
16286 : if (1) {
16287 0 : zval_ptr_dtor(&property);
16288 : } else {
16289 : zval_dtor(free_op2.var);
16290 : }
16291 : if (IS_UNUSED == IS_VAR && 0 &&
16292 : READY_TO_DESTROY(free_op1.var) &&
16293 : !RETURN_VALUE_UNUSED(&opline->result)) {
16294 : AI_USE_PTR(EX_T(opline->result.u.var).var);
16295 : }
16296 :
16297 0 : ZEND_VM_NEXT_OPCODE();
16298 : }
16299 :
16300 : static int ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16301 0 : {
16302 0 : zend_op *opline = EX(opline);
16303 : zend_free_op free_op1, free_op2;
16304 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
16305 :
16306 : if (1) {
16307 0 : MAKE_REAL_ZVAL_PTR(property);
16308 : }
16309 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(TSRMLS_C), property, BP_VAR_RW TSRMLS_CC);
16310 : if (1) {
16311 0 : zval_ptr_dtor(&property);
16312 : } else {
16313 : zval_dtor(free_op2.var);
16314 : }
16315 : if (IS_UNUSED == IS_VAR && 0 &&
16316 : READY_TO_DESTROY(free_op1.var) &&
16317 : !RETURN_VALUE_UNUSED(&opline->result)) {
16318 : AI_USE_PTR(EX_T(opline->result.u.var).var);
16319 : }
16320 :
16321 0 : ZEND_VM_NEXT_OPCODE();
16322 : }
16323 :
16324 : static int ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16325 0 : {
16326 0 : return zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16327 : }
16328 :
16329 : static int ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16330 0 : {
16331 0 : zend_op *opline = EX(opline);
16332 :
16333 0 : if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
16334 : /* Behave like FETCH_OBJ_W */
16335 : zend_free_op free_op1, free_op2;
16336 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
16337 :
16338 : if (1) {
16339 0 : MAKE_REAL_ZVAL_PTR(property);
16340 : }
16341 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(TSRMLS_C), property, BP_VAR_W TSRMLS_CC);
16342 : if (1) {
16343 0 : zval_ptr_dtor(&property);
16344 : } else {
16345 : zval_dtor(free_op2.var);
16346 : }
16347 : if (IS_UNUSED == IS_VAR && 0 &&
16348 : READY_TO_DESTROY(free_op1.var) &&
16349 : !RETURN_VALUE_UNUSED(&opline->result)) {
16350 : AI_USE_PTR(EX_T(opline->result.u.var).var);
16351 : }
16352 :
16353 0 : ZEND_VM_NEXT_OPCODE();
16354 : } else {
16355 0 : return zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16356 : }
16357 : }
16358 :
16359 : static int ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16360 0 : {
16361 0 : zend_op *opline = EX(opline);
16362 : zend_free_op free_op1, free_op2, free_res;
16363 0 : zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
16364 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
16365 :
16366 : if (IS_UNUSED == IS_CV) {
16367 : if (container != &EG(uninitialized_zval_ptr)) {
16368 : SEPARATE_ZVAL_IF_NOT_REF(container);
16369 : }
16370 : }
16371 : if (1) {
16372 0 : MAKE_REAL_ZVAL_PTR(property);
16373 : }
16374 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
16375 : if (1) {
16376 0 : zval_ptr_dtor(&property);
16377 : } else {
16378 : zval_dtor(free_op2.var);
16379 : }
16380 : if (IS_UNUSED == IS_VAR && 0 &&
16381 : READY_TO_DESTROY(free_op1.var) &&
16382 : !RETURN_VALUE_UNUSED(&opline->result)) {
16383 : AI_USE_PTR(EX_T(opline->result.u.var).var);
16384 : }
16385 :
16386 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
16387 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
16388 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
16389 : }
16390 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
16391 0 : FREE_OP_VAR_PTR(free_res);
16392 0 : ZEND_VM_NEXT_OPCODE();
16393 : }
16394 :
16395 : static int ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16396 0 : {
16397 0 : zend_op *opline = EX(opline);
16398 0 : zend_op *op_data = opline+1;
16399 :
16400 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
16401 :
16402 0 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
16403 :
16404 : /* assign_obj has two opcodes! */
16405 0 : ZEND_VM_INC_OPCODE();
16406 0 : ZEND_VM_NEXT_OPCODE();
16407 : }
16408 :
16409 : static int ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16410 0 : {
16411 0 : zend_op *opline = EX(opline);
16412 : zval *function_name;
16413 : char *function_name_strval;
16414 : int function_name_strlen;
16415 : zend_free_op free_op2;
16416 :
16417 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
16418 :
16419 0 : function_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
16420 :
16421 0 : if (Z_TYPE_P(function_name)!=IS_STRING) {
16422 0 : zend_error_noreturn(E_ERROR, "Method name must be a string");
16423 : }
16424 :
16425 0 : function_name_strval = Z_STRVAL_P(function_name);
16426 0 : function_name_strlen = Z_STRLEN_P(function_name);
16427 :
16428 0 : EX(object) = _get_obj_zval_ptr_unused(TSRMLS_C);
16429 :
16430 0 : if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
16431 0 : if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
16432 0 : zend_error_noreturn(E_ERROR, "Object does not support method calls");
16433 : }
16434 :
16435 : /* First, locate the function. */
16436 0 : EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
16437 0 : if (!EX(fbc)) {
16438 0 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
16439 : }
16440 : } else {
16441 0 : zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
16442 : }
16443 :
16444 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
16445 0 : EX(object) = NULL;
16446 : } else {
16447 0 : if (!PZVAL_IS_REF(EX(object))) {
16448 0 : EX(object)->refcount++; /* For $this pointer */
16449 : } else {
16450 : zval *this_ptr;
16451 0 : ALLOC_ZVAL(this_ptr);
16452 0 : INIT_PZVAL_COPY(this_ptr, EX(object));
16453 0 : zval_copy_ctor(this_ptr);
16454 0 : EX(object) = this_ptr;
16455 : }
16456 : }
16457 :
16458 0 : zval_dtor(free_op2.var);
16459 :
16460 0 : ZEND_VM_NEXT_OPCODE();
16461 : }
16462 :
16463 : static int ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16464 0 : {
16465 0 : zend_op *opline = EX(opline);
16466 :
16467 0 : array_init(&EX_T(opline->result.u.var).tmp_var);
16468 : if (IS_UNUSED == IS_UNUSED) {
16469 0 : ZEND_VM_NEXT_OPCODE();
16470 : #if 0 || IS_UNUSED != IS_UNUSED
16471 : } else {
16472 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16473 : #endif
16474 : }
16475 : }
16476 :
16477 : static int ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16478 0 : {
16479 0 : zend_op *opline = EX(opline);
16480 : zend_free_op free_op2;
16481 0 : zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
16482 0 : zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
16483 : long index;
16484 :
16485 0 : if (container) {
16486 : if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
16487 : SEPARATE_ZVAL_IF_NOT_REF(container);
16488 : }
16489 0 : switch (Z_TYPE_PP(container)) {
16490 : case IS_ARRAY: {
16491 0 : HashTable *ht = Z_ARRVAL_PP(container);
16492 :
16493 0 : switch (Z_TYPE_P(offset)) {
16494 : case IS_DOUBLE:
16495 0 : index = (long) Z_DVAL_P(offset);
16496 0 : zend_hash_index_del(ht, index);
16497 0 : break;
16498 : case IS_RESOURCE:
16499 : case IS_BOOL:
16500 : case IS_LONG:
16501 0 : index = Z_LVAL_P(offset);
16502 0 : zend_hash_index_del(ht, index);
16503 0 : break;
16504 : case IS_STRING:
16505 : if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
16506 : offset->refcount++;
16507 : }
16508 0 : if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
16509 : ht == &EG(symbol_table)) {
16510 : zend_execute_data *ex;
16511 0 : ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
16512 :
16513 0 : for (ex = execute_data; ex; ex = ex->prev_execute_data) {
16514 0 : if (ex->op_array && ex->symbol_table == ht) {
16515 : int i;
16516 :
16517 0 : for (i = 0; i < ex->op_array->last_var; i++) {
16518 0 : if (ex->op_array->vars[i].hash_value == hash_value &&
16519 : ex->op_array->vars[i].name_len == offset->value.str.len &&
16520 : !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
16521 0 : ex->CVs[i] = NULL;
16522 0 : break;
16523 : }
16524 : }
16525 : }
16526 : }
16527 : }
16528 : if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
16529 : zval_ptr_dtor(&offset);
16530 : }
16531 0 : break;
16532 : case IS_NULL:
16533 0 : zend_hash_del(ht, "", sizeof(""));
16534 0 : break;
16535 : default:
16536 0 : zend_error(E_WARNING, "Illegal offset type in unset");
16537 : break;
16538 : }
16539 0 : zval_dtor(free_op2.var);
16540 0 : break;
16541 : }
16542 : case IS_OBJECT:
16543 0 : if (!Z_OBJ_HT_P(*container)->unset_dimension) {
16544 0 : zend_error_noreturn(E_ERROR, "Cannot use object as array");
16545 : }
16546 : if (1) {
16547 0 : MAKE_REAL_ZVAL_PTR(offset);
16548 : }
16549 0 : Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
16550 : if (1) {
16551 0 : zval_ptr_dtor(&offset);
16552 : } else {
16553 : zval_dtor(free_op2.var);
16554 : }
16555 0 : break;
16556 : case IS_STRING:
16557 0 : zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
16558 : ZEND_VM_CONTINUE(); /* bailed out before */
16559 : default:
16560 0 : zval_dtor(free_op2.var);
16561 : break;
16562 : }
16563 : } else {
16564 0 : zval_dtor(free_op2.var);
16565 : }
16566 :
16567 0 : ZEND_VM_NEXT_OPCODE();
16568 : }
16569 :
16570 : static int ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16571 0 : {
16572 0 : zend_op *opline = EX(opline);
16573 : zend_free_op free_op2;
16574 0 : zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
16575 0 : zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
16576 :
16577 0 : if (container) {
16578 : if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
16579 : SEPARATE_ZVAL_IF_NOT_REF(container);
16580 : }
16581 0 : if (Z_TYPE_PP(container) == IS_OBJECT) {
16582 : if (1) {
16583 0 : MAKE_REAL_ZVAL_PTR(offset);
16584 : }
16585 0 : Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
16586 : if (1) {
16587 0 : zval_ptr_dtor(&offset);
16588 : } else {
16589 : zval_dtor(free_op2.var);
16590 : }
16591 : } else {
16592 0 : zval_dtor(free_op2.var);
16593 : }
16594 : } else {
16595 0 : zval_dtor(free_op2.var);
16596 : }
16597 :
16598 0 : ZEND_VM_NEXT_OPCODE();
16599 : }
16600 :
16601 : static int zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
16602 0 : {
16603 0 : zend_op *opline = EX(opline);
16604 :
16605 0 : zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
16606 0 : zval **value = NULL;
16607 0 : int result = 0;
16608 : long index;
16609 :
16610 0 : if (container) {
16611 : zend_free_op free_op2;
16612 0 : zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
16613 :
16614 0 : if (Z_TYPE_PP(container) == IS_ARRAY) {
16615 : HashTable *ht;
16616 0 : int isset = 0;
16617 :
16618 0 : ht = Z_ARRVAL_PP(container);
16619 :
16620 0 : switch (Z_TYPE_P(offset)) {
16621 : case IS_DOUBLE:
16622 0 : index = (long) Z_DVAL_P(offset);
16623 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
16624 0 : isset = 1;
16625 : }
16626 0 : break;
16627 : case IS_RESOURCE:
16628 : case IS_BOOL:
16629 : case IS_LONG:
16630 0 : index = Z_LVAL_P(offset);
16631 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
16632 0 : isset = 1;
16633 : }
16634 0 : break;
16635 : case IS_STRING:
16636 0 : if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
16637 0 : isset = 1;
16638 : }
16639 0 : break;
16640 : case IS_NULL:
16641 0 : if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
16642 0 : isset = 1;
16643 : }
16644 0 : break;
16645 : default:
16646 0 : zend_error(E_WARNING, "Illegal offset type in isset or empty");
16647 :
16648 : break;
16649 : }
16650 :
16651 0 : switch (opline->extended_value) {
16652 : case ZEND_ISSET:
16653 0 : if (isset && Z_TYPE_PP(value) == IS_NULL) {
16654 0 : result = 0;
16655 : } else {
16656 0 : result = isset;
16657 : }
16658 0 : break;
16659 : case ZEND_ISEMPTY:
16660 0 : if (!isset || !i_zend_is_true(*value)) {
16661 0 : result = 0;
16662 : } else {
16663 0 : result = 1;
16664 : }
16665 : break;
16666 : }
16667 0 : zval_dtor(free_op2.var);
16668 0 : } else if (Z_TYPE_PP(container) == IS_OBJECT) {
16669 : if (1) {
16670 0 : MAKE_REAL_ZVAL_PTR(offset);
16671 : }
16672 0 : if (prop_dim) {
16673 0 : result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
16674 : } else {
16675 0 : result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
16676 : }
16677 : if (1) {
16678 0 : zval_ptr_dtor(&offset);
16679 : } else {
16680 : zval_dtor(free_op2.var);
16681 : }
16682 0 : } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
16683 : zval tmp;
16684 :
16685 0 : if (Z_TYPE_P(offset) != IS_LONG) {
16686 0 : tmp = *offset;
16687 0 : zval_copy_ctor(&tmp);
16688 0 : convert_to_long(&tmp);
16689 0 : offset = &tmp;
16690 : }
16691 0 : if (Z_TYPE_P(offset) == IS_LONG) {
16692 0 : switch (opline->extended_value) {
16693 : case ZEND_ISSET:
16694 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
16695 0 : result = 1;
16696 : }
16697 0 : break;
16698 : case ZEND_ISEMPTY:
16699 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
16700 0 : result = 1;
16701 : }
16702 : break;
16703 : }
16704 : }
16705 0 : zval_dtor(free_op2.var);
16706 : } else {
16707 0 : zval_dtor(free_op2.var);
16708 : }
16709 : }
16710 :
16711 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
16712 :
16713 0 : switch (opline->extended_value) {
16714 : case ZEND_ISSET:
16715 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
16716 0 : break;
16717 : case ZEND_ISEMPTY:
16718 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
16719 : break;
16720 : }
16721 :
16722 0 : ZEND_VM_NEXT_OPCODE();
16723 : }
16724 :
16725 : static int ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16726 0 : {
16727 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16728 : }
16729 :
16730 : static int ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16731 0 : {
16732 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16733 : }
16734 :
16735 : static int zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
16736 0 : {
16737 0 : zend_op *opline = EX(opline);
16738 0 : zend_op *op_data = opline+1;
16739 : zend_free_op free_op2, free_op_data1;
16740 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
16741 : zval *object;
16742 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
16743 0 : zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
16744 0 : znode *result = &opline->result;
16745 0 : zval **retval = &EX_T(result->u.var).var.ptr;
16746 0 : int have_get_ptr = 0;
16747 :
16748 0 : EX_T(result->u.var).var.ptr_ptr = NULL;
16749 0 : make_real_object(object_ptr TSRMLS_CC);
16750 0 : object = *object_ptr;
16751 :
16752 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
16753 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
16754 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
16755 0 : FREE_OP(free_op_data1);
16756 :
16757 0 : if (!RETURN_VALUE_UNUSED(result)) {
16758 0 : *retval = EG(uninitialized_zval_ptr);
16759 0 : PZVAL_LOCK(*retval);
16760 : }
16761 : } else {
16762 : /* here we are sure we are dealing with an object */
16763 : if (0) {
16764 : MAKE_REAL_ZVAL_PTR(property);
16765 : }
16766 :
16767 : /* here property is a string */
16768 0 : if (opline->extended_value == ZEND_ASSIGN_OBJ
16769 : && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
16770 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
16771 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
16772 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
16773 :
16774 0 : have_get_ptr = 1;
16775 0 : binary_op(*zptr, *zptr, value TSRMLS_CC);
16776 0 : if (!RETURN_VALUE_UNUSED(result)) {
16777 0 : *retval = *zptr;
16778 0 : PZVAL_LOCK(*retval);
16779 : }
16780 : }
16781 : }
16782 :
16783 0 : if (!have_get_ptr) {
16784 0 : zval *z = NULL;
16785 :
16786 0 : switch (opline->extended_value) {
16787 : case ZEND_ASSIGN_OBJ:
16788 0 : if (Z_OBJ_HT_P(object)->read_property) {
16789 0 : z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
16790 : }
16791 0 : break;
16792 : case ZEND_ASSIGN_DIM:
16793 0 : if (Z_OBJ_HT_P(object)->read_dimension) {
16794 0 : z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
16795 : }
16796 : break;
16797 : }
16798 0 : if (z) {
16799 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
16800 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
16801 :
16802 0 : if (z->refcount == 0) {
16803 0 : zval_dtor(z);
16804 0 : FREE_ZVAL(z);
16805 : }
16806 0 : z = value;
16807 : }
16808 0 : z->refcount++;
16809 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
16810 0 : binary_op(z, z, value TSRMLS_CC);
16811 0 : switch (opline->extended_value) {
16812 : case ZEND_ASSIGN_OBJ:
16813 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
16814 0 : break;
16815 : case ZEND_ASSIGN_DIM:
16816 0 : Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
16817 : break;
16818 : }
16819 0 : if (!RETURN_VALUE_UNUSED(result)) {
16820 0 : *retval = z;
16821 0 : PZVAL_LOCK(*retval);
16822 : }
16823 0 : zval_ptr_dtor(&z);
16824 : } else {
16825 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
16826 0 : if (!RETURN_VALUE_UNUSED(result)) {
16827 0 : *retval = EG(uninitialized_zval_ptr);
16828 0 : PZVAL_LOCK(*retval);
16829 : }
16830 : }
16831 : }
16832 :
16833 : if (0) {
16834 : zval_ptr_dtor(&property);
16835 : } else {
16836 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
16837 : }
16838 0 : FREE_OP(free_op_data1);
16839 : }
16840 :
16841 : /* assign_obj has two opcodes! */
16842 0 : ZEND_VM_INC_OPCODE();
16843 0 : ZEND_VM_NEXT_OPCODE();
16844 : }
16845 :
16846 : static int zend_binary_assign_op_helper_SPEC_UNUSED_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
16847 0 : {
16848 0 : zend_op *opline = EX(opline);
16849 : zend_free_op free_op2, free_op_data2, free_op_data1;
16850 : zval **var_ptr;
16851 : zval *value;
16852 0 : zend_bool increment_opline = 0;
16853 :
16854 0 : switch (opline->extended_value) {
16855 : case ZEND_ASSIGN_OBJ:
16856 0 : return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16857 : break;
16858 : case ZEND_ASSIGN_DIM: {
16859 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
16860 :
16861 0 : if (object_ptr && IS_UNUSED != IS_CV && !0) {
16862 0 : (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
16863 : }
16864 :
16865 0 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
16866 0 : return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16867 : } else {
16868 0 : zend_op *op_data = opline+1;
16869 0 : zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
16870 :
16871 0 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), NULL, dim, 0, BP_VAR_RW TSRMLS_CC);
16872 0 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
16873 0 : var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
16874 0 : increment_opline = 1;
16875 : }
16876 : }
16877 0 : break;
16878 : default:
16879 0 : value = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
16880 0 : var_ptr = NULL;
16881 : /* do nothing */
16882 : break;
16883 : }
16884 :
16885 0 : if (!var_ptr) {
16886 0 : zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
16887 : }
16888 :
16889 0 : if (*var_ptr == EG(error_zval_ptr)) {
16890 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
16891 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
16892 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
16893 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
16894 : }
16895 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
16896 :
16897 0 : if (increment_opline) {
16898 0 : ZEND_VM_INC_OPCODE();
16899 : }
16900 0 : ZEND_VM_NEXT_OPCODE();
16901 : }
16902 :
16903 0 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
16904 :
16905 0 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
16906 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
16907 : /* proxy object */
16908 0 : zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
16909 0 : objval->refcount++;
16910 0 : binary_op(objval, objval, value TSRMLS_CC);
16911 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
16912 0 : zval_ptr_dtor(&objval);
16913 : } else {
16914 0 : binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
16915 : }
16916 :
16917 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
16918 0 : EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
16919 0 : PZVAL_LOCK(*var_ptr);
16920 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
16921 : }
16922 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
16923 :
16924 0 : if (increment_opline) {
16925 0 : ZEND_VM_INC_OPCODE();
16926 0 : FREE_OP(free_op_data1);
16927 0 : FREE_OP_VAR_PTR(free_op_data2);
16928 : }
16929 :
16930 0 : ZEND_VM_NEXT_OPCODE();
16931 : }
16932 :
16933 : static int ZEND_ASSIGN_ADD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16934 0 : {
16935 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16936 : }
16937 :
16938 : static int ZEND_ASSIGN_SUB_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16939 0 : {
16940 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16941 : }
16942 :
16943 : static int ZEND_ASSIGN_MUL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16944 0 : {
16945 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16946 : }
16947 :
16948 : static int ZEND_ASSIGN_DIV_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16949 0 : {
16950 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16951 : }
16952 :
16953 : static int ZEND_ASSIGN_MOD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16954 0 : {
16955 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16956 : }
16957 :
16958 : static int ZEND_ASSIGN_SL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16959 0 : {
16960 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16961 : }
16962 :
16963 : static int ZEND_ASSIGN_SR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16964 0 : {
16965 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16966 : }
16967 :
16968 : static int ZEND_ASSIGN_CONCAT_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16969 0 : {
16970 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16971 : }
16972 :
16973 : static int ZEND_ASSIGN_BW_OR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16974 0 : {
16975 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16976 : }
16977 :
16978 : static int ZEND_ASSIGN_BW_AND_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16979 0 : {
16980 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16981 : }
16982 :
16983 : static int ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16984 0 : {
16985 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16986 : }
16987 :
16988 : static int zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
16989 0 : {
16990 0 : zend_op *opline = EX(opline);
16991 : zend_free_op free_op2;
16992 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
16993 : zval *object;
16994 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
16995 0 : zval **retval = &EX_T(opline->result.u.var).var.ptr;
16996 0 : int have_get_ptr = 0;
16997 :
16998 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
16999 0 : object = *object_ptr;
17000 :
17001 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
17002 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
17003 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17004 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
17005 0 : *retval = EG(uninitialized_zval_ptr);
17006 0 : PZVAL_LOCK(*retval);
17007 : }
17008 :
17009 0 : ZEND_VM_NEXT_OPCODE();
17010 : }
17011 :
17012 : /* here we are sure we are dealing with an object */
17013 :
17014 : if (0) {
17015 : MAKE_REAL_ZVAL_PTR(property);
17016 : }
17017 :
17018 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
17019 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
17020 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
17021 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
17022 :
17023 0 : have_get_ptr = 1;
17024 0 : incdec_op(*zptr);
17025 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
17026 0 : *retval = *zptr;
17027 0 : PZVAL_LOCK(*retval);
17028 : }
17029 : }
17030 : }
17031 :
17032 0 : if (!have_get_ptr) {
17033 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
17034 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
17035 :
17036 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
17037 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
17038 :
17039 0 : if (z->refcount == 0) {
17040 0 : zval_dtor(z);
17041 0 : FREE_ZVAL(z);
17042 : }
17043 0 : z = value;
17044 : }
17045 0 : z->refcount++;
17046 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
17047 0 : incdec_op(z);
17048 0 : *retval = z;
17049 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
17050 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
17051 0 : zval_ptr_dtor(&z);
17052 : } else {
17053 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
17054 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
17055 0 : *retval = EG(uninitialized_zval_ptr);
17056 0 : PZVAL_LOCK(*retval);
17057 : }
17058 : }
17059 : }
17060 :
17061 : if (0) {
17062 : zval_ptr_dtor(&property);
17063 : } else {
17064 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17065 : }
17066 :
17067 0 : ZEND_VM_NEXT_OPCODE();
17068 : }
17069 :
17070 : static int ZEND_PRE_INC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17071 0 : {
17072 0 : return zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17073 : }
17074 :
17075 : static int ZEND_PRE_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17076 0 : {
17077 0 : return zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17078 : }
17079 :
17080 : static int zend_post_incdec_property_helper_SPEC_UNUSED_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
17081 0 : {
17082 0 : zend_op *opline = EX(opline);
17083 : zend_free_op free_op2;
17084 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
17085 : zval *object;
17086 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
17087 0 : zval *retval = &EX_T(opline->result.u.var).tmp_var;
17088 0 : int have_get_ptr = 0;
17089 :
17090 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
17091 0 : object = *object_ptr;
17092 :
17093 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
17094 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
17095 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17096 0 : *retval = *EG(uninitialized_zval_ptr);
17097 :
17098 0 : ZEND_VM_NEXT_OPCODE();
17099 : }
17100 :
17101 : /* here we are sure we are dealing with an object */
17102 :
17103 : if (0) {
17104 : MAKE_REAL_ZVAL_PTR(property);
17105 : }
17106 :
17107 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
17108 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
17109 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
17110 0 : have_get_ptr = 1;
17111 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
17112 :
17113 0 : *retval = **zptr;
17114 0 : zendi_zval_copy_ctor(*retval);
17115 :
17116 0 : incdec_op(*zptr);
17117 :
17118 : }
17119 : }
17120 :
17121 0 : if (!have_get_ptr) {
17122 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
17123 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
17124 : zval *z_copy;
17125 :
17126 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
17127 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
17128 :
17129 0 : if (z->refcount == 0) {
17130 0 : zval_dtor(z);
17131 0 : FREE_ZVAL(z);
17132 : }
17133 0 : z = value;
17134 : }
17135 0 : *retval = *z;
17136 0 : zendi_zval_copy_ctor(*retval);
17137 0 : ALLOC_ZVAL(z_copy);
17138 0 : *z_copy = *z;
17139 0 : zendi_zval_copy_ctor(*z_copy);
17140 0 : INIT_PZVAL(z_copy);
17141 0 : incdec_op(z_copy);
17142 0 : z->refcount++;
17143 0 : Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
17144 0 : zval_ptr_dtor(&z_copy);
17145 0 : zval_ptr_dtor(&z);
17146 : } else {
17147 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
17148 0 : *retval = *EG(uninitialized_zval_ptr);
17149 : }
17150 : }
17151 :
17152 : if (0) {
17153 : zval_ptr_dtor(&property);
17154 : } else {
17155 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17156 : }
17157 :
17158 0 : ZEND_VM_NEXT_OPCODE();
17159 : }
17160 :
17161 : static int ZEND_POST_INC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17162 0 : {
17163 0 : return zend_post_incdec_property_helper_SPEC_UNUSED_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17164 : }
17165 :
17166 : static int ZEND_POST_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17167 0 : {
17168 0 : return zend_post_incdec_property_helper_SPEC_UNUSED_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17169 : }
17170 :
17171 : static int zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
17172 0 : {
17173 0 : zend_op *opline = EX(opline);
17174 : zval *container;
17175 : zval **retval;
17176 :
17177 :
17178 0 : retval = &EX_T(opline->result.u.var).var.ptr;
17179 0 : EX_T(opline->result.u.var).var.ptr_ptr = retval;
17180 :
17181 0 : container = _get_obj_zval_ptr_unused(TSRMLS_C);
17182 :
17183 0 : if (container == EG(error_zval_ptr)) {
17184 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
17185 0 : *retval = EG(error_zval_ptr);
17186 0 : PZVAL_LOCK(*retval);
17187 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
17188 : }
17189 :
17190 0 : ZEND_VM_NEXT_OPCODE();
17191 : }
17192 :
17193 :
17194 0 : if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
17195 0 : if (type != BP_VAR_IS) {
17196 0 : zend_error(E_NOTICE, "Trying to get property of non-object");
17197 : }
17198 0 : *retval = EG(uninitialized_zval_ptr);
17199 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
17200 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
17201 : } else {
17202 : zend_free_op free_op2;
17203 0 : zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
17204 :
17205 : if (0) {
17206 : MAKE_REAL_ZVAL_PTR(offset);
17207 : }
17208 :
17209 : /* here we are sure we are dealing with an object */
17210 0 : *retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
17211 :
17212 0 : if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
17213 0 : zval_dtor(*retval);
17214 0 : FREE_ZVAL(*retval);
17215 : } else {
17216 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
17217 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
17218 : }
17219 :
17220 : if (0) {
17221 : zval_ptr_dtor(&offset);
17222 : } else {
17223 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17224 : }
17225 : }
17226 :
17227 0 : ZEND_VM_NEXT_OPCODE();
17228 : }
17229 :
17230 : static int ZEND_FETCH_OBJ_R_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17231 0 : {
17232 0 : return zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17233 : }
17234 :
17235 : static int ZEND_FETCH_OBJ_W_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17236 0 : {
17237 0 : zend_op *opline = EX(opline);
17238 : zend_free_op free_op1, free_op2;
17239 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
17240 :
17241 0 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_UNUSED != IS_CV) {
17242 0 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
17243 0 : EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
17244 : }
17245 :
17246 : if (0) {
17247 : MAKE_REAL_ZVAL_PTR(property);
17248 : }
17249 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(TSRMLS_C), property, BP_VAR_W TSRMLS_CC);
17250 : if (0) {
17251 : zval_ptr_dtor(&property);
17252 : } else {
17253 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17254 : }
17255 : if (IS_UNUSED == IS_VAR && 0 &&
17256 : READY_TO_DESTROY(free_op1.var) &&
17257 : !RETURN_VALUE_UNUSED(&opline->result)) {
17258 : AI_USE_PTR(EX_T(opline->result.u.var).var);
17259 : }
17260 :
17261 0 : ZEND_VM_NEXT_OPCODE();
17262 : }
17263 :
17264 : static int ZEND_FETCH_OBJ_RW_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17265 0 : {
17266 0 : zend_op *opline = EX(opline);
17267 : zend_free_op free_op1, free_op2;
17268 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
17269 :
17270 : if (0) {
17271 : MAKE_REAL_ZVAL_PTR(property);
17272 : }
17273 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(TSRMLS_C), property, BP_VAR_RW TSRMLS_CC);
17274 : if (0) {
17275 : zval_ptr_dtor(&property);
17276 : } else {
17277 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17278 : }
17279 : if (IS_UNUSED == IS_VAR && 0 &&
17280 : READY_TO_DESTROY(free_op1.var) &&
17281 : !RETURN_VALUE_UNUSED(&opline->result)) {
17282 : AI_USE_PTR(EX_T(opline->result.u.var).var);
17283 : }
17284 :
17285 0 : ZEND_VM_NEXT_OPCODE();
17286 : }
17287 :
17288 : static int ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17289 0 : {
17290 0 : return zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17291 : }
17292 :
17293 : static int ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17294 0 : {
17295 0 : zend_op *opline = EX(opline);
17296 :
17297 0 : if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
17298 : /* Behave like FETCH_OBJ_W */
17299 : zend_free_op free_op1, free_op2;
17300 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
17301 :
17302 : if (0) {
17303 : MAKE_REAL_ZVAL_PTR(property);
17304 : }
17305 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(TSRMLS_C), property, BP_VAR_W TSRMLS_CC);
17306 : if (0) {
17307 : zval_ptr_dtor(&property);
17308 : } else {
17309 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17310 : }
17311 : if (IS_UNUSED == IS_VAR && 0 &&
17312 : READY_TO_DESTROY(free_op1.var) &&
17313 : !RETURN_VALUE_UNUSED(&opline->result)) {
17314 : AI_USE_PTR(EX_T(opline->result.u.var).var);
17315 : }
17316 :
17317 0 : ZEND_VM_NEXT_OPCODE();
17318 : } else {
17319 0 : return zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17320 : }
17321 : }
17322 :
17323 : static int ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17324 0 : {
17325 0 : zend_op *opline = EX(opline);
17326 : zend_free_op free_op1, free_op2, free_res;
17327 0 : zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
17328 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
17329 :
17330 : if (IS_UNUSED == IS_CV) {
17331 : if (container != &EG(uninitialized_zval_ptr)) {
17332 : SEPARATE_ZVAL_IF_NOT_REF(container);
17333 : }
17334 : }
17335 : if (0) {
17336 : MAKE_REAL_ZVAL_PTR(property);
17337 : }
17338 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
17339 : if (0) {
17340 : zval_ptr_dtor(&property);
17341 : } else {
17342 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17343 : }
17344 : if (IS_UNUSED == IS_VAR && 0 &&
17345 : READY_TO_DESTROY(free_op1.var) &&
17346 : !RETURN_VALUE_UNUSED(&opline->result)) {
17347 : AI_USE_PTR(EX_T(opline->result.u.var).var);
17348 : }
17349 :
17350 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
17351 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
17352 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
17353 : }
17354 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
17355 0 : FREE_OP_VAR_PTR(free_res);
17356 0 : ZEND_VM_NEXT_OPCODE();
17357 : }
17358 :
17359 : static int ZEND_ASSIGN_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17360 0 : {
17361 0 : zend_op *opline = EX(opline);
17362 0 : zend_op *op_data = opline+1;
17363 :
17364 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
17365 :
17366 0 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
17367 :
17368 : /* assign_obj has two opcodes! */
17369 0 : ZEND_VM_INC_OPCODE();
17370 0 : ZEND_VM_NEXT_OPCODE();
17371 : }
17372 :
17373 : static int ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17374 0 : {
17375 0 : zend_op *opline = EX(opline);
17376 : zval *function_name;
17377 : char *function_name_strval;
17378 : int function_name_strlen;
17379 : zend_free_op free_op2;
17380 :
17381 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
17382 :
17383 0 : function_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
17384 :
17385 0 : if (Z_TYPE_P(function_name)!=IS_STRING) {
17386 0 : zend_error_noreturn(E_ERROR, "Method name must be a string");
17387 : }
17388 :
17389 0 : function_name_strval = Z_STRVAL_P(function_name);
17390 0 : function_name_strlen = Z_STRLEN_P(function_name);
17391 :
17392 0 : EX(object) = _get_obj_zval_ptr_unused(TSRMLS_C);
17393 :
17394 0 : if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
17395 0 : if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
17396 0 : zend_error_noreturn(E_ERROR, "Object does not support method calls");
17397 : }
17398 :
17399 : /* First, locate the function. */
17400 0 : EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
17401 0 : if (!EX(fbc)) {
17402 0 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
17403 : }
17404 : } else {
17405 0 : zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
17406 : }
17407 :
17408 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
17409 0 : EX(object) = NULL;
17410 : } else {
17411 0 : if (!PZVAL_IS_REF(EX(object))) {
17412 0 : EX(object)->refcount++; /* For $this pointer */
17413 : } else {
17414 : zval *this_ptr;
17415 0 : ALLOC_ZVAL(this_ptr);
17416 0 : INIT_PZVAL_COPY(this_ptr, EX(object));
17417 0 : zval_copy_ctor(this_ptr);
17418 0 : EX(object) = this_ptr;
17419 : }
17420 : }
17421 :
17422 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17423 :
17424 0 : ZEND_VM_NEXT_OPCODE();
17425 : }
17426 :
17427 : static int ZEND_INIT_ARRAY_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17428 0 : {
17429 0 : zend_op *opline = EX(opline);
17430 :
17431 0 : array_init(&EX_T(opline->result.u.var).tmp_var);
17432 : if (IS_UNUSED == IS_UNUSED) {
17433 0 : ZEND_VM_NEXT_OPCODE();
17434 : #if 0 || IS_UNUSED != IS_UNUSED
17435 : } else {
17436 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17437 : #endif
17438 : }
17439 : }
17440 :
17441 : static int ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17442 0 : {
17443 0 : zend_op *opline = EX(opline);
17444 : zend_free_op free_op2;
17445 0 : zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
17446 0 : zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
17447 : long index;
17448 :
17449 0 : if (container) {
17450 : if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
17451 : SEPARATE_ZVAL_IF_NOT_REF(container);
17452 : }
17453 0 : switch (Z_TYPE_PP(container)) {
17454 : case IS_ARRAY: {
17455 0 : HashTable *ht = Z_ARRVAL_PP(container);
17456 :
17457 0 : switch (Z_TYPE_P(offset)) {
17458 : case IS_DOUBLE:
17459 0 : index = (long) Z_DVAL_P(offset);
17460 0 : zend_hash_index_del(ht, index);
17461 0 : break;
17462 : case IS_RESOURCE:
17463 : case IS_BOOL:
17464 : case IS_LONG:
17465 0 : index = Z_LVAL_P(offset);
17466 0 : zend_hash_index_del(ht, index);
17467 0 : break;
17468 : case IS_STRING:
17469 : if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
17470 0 : offset->refcount++;
17471 : }
17472 0 : if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
17473 : ht == &EG(symbol_table)) {
17474 : zend_execute_data *ex;
17475 0 : ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
17476 :
17477 0 : for (ex = execute_data; ex; ex = ex->prev_execute_data) {
17478 0 : if (ex->op_array && ex->symbol_table == ht) {
17479 : int i;
17480 :
17481 0 : for (i = 0; i < ex->op_array->last_var; i++) {
17482 0 : if (ex->op_array->vars[i].hash_value == hash_value &&
17483 : ex->op_array->vars[i].name_len == offset->value.str.len &&
17484 : !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
17485 0 : ex->CVs[i] = NULL;
17486 0 : break;
17487 : }
17488 : }
17489 : }
17490 : }
17491 : }
17492 : if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
17493 0 : zval_ptr_dtor(&offset);
17494 : }
17495 0 : break;
17496 : case IS_NULL:
17497 0 : zend_hash_del(ht, "", sizeof(""));
17498 0 : break;
17499 : default:
17500 0 : zend_error(E_WARNING, "Illegal offset type in unset");
17501 : break;
17502 : }
17503 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17504 0 : break;
17505 : }
17506 : case IS_OBJECT:
17507 0 : if (!Z_OBJ_HT_P(*container)->unset_dimension) {
17508 0 : zend_error_noreturn(E_ERROR, "Cannot use object as array");
17509 : }
17510 : if (0) {
17511 : MAKE_REAL_ZVAL_PTR(offset);
17512 : }
17513 0 : Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
17514 : if (0) {
17515 : zval_ptr_dtor(&offset);
17516 : } else {
17517 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17518 : }
17519 0 : break;
17520 : case IS_STRING:
17521 0 : zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
17522 : ZEND_VM_CONTINUE(); /* bailed out before */
17523 : default:
17524 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17525 : break;
17526 : }
17527 : } else {
17528 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17529 : }
17530 :
17531 0 : ZEND_VM_NEXT_OPCODE();
17532 : }
17533 :
17534 : static int ZEND_UNSET_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17535 0 : {
17536 0 : zend_op *opline = EX(opline);
17537 : zend_free_op free_op2;
17538 0 : zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
17539 0 : zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
17540 :
17541 0 : if (container) {
17542 : if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
17543 : SEPARATE_ZVAL_IF_NOT_REF(container);
17544 : }
17545 0 : if (Z_TYPE_PP(container) == IS_OBJECT) {
17546 : if (0) {
17547 : MAKE_REAL_ZVAL_PTR(offset);
17548 : }
17549 0 : Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
17550 : if (0) {
17551 : zval_ptr_dtor(&offset);
17552 : } else {
17553 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17554 : }
17555 : } else {
17556 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17557 : }
17558 : } else {
17559 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17560 : }
17561 :
17562 0 : ZEND_VM_NEXT_OPCODE();
17563 : }
17564 :
17565 : static int zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
17566 0 : {
17567 0 : zend_op *opline = EX(opline);
17568 :
17569 0 : zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
17570 0 : zval **value = NULL;
17571 0 : int result = 0;
17572 : long index;
17573 :
17574 0 : if (container) {
17575 : zend_free_op free_op2;
17576 0 : zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
17577 :
17578 0 : if (Z_TYPE_PP(container) == IS_ARRAY) {
17579 : HashTable *ht;
17580 0 : int isset = 0;
17581 :
17582 0 : ht = Z_ARRVAL_PP(container);
17583 :
17584 0 : switch (Z_TYPE_P(offset)) {
17585 : case IS_DOUBLE:
17586 0 : index = (long) Z_DVAL_P(offset);
17587 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
17588 0 : isset = 1;
17589 : }
17590 0 : break;
17591 : case IS_RESOURCE:
17592 : case IS_BOOL:
17593 : case IS_LONG:
17594 0 : index = Z_LVAL_P(offset);
17595 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
17596 0 : isset = 1;
17597 : }
17598 0 : break;
17599 : case IS_STRING:
17600 0 : if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
17601 0 : isset = 1;
17602 : }
17603 0 : break;
17604 : case IS_NULL:
17605 0 : if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
17606 0 : isset = 1;
17607 : }
17608 0 : break;
17609 : default:
17610 0 : zend_error(E_WARNING, "Illegal offset type in isset or empty");
17611 :
17612 : break;
17613 : }
17614 :
17615 0 : switch (opline->extended_value) {
17616 : case ZEND_ISSET:
17617 0 : if (isset && Z_TYPE_PP(value) == IS_NULL) {
17618 0 : result = 0;
17619 : } else {
17620 0 : result = isset;
17621 : }
17622 0 : break;
17623 : case ZEND_ISEMPTY:
17624 0 : if (!isset || !i_zend_is_true(*value)) {
17625 0 : result = 0;
17626 : } else {
17627 0 : result = 1;
17628 : }
17629 : break;
17630 : }
17631 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17632 0 : } else if (Z_TYPE_PP(container) == IS_OBJECT) {
17633 : if (0) {
17634 : MAKE_REAL_ZVAL_PTR(offset);
17635 : }
17636 0 : if (prop_dim) {
17637 0 : result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
17638 : } else {
17639 0 : result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
17640 : }
17641 : if (0) {
17642 : zval_ptr_dtor(&offset);
17643 : } else {
17644 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17645 : }
17646 0 : } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
17647 : zval tmp;
17648 :
17649 0 : if (Z_TYPE_P(offset) != IS_LONG) {
17650 0 : tmp = *offset;
17651 0 : zval_copy_ctor(&tmp);
17652 0 : convert_to_long(&tmp);
17653 0 : offset = &tmp;
17654 : }
17655 0 : if (Z_TYPE_P(offset) == IS_LONG) {
17656 0 : switch (opline->extended_value) {
17657 : case ZEND_ISSET:
17658 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
17659 0 : result = 1;
17660 : }
17661 0 : break;
17662 : case ZEND_ISEMPTY:
17663 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
17664 0 : result = 1;
17665 : }
17666 : break;
17667 : }
17668 : }
17669 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17670 : } else {
17671 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
17672 : }
17673 : }
17674 :
17675 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
17676 :
17677 0 : switch (opline->extended_value) {
17678 : case ZEND_ISSET:
17679 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
17680 0 : break;
17681 : case ZEND_ISEMPTY:
17682 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
17683 : break;
17684 : }
17685 :
17686 0 : ZEND_VM_NEXT_OPCODE();
17687 : }
17688 :
17689 : static int ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17690 0 : {
17691 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17692 : }
17693 :
17694 : static int ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17695 0 : {
17696 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17697 : }
17698 :
17699 : static int zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
17700 0 : {
17701 0 : zend_op *opline = EX(opline);
17702 0 : zend_op *op_data = opline+1;
17703 : zend_free_op free_op_data1;
17704 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
17705 : zval *object;
17706 0 : zval *property = NULL;
17707 0 : zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
17708 0 : znode *result = &opline->result;
17709 0 : zval **retval = &EX_T(result->u.var).var.ptr;
17710 0 : int have_get_ptr = 0;
17711 :
17712 0 : EX_T(result->u.var).var.ptr_ptr = NULL;
17713 0 : make_real_object(object_ptr TSRMLS_CC);
17714 0 : object = *object_ptr;
17715 :
17716 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
17717 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
17718 :
17719 0 : FREE_OP(free_op_data1);
17720 :
17721 0 : if (!RETURN_VALUE_UNUSED(result)) {
17722 0 : *retval = EG(uninitialized_zval_ptr);
17723 0 : PZVAL_LOCK(*retval);
17724 : }
17725 : } else {
17726 : /* here we are sure we are dealing with an object */
17727 : if (0) {
17728 : MAKE_REAL_ZVAL_PTR(property);
17729 : }
17730 :
17731 : /* here property is a string */
17732 0 : if (opline->extended_value == ZEND_ASSIGN_OBJ
17733 : && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
17734 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
17735 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
17736 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
17737 :
17738 0 : have_get_ptr = 1;
17739 0 : binary_op(*zptr, *zptr, value TSRMLS_CC);
17740 0 : if (!RETURN_VALUE_UNUSED(result)) {
17741 0 : *retval = *zptr;
17742 0 : PZVAL_LOCK(*retval);
17743 : }
17744 : }
17745 : }
17746 :
17747 0 : if (!have_get_ptr) {
17748 0 : zval *z = NULL;
17749 :
17750 0 : switch (opline->extended_value) {
17751 : case ZEND_ASSIGN_OBJ:
17752 0 : if (Z_OBJ_HT_P(object)->read_property) {
17753 0 : z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
17754 : }
17755 0 : break;
17756 : case ZEND_ASSIGN_DIM:
17757 0 : if (Z_OBJ_HT_P(object)->read_dimension) {
17758 0 : z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
17759 : }
17760 : break;
17761 : }
17762 0 : if (z) {
17763 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
17764 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
17765 :
17766 0 : if (z->refcount == 0) {
17767 0 : zval_dtor(z);
17768 0 : FREE_ZVAL(z);
17769 : }
17770 0 : z = value;
17771 : }
17772 0 : z->refcount++;
17773 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
17774 0 : binary_op(z, z, value TSRMLS_CC);
17775 0 : switch (opline->extended_value) {
17776 : case ZEND_ASSIGN_OBJ:
17777 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
17778 0 : break;
17779 : case ZEND_ASSIGN_DIM:
17780 0 : Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
17781 : break;
17782 : }
17783 0 : if (!RETURN_VALUE_UNUSED(result)) {
17784 0 : *retval = z;
17785 0 : PZVAL_LOCK(*retval);
17786 : }
17787 0 : zval_ptr_dtor(&z);
17788 : } else {
17789 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
17790 0 : if (!RETURN_VALUE_UNUSED(result)) {
17791 0 : *retval = EG(uninitialized_zval_ptr);
17792 0 : PZVAL_LOCK(*retval);
17793 : }
17794 : }
17795 : }
17796 :
17797 : if (0) {
17798 : zval_ptr_dtor(&property);
17799 : } else {
17800 :
17801 : }
17802 0 : FREE_OP(free_op_data1);
17803 : }
17804 :
17805 : /* assign_obj has two opcodes! */
17806 0 : ZEND_VM_INC_OPCODE();
17807 0 : ZEND_VM_NEXT_OPCODE();
17808 : }
17809 :
17810 : static int zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
17811 0 : {
17812 0 : zend_op *opline = EX(opline);
17813 : zend_free_op free_op_data2, free_op_data1;
17814 : zval **var_ptr;
17815 : zval *value;
17816 0 : zend_bool increment_opline = 0;
17817 :
17818 0 : switch (opline->extended_value) {
17819 : case ZEND_ASSIGN_OBJ:
17820 0 : return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17821 : break;
17822 : case ZEND_ASSIGN_DIM: {
17823 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
17824 :
17825 0 : if (object_ptr && IS_UNUSED != IS_CV && !0) {
17826 0 : (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
17827 : }
17828 :
17829 0 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
17830 0 : return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17831 : } else {
17832 0 : zend_op *op_data = opline+1;
17833 0 : zval *dim = NULL;
17834 :
17835 0 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), NULL, dim, 0, BP_VAR_RW TSRMLS_CC);
17836 0 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
17837 0 : var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
17838 0 : increment_opline = 1;
17839 : }
17840 : }
17841 0 : break;
17842 : default:
17843 0 : value = NULL;
17844 0 : var_ptr = NULL;
17845 : /* do nothing */
17846 : break;
17847 : }
17848 :
17849 0 : if (!var_ptr) {
17850 0 : zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
17851 : }
17852 :
17853 0 : if (*var_ptr == EG(error_zval_ptr)) {
17854 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
17855 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
17856 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
17857 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
17858 : }
17859 :
17860 :
17861 0 : if (increment_opline) {
17862 0 : ZEND_VM_INC_OPCODE();
17863 : }
17864 0 : ZEND_VM_NEXT_OPCODE();
17865 : }
17866 :
17867 0 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
17868 :
17869 0 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
17870 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
17871 : /* proxy object */
17872 0 : zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
17873 0 : objval->refcount++;
17874 0 : binary_op(objval, objval, value TSRMLS_CC);
17875 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
17876 0 : zval_ptr_dtor(&objval);
17877 : } else {
17878 0 : binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
17879 : }
17880 :
17881 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
17882 0 : EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
17883 0 : PZVAL_LOCK(*var_ptr);
17884 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
17885 : }
17886 :
17887 0 : if (increment_opline) {
17888 0 : ZEND_VM_INC_OPCODE();
17889 0 : FREE_OP(free_op_data1);
17890 0 : FREE_OP_VAR_PTR(free_op_data2);
17891 : }
17892 :
17893 0 : ZEND_VM_NEXT_OPCODE();
17894 : }
17895 :
17896 : static int ZEND_ASSIGN_ADD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17897 0 : {
17898 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17899 : }
17900 :
17901 : static int ZEND_ASSIGN_SUB_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17902 0 : {
17903 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17904 : }
17905 :
17906 : static int ZEND_ASSIGN_MUL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17907 0 : {
17908 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17909 : }
17910 :
17911 : static int ZEND_ASSIGN_DIV_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17912 0 : {
17913 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17914 : }
17915 :
17916 : static int ZEND_ASSIGN_MOD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17917 0 : {
17918 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17919 : }
17920 :
17921 : static int ZEND_ASSIGN_SL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17922 0 : {
17923 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17924 : }
17925 :
17926 : static int ZEND_ASSIGN_SR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17927 0 : {
17928 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17929 : }
17930 :
17931 : static int ZEND_ASSIGN_CONCAT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17932 0 : {
17933 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17934 : }
17935 :
17936 : static int ZEND_ASSIGN_BW_OR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17937 0 : {
17938 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17939 : }
17940 :
17941 : static int ZEND_ASSIGN_BW_AND_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17942 0 : {
17943 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17944 : }
17945 :
17946 : static int ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17947 0 : {
17948 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17949 : }
17950 :
17951 : static int ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17952 136 : {
17953 136 : zend_op *opline = EX(opline);
17954 :
17955 136 : array_init(&EX_T(opline->result.u.var).tmp_var);
17956 : if (IS_UNUSED == IS_UNUSED) {
17957 136 : ZEND_VM_NEXT_OPCODE();
17958 : #if 0 || IS_UNUSED != IS_UNUSED
17959 : } else {
17960 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17961 : #endif
17962 : }
17963 : }
17964 :
17965 : static int zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
17966 0 : {
17967 0 : zend_op *opline = EX(opline);
17968 0 : zend_op *op_data = opline+1;
17969 : zend_free_op free_op_data1;
17970 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
17971 : zval *object;
17972 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
17973 0 : zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
17974 0 : znode *result = &opline->result;
17975 0 : zval **retval = &EX_T(result->u.var).var.ptr;
17976 0 : int have_get_ptr = 0;
17977 :
17978 0 : EX_T(result->u.var).var.ptr_ptr = NULL;
17979 0 : make_real_object(object_ptr TSRMLS_CC);
17980 0 : object = *object_ptr;
17981 :
17982 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
17983 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
17984 :
17985 0 : FREE_OP(free_op_data1);
17986 :
17987 0 : if (!RETURN_VALUE_UNUSED(result)) {
17988 0 : *retval = EG(uninitialized_zval_ptr);
17989 0 : PZVAL_LOCK(*retval);
17990 : }
17991 : } else {
17992 : /* here we are sure we are dealing with an object */
17993 : if (0) {
17994 : MAKE_REAL_ZVAL_PTR(property);
17995 : }
17996 :
17997 : /* here property is a string */
17998 0 : if (opline->extended_value == ZEND_ASSIGN_OBJ
17999 : && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
18000 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
18001 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
18002 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
18003 :
18004 0 : have_get_ptr = 1;
18005 0 : binary_op(*zptr, *zptr, value TSRMLS_CC);
18006 0 : if (!RETURN_VALUE_UNUSED(result)) {
18007 0 : *retval = *zptr;
18008 0 : PZVAL_LOCK(*retval);
18009 : }
18010 : }
18011 : }
18012 :
18013 0 : if (!have_get_ptr) {
18014 0 : zval *z = NULL;
18015 :
18016 0 : switch (opline->extended_value) {
18017 : case ZEND_ASSIGN_OBJ:
18018 0 : if (Z_OBJ_HT_P(object)->read_property) {
18019 0 : z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
18020 : }
18021 0 : break;
18022 : case ZEND_ASSIGN_DIM:
18023 0 : if (Z_OBJ_HT_P(object)->read_dimension) {
18024 0 : z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
18025 : }
18026 : break;
18027 : }
18028 0 : if (z) {
18029 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
18030 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
18031 :
18032 0 : if (z->refcount == 0) {
18033 0 : zval_dtor(z);
18034 0 : FREE_ZVAL(z);
18035 : }
18036 0 : z = value;
18037 : }
18038 0 : z->refcount++;
18039 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
18040 0 : binary_op(z, z, value TSRMLS_CC);
18041 0 : switch (opline->extended_value) {
18042 : case ZEND_ASSIGN_OBJ:
18043 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
18044 0 : break;
18045 : case ZEND_ASSIGN_DIM:
18046 0 : Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
18047 : break;
18048 : }
18049 0 : if (!RETURN_VALUE_UNUSED(result)) {
18050 0 : *retval = z;
18051 0 : PZVAL_LOCK(*retval);
18052 : }
18053 0 : zval_ptr_dtor(&z);
18054 : } else {
18055 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
18056 0 : if (!RETURN_VALUE_UNUSED(result)) {
18057 0 : *retval = EG(uninitialized_zval_ptr);
18058 0 : PZVAL_LOCK(*retval);
18059 : }
18060 : }
18061 : }
18062 :
18063 : if (0) {
18064 : zval_ptr_dtor(&property);
18065 : } else {
18066 :
18067 : }
18068 0 : FREE_OP(free_op_data1);
18069 : }
18070 :
18071 : /* assign_obj has two opcodes! */
18072 0 : ZEND_VM_INC_OPCODE();
18073 0 : ZEND_VM_NEXT_OPCODE();
18074 : }
18075 :
18076 : static int zend_binary_assign_op_helper_SPEC_UNUSED_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
18077 0 : {
18078 0 : zend_op *opline = EX(opline);
18079 : zend_free_op free_op_data2, free_op_data1;
18080 : zval **var_ptr;
18081 : zval *value;
18082 0 : zend_bool increment_opline = 0;
18083 :
18084 0 : switch (opline->extended_value) {
18085 : case ZEND_ASSIGN_OBJ:
18086 0 : return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18087 : break;
18088 : case ZEND_ASSIGN_DIM: {
18089 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
18090 :
18091 0 : if (object_ptr && IS_UNUSED != IS_CV && !0) {
18092 0 : (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
18093 : }
18094 :
18095 0 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
18096 0 : return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18097 : } else {
18098 0 : zend_op *op_data = opline+1;
18099 0 : zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
18100 :
18101 0 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), NULL, dim, 0, BP_VAR_RW TSRMLS_CC);
18102 0 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
18103 0 : var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
18104 0 : increment_opline = 1;
18105 : }
18106 : }
18107 0 : break;
18108 : default:
18109 0 : value = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
18110 0 : var_ptr = NULL;
18111 : /* do nothing */
18112 : break;
18113 : }
18114 :
18115 0 : if (!var_ptr) {
18116 0 : zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
18117 : }
18118 :
18119 0 : if (*var_ptr == EG(error_zval_ptr)) {
18120 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
18121 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
18122 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
18123 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
18124 : }
18125 :
18126 :
18127 0 : if (increment_opline) {
18128 0 : ZEND_VM_INC_OPCODE();
18129 : }
18130 0 : ZEND_VM_NEXT_OPCODE();
18131 : }
18132 :
18133 0 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
18134 :
18135 0 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
18136 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
18137 : /* proxy object */
18138 0 : zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
18139 0 : objval->refcount++;
18140 0 : binary_op(objval, objval, value TSRMLS_CC);
18141 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
18142 0 : zval_ptr_dtor(&objval);
18143 : } else {
18144 0 : binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
18145 : }
18146 :
18147 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
18148 0 : EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
18149 0 : PZVAL_LOCK(*var_ptr);
18150 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
18151 : }
18152 :
18153 0 : if (increment_opline) {
18154 0 : ZEND_VM_INC_OPCODE();
18155 0 : FREE_OP(free_op_data1);
18156 0 : FREE_OP_VAR_PTR(free_op_data2);
18157 : }
18158 :
18159 0 : ZEND_VM_NEXT_OPCODE();
18160 : }
18161 :
18162 : static int ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18163 0 : {
18164 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18165 : }
18166 :
18167 : static int ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18168 0 : {
18169 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18170 : }
18171 :
18172 : static int ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18173 0 : {
18174 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18175 : }
18176 :
18177 : static int ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18178 0 : {
18179 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18180 : }
18181 :
18182 : static int ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18183 0 : {
18184 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18185 : }
18186 :
18187 : static int ZEND_ASSIGN_SL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18188 0 : {
18189 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18190 : }
18191 :
18192 : static int ZEND_ASSIGN_SR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18193 0 : {
18194 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18195 : }
18196 :
18197 : static int ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18198 0 : {
18199 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18200 : }
18201 :
18202 : static int ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18203 0 : {
18204 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18205 : }
18206 :
18207 : static int ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18208 0 : {
18209 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18210 : }
18211 :
18212 : static int ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18213 0 : {
18214 0 : return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18215 : }
18216 :
18217 : static int zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
18218 0 : {
18219 0 : zend_op *opline = EX(opline);
18220 :
18221 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
18222 : zval *object;
18223 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
18224 0 : zval **retval = &EX_T(opline->result.u.var).var.ptr;
18225 0 : int have_get_ptr = 0;
18226 :
18227 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
18228 0 : object = *object_ptr;
18229 :
18230 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
18231 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
18232 :
18233 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
18234 0 : *retval = EG(uninitialized_zval_ptr);
18235 0 : PZVAL_LOCK(*retval);
18236 : }
18237 :
18238 0 : ZEND_VM_NEXT_OPCODE();
18239 : }
18240 :
18241 : /* here we are sure we are dealing with an object */
18242 :
18243 : if (0) {
18244 : MAKE_REAL_ZVAL_PTR(property);
18245 : }
18246 :
18247 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
18248 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
18249 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
18250 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
18251 :
18252 0 : have_get_ptr = 1;
18253 0 : incdec_op(*zptr);
18254 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
18255 0 : *retval = *zptr;
18256 0 : PZVAL_LOCK(*retval);
18257 : }
18258 : }
18259 : }
18260 :
18261 0 : if (!have_get_ptr) {
18262 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
18263 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
18264 :
18265 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
18266 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
18267 :
18268 0 : if (z->refcount == 0) {
18269 0 : zval_dtor(z);
18270 0 : FREE_ZVAL(z);
18271 : }
18272 0 : z = value;
18273 : }
18274 0 : z->refcount++;
18275 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
18276 0 : incdec_op(z);
18277 0 : *retval = z;
18278 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
18279 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
18280 0 : zval_ptr_dtor(&z);
18281 : } else {
18282 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
18283 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
18284 0 : *retval = EG(uninitialized_zval_ptr);
18285 0 : PZVAL_LOCK(*retval);
18286 : }
18287 : }
18288 : }
18289 :
18290 : if (0) {
18291 : zval_ptr_dtor(&property);
18292 : } else {
18293 :
18294 : }
18295 :
18296 0 : ZEND_VM_NEXT_OPCODE();
18297 : }
18298 :
18299 : static int ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18300 0 : {
18301 0 : return zend_pre_incdec_property_helper_SPEC_UNUSED_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18302 : }
18303 :
18304 : static int ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18305 0 : {
18306 0 : return zend_pre_incdec_property_helper_SPEC_UNUSED_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18307 : }
18308 :
18309 : static int zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
18310 0 : {
18311 0 : zend_op *opline = EX(opline);
18312 :
18313 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
18314 : zval *object;
18315 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
18316 0 : zval *retval = &EX_T(opline->result.u.var).tmp_var;
18317 0 : int have_get_ptr = 0;
18318 :
18319 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
18320 0 : object = *object_ptr;
18321 :
18322 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
18323 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
18324 :
18325 0 : *retval = *EG(uninitialized_zval_ptr);
18326 :
18327 0 : ZEND_VM_NEXT_OPCODE();
18328 : }
18329 :
18330 : /* here we are sure we are dealing with an object */
18331 :
18332 : if (0) {
18333 : MAKE_REAL_ZVAL_PTR(property);
18334 : }
18335 :
18336 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
18337 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
18338 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
18339 0 : have_get_ptr = 1;
18340 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
18341 :
18342 0 : *retval = **zptr;
18343 0 : zendi_zval_copy_ctor(*retval);
18344 :
18345 0 : incdec_op(*zptr);
18346 :
18347 : }
18348 : }
18349 :
18350 0 : if (!have_get_ptr) {
18351 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
18352 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
18353 : zval *z_copy;
18354 :
18355 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
18356 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
18357 :
18358 0 : if (z->refcount == 0) {
18359 0 : zval_dtor(z);
18360 0 : FREE_ZVAL(z);
18361 : }
18362 0 : z = value;
18363 : }
18364 0 : *retval = *z;
18365 0 : zendi_zval_copy_ctor(*retval);
18366 0 : ALLOC_ZVAL(z_copy);
18367 0 : *z_copy = *z;
18368 0 : zendi_zval_copy_ctor(*z_copy);
18369 0 : INIT_PZVAL(z_copy);
18370 0 : incdec_op(z_copy);
18371 0 : z->refcount++;
18372 0 : Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
18373 0 : zval_ptr_dtor(&z_copy);
18374 0 : zval_ptr_dtor(&z);
18375 : } else {
18376 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
18377 0 : *retval = *EG(uninitialized_zval_ptr);
18378 : }
18379 : }
18380 :
18381 : if (0) {
18382 : zval_ptr_dtor(&property);
18383 : } else {
18384 :
18385 : }
18386 :
18387 0 : ZEND_VM_NEXT_OPCODE();
18388 : }
18389 :
18390 : static int ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18391 0 : {
18392 0 : return zend_post_incdec_property_helper_SPEC_UNUSED_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18393 : }
18394 :
18395 : static int ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18396 0 : {
18397 0 : return zend_post_incdec_property_helper_SPEC_UNUSED_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18398 : }
18399 :
18400 : static int zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(int type, ZEND_OPCODE_HANDLER_ARGS)
18401 0 : {
18402 0 : zend_op *opline = EX(opline);
18403 : zval *container;
18404 : zval **retval;
18405 :
18406 :
18407 0 : retval = &EX_T(opline->result.u.var).var.ptr;
18408 0 : EX_T(opline->result.u.var).var.ptr_ptr = retval;
18409 :
18410 0 : container = _get_obj_zval_ptr_unused(TSRMLS_C);
18411 :
18412 0 : if (container == EG(error_zval_ptr)) {
18413 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
18414 0 : *retval = EG(error_zval_ptr);
18415 0 : PZVAL_LOCK(*retval);
18416 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
18417 : }
18418 :
18419 0 : ZEND_VM_NEXT_OPCODE();
18420 : }
18421 :
18422 :
18423 0 : if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
18424 0 : if (type != BP_VAR_IS) {
18425 0 : zend_error(E_NOTICE, "Trying to get property of non-object");
18426 : }
18427 0 : *retval = EG(uninitialized_zval_ptr);
18428 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
18429 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
18430 : } else {
18431 :
18432 0 : zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
18433 :
18434 : if (0) {
18435 : MAKE_REAL_ZVAL_PTR(offset);
18436 : }
18437 :
18438 : /* here we are sure we are dealing with an object */
18439 0 : *retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
18440 :
18441 0 : if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
18442 0 : zval_dtor(*retval);
18443 0 : FREE_ZVAL(*retval);
18444 : } else {
18445 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
18446 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
18447 : }
18448 :
18449 : if (0) {
18450 : zval_ptr_dtor(&offset);
18451 : } else {
18452 :
18453 : }
18454 : }
18455 :
18456 0 : ZEND_VM_NEXT_OPCODE();
18457 : }
18458 :
18459 : static int ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18460 0 : {
18461 0 : return zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18462 : }
18463 :
18464 : static int ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18465 0 : {
18466 0 : zend_op *opline = EX(opline);
18467 : zend_free_op free_op1;
18468 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
18469 :
18470 0 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_UNUSED != IS_CV) {
18471 0 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
18472 0 : EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
18473 : }
18474 :
18475 : if (0) {
18476 : MAKE_REAL_ZVAL_PTR(property);
18477 : }
18478 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(TSRMLS_C), property, BP_VAR_W TSRMLS_CC);
18479 : if (0) {
18480 : zval_ptr_dtor(&property);
18481 : } else {
18482 :
18483 : }
18484 : if (IS_UNUSED == IS_VAR && 0 &&
18485 : READY_TO_DESTROY(free_op1.var) &&
18486 : !RETURN_VALUE_UNUSED(&opline->result)) {
18487 : AI_USE_PTR(EX_T(opline->result.u.var).var);
18488 : }
18489 :
18490 0 : ZEND_VM_NEXT_OPCODE();
18491 : }
18492 :
18493 : static int ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18494 0 : {
18495 0 : zend_op *opline = EX(opline);
18496 : zend_free_op free_op1;
18497 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
18498 :
18499 : if (0) {
18500 : MAKE_REAL_ZVAL_PTR(property);
18501 : }
18502 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(TSRMLS_C), property, BP_VAR_RW TSRMLS_CC);
18503 : if (0) {
18504 : zval_ptr_dtor(&property);
18505 : } else {
18506 :
18507 : }
18508 : if (IS_UNUSED == IS_VAR && 0 &&
18509 : READY_TO_DESTROY(free_op1.var) &&
18510 : !RETURN_VALUE_UNUSED(&opline->result)) {
18511 : AI_USE_PTR(EX_T(opline->result.u.var).var);
18512 : }
18513 :
18514 0 : ZEND_VM_NEXT_OPCODE();
18515 : }
18516 :
18517 : static int ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18518 0 : {
18519 0 : return zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18520 : }
18521 :
18522 : static int ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18523 0 : {
18524 0 : zend_op *opline = EX(opline);
18525 :
18526 0 : if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
18527 : /* Behave like FETCH_OBJ_W */
18528 : zend_free_op free_op1;
18529 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
18530 :
18531 : if (0) {
18532 : MAKE_REAL_ZVAL_PTR(property);
18533 : }
18534 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(TSRMLS_C), property, BP_VAR_W TSRMLS_CC);
18535 : if (0) {
18536 : zval_ptr_dtor(&property);
18537 : } else {
18538 :
18539 : }
18540 : if (IS_UNUSED == IS_VAR && 0 &&
18541 : READY_TO_DESTROY(free_op1.var) &&
18542 : !RETURN_VALUE_UNUSED(&opline->result)) {
18543 : AI_USE_PTR(EX_T(opline->result.u.var).var);
18544 : }
18545 :
18546 0 : ZEND_VM_NEXT_OPCODE();
18547 : } else {
18548 0 : return zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18549 : }
18550 : }
18551 :
18552 : static int ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18553 0 : {
18554 0 : zend_op *opline = EX(opline);
18555 : zend_free_op free_op1, free_res;
18556 0 : zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
18557 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
18558 :
18559 : if (IS_UNUSED == IS_CV) {
18560 : if (container != &EG(uninitialized_zval_ptr)) {
18561 : SEPARATE_ZVAL_IF_NOT_REF(container);
18562 : }
18563 : }
18564 : if (0) {
18565 : MAKE_REAL_ZVAL_PTR(property);
18566 : }
18567 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
18568 : if (0) {
18569 : zval_ptr_dtor(&property);
18570 : } else {
18571 :
18572 : }
18573 : if (IS_UNUSED == IS_VAR && 0 &&
18574 : READY_TO_DESTROY(free_op1.var) &&
18575 : !RETURN_VALUE_UNUSED(&opline->result)) {
18576 : AI_USE_PTR(EX_T(opline->result.u.var).var);
18577 : }
18578 :
18579 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
18580 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
18581 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
18582 : }
18583 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
18584 0 : FREE_OP_VAR_PTR(free_res);
18585 0 : ZEND_VM_NEXT_OPCODE();
18586 : }
18587 :
18588 : static int ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18589 0 : {
18590 0 : zend_op *opline = EX(opline);
18591 0 : zend_op *op_data = opline+1;
18592 :
18593 0 : zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
18594 :
18595 0 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
18596 :
18597 : /* assign_obj has two opcodes! */
18598 0 : ZEND_VM_INC_OPCODE();
18599 0 : ZEND_VM_NEXT_OPCODE();
18600 : }
18601 :
18602 : static int ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18603 0 : {
18604 0 : zend_op *opline = EX(opline);
18605 : zval *function_name;
18606 : char *function_name_strval;
18607 : int function_name_strlen;
18608 :
18609 :
18610 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
18611 :
18612 0 : function_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
18613 :
18614 0 : if (Z_TYPE_P(function_name)!=IS_STRING) {
18615 0 : zend_error_noreturn(E_ERROR, "Method name must be a string");
18616 : }
18617 :
18618 0 : function_name_strval = Z_STRVAL_P(function_name);
18619 0 : function_name_strlen = Z_STRLEN_P(function_name);
18620 :
18621 0 : EX(object) = _get_obj_zval_ptr_unused(TSRMLS_C);
18622 :
18623 0 : if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
18624 0 : if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
18625 0 : zend_error_noreturn(E_ERROR, "Object does not support method calls");
18626 : }
18627 :
18628 : /* First, locate the function. */
18629 0 : EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
18630 0 : if (!EX(fbc)) {
18631 0 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
18632 : }
18633 : } else {
18634 0 : zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
18635 : }
18636 :
18637 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
18638 0 : EX(object) = NULL;
18639 : } else {
18640 0 : if (!PZVAL_IS_REF(EX(object))) {
18641 0 : EX(object)->refcount++; /* For $this pointer */
18642 : } else {
18643 : zval *this_ptr;
18644 0 : ALLOC_ZVAL(this_ptr);
18645 0 : INIT_PZVAL_COPY(this_ptr, EX(object));
18646 0 : zval_copy_ctor(this_ptr);
18647 0 : EX(object) = this_ptr;
18648 : }
18649 : }
18650 :
18651 :
18652 0 : ZEND_VM_NEXT_OPCODE();
18653 : }
18654 :
18655 : static int ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18656 0 : {
18657 0 : zend_op *opline = EX(opline);
18658 :
18659 0 : array_init(&EX_T(opline->result.u.var).tmp_var);
18660 : if (IS_UNUSED == IS_UNUSED) {
18661 0 : ZEND_VM_NEXT_OPCODE();
18662 : #if 0 || IS_UNUSED != IS_UNUSED
18663 : } else {
18664 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18665 : #endif
18666 : }
18667 : }
18668 :
18669 : static int ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18670 0 : {
18671 0 : zend_op *opline = EX(opline);
18672 :
18673 0 : zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
18674 0 : zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
18675 : long index;
18676 :
18677 0 : if (container) {
18678 : if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
18679 : SEPARATE_ZVAL_IF_NOT_REF(container);
18680 : }
18681 0 : switch (Z_TYPE_PP(container)) {
18682 : case IS_ARRAY: {
18683 0 : HashTable *ht = Z_ARRVAL_PP(container);
18684 :
18685 0 : switch (Z_TYPE_P(offset)) {
18686 : case IS_DOUBLE:
18687 0 : index = (long) Z_DVAL_P(offset);
18688 0 : zend_hash_index_del(ht, index);
18689 0 : break;
18690 : case IS_RESOURCE:
18691 : case IS_BOOL:
18692 : case IS_LONG:
18693 0 : index = Z_LVAL_P(offset);
18694 0 : zend_hash_index_del(ht, index);
18695 0 : break;
18696 : case IS_STRING:
18697 : if (IS_CV == IS_CV || IS_CV == IS_VAR) {
18698 0 : offset->refcount++;
18699 : }
18700 0 : if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
18701 : ht == &EG(symbol_table)) {
18702 : zend_execute_data *ex;
18703 0 : ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
18704 :
18705 0 : for (ex = execute_data; ex; ex = ex->prev_execute_data) {
18706 0 : if (ex->op_array && ex->symbol_table == ht) {
18707 : int i;
18708 :
18709 0 : for (i = 0; i < ex->op_array->last_var; i++) {
18710 0 : if (ex->op_array->vars[i].hash_value == hash_value &&
18711 : ex->op_array->vars[i].name_len == offset->value.str.len &&
18712 : !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
18713 0 : ex->CVs[i] = NULL;
18714 0 : break;
18715 : }
18716 : }
18717 : }
18718 : }
18719 : }
18720 : if (IS_CV == IS_CV || IS_CV == IS_VAR) {
18721 0 : zval_ptr_dtor(&offset);
18722 : }
18723 0 : break;
18724 : case IS_NULL:
18725 0 : zend_hash_del(ht, "", sizeof(""));
18726 0 : break;
18727 : default:
18728 0 : zend_error(E_WARNING, "Illegal offset type in unset");
18729 : break;
18730 : }
18731 :
18732 0 : break;
18733 : }
18734 : case IS_OBJECT:
18735 0 : if (!Z_OBJ_HT_P(*container)->unset_dimension) {
18736 0 : zend_error_noreturn(E_ERROR, "Cannot use object as array");
18737 : }
18738 : if (0) {
18739 : MAKE_REAL_ZVAL_PTR(offset);
18740 : }
18741 0 : Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
18742 : if (0) {
18743 : zval_ptr_dtor(&offset);
18744 : } else {
18745 :
18746 : }
18747 0 : break;
18748 : case IS_STRING:
18749 0 : zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
18750 : ZEND_VM_CONTINUE(); /* bailed out before */
18751 : default:
18752 :
18753 : break;
18754 : }
18755 : } else {
18756 :
18757 : }
18758 :
18759 0 : ZEND_VM_NEXT_OPCODE();
18760 : }
18761 :
18762 : static int ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18763 0 : {
18764 0 : zend_op *opline = EX(opline);
18765 :
18766 0 : zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
18767 0 : zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
18768 :
18769 0 : if (container) {
18770 : if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
18771 : SEPARATE_ZVAL_IF_NOT_REF(container);
18772 : }
18773 0 : if (Z_TYPE_PP(container) == IS_OBJECT) {
18774 : if (0) {
18775 : MAKE_REAL_ZVAL_PTR(offset);
18776 : }
18777 0 : Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
18778 : if (0) {
18779 : zval_ptr_dtor(&offset);
18780 : } else {
18781 :
18782 : }
18783 : } else {
18784 :
18785 : }
18786 : } else {
18787 :
18788 : }
18789 :
18790 0 : ZEND_VM_NEXT_OPCODE();
18791 : }
18792 :
18793 : static int zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
18794 0 : {
18795 0 : zend_op *opline = EX(opline);
18796 :
18797 0 : zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
18798 0 : zval **value = NULL;
18799 0 : int result = 0;
18800 : long index;
18801 :
18802 0 : if (container) {
18803 :
18804 0 : zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
18805 :
18806 0 : if (Z_TYPE_PP(container) == IS_ARRAY) {
18807 : HashTable *ht;
18808 0 : int isset = 0;
18809 :
18810 0 : ht = Z_ARRVAL_PP(container);
18811 :
18812 0 : switch (Z_TYPE_P(offset)) {
18813 : case IS_DOUBLE:
18814 0 : index = (long) Z_DVAL_P(offset);
18815 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
18816 0 : isset = 1;
18817 : }
18818 0 : break;
18819 : case IS_RESOURCE:
18820 : case IS_BOOL:
18821 : case IS_LONG:
18822 0 : index = Z_LVAL_P(offset);
18823 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
18824 0 : isset = 1;
18825 : }
18826 0 : break;
18827 : case IS_STRING:
18828 0 : if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
18829 0 : isset = 1;
18830 : }
18831 0 : break;
18832 : case IS_NULL:
18833 0 : if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
18834 0 : isset = 1;
18835 : }
18836 0 : break;
18837 : default:
18838 0 : zend_error(E_WARNING, "Illegal offset type in isset or empty");
18839 :
18840 : break;
18841 : }
18842 :
18843 0 : switch (opline->extended_value) {
18844 : case ZEND_ISSET:
18845 0 : if (isset && Z_TYPE_PP(value) == IS_NULL) {
18846 0 : result = 0;
18847 : } else {
18848 0 : result = isset;
18849 : }
18850 0 : break;
18851 : case ZEND_ISEMPTY:
18852 0 : if (!isset || !i_zend_is_true(*value)) {
18853 0 : result = 0;
18854 : } else {
18855 0 : result = 1;
18856 : }
18857 : break;
18858 : }
18859 :
18860 0 : } else if (Z_TYPE_PP(container) == IS_OBJECT) {
18861 : if (0) {
18862 : MAKE_REAL_ZVAL_PTR(offset);
18863 : }
18864 0 : if (prop_dim) {
18865 0 : result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
18866 : } else {
18867 0 : result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
18868 : }
18869 : if (0) {
18870 : zval_ptr_dtor(&offset);
18871 : } else {
18872 :
18873 : }
18874 0 : } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
18875 : zval tmp;
18876 :
18877 0 : if (Z_TYPE_P(offset) != IS_LONG) {
18878 0 : tmp = *offset;
18879 0 : zval_copy_ctor(&tmp);
18880 0 : convert_to_long(&tmp);
18881 0 : offset = &tmp;
18882 : }
18883 0 : if (Z_TYPE_P(offset) == IS_LONG) {
18884 0 : switch (opline->extended_value) {
18885 : case ZEND_ISSET:
18886 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
18887 0 : result = 1;
18888 : }
18889 0 : break;
18890 : case ZEND_ISEMPTY:
18891 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
18892 0 : result = 1;
18893 : }
18894 : break;
18895 : }
18896 : }
18897 :
18898 : } else {
18899 :
18900 : }
18901 : }
18902 :
18903 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
18904 :
18905 0 : switch (opline->extended_value) {
18906 : case ZEND_ISSET:
18907 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
18908 0 : break;
18909 : case ZEND_ISEMPTY:
18910 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
18911 : break;
18912 : }
18913 :
18914 0 : ZEND_VM_NEXT_OPCODE();
18915 : }
18916 :
18917 : static int ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18918 0 : {
18919 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18920 : }
18921 :
18922 : static int ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18923 0 : {
18924 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18925 : }
18926 :
18927 : static int ZEND_BW_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18928 0 : {
18929 0 : zend_op *opline = EX(opline);
18930 :
18931 :
18932 0 : bitwise_not_function(&EX_T(opline->result.u.var).tmp_var,
18933 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
18934 :
18935 0 : ZEND_VM_NEXT_OPCODE();
18936 : }
18937 :
18938 : static int ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18939 4569 : {
18940 4569 : zend_op *opline = EX(opline);
18941 :
18942 :
18943 4569 : boolean_not_function(&EX_T(opline->result.u.var).tmp_var,
18944 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
18945 :
18946 4569 : ZEND_VM_NEXT_OPCODE();
18947 : }
18948 :
18949 : static int ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18950 5047 : {
18951 5047 : zend_op *opline = EX(opline);
18952 :
18953 5047 : zval **var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
18954 :
18955 5047 : if (!var_ptr) {
18956 0 : zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
18957 : }
18958 5047 : if (*var_ptr == EG(error_zval_ptr)) {
18959 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
18960 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
18961 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
18962 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
18963 : }
18964 :
18965 0 : ZEND_VM_NEXT_OPCODE();
18966 : }
18967 :
18968 5047 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
18969 :
18970 5047 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
18971 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
18972 : /* proxy object */
18973 0 : zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
18974 0 : val->refcount++;
18975 0 : increment_function(val);
18976 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
18977 0 : zval_ptr_dtor(&val);
18978 : } else {
18979 5047 : increment_function(*var_ptr);
18980 : }
18981 :
18982 5047 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
18983 0 : EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
18984 0 : PZVAL_LOCK(*var_ptr);
18985 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
18986 : }
18987 :
18988 5047 : ZEND_VM_NEXT_OPCODE();
18989 : }
18990 :
18991 : static int ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18992 10850 : {
18993 10850 : zend_op *opline = EX(opline);
18994 :
18995 10850 : zval **var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
18996 :
18997 10850 : if (!var_ptr) {
18998 0 : zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
18999 : }
19000 10850 : if (*var_ptr == EG(error_zval_ptr)) {
19001 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
19002 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
19003 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
19004 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
19005 : }
19006 :
19007 0 : ZEND_VM_NEXT_OPCODE();
19008 : }
19009 :
19010 10850 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
19011 :
19012 10850 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
19013 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
19014 : /* proxy object */
19015 0 : zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
19016 0 : val->refcount++;
19017 0 : decrement_function(val);
19018 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
19019 0 : zval_ptr_dtor(&val);
19020 : } else {
19021 10850 : decrement_function(*var_ptr);
19022 : }
19023 :
19024 10850 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
19025 10850 : EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
19026 10850 : PZVAL_LOCK(*var_ptr);
19027 10850 : AI_USE_PTR(EX_T(opline->result.u.var).var);
19028 : }
19029 :
19030 10850 : ZEND_VM_NEXT_OPCODE();
19031 : }
19032 :
19033 : static int ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19034 23771 : {
19035 23771 : zend_op *opline = EX(opline);
19036 :
19037 23771 : zval **var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
19038 :
19039 23771 : if (!var_ptr) {
19040 0 : zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
19041 : }
19042 23771 : if (*var_ptr == EG(error_zval_ptr)) {
19043 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
19044 0 : EX_T(opline->result.u.var).tmp_var = *EG(uninitialized_zval_ptr);
19045 : }
19046 :
19047 0 : ZEND_VM_NEXT_OPCODE();
19048 : }
19049 :
19050 23771 : EX_T(opline->result.u.var).tmp_var = **var_ptr;
19051 23771 : zendi_zval_copy_ctor(EX_T(opline->result.u.var).tmp_var);
19052 :
19053 23771 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
19054 :
19055 23771 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
19056 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
19057 : /* proxy object */
19058 0 : zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
19059 0 : val->refcount++;
19060 0 : increment_function(val);
19061 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
19062 0 : zval_ptr_dtor(&val);
19063 : } else {
19064 23771 : increment_function(*var_ptr);
19065 : }
19066 :
19067 23771 : ZEND_VM_NEXT_OPCODE();
19068 : }
19069 :
19070 : static int ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19071 20164 : {
19072 20164 : zend_op *opline = EX(opline);
19073 :
19074 20164 : zval **var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
19075 :
19076 20164 : if (!var_ptr) {
19077 0 : zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
19078 : }
19079 20164 : if (*var_ptr == EG(error_zval_ptr)) {
19080 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
19081 0 : EX_T(opline->result.u.var).tmp_var = *EG(uninitialized_zval_ptr);
19082 : }
19083 :
19084 0 : ZEND_VM_NEXT_OPCODE();
19085 : }
19086 :
19087 20164 : EX_T(opline->result.u.var).tmp_var = **var_ptr;
19088 20164 : zendi_zval_copy_ctor(EX_T(opline->result.u.var).tmp_var);
19089 :
19090 20164 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
19091 :
19092 20164 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
19093 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
19094 : /* proxy object */
19095 0 : zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
19096 0 : val->refcount++;
19097 0 : decrement_function(val);
19098 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
19099 0 : zval_ptr_dtor(&val);
19100 : } else {
19101 20164 : decrement_function(*var_ptr);
19102 : }
19103 :
19104 20164 : ZEND_VM_NEXT_OPCODE();
19105 : }
19106 :
19107 : static int ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19108 6 : {
19109 6 : zend_op *opline = EX(opline);
19110 :
19111 : zval z_copy;
19112 6 : zval *z = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
19113 :
19114 12 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get_method != NULL &&
19115 : zend_std_cast_object_tostring(z, &z_copy, IS_STRING TSRMLS_CC) == SUCCESS) {
19116 6 : zend_print_variable(&z_copy);
19117 6 : zval_dtor(&z_copy);
19118 : } else {
19119 0 : zend_print_variable(z);
19120 : }
19121 :
19122 6 : ZEND_VM_NEXT_OPCODE();
19123 : }
19124 :
19125 : static int ZEND_PRINT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19126 0 : {
19127 0 : zend_op *opline = EX(opline);
19128 :
19129 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
19130 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_LONG;
19131 :
19132 0 : return ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19133 : }
19134 :
19135 : static int zend_fetch_var_address_helper_SPEC_CV(int type, ZEND_OPCODE_HANDLER_ARGS)
19136 0 : {
19137 0 : zend_op *opline = EX(opline);
19138 : zend_free_op free_op1;
19139 0 : zval *varname = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
19140 : zval **retval;
19141 : zval tmp_varname;
19142 : HashTable *target_symbol_table;
19143 :
19144 0 : if (Z_TYPE_P(varname) != IS_STRING) {
19145 0 : tmp_varname = *varname;
19146 0 : zval_copy_ctor(&tmp_varname);
19147 0 : convert_to_string(&tmp_varname);
19148 0 : varname = &tmp_varname;
19149 : }
19150 :
19151 0 : if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
19152 0 : 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);
19153 : } else {
19154 0 : target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), type, varname TSRMLS_CC);
19155 : /*
19156 : if (!target_symbol_table) {
19157 : ZEND_VM_NEXT_OPCODE();
19158 : }
19159 : */
19160 0 : if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &retval) == FAILURE) {
19161 0 : switch (type) {
19162 : case BP_VAR_R:
19163 : case BP_VAR_UNSET:
19164 0 : zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
19165 : /* break missing intentionally */
19166 : case BP_VAR_IS:
19167 0 : retval = &EG(uninitialized_zval_ptr);
19168 0 : break;
19169 : case BP_VAR_RW:
19170 0 : zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
19171 : /* break missing intentionally */
19172 : case BP_VAR_W: {
19173 0 : zval *new_zval = &EG(uninitialized_zval);
19174 :
19175 0 : new_zval->refcount++;
19176 0 : zend_hash_update(target_symbol_table, varname->value.str.val, varname->value.str.len+1, &new_zval, sizeof(zval *), (void **) &retval);
19177 : }
19178 : break;
19179 : EMPTY_SWITCH_DEFAULT_CASE()
19180 : }
19181 : }
19182 0 : switch (opline->op2.u.EA.type) {
19183 : case ZEND_FETCH_GLOBAL:
19184 : if (IS_CV != IS_TMP_VAR) {
19185 :
19186 : }
19187 0 : break;
19188 : case ZEND_FETCH_LOCAL:
19189 :
19190 0 : break;
19191 : case ZEND_FETCH_STATIC:
19192 0 : zval_update_constant(retval, (void*) 1 TSRMLS_CC);
19193 : break;
19194 : case ZEND_FETCH_GLOBAL_LOCK:
19195 : if (IS_CV == IS_VAR && !free_op1.var) {
19196 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
19197 : }
19198 : break;
19199 : }
19200 : }
19201 :
19202 :
19203 0 : if (varname == &tmp_varname) {
19204 0 : zval_dtor(varname);
19205 : }
19206 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
19207 0 : EX_T(opline->result.u.var).var.ptr_ptr = retval;
19208 0 : PZVAL_LOCK(*retval);
19209 0 : switch (type) {
19210 : case BP_VAR_R:
19211 : case BP_VAR_IS:
19212 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
19213 0 : break;
19214 : case BP_VAR_UNSET: {
19215 : zend_free_op free_res;
19216 :
19217 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
19218 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
19219 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
19220 : }
19221 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
19222 0 : FREE_OP_VAR_PTR(free_res);
19223 : break;
19224 : }
19225 : }
19226 : }
19227 0 : ZEND_VM_NEXT_OPCODE();
19228 : }
19229 :
19230 : static int ZEND_FETCH_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19231 0 : {
19232 0 : return zend_fetch_var_address_helper_SPEC_CV(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19233 : }
19234 :
19235 : static int ZEND_FETCH_W_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19236 0 : {
19237 0 : return zend_fetch_var_address_helper_SPEC_CV(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19238 : }
19239 :
19240 : static int ZEND_FETCH_RW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19241 0 : {
19242 0 : return zend_fetch_var_address_helper_SPEC_CV(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19243 : }
19244 :
19245 : static int ZEND_FETCH_FUNC_ARG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19246 0 : {
19247 0 : 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);
19248 : }
19249 :
19250 : static int ZEND_FETCH_UNSET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19251 0 : {
19252 0 : return zend_fetch_var_address_helper_SPEC_CV(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19253 : }
19254 :
19255 : static int ZEND_FETCH_IS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19256 0 : {
19257 0 : return zend_fetch_var_address_helper_SPEC_CV(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19258 : }
19259 :
19260 : static int ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19261 18015 : {
19262 18015 : zend_op *opline = EX(opline);
19263 :
19264 18015 : int ret = i_zend_is_true(_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC));
19265 :
19266 18015 : if (!ret) {
19267 : #if DEBUG_ZEND>=2
19268 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
19269 : #endif
19270 2968 : ZEND_VM_JMP(opline->op2.u.jmp_addr);
19271 : }
19272 :
19273 15047 : ZEND_VM_NEXT_OPCODE();
19274 : }
19275 :
19276 : static int ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19277 0 : {
19278 0 : zend_op *opline = EX(opline);
19279 :
19280 0 : int ret = i_zend_is_true(_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC));
19281 :
19282 0 : if (ret) {
19283 : #if DEBUG_ZEND>=2
19284 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
19285 : #endif
19286 0 : ZEND_VM_JMP(opline->op2.u.jmp_addr);
19287 : }
19288 :
19289 0 : ZEND_VM_NEXT_OPCODE();
19290 : }
19291 :
19292 : static int ZEND_JMPZNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19293 10 : {
19294 10 : zend_op *opline = EX(opline);
19295 :
19296 10 : int retval = i_zend_is_true(_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC));
19297 :
19298 10 : if (retval) {
19299 : #if DEBUG_ZEND>=2
19300 : printf("Conditional jmp on true to %d\n", opline->extended_value);
19301 : #endif
19302 8 : ZEND_VM_JMP(&EX(op_array)->opcodes[opline->extended_value]);
19303 : } else {
19304 : #if DEBUG_ZEND>=2
19305 : printf("Conditional jmp on false to %d\n", opline->op2.u.opline_num);
19306 : #endif
19307 2 : ZEND_VM_JMP(&EX(op_array)->opcodes[opline->op2.u.opline_num]);
19308 : }
19309 : }
19310 :
19311 : static int ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19312 4695 : {
19313 4695 : zend_op *opline = EX(opline);
19314 :
19315 4695 : int retval = i_zend_is_true(_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC));
19316 :
19317 4695 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
19318 4695 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
19319 4695 : if (!retval) {
19320 : #if DEBUG_ZEND>=2
19321 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
19322 : #endif
19323 2987 : ZEND_VM_JMP(opline->op2.u.jmp_addr);
19324 : }
19325 1708 : ZEND_VM_NEXT_OPCODE();
19326 : }
19327 :
19328 : static int ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19329 13 : {
19330 13 : zend_op *opline = EX(opline);
19331 :
19332 13 : int retval = i_zend_is_true(_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC));
19333 :
19334 13 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
19335 13 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
19336 13 : if (retval) {
19337 : #if DEBUG_ZEND>=2
19338 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
19339 : #endif
19340 0 : ZEND_VM_JMP(opline->op2.u.jmp_addr);
19341 : }
19342 13 : ZEND_VM_NEXT_OPCODE();
19343 : }
19344 :
19345 : static int ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19346 12837 : {
19347 12837 : zend_op *opline = EX(opline);
19348 : zval *retval_ptr;
19349 : zval **retval_ptr_ptr;
19350 :
19351 :
19352 12837 : if (EG(active_op_array)->return_reference == ZEND_RETURN_REF) {
19353 :
19354 : if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
19355 : /* Not supposed to happen, but we'll allow it */
19356 : zend_error(E_NOTICE, "Only variable references should be returned by reference");
19357 : goto return_by_value;
19358 : }
19359 :
19360 0 : retval_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
19361 :
19362 0 : if (!retval_ptr_ptr) {
19363 0 : zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
19364 : }
19365 :
19366 : if (IS_CV == IS_VAR && !(*retval_ptr_ptr)->is_ref) {
19367 : if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
19368 : EX_T(opline->op1.u.var).var.fcall_returned_reference) {
19369 : } else if (EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
19370 : if (IS_CV == IS_VAR && !0) {
19371 : PZVAL_LOCK(*retval_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
19372 : }
19373 : zend_error(E_NOTICE, "Only variable references should be returned by reference");
19374 : goto return_by_value;
19375 : }
19376 : }
19377 :
19378 0 : SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
19379 0 : (*retval_ptr_ptr)->refcount++;
19380 :
19381 0 : (*EG(return_value_ptr_ptr)) = (*retval_ptr_ptr);
19382 : } else {
19383 12837 : return_by_value:
19384 :
19385 12837 : retval_ptr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
19386 :
19387 12837 : if (EG(ze1_compatibility_mode) && Z_TYPE_P(retval_ptr) == IS_OBJECT) {
19388 : zval *ret;
19389 : char *class_name;
19390 : zend_uint class_name_len;
19391 : int dup;
19392 :
19393 0 : ALLOC_ZVAL(ret);
19394 0 : INIT_PZVAL_COPY(ret, retval_ptr);
19395 0 : dup = zend_get_object_classname(retval_ptr, &class_name, &class_name_len TSRMLS_CC);
19396 0 : if (Z_OBJ_HT_P(retval_ptr)->clone_obj == NULL) {
19397 0 : zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", class_name);
19398 : }
19399 0 : zend_error(E_STRICT, "Implicit cloning object of class '%s' because of 'zend.ze1_compatibility_mode'", class_name);
19400 0 : ret->value.obj = Z_OBJ_HT_P(retval_ptr)->clone_obj(retval_ptr TSRMLS_CC);
19401 0 : *EG(return_value_ptr_ptr) = ret;
19402 0 : if (!dup) {
19403 0 : efree(class_name);
19404 : }
19405 : } else if (!0) { /* Not a temp var */
19406 12837 : if (EG(active_op_array)->return_reference == ZEND_RETURN_REF ||
19407 : (PZVAL_IS_REF(retval_ptr) && retval_ptr->refcount > 0)) {
19408 : zval *ret;
19409 :
19410 0 : ALLOC_ZVAL(ret);
19411 0 : INIT_PZVAL_COPY(ret, retval_ptr);
19412 0 : zval_copy_ctor(ret);
19413 0 : *EG(return_value_ptr_ptr) = ret;
19414 : } else {
19415 12837 : *EG(return_value_ptr_ptr) = retval_ptr;
19416 12837 : retval_ptr->refcount++;
19417 : }
19418 : } else {
19419 : zval *ret;
19420 :
19421 : ALLOC_ZVAL(ret);
19422 : INIT_PZVAL_COPY(ret, retval_ptr);
19423 : *EG(return_value_ptr_ptr) = ret;
19424 : }
19425 : }
19426 :
19427 12837 : ZEND_VM_RETURN_FROM_EXECUTE_LOOP();
19428 : }
19429 :
19430 : static int ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19431 0 : {
19432 0 : zend_op *opline = EX(opline);
19433 : zval *value;
19434 : zval *exception;
19435 :
19436 :
19437 0 : value = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
19438 :
19439 0 : if (Z_TYPE_P(value) != IS_OBJECT) {
19440 0 : zend_error_noreturn(E_ERROR, "Can only throw objects");
19441 : }
19442 : /* Not sure if a complete copy is what we want here */
19443 0 : ALLOC_ZVAL(exception);
19444 0 : INIT_PZVAL_COPY(exception, value);
19445 : if (!0) {
19446 0 : zval_copy_ctor(exception);
19447 : }
19448 :
19449 0 : zend_throw_exception_object(exception TSRMLS_CC);
19450 :
19451 0 : ZEND_VM_NEXT_OPCODE();
19452 : }
19453 :
19454 : static int ZEND_SEND_VAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19455 0 : {
19456 0 : zend_op *opline = EX(opline);
19457 0 : if (opline->extended_value==ZEND_DO_FCALL_BY_NAME
19458 : && ARG_MUST_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
19459 0 : zend_error_noreturn(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.u.opline_num);
19460 : }
19461 : {
19462 : zval *valptr;
19463 : zval *value;
19464 :
19465 :
19466 0 : value = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
19467 :
19468 0 : ALLOC_ZVAL(valptr);
19469 0 : INIT_PZVAL_COPY(valptr, value);
19470 : if (!0) {
19471 0 : zval_copy_ctor(valptr);
19472 : }
19473 0 : zend_ptr_stack_push(&EG(argument_stack), valptr);
19474 :
19475 : }
19476 0 : ZEND_VM_NEXT_OPCODE();
19477 : }
19478 :
19479 : static int zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
19480 169964 : {
19481 169964 : zend_op *opline = EX(opline);
19482 : zval *varptr;
19483 :
19484 169964 : varptr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
19485 :
19486 169964 : if (varptr == &EG(uninitialized_zval)) {
19487 0 : ALLOC_ZVAL(varptr);
19488 0 : INIT_ZVAL(*varptr);
19489 0 : varptr->refcount = 0;
19490 169964 : } else if (PZVAL_IS_REF(varptr)) {
19491 575 : zval *original_var = varptr;
19492 :
19493 575 : ALLOC_ZVAL(varptr);
19494 575 : *varptr = *original_var;
19495 575 : varptr->is_ref = 0;
19496 575 : varptr->refcount = 0;
19497 575 : zval_copy_ctor(varptr);
19498 : }
19499 169964 : varptr->refcount++;
19500 169964 : zend_ptr_stack_push(&EG(argument_stack), varptr);
19501 : ; /* for string offsets */
19502 :
19503 169964 : ZEND_VM_NEXT_OPCODE();
19504 : }
19505 :
19506 : static int ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19507 0 : {
19508 0 : zend_op *opline = EX(opline);
19509 : zend_free_op free_op1;
19510 : zval *varptr;
19511 :
19512 0 : if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */
19513 0 : if (!(opline->extended_value & ZEND_ARG_SEND_BY_REF)) {
19514 0 : return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19515 : }
19516 0 : } else if (!ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
19517 0 : return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19518 : }
19519 :
19520 : if (IS_CV == IS_VAR &&
19521 : (opline->extended_value & ZEND_ARG_SEND_FUNCTION) &&
19522 : EX_T(opline->op1.u.var).var.fcall_returned_reference &&
19523 : EX_T(opline->op1.u.var).var.ptr) {
19524 : varptr = EX_T(opline->op1.u.var).var.ptr;
19525 : PZVAL_UNLOCK_EX(varptr, &free_op1, 0);
19526 : } else {
19527 0 : varptr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
19528 : }
19529 0 : if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
19530 : EX_T(opline->op1.u.var).var.fcall_returned_reference) &&
19531 : varptr != &EG(uninitialized_zval) &&
19532 : (PZVAL_IS_REF(varptr) ||
19533 : (varptr->refcount == 1 && (IS_CV == IS_CV || free_op1.var)))) {
19534 0 : varptr->is_ref = 1;
19535 0 : varptr->refcount++;
19536 0 : zend_ptr_stack_push(&EG(argument_stack), varptr);
19537 : } else {
19538 : zval *valptr;
19539 :
19540 0 : zend_error(E_STRICT, "Only variables should be passed by reference");
19541 0 : ALLOC_ZVAL(valptr);
19542 0 : INIT_PZVAL_COPY(valptr, varptr);
19543 : if (!0) {
19544 0 : zval_copy_ctor(valptr);
19545 : }
19546 0 : zend_ptr_stack_push(&EG(argument_stack), valptr);
19547 : }
19548 :
19549 0 : ZEND_VM_NEXT_OPCODE();
19550 : }
19551 :
19552 : static int ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19553 8743 : {
19554 8743 : zend_op *opline = EX(opline);
19555 :
19556 : zval **varptr_ptr;
19557 : zval *varptr;
19558 8743 : varptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
19559 :
19560 8743 : if (!varptr_ptr) {
19561 0 : zend_error_noreturn(E_ERROR, "Only variables can be passed by reference");
19562 : }
19563 :
19564 8743 : SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr);
19565 8743 : varptr = *varptr_ptr;
19566 8743 : varptr->refcount++;
19567 8743 : zend_ptr_stack_push(&EG(argument_stack), varptr);
19568 :
19569 8743 : ZEND_VM_NEXT_OPCODE();
19570 : }
19571 :
19572 : static int ZEND_SEND_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19573 170185 : {
19574 170185 : zend_op *opline = EX(opline);
19575 :
19576 170185 : if ((opline->extended_value == ZEND_DO_FCALL_BY_NAME)
19577 : && ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
19578 221 : return ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19579 : }
19580 169964 : return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19581 : }
19582 :
19583 : static int ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19584 13 : {
19585 13 : zend_op *opline = EX(opline);
19586 :
19587 :
19588 : /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
19589 13 : 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));
19590 13 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
19591 :
19592 13 : ZEND_VM_NEXT_OPCODE();
19593 : }
19594 :
19595 : static int ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19596 1 : {
19597 1 : zend_op *opline = EX(opline);
19598 :
19599 1 : zval *obj = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
19600 : zend_class_entry *ce;
19601 : zend_function *clone;
19602 : zend_object_clone_obj_t clone_call;
19603 :
19604 1 : if (!obj || Z_TYPE_P(obj) != IS_OBJECT) {
19605 0 : zend_error(E_WARNING, "__clone method called on non-object");
19606 0 : EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
19607 0 : EX_T(opline->result.u.var).var.ptr->refcount++;
19608 :
19609 0 : ZEND_VM_NEXT_OPCODE();
19610 : }
19611 :
19612 1 : ce = Z_OBJCE_P(obj);
19613 1 : clone = ce ? ce->clone : NULL;
19614 1 : clone_call = Z_OBJ_HT_P(obj)->clone_obj;
19615 1 : if (!clone_call) {
19616 0 : if (ce) {
19617 0 : zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
19618 : } else {
19619 0 : zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
19620 : }
19621 : EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
19622 : EX_T(opline->result.u.var).var.ptr->refcount++;
19623 : }
19624 :
19625 1 : if (ce && clone) {
19626 0 : if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
19627 : /* Ensure that if we're calling a private function, we're allowed to do so.
19628 : */
19629 0 : if (ce != EG(scope)) {
19630 0 : zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
19631 : }
19632 0 : } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
19633 : /* Ensure that if we're calling a protected function, we're allowed to do so.
19634 : */
19635 0 : if (!zend_check_protected(clone->common.scope, EG(scope))) {
19636 0 : zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
19637 : }
19638 : }
19639 : }
19640 :
19641 1 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
19642 1 : if (!EG(exception)) {
19643 1 : ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
19644 1 : Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC);
19645 1 : Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
19646 1 : EX_T(opline->result.u.var).var.ptr->refcount=1;
19647 1 : EX_T(opline->result.u.var).var.ptr->is_ref=1;
19648 1 : if (!RETURN_VALUE_USED(opline) || EG(exception)) {
19649 0 : zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
19650 : }
19651 : }
19652 :
19653 1 : ZEND_VM_NEXT_OPCODE();
19654 : }
19655 :
19656 : static int ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19657 3 : {
19658 3 : zend_op *opline = EX(opline);
19659 :
19660 3 : zval *expr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
19661 3 : zval *result = &EX_T(opline->result.u.var).tmp_var;
19662 :
19663 3 : *result = *expr;
19664 : if (!0) {
19665 3 : zendi_zval_copy_ctor(*result);
19666 : }
19667 3 : switch (opline->extended_value) {
19668 : case IS_NULL:
19669 0 : convert_to_null(result);
19670 0 : break;
19671 : case IS_BOOL:
19672 0 : convert_to_boolean(result);
19673 0 : break;
19674 : case IS_LONG:
19675 0 : convert_to_long(result);
19676 0 : break;
19677 : case IS_DOUBLE:
19678 0 : convert_to_double(result);
19679 0 : break;
19680 : case IS_STRING: {
19681 : zval var_copy;
19682 : int use_copy;
19683 :
19684 0 : zend_make_printable_zval(result, &var_copy, &use_copy);
19685 0 : if (use_copy) {
19686 0 : zval_dtor(result);
19687 0 : *result = var_copy;
19688 : }
19689 0 : break;
19690 : }
19691 : case IS_ARRAY:
19692 3 : convert_to_array(result);
19693 3 : break;
19694 : case IS_OBJECT:
19695 0 : convert_to_object(result);
19696 : break;
19697 : }
19698 :
19699 3 : ZEND_VM_NEXT_OPCODE();
19700 : }
19701 :
19702 : static int ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19703 0 : {
19704 0 : zend_op *opline = EX(opline);
19705 0 : zend_op_array *new_op_array=NULL;
19706 0 : zval **original_return_value = EG(return_value_ptr_ptr);
19707 : int return_value_used;
19708 :
19709 0 : zval *inc_filename = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
19710 : zval tmp_inc_filename;
19711 0 : zend_bool failure_retval=0;
19712 :
19713 0 : if (inc_filename->type!=IS_STRING) {
19714 0 : tmp_inc_filename = *inc_filename;
19715 0 : zval_copy_ctor(&tmp_inc_filename);
19716 0 : convert_to_string(&tmp_inc_filename);
19717 0 : inc_filename = &tmp_inc_filename;
19718 : }
19719 :
19720 0 : return_value_used = RETURN_VALUE_USED(opline);
19721 :
19722 0 : switch (Z_LVAL(opline->op2.u.constant)) {
19723 : case ZEND_INCLUDE_ONCE:
19724 : case ZEND_REQUIRE_ONCE: {
19725 : zend_file_handle file_handle;
19726 : char cwd[MAXPATHLEN];
19727 : cwd_state state;
19728 :
19729 0 : if (IS_ABSOLUTE_PATH(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename))) {
19730 0 : cwd[0] = '\0';
19731 0 : } else if (!VCWD_GETCWD(cwd, MAXPATHLEN)) {
19732 0 : cwd[0] = '\0';
19733 : }
19734 :
19735 0 : state.cwd_length = strlen(cwd);
19736 0 : state.cwd = zend_strndup(cwd, state.cwd_length);
19737 :
19738 0 : failure_retval = (!virtual_file_ex(&state, Z_STRVAL_P(inc_filename), NULL, 1) &&
19739 : zend_hash_exists(&EG(included_files), state.cwd, state.cwd_length+1));
19740 :
19741 0 : free(state.cwd);
19742 :
19743 0 : if (failure_retval) {
19744 : /* do nothing */
19745 0 : } else if (SUCCESS == zend_stream_open(Z_STRVAL_P(inc_filename), &file_handle TSRMLS_CC)) {
19746 :
19747 0 : if (!file_handle.opened_path) {
19748 0 : file_handle.opened_path = estrndup(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename));
19749 : }
19750 :
19751 0 : if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
19752 0 : new_op_array = zend_compile_file(&file_handle, (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
19753 0 : zend_destroy_file_handle(&file_handle TSRMLS_CC);
19754 : } else {
19755 0 : zend_file_handle_dtor(&file_handle);
19756 0 : failure_retval=1;
19757 : }
19758 : } else {
19759 0 : if (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE) {
19760 0 : zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename));
19761 : } else {
19762 0 : zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename));
19763 : }
19764 : }
19765 : }
19766 0 : break;
19767 : case ZEND_INCLUDE:
19768 : case ZEND_REQUIRE:
19769 0 : new_op_array = compile_filename(Z_LVAL(opline->op2.u.constant), inc_filename TSRMLS_CC);
19770 0 : break;
19771 : case ZEND_EVAL: {
19772 0 : char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
19773 :
19774 0 : new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
19775 0 : efree(eval_desc);
19776 : }
19777 : break;
19778 : EMPTY_SWITCH_DEFAULT_CASE()
19779 : }
19780 0 : if (inc_filename==&tmp_inc_filename) {
19781 0 : zval_dtor(&tmp_inc_filename);
19782 : }
19783 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
19784 0 : if (new_op_array) {
19785 : zval *saved_object;
19786 : zend_function *saved_function;
19787 :
19788 0 : EG(return_value_ptr_ptr) = EX_T(opline->result.u.var).var.ptr_ptr;
19789 0 : EG(active_op_array) = new_op_array;
19790 0 : EX_T(opline->result.u.var).var.ptr = NULL;
19791 :
19792 0 : saved_object = EX(object);
19793 0 : saved_function = EX(function_state).function;
19794 :
19795 0 : EX(function_state).function = (zend_function *) new_op_array;
19796 0 : EX(object) = NULL;
19797 :
19798 0 : zend_execute(new_op_array TSRMLS_CC);
19799 :
19800 0 : EX(function_state).function = saved_function;
19801 0 : EX(object) = saved_object;
19802 :
19803 0 : if (!return_value_used) {
19804 0 : if (EX_T(opline->result.u.var).var.ptr) {
19805 0 : zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
19806 : }
19807 : } else { /* return value is used */
19808 0 : if (!EX_T(opline->result.u.var).var.ptr) { /* there was no return statement */
19809 0 : ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
19810 0 : INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
19811 0 : Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = 1;
19812 0 : Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
19813 : }
19814 : }
19815 :
19816 0 : EG(opline_ptr) = &EX(opline);
19817 0 : EG(active_op_array) = EX(op_array);
19818 0 : EG(function_state_ptr) = &EX(function_state);
19819 0 : destroy_op_array(new_op_array TSRMLS_CC);
19820 0 : efree(new_op_array);
19821 0 : if (EG(exception)) {
19822 0 : zend_throw_exception_internal(NULL TSRMLS_CC);
19823 : }
19824 : } else {
19825 0 : if (return_value_used) {
19826 0 : ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
19827 0 : INIT_ZVAL(*EX_T(opline->result.u.var).var.ptr);
19828 0 : Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = failure_retval;
19829 0 : Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
19830 : }
19831 : }
19832 :
19833 0 : EG(return_value_ptr_ptr) = original_return_value;
19834 0 : ZEND_VM_NEXT_OPCODE();
19835 : }
19836 :
19837 : static int ZEND_UNSET_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19838 0 : {
19839 0 : zend_op *opline = EX(opline);
19840 : zval tmp, *varname;
19841 : HashTable *target_symbol_table;
19842 :
19843 :
19844 0 : varname = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
19845 :
19846 0 : if (Z_TYPE_P(varname) != IS_STRING) {
19847 0 : tmp = *varname;
19848 0 : zval_copy_ctor(&tmp);
19849 0 : convert_to_string(&tmp);
19850 0 : varname = &tmp;
19851 : } else if (IS_CV == IS_CV || IS_CV == IS_VAR) {
19852 0 : varname->refcount++;
19853 : }
19854 :
19855 0 : if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
19856 0 : zend_std_unset_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname) TSRMLS_CC);
19857 : } else {
19858 0 : target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
19859 0 : if (zend_hash_del(target_symbol_table, varname->value.str.val, varname->value.str.len+1) == SUCCESS) {
19860 0 : zend_execute_data *ex = execute_data;
19861 0 : ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
19862 :
19863 : do {
19864 : int i;
19865 :
19866 0 : if (ex->op_array) {
19867 0 : for (i = 0; i < ex->op_array->last_var; i++) {
19868 0 : if (ex->op_array->vars[i].hash_value == hash_value &&
19869 : ex->op_array->vars[i].name_len == varname->value.str.len &&
19870 : !memcmp(ex->op_array->vars[i].name, varname->value.str.val, varname->value.str.len)) {
19871 0 : ex->CVs[i] = NULL;
19872 0 : break;
19873 : }
19874 : }
19875 : }
19876 0 : ex = ex->prev_execute_data;
19877 0 : } while (ex && ex->symbol_table == target_symbol_table);
19878 : }
19879 : }
19880 :
19881 0 : if (varname == &tmp) {
19882 0 : zval_dtor(&tmp);
19883 : } else if (IS_CV == IS_CV || IS_CV == IS_VAR) {
19884 0 : zval_ptr_dtor(&varname);
19885 : }
19886 :
19887 0 : ZEND_VM_NEXT_OPCODE();
19888 : }
19889 :
19890 : static int ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19891 238 : {
19892 238 : zend_op *opline = EX(opline);
19893 : zend_free_op free_op1;
19894 : zval *array_ptr, **array_ptr_ptr;
19895 : HashTable *fe_ht;
19896 238 : zend_object_iterator *iter = NULL;
19897 238 : zend_class_entry *ce = NULL;
19898 238 : zend_bool is_empty = 0;
19899 :
19900 238 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
19901 0 : array_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
19902 0 : if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
19903 0 : ALLOC_INIT_ZVAL(array_ptr);
19904 0 : } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
19905 0 : if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
19906 0 : zend_error(E_WARNING, "foreach() can not iterate over objects without PHP class");
19907 0 : ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
19908 : }
19909 :
19910 0 : ce = Z_OBJCE_PP(array_ptr_ptr);
19911 0 : if (!ce || ce->get_iterator == NULL) {
19912 0 : SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
19913 0 : (*array_ptr_ptr)->refcount++;
19914 : }
19915 0 : array_ptr = *array_ptr_ptr;
19916 : } else {
19917 0 : if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
19918 0 : SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
19919 0 : if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
19920 0 : (*array_ptr_ptr)->is_ref = 1;
19921 : }
19922 : }
19923 0 : array_ptr = *array_ptr_ptr;
19924 0 : array_ptr->refcount++;
19925 : }
19926 : } else {
19927 238 : array_ptr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
19928 : if (0) { /* IS_TMP_VAR */
19929 : zval *tmp;
19930 :
19931 : ALLOC_ZVAL(tmp);
19932 : INIT_PZVAL_COPY(tmp, array_ptr);
19933 : array_ptr = tmp;
19934 238 : } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
19935 4 : ce = Z_OBJCE_P(array_ptr);
19936 4 : if (!ce || !ce->get_iterator) {
19937 0 : array_ptr->refcount++;
19938 : }
19939 : } else {
19940 : if (IS_CV == IS_VAR &&
19941 : free_op1.var == NULL &&
19942 : !array_ptr->is_ref &&
19943 : array_ptr->refcount > 1) {
19944 : /* non-separated return value from function */
19945 : zval *tmp;
19946 :
19947 : ALLOC_ZVAL(tmp);
19948 : INIT_PZVAL_COPY(tmp, array_ptr);
19949 : zval_copy_ctor(tmp);
19950 : array_ptr = tmp;
19951 : } else {
19952 234 : array_ptr->refcount++;
19953 : }
19954 : }
19955 : }
19956 :
19957 238 : if (IS_CV != IS_TMP_VAR && ce && ce->get_iterator) {
19958 4 : iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC);
19959 :
19960 8 : if (iter && !EG(exception)) {
19961 4 : array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
19962 : } else {
19963 0 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
19964 :
19965 : } else {
19966 :
19967 : }
19968 0 : if (!EG(exception)) {
19969 0 : zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
19970 : }
19971 0 : zend_throw_exception_internal(NULL TSRMLS_CC);
19972 0 : ZEND_VM_NEXT_OPCODE();
19973 : }
19974 : }
19975 :
19976 238 : PZVAL_LOCK(array_ptr);
19977 238 : EX_T(opline->result.u.var).var.ptr = array_ptr;
19978 238 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
19979 :
19980 238 : if (iter) {
19981 4 : iter->index = 0;
19982 4 : if (iter->funcs->rewind) {
19983 4 : iter->funcs->rewind(iter TSRMLS_CC);
19984 4 : if (EG(exception)) {
19985 0 : array_ptr->refcount--;
19986 0 : zval_ptr_dtor(&array_ptr);
19987 0 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
19988 :
19989 : } else {
19990 :
19991 : }
19992 0 : ZEND_VM_NEXT_OPCODE();
19993 : }
19994 : }
19995 4 : is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
19996 4 : if (EG(exception)) {
19997 0 : array_ptr->refcount--;
19998 0 : zval_ptr_dtor(&array_ptr);
19999 0 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
20000 :
20001 : } else {
20002 :
20003 : }
20004 0 : ZEND_VM_NEXT_OPCODE();
20005 : }
20006 4 : iter->index = -1; /* will be set to 0 before using next handler */
20007 234 : } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
20008 234 : zend_hash_internal_pointer_reset(fe_ht);
20009 234 : if (ce) {
20010 0 : zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
20011 0 : while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
20012 : char *str_key;
20013 : uint str_key_len;
20014 : ulong int_key;
20015 : zend_uchar key_type;
20016 :
20017 0 : key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
20018 0 : if (key_type != HASH_KEY_NON_EXISTANT &&
20019 : (key_type == HASH_KEY_IS_LONG ||
20020 : zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
20021 : break;
20022 : }
20023 0 : zend_hash_move_forward(fe_ht);
20024 : }
20025 : }
20026 234 : is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
20027 234 : zend_hash_get_pointer(fe_ht, &EX_T(opline->result.u.var).fe.fe_pos);
20028 : } else {
20029 0 : zend_error(E_WARNING, "Invalid argument supplied for foreach()");
20030 0 : is_empty = 1;
20031 : }
20032 :
20033 238 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
20034 :
20035 : } else {
20036 :
20037 : }
20038 238 : if (is_empty) {
20039 1 : ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
20040 : } else {
20041 237 : ZEND_VM_NEXT_OPCODE();
20042 : }
20043 : }
20044 :
20045 : static int ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20046 0 : {
20047 0 : zend_op *opline = EX(opline);
20048 :
20049 0 : zval tmp, *varname = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
20050 : zval **value;
20051 0 : zend_bool isset = 1;
20052 : HashTable *target_symbol_table;
20053 :
20054 0 : if (Z_TYPE_P(varname) != IS_STRING) {
20055 0 : tmp = *varname;
20056 0 : zval_copy_ctor(&tmp);
20057 0 : convert_to_string(&tmp);
20058 0 : varname = &tmp;
20059 : }
20060 :
20061 0 : if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
20062 0 : 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);
20063 0 : if (!value) {
20064 0 : isset = 0;
20065 : }
20066 : } else {
20067 0 : target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
20068 0 : if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
20069 0 : isset = 0;
20070 : }
20071 : }
20072 :
20073 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
20074 :
20075 0 : switch (opline->extended_value) {
20076 : case ZEND_ISSET:
20077 0 : if (isset && Z_TYPE_PP(value) == IS_NULL) {
20078 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
20079 : } else {
20080 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = isset;
20081 : }
20082 0 : break;
20083 : case ZEND_ISEMPTY:
20084 0 : if (!isset || !i_zend_is_true(*value)) {
20085 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
20086 : } else {
20087 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
20088 : }
20089 : break;
20090 : }
20091 :
20092 0 : if (varname == &tmp) {
20093 0 : zval_dtor(&tmp);
20094 : }
20095 :
20096 0 : ZEND_VM_NEXT_OPCODE();
20097 : }
20098 :
20099 : static int ZEND_EXIT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20100 0 : {
20101 : #if 0 || (IS_CV != IS_UNUSED)
20102 0 : zend_op *opline = EX(opline);
20103 : if (IS_CV != IS_UNUSED) {
20104 :
20105 0 : zval *ptr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
20106 :
20107 0 : if (Z_TYPE_P(ptr) == IS_LONG) {
20108 0 : EG(exit_status) = Z_LVAL_P(ptr);
20109 : } else {
20110 0 : zend_print_variable(ptr);
20111 : }
20112 :
20113 : }
20114 : #endif
20115 0 : zend_bailout();
20116 0 : ZEND_VM_NEXT_OPCODE();
20117 : }
20118 :
20119 : static int ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20120 1 : {
20121 1 : zend_op *opline = EX(opline);
20122 :
20123 1 : zval *value = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
20124 :
20125 1 : EX_T(opline->result.u.var).tmp_var = *value;
20126 : if (!0) {
20127 1 : zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
20128 : }
20129 :
20130 1 : ZEND_VM_NEXT_OPCODE();
20131 : }
20132 :
20133 : static int ZEND_INSTANCEOF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20134 0 : {
20135 0 : zend_op *opline = EX(opline);
20136 :
20137 0 : zval *expr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
20138 : zend_bool result;
20139 :
20140 0 : if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) {
20141 0 : result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.u.var).class_entry TSRMLS_CC);
20142 : } else {
20143 0 : result = 0;
20144 : }
20145 0 : ZVAL_BOOL(&EX_T(opline->result.u.var).tmp_var, result);
20146 :
20147 0 : ZEND_VM_NEXT_OPCODE();
20148 : }
20149 :
20150 : static int ZEND_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20151 6061 : {
20152 6061 : zend_op *opline = EX(opline);
20153 :
20154 :
20155 6061 : add_function(&EX_T(opline->result.u.var).tmp_var,
20156 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
20157 : &opline->op2.u.constant TSRMLS_CC);
20158 :
20159 :
20160 6061 : ZEND_VM_NEXT_OPCODE();
20161 : }
20162 :
20163 : static int ZEND_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20164 0 : {
20165 0 : zend_op *opline = EX(opline);
20166 :
20167 :
20168 0 : sub_function(&EX_T(opline->result.u.var).tmp_var,
20169 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
20170 : &opline->op2.u.constant TSRMLS_CC);
20171 :
20172 :
20173 0 : ZEND_VM_NEXT_OPCODE();
20174 : }
20175 :
20176 : static int ZEND_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20177 0 : {
20178 0 : zend_op *opline = EX(opline);
20179 :
20180 :
20181 0 : mul_function(&EX_T(opline->result.u.var).tmp_var,
20182 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
20183 : &opline->op2.u.constant TSRMLS_CC);
20184 :
20185 :
20186 0 : ZEND_VM_NEXT_OPCODE();
20187 : }
20188 :
20189 : static int ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20190 2888 : {
20191 2888 : zend_op *opline = EX(opline);
20192 :
20193 :
20194 2888 : div_function(&EX_T(opline->result.u.var).tmp_var,
20195 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
20196 : &opline->op2.u.constant TSRMLS_CC);
20197 :
20198 :
20199 2888 : ZEND_VM_NEXT_OPCODE();
20200 : }
20201 :
20202 : static int ZEND_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20203 0 : {
20204 0 : zend_op *opline = EX(opline);
20205 :
20206 :
20207 0 : mod_function(&EX_T(opline->result.u.var).tmp_var,
20208 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
20209 : &opline->op2.u.constant TSRMLS_CC);
20210 :
20211 :
20212 0 : ZEND_VM_NEXT_OPCODE();
20213 : }
20214 :
20215 : static int ZEND_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20216 0 : {
20217 0 : zend_op *opline = EX(opline);
20218 :
20219 :
20220 0 : shift_left_function(&EX_T(opline->result.u.var).tmp_var,
20221 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
20222 : &opline->op2.u.constant TSRMLS_CC);
20223 :
20224 :
20225 0 : ZEND_VM_NEXT_OPCODE();
20226 : }
20227 :
20228 : static int ZEND_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20229 0 : {
20230 0 : zend_op *opline = EX(opline);
20231 :
20232 :
20233 0 : shift_right_function(&EX_T(opline->result.u.var).tmp_var,
20234 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
20235 : &opline->op2.u.constant TSRMLS_CC);
20236 :
20237 :
20238 0 : ZEND_VM_NEXT_OPCODE();
20239 : }
20240 :
20241 : static int ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20242 115 : {
20243 115 : zend_op *opline = EX(opline);
20244 :
20245 :
20246 115 : concat_function(&EX_T(opline->result.u.var).tmp_var,
20247 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
20248 : &opline->op2.u.constant TSRMLS_CC);
20249 :
20250 :
20251 115 : ZEND_VM_NEXT_OPCODE();
20252 : }
20253 :
20254 : static int ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20255 1868 : {
20256 1868 : zend_op *opline = EX(opline);
20257 :
20258 :
20259 1868 : is_identical_function(&EX_T(opline->result.u.var).tmp_var,
20260 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
20261 : &opline->op2.u.constant TSRMLS_CC);
20262 :
20263 :
20264 1868 : ZEND_VM_NEXT_OPCODE();
20265 : }
20266 :
20267 : static int ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20268 88 : {
20269 88 : zend_op *opline = EX(opline);
20270 :
20271 :
20272 88 : is_not_identical_function(&EX_T(opline->result.u.var).tmp_var,
20273 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
20274 : &opline->op2.u.constant TSRMLS_CC);
20275 :
20276 :
20277 88 : ZEND_VM_NEXT_OPCODE();
20278 : }
20279 :
20280 : static int ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20281 2871 : {
20282 2871 : zend_op *opline = EX(opline);
20283 :
20284 :
20285 2871 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
20286 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
20287 : &opline->op2.u.constant TSRMLS_CC);
20288 :
20289 :
20290 2871 : ZEND_VM_NEXT_OPCODE();
20291 : }
20292 :
20293 : static int ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20294 112 : {
20295 112 : zend_op *opline = EX(opline);
20296 :
20297 :
20298 112 : is_not_equal_function(&EX_T(opline->result.u.var).tmp_var,
20299 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
20300 : &opline->op2.u.constant TSRMLS_CC);
20301 :
20302 :
20303 112 : ZEND_VM_NEXT_OPCODE();
20304 : }
20305 :
20306 : static int ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20307 5013 : {
20308 5013 : zend_op *opline = EX(opline);
20309 :
20310 :
20311 5013 : is_smaller_function(&EX_T(opline->result.u.var).tmp_var,
20312 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
20313 : &opline->op2.u.constant TSRMLS_CC);
20314 :
20315 :
20316 5013 : ZEND_VM_NEXT_OPCODE();
20317 : }
20318 :
20319 : static int ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20320 0 : {
20321 0 : zend_op *opline = EX(opline);
20322 :
20323 :
20324 0 : is_smaller_or_equal_function(&EX_T(opline->result.u.var).tmp_var,
20325 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
20326 : &opline->op2.u.constant TSRMLS_CC);
20327 :
20328 :
20329 0 : ZEND_VM_NEXT_OPCODE();
20330 : }
20331 :
20332 : static int ZEND_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20333 0 : {
20334 0 : zend_op *opline = EX(opline);
20335 :
20336 :
20337 0 : bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
20338 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
20339 : &opline->op2.u.constant TSRMLS_CC);
20340 :
20341 :
20342 0 : ZEND_VM_NEXT_OPCODE();
20343 : }
20344 :
20345 : static int ZEND_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20346 0 : {
20347 0 : zend_op *opline = EX(opline);
20348 :
20349 :
20350 0 : bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
20351 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
20352 : &opline->op2.u.constant TSRMLS_CC);
20353 :
20354 :
20355 0 : ZEND_VM_NEXT_OPCODE();
20356 : }
20357 :
20358 : static int ZEND_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20359 0 : {
20360 0 : zend_op *opline = EX(opline);
20361 :
20362 :
20363 0 : bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
20364 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
20365 : &opline->op2.u.constant TSRMLS_CC);
20366 :
20367 :
20368 0 : ZEND_VM_NEXT_OPCODE();
20369 : }
20370 :
20371 : static int ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20372 0 : {
20373 0 : zend_op *opline = EX(opline);
20374 :
20375 :
20376 0 : boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
20377 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
20378 : &opline->op2.u.constant TSRMLS_CC);
20379 :
20380 :
20381 0 : ZEND_VM_NEXT_OPCODE();
20382 : }
20383 :
20384 : static int zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
20385 0 : {
20386 0 : zend_op *opline = EX(opline);
20387 0 : zend_op *op_data = opline+1;
20388 : zend_free_op free_op_data1;
20389 0 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
20390 : zval *object;
20391 0 : zval *property = &opline->op2.u.constant;
20392 0 : zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
20393 0 : znode *result = &opline->result;
20394 0 : zval **retval = &EX_T(result->u.var).var.ptr;
20395 0 : int have_get_ptr = 0;
20396 :
20397 0 : EX_T(result->u.var).var.ptr_ptr = NULL;
20398 0 : make_real_object(object_ptr TSRMLS_CC);
20399 0 : object = *object_ptr;
20400 :
20401 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
20402 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
20403 :
20404 0 : FREE_OP(free_op_data1);
20405 :
20406 0 : if (!RETURN_VALUE_UNUSED(result)) {
20407 0 : *retval = EG(uninitialized_zval_ptr);
20408 0 : PZVAL_LOCK(*retval);
20409 : }
20410 : } else {
20411 : /* here we are sure we are dealing with an object */
20412 : if (0) {
20413 : MAKE_REAL_ZVAL_PTR(property);
20414 : }
20415 :
20416 : /* here property is a string */
20417 0 : if (opline->extended_value == ZEND_ASSIGN_OBJ
20418 : && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
20419 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
20420 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
20421 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
20422 :
20423 0 : have_get_ptr = 1;
20424 0 : binary_op(*zptr, *zptr, value TSRMLS_CC);
20425 0 : if (!RETURN_VALUE_UNUSED(result)) {
20426 0 : *retval = *zptr;
20427 0 : PZVAL_LOCK(*retval);
20428 : }
20429 : }
20430 : }
20431 :
20432 0 : if (!have_get_ptr) {
20433 0 : zval *z = NULL;
20434 :
20435 0 : switch (opline->extended_value) {
20436 : case ZEND_ASSIGN_OBJ:
20437 0 : if (Z_OBJ_HT_P(object)->read_property) {
20438 0 : z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
20439 : }
20440 0 : break;
20441 : case ZEND_ASSIGN_DIM:
20442 0 : if (Z_OBJ_HT_P(object)->read_dimension) {
20443 0 : z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
20444 : }
20445 : break;
20446 : }
20447 0 : if (z) {
20448 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
20449 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
20450 :
20451 0 : if (z->refcount == 0) {
20452 0 : zval_dtor(z);
20453 0 : FREE_ZVAL(z);
20454 : }
20455 0 : z = value;
20456 : }
20457 0 : z->refcount++;
20458 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
20459 0 : binary_op(z, z, value TSRMLS_CC);
20460 0 : switch (opline->extended_value) {
20461 : case ZEND_ASSIGN_OBJ:
20462 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
20463 0 : break;
20464 : case ZEND_ASSIGN_DIM:
20465 0 : Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
20466 : break;
20467 : }
20468 0 : if (!RETURN_VALUE_UNUSED(result)) {
20469 0 : *retval = z;
20470 0 : PZVAL_LOCK(*retval);
20471 : }
20472 0 : zval_ptr_dtor(&z);
20473 : } else {
20474 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
20475 0 : if (!RETURN_VALUE_UNUSED(result)) {
20476 0 : *retval = EG(uninitialized_zval_ptr);
20477 0 : PZVAL_LOCK(*retval);
20478 : }
20479 : }
20480 : }
20481 :
20482 : if (0) {
20483 : zval_ptr_dtor(&property);
20484 : } else {
20485 :
20486 : }
20487 0 : FREE_OP(free_op_data1);
20488 : }
20489 :
20490 : /* assign_obj has two opcodes! */
20491 0 : ZEND_VM_INC_OPCODE();
20492 0 : ZEND_VM_NEXT_OPCODE();
20493 : }
20494 :
20495 : static int zend_binary_assign_op_helper_SPEC_CV_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
20496 3 : {
20497 3 : zend_op *opline = EX(opline);
20498 : zend_free_op free_op_data2, free_op_data1;
20499 : zval **var_ptr;
20500 : zval *value;
20501 3 : zend_bool increment_opline = 0;
20502 :
20503 3 : switch (opline->extended_value) {
20504 : case ZEND_ASSIGN_OBJ:
20505 0 : return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20506 : break;
20507 : case ZEND_ASSIGN_DIM: {
20508 1 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
20509 :
20510 : if (object_ptr && IS_CV != IS_CV && !0) {
20511 : (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
20512 : }
20513 :
20514 1 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
20515 0 : return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20516 : } else {
20517 1 : zend_op *op_data = opline+1;
20518 1 : zval *dim = &opline->op2.u.constant;
20519 :
20520 1 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
20521 1 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
20522 1 : var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
20523 1 : increment_opline = 1;
20524 : }
20525 : }
20526 1 : break;
20527 : default:
20528 2 : value = &opline->op2.u.constant;
20529 2 : var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
20530 : /* do nothing */
20531 : break;
20532 : }
20533 :
20534 3 : if (!var_ptr) {
20535 0 : zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
20536 : }
20537 :
20538 3 : if (*var_ptr == EG(error_zval_ptr)) {
20539 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
20540 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
20541 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
20542 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
20543 : }
20544 :
20545 :
20546 0 : if (increment_opline) {
20547 0 : ZEND_VM_INC_OPCODE();
20548 : }
20549 0 : ZEND_VM_NEXT_OPCODE();
20550 : }
20551 :
20552 3 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
20553 :
20554 3 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
20555 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
20556 : /* proxy object */
20557 0 : zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
20558 0 : objval->refcount++;
20559 0 : binary_op(objval, objval, value TSRMLS_CC);
20560 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
20561 0 : zval_ptr_dtor(&objval);
20562 : } else {
20563 3 : binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
20564 : }
20565 :
20566 3 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
20567 0 : EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
20568 0 : PZVAL_LOCK(*var_ptr);
20569 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
20570 : }
20571 :
20572 3 : if (increment_opline) {
20573 1 : ZEND_VM_INC_OPCODE();
20574 1 : FREE_OP(free_op_data1);
20575 1 : FREE_OP_VAR_PTR(free_op_data2);
20576 : }
20577 :
20578 3 : ZEND_VM_NEXT_OPCODE();
20579 : }
20580 :
20581 : static int ZEND_ASSIGN_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20582 1 : {
20583 1 : return zend_binary_assign_op_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20584 : }
20585 :
20586 : static int ZEND_ASSIGN_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20587 0 : {
20588 0 : return zend_binary_assign_op_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20589 : }
20590 :
20591 : static int ZEND_ASSIGN_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20592 0 : {
20593 0 : return zend_binary_assign_op_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20594 : }
20595 :
20596 : static int ZEND_ASSIGN_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20597 0 : {
20598 0 : return zend_binary_assign_op_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20599 : }
20600 :
20601 : static int ZEND_ASSIGN_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20602 0 : {
20603 0 : return zend_binary_assign_op_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20604 : }
20605 :
20606 : static int ZEND_ASSIGN_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20607 0 : {
20608 0 : return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20609 : }
20610 :
20611 : static int ZEND_ASSIGN_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20612 0 : {
20613 0 : return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20614 : }
20615 :
20616 : static int ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20617 2 : {
20618 2 : return zend_binary_assign_op_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20619 : }
20620 :
20621 : static int ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20622 0 : {
20623 0 : return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20624 : }
20625 :
20626 : static int ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20627 0 : {
20628 0 : return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20629 : }
20630 :
20631 : static int ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20632 0 : {
20633 0 : return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20634 : }
20635 :
20636 : static int zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
20637 0 : {
20638 0 : zend_op *opline = EX(opline);
20639 :
20640 0 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
20641 : zval *object;
20642 0 : zval *property = &opline->op2.u.constant;
20643 0 : zval **retval = &EX_T(opline->result.u.var).var.ptr;
20644 0 : int have_get_ptr = 0;
20645 :
20646 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
20647 0 : object = *object_ptr;
20648 :
20649 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
20650 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
20651 :
20652 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
20653 0 : *retval = EG(uninitialized_zval_ptr);
20654 0 : PZVAL_LOCK(*retval);
20655 : }
20656 :
20657 0 : ZEND_VM_NEXT_OPCODE();
20658 : }
20659 :
20660 : /* here we are sure we are dealing with an object */
20661 :
20662 : if (0) {
20663 : MAKE_REAL_ZVAL_PTR(property);
20664 : }
20665 :
20666 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
20667 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
20668 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
20669 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
20670 :
20671 0 : have_get_ptr = 1;
20672 0 : incdec_op(*zptr);
20673 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
20674 0 : *retval = *zptr;
20675 0 : PZVAL_LOCK(*retval);
20676 : }
20677 : }
20678 : }
20679 :
20680 0 : if (!have_get_ptr) {
20681 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
20682 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
20683 :
20684 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
20685 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
20686 :
20687 0 : if (z->refcount == 0) {
20688 0 : zval_dtor(z);
20689 0 : FREE_ZVAL(z);
20690 : }
20691 0 : z = value;
20692 : }
20693 0 : z->refcount++;
20694 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
20695 0 : incdec_op(z);
20696 0 : *retval = z;
20697 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
20698 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
20699 0 : zval_ptr_dtor(&z);
20700 : } else {
20701 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
20702 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
20703 0 : *retval = EG(uninitialized_zval_ptr);
20704 0 : PZVAL_LOCK(*retval);
20705 : }
20706 : }
20707 : }
20708 :
20709 : if (0) {
20710 : zval_ptr_dtor(&property);
20711 : } else {
20712 :
20713 : }
20714 :
20715 0 : ZEND_VM_NEXT_OPCODE();
20716 : }
20717 :
20718 : static int ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20719 0 : {
20720 0 : return zend_pre_incdec_property_helper_SPEC_CV_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20721 : }
20722 :
20723 : static int ZEND_PRE_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20724 0 : {
20725 0 : return zend_pre_incdec_property_helper_SPEC_CV_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20726 : }
20727 :
20728 : static int zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
20729 0 : {
20730 0 : zend_op *opline = EX(opline);
20731 :
20732 0 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
20733 : zval *object;
20734 0 : zval *property = &opline->op2.u.constant;
20735 0 : zval *retval = &EX_T(opline->result.u.var).tmp_var;
20736 0 : int have_get_ptr = 0;
20737 :
20738 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
20739 0 : object = *object_ptr;
20740 :
20741 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
20742 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
20743 :
20744 0 : *retval = *EG(uninitialized_zval_ptr);
20745 :
20746 0 : ZEND_VM_NEXT_OPCODE();
20747 : }
20748 :
20749 : /* here we are sure we are dealing with an object */
20750 :
20751 : if (0) {
20752 : MAKE_REAL_ZVAL_PTR(property);
20753 : }
20754 :
20755 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
20756 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
20757 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
20758 0 : have_get_ptr = 1;
20759 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
20760 :
20761 0 : *retval = **zptr;
20762 0 : zendi_zval_copy_ctor(*retval);
20763 :
20764 0 : incdec_op(*zptr);
20765 :
20766 : }
20767 : }
20768 :
20769 0 : if (!have_get_ptr) {
20770 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
20771 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
20772 : zval *z_copy;
20773 :
20774 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
20775 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
20776 :
20777 0 : if (z->refcount == 0) {
20778 0 : zval_dtor(z);
20779 0 : FREE_ZVAL(z);
20780 : }
20781 0 : z = value;
20782 : }
20783 0 : *retval = *z;
20784 0 : zendi_zval_copy_ctor(*retval);
20785 0 : ALLOC_ZVAL(z_copy);
20786 0 : *z_copy = *z;
20787 0 : zendi_zval_copy_ctor(*z_copy);
20788 0 : INIT_PZVAL(z_copy);
20789 0 : incdec_op(z_copy);
20790 0 : z->refcount++;
20791 0 : Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
20792 0 : zval_ptr_dtor(&z_copy);
20793 0 : zval_ptr_dtor(&z);
20794 : } else {
20795 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
20796 0 : *retval = *EG(uninitialized_zval_ptr);
20797 : }
20798 : }
20799 :
20800 : if (0) {
20801 : zval_ptr_dtor(&property);
20802 : } else {
20803 :
20804 : }
20805 :
20806 0 : ZEND_VM_NEXT_OPCODE();
20807 : }
20808 :
20809 : static int ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20810 0 : {
20811 0 : return zend_post_incdec_property_helper_SPEC_CV_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20812 : }
20813 :
20814 : static int ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20815 0 : {
20816 0 : return zend_post_incdec_property_helper_SPEC_CV_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20817 : }
20818 :
20819 : static int ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20820 8532 : {
20821 8532 : zend_op *opline = EX(opline);
20822 :
20823 8532 : zval *dim = &opline->op2.u.constant;
20824 :
20825 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK &&
20826 : IS_CV != IS_CV &&
20827 : EX_T(opline->op1.u.var).var.ptr_ptr) {
20828 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
20829 : }
20830 8532 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC), dim, 0, BP_VAR_R TSRMLS_CC);
20831 :
20832 :
20833 8532 : ZEND_VM_NEXT_OPCODE();
20834 : }
20835 :
20836 : static int ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20837 0 : {
20838 0 : zend_op *opline = EX(opline);
20839 : zend_free_op free_op1;
20840 0 : zval *dim = &opline->op2.u.constant;
20841 :
20842 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC), dim, 0, BP_VAR_W TSRMLS_CC);
20843 :
20844 : if (IS_CV == IS_VAR && 0 &&
20845 : READY_TO_DESTROY(free_op1.var) &&
20846 : !RETURN_VALUE_UNUSED(&opline->result)) {
20847 : AI_USE_PTR(EX_T(opline->result.u.var).var);
20848 : }
20849 :
20850 0 : ZEND_VM_NEXT_OPCODE();
20851 : }
20852 :
20853 : static int ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20854 0 : {
20855 0 : zend_op *opline = EX(opline);
20856 : zend_free_op free_op1;
20857 0 : zval *dim = &opline->op2.u.constant;
20858 :
20859 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
20860 :
20861 : if (IS_CV == IS_VAR && 0 &&
20862 : READY_TO_DESTROY(free_op1.var) &&
20863 : !RETURN_VALUE_UNUSED(&opline->result)) {
20864 : AI_USE_PTR(EX_T(opline->result.u.var).var);
20865 : }
20866 :
20867 0 : ZEND_VM_NEXT_OPCODE();
20868 : }
20869 :
20870 : static int ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20871 0 : {
20872 0 : zend_op *opline = EX(opline);
20873 :
20874 0 : zval *dim = &opline->op2.u.constant;
20875 :
20876 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC), dim, 0, BP_VAR_IS TSRMLS_CC);
20877 :
20878 :
20879 0 : ZEND_VM_NEXT_OPCODE();
20880 : }
20881 :
20882 : static int ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20883 2 : {
20884 2 : zend_op *opline = EX(opline);
20885 : zend_free_op free_op1;
20886 2 : int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
20887 : zval *dim;
20888 :
20889 : if (IS_CONST == IS_UNUSED && type == BP_VAR_R) {
20890 : zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
20891 : }
20892 2 : dim = &opline->op2.u.constant;
20893 2 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), type TSRMLS_CC), dim, 0, type TSRMLS_CC);
20894 :
20895 : if (IS_CV == IS_VAR && type == BP_VAR_W && 0 &&
20896 : READY_TO_DESTROY(free_op1.var) &&
20897 : !RETURN_VALUE_UNUSED(&opline->result)) {
20898 : AI_USE_PTR(EX_T(opline->result.u.var).var);
20899 : }
20900 :
20901 2 : ZEND_VM_NEXT_OPCODE();
20902 : }
20903 :
20904 : static int ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20905 0 : {
20906 0 : zend_op *opline = EX(opline);
20907 : zend_free_op free_op1;
20908 0 : zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
20909 0 : zval *dim = &opline->op2.u.constant;
20910 :
20911 : /* Not needed in DIM_UNSET
20912 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
20913 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
20914 : }
20915 : */
20916 : if (IS_CV == IS_CV) {
20917 0 : if (container != &EG(uninitialized_zval_ptr)) {
20918 0 : SEPARATE_ZVAL_IF_NOT_REF(container);
20919 : }
20920 : }
20921 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_UNSET TSRMLS_CC);
20922 :
20923 : if (IS_CV == IS_VAR && 0 &&
20924 : READY_TO_DESTROY(free_op1.var) &&
20925 : !RETURN_VALUE_UNUSED(&opline->result)) {
20926 : AI_USE_PTR(EX_T(opline->result.u.var).var);
20927 : }
20928 :
20929 0 : if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
20930 0 : zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
20931 : } else {
20932 : zend_free_op free_res;
20933 :
20934 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
20935 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
20936 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
20937 : }
20938 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
20939 0 : FREE_OP_VAR_PTR(free_res);
20940 : }
20941 0 : ZEND_VM_NEXT_OPCODE();
20942 : }
20943 :
20944 : static int zend_fetch_property_address_read_helper_SPEC_CV_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
20945 1 : {
20946 1 : zend_op *opline = EX(opline);
20947 : zval *container;
20948 : zval **retval;
20949 :
20950 :
20951 1 : retval = &EX_T(opline->result.u.var).var.ptr;
20952 1 : EX_T(opline->result.u.var).var.ptr_ptr = retval;
20953 :
20954 1 : container = _get_zval_ptr_cv(&opline->op1, EX(Ts), type TSRMLS_CC);
20955 :
20956 1 : if (container == EG(error_zval_ptr)) {
20957 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
20958 0 : *retval = EG(error_zval_ptr);
20959 0 : PZVAL_LOCK(*retval);
20960 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
20961 : }
20962 :
20963 0 : ZEND_VM_NEXT_OPCODE();
20964 : }
20965 :
20966 :
20967 1 : if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
20968 0 : if (type != BP_VAR_IS) {
20969 0 : zend_error(E_NOTICE, "Trying to get property of non-object");
20970 : }
20971 0 : *retval = EG(uninitialized_zval_ptr);
20972 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
20973 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
20974 : } else {
20975 :
20976 1 : zval *offset = &opline->op2.u.constant;
20977 :
20978 : if (0) {
20979 : MAKE_REAL_ZVAL_PTR(offset);
20980 : }
20981 :
20982 : /* here we are sure we are dealing with an object */
20983 1 : *retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
20984 :
20985 1 : if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
20986 0 : zval_dtor(*retval);
20987 0 : FREE_ZVAL(*retval);
20988 : } else {
20989 1 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
20990 1 : AI_USE_PTR(EX_T(opline->result.u.var).var);
20991 : }
20992 :
20993 : if (0) {
20994 : zval_ptr_dtor(&offset);
20995 : } else {
20996 :
20997 : }
20998 : }
20999 :
21000 1 : ZEND_VM_NEXT_OPCODE();
21001 : }
21002 :
21003 : static int ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21004 1 : {
21005 1 : return zend_fetch_property_address_read_helper_SPEC_CV_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21006 : }
21007 :
21008 : static int ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21009 2 : {
21010 2 : zend_op *opline = EX(opline);
21011 : zend_free_op free_op1;
21012 2 : zval *property = &opline->op2.u.constant;
21013 :
21014 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_CV != IS_CV) {
21015 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
21016 : EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
21017 : }
21018 :
21019 : if (0) {
21020 : MAKE_REAL_ZVAL_PTR(property);
21021 : }
21022 2 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
21023 : if (0) {
21024 : zval_ptr_dtor(&property);
21025 : } else {
21026 :
21027 : }
21028 : if (IS_CV == IS_VAR && 0 &&
21029 : READY_TO_DESTROY(free_op1.var) &&
21030 : !RETURN_VALUE_UNUSED(&opline->result)) {
21031 : AI_USE_PTR(EX_T(opline->result.u.var).var);
21032 : }
21033 :
21034 2 : ZEND_VM_NEXT_OPCODE();
21035 : }
21036 :
21037 : static int ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21038 0 : {
21039 0 : zend_op *opline = EX(opline);
21040 : zend_free_op free_op1;
21041 0 : zval *property = &opline->op2.u.constant;
21042 :
21043 : if (0) {
21044 : MAKE_REAL_ZVAL_PTR(property);
21045 : }
21046 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC), property, BP_VAR_RW TSRMLS_CC);
21047 : if (0) {
21048 : zval_ptr_dtor(&property);
21049 : } else {
21050 :
21051 : }
21052 : if (IS_CV == IS_VAR && 0 &&
21053 : READY_TO_DESTROY(free_op1.var) &&
21054 : !RETURN_VALUE_UNUSED(&opline->result)) {
21055 : AI_USE_PTR(EX_T(opline->result.u.var).var);
21056 : }
21057 :
21058 0 : ZEND_VM_NEXT_OPCODE();
21059 : }
21060 :
21061 : static int ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21062 0 : {
21063 0 : return zend_fetch_property_address_read_helper_SPEC_CV_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21064 : }
21065 :
21066 : static int ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21067 0 : {
21068 0 : zend_op *opline = EX(opline);
21069 :
21070 0 : if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
21071 : /* Behave like FETCH_OBJ_W */
21072 : zend_free_op free_op1;
21073 0 : zval *property = &opline->op2.u.constant;
21074 :
21075 : if (0) {
21076 : MAKE_REAL_ZVAL_PTR(property);
21077 : }
21078 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
21079 : if (0) {
21080 : zval_ptr_dtor(&property);
21081 : } else {
21082 :
21083 : }
21084 : if (IS_CV == IS_VAR && 0 &&
21085 : READY_TO_DESTROY(free_op1.var) &&
21086 : !RETURN_VALUE_UNUSED(&opline->result)) {
21087 : AI_USE_PTR(EX_T(opline->result.u.var).var);
21088 : }
21089 :
21090 0 : ZEND_VM_NEXT_OPCODE();
21091 : } else {
21092 0 : return zend_fetch_property_address_read_helper_SPEC_CV_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21093 : }
21094 : }
21095 :
21096 : static int ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21097 0 : {
21098 0 : zend_op *opline = EX(opline);
21099 : zend_free_op free_op1, free_res;
21100 0 : zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
21101 0 : zval *property = &opline->op2.u.constant;
21102 :
21103 : if (IS_CV == IS_CV) {
21104 0 : if (container != &EG(uninitialized_zval_ptr)) {
21105 0 : SEPARATE_ZVAL_IF_NOT_REF(container);
21106 : }
21107 : }
21108 : if (0) {
21109 : MAKE_REAL_ZVAL_PTR(property);
21110 : }
21111 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
21112 : if (0) {
21113 : zval_ptr_dtor(&property);
21114 : } else {
21115 :
21116 : }
21117 : if (IS_CV == IS_VAR && 0 &&
21118 : READY_TO_DESTROY(free_op1.var) &&
21119 : !RETURN_VALUE_UNUSED(&opline->result)) {
21120 : AI_USE_PTR(EX_T(opline->result.u.var).var);
21121 : }
21122 :
21123 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
21124 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
21125 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
21126 : }
21127 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
21128 0 : FREE_OP_VAR_PTR(free_res);
21129 0 : ZEND_VM_NEXT_OPCODE();
21130 : }
21131 :
21132 : static int ZEND_ASSIGN_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21133 5 : {
21134 5 : zend_op *opline = EX(opline);
21135 5 : zend_op *op_data = opline+1;
21136 :
21137 5 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
21138 :
21139 5 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
21140 :
21141 : /* assign_obj has two opcodes! */
21142 5 : ZEND_VM_INC_OPCODE();
21143 5 : ZEND_VM_NEXT_OPCODE();
21144 : }
21145 :
21146 : static int ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21147 1740 : {
21148 1740 : zend_op *opline = EX(opline);
21149 1740 : zend_op *op_data = opline+1;
21150 :
21151 : zval **object_ptr;
21152 :
21153 : if (IS_CV == IS_CV || EX_T(opline->op1.u.var).var.ptr_ptr) {
21154 : /* not an array offset */
21155 1740 : object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
21156 : } else {
21157 : object_ptr = NULL;
21158 : }
21159 :
21160 1740 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
21161 0 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
21162 : } else {
21163 : zend_free_op free_op_data1;
21164 : zval *value;
21165 1740 : zval *dim = &opline->op2.u.constant;
21166 :
21167 1740 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
21168 :
21169 1740 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
21170 1740 : zend_assign_to_variable(&opline->result, &op_data->op2, &op_data->op1, value, (IS_TMP_FREE(free_op_data1)?IS_TMP_VAR:op_data->op1.op_type), EX(Ts) TSRMLS_CC);
21171 1740 : FREE_OP_IF_VAR(free_op_data1);
21172 : }
21173 :
21174 : /* assign_dim has two opcodes! */
21175 1740 : ZEND_VM_INC_OPCODE();
21176 1740 : ZEND_VM_NEXT_OPCODE();
21177 : }
21178 :
21179 : static int ZEND_ASSIGN_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21180 22418 : {
21181 22418 : zend_op *opline = EX(opline);
21182 :
21183 22418 : zval *value = &opline->op2.u.constant;
21184 :
21185 22418 : zend_assign_to_variable(&opline->result, &opline->op1, &opline->op2, value, (0?IS_TMP_VAR:IS_CONST), EX(Ts) TSRMLS_CC);
21186 : /* zend_assign_to_variable() always takes care of op2, never free it! */
21187 :
21188 22418 : ZEND_VM_NEXT_OPCODE();
21189 : }
21190 :
21191 : static int ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21192 552 : {
21193 552 : zend_op *opline = EX(opline);
21194 : zval *function_name;
21195 : char *function_name_strval;
21196 : int function_name_strlen;
21197 :
21198 :
21199 552 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
21200 :
21201 552 : function_name = &opline->op2.u.constant;
21202 :
21203 552 : if (Z_TYPE_P(function_name)!=IS_STRING) {
21204 0 : zend_error_noreturn(E_ERROR, "Method name must be a string");
21205 : }
21206 :
21207 552 : function_name_strval = Z_STRVAL_P(function_name);
21208 552 : function_name_strlen = Z_STRLEN_P(function_name);
21209 :
21210 552 : EX(object) = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
21211 :
21212 552 : if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
21213 552 : if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
21214 0 : zend_error_noreturn(E_ERROR, "Object does not support method calls");
21215 : }
21216 :
21217 : /* First, locate the function. */
21218 552 : EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
21219 552 : if (!EX(fbc)) {
21220 0 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
21221 : }
21222 : } else {
21223 0 : zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
21224 : }
21225 :
21226 552 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
21227 0 : EX(object) = NULL;
21228 : } else {
21229 552 : if (!PZVAL_IS_REF(EX(object))) {
21230 552 : EX(object)->refcount++; /* For $this pointer */
21231 : } else {
21232 : zval *this_ptr;
21233 0 : ALLOC_ZVAL(this_ptr);
21234 0 : INIT_PZVAL_COPY(this_ptr, EX(object));
21235 0 : zval_copy_ctor(this_ptr);
21236 0 : EX(object) = this_ptr;
21237 : }
21238 : }
21239 :
21240 :
21241 552 : ZEND_VM_NEXT_OPCODE();
21242 : }
21243 :
21244 : static int ZEND_CASE_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21245 0 : {
21246 0 : zend_op *opline = EX(opline);
21247 0 : int switch_expr_is_overloaded=0;
21248 :
21249 :
21250 : if (IS_CV==IS_VAR) {
21251 : if (EX_T(opline->op1.u.var).var.ptr_ptr) {
21252 : PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
21253 : } else {
21254 : switch_expr_is_overloaded = 1;
21255 : EX_T(opline->op1.u.var).str_offset.str->refcount++;
21256 : }
21257 : }
21258 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
21259 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
21260 : &opline->op2.u.constant TSRMLS_CC);
21261 :
21262 0 : if (switch_expr_is_overloaded) {
21263 : /* We only free op1 if this is a string offset,
21264 : * Since if it is a TMP_VAR, it'll be reused by
21265 : * other CASE opcodes (whereas string offsets
21266 : * are allocated at each get_zval_ptr())
21267 : */
21268 :
21269 0 : EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
21270 0 : AI_USE_PTR(EX_T(opline->op1.u.var).var);
21271 : }
21272 0 : ZEND_VM_NEXT_OPCODE();
21273 : }
21274 :
21275 : static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21276 17 : {
21277 17 : zend_op *opline = EX(opline);
21278 :
21279 17 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
21280 : zval *expr_ptr;
21281 17 : zval *offset=&opline->op2.u.constant;
21282 :
21283 : #if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
21284 17 : zval **expr_ptr_ptr = NULL;
21285 :
21286 17 : if (opline->extended_value) {
21287 0 : expr_ptr_ptr=_get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
21288 0 : expr_ptr = *expr_ptr_ptr;
21289 : } else {
21290 17 : expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
21291 : }
21292 : #else
21293 : expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
21294 : #endif
21295 :
21296 : if (0) { /* temporary variable */
21297 : zval *new_expr;
21298 :
21299 : ALLOC_ZVAL(new_expr);
21300 : INIT_PZVAL_COPY(new_expr, expr_ptr);
21301 : expr_ptr = new_expr;
21302 : } else {
21303 : #if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
21304 17 : if (opline->extended_value) {
21305 0 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
21306 0 : expr_ptr = *expr_ptr_ptr;
21307 0 : expr_ptr->refcount++;
21308 : } else
21309 : #endif
21310 17 : if (PZVAL_IS_REF(expr_ptr)) {
21311 : zval *new_expr;
21312 :
21313 0 : ALLOC_ZVAL(new_expr);
21314 0 : INIT_PZVAL_COPY(new_expr, expr_ptr);
21315 0 : expr_ptr = new_expr;
21316 0 : zendi_zval_copy_ctor(*expr_ptr);
21317 : } else {
21318 17 : expr_ptr->refcount++;
21319 : }
21320 : }
21321 17 : if (offset) {
21322 17 : switch (Z_TYPE_P(offset)) {
21323 : case IS_DOUBLE:
21324 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
21325 0 : break;
21326 : case IS_LONG:
21327 : case IS_BOOL:
21328 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
21329 0 : break;
21330 : case IS_STRING:
21331 17 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
21332 17 : break;
21333 : case IS_NULL:
21334 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
21335 0 : break;
21336 : default:
21337 0 : zend_error(E_WARNING, "Illegal offset type");
21338 0 : zval_ptr_dtor(&expr_ptr);
21339 : /* do nothing */
21340 : break;
21341 : }
21342 :
21343 : } else {
21344 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
21345 : }
21346 17 : if (opline->extended_value) {
21347 :
21348 : } else {
21349 :
21350 : }
21351 17 : ZEND_VM_NEXT_OPCODE();
21352 : }
21353 :
21354 : static int ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21355 5 : {
21356 5 : zend_op *opline = EX(opline);
21357 :
21358 5 : array_init(&EX_T(opline->result.u.var).tmp_var);
21359 : if (IS_CV == IS_UNUSED) {
21360 : ZEND_VM_NEXT_OPCODE();
21361 : #if 0 || IS_CV != IS_UNUSED
21362 : } else {
21363 5 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21364 : #endif
21365 : }
21366 : }
21367 :
21368 : static int ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21369 0 : {
21370 0 : zend_op *opline = EX(opline);
21371 :
21372 0 : zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
21373 0 : zval *offset = &opline->op2.u.constant;
21374 : long index;
21375 :
21376 0 : if (container) {
21377 0 : if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
21378 0 : SEPARATE_ZVAL_IF_NOT_REF(container);
21379 : }
21380 0 : switch (Z_TYPE_PP(container)) {
21381 : case IS_ARRAY: {
21382 0 : HashTable *ht = Z_ARRVAL_PP(container);
21383 :
21384 0 : switch (Z_TYPE_P(offset)) {
21385 : case IS_DOUBLE:
21386 0 : index = (long) Z_DVAL_P(offset);
21387 0 : zend_hash_index_del(ht, index);
21388 0 : break;
21389 : case IS_RESOURCE:
21390 : case IS_BOOL:
21391 : case IS_LONG:
21392 0 : index = Z_LVAL_P(offset);
21393 0 : zend_hash_index_del(ht, index);
21394 0 : break;
21395 : case IS_STRING:
21396 : if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
21397 : offset->refcount++;
21398 : }
21399 0 : if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
21400 : ht == &EG(symbol_table)) {
21401 : zend_execute_data *ex;
21402 0 : ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
21403 :
21404 0 : for (ex = execute_data; ex; ex = ex->prev_execute_data) {
21405 0 : if (ex->op_array && ex->symbol_table == ht) {
21406 : int i;
21407 :
21408 0 : for (i = 0; i < ex->op_array->last_var; i++) {
21409 0 : if (ex->op_array->vars[i].hash_value == hash_value &&
21410 : ex->op_array->vars[i].name_len == offset->value.str.len &&
21411 : !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
21412 0 : ex->CVs[i] = NULL;
21413 0 : break;
21414 : }
21415 : }
21416 : }
21417 : }
21418 : }
21419 : if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
21420 : zval_ptr_dtor(&offset);
21421 : }
21422 0 : break;
21423 : case IS_NULL:
21424 0 : zend_hash_del(ht, "", sizeof(""));
21425 0 : break;
21426 : default:
21427 0 : zend_error(E_WARNING, "Illegal offset type in unset");
21428 : break;
21429 : }
21430 :
21431 0 : break;
21432 : }
21433 : case IS_OBJECT:
21434 0 : if (!Z_OBJ_HT_P(*container)->unset_dimension) {
21435 0 : zend_error_noreturn(E_ERROR, "Cannot use object as array");
21436 : }
21437 : if (0) {
21438 : MAKE_REAL_ZVAL_PTR(offset);
21439 : }
21440 0 : Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
21441 : if (0) {
21442 : zval_ptr_dtor(&offset);
21443 : } else {
21444 :
21445 : }
21446 0 : break;
21447 : case IS_STRING:
21448 0 : zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
21449 : ZEND_VM_CONTINUE(); /* bailed out before */
21450 : default:
21451 :
21452 : break;
21453 : }
21454 : } else {
21455 :
21456 : }
21457 :
21458 0 : ZEND_VM_NEXT_OPCODE();
21459 : }
21460 :
21461 : static int ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21462 0 : {
21463 0 : zend_op *opline = EX(opline);
21464 :
21465 0 : zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
21466 0 : zval *offset = &opline->op2.u.constant;
21467 :
21468 0 : if (container) {
21469 0 : if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
21470 0 : SEPARATE_ZVAL_IF_NOT_REF(container);
21471 : }
21472 0 : if (Z_TYPE_PP(container) == IS_OBJECT) {
21473 : if (0) {
21474 : MAKE_REAL_ZVAL_PTR(offset);
21475 : }
21476 0 : Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
21477 : if (0) {
21478 : zval_ptr_dtor(&offset);
21479 : } else {
21480 :
21481 : }
21482 : } else {
21483 :
21484 : }
21485 : } else {
21486 :
21487 : }
21488 :
21489 0 : ZEND_VM_NEXT_OPCODE();
21490 : }
21491 :
21492 : static int zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
21493 1495 : {
21494 1495 : zend_op *opline = EX(opline);
21495 :
21496 1495 : zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
21497 1495 : zval **value = NULL;
21498 1495 : int result = 0;
21499 : long index;
21500 :
21501 1495 : if (container) {
21502 :
21503 1495 : zval *offset = &opline->op2.u.constant;
21504 :
21505 1495 : if (Z_TYPE_PP(container) == IS_ARRAY) {
21506 : HashTable *ht;
21507 1495 : int isset = 0;
21508 :
21509 1495 : ht = Z_ARRVAL_PP(container);
21510 :
21511 1495 : switch (Z_TYPE_P(offset)) {
21512 : case IS_DOUBLE:
21513 0 : index = (long) Z_DVAL_P(offset);
21514 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
21515 0 : isset = 1;
21516 : }
21517 0 : break;
21518 : case IS_RESOURCE:
21519 : case IS_BOOL:
21520 : case IS_LONG:
21521 80 : index = Z_LVAL_P(offset);
21522 80 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
21523 80 : isset = 1;
21524 : }
21525 80 : break;
21526 : case IS_STRING:
21527 1415 : if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
21528 1010 : isset = 1;
21529 : }
21530 1415 : break;
21531 : case IS_NULL:
21532 0 : if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
21533 0 : isset = 1;
21534 : }
21535 0 : break;
21536 : default:
21537 0 : zend_error(E_WARNING, "Illegal offset type in isset or empty");
21538 :
21539 : break;
21540 : }
21541 :
21542 1495 : switch (opline->extended_value) {
21543 : case ZEND_ISSET:
21544 690 : if (isset && Z_TYPE_PP(value) == IS_NULL) {
21545 0 : result = 0;
21546 : } else {
21547 690 : result = isset;
21548 : }
21549 690 : break;
21550 : case ZEND_ISEMPTY:
21551 1536 : if (!isset || !i_zend_is_true(*value)) {
21552 731 : result = 0;
21553 : } else {
21554 74 : result = 1;
21555 : }
21556 : break;
21557 : }
21558 :
21559 0 : } else if (Z_TYPE_PP(container) == IS_OBJECT) {
21560 : if (0) {
21561 : MAKE_REAL_ZVAL_PTR(offset);
21562 : }
21563 0 : if (prop_dim) {
21564 0 : result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
21565 : } else {
21566 0 : result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
21567 : }
21568 : if (0) {
21569 : zval_ptr_dtor(&offset);
21570 : } else {
21571 :
21572 : }
21573 0 : } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
21574 : zval tmp;
21575 :
21576 0 : if (Z_TYPE_P(offset) != IS_LONG) {
21577 0 : tmp = *offset;
21578 0 : zval_copy_ctor(&tmp);
21579 0 : convert_to_long(&tmp);
21580 0 : offset = &tmp;
21581 : }
21582 0 : if (Z_TYPE_P(offset) == IS_LONG) {
21583 0 : switch (opline->extended_value) {
21584 : case ZEND_ISSET:
21585 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
21586 0 : result = 1;
21587 : }
21588 0 : break;
21589 : case ZEND_ISEMPTY:
21590 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
21591 0 : result = 1;
21592 : }
21593 : break;
21594 : }
21595 : }
21596 :
21597 : } else {
21598 :
21599 : }
21600 : }
21601 :
21602 1495 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
21603 :
21604 1495 : switch (opline->extended_value) {
21605 : case ZEND_ISSET:
21606 690 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
21607 690 : break;
21608 : case ZEND_ISEMPTY:
21609 805 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
21610 : break;
21611 : }
21612 :
21613 1495 : ZEND_VM_NEXT_OPCODE();
21614 : }
21615 :
21616 : static int ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21617 1495 : {
21618 1495 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21619 : }
21620 :
21621 : static int ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21622 0 : {
21623 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21624 : }
21625 :
21626 : static int ZEND_ADD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21627 5 : {
21628 5 : zend_op *opline = EX(opline);
21629 : zend_free_op free_op2;
21630 :
21631 5 : add_function(&EX_T(opline->result.u.var).tmp_var,
21632 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
21633 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
21634 :
21635 5 : zval_dtor(free_op2.var);
21636 5 : ZEND_VM_NEXT_OPCODE();
21637 : }
21638 :
21639 : static int ZEND_SUB_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21640 0 : {
21641 0 : zend_op *opline = EX(opline);
21642 : zend_free_op free_op2;
21643 :
21644 0 : sub_function(&EX_T(opline->result.u.var).tmp_var,
21645 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
21646 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
21647 :
21648 0 : zval_dtor(free_op2.var);
21649 0 : ZEND_VM_NEXT_OPCODE();
21650 : }
21651 :
21652 : static int ZEND_MUL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21653 0 : {
21654 0 : zend_op *opline = EX(opline);
21655 : zend_free_op free_op2;
21656 :
21657 0 : mul_function(&EX_T(opline->result.u.var).tmp_var,
21658 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
21659 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
21660 :
21661 0 : zval_dtor(free_op2.var);
21662 0 : ZEND_VM_NEXT_OPCODE();
21663 : }
21664 :
21665 : static int ZEND_DIV_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21666 0 : {
21667 0 : zend_op *opline = EX(opline);
21668 : zend_free_op free_op2;
21669 :
21670 0 : div_function(&EX_T(opline->result.u.var).tmp_var,
21671 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
21672 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
21673 :
21674 0 : zval_dtor(free_op2.var);
21675 0 : ZEND_VM_NEXT_OPCODE();
21676 : }
21677 :
21678 : static int ZEND_MOD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21679 0 : {
21680 0 : zend_op *opline = EX(opline);
21681 : zend_free_op free_op2;
21682 :
21683 0 : mod_function(&EX_T(opline->result.u.var).tmp_var,
21684 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
21685 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
21686 :
21687 0 : zval_dtor(free_op2.var);
21688 0 : ZEND_VM_NEXT_OPCODE();
21689 : }
21690 :
21691 : static int ZEND_SL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21692 0 : {
21693 0 : zend_op *opline = EX(opline);
21694 : zend_free_op free_op2;
21695 :
21696 0 : shift_left_function(&EX_T(opline->result.u.var).tmp_var,
21697 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
21698 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
21699 :
21700 0 : zval_dtor(free_op2.var);
21701 0 : ZEND_VM_NEXT_OPCODE();
21702 : }
21703 :
21704 : static int ZEND_SR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21705 0 : {
21706 0 : zend_op *opline = EX(opline);
21707 : zend_free_op free_op2;
21708 :
21709 0 : shift_right_function(&EX_T(opline->result.u.var).tmp_var,
21710 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
21711 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
21712 :
21713 0 : zval_dtor(free_op2.var);
21714 0 : ZEND_VM_NEXT_OPCODE();
21715 : }
21716 :
21717 : static int ZEND_CONCAT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21718 1308 : {
21719 1308 : zend_op *opline = EX(opline);
21720 : zend_free_op free_op2;
21721 :
21722 1308 : concat_function(&EX_T(opline->result.u.var).tmp_var,
21723 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
21724 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
21725 :
21726 1308 : zval_dtor(free_op2.var);
21727 1308 : ZEND_VM_NEXT_OPCODE();
21728 : }
21729 :
21730 : static int ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21731 0 : {
21732 0 : zend_op *opline = EX(opline);
21733 : zend_free_op free_op2;
21734 :
21735 0 : is_identical_function(&EX_T(opline->result.u.var).tmp_var,
21736 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
21737 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
21738 :
21739 0 : zval_dtor(free_op2.var);
21740 0 : ZEND_VM_NEXT_OPCODE();
21741 : }
21742 :
21743 : static int ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21744 0 : {
21745 0 : zend_op *opline = EX(opline);
21746 : zend_free_op free_op2;
21747 :
21748 0 : is_not_identical_function(&EX_T(opline->result.u.var).tmp_var,
21749 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
21750 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
21751 :
21752 0 : zval_dtor(free_op2.var);
21753 0 : ZEND_VM_NEXT_OPCODE();
21754 : }
21755 :
21756 : static int ZEND_IS_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21757 111 : {
21758 111 : zend_op *opline = EX(opline);
21759 : zend_free_op free_op2;
21760 :
21761 111 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
21762 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
21763 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
21764 :
21765 111 : zval_dtor(free_op2.var);
21766 111 : ZEND_VM_NEXT_OPCODE();
21767 : }
21768 :
21769 : static int ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21770 0 : {
21771 0 : zend_op *opline = EX(opline);
21772 : zend_free_op free_op2;
21773 :
21774 0 : is_not_equal_function(&EX_T(opline->result.u.var).tmp_var,
21775 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
21776 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
21777 :
21778 0 : zval_dtor(free_op2.var);
21779 0 : ZEND_VM_NEXT_OPCODE();
21780 : }
21781 :
21782 : static int ZEND_IS_SMALLER_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21783 0 : {
21784 0 : zend_op *opline = EX(opline);
21785 : zend_free_op free_op2;
21786 :
21787 0 : is_smaller_function(&EX_T(opline->result.u.var).tmp_var,
21788 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
21789 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
21790 :
21791 0 : zval_dtor(free_op2.var);
21792 0 : ZEND_VM_NEXT_OPCODE();
21793 : }
21794 :
21795 : static int ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21796 30 : {
21797 30 : zend_op *opline = EX(opline);
21798 : zend_free_op free_op2;
21799 :
21800 30 : is_smaller_or_equal_function(&EX_T(opline->result.u.var).tmp_var,
21801 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
21802 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
21803 :
21804 30 : zval_dtor(free_op2.var);
21805 30 : ZEND_VM_NEXT_OPCODE();
21806 : }
21807 :
21808 : static int ZEND_BW_OR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21809 0 : {
21810 0 : zend_op *opline = EX(opline);
21811 : zend_free_op free_op2;
21812 :
21813 0 : bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
21814 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
21815 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
21816 :
21817 0 : zval_dtor(free_op2.var);
21818 0 : ZEND_VM_NEXT_OPCODE();
21819 : }
21820 :
21821 : static int ZEND_BW_AND_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21822 0 : {
21823 0 : zend_op *opline = EX(opline);
21824 : zend_free_op free_op2;
21825 :
21826 0 : bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
21827 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
21828 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
21829 :
21830 0 : zval_dtor(free_op2.var);
21831 0 : ZEND_VM_NEXT_OPCODE();
21832 : }
21833 :
21834 : static int ZEND_BW_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21835 0 : {
21836 0 : zend_op *opline = EX(opline);
21837 : zend_free_op free_op2;
21838 :
21839 0 : bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
21840 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
21841 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
21842 :
21843 0 : zval_dtor(free_op2.var);
21844 0 : ZEND_VM_NEXT_OPCODE();
21845 : }
21846 :
21847 : static int ZEND_BOOL_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21848 0 : {
21849 0 : zend_op *opline = EX(opline);
21850 : zend_free_op free_op2;
21851 :
21852 0 : boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
21853 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
21854 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
21855 :
21856 0 : zval_dtor(free_op2.var);
21857 0 : ZEND_VM_NEXT_OPCODE();
21858 : }
21859 :
21860 : static int zend_binary_assign_op_obj_helper_SPEC_CV_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
21861 0 : {
21862 0 : zend_op *opline = EX(opline);
21863 0 : zend_op *op_data = opline+1;
21864 : zend_free_op free_op2, free_op_data1;
21865 0 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
21866 : zval *object;
21867 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
21868 0 : zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
21869 0 : znode *result = &opline->result;
21870 0 : zval **retval = &EX_T(result->u.var).var.ptr;
21871 0 : int have_get_ptr = 0;
21872 :
21873 0 : EX_T(result->u.var).var.ptr_ptr = NULL;
21874 0 : make_real_object(object_ptr TSRMLS_CC);
21875 0 : object = *object_ptr;
21876 :
21877 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
21878 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
21879 0 : zval_dtor(free_op2.var);
21880 0 : FREE_OP(free_op_data1);
21881 :
21882 0 : if (!RETURN_VALUE_UNUSED(result)) {
21883 0 : *retval = EG(uninitialized_zval_ptr);
21884 0 : PZVAL_LOCK(*retval);
21885 : }
21886 : } else {
21887 : /* here we are sure we are dealing with an object */
21888 : if (1) {
21889 0 : MAKE_REAL_ZVAL_PTR(property);
21890 : }
21891 :
21892 : /* here property is a string */
21893 0 : if (opline->extended_value == ZEND_ASSIGN_OBJ
21894 : && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
21895 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
21896 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
21897 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
21898 :
21899 0 : have_get_ptr = 1;
21900 0 : binary_op(*zptr, *zptr, value TSRMLS_CC);
21901 0 : if (!RETURN_VALUE_UNUSED(result)) {
21902 0 : *retval = *zptr;
21903 0 : PZVAL_LOCK(*retval);
21904 : }
21905 : }
21906 : }
21907 :
21908 0 : if (!have_get_ptr) {
21909 0 : zval *z = NULL;
21910 :
21911 0 : switch (opline->extended_value) {
21912 : case ZEND_ASSIGN_OBJ:
21913 0 : if (Z_OBJ_HT_P(object)->read_property) {
21914 0 : z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
21915 : }
21916 0 : break;
21917 : case ZEND_ASSIGN_DIM:
21918 0 : if (Z_OBJ_HT_P(object)->read_dimension) {
21919 0 : z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
21920 : }
21921 : break;
21922 : }
21923 0 : if (z) {
21924 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
21925 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
21926 :
21927 0 : if (z->refcount == 0) {
21928 0 : zval_dtor(z);
21929 0 : FREE_ZVAL(z);
21930 : }
21931 0 : z = value;
21932 : }
21933 0 : z->refcount++;
21934 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
21935 0 : binary_op(z, z, value TSRMLS_CC);
21936 0 : switch (opline->extended_value) {
21937 : case ZEND_ASSIGN_OBJ:
21938 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
21939 0 : break;
21940 : case ZEND_ASSIGN_DIM:
21941 0 : Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
21942 : break;
21943 : }
21944 0 : if (!RETURN_VALUE_UNUSED(result)) {
21945 0 : *retval = z;
21946 0 : PZVAL_LOCK(*retval);
21947 : }
21948 0 : zval_ptr_dtor(&z);
21949 : } else {
21950 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
21951 0 : if (!RETURN_VALUE_UNUSED(result)) {
21952 0 : *retval = EG(uninitialized_zval_ptr);
21953 0 : PZVAL_LOCK(*retval);
21954 : }
21955 : }
21956 : }
21957 :
21958 : if (1) {
21959 0 : zval_ptr_dtor(&property);
21960 : } else {
21961 : zval_dtor(free_op2.var);
21962 : }
21963 0 : FREE_OP(free_op_data1);
21964 : }
21965 :
21966 : /* assign_obj has two opcodes! */
21967 0 : ZEND_VM_INC_OPCODE();
21968 0 : ZEND_VM_NEXT_OPCODE();
21969 : }
21970 :
21971 : static int zend_binary_assign_op_helper_SPEC_CV_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
21972 2208 : {
21973 2208 : zend_op *opline = EX(opline);
21974 : zend_free_op free_op2, free_op_data2, free_op_data1;
21975 : zval **var_ptr;
21976 : zval *value;
21977 2208 : zend_bool increment_opline = 0;
21978 :
21979 2208 : switch (opline->extended_value) {
21980 : case ZEND_ASSIGN_OBJ:
21981 0 : return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21982 : break;
21983 : case ZEND_ASSIGN_DIM: {
21984 0 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
21985 :
21986 : if (object_ptr && IS_CV != IS_CV && !0) {
21987 : (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
21988 : }
21989 :
21990 0 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
21991 0 : return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21992 : } else {
21993 0 : zend_op *op_data = opline+1;
21994 0 : zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
21995 :
21996 0 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC), dim, 1, BP_VAR_RW TSRMLS_CC);
21997 0 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
21998 0 : var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
21999 0 : increment_opline = 1;
22000 : }
22001 : }
22002 0 : break;
22003 : default:
22004 2208 : value = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22005 2208 : var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
22006 : /* do nothing */
22007 : break;
22008 : }
22009 :
22010 2208 : if (!var_ptr) {
22011 0 : zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
22012 : }
22013 :
22014 2208 : if (*var_ptr == EG(error_zval_ptr)) {
22015 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
22016 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
22017 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
22018 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
22019 : }
22020 0 : zval_dtor(free_op2.var);
22021 :
22022 0 : if (increment_opline) {
22023 0 : ZEND_VM_INC_OPCODE();
22024 : }
22025 0 : ZEND_VM_NEXT_OPCODE();
22026 : }
22027 :
22028 2208 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
22029 :
22030 2208 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
22031 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
22032 : /* proxy object */
22033 0 : zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
22034 0 : objval->refcount++;
22035 0 : binary_op(objval, objval, value TSRMLS_CC);
22036 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
22037 0 : zval_ptr_dtor(&objval);
22038 : } else {
22039 2208 : binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
22040 : }
22041 :
22042 2208 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
22043 0 : EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
22044 0 : PZVAL_LOCK(*var_ptr);
22045 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
22046 : }
22047 2208 : zval_dtor(free_op2.var);
22048 :
22049 2208 : if (increment_opline) {
22050 0 : ZEND_VM_INC_OPCODE();
22051 0 : FREE_OP(free_op_data1);
22052 0 : FREE_OP_VAR_PTR(free_op_data2);
22053 : }
22054 :
22055 2208 : ZEND_VM_NEXT_OPCODE();
22056 : }
22057 :
22058 : static int ZEND_ASSIGN_ADD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22059 0 : {
22060 0 : return zend_binary_assign_op_helper_SPEC_CV_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22061 : }
22062 :
22063 : static int ZEND_ASSIGN_SUB_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22064 0 : {
22065 0 : return zend_binary_assign_op_helper_SPEC_CV_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22066 : }
22067 :
22068 : static int ZEND_ASSIGN_MUL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22069 0 : {
22070 0 : return zend_binary_assign_op_helper_SPEC_CV_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22071 : }
22072 :
22073 : static int ZEND_ASSIGN_DIV_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22074 0 : {
22075 0 : return zend_binary_assign_op_helper_SPEC_CV_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22076 : }
22077 :
22078 : static int ZEND_ASSIGN_MOD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22079 0 : {
22080 0 : return zend_binary_assign_op_helper_SPEC_CV_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22081 : }
22082 :
22083 : static int ZEND_ASSIGN_SL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22084 0 : {
22085 0 : return zend_binary_assign_op_helper_SPEC_CV_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22086 : }
22087 :
22088 : static int ZEND_ASSIGN_SR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22089 0 : {
22090 0 : return zend_binary_assign_op_helper_SPEC_CV_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22091 : }
22092 :
22093 : static int ZEND_ASSIGN_CONCAT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22094 2208 : {
22095 2208 : return zend_binary_assign_op_helper_SPEC_CV_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22096 : }
22097 :
22098 : static int ZEND_ASSIGN_BW_OR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22099 0 : {
22100 0 : return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22101 : }
22102 :
22103 : static int ZEND_ASSIGN_BW_AND_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22104 0 : {
22105 0 : return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22106 : }
22107 :
22108 : static int ZEND_ASSIGN_BW_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22109 0 : {
22110 0 : return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22111 : }
22112 :
22113 : static int zend_pre_incdec_property_helper_SPEC_CV_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
22114 0 : {
22115 0 : zend_op *opline = EX(opline);
22116 : zend_free_op free_op2;
22117 0 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
22118 : zval *object;
22119 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22120 0 : zval **retval = &EX_T(opline->result.u.var).var.ptr;
22121 0 : int have_get_ptr = 0;
22122 :
22123 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
22124 0 : object = *object_ptr;
22125 :
22126 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
22127 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
22128 0 : zval_dtor(free_op2.var);
22129 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
22130 0 : *retval = EG(uninitialized_zval_ptr);
22131 0 : PZVAL_LOCK(*retval);
22132 : }
22133 :
22134 0 : ZEND_VM_NEXT_OPCODE();
22135 : }
22136 :
22137 : /* here we are sure we are dealing with an object */
22138 :
22139 : if (1) {
22140 0 : MAKE_REAL_ZVAL_PTR(property);
22141 : }
22142 :
22143 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
22144 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
22145 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
22146 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
22147 :
22148 0 : have_get_ptr = 1;
22149 0 : incdec_op(*zptr);
22150 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
22151 0 : *retval = *zptr;
22152 0 : PZVAL_LOCK(*retval);
22153 : }
22154 : }
22155 : }
22156 :
22157 0 : if (!have_get_ptr) {
22158 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
22159 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
22160 :
22161 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
22162 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
22163 :
22164 0 : if (z->refcount == 0) {
22165 0 : zval_dtor(z);
22166 0 : FREE_ZVAL(z);
22167 : }
22168 0 : z = value;
22169 : }
22170 0 : z->refcount++;
22171 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
22172 0 : incdec_op(z);
22173 0 : *retval = z;
22174 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
22175 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
22176 0 : zval_ptr_dtor(&z);
22177 : } else {
22178 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
22179 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
22180 0 : *retval = EG(uninitialized_zval_ptr);
22181 0 : PZVAL_LOCK(*retval);
22182 : }
22183 : }
22184 : }
22185 :
22186 : if (1) {
22187 0 : zval_ptr_dtor(&property);
22188 : } else {
22189 : zval_dtor(free_op2.var);
22190 : }
22191 :
22192 0 : ZEND_VM_NEXT_OPCODE();
22193 : }
22194 :
22195 : static int ZEND_PRE_INC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22196 0 : {
22197 0 : return zend_pre_incdec_property_helper_SPEC_CV_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22198 : }
22199 :
22200 : static int ZEND_PRE_DEC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22201 0 : {
22202 0 : return zend_pre_incdec_property_helper_SPEC_CV_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22203 : }
22204 :
22205 : static int zend_post_incdec_property_helper_SPEC_CV_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
22206 0 : {
22207 0 : zend_op *opline = EX(opline);
22208 : zend_free_op free_op2;
22209 0 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
22210 : zval *object;
22211 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22212 0 : zval *retval = &EX_T(opline->result.u.var).tmp_var;
22213 0 : int have_get_ptr = 0;
22214 :
22215 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
22216 0 : object = *object_ptr;
22217 :
22218 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
22219 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
22220 0 : zval_dtor(free_op2.var);
22221 0 : *retval = *EG(uninitialized_zval_ptr);
22222 :
22223 0 : ZEND_VM_NEXT_OPCODE();
22224 : }
22225 :
22226 : /* here we are sure we are dealing with an object */
22227 :
22228 : if (1) {
22229 0 : MAKE_REAL_ZVAL_PTR(property);
22230 : }
22231 :
22232 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
22233 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
22234 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
22235 0 : have_get_ptr = 1;
22236 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
22237 :
22238 0 : *retval = **zptr;
22239 0 : zendi_zval_copy_ctor(*retval);
22240 :
22241 0 : incdec_op(*zptr);
22242 :
22243 : }
22244 : }
22245 :
22246 0 : if (!have_get_ptr) {
22247 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
22248 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
22249 : zval *z_copy;
22250 :
22251 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
22252 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
22253 :
22254 0 : if (z->refcount == 0) {
22255 0 : zval_dtor(z);
22256 0 : FREE_ZVAL(z);
22257 : }
22258 0 : z = value;
22259 : }
22260 0 : *retval = *z;
22261 0 : zendi_zval_copy_ctor(*retval);
22262 0 : ALLOC_ZVAL(z_copy);
22263 0 : *z_copy = *z;
22264 0 : zendi_zval_copy_ctor(*z_copy);
22265 0 : INIT_PZVAL(z_copy);
22266 0 : incdec_op(z_copy);
22267 0 : z->refcount++;
22268 0 : Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
22269 0 : zval_ptr_dtor(&z_copy);
22270 0 : zval_ptr_dtor(&z);
22271 : } else {
22272 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
22273 0 : *retval = *EG(uninitialized_zval_ptr);
22274 : }
22275 : }
22276 :
22277 : if (1) {
22278 0 : zval_ptr_dtor(&property);
22279 : } else {
22280 : zval_dtor(free_op2.var);
22281 : }
22282 :
22283 0 : ZEND_VM_NEXT_OPCODE();
22284 : }
22285 :
22286 : static int ZEND_POST_INC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22287 0 : {
22288 0 : return zend_post_incdec_property_helper_SPEC_CV_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22289 : }
22290 :
22291 : static int ZEND_POST_DEC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22292 0 : {
22293 0 : return zend_post_incdec_property_helper_SPEC_CV_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22294 : }
22295 :
22296 : static int ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22297 72 : {
22298 72 : zend_op *opline = EX(opline);
22299 : zend_free_op free_op2;
22300 72 : zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22301 :
22302 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK &&
22303 : IS_CV != IS_CV &&
22304 : EX_T(opline->op1.u.var).var.ptr_ptr) {
22305 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
22306 : }
22307 72 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC), dim, 1, BP_VAR_R TSRMLS_CC);
22308 72 : zval_dtor(free_op2.var);
22309 :
22310 72 : ZEND_VM_NEXT_OPCODE();
22311 : }
22312 :
22313 : static int ZEND_FETCH_DIM_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22314 4 : {
22315 4 : zend_op *opline = EX(opline);
22316 : zend_free_op free_op1, free_op2;
22317 4 : zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22318 :
22319 4 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC), dim, 1, BP_VAR_W TSRMLS_CC);
22320 4 : zval_dtor(free_op2.var);
22321 : if (IS_CV == IS_VAR && 0 &&
22322 : READY_TO_DESTROY(free_op1.var) &&
22323 : !RETURN_VALUE_UNUSED(&opline->result)) {
22324 : AI_USE_PTR(EX_T(opline->result.u.var).var);
22325 : }
22326 :
22327 4 : ZEND_VM_NEXT_OPCODE();
22328 : }
22329 :
22330 : static int ZEND_FETCH_DIM_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22331 0 : {
22332 0 : zend_op *opline = EX(opline);
22333 : zend_free_op free_op1, free_op2;
22334 0 : zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22335 :
22336 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC), dim, 1, BP_VAR_RW TSRMLS_CC);
22337 0 : zval_dtor(free_op2.var);
22338 : if (IS_CV == IS_VAR && 0 &&
22339 : READY_TO_DESTROY(free_op1.var) &&
22340 : !RETURN_VALUE_UNUSED(&opline->result)) {
22341 : AI_USE_PTR(EX_T(opline->result.u.var).var);
22342 : }
22343 :
22344 0 : ZEND_VM_NEXT_OPCODE();
22345 : }
22346 :
22347 : static int ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22348 0 : {
22349 0 : zend_op *opline = EX(opline);
22350 : zend_free_op free_op2;
22351 0 : zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22352 :
22353 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC), dim, 1, BP_VAR_IS TSRMLS_CC);
22354 0 : zval_dtor(free_op2.var);
22355 :
22356 0 : ZEND_VM_NEXT_OPCODE();
22357 : }
22358 :
22359 : static int ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22360 0 : {
22361 0 : zend_op *opline = EX(opline);
22362 : zend_free_op free_op1, free_op2;
22363 0 : int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
22364 : zval *dim;
22365 :
22366 : if (IS_TMP_VAR == IS_UNUSED && type == BP_VAR_R) {
22367 : zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
22368 : }
22369 0 : dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22370 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), type TSRMLS_CC), dim, 1, type TSRMLS_CC);
22371 0 : zval_dtor(free_op2.var);
22372 : if (IS_CV == IS_VAR && type == BP_VAR_W && 0 &&
22373 : READY_TO_DESTROY(free_op1.var) &&
22374 : !RETURN_VALUE_UNUSED(&opline->result)) {
22375 : AI_USE_PTR(EX_T(opline->result.u.var).var);
22376 : }
22377 :
22378 0 : ZEND_VM_NEXT_OPCODE();
22379 : }
22380 :
22381 : static int ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22382 0 : {
22383 0 : zend_op *opline = EX(opline);
22384 : zend_free_op free_op1, free_op2;
22385 0 : zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
22386 0 : zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22387 :
22388 : /* Not needed in DIM_UNSET
22389 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
22390 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
22391 : }
22392 : */
22393 : if (IS_CV == IS_CV) {
22394 0 : if (container != &EG(uninitialized_zval_ptr)) {
22395 0 : SEPARATE_ZVAL_IF_NOT_REF(container);
22396 : }
22397 : }
22398 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, dim, 1, BP_VAR_UNSET TSRMLS_CC);
22399 0 : zval_dtor(free_op2.var);
22400 : if (IS_CV == IS_VAR && 0 &&
22401 : READY_TO_DESTROY(free_op1.var) &&
22402 : !RETURN_VALUE_UNUSED(&opline->result)) {
22403 : AI_USE_PTR(EX_T(opline->result.u.var).var);
22404 : }
22405 :
22406 0 : if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
22407 0 : zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
22408 : } else {
22409 : zend_free_op free_res;
22410 :
22411 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
22412 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
22413 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
22414 : }
22415 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
22416 0 : FREE_OP_VAR_PTR(free_res);
22417 : }
22418 0 : ZEND_VM_NEXT_OPCODE();
22419 : }
22420 :
22421 : static int zend_fetch_property_address_read_helper_SPEC_CV_TMP(int type, ZEND_OPCODE_HANDLER_ARGS)
22422 0 : {
22423 0 : zend_op *opline = EX(opline);
22424 : zval *container;
22425 : zval **retval;
22426 :
22427 :
22428 0 : retval = &EX_T(opline->result.u.var).var.ptr;
22429 0 : EX_T(opline->result.u.var).var.ptr_ptr = retval;
22430 :
22431 0 : container = _get_zval_ptr_cv(&opline->op1, EX(Ts), type TSRMLS_CC);
22432 :
22433 0 : if (container == EG(error_zval_ptr)) {
22434 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
22435 0 : *retval = EG(error_zval_ptr);
22436 0 : PZVAL_LOCK(*retval);
22437 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
22438 : }
22439 :
22440 0 : ZEND_VM_NEXT_OPCODE();
22441 : }
22442 :
22443 :
22444 0 : if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
22445 0 : if (type != BP_VAR_IS) {
22446 0 : zend_error(E_NOTICE, "Trying to get property of non-object");
22447 : }
22448 0 : *retval = EG(uninitialized_zval_ptr);
22449 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
22450 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
22451 : } else {
22452 : zend_free_op free_op2;
22453 0 : zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22454 :
22455 : if (1) {
22456 0 : MAKE_REAL_ZVAL_PTR(offset);
22457 : }
22458 :
22459 : /* here we are sure we are dealing with an object */
22460 0 : *retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
22461 :
22462 0 : if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
22463 0 : zval_dtor(*retval);
22464 0 : FREE_ZVAL(*retval);
22465 : } else {
22466 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
22467 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
22468 : }
22469 :
22470 : if (1) {
22471 0 : zval_ptr_dtor(&offset);
22472 : } else {
22473 : zval_dtor(free_op2.var);
22474 : }
22475 : }
22476 :
22477 0 : ZEND_VM_NEXT_OPCODE();
22478 : }
22479 :
22480 : static int ZEND_FETCH_OBJ_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22481 0 : {
22482 0 : return zend_fetch_property_address_read_helper_SPEC_CV_TMP(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22483 : }
22484 :
22485 : static int ZEND_FETCH_OBJ_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22486 0 : {
22487 0 : zend_op *opline = EX(opline);
22488 : zend_free_op free_op1, free_op2;
22489 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22490 :
22491 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_CV != IS_CV) {
22492 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
22493 : EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
22494 : }
22495 :
22496 : if (1) {
22497 0 : MAKE_REAL_ZVAL_PTR(property);
22498 : }
22499 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
22500 : if (1) {
22501 0 : zval_ptr_dtor(&property);
22502 : } else {
22503 : zval_dtor(free_op2.var);
22504 : }
22505 : if (IS_CV == IS_VAR && 0 &&
22506 : READY_TO_DESTROY(free_op1.var) &&
22507 : !RETURN_VALUE_UNUSED(&opline->result)) {
22508 : AI_USE_PTR(EX_T(opline->result.u.var).var);
22509 : }
22510 :
22511 0 : ZEND_VM_NEXT_OPCODE();
22512 : }
22513 :
22514 : static int ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22515 0 : {
22516 0 : zend_op *opline = EX(opline);
22517 : zend_free_op free_op1, free_op2;
22518 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22519 :
22520 : if (1) {
22521 0 : MAKE_REAL_ZVAL_PTR(property);
22522 : }
22523 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC), property, BP_VAR_RW TSRMLS_CC);
22524 : if (1) {
22525 0 : zval_ptr_dtor(&property);
22526 : } else {
22527 : zval_dtor(free_op2.var);
22528 : }
22529 : if (IS_CV == IS_VAR && 0 &&
22530 : READY_TO_DESTROY(free_op1.var) &&
22531 : !RETURN_VALUE_UNUSED(&opline->result)) {
22532 : AI_USE_PTR(EX_T(opline->result.u.var).var);
22533 : }
22534 :
22535 0 : ZEND_VM_NEXT_OPCODE();
22536 : }
22537 :
22538 : static int ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22539 0 : {
22540 0 : return zend_fetch_property_address_read_helper_SPEC_CV_TMP(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22541 : }
22542 :
22543 : static int ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22544 0 : {
22545 0 : zend_op *opline = EX(opline);
22546 :
22547 0 : if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
22548 : /* Behave like FETCH_OBJ_W */
22549 : zend_free_op free_op1, free_op2;
22550 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22551 :
22552 : if (1) {
22553 0 : MAKE_REAL_ZVAL_PTR(property);
22554 : }
22555 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
22556 : if (1) {
22557 0 : zval_ptr_dtor(&property);
22558 : } else {
22559 : zval_dtor(free_op2.var);
22560 : }
22561 : if (IS_CV == IS_VAR && 0 &&
22562 : READY_TO_DESTROY(free_op1.var) &&
22563 : !RETURN_VALUE_UNUSED(&opline->result)) {
22564 : AI_USE_PTR(EX_T(opline->result.u.var).var);
22565 : }
22566 :
22567 0 : ZEND_VM_NEXT_OPCODE();
22568 : } else {
22569 0 : return zend_fetch_property_address_read_helper_SPEC_CV_TMP(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22570 : }
22571 : }
22572 :
22573 : static int ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22574 0 : {
22575 0 : zend_op *opline = EX(opline);
22576 : zend_free_op free_op1, free_op2, free_res;
22577 0 : zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
22578 0 : zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22579 :
22580 : if (IS_CV == IS_CV) {
22581 0 : if (container != &EG(uninitialized_zval_ptr)) {
22582 0 : SEPARATE_ZVAL_IF_NOT_REF(container);
22583 : }
22584 : }
22585 : if (1) {
22586 0 : MAKE_REAL_ZVAL_PTR(property);
22587 : }
22588 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
22589 : if (1) {
22590 0 : zval_ptr_dtor(&property);
22591 : } else {
22592 : zval_dtor(free_op2.var);
22593 : }
22594 : if (IS_CV == IS_VAR && 0 &&
22595 : READY_TO_DESTROY(free_op1.var) &&
22596 : !RETURN_VALUE_UNUSED(&opline->result)) {
22597 : AI_USE_PTR(EX_T(opline->result.u.var).var);
22598 : }
22599 :
22600 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
22601 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
22602 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
22603 : }
22604 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
22605 0 : FREE_OP_VAR_PTR(free_res);
22606 0 : ZEND_VM_NEXT_OPCODE();
22607 : }
22608 :
22609 : static int ZEND_ASSIGN_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22610 0 : {
22611 0 : zend_op *opline = EX(opline);
22612 0 : zend_op *op_data = opline+1;
22613 :
22614 0 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
22615 :
22616 0 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
22617 :
22618 : /* assign_obj has two opcodes! */
22619 0 : ZEND_VM_INC_OPCODE();
22620 0 : ZEND_VM_NEXT_OPCODE();
22621 : }
22622 :
22623 : static int ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22624 0 : {
22625 0 : zend_op *opline = EX(opline);
22626 0 : zend_op *op_data = opline+1;
22627 :
22628 : zval **object_ptr;
22629 :
22630 : if (IS_CV == IS_CV || EX_T(opline->op1.u.var).var.ptr_ptr) {
22631 : /* not an array offset */
22632 0 : object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
22633 : } else {
22634 : object_ptr = NULL;
22635 : }
22636 :
22637 0 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
22638 0 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
22639 : } else {
22640 : zend_free_op free_op2, free_op_data1;
22641 : zval *value;
22642 0 : zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22643 :
22644 0 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 1, BP_VAR_W TSRMLS_CC);
22645 0 : zval_dtor(free_op2.var);
22646 :
22647 0 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
22648 0 : zend_assign_to_variable(&opline->result, &op_data->op2, &op_data->op1, value, (IS_TMP_FREE(free_op_data1)?IS_TMP_VAR:op_data->op1.op_type), EX(Ts) TSRMLS_CC);
22649 0 : FREE_OP_IF_VAR(free_op_data1);
22650 : }
22651 :
22652 : /* assign_dim has two opcodes! */
22653 0 : ZEND_VM_INC_OPCODE();
22654 0 : ZEND_VM_NEXT_OPCODE();
22655 : }
22656 :
22657 : static int ZEND_ASSIGN_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22658 14887 : {
22659 14887 : zend_op *opline = EX(opline);
22660 : zend_free_op free_op2;
22661 14887 : zval *value = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22662 :
22663 14887 : zend_assign_to_variable(&opline->result, &opline->op1, &opline->op2, value, (1?IS_TMP_VAR:IS_TMP_VAR), EX(Ts) TSRMLS_CC);
22664 : /* zend_assign_to_variable() always takes care of op2, never free it! */
22665 :
22666 14887 : ZEND_VM_NEXT_OPCODE();
22667 : }
22668 :
22669 : static int ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22670 0 : {
22671 0 : zend_op *opline = EX(opline);
22672 : zval *function_name;
22673 : char *function_name_strval;
22674 : int function_name_strlen;
22675 : zend_free_op free_op2;
22676 :
22677 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
22678 :
22679 0 : function_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22680 :
22681 0 : if (Z_TYPE_P(function_name)!=IS_STRING) {
22682 0 : zend_error_noreturn(E_ERROR, "Method name must be a string");
22683 : }
22684 :
22685 0 : function_name_strval = Z_STRVAL_P(function_name);
22686 0 : function_name_strlen = Z_STRLEN_P(function_name);
22687 :
22688 0 : EX(object) = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
22689 :
22690 0 : if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
22691 0 : if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
22692 0 : zend_error_noreturn(E_ERROR, "Object does not support method calls");
22693 : }
22694 :
22695 : /* First, locate the function. */
22696 0 : EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
22697 0 : if (!EX(fbc)) {
22698 0 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
22699 : }
22700 : } else {
22701 0 : zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
22702 : }
22703 :
22704 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
22705 0 : EX(object) = NULL;
22706 : } else {
22707 0 : if (!PZVAL_IS_REF(EX(object))) {
22708 0 : EX(object)->refcount++; /* For $this pointer */
22709 : } else {
22710 : zval *this_ptr;
22711 0 : ALLOC_ZVAL(this_ptr);
22712 0 : INIT_PZVAL_COPY(this_ptr, EX(object));
22713 0 : zval_copy_ctor(this_ptr);
22714 0 : EX(object) = this_ptr;
22715 : }
22716 : }
22717 :
22718 0 : zval_dtor(free_op2.var);
22719 :
22720 0 : ZEND_VM_NEXT_OPCODE();
22721 : }
22722 :
22723 : static int ZEND_CASE_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22724 6 : {
22725 6 : zend_op *opline = EX(opline);
22726 6 : int switch_expr_is_overloaded=0;
22727 : zend_free_op free_op2;
22728 :
22729 : if (IS_CV==IS_VAR) {
22730 : if (EX_T(opline->op1.u.var).var.ptr_ptr) {
22731 : PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
22732 : } else {
22733 : switch_expr_is_overloaded = 1;
22734 : EX_T(opline->op1.u.var).str_offset.str->refcount++;
22735 : }
22736 : }
22737 6 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
22738 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
22739 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
22740 :
22741 6 : zval_dtor(free_op2.var);
22742 6 : if (switch_expr_is_overloaded) {
22743 : /* We only free op1 if this is a string offset,
22744 : * Since if it is a TMP_VAR, it'll be reused by
22745 : * other CASE opcodes (whereas string offsets
22746 : * are allocated at each get_zval_ptr())
22747 : */
22748 :
22749 0 : EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
22750 0 : AI_USE_PTR(EX_T(opline->op1.u.var).var);
22751 : }
22752 6 : ZEND_VM_NEXT_OPCODE();
22753 : }
22754 :
22755 : static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22756 0 : {
22757 0 : zend_op *opline = EX(opline);
22758 : zend_free_op free_op2;
22759 0 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
22760 : zval *expr_ptr;
22761 0 : zval *offset=_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22762 :
22763 : #if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
22764 0 : zval **expr_ptr_ptr = NULL;
22765 :
22766 0 : if (opline->extended_value) {
22767 0 : expr_ptr_ptr=_get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
22768 0 : expr_ptr = *expr_ptr_ptr;
22769 : } else {
22770 0 : expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
22771 : }
22772 : #else
22773 : expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
22774 : #endif
22775 :
22776 : if (0) { /* temporary variable */
22777 : zval *new_expr;
22778 :
22779 : ALLOC_ZVAL(new_expr);
22780 : INIT_PZVAL_COPY(new_expr, expr_ptr);
22781 : expr_ptr = new_expr;
22782 : } else {
22783 : #if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
22784 0 : if (opline->extended_value) {
22785 0 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
22786 0 : expr_ptr = *expr_ptr_ptr;
22787 0 : expr_ptr->refcount++;
22788 : } else
22789 : #endif
22790 0 : if (PZVAL_IS_REF(expr_ptr)) {
22791 : zval *new_expr;
22792 :
22793 0 : ALLOC_ZVAL(new_expr);
22794 0 : INIT_PZVAL_COPY(new_expr, expr_ptr);
22795 0 : expr_ptr = new_expr;
22796 0 : zendi_zval_copy_ctor(*expr_ptr);
22797 : } else {
22798 0 : expr_ptr->refcount++;
22799 : }
22800 : }
22801 0 : if (offset) {
22802 0 : switch (Z_TYPE_P(offset)) {
22803 : case IS_DOUBLE:
22804 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
22805 0 : break;
22806 : case IS_LONG:
22807 : case IS_BOOL:
22808 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
22809 0 : break;
22810 : case IS_STRING:
22811 0 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
22812 0 : break;
22813 : case IS_NULL:
22814 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
22815 0 : break;
22816 : default:
22817 0 : zend_error(E_WARNING, "Illegal offset type");
22818 0 : zval_ptr_dtor(&expr_ptr);
22819 : /* do nothing */
22820 : break;
22821 : }
22822 0 : zval_dtor(free_op2.var);
22823 : } else {
22824 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
22825 : }
22826 0 : if (opline->extended_value) {
22827 :
22828 : } else {
22829 :
22830 : }
22831 0 : ZEND_VM_NEXT_OPCODE();
22832 : }
22833 :
22834 : static int ZEND_INIT_ARRAY_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22835 0 : {
22836 0 : zend_op *opline = EX(opline);
22837 :
22838 0 : array_init(&EX_T(opline->result.u.var).tmp_var);
22839 : if (IS_CV == IS_UNUSED) {
22840 : ZEND_VM_NEXT_OPCODE();
22841 : #if 0 || IS_CV != IS_UNUSED
22842 : } else {
22843 0 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22844 : #endif
22845 : }
22846 : }
22847 :
22848 : static int ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22849 0 : {
22850 0 : zend_op *opline = EX(opline);
22851 : zend_free_op free_op2;
22852 0 : zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
22853 0 : zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22854 : long index;
22855 :
22856 0 : if (container) {
22857 0 : if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
22858 0 : SEPARATE_ZVAL_IF_NOT_REF(container);
22859 : }
22860 0 : switch (Z_TYPE_PP(container)) {
22861 : case IS_ARRAY: {
22862 0 : HashTable *ht = Z_ARRVAL_PP(container);
22863 :
22864 0 : switch (Z_TYPE_P(offset)) {
22865 : case IS_DOUBLE:
22866 0 : index = (long) Z_DVAL_P(offset);
22867 0 : zend_hash_index_del(ht, index);
22868 0 : break;
22869 : case IS_RESOURCE:
22870 : case IS_BOOL:
22871 : case IS_LONG:
22872 0 : index = Z_LVAL_P(offset);
22873 0 : zend_hash_index_del(ht, index);
22874 0 : break;
22875 : case IS_STRING:
22876 : if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
22877 : offset->refcount++;
22878 : }
22879 0 : if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
22880 : ht == &EG(symbol_table)) {
22881 : zend_execute_data *ex;
22882 0 : ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
22883 :
22884 0 : for (ex = execute_data; ex; ex = ex->prev_execute_data) {
22885 0 : if (ex->op_array && ex->symbol_table == ht) {
22886 : int i;
22887 :
22888 0 : for (i = 0; i < ex->op_array->last_var; i++) {
22889 0 : if (ex->op_array->vars[i].hash_value == hash_value &&
22890 : ex->op_array->vars[i].name_len == offset->value.str.len &&
22891 : !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
22892 0 : ex->CVs[i] = NULL;
22893 0 : break;
22894 : }
22895 : }
22896 : }
22897 : }
22898 : }
22899 : if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
22900 : zval_ptr_dtor(&offset);
22901 : }
22902 0 : break;
22903 : case IS_NULL:
22904 0 : zend_hash_del(ht, "", sizeof(""));
22905 0 : break;
22906 : default:
22907 0 : zend_error(E_WARNING, "Illegal offset type in unset");
22908 : break;
22909 : }
22910 0 : zval_dtor(free_op2.var);
22911 0 : break;
22912 : }
22913 : case IS_OBJECT:
22914 0 : if (!Z_OBJ_HT_P(*container)->unset_dimension) {
22915 0 : zend_error_noreturn(E_ERROR, "Cannot use object as array");
22916 : }
22917 : if (1) {
22918 0 : MAKE_REAL_ZVAL_PTR(offset);
22919 : }
22920 0 : Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
22921 : if (1) {
22922 0 : zval_ptr_dtor(&offset);
22923 : } else {
22924 : zval_dtor(free_op2.var);
22925 : }
22926 0 : break;
22927 : case IS_STRING:
22928 0 : zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
22929 : ZEND_VM_CONTINUE(); /* bailed out before */
22930 : default:
22931 0 : zval_dtor(free_op2.var);
22932 : break;
22933 : }
22934 : } else {
22935 0 : zval_dtor(free_op2.var);
22936 : }
22937 :
22938 0 : ZEND_VM_NEXT_OPCODE();
22939 : }
22940 :
22941 : static int ZEND_UNSET_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22942 0 : {
22943 0 : zend_op *opline = EX(opline);
22944 : zend_free_op free_op2;
22945 0 : zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
22946 0 : zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22947 :
22948 0 : if (container) {
22949 0 : if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
22950 0 : SEPARATE_ZVAL_IF_NOT_REF(container);
22951 : }
22952 0 : if (Z_TYPE_PP(container) == IS_OBJECT) {
22953 : if (1) {
22954 0 : MAKE_REAL_ZVAL_PTR(offset);
22955 : }
22956 0 : Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
22957 : if (1) {
22958 0 : zval_ptr_dtor(&offset);
22959 : } else {
22960 : zval_dtor(free_op2.var);
22961 : }
22962 : } else {
22963 0 : zval_dtor(free_op2.var);
22964 : }
22965 : } else {
22966 0 : zval_dtor(free_op2.var);
22967 : }
22968 :
22969 0 : ZEND_VM_NEXT_OPCODE();
22970 : }
22971 :
22972 : static int zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
22973 0 : {
22974 0 : zend_op *opline = EX(opline);
22975 :
22976 0 : zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
22977 0 : zval **value = NULL;
22978 0 : int result = 0;
22979 : long index;
22980 :
22981 0 : if (container) {
22982 : zend_free_op free_op2;
22983 0 : zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
22984 :
22985 0 : if (Z_TYPE_PP(container) == IS_ARRAY) {
22986 : HashTable *ht;
22987 0 : int isset = 0;
22988 :
22989 0 : ht = Z_ARRVAL_PP(container);
22990 :
22991 0 : switch (Z_TYPE_P(offset)) {
22992 : case IS_DOUBLE:
22993 0 : index = (long) Z_DVAL_P(offset);
22994 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
22995 0 : isset = 1;
22996 : }
22997 0 : break;
22998 : case IS_RESOURCE:
22999 : case IS_BOOL:
23000 : case IS_LONG:
23001 0 : index = Z_LVAL_P(offset);
23002 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
23003 0 : isset = 1;
23004 : }
23005 0 : break;
23006 : case IS_STRING:
23007 0 : if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
23008 0 : isset = 1;
23009 : }
23010 0 : break;
23011 : case IS_NULL:
23012 0 : if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
23013 0 : isset = 1;
23014 : }
23015 0 : break;
23016 : default:
23017 0 : zend_error(E_WARNING, "Illegal offset type in isset or empty");
23018 :
23019 : break;
23020 : }
23021 :
23022 0 : switch (opline->extended_value) {
23023 : case ZEND_ISSET:
23024 0 : if (isset && Z_TYPE_PP(value) == IS_NULL) {
23025 0 : result = 0;
23026 : } else {
23027 0 : result = isset;
23028 : }
23029 0 : break;
23030 : case ZEND_ISEMPTY:
23031 0 : if (!isset || !i_zend_is_true(*value)) {
23032 0 : result = 0;
23033 : } else {
23034 0 : result = 1;
23035 : }
23036 : break;
23037 : }
23038 0 : zval_dtor(free_op2.var);
23039 0 : } else if (Z_TYPE_PP(container) == IS_OBJECT) {
23040 : if (1) {
23041 0 : MAKE_REAL_ZVAL_PTR(offset);
23042 : }
23043 0 : if (prop_dim) {
23044 0 : result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
23045 : } else {
23046 0 : result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
23047 : }
23048 : if (1) {
23049 0 : zval_ptr_dtor(&offset);
23050 : } else {
23051 : zval_dtor(free_op2.var);
23052 : }
23053 0 : } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
23054 : zval tmp;
23055 :
23056 0 : if (Z_TYPE_P(offset) != IS_LONG) {
23057 0 : tmp = *offset;
23058 0 : zval_copy_ctor(&tmp);
23059 0 : convert_to_long(&tmp);
23060 0 : offset = &tmp;
23061 : }
23062 0 : if (Z_TYPE_P(offset) == IS_LONG) {
23063 0 : switch (opline->extended_value) {
23064 : case ZEND_ISSET:
23065 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
23066 0 : result = 1;
23067 : }
23068 0 : break;
23069 : case ZEND_ISEMPTY:
23070 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
23071 0 : result = 1;
23072 : }
23073 : break;
23074 : }
23075 : }
23076 0 : zval_dtor(free_op2.var);
23077 : } else {
23078 0 : zval_dtor(free_op2.var);
23079 : }
23080 : }
23081 :
23082 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
23083 :
23084 0 : switch (opline->extended_value) {
23085 : case ZEND_ISSET:
23086 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
23087 0 : break;
23088 : case ZEND_ISEMPTY:
23089 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
23090 : break;
23091 : }
23092 :
23093 0 : ZEND_VM_NEXT_OPCODE();
23094 : }
23095 :
23096 : static int ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23097 0 : {
23098 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23099 : }
23100 :
23101 : static int ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23102 0 : {
23103 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23104 : }
23105 :
23106 : static int ZEND_ADD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23107 0 : {
23108 0 : zend_op *opline = EX(opline);
23109 : zend_free_op free_op2;
23110 :
23111 0 : add_function(&EX_T(opline->result.u.var).tmp_var,
23112 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23113 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
23114 :
23115 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23116 0 : ZEND_VM_NEXT_OPCODE();
23117 : }
23118 :
23119 : static int ZEND_SUB_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23120 1 : {
23121 1 : zend_op *opline = EX(opline);
23122 : zend_free_op free_op2;
23123 :
23124 1 : sub_function(&EX_T(opline->result.u.var).tmp_var,
23125 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23126 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
23127 :
23128 1 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23129 1 : ZEND_VM_NEXT_OPCODE();
23130 : }
23131 :
23132 : static int ZEND_MUL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23133 0 : {
23134 0 : zend_op *opline = EX(opline);
23135 : zend_free_op free_op2;
23136 :
23137 0 : mul_function(&EX_T(opline->result.u.var).tmp_var,
23138 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23139 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
23140 :
23141 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23142 0 : ZEND_VM_NEXT_OPCODE();
23143 : }
23144 :
23145 : static int ZEND_DIV_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23146 0 : {
23147 0 : zend_op *opline = EX(opline);
23148 : zend_free_op free_op2;
23149 :
23150 0 : div_function(&EX_T(opline->result.u.var).tmp_var,
23151 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23152 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
23153 :
23154 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23155 0 : ZEND_VM_NEXT_OPCODE();
23156 : }
23157 :
23158 : static int ZEND_MOD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23159 0 : {
23160 0 : zend_op *opline = EX(opline);
23161 : zend_free_op free_op2;
23162 :
23163 0 : mod_function(&EX_T(opline->result.u.var).tmp_var,
23164 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23165 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
23166 :
23167 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23168 0 : ZEND_VM_NEXT_OPCODE();
23169 : }
23170 :
23171 : static int ZEND_SL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23172 0 : {
23173 0 : zend_op *opline = EX(opline);
23174 : zend_free_op free_op2;
23175 :
23176 0 : shift_left_function(&EX_T(opline->result.u.var).tmp_var,
23177 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23178 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
23179 :
23180 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23181 0 : ZEND_VM_NEXT_OPCODE();
23182 : }
23183 :
23184 : static int ZEND_SR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23185 0 : {
23186 0 : zend_op *opline = EX(opline);
23187 : zend_free_op free_op2;
23188 :
23189 0 : shift_right_function(&EX_T(opline->result.u.var).tmp_var,
23190 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23191 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
23192 :
23193 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23194 0 : ZEND_VM_NEXT_OPCODE();
23195 : }
23196 :
23197 : static int ZEND_CONCAT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23198 0 : {
23199 0 : zend_op *opline = EX(opline);
23200 : zend_free_op free_op2;
23201 :
23202 0 : concat_function(&EX_T(opline->result.u.var).tmp_var,
23203 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23204 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
23205 :
23206 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23207 0 : ZEND_VM_NEXT_OPCODE();
23208 : }
23209 :
23210 : static int ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23211 0 : {
23212 0 : zend_op *opline = EX(opline);
23213 : zend_free_op free_op2;
23214 :
23215 0 : is_identical_function(&EX_T(opline->result.u.var).tmp_var,
23216 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23217 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
23218 :
23219 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23220 0 : ZEND_VM_NEXT_OPCODE();
23221 : }
23222 :
23223 : static int ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23224 0 : {
23225 0 : zend_op *opline = EX(opline);
23226 : zend_free_op free_op2;
23227 :
23228 0 : is_not_identical_function(&EX_T(opline->result.u.var).tmp_var,
23229 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23230 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
23231 :
23232 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23233 0 : ZEND_VM_NEXT_OPCODE();
23234 : }
23235 :
23236 : static int ZEND_IS_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23237 3 : {
23238 3 : zend_op *opline = EX(opline);
23239 : zend_free_op free_op2;
23240 :
23241 3 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
23242 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23243 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
23244 :
23245 3 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23246 3 : ZEND_VM_NEXT_OPCODE();
23247 : }
23248 :
23249 : static int ZEND_IS_NOT_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23250 0 : {
23251 0 : zend_op *opline = EX(opline);
23252 : zend_free_op free_op2;
23253 :
23254 0 : is_not_equal_function(&EX_T(opline->result.u.var).tmp_var,
23255 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23256 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
23257 :
23258 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23259 0 : ZEND_VM_NEXT_OPCODE();
23260 : }
23261 :
23262 : static int ZEND_IS_SMALLER_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23263 0 : {
23264 0 : zend_op *opline = EX(opline);
23265 : zend_free_op free_op2;
23266 :
23267 0 : is_smaller_function(&EX_T(opline->result.u.var).tmp_var,
23268 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23269 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
23270 :
23271 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23272 0 : ZEND_VM_NEXT_OPCODE();
23273 : }
23274 :
23275 : static int ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23276 0 : {
23277 0 : zend_op *opline = EX(opline);
23278 : zend_free_op free_op2;
23279 :
23280 0 : is_smaller_or_equal_function(&EX_T(opline->result.u.var).tmp_var,
23281 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23282 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
23283 :
23284 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23285 0 : ZEND_VM_NEXT_OPCODE();
23286 : }
23287 :
23288 : static int ZEND_BW_OR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23289 0 : {
23290 0 : zend_op *opline = EX(opline);
23291 : zend_free_op free_op2;
23292 :
23293 0 : bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
23294 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23295 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
23296 :
23297 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23298 0 : ZEND_VM_NEXT_OPCODE();
23299 : }
23300 :
23301 : static int ZEND_BW_AND_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23302 0 : {
23303 0 : zend_op *opline = EX(opline);
23304 : zend_free_op free_op2;
23305 :
23306 0 : bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
23307 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23308 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
23309 :
23310 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23311 0 : ZEND_VM_NEXT_OPCODE();
23312 : }
23313 :
23314 : static int ZEND_BW_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23315 0 : {
23316 0 : zend_op *opline = EX(opline);
23317 : zend_free_op free_op2;
23318 :
23319 0 : bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
23320 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23321 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
23322 :
23323 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23324 0 : ZEND_VM_NEXT_OPCODE();
23325 : }
23326 :
23327 : static int ZEND_BOOL_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23328 0 : {
23329 0 : zend_op *opline = EX(opline);
23330 : zend_free_op free_op2;
23331 :
23332 0 : boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
23333 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
23334 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
23335 :
23336 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23337 0 : ZEND_VM_NEXT_OPCODE();
23338 : }
23339 :
23340 : static int zend_binary_assign_op_obj_helper_SPEC_CV_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
23341 0 : {
23342 0 : zend_op *opline = EX(opline);
23343 0 : zend_op *op_data = opline+1;
23344 : zend_free_op free_op2, free_op_data1;
23345 0 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
23346 : zval *object;
23347 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
23348 0 : zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
23349 0 : znode *result = &opline->result;
23350 0 : zval **retval = &EX_T(result->u.var).var.ptr;
23351 0 : int have_get_ptr = 0;
23352 :
23353 0 : EX_T(result->u.var).var.ptr_ptr = NULL;
23354 0 : make_real_object(object_ptr TSRMLS_CC);
23355 0 : object = *object_ptr;
23356 :
23357 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
23358 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
23359 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23360 0 : FREE_OP(free_op_data1);
23361 :
23362 0 : if (!RETURN_VALUE_UNUSED(result)) {
23363 0 : *retval = EG(uninitialized_zval_ptr);
23364 0 : PZVAL_LOCK(*retval);
23365 : }
23366 : } else {
23367 : /* here we are sure we are dealing with an object */
23368 : if (0) {
23369 : MAKE_REAL_ZVAL_PTR(property);
23370 : }
23371 :
23372 : /* here property is a string */
23373 0 : if (opline->extended_value == ZEND_ASSIGN_OBJ
23374 : && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
23375 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
23376 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
23377 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
23378 :
23379 0 : have_get_ptr = 1;
23380 0 : binary_op(*zptr, *zptr, value TSRMLS_CC);
23381 0 : if (!RETURN_VALUE_UNUSED(result)) {
23382 0 : *retval = *zptr;
23383 0 : PZVAL_LOCK(*retval);
23384 : }
23385 : }
23386 : }
23387 :
23388 0 : if (!have_get_ptr) {
23389 0 : zval *z = NULL;
23390 :
23391 0 : switch (opline->extended_value) {
23392 : case ZEND_ASSIGN_OBJ:
23393 0 : if (Z_OBJ_HT_P(object)->read_property) {
23394 0 : z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
23395 : }
23396 0 : break;
23397 : case ZEND_ASSIGN_DIM:
23398 0 : if (Z_OBJ_HT_P(object)->read_dimension) {
23399 0 : z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
23400 : }
23401 : break;
23402 : }
23403 0 : if (z) {
23404 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
23405 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
23406 :
23407 0 : if (z->refcount == 0) {
23408 0 : zval_dtor(z);
23409 0 : FREE_ZVAL(z);
23410 : }
23411 0 : z = value;
23412 : }
23413 0 : z->refcount++;
23414 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
23415 0 : binary_op(z, z, value TSRMLS_CC);
23416 0 : switch (opline->extended_value) {
23417 : case ZEND_ASSIGN_OBJ:
23418 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
23419 0 : break;
23420 : case ZEND_ASSIGN_DIM:
23421 0 : Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
23422 : break;
23423 : }
23424 0 : if (!RETURN_VALUE_UNUSED(result)) {
23425 0 : *retval = z;
23426 0 : PZVAL_LOCK(*retval);
23427 : }
23428 0 : zval_ptr_dtor(&z);
23429 : } else {
23430 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
23431 0 : if (!RETURN_VALUE_UNUSED(result)) {
23432 0 : *retval = EG(uninitialized_zval_ptr);
23433 0 : PZVAL_LOCK(*retval);
23434 : }
23435 : }
23436 : }
23437 :
23438 : if (0) {
23439 : zval_ptr_dtor(&property);
23440 : } else {
23441 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23442 : }
23443 0 : FREE_OP(free_op_data1);
23444 : }
23445 :
23446 : /* assign_obj has two opcodes! */
23447 0 : ZEND_VM_INC_OPCODE();
23448 0 : ZEND_VM_NEXT_OPCODE();
23449 : }
23450 :
23451 : static int zend_binary_assign_op_helper_SPEC_CV_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
23452 5111 : {
23453 5111 : zend_op *opline = EX(opline);
23454 : zend_free_op free_op2, free_op_data2, free_op_data1;
23455 : zval **var_ptr;
23456 : zval *value;
23457 5111 : zend_bool increment_opline = 0;
23458 :
23459 5111 : switch (opline->extended_value) {
23460 : case ZEND_ASSIGN_OBJ:
23461 0 : return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23462 : break;
23463 : case ZEND_ASSIGN_DIM: {
23464 0 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
23465 :
23466 : if (object_ptr && IS_CV != IS_CV && !0) {
23467 : (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
23468 : }
23469 :
23470 0 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
23471 0 : return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23472 : } else {
23473 0 : zend_op *op_data = opline+1;
23474 0 : zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
23475 :
23476 0 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
23477 0 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
23478 0 : var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
23479 0 : increment_opline = 1;
23480 : }
23481 : }
23482 0 : break;
23483 : default:
23484 5111 : value = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
23485 5111 : var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
23486 : /* do nothing */
23487 : break;
23488 : }
23489 :
23490 5111 : if (!var_ptr) {
23491 0 : zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
23492 : }
23493 :
23494 5111 : if (*var_ptr == EG(error_zval_ptr)) {
23495 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
23496 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
23497 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
23498 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
23499 : }
23500 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23501 :
23502 0 : if (increment_opline) {
23503 0 : ZEND_VM_INC_OPCODE();
23504 : }
23505 0 : ZEND_VM_NEXT_OPCODE();
23506 : }
23507 :
23508 5111 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
23509 :
23510 5111 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
23511 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
23512 : /* proxy object */
23513 0 : zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
23514 0 : objval->refcount++;
23515 0 : binary_op(objval, objval, value TSRMLS_CC);
23516 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
23517 0 : zval_ptr_dtor(&objval);
23518 : } else {
23519 5111 : binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
23520 : }
23521 :
23522 5111 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
23523 0 : EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
23524 0 : PZVAL_LOCK(*var_ptr);
23525 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
23526 : }
23527 5111 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23528 :
23529 5111 : if (increment_opline) {
23530 0 : ZEND_VM_INC_OPCODE();
23531 0 : FREE_OP(free_op_data1);
23532 0 : FREE_OP_VAR_PTR(free_op_data2);
23533 : }
23534 :
23535 5111 : ZEND_VM_NEXT_OPCODE();
23536 : }
23537 :
23538 : static int ZEND_ASSIGN_ADD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23539 0 : {
23540 0 : return zend_binary_assign_op_helper_SPEC_CV_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23541 : }
23542 :
23543 : static int ZEND_ASSIGN_SUB_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23544 0 : {
23545 0 : return zend_binary_assign_op_helper_SPEC_CV_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23546 : }
23547 :
23548 : static int ZEND_ASSIGN_MUL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23549 0 : {
23550 0 : return zend_binary_assign_op_helper_SPEC_CV_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23551 : }
23552 :
23553 : static int ZEND_ASSIGN_DIV_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23554 0 : {
23555 0 : return zend_binary_assign_op_helper_SPEC_CV_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23556 : }
23557 :
23558 : static int ZEND_ASSIGN_MOD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23559 0 : {
23560 0 : return zend_binary_assign_op_helper_SPEC_CV_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23561 : }
23562 :
23563 : static int ZEND_ASSIGN_SL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23564 0 : {
23565 0 : return zend_binary_assign_op_helper_SPEC_CV_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23566 : }
23567 :
23568 : static int ZEND_ASSIGN_SR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23569 0 : {
23570 0 : return zend_binary_assign_op_helper_SPEC_CV_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23571 : }
23572 :
23573 : static int ZEND_ASSIGN_CONCAT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23574 5111 : {
23575 5111 : return zend_binary_assign_op_helper_SPEC_CV_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23576 : }
23577 :
23578 : static int ZEND_ASSIGN_BW_OR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23579 0 : {
23580 0 : return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23581 : }
23582 :
23583 : static int ZEND_ASSIGN_BW_AND_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23584 0 : {
23585 0 : return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23586 : }
23587 :
23588 : static int ZEND_ASSIGN_BW_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23589 0 : {
23590 0 : return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23591 : }
23592 :
23593 : static int zend_pre_incdec_property_helper_SPEC_CV_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
23594 0 : {
23595 0 : zend_op *opline = EX(opline);
23596 : zend_free_op free_op2;
23597 0 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
23598 : zval *object;
23599 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
23600 0 : zval **retval = &EX_T(opline->result.u.var).var.ptr;
23601 0 : int have_get_ptr = 0;
23602 :
23603 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
23604 0 : object = *object_ptr;
23605 :
23606 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
23607 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
23608 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23609 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
23610 0 : *retval = EG(uninitialized_zval_ptr);
23611 0 : PZVAL_LOCK(*retval);
23612 : }
23613 :
23614 0 : ZEND_VM_NEXT_OPCODE();
23615 : }
23616 :
23617 : /* here we are sure we are dealing with an object */
23618 :
23619 : if (0) {
23620 : MAKE_REAL_ZVAL_PTR(property);
23621 : }
23622 :
23623 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
23624 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
23625 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
23626 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
23627 :
23628 0 : have_get_ptr = 1;
23629 0 : incdec_op(*zptr);
23630 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
23631 0 : *retval = *zptr;
23632 0 : PZVAL_LOCK(*retval);
23633 : }
23634 : }
23635 : }
23636 :
23637 0 : if (!have_get_ptr) {
23638 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
23639 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
23640 :
23641 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
23642 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
23643 :
23644 0 : if (z->refcount == 0) {
23645 0 : zval_dtor(z);
23646 0 : FREE_ZVAL(z);
23647 : }
23648 0 : z = value;
23649 : }
23650 0 : z->refcount++;
23651 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
23652 0 : incdec_op(z);
23653 0 : *retval = z;
23654 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
23655 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
23656 0 : zval_ptr_dtor(&z);
23657 : } else {
23658 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
23659 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
23660 0 : *retval = EG(uninitialized_zval_ptr);
23661 0 : PZVAL_LOCK(*retval);
23662 : }
23663 : }
23664 : }
23665 :
23666 : if (0) {
23667 : zval_ptr_dtor(&property);
23668 : } else {
23669 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23670 : }
23671 :
23672 0 : ZEND_VM_NEXT_OPCODE();
23673 : }
23674 :
23675 : static int ZEND_PRE_INC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23676 0 : {
23677 0 : return zend_pre_incdec_property_helper_SPEC_CV_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23678 : }
23679 :
23680 : static int ZEND_PRE_DEC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23681 0 : {
23682 0 : return zend_pre_incdec_property_helper_SPEC_CV_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23683 : }
23684 :
23685 : static int zend_post_incdec_property_helper_SPEC_CV_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
23686 0 : {
23687 0 : zend_op *opline = EX(opline);
23688 : zend_free_op free_op2;
23689 0 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
23690 : zval *object;
23691 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
23692 0 : zval *retval = &EX_T(opline->result.u.var).tmp_var;
23693 0 : int have_get_ptr = 0;
23694 :
23695 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
23696 0 : object = *object_ptr;
23697 :
23698 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
23699 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
23700 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23701 0 : *retval = *EG(uninitialized_zval_ptr);
23702 :
23703 0 : ZEND_VM_NEXT_OPCODE();
23704 : }
23705 :
23706 : /* here we are sure we are dealing with an object */
23707 :
23708 : if (0) {
23709 : MAKE_REAL_ZVAL_PTR(property);
23710 : }
23711 :
23712 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
23713 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
23714 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
23715 0 : have_get_ptr = 1;
23716 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
23717 :
23718 0 : *retval = **zptr;
23719 0 : zendi_zval_copy_ctor(*retval);
23720 :
23721 0 : incdec_op(*zptr);
23722 :
23723 : }
23724 : }
23725 :
23726 0 : if (!have_get_ptr) {
23727 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
23728 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
23729 : zval *z_copy;
23730 :
23731 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
23732 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
23733 :
23734 0 : if (z->refcount == 0) {
23735 0 : zval_dtor(z);
23736 0 : FREE_ZVAL(z);
23737 : }
23738 0 : z = value;
23739 : }
23740 0 : *retval = *z;
23741 0 : zendi_zval_copy_ctor(*retval);
23742 0 : ALLOC_ZVAL(z_copy);
23743 0 : *z_copy = *z;
23744 0 : zendi_zval_copy_ctor(*z_copy);
23745 0 : INIT_PZVAL(z_copy);
23746 0 : incdec_op(z_copy);
23747 0 : z->refcount++;
23748 0 : Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
23749 0 : zval_ptr_dtor(&z_copy);
23750 0 : zval_ptr_dtor(&z);
23751 : } else {
23752 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
23753 0 : *retval = *EG(uninitialized_zval_ptr);
23754 : }
23755 : }
23756 :
23757 : if (0) {
23758 : zval_ptr_dtor(&property);
23759 : } else {
23760 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23761 : }
23762 :
23763 0 : ZEND_VM_NEXT_OPCODE();
23764 : }
23765 :
23766 : static int ZEND_POST_INC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23767 0 : {
23768 0 : return zend_post_incdec_property_helper_SPEC_CV_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23769 : }
23770 :
23771 : static int ZEND_POST_DEC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23772 0 : {
23773 0 : return zend_post_incdec_property_helper_SPEC_CV_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23774 : }
23775 :
23776 : static int ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23777 0 : {
23778 0 : zend_op *opline = EX(opline);
23779 : zend_free_op free_op2;
23780 0 : zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
23781 :
23782 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK &&
23783 : IS_CV != IS_CV &&
23784 : EX_T(opline->op1.u.var).var.ptr_ptr) {
23785 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
23786 : }
23787 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC), dim, 0, BP_VAR_R TSRMLS_CC);
23788 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23789 :
23790 0 : ZEND_VM_NEXT_OPCODE();
23791 : }
23792 :
23793 : static int ZEND_FETCH_DIM_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23794 0 : {
23795 0 : zend_op *opline = EX(opline);
23796 : zend_free_op free_op1, free_op2;
23797 0 : zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
23798 :
23799 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC), dim, 0, BP_VAR_W TSRMLS_CC);
23800 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23801 : if (IS_CV == IS_VAR && 0 &&
23802 : READY_TO_DESTROY(free_op1.var) &&
23803 : !RETURN_VALUE_UNUSED(&opline->result)) {
23804 : AI_USE_PTR(EX_T(opline->result.u.var).var);
23805 : }
23806 :
23807 0 : ZEND_VM_NEXT_OPCODE();
23808 : }
23809 :
23810 : static int ZEND_FETCH_DIM_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23811 0 : {
23812 0 : zend_op *opline = EX(opline);
23813 : zend_free_op free_op1, free_op2;
23814 0 : zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
23815 :
23816 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
23817 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23818 : if (IS_CV == IS_VAR && 0 &&
23819 : READY_TO_DESTROY(free_op1.var) &&
23820 : !RETURN_VALUE_UNUSED(&opline->result)) {
23821 : AI_USE_PTR(EX_T(opline->result.u.var).var);
23822 : }
23823 :
23824 0 : ZEND_VM_NEXT_OPCODE();
23825 : }
23826 :
23827 : static int ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23828 0 : {
23829 0 : zend_op *opline = EX(opline);
23830 : zend_free_op free_op2;
23831 0 : zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
23832 :
23833 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC), dim, 0, BP_VAR_IS TSRMLS_CC);
23834 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23835 :
23836 0 : ZEND_VM_NEXT_OPCODE();
23837 : }
23838 :
23839 : static int ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23840 0 : {
23841 0 : zend_op *opline = EX(opline);
23842 : zend_free_op free_op1, free_op2;
23843 0 : int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
23844 : zval *dim;
23845 :
23846 : if (IS_VAR == IS_UNUSED && type == BP_VAR_R) {
23847 : zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
23848 : }
23849 0 : dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
23850 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), type TSRMLS_CC), dim, 0, type TSRMLS_CC);
23851 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23852 : if (IS_CV == IS_VAR && type == BP_VAR_W && 0 &&
23853 : READY_TO_DESTROY(free_op1.var) &&
23854 : !RETURN_VALUE_UNUSED(&opline->result)) {
23855 : AI_USE_PTR(EX_T(opline->result.u.var).var);
23856 : }
23857 :
23858 0 : ZEND_VM_NEXT_OPCODE();
23859 : }
23860 :
23861 : static int ZEND_FETCH_DIM_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23862 0 : {
23863 0 : zend_op *opline = EX(opline);
23864 : zend_free_op free_op1, free_op2;
23865 0 : zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
23866 0 : zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
23867 :
23868 : /* Not needed in DIM_UNSET
23869 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
23870 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
23871 : }
23872 : */
23873 : if (IS_CV == IS_CV) {
23874 0 : if (container != &EG(uninitialized_zval_ptr)) {
23875 0 : SEPARATE_ZVAL_IF_NOT_REF(container);
23876 : }
23877 : }
23878 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_UNSET TSRMLS_CC);
23879 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23880 : if (IS_CV == IS_VAR && 0 &&
23881 : READY_TO_DESTROY(free_op1.var) &&
23882 : !RETURN_VALUE_UNUSED(&opline->result)) {
23883 : AI_USE_PTR(EX_T(opline->result.u.var).var);
23884 : }
23885 :
23886 0 : if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
23887 0 : zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
23888 : } else {
23889 : zend_free_op free_res;
23890 :
23891 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
23892 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
23893 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
23894 : }
23895 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
23896 0 : FREE_OP_VAR_PTR(free_res);
23897 : }
23898 0 : ZEND_VM_NEXT_OPCODE();
23899 : }
23900 :
23901 : static int zend_fetch_property_address_read_helper_SPEC_CV_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
23902 0 : {
23903 0 : zend_op *opline = EX(opline);
23904 : zval *container;
23905 : zval **retval;
23906 :
23907 :
23908 0 : retval = &EX_T(opline->result.u.var).var.ptr;
23909 0 : EX_T(opline->result.u.var).var.ptr_ptr = retval;
23910 :
23911 0 : container = _get_zval_ptr_cv(&opline->op1, EX(Ts), type TSRMLS_CC);
23912 :
23913 0 : if (container == EG(error_zval_ptr)) {
23914 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
23915 0 : *retval = EG(error_zval_ptr);
23916 0 : PZVAL_LOCK(*retval);
23917 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
23918 : }
23919 :
23920 0 : ZEND_VM_NEXT_OPCODE();
23921 : }
23922 :
23923 :
23924 0 : if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
23925 0 : if (type != BP_VAR_IS) {
23926 0 : zend_error(E_NOTICE, "Trying to get property of non-object");
23927 : }
23928 0 : *retval = EG(uninitialized_zval_ptr);
23929 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
23930 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
23931 : } else {
23932 : zend_free_op free_op2;
23933 0 : zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
23934 :
23935 : if (0) {
23936 : MAKE_REAL_ZVAL_PTR(offset);
23937 : }
23938 :
23939 : /* here we are sure we are dealing with an object */
23940 0 : *retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
23941 :
23942 0 : if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
23943 0 : zval_dtor(*retval);
23944 0 : FREE_ZVAL(*retval);
23945 : } else {
23946 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
23947 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
23948 : }
23949 :
23950 : if (0) {
23951 : zval_ptr_dtor(&offset);
23952 : } else {
23953 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23954 : }
23955 : }
23956 :
23957 0 : ZEND_VM_NEXT_OPCODE();
23958 : }
23959 :
23960 : static int ZEND_FETCH_OBJ_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23961 0 : {
23962 0 : return zend_fetch_property_address_read_helper_SPEC_CV_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23963 : }
23964 :
23965 : static int ZEND_FETCH_OBJ_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23966 0 : {
23967 0 : zend_op *opline = EX(opline);
23968 : zend_free_op free_op1, free_op2;
23969 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
23970 :
23971 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_CV != IS_CV) {
23972 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
23973 : EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
23974 : }
23975 :
23976 : if (0) {
23977 : MAKE_REAL_ZVAL_PTR(property);
23978 : }
23979 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
23980 : if (0) {
23981 : zval_ptr_dtor(&property);
23982 : } else {
23983 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
23984 : }
23985 : if (IS_CV == IS_VAR && 0 &&
23986 : READY_TO_DESTROY(free_op1.var) &&
23987 : !RETURN_VALUE_UNUSED(&opline->result)) {
23988 : AI_USE_PTR(EX_T(opline->result.u.var).var);
23989 : }
23990 :
23991 0 : ZEND_VM_NEXT_OPCODE();
23992 : }
23993 :
23994 : static int ZEND_FETCH_OBJ_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23995 0 : {
23996 0 : zend_op *opline = EX(opline);
23997 : zend_free_op free_op1, free_op2;
23998 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
23999 :
24000 : if (0) {
24001 : MAKE_REAL_ZVAL_PTR(property);
24002 : }
24003 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC), property, BP_VAR_RW TSRMLS_CC);
24004 : if (0) {
24005 : zval_ptr_dtor(&property);
24006 : } else {
24007 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
24008 : }
24009 : if (IS_CV == IS_VAR && 0 &&
24010 : READY_TO_DESTROY(free_op1.var) &&
24011 : !RETURN_VALUE_UNUSED(&opline->result)) {
24012 : AI_USE_PTR(EX_T(opline->result.u.var).var);
24013 : }
24014 :
24015 0 : ZEND_VM_NEXT_OPCODE();
24016 : }
24017 :
24018 : static int ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24019 0 : {
24020 0 : return zend_fetch_property_address_read_helper_SPEC_CV_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24021 : }
24022 :
24023 : static int ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24024 0 : {
24025 0 : zend_op *opline = EX(opline);
24026 :
24027 0 : if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
24028 : /* Behave like FETCH_OBJ_W */
24029 : zend_free_op free_op1, free_op2;
24030 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
24031 :
24032 : if (0) {
24033 : MAKE_REAL_ZVAL_PTR(property);
24034 : }
24035 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
24036 : if (0) {
24037 : zval_ptr_dtor(&property);
24038 : } else {
24039 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
24040 : }
24041 : if (IS_CV == IS_VAR && 0 &&
24042 : READY_TO_DESTROY(free_op1.var) &&
24043 : !RETURN_VALUE_UNUSED(&opline->result)) {
24044 : AI_USE_PTR(EX_T(opline->result.u.var).var);
24045 : }
24046 :
24047 0 : ZEND_VM_NEXT_OPCODE();
24048 : } else {
24049 0 : return zend_fetch_property_address_read_helper_SPEC_CV_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24050 : }
24051 : }
24052 :
24053 : static int ZEND_FETCH_OBJ_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24054 0 : {
24055 0 : zend_op *opline = EX(opline);
24056 : zend_free_op free_op1, free_op2, free_res;
24057 0 : zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
24058 0 : zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
24059 :
24060 : if (IS_CV == IS_CV) {
24061 0 : if (container != &EG(uninitialized_zval_ptr)) {
24062 0 : SEPARATE_ZVAL_IF_NOT_REF(container);
24063 : }
24064 : }
24065 : if (0) {
24066 : MAKE_REAL_ZVAL_PTR(property);
24067 : }
24068 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
24069 : if (0) {
24070 : zval_ptr_dtor(&property);
24071 : } else {
24072 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
24073 : }
24074 : if (IS_CV == IS_VAR && 0 &&
24075 : READY_TO_DESTROY(free_op1.var) &&
24076 : !RETURN_VALUE_UNUSED(&opline->result)) {
24077 : AI_USE_PTR(EX_T(opline->result.u.var).var);
24078 : }
24079 :
24080 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
24081 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
24082 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
24083 : }
24084 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
24085 0 : FREE_OP_VAR_PTR(free_res);
24086 0 : ZEND_VM_NEXT_OPCODE();
24087 : }
24088 :
24089 : static int ZEND_ASSIGN_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24090 0 : {
24091 0 : zend_op *opline = EX(opline);
24092 0 : zend_op *op_data = opline+1;
24093 :
24094 0 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
24095 :
24096 0 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
24097 :
24098 : /* assign_obj has two opcodes! */
24099 0 : ZEND_VM_INC_OPCODE();
24100 0 : ZEND_VM_NEXT_OPCODE();
24101 : }
24102 :
24103 : static int ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24104 41 : {
24105 41 : zend_op *opline = EX(opline);
24106 41 : zend_op *op_data = opline+1;
24107 :
24108 : zval **object_ptr;
24109 :
24110 : if (IS_CV == IS_CV || EX_T(opline->op1.u.var).var.ptr_ptr) {
24111 : /* not an array offset */
24112 41 : object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
24113 : } else {
24114 : object_ptr = NULL;
24115 : }
24116 :
24117 41 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
24118 0 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
24119 : } else {
24120 : zend_free_op free_op2, free_op_data1;
24121 : zval *value;
24122 41 : zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
24123 :
24124 41 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
24125 41 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
24126 :
24127 41 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
24128 41 : zend_assign_to_variable(&opline->result, &op_data->op2, &op_data->op1, value, (IS_TMP_FREE(free_op_data1)?IS_TMP_VAR:op_data->op1.op_type), EX(Ts) TSRMLS_CC);
24129 41 : FREE_OP_IF_VAR(free_op_data1);
24130 : }
24131 :
24132 : /* assign_dim has two opcodes! */
24133 41 : ZEND_VM_INC_OPCODE();
24134 41 : ZEND_VM_NEXT_OPCODE();
24135 : }
24136 :
24137 : static int ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24138 39515 : {
24139 39515 : zend_op *opline = EX(opline);
24140 : zend_free_op free_op2;
24141 39515 : zval *value = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
24142 :
24143 39515 : zend_assign_to_variable(&opline->result, &opline->op1, &opline->op2, value, (0?IS_TMP_VAR:IS_VAR), EX(Ts) TSRMLS_CC);
24144 : /* zend_assign_to_variable() always takes care of op2, never free it! */
24145 39515 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
24146 :
24147 39515 : ZEND_VM_NEXT_OPCODE();
24148 : }
24149 :
24150 : static int ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24151 3605 : {
24152 3605 : zend_op *opline = EX(opline);
24153 : zend_free_op free_op2;
24154 : zval **variable_ptr_ptr;
24155 3605 : zval **value_ptr_ptr = _get_zval_ptr_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
24156 :
24157 3605 : if (IS_VAR == IS_VAR &&
24158 : value_ptr_ptr &&
24159 : !(*value_ptr_ptr)->is_ref &&
24160 : opline->extended_value == ZEND_RETURNS_FUNCTION &&
24161 : !EX_T(opline->op2.u.var).var.fcall_returned_reference) {
24162 0 : if (free_op2.var == NULL) {
24163 0 : PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
24164 : }
24165 0 : zend_error(E_STRICT, "Only variables should be assigned by reference");
24166 0 : return ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24167 : }
24168 : if (IS_CV == IS_VAR && EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
24169 : zend_error(E_ERROR, "Cannot assign by reference to overloaded object");
24170 : }
24171 :
24172 3605 : variable_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
24173 3605 : zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
24174 :
24175 3605 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
24176 0 : EX_T(opline->result.u.var).var.ptr_ptr = variable_ptr_ptr;
24177 0 : PZVAL_LOCK(*variable_ptr_ptr);
24178 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
24179 : }
24180 :
24181 3605 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
24182 :
24183 3605 : ZEND_VM_NEXT_OPCODE();
24184 : }
24185 :
24186 : static int ZEND_INIT_METHOD_CALL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24187 0 : {
24188 0 : zend_op *opline = EX(opline);
24189 : zval *function_name;
24190 : char *function_name_strval;
24191 : int function_name_strlen;
24192 : zend_free_op free_op2;
24193 :
24194 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
24195 :
24196 0 : function_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
24197 :
24198 0 : if (Z_TYPE_P(function_name)!=IS_STRING) {
24199 0 : zend_error_noreturn(E_ERROR, "Method name must be a string");
24200 : }
24201 :
24202 0 : function_name_strval = Z_STRVAL_P(function_name);
24203 0 : function_name_strlen = Z_STRLEN_P(function_name);
24204 :
24205 0 : EX(object) = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
24206 :
24207 0 : if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
24208 0 : if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
24209 0 : zend_error_noreturn(E_ERROR, "Object does not support method calls");
24210 : }
24211 :
24212 : /* First, locate the function. */
24213 0 : EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
24214 0 : if (!EX(fbc)) {
24215 0 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
24216 : }
24217 : } else {
24218 0 : zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
24219 : }
24220 :
24221 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
24222 0 : EX(object) = NULL;
24223 : } else {
24224 0 : if (!PZVAL_IS_REF(EX(object))) {
24225 0 : EX(object)->refcount++; /* For $this pointer */
24226 : } else {
24227 : zval *this_ptr;
24228 0 : ALLOC_ZVAL(this_ptr);
24229 0 : INIT_PZVAL_COPY(this_ptr, EX(object));
24230 0 : zval_copy_ctor(this_ptr);
24231 0 : EX(object) = this_ptr;
24232 : }
24233 : }
24234 :
24235 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
24236 :
24237 0 : ZEND_VM_NEXT_OPCODE();
24238 : }
24239 :
24240 : static int ZEND_CASE_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24241 0 : {
24242 0 : zend_op *opline = EX(opline);
24243 0 : int switch_expr_is_overloaded=0;
24244 : zend_free_op free_op2;
24245 :
24246 : if (IS_CV==IS_VAR) {
24247 : if (EX_T(opline->op1.u.var).var.ptr_ptr) {
24248 : PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
24249 : } else {
24250 : switch_expr_is_overloaded = 1;
24251 : EX_T(opline->op1.u.var).str_offset.str->refcount++;
24252 : }
24253 : }
24254 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
24255 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
24256 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
24257 :
24258 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
24259 0 : if (switch_expr_is_overloaded) {
24260 : /* We only free op1 if this is a string offset,
24261 : * Since if it is a TMP_VAR, it'll be reused by
24262 : * other CASE opcodes (whereas string offsets
24263 : * are allocated at each get_zval_ptr())
24264 : */
24265 :
24266 0 : EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
24267 0 : AI_USE_PTR(EX_T(opline->op1.u.var).var);
24268 : }
24269 0 : ZEND_VM_NEXT_OPCODE();
24270 : }
24271 :
24272 : static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24273 0 : {
24274 0 : zend_op *opline = EX(opline);
24275 : zend_free_op free_op2;
24276 0 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
24277 : zval *expr_ptr;
24278 0 : zval *offset=_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
24279 :
24280 : #if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
24281 0 : zval **expr_ptr_ptr = NULL;
24282 :
24283 0 : if (opline->extended_value) {
24284 0 : expr_ptr_ptr=_get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
24285 0 : expr_ptr = *expr_ptr_ptr;
24286 : } else {
24287 0 : expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
24288 : }
24289 : #else
24290 : expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
24291 : #endif
24292 :
24293 : if (0) { /* temporary variable */
24294 : zval *new_expr;
24295 :
24296 : ALLOC_ZVAL(new_expr);
24297 : INIT_PZVAL_COPY(new_expr, expr_ptr);
24298 : expr_ptr = new_expr;
24299 : } else {
24300 : #if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
24301 0 : if (opline->extended_value) {
24302 0 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
24303 0 : expr_ptr = *expr_ptr_ptr;
24304 0 : expr_ptr->refcount++;
24305 : } else
24306 : #endif
24307 0 : if (PZVAL_IS_REF(expr_ptr)) {
24308 : zval *new_expr;
24309 :
24310 0 : ALLOC_ZVAL(new_expr);
24311 0 : INIT_PZVAL_COPY(new_expr, expr_ptr);
24312 0 : expr_ptr = new_expr;
24313 0 : zendi_zval_copy_ctor(*expr_ptr);
24314 : } else {
24315 0 : expr_ptr->refcount++;
24316 : }
24317 : }
24318 0 : if (offset) {
24319 0 : switch (Z_TYPE_P(offset)) {
24320 : case IS_DOUBLE:
24321 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
24322 0 : break;
24323 : case IS_LONG:
24324 : case IS_BOOL:
24325 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
24326 0 : break;
24327 : case IS_STRING:
24328 0 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
24329 0 : break;
24330 : case IS_NULL:
24331 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
24332 0 : break;
24333 : default:
24334 0 : zend_error(E_WARNING, "Illegal offset type");
24335 0 : zval_ptr_dtor(&expr_ptr);
24336 : /* do nothing */
24337 : break;
24338 : }
24339 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
24340 : } else {
24341 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
24342 : }
24343 0 : if (opline->extended_value) {
24344 :
24345 : } else {
24346 :
24347 : }
24348 0 : ZEND_VM_NEXT_OPCODE();
24349 : }
24350 :
24351 : static int ZEND_INIT_ARRAY_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24352 0 : {
24353 0 : zend_op *opline = EX(opline);
24354 :
24355 0 : array_init(&EX_T(opline->result.u.var).tmp_var);
24356 : if (IS_CV == IS_UNUSED) {
24357 : ZEND_VM_NEXT_OPCODE();
24358 : #if 0 || IS_CV != IS_UNUSED
24359 : } else {
24360 0 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24361 : #endif
24362 : }
24363 : }
24364 :
24365 : static int ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24366 0 : {
24367 0 : zend_op *opline = EX(opline);
24368 : zend_free_op free_op2;
24369 0 : zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
24370 0 : zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
24371 : long index;
24372 :
24373 0 : if (container) {
24374 0 : if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
24375 0 : SEPARATE_ZVAL_IF_NOT_REF(container);
24376 : }
24377 0 : switch (Z_TYPE_PP(container)) {
24378 : case IS_ARRAY: {
24379 0 : HashTable *ht = Z_ARRVAL_PP(container);
24380 :
24381 0 : switch (Z_TYPE_P(offset)) {
24382 : case IS_DOUBLE:
24383 0 : index = (long) Z_DVAL_P(offset);
24384 0 : zend_hash_index_del(ht, index);
24385 0 : break;
24386 : case IS_RESOURCE:
24387 : case IS_BOOL:
24388 : case IS_LONG:
24389 0 : index = Z_LVAL_P(offset);
24390 0 : zend_hash_index_del(ht, index);
24391 0 : break;
24392 : case IS_STRING:
24393 : if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
24394 0 : offset->refcount++;
24395 : }
24396 0 : if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
24397 : ht == &EG(symbol_table)) {
24398 : zend_execute_data *ex;
24399 0 : ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
24400 :
24401 0 : for (ex = execute_data; ex; ex = ex->prev_execute_data) {
24402 0 : if (ex->op_array && ex->symbol_table == ht) {
24403 : int i;
24404 :
24405 0 : for (i = 0; i < ex->op_array->last_var; i++) {
24406 0 : if (ex->op_array->vars[i].hash_value == hash_value &&
24407 : ex->op_array->vars[i].name_len == offset->value.str.len &&
24408 : !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
24409 0 : ex->CVs[i] = NULL;
24410 0 : break;
24411 : }
24412 : }
24413 : }
24414 : }
24415 : }
24416 : if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
24417 0 : zval_ptr_dtor(&offset);
24418 : }
24419 0 : break;
24420 : case IS_NULL:
24421 0 : zend_hash_del(ht, "", sizeof(""));
24422 0 : break;
24423 : default:
24424 0 : zend_error(E_WARNING, "Illegal offset type in unset");
24425 : break;
24426 : }
24427 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
24428 0 : break;
24429 : }
24430 : case IS_OBJECT:
24431 0 : if (!Z_OBJ_HT_P(*container)->unset_dimension) {
24432 0 : zend_error_noreturn(E_ERROR, "Cannot use object as array");
24433 : }
24434 : if (0) {
24435 : MAKE_REAL_ZVAL_PTR(offset);
24436 : }
24437 0 : Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
24438 : if (0) {
24439 : zval_ptr_dtor(&offset);
24440 : } else {
24441 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
24442 : }
24443 0 : break;
24444 : case IS_STRING:
24445 0 : zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
24446 : ZEND_VM_CONTINUE(); /* bailed out before */
24447 : default:
24448 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
24449 : break;
24450 : }
24451 : } else {
24452 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
24453 : }
24454 :
24455 0 : ZEND_VM_NEXT_OPCODE();
24456 : }
24457 :
24458 : static int ZEND_UNSET_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24459 0 : {
24460 0 : zend_op *opline = EX(opline);
24461 : zend_free_op free_op2;
24462 0 : zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
24463 0 : zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
24464 :
24465 0 : if (container) {
24466 0 : if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
24467 0 : SEPARATE_ZVAL_IF_NOT_REF(container);
24468 : }
24469 0 : if (Z_TYPE_PP(container) == IS_OBJECT) {
24470 : if (0) {
24471 : MAKE_REAL_ZVAL_PTR(offset);
24472 : }
24473 0 : Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
24474 : if (0) {
24475 : zval_ptr_dtor(&offset);
24476 : } else {
24477 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
24478 : }
24479 : } else {
24480 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
24481 : }
24482 : } else {
24483 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
24484 : }
24485 :
24486 0 : ZEND_VM_NEXT_OPCODE();
24487 : }
24488 :
24489 : static int zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
24490 7 : {
24491 7 : zend_op *opline = EX(opline);
24492 :
24493 7 : zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
24494 7 : zval **value = NULL;
24495 7 : int result = 0;
24496 : long index;
24497 :
24498 7 : if (container) {
24499 : zend_free_op free_op2;
24500 7 : zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
24501 :
24502 7 : if (Z_TYPE_PP(container) == IS_ARRAY) {
24503 : HashTable *ht;
24504 7 : int isset = 0;
24505 :
24506 7 : ht = Z_ARRVAL_PP(container);
24507 :
24508 7 : switch (Z_TYPE_P(offset)) {
24509 : case IS_DOUBLE:
24510 0 : index = (long) Z_DVAL_P(offset);
24511 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
24512 0 : isset = 1;
24513 : }
24514 0 : break;
24515 : case IS_RESOURCE:
24516 : case IS_BOOL:
24517 : case IS_LONG:
24518 0 : index = Z_LVAL_P(offset);
24519 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
24520 0 : isset = 1;
24521 : }
24522 0 : break;
24523 : case IS_STRING:
24524 7 : if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
24525 5 : isset = 1;
24526 : }
24527 7 : break;
24528 : case IS_NULL:
24529 0 : if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
24530 0 : isset = 1;
24531 : }
24532 0 : break;
24533 : default:
24534 0 : zend_error(E_WARNING, "Illegal offset type in isset or empty");
24535 :
24536 : break;
24537 : }
24538 :
24539 7 : switch (opline->extended_value) {
24540 : case ZEND_ISSET:
24541 0 : if (isset && Z_TYPE_PP(value) == IS_NULL) {
24542 0 : result = 0;
24543 : } else {
24544 0 : result = isset;
24545 : }
24546 0 : break;
24547 : case ZEND_ISEMPTY:
24548 9 : if (!isset || !i_zend_is_true(*value)) {
24549 2 : result = 0;
24550 : } else {
24551 5 : result = 1;
24552 : }
24553 : break;
24554 : }
24555 7 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
24556 0 : } else if (Z_TYPE_PP(container) == IS_OBJECT) {
24557 : if (0) {
24558 : MAKE_REAL_ZVAL_PTR(offset);
24559 : }
24560 0 : if (prop_dim) {
24561 0 : result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
24562 : } else {
24563 0 : result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
24564 : }
24565 : if (0) {
24566 : zval_ptr_dtor(&offset);
24567 : } else {
24568 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
24569 : }
24570 0 : } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
24571 : zval tmp;
24572 :
24573 0 : if (Z_TYPE_P(offset) != IS_LONG) {
24574 0 : tmp = *offset;
24575 0 : zval_copy_ctor(&tmp);
24576 0 : convert_to_long(&tmp);
24577 0 : offset = &tmp;
24578 : }
24579 0 : if (Z_TYPE_P(offset) == IS_LONG) {
24580 0 : switch (opline->extended_value) {
24581 : case ZEND_ISSET:
24582 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
24583 0 : result = 1;
24584 : }
24585 0 : break;
24586 : case ZEND_ISEMPTY:
24587 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
24588 0 : result = 1;
24589 : }
24590 : break;
24591 : }
24592 : }
24593 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
24594 : } else {
24595 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
24596 : }
24597 : }
24598 :
24599 7 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
24600 :
24601 7 : switch (opline->extended_value) {
24602 : case ZEND_ISSET:
24603 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
24604 0 : break;
24605 : case ZEND_ISEMPTY:
24606 7 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
24607 : break;
24608 : }
24609 :
24610 7 : ZEND_VM_NEXT_OPCODE();
24611 : }
24612 :
24613 : static int ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24614 7 : {
24615 7 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24616 : }
24617 :
24618 : static int ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24619 0 : {
24620 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24621 : }
24622 :
24623 : static int zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
24624 0 : {
24625 0 : zend_op *opline = EX(opline);
24626 0 : zend_op *op_data = opline+1;
24627 : zend_free_op free_op_data1;
24628 0 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
24629 : zval *object;
24630 0 : zval *property = NULL;
24631 0 : zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
24632 0 : znode *result = &opline->result;
24633 0 : zval **retval = &EX_T(result->u.var).var.ptr;
24634 0 : int have_get_ptr = 0;
24635 :
24636 0 : EX_T(result->u.var).var.ptr_ptr = NULL;
24637 0 : make_real_object(object_ptr TSRMLS_CC);
24638 0 : object = *object_ptr;
24639 :
24640 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
24641 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
24642 :
24643 0 : FREE_OP(free_op_data1);
24644 :
24645 0 : if (!RETURN_VALUE_UNUSED(result)) {
24646 0 : *retval = EG(uninitialized_zval_ptr);
24647 0 : PZVAL_LOCK(*retval);
24648 : }
24649 : } else {
24650 : /* here we are sure we are dealing with an object */
24651 : if (0) {
24652 : MAKE_REAL_ZVAL_PTR(property);
24653 : }
24654 :
24655 : /* here property is a string */
24656 0 : if (opline->extended_value == ZEND_ASSIGN_OBJ
24657 : && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
24658 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
24659 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
24660 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
24661 :
24662 0 : have_get_ptr = 1;
24663 0 : binary_op(*zptr, *zptr, value TSRMLS_CC);
24664 0 : if (!RETURN_VALUE_UNUSED(result)) {
24665 0 : *retval = *zptr;
24666 0 : PZVAL_LOCK(*retval);
24667 : }
24668 : }
24669 : }
24670 :
24671 0 : if (!have_get_ptr) {
24672 0 : zval *z = NULL;
24673 :
24674 0 : switch (opline->extended_value) {
24675 : case ZEND_ASSIGN_OBJ:
24676 0 : if (Z_OBJ_HT_P(object)->read_property) {
24677 0 : z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
24678 : }
24679 0 : break;
24680 : case ZEND_ASSIGN_DIM:
24681 0 : if (Z_OBJ_HT_P(object)->read_dimension) {
24682 0 : z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
24683 : }
24684 : break;
24685 : }
24686 0 : if (z) {
24687 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
24688 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
24689 :
24690 0 : if (z->refcount == 0) {
24691 0 : zval_dtor(z);
24692 0 : FREE_ZVAL(z);
24693 : }
24694 0 : z = value;
24695 : }
24696 0 : z->refcount++;
24697 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
24698 0 : binary_op(z, z, value TSRMLS_CC);
24699 0 : switch (opline->extended_value) {
24700 : case ZEND_ASSIGN_OBJ:
24701 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
24702 0 : break;
24703 : case ZEND_ASSIGN_DIM:
24704 0 : Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
24705 : break;
24706 : }
24707 0 : if (!RETURN_VALUE_UNUSED(result)) {
24708 0 : *retval = z;
24709 0 : PZVAL_LOCK(*retval);
24710 : }
24711 0 : zval_ptr_dtor(&z);
24712 : } else {
24713 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
24714 0 : if (!RETURN_VALUE_UNUSED(result)) {
24715 0 : *retval = EG(uninitialized_zval_ptr);
24716 0 : PZVAL_LOCK(*retval);
24717 : }
24718 : }
24719 : }
24720 :
24721 : if (0) {
24722 : zval_ptr_dtor(&property);
24723 : } else {
24724 :
24725 : }
24726 0 : FREE_OP(free_op_data1);
24727 : }
24728 :
24729 : /* assign_obj has two opcodes! */
24730 0 : ZEND_VM_INC_OPCODE();
24731 0 : ZEND_VM_NEXT_OPCODE();
24732 : }
24733 :
24734 : static int zend_binary_assign_op_helper_SPEC_CV_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
24735 0 : {
24736 0 : zend_op *opline = EX(opline);
24737 : zend_free_op free_op_data2, free_op_data1;
24738 : zval **var_ptr;
24739 : zval *value;
24740 0 : zend_bool increment_opline = 0;
24741 :
24742 0 : switch (opline->extended_value) {
24743 : case ZEND_ASSIGN_OBJ:
24744 0 : return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24745 : break;
24746 : case ZEND_ASSIGN_DIM: {
24747 0 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
24748 :
24749 : if (object_ptr && IS_CV != IS_CV && !0) {
24750 : (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
24751 : }
24752 :
24753 0 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
24754 0 : return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24755 : } else {
24756 0 : zend_op *op_data = opline+1;
24757 0 : zval *dim = NULL;
24758 :
24759 0 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
24760 0 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
24761 0 : var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
24762 0 : increment_opline = 1;
24763 : }
24764 : }
24765 0 : break;
24766 : default:
24767 0 : value = NULL;
24768 0 : var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
24769 : /* do nothing */
24770 : break;
24771 : }
24772 :
24773 0 : if (!var_ptr) {
24774 0 : zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
24775 : }
24776 :
24777 0 : if (*var_ptr == EG(error_zval_ptr)) {
24778 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
24779 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
24780 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
24781 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
24782 : }
24783 :
24784 :
24785 0 : if (increment_opline) {
24786 0 : ZEND_VM_INC_OPCODE();
24787 : }
24788 0 : ZEND_VM_NEXT_OPCODE();
24789 : }
24790 :
24791 0 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
24792 :
24793 0 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
24794 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
24795 : /* proxy object */
24796 0 : zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
24797 0 : objval->refcount++;
24798 0 : binary_op(objval, objval, value TSRMLS_CC);
24799 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
24800 0 : zval_ptr_dtor(&objval);
24801 : } else {
24802 0 : binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
24803 : }
24804 :
24805 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
24806 0 : EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
24807 0 : PZVAL_LOCK(*var_ptr);
24808 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
24809 : }
24810 :
24811 0 : if (increment_opline) {
24812 0 : ZEND_VM_INC_OPCODE();
24813 0 : FREE_OP(free_op_data1);
24814 0 : FREE_OP_VAR_PTR(free_op_data2);
24815 : }
24816 :
24817 0 : ZEND_VM_NEXT_OPCODE();
24818 : }
24819 :
24820 : static int ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24821 0 : {
24822 0 : return zend_binary_assign_op_helper_SPEC_CV_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24823 : }
24824 :
24825 : static int ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24826 0 : {
24827 0 : return zend_binary_assign_op_helper_SPEC_CV_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24828 : }
24829 :
24830 : static int ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24831 0 : {
24832 0 : return zend_binary_assign_op_helper_SPEC_CV_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24833 : }
24834 :
24835 : static int ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24836 0 : {
24837 0 : return zend_binary_assign_op_helper_SPEC_CV_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24838 : }
24839 :
24840 : static int ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24841 0 : {
24842 0 : return zend_binary_assign_op_helper_SPEC_CV_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24843 : }
24844 :
24845 : static int ZEND_ASSIGN_SL_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24846 0 : {
24847 0 : return zend_binary_assign_op_helper_SPEC_CV_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24848 : }
24849 :
24850 : static int ZEND_ASSIGN_SR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24851 0 : {
24852 0 : return zend_binary_assign_op_helper_SPEC_CV_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24853 : }
24854 :
24855 : static int ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24856 0 : {
24857 0 : return zend_binary_assign_op_helper_SPEC_CV_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24858 : }
24859 :
24860 : static int ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24861 0 : {
24862 0 : return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24863 : }
24864 :
24865 : static int ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24866 0 : {
24867 0 : return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24868 : }
24869 :
24870 : static int ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24871 0 : {
24872 0 : return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24873 : }
24874 :
24875 : static int ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24876 2 : {
24877 2 : zend_op *opline = EX(opline);
24878 : zend_free_op free_op1;
24879 2 : zval *dim = NULL;
24880 :
24881 2 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC), dim, 0, BP_VAR_W TSRMLS_CC);
24882 :
24883 : if (IS_CV == IS_VAR && 0 &&
24884 : READY_TO_DESTROY(free_op1.var) &&
24885 : !RETURN_VALUE_UNUSED(&opline->result)) {
24886 : AI_USE_PTR(EX_T(opline->result.u.var).var);
24887 : }
24888 :
24889 2 : ZEND_VM_NEXT_OPCODE();
24890 : }
24891 :
24892 : static int ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24893 0 : {
24894 0 : zend_op *opline = EX(opline);
24895 : zend_free_op free_op1;
24896 0 : zval *dim = NULL;
24897 :
24898 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
24899 :
24900 : if (IS_CV == IS_VAR && 0 &&
24901 : READY_TO_DESTROY(free_op1.var) &&
24902 : !RETURN_VALUE_UNUSED(&opline->result)) {
24903 : AI_USE_PTR(EX_T(opline->result.u.var).var);
24904 : }
24905 :
24906 0 : ZEND_VM_NEXT_OPCODE();
24907 : }
24908 :
24909 : static int ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24910 0 : {
24911 0 : zend_op *opline = EX(opline);
24912 : zend_free_op free_op1;
24913 0 : int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
24914 : zval *dim;
24915 :
24916 0 : if (IS_UNUSED == IS_UNUSED && type == BP_VAR_R) {
24917 0 : zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
24918 : }
24919 0 : dim = NULL;
24920 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), type TSRMLS_CC), dim, 0, type TSRMLS_CC);
24921 :
24922 : if (IS_CV == IS_VAR && type == BP_VAR_W && 0 &&
24923 : READY_TO_DESTROY(free_op1.var) &&
24924 : !RETURN_VALUE_UNUSED(&opline->result)) {
24925 : AI_USE_PTR(EX_T(opline->result.u.var).var);
24926 : }
24927 :
24928 0 : ZEND_VM_NEXT_OPCODE();
24929 : }
24930 :
24931 : static int ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24932 186 : {
24933 186 : zend_op *opline = EX(opline);
24934 186 : zend_op *op_data = opline+1;
24935 :
24936 : zval **object_ptr;
24937 :
24938 : if (IS_CV == IS_CV || EX_T(opline->op1.u.var).var.ptr_ptr) {
24939 : /* not an array offset */
24940 186 : object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
24941 : } else {
24942 : object_ptr = NULL;
24943 : }
24944 :
24945 186 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
24946 0 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
24947 : } else {
24948 : zend_free_op free_op_data1;
24949 : zval *value;
24950 186 : zval *dim = NULL;
24951 :
24952 186 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
24953 :
24954 186 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
24955 186 : zend_assign_to_variable(&opline->result, &op_data->op2, &op_data->op1, value, (IS_TMP_FREE(free_op_data1)?IS_TMP_VAR:op_data->op1.op_type), EX(Ts) TSRMLS_CC);
24956 186 : FREE_OP_IF_VAR(free_op_data1);
24957 : }
24958 :
24959 : /* assign_dim has two opcodes! */
24960 186 : ZEND_VM_INC_OPCODE();
24961 186 : ZEND_VM_NEXT_OPCODE();
24962 : }
24963 :
24964 : static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24965 2 : {
24966 2 : zend_op *opline = EX(opline);
24967 :
24968 2 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
24969 : zval *expr_ptr;
24970 2 : zval *offset=NULL;
24971 :
24972 : #if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
24973 2 : zval **expr_ptr_ptr = NULL;
24974 :
24975 2 : if (opline->extended_value) {
24976 0 : expr_ptr_ptr=_get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
24977 0 : expr_ptr = *expr_ptr_ptr;
24978 : } else {
24979 2 : expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
24980 : }
24981 : #else
24982 : expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
24983 : #endif
24984 :
24985 : if (0) { /* temporary variable */
24986 : zval *new_expr;
24987 :
24988 : ALLOC_ZVAL(new_expr);
24989 : INIT_PZVAL_COPY(new_expr, expr_ptr);
24990 : expr_ptr = new_expr;
24991 : } else {
24992 : #if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
24993 2 : if (opline->extended_value) {
24994 0 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
24995 0 : expr_ptr = *expr_ptr_ptr;
24996 0 : expr_ptr->refcount++;
24997 : } else
24998 : #endif
24999 2 : if (PZVAL_IS_REF(expr_ptr)) {
25000 : zval *new_expr;
25001 :
25002 0 : ALLOC_ZVAL(new_expr);
25003 0 : INIT_PZVAL_COPY(new_expr, expr_ptr);
25004 0 : expr_ptr = new_expr;
25005 0 : zendi_zval_copy_ctor(*expr_ptr);
25006 : } else {
25007 2 : expr_ptr->refcount++;
25008 : }
25009 : }
25010 2 : if (offset) {
25011 0 : switch (Z_TYPE_P(offset)) {
25012 : case IS_DOUBLE:
25013 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
25014 0 : break;
25015 : case IS_LONG:
25016 : case IS_BOOL:
25017 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
25018 0 : break;
25019 : case IS_STRING:
25020 0 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
25021 0 : break;
25022 : case IS_NULL:
25023 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
25024 0 : break;
25025 : default:
25026 0 : zend_error(E_WARNING, "Illegal offset type");
25027 0 : zval_ptr_dtor(&expr_ptr);
25028 : /* do nothing */
25029 : break;
25030 : }
25031 :
25032 : } else {
25033 2 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
25034 : }
25035 2 : if (opline->extended_value) {
25036 :
25037 : } else {
25038 :
25039 : }
25040 2 : ZEND_VM_NEXT_OPCODE();
25041 : }
25042 :
25043 : static int ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25044 1 : {
25045 1 : zend_op *opline = EX(opline);
25046 :
25047 1 : array_init(&EX_T(opline->result.u.var).tmp_var);
25048 : if (IS_CV == IS_UNUSED) {
25049 : ZEND_VM_NEXT_OPCODE();
25050 : #if 0 || IS_CV != IS_UNUSED
25051 : } else {
25052 1 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25053 : #endif
25054 : }
25055 : }
25056 :
25057 : static int ZEND_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25058 0 : {
25059 0 : zend_op *opline = EX(opline);
25060 :
25061 :
25062 0 : add_function(&EX_T(opline->result.u.var).tmp_var,
25063 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
25064 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
25065 :
25066 :
25067 0 : ZEND_VM_NEXT_OPCODE();
25068 : }
25069 :
25070 : static int ZEND_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25071 1 : {
25072 1 : zend_op *opline = EX(opline);
25073 :
25074 :
25075 1 : sub_function(&EX_T(opline->result.u.var).tmp_var,
25076 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
25077 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
25078 :
25079 :
25080 1 : ZEND_VM_NEXT_OPCODE();
25081 : }
25082 :
25083 : static int ZEND_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25084 0 : {
25085 0 : zend_op *opline = EX(opline);
25086 :
25087 :
25088 0 : mul_function(&EX_T(opline->result.u.var).tmp_var,
25089 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
25090 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
25091 :
25092 :
25093 0 : ZEND_VM_NEXT_OPCODE();
25094 : }
25095 :
25096 : static int ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25097 0 : {
25098 0 : zend_op *opline = EX(opline);
25099 :
25100 :
25101 0 : div_function(&EX_T(opline->result.u.var).tmp_var,
25102 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
25103 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
25104 :
25105 :
25106 0 : ZEND_VM_NEXT_OPCODE();
25107 : }
25108 :
25109 : static int ZEND_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25110 0 : {
25111 0 : zend_op *opline = EX(opline);
25112 :
25113 :
25114 0 : mod_function(&EX_T(opline->result.u.var).tmp_var,
25115 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
25116 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
25117 :
25118 :
25119 0 : ZEND_VM_NEXT_OPCODE();
25120 : }
25121 :
25122 : static int ZEND_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25123 0 : {
25124 0 : zend_op *opline = EX(opline);
25125 :
25126 :
25127 0 : shift_left_function(&EX_T(opline->result.u.var).tmp_var,
25128 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
25129 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
25130 :
25131 :
25132 0 : ZEND_VM_NEXT_OPCODE();
25133 : }
25134 :
25135 : static int ZEND_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25136 0 : {
25137 0 : zend_op *opline = EX(opline);
25138 :
25139 :
25140 0 : shift_right_function(&EX_T(opline->result.u.var).tmp_var,
25141 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
25142 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
25143 :
25144 :
25145 0 : ZEND_VM_NEXT_OPCODE();
25146 : }
25147 :
25148 : static int ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25149 3 : {
25150 3 : zend_op *opline = EX(opline);
25151 :
25152 :
25153 3 : concat_function(&EX_T(opline->result.u.var).tmp_var,
25154 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
25155 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
25156 :
25157 :
25158 3 : ZEND_VM_NEXT_OPCODE();
25159 : }
25160 :
25161 : static int ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25162 0 : {
25163 0 : zend_op *opline = EX(opline);
25164 :
25165 :
25166 0 : is_identical_function(&EX_T(opline->result.u.var).tmp_var,
25167 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
25168 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
25169 :
25170 :
25171 0 : ZEND_VM_NEXT_OPCODE();
25172 : }
25173 :
25174 : static int ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25175 0 : {
25176 0 : zend_op *opline = EX(opline);
25177 :
25178 :
25179 0 : is_not_identical_function(&EX_T(opline->result.u.var).tmp_var,
25180 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
25181 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
25182 :
25183 :
25184 0 : ZEND_VM_NEXT_OPCODE();
25185 : }
25186 :
25187 : static int ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25188 759 : {
25189 759 : zend_op *opline = EX(opline);
25190 :
25191 :
25192 759 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
25193 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
25194 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
25195 :
25196 :
25197 759 : ZEND_VM_NEXT_OPCODE();
25198 : }
25199 :
25200 : static int ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25201 216 : {
25202 216 : zend_op *opline = EX(opline);
25203 :
25204 :
25205 216 : is_not_equal_function(&EX_T(opline->result.u.var).tmp_var,
25206 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
25207 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
25208 :
25209 :
25210 216 : ZEND_VM_NEXT_OPCODE();
25211 : }
25212 :
25213 : static int ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25214 60524 : {
25215 60524 : zend_op *opline = EX(opline);
25216 :
25217 :
25218 60524 : is_smaller_function(&EX_T(opline->result.u.var).tmp_var,
25219 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
25220 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
25221 :
25222 :
25223 60524 : ZEND_VM_NEXT_OPCODE();
25224 : }
25225 :
25226 : static int ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25227 0 : {
25228 0 : zend_op *opline = EX(opline);
25229 :
25230 :
25231 0 : is_smaller_or_equal_function(&EX_T(opline->result.u.var).tmp_var,
25232 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
25233 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
25234 :
25235 :
25236 0 : ZEND_VM_NEXT_OPCODE();
25237 : }
25238 :
25239 : static int ZEND_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25240 0 : {
25241 0 : zend_op *opline = EX(opline);
25242 :
25243 :
25244 0 : bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
25245 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
25246 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
25247 :
25248 :
25249 0 : ZEND_VM_NEXT_OPCODE();
25250 : }
25251 :
25252 : static int ZEND_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25253 0 : {
25254 0 : zend_op *opline = EX(opline);
25255 :
25256 :
25257 0 : bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
25258 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
25259 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
25260 :
25261 :
25262 0 : ZEND_VM_NEXT_OPCODE();
25263 : }
25264 :
25265 : static int ZEND_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25266 0 : {
25267 0 : zend_op *opline = EX(opline);
25268 :
25269 :
25270 0 : bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
25271 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
25272 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
25273 :
25274 :
25275 0 : ZEND_VM_NEXT_OPCODE();
25276 : }
25277 :
25278 : static int ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25279 0 : {
25280 0 : zend_op *opline = EX(opline);
25281 :
25282 :
25283 0 : boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
25284 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
25285 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
25286 :
25287 :
25288 0 : ZEND_VM_NEXT_OPCODE();
25289 : }
25290 :
25291 : static int zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
25292 0 : {
25293 0 : zend_op *opline = EX(opline);
25294 0 : zend_op *op_data = opline+1;
25295 : zend_free_op free_op_data1;
25296 0 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
25297 : zval *object;
25298 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
25299 0 : zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
25300 0 : znode *result = &opline->result;
25301 0 : zval **retval = &EX_T(result->u.var).var.ptr;
25302 0 : int have_get_ptr = 0;
25303 :
25304 0 : EX_T(result->u.var).var.ptr_ptr = NULL;
25305 0 : make_real_object(object_ptr TSRMLS_CC);
25306 0 : object = *object_ptr;
25307 :
25308 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
25309 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
25310 :
25311 0 : FREE_OP(free_op_data1);
25312 :
25313 0 : if (!RETURN_VALUE_UNUSED(result)) {
25314 0 : *retval = EG(uninitialized_zval_ptr);
25315 0 : PZVAL_LOCK(*retval);
25316 : }
25317 : } else {
25318 : /* here we are sure we are dealing with an object */
25319 : if (0) {
25320 : MAKE_REAL_ZVAL_PTR(property);
25321 : }
25322 :
25323 : /* here property is a string */
25324 0 : if (opline->extended_value == ZEND_ASSIGN_OBJ
25325 : && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
25326 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
25327 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
25328 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
25329 :
25330 0 : have_get_ptr = 1;
25331 0 : binary_op(*zptr, *zptr, value TSRMLS_CC);
25332 0 : if (!RETURN_VALUE_UNUSED(result)) {
25333 0 : *retval = *zptr;
25334 0 : PZVAL_LOCK(*retval);
25335 : }
25336 : }
25337 : }
25338 :
25339 0 : if (!have_get_ptr) {
25340 0 : zval *z = NULL;
25341 :
25342 0 : switch (opline->extended_value) {
25343 : case ZEND_ASSIGN_OBJ:
25344 0 : if (Z_OBJ_HT_P(object)->read_property) {
25345 0 : z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
25346 : }
25347 0 : break;
25348 : case ZEND_ASSIGN_DIM:
25349 0 : if (Z_OBJ_HT_P(object)->read_dimension) {
25350 0 : z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
25351 : }
25352 : break;
25353 : }
25354 0 : if (z) {
25355 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
25356 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
25357 :
25358 0 : if (z->refcount == 0) {
25359 0 : zval_dtor(z);
25360 0 : FREE_ZVAL(z);
25361 : }
25362 0 : z = value;
25363 : }
25364 0 : z->refcount++;
25365 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
25366 0 : binary_op(z, z, value TSRMLS_CC);
25367 0 : switch (opline->extended_value) {
25368 : case ZEND_ASSIGN_OBJ:
25369 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
25370 0 : break;
25371 : case ZEND_ASSIGN_DIM:
25372 0 : Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
25373 : break;
25374 : }
25375 0 : if (!RETURN_VALUE_UNUSED(result)) {
25376 0 : *retval = z;
25377 0 : PZVAL_LOCK(*retval);
25378 : }
25379 0 : zval_ptr_dtor(&z);
25380 : } else {
25381 0 : zend_error(E_WARNING, "Attempt to assign property of non-object");
25382 0 : if (!RETURN_VALUE_UNUSED(result)) {
25383 0 : *retval = EG(uninitialized_zval_ptr);
25384 0 : PZVAL_LOCK(*retval);
25385 : }
25386 : }
25387 : }
25388 :
25389 : if (0) {
25390 : zval_ptr_dtor(&property);
25391 : } else {
25392 :
25393 : }
25394 0 : FREE_OP(free_op_data1);
25395 : }
25396 :
25397 : /* assign_obj has two opcodes! */
25398 0 : ZEND_VM_INC_OPCODE();
25399 0 : ZEND_VM_NEXT_OPCODE();
25400 : }
25401 :
25402 : static int zend_binary_assign_op_helper_SPEC_CV_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
25403 6407 : {
25404 6407 : zend_op *opline = EX(opline);
25405 : zend_free_op free_op_data2, free_op_data1;
25406 : zval **var_ptr;
25407 : zval *value;
25408 6407 : zend_bool increment_opline = 0;
25409 :
25410 6407 : switch (opline->extended_value) {
25411 : case ZEND_ASSIGN_OBJ:
25412 0 : return zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25413 : break;
25414 : case ZEND_ASSIGN_DIM: {
25415 4135 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
25416 :
25417 : if (object_ptr && IS_CV != IS_CV && !0) {
25418 : (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
25419 : }
25420 :
25421 4135 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
25422 0 : return zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25423 : } else {
25424 4135 : zend_op *op_data = opline+1;
25425 4135 : zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
25426 :
25427 4135 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
25428 4135 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
25429 4135 : var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
25430 4135 : increment_opline = 1;
25431 : }
25432 : }
25433 4135 : break;
25434 : default:
25435 2272 : value = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
25436 2272 : var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
25437 : /* do nothing */
25438 : break;
25439 : }
25440 :
25441 6407 : if (!var_ptr) {
25442 0 : zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
25443 : }
25444 :
25445 6407 : if (*var_ptr == EG(error_zval_ptr)) {
25446 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
25447 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
25448 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
25449 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
25450 : }
25451 :
25452 :
25453 0 : if (increment_opline) {
25454 0 : ZEND_VM_INC_OPCODE();
25455 : }
25456 0 : ZEND_VM_NEXT_OPCODE();
25457 : }
25458 :
25459 6407 : SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
25460 :
25461 6407 : if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
25462 : && Z_OBJ_HANDLER_PP(var_ptr, set)) {
25463 : /* proxy object */
25464 0 : zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
25465 0 : objval->refcount++;
25466 0 : binary_op(objval, objval, value TSRMLS_CC);
25467 0 : Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
25468 0 : zval_ptr_dtor(&objval);
25469 : } else {
25470 6407 : binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
25471 : }
25472 :
25473 6407 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
25474 0 : EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
25475 0 : PZVAL_LOCK(*var_ptr);
25476 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
25477 : }
25478 :
25479 6407 : if (increment_opline) {
25480 4135 : ZEND_VM_INC_OPCODE();
25481 4135 : FREE_OP(free_op_data1);
25482 4135 : FREE_OP_VAR_PTR(free_op_data2);
25483 : }
25484 :
25485 6407 : ZEND_VM_NEXT_OPCODE();
25486 : }
25487 :
25488 : static int ZEND_ASSIGN_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25489 579 : {
25490 579 : return zend_binary_assign_op_helper_SPEC_CV_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25491 : }
25492 :
25493 : static int ZEND_ASSIGN_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25494 0 : {
25495 0 : return zend_binary_assign_op_helper_SPEC_CV_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25496 : }
25497 :
25498 : static int ZEND_ASSIGN_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25499 0 : {
25500 0 : return zend_binary_assign_op_helper_SPEC_CV_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25501 : }
25502 :
25503 : static int ZEND_ASSIGN_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25504 0 : {
25505 0 : return zend_binary_assign_op_helper_SPEC_CV_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25506 : }
25507 :
25508 : static int ZEND_ASSIGN_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25509 0 : {
25510 0 : return zend_binary_assign_op_helper_SPEC_CV_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25511 : }
25512 :
25513 : static int ZEND_ASSIGN_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25514 0 : {
25515 0 : return zend_binary_assign_op_helper_SPEC_CV_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25516 : }
25517 :
25518 : static int ZEND_ASSIGN_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25519 0 : {
25520 0 : return zend_binary_assign_op_helper_SPEC_CV_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25521 : }
25522 :
25523 : static int ZEND_ASSIGN_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25524 5828 : {
25525 5828 : return zend_binary_assign_op_helper_SPEC_CV_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25526 : }
25527 :
25528 : static int ZEND_ASSIGN_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25529 0 : {
25530 0 : return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25531 : }
25532 :
25533 : static int ZEND_ASSIGN_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25534 0 : {
25535 0 : return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25536 : }
25537 :
25538 : static int ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25539 0 : {
25540 0 : return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25541 : }
25542 :
25543 : static int zend_pre_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
25544 0 : {
25545 0 : zend_op *opline = EX(opline);
25546 :
25547 0 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
25548 : zval *object;
25549 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
25550 0 : zval **retval = &EX_T(opline->result.u.var).var.ptr;
25551 0 : int have_get_ptr = 0;
25552 :
25553 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
25554 0 : object = *object_ptr;
25555 :
25556 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
25557 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
25558 :
25559 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
25560 0 : *retval = EG(uninitialized_zval_ptr);
25561 0 : PZVAL_LOCK(*retval);
25562 : }
25563 :
25564 0 : ZEND_VM_NEXT_OPCODE();
25565 : }
25566 :
25567 : /* here we are sure we are dealing with an object */
25568 :
25569 : if (0) {
25570 : MAKE_REAL_ZVAL_PTR(property);
25571 : }
25572 :
25573 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
25574 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
25575 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
25576 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
25577 :
25578 0 : have_get_ptr = 1;
25579 0 : incdec_op(*zptr);
25580 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
25581 0 : *retval = *zptr;
25582 0 : PZVAL_LOCK(*retval);
25583 : }
25584 : }
25585 : }
25586 :
25587 0 : if (!have_get_ptr) {
25588 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
25589 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
25590 :
25591 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
25592 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
25593 :
25594 0 : if (z->refcount == 0) {
25595 0 : zval_dtor(z);
25596 0 : FREE_ZVAL(z);
25597 : }
25598 0 : z = value;
25599 : }
25600 0 : z->refcount++;
25601 0 : SEPARATE_ZVAL_IF_NOT_REF(&z);
25602 0 : incdec_op(z);
25603 0 : *retval = z;
25604 0 : Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
25605 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
25606 0 : zval_ptr_dtor(&z);
25607 : } else {
25608 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
25609 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
25610 0 : *retval = EG(uninitialized_zval_ptr);
25611 0 : PZVAL_LOCK(*retval);
25612 : }
25613 : }
25614 : }
25615 :
25616 : if (0) {
25617 : zval_ptr_dtor(&property);
25618 : } else {
25619 :
25620 : }
25621 :
25622 0 : ZEND_VM_NEXT_OPCODE();
25623 : }
25624 :
25625 : static int ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25626 0 : {
25627 0 : return zend_pre_incdec_property_helper_SPEC_CV_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25628 : }
25629 :
25630 : static int ZEND_PRE_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25631 0 : {
25632 0 : return zend_pre_incdec_property_helper_SPEC_CV_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25633 : }
25634 :
25635 : static int zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
25636 0 : {
25637 0 : zend_op *opline = EX(opline);
25638 :
25639 0 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
25640 : zval *object;
25641 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
25642 0 : zval *retval = &EX_T(opline->result.u.var).tmp_var;
25643 0 : int have_get_ptr = 0;
25644 :
25645 0 : make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
25646 0 : object = *object_ptr;
25647 :
25648 0 : if (Z_TYPE_P(object) != IS_OBJECT) {
25649 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
25650 :
25651 0 : *retval = *EG(uninitialized_zval_ptr);
25652 :
25653 0 : ZEND_VM_NEXT_OPCODE();
25654 : }
25655 :
25656 : /* here we are sure we are dealing with an object */
25657 :
25658 : if (0) {
25659 : MAKE_REAL_ZVAL_PTR(property);
25660 : }
25661 :
25662 0 : if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
25663 0 : zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
25664 0 : if (zptr != NULL) { /* NULL means no success in getting PTR */
25665 0 : have_get_ptr = 1;
25666 0 : SEPARATE_ZVAL_IF_NOT_REF(zptr);
25667 :
25668 0 : *retval = **zptr;
25669 0 : zendi_zval_copy_ctor(*retval);
25670 :
25671 0 : incdec_op(*zptr);
25672 :
25673 : }
25674 : }
25675 :
25676 0 : if (!have_get_ptr) {
25677 0 : if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
25678 0 : zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
25679 : zval *z_copy;
25680 :
25681 0 : if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
25682 0 : zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
25683 :
25684 0 : if (z->refcount == 0) {
25685 0 : zval_dtor(z);
25686 0 : FREE_ZVAL(z);
25687 : }
25688 0 : z = value;
25689 : }
25690 0 : *retval = *z;
25691 0 : zendi_zval_copy_ctor(*retval);
25692 0 : ALLOC_ZVAL(z_copy);
25693 0 : *z_copy = *z;
25694 0 : zendi_zval_copy_ctor(*z_copy);
25695 0 : INIT_PZVAL(z_copy);
25696 0 : incdec_op(z_copy);
25697 0 : z->refcount++;
25698 0 : Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
25699 0 : zval_ptr_dtor(&z_copy);
25700 0 : zval_ptr_dtor(&z);
25701 : } else {
25702 0 : zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
25703 0 : *retval = *EG(uninitialized_zval_ptr);
25704 : }
25705 : }
25706 :
25707 : if (0) {
25708 : zval_ptr_dtor(&property);
25709 : } else {
25710 :
25711 : }
25712 :
25713 0 : ZEND_VM_NEXT_OPCODE();
25714 : }
25715 :
25716 : static int ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25717 0 : {
25718 0 : return zend_post_incdec_property_helper_SPEC_CV_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25719 : }
25720 :
25721 : static int ZEND_POST_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25722 0 : {
25723 0 : return zend_post_incdec_property_helper_SPEC_CV_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25724 : }
25725 :
25726 : static int ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25727 30091 : {
25728 30091 : zend_op *opline = EX(opline);
25729 :
25730 30091 : zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
25731 :
25732 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK &&
25733 : IS_CV != IS_CV &&
25734 : EX_T(opline->op1.u.var).var.ptr_ptr) {
25735 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
25736 : }
25737 30091 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC), dim, 0, BP_VAR_R TSRMLS_CC);
25738 :
25739 :
25740 30091 : ZEND_VM_NEXT_OPCODE();
25741 : }
25742 :
25743 : static int ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25744 6 : {
25745 6 : zend_op *opline = EX(opline);
25746 : zend_free_op free_op1;
25747 6 : zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
25748 :
25749 6 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC), dim, 0, BP_VAR_W TSRMLS_CC);
25750 :
25751 : if (IS_CV == IS_VAR && 0 &&
25752 : READY_TO_DESTROY(free_op1.var) &&
25753 : !RETURN_VALUE_UNUSED(&opline->result)) {
25754 : AI_USE_PTR(EX_T(opline->result.u.var).var);
25755 : }
25756 :
25757 6 : ZEND_VM_NEXT_OPCODE();
25758 : }
25759 :
25760 : static int ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25761 110 : {
25762 110 : zend_op *opline = EX(opline);
25763 : zend_free_op free_op1;
25764 110 : zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
25765 :
25766 110 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
25767 :
25768 : if (IS_CV == IS_VAR && 0 &&
25769 : READY_TO_DESTROY(free_op1.var) &&
25770 : !RETURN_VALUE_UNUSED(&opline->result)) {
25771 : AI_USE_PTR(EX_T(opline->result.u.var).var);
25772 : }
25773 :
25774 110 : ZEND_VM_NEXT_OPCODE();
25775 : }
25776 :
25777 : static int ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25778 0 : {
25779 0 : zend_op *opline = EX(opline);
25780 :
25781 0 : zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
25782 :
25783 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC), dim, 0, BP_VAR_IS TSRMLS_CC);
25784 :
25785 :
25786 0 : ZEND_VM_NEXT_OPCODE();
25787 : }
25788 :
25789 : static int ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25790 0 : {
25791 0 : zend_op *opline = EX(opline);
25792 : zend_free_op free_op1;
25793 0 : int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
25794 : zval *dim;
25795 :
25796 : if (IS_CV == IS_UNUSED && type == BP_VAR_R) {
25797 : zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
25798 : }
25799 0 : dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
25800 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), type TSRMLS_CC), dim, 0, type TSRMLS_CC);
25801 :
25802 : if (IS_CV == IS_VAR && type == BP_VAR_W && 0 &&
25803 : READY_TO_DESTROY(free_op1.var) &&
25804 : !RETURN_VALUE_UNUSED(&opline->result)) {
25805 : AI_USE_PTR(EX_T(opline->result.u.var).var);
25806 : }
25807 :
25808 0 : ZEND_VM_NEXT_OPCODE();
25809 : }
25810 :
25811 : static int ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25812 0 : {
25813 0 : zend_op *opline = EX(opline);
25814 : zend_free_op free_op1;
25815 0 : zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
25816 0 : zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
25817 :
25818 : /* Not needed in DIM_UNSET
25819 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
25820 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
25821 : }
25822 : */
25823 : if (IS_CV == IS_CV) {
25824 0 : if (container != &EG(uninitialized_zval_ptr)) {
25825 0 : SEPARATE_ZVAL_IF_NOT_REF(container);
25826 : }
25827 : }
25828 0 : zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, dim, 0, BP_VAR_UNSET TSRMLS_CC);
25829 :
25830 : if (IS_CV == IS_VAR && 0 &&
25831 : READY_TO_DESTROY(free_op1.var) &&
25832 : !RETURN_VALUE_UNUSED(&opline->result)) {
25833 : AI_USE_PTR(EX_T(opline->result.u.var).var);
25834 : }
25835 :
25836 0 : if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
25837 0 : zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
25838 : } else {
25839 : zend_free_op free_res;
25840 :
25841 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
25842 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
25843 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
25844 : }
25845 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
25846 0 : FREE_OP_VAR_PTR(free_res);
25847 : }
25848 0 : ZEND_VM_NEXT_OPCODE();
25849 : }
25850 :
25851 : static int zend_fetch_property_address_read_helper_SPEC_CV_CV(int type, ZEND_OPCODE_HANDLER_ARGS)
25852 0 : {
25853 0 : zend_op *opline = EX(opline);
25854 : zval *container;
25855 : zval **retval;
25856 :
25857 :
25858 0 : retval = &EX_T(opline->result.u.var).var.ptr;
25859 0 : EX_T(opline->result.u.var).var.ptr_ptr = retval;
25860 :
25861 0 : container = _get_zval_ptr_cv(&opline->op1, EX(Ts), type TSRMLS_CC);
25862 :
25863 0 : if (container == EG(error_zval_ptr)) {
25864 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
25865 0 : *retval = EG(error_zval_ptr);
25866 0 : PZVAL_LOCK(*retval);
25867 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
25868 : }
25869 :
25870 0 : ZEND_VM_NEXT_OPCODE();
25871 : }
25872 :
25873 :
25874 0 : if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
25875 0 : if (type != BP_VAR_IS) {
25876 0 : zend_error(E_NOTICE, "Trying to get property of non-object");
25877 : }
25878 0 : *retval = EG(uninitialized_zval_ptr);
25879 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
25880 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
25881 : } else {
25882 :
25883 0 : zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
25884 :
25885 : if (0) {
25886 : MAKE_REAL_ZVAL_PTR(offset);
25887 : }
25888 :
25889 : /* here we are sure we are dealing with an object */
25890 0 : *retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
25891 :
25892 0 : if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
25893 0 : zval_dtor(*retval);
25894 0 : FREE_ZVAL(*retval);
25895 : } else {
25896 0 : SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
25897 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
25898 : }
25899 :
25900 : if (0) {
25901 : zval_ptr_dtor(&offset);
25902 : } else {
25903 :
25904 : }
25905 : }
25906 :
25907 0 : ZEND_VM_NEXT_OPCODE();
25908 : }
25909 :
25910 : static int ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25911 0 : {
25912 0 : return zend_fetch_property_address_read_helper_SPEC_CV_CV(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25913 : }
25914 :
25915 : static int ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25916 0 : {
25917 0 : zend_op *opline = EX(opline);
25918 : zend_free_op free_op1;
25919 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
25920 :
25921 : if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_CV != IS_CV) {
25922 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
25923 : EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
25924 : }
25925 :
25926 : if (0) {
25927 : MAKE_REAL_ZVAL_PTR(property);
25928 : }
25929 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
25930 : if (0) {
25931 : zval_ptr_dtor(&property);
25932 : } else {
25933 :
25934 : }
25935 : if (IS_CV == IS_VAR && 0 &&
25936 : READY_TO_DESTROY(free_op1.var) &&
25937 : !RETURN_VALUE_UNUSED(&opline->result)) {
25938 : AI_USE_PTR(EX_T(opline->result.u.var).var);
25939 : }
25940 :
25941 0 : ZEND_VM_NEXT_OPCODE();
25942 : }
25943 :
25944 : static int ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25945 0 : {
25946 0 : zend_op *opline = EX(opline);
25947 : zend_free_op free_op1;
25948 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
25949 :
25950 : if (0) {
25951 : MAKE_REAL_ZVAL_PTR(property);
25952 : }
25953 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC), property, BP_VAR_RW TSRMLS_CC);
25954 : if (0) {
25955 : zval_ptr_dtor(&property);
25956 : } else {
25957 :
25958 : }
25959 : if (IS_CV == IS_VAR && 0 &&
25960 : READY_TO_DESTROY(free_op1.var) &&
25961 : !RETURN_VALUE_UNUSED(&opline->result)) {
25962 : AI_USE_PTR(EX_T(opline->result.u.var).var);
25963 : }
25964 :
25965 0 : ZEND_VM_NEXT_OPCODE();
25966 : }
25967 :
25968 : static int ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25969 0 : {
25970 0 : return zend_fetch_property_address_read_helper_SPEC_CV_CV(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25971 : }
25972 :
25973 : static int ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25974 0 : {
25975 0 : zend_op *opline = EX(opline);
25976 :
25977 0 : if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
25978 : /* Behave like FETCH_OBJ_W */
25979 : zend_free_op free_op1;
25980 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
25981 :
25982 : if (0) {
25983 : MAKE_REAL_ZVAL_PTR(property);
25984 : }
25985 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
25986 : if (0) {
25987 : zval_ptr_dtor(&property);
25988 : } else {
25989 :
25990 : }
25991 : if (IS_CV == IS_VAR && 0 &&
25992 : READY_TO_DESTROY(free_op1.var) &&
25993 : !RETURN_VALUE_UNUSED(&opline->result)) {
25994 : AI_USE_PTR(EX_T(opline->result.u.var).var);
25995 : }
25996 :
25997 0 : ZEND_VM_NEXT_OPCODE();
25998 : } else {
25999 0 : return zend_fetch_property_address_read_helper_SPEC_CV_CV(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26000 : }
26001 : }
26002 :
26003 : static int ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26004 0 : {
26005 0 : zend_op *opline = EX(opline);
26006 : zend_free_op free_op1, free_res;
26007 0 : zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
26008 0 : zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
26009 :
26010 : if (IS_CV == IS_CV) {
26011 0 : if (container != &EG(uninitialized_zval_ptr)) {
26012 0 : SEPARATE_ZVAL_IF_NOT_REF(container);
26013 : }
26014 : }
26015 : if (0) {
26016 : MAKE_REAL_ZVAL_PTR(property);
26017 : }
26018 0 : zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
26019 : if (0) {
26020 : zval_ptr_dtor(&property);
26021 : } else {
26022 :
26023 : }
26024 : if (IS_CV == IS_VAR && 0 &&
26025 : READY_TO_DESTROY(free_op1.var) &&
26026 : !RETURN_VALUE_UNUSED(&opline->result)) {
26027 : AI_USE_PTR(EX_T(opline->result.u.var).var);
26028 : }
26029 :
26030 0 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
26031 0 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
26032 0 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
26033 : }
26034 0 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
26035 0 : FREE_OP_VAR_PTR(free_res);
26036 0 : ZEND_VM_NEXT_OPCODE();
26037 : }
26038 :
26039 : static int ZEND_ASSIGN_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26040 0 : {
26041 0 : zend_op *opline = EX(opline);
26042 0 : zend_op *op_data = opline+1;
26043 :
26044 0 : zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
26045 :
26046 0 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
26047 :
26048 : /* assign_obj has two opcodes! */
26049 0 : ZEND_VM_INC_OPCODE();
26050 0 : ZEND_VM_NEXT_OPCODE();
26051 : }
26052 :
26053 : static int ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26054 2746 : {
26055 2746 : zend_op *opline = EX(opline);
26056 2746 : zend_op *op_data = opline+1;
26057 :
26058 : zval **object_ptr;
26059 :
26060 : if (IS_CV == IS_CV || EX_T(opline->op1.u.var).var.ptr_ptr) {
26061 : /* not an array offset */
26062 2746 : object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
26063 : } else {
26064 : object_ptr = NULL;
26065 : }
26066 :
26067 2746 : if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
26068 0 : zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
26069 : } else {
26070 : zend_free_op free_op_data1;
26071 : zval *value;
26072 2746 : zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
26073 :
26074 2746 : zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
26075 :
26076 2746 : value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
26077 2746 : zend_assign_to_variable(&opline->result, &op_data->op2, &op_data->op1, value, (IS_TMP_FREE(free_op_data1)?IS_TMP_VAR:op_data->op1.op_type), EX(Ts) TSRMLS_CC);
26078 2746 : FREE_OP_IF_VAR(free_op_data1);
26079 : }
26080 :
26081 : /* assign_dim has two opcodes! */
26082 2746 : ZEND_VM_INC_OPCODE();
26083 2746 : ZEND_VM_NEXT_OPCODE();
26084 : }
26085 :
26086 : static int ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26087 5846 : {
26088 5846 : zend_op *opline = EX(opline);
26089 :
26090 5846 : zval *value = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
26091 :
26092 5846 : zend_assign_to_variable(&opline->result, &opline->op1, &opline->op2, value, (0?IS_TMP_VAR:IS_CV), EX(Ts) TSRMLS_CC);
26093 : /* zend_assign_to_variable() always takes care of op2, never free it! */
26094 :
26095 5846 : ZEND_VM_NEXT_OPCODE();
26096 : }
26097 :
26098 : static int ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26099 0 : {
26100 0 : zend_op *opline = EX(opline);
26101 : zend_free_op free_op2;
26102 : zval **variable_ptr_ptr;
26103 0 : zval **value_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op2, EX(Ts), BP_VAR_W TSRMLS_CC);
26104 :
26105 : if (IS_CV == IS_VAR &&
26106 : value_ptr_ptr &&
26107 : !(*value_ptr_ptr)->is_ref &&
26108 : opline->extended_value == ZEND_RETURNS_FUNCTION &&
26109 : !EX_T(opline->op2.u.var).var.fcall_returned_reference) {
26110 : if (free_op2.var == NULL) {
26111 : PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
26112 : }
26113 : zend_error(E_STRICT, "Only variables should be assigned by reference");
26114 : return ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26115 : }
26116 : if (IS_CV == IS_VAR && EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
26117 : zend_error(E_ERROR, "Cannot assign by reference to overloaded object");
26118 : }
26119 :
26120 0 : variable_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
26121 0 : zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
26122 :
26123 0 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
26124 0 : EX_T(opline->result.u.var).var.ptr_ptr = variable_ptr_ptr;
26125 0 : PZVAL_LOCK(*variable_ptr_ptr);
26126 0 : AI_USE_PTR(EX_T(opline->result.u.var).var);
26127 : }
26128 :
26129 :
26130 0 : ZEND_VM_NEXT_OPCODE();
26131 : }
26132 :
26133 : static int ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26134 26 : {
26135 26 : zend_op *opline = EX(opline);
26136 : zval *function_name;
26137 : char *function_name_strval;
26138 : int function_name_strlen;
26139 :
26140 :
26141 26 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
26142 :
26143 26 : function_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
26144 :
26145 26 : if (Z_TYPE_P(function_name)!=IS_STRING) {
26146 0 : zend_error_noreturn(E_ERROR, "Method name must be a string");
26147 : }
26148 :
26149 26 : function_name_strval = Z_STRVAL_P(function_name);
26150 26 : function_name_strlen = Z_STRLEN_P(function_name);
26151 :
26152 26 : EX(object) = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
26153 :
26154 26 : if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
26155 26 : if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
26156 0 : zend_error_noreturn(E_ERROR, "Object does not support method calls");
26157 : }
26158 :
26159 : /* First, locate the function. */
26160 26 : EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
26161 26 : if (!EX(fbc)) {
26162 0 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
26163 : }
26164 : } else {
26165 0 : zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
26166 : }
26167 :
26168 26 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
26169 0 : EX(object) = NULL;
26170 : } else {
26171 26 : if (!PZVAL_IS_REF(EX(object))) {
26172 26 : EX(object)->refcount++; /* For $this pointer */
26173 : } else {
26174 : zval *this_ptr;
26175 0 : ALLOC_ZVAL(this_ptr);
26176 0 : INIT_PZVAL_COPY(this_ptr, EX(object));
26177 0 : zval_copy_ctor(this_ptr);
26178 0 : EX(object) = this_ptr;
26179 : }
26180 : }
26181 :
26182 :
26183 26 : ZEND_VM_NEXT_OPCODE();
26184 : }
26185 :
26186 : static int ZEND_CASE_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26187 0 : {
26188 0 : zend_op *opline = EX(opline);
26189 0 : int switch_expr_is_overloaded=0;
26190 :
26191 :
26192 : if (IS_CV==IS_VAR) {
26193 : if (EX_T(opline->op1.u.var).var.ptr_ptr) {
26194 : PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
26195 : } else {
26196 : switch_expr_is_overloaded = 1;
26197 : EX_T(opline->op1.u.var).str_offset.str->refcount++;
26198 : }
26199 : }
26200 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
26201 : _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
26202 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
26203 :
26204 0 : if (switch_expr_is_overloaded) {
26205 : /* We only free op1 if this is a string offset,
26206 : * Since if it is a TMP_VAR, it'll be reused by
26207 : * other CASE opcodes (whereas string offsets
26208 : * are allocated at each get_zval_ptr())
26209 : */
26210 :
26211 0 : EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
26212 0 : AI_USE_PTR(EX_T(opline->op1.u.var).var);
26213 : }
26214 0 : ZEND_VM_NEXT_OPCODE();
26215 : }
26216 :
26217 : static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26218 0 : {
26219 0 : zend_op *opline = EX(opline);
26220 :
26221 0 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
26222 : zval *expr_ptr;
26223 0 : zval *offset=_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
26224 :
26225 : #if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
26226 0 : zval **expr_ptr_ptr = NULL;
26227 :
26228 0 : if (opline->extended_value) {
26229 0 : expr_ptr_ptr=_get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
26230 0 : expr_ptr = *expr_ptr_ptr;
26231 : } else {
26232 0 : expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
26233 : }
26234 : #else
26235 : expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
26236 : #endif
26237 :
26238 : if (0) { /* temporary variable */
26239 : zval *new_expr;
26240 :
26241 : ALLOC_ZVAL(new_expr);
26242 : INIT_PZVAL_COPY(new_expr, expr_ptr);
26243 : expr_ptr = new_expr;
26244 : } else {
26245 : #if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
26246 0 : if (opline->extended_value) {
26247 0 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
26248 0 : expr_ptr = *expr_ptr_ptr;
26249 0 : expr_ptr->refcount++;
26250 : } else
26251 : #endif
26252 0 : if (PZVAL_IS_REF(expr_ptr)) {
26253 : zval *new_expr;
26254 :
26255 0 : ALLOC_ZVAL(new_expr);
26256 0 : INIT_PZVAL_COPY(new_expr, expr_ptr);
26257 0 : expr_ptr = new_expr;
26258 0 : zendi_zval_copy_ctor(*expr_ptr);
26259 : } else {
26260 0 : expr_ptr->refcount++;
26261 : }
26262 : }
26263 0 : if (offset) {
26264 0 : switch (Z_TYPE_P(offset)) {
26265 : case IS_DOUBLE:
26266 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
26267 0 : break;
26268 : case IS_LONG:
26269 : case IS_BOOL:
26270 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
26271 0 : break;
26272 : case IS_STRING:
26273 0 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
26274 0 : break;
26275 : case IS_NULL:
26276 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
26277 0 : break;
26278 : default:
26279 0 : zend_error(E_WARNING, "Illegal offset type");
26280 0 : zval_ptr_dtor(&expr_ptr);
26281 : /* do nothing */
26282 : break;
26283 : }
26284 :
26285 : } else {
26286 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
26287 : }
26288 0 : if (opline->extended_value) {
26289 :
26290 : } else {
26291 :
26292 : }
26293 0 : ZEND_VM_NEXT_OPCODE();
26294 : }
26295 :
26296 : static int ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26297 0 : {
26298 0 : zend_op *opline = EX(opline);
26299 :
26300 0 : array_init(&EX_T(opline->result.u.var).tmp_var);
26301 : if (IS_CV == IS_UNUSED) {
26302 : ZEND_VM_NEXT_OPCODE();
26303 : #if 0 || IS_CV != IS_UNUSED
26304 : } else {
26305 0 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26306 : #endif
26307 : }
26308 : }
26309 :
26310 : static int ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26311 0 : {
26312 0 : zend_op *opline = EX(opline);
26313 :
26314 0 : zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
26315 0 : zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
26316 : long index;
26317 :
26318 0 : if (container) {
26319 0 : if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
26320 0 : SEPARATE_ZVAL_IF_NOT_REF(container);
26321 : }
26322 0 : switch (Z_TYPE_PP(container)) {
26323 : case IS_ARRAY: {
26324 0 : HashTable *ht = Z_ARRVAL_PP(container);
26325 :
26326 0 : switch (Z_TYPE_P(offset)) {
26327 : case IS_DOUBLE:
26328 0 : index = (long) Z_DVAL_P(offset);
26329 0 : zend_hash_index_del(ht, index);
26330 0 : break;
26331 : case IS_RESOURCE:
26332 : case IS_BOOL:
26333 : case IS_LONG:
26334 0 : index = Z_LVAL_P(offset);
26335 0 : zend_hash_index_del(ht, index);
26336 0 : break;
26337 : case IS_STRING:
26338 : if (IS_CV == IS_CV || IS_CV == IS_VAR) {
26339 0 : offset->refcount++;
26340 : }
26341 0 : if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
26342 : ht == &EG(symbol_table)) {
26343 : zend_execute_data *ex;
26344 0 : ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
26345 :
26346 0 : for (ex = execute_data; ex; ex = ex->prev_execute_data) {
26347 0 : if (ex->op_array && ex->symbol_table == ht) {
26348 : int i;
26349 :
26350 0 : for (i = 0; i < ex->op_array->last_var; i++) {
26351 0 : if (ex->op_array->vars[i].hash_value == hash_value &&
26352 : ex->op_array->vars[i].name_len == offset->value.str.len &&
26353 : !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
26354 0 : ex->CVs[i] = NULL;
26355 0 : break;
26356 : }
26357 : }
26358 : }
26359 : }
26360 : }
26361 : if (IS_CV == IS_CV || IS_CV == IS_VAR) {
26362 0 : zval_ptr_dtor(&offset);
26363 : }
26364 0 : break;
26365 : case IS_NULL:
26366 0 : zend_hash_del(ht, "", sizeof(""));
26367 0 : break;
26368 : default:
26369 0 : zend_error(E_WARNING, "Illegal offset type in unset");
26370 : break;
26371 : }
26372 :
26373 0 : break;
26374 : }
26375 : case IS_OBJECT:
26376 0 : if (!Z_OBJ_HT_P(*container)->unset_dimension) {
26377 0 : zend_error_noreturn(E_ERROR, "Cannot use object as array");
26378 : }
26379 : if (0) {
26380 : MAKE_REAL_ZVAL_PTR(offset);
26381 : }
26382 0 : Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
26383 : if (0) {
26384 : zval_ptr_dtor(&offset);
26385 : } else {
26386 :
26387 : }
26388 0 : break;
26389 : case IS_STRING:
26390 0 : zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
26391 : ZEND_VM_CONTINUE(); /* bailed out before */
26392 : default:
26393 :
26394 : break;
26395 : }
26396 : } else {
26397 :
26398 : }
26399 :
26400 0 : ZEND_VM_NEXT_OPCODE();
26401 : }
26402 :
26403 : static int ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26404 0 : {
26405 0 : zend_op *opline = EX(opline);
26406 :
26407 0 : zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
26408 0 : zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
26409 :
26410 0 : if (container) {
26411 0 : if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
26412 0 : SEPARATE_ZVAL_IF_NOT_REF(container);
26413 : }
26414 0 : if (Z_TYPE_PP(container) == IS_OBJECT) {
26415 : if (0) {
26416 : MAKE_REAL_ZVAL_PTR(offset);
26417 : }
26418 0 : Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
26419 : if (0) {
26420 : zval_ptr_dtor(&offset);
26421 : } else {
26422 :
26423 : }
26424 : } else {
26425 :
26426 : }
26427 : } else {
26428 :
26429 : }
26430 :
26431 0 : ZEND_VM_NEXT_OPCODE();
26432 : }
26433 :
26434 : static int zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
26435 0 : {
26436 0 : zend_op *opline = EX(opline);
26437 :
26438 0 : zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
26439 0 : zval **value = NULL;
26440 0 : int result = 0;
26441 : long index;
26442 :
26443 0 : if (container) {
26444 :
26445 0 : zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
26446 :
26447 0 : if (Z_TYPE_PP(container) == IS_ARRAY) {
26448 : HashTable *ht;
26449 0 : int isset = 0;
26450 :
26451 0 : ht = Z_ARRVAL_PP(container);
26452 :
26453 0 : switch (Z_TYPE_P(offset)) {
26454 : case IS_DOUBLE:
26455 0 : index = (long) Z_DVAL_P(offset);
26456 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
26457 0 : isset = 1;
26458 : }
26459 0 : break;
26460 : case IS_RESOURCE:
26461 : case IS_BOOL:
26462 : case IS_LONG:
26463 0 : index = Z_LVAL_P(offset);
26464 0 : if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
26465 0 : isset = 1;
26466 : }
26467 0 : break;
26468 : case IS_STRING:
26469 0 : if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
26470 0 : isset = 1;
26471 : }
26472 0 : break;
26473 : case IS_NULL:
26474 0 : if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
26475 0 : isset = 1;
26476 : }
26477 0 : break;
26478 : default:
26479 0 : zend_error(E_WARNING, "Illegal offset type in isset or empty");
26480 :
26481 : break;
26482 : }
26483 :
26484 0 : switch (opline->extended_value) {
26485 : case ZEND_ISSET:
26486 0 : if (isset && Z_TYPE_PP(value) == IS_NULL) {
26487 0 : result = 0;
26488 : } else {
26489 0 : result = isset;
26490 : }
26491 0 : break;
26492 : case ZEND_ISEMPTY:
26493 0 : if (!isset || !i_zend_is_true(*value)) {
26494 0 : result = 0;
26495 : } else {
26496 0 : result = 1;
26497 : }
26498 : break;
26499 : }
26500 :
26501 0 : } else if (Z_TYPE_PP(container) == IS_OBJECT) {
26502 : if (0) {
26503 : MAKE_REAL_ZVAL_PTR(offset);
26504 : }
26505 0 : if (prop_dim) {
26506 0 : result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
26507 : } else {
26508 0 : result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
26509 : }
26510 : if (0) {
26511 : zval_ptr_dtor(&offset);
26512 : } else {
26513 :
26514 : }
26515 0 : } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
26516 : zval tmp;
26517 :
26518 0 : if (Z_TYPE_P(offset) != IS_LONG) {
26519 0 : tmp = *offset;
26520 0 : zval_copy_ctor(&tmp);
26521 0 : convert_to_long(&tmp);
26522 0 : offset = &tmp;
26523 : }
26524 0 : if (Z_TYPE_P(offset) == IS_LONG) {
26525 0 : switch (opline->extended_value) {
26526 : case ZEND_ISSET:
26527 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
26528 0 : result = 1;
26529 : }
26530 0 : break;
26531 : case ZEND_ISEMPTY:
26532 0 : if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
26533 0 : result = 1;
26534 : }
26535 : break;
26536 : }
26537 : }
26538 :
26539 : } else {
26540 :
26541 : }
26542 : }
26543 :
26544 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
26545 :
26546 0 : switch (opline->extended_value) {
26547 : case ZEND_ISSET:
26548 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
26549 0 : break;
26550 : case ZEND_ISEMPTY:
26551 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
26552 : break;
26553 : }
26554 :
26555 0 : ZEND_VM_NEXT_OPCODE();
26556 : }
26557 :
26558 : static int ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26559 0 : {
26560 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26561 : }
26562 :
26563 : static int ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26564 0 : {
26565 0 : return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26566 : }
26567 :
26568 : static int ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26569 0 : {
26570 0 : zend_error_noreturn(E_ERROR, "Invalid opcode %d/%d/%d.", EX(opline)->opcode, EX(opline)->op1.op_type, EX(opline)->op2.op_type);
26571 : ZEND_VM_RETURN_FROM_EXECUTE_LOOP();
26572 : }
26573 :
26574 :
26575 : void zend_init_opcodes_handlers()
26576 220 : {
26577 : static const opcode_handler_t labels[] = {
26578 : ZEND_NOP_SPEC_HANDLER,
26579 : ZEND_NOP_SPEC_HANDLER,
26580 : ZEND_NOP_SPEC_HANDLER,
26581 : ZEND_NOP_SPEC_HANDLER,
26582 : ZEND_NOP_SPEC_HANDLER,
26583 : ZEND_NOP_SPEC_HANDLER,
26584 : ZEND_NOP_SPEC_HANDLER,
26585 : ZEND_NOP_SPEC_HANDLER,
26586 : ZEND_NOP_SPEC_HANDLER,
26587 : ZEND_NOP_SPEC_HANDLER,
26588 : ZEND_NOP_SPEC_HANDLER,
26589 : ZEND_NOP_SPEC_HANDLER,
26590 : ZEND_NOP_SPEC_HANDLER,
26591 : ZEND_NOP_SPEC_HANDLER,
26592 : ZEND_NOP_SPEC_HANDLER,
26593 : ZEND_NOP_SPEC_HANDLER,
26594 : ZEND_NOP_SPEC_HANDLER,
26595 : ZEND_NOP_SPEC_HANDLER,
26596 : ZEND_NOP_SPEC_HANDLER,
26597 : ZEND_NOP_SPEC_HANDLER,
26598 : ZEND_NOP_SPEC_HANDLER,
26599 : ZEND_NOP_SPEC_HANDLER,
26600 : ZEND_NOP_SPEC_HANDLER,
26601 : ZEND_NOP_SPEC_HANDLER,
26602 : ZEND_NOP_SPEC_HANDLER,
26603 : ZEND_ADD_SPEC_CONST_CONST_HANDLER,
26604 : ZEND_ADD_SPEC_CONST_TMP_HANDLER,
26605 : ZEND_ADD_SPEC_CONST_VAR_HANDLER,
26606 : ZEND_NULL_HANDLER,
26607 : ZEND_ADD_SPEC_CONST_CV_HANDLER,
26608 : ZEND_ADD_SPEC_TMP_CONST_HANDLER,
26609 : ZEND_ADD_SPEC_TMP_TMP_HANDLER,
26610 : ZEND_ADD_SPEC_TMP_VAR_HANDLER,
26611 : ZEND_NULL_HANDLER,
26612 : ZEND_ADD_SPEC_TMP_CV_HANDLER,
26613 : ZEND_ADD_SPEC_VAR_CONST_HANDLER,
26614 : ZEND_ADD_SPEC_VAR_TMP_HANDLER,
26615 : ZEND_ADD_SPEC_VAR_VAR_HANDLER,
26616 : ZEND_NULL_HANDLER,
26617 : ZEND_ADD_SPEC_VAR_CV_HANDLER,
26618 : ZEND_NULL_HANDLER,
26619 : ZEND_NULL_HANDLER,
26620 : ZEND_NULL_HANDLER,
26621 : ZEND_NULL_HANDLER,
26622 : ZEND_NULL_HANDLER,
26623 : ZEND_ADD_SPEC_CV_CONST_HANDLER,
26624 : ZEND_ADD_SPEC_CV_TMP_HANDLER,
26625 : ZEND_ADD_SPEC_CV_VAR_HANDLER,
26626 : ZEND_NULL_HANDLER,
26627 : ZEND_ADD_SPEC_CV_CV_HANDLER,
26628 : ZEND_SUB_SPEC_CONST_CONST_HANDLER,
26629 : ZEND_SUB_SPEC_CONST_TMP_HANDLER,
26630 : ZEND_SUB_SPEC_CONST_VAR_HANDLER,
26631 : ZEND_NULL_HANDLER,
26632 : ZEND_SUB_SPEC_CONST_CV_HANDLER,
26633 : ZEND_SUB_SPEC_TMP_CONST_HANDLER,
26634 : ZEND_SUB_SPEC_TMP_TMP_HANDLER,
26635 : ZEND_SUB_SPEC_TMP_VAR_HANDLER,
26636 : ZEND_NULL_HANDLER,
26637 : ZEND_SUB_SPEC_TMP_CV_HANDLER,
26638 : ZEND_SUB_SPEC_VAR_CONST_HANDLER,
26639 : ZEND_SUB_SPEC_VAR_TMP_HANDLER,
26640 : ZEND_SUB_SPEC_VAR_VAR_HANDLER,
26641 : ZEND_NULL_HANDLER,
26642 : ZEND_SUB_SPEC_VAR_CV_HANDLER,
26643 : ZEND_NULL_HANDLER,
26644 : ZEND_NULL_HANDLER,
26645 : ZEND_NULL_HANDLER,
26646 : ZEND_NULL_HANDLER,
26647 : ZEND_NULL_HANDLER,
26648 : ZEND_SUB_SPEC_CV_CONST_HANDLER,
26649 : ZEND_SUB_SPEC_CV_TMP_HANDLER,
26650 : ZEND_SUB_SPEC_CV_VAR_HANDLER,
26651 : ZEND_NULL_HANDLER,
26652 : ZEND_SUB_SPEC_CV_CV_HANDLER,
26653 : ZEND_MUL_SPEC_CONST_CONST_HANDLER,
26654 : ZEND_MUL_SPEC_CONST_TMP_HANDLER,
26655 : ZEND_MUL_SPEC_CONST_VAR_HANDLER,
26656 : ZEND_NULL_HANDLER,
26657 : ZEND_MUL_SPEC_CONST_CV_HANDLER,
26658 : ZEND_MUL_SPEC_TMP_CONST_HANDLER,
26659 : ZEND_MUL_SPEC_TMP_TMP_HANDLER,
26660 : ZEND_MUL_SPEC_TMP_VAR_HANDLER,
26661 : ZEND_NULL_HANDLER,
26662 : ZEND_MUL_SPEC_TMP_CV_HANDLER,
26663 : ZEND_MUL_SPEC_VAR_CONST_HANDLER,
26664 : ZEND_MUL_SPEC_VAR_TMP_HANDLER,
26665 : ZEND_MUL_SPEC_VAR_VAR_HANDLER,
26666 : ZEND_NULL_HANDLER,
26667 : ZEND_MUL_SPEC_VAR_CV_HANDLER,
26668 : ZEND_NULL_HANDLER,
26669 : ZEND_NULL_HANDLER,
26670 : ZEND_NULL_HANDLER,
26671 : ZEND_NULL_HANDLER,
26672 : ZEND_NULL_HANDLER,
26673 : ZEND_MUL_SPEC_CV_CONST_HANDLER,
26674 : ZEND_MUL_SPEC_CV_TMP_HANDLER,
26675 : ZEND_MUL_SPEC_CV_VAR_HANDLER,
26676 : ZEND_NULL_HANDLER,
26677 : ZEND_MUL_SPEC_CV_CV_HANDLER,
26678 : ZEND_DIV_SPEC_CONST_CONST_HANDLER,
26679 : ZEND_DIV_SPEC_CONST_TMP_HANDLER,
26680 : ZEND_DIV_SPEC_CONST_VAR_HANDLER,
26681 : ZEND_NULL_HANDLER,
26682 : ZEND_DIV_SPEC_CONST_CV_HANDLER,
26683 : ZEND_DIV_SPEC_TMP_CONST_HANDLER,
26684 : ZEND_DIV_SPEC_TMP_TMP_HANDLER,
26685 : ZEND_DIV_SPEC_TMP_VAR_HANDLER,
26686 : ZEND_NULL_HANDLER,
26687 : ZEND_DIV_SPEC_TMP_CV_HANDLER,
26688 : ZEND_DIV_SPEC_VAR_CONST_HANDLER,
26689 : ZEND_DIV_SPEC_VAR_TMP_HANDLER,
26690 : ZEND_DIV_SPEC_VAR_VAR_HANDLER,
26691 : ZEND_NULL_HANDLER,
26692 : ZEND_DIV_SPEC_VAR_CV_HANDLER,
26693 : ZEND_NULL_HANDLER,
26694 : ZEND_NULL_HANDLER,
26695 : ZEND_NULL_HANDLER,
26696 : ZEND_NULL_HANDLER,
26697 : ZEND_NULL_HANDLER,
26698 : ZEND_DIV_SPEC_CV_CONST_HANDLER,
26699 : ZEND_DIV_SPEC_CV_TMP_HANDLER,
26700 : ZEND_DIV_SPEC_CV_VAR_HANDLER,
26701 : ZEND_NULL_HANDLER,
26702 : ZEND_DIV_SPEC_CV_CV_HANDLER,
26703 : ZEND_MOD_SPEC_CONST_CONST_HANDLER,
26704 : ZEND_MOD_SPEC_CONST_TMP_HANDLER,
26705 : ZEND_MOD_SPEC_CONST_VAR_HANDLER,
26706 : ZEND_NULL_HANDLER,
26707 : ZEND_MOD_SPEC_CONST_CV_HANDLER,
26708 : ZEND_MOD_SPEC_TMP_CONST_HANDLER,
26709 : ZEND_MOD_SPEC_TMP_TMP_HANDLER,
26710 : ZEND_MOD_SPEC_TMP_VAR_HANDLER,
26711 : ZEND_NULL_HANDLER,
26712 : ZEND_MOD_SPEC_TMP_CV_HANDLER,
26713 : ZEND_MOD_SPEC_VAR_CONST_HANDLER,
26714 : ZEND_MOD_SPEC_VAR_TMP_HANDLER,
26715 : ZEND_MOD_SPEC_VAR_VAR_HANDLER,
26716 : ZEND_NULL_HANDLER,
26717 : ZEND_MOD_SPEC_VAR_CV_HANDLER,
26718 : ZEND_NULL_HANDLER,
26719 : ZEND_NULL_HANDLER,
26720 : ZEND_NULL_HANDLER,
26721 : ZEND_NULL_HANDLER,
26722 : ZEND_NULL_HANDLER,
26723 : ZEND_MOD_SPEC_CV_CONST_HANDLER,
26724 : ZEND_MOD_SPEC_CV_TMP_HANDLER,
26725 : ZEND_MOD_SPEC_CV_VAR_HANDLER,
26726 : ZEND_NULL_HANDLER,
26727 : ZEND_MOD_SPEC_CV_CV_HANDLER,
26728 : ZEND_SL_SPEC_CONST_CONST_HANDLER,
26729 : ZEND_SL_SPEC_CONST_TMP_HANDLER,
26730 : ZEND_SL_SPEC_CONST_VAR_HANDLER,
26731 : ZEND_NULL_HANDLER,
26732 : ZEND_SL_SPEC_CONST_CV_HANDLER,
26733 : ZEND_SL_SPEC_TMP_CONST_HANDLER,
26734 : ZEND_SL_SPEC_TMP_TMP_HANDLER,
26735 : ZEND_SL_SPEC_TMP_VAR_HANDLER,
26736 : ZEND_NULL_HANDLER,
26737 : ZEND_SL_SPEC_TMP_CV_HANDLER,
26738 : ZEND_SL_SPEC_VAR_CONST_HANDLER,
26739 : ZEND_SL_SPEC_VAR_TMP_HANDLER,
26740 : ZEND_SL_SPEC_VAR_VAR_HANDLER,
26741 : ZEND_NULL_HANDLER,
26742 : ZEND_SL_SPEC_VAR_CV_HANDLER,
26743 : ZEND_NULL_HANDLER,
26744 : ZEND_NULL_HANDLER,
26745 : ZEND_NULL_HANDLER,
26746 : ZEND_NULL_HANDLER,
26747 : ZEND_NULL_HANDLER,
26748 : ZEND_SL_SPEC_CV_CONST_HANDLER,
26749 : ZEND_SL_SPEC_CV_TMP_HANDLER,
26750 : ZEND_SL_SPEC_CV_VAR_HANDLER,
26751 : ZEND_NULL_HANDLER,
26752 : ZEND_SL_SPEC_CV_CV_HANDLER,
26753 : ZEND_SR_SPEC_CONST_CONST_HANDLER,
26754 : ZEND_SR_SPEC_CONST_TMP_HANDLER,
26755 : ZEND_SR_SPEC_CONST_VAR_HANDLER,
26756 : ZEND_NULL_HANDLER,
26757 : ZEND_SR_SPEC_CONST_CV_HANDLER,
26758 : ZEND_SR_SPEC_TMP_CONST_HANDLER,
26759 : ZEND_SR_SPEC_TMP_TMP_HANDLER,
26760 : ZEND_SR_SPEC_TMP_VAR_HANDLER,
26761 : ZEND_NULL_HANDLER,
26762 : ZEND_SR_SPEC_TMP_CV_HANDLER,
26763 : ZEND_SR_SPEC_VAR_CONST_HANDLER,
26764 : ZEND_SR_SPEC_VAR_TMP_HANDLER,
26765 : ZEND_SR_SPEC_VAR_VAR_HANDLER,
26766 : ZEND_NULL_HANDLER,
26767 : ZEND_SR_SPEC_VAR_CV_HANDLER,
26768 : ZEND_NULL_HANDLER,
26769 : ZEND_NULL_HANDLER,
26770 : ZEND_NULL_HANDLER,
26771 : ZEND_NULL_HANDLER,
26772 : ZEND_NULL_HANDLER,
26773 : ZEND_SR_SPEC_CV_CONST_HANDLER,
26774 : ZEND_SR_SPEC_CV_TMP_HANDLER,
26775 : ZEND_SR_SPEC_CV_VAR_HANDLER,
26776 : ZEND_NULL_HANDLER,
26777 : ZEND_SR_SPEC_CV_CV_HANDLER,
26778 : ZEND_CONCAT_SPEC_CONST_CONST_HANDLER,
26779 : ZEND_CONCAT_SPEC_CONST_TMP_HANDLER,
26780 : ZEND_CONCAT_SPEC_CONST_VAR_HANDLER,
26781 : ZEND_NULL_HANDLER,
26782 : ZEND_CONCAT_SPEC_CONST_CV_HANDLER,
26783 : ZEND_CONCAT_SPEC_TMP_CONST_HANDLER,
26784 : ZEND_CONCAT_SPEC_TMP_TMP_HANDLER,
26785 : ZEND_CONCAT_SPEC_TMP_VAR_HANDLER,
26786 : ZEND_NULL_HANDLER,
26787 : ZEND_CONCAT_SPEC_TMP_CV_HANDLER,
26788 : ZEND_CONCAT_SPEC_VAR_CONST_HANDLER,
26789 : ZEND_CONCAT_SPEC_VAR_TMP_HANDLER,
26790 : ZEND_CONCAT_SPEC_VAR_VAR_HANDLER,
26791 : ZEND_NULL_HANDLER,
26792 : ZEND_CONCAT_SPEC_VAR_CV_HANDLER,
26793 : ZEND_NULL_HANDLER,
26794 : ZEND_NULL_HANDLER,
26795 : ZEND_NULL_HANDLER,
26796 : ZEND_NULL_HANDLER,
26797 : ZEND_NULL_HANDLER,
26798 : ZEND_CONCAT_SPEC_CV_CONST_HANDLER,
26799 : ZEND_CONCAT_SPEC_CV_TMP_HANDLER,
26800 : ZEND_CONCAT_SPEC_CV_VAR_HANDLER,
26801 : ZEND_NULL_HANDLER,
26802 : ZEND_CONCAT_SPEC_CV_CV_HANDLER,
26803 : ZEND_BW_OR_SPEC_CONST_CONST_HANDLER,
26804 : ZEND_BW_OR_SPEC_CONST_TMP_HANDLER,
26805 : ZEND_BW_OR_SPEC_CONST_VAR_HANDLER,
26806 : ZEND_NULL_HANDLER,
26807 : ZEND_BW_OR_SPEC_CONST_CV_HANDLER,
26808 : ZEND_BW_OR_SPEC_TMP_CONST_HANDLER,
26809 : ZEND_BW_OR_SPEC_TMP_TMP_HANDLER,
26810 : ZEND_BW_OR_SPEC_TMP_VAR_HANDLER,
26811 : ZEND_NULL_HANDLER,
26812 : ZEND_BW_OR_SPEC_TMP_CV_HANDLER,
26813 : ZEND_BW_OR_SPEC_VAR_CONST_HANDLER,
26814 : ZEND_BW_OR_SPEC_VAR_TMP_HANDLER,
26815 : ZEND_BW_OR_SPEC_VAR_VAR_HANDLER,
26816 : ZEND_NULL_HANDLER,
26817 : ZEND_BW_OR_SPEC_VAR_CV_HANDLER,
26818 : ZEND_NULL_HANDLER,
26819 : ZEND_NULL_HANDLER,
26820 : ZEND_NULL_HANDLER,
26821 : ZEND_NULL_HANDLER,
26822 : ZEND_NULL_HANDLER,
26823 : ZEND_BW_OR_SPEC_CV_CONST_HANDLER,
26824 : ZEND_BW_OR_SPEC_CV_TMP_HANDLER,
26825 : ZEND_BW_OR_SPEC_CV_VAR_HANDLER,
26826 : ZEND_NULL_HANDLER,
26827 : ZEND_BW_OR_SPEC_CV_CV_HANDLER,
26828 : ZEND_BW_AND_SPEC_CONST_CONST_HANDLER,
26829 : ZEND_BW_AND_SPEC_CONST_TMP_HANDLER,
26830 : ZEND_BW_AND_SPEC_CONST_VAR_HANDLER,
26831 : ZEND_NULL_HANDLER,
26832 : ZEND_BW_AND_SPEC_CONST_CV_HANDLER,
26833 : ZEND_BW_AND_SPEC_TMP_CONST_HANDLER,
26834 : ZEND_BW_AND_SPEC_TMP_TMP_HANDLER,
26835 : ZEND_BW_AND_SPEC_TMP_VAR_HANDLER,
26836 : ZEND_NULL_HANDLER,
26837 : ZEND_BW_AND_SPEC_TMP_CV_HANDLER,
26838 : ZEND_BW_AND_SPEC_VAR_CONST_HANDLER,
26839 : ZEND_BW_AND_SPEC_VAR_TMP_HANDLER,
26840 : ZEND_BW_AND_SPEC_VAR_VAR_HANDLER,
26841 : ZEND_NULL_HANDLER,
26842 : ZEND_BW_AND_SPEC_VAR_CV_HANDLER,
26843 : ZEND_NULL_HANDLER,
26844 : ZEND_NULL_HANDLER,
26845 : ZEND_NULL_HANDLER,
26846 : ZEND_NULL_HANDLER,
26847 : ZEND_NULL_HANDLER,
26848 : ZEND_BW_AND_SPEC_CV_CONST_HANDLER,
26849 : ZEND_BW_AND_SPEC_CV_TMP_HANDLER,
26850 : ZEND_BW_AND_SPEC_CV_VAR_HANDLER,
26851 : ZEND_NULL_HANDLER,
26852 : ZEND_BW_AND_SPEC_CV_CV_HANDLER,
26853 : ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER,
26854 : ZEND_BW_XOR_SPEC_CONST_TMP_HANDLER,
26855 : ZEND_BW_XOR_SPEC_CONST_VAR_HANDLER,
26856 : ZEND_NULL_HANDLER,
26857 : ZEND_BW_XOR_SPEC_CONST_CV_HANDLER,
26858 : ZEND_BW_XOR_SPEC_TMP_CONST_HANDLER,
26859 : ZEND_BW_XOR_SPEC_TMP_TMP_HANDLER,
26860 : ZEND_BW_XOR_SPEC_TMP_VAR_HANDLER,
26861 : ZEND_NULL_HANDLER,
26862 : ZEND_BW_XOR_SPEC_TMP_CV_HANDLER,
26863 : ZEND_BW_XOR_SPEC_VAR_CONST_HANDLER,
26864 : ZEND_BW_XOR_SPEC_VAR_TMP_HANDLER,
26865 : ZEND_BW_XOR_SPEC_VAR_VAR_HANDLER,
26866 : ZEND_NULL_HANDLER,
26867 : ZEND_BW_XOR_SPEC_VAR_CV_HANDLER,
26868 : ZEND_NULL_HANDLER,
26869 : ZEND_NULL_HANDLER,
26870 : ZEND_NULL_HANDLER,
26871 : ZEND_NULL_HANDLER,
26872 : ZEND_NULL_HANDLER,
26873 : ZEND_BW_XOR_SPEC_CV_CONST_HANDLER,
26874 : ZEND_BW_XOR_SPEC_CV_TMP_HANDLER,
26875 : ZEND_BW_XOR_SPEC_CV_VAR_HANDLER,
26876 : ZEND_NULL_HANDLER,
26877 : ZEND_BW_XOR_SPEC_CV_CV_HANDLER,
26878 : ZEND_BW_NOT_SPEC_CONST_HANDLER,
26879 : ZEND_BW_NOT_SPEC_CONST_HANDLER,
26880 : ZEND_BW_NOT_SPEC_CONST_HANDLER,
26881 : ZEND_BW_NOT_SPEC_CONST_HANDLER,
26882 : ZEND_BW_NOT_SPEC_CONST_HANDLER,
26883 : ZEND_BW_NOT_SPEC_TMP_HANDLER,
26884 : ZEND_BW_NOT_SPEC_TMP_HANDLER,
26885 : ZEND_BW_NOT_SPEC_TMP_HANDLER,
26886 : ZEND_BW_NOT_SPEC_TMP_HANDLER,
26887 : ZEND_BW_NOT_SPEC_TMP_HANDLER,
26888 : ZEND_BW_NOT_SPEC_VAR_HANDLER,
26889 : ZEND_BW_NOT_SPEC_VAR_HANDLER,
26890 : ZEND_BW_NOT_SPEC_VAR_HANDLER,
26891 : ZEND_BW_NOT_SPEC_VAR_HANDLER,
26892 : ZEND_BW_NOT_SPEC_VAR_HANDLER,
26893 : ZEND_NULL_HANDLER,
26894 : ZEND_NULL_HANDLER,
26895 : ZEND_NULL_HANDLER,
26896 : ZEND_NULL_HANDLER,
26897 : ZEND_NULL_HANDLER,
26898 : ZEND_BW_NOT_SPEC_CV_HANDLER,
26899 : ZEND_BW_NOT_SPEC_CV_HANDLER,
26900 : ZEND_BW_NOT_SPEC_CV_HANDLER,
26901 : ZEND_BW_NOT_SPEC_CV_HANDLER,
26902 : ZEND_BW_NOT_SPEC_CV_HANDLER,
26903 : ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
26904 : ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
26905 : ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
26906 : ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
26907 : ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
26908 : ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
26909 : ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
26910 : ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
26911 : ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
26912 : ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
26913 : ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
26914 : ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
26915 : ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
26916 : ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
26917 : ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
26918 : ZEND_NULL_HANDLER,
26919 : ZEND_NULL_HANDLER,
26920 : ZEND_NULL_HANDLER,
26921 : ZEND_NULL_HANDLER,
26922 : ZEND_NULL_HANDLER,
26923 : ZEND_BOOL_NOT_SPEC_CV_HANDLER,
26924 : ZEND_BOOL_NOT_SPEC_CV_HANDLER,
26925 : ZEND_BOOL_NOT_SPEC_CV_HANDLER,
26926 : ZEND_BOOL_NOT_SPEC_CV_HANDLER,
26927 : ZEND_BOOL_NOT_SPEC_CV_HANDLER,
26928 : ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER,
26929 : ZEND_BOOL_XOR_SPEC_CONST_TMP_HANDLER,
26930 : ZEND_BOOL_XOR_SPEC_CONST_VAR_HANDLER,
26931 : ZEND_NULL_HANDLER,
26932 : ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER,
26933 : ZEND_BOOL_XOR_SPEC_TMP_CONST_HANDLER,
26934 : ZEND_BOOL_XOR_SPEC_TMP_TMP_HANDLER,
26935 : ZEND_BOOL_XOR_SPEC_TMP_VAR_HANDLER,
26936 : ZEND_NULL_HANDLER,
26937 : ZEND_BOOL_XOR_SPEC_TMP_CV_HANDLER,
26938 : ZEND_BOOL_XOR_SPEC_VAR_CONST_HANDLER,
26939 : ZEND_BOOL_XOR_SPEC_VAR_TMP_HANDLER,
26940 : ZEND_BOOL_XOR_SPEC_VAR_VAR_HANDLER,
26941 : ZEND_NULL_HANDLER,
26942 : ZEND_BOOL_XOR_SPEC_VAR_CV_HANDLER,
26943 : ZEND_NULL_HANDLER,
26944 : ZEND_NULL_HANDLER,
26945 : ZEND_NULL_HANDLER,
26946 : ZEND_NULL_HANDLER,
26947 : ZEND_NULL_HANDLER,
26948 : ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER,
26949 : ZEND_BOOL_XOR_SPEC_CV_TMP_HANDLER,
26950 : ZEND_BOOL_XOR_SPEC_CV_VAR_HANDLER,
26951 : ZEND_NULL_HANDLER,
26952 : ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER,
26953 : ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER,
26954 : ZEND_IS_IDENTICAL_SPEC_CONST_TMP_HANDLER,
26955 : ZEND_IS_IDENTICAL_SPEC_CONST_VAR_HANDLER,
26956 : ZEND_NULL_HANDLER,
26957 : ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER,
26958 : ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER,
26959 : ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER,
26960 : ZEND_IS_IDENTICAL_SPEC_TMP_VAR_HANDLER,
26961 : ZEND_NULL_HANDLER,
26962 : ZEND_IS_IDENTICAL_SPEC_TMP_CV_HANDLER,
26963 : ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER,
26964 : ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER,
26965 : ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER,
26966 : ZEND_NULL_HANDLER,
26967 : ZEND_IS_IDENTICAL_SPEC_VAR_CV_HANDLER,
26968 : ZEND_NULL_HANDLER,
26969 : ZEND_NULL_HANDLER,
26970 : ZEND_NULL_HANDLER,
26971 : ZEND_NULL_HANDLER,
26972 : ZEND_NULL_HANDLER,
26973 : ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER,
26974 : ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER,
26975 : ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER,
26976 : ZEND_NULL_HANDLER,
26977 : ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER,
26978 : ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER,
26979 : ZEND_IS_NOT_IDENTICAL_SPEC_CONST_TMP_HANDLER,
26980 : ZEND_IS_NOT_IDENTICAL_SPEC_CONST_VAR_HANDLER,
26981 : ZEND_NULL_HANDLER,
26982 : ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER,
26983 : ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER,
26984 : ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER,
26985 : ZEND_IS_NOT_IDENTICAL_SPEC_TMP_VAR_HANDLER,
26986 : ZEND_NULL_HANDLER,
26987 : ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CV_HANDLER,
26988 : ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER,
26989 : ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER,
26990 : ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER,
26991 : ZEND_NULL_HANDLER,
26992 : ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CV_HANDLER,
26993 : ZEND_NULL_HANDLER,
26994 : ZEND_NULL_HANDLER,
26995 : ZEND_NULL_HANDLER,
26996 : ZEND_NULL_HANDLER,
26997 : ZEND_NULL_HANDLER,
26998 : ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER,
26999 : ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER,
27000 : ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER,
27001 : ZEND_NULL_HANDLER,
27002 : ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER,
27003 : ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
27004 : ZEND_IS_EQUAL_SPEC_CONST_TMP_HANDLER,
27005 : ZEND_IS_EQUAL_SPEC_CONST_VAR_HANDLER,
27006 : ZEND_NULL_HANDLER,
27007 : ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER,
27008 : ZEND_IS_EQUAL_SPEC_TMP_CONST_HANDLER,
27009 : ZEND_IS_EQUAL_SPEC_TMP_TMP_HANDLER,
27010 : ZEND_IS_EQUAL_SPEC_TMP_VAR_HANDLER,
27011 : ZEND_NULL_HANDLER,
27012 : ZEND_IS_EQUAL_SPEC_TMP_CV_HANDLER,
27013 : ZEND_IS_EQUAL_SPEC_VAR_CONST_HANDLER,
27014 : ZEND_IS_EQUAL_SPEC_VAR_TMP_HANDLER,
27015 : ZEND_IS_EQUAL_SPEC_VAR_VAR_HANDLER,
27016 : ZEND_NULL_HANDLER,
27017 : ZEND_IS_EQUAL_SPEC_VAR_CV_HANDLER,
27018 : ZEND_NULL_HANDLER,
27019 : ZEND_NULL_HANDLER,
27020 : ZEND_NULL_HANDLER,
27021 : ZEND_NULL_HANDLER,
27022 : ZEND_NULL_HANDLER,
27023 : ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER,
27024 : ZEND_IS_EQUAL_SPEC_CV_TMP_HANDLER,
27025 : ZEND_IS_EQUAL_SPEC_CV_VAR_HANDLER,
27026 : ZEND_NULL_HANDLER,
27027 : ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER,
27028 : ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
27029 : ZEND_IS_NOT_EQUAL_SPEC_CONST_TMP_HANDLER,
27030 : ZEND_IS_NOT_EQUAL_SPEC_CONST_VAR_HANDLER,
27031 : ZEND_NULL_HANDLER,
27032 : ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER,
27033 : ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_HANDLER,
27034 : ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_HANDLER,
27035 : ZEND_IS_NOT_EQUAL_SPEC_TMP_VAR_HANDLER,
27036 : ZEND_NULL_HANDLER,
27037 : ZEND_IS_NOT_EQUAL_SPEC_TMP_CV_HANDLER,
27038 : ZEND_IS_NOT_EQUAL_SPEC_VAR_CONST_HANDLER,
27039 : ZEND_IS_NOT_EQUAL_SPEC_VAR_TMP_HANDLER,
27040 : ZEND_IS_NOT_EQUAL_SPEC_VAR_VAR_HANDLER,
27041 : ZEND_NULL_HANDLER,
27042 : ZEND_IS_NOT_EQUAL_SPEC_VAR_CV_HANDLER,
27043 : ZEND_NULL_HANDLER,
27044 : ZEND_NULL_HANDLER,
27045 : ZEND_NULL_HANDLER,
27046 : ZEND_NULL_HANDLER,
27047 : ZEND_NULL_HANDLER,
27048 : ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER,
27049 : ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_HANDLER,
27050 : ZEND_IS_NOT_EQUAL_SPEC_CV_VAR_HANDLER,
27051 : ZEND_NULL_HANDLER,
27052 : ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER,
27053 : ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
27054 : ZEND_IS_SMALLER_SPEC_CONST_TMP_HANDLER,
27055 : ZEND_IS_SMALLER_SPEC_CONST_VAR_HANDLER,
27056 : ZEND_NULL_HANDLER,
27057 : ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER,
27058 : ZEND_IS_SMALLER_SPEC_TMP_CONST_HANDLER,
27059 : ZEND_IS_SMALLER_SPEC_TMP_TMP_HANDLER,
27060 : ZEND_IS_SMALLER_SPEC_TMP_VAR_HANDLER,
27061 : ZEND_NULL_HANDLER,
27062 : ZEND_IS_SMALLER_SPEC_TMP_CV_HANDLER,
27063 : ZEND_IS_SMALLER_SPEC_VAR_CONST_HANDLER,
27064 : ZEND_IS_SMALLER_SPEC_VAR_TMP_HANDLER,
27065 : ZEND_IS_SMALLER_SPEC_VAR_VAR_HANDLER,
27066 : ZEND_NULL_HANDLER,
27067 : ZEND_IS_SMALLER_SPEC_VAR_CV_HANDLER,
27068 : ZEND_NULL_HANDLER,
27069 : ZEND_NULL_HANDLER,
27070 : ZEND_NULL_HANDLER,
27071 : ZEND_NULL_HANDLER,
27072 : ZEND_NULL_HANDLER,
27073 : ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER,
27074 : ZEND_IS_SMALLER_SPEC_CV_TMP_HANDLER,
27075 : ZEND_IS_SMALLER_SPEC_CV_VAR_HANDLER,
27076 : ZEND_NULL_HANDLER,
27077 : ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER,
27078 : ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
27079 : ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMP_HANDLER,
27080 : ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_VAR_HANDLER,
27081 : ZEND_NULL_HANDLER,
27082 : ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER,
27083 : ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CONST_HANDLER,
27084 : ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_TMP_HANDLER,
27085 : ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_VAR_HANDLER,
27086 : ZEND_NULL_HANDLER,
27087 : ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CV_HANDLER,
27088 : ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CONST_HANDLER,
27089 : ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_TMP_HANDLER,
27090 : ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_VAR_HANDLER,
27091 : ZEND_NULL_HANDLER,
27092 : ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CV_HANDLER,
27093 : ZEND_NULL_HANDLER,
27094 : ZEND_NULL_HANDLER,
27095 : ZEND_NULL_HANDLER,
27096 : ZEND_NULL_HANDLER,
27097 : ZEND_NULL_HANDLER,
27098 : ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER,
27099 : ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMP_HANDLER,
27100 : ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_VAR_HANDLER,
27101 : ZEND_NULL_HANDLER,
27102 : ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER,
27103 : ZEND_CAST_SPEC_CONST_HANDLER,
27104 : ZEND_CAST_SPEC_CONST_HANDLER,
27105 : ZEND_CAST_SPEC_CONST_HANDLER,
27106 : ZEND_CAST_SPEC_CONST_HANDLER,
27107 : ZEND_CAST_SPEC_CONST_HANDLER,
27108 : ZEND_CAST_SPEC_TMP_HANDLER,
27109 : ZEND_CAST_SPEC_TMP_HANDLER,
27110 : ZEND_CAST_SPEC_TMP_HANDLER,
27111 : ZEND_CAST_SPEC_TMP_HANDLER,
27112 : ZEND_CAST_SPEC_TMP_HANDLER,
27113 : ZEND_CAST_SPEC_VAR_HANDLER,
27114 : ZEND_CAST_SPEC_VAR_HANDLER,
27115 : ZEND_CAST_SPEC_VAR_HANDLER,
27116 : ZEND_CAST_SPEC_VAR_HANDLER,
27117 : ZEND_CAST_SPEC_VAR_HANDLER,
27118 : ZEND_NULL_HANDLER,
27119 : ZEND_NULL_HANDLER,
27120 : ZEND_NULL_HANDLER,
27121 : ZEND_NULL_HANDLER,
27122 : ZEND_NULL_HANDLER,
27123 : ZEND_CAST_SPEC_CV_HANDLER,
27124 : ZEND_CAST_SPEC_CV_HANDLER,
27125 : ZEND_CAST_SPEC_CV_HANDLER,
27126 : ZEND_CAST_SPEC_CV_HANDLER,
27127 : ZEND_CAST_SPEC_CV_HANDLER,
27128 : ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
27129 : ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
27130 : ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
27131 : ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
27132 : ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
27133 : ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
27134 : ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
27135 : ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
27136 : ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
27137 : ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
27138 : ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
27139 : ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
27140 : ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
27141 : ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
27142 : ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
27143 : ZEND_NULL_HANDLER,
27144 : ZEND_NULL_HANDLER,
27145 : ZEND_NULL_HANDLER,
27146 : ZEND_NULL_HANDLER,
27147 : ZEND_NULL_HANDLER,
27148 : ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
27149 : ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
27150 : ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
27151 : ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
27152 : ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
27153 : ZEND_NULL_HANDLER,
27154 : ZEND_NULL_HANDLER,
27155 : ZEND_NULL_HANDLER,
27156 : ZEND_NULL_HANDLER,
27157 : ZEND_NULL_HANDLER,
27158 : ZEND_NULL_HANDLER,
27159 : ZEND_NULL_HANDLER,
27160 : ZEND_NULL_HANDLER,
27161 : ZEND_NULL_HANDLER,
27162 : ZEND_NULL_HANDLER,
27163 : ZEND_ASSIGN_ADD_SPEC_VAR_CONST_HANDLER,
27164 : ZEND_ASSIGN_ADD_SPEC_VAR_TMP_HANDLER,
27165 : ZEND_ASSIGN_ADD_SPEC_VAR_VAR_HANDLER,
27166 : ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_HANDLER,
27167 : ZEND_ASSIGN_ADD_SPEC_VAR_CV_HANDLER,
27168 : ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_HANDLER,
27169 : ZEND_ASSIGN_ADD_SPEC_UNUSED_TMP_HANDLER,
27170 : ZEND_ASSIGN_ADD_SPEC_UNUSED_VAR_HANDLER,
27171 : ZEND_ASSIGN_ADD_SPEC_UNUSED_UNUSED_HANDLER,
27172 : ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_HANDLER,
27173 : ZEND_ASSIGN_ADD_SPEC_CV_CONST_HANDLER,
27174 : ZEND_ASSIGN_ADD_SPEC_CV_TMP_HANDLER,
27175 : ZEND_ASSIGN_ADD_SPEC_CV_VAR_HANDLER,
27176 : ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_HANDLER,
27177 : ZEND_ASSIGN_ADD_SPEC_CV_CV_HANDLER,
27178 : ZEND_NULL_HANDLER,
27179 : ZEND_NULL_HANDLER,
27180 : ZEND_NULL_HANDLER,
27181 : ZEND_NULL_HANDLER,
27182 : ZEND_NULL_HANDLER,
27183 : ZEND_NULL_HANDLER,
27184 : ZEND_NULL_HANDLER,
27185 : ZEND_NULL_HANDLER,
27186 : ZEND_NULL_HANDLER,
27187 : ZEND_NULL_HANDLER,
27188 : ZEND_ASSIGN_SUB_SPEC_VAR_CONST_HANDLER,
27189 : ZEND_ASSIGN_SUB_SPEC_VAR_TMP_HANDLER,
27190 : ZEND_ASSIGN_SUB_SPEC_VAR_VAR_HANDLER,
27191 : ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_HANDLER,
27192 : ZEND_ASSIGN_SUB_SPEC_VAR_CV_HANDLER,
27193 : ZEND_ASSIGN_SUB_SPEC_UNUSED_CONST_HANDLER,
27194 : ZEND_ASSIGN_SUB_SPEC_UNUSED_TMP_HANDLER,
27195 : ZEND_ASSIGN_SUB_SPEC_UNUSED_VAR_HANDLER,
27196 : ZEND_ASSIGN_SUB_SPEC_UNUSED_UNUSED_HANDLER,
27197 : ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_HANDLER,
27198 : ZEND_ASSIGN_SUB_SPEC_CV_CONST_HANDLER,
27199 : ZEND_ASSIGN_SUB_SPEC_CV_TMP_HANDLER,
27200 : ZEND_ASSIGN_SUB_SPEC_CV_VAR_HANDLER,
27201 : ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_HANDLER,
27202 : ZEND_ASSIGN_SUB_SPEC_CV_CV_HANDLER,
27203 : ZEND_NULL_HANDLER,
27204 : ZEND_NULL_HANDLER,
27205 : ZEND_NULL_HANDLER,
27206 : ZEND_NULL_HANDLER,
27207 : ZEND_NULL_HANDLER,
27208 : ZEND_NULL_HANDLER,
27209 : ZEND_NULL_HANDLER,
27210 : ZEND_NULL_HANDLER,
27211 : ZEND_NULL_HANDLER,
27212 : ZEND_NULL_HANDLER,
27213 : ZEND_ASSIGN_MUL_SPEC_VAR_CONST_HANDLER,
27214 : ZEND_ASSIGN_MUL_SPEC_VAR_TMP_HANDLER,
27215 : ZEND_ASSIGN_MUL_SPEC_VAR_VAR_HANDLER,
27216 : ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_HANDLER,
27217 : ZEND_ASSIGN_MUL_SPEC_VAR_CV_HANDLER,
27218 : ZEND_ASSIGN_MUL_SPEC_UNUSED_CONST_HANDLER,
27219 : ZEND_ASSIGN_MUL_SPEC_UNUSED_TMP_HANDLER,
27220 : ZEND_ASSIGN_MUL_SPEC_UNUSED_VAR_HANDLER,
27221 : ZEND_ASSIGN_MUL_SPEC_UNUSED_UNUSED_HANDLER,
27222 : ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_HANDLER,
27223 : ZEND_ASSIGN_MUL_SPEC_CV_CONST_HANDLER,
27224 : ZEND_ASSIGN_MUL_SPEC_CV_TMP_HANDLER,
27225 : ZEND_ASSIGN_MUL_SPEC_CV_VAR_HANDLER,
27226 : ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_HANDLER,
27227 : ZEND_ASSIGN_MUL_SPEC_CV_CV_HANDLER,
27228 : ZEND_NULL_HANDLER,
27229 : ZEND_NULL_HANDLER,
27230 : ZEND_NULL_HANDLER,
27231 : ZEND_NULL_HANDLER,
27232 : ZEND_NULL_HANDLER,
27233 : ZEND_NULL_HANDLER,
27234 : ZEND_NULL_HANDLER,
27235 : ZEND_NULL_HANDLER,
27236 : ZEND_NULL_HANDLER,
27237 : ZEND_NULL_HANDLER,
27238 : ZEND_ASSIGN_DIV_SPEC_VAR_CONST_HANDLER,
27239 : ZEND_ASSIGN_DIV_SPEC_VAR_TMP_HANDLER,
27240 : ZEND_ASSIGN_DIV_SPEC_VAR_VAR_HANDLER,
27241 : ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_HANDLER,
27242 : ZEND_ASSIGN_DIV_SPEC_VAR_CV_HANDLER,
27243 : ZEND_ASSIGN_DIV_SPEC_UNUSED_CONST_HANDLER,
27244 : ZEND_ASSIGN_DIV_SPEC_UNUSED_TMP_HANDLER,
27245 : ZEND_ASSIGN_DIV_SPEC_UNUSED_VAR_HANDLER,
27246 : ZEND_ASSIGN_DIV_SPEC_UNUSED_UNUSED_HANDLER,
27247 : ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_HANDLER,
27248 : ZEND_ASSIGN_DIV_SPEC_CV_CONST_HANDLER,
27249 : ZEND_ASSIGN_DIV_SPEC_CV_TMP_HANDLER,
27250 : ZEND_ASSIGN_DIV_SPEC_CV_VAR_HANDLER,
27251 : ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_HANDLER,
27252 : ZEND_ASSIGN_DIV_SPEC_CV_CV_HANDLER,
27253 : ZEND_NULL_HANDLER,
27254 : ZEND_NULL_HANDLER,
27255 : ZEND_NULL_HANDLER,
27256 : ZEND_NULL_HANDLER,
27257 : ZEND_NULL_HANDLER,
27258 : ZEND_NULL_HANDLER,
27259 : ZEND_NULL_HANDLER,
27260 : ZEND_NULL_HANDLER,
27261 : ZEND_NULL_HANDLER,
27262 : ZEND_NULL_HANDLER,
27263 : ZEND_ASSIGN_MOD_SPEC_VAR_CONST_HANDLER,
27264 : ZEND_ASSIGN_MOD_SPEC_VAR_TMP_HANDLER,
27265 : ZEND_ASSIGN_MOD_SPEC_VAR_VAR_HANDLER,
27266 : ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_HANDLER,
27267 : ZEND_ASSIGN_MOD_SPEC_VAR_CV_HANDLER,
27268 : ZEND_ASSIGN_MOD_SPEC_UNUSED_CONST_HANDLER,
27269 : ZEND_ASSIGN_MOD_SPEC_UNUSED_TMP_HANDLER,
27270 : ZEND_ASSIGN_MOD_SPEC_UNUSED_VAR_HANDLER,
27271 : ZEND_ASSIGN_MOD_SPEC_UNUSED_UNUSED_HANDLER,
27272 : ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_HANDLER,
27273 : ZEND_ASSIGN_MOD_SPEC_CV_CONST_HANDLER,
27274 : ZEND_ASSIGN_MOD_SPEC_CV_TMP_HANDLER,
27275 : ZEND_ASSIGN_MOD_SPEC_CV_VAR_HANDLER,
27276 : ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_HANDLER,
27277 : ZEND_ASSIGN_MOD_SPEC_CV_CV_HANDLER,
27278 : ZEND_NULL_HANDLER,
27279 : ZEND_NULL_HANDLER,
27280 : ZEND_NULL_HANDLER,
27281 : ZEND_NULL_HANDLER,
27282 : ZEND_NULL_HANDLER,
27283 : ZEND_NULL_HANDLER,
27284 : ZEND_NULL_HANDLER,
27285 : ZEND_NULL_HANDLER,
27286 : ZEND_NULL_HANDLER,
27287 : ZEND_NULL_HANDLER,
27288 : ZEND_ASSIGN_SL_SPEC_VAR_CONST_HANDLER,
27289 : ZEND_ASSIGN_SL_SPEC_VAR_TMP_HANDLER,
27290 : ZEND_ASSIGN_SL_SPEC_VAR_VAR_HANDLER,
27291 : ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_HANDLER,
27292 : ZEND_ASSIGN_SL_SPEC_VAR_CV_HANDLER,
27293 : ZEND_ASSIGN_SL_SPEC_UNUSED_CONST_HANDLER,
27294 : ZEND_ASSIGN_SL_SPEC_UNUSED_TMP_HANDLER,
27295 : ZEND_ASSIGN_SL_SPEC_UNUSED_VAR_HANDLER,
27296 : ZEND_ASSIGN_SL_SPEC_UNUSED_UNUSED_HANDLER,
27297 : ZEND_ASSIGN_SL_SPEC_UNUSED_CV_HANDLER,
27298 : ZEND_ASSIGN_SL_SPEC_CV_CONST_HANDLER,
27299 : ZEND_ASSIGN_SL_SPEC_CV_TMP_HANDLER,
27300 : ZEND_ASSIGN_SL_SPEC_CV_VAR_HANDLER,
27301 : ZEND_ASSIGN_SL_SPEC_CV_UNUSED_HANDLER,
27302 : ZEND_ASSIGN_SL_SPEC_CV_CV_HANDLER,
27303 : ZEND_NULL_HANDLER,
27304 : ZEND_NULL_HANDLER,
27305 : ZEND_NULL_HANDLER,
27306 : ZEND_NULL_HANDLER,
27307 : ZEND_NULL_HANDLER,
27308 : ZEND_NULL_HANDLER,
27309 : ZEND_NULL_HANDLER,
27310 : ZEND_NULL_HANDLER,
27311 : ZEND_NULL_HANDLER,
27312 : ZEND_NULL_HANDLER,
27313 : ZEND_ASSIGN_SR_SPEC_VAR_CONST_HANDLER,
27314 : ZEND_ASSIGN_SR_SPEC_VAR_TMP_HANDLER,
27315 : ZEND_ASSIGN_SR_SPEC_VAR_VAR_HANDLER,
27316 : ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_HANDLER,
27317 : ZEND_ASSIGN_SR_SPEC_VAR_CV_HANDLER,
27318 : ZEND_ASSIGN_SR_SPEC_UNUSED_CONST_HANDLER,
27319 : ZEND_ASSIGN_SR_SPEC_UNUSED_TMP_HANDLER,
27320 : ZEND_ASSIGN_SR_SPEC_UNUSED_VAR_HANDLER,
27321 : ZEND_ASSIGN_SR_SPEC_UNUSED_UNUSED_HANDLER,
27322 : ZEND_ASSIGN_SR_SPEC_UNUSED_CV_HANDLER,
27323 : ZEND_ASSIGN_SR_SPEC_CV_CONST_HANDLER,
27324 : ZEND_ASSIGN_SR_SPEC_CV_TMP_HANDLER,
27325 : ZEND_ASSIGN_SR_SPEC_CV_VAR_HANDLER,
27326 : ZEND_ASSIGN_SR_SPEC_CV_UNUSED_HANDLER,
27327 : ZEND_ASSIGN_SR_SPEC_CV_CV_HANDLER,
27328 : ZEND_NULL_HANDLER,
27329 : ZEND_NULL_HANDLER,
27330 : ZEND_NULL_HANDLER,
27331 : ZEND_NULL_HANDLER,
27332 : ZEND_NULL_HANDLER,
27333 : ZEND_NULL_HANDLER,
27334 : ZEND_NULL_HANDLER,
27335 : ZEND_NULL_HANDLER,
27336 : ZEND_NULL_HANDLER,
27337 : ZEND_NULL_HANDLER,
27338 : ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_HANDLER,
27339 : ZEND_ASSIGN_CONCAT_SPEC_VAR_TMP_HANDLER,
27340 : ZEND_ASSIGN_CONCAT_SPEC_VAR_VAR_HANDLER,
27341 : ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_HANDLER,
27342 : ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_HANDLER,
27343 : ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CONST_HANDLER,
27344 : ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMP_HANDLER,
27345 : ZEND_ASSIGN_CONCAT_SPEC_UNUSED_VAR_HANDLER,
27346 : ZEND_ASSIGN_CONCAT_SPEC_UNUSED_UNUSED_HANDLER,
27347 : ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_HANDLER,
27348 : ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_HANDLER,
27349 : ZEND_ASSIGN_CONCAT_SPEC_CV_TMP_HANDLER,
27350 : ZEND_ASSIGN_CONCAT_SPEC_CV_VAR_HANDLER,
27351 : ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_HANDLER,
27352 : ZEND_ASSIGN_CONCAT_SPEC_CV_CV_HANDLER,
27353 : ZEND_NULL_HANDLER,
27354 : ZEND_NULL_HANDLER,
27355 : ZEND_NULL_HANDLER,
27356 : ZEND_NULL_HANDLER,
27357 : ZEND_NULL_HANDLER,
27358 : ZEND_NULL_HANDLER,
27359 : ZEND_NULL_HANDLER,
27360 : ZEND_NULL_HANDLER,
27361 : ZEND_NULL_HANDLER,
27362 : ZEND_NULL_HANDLER,
27363 : ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_HANDLER,
27364 : ZEND_ASSIGN_BW_OR_SPEC_VAR_TMP_HANDLER,
27365 : ZEND_ASSIGN_BW_OR_SPEC_VAR_VAR_HANDLER,
27366 : ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_HANDLER,
27367 : ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_HANDLER,
27368 : ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CONST_HANDLER,
27369 : ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMP_HANDLER,
27370 : ZEND_ASSIGN_BW_OR_SPEC_UNUSED_VAR_HANDLER,
27371 : ZEND_ASSIGN_BW_OR_SPEC_UNUSED_UNUSED_HANDLER,
27372 : ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_HANDLER,
27373 : ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_HANDLER,
27374 : ZEND_ASSIGN_BW_OR_SPEC_CV_TMP_HANDLER,
27375 : ZEND_ASSIGN_BW_OR_SPEC_CV_VAR_HANDLER,
27376 : ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_HANDLER,
27377 : ZEND_ASSIGN_BW_OR_SPEC_CV_CV_HANDLER,
27378 : ZEND_NULL_HANDLER,
27379 : ZEND_NULL_HANDLER,
27380 : ZEND_NULL_HANDLER,
27381 : ZEND_NULL_HANDLER,
27382 : ZEND_NULL_HANDLER,
27383 : ZEND_NULL_HANDLER,
27384 : ZEND_NULL_HANDLER,
27385 : ZEND_NULL_HANDLER,
27386 : ZEND_NULL_HANDLER,
27387 : ZEND_NULL_HANDLER,
27388 : ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_HANDLER,
27389 : ZEND_ASSIGN_BW_AND_SPEC_VAR_TMP_HANDLER,
27390 : ZEND_ASSIGN_BW_AND_SPEC_VAR_VAR_HANDLER,
27391 : ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_HANDLER,
27392 : ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_HANDLER,
27393 : ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CONST_HANDLER,
27394 : ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMP_HANDLER,
27395 : ZEND_ASSIGN_BW_AND_SPEC_UNUSED_VAR_HANDLER,
27396 : ZEND_ASSIGN_BW_AND_SPEC_UNUSED_UNUSED_HANDLER,
27397 : ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_HANDLER,
27398 : ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_HANDLER,
27399 : ZEND_ASSIGN_BW_AND_SPEC_CV_TMP_HANDLER,
27400 : ZEND_ASSIGN_BW_AND_SPEC_CV_VAR_HANDLER,
27401 : ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_HANDLER,
27402 : ZEND_ASSIGN_BW_AND_SPEC_CV_CV_HANDLER,
27403 : ZEND_NULL_HANDLER,
27404 : ZEND_NULL_HANDLER,
27405 : ZEND_NULL_HANDLER,
27406 : ZEND_NULL_HANDLER,
27407 : ZEND_NULL_HANDLER,
27408 : ZEND_NULL_HANDLER,
27409 : ZEND_NULL_HANDLER,
27410 : ZEND_NULL_HANDLER,
27411 : ZEND_NULL_HANDLER,
27412 : ZEND_NULL_HANDLER,
27413 : ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_HANDLER,
27414 : ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMP_HANDLER,
27415 : ZEND_ASSIGN_BW_XOR_SPEC_VAR_VAR_HANDLER,
27416 : ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_HANDLER,
27417 : ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_HANDLER,
27418 : ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_HANDLER,
27419 : ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMP_HANDLER,
27420 : ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_VAR_HANDLER,
27421 : ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_UNUSED_HANDLER,
27422 : ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_HANDLER,
27423 : ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER,
27424 : ZEND_ASSIGN_BW_XOR_SPEC_CV_TMP_HANDLER,
27425 : ZEND_ASSIGN_BW_XOR_SPEC_CV_VAR_HANDLER,
27426 : ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_HANDLER,
27427 : ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_HANDLER,
27428 : ZEND_NULL_HANDLER,
27429 : ZEND_NULL_HANDLER,
27430 : ZEND_NULL_HANDLER,
27431 : ZEND_NULL_HANDLER,
27432 : ZEND_NULL_HANDLER,
27433 : ZEND_NULL_HANDLER,
27434 : ZEND_NULL_HANDLER,
27435 : ZEND_NULL_HANDLER,
27436 : ZEND_NULL_HANDLER,
27437 : ZEND_NULL_HANDLER,
27438 : ZEND_PRE_INC_SPEC_VAR_HANDLER,
27439 : ZEND_PRE_INC_SPEC_VAR_HANDLER,
27440 : ZEND_PRE_INC_SPEC_VAR_HANDLER,
27441 : ZEND_PRE_INC_SPEC_VAR_HANDLER,
27442 : ZEND_PRE_INC_SPEC_VAR_HANDLER,
27443 : ZEND_NULL_HANDLER,
27444 : ZEND_NULL_HANDLER,
27445 : ZEND_NULL_HANDLER,
27446 : ZEND_NULL_HANDLER,
27447 : ZEND_NULL_HANDLER,
27448 : ZEND_PRE_INC_SPEC_CV_HANDLER,
27449 : ZEND_PRE_INC_SPEC_CV_HANDLER,
27450 : ZEND_PRE_INC_SPEC_CV_HANDLER,
27451 : ZEND_PRE_INC_SPEC_CV_HANDLER,
27452 : ZEND_PRE_INC_SPEC_CV_HANDLER,
27453 : ZEND_NULL_HANDLER,
27454 : ZEND_NULL_HANDLER,
27455 : ZEND_NULL_HANDLER,
27456 : ZEND_NULL_HANDLER,
27457 : ZEND_NULL_HANDLER,
27458 : ZEND_NULL_HANDLER,
27459 : ZEND_NULL_HANDLER,
27460 : ZEND_NULL_HANDLER,
27461 : ZEND_NULL_HANDLER,
27462 : ZEND_NULL_HANDLER,
27463 : ZEND_PRE_DEC_SPEC_VAR_HANDLER,
27464 : ZEND_PRE_DEC_SPEC_VAR_HANDLER,
27465 : ZEND_PRE_DEC_SPEC_VAR_HANDLER,
27466 : ZEND_PRE_DEC_SPEC_VAR_HANDLER,
27467 : ZEND_PRE_DEC_SPEC_VAR_HANDLER,
27468 : ZEND_NULL_HANDLER,
27469 : ZEND_NULL_HANDLER,
27470 : ZEND_NULL_HANDLER,
27471 : ZEND_NULL_HANDLER,
27472 : ZEND_NULL_HANDLER,
27473 : ZEND_PRE_DEC_SPEC_CV_HANDLER,
27474 : ZEND_PRE_DEC_SPEC_CV_HANDLER,
27475 : ZEND_PRE_DEC_SPEC_CV_HANDLER,
27476 : ZEND_PRE_DEC_SPEC_CV_HANDLER,
27477 : ZEND_PRE_DEC_SPEC_CV_HANDLER,
27478 : ZEND_NULL_HANDLER,
27479 : ZEND_NULL_HANDLER,
27480 : ZEND_NULL_HANDLER,
27481 : ZEND_NULL_HANDLER,
27482 : ZEND_NULL_HANDLER,
27483 : ZEND_NULL_HANDLER,
27484 : ZEND_NULL_HANDLER,
27485 : ZEND_NULL_HANDLER,
27486 : ZEND_NULL_HANDLER,
27487 : ZEND_NULL_HANDLER,
27488 : ZEND_POST_INC_SPEC_VAR_HANDLER,
27489 : ZEND_POST_INC_SPEC_VAR_HANDLER,
27490 : ZEND_POST_INC_SPEC_VAR_HANDLER,
27491 : ZEND_POST_INC_SPEC_VAR_HANDLER,
27492 : ZEND_POST_INC_SPEC_VAR_HANDLER,
27493 : ZEND_NULL_HANDLER,
27494 : ZEND_NULL_HANDLER,
27495 : ZEND_NULL_HANDLER,
27496 : ZEND_NULL_HANDLER,
27497 : ZEND_NULL_HANDLER,
27498 : ZEND_POST_INC_SPEC_CV_HANDLER,
27499 : ZEND_POST_INC_SPEC_CV_HANDLER,
27500 : ZEND_POST_INC_SPEC_CV_HANDLER,
27501 : ZEND_POST_INC_SPEC_CV_HANDLER,
27502 : ZEND_POST_INC_SPEC_CV_HANDLER,
27503 : ZEND_NULL_HANDLER,
27504 : ZEND_NULL_HANDLER,
27505 : ZEND_NULL_HANDLER,
27506 : ZEND_NULL_HANDLER,
27507 : ZEND_NULL_HANDLER,
27508 : ZEND_NULL_HANDLER,
27509 : ZEND_NULL_HANDLER,
27510 : ZEND_NULL_HANDLER,
27511 : ZEND_NULL_HANDLER,
27512 : ZEND_NULL_HANDLER,
27513 : ZEND_POST_DEC_SPEC_VAR_HANDLER,
27514 : ZEND_POST_DEC_SPEC_VAR_HANDLER,
27515 : ZEND_POST_DEC_SPEC_VAR_HANDLER,
27516 : ZEND_POST_DEC_SPEC_VAR_HANDLER,
27517 : ZEND_POST_DEC_SPEC_VAR_HANDLER,
27518 : ZEND_NULL_HANDLER,
27519 : ZEND_NULL_HANDLER,
27520 : ZEND_NULL_HANDLER,
27521 : ZEND_NULL_HANDLER,
27522 : ZEND_NULL_HANDLER,
27523 : ZEND_POST_DEC_SPEC_CV_HANDLER,
27524 : ZEND_POST_DEC_SPEC_CV_HANDLER,
27525 : ZEND_POST_DEC_SPEC_CV_HANDLER,
27526 : ZEND_POST_DEC_SPEC_CV_HANDLER,
27527 : ZEND_POST_DEC_SPEC_CV_HANDLER,
27528 : ZEND_NULL_HANDLER,
27529 : ZEND_NULL_HANDLER,
27530 : ZEND_NULL_HANDLER,
27531 : ZEND_NULL_HANDLER,
27532 : ZEND_NULL_HANDLER,
27533 : ZEND_NULL_HANDLER,
27534 : ZEND_NULL_HANDLER,
27535 : ZEND_NULL_HANDLER,
27536 : ZEND_NULL_HANDLER,
27537 : ZEND_NULL_HANDLER,
27538 : ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER,
27539 : ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER,
27540 : ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER,
27541 : ZEND_NULL_HANDLER,
27542 : ZEND_ASSIGN_SPEC_VAR_CV_HANDLER,
27543 : ZEND_NULL_HANDLER,
27544 : ZEND_NULL_HANDLER,
27545 : ZEND_NULL_HANDLER,
27546 : ZEND_NULL_HANDLER,
27547 : ZEND_NULL_HANDLER,
27548 : ZEND_ASSIGN_SPEC_CV_CONST_HANDLER,
27549 : ZEND_ASSIGN_SPEC_CV_TMP_HANDLER,
27550 : ZEND_ASSIGN_SPEC_CV_VAR_HANDLER,
27551 : ZEND_NULL_HANDLER,
27552 : ZEND_ASSIGN_SPEC_CV_CV_HANDLER,
27553 : ZEND_NULL_HANDLER,
27554 : ZEND_NULL_HANDLER,
27555 : ZEND_NULL_HANDLER,
27556 : ZEND_NULL_HANDLER,
27557 : ZEND_NULL_HANDLER,
27558 : ZEND_NULL_HANDLER,
27559 : ZEND_NULL_HANDLER,
27560 : ZEND_NULL_HANDLER,
27561 : ZEND_NULL_HANDLER,
27562 : ZEND_NULL_HANDLER,
27563 : ZEND_NULL_HANDLER,
27564 : ZEND_NULL_HANDLER,
27565 : ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER,
27566 : ZEND_NULL_HANDLER,
27567 : ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER,
27568 : ZEND_NULL_HANDLER,
27569 : ZEND_NULL_HANDLER,
27570 : ZEND_NULL_HANDLER,
27571 : ZEND_NULL_HANDLER,
27572 : ZEND_NULL_HANDLER,
27573 : ZEND_NULL_HANDLER,
27574 : ZEND_NULL_HANDLER,
27575 : ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER,
27576 : ZEND_NULL_HANDLER,
27577 : ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER,
27578 : ZEND_ECHO_SPEC_CONST_HANDLER,
27579 : ZEND_ECHO_SPEC_CONST_HANDLER,
27580 : ZEND_ECHO_SPEC_CONST_HANDLER,
27581 : ZEND_ECHO_SPEC_CONST_HANDLER,
27582 : ZEND_ECHO_SPEC_CONST_HANDLER,
27583 : ZEND_ECHO_SPEC_TMP_HANDLER,
27584 : ZEND_ECHO_SPEC_TMP_HANDLER,
27585 : ZEND_ECHO_SPEC_TMP_HANDLER,
27586 : ZEND_ECHO_SPEC_TMP_HANDLER,
27587 : ZEND_ECHO_SPEC_TMP_HANDLER,
27588 : ZEND_ECHO_SPEC_VAR_HANDLER,
27589 : ZEND_ECHO_SPEC_VAR_HANDLER,
27590 : ZEND_ECHO_SPEC_VAR_HANDLER,
27591 : ZEND_ECHO_SPEC_VAR_HANDLER,
27592 : ZEND_ECHO_SPEC_VAR_HANDLER,
27593 : ZEND_NULL_HANDLER,
27594 : ZEND_NULL_HANDLER,
27595 : ZEND_NULL_HANDLER,
27596 : ZEND_NULL_HANDLER,
27597 : ZEND_NULL_HANDLER,
27598 : ZEND_ECHO_SPEC_CV_HANDLER,
27599 : ZEND_ECHO_SPEC_CV_HANDLER,
27600 : ZEND_ECHO_SPEC_CV_HANDLER,
27601 : ZEND_ECHO_SPEC_CV_HANDLER,
27602 : ZEND_ECHO_SPEC_CV_HANDLER,
27603 : ZEND_PRINT_SPEC_CONST_HANDLER,
27604 : ZEND_PRINT_SPEC_CONST_HANDLER,
27605 : ZEND_PRINT_SPEC_CONST_HANDLER,
27606 : ZEND_PRINT_SPEC_CONST_HANDLER,
27607 : ZEND_PRINT_SPEC_CONST_HANDLER,
27608 : ZEND_PRINT_SPEC_TMP_HANDLER,
27609 : ZEND_PRINT_SPEC_TMP_HANDLER,
27610 : ZEND_PRINT_SPEC_TMP_HANDLER,
27611 : ZEND_PRINT_SPEC_TMP_HANDLER,
27612 : ZEND_PRINT_SPEC_TMP_HANDLER,
27613 : ZEND_PRINT_SPEC_VAR_HANDLER,
27614 : ZEND_PRINT_SPEC_VAR_HANDLER,
27615 : ZEND_PRINT_SPEC_VAR_HANDLER,
27616 : ZEND_PRINT_SPEC_VAR_HANDLER,
27617 : ZEND_PRINT_SPEC_VAR_HANDLER,
27618 : ZEND_NULL_HANDLER,
27619 : ZEND_NULL_HANDLER,
27620 : ZEND_NULL_HANDLER,
27621 : ZEND_NULL_HANDLER,
27622 : ZEND_NULL_HANDLER,
27623 : ZEND_PRINT_SPEC_CV_HANDLER,
27624 : ZEND_PRINT_SPEC_CV_HANDLER,
27625 : ZEND_PRINT_SPEC_CV_HANDLER,
27626 : ZEND_PRINT_SPEC_CV_HANDLER,
27627 : ZEND_PRINT_SPEC_CV_HANDLER,
27628 : ZEND_JMP_SPEC_HANDLER,
27629 : ZEND_JMP_SPEC_HANDLER,
27630 : ZEND_JMP_SPEC_HANDLER,
27631 : ZEND_JMP_SPEC_HANDLER,
27632 : ZEND_JMP_SPEC_HANDLER,
27633 : ZEND_JMP_SPEC_HANDLER,
27634 : ZEND_JMP_SPEC_HANDLER,
27635 : ZEND_JMP_SPEC_HANDLER,
27636 : ZEND_JMP_SPEC_HANDLER,
27637 : ZEND_JMP_SPEC_HANDLER,
27638 : ZEND_JMP_SPEC_HANDLER,
27639 : ZEND_JMP_SPEC_HANDLER,
27640 : ZEND_JMP_SPEC_HANDLER,
27641 : ZEND_JMP_SPEC_HANDLER,
27642 : ZEND_JMP_SPEC_HANDLER,
27643 : ZEND_JMP_SPEC_HANDLER,
27644 : ZEND_JMP_SPEC_HANDLER,
27645 : ZEND_JMP_SPEC_HANDLER,
27646 : ZEND_JMP_SPEC_HANDLER,
27647 : ZEND_JMP_SPEC_HANDLER,
27648 : ZEND_JMP_SPEC_HANDLER,
27649 : ZEND_JMP_SPEC_HANDLER,
27650 : ZEND_JMP_SPEC_HANDLER,
27651 : ZEND_JMP_SPEC_HANDLER,
27652 : ZEND_JMP_SPEC_HANDLER,
27653 : ZEND_JMPZ_SPEC_CONST_HANDLER,
27654 : ZEND_JMPZ_SPEC_CONST_HANDLER,
27655 : ZEND_JMPZ_SPEC_CONST_HANDLER,
27656 : ZEND_JMPZ_SPEC_CONST_HANDLER,
27657 : ZEND_JMPZ_SPEC_CONST_HANDLER,
27658 : ZEND_JMPZ_SPEC_TMP_HANDLER,
27659 : ZEND_JMPZ_SPEC_TMP_HANDLER,
27660 : ZEND_JMPZ_SPEC_TMP_HANDLER,
27661 : ZEND_JMPZ_SPEC_TMP_HANDLER,
27662 : ZEND_JMPZ_SPEC_TMP_HANDLER,
27663 : ZEND_JMPZ_SPEC_VAR_HANDLER,
27664 : ZEND_JMPZ_SPEC_VAR_HANDLER,
27665 : ZEND_JMPZ_SPEC_VAR_HANDLER,
27666 : ZEND_JMPZ_SPEC_VAR_HANDLER,
27667 : ZEND_JMPZ_SPEC_VAR_HANDLER,
27668 : ZEND_NULL_HANDLER,
27669 : ZEND_NULL_HANDLER,
27670 : ZEND_NULL_HANDLER,
27671 : ZEND_NULL_HANDLER,
27672 : ZEND_NULL_HANDLER,
27673 : ZEND_JMPZ_SPEC_CV_HANDLER,
27674 : ZEND_JMPZ_SPEC_CV_HANDLER,
27675 : ZEND_JMPZ_SPEC_CV_HANDLER,
27676 : ZEND_JMPZ_SPEC_CV_HANDLER,
27677 : ZEND_JMPZ_SPEC_CV_HANDLER,
27678 : ZEND_JMPNZ_SPEC_CONST_HANDLER,
27679 : ZEND_JMPNZ_SPEC_CONST_HANDLER,
27680 : ZEND_JMPNZ_SPEC_CONST_HANDLER,
27681 : ZEND_JMPNZ_SPEC_CONST_HANDLER,
27682 : ZEND_JMPNZ_SPEC_CONST_HANDLER,
27683 : ZEND_JMPNZ_SPEC_TMP_HANDLER,
27684 : ZEND_JMPNZ_SPEC_TMP_HANDLER,
27685 : ZEND_JMPNZ_SPEC_TMP_HANDLER,
27686 : ZEND_JMPNZ_SPEC_TMP_HANDLER,
27687 : ZEND_JMPNZ_SPEC_TMP_HANDLER,
27688 : ZEND_JMPNZ_SPEC_VAR_HANDLER,
27689 : ZEND_JMPNZ_SPEC_VAR_HANDLER,
27690 : ZEND_JMPNZ_SPEC_VAR_HANDLER,
27691 : ZEND_JMPNZ_SPEC_VAR_HANDLER,
27692 : ZEND_JMPNZ_SPEC_VAR_HANDLER,
27693 : ZEND_NULL_HANDLER,
27694 : ZEND_NULL_HANDLER,
27695 : ZEND_NULL_HANDLER,
27696 : ZEND_NULL_HANDLER,
27697 : ZEND_NULL_HANDLER,
27698 : ZEND_JMPNZ_SPEC_CV_HANDLER,
27699 : ZEND_JMPNZ_SPEC_CV_HANDLER,
27700 : ZEND_JMPNZ_SPEC_CV_HANDLER,
27701 : ZEND_JMPNZ_SPEC_CV_HANDLER,
27702 : ZEND_JMPNZ_SPEC_CV_HANDLER,
27703 : ZEND_JMPZNZ_SPEC_CONST_HANDLER,
27704 : ZEND_JMPZNZ_SPEC_CONST_HANDLER,
27705 : ZEND_JMPZNZ_SPEC_CONST_HANDLER,
27706 : ZEND_JMPZNZ_SPEC_CONST_HANDLER,
27707 : ZEND_JMPZNZ_SPEC_CONST_HANDLER,
27708 : ZEND_JMPZNZ_SPEC_TMP_HANDLER,
27709 : ZEND_JMPZNZ_SPEC_TMP_HANDLER,
27710 : ZEND_JMPZNZ_SPEC_TMP_HANDLER,
27711 : ZEND_JMPZNZ_SPEC_TMP_HANDLER,
27712 : ZEND_JMPZNZ_SPEC_TMP_HANDLER,
27713 : ZEND_JMPZNZ_SPEC_VAR_HANDLER,
27714 : ZEND_JMPZNZ_SPEC_VAR_HANDLER,
27715 : ZEND_JMPZNZ_SPEC_VAR_HANDLER,
27716 : ZEND_JMPZNZ_SPEC_VAR_HANDLER,
27717 : ZEND_JMPZNZ_SPEC_VAR_HANDLER,
27718 : ZEND_NULL_HANDLER,
27719 : ZEND_NULL_HANDLER,
27720 : ZEND_NULL_HANDLER,
27721 : ZEND_NULL_HANDLER,
27722 : ZEND_NULL_HANDLER,
27723 : ZEND_JMPZNZ_SPEC_CV_HANDLER,
27724 : ZEND_JMPZNZ_SPEC_CV_HANDLER,
27725 : ZEND_JMPZNZ_SPEC_CV_HANDLER,
27726 : ZEND_JMPZNZ_SPEC_CV_HANDLER,
27727 : ZEND_JMPZNZ_SPEC_CV_HANDLER,
27728 : ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
27729 : ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
27730 : ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
27731 : ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
27732 : ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
27733 : ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
27734 : ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
27735 : ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
27736 : ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
27737 : ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
27738 : ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
27739 : ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
27740 : ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
27741 : ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
27742 : ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
27743 : ZEND_NULL_HANDLER,
27744 : ZEND_NULL_HANDLER,
27745 : ZEND_NULL_HANDLER,
27746 : ZEND_NULL_HANDLER,
27747 : ZEND_NULL_HANDLER,
27748 : ZEND_JMPZ_EX_SPEC_CV_HANDLER,
27749 : ZEND_JMPZ_EX_SPEC_CV_HANDLER,
27750 : ZEND_JMPZ_EX_SPEC_CV_HANDLER,
27751 : ZEND_JMPZ_EX_SPEC_CV_HANDLER,
27752 : ZEND_JMPZ_EX_SPEC_CV_HANDLER,
27753 : ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
27754 : ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
27755 : ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
27756 : ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
27757 : ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
27758 : ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
27759 : ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
27760 : ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
27761 : ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
27762 : ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
27763 : ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
27764 : ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
27765 : ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
27766 : ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
27767 : ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
27768 : ZEND_NULL_HANDLER,
27769 : ZEND_NULL_HANDLER,
27770 : ZEND_NULL_HANDLER,
27771 : ZEND_NULL_HANDLER,
27772 : ZEND_NULL_HANDLER,
27773 : ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
27774 : ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
27775 : ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
27776 : ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
27777 : ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
27778 : ZEND_CASE_SPEC_CONST_CONST_HANDLER,
27779 : ZEND_CASE_SPEC_CONST_TMP_HANDLER,
27780 : ZEND_CASE_SPEC_CONST_VAR_HANDLER,
27781 : ZEND_NULL_HANDLER,
27782 : ZEND_CASE_SPEC_CONST_CV_HANDLER,
27783 : ZEND_CASE_SPEC_TMP_CONST_HANDLER,
27784 : ZEND_CASE_SPEC_TMP_TMP_HANDLER,
27785 : ZEND_CASE_SPEC_TMP_VAR_HANDLER,
27786 : ZEND_NULL_HANDLER,
27787 : ZEND_CASE_SPEC_TMP_CV_HANDLER,
27788 : ZEND_CASE_SPEC_VAR_CONST_HANDLER,
27789 : ZEND_CASE_SPEC_VAR_TMP_HANDLER,
27790 : ZEND_CASE_SPEC_VAR_VAR_HANDLER,
27791 : ZEND_NULL_HANDLER,
27792 : ZEND_CASE_SPEC_VAR_CV_HANDLER,
27793 : ZEND_NULL_HANDLER,
27794 : ZEND_NULL_HANDLER,
27795 : ZEND_NULL_HANDLER,
27796 : ZEND_NULL_HANDLER,
27797 : ZEND_NULL_HANDLER,
27798 : ZEND_CASE_SPEC_CV_CONST_HANDLER,
27799 : ZEND_CASE_SPEC_CV_TMP_HANDLER,
27800 : ZEND_CASE_SPEC_CV_VAR_HANDLER,
27801 : ZEND_NULL_HANDLER,
27802 : ZEND_CASE_SPEC_CV_CV_HANDLER,
27803 : ZEND_NULL_HANDLER,
27804 : ZEND_NULL_HANDLER,
27805 : ZEND_NULL_HANDLER,
27806 : ZEND_NULL_HANDLER,
27807 : ZEND_NULL_HANDLER,
27808 : ZEND_SWITCH_FREE_SPEC_TMP_HANDLER,
27809 : ZEND_SWITCH_FREE_SPEC_TMP_HANDLER,
27810 : ZEND_SWITCH_FREE_SPEC_TMP_HANDLER,
27811 : ZEND_SWITCH_FREE_SPEC_TMP_HANDLER,
27812 : ZEND_SWITCH_FREE_SPEC_TMP_HANDLER,
27813 : ZEND_SWITCH_FREE_SPEC_VAR_HANDLER,
27814 : ZEND_SWITCH_FREE_SPEC_VAR_HANDLER,
27815 : ZEND_SWITCH_FREE_SPEC_VAR_HANDLER,
27816 : ZEND_SWITCH_FREE_SPEC_VAR_HANDLER,
27817 : ZEND_SWITCH_FREE_SPEC_VAR_HANDLER,
27818 : ZEND_NULL_HANDLER,
27819 : ZEND_NULL_HANDLER,
27820 : ZEND_NULL_HANDLER,
27821 : ZEND_NULL_HANDLER,
27822 : ZEND_NULL_HANDLER,
27823 : ZEND_NULL_HANDLER,
27824 : ZEND_NULL_HANDLER,
27825 : ZEND_NULL_HANDLER,
27826 : ZEND_NULL_HANDLER,
27827 : ZEND_NULL_HANDLER,
27828 : ZEND_BRK_SPEC_CONST_HANDLER,
27829 : ZEND_BRK_SPEC_TMP_HANDLER,
27830 : ZEND_BRK_SPEC_VAR_HANDLER,
27831 : ZEND_NULL_HANDLER,
27832 : ZEND_BRK_SPEC_CV_HANDLER,
27833 : ZEND_BRK_SPEC_CONST_HANDLER,
27834 : ZEND_BRK_SPEC_TMP_HANDLER,
27835 : ZEND_BRK_SPEC_VAR_HANDLER,
27836 : ZEND_NULL_HANDLER,
27837 : ZEND_BRK_SPEC_CV_HANDLER,
27838 : ZEND_BRK_SPEC_CONST_HANDLER,
27839 : ZEND_BRK_SPEC_TMP_HANDLER,
27840 : ZEND_BRK_SPEC_VAR_HANDLER,
27841 : ZEND_NULL_HANDLER,
27842 : ZEND_BRK_SPEC_CV_HANDLER,
27843 : ZEND_BRK_SPEC_CONST_HANDLER,
27844 : ZEND_BRK_SPEC_TMP_HANDLER,
27845 : ZEND_BRK_SPEC_VAR_HANDLER,
27846 : ZEND_NULL_HANDLER,
27847 : ZEND_BRK_SPEC_CV_HANDLER,
27848 : ZEND_BRK_SPEC_CONST_HANDLER,
27849 : ZEND_BRK_SPEC_TMP_HANDLER,
27850 : ZEND_BRK_SPEC_VAR_HANDLER,
27851 : ZEND_NULL_HANDLER,
27852 : ZEND_BRK_SPEC_CV_HANDLER,
27853 : ZEND_CONT_SPEC_CONST_HANDLER,
27854 : ZEND_CONT_SPEC_TMP_HANDLER,
27855 : ZEND_CONT_SPEC_VAR_HANDLER,
27856 : ZEND_NULL_HANDLER,
27857 : ZEND_CONT_SPEC_CV_HANDLER,
27858 : ZEND_CONT_SPEC_CONST_HANDLER,
27859 : ZEND_CONT_SPEC_TMP_HANDLER,
27860 : ZEND_CONT_SPEC_VAR_HANDLER,
27861 : ZEND_NULL_HANDLER,
27862 : ZEND_CONT_SPEC_CV_HANDLER,
27863 : ZEND_CONT_SPEC_CONST_HANDLER,
27864 : ZEND_CONT_SPEC_TMP_HANDLER,
27865 : ZEND_CONT_SPEC_VAR_HANDLER,
27866 : ZEND_NULL_HANDLER,
27867 : ZEND_CONT_SPEC_CV_HANDLER,
27868 : ZEND_CONT_SPEC_CONST_HANDLER,
27869 : ZEND_CONT_SPEC_TMP_HANDLER,
27870 : ZEND_CONT_SPEC_VAR_HANDLER,
27871 : ZEND_NULL_HANDLER,
27872 : ZEND_CONT_SPEC_CV_HANDLER,
27873 : ZEND_CONT_SPEC_CONST_HANDLER,
27874 : ZEND_CONT_SPEC_TMP_HANDLER,
27875 : ZEND_CONT_SPEC_VAR_HANDLER,
27876 : ZEND_NULL_HANDLER,
27877 : ZEND_CONT_SPEC_CV_HANDLER,
27878 : ZEND_BOOL_SPEC_CONST_HANDLER,
27879 : ZEND_BOOL_SPEC_CONST_HANDLER,
27880 : ZEND_BOOL_SPEC_CONST_HANDLER,
27881 : ZEND_BOOL_SPEC_CONST_HANDLER,
27882 : ZEND_BOOL_SPEC_CONST_HANDLER,
27883 : ZEND_BOOL_SPEC_TMP_HANDLER,
27884 : ZEND_BOOL_SPEC_TMP_HANDLER,
27885 : ZEND_BOOL_SPEC_TMP_HANDLER,
27886 : ZEND_BOOL_SPEC_TMP_HANDLER,
27887 : ZEND_BOOL_SPEC_TMP_HANDLER,
27888 : ZEND_BOOL_SPEC_VAR_HANDLER,
27889 : ZEND_BOOL_SPEC_VAR_HANDLER,
27890 : ZEND_BOOL_SPEC_VAR_HANDLER,
27891 : ZEND_BOOL_SPEC_VAR_HANDLER,
27892 : ZEND_BOOL_SPEC_VAR_HANDLER,
27893 : ZEND_NULL_HANDLER,
27894 : ZEND_NULL_HANDLER,
27895 : ZEND_NULL_HANDLER,
27896 : ZEND_NULL_HANDLER,
27897 : ZEND_NULL_HANDLER,
27898 : ZEND_BOOL_SPEC_CV_HANDLER,
27899 : ZEND_BOOL_SPEC_CV_HANDLER,
27900 : ZEND_BOOL_SPEC_CV_HANDLER,
27901 : ZEND_BOOL_SPEC_CV_HANDLER,
27902 : ZEND_BOOL_SPEC_CV_HANDLER,
27903 : ZEND_INIT_STRING_SPEC_HANDLER,
27904 : ZEND_INIT_STRING_SPEC_HANDLER,
27905 : ZEND_INIT_STRING_SPEC_HANDLER,
27906 : ZEND_INIT_STRING_SPEC_HANDLER,
27907 : ZEND_INIT_STRING_SPEC_HANDLER,
27908 : ZEND_INIT_STRING_SPEC_HANDLER,
27909 : ZEND_INIT_STRING_SPEC_HANDLER,
27910 : ZEND_INIT_STRING_SPEC_HANDLER,
27911 : ZEND_INIT_STRING_SPEC_HANDLER,
27912 : ZEND_INIT_STRING_SPEC_HANDLER,
27913 : ZEND_INIT_STRING_SPEC_HANDLER,
27914 : ZEND_INIT_STRING_SPEC_HANDLER,
27915 : ZEND_INIT_STRING_SPEC_HANDLER,
27916 : ZEND_INIT_STRING_SPEC_HANDLER,
27917 : ZEND_INIT_STRING_SPEC_HANDLER,
27918 : ZEND_INIT_STRING_SPEC_HANDLER,
27919 : ZEND_INIT_STRING_SPEC_HANDLER,
27920 : ZEND_INIT_STRING_SPEC_HANDLER,
27921 : ZEND_INIT_STRING_SPEC_HANDLER,
27922 : ZEND_INIT_STRING_SPEC_HANDLER,
27923 : ZEND_INIT_STRING_SPEC_HANDLER,
27924 : ZEND_INIT_STRING_SPEC_HANDLER,
27925 : ZEND_INIT_STRING_SPEC_HANDLER,
27926 : ZEND_INIT_STRING_SPEC_HANDLER,
27927 : ZEND_INIT_STRING_SPEC_HANDLER,
27928 : ZEND_NULL_HANDLER,
27929 : ZEND_NULL_HANDLER,
27930 : ZEND_NULL_HANDLER,
27931 : ZEND_NULL_HANDLER,
27932 : ZEND_NULL_HANDLER,
27933 : ZEND_ADD_CHAR_SPEC_TMP_CONST_HANDLER,
27934 : ZEND_NULL_HANDLER,
27935 : ZEND_NULL_HANDLER,
27936 : ZEND_NULL_HANDLER,
27937 : ZEND_NULL_HANDLER,
27938 : ZEND_NULL_HANDLER,
27939 : ZEND_NULL_HANDLER,
27940 : ZEND_NULL_HANDLER,
27941 : ZEND_NULL_HANDLER,
27942 : ZEND_NULL_HANDLER,
27943 : ZEND_NULL_HANDLER,
27944 : ZEND_NULL_HANDLER,
27945 : ZEND_NULL_HANDLER,
27946 : ZEND_NULL_HANDLER,
27947 : ZEND_NULL_HANDLER,
27948 : ZEND_NULL_HANDLER,
27949 : ZEND_NULL_HANDLER,
27950 : ZEND_NULL_HANDLER,
27951 : ZEND_NULL_HANDLER,
27952 : ZEND_NULL_HANDLER,
27953 : ZEND_NULL_HANDLER,
27954 : ZEND_NULL_HANDLER,
27955 : ZEND_NULL_HANDLER,
27956 : ZEND_NULL_HANDLER,
27957 : ZEND_NULL_HANDLER,
27958 : ZEND_ADD_STRING_SPEC_TMP_CONST_HANDLER,
27959 : ZEND_NULL_HANDLER,
27960 : ZEND_NULL_HANDLER,
27961 : ZEND_NULL_HANDLER,
27962 : ZEND_NULL_HANDLER,
27963 : ZEND_NULL_HANDLER,
27964 : ZEND_NULL_HANDLER,
27965 : ZEND_NULL_HANDLER,
27966 : ZEND_NULL_HANDLER,
27967 : ZEND_NULL_HANDLER,
27968 : ZEND_NULL_HANDLER,
27969 : ZEND_NULL_HANDLER,
27970 : ZEND_NULL_HANDLER,
27971 : ZEND_NULL_HANDLER,
27972 : ZEND_NULL_HANDLER,
27973 : ZEND_NULL_HANDLER,
27974 : ZEND_NULL_HANDLER,
27975 : ZEND_NULL_HANDLER,
27976 : ZEND_NULL_HANDLER,
27977 : ZEND_NULL_HANDLER,
27978 : ZEND_NULL_HANDLER,
27979 : ZEND_NULL_HANDLER,
27980 : ZEND_NULL_HANDLER,
27981 : ZEND_NULL_HANDLER,
27982 : ZEND_NULL_HANDLER,
27983 : ZEND_NULL_HANDLER,
27984 : ZEND_ADD_VAR_SPEC_TMP_TMP_HANDLER,
27985 : ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER,
27986 : ZEND_NULL_HANDLER,
27987 : ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER,
27988 : ZEND_NULL_HANDLER,
27989 : ZEND_NULL_HANDLER,
27990 : ZEND_NULL_HANDLER,
27991 : ZEND_NULL_HANDLER,
27992 : ZEND_NULL_HANDLER,
27993 : ZEND_NULL_HANDLER,
27994 : ZEND_NULL_HANDLER,
27995 : ZEND_NULL_HANDLER,
27996 : ZEND_NULL_HANDLER,
27997 : ZEND_NULL_HANDLER,
27998 : ZEND_NULL_HANDLER,
27999 : ZEND_NULL_HANDLER,
28000 : ZEND_NULL_HANDLER,
28001 : ZEND_NULL_HANDLER,
28002 : ZEND_NULL_HANDLER,
28003 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28004 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28005 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28006 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28007 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28008 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28009 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28010 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28011 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28012 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28013 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28014 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28015 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28016 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28017 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28018 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28019 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28020 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28021 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28022 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28023 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28024 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28025 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28026 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28027 : ZEND_BEGIN_SILENCE_SPEC_HANDLER,
28028 : ZEND_NULL_HANDLER,
28029 : ZEND_NULL_HANDLER,
28030 : ZEND_NULL_HANDLER,
28031 : ZEND_NULL_HANDLER,
28032 : ZEND_NULL_HANDLER,
28033 : ZEND_END_SILENCE_SPEC_TMP_HANDLER,
28034 : ZEND_END_SILENCE_SPEC_TMP_HANDLER,
28035 : ZEND_END_SILENCE_SPEC_TMP_HANDLER,
28036 : ZEND_END_SILENCE_SPEC_TMP_HANDLER,
28037 : ZEND_END_SILENCE_SPEC_TMP_HANDLER,
28038 : ZEND_NULL_HANDLER,
28039 : ZEND_NULL_HANDLER,
28040 : ZEND_NULL_HANDLER,
28041 : ZEND_NULL_HANDLER,
28042 : ZEND_NULL_HANDLER,
28043 : ZEND_NULL_HANDLER,
28044 : ZEND_NULL_HANDLER,
28045 : ZEND_NULL_HANDLER,
28046 : ZEND_NULL_HANDLER,
28047 : ZEND_NULL_HANDLER,
28048 : ZEND_NULL_HANDLER,
28049 : ZEND_NULL_HANDLER,
28050 : ZEND_NULL_HANDLER,
28051 : ZEND_NULL_HANDLER,
28052 : ZEND_NULL_HANDLER,
28053 : ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
28054 : ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER,
28055 : ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER,
28056 : ZEND_NULL_HANDLER,
28057 : ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER,
28058 : ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
28059 : ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER,
28060 : ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER,
28061 : ZEND_NULL_HANDLER,
28062 : ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER,
28063 : ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
28064 : ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER,
28065 : ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER,
28066 : ZEND_NULL_HANDLER,
28067 : ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER,
28068 : ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
28069 : ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER,
28070 : ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER,
28071 : ZEND_NULL_HANDLER,
28072 : ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER,
28073 : ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
28074 : ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER,
28075 : ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER,
28076 : ZEND_NULL_HANDLER,
28077 : ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER,
28078 : ZEND_DO_FCALL_SPEC_CONST_HANDLER,
28079 : ZEND_DO_FCALL_SPEC_CONST_HANDLER,
28080 : ZEND_DO_FCALL_SPEC_CONST_HANDLER,
28081 : ZEND_DO_FCALL_SPEC_CONST_HANDLER,
28082 : ZEND_DO_FCALL_SPEC_CONST_HANDLER,
28083 : ZEND_NULL_HANDLER,
28084 : ZEND_NULL_HANDLER,
28085 : ZEND_NULL_HANDLER,
28086 : ZEND_NULL_HANDLER,
28087 : ZEND_NULL_HANDLER,
28088 : ZEND_NULL_HANDLER,
28089 : ZEND_NULL_HANDLER,
28090 : ZEND_NULL_HANDLER,
28091 : ZEND_NULL_HANDLER,
28092 : ZEND_NULL_HANDLER,
28093 : ZEND_NULL_HANDLER,
28094 : ZEND_NULL_HANDLER,
28095 : ZEND_NULL_HANDLER,
28096 : ZEND_NULL_HANDLER,
28097 : ZEND_NULL_HANDLER,
28098 : ZEND_NULL_HANDLER,
28099 : ZEND_NULL_HANDLER,
28100 : ZEND_NULL_HANDLER,
28101 : ZEND_NULL_HANDLER,
28102 : ZEND_NULL_HANDLER,
28103 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28104 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28105 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28106 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28107 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28108 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28109 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28110 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28111 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28112 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28113 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28114 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28115 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28116 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28117 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28118 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28119 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28120 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28121 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28122 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28123 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28124 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28125 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28126 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28127 : ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
28128 : ZEND_RETURN_SPEC_CONST_HANDLER,
28129 : ZEND_RETURN_SPEC_CONST_HANDLER,
28130 : ZEND_RETURN_SPEC_CONST_HANDLER,
28131 : ZEND_RETURN_SPEC_CONST_HANDLER,
28132 : ZEND_RETURN_SPEC_CONST_HANDLER,
28133 : ZEND_RETURN_SPEC_TMP_HANDLER,
28134 : ZEND_RETURN_SPEC_TMP_HANDLER,
28135 : ZEND_RETURN_SPEC_TMP_HANDLER,
28136 : ZEND_RETURN_SPEC_TMP_HANDLER,
28137 : ZEND_RETURN_SPEC_TMP_HANDLER,
28138 : ZEND_RETURN_SPEC_VAR_HANDLER,
28139 : ZEND_RETURN_SPEC_VAR_HANDLER,
28140 : ZEND_RETURN_SPEC_VAR_HANDLER,
28141 : ZEND_RETURN_SPEC_VAR_HANDLER,
28142 : ZEND_RETURN_SPEC_VAR_HANDLER,
28143 : ZEND_NULL_HANDLER,
28144 : ZEND_NULL_HANDLER,
28145 : ZEND_NULL_HANDLER,
28146 : ZEND_NULL_HANDLER,
28147 : ZEND_NULL_HANDLER,
28148 : ZEND_RETURN_SPEC_CV_HANDLER,
28149 : ZEND_RETURN_SPEC_CV_HANDLER,
28150 : ZEND_RETURN_SPEC_CV_HANDLER,
28151 : ZEND_RETURN_SPEC_CV_HANDLER,
28152 : ZEND_RETURN_SPEC_CV_HANDLER,
28153 : ZEND_RECV_SPEC_HANDLER,
28154 : ZEND_RECV_SPEC_HANDLER,
28155 : ZEND_RECV_SPEC_HANDLER,
28156 : ZEND_RECV_SPEC_HANDLER,
28157 : ZEND_RECV_SPEC_HANDLER,
28158 : ZEND_RECV_SPEC_HANDLER,
28159 : ZEND_RECV_SPEC_HANDLER,
28160 : ZEND_RECV_SPEC_HANDLER,
28161 : ZEND_RECV_SPEC_HANDLER,
28162 : ZEND_RECV_SPEC_HANDLER,
28163 : ZEND_RECV_SPEC_HANDLER,
28164 : ZEND_RECV_SPEC_HANDLER,
28165 : ZEND_RECV_SPEC_HANDLER,
28166 : ZEND_RECV_SPEC_HANDLER,
28167 : ZEND_RECV_SPEC_HANDLER,
28168 : ZEND_RECV_SPEC_HANDLER,
28169 : ZEND_RECV_SPEC_HANDLER,
28170 : ZEND_RECV_SPEC_HANDLER,
28171 : ZEND_RECV_SPEC_HANDLER,
28172 : ZEND_RECV_SPEC_HANDLER,
28173 : ZEND_RECV_SPEC_HANDLER,
28174 : ZEND_RECV_SPEC_HANDLER,
28175 : ZEND_RECV_SPEC_HANDLER,
28176 : ZEND_RECV_SPEC_HANDLER,
28177 : ZEND_RECV_SPEC_HANDLER,
28178 : ZEND_RECV_INIT_SPEC_CONST_HANDLER,
28179 : ZEND_NULL_HANDLER,
28180 : ZEND_NULL_HANDLER,
28181 : ZEND_NULL_HANDLER,
28182 : ZEND_NULL_HANDLER,
28183 : ZEND_RECV_INIT_SPEC_CONST_HANDLER,
28184 : ZEND_NULL_HANDLER,
28185 : ZEND_NULL_HANDLER,
28186 : ZEND_NULL_HANDLER,
28187 : ZEND_NULL_HANDLER,
28188 : ZEND_RECV_INIT_SPEC_CONST_HANDLER,
28189 : ZEND_NULL_HANDLER,
28190 : ZEND_NULL_HANDLER,
28191 : ZEND_NULL_HANDLER,
28192 : ZEND_NULL_HANDLER,
28193 : ZEND_RECV_INIT_SPEC_CONST_HANDLER,
28194 : ZEND_NULL_HANDLER,
28195 : ZEND_NULL_HANDLER,
28196 : ZEND_NULL_HANDLER,
28197 : ZEND_NULL_HANDLER,
28198 : ZEND_RECV_INIT_SPEC_CONST_HANDLER,
28199 : ZEND_NULL_HANDLER,
28200 : ZEND_NULL_HANDLER,
28201 : ZEND_NULL_HANDLER,
28202 : ZEND_NULL_HANDLER,
28203 : ZEND_SEND_VAL_SPEC_CONST_HANDLER,
28204 : ZEND_SEND_VAL_SPEC_CONST_HANDLER,
28205 : ZEND_SEND_VAL_SPEC_CONST_HANDLER,
28206 : ZEND_SEND_VAL_SPEC_CONST_HANDLER,
28207 : ZEND_SEND_VAL_SPEC_CONST_HANDLER,
28208 : ZEND_SEND_VAL_SPEC_TMP_HANDLER,
28209 : ZEND_SEND_VAL_SPEC_TMP_HANDLER,
28210 : ZEND_SEND_VAL_SPEC_TMP_HANDLER,
28211 : ZEND_SEND_VAL_SPEC_TMP_HANDLER,
28212 : ZEND_SEND_VAL_SPEC_TMP_HANDLER,
28213 : ZEND_SEND_VAL_SPEC_VAR_HANDLER,
28214 : ZEND_SEND_VAL_SPEC_VAR_HANDLER,
28215 : ZEND_SEND_VAL_SPEC_VAR_HANDLER,
28216 : ZEND_SEND_VAL_SPEC_VAR_HANDLER,
28217 : ZEND_SEND_VAL_SPEC_VAR_HANDLER,
28218 : ZEND_NULL_HANDLER,
28219 : ZEND_NULL_HANDLER,
28220 : ZEND_NULL_HANDLER,
28221 : ZEND_NULL_HANDLER,
28222 : ZEND_NULL_HANDLER,
28223 : ZEND_SEND_VAL_SPEC_CV_HANDLER,
28224 : ZEND_SEND_VAL_SPEC_CV_HANDLER,
28225 : ZEND_SEND_VAL_SPEC_CV_HANDLER,
28226 : ZEND_SEND_VAL_SPEC_CV_HANDLER,
28227 : ZEND_SEND_VAL_SPEC_CV_HANDLER,
28228 : ZEND_NULL_HANDLER,
28229 : ZEND_NULL_HANDLER,
28230 : ZEND_NULL_HANDLER,
28231 : ZEND_NULL_HANDLER,
28232 : ZEND_NULL_HANDLER,
28233 : ZEND_NULL_HANDLER,
28234 : ZEND_NULL_HANDLER,
28235 : ZEND_NULL_HANDLER,
28236 : ZEND_NULL_HANDLER,
28237 : ZEND_NULL_HANDLER,
28238 : ZEND_SEND_VAR_SPEC_VAR_HANDLER,
28239 : ZEND_SEND_VAR_SPEC_VAR_HANDLER,
28240 : ZEND_SEND_VAR_SPEC_VAR_HANDLER,
28241 : ZEND_SEND_VAR_SPEC_VAR_HANDLER,
28242 : ZEND_SEND_VAR_SPEC_VAR_HANDLER,
28243 : ZEND_NULL_HANDLER,
28244 : ZEND_NULL_HANDLER,
28245 : ZEND_NULL_HANDLER,
28246 : ZEND_NULL_HANDLER,
28247 : ZEND_NULL_HANDLER,
28248 : ZEND_SEND_VAR_SPEC_CV_HANDLER,
28249 : ZEND_SEND_VAR_SPEC_CV_HANDLER,
28250 : ZEND_SEND_VAR_SPEC_CV_HANDLER,
28251 : ZEND_SEND_VAR_SPEC_CV_HANDLER,
28252 : ZEND_SEND_VAR_SPEC_CV_HANDLER,
28253 : ZEND_NULL_HANDLER,
28254 : ZEND_NULL_HANDLER,
28255 : ZEND_NULL_HANDLER,
28256 : ZEND_NULL_HANDLER,
28257 : ZEND_NULL_HANDLER,
28258 : ZEND_NULL_HANDLER,
28259 : ZEND_NULL_HANDLER,
28260 : ZEND_NULL_HANDLER,
28261 : ZEND_NULL_HANDLER,
28262 : ZEND_NULL_HANDLER,
28263 : ZEND_SEND_REF_SPEC_VAR_HANDLER,
28264 : ZEND_SEND_REF_SPEC_VAR_HANDLER,
28265 : ZEND_SEND_REF_SPEC_VAR_HANDLER,
28266 : ZEND_SEND_REF_SPEC_VAR_HANDLER,
28267 : ZEND_SEND_REF_SPEC_VAR_HANDLER,
28268 : ZEND_NULL_HANDLER,
28269 : ZEND_NULL_HANDLER,
28270 : ZEND_NULL_HANDLER,
28271 : ZEND_NULL_HANDLER,
28272 : ZEND_NULL_HANDLER,
28273 : ZEND_SEND_REF_SPEC_CV_HANDLER,
28274 : ZEND_SEND_REF_SPEC_CV_HANDLER,
28275 : ZEND_SEND_REF_SPEC_CV_HANDLER,
28276 : ZEND_SEND_REF_SPEC_CV_HANDLER,
28277 : ZEND_SEND_REF_SPEC_CV_HANDLER,
28278 : ZEND_NEW_SPEC_HANDLER,
28279 : ZEND_NEW_SPEC_HANDLER,
28280 : ZEND_NEW_SPEC_HANDLER,
28281 : ZEND_NEW_SPEC_HANDLER,
28282 : ZEND_NEW_SPEC_HANDLER,
28283 : ZEND_NEW_SPEC_HANDLER,
28284 : ZEND_NEW_SPEC_HANDLER,
28285 : ZEND_NEW_SPEC_HANDLER,
28286 : ZEND_NEW_SPEC_HANDLER,
28287 : ZEND_NEW_SPEC_HANDLER,
28288 : ZEND_NEW_SPEC_HANDLER,
28289 : ZEND_NEW_SPEC_HANDLER,
28290 : ZEND_NEW_SPEC_HANDLER,
28291 : ZEND_NEW_SPEC_HANDLER,
28292 : ZEND_NEW_SPEC_HANDLER,
28293 : ZEND_NEW_SPEC_HANDLER,
28294 : ZEND_NEW_SPEC_HANDLER,
28295 : ZEND_NEW_SPEC_HANDLER,
28296 : ZEND_NEW_SPEC_HANDLER,
28297 : ZEND_NEW_SPEC_HANDLER,
28298 : ZEND_NEW_SPEC_HANDLER,
28299 : ZEND_NEW_SPEC_HANDLER,
28300 : ZEND_NEW_SPEC_HANDLER,
28301 : ZEND_NEW_SPEC_HANDLER,
28302 : ZEND_NEW_SPEC_HANDLER,
28303 : ZEND_NULL_HANDLER,
28304 : ZEND_NULL_HANDLER,
28305 : ZEND_NULL_HANDLER,
28306 : ZEND_NULL_HANDLER,
28307 : ZEND_NULL_HANDLER,
28308 : ZEND_NULL_HANDLER,
28309 : ZEND_NULL_HANDLER,
28310 : ZEND_NULL_HANDLER,
28311 : ZEND_NULL_HANDLER,
28312 : ZEND_NULL_HANDLER,
28313 : ZEND_NULL_HANDLER,
28314 : ZEND_NULL_HANDLER,
28315 : ZEND_NULL_HANDLER,
28316 : ZEND_NULL_HANDLER,
28317 : ZEND_NULL_HANDLER,
28318 : ZEND_NULL_HANDLER,
28319 : ZEND_NULL_HANDLER,
28320 : ZEND_NULL_HANDLER,
28321 : ZEND_NULL_HANDLER,
28322 : ZEND_NULL_HANDLER,
28323 : ZEND_NULL_HANDLER,
28324 : ZEND_NULL_HANDLER,
28325 : ZEND_NULL_HANDLER,
28326 : ZEND_NULL_HANDLER,
28327 : ZEND_NULL_HANDLER,
28328 : ZEND_NULL_HANDLER,
28329 : ZEND_NULL_HANDLER,
28330 : ZEND_NULL_HANDLER,
28331 : ZEND_NULL_HANDLER,
28332 : ZEND_NULL_HANDLER,
28333 : ZEND_FREE_SPEC_TMP_HANDLER,
28334 : ZEND_FREE_SPEC_TMP_HANDLER,
28335 : ZEND_FREE_SPEC_TMP_HANDLER,
28336 : ZEND_FREE_SPEC_TMP_HANDLER,
28337 : ZEND_FREE_SPEC_TMP_HANDLER,
28338 : ZEND_NULL_HANDLER,
28339 : ZEND_NULL_HANDLER,
28340 : ZEND_NULL_HANDLER,
28341 : ZEND_NULL_HANDLER,
28342 : ZEND_NULL_HANDLER,
28343 : ZEND_NULL_HANDLER,
28344 : ZEND_NULL_HANDLER,
28345 : ZEND_NULL_HANDLER,
28346 : ZEND_NULL_HANDLER,
28347 : ZEND_NULL_HANDLER,
28348 : ZEND_NULL_HANDLER,
28349 : ZEND_NULL_HANDLER,
28350 : ZEND_NULL_HANDLER,
28351 : ZEND_NULL_HANDLER,
28352 : ZEND_NULL_HANDLER,
28353 : ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER,
28354 : ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER,
28355 : ZEND_INIT_ARRAY_SPEC_CONST_VAR_HANDLER,
28356 : ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER,
28357 : ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER,
28358 : ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER,
28359 : ZEND_INIT_ARRAY_SPEC_TMP_TMP_HANDLER,
28360 : ZEND_INIT_ARRAY_SPEC_TMP_VAR_HANDLER,
28361 : ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER,
28362 : ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER,
28363 : ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER,
28364 : ZEND_INIT_ARRAY_SPEC_VAR_TMP_HANDLER,
28365 : ZEND_INIT_ARRAY_SPEC_VAR_VAR_HANDLER,
28366 : ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER,
28367 : ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER,
28368 : ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER,
28369 : ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER,
28370 : ZEND_INIT_ARRAY_SPEC_UNUSED_VAR_HANDLER,
28371 : ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER,
28372 : ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER,
28373 : ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER,
28374 : ZEND_INIT_ARRAY_SPEC_CV_TMP_HANDLER,
28375 : ZEND_INIT_ARRAY_SPEC_CV_VAR_HANDLER,
28376 : ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER,
28377 : ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER,
28378 : ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER,
28379 : ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER,
28380 : ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER,
28381 : ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER,
28382 : ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER,
28383 : ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER,
28384 : ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER,
28385 : ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER,
28386 : ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER,
28387 : ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER,
28388 : ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER,
28389 : ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER,
28390 : ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER,
28391 : ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER,
28392 : ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER,
28393 : ZEND_NULL_HANDLER,
28394 : ZEND_NULL_HANDLER,
28395 : ZEND_NULL_HANDLER,
28396 : ZEND_NULL_HANDLER,
28397 : ZEND_NULL_HANDLER,
28398 : ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER,
28399 : ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER,
28400 : ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER,
28401 : ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER,
28402 : ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER,
28403 : ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
28404 : ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
28405 : ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
28406 : ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
28407 : ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
28408 : ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER,
28409 : ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER,
28410 : ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER,
28411 : ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER,
28412 : ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER,
28413 : ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER,
28414 : ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER,
28415 : ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER,
28416 : ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER,
28417 : ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER,
28418 : ZEND_NULL_HANDLER,
28419 : ZEND_NULL_HANDLER,
28420 : ZEND_NULL_HANDLER,
28421 : ZEND_NULL_HANDLER,
28422 : ZEND_NULL_HANDLER,
28423 : ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
28424 : ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
28425 : ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
28426 : ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
28427 : ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
28428 : ZEND_UNSET_VAR_SPEC_CONST_HANDLER,
28429 : ZEND_UNSET_VAR_SPEC_CONST_HANDLER,
28430 : ZEND_UNSET_VAR_SPEC_CONST_HANDLER,
28431 : ZEND_UNSET_VAR_SPEC_CONST_HANDLER,
28432 : ZEND_UNSET_VAR_SPEC_CONST_HANDLER,
28433 : ZEND_UNSET_VAR_SPEC_TMP_HANDLER,
28434 : ZEND_UNSET_VAR_SPEC_TMP_HANDLER,
28435 : ZEND_UNSET_VAR_SPEC_TMP_HANDLER,
28436 : ZEND_UNSET_VAR_SPEC_TMP_HANDLER,
28437 : ZEND_UNSET_VAR_SPEC_TMP_HANDLER,
28438 : ZEND_UNSET_VAR_SPEC_VAR_HANDLER,
28439 : ZEND_UNSET_VAR_SPEC_VAR_HANDLER,
28440 : ZEND_UNSET_VAR_SPEC_VAR_HANDLER,
28441 : ZEND_UNSET_VAR_SPEC_VAR_HANDLER,
28442 : ZEND_UNSET_VAR_SPEC_VAR_HANDLER,
28443 : ZEND_NULL_HANDLER,
28444 : ZEND_NULL_HANDLER,
28445 : ZEND_NULL_HANDLER,
28446 : ZEND_NULL_HANDLER,
28447 : ZEND_NULL_HANDLER,
28448 : ZEND_UNSET_VAR_SPEC_CV_HANDLER,
28449 : ZEND_UNSET_VAR_SPEC_CV_HANDLER,
28450 : ZEND_UNSET_VAR_SPEC_CV_HANDLER,
28451 : ZEND_UNSET_VAR_SPEC_CV_HANDLER,
28452 : ZEND_UNSET_VAR_SPEC_CV_HANDLER,
28453 : ZEND_NULL_HANDLER,
28454 : ZEND_NULL_HANDLER,
28455 : ZEND_NULL_HANDLER,
28456 : ZEND_NULL_HANDLER,
28457 : ZEND_NULL_HANDLER,
28458 : ZEND_NULL_HANDLER,
28459 : ZEND_NULL_HANDLER,
28460 : ZEND_NULL_HANDLER,
28461 : ZEND_NULL_HANDLER,
28462 : ZEND_NULL_HANDLER,
28463 : ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER,
28464 : ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER,
28465 : ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER,
28466 : ZEND_NULL_HANDLER,
28467 : ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER,
28468 : ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER,
28469 : ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER,
28470 : ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER,
28471 : ZEND_NULL_HANDLER,
28472 : ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER,
28473 : ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER,
28474 : ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER,
28475 : ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER,
28476 : ZEND_NULL_HANDLER,
28477 : ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER,
28478 : ZEND_NULL_HANDLER,
28479 : ZEND_NULL_HANDLER,
28480 : ZEND_NULL_HANDLER,
28481 : ZEND_NULL_HANDLER,
28482 : ZEND_NULL_HANDLER,
28483 : ZEND_NULL_HANDLER,
28484 : ZEND_NULL_HANDLER,
28485 : ZEND_NULL_HANDLER,
28486 : ZEND_NULL_HANDLER,
28487 : ZEND_NULL_HANDLER,
28488 : ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER,
28489 : ZEND_UNSET_OBJ_SPEC_VAR_TMP_HANDLER,
28490 : ZEND_UNSET_OBJ_SPEC_VAR_VAR_HANDLER,
28491 : ZEND_NULL_HANDLER,
28492 : ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER,
28493 : ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER,
28494 : ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER,
28495 : ZEND_UNSET_OBJ_SPEC_UNUSED_VAR_HANDLER,
28496 : ZEND_NULL_HANDLER,
28497 : ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER,
28498 : ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER,
28499 : ZEND_UNSET_OBJ_SPEC_CV_TMP_HANDLER,
28500 : ZEND_UNSET_OBJ_SPEC_CV_VAR_HANDLER,
28501 : ZEND_NULL_HANDLER,
28502 : ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER,
28503 : ZEND_FE_RESET_SPEC_CONST_HANDLER,
28504 : ZEND_FE_RESET_SPEC_CONST_HANDLER,
28505 : ZEND_FE_RESET_SPEC_CONST_HANDLER,
28506 : ZEND_FE_RESET_SPEC_CONST_HANDLER,
28507 : ZEND_FE_RESET_SPEC_CONST_HANDLER,
28508 : ZEND_FE_RESET_SPEC_TMP_HANDLER,
28509 : ZEND_FE_RESET_SPEC_TMP_HANDLER,
28510 : ZEND_FE_RESET_SPEC_TMP_HANDLER,
28511 : ZEND_FE_RESET_SPEC_TMP_HANDLER,
28512 : ZEND_FE_RESET_SPEC_TMP_HANDLER,
28513 : ZEND_FE_RESET_SPEC_VAR_HANDLER,
28514 : ZEND_FE_RESET_SPEC_VAR_HANDLER,
28515 : ZEND_FE_RESET_SPEC_VAR_HANDLER,
28516 : ZEND_FE_RESET_SPEC_VAR_HANDLER,
28517 : ZEND_FE_RESET_SPEC_VAR_HANDLER,
28518 : ZEND_NULL_HANDLER,
28519 : ZEND_NULL_HANDLER,
28520 : ZEND_NULL_HANDLER,
28521 : ZEND_NULL_HANDLER,
28522 : ZEND_NULL_HANDLER,
28523 : ZEND_FE_RESET_SPEC_CV_HANDLER,
28524 : ZEND_FE_RESET_SPEC_CV_HANDLER,
28525 : ZEND_FE_RESET_SPEC_CV_HANDLER,
28526 : ZEND_FE_RESET_SPEC_CV_HANDLER,
28527 : ZEND_FE_RESET_SPEC_CV_HANDLER,
28528 : ZEND_NULL_HANDLER,
28529 : ZEND_NULL_HANDLER,
28530 : ZEND_NULL_HANDLER,
28531 : ZEND_NULL_HANDLER,
28532 : ZEND_NULL_HANDLER,
28533 : ZEND_NULL_HANDLER,
28534 : ZEND_NULL_HANDLER,
28535 : ZEND_NULL_HANDLER,
28536 : ZEND_NULL_HANDLER,
28537 : ZEND_NULL_HANDLER,
28538 : ZEND_FE_FETCH_SPEC_VAR_HANDLER,
28539 : ZEND_FE_FETCH_SPEC_VAR_HANDLER,
28540 : ZEND_FE_FETCH_SPEC_VAR_HANDLER,
28541 : ZEND_FE_FETCH_SPEC_VAR_HANDLER,
28542 : ZEND_FE_FETCH_SPEC_VAR_HANDLER,
28543 : ZEND_NULL_HANDLER,
28544 : ZEND_NULL_HANDLER,
28545 : ZEND_NULL_HANDLER,
28546 : ZEND_NULL_HANDLER,
28547 : ZEND_NULL_HANDLER,
28548 : ZEND_NULL_HANDLER,
28549 : ZEND_NULL_HANDLER,
28550 : ZEND_NULL_HANDLER,
28551 : ZEND_NULL_HANDLER,
28552 : ZEND_NULL_HANDLER,
28553 : ZEND_EXIT_SPEC_CONST_HANDLER,
28554 : ZEND_EXIT_SPEC_CONST_HANDLER,
28555 : ZEND_EXIT_SPEC_CONST_HANDLER,
28556 : ZEND_EXIT_SPEC_CONST_HANDLER,
28557 : ZEND_EXIT_SPEC_CONST_HANDLER,
28558 : ZEND_EXIT_SPEC_TMP_HANDLER,
28559 : ZEND_EXIT_SPEC_TMP_HANDLER,
28560 : ZEND_EXIT_SPEC_TMP_HANDLER,
28561 : ZEND_EXIT_SPEC_TMP_HANDLER,
28562 : ZEND_EXIT_SPEC_TMP_HANDLER,
28563 : ZEND_EXIT_SPEC_VAR_HANDLER,
28564 : ZEND_EXIT_SPEC_VAR_HANDLER,
28565 : ZEND_EXIT_SPEC_VAR_HANDLER,
28566 : ZEND_EXIT_SPEC_VAR_HANDLER,
28567 : ZEND_EXIT_SPEC_VAR_HANDLER,
28568 : ZEND_EXIT_SPEC_UNUSED_HANDLER,
28569 : ZEND_EXIT_SPEC_UNUSED_HANDLER,
28570 : ZEND_EXIT_SPEC_UNUSED_HANDLER,
28571 : ZEND_EXIT_SPEC_UNUSED_HANDLER,
28572 : ZEND_EXIT_SPEC_UNUSED_HANDLER,
28573 : ZEND_EXIT_SPEC_CV_HANDLER,
28574 : ZEND_EXIT_SPEC_CV_HANDLER,
28575 : ZEND_EXIT_SPEC_CV_HANDLER,
28576 : ZEND_EXIT_SPEC_CV_HANDLER,
28577 : ZEND_EXIT_SPEC_CV_HANDLER,
28578 : ZEND_FETCH_R_SPEC_CONST_HANDLER,
28579 : ZEND_FETCH_R_SPEC_CONST_HANDLER,
28580 : ZEND_FETCH_R_SPEC_CONST_HANDLER,
28581 : ZEND_FETCH_R_SPEC_CONST_HANDLER,
28582 : ZEND_FETCH_R_SPEC_CONST_HANDLER,
28583 : ZEND_FETCH_R_SPEC_TMP_HANDLER,
28584 : ZEND_FETCH_R_SPEC_TMP_HANDLER,
28585 : ZEND_FETCH_R_SPEC_TMP_HANDLER,
28586 : ZEND_FETCH_R_SPEC_TMP_HANDLER,
28587 : ZEND_FETCH_R_SPEC_TMP_HANDLER,
28588 : ZEND_FETCH_R_SPEC_VAR_HANDLER,
28589 : ZEND_FETCH_R_SPEC_VAR_HANDLER,
28590 : ZEND_FETCH_R_SPEC_VAR_HANDLER,
28591 : ZEND_FETCH_R_SPEC_VAR_HANDLER,
28592 : ZEND_FETCH_R_SPEC_VAR_HANDLER,
28593 : ZEND_NULL_HANDLER,
28594 : ZEND_NULL_HANDLER,
28595 : ZEND_NULL_HANDLER,
28596 : ZEND_NULL_HANDLER,
28597 : ZEND_NULL_HANDLER,
28598 : ZEND_FETCH_R_SPEC_CV_HANDLER,
28599 : ZEND_FETCH_R_SPEC_CV_HANDLER,
28600 : ZEND_FETCH_R_SPEC_CV_HANDLER,
28601 : ZEND_FETCH_R_SPEC_CV_HANDLER,
28602 : ZEND_FETCH_R_SPEC_CV_HANDLER,
28603 : ZEND_NULL_HANDLER,
28604 : ZEND_NULL_HANDLER,
28605 : ZEND_NULL_HANDLER,
28606 : ZEND_NULL_HANDLER,
28607 : ZEND_NULL_HANDLER,
28608 : ZEND_NULL_HANDLER,
28609 : ZEND_NULL_HANDLER,
28610 : ZEND_NULL_HANDLER,
28611 : ZEND_NULL_HANDLER,
28612 : ZEND_NULL_HANDLER,
28613 : ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER,
28614 : ZEND_FETCH_DIM_R_SPEC_VAR_TMP_HANDLER,
28615 : ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER,
28616 : ZEND_NULL_HANDLER,
28617 : ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER,
28618 : ZEND_NULL_HANDLER,
28619 : ZEND_NULL_HANDLER,
28620 : ZEND_NULL_HANDLER,
28621 : ZEND_NULL_HANDLER,
28622 : ZEND_NULL_HANDLER,
28623 : ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER,
28624 : ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER,
28625 : ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER,
28626 : ZEND_NULL_HANDLER,
28627 : ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER,
28628 : ZEND_NULL_HANDLER,
28629 : ZEND_NULL_HANDLER,
28630 : ZEND_NULL_HANDLER,
28631 : ZEND_NULL_HANDLER,
28632 : ZEND_NULL_HANDLER,
28633 : ZEND_NULL_HANDLER,
28634 : ZEND_NULL_HANDLER,
28635 : ZEND_NULL_HANDLER,
28636 : ZEND_NULL_HANDLER,
28637 : ZEND_NULL_HANDLER,
28638 : ZEND_FETCH_OBJ_R_SPEC_VAR_CONST_HANDLER,
28639 : ZEND_FETCH_OBJ_R_SPEC_VAR_TMP_HANDLER,
28640 : ZEND_FETCH_OBJ_R_SPEC_VAR_VAR_HANDLER,
28641 : ZEND_NULL_HANDLER,
28642 : ZEND_FETCH_OBJ_R_SPEC_VAR_CV_HANDLER,
28643 : ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER,
28644 : ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_HANDLER,
28645 : ZEND_FETCH_OBJ_R_SPEC_UNUSED_VAR_HANDLER,
28646 : ZEND_NULL_HANDLER,
28647 : ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER,
28648 : ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER,
28649 : ZEND_FETCH_OBJ_R_SPEC_CV_TMP_HANDLER,
28650 : ZEND_FETCH_OBJ_R_SPEC_CV_VAR_HANDLER,
28651 : ZEND_NULL_HANDLER,
28652 : ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER,
28653 : ZEND_FETCH_W_SPEC_CONST_HANDLER,
28654 : ZEND_FETCH_W_SPEC_CONST_HANDLER,
28655 : ZEND_FETCH_W_SPEC_CONST_HANDLER,
28656 : ZEND_FETCH_W_SPEC_CONST_HANDLER,
28657 : ZEND_FETCH_W_SPEC_CONST_HANDLER,
28658 : ZEND_FETCH_W_SPEC_TMP_HANDLER,
28659 : ZEND_FETCH_W_SPEC_TMP_HANDLER,
28660 : ZEND_FETCH_W_SPEC_TMP_HANDLER,
28661 : ZEND_FETCH_W_SPEC_TMP_HANDLER,
28662 : ZEND_FETCH_W_SPEC_TMP_HANDLER,
28663 : ZEND_FETCH_W_SPEC_VAR_HANDLER,
28664 : ZEND_FETCH_W_SPEC_VAR_HANDLER,
28665 : ZEND_FETCH_W_SPEC_VAR_HANDLER,
28666 : ZEND_FETCH_W_SPEC_VAR_HANDLER,
28667 : ZEND_FETCH_W_SPEC_VAR_HANDLER,
28668 : ZEND_NULL_HANDLER,
28669 : ZEND_NULL_HANDLER,
28670 : ZEND_NULL_HANDLER,
28671 : ZEND_NULL_HANDLER,
28672 : ZEND_NULL_HANDLER,
28673 : ZEND_FETCH_W_SPEC_CV_HANDLER,
28674 : ZEND_FETCH_W_SPEC_CV_HANDLER,
28675 : ZEND_FETCH_W_SPEC_CV_HANDLER,
28676 : ZEND_FETCH_W_SPEC_CV_HANDLER,
28677 : ZEND_FETCH_W_SPEC_CV_HANDLER,
28678 : ZEND_NULL_HANDLER,
28679 : ZEND_NULL_HANDLER,
28680 : ZEND_NULL_HANDLER,
28681 : ZEND_NULL_HANDLER,
28682 : ZEND_NULL_HANDLER,
28683 : ZEND_NULL_HANDLER,
28684 : ZEND_NULL_HANDLER,
28685 : ZEND_NULL_HANDLER,
28686 : ZEND_NULL_HANDLER,
28687 : ZEND_NULL_HANDLER,
28688 : ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER,
28689 : ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER,
28690 : ZEND_FETCH_DIM_W_SPEC_VAR_VAR_HANDLER,
28691 : ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER,
28692 : ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER,
28693 : ZEND_NULL_HANDLER,
28694 : ZEND_NULL_HANDLER,
28695 : ZEND_NULL_HANDLER,
28696 : ZEND_NULL_HANDLER,
28697 : ZEND_NULL_HANDLER,
28698 : ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER,
28699 : ZEND_FETCH_DIM_W_SPEC_CV_TMP_HANDLER,
28700 : ZEND_FETCH_DIM_W_SPEC_CV_VAR_HANDLER,
28701 : ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER,
28702 : ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER,
28703 : ZEND_NULL_HANDLER,
28704 : ZEND_NULL_HANDLER,
28705 : ZEND_NULL_HANDLER,
28706 : ZEND_NULL_HANDLER,
28707 : ZEND_NULL_HANDLER,
28708 : ZEND_NULL_HANDLER,
28709 : ZEND_NULL_HANDLER,
28710 : ZEND_NULL_HANDLER,
28711 : ZEND_NULL_HANDLER,
28712 : ZEND_NULL_HANDLER,
28713 : ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER,
28714 : ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_HANDLER,
28715 : ZEND_FETCH_OBJ_W_SPEC_VAR_VAR_HANDLER,
28716 : ZEND_NULL_HANDLER,
28717 : ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER,
28718 : ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER,
28719 : ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER,
28720 : ZEND_FETCH_OBJ_W_SPEC_UNUSED_VAR_HANDLER,
28721 : ZEND_NULL_HANDLER,
28722 : ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER,
28723 : ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER,
28724 : ZEND_FETCH_OBJ_W_SPEC_CV_TMP_HANDLER,
28725 : ZEND_FETCH_OBJ_W_SPEC_CV_VAR_HANDLER,
28726 : ZEND_NULL_HANDLER,
28727 : ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER,
28728 : ZEND_FETCH_RW_SPEC_CONST_HANDLER,
28729 : ZEND_FETCH_RW_SPEC_CONST_HANDLER,
28730 : ZEND_FETCH_RW_SPEC_CONST_HANDLER,
28731 : ZEND_FETCH_RW_SPEC_CONST_HANDLER,
28732 : ZEND_FETCH_RW_SPEC_CONST_HANDLER,
28733 : ZEND_FETCH_RW_SPEC_TMP_HANDLER,
28734 : ZEND_FETCH_RW_SPEC_TMP_HANDLER,
28735 : ZEND_FETCH_RW_SPEC_TMP_HANDLER,
28736 : ZEND_FETCH_RW_SPEC_TMP_HANDLER,
28737 : ZEND_FETCH_RW_SPEC_TMP_HANDLER,
28738 : ZEND_FETCH_RW_SPEC_VAR_HANDLER,
28739 : ZEND_FETCH_RW_SPEC_VAR_HANDLER,
28740 : ZEND_FETCH_RW_SPEC_VAR_HANDLER,
28741 : ZEND_FETCH_RW_SPEC_VAR_HANDLER,
28742 : ZEND_FETCH_RW_SPEC_VAR_HANDLER,
28743 : ZEND_NULL_HANDLER,
28744 : ZEND_NULL_HANDLER,
28745 : ZEND_NULL_HANDLER,
28746 : ZEND_NULL_HANDLER,
28747 : ZEND_NULL_HANDLER,
28748 : ZEND_FETCH_RW_SPEC_CV_HANDLER,
28749 : ZEND_FETCH_RW_SPEC_CV_HANDLER,
28750 : ZEND_FETCH_RW_SPEC_CV_HANDLER,
28751 : ZEND_FETCH_RW_SPEC_CV_HANDLER,
28752 : ZEND_FETCH_RW_SPEC_CV_HANDLER,
28753 : ZEND_NULL_HANDLER,
28754 : ZEND_NULL_HANDLER,
28755 : ZEND_NULL_HANDLER,
28756 : ZEND_NULL_HANDLER,
28757 : ZEND_NULL_HANDLER,
28758 : ZEND_NULL_HANDLER,
28759 : ZEND_NULL_HANDLER,
28760 : ZEND_NULL_HANDLER,
28761 : ZEND_NULL_HANDLER,
28762 : ZEND_NULL_HANDLER,
28763 : ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER,
28764 : ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_HANDLER,
28765 : ZEND_FETCH_DIM_RW_SPEC_VAR_VAR_HANDLER,
28766 : ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER,
28767 : ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER,
28768 : ZEND_NULL_HANDLER,
28769 : ZEND_NULL_HANDLER,
28770 : ZEND_NULL_HANDLER,
28771 : ZEND_NULL_HANDLER,
28772 : ZEND_NULL_HANDLER,
28773 : ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER,
28774 : ZEND_FETCH_DIM_RW_SPEC_CV_TMP_HANDLER,
28775 : ZEND_FETCH_DIM_RW_SPEC_CV_VAR_HANDLER,
28776 : ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER,
28777 : ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER,
28778 : ZEND_NULL_HANDLER,
28779 : ZEND_NULL_HANDLER,
28780 : ZEND_NULL_HANDLER,
28781 : ZEND_NULL_HANDLER,
28782 : ZEND_NULL_HANDLER,
28783 : ZEND_NULL_HANDLER,
28784 : ZEND_NULL_HANDLER,
28785 : ZEND_NULL_HANDLER,
28786 : ZEND_NULL_HANDLER,
28787 : ZEND_NULL_HANDLER,
28788 : ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER,
28789 : ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_HANDLER,
28790 : ZEND_FETCH_OBJ_RW_SPEC_VAR_VAR_HANDLER,
28791 : ZEND_NULL_HANDLER,
28792 : ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER,
28793 : ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER,
28794 : ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER,
28795 : ZEND_FETCH_OBJ_RW_SPEC_UNUSED_VAR_HANDLER,
28796 : ZEND_NULL_HANDLER,
28797 : ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER,
28798 : ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER,
28799 : ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_HANDLER,
28800 : ZEND_FETCH_OBJ_RW_SPEC_CV_VAR_HANDLER,
28801 : ZEND_NULL_HANDLER,
28802 : ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER,
28803 : ZEND_FETCH_IS_SPEC_CONST_HANDLER,
28804 : ZEND_FETCH_IS_SPEC_CONST_HANDLER,
28805 : ZEND_FETCH_IS_SPEC_CONST_HANDLER,
28806 : ZEND_FETCH_IS_SPEC_CONST_HANDLER,
28807 : ZEND_FETCH_IS_SPEC_CONST_HANDLER,
28808 : ZEND_FETCH_IS_SPEC_TMP_HANDLER,
28809 : ZEND_FETCH_IS_SPEC_TMP_HANDLER,
28810 : ZEND_FETCH_IS_SPEC_TMP_HANDLER,
28811 : ZEND_FETCH_IS_SPEC_TMP_HANDLER,
28812 : ZEND_FETCH_IS_SPEC_TMP_HANDLER,
28813 : ZEND_FETCH_IS_SPEC_VAR_HANDLER,
28814 : ZEND_FETCH_IS_SPEC_VAR_HANDLER,
28815 : ZEND_FETCH_IS_SPEC_VAR_HANDLER,
28816 : ZEND_FETCH_IS_SPEC_VAR_HANDLER,
28817 : ZEND_FETCH_IS_SPEC_VAR_HANDLER,
28818 : ZEND_NULL_HANDLER,
28819 : ZEND_NULL_HANDLER,
28820 : ZEND_NULL_HANDLER,
28821 : ZEND_NULL_HANDLER,
28822 : ZEND_NULL_HANDLER,
28823 : ZEND_FETCH_IS_SPEC_CV_HANDLER,
28824 : ZEND_FETCH_IS_SPEC_CV_HANDLER,
28825 : ZEND_FETCH_IS_SPEC_CV_HANDLER,
28826 : ZEND_FETCH_IS_SPEC_CV_HANDLER,
28827 : ZEND_FETCH_IS_SPEC_CV_HANDLER,
28828 : ZEND_NULL_HANDLER,
28829 : ZEND_NULL_HANDLER,
28830 : ZEND_NULL_HANDLER,
28831 : ZEND_NULL_HANDLER,
28832 : ZEND_NULL_HANDLER,
28833 : ZEND_NULL_HANDLER,
28834 : ZEND_NULL_HANDLER,
28835 : ZEND_NULL_HANDLER,
28836 : ZEND_NULL_HANDLER,
28837 : ZEND_NULL_HANDLER,
28838 : ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER,
28839 : ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER,
28840 : ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER,
28841 : ZEND_NULL_HANDLER,
28842 : ZEND_FETCH_DIM_IS_SPEC_VAR_CV_HANDLER,
28843 : ZEND_NULL_HANDLER,
28844 : ZEND_NULL_HANDLER,
28845 : ZEND_NULL_HANDLER,
28846 : ZEND_NULL_HANDLER,
28847 : ZEND_NULL_HANDLER,
28848 : ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER,
28849 : ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER,
28850 : ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER,
28851 : ZEND_NULL_HANDLER,
28852 : ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER,
28853 : ZEND_NULL_HANDLER,
28854 : ZEND_NULL_HANDLER,
28855 : ZEND_NULL_HANDLER,
28856 : ZEND_NULL_HANDLER,
28857 : ZEND_NULL_HANDLER,
28858 : ZEND_NULL_HANDLER,
28859 : ZEND_NULL_HANDLER,
28860 : ZEND_NULL_HANDLER,
28861 : ZEND_NULL_HANDLER,
28862 : ZEND_NULL_HANDLER,
28863 : ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER,
28864 : ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER,
28865 : ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER,
28866 : ZEND_NULL_HANDLER,
28867 : ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER,
28868 : ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER,
28869 : ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER,
28870 : ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER,
28871 : ZEND_NULL_HANDLER,
28872 : ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER,
28873 : ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER,
28874 : ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER,
28875 : ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER,
28876 : ZEND_NULL_HANDLER,
28877 : ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER,
28878 : ZEND_FETCH_FUNC_ARG_SPEC_CONST_HANDLER,
28879 : ZEND_FETCH_FUNC_ARG_SPEC_CONST_HANDLER,
28880 : ZEND_FETCH_FUNC_ARG_SPEC_CONST_HANDLER,
28881 : ZEND_FETCH_FUNC_ARG_SPEC_CONST_HANDLER,
28882 : ZEND_FETCH_FUNC_ARG_SPEC_CONST_HANDLER,
28883 : ZEND_FETCH_FUNC_ARG_SPEC_TMP_HANDLER,
28884 : ZEND_FETCH_FUNC_ARG_SPEC_TMP_HANDLER,
28885 : ZEND_FETCH_FUNC_ARG_SPEC_TMP_HANDLER,
28886 : ZEND_FETCH_FUNC_ARG_SPEC_TMP_HANDLER,
28887 : ZEND_FETCH_FUNC_ARG_SPEC_TMP_HANDLER,
28888 : ZEND_FETCH_FUNC_ARG_SPEC_VAR_HANDLER,
28889 : ZEND_FETCH_FUNC_ARG_SPEC_VAR_HANDLER,
28890 : ZEND_FETCH_FUNC_ARG_SPEC_VAR_HANDLER,
28891 : ZEND_FETCH_FUNC_ARG_SPEC_VAR_HANDLER,
28892 : ZEND_FETCH_FUNC_ARG_SPEC_VAR_HANDLER,
28893 : ZEND_NULL_HANDLER,
28894 : ZEND_NULL_HANDLER,
28895 : ZEND_NULL_HANDLER,
28896 : ZEND_NULL_HANDLER,
28897 : ZEND_NULL_HANDLER,
28898 : ZEND_FETCH_FUNC_ARG_SPEC_CV_HANDLER,
28899 : ZEND_FETCH_FUNC_ARG_SPEC_CV_HANDLER,
28900 : ZEND_FETCH_FUNC_ARG_SPEC_CV_HANDLER,
28901 : ZEND_FETCH_FUNC_ARG_SPEC_CV_HANDLER,
28902 : ZEND_FETCH_FUNC_ARG_SPEC_CV_HANDLER,
28903 : ZEND_NULL_HANDLER,
28904 : ZEND_NULL_HANDLER,
28905 : ZEND_NULL_HANDLER,
28906 : ZEND_NULL_HANDLER,
28907 : ZEND_NULL_HANDLER,
28908 : ZEND_NULL_HANDLER,
28909 : ZEND_NULL_HANDLER,
28910 : ZEND_NULL_HANDLER,
28911 : ZEND_NULL_HANDLER,
28912 : ZEND_NULL_HANDLER,
28913 : ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
28914 : ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER,
28915 : ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER,
28916 : ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER,
28917 : ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER,
28918 : ZEND_NULL_HANDLER,
28919 : ZEND_NULL_HANDLER,
28920 : ZEND_NULL_HANDLER,
28921 : ZEND_NULL_HANDLER,
28922 : ZEND_NULL_HANDLER,
28923 : ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER,
28924 : ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER,
28925 : ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER,
28926 : ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
28927 : ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER,
28928 : ZEND_NULL_HANDLER,
28929 : ZEND_NULL_HANDLER,
28930 : ZEND_NULL_HANDLER,
28931 : ZEND_NULL_HANDLER,
28932 : ZEND_NULL_HANDLER,
28933 : ZEND_NULL_HANDLER,
28934 : ZEND_NULL_HANDLER,
28935 : ZEND_NULL_HANDLER,
28936 : ZEND_NULL_HANDLER,
28937 : ZEND_NULL_HANDLER,
28938 : ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
28939 : ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER,
28940 : ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER,
28941 : ZEND_NULL_HANDLER,
28942 : ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER,
28943 : ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
28944 : ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER,
28945 : ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_VAR_HANDLER,
28946 : ZEND_NULL_HANDLER,
28947 : ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER,
28948 : ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER,
28949 : ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER,
28950 : ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_VAR_HANDLER,
28951 : ZEND_NULL_HANDLER,
28952 : ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER,
28953 : ZEND_FETCH_UNSET_SPEC_CONST_HANDLER,
28954 : ZEND_FETCH_UNSET_SPEC_CONST_HANDLER,
28955 : ZEND_FETCH_UNSET_SPEC_CONST_HANDLER,
28956 : ZEND_FETCH_UNSET_SPEC_CONST_HANDLER,
28957 : ZEND_FETCH_UNSET_SPEC_CONST_HANDLER,
28958 : ZEND_FETCH_UNSET_SPEC_TMP_HANDLER,
28959 : ZEND_FETCH_UNSET_SPEC_TMP_HANDLER,
28960 : ZEND_FETCH_UNSET_SPEC_TMP_HANDLER,
28961 : ZEND_FETCH_UNSET_SPEC_TMP_HANDLER,
28962 : ZEND_FETCH_UNSET_SPEC_TMP_HANDLER,
28963 : ZEND_FETCH_UNSET_SPEC_VAR_HANDLER,
28964 : ZEND_FETCH_UNSET_SPEC_VAR_HANDLER,
28965 : ZEND_FETCH_UNSET_SPEC_VAR_HANDLER,
28966 : ZEND_FETCH_UNSET_SPEC_VAR_HANDLER,
28967 : ZEND_FETCH_UNSET_SPEC_VAR_HANDLER,
28968 : ZEND_NULL_HANDLER,
28969 : ZEND_NULL_HANDLER,
28970 : ZEND_NULL_HANDLER,
28971 : ZEND_NULL_HANDLER,
28972 : ZEND_NULL_HANDLER,
28973 : ZEND_FETCH_UNSET_SPEC_CV_HANDLER,
28974 : ZEND_FETCH_UNSET_SPEC_CV_HANDLER,
28975 : ZEND_FETCH_UNSET_SPEC_CV_HANDLER,
28976 : ZEND_FETCH_UNSET_SPEC_CV_HANDLER,
28977 : ZEND_FETCH_UNSET_SPEC_CV_HANDLER,
28978 : ZEND_NULL_HANDLER,
28979 : ZEND_NULL_HANDLER,
28980 : ZEND_NULL_HANDLER,
28981 : ZEND_NULL_HANDLER,
28982 : ZEND_NULL_HANDLER,
28983 : ZEND_NULL_HANDLER,
28984 : ZEND_NULL_HANDLER,
28985 : ZEND_NULL_HANDLER,
28986 : ZEND_NULL_HANDLER,
28987 : ZEND_NULL_HANDLER,
28988 : ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER,
28989 : ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_HANDLER,
28990 : ZEND_FETCH_DIM_UNSET_SPEC_VAR_VAR_HANDLER,
28991 : ZEND_NULL_HANDLER,
28992 : ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER,
28993 : ZEND_NULL_HANDLER,
28994 : ZEND_NULL_HANDLER,
28995 : ZEND_NULL_HANDLER,
28996 : ZEND_NULL_HANDLER,
28997 : ZEND_NULL_HANDLER,
28998 : ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER,
28999 : ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER,
29000 : ZEND_FETCH_DIM_UNSET_SPEC_CV_VAR_HANDLER,
29001 : ZEND_NULL_HANDLER,
29002 : ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER,
29003 : ZEND_NULL_HANDLER,
29004 : ZEND_NULL_HANDLER,
29005 : ZEND_NULL_HANDLER,
29006 : ZEND_NULL_HANDLER,
29007 : ZEND_NULL_HANDLER,
29008 : ZEND_NULL_HANDLER,
29009 : ZEND_NULL_HANDLER,
29010 : ZEND_NULL_HANDLER,
29011 : ZEND_NULL_HANDLER,
29012 : ZEND_NULL_HANDLER,
29013 : ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER,
29014 : ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_HANDLER,
29015 : ZEND_FETCH_OBJ_UNSET_SPEC_VAR_VAR_HANDLER,
29016 : ZEND_NULL_HANDLER,
29017 : ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER,
29018 : ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER,
29019 : ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER,
29020 : ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_VAR_HANDLER,
29021 : ZEND_NULL_HANDLER,
29022 : ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER,
29023 : ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER,
29024 : ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_HANDLER,
29025 : ZEND_FETCH_OBJ_UNSET_SPEC_CV_VAR_HANDLER,
29026 : ZEND_NULL_HANDLER,
29027 : ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER,
29028 : ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER,
29029 : ZEND_NULL_HANDLER,
29030 : ZEND_NULL_HANDLER,
29031 : ZEND_NULL_HANDLER,
29032 : ZEND_NULL_HANDLER,
29033 : ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER,
29034 : ZEND_NULL_HANDLER,
29035 : ZEND_NULL_HANDLER,
29036 : ZEND_NULL_HANDLER,
29037 : ZEND_NULL_HANDLER,
29038 : ZEND_NULL_HANDLER,
29039 : ZEND_NULL_HANDLER,
29040 : ZEND_NULL_HANDLER,
29041 : ZEND_NULL_HANDLER,
29042 : ZEND_NULL_HANDLER,
29043 : ZEND_NULL_HANDLER,
29044 : ZEND_NULL_HANDLER,
29045 : ZEND_NULL_HANDLER,
29046 : ZEND_NULL_HANDLER,
29047 : ZEND_NULL_HANDLER,
29048 : ZEND_NULL_HANDLER,
29049 : ZEND_NULL_HANDLER,
29050 : ZEND_NULL_HANDLER,
29051 : ZEND_NULL_HANDLER,
29052 : ZEND_NULL_HANDLER,
29053 : ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER,
29054 : ZEND_NULL_HANDLER,
29055 : ZEND_NULL_HANDLER,
29056 : ZEND_NULL_HANDLER,
29057 : ZEND_NULL_HANDLER,
29058 : ZEND_NULL_HANDLER,
29059 : ZEND_NULL_HANDLER,
29060 : ZEND_NULL_HANDLER,
29061 : ZEND_NULL_HANDLER,
29062 : ZEND_NULL_HANDLER,
29063 : ZEND_NULL_HANDLER,
29064 : ZEND_NULL_HANDLER,
29065 : ZEND_NULL_HANDLER,
29066 : ZEND_NULL_HANDLER,
29067 : ZEND_NULL_HANDLER,
29068 : ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER,
29069 : ZEND_NULL_HANDLER,
29070 : ZEND_NULL_HANDLER,
29071 : ZEND_NULL_HANDLER,
29072 : ZEND_NULL_HANDLER,
29073 : ZEND_NULL_HANDLER,
29074 : ZEND_NULL_HANDLER,
29075 : ZEND_NULL_HANDLER,
29076 : ZEND_NULL_HANDLER,
29077 : ZEND_NULL_HANDLER,
29078 : ZEND_NULL_HANDLER,
29079 : ZEND_NULL_HANDLER,
29080 : ZEND_NULL_HANDLER,
29081 : ZEND_NULL_HANDLER,
29082 : ZEND_NULL_HANDLER,
29083 : ZEND_NULL_HANDLER,
29084 : ZEND_NULL_HANDLER,
29085 : ZEND_NULL_HANDLER,
29086 : ZEND_NULL_HANDLER,
29087 : ZEND_NULL_HANDLER,
29088 : ZEND_NULL_HANDLER,
29089 : ZEND_NULL_HANDLER,
29090 : ZEND_NULL_HANDLER,
29091 : ZEND_NULL_HANDLER,
29092 : ZEND_NULL_HANDLER,
29093 : ZEND_NULL_HANDLER,
29094 : ZEND_NULL_HANDLER,
29095 : ZEND_NULL_HANDLER,
29096 : ZEND_NULL_HANDLER,
29097 : ZEND_NULL_HANDLER,
29098 : ZEND_NULL_HANDLER,
29099 : ZEND_NULL_HANDLER,
29100 : ZEND_NULL_HANDLER,
29101 : ZEND_NULL_HANDLER,
29102 : ZEND_NULL_HANDLER,
29103 : ZEND_EXT_STMT_SPEC_HANDLER,
29104 : ZEND_EXT_STMT_SPEC_HANDLER,
29105 : ZEND_EXT_STMT_SPEC_HANDLER,
29106 : ZEND_EXT_STMT_SPEC_HANDLER,
29107 : ZEND_EXT_STMT_SPEC_HANDLER,
29108 : ZEND_EXT_STMT_SPEC_HANDLER,
29109 : ZEND_EXT_STMT_SPEC_HANDLER,
29110 : ZEND_EXT_STMT_SPEC_HANDLER,
29111 : ZEND_EXT_STMT_SPEC_HANDLER,
29112 : ZEND_EXT_STMT_SPEC_HANDLER,
29113 : ZEND_EXT_STMT_SPEC_HANDLER,
29114 : ZEND_EXT_STMT_SPEC_HANDLER,
29115 : ZEND_EXT_STMT_SPEC_HANDLER,
29116 : ZEND_EXT_STMT_SPEC_HANDLER,
29117 : ZEND_EXT_STMT_SPEC_HANDLER,
29118 : ZEND_EXT_STMT_SPEC_HANDLER,
29119 : ZEND_EXT_STMT_SPEC_HANDLER,
29120 : ZEND_EXT_STMT_SPEC_HANDLER,
29121 : ZEND_EXT_STMT_SPEC_HANDLER,
29122 : ZEND_EXT_STMT_SPEC_HANDLER,
29123 : ZEND_EXT_STMT_SPEC_HANDLER,
29124 : ZEND_EXT_STMT_SPEC_HANDLER,
29125 : ZEND_EXT_STMT_SPEC_HANDLER,
29126 : ZEND_EXT_STMT_SPEC_HANDLER,
29127 : ZEND_EXT_STMT_SPEC_HANDLER,
29128 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29129 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29130 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29131 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29132 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29133 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29134 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29135 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29136 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29137 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29138 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29139 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29140 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29141 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29142 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29143 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29144 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29145 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29146 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29147 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29148 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29149 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29150 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29151 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29152 : ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
29153 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29154 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29155 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29156 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29157 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29158 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29159 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29160 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29161 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29162 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29163 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29164 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29165 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29166 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29167 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29168 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29169 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29170 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29171 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29172 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29173 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29174 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29175 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29176 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29177 : ZEND_EXT_FCALL_END_SPEC_HANDLER,
29178 : ZEND_EXT_NOP_SPEC_HANDLER,
29179 : ZEND_EXT_NOP_SPEC_HANDLER,
29180 : ZEND_EXT_NOP_SPEC_HANDLER,
29181 : ZEND_EXT_NOP_SPEC_HANDLER,
29182 : ZEND_EXT_NOP_SPEC_HANDLER,
29183 : ZEND_EXT_NOP_SPEC_HANDLER,
29184 : ZEND_EXT_NOP_SPEC_HANDLER,
29185 : ZEND_EXT_NOP_SPEC_HANDLER,
29186 : ZEND_EXT_NOP_SPEC_HANDLER,
29187 : ZEND_EXT_NOP_SPEC_HANDLER,
29188 : ZEND_EXT_NOP_SPEC_HANDLER,
29189 : ZEND_EXT_NOP_SPEC_HANDLER,
29190 : ZEND_EXT_NOP_SPEC_HANDLER,
29191 : ZEND_EXT_NOP_SPEC_HANDLER,
29192 : ZEND_EXT_NOP_SPEC_HANDLER,
29193 : ZEND_EXT_NOP_SPEC_HANDLER,
29194 : ZEND_EXT_NOP_SPEC_HANDLER,
29195 : ZEND_EXT_NOP_SPEC_HANDLER,
29196 : ZEND_EXT_NOP_SPEC_HANDLER,
29197 : ZEND_EXT_NOP_SPEC_HANDLER,
29198 : ZEND_EXT_NOP_SPEC_HANDLER,
29199 : ZEND_EXT_NOP_SPEC_HANDLER,
29200 : ZEND_EXT_NOP_SPEC_HANDLER,
29201 : ZEND_EXT_NOP_SPEC_HANDLER,
29202 : ZEND_EXT_NOP_SPEC_HANDLER,
29203 : ZEND_TICKS_SPEC_CONST_HANDLER,
29204 : ZEND_TICKS_SPEC_CONST_HANDLER,
29205 : ZEND_TICKS_SPEC_CONST_HANDLER,
29206 : ZEND_TICKS_SPEC_CONST_HANDLER,
29207 : ZEND_TICKS_SPEC_CONST_HANDLER,
29208 : ZEND_NULL_HANDLER,
29209 : ZEND_NULL_HANDLER,
29210 : ZEND_NULL_HANDLER,
29211 : ZEND_NULL_HANDLER,
29212 : ZEND_NULL_HANDLER,
29213 : ZEND_NULL_HANDLER,
29214 : ZEND_NULL_HANDLER,
29215 : ZEND_NULL_HANDLER,
29216 : ZEND_NULL_HANDLER,
29217 : ZEND_NULL_HANDLER,
29218 : ZEND_NULL_HANDLER,
29219 : ZEND_NULL_HANDLER,
29220 : ZEND_NULL_HANDLER,
29221 : ZEND_NULL_HANDLER,
29222 : ZEND_NULL_HANDLER,
29223 : ZEND_NULL_HANDLER,
29224 : ZEND_NULL_HANDLER,
29225 : ZEND_NULL_HANDLER,
29226 : ZEND_NULL_HANDLER,
29227 : ZEND_NULL_HANDLER,
29228 : ZEND_NULL_HANDLER,
29229 : ZEND_NULL_HANDLER,
29230 : ZEND_NULL_HANDLER,
29231 : ZEND_NULL_HANDLER,
29232 : ZEND_NULL_HANDLER,
29233 : ZEND_NULL_HANDLER,
29234 : ZEND_NULL_HANDLER,
29235 : ZEND_NULL_HANDLER,
29236 : ZEND_NULL_HANDLER,
29237 : ZEND_NULL_HANDLER,
29238 : ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER,
29239 : ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER,
29240 : ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER,
29241 : ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER,
29242 : ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER,
29243 : ZEND_NULL_HANDLER,
29244 : ZEND_NULL_HANDLER,
29245 : ZEND_NULL_HANDLER,
29246 : ZEND_NULL_HANDLER,
29247 : ZEND_NULL_HANDLER,
29248 : ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER,
29249 : ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER,
29250 : ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER,
29251 : ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER,
29252 : ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER,
29253 : ZEND_CATCH_SPEC_HANDLER,
29254 : ZEND_CATCH_SPEC_HANDLER,
29255 : ZEND_CATCH_SPEC_HANDLER,
29256 : ZEND_CATCH_SPEC_HANDLER,
29257 : ZEND_CATCH_SPEC_HANDLER,
29258 : ZEND_CATCH_SPEC_HANDLER,
29259 : ZEND_CATCH_SPEC_HANDLER,
29260 : ZEND_CATCH_SPEC_HANDLER,
29261 : ZEND_CATCH_SPEC_HANDLER,
29262 : ZEND_CATCH_SPEC_HANDLER,
29263 : ZEND_CATCH_SPEC_HANDLER,
29264 : ZEND_CATCH_SPEC_HANDLER,
29265 : ZEND_CATCH_SPEC_HANDLER,
29266 : ZEND_CATCH_SPEC_HANDLER,
29267 : ZEND_CATCH_SPEC_HANDLER,
29268 : ZEND_CATCH_SPEC_HANDLER,
29269 : ZEND_CATCH_SPEC_HANDLER,
29270 : ZEND_CATCH_SPEC_HANDLER,
29271 : ZEND_CATCH_SPEC_HANDLER,
29272 : ZEND_CATCH_SPEC_HANDLER,
29273 : ZEND_CATCH_SPEC_HANDLER,
29274 : ZEND_CATCH_SPEC_HANDLER,
29275 : ZEND_CATCH_SPEC_HANDLER,
29276 : ZEND_CATCH_SPEC_HANDLER,
29277 : ZEND_CATCH_SPEC_HANDLER,
29278 : ZEND_THROW_SPEC_CONST_HANDLER,
29279 : ZEND_THROW_SPEC_CONST_HANDLER,
29280 : ZEND_THROW_SPEC_CONST_HANDLER,
29281 : ZEND_THROW_SPEC_CONST_HANDLER,
29282 : ZEND_THROW_SPEC_CONST_HANDLER,
29283 : ZEND_THROW_SPEC_TMP_HANDLER,
29284 : ZEND_THROW_SPEC_TMP_HANDLER,
29285 : ZEND_THROW_SPEC_TMP_HANDLER,
29286 : ZEND_THROW_SPEC_TMP_HANDLER,
29287 : ZEND_THROW_SPEC_TMP_HANDLER,
29288 : ZEND_THROW_SPEC_VAR_HANDLER,
29289 : ZEND_THROW_SPEC_VAR_HANDLER,
29290 : ZEND_THROW_SPEC_VAR_HANDLER,
29291 : ZEND_THROW_SPEC_VAR_HANDLER,
29292 : ZEND_THROW_SPEC_VAR_HANDLER,
29293 : ZEND_NULL_HANDLER,
29294 : ZEND_NULL_HANDLER,
29295 : ZEND_NULL_HANDLER,
29296 : ZEND_NULL_HANDLER,
29297 : ZEND_NULL_HANDLER,
29298 : ZEND_THROW_SPEC_CV_HANDLER,
29299 : ZEND_THROW_SPEC_CV_HANDLER,
29300 : ZEND_THROW_SPEC_CV_HANDLER,
29301 : ZEND_THROW_SPEC_CV_HANDLER,
29302 : ZEND_THROW_SPEC_CV_HANDLER,
29303 : ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
29304 : ZEND_FETCH_CLASS_SPEC_TMP_HANDLER,
29305 : ZEND_FETCH_CLASS_SPEC_VAR_HANDLER,
29306 : ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
29307 : ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
29308 : ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
29309 : ZEND_FETCH_CLASS_SPEC_TMP_HANDLER,
29310 : ZEND_FETCH_CLASS_SPEC_VAR_HANDLER,
29311 : ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
29312 : ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
29313 : ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
29314 : ZEND_FETCH_CLASS_SPEC_TMP_HANDLER,
29315 : ZEND_FETCH_CLASS_SPEC_VAR_HANDLER,
29316 : ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
29317 : ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
29318 : ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
29319 : ZEND_FETCH_CLASS_SPEC_TMP_HANDLER,
29320 : ZEND_FETCH_CLASS_SPEC_VAR_HANDLER,
29321 : ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
29322 : ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
29323 : ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
29324 : ZEND_FETCH_CLASS_SPEC_TMP_HANDLER,
29325 : ZEND_FETCH_CLASS_SPEC_VAR_HANDLER,
29326 : ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
29327 : ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
29328 : ZEND_CLONE_SPEC_CONST_HANDLER,
29329 : ZEND_CLONE_SPEC_CONST_HANDLER,
29330 : ZEND_CLONE_SPEC_CONST_HANDLER,
29331 : ZEND_CLONE_SPEC_CONST_HANDLER,
29332 : ZEND_CLONE_SPEC_CONST_HANDLER,
29333 : ZEND_CLONE_SPEC_TMP_HANDLER,
29334 : ZEND_CLONE_SPEC_TMP_HANDLER,
29335 : ZEND_CLONE_SPEC_TMP_HANDLER,
29336 : ZEND_CLONE_SPEC_TMP_HANDLER,
29337 : ZEND_CLONE_SPEC_TMP_HANDLER,
29338 : ZEND_CLONE_SPEC_VAR_HANDLER,
29339 : ZEND_CLONE_SPEC_VAR_HANDLER,
29340 : ZEND_CLONE_SPEC_VAR_HANDLER,
29341 : ZEND_CLONE_SPEC_VAR_HANDLER,
29342 : ZEND_CLONE_SPEC_VAR_HANDLER,
29343 : ZEND_CLONE_SPEC_UNUSED_HANDLER,
29344 : ZEND_CLONE_SPEC_UNUSED_HANDLER,
29345 : ZEND_CLONE_SPEC_UNUSED_HANDLER,
29346 : ZEND_CLONE_SPEC_UNUSED_HANDLER,
29347 : ZEND_CLONE_SPEC_UNUSED_HANDLER,
29348 : ZEND_CLONE_SPEC_CV_HANDLER,
29349 : ZEND_CLONE_SPEC_CV_HANDLER,
29350 : ZEND_CLONE_SPEC_CV_HANDLER,
29351 : ZEND_CLONE_SPEC_CV_HANDLER,
29352 : ZEND_CLONE_SPEC_CV_HANDLER,
29353 : ZEND_NULL_HANDLER,
29354 : ZEND_NULL_HANDLER,
29355 : ZEND_NULL_HANDLER,
29356 : ZEND_NULL_HANDLER,
29357 : ZEND_NULL_HANDLER,
29358 : ZEND_NULL_HANDLER,
29359 : ZEND_NULL_HANDLER,
29360 : ZEND_NULL_HANDLER,
29361 : ZEND_NULL_HANDLER,
29362 : ZEND_NULL_HANDLER,
29363 : ZEND_NULL_HANDLER,
29364 : ZEND_NULL_HANDLER,
29365 : ZEND_NULL_HANDLER,
29366 : ZEND_NULL_HANDLER,
29367 : ZEND_NULL_HANDLER,
29368 : ZEND_NULL_HANDLER,
29369 : ZEND_NULL_HANDLER,
29370 : ZEND_NULL_HANDLER,
29371 : ZEND_NULL_HANDLER,
29372 : ZEND_NULL_HANDLER,
29373 : ZEND_NULL_HANDLER,
29374 : ZEND_NULL_HANDLER,
29375 : ZEND_NULL_HANDLER,
29376 : ZEND_NULL_HANDLER,
29377 : ZEND_NULL_HANDLER,
29378 : ZEND_NULL_HANDLER,
29379 : ZEND_NULL_HANDLER,
29380 : ZEND_NULL_HANDLER,
29381 : ZEND_NULL_HANDLER,
29382 : ZEND_NULL_HANDLER,
29383 : ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER,
29384 : ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER,
29385 : ZEND_INIT_METHOD_CALL_SPEC_TMP_VAR_HANDLER,
29386 : ZEND_NULL_HANDLER,
29387 : ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER,
29388 : ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER,
29389 : ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER,
29390 : ZEND_INIT_METHOD_CALL_SPEC_VAR_VAR_HANDLER,
29391 : ZEND_NULL_HANDLER,
29392 : ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER,
29393 : ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER,
29394 : ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER,
29395 : ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER,
29396 : ZEND_NULL_HANDLER,
29397 : ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER,
29398 : ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER,
29399 : ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER,
29400 : ZEND_INIT_METHOD_CALL_SPEC_CV_VAR_HANDLER,
29401 : ZEND_NULL_HANDLER,
29402 : ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER,
29403 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_HANDLER,
29404 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_TMP_HANDLER,
29405 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_HANDLER,
29406 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_HANDLER,
29407 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_CV_HANDLER,
29408 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_HANDLER,
29409 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_TMP_HANDLER,
29410 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_HANDLER,
29411 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_HANDLER,
29412 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_CV_HANDLER,
29413 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_HANDLER,
29414 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_TMP_HANDLER,
29415 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_HANDLER,
29416 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_HANDLER,
29417 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_CV_HANDLER,
29418 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_HANDLER,
29419 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_TMP_HANDLER,
29420 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_HANDLER,
29421 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_HANDLER,
29422 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_CV_HANDLER,
29423 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_HANDLER,
29424 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_TMP_HANDLER,
29425 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_HANDLER,
29426 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_HANDLER,
29427 : ZEND_INIT_STATIC_METHOD_CALL_SPEC_CV_HANDLER,
29428 : ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER,
29429 : ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER,
29430 : ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER,
29431 : ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER,
29432 : ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER,
29433 : ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER,
29434 : ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER,
29435 : ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER,
29436 : ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER,
29437 : ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER,
29438 : ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER,
29439 : ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER,
29440 : ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER,
29441 : ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER,
29442 : ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER,
29443 : ZEND_NULL_HANDLER,
29444 : ZEND_NULL_HANDLER,
29445 : ZEND_NULL_HANDLER,
29446 : ZEND_NULL_HANDLER,
29447 : ZEND_NULL_HANDLER,
29448 : ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER,
29449 : ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER,
29450 : ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER,
29451 : ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER,
29452 : ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER,
29453 : ZEND_NULL_HANDLER,
29454 : ZEND_NULL_HANDLER,
29455 : ZEND_NULL_HANDLER,
29456 : ZEND_NULL_HANDLER,
29457 : ZEND_NULL_HANDLER,
29458 : ZEND_NULL_HANDLER,
29459 : ZEND_NULL_HANDLER,
29460 : ZEND_NULL_HANDLER,
29461 : ZEND_NULL_HANDLER,
29462 : ZEND_NULL_HANDLER,
29463 : ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER,
29464 : ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER,
29465 : ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER,
29466 : ZEND_NULL_HANDLER,
29467 : ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CV_HANDLER,
29468 : ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CONST_HANDLER,
29469 : ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_TMP_HANDLER,
29470 : ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_VAR_HANDLER,
29471 : ZEND_NULL_HANDLER,
29472 : ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CV_HANDLER,
29473 : ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER,
29474 : ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER,
29475 : ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_VAR_HANDLER,
29476 : ZEND_NULL_HANDLER,
29477 : ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER,
29478 : ZEND_NULL_HANDLER,
29479 : ZEND_NULL_HANDLER,
29480 : ZEND_NULL_HANDLER,
29481 : ZEND_NULL_HANDLER,
29482 : ZEND_NULL_HANDLER,
29483 : ZEND_NULL_HANDLER,
29484 : ZEND_NULL_HANDLER,
29485 : ZEND_NULL_HANDLER,
29486 : ZEND_NULL_HANDLER,
29487 : ZEND_NULL_HANDLER,
29488 : ZEND_NULL_HANDLER,
29489 : ZEND_NULL_HANDLER,
29490 : ZEND_NULL_HANDLER,
29491 : ZEND_NULL_HANDLER,
29492 : ZEND_NULL_HANDLER,
29493 : ZEND_NULL_HANDLER,
29494 : ZEND_NULL_HANDLER,
29495 : ZEND_NULL_HANDLER,
29496 : ZEND_NULL_HANDLER,
29497 : ZEND_NULL_HANDLER,
29498 : ZEND_NULL_HANDLER,
29499 : ZEND_NULL_HANDLER,
29500 : ZEND_NULL_HANDLER,
29501 : ZEND_NULL_HANDLER,
29502 : ZEND_NULL_HANDLER,
29503 : ZEND_NULL_HANDLER,
29504 : ZEND_NULL_HANDLER,
29505 : ZEND_NULL_HANDLER,
29506 : ZEND_NULL_HANDLER,
29507 : ZEND_NULL_HANDLER,
29508 : ZEND_NULL_HANDLER,
29509 : ZEND_NULL_HANDLER,
29510 : ZEND_NULL_HANDLER,
29511 : ZEND_NULL_HANDLER,
29512 : ZEND_NULL_HANDLER,
29513 : ZEND_NULL_HANDLER,
29514 : ZEND_NULL_HANDLER,
29515 : ZEND_NULL_HANDLER,
29516 : ZEND_NULL_HANDLER,
29517 : ZEND_NULL_HANDLER,
29518 : ZEND_NULL_HANDLER,
29519 : ZEND_NULL_HANDLER,
29520 : ZEND_NULL_HANDLER,
29521 : ZEND_NULL_HANDLER,
29522 : ZEND_NULL_HANDLER,
29523 : ZEND_NULL_HANDLER,
29524 : ZEND_NULL_HANDLER,
29525 : ZEND_NULL_HANDLER,
29526 : ZEND_NULL_HANDLER,
29527 : ZEND_NULL_HANDLER,
29528 : ZEND_NULL_HANDLER,
29529 : ZEND_NULL_HANDLER,
29530 : ZEND_NULL_HANDLER,
29531 : ZEND_NULL_HANDLER,
29532 : ZEND_NULL_HANDLER,
29533 : ZEND_NULL_HANDLER,
29534 : ZEND_NULL_HANDLER,
29535 : ZEND_NULL_HANDLER,
29536 : ZEND_NULL_HANDLER,
29537 : ZEND_NULL_HANDLER,
29538 : ZEND_NULL_HANDLER,
29539 : ZEND_NULL_HANDLER,
29540 : ZEND_NULL_HANDLER,
29541 : ZEND_NULL_HANDLER,
29542 : ZEND_NULL_HANDLER,
29543 : ZEND_NULL_HANDLER,
29544 : ZEND_NULL_HANDLER,
29545 : ZEND_NULL_HANDLER,
29546 : ZEND_NULL_HANDLER,
29547 : ZEND_NULL_HANDLER,
29548 : ZEND_NULL_HANDLER,
29549 : ZEND_NULL_HANDLER,
29550 : ZEND_NULL_HANDLER,
29551 : ZEND_NULL_HANDLER,
29552 : ZEND_NULL_HANDLER,
29553 : ZEND_NULL_HANDLER,
29554 : ZEND_NULL_HANDLER,
29555 : ZEND_NULL_HANDLER,
29556 : ZEND_NULL_HANDLER,
29557 : ZEND_NULL_HANDLER,
29558 : ZEND_NULL_HANDLER,
29559 : ZEND_NULL_HANDLER,
29560 : ZEND_NULL_HANDLER,
29561 : ZEND_NULL_HANDLER,
29562 : ZEND_NULL_HANDLER,
29563 : ZEND_NULL_HANDLER,
29564 : ZEND_NULL_HANDLER,
29565 : ZEND_NULL_HANDLER,
29566 : ZEND_NULL_HANDLER,
29567 : ZEND_NULL_HANDLER,
29568 : ZEND_NULL_HANDLER,
29569 : ZEND_NULL_HANDLER,
29570 : ZEND_NULL_HANDLER,
29571 : ZEND_NULL_HANDLER,
29572 : ZEND_NULL_HANDLER,
29573 : ZEND_NULL_HANDLER,
29574 : ZEND_NULL_HANDLER,
29575 : ZEND_NULL_HANDLER,
29576 : ZEND_NULL_HANDLER,
29577 : ZEND_NULL_HANDLER,
29578 : ZEND_NULL_HANDLER,
29579 : ZEND_NULL_HANDLER,
29580 : ZEND_NULL_HANDLER,
29581 : ZEND_NULL_HANDLER,
29582 : ZEND_NULL_HANDLER,
29583 : ZEND_NULL_HANDLER,
29584 : ZEND_NULL_HANDLER,
29585 : ZEND_NULL_HANDLER,
29586 : ZEND_NULL_HANDLER,
29587 : ZEND_NULL_HANDLER,
29588 : ZEND_NULL_HANDLER,
29589 : ZEND_NULL_HANDLER,
29590 : ZEND_NULL_HANDLER,
29591 : ZEND_NULL_HANDLER,
29592 : ZEND_NULL_HANDLER,
29593 : ZEND_NULL_HANDLER,
29594 : ZEND_NULL_HANDLER,
29595 : ZEND_NULL_HANDLER,
29596 : ZEND_NULL_HANDLER,
29597 : ZEND_NULL_HANDLER,
29598 : ZEND_NULL_HANDLER,
29599 : ZEND_NULL_HANDLER,
29600 : ZEND_NULL_HANDLER,
29601 : ZEND_NULL_HANDLER,
29602 : ZEND_NULL_HANDLER,
29603 : ZEND_NULL_HANDLER,
29604 : ZEND_NULL_HANDLER,
29605 : ZEND_NULL_HANDLER,
29606 : ZEND_NULL_HANDLER,
29607 : ZEND_NULL_HANDLER,
29608 : ZEND_NULL_HANDLER,
29609 : ZEND_NULL_HANDLER,
29610 : ZEND_NULL_HANDLER,
29611 : ZEND_NULL_HANDLER,
29612 : ZEND_NULL_HANDLER,
29613 : ZEND_NULL_HANDLER,
29614 : ZEND_NULL_HANDLER,
29615 : ZEND_NULL_HANDLER,
29616 : ZEND_NULL_HANDLER,
29617 : ZEND_NULL_HANDLER,
29618 : ZEND_NULL_HANDLER,
29619 : ZEND_NULL_HANDLER,
29620 : ZEND_NULL_HANDLER,
29621 : ZEND_NULL_HANDLER,
29622 : ZEND_NULL_HANDLER,
29623 : ZEND_NULL_HANDLER,
29624 : ZEND_NULL_HANDLER,
29625 : ZEND_NULL_HANDLER,
29626 : ZEND_NULL_HANDLER,
29627 : ZEND_NULL_HANDLER,
29628 : ZEND_NULL_HANDLER,
29629 : ZEND_NULL_HANDLER,
29630 : ZEND_NULL_HANDLER,
29631 : ZEND_NULL_HANDLER,
29632 : ZEND_NULL_HANDLER,
29633 : ZEND_NULL_HANDLER,
29634 : ZEND_NULL_HANDLER,
29635 : ZEND_NULL_HANDLER,
29636 : ZEND_NULL_HANDLER,
29637 : ZEND_NULL_HANDLER,
29638 : ZEND_NULL_HANDLER,
29639 : ZEND_NULL_HANDLER,
29640 : ZEND_NULL_HANDLER,
29641 : ZEND_NULL_HANDLER,
29642 : ZEND_NULL_HANDLER,
29643 : ZEND_NULL_HANDLER,
29644 : ZEND_NULL_HANDLER,
29645 : ZEND_NULL_HANDLER,
29646 : ZEND_NULL_HANDLER,
29647 : ZEND_NULL_HANDLER,
29648 : ZEND_NULL_HANDLER,
29649 : ZEND_NULL_HANDLER,
29650 : ZEND_NULL_HANDLER,
29651 : ZEND_NULL_HANDLER,
29652 : ZEND_NULL_HANDLER,
29653 : ZEND_NULL_HANDLER,
29654 : ZEND_NULL_HANDLER,
29655 : ZEND_NULL_HANDLER,
29656 : ZEND_NULL_HANDLER,
29657 : ZEND_NULL_HANDLER,
29658 : ZEND_NULL_HANDLER,
29659 : ZEND_NULL_HANDLER,
29660 : ZEND_NULL_HANDLER,
29661 : ZEND_NULL_HANDLER,
29662 : ZEND_NULL_HANDLER,
29663 : ZEND_NULL_HANDLER,
29664 : ZEND_NULL_HANDLER,
29665 : ZEND_NULL_HANDLER,
29666 : ZEND_NULL_HANDLER,
29667 : ZEND_NULL_HANDLER,
29668 : ZEND_NULL_HANDLER,
29669 : ZEND_NULL_HANDLER,
29670 : ZEND_NULL_HANDLER,
29671 : ZEND_NULL_HANDLER,
29672 : ZEND_NULL_HANDLER,
29673 : ZEND_NULL_HANDLER,
29674 : ZEND_NULL_HANDLER,
29675 : ZEND_NULL_HANDLER,
29676 : ZEND_NULL_HANDLER,
29677 : ZEND_NULL_HANDLER,
29678 : ZEND_NULL_HANDLER,
29679 : ZEND_NULL_HANDLER,
29680 : ZEND_NULL_HANDLER,
29681 : ZEND_NULL_HANDLER,
29682 : ZEND_NULL_HANDLER,
29683 : ZEND_NULL_HANDLER,
29684 : ZEND_NULL_HANDLER,
29685 : ZEND_NULL_HANDLER,
29686 : ZEND_NULL_HANDLER,
29687 : ZEND_NULL_HANDLER,
29688 : ZEND_NULL_HANDLER,
29689 : ZEND_NULL_HANDLER,
29690 : ZEND_NULL_HANDLER,
29691 : ZEND_NULL_HANDLER,
29692 : ZEND_NULL_HANDLER,
29693 : ZEND_NULL_HANDLER,
29694 : ZEND_NULL_HANDLER,
29695 : ZEND_NULL_HANDLER,
29696 : ZEND_NULL_HANDLER,
29697 : ZEND_NULL_HANDLER,
29698 : ZEND_NULL_HANDLER,
29699 : ZEND_NULL_HANDLER,
29700 : ZEND_NULL_HANDLER,
29701 : ZEND_NULL_HANDLER,
29702 : ZEND_NULL_HANDLER,
29703 : ZEND_NULL_HANDLER,
29704 : ZEND_NULL_HANDLER,
29705 : ZEND_NULL_HANDLER,
29706 : ZEND_NULL_HANDLER,
29707 : ZEND_NULL_HANDLER,
29708 : ZEND_NULL_HANDLER,
29709 : ZEND_NULL_HANDLER,
29710 : ZEND_NULL_HANDLER,
29711 : ZEND_NULL_HANDLER,
29712 : ZEND_NULL_HANDLER,
29713 : ZEND_NULL_HANDLER,
29714 : ZEND_NULL_HANDLER,
29715 : ZEND_NULL_HANDLER,
29716 : ZEND_NULL_HANDLER,
29717 : ZEND_NULL_HANDLER,
29718 : ZEND_NULL_HANDLER,
29719 : ZEND_NULL_HANDLER,
29720 : ZEND_NULL_HANDLER,
29721 : ZEND_NULL_HANDLER,
29722 : ZEND_NULL_HANDLER,
29723 : ZEND_NULL_HANDLER,
29724 : ZEND_NULL_HANDLER,
29725 : ZEND_NULL_HANDLER,
29726 : ZEND_NULL_HANDLER,
29727 : ZEND_NULL_HANDLER,
29728 : ZEND_NULL_HANDLER,
29729 : ZEND_NULL_HANDLER,
29730 : ZEND_NULL_HANDLER,
29731 : ZEND_NULL_HANDLER,
29732 : ZEND_NULL_HANDLER,
29733 : ZEND_NULL_HANDLER,
29734 : ZEND_NULL_HANDLER,
29735 : ZEND_NULL_HANDLER,
29736 : ZEND_NULL_HANDLER,
29737 : ZEND_NULL_HANDLER,
29738 : ZEND_NULL_HANDLER,
29739 : ZEND_NULL_HANDLER,
29740 : ZEND_NULL_HANDLER,
29741 : ZEND_NULL_HANDLER,
29742 : ZEND_NULL_HANDLER,
29743 : ZEND_NULL_HANDLER,
29744 : ZEND_NULL_HANDLER,
29745 : ZEND_NULL_HANDLER,
29746 : ZEND_NULL_HANDLER,
29747 : ZEND_NULL_HANDLER,
29748 : ZEND_NULL_HANDLER,
29749 : ZEND_NULL_HANDLER,
29750 : ZEND_NULL_HANDLER,
29751 : ZEND_NULL_HANDLER,
29752 : ZEND_NULL_HANDLER,
29753 : ZEND_NULL_HANDLER,
29754 : ZEND_NULL_HANDLER,
29755 : ZEND_NULL_HANDLER,
29756 : ZEND_NULL_HANDLER,
29757 : ZEND_NULL_HANDLER,
29758 : ZEND_NULL_HANDLER,
29759 : ZEND_NULL_HANDLER,
29760 : ZEND_NULL_HANDLER,
29761 : ZEND_NULL_HANDLER,
29762 : ZEND_NULL_HANDLER,
29763 : ZEND_NULL_HANDLER,
29764 : ZEND_NULL_HANDLER,
29765 : ZEND_NULL_HANDLER,
29766 : ZEND_NULL_HANDLER,
29767 : ZEND_NULL_HANDLER,
29768 : ZEND_NULL_HANDLER,
29769 : ZEND_NULL_HANDLER,
29770 : ZEND_NULL_HANDLER,
29771 : ZEND_NULL_HANDLER,
29772 : ZEND_NULL_HANDLER,
29773 : ZEND_NULL_HANDLER,
29774 : ZEND_NULL_HANDLER,
29775 : ZEND_NULL_HANDLER,
29776 : ZEND_NULL_HANDLER,
29777 : ZEND_NULL_HANDLER,
29778 : ZEND_NULL_HANDLER,
29779 : ZEND_NULL_HANDLER,
29780 : ZEND_NULL_HANDLER,
29781 : ZEND_NULL_HANDLER,
29782 : ZEND_NULL_HANDLER,
29783 : ZEND_NULL_HANDLER,
29784 : ZEND_NULL_HANDLER,
29785 : ZEND_NULL_HANDLER,
29786 : ZEND_NULL_HANDLER,
29787 : ZEND_NULL_HANDLER,
29788 : ZEND_NULL_HANDLER,
29789 : ZEND_NULL_HANDLER,
29790 : ZEND_NULL_HANDLER,
29791 : ZEND_NULL_HANDLER,
29792 : ZEND_NULL_HANDLER,
29793 : ZEND_NULL_HANDLER,
29794 : ZEND_NULL_HANDLER,
29795 : ZEND_NULL_HANDLER,
29796 : ZEND_NULL_HANDLER,
29797 : ZEND_NULL_HANDLER,
29798 : ZEND_NULL_HANDLER,
29799 : ZEND_NULL_HANDLER,
29800 : ZEND_NULL_HANDLER,
29801 : ZEND_NULL_HANDLER,
29802 : ZEND_NULL_HANDLER,
29803 : ZEND_NULL_HANDLER,
29804 : ZEND_NULL_HANDLER,
29805 : ZEND_NULL_HANDLER,
29806 : ZEND_NULL_HANDLER,
29807 : ZEND_NULL_HANDLER,
29808 : ZEND_NULL_HANDLER,
29809 : ZEND_NULL_HANDLER,
29810 : ZEND_NULL_HANDLER,
29811 : ZEND_NULL_HANDLER,
29812 : ZEND_NULL_HANDLER,
29813 : ZEND_NULL_HANDLER,
29814 : ZEND_NULL_HANDLER,
29815 : ZEND_NULL_HANDLER,
29816 : ZEND_NULL_HANDLER,
29817 : ZEND_NULL_HANDLER,
29818 : ZEND_NULL_HANDLER,
29819 : ZEND_NULL_HANDLER,
29820 : ZEND_NULL_HANDLER,
29821 : ZEND_NULL_HANDLER,
29822 : ZEND_NULL_HANDLER,
29823 : ZEND_NULL_HANDLER,
29824 : ZEND_NULL_HANDLER,
29825 : ZEND_NULL_HANDLER,
29826 : ZEND_NULL_HANDLER,
29827 : ZEND_NULL_HANDLER,
29828 : ZEND_NULL_HANDLER,
29829 : ZEND_NULL_HANDLER,
29830 : ZEND_NULL_HANDLER,
29831 : ZEND_NULL_HANDLER,
29832 : ZEND_NULL_HANDLER,
29833 : ZEND_NULL_HANDLER,
29834 : ZEND_NULL_HANDLER,
29835 : ZEND_NULL_HANDLER,
29836 : ZEND_NULL_HANDLER,
29837 : ZEND_NULL_HANDLER,
29838 : ZEND_NULL_HANDLER,
29839 : ZEND_NULL_HANDLER,
29840 : ZEND_NULL_HANDLER,
29841 : ZEND_NULL_HANDLER,
29842 : ZEND_NULL_HANDLER,
29843 : ZEND_NULL_HANDLER,
29844 : ZEND_NULL_HANDLER,
29845 : ZEND_NULL_HANDLER,
29846 : ZEND_NULL_HANDLER,
29847 : ZEND_NULL_HANDLER,
29848 : ZEND_NULL_HANDLER,
29849 : ZEND_NULL_HANDLER,
29850 : ZEND_NULL_HANDLER,
29851 : ZEND_NULL_HANDLER,
29852 : ZEND_NULL_HANDLER,
29853 : ZEND_NULL_HANDLER,
29854 : ZEND_NULL_HANDLER,
29855 : ZEND_NULL_HANDLER,
29856 : ZEND_NULL_HANDLER,
29857 : ZEND_NULL_HANDLER,
29858 : ZEND_NULL_HANDLER,
29859 : ZEND_NULL_HANDLER,
29860 : ZEND_NULL_HANDLER,
29861 : ZEND_NULL_HANDLER,
29862 : ZEND_NULL_HANDLER,
29863 : ZEND_NULL_HANDLER,
29864 : ZEND_NULL_HANDLER,
29865 : ZEND_NULL_HANDLER,
29866 : ZEND_NULL_HANDLER,
29867 : ZEND_NULL_HANDLER,
29868 : ZEND_NULL_HANDLER,
29869 : ZEND_NULL_HANDLER,
29870 : ZEND_NULL_HANDLER,
29871 : ZEND_NULL_HANDLER,
29872 : ZEND_NULL_HANDLER,
29873 : ZEND_NULL_HANDLER,
29874 : ZEND_NULL_HANDLER,
29875 : ZEND_NULL_HANDLER,
29876 : ZEND_NULL_HANDLER,
29877 : ZEND_NULL_HANDLER,
29878 : ZEND_NULL_HANDLER,
29879 : ZEND_NULL_HANDLER,
29880 : ZEND_NULL_HANDLER,
29881 : ZEND_NULL_HANDLER,
29882 : ZEND_NULL_HANDLER,
29883 : ZEND_NULL_HANDLER,
29884 : ZEND_NULL_HANDLER,
29885 : ZEND_NULL_HANDLER,
29886 : ZEND_NULL_HANDLER,
29887 : ZEND_NULL_HANDLER,
29888 : ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER,
29889 : ZEND_PRE_INC_OBJ_SPEC_VAR_TMP_HANDLER,
29890 : ZEND_PRE_INC_OBJ_SPEC_VAR_VAR_HANDLER,
29891 : ZEND_NULL_HANDLER,
29892 : ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER,
29893 : ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER,
29894 : ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP_HANDLER,
29895 : ZEND_PRE_INC_OBJ_SPEC_UNUSED_VAR_HANDLER,
29896 : ZEND_NULL_HANDLER,
29897 : ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER,
29898 : ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER,
29899 : ZEND_PRE_INC_OBJ_SPEC_CV_TMP_HANDLER,
29900 : ZEND_PRE_INC_OBJ_SPEC_CV_VAR_HANDLER,
29901 : ZEND_NULL_HANDLER,
29902 : ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER,
29903 : ZEND_NULL_HANDLER,
29904 : ZEND_NULL_HANDLER,
29905 : ZEND_NULL_HANDLER,
29906 : ZEND_NULL_HANDLER,
29907 : ZEND_NULL_HANDLER,
29908 : ZEND_NULL_HANDLER,
29909 : ZEND_NULL_HANDLER,
29910 : ZEND_NULL_HANDLER,
29911 : ZEND_NULL_HANDLER,
29912 : ZEND_NULL_HANDLER,
29913 : ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST_HANDLER,
29914 : ZEND_PRE_DEC_OBJ_SPEC_VAR_TMP_HANDLER,
29915 : ZEND_PRE_DEC_OBJ_SPEC_VAR_VAR_HANDLER,
29916 : ZEND_NULL_HANDLER,
29917 : ZEND_PRE_DEC_OBJ_SPEC_VAR_CV_HANDLER,
29918 : ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER,
29919 : ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER,
29920 : ZEND_PRE_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER,
29921 : ZEND_NULL_HANDLER,
29922 : ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV_HANDLER,
29923 : ZEND_PRE_DEC_OBJ_SPEC_CV_CONST_HANDLER,
29924 : ZEND_PRE_DEC_OBJ_SPEC_CV_TMP_HANDLER,
29925 : ZEND_PRE_DEC_OBJ_SPEC_CV_VAR_HANDLER,
29926 : ZEND_NULL_HANDLER,
29927 : ZEND_PRE_DEC_OBJ_SPEC_CV_CV_HANDLER,
29928 : ZEND_NULL_HANDLER,
29929 : ZEND_NULL_HANDLER,
29930 : ZEND_NULL_HANDLER,
29931 : ZEND_NULL_HANDLER,
29932 : ZEND_NULL_HANDLER,
29933 : ZEND_NULL_HANDLER,
29934 : ZEND_NULL_HANDLER,
29935 : ZEND_NULL_HANDLER,
29936 : ZEND_NULL_HANDLER,
29937 : ZEND_NULL_HANDLER,
29938 : ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER,
29939 : ZEND_POST_INC_OBJ_SPEC_VAR_TMP_HANDLER,
29940 : ZEND_POST_INC_OBJ_SPEC_VAR_VAR_HANDLER,
29941 : ZEND_NULL_HANDLER,
29942 : ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER,
29943 : ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER,
29944 : ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP_HANDLER,
29945 : ZEND_POST_INC_OBJ_SPEC_UNUSED_VAR_HANDLER,
29946 : ZEND_NULL_HANDLER,
29947 : ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER,
29948 : ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER,
29949 : ZEND_POST_INC_OBJ_SPEC_CV_TMP_HANDLER,
29950 : ZEND_POST_INC_OBJ_SPEC_CV_VAR_HANDLER,
29951 : ZEND_NULL_HANDLER,
29952 : ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER,
29953 : ZEND_NULL_HANDLER,
29954 : ZEND_NULL_HANDLER,
29955 : ZEND_NULL_HANDLER,
29956 : ZEND_NULL_HANDLER,
29957 : ZEND_NULL_HANDLER,
29958 : ZEND_NULL_HANDLER,
29959 : ZEND_NULL_HANDLER,
29960 : ZEND_NULL_HANDLER,
29961 : ZEND_NULL_HANDLER,
29962 : ZEND_NULL_HANDLER,
29963 : ZEND_POST_DEC_OBJ_SPEC_VAR_CONST_HANDLER,
29964 : ZEND_POST_DEC_OBJ_SPEC_VAR_TMP_HANDLER,
29965 : ZEND_POST_DEC_OBJ_SPEC_VAR_VAR_HANDLER,
29966 : ZEND_NULL_HANDLER,
29967 : ZEND_POST_DEC_OBJ_SPEC_VAR_CV_HANDLER,
29968 : ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER,
29969 : ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER,
29970 : ZEND_POST_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER,
29971 : ZEND_NULL_HANDLER,
29972 : ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV_HANDLER,
29973 : ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER,
29974 : ZEND_POST_DEC_OBJ_SPEC_CV_TMP_HANDLER,
29975 : ZEND_POST_DEC_OBJ_SPEC_CV_VAR_HANDLER,
29976 : ZEND_NULL_HANDLER,
29977 : ZEND_POST_DEC_OBJ_SPEC_CV_CV_HANDLER,
29978 : ZEND_NULL_HANDLER,
29979 : ZEND_NULL_HANDLER,
29980 : ZEND_NULL_HANDLER,
29981 : ZEND_NULL_HANDLER,
29982 : ZEND_NULL_HANDLER,
29983 : ZEND_NULL_HANDLER,
29984 : ZEND_NULL_HANDLER,
29985 : ZEND_NULL_HANDLER,
29986 : ZEND_NULL_HANDLER,
29987 : ZEND_NULL_HANDLER,
29988 : ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_HANDLER,
29989 : ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_HANDLER,
29990 : ZEND_ASSIGN_OBJ_SPEC_VAR_VAR_HANDLER,
29991 : ZEND_NULL_HANDLER,
29992 : ZEND_ASSIGN_OBJ_SPEC_VAR_CV_HANDLER,
29993 : ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER,
29994 : ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_HANDLER,
29995 : ZEND_ASSIGN_OBJ_SPEC_UNUSED_VAR_HANDLER,
29996 : ZEND_NULL_HANDLER,
29997 : ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER,
29998 : ZEND_ASSIGN_OBJ_SPEC_CV_CONST_HANDLER,
29999 : ZEND_ASSIGN_OBJ_SPEC_CV_TMP_HANDLER,
30000 : ZEND_ASSIGN_OBJ_SPEC_CV_VAR_HANDLER,
30001 : ZEND_NULL_HANDLER,
30002 : ZEND_ASSIGN_OBJ_SPEC_CV_CV_HANDLER,
30003 : ZEND_NULL_HANDLER,
30004 : ZEND_NULL_HANDLER,
30005 : ZEND_NULL_HANDLER,
30006 : ZEND_NULL_HANDLER,
30007 : ZEND_NULL_HANDLER,
30008 : ZEND_NULL_HANDLER,
30009 : ZEND_NULL_HANDLER,
30010 : ZEND_NULL_HANDLER,
30011 : ZEND_NULL_HANDLER,
30012 : ZEND_NULL_HANDLER,
30013 : ZEND_NULL_HANDLER,
30014 : ZEND_NULL_HANDLER,
30015 : ZEND_NULL_HANDLER,
30016 : ZEND_NULL_HANDLER,
30017 : ZEND_NULL_HANDLER,
30018 : ZEND_NULL_HANDLER,
30019 : ZEND_NULL_HANDLER,
30020 : ZEND_NULL_HANDLER,
30021 : ZEND_NULL_HANDLER,
30022 : ZEND_NULL_HANDLER,
30023 : ZEND_NULL_HANDLER,
30024 : ZEND_NULL_HANDLER,
30025 : ZEND_NULL_HANDLER,
30026 : ZEND_NULL_HANDLER,
30027 : ZEND_NULL_HANDLER,
30028 : ZEND_NULL_HANDLER,
30029 : ZEND_NULL_HANDLER,
30030 : ZEND_NULL_HANDLER,
30031 : ZEND_NULL_HANDLER,
30032 : ZEND_NULL_HANDLER,
30033 : ZEND_INSTANCEOF_SPEC_TMP_HANDLER,
30034 : ZEND_INSTANCEOF_SPEC_TMP_HANDLER,
30035 : ZEND_INSTANCEOF_SPEC_TMP_HANDLER,
30036 : ZEND_INSTANCEOF_SPEC_TMP_HANDLER,
30037 : ZEND_INSTANCEOF_SPEC_TMP_HANDLER,
30038 : ZEND_INSTANCEOF_SPEC_VAR_HANDLER,
30039 : ZEND_INSTANCEOF_SPEC_VAR_HANDLER,
30040 : ZEND_INSTANCEOF_SPEC_VAR_HANDLER,
30041 : ZEND_INSTANCEOF_SPEC_VAR_HANDLER,
30042 : ZEND_INSTANCEOF_SPEC_VAR_HANDLER,
30043 : ZEND_NULL_HANDLER,
30044 : ZEND_NULL_HANDLER,
30045 : ZEND_NULL_HANDLER,
30046 : ZEND_NULL_HANDLER,
30047 : ZEND_NULL_HANDLER,
30048 : ZEND_INSTANCEOF_SPEC_CV_HANDLER,
30049 : ZEND_INSTANCEOF_SPEC_CV_HANDLER,
30050 : ZEND_INSTANCEOF_SPEC_CV_HANDLER,
30051 : ZEND_INSTANCEOF_SPEC_CV_HANDLER,
30052 : ZEND_INSTANCEOF_SPEC_CV_HANDLER,
30053 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30054 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30055 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30056 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30057 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30058 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30059 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30060 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30061 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30062 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30063 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30064 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30065 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30066 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30067 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30068 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30069 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30070 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30071 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30072 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30073 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30074 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30075 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30076 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30077 : ZEND_DECLARE_CLASS_SPEC_HANDLER,
30078 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30079 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30080 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30081 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30082 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30083 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30084 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30085 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30086 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30087 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30088 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30089 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30090 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30091 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30092 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30093 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30094 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30095 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30096 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30097 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30098 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30099 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30100 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30101 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30102 : ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
30103 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30104 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30105 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30106 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30107 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30108 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30109 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30110 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30111 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30112 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30113 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30114 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30115 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30116 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30117 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30118 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30119 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30120 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30121 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30122 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30123 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30124 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30125 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30126 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30127 : ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
30128 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30129 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30130 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30131 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30132 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30133 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30134 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30135 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30136 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30137 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30138 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30139 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30140 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30141 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30142 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30143 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30144 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30145 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30146 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30147 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30148 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30149 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30150 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30151 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30152 : ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
30153 : ZEND_NULL_HANDLER,
30154 : ZEND_NULL_HANDLER,
30155 : ZEND_NULL_HANDLER,
30156 : ZEND_NULL_HANDLER,
30157 : ZEND_NULL_HANDLER,
30158 : ZEND_NULL_HANDLER,
30159 : ZEND_NULL_HANDLER,
30160 : ZEND_NULL_HANDLER,
30161 : ZEND_NULL_HANDLER,
30162 : ZEND_NULL_HANDLER,
30163 : ZEND_NULL_HANDLER,
30164 : ZEND_NULL_HANDLER,
30165 : ZEND_NULL_HANDLER,
30166 : ZEND_NULL_HANDLER,
30167 : ZEND_NULL_HANDLER,
30168 : ZEND_NULL_HANDLER,
30169 : ZEND_NULL_HANDLER,
30170 : ZEND_NULL_HANDLER,
30171 : ZEND_NULL_HANDLER,
30172 : ZEND_NULL_HANDLER,
30173 : ZEND_NULL_HANDLER,
30174 : ZEND_NULL_HANDLER,
30175 : ZEND_NULL_HANDLER,
30176 : ZEND_NULL_HANDLER,
30177 : ZEND_NULL_HANDLER,
30178 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30179 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30180 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30181 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30182 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30183 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30184 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30185 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30186 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30187 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30188 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30189 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30190 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30191 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30192 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30193 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30194 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30195 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30196 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30197 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30198 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30199 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30200 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30201 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30202 : ZEND_ADD_INTERFACE_SPEC_HANDLER,
30203 : ZEND_NULL_HANDLER,
30204 : ZEND_NULL_HANDLER,
30205 : ZEND_NULL_HANDLER,
30206 : ZEND_NULL_HANDLER,
30207 : ZEND_NULL_HANDLER,
30208 : ZEND_NULL_HANDLER,
30209 : ZEND_NULL_HANDLER,
30210 : ZEND_NULL_HANDLER,
30211 : ZEND_NULL_HANDLER,
30212 : ZEND_NULL_HANDLER,
30213 : ZEND_NULL_HANDLER,
30214 : ZEND_NULL_HANDLER,
30215 : ZEND_NULL_HANDLER,
30216 : ZEND_NULL_HANDLER,
30217 : ZEND_NULL_HANDLER,
30218 : ZEND_NULL_HANDLER,
30219 : ZEND_NULL_HANDLER,
30220 : ZEND_NULL_HANDLER,
30221 : ZEND_NULL_HANDLER,
30222 : ZEND_NULL_HANDLER,
30223 : ZEND_NULL_HANDLER,
30224 : ZEND_NULL_HANDLER,
30225 : ZEND_NULL_HANDLER,
30226 : ZEND_NULL_HANDLER,
30227 : ZEND_NULL_HANDLER,
30228 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30229 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30230 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30231 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30232 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30233 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30234 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30235 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30236 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30237 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30238 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30239 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30240 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30241 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30242 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30243 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30244 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30245 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30246 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30247 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30248 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30249 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30250 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30251 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30252 : ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
30253 : ZEND_NULL_HANDLER,
30254 : ZEND_NULL_HANDLER,
30255 : ZEND_NULL_HANDLER,
30256 : ZEND_NULL_HANDLER,
30257 : ZEND_NULL_HANDLER,
30258 : ZEND_NULL_HANDLER,
30259 : ZEND_NULL_HANDLER,
30260 : ZEND_NULL_HANDLER,
30261 : ZEND_NULL_HANDLER,
30262 : ZEND_NULL_HANDLER,
30263 : ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER,
30264 : ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER,
30265 : ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER,
30266 : ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER,
30267 : ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER,
30268 : ZEND_NULL_HANDLER,
30269 : ZEND_NULL_HANDLER,
30270 : ZEND_NULL_HANDLER,
30271 : ZEND_NULL_HANDLER,
30272 : ZEND_NULL_HANDLER,
30273 : ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER,
30274 : ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER,
30275 : ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER,
30276 : ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER,
30277 : ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER,
30278 : ZEND_NULL_HANDLER,
30279 : ZEND_NULL_HANDLER,
30280 : ZEND_NULL_HANDLER,
30281 : ZEND_NULL_HANDLER,
30282 : ZEND_NULL_HANDLER,
30283 : ZEND_NULL_HANDLER,
30284 : ZEND_NULL_HANDLER,
30285 : ZEND_NULL_HANDLER,
30286 : ZEND_NULL_HANDLER,
30287 : ZEND_NULL_HANDLER,
30288 : ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CONST_HANDLER,
30289 : ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_TMP_HANDLER,
30290 : ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_VAR_HANDLER,
30291 : ZEND_NULL_HANDLER,
30292 : ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CV_HANDLER,
30293 : ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER,
30294 : ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_HANDLER,
30295 : ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_VAR_HANDLER,
30296 : ZEND_NULL_HANDLER,
30297 : ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER,
30298 : ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER,
30299 : ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_HANDLER,
30300 : ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_VAR_HANDLER,
30301 : ZEND_NULL_HANDLER,
30302 : ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER,
30303 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30304 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30305 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30306 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30307 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30308 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30309 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30310 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30311 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30312 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30313 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30314 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30315 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30316 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30317 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30318 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30319 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30320 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30321 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30322 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30323 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30324 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30325 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30326 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30327 : ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
30328 : ZEND_USER_OPCODE_SPEC_HANDLER,
30329 : ZEND_USER_OPCODE_SPEC_HANDLER,
30330 : ZEND_USER_OPCODE_SPEC_HANDLER,
30331 : ZEND_USER_OPCODE_SPEC_HANDLER,
30332 : ZEND_USER_OPCODE_SPEC_HANDLER,
30333 : ZEND_USER_OPCODE_SPEC_HANDLER,
30334 : ZEND_USER_OPCODE_SPEC_HANDLER,
30335 : ZEND_USER_OPCODE_SPEC_HANDLER,
30336 : ZEND_USER_OPCODE_SPEC_HANDLER,
30337 : ZEND_USER_OPCODE_SPEC_HANDLER,
30338 : ZEND_USER_OPCODE_SPEC_HANDLER,
30339 : ZEND_USER_OPCODE_SPEC_HANDLER,
30340 : ZEND_USER_OPCODE_SPEC_HANDLER,
30341 : ZEND_USER_OPCODE_SPEC_HANDLER,
30342 : ZEND_USER_OPCODE_SPEC_HANDLER,
30343 : ZEND_USER_OPCODE_SPEC_HANDLER,
30344 : ZEND_USER_OPCODE_SPEC_HANDLER,
30345 : ZEND_USER_OPCODE_SPEC_HANDLER,
30346 : ZEND_USER_OPCODE_SPEC_HANDLER,
30347 : ZEND_USER_OPCODE_SPEC_HANDLER,
30348 : ZEND_USER_OPCODE_SPEC_HANDLER,
30349 : ZEND_USER_OPCODE_SPEC_HANDLER,
30350 : ZEND_USER_OPCODE_SPEC_HANDLER,
30351 : ZEND_USER_OPCODE_SPEC_HANDLER,
30352 : ZEND_USER_OPCODE_SPEC_HANDLER,
30353 : ZEND_NULL_HANDLER
30354 : };
30355 220 : zend_opcode_handlers = (opcode_handler_t*)labels;
30356 220 : }
30357 : static opcode_handler_t zend_vm_get_opcode_handler(zend_uchar opcode, zend_op* op)
30358 25849 : {
30359 : static const int zend_vm_decode[] = {
30360 : _UNUSED_CODE, /* 0 */
30361 : _CONST_CODE, /* 1 = IS_CONST */
30362 : _TMP_CODE, /* 2 = IS_TMP_VAR */
30363 : _UNUSED_CODE, /* 3 */
30364 : _VAR_CODE, /* 4 = IS_VAR */
30365 : _UNUSED_CODE, /* 5 */
30366 : _UNUSED_CODE, /* 6 */
30367 : _UNUSED_CODE, /* 7 */
30368 : _UNUSED_CODE, /* 8 = IS_UNUSED */
30369 : _UNUSED_CODE, /* 9 */
30370 : _UNUSED_CODE, /* 10 */
30371 : _UNUSED_CODE, /* 11 */
30372 : _UNUSED_CODE, /* 12 */
30373 : _UNUSED_CODE, /* 13 */
30374 : _UNUSED_CODE, /* 14 */
30375 : _UNUSED_CODE, /* 15 */
30376 : _CV_CODE /* 16 = IS_CV */
30377 : };
30378 25849 : return zend_opcode_handlers[opcode * 25 + zend_vm_decode[op->op1.op_type] * 5 + zend_vm_decode[op->op2.op_type]];
30379 : }
30380 :
30381 : ZEND_API void zend_vm_set_opcode_handler(zend_op* op)
30382 25849 : {
30383 25849 : op->handler = zend_vm_get_opcode_handler(zend_user_opcodes[op->opcode], op);
30384 25849 : }
30385 :
30386 : ZEND_API int zend_do_fcall(ZEND_OPCODE_HANDLER_ARGS)
30387 0 : {
30388 0 : return zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
30389 : }
30390 :
|
