2
+----------------------------------------------------------------------+
4
+----------------------------------------------------------------------+
5
| Copyright (c) 1998-2004 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
+----------------------------------------------------------------------+
20
/* $Id: zend_execute.c,v 1.652.2.49 2005/09/01 13:21:56 dmitry Exp $ */
22
#define ZEND_INTENSIVE_DEBUGGING 0
28
#include "zend_compile.h"
29
#include "zend_execute.h"
31
#include "zend_ptr_stack.h"
32
#include "zend_constants.h"
33
#include "zend_extensions.h"
34
#include "zend_fast_cache.h"
36
#include "zend_exceptions.h"
38
#define get_zval_ptr(node, Ts, should_free, type) _get_zval_ptr(node, Ts, should_free TSRMLS_CC)
39
#define get_zval_ptr_ptr(node, Ts, type) _get_zval_ptr_ptr(node, Ts TSRMLS_CC)
42
static void zend_fetch_var_address(zend_op *opline, temp_variable *Ts, int type TSRMLS_DC);
43
static void zend_fetch_dimension_address(znode *result, znode *op1, znode *op2, temp_variable *Ts, int type TSRMLS_DC);
44
static void zend_fetch_property_address(znode *result, znode *op1, znode *op2, temp_variable *Ts, int type TSRMLS_DC);
45
static void zend_fetch_dimension_address_from_tmp_var(znode *result, znode *op1, znode *op2, temp_variable *Ts TSRMLS_DC);
46
static void zend_extension_statement_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC);
47
static void zend_extension_fcall_begin_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC);
48
static void zend_extension_fcall_end_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC);
50
#define RETURN_VALUE_USED(opline) (!((opline)->result.u.EA.type & EXT_TYPE_UNUSED))
52
#define EX_T(offset) (*(temp_variable *)((char *) EX(Ts) + offset))
53
#define T(offset) (*(temp_variable *)((char *) Ts + offset))
55
#define TEMP_VAR_STACK_LIMIT 2000
57
#define MAKE_REAL_ZVAL_PTR(val) \
61
_tmp->value = (val)->value; \
62
_tmp->type = (val)->type; \
68
/* former zend_execute_locks.h */
69
static inline void zend_pzval_lock_func(zval *z)
75
static inline void zend_pzval_unlock_func(zval *z TSRMLS_DC)
81
EG(garbage)[EG(garbage_ptr)++] = z;
85
static inline void zend_clean_garbage(TSRMLS_D)
87
while (EG(garbage_ptr)) {
88
zval_ptr_dtor(&EG(garbage)[--EG(garbage_ptr)]);
92
#define PZVAL_UNLOCK(z) zend_pzval_unlock_func(z TSRMLS_CC)
93
#define PZVAL_LOCK(z) zend_pzval_lock_func(z)
94
#define RETURN_VALUE_UNUSED(pzn) (((pzn)->u.EA.type & EXT_TYPE_UNUSED))
95
#define SELECTIVE_PZVAL_LOCK(pzv, pzn) if (!RETURN_VALUE_UNUSED(pzn)) { PZVAL_LOCK(pzv); }
98
/* End of zend_execute_locks.h */
100
static inline zval *_get_zval_ptr(znode *node, temp_variable *Ts, zval **should_free TSRMLS_DC)
102
switch (node->op_type) {
105
return &node->u.constant;
108
return *should_free = &T(node->u.var).tmp_var;
111
if (T(node->u.var).var.ptr) {
112
PZVAL_UNLOCK(T(node->u.var).var.ptr);
114
return T(node->u.var).var.ptr;
116
temp_variable *T = &T(node->u.var);
117
zval *str = T->str_offset.str;
120
*should_free = &T(node->u.var).tmp_var;
122
if (T->str_offset.str->type != IS_STRING
123
|| ((int)T->str_offset.offset<0)
124
|| (T->str_offset.str->value.str.len <= T->str_offset.offset)) {
125
zend_error(E_NOTICE, "Uninitialized string offset: %d", T->str_offset.offset);
126
T->tmp_var.value.str.val = empty_string;
127
T->tmp_var.value.str.len = 0;
129
char c = str->value.str.val[T->str_offset.offset];
131
T->tmp_var.value.str.val = estrndup(&c, 1);
132
T->tmp_var.value.str.len = 1;
135
T->tmp_var.refcount=1;
137
T->tmp_var.type = IS_STRING;
145
EMPTY_SWITCH_DEFAULT_CASE()
150
static inline zval **_get_zval_ptr_ptr(znode *node, temp_variable *Ts TSRMLS_DC)
152
if (node->op_type==IS_VAR) {
153
if (T(node->u.var).var.ptr_ptr) {
154
PZVAL_UNLOCK(*T(node->u.var).var.ptr_ptr);
157
PZVAL_UNLOCK(T(node->u.var).str_offset.str);
159
return T(node->u.var).var.ptr_ptr;
165
static inline void zend_fetch_property_address_inner(zval *object, znode *op2, znode *result, temp_variable *Ts, int type TSRMLS_DC)
167
zval *prop_ptr = get_zval_ptr(op2, Ts, &EG(free_op2), BP_VAR_R);
170
MAKE_REAL_ZVAL_PTR(prop_ptr);
173
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
174
zval **ptr_ptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, prop_ptr TSRMLS_CC);
175
if(NULL == ptr_ptr) {
176
if (Z_OBJ_HT_P(object)->read_property &&
177
(T(result->u.var).var.ptr = Z_OBJ_HT_P(object)->read_property(object, prop_ptr, BP_VAR_W TSRMLS_CC)) != NULL) {
178
T(result->u.var).var.ptr_ptr = &T(result->u.var).var.ptr;
180
zend_error(E_ERROR, "Cannot access undefined property for object with overloaded property access");
183
T(result->u.var).var.ptr_ptr = ptr_ptr;
185
} else if (Z_OBJ_HT_P(object)->read_property) {
186
T(result->u.var).var.ptr = Z_OBJ_HT_P(object)->read_property(object, prop_ptr, BP_VAR_W TSRMLS_CC);
187
T(result->u.var).var.ptr_ptr = &T(result->u.var).var.ptr;
189
zend_error(E_WARNING, "This object doesn't support property references");
190
T(result->u.var).var.ptr_ptr = &EG(error_zval_ptr);
194
zval_ptr_dtor(&prop_ptr);
200
static inline void zend_switch_free(zend_op *opline, temp_variable *Ts TSRMLS_DC)
202
switch (opline->op1.op_type) {
204
if (!T(opline->op1.u.var).var.ptr_ptr) {
205
temp_variable *T = &T(opline->op1.u.var);
206
/* perform the equivalent of equivalent of a
207
* quick & silent get_zval_ptr, and FREE_OP
209
PZVAL_UNLOCK(T->str_offset.str);
211
zval_ptr_dtor(&T(opline->op1.u.var).var.ptr);
212
if (opline->extended_value) { /* foreach() free */
213
zval_ptr_dtor(&T(opline->op1.u.var).var.ptr);
218
zendi_zval_dtor(T(opline->op1.u.var).tmp_var);
220
EMPTY_SWITCH_DEFAULT_CASE()
224
void zend_assign_to_variable_reference(znode *result, zval **variable_ptr_ptr, zval **value_ptr_ptr, temp_variable *Ts TSRMLS_DC)
229
if (!value_ptr_ptr || !variable_ptr_ptr) {
230
zend_error(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
234
variable_ptr = *variable_ptr_ptr;
235
value_ptr = *value_ptr_ptr;
237
if (variable_ptr == EG(error_zval_ptr) || value_ptr==EG(error_zval_ptr)) {
238
variable_ptr_ptr = &EG(uninitialized_zval_ptr);
239
} else if (variable_ptr != value_ptr) {
240
if (!PZVAL_IS_REF(value_ptr)) {
242
value_ptr->refcount--;
243
if (value_ptr->refcount>0) {
244
ALLOC_ZVAL(*value_ptr_ptr);
245
**value_ptr_ptr = *value_ptr;
246
value_ptr = *value_ptr_ptr;
247
zendi_zval_copy_ctor(*value_ptr);
249
value_ptr->refcount = 1;
250
value_ptr->is_ref = 1;
252
*variable_ptr_ptr = value_ptr;
253
value_ptr->refcount++;
255
variable_ptr->refcount--;
256
if (variable_ptr->refcount==0) {
257
zendi_zval_dtor(*variable_ptr);
258
FREE_ZVAL(variable_ptr);
260
} else if (!variable_ptr->is_ref) {
261
if (variable_ptr_ptr == value_ptr_ptr) {
262
SEPARATE_ZVAL(variable_ptr_ptr);
263
} else if (variable_ptr==EG(uninitialized_zval_ptr)
264
|| variable_ptr->refcount>2) {
265
/* we need to separate */
266
variable_ptr->refcount -= 2;
267
ALLOC_ZVAL(*variable_ptr_ptr);
268
**variable_ptr_ptr = *variable_ptr;
269
zval_copy_ctor(*variable_ptr_ptr);
270
*value_ptr_ptr = *variable_ptr_ptr;
271
(*variable_ptr_ptr)->refcount = 2;
273
(*variable_ptr_ptr)->is_ref = 1;
276
if (result && !(result->u.EA.type & EXT_TYPE_UNUSED)) {
277
T(result->u.var).var.ptr_ptr = variable_ptr_ptr;
278
SELECTIVE_PZVAL_LOCK(*variable_ptr_ptr, result);
279
AI_USE_PTR(T(result->u.var).var);
283
static inline void make_real_object(zval **object_ptr TSRMLS_DC)
285
/* this should modify object only if it's empty */
286
if ((*object_ptr)->type == IS_NULL
287
|| ((*object_ptr)->type == IS_BOOL && (*object_ptr)->value.lval==0)
288
|| ((*object_ptr)->type == IS_STRING && (*object_ptr)->value.str.len == 0)) {
289
if (!PZVAL_IS_REF(*object_ptr)) {
290
SEPARATE_ZVAL(object_ptr);
292
zend_error(E_STRICT, "Creating default object from empty value");
293
object_init(*object_ptr);
297
static inline zval **get_obj_zval_ptr_ptr(znode *op, temp_variable *Ts, int type TSRMLS_DC)
299
if (op->op_type == IS_UNUSED) {
301
/* this should actually never be modified, _ptr_ptr is modified only when
302
the object is empty */
305
zend_error(E_ERROR, "Using $this when not in object context");
308
return get_zval_ptr_ptr(op, Ts, type);
311
static inline zval *get_obj_zval_ptr(znode *op, temp_variable *Ts, zval **freeop, int type TSRMLS_DC)
313
if (op->op_type == IS_UNUSED) {
317
zend_error(E_ERROR, "Using $this when not in object context");
320
return get_zval_ptr(op, Ts, freeop, type);
324
static inline void zend_verify_arg_type(zend_function *zf, zend_uint arg_num, zval *arg TSRMLS_DC)
326
zend_arg_info *cur_arg_info;
328
if (!zf->common.arg_info
329
|| arg_num>zf->common.num_args) {
333
cur_arg_info = &zf->common.arg_info[arg_num-1];
335
if (cur_arg_info->class_name) {
337
zend_error(E_ERROR, "Argument %d must be an object of class %s", arg_num, cur_arg_info->class_name);
339
switch (Z_TYPE_P(arg)) {
341
if (!cur_arg_info->allow_null) {
342
zend_error(E_ERROR, "Argument %d must not be null", arg_num);
346
zend_class_entry *ce = zend_fetch_class(cur_arg_info->class_name, cur_arg_info->class_name_len, ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
347
if (!instanceof_function(Z_OBJCE_P(arg), ce TSRMLS_CC)) {
350
if (ce->ce_flags & ZEND_ACC_INTERFACE) {
351
error_msg = "implement interface";
353
error_msg = "be an instance of";
355
zend_error(E_ERROR, "Argument %d must %s %s", arg_num, error_msg, ce->name);
360
zend_error(E_ERROR, "Argument %d must be an object of class %s", arg_num, cur_arg_info->class_name);
366
static inline void zend_assign_to_object(znode *result, zval **object_ptr, znode *op2, znode *value_op, temp_variable *Ts, int opcode TSRMLS_DC)
369
zval *property_name = get_zval_ptr(op2, Ts, &EG(free_op2), BP_VAR_R);
371
zval *value = get_zval_ptr(value_op, Ts, &free_value, BP_VAR_R);
372
zval **retval = &T(result->u.var).var.ptr;
374
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
375
object = *object_ptr;
377
if (object->type != IS_OBJECT) {
378
zend_error(E_WARNING, "Attempt to assign property of non-object");
379
FREE_OP(Ts, op2, EG(free_op2));
380
*retval = EG(uninitialized_zval_ptr);
382
SELECTIVE_PZVAL_LOCK(*retval, result);
383
FREE_OP(Ts, value_op, free_value);
387
/* here we are sure we are dealing with an object */
389
/* separate our value if necessary */
390
if (EG(ze1_compatibility_mode) && Z_TYPE_P(value) == IS_OBJECT) {
391
zval *orig_value = value;
393
zend_uint class_name_len;
397
*value = *orig_value;
401
dup = zend_get_object_classname(orig_value, &class_name, &class_name_len TSRMLS_CC);
403
if (Z_OBJ_HANDLER_P(value, clone_obj) == NULL) {
404
zend_error(E_ERROR, "Trying to clone an uncloneable object of class %s", class_name);
407
zend_error(E_STRICT, "Implicit cloning object of class '%s' because of 'zend.ze1_compatibility_mode'", class_name);
413
value->value.obj = Z_OBJ_HANDLER_P(orig_value, clone_obj)(orig_value TSRMLS_CC);
414
} else if (value_op->op_type == IS_TMP_VAR) {
415
zval *orig_value = value;
418
*value = *orig_value;
421
} else if (value_op->op_type == IS_CONST) {
422
zval *orig_value = value;
425
*value = *orig_value;
428
zval_copy_ctor(value);
433
if (opcode == ZEND_ASSIGN_OBJ) {
435
MAKE_REAL_ZVAL_PTR(property_name);
437
Z_OBJ_HT_P(object)->write_property(object, property_name, value TSRMLS_CC);
439
/* Note: property_name in this case is really the array index! */
440
if (!Z_OBJ_HT_P(object)->write_dimension) {
441
zend_error(E_ERROR, "Cannot use object as array");
444
MAKE_REAL_ZVAL_PTR(property_name);
446
Z_OBJ_HT_P(object)->write_dimension(object, property_name, value TSRMLS_CC);
450
T(result->u.var).var.ptr = value;
451
T(result->u.var).var.ptr_ptr = &T(result->u.var).var.ptr; /* this is so that we could use it in FETCH_DIM_R, etc. - see bug #27876 */
452
SELECTIVE_PZVAL_LOCK(value, result);
455
zval_ptr_dtor(&property_name);
457
zval_ptr_dtor(&value);
461
static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2, zval *value, int type, temp_variable *Ts TSRMLS_DC)
463
zval **variable_ptr_ptr = get_zval_ptr_ptr(op1, Ts, BP_VAR_W);
466
if (!variable_ptr_ptr) {
467
temp_variable *T = &T(op1->u.var);
469
if (T->str_offset.str->type == IS_STRING) do {
471
zval *final_value = value;
473
if (((int)T->str_offset.offset < 0)) {
474
zend_error(E_WARNING, "Illegal string offset: %d", T->str_offset.offset);
477
if (T->str_offset.offset >= T->str_offset.str->value.str.len) {
480
if (T->str_offset.str->value.str.len==0) {
481
STR_FREE(T->str_offset.str->value.str.val);
482
T->str_offset.str->value.str.val = (char *) emalloc(T->str_offset.offset+1+1);
484
T->str_offset.str->value.str.val = (char *) erealloc(T->str_offset.str->value.str.val, T->str_offset.offset+1+1);
486
for (i=T->str_offset.str->value.str.len; i<T->str_offset.offset; i++) {
487
T->str_offset.str->value.str.val[i] = ' ';
489
T->str_offset.str->value.str.val[T->str_offset.offset+1] = 0;
490
T->str_offset.str->value.str.len = T->str_offset.offset+1;
493
if (value->type!=IS_STRING) {
495
if (op2 && op2->op_type == IS_VAR) {
496
zval_copy_ctor(&tmp);
498
convert_to_string(&tmp);
502
T->str_offset.str->value.str.val[T->str_offset.offset] = final_value->value.str.val[0];
505
if (op2->op_type == IS_VAR) {
506
if (value == &T(op2->u.var).tmp_var) {
507
if (result->u.EA.type & EXT_TYPE_UNUSED) {
508
/* We are not going to use return value, drop it */
509
STR_FREE(value->value.str.val);
511
/* We are going to use return value, make it real zval */
513
*value = T(op2->u.var).tmp_var;
515
value->refcount = 0; /* LOCK will increase it */
519
if (final_value == &T(op2->u.var).tmp_var) {
520
/* we can safely free final_value here
521
* because separation is done only
522
* in case op2->op_type == IS_VAR */
523
STR_FREE(final_value->value.str.val);
527
if (final_value == &tmp) {
528
zval_dtor(final_value);
531
* the value of an assignment to a string offset is undefined
532
T(result->u.var).var = &T->str_offset.str;
535
/* zval_ptr_dtor(&T->str_offset.str); Nuke this line if it doesn't cause a leak */
536
T->tmp_var.type = IS_STRING;
538
/* T(result->u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr); */
539
T(result->u.var).var.ptr_ptr = &value;
540
SELECTIVE_PZVAL_LOCK(*T(result->u.var).var.ptr_ptr, result);
541
AI_USE_PTR(T(result->u.var).var);
545
variable_ptr = *variable_ptr_ptr;
547
if (variable_ptr == EG(error_zval_ptr)) {
549
T(result->u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
550
SELECTIVE_PZVAL_LOCK(*T(result->u.var).var.ptr_ptr, result);
551
AI_USE_PTR(T(result->u.var).var);
553
if (type==IS_TMP_VAR) {
559
if(Z_TYPE_P(variable_ptr) == IS_OBJECT && Z_OBJ_HANDLER_P(variable_ptr, set)) {
560
/* TODO? ze1_compatibility_mode support */
561
Z_OBJ_HANDLER_P(variable_ptr, set)(variable_ptr_ptr, value TSRMLS_CC);
562
goto done_setting_var;
565
if (EG(ze1_compatibility_mode) && Z_TYPE_P(value) == IS_OBJECT) {
567
zend_uint class_name_len;
570
dup = zend_get_object_classname(value, &class_name, &class_name_len TSRMLS_CC);
572
if (Z_OBJ_HANDLER_P(value, clone_obj) == NULL) {
573
zend_error(E_ERROR, "Trying to clone an uncloneable object of class %s", class_name);
574
} else if (PZVAL_IS_REF(variable_ptr)) {
575
if (variable_ptr != value) {
576
zend_uint refcount = variable_ptr->refcount;
579
if (type != IS_TMP_VAR) {
583
garbage = *variable_ptr;
584
*variable_ptr = *value;
585
variable_ptr->refcount = refcount;
586
variable_ptr->is_ref = 1;
588
zend_error(E_STRICT, "Implicit cloning object of class '%s' because of 'zend.ze1_compatibility_mode'", class_name);
590
variable_ptr->value.obj = Z_OBJ_HANDLER_P(value, clone_obj)(value TSRMLS_CC);
592
if (type != IS_TMP_VAR) {
596
zendi_zval_dtor(garbage);
599
if (variable_ptr != value) {
601
variable_ptr->refcount--;
602
if (variable_ptr->refcount == 0) {
603
zendi_zval_dtor(*variable_ptr);
605
ALLOC_ZVAL(variable_ptr);
606
*variable_ptr_ptr = variable_ptr;
608
*variable_ptr = *value;
609
INIT_PZVAL(variable_ptr);
610
zend_error(E_STRICT, "Implicit cloning object of class '%s' because of 'zend.ze1_compatibility_mode'", class_name);
611
variable_ptr->value.obj = Z_OBJ_HANDLER_P(value, clone_obj)(value TSRMLS_CC);
612
zval_ptr_dtor(&value);
620
} else if (PZVAL_IS_REF(variable_ptr)) {
621
if (variable_ptr!=value) {
622
zend_uint refcount = variable_ptr->refcount;
625
if (type!=IS_TMP_VAR) {
628
garbage = *variable_ptr;
629
*variable_ptr = *value;
630
variable_ptr->refcount = refcount;
631
variable_ptr->is_ref = 1;
632
if (type!=IS_TMP_VAR) {
633
zendi_zval_copy_ctor(*variable_ptr);
636
zendi_zval_dtor(garbage);
639
variable_ptr->refcount--;
640
if (variable_ptr->refcount==0) {
643
/* break missing intentionally */
645
if (variable_ptr==value) {
646
variable_ptr->refcount++;
647
} else if (PZVAL_IS_REF(value)) {
651
zval_copy_ctor(&tmp);
653
zendi_zval_dtor(*variable_ptr);
657
zendi_zval_dtor(*variable_ptr);
658
safe_free_zval_ptr(variable_ptr);
659
*variable_ptr_ptr = value;
663
zendi_zval_dtor(*variable_ptr);
665
*variable_ptr = *value;
667
EMPTY_SWITCH_DEFAULT_CASE()
669
} else { /* we need to split */
672
/* break missing intentionally */
674
if (PZVAL_IS_REF(value) && value->refcount > 0) {
675
ALLOC_ZVAL(variable_ptr);
676
*variable_ptr_ptr = variable_ptr;
677
*variable_ptr = *value;
678
zval_copy_ctor(variable_ptr);
679
variable_ptr->refcount=1;
682
*variable_ptr_ptr = value;
686
ALLOC_ZVAL(*variable_ptr_ptr);
688
**variable_ptr_ptr = *value;
690
EMPTY_SWITCH_DEFAULT_CASE()
693
(*variable_ptr_ptr)->is_ref=0;
698
T(result->u.var).var.ptr_ptr = variable_ptr_ptr;
699
SELECTIVE_PZVAL_LOCK(*variable_ptr_ptr, result);
700
AI_USE_PTR(T(result->u.var).var);
705
/* Utility Functions for Extensions */
706
static void zend_extension_statement_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC)
708
if (extension->statement_handler) {
709
extension->statement_handler(op_array);
714
static void zend_extension_fcall_begin_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC)
716
if (extension->fcall_begin_handler) {
717
extension->fcall_begin_handler(op_array);
722
static void zend_extension_fcall_end_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC)
724
if (extension->fcall_end_handler) {
725
extension->fcall_end_handler(op_array);
730
static void print_refcount(zval *p, char *str)
732
print_refcount(NULL, NULL);
736
static inline HashTable *zend_get_target_symbol_table(zend_op *opline, temp_variable *Ts, int type, zval *variable TSRMLS_DC)
738
switch (opline->op2.u.EA.type) {
739
case ZEND_FETCH_LOCAL:
740
return EG(active_symbol_table);
742
case ZEND_FETCH_GLOBAL:
743
return &EG(symbol_table);
745
case ZEND_FETCH_STATIC:
746
if (!EG(active_op_array)->static_variables) {
747
ALLOC_HASHTABLE(EG(active_op_array)->static_variables);
748
zend_hash_init(EG(active_op_array)->static_variables, 2, NULL, ZVAL_PTR_DTOR, 0);
750
return EG(active_op_array)->static_variables;
752
EMPTY_SWITCH_DEFAULT_CASE()
758
static void zend_fetch_var_address(zend_op *opline, temp_variable *Ts, int type TSRMLS_DC)
761
zval *varname = get_zval_ptr(&opline->op1, Ts, &free_op1, BP_VAR_R);
764
HashTable *target_symbol_table;
765
zend_bool free_tmp = 0;
767
if (varname->type != IS_STRING) {
768
tmp_varname = *varname;
769
zval_copy_ctor(&tmp_varname);
770
convert_to_string(&tmp_varname);
771
varname = &tmp_varname;
775
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
776
target_symbol_table = NULL;
777
retval = zend_std_get_static_property(T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0 TSRMLS_CC);
779
if (opline->op2.u.EA.type == ZEND_FETCH_GLOBAL && opline->op1.op_type == IS_VAR) {
782
target_symbol_table = zend_get_target_symbol_table(opline, Ts, type, varname TSRMLS_CC);
783
if (!target_symbol_table) {
786
if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &retval) == FAILURE) {
789
zend_error(E_NOTICE,"Undefined variable: %s", varname->value.str.val);
790
/* break missing intentionally */
792
retval = &EG(uninitialized_zval_ptr);
795
zend_error(E_NOTICE,"Undefined variable: %s", varname->value.str.val);
796
/* break missing intentionally */
798
zval *new_zval = &EG(uninitialized_zval);
800
new_zval->refcount++;
801
zend_hash_update(target_symbol_table, varname->value.str.val, varname->value.str.len+1, &new_zval, sizeof(zval *), (void **) &retval);
804
EMPTY_SWITCH_DEFAULT_CASE()
807
switch (opline->op2.u.EA.type) {
808
case ZEND_FETCH_LOCAL:
809
FREE_OP(Ts, &opline->op1, free_op1);
811
case ZEND_FETCH_STATIC:
812
zval_update_constant(retval, (void*) 1 TSRMLS_CC);
821
T(opline->result.u.var).var.ptr_ptr = retval;
822
SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
826
static inline zval **zend_fetch_dimension_address_inner(HashTable *ht, znode *op2, temp_variable *Ts, int type TSRMLS_DC)
828
zval *dim = get_zval_ptr(op2, Ts, &EG(free_op2), BP_VAR_R);
831
int offset_key_length;
836
offset_key_length = 0;
837
goto fetch_string_dim;
840
offset_key = dim->value.str.val;
841
offset_key_length = dim->value.str.len;
844
if (zend_symtable_find(ht, offset_key, offset_key_length+1, (void **) &retval) == FAILURE) {
847
zend_error(E_NOTICE, "Undefined index: %s", offset_key);
848
/* break missing intentionally */
851
retval = &EG(uninitialized_zval_ptr);
854
zend_error(E_NOTICE,"Undefined index: %s", offset_key);
855
/* break missing intentionally */
857
zval *new_zval = &EG(uninitialized_zval);
859
new_zval->refcount++;
860
zend_symtable_update(ht, offset_key, offset_key_length+1, &new_zval, sizeof(zval *), (void **) &retval);
867
zend_error(E_STRICT, "Resource ID#%ld used as offset, casting to integer (%ld)", dim->value.lval, dim->value.lval);
874
if (dim->type == IS_DOUBLE) {
875
index = (long)dim->value.dval;
877
index = dim->value.lval;
879
if (zend_hash_index_find(ht, index, (void **) &retval) == FAILURE) {
882
zend_error(E_NOTICE,"Undefined offset: %ld", index);
883
/* break missing intentionally */
886
retval = &EG(uninitialized_zval_ptr);
889
zend_error(E_NOTICE,"Undefined offset: %ld", index);
890
/* break missing intentionally */
892
zval *new_zval = &EG(uninitialized_zval);
894
new_zval->refcount++;
895
zend_hash_index_update(ht, index, &new_zval, sizeof(zval *), (void **) &retval);
903
zend_error(E_WARNING, "Illegal offset type");
908
retval = &EG(uninitialized_zval_ptr);
911
retval = &EG(error_zval_ptr);
916
FREE_OP(Ts, op2, EG(free_op2));
920
static void zend_fetch_dimension_address(znode *result, znode *op1, znode *op2, temp_variable *Ts, int type TSRMLS_DC)
922
zval **container_ptr = get_zval_ptr_ptr(op1, Ts, type);
924
zval ***retval = &T(result->u.var).var.ptr_ptr;
926
if (!container_ptr) {
927
zend_error(E_ERROR, "Cannot use string offset as an array");
930
container = *container_ptr;
932
if (container == EG(error_zval_ptr)) {
933
*retval = &EG(error_zval_ptr);
934
SELECTIVE_PZVAL_LOCK(**retval, result);
938
if (container->type==IS_NULL
939
|| (container->type==IS_BOOL && container->value.lval==0)
940
|| (container->type==IS_STRING && container->value.str.len==0)) {
944
if (!PZVAL_IS_REF(container)) {
945
SEPARATE_ZVAL(container_ptr);
946
container = *container_ptr;
948
array_init(container);
953
switch (container->type) {
955
if ((type==BP_VAR_W || type==BP_VAR_RW) && container->refcount>1 && !PZVAL_IS_REF(container)) {
956
SEPARATE_ZVAL(container_ptr);
957
container = *container_ptr;
959
if (op2->op_type == IS_UNUSED) {
960
zval *new_zval = &EG(uninitialized_zval);
962
new_zval->refcount++;
963
if (zend_hash_next_index_insert(container->value.ht, &new_zval, sizeof(zval *), (void **) retval) == FAILURE) {
964
zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
965
*retval = &EG(error_zval_ptr);
966
new_zval->refcount--;
969
*retval = zend_fetch_dimension_address_inner(container->value.ht, op2, Ts, type TSRMLS_CC);
971
SELECTIVE_PZVAL_LOCK(**retval, result);
974
/* for read-mode only */
975
get_zval_ptr(op2, Ts, &EG(free_op2), BP_VAR_R);
976
*retval = &EG(uninitialized_zval_ptr);
977
SELECTIVE_PZVAL_LOCK(**retval, result);
978
FREE_OP(Ts, op2, EG(free_op2));
979
if (type==BP_VAR_W || type==BP_VAR_RW) {
980
zend_error(E_WARNING, "Cannot use a NULL value as an array");
987
if (op2->op_type==IS_UNUSED) {
988
zend_error(E_ERROR, "[] operator not supported for strings");
991
offset = get_zval_ptr(op2, Ts, &EG(free_op2), BP_VAR_R);
993
if (offset->type != IS_LONG) {
995
zval_copy_ctor(&tmp);
996
convert_to_long(&tmp);
1006
SEPARATE_ZVAL_IF_NOT_REF(container_ptr);
1009
container = *container_ptr;
1010
T(result->u.var).str_offset.str = container;
1011
PZVAL_LOCK(container);
1012
T(result->u.var).str_offset.offset = offset->value.lval;
1013
FREE_OP(Ts, op2, EG(free_op2));
1019
if (!Z_OBJ_HT_P(container)->read_dimension) {
1020
zend_error(E_ERROR, "Cannot use object as array");
1022
zval *dim = get_zval_ptr(op2, Ts, &EG(free_op2), BP_VAR_R);
1023
zval *overloaded_result;
1026
MAKE_REAL_ZVAL_PTR(dim);
1028
overloaded_result = Z_OBJ_HT_P(container)->read_dimension(container, dim, type TSRMLS_CC);
1029
if (overloaded_result) {
1033
if (overloaded_result->type != IS_OBJECT
1034
&& !overloaded_result->is_ref) {
1035
zend_error(E_ERROR, "Objects used as arrays in post/pre increment/decrement must return values by reference");
1040
*retval = &overloaded_result;
1042
*retval = &EG(error_zval_ptr);
1044
AI_USE_PTR(T(result->u.var).var);
1045
SELECTIVE_PZVAL_LOCK(**retval, result);
1047
zval_ptr_dtor(&dim);
1052
get_zval_ptr(op2, Ts, &EG(free_op2), BP_VAR_R);
1056
zend_error(E_WARNING, "Cannot unset offset in a non-array variable");
1057
/* break missing intentionally */
1060
*retval = &EG(uninitialized_zval_ptr);
1063
*retval = &EG(error_zval_ptr);
1066
FREE_OP(Ts, op2, EG(free_op2));
1067
SELECTIVE_PZVAL_LOCK(**retval, result);
1068
if (type==BP_VAR_W || type==BP_VAR_RW) {
1069
zend_error(E_WARNING, "Cannot use a scalar value as an array");
1077
static void zend_fetch_dimension_address_from_tmp_var(znode *result, znode *op1, znode *op2, temp_variable *Ts TSRMLS_DC)
1080
zval *container = get_zval_ptr(op1, Ts, &free_op1, BP_VAR_R);
1082
if (container->type != IS_ARRAY) {
1083
T(result->u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
1084
SELECTIVE_PZVAL_LOCK(*T(result->u.var).var.ptr_ptr, result);
1088
T(result->u.var).var.ptr_ptr = zend_fetch_dimension_address_inner(container->value.ht, op2, Ts, BP_VAR_R TSRMLS_CC);
1089
SELECTIVE_PZVAL_LOCK(*T(result->u.var).var.ptr_ptr, result);
1092
static void zend_fetch_property_address(znode *result, znode *op1, znode *op2, temp_variable *Ts, int type TSRMLS_DC)
1094
zval **container_ptr = get_obj_zval_ptr_ptr(op1, Ts, type TSRMLS_CC);
1096
zval ***retval = &T(result->u.var).var.ptr_ptr;
1098
container = *container_ptr;
1099
if (container == EG(error_zval_ptr)) {
1100
*retval = &EG(error_zval_ptr);
1101
SELECTIVE_PZVAL_LOCK(**retval, result);
1104
/* this should modify object only if it's empty */
1105
if (container->type == IS_NULL
1106
|| (container->type == IS_BOOL && container->value.lval==0)
1107
|| (container->type == IS_STRING && container->value.str.len == 0)) {
1111
if (!PZVAL_IS_REF(container)) {
1112
SEPARATE_ZVAL(container_ptr);
1113
container = *container_ptr;
1115
object_init(container);
1120
if (container->type != IS_OBJECT) {
1121
get_zval_ptr(op2, Ts, &EG(free_op2), BP_VAR_R);
1122
FREE_OP(Ts, op2, EG(free_op2));
1123
if (type == BP_VAR_R || type == BP_VAR_IS) {
1124
*retval = &EG(uninitialized_zval_ptr);
1126
*retval = &EG(error_zval_ptr);
1128
SELECTIVE_PZVAL_LOCK(**retval, result);
1133
if ((type==BP_VAR_W || type==BP_VAR_RW) && container->refcount>1 && !PZVAL_IS_REF(container)) {
1134
SEPARATE_ZVAL(container_ptr);
1135
container = *container_ptr;
1137
zend_fetch_property_address_inner(container, op2, result, Ts, type TSRMLS_CC);
1138
SELECTIVE_PZVAL_LOCK(**retval, result);
1141
static void zend_fetch_property_address_read(znode *result, znode *op1, znode *op2, temp_variable *Ts, int type TSRMLS_DC)
1146
retval = &T(result->u.var).var.ptr;
1147
T(result->u.var).var.ptr_ptr = retval;
1149
container = get_obj_zval_ptr(op1, Ts, &EG(free_op1), type TSRMLS_CC);
1151
if (container == EG(error_zval_ptr)) {
1152
*retval = EG(error_zval_ptr);
1153
SELECTIVE_PZVAL_LOCK(*retval, result);
1158
if (container->type != IS_OBJECT) {
1159
zend_error(E_NOTICE, "Trying to get property of non-object");
1161
if (type==BP_VAR_R || type==BP_VAR_IS) {
1162
*retval = EG(uninitialized_zval_ptr);
1164
*retval = EG(error_zval_ptr);
1166
SELECTIVE_PZVAL_LOCK(*retval, result);
1170
offset = get_zval_ptr(op2, Ts, &EG(free_op2), BP_VAR_R);
1172
MAKE_REAL_ZVAL_PTR(offset);
1175
/* here we are sure we are dealing with an object */
1176
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
1178
if (RETURN_VALUE_UNUSED(result) && ((*retval)->refcount == 0)) {
1182
SELECTIVE_PZVAL_LOCK(*retval, result);
1186
zval_ptr_dtor(&offset);
1191
static void zend_pre_incdec_property(znode *result, znode *op1, znode *op2, temp_variable * Ts, int (*incdec_op)(zval *) TSRMLS_DC)
1193
zval **object_ptr = get_obj_zval_ptr_ptr(op1, Ts, BP_VAR_W TSRMLS_CC);
1195
zval *property = get_zval_ptr(op2, Ts, &EG(free_op2), BP_VAR_R);
1196
zval **retval = &T(result->u.var).var.ptr;
1197
int have_get_ptr = 0;
1199
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
1200
object = *object_ptr;
1202
if (object->type != IS_OBJECT) {
1203
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
1204
FREE_OP(Ts, op2, EG(free_op2));
1205
*retval = EG(uninitialized_zval_ptr);
1207
SELECTIVE_PZVAL_LOCK(*retval, result);
1212
MAKE_REAL_ZVAL_PTR(property);
1215
/* here we are sure we are dealing with an object */
1217
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
1218
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
1219
if (zptr != NULL) { /* NULL means no success in getting PTR */
1220
SEPARATE_ZVAL_IF_NOT_REF(zptr);
1225
SELECTIVE_PZVAL_LOCK(*retval, result);
1229
if (!have_get_ptr) {
1230
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_RW TSRMLS_CC);
1232
if (z->type == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
1233
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
1235
if (z->refcount == 0) {
1242
SEPARATE_ZVAL_IF_NOT_REF(&z);
1245
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
1246
SELECTIVE_PZVAL_LOCK(*retval, result);
1251
zval_ptr_dtor(&property);
1255
static void zend_post_incdec_property(znode *result, znode *op1, znode *op2, temp_variable * Ts, int (*incdec_op)(zval *) TSRMLS_DC)
1257
zval **object_ptr = get_obj_zval_ptr_ptr(op1, Ts, BP_VAR_W TSRMLS_CC);
1259
zval *property = get_zval_ptr(op2, Ts, &EG(free_op2), BP_VAR_R);
1260
zval *retval = &T(result->u.var).tmp_var;
1261
int have_get_ptr = 0;
1263
make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
1264
object = *object_ptr;
1266
if (object->type != IS_OBJECT) {
1267
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
1268
FREE_OP(Ts, op2, EG(free_op2));
1269
*retval = *EG(uninitialized_zval_ptr);
1274
MAKE_REAL_ZVAL_PTR(property);
1277
/* here we are sure we are dealing with an object */
1279
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
1280
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
1281
if (zptr != NULL) { /* NULL means no success in getting PTR */
1283
SEPARATE_ZVAL_IF_NOT_REF(zptr);
1286
zendi_zval_copy_ctor(*retval);
1293
if (!have_get_ptr) {
1294
zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_RW TSRMLS_CC);
1297
if (z->type == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
1298
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
1300
if (z->refcount == 0) {
1307
zendi_zval_copy_ctor(*retval);
1310
zendi_zval_copy_ctor(*z_copy);
1314
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
1315
zval_ptr_dtor(&z_copy);
1316
/* this would destroy z if it was returned with refcount == 0 and undo
1317
recount++ above otherwise */
1322
zval_ptr_dtor(&property);
1327
#if ZEND_INTENSIVE_DEBUGGING
1329
#define CHECK_SYMBOL_TABLES() \
1330
zend_hash_apply(&EG(symbol_table), (apply_func_t) zend_check_symbol TSRMLS_CC); \
1331
if (&EG(symbol_table)!=EG(active_symbol_table)) { \
1332
zend_hash_apply(EG(active_symbol_table), (apply_func_t) zend_check_symbol TSRMLS_CC); \
1335
static int zend_check_symbol(zval **pz TSRMLS_DC)
1337
if (Z_TYPE_PP(pz) > 9) {
1338
fprintf(stderr, "Warning! %x has invalid type!\n", *pz);
1339
} else if (Z_TYPE_PP(pz) == IS_ARRAY) {
1340
zend_hash_apply(Z_ARRVAL_PP(pz), (apply_func_t) zend_check_symbol TSRMLS_CC);
1341
} else if (Z_TYPE_PP(pz) == IS_OBJECT) {
1343
/* OBJ-TBI - doesn't support new object model! */
1344
zend_hash_apply(Z_OBJPROP_PP(pz), (apply_func_t) zend_check_symbol TSRMLS_CC);
1352
#define CHECK_SYMBOL_TABLES()
1355
#define NEXT_OPCODE() \
1356
CHECK_SYMBOL_TABLES() \
1358
return 0; /* CHECK_ME */
1360
#define SET_OPCODE(new_op) \
1361
CHECK_SYMBOL_TABLES() \
1362
EX(opline) = new_op; \
1364
#define INC_OPCODE() \
1365
if (!EG(exception)) { \
1366
CHECK_SYMBOL_TABLES() \
1370
#define RETURN_FROM_EXECUTE_LOOP(execute_data) \
1371
if (EX(op_array)->T < TEMP_VAR_STACK_LIMIT) { \
1372
free_alloca(EX(Ts)); \
1376
EG(in_execution) = EX(original_in_execution); \
1377
EG(current_execute_data) = EX(prev_execute_data); \
1378
return 1; /* CHECK_ME */
1380
ZEND_API opcode_handler_t zend_opcode_handlers[512];
1382
ZEND_API void execute_internal(zend_execute_data *execute_data_ptr, int return_value_used TSRMLS_DC)
1384
((zend_internal_function *) execute_data_ptr->function_state.function)->handler(execute_data_ptr->opline->extended_value, (*(temp_variable *)((char *) execute_data_ptr->Ts + execute_data_ptr->opline->result.u.var)).var.ptr, execute_data_ptr->object, return_value_used TSRMLS_CC);
1387
ZEND_API void execute(zend_op_array *op_array TSRMLS_DC)
1389
zend_execute_data execute_data;
1391
/* Initialize execute_data */
1394
if (op_array->T < TEMP_VAR_STACK_LIMIT) {
1395
EX(Ts) = (temp_variable *) do_alloca(sizeof(temp_variable) * op_array->T);
1397
EX(Ts) = (temp_variable *) safe_emalloc(sizeof(temp_variable), op_array->T, 0);
1399
EX(op_array) = op_array;
1400
EX(original_in_execution) = EG(in_execution);
1401
EX(prev_execute_data) = EG(current_execute_data);
1402
EG(current_execute_data) = &execute_data;
1404
EG(in_execution) = 1;
1405
if (op_array->start_op) {
1406
SET_OPCODE(op_array->start_op);
1408
SET_OPCODE(op_array->opcodes);
1411
if (op_array->uses_this && EG(This)) {
1412
EG(This)->refcount++; /* For $this pointer */
1413
if (zend_hash_add(EG(active_symbol_table), "this", sizeof("this"), &EG(This), sizeof(zval *), NULL)==FAILURE) {
1414
EG(This)->refcount--;
1418
EG(opline_ptr) = &EX(opline);
1420
EX(function_state).function = (zend_function *) op_array;
1421
EG(function_state_ptr) = &EX(function_state);
1423
/* function_state.function_symbol_table is saved as-is to a stack,
1424
* which is an intentional UMR. Shut it up if we're in DEBUG.
1426
EX(function_state).function_symbol_table = NULL;
1431
if (EG(timed_out)) {
1436
zend_clean_garbage(TSRMLS_C);
1437
if (EX(opline)->handler(&execute_data, EX(opline), op_array TSRMLS_CC)) {
1441
zend_error(E_ERROR, "Arrived at end of main loop which shouldn't happen");
1446
#define EX(element) execute_data->element
1448
int zend_add_handler(ZEND_OPCODE_HANDLER_ARGS)
1450
add_function(&EX_T(opline->result.u.var).tmp_var,
1451
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R),
1452
get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC);
1453
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
1454
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
1459
int zend_sub_handler(ZEND_OPCODE_HANDLER_ARGS)
1461
sub_function(&EX_T(opline->result.u.var).tmp_var,
1462
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R),
1463
get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC);
1464
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
1465
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
1470
int zend_mul_handler(ZEND_OPCODE_HANDLER_ARGS)
1472
mul_function(&EX_T(opline->result.u.var).tmp_var,
1473
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R),
1474
get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC);
1475
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
1476
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
1481
int zend_div_handler(ZEND_OPCODE_HANDLER_ARGS)
1483
div_function(&EX_T(opline->result.u.var).tmp_var,
1484
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R),
1485
get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC);
1486
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
1487
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
1492
int zend_mod_handler(ZEND_OPCODE_HANDLER_ARGS)
1494
mod_function(&EX_T(opline->result.u.var).tmp_var,
1495
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R),
1496
get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC);
1497
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
1498
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
1503
int zend_sl_handler(ZEND_OPCODE_HANDLER_ARGS)
1505
shift_left_function(&EX_T(opline->result.u.var).tmp_var,
1506
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R),
1507
get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC);
1508
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
1509
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
1514
int zend_sr_handler(ZEND_OPCODE_HANDLER_ARGS)
1516
shift_right_function(&EX_T(opline->result.u.var).tmp_var,
1517
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R),
1518
get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC);
1519
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
1520
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
1525
int zend_concat_handler(ZEND_OPCODE_HANDLER_ARGS)
1527
concat_function(&EX_T(opline->result.u.var).tmp_var,
1528
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R),
1529
get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC);
1530
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
1531
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
1536
int zend_is_identical_handler(ZEND_OPCODE_HANDLER_ARGS)
1538
is_identical_function(&EX_T(opline->result.u.var).tmp_var,
1539
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R),
1540
get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC);
1541
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
1542
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
1547
int zend_is_not_identical_handler(ZEND_OPCODE_HANDLER_ARGS)
1549
is_not_identical_function(&EX_T(opline->result.u.var).tmp_var,
1550
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R),
1551
get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC);
1552
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
1553
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
1558
int zend_is_equal_handler(ZEND_OPCODE_HANDLER_ARGS)
1560
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
1561
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R),
1562
get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC);
1563
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
1564
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
1569
int zend_is_not_equal_handler(ZEND_OPCODE_HANDLER_ARGS)
1571
is_not_equal_function(&EX_T(opline->result.u.var).tmp_var,
1572
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R),
1573
get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC);
1574
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
1575
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
1580
int zend_is_smaller_handler(ZEND_OPCODE_HANDLER_ARGS)
1582
is_smaller_function(&EX_T(opline->result.u.var).tmp_var,
1583
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R),
1584
get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC);
1585
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
1586
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
1591
int zend_is_smaller_or_equal_handler(ZEND_OPCODE_HANDLER_ARGS)
1593
is_smaller_or_equal_function(&EX_T(opline->result.u.var).tmp_var,
1594
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R),
1595
get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC);
1596
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
1597
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
1602
int zend_bw_or_handler(ZEND_OPCODE_HANDLER_ARGS)
1604
bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
1605
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R),
1606
get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC);
1607
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
1608
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
1613
int zend_bw_and_handler(ZEND_OPCODE_HANDLER_ARGS)
1615
bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
1616
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R),
1617
get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC);
1618
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
1619
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
1624
int zend_bw_xor_handler(ZEND_OPCODE_HANDLER_ARGS)
1626
bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
1627
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R),
1628
get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC);
1629
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
1630
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
1635
int zend_bool_xor_handler(ZEND_OPCODE_HANDLER_ARGS)
1637
boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
1638
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R),
1639
get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC);
1640
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
1641
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
1646
int zend_bw_not_handler(ZEND_OPCODE_HANDLER_ARGS)
1648
bitwise_not_function(&EX_T(opline->result.u.var).tmp_var,
1649
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R) TSRMLS_CC);
1650
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
1655
int zend_bool_not_handler(ZEND_OPCODE_HANDLER_ARGS)
1657
boolean_not_function(&EX_T(opline->result.u.var).tmp_var,
1658
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R) TSRMLS_CC);
1659
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
1664
static inline int zend_binary_assign_op_obj_helper(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
1666
zend_op *op_data = opline+1;
1667
zval **object_ptr = get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
1669
zval *property = get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R);
1671
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_value, BP_VAR_R);
1672
znode *result = &opline->result;
1673
zval **retval = &EX_T(result->u.var).var.ptr;
1674
int have_get_ptr = 0;
1676
EX_T(result->u.var).var.ptr_ptr = NULL;
1677
make_real_object(object_ptr TSRMLS_CC);
1678
object = *object_ptr;
1680
if (object->type != IS_OBJECT) {
1681
zend_error(E_WARNING, "Attempt to assign property of non-object");
1682
FREE_OP(Ts, op2, EG(free_op2));
1683
FREE_OP(Ts, value, free_value);
1685
*retval = EG(uninitialized_zval_ptr);
1687
SELECTIVE_PZVAL_LOCK(*retval, result);
1689
/* here we are sure we are dealing with an object */
1691
MAKE_REAL_ZVAL_PTR(property);
1694
/* here property is a string */
1695
if (opline->extended_value == ZEND_ASSIGN_OBJ
1696
&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
1697
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
1698
if (zptr != NULL) { /* NULL means no success in getting PTR */
1699
SEPARATE_ZVAL_IF_NOT_REF(zptr);
1702
binary_op(*zptr, *zptr, value TSRMLS_CC);
1704
SELECTIVE_PZVAL_LOCK(*retval, result);
1708
if (!have_get_ptr) {
1711
switch (opline->extended_value) {
1712
case ZEND_ASSIGN_OBJ:
1713
z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_RW TSRMLS_CC);
1715
case ZEND_ASSIGN_DIM:
1716
z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_RW TSRMLS_CC);
1719
if (z->type == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
1720
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
1722
if (z->refcount == 0) {
1729
SEPARATE_ZVAL_IF_NOT_REF(&z);
1730
binary_op(z, z, value TSRMLS_CC);
1731
switch (opline->extended_value) {
1732
case ZEND_ASSIGN_OBJ:
1733
Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
1735
case ZEND_ASSIGN_DIM:
1736
Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
1740
SELECTIVE_PZVAL_LOCK(*retval, result);
1745
zval_ptr_dtor(&property);
1747
FREE_OP(Ts, value, free_value);
1750
/* assign_obj has two opcodes! */
1756
static inline int zend_binary_assign_op_helper(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
1760
zend_bool increment_opline = 0;
1762
switch (opline->extended_value) {
1763
case ZEND_ASSIGN_OBJ:
1764
return zend_binary_assign_op_obj_helper(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1766
case ZEND_ASSIGN_DIM: {
1767
zval **object_ptr = get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
1769
(*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
1771
if ((*object_ptr)->type == IS_OBJECT) {
1772
return zend_binary_assign_op_obj_helper(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1774
zend_op *op_data = opline+1;
1776
zend_fetch_dimension_address(&op_data->op2, &opline->op1, &opline->op2, EX(Ts), BP_VAR_RW TSRMLS_CC);
1778
value = get_zval_ptr(&op_data->op1, EX(Ts), &EG(free_op1), BP_VAR_R);
1779
var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), BP_VAR_RW);
1781
increment_opline = 1;
1786
value = get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R);
1787
var_ptr = get_zval_ptr_ptr(&opline->op1, EX(Ts), BP_VAR_RW);
1794
zend_error(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
1797
if (*var_ptr == EG(error_zval_ptr)) {
1798
EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
1799
SELECTIVE_PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &opline->result);
1800
AI_USE_PTR(EX_T(opline->result.u.var).var);
1801
if (increment_opline) {
1807
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
1809
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
1810
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
1812
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
1814
binary_op(objval, objval, value TSRMLS_CC);
1815
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
1816
zval_ptr_dtor(&objval);
1818
binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
1821
EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
1822
SELECTIVE_PZVAL_LOCK(*var_ptr, &opline->result);
1823
FREE_OP(Ex(Ts), &opline->op1, EG(free_op1));
1824
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
1825
AI_USE_PTR(EX_T(opline->result.u.var).var);
1827
if (increment_opline) {
1834
int zend_assign_add_handler(ZEND_OPCODE_HANDLER_ARGS)
1836
return zend_binary_assign_op_helper(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1840
int zend_assign_sub_handler(ZEND_OPCODE_HANDLER_ARGS)
1842
return zend_binary_assign_op_helper(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1846
int zend_assign_mul_handler(ZEND_OPCODE_HANDLER_ARGS)
1848
return zend_binary_assign_op_helper(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1852
int zend_assign_div_handler(ZEND_OPCODE_HANDLER_ARGS)
1854
return zend_binary_assign_op_helper(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1858
int zend_assign_mod_handler(ZEND_OPCODE_HANDLER_ARGS)
1860
return zend_binary_assign_op_helper(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1864
int zend_assign_sl_handler(ZEND_OPCODE_HANDLER_ARGS)
1866
return zend_binary_assign_op_helper(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1870
int zend_assign_sr_handler(ZEND_OPCODE_HANDLER_ARGS)
1872
return zend_binary_assign_op_helper(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1876
int zend_assign_concat_handler(ZEND_OPCODE_HANDLER_ARGS)
1878
return zend_binary_assign_op_helper(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1882
int zend_assign_bw_or_handler(ZEND_OPCODE_HANDLER_ARGS)
1884
return zend_binary_assign_op_helper(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1888
int zend_assign_bw_and_handler(ZEND_OPCODE_HANDLER_ARGS)
1890
return zend_binary_assign_op_helper(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1894
int zend_assign_bw_xor_handler(ZEND_OPCODE_HANDLER_ARGS)
1896
return zend_binary_assign_op_helper(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1899
int zend_pre_inc_obj_handler(ZEND_OPCODE_HANDLER_ARGS)
1901
zend_pre_incdec_property(&opline->result, &opline->op1, &opline->op2, EX(Ts), increment_function TSRMLS_CC);
1906
int zend_pre_dec_obj_handler(ZEND_OPCODE_HANDLER_ARGS)
1908
zend_pre_incdec_property(&opline->result, &opline->op1, &opline->op2, EX(Ts), decrement_function TSRMLS_CC);
1913
int zend_post_inc_obj_handler(ZEND_OPCODE_HANDLER_ARGS)
1915
zend_post_incdec_property(&opline->result, &opline->op1, &opline->op2, EX(Ts), increment_function TSRMLS_CC);
1920
int zend_post_dec_obj_handler(ZEND_OPCODE_HANDLER_ARGS)
1922
zend_post_incdec_property(&opline->result, &opline->op1, &opline->op2, EX(Ts), decrement_function TSRMLS_CC);
1926
typedef int (*incdec_t)(zval *);
1928
static inline int zend_incdec_op_helper(incdec_t incdec_op_arg, ZEND_OPCODE_HANDLER_ARGS)
1930
zval **var_ptr = get_zval_ptr_ptr(&opline->op1, EX(Ts), BP_VAR_RW);
1931
int (*incdec_op)(zval *op1) = incdec_op_arg;
1934
zend_error(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
1936
if (*var_ptr == EG(error_zval_ptr)) {
1937
switch (opline->opcode) {
1940
EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
1941
SELECTIVE_PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &opline->result);
1942
AI_USE_PTR(EX_T(opline->result.u.var).var);
1947
EX_T(opline->result.u.var).tmp_var = *EG(uninitialized_zval_ptr);
1953
switch (opline->opcode) {
1956
EX_T(opline->result.u.var).tmp_var = **var_ptr;
1957
zendi_zval_copy_ctor(EX_T(opline->result.u.var).tmp_var);
1961
SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
1963
if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
1964
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
1966
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
1969
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
1970
zval_ptr_dtor(&val);
1972
incdec_op(*var_ptr);
1975
switch (opline->opcode) {
1978
EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
1979
SELECTIVE_PZVAL_LOCK(*var_ptr, &opline->result);
1980
AI_USE_PTR(EX_T(opline->result.u.var).var);
1987
int zend_pre_inc_handler(ZEND_OPCODE_HANDLER_ARGS)
1989
return zend_incdec_op_helper(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1993
int zend_pre_dec_handler(ZEND_OPCODE_HANDLER_ARGS)
1995
return zend_incdec_op_helper(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1999
int zend_post_inc_handler(ZEND_OPCODE_HANDLER_ARGS)
2001
return zend_incdec_op_helper(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
2005
int zend_post_dec_handler(ZEND_OPCODE_HANDLER_ARGS)
2007
return zend_incdec_op_helper(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
2011
int zend_echo_handler(ZEND_OPCODE_HANDLER_ARGS)
2015
zval *z = get_zval_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_R);
2017
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get_method != NULL &&
2018
zend_std_cast_object_tostring(z, &z_copy, IS_STRING, 0 TSRMLS_CC) == SUCCESS) {
2019
zend_print_variable(&z_copy);
2022
zend_print_variable(z);
2025
FREE_OP(EX(Ts), &opline->op1, free_op1);
2030
int zend_print_handler(ZEND_OPCODE_HANDLER_ARGS)
2032
EX_T(opline->result.u.var).tmp_var.value.lval = 1;
2033
EX_T(opline->result.u.var).tmp_var.type = IS_LONG;
2035
return zend_echo_handler(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
2039
int zend_fetch_r_handler(ZEND_OPCODE_HANDLER_ARGS)
2041
zend_fetch_var_address(opline, EX(Ts), BP_VAR_R TSRMLS_CC);
2042
AI_USE_PTR(EX_T(opline->result.u.var).var);
2047
int zend_fetch_w_handler(ZEND_OPCODE_HANDLER_ARGS)
2049
zend_fetch_var_address(opline, EX(Ts), BP_VAR_W TSRMLS_CC);
2054
int zend_fetch_rw_handler(ZEND_OPCODE_HANDLER_ARGS)
2056
zend_fetch_var_address(opline, EX(Ts), BP_VAR_RW TSRMLS_CC);
2061
int zend_fetch_func_arg_handler(ZEND_OPCODE_HANDLER_ARGS)
2063
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
2064
/* Behave like FETCH_W */
2065
zend_fetch_var_address(opline, EX(Ts), BP_VAR_W TSRMLS_CC);
2067
/* Behave like FETCH_R */
2068
zend_fetch_var_address(opline, EX(Ts), BP_VAR_R TSRMLS_CC);
2069
AI_USE_PTR(EX_T(opline->result.u.var).var);
2075
int zend_fetch_unset_handler(ZEND_OPCODE_HANDLER_ARGS)
2077
zend_fetch_var_address(opline, EX(Ts), BP_VAR_R TSRMLS_CC);
2078
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
2079
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
2080
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
2082
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
2087
int zend_fetch_is_handler(ZEND_OPCODE_HANDLER_ARGS)
2089
zend_fetch_var_address(opline, EX(Ts), BP_VAR_IS TSRMLS_CC);
2090
AI_USE_PTR(EX_T(opline->result.u.var).var);
2095
int zend_fetch_dim_r_handler(ZEND_OPCODE_HANDLER_ARGS)
2097
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
2098
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
2100
zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
2101
AI_USE_PTR(EX_T(opline->result.u.var).var);
2106
int zend_fetch_dim_w_handler(ZEND_OPCODE_HANDLER_ARGS)
2108
zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, EX(Ts), BP_VAR_W TSRMLS_CC);
2113
int zend_fetch_dim_rw_handler(ZEND_OPCODE_HANDLER_ARGS)
2115
zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, EX(Ts), BP_VAR_RW TSRMLS_CC);
2120
int zend_fetch_dim_is_handler(ZEND_OPCODE_HANDLER_ARGS)
2122
zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, EX(Ts), BP_VAR_IS TSRMLS_CC);
2123
AI_USE_PTR(EX_T(opline->result.u.var).var);
2128
int zend_fetch_dim_func_arg_handler(ZEND_OPCODE_HANDLER_ARGS)
2130
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
2131
/* Behave like FETCH_DIM_W */
2132
zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, EX(Ts), BP_VAR_W TSRMLS_CC);
2134
if (opline->op2.op_type == IS_UNUSED) {
2135
zend_error(E_ERROR, "Cannot use [] for reading");
2137
/* Behave like FETCH_DIM_R, except for locking used for list() */
2138
zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
2139
AI_USE_PTR(EX_T(opline->result.u.var).var);
2145
int zend_fetch_dim_unset_handler(ZEND_OPCODE_HANDLER_ARGS)
2147
/* Not needed in DIM_UNSET
2148
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
2149
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
2152
zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
2153
if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
2154
zend_error(E_ERROR, "Cannot unset string offsets");
2156
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
2157
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
2158
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
2160
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
2166
int zend_fetch_obj_r_handler(ZEND_OPCODE_HANDLER_ARGS)
2168
zend_fetch_property_address_read(&opline->result, &opline->op1, &opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
2169
AI_USE_PTR(EX_T(opline->result.u.var).var);
2174
int zend_fetch_obj_w_handler(ZEND_OPCODE_HANDLER_ARGS)
2176
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
2177
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
2178
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
2180
zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, EX(Ts), BP_VAR_W TSRMLS_CC);
2185
int zend_fetch_obj_rw_handler(ZEND_OPCODE_HANDLER_ARGS)
2187
zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, EX(Ts), BP_VAR_RW TSRMLS_CC);
2192
int zend_fetch_obj_is_handler(ZEND_OPCODE_HANDLER_ARGS)
2194
zend_fetch_property_address_read(&opline->result, &opline->op1, &opline->op2, EX(Ts), BP_VAR_IS TSRMLS_CC);
2195
AI_USE_PTR(EX_T(opline->result.u.var).var);
2200
int zend_fetch_obj_func_arg_handler(ZEND_OPCODE_HANDLER_ARGS)
2202
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
2203
/* Behave like FETCH_OBJ_W */
2204
zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, EX(Ts), BP_VAR_W TSRMLS_CC);
2206
zend_fetch_property_address_read(&opline->result, &opline->op1, &opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
2207
AI_USE_PTR(EX_T(opline->result.u.var).var);
2213
int zend_fetch_obj_unset_handler(ZEND_OPCODE_HANDLER_ARGS)
2215
zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
2217
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
2218
if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
2219
SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
2221
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
2226
int zend_fetch_dim_tmp_var_handler(ZEND_OPCODE_HANDLER_ARGS)
2228
zend_fetch_dimension_address_from_tmp_var(&opline->result, &opline->op1, &opline->op2, EX(Ts) TSRMLS_CC);
2229
AI_USE_PTR(EX_T(opline->result.u.var).var);
2234
int zend_assign_obj_handler(ZEND_OPCODE_HANDLER_ARGS)
2236
zend_op *op_data = opline+1;
2237
zval **object_ptr = get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
2239
zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
2240
/* assign_obj has two opcodes! */
2246
int zend_assign_dim_handler(ZEND_OPCODE_HANDLER_ARGS)
2248
zend_op *op_data = opline+1;
2251
if (EX_T(opline->op1.u.var).var.ptr_ptr) {
2252
/* not an array offset */
2253
object_ptr = get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
2258
if (object_ptr && (*object_ptr)->type == IS_OBJECT) {
2259
zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
2264
(*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
2266
zend_fetch_dimension_address(&op_data->op2, &opline->op1, &opline->op2, EX(Ts), BP_VAR_W TSRMLS_CC);
2268
value = get_zval_ptr(&op_data->op1, EX(Ts), &EG(free_op1), BP_VAR_R);
2269
zend_assign_to_variable(&opline->result, &op_data->op2, &op_data->op1, value, (EG(free_op1)?IS_TMP_VAR:op_data->op1.op_type), EX(Ts) TSRMLS_CC);
2271
/* assign_dim has two opcodes! */
2277
int zend_assign_handler(ZEND_OPCODE_HANDLER_ARGS)
2280
value = get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R);
2282
zend_assign_to_variable(&opline->result, &opline->op1, &opline->op2, value, (EG(free_op2)?IS_TMP_VAR:opline->op2.op_type), EX(Ts) TSRMLS_CC);
2283
/* zend_assign_to_variable() always takes care of op2, never free it! */
2289
int zend_assign_ref_handler(ZEND_OPCODE_HANDLER_ARGS)
2291
zval **value_ptr_ptr = get_zval_ptr_ptr(&opline->op2, EX(Ts), BP_VAR_W);
2293
if (opline->op2.op_type == IS_VAR &&
2295
!(*value_ptr_ptr)->is_ref &&
2296
opline->extended_value == ZEND_RETURNS_FUNCTION &&
2297
!EX_T(opline->op2.u.var).var.fcall_returned_reference) {
2298
PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
2299
zend_error(E_STRICT, "Only variables should be assigned by reference");
2300
return zend_assign_handler(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
2302
if (opline->op1.op_type == IS_VAR && EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
2303
zend_error(E_ERROR, "Cannot assign by reference to overloaded object");
2306
zend_assign_to_variable_reference(&opline->result, get_zval_ptr_ptr(&opline->op1, EX(Ts), BP_VAR_W), value_ptr_ptr, EX(Ts) TSRMLS_CC);
2312
int zend_jmp_handler(ZEND_OPCODE_HANDLER_ARGS)
2315
printf("Jumping to %d\n", opline->op1.u.opline_num);
2317
SET_OPCODE(opline->op1.u.jmp_addr);
2318
return 0; /* CHECK_ME */
2322
int zend_jmpz_handler(ZEND_OPCODE_HANDLER_ARGS)
2324
znode *op1 = &opline->op1;
2326
if (!i_zend_is_true(get_zval_ptr(op1, EX(Ts), &EG(free_op1), BP_VAR_R))) {
2328
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
2330
SET_OPCODE(opline->op2.u.jmp_addr);
2331
FREE_OP(EX(Ts), op1, EG(free_op1));
2332
return 0; /* CHECK_ME */
2334
FREE_OP(EX(Ts), op1, EG(free_op1));
2340
int zend_jmpnz_handler(ZEND_OPCODE_HANDLER_ARGS)
2342
znode *op1 = &opline->op1;
2344
if (zend_is_true(get_zval_ptr(op1, EX(Ts), &EG(free_op1), BP_VAR_R))) {
2346
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
2348
SET_OPCODE(opline->op2.u.jmp_addr);
2349
FREE_OP(EX(Ts), op1, EG(free_op1));
2350
return 0; /* CHECK_ME */
2352
FREE_OP(EX(Ts), op1, EG(free_op1));
2358
int zend_jmpznz_handler(ZEND_OPCODE_HANDLER_ARGS)
2360
znode *res = &opline->op1;
2362
if (zend_is_true(get_zval_ptr(res, EX(Ts), &EG(free_op1), BP_VAR_R))) {
2364
printf("Conditional jmp on true to %d\n", opline->extended_value);
2366
SET_OPCODE(&op_array->opcodes[opline->extended_value]);
2369
printf("Conditional jmp on false to %d\n", opline->op2.u.opline_num);
2371
SET_OPCODE(&op_array->opcodes[opline->op2.u.opline_num]);
2373
FREE_OP(EX(Ts), res, EG(free_op1));
2375
return 0; /* CHECK_ME */
2379
int zend_jmpz_ex_handler(ZEND_OPCODE_HANDLER_ARGS)
2381
zend_op *original_opline = opline;
2382
int retval = zend_is_true(get_zval_ptr(&original_opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R));
2384
FREE_OP(EX(Ts), &original_opline->op1, EG(free_op1));
2385
EX_T(original_opline->result.u.var).tmp_var.value.lval = retval;
2386
EX_T(original_opline->result.u.var).tmp_var.type = IS_BOOL;
2389
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
2391
SET_OPCODE(opline->op2.u.jmp_addr);
2392
return 0; /* CHECK_ME */
2398
int zend_jmpnz_ex_handler(ZEND_OPCODE_HANDLER_ARGS)
2400
zend_op *original_opline = opline;
2401
int retval = zend_is_true(get_zval_ptr(&original_opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R));
2403
FREE_OP(EX(Ts), &original_opline->op1, EG(free_op1));
2404
EX_T(original_opline->result.u.var).tmp_var.value.lval = retval;
2405
EX_T(original_opline->result.u.var).tmp_var.type = IS_BOOL;
2408
printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
2410
SET_OPCODE(opline->op2.u.jmp_addr);
2411
return 0; /* CHECK_ME */
2417
int zend_free_handler(ZEND_OPCODE_HANDLER_ARGS)
2419
zendi_zval_dtor(EX_T(opline->op1.u.var).tmp_var);
2424
int zend_init_string_handler(ZEND_OPCODE_HANDLER_ARGS)
2426
EX_T(opline->result.u.var).tmp_var.value.str.val = emalloc(1);
2427
EX_T(opline->result.u.var).tmp_var.value.str.val[0] = 0;
2428
EX_T(opline->result.u.var).tmp_var.value.str.len = 0;
2429
EX_T(opline->result.u.var).tmp_var.refcount = 1;
2430
EX_T(opline->result.u.var).tmp_var.type = IS_STRING;
2431
EX_T(opline->result.u.var).tmp_var.is_ref = 0;
2436
int zend_add_char_handler(ZEND_OPCODE_HANDLER_ARGS)
2438
add_char_to_string(&EX_T(opline->result.u.var).tmp_var,
2439
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_NA),
2440
&opline->op2.u.constant);
2441
/* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
2446
int zend_add_string_handler(ZEND_OPCODE_HANDLER_ARGS)
2448
add_string_to_string(&EX_T(opline->result.u.var).tmp_var,
2449
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_NA),
2450
&opline->op2.u.constant);
2451
/* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
2456
int zend_add_var_handler(ZEND_OPCODE_HANDLER_ARGS)
2458
zval *var = get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R);
2462
zend_make_printable_zval(var, &var_copy, &use_copy);
2466
add_string_to_string( &EX_T(opline->result.u.var).tmp_var,
2467
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_NA),
2472
/* original comment, possibly problematic:
2473
* FREE_OP is missing intentionally here - we're always working on the same temporary variable
2474
* (Zeev): I don't think it's problematic, we only use variables
2475
* which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
2476
* string offsets or overloaded objects
2478
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
2484
int zend_fetch_class_handler(ZEND_OPCODE_HANDLER_ARGS)
2489
if (opline->op2.op_type == IS_UNUSED) {
2490
EX_T(opline->result.u.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
2494
class_name = get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R);
2496
switch (class_name->type) {
2498
EX_T(opline->result.u.var).class_entry = Z_OBJCE_P(class_name);
2501
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);
2504
zend_error(E_ERROR, "Class name must be a valid object or a string");
2508
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
2513
int zend_init_ctor_call_handler(ZEND_OPCODE_HANDLER_ARGS)
2515
zend_ptr_stack_n_push(&EG(arg_types_stack), 3, EX(fbc), EX(object), EX(calling_scope));
2517
if (opline->op1.op_type == IS_VAR) {
2518
SELECTIVE_PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr, &opline->op1);
2521
/* We are not handling overloaded classes right now */
2522
EX(object) = get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R);
2524
/* New always returns the object as is_ref=0, therefore, we can just increment the reference count */
2525
EX(object)->refcount++; /* For $this pointer */
2527
EX(fbc) = EX(fbc_constructor);
2529
if (EX(fbc)->type == ZEND_USER_FUNCTION) { /* HACK!! */
2530
EX(calling_scope) = EX(fbc)->common.scope;
2532
EX(calling_scope) = NULL;
2539
int zend_init_method_call_handler(ZEND_OPCODE_HANDLER_ARGS)
2541
zval *function_name;
2542
char *function_name_strval;
2543
int function_name_strlen;
2545
zend_ptr_stack_n_push(&EG(arg_types_stack), 3, EX(fbc), EX(object), EX(calling_scope));
2547
function_name = get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R);
2549
if (Z_TYPE_P(function_name)!=IS_STRING) {
2550
zend_error(E_ERROR, "Method name must be a string");
2553
function_name_strval = function_name->value.str.val;
2554
function_name_strlen = function_name->value.str.len;
2556
EX(calling_scope) = EG(scope);
2558
EX(object) = get_obj_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R TSRMLS_CC);
2560
if (EX(object) && EX(object)->type == IS_OBJECT) {
2561
if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
2562
zend_error(E_ERROR, "Object does not support method calls");
2565
/* First, locate the function. */
2566
EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
2568
zend_error(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
2571
zend_error(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
2574
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
2577
if (!PZVAL_IS_REF(EX(object))) {
2578
EX(object)->refcount++; /* For $this pointer */
2581
ALLOC_ZVAL(this_ptr);
2582
*this_ptr = *EX(object);
2583
INIT_PZVAL(this_ptr);
2584
zval_copy_ctor(this_ptr);
2585
EX(object) = this_ptr;
2589
if (EX(fbc)->type == ZEND_USER_FUNCTION) {
2590
EX(calling_scope) = EX(fbc)->common.scope;
2592
EX(calling_scope) = NULL;
2595
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
2601
int zend_init_static_method_call_handler(ZEND_OPCODE_HANDLER_ARGS)
2603
zval *function_name;
2604
zend_class_entry *ce;
2606
zend_ptr_stack_n_push(&EG(arg_types_stack), 3, EX(fbc), EX(object), EX(calling_scope));
2608
ce = EX_T(opline->op1.u.var).class_entry;
2609
if(opline->op2.op_type != IS_UNUSED) {
2610
char *function_name_strval;
2611
int function_name_strlen;
2612
zend_bool is_const = (opline->op2.op_type == IS_CONST);
2615
function_name_strval = opline->op2.u.constant.value.str.val;
2616
function_name_strlen = opline->op2.u.constant.value.str.len;
2618
function_name = get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R);
2620
if (Z_TYPE_P(function_name) != IS_STRING) {
2621
zend_error(E_ERROR, "Function name must be a string");
2623
function_name_strval = zend_str_tolower_dup(function_name->value.str.val, function_name->value.str.len);
2624
function_name_strlen = function_name->value.str.len;
2627
EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
2630
efree(function_name_strval);
2631
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
2634
if(!ce->constructor) {
2635
zend_error(E_ERROR, "Can not call constructor");
2637
EX(fbc) = ce->constructor;
2640
EX(calling_scope) = EX(fbc)->common.scope;
2642
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
2645
if ((EX(object) = EG(This))) {
2646
EX(object)->refcount++;
2653
int zend_init_fcall_by_name_handler(ZEND_OPCODE_HANDLER_ARGS)
2655
zval *function_name;
2656
zend_function *function;
2658
char *function_name_strval, *lcname;
2659
int function_name_strlen;
2661
zend_ptr_stack_n_push(&EG(arg_types_stack), 3, EX(fbc), EX(object), EX(calling_scope));
2663
is_const = (opline->op2.op_type == IS_CONST);
2666
function_name_strval = opline->op2.u.constant.value.str.val;
2667
function_name_strlen = opline->op2.u.constant.value.str.len;
2669
function_name = get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R);
2671
if (Z_TYPE_P(function_name) != IS_STRING) {
2672
zend_error(E_ERROR, "Function name must be a string");
2674
function_name_strval = function_name->value.str.val;
2675
function_name_strlen = function_name->value.str.len;
2678
lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
2679
if (zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &function)==FAILURE) {
2681
zend_error(E_ERROR, "Call to undefined function %s()", function_name_strval);
2686
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
2689
EX(calling_scope) = function->common.scope;
2697
int zend_do_fcall_common_helper(ZEND_OPCODE_HANDLER_ARGS)
2699
zval **original_return_value;
2700
zend_class_entry *current_scope;
2702
int return_value_used = RETURN_VALUE_USED(opline);
2703
zend_bool should_change_scope;
2705
if (EX(function_state).function->common.fn_flags & ZEND_ACC_ABSTRACT) {
2706
zend_error(E_ERROR, "Cannot call abstract method %s::%s()", EX(function_state).function->common.scope->name, EX(function_state).function->common.function_name);
2707
NEXT_OPCODE(); /* Never reached */
2710
zend_ptr_stack_n_push(&EG(argument_stack), 2, (void *) opline->extended_value, NULL);
2712
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
2714
if (EX(function_state).function->type == ZEND_USER_FUNCTION
2715
|| EX(function_state).function->common.scope) {
2716
should_change_scope = 1;
2717
current_this = EG(This);
2718
EG(This) = EX(object);
2719
current_scope = EG(scope);
2720
EG(scope) = EX(calling_scope);
2722
should_change_scope = 0;
2725
EX_T(opline->result.u.var).var.fcall_returned_reference = 0;
2727
if (EX(function_state).function->common.scope) {
2728
if (!EG(This) && !(EX(function_state).function->common.fn_flags & ZEND_ACC_STATIC)) {
2730
char *severity_word;
2731
if (EX(function_state).function->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
2732
severity = E_STRICT;
2733
severity_word = "should not";
2736
severity_word = "cannot";
2738
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);
2741
if (EX(function_state).function->type == ZEND_INTERNAL_FUNCTION) {
2742
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
2743
INIT_ZVAL(*(EX_T(opline->result.u.var).var.ptr));
2745
if (EX(function_state).function->common.arg_info) {
2750
p = (zval **) EG(argument_stack).top_element-2;
2751
arg_count = (ulong) *p;
2753
while (arg_count>0) {
2754
zend_verify_arg_type(EX(function_state).function, ++i, *(p-arg_count) TSRMLS_CC);
2758
if (!zend_execute_internal) {
2759
/* saves one function call if zend_execute_internal is not used */
2760
((zend_internal_function *) EX(function_state).function)->handler(opline->extended_value, EX_T(opline->result.u.var).var.ptr, EX(object), return_value_used TSRMLS_CC);
2762
zend_execute_internal(execute_data, return_value_used TSRMLS_CC);
2765
EG(current_execute_data) = execute_data;
2766
EX_T(opline->result.u.var).var.ptr->is_ref = 0;
2767
EX_T(opline->result.u.var).var.ptr->refcount = 1;
2768
if (!return_value_used) {
2769
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
2771
} else if (EX(function_state).function->type == ZEND_USER_FUNCTION) {
2772
HashTable *calling_symbol_table;
2774
EX_T(opline->result.u.var).var.ptr = NULL;
2775
if (EG(symtable_cache_ptr)>=EG(symtable_cache)) {
2776
/*printf("Cache hit! Reusing %x\n", symtable_cache[symtable_cache_ptr]);*/
2777
EX(function_state).function_symbol_table = *(EG(symtable_cache_ptr)--);
2779
ALLOC_HASHTABLE(EX(function_state).function_symbol_table);
2780
zend_hash_init(EX(function_state).function_symbol_table, 0, NULL, ZVAL_PTR_DTOR, 0);
2781
/*printf("Cache miss! Initialized %x\n", function_state.function_symbol_table);*/
2783
calling_symbol_table = EG(active_symbol_table);
2784
EG(active_symbol_table) = EX(function_state).function_symbol_table;
2785
original_return_value = EG(return_value_ptr_ptr);
2786
EG(return_value_ptr_ptr) = EX_T(opline->result.u.var).var.ptr_ptr;
2787
EG(active_op_array) = (zend_op_array *) EX(function_state).function;
2789
zend_execute(EG(active_op_array) TSRMLS_CC);
2790
EX_T(opline->result.u.var).var.fcall_returned_reference = EG(active_op_array)->return_reference;
2792
if (return_value_used && !EX_T(opline->result.u.var).var.ptr) {
2793
if (!EG(exception)) {
2794
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
2795
INIT_ZVAL(*EX_T(opline->result.u.var).var.ptr);
2797
} else if (!return_value_used && EX_T(opline->result.u.var).var.ptr) {
2798
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
2801
EG(opline_ptr) = &EX(opline);
2802
EG(active_op_array) = op_array;
2803
EG(return_value_ptr_ptr)=original_return_value;
2804
if (EG(symtable_cache_ptr)>=EG(symtable_cache_limit)) {
2805
zend_hash_destroy(EX(function_state).function_symbol_table);
2806
FREE_HASHTABLE(EX(function_state).function_symbol_table);
2808
/* clean before putting into the cache, since clean
2809
could call dtors, which could use cached hash */
2810
zend_hash_clean(EX(function_state).function_symbol_table);
2811
*(++EG(symtable_cache_ptr)) = EX(function_state).function_symbol_table;
2813
EG(active_symbol_table) = calling_symbol_table;
2814
} else { /* ZEND_OVERLOADED_FUNCTION */
2815
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
2816
INIT_ZVAL(*(EX_T(opline->result.u.var).var.ptr));
2818
/* Not sure what should be done here if it's a static method */
2820
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(object), return_value_used TSRMLS_CC);
2822
zend_error(E_ERROR, "Cannot call overloaded function for non-object");
2825
if (EX(function_state).function->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
2826
efree(EX(function_state).function->common.function_name);
2830
if (!return_value_used) {
2831
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
2833
EX_T(opline->result.u.var).var.ptr->is_ref = 0;
2834
EX_T(opline->result.u.var).var.ptr->refcount = 1;
2839
if (EG(exception) && EX(fbc) && EX(fbc)->common.fn_flags&ZEND_ACC_CTOR) {
2840
EG(This)->refcount--;
2841
if (EG(This)->refcount == 1) {
2842
zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
2844
if (should_change_scope && EG(This) != current_this) {
2845
zval_ptr_dtor(&EG(This));
2847
} else if (should_change_scope) {
2848
zval_ptr_dtor(&EG(This));
2852
if (should_change_scope) {
2853
EG(This) = current_this;
2854
EG(scope) = current_scope;
2856
zend_ptr_stack_n_pop(&EG(arg_types_stack), 3, &EX(calling_scope), &EX(object), &EX(fbc));
2858
EX(function_state).function = (zend_function *) op_array;
2859
EG(function_state_ptr) = &EX(function_state);
2860
zend_ptr_stack_clear_multiple(TSRMLS_C);
2862
if (EG(exception)) {
2863
zend_throw_exception_internal(NULL TSRMLS_CC);
2864
if (return_value_used && EX_T(opline->result.u.var).var.ptr) {
2865
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
2873
int zend_do_fcall_by_name_handler(ZEND_OPCODE_HANDLER_ARGS)
2875
EX(function_state).function = EX(fbc);
2876
return zend_do_fcall_common_helper(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
2880
int zend_do_fcall_handler(ZEND_OPCODE_HANDLER_ARGS)
2882
zval *fname = get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R);
2884
zend_ptr_stack_n_push(&EG(arg_types_stack), 3, EX(fbc), EX(object), EX(calling_scope));
2886
if (zend_hash_find(EG(function_table), fname->value.str.val, fname->value.str.len+1, (void **) &EX(function_state).function)==FAILURE) {
2887
zend_error(E_ERROR, "Unknown function: %s()\n", fname->value.str.val);
2890
EX(calling_scope) = EX(function_state).function->common.scope;
2892
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
2894
return zend_do_fcall_common_helper(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
2898
int zend_return_handler(ZEND_OPCODE_HANDLER_ARGS)
2901
zval **retval_ptr_ptr;
2903
if (EG(active_op_array)->return_reference == ZEND_RETURN_REF) {
2904
if (opline->op1.op_type == IS_CONST || opline->op1.op_type == IS_TMP_VAR) {
2905
/* Not supposed to happen, but we'll allow it */
2906
zend_error(E_STRICT, "Only variable references should be returned by reference");
2907
goto return_by_value;
2910
retval_ptr_ptr = get_zval_ptr_ptr(&opline->op1, EX(Ts), BP_VAR_W);
2912
if (!retval_ptr_ptr) {
2913
zend_error(E_ERROR, "Cannot return string offsets by reference");
2916
if (!(*retval_ptr_ptr)->is_ref) {
2917
if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
2918
EX_T(opline->op1.u.var).var.fcall_returned_reference) {
2919
} else if (EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
2920
PZVAL_LOCK(*retval_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
2921
zend_error(E_STRICT, "Only variable references should be returned by reference");
2922
goto return_by_value;
2926
SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
2927
(*retval_ptr_ptr)->refcount++;
2929
(*EG(return_value_ptr_ptr)) = (*retval_ptr_ptr);
2932
retval_ptr = get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R);
2934
if (EG(ze1_compatibility_mode) && Z_TYPE_P(retval_ptr) == IS_OBJECT) {
2936
zend_uint class_name_len;
2939
dup = zend_get_object_classname(retval_ptr, &class_name, &class_name_len TSRMLS_CC);
2941
ALLOC_ZVAL(*(EG(return_value_ptr_ptr)));
2942
**EG(return_value_ptr_ptr) = *retval_ptr;
2943
INIT_PZVAL(*EG(return_value_ptr_ptr));
2944
if (Z_OBJ_HT_P(retval_ptr)->clone_obj == NULL) {
2945
zend_error(E_ERROR, "Trying to clone an uncloneable object of class %s", class_name);
2947
zend_error(E_STRICT, "Implicit cloning object of class '%s' because of 'zend.ze1_compatibility_mode'", class_name);
2948
(*EG(return_value_ptr_ptr))->value.obj = Z_OBJ_HT_P(retval_ptr)->clone_obj(retval_ptr TSRMLS_CC);
2953
} else if (!EG(free_op1)) { /* Not a temp var */
2954
if (EG(active_op_array)->return_reference == ZEND_RETURN_REF ||
2955
(PZVAL_IS_REF(retval_ptr) && retval_ptr->refcount > 0)) {
2956
ALLOC_ZVAL(*(EG(return_value_ptr_ptr)));
2957
**EG(return_value_ptr_ptr) = *retval_ptr;
2958
(*EG(return_value_ptr_ptr))->is_ref = 0;
2959
(*EG(return_value_ptr_ptr))->refcount = 1;
2960
zval_copy_ctor(*EG(return_value_ptr_ptr));
2962
*EG(return_value_ptr_ptr) = retval_ptr;
2963
retval_ptr->refcount++;
2966
ALLOC_ZVAL(*(EG(return_value_ptr_ptr)));
2967
**EG(return_value_ptr_ptr) = *retval_ptr;
2968
(*EG(return_value_ptr_ptr))->refcount = 1;
2969
(*EG(return_value_ptr_ptr))->is_ref = 0;
2972
RETURN_FROM_EXECUTE_LOOP(execute_data);
2976
int zend_throw_handler(ZEND_OPCODE_HANDLER_ARGS)
2981
value = get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R);
2983
if (value->type != IS_OBJECT) {
2984
zend_error(E_ERROR, "Can only throw objects");
2986
/* Not sure if a complete copy is what we want here */
2987
MAKE_STD_ZVAL(exception);
2988
*exception = *value;
2989
if (!EG(free_op1)) {
2990
zval_copy_ctor(exception);
2992
INIT_PZVAL(exception);
2994
zend_throw_exception_object(exception TSRMLS_CC);
2999
int zend_catch_handler(ZEND_OPCODE_HANDLER_ARGS)
3001
zend_class_entry *ce;
3003
/* Check whether an exception has been thrown, if not, jump over code */
3004
if (EG(exception) == NULL) {
3005
SET_OPCODE(&op_array->opcodes[opline->extended_value]);
3006
return 0; /* CHECK_ME */
3008
ce = Z_OBJCE_P(EG(exception));
3009
if (ce != EX_T(opline->op1.u.var).class_entry) {
3010
if (!instanceof_function(ce, EX_T(opline->op1.u.var).class_entry TSRMLS_CC)) {
3011
if (opline->op1.u.EA.type) {
3012
zend_throw_exception_internal(NULL TSRMLS_CC);
3015
SET_OPCODE(&op_array->opcodes[opline->extended_value]);
3016
return 0; /* CHECK_ME */
3020
zend_hash_update(EG(active_symbol_table), opline->op2.u.constant.value.str.val,
3021
opline->op2.u.constant.value.str.len+1, &EG(exception), sizeof(zval *), (void **) NULL);
3022
EG(exception) = NULL;
3027
int zend_send_val_handler(ZEND_OPCODE_HANDLER_ARGS)
3029
if (opline->extended_value==ZEND_DO_FCALL_BY_NAME
3030
&& ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
3031
zend_error(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.u.opline_num);
3037
value = get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R);
3041
if (!EG(free_op1)) {
3042
zval_copy_ctor(valptr);
3045
zend_ptr_stack_push(&EG(argument_stack), valptr);
3051
static inline int zend_send_by_var_helper(ZEND_OPCODE_HANDLER_ARGS)
3054
varptr = get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R);
3056
if (varptr == &EG(uninitialized_zval)) {
3059
varptr->refcount = 0;
3060
} else if (PZVAL_IS_REF(varptr)) {
3061
zval *original_var = varptr;
3064
*varptr = *original_var;
3066
varptr->refcount = 0;
3067
zval_copy_ctor(varptr);
3070
zend_ptr_stack_push(&EG(argument_stack), varptr);
3071
FREE_OP(EX(Ts), &opline->op1, EG(free_op1)); /* for string offsets */
3077
int zend_send_var_no_ref_handler(ZEND_OPCODE_HANDLER_ARGS)
3079
if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */
3080
if (!(opline->extended_value & ZEND_ARG_SEND_BY_REF)) {
3081
return zend_send_by_var_helper(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3083
} else if (!ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
3084
return zend_send_by_var_helper(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3086
if ((opline->extended_value & ZEND_ARG_SEND_FUNCTION) &&
3087
!EX_T(opline->op1.u.var).var.fcall_returned_reference) {
3088
zend_error(E_ERROR, "Only variables can be passed by reference");
3091
varptr = get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R);
3093
if (varptr != &EG(uninitialized_zval) && (PZVAL_IS_REF(varptr) || varptr->refcount == 1)) {
3096
zend_ptr_stack_push(&EG(argument_stack), varptr);
3099
zend_error(E_ERROR, "Only variables can be passed by reference");
3105
int zend_send_ref_handler(ZEND_OPCODE_HANDLER_ARGS)
3109
varptr_ptr = get_zval_ptr_ptr(&opline->op1, EX(Ts), BP_VAR_W);
3112
zend_error(E_ERROR, "Only variables can be passed by reference");
3115
SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr);
3116
varptr = *varptr_ptr;
3118
zend_ptr_stack_push(&EG(argument_stack), varptr);
3124
int zend_send_var_handler(ZEND_OPCODE_HANDLER_ARGS)
3126
if ((opline->extended_value == ZEND_DO_FCALL_BY_NAME)
3127
&& ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
3128
return zend_send_ref_handler(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3130
return zend_send_by_var_helper(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3134
int zend_recv_handler(ZEND_OPCODE_HANDLER_ARGS)
3137
zend_uint arg_num = opline->op1.u.constant.value.lval;
3139
if (zend_ptr_stack_get_arg(arg_num, (void **) ¶m TSRMLS_CC)==FAILURE) {
3141
char *class_name = get_active_class_name(&space TSRMLS_CC);
3142
zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, NULL TSRMLS_CC);
3143
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));
3144
if (opline->result.op_type == IS_VAR) {
3145
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
3148
zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, *param TSRMLS_CC);
3149
if (PZVAL_IS_REF(*param)) {
3150
zend_assign_to_variable_reference(NULL, get_zval_ptr_ptr(&opline->result, EX(Ts), BP_VAR_W), param, NULL TSRMLS_CC);
3152
zend_assign_to_variable(NULL, &opline->result, NULL, *param, IS_VAR, EX(Ts) TSRMLS_CC);
3160
int zend_recv_init_handler(ZEND_OPCODE_HANDLER_ARGS)
3162
zval **param, *assignment_value;
3163
zend_uint arg_num = opline->op1.u.constant.value.lval;
3165
if (zend_ptr_stack_get_arg(arg_num, (void **) ¶m TSRMLS_CC)==FAILURE) {
3166
if (opline->op2.u.constant.type == IS_CONSTANT || opline->op2.u.constant.type==IS_CONSTANT_ARRAY) {
3167
zval *default_value;
3169
ALLOC_ZVAL(default_value);
3170
*default_value = opline->op2.u.constant;
3171
if (opline->op2.u.constant.type==IS_CONSTANT_ARRAY) {
3172
zval_copy_ctor(default_value);
3174
default_value->refcount=1;
3175
zval_update_constant(&default_value, 0 TSRMLS_CC);
3176
default_value->refcount=0;
3177
default_value->is_ref=0;
3178
param = &default_value;
3179
assignment_value = default_value;
3182
assignment_value = &opline->op2.u.constant;
3184
zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, assignment_value TSRMLS_CC);
3185
zend_assign_to_variable(NULL, &opline->result, NULL, assignment_value, IS_VAR, EX(Ts) TSRMLS_CC);
3187
assignment_value = *param;
3188
zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, assignment_value TSRMLS_CC);
3189
if (PZVAL_IS_REF(assignment_value)) {
3190
zend_assign_to_variable_reference(NULL, get_zval_ptr_ptr(&opline->result, EX(Ts), BP_VAR_W), param, NULL TSRMLS_CC);
3192
zend_assign_to_variable(NULL, &opline->result, NULL, assignment_value, IS_VAR, EX(Ts) TSRMLS_CC);
3200
int zend_bool_handler(ZEND_OPCODE_HANDLER_ARGS)
3202
/* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
3203
EX_T(opline->result.u.var).tmp_var.value.lval = zend_is_true(get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R));
3204
EX_T(opline->result.u.var).tmp_var.type = IS_BOOL;
3205
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
3211
static inline int zend_brk_cont_helper(ZEND_OPCODE_HANDLER_ARGS)
3213
zval *nest_levels_zval = get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R);
3215
int array_offset, nest_levels, original_nest_levels;
3216
zend_brk_cont_element *jmp_to;
3218
if (nest_levels_zval->type != IS_LONG) {
3219
tmp = *nest_levels_zval;
3220
zval_copy_ctor(&tmp);
3221
convert_to_long(&tmp);
3222
nest_levels = tmp.value.lval;
3224
nest_levels = nest_levels_zval->value.lval;
3226
original_nest_levels = nest_levels;
3227
array_offset = opline->op1.u.opline_num;
3229
if (array_offset==-1) {
3230
zend_error(E_ERROR, "Cannot break/continue %d level%s", original_nest_levels, (original_nest_levels == 1) ? "" : "s");
3232
jmp_to = &op_array->brk_cont_array[array_offset];
3233
if (nest_levels>1) {
3234
zend_op *brk_opline = &op_array->opcodes[jmp_to->brk];
3236
switch (brk_opline->opcode) {
3237
case ZEND_SWITCH_FREE:
3238
zend_switch_free(brk_opline, EX(Ts) TSRMLS_CC);
3241
zendi_zval_dtor(EX_T(brk_opline->op1.u.var).tmp_var);
3245
array_offset = jmp_to->parent;
3246
} while (--nest_levels > 0);
3248
if (opline->opcode == ZEND_BRK) {
3249
SET_OPCODE(op_array->opcodes+jmp_to->brk);
3251
SET_OPCODE(op_array->opcodes+jmp_to->cont);
3253
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
3254
return 0; /* CHECK_ME */
3258
int zend_brk_handler(ZEND_OPCODE_HANDLER_ARGS)
3260
return zend_brk_cont_helper(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3264
int zend_cont_handler(ZEND_OPCODE_HANDLER_ARGS)
3266
return zend_brk_cont_helper(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3270
int zend_case_handler(ZEND_OPCODE_HANDLER_ARGS)
3272
int switch_expr_is_overloaded=0;
3274
if (opline->op1.op_type==IS_VAR) {
3275
if (EX_T(opline->op1.u.var).var.ptr_ptr) {
3276
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
3278
switch_expr_is_overloaded = 1;
3279
EX_T(opline->op1.u.var).str_offset.str->refcount++;
3282
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
3283
get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R),
3284
get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC);
3286
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
3287
if (switch_expr_is_overloaded) {
3288
/* We only free op1 if this is a string offset,
3289
* Since if it is a TMP_VAR, it'll be reused by
3290
* other CASE opcodes (whereas string offsets
3291
* are allocated at each get_zval_ptr())
3293
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
3294
EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
3295
AI_USE_PTR(EX_T(opline->op1.u.var).var);
3301
int zend_switch_free_handler(ZEND_OPCODE_HANDLER_ARGS)
3303
zend_switch_free(opline, EX(Ts) TSRMLS_CC);
3308
int zend_new_handler(ZEND_OPCODE_HANDLER_ARGS)
3310
if (EX_T(opline->op1.u.var).class_entry->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) {
3313
if (EX_T(opline->op1.u.var).class_entry->ce_flags & ZEND_ACC_INTERFACE) {
3314
class_type = "interface";
3316
class_type = "abstract class";
3318
zend_error(E_ERROR, "Cannot instantiate %s %s", class_type, EX_T(opline->op1.u.var).class_entry->name);
3320
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
3321
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
3322
object_init_ex(EX_T(opline->result.u.var).var.ptr, EX_T(opline->op1.u.var).class_entry);
3323
EX_T(opline->result.u.var).var.ptr->refcount=1;
3324
EX_T(opline->result.u.var).var.ptr->is_ref=0;
3330
int zend_clone_handler(ZEND_OPCODE_HANDLER_ARGS)
3332
zval *obj = get_obj_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R TSRMLS_CC);
3333
zend_class_entry *ce;
3334
zend_function *clone;
3335
zend_object_clone_obj_t clone_call;
3337
if (!obj || Z_TYPE_P(obj) != IS_OBJECT) {
3338
zend_error(E_WARNING, "__clone method called on non-object");
3339
EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
3340
EX_T(opline->result.u.var).var.ptr->refcount++;
3344
ce = (Z_OBJ_HT_P(obj)->get_class_entry) ? Z_OBJCE_P(obj) : NULL;
3345
clone = ce ? ce->clone : NULL;
3346
clone_call = Z_OBJ_HT_P(obj)->clone_obj;
3348
zend_error(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
3349
EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
3350
EX_T(opline->result.u.var).var.ptr->refcount++;
3354
if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
3355
/* Ensure that if we're calling a private function, we're allowed to do so.
3357
if (ce != EG(scope)) {
3358
zend_error(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
3360
} else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
3361
/* Ensure that if we're calling a protected function, we're allowed to do so.
3363
if (!zend_check_protected(clone->common.scope, EG(scope))) {
3364
zend_error(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
3369
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
3370
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
3371
EX_T(opline->result.u.var).var.ptr->value.obj = clone_call(obj TSRMLS_CC);
3372
if (EG(exception)) {
3373
FREE_ZVAL(EX_T(opline->result.u.var).var.ptr);
3375
EX_T(opline->result.u.var).var.ptr->type = IS_OBJECT;
3376
EX_T(opline->result.u.var).var.ptr->refcount=1;
3377
EX_T(opline->result.u.var).var.ptr->is_ref=1;
3383
int zend_fetch_constant_handler(ZEND_OPCODE_HANDLER_ARGS)
3385
zend_class_entry *ce = NULL;
3388
if (opline->op1.op_type == IS_UNUSED) {
3389
/* This seems to be a reminant of namespaces
3392
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) {
3393
zval_update_constant(value, (void *) 1 TSRMLS_CC);
3394
EX_T(opline->result.u.var).tmp_var = **value;
3395
zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
3400
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)) {
3401
zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",
3402
opline->op2.u.constant.value.str.val,
3403
opline->op2.u.constant.value.str.val);
3404
EX_T(opline->result.u.var).tmp_var = opline->op2.u.constant;
3405
zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
3410
ce = EX_T(opline->op1.u.var).class_entry;
3412
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) {
3413
zval_update_constant(value, (void *) 1 TSRMLS_CC);
3414
EX_T(opline->result.u.var).tmp_var = **value;
3415
zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
3417
zend_error(E_ERROR, "Undefined class constant '%s'", opline->op2.u.constant.value.str.val);
3424
static inline int zend_init_add_array_helper(ZEND_OPCODE_HANDLER_ARGS)
3426
zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
3427
zval *expr_ptr, **expr_ptr_ptr = NULL;
3428
zval *offset=get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R);
3430
if (opline->extended_value) {
3431
expr_ptr_ptr=get_zval_ptr_ptr(&opline->op1, EX(Ts), BP_VAR_R);
3432
expr_ptr = *expr_ptr_ptr;
3434
expr_ptr=get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R);
3437
if (opline->opcode == ZEND_INIT_ARRAY) {
3438
array_init(array_ptr);
3443
if (!opline->extended_value && EG(free_op1)) { /* temporary variable */
3446
ALLOC_ZVAL(new_expr);
3447
*new_expr = *expr_ptr;
3448
expr_ptr = new_expr;
3449
INIT_PZVAL(expr_ptr);
3451
if (opline->extended_value) {
3452
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
3453
expr_ptr = *expr_ptr_ptr;
3454
expr_ptr->refcount++;
3455
} else if (PZVAL_IS_REF(expr_ptr)) {
3458
ALLOC_ZVAL(new_expr);
3459
*new_expr = *expr_ptr;
3460
expr_ptr = new_expr;
3461
zendi_zval_copy_ctor(*expr_ptr);
3462
INIT_PZVAL(expr_ptr);
3464
expr_ptr->refcount++;
3468
switch (offset->type) {
3470
zend_hash_index_update(array_ptr->value.ht, (long) offset->value.dval, &expr_ptr, sizeof(zval *), NULL);
3474
zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
3477
zend_symtable_update(array_ptr->value.ht, offset->value.str.val, offset->value.str.len+1, &expr_ptr, sizeof(zval *), NULL);
3480
zend_hash_update(array_ptr->value.ht, "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
3483
zend_error(E_WARNING, "Illegal offset type");
3484
zval_ptr_dtor(&expr_ptr);
3488
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
3490
zend_hash_next_index_insert(array_ptr->value.ht, &expr_ptr, sizeof(zval *), NULL);
3496
int zend_init_array_handler(ZEND_OPCODE_HANDLER_ARGS)
3498
return zend_init_add_array_helper(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3502
int zend_add_array_element_handler(ZEND_OPCODE_HANDLER_ARGS)
3504
return zend_init_add_array_helper(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3508
int zend_cast_handler(ZEND_OPCODE_HANDLER_ARGS)
3510
zval *expr = get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R);
3511
zval *result = &EX_T(opline->result.u.var).tmp_var;
3514
if (!EG(free_op1)) {
3515
zendi_zval_copy_ctor(*result);
3517
switch (opline->extended_value) {
3519
convert_to_null(result);
3522
convert_to_boolean(result);
3525
convert_to_long(result);
3528
convert_to_double(result);
3534
zend_make_printable_zval(result, &var_copy, &use_copy);
3542
convert_to_array(result);
3545
convert_to_object(result);
3552
int zend_include_or_eval_handler(ZEND_OPCODE_HANDLER_ARGS)
3554
zend_op_array *new_op_array=NULL;
3555
zval **original_return_value = EG(return_value_ptr_ptr);
3556
int return_value_used;
3557
zval *inc_filename = get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R);
3558
zval tmp_inc_filename;
3559
zend_bool failure_retval=0;
3561
if (inc_filename->type!=IS_STRING) {
3562
tmp_inc_filename = *inc_filename;
3563
zval_copy_ctor(&tmp_inc_filename);
3564
convert_to_string(&tmp_inc_filename);
3565
inc_filename = &tmp_inc_filename;
3568
return_value_used = RETURN_VALUE_USED(opline);
3570
switch (opline->op2.u.constant.value.lval) {
3571
case ZEND_INCLUDE_ONCE:
3572
case ZEND_REQUIRE_ONCE: {
3574
zend_file_handle file_handle;
3576
if (SUCCESS == zend_stream_open(inc_filename->value.str.val, &file_handle TSRMLS_CC)) {
3578
if (!file_handle.opened_path) {
3579
file_handle.opened_path = estrndup(inc_filename->value.str.val, inc_filename->value.str.len);
3582
if (zend_hash_add(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1, (void *)&dummy, sizeof(int), NULL)==SUCCESS) {
3583
new_op_array = zend_compile_file(&file_handle, (opline->op2.u.constant.value.lval==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
3584
zend_destroy_file_handle(&file_handle TSRMLS_CC);
3586
zend_file_handle_dtor(&file_handle);
3590
if (opline->op2.u.constant.value.lval==ZEND_INCLUDE_ONCE) {
3591
zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, inc_filename->value.str.val);
3593
zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, inc_filename->value.str.val);
3601
new_op_array = compile_filename(opline->op2.u.constant.value.lval, inc_filename TSRMLS_CC);
3604
char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
3606
new_op_array = compile_string(inc_filename, eval_desc TSRMLS_CC);
3610
EMPTY_SWITCH_DEFAULT_CASE()
3612
if (inc_filename==&tmp_inc_filename) {
3613
zval_dtor(&tmp_inc_filename);
3615
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
3616
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
3619
zend_function *saved_function;
3621
EG(return_value_ptr_ptr) = EX_T(opline->result.u.var).var.ptr_ptr;
3622
EG(active_op_array) = new_op_array;
3623
EX_T(opline->result.u.var).var.ptr = NULL;
3625
saved_object = EX(object);
3626
saved_function = EX(function_state).function;
3628
EX(function_state).function = (zend_function *) new_op_array;
3631
zend_execute(new_op_array TSRMLS_CC);
3633
EX(function_state).function = saved_function;
3634
EX(object) = saved_object;
3636
if (!return_value_used) {
3637
if (EX_T(opline->result.u.var).var.ptr) {
3638
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
3640
} else { /* return value is used */
3641
if (!EX_T(opline->result.u.var).var.ptr) { /* there was no return statement */
3642
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
3643
INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
3644
EX_T(opline->result.u.var).var.ptr->value.lval = 1;
3645
EX_T(opline->result.u.var).var.ptr->type = IS_BOOL;
3649
EG(opline_ptr) = &EX(opline);
3650
EG(active_op_array) = op_array;
3651
EG(function_state_ptr) = &EX(function_state);
3652
destroy_op_array(new_op_array TSRMLS_CC);
3653
efree(new_op_array);
3654
if (EG(exception)) {
3655
zend_throw_exception_internal(NULL TSRMLS_CC);
3658
if (return_value_used) {
3659
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
3660
INIT_ZVAL(*EX_T(opline->result.u.var).var.ptr);
3661
EX_T(opline->result.u.var).var.ptr->value.lval = failure_retval;
3662
EX_T(opline->result.u.var).var.ptr->type = IS_BOOL;
3665
EG(return_value_ptr_ptr) = original_return_value;
3670
int zend_unset_var_handler(ZEND_OPCODE_HANDLER_ARGS)
3673
HashTable *target_symbol_table;
3675
varname = get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R);
3677
if (varname->type != IS_STRING) {
3679
zval_copy_ctor(&tmp);
3680
convert_to_string(&tmp);
3684
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
3685
zend_std_unset_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname) TSRMLS_CC);
3687
target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
3688
zend_hash_del(target_symbol_table, varname->value.str.val, varname->value.str.len+1);
3691
if (varname == &tmp) {
3694
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
3700
int zend_unset_dim_obj_handler(ZEND_OPCODE_HANDLER_ARGS)
3702
zval **container = get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
3703
zval *offset = get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R);
3707
if (opline->extended_value == ZEND_UNSET_DIM) {
3708
switch (Z_TYPE_PP(container)) {
3710
HashTable *ht = Z_ARRVAL_PP(container);
3711
switch (offset->type) {
3716
if (offset->type == IS_DOUBLE) {
3717
index = (long) offset->value.dval;
3719
index = offset->value.lval;
3722
zend_hash_index_del(ht, index);
3725
zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1);
3728
zend_hash_del(ht, "", sizeof(""));
3731
zend_error(E_WARNING, "Illegal offset type in unset");
3734
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
3738
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
3739
zend_error(E_ERROR, "Cannot use object as array");
3742
MAKE_REAL_ZVAL_PTR(offset);
3744
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
3746
zval_ptr_dtor(&offset);
3750
zend_error(E_ERROR, "Cannot unset string offsets");
3751
return 0; /* bailed out before */
3753
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
3756
} else { /* ZEND_UNSET_OBJ */
3757
if (Z_TYPE_PP(container) == IS_OBJECT) {
3759
MAKE_REAL_ZVAL_PTR(offset);
3761
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
3763
zval_ptr_dtor(&offset);
3768
/* overloaded element */
3769
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
3776
int zend_fe_reset_handler(ZEND_OPCODE_HANDLER_ARGS)
3778
zval *array_ptr, **array_ptr_ptr;
3780
zend_object_iterator *iter = NULL;
3781
zend_class_entry *ce = NULL;
3783
if (opline->extended_value) {
3784
array_ptr_ptr = get_zval_ptr_ptr(&opline->op1, EX(Ts), BP_VAR_R);
3785
if (array_ptr_ptr == NULL) {
3786
ALLOC_INIT_ZVAL(array_ptr);
3787
} else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
3788
if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
3789
zend_error(E_WARNING, "foreach() can not iterate over objects without PHP class");
3791
SET_OPCODE(op_array->opcodes+opline->op2.u.opline_num);
3794
ce = Z_OBJCE_PP(array_ptr_ptr);
3795
if (!ce || ce->get_iterator == NULL) {
3796
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
3797
(*array_ptr_ptr)->refcount++;
3799
array_ptr = *array_ptr_ptr;
3801
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
3802
array_ptr = *array_ptr_ptr;
3803
array_ptr->refcount++;
3806
array_ptr = get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R);
3807
if (EG(free_op1)) { /* IS_TMP_VAR */
3814
} else if (Z_TYPE_P(array_ptr) == IS_OBJECT && Z_OBJ_HT_P(array_ptr)->get_class_entry) {
3815
ce = Z_OBJCE_P(array_ptr);
3817
array_ptr->refcount++;
3821
if (ce && ce->get_iterator) {
3822
iter = ce->get_iterator(ce, array_ptr TSRMLS_CC);
3824
if (iter && !EG(exception)) {
3825
array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
3827
FREE_OP(Ts, op1, EG(free_op1));
3828
if (!EG(exception)) {
3829
zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
3831
zend_throw_exception_internal(NULL TSRMLS_CC);
3837
PZVAL_LOCK(array_ptr);
3838
EX_T(opline->result.u.var).var.ptr = array_ptr;
3839
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
3843
if (iter->funcs->rewind) {
3844
iter->funcs->rewind(iter TSRMLS_CC);
3845
if (EG(exception)) {
3846
array_ptr->refcount--;
3847
zval_ptr_dtor(&array_ptr);
3851
} else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
3852
/* probably redundant */
3853
zend_hash_internal_pointer_reset(fe_ht);
3855
zend_error(E_WARNING, "Invalid argument supplied for foreach()");
3858
SET_OPCODE(op_array->opcodes+opline->op2.u.opline_num);
3866
int zend_fe_fetch_handler(ZEND_OPCODE_HANDLER_ARGS)
3868
zval *array = get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R);
3869
zval *result = &EX_T(opline->result.u.var).tmp_var;
3875
zend_object_iterator *iter = NULL;
3880
switch (zend_iterator_unwrap(array, &iter TSRMLS_CC)) {
3882
case ZEND_ITER_INVALID:
3883
zend_error(E_WARNING, "Invalid argument supplied for foreach()");
3884
SET_OPCODE(op_array->opcodes+opline->op2.u.opline_num);
3885
return 0; /* CHECK_ME */
3887
case ZEND_ITER_PLAIN_OBJECT: {
3888
char *class_name, *prop_name;
3889
zend_object *zobj = zend_objects_get_address(array TSRMLS_CC);
3891
fe_ht = HASH_OF(array);
3893
if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) {
3894
/* reached end of iteration */
3895
SET_OPCODE(op_array->opcodes+opline->op2.u.opline_num);
3896
return 0; /* CHECK_ME */
3898
key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
3900
zend_hash_move_forward(fe_ht);
3901
} while (key_type != HASH_KEY_IS_STRING || zend_check_property_access(zobj, str_key TSRMLS_CC) != SUCCESS);
3902
zend_unmangle_property_name(str_key, &class_name, &prop_name);
3903
str_key_len = strlen(prop_name);
3904
str_key = estrndup(prop_name, str_key_len);
3909
case ZEND_ITER_PLAIN_ARRAY:
3910
fe_ht = HASH_OF(array);
3911
if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) {
3912
/* reached end of iteration */
3913
SET_OPCODE(op_array->opcodes+opline->op2.u.opline_num);
3914
return 0; /* CHECK_ME */
3916
key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 1, NULL);
3917
zend_hash_move_forward(fe_ht);
3920
case ZEND_ITER_OBJECT:
3921
/* !iter happens from exception */
3922
if (iter && iter->index++) {
3923
/* This could cause an endless loop if index becomes zero again.
3924
* In case that ever happens we need an additional flag. */
3925
iter->funcs->move_forward(iter TSRMLS_CC);
3926
if (EG(exception)) {
3928
zval_ptr_dtor(&array);
3932
if (!iter || iter->funcs->valid(iter TSRMLS_CC) == FAILURE) {
3933
/* reached end of iteration */
3934
if (EG(exception)) {
3936
zval_ptr_dtor(&array);
3939
SET_OPCODE(op_array->opcodes+opline->op2.u.opline_num);
3940
return 0; /* CHECK_ME */
3942
iter->funcs->get_current_data(iter, &value TSRMLS_CC);
3943
if (EG(exception)) {
3945
zval_ptr_dtor(&array);
3949
/* failure in get_current_data */
3950
SET_OPCODE(op_array->opcodes+opline->op2.u.opline_num);
3951
return 0; /* CHECK_ME */
3953
if (iter->funcs->get_current_key) {
3954
key_type = iter->funcs->get_current_key(iter, &str_key, &str_key_len, &int_key TSRMLS_CC);
3955
if (EG(exception)) {
3957
zval_ptr_dtor(&array);
3961
key_type = HASH_KEY_IS_LONG;
3962
int_key = iter->index;
3970
if (opline->extended_value) {
3971
SEPARATE_ZVAL_IF_NOT_REF(value);
3972
(*value)->is_ref = 1;
3974
(*value)->refcount++;
3975
zend_hash_index_update(result->value.ht, 0, value, sizeof(zval *), NULL);
3981
case HASH_KEY_IS_STRING:
3982
key->value.str.val = str_key;
3983
key->value.str.len = str_key_len-1;
3984
key->type = IS_STRING;
3986
case HASH_KEY_IS_LONG:
3987
key->value.lval = int_key;
3988
key->type = IS_LONG;
3990
EMPTY_SWITCH_DEFAULT_CASE()
3992
zend_hash_index_update(result->value.ht, 1, &key, sizeof(zval *), NULL);
3998
int zend_jmp_no_ctor_handler(ZEND_OPCODE_HANDLER_ARGS)
4001
zend_function *constructor;
4003
if (opline->op1.op_type == IS_VAR) {
4004
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
4007
object_zval = get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R);
4008
constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC);
4010
EX(fbc_constructor) = NULL;
4011
if (constructor == NULL) {
4012
if(opline->op1.u.EA.type & EXT_TYPE_UNUSED) {
4013
zval_ptr_dtor(EX_T(opline->op1.u.var).var.ptr_ptr);
4015
SET_OPCODE(op_array->opcodes + opline->op2.u.opline_num);
4016
return 0; /* CHECK_ME */
4018
EX(fbc_constructor) = constructor;
4025
int zend_isset_isempty_var_handler(ZEND_OPCODE_HANDLER_ARGS)
4027
zval tmp, *varname = get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R);
4029
zend_bool isset = 1;
4030
HashTable *target_symbol_table;
4032
if (varname->type != IS_STRING) {
4034
zval_copy_ctor(&tmp);
4035
convert_to_string(&tmp);
4039
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
4040
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);
4045
target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
4046
if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
4051
EX_T(opline->result.u.var).tmp_var.type = IS_BOOL;
4053
switch (opline->extended_value) {
4055
if (isset && Z_TYPE_PP(value) == IS_NULL) {
4056
EX_T(opline->result.u.var).tmp_var.value.lval = 0;
4058
EX_T(opline->result.u.var).tmp_var.value.lval = isset;
4062
if (!isset || !zend_is_true(*value)) {
4063
EX_T(opline->result.u.var).tmp_var.value.lval = 1;
4065
EX_T(opline->result.u.var).tmp_var.value.lval = 0;
4070
if (varname == &tmp) {
4073
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
4079
static int zend_isset_isempty_dim_prop_obj_handler(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
4081
zval **container = get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
4082
zval **value = NULL;
4087
zval *offset = get_zval_ptr(&opline->op2, EX(Ts), &EG(free_op2), BP_VAR_R);
4089
if ((*container)->type == IS_ARRAY) {
4093
ht = (*container)->value.ht;
4095
switch (offset->type) {
4100
if (offset->type == IS_DOUBLE) {
4101
index = (long) offset->value.dval;
4103
index = offset->value.lval;
4105
if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
4110
if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
4115
if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
4120
zend_error(E_WARNING, "Illegal offset type in unset");
4125
switch (opline->extended_value) {
4127
if (isset && Z_TYPE_PP(value) == IS_NULL) {
4134
if (!isset || !zend_is_true(*value)) {
4141
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
4142
} else if ((*container)->type == IS_OBJECT) {
4144
MAKE_REAL_ZVAL_PTR(offset);
4147
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
4149
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
4152
zval_ptr_dtor(&offset);
4154
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
4157
if (offset->type != IS_LONG) {
4159
zval_copy_ctor(&tmp);
4160
convert_to_long(&tmp);
4163
switch (opline->extended_value) {
4165
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
4170
if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
4175
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
4177
FREE_OP(EX(Ts), &opline->op2, EG(free_op2));
4181
EX_T(opline->result.u.var).tmp_var.type = IS_BOOL;
4183
switch (opline->extended_value) {
4185
EX_T(opline->result.u.var).tmp_var.value.lval = result;
4188
EX_T(opline->result.u.var).tmp_var.value.lval = !result;
4196
int zend_isset_isempty_dim_obj_handler(ZEND_OPCODE_HANDLER_ARGS)
4198
return zend_isset_isempty_dim_prop_obj_handler(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4202
int zend_isset_isempty_prop_obj_handler(ZEND_OPCODE_HANDLER_ARGS)
4204
return zend_isset_isempty_dim_prop_obj_handler(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4208
int zend_exit_handler(ZEND_OPCODE_HANDLER_ARGS)
4210
if (opline->op1.op_type != IS_UNUSED) {
4213
ptr = get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R);
4214
if (Z_TYPE_P(ptr) == IS_LONG) {
4215
EG(exit_status) = Z_LVAL_P(ptr);
4217
zend_print_variable(ptr);
4219
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
4226
int zend_begin_silence_handler(ZEND_OPCODE_HANDLER_ARGS)
4228
EX_T(opline->result.u.var).tmp_var.value.lval = EG(error_reporting);
4229
EX_T(opline->result.u.var).tmp_var.type = IS_LONG; /* shouldn't be necessary */
4230
zend_alter_ini_entry("error_reporting", sizeof("error_reporting"), "0", 1, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
4235
int zend_raise_abstract_error_handler(ZEND_OPCODE_HANDLER_ARGS)
4237
zend_error(E_ERROR, "Cannot call abstract method %s::%s()", EG(scope)->name, op_array->function_name);
4238
NEXT_OPCODE(); /* Never reached */
4242
int zend_end_silence_handler(ZEND_OPCODE_HANDLER_ARGS)
4244
zval restored_error_reporting;
4246
if (!EG(error_reporting)) {
4247
restored_error_reporting.type = IS_LONG;
4248
restored_error_reporting.value.lval = EX_T(opline->op1.u.var).tmp_var.value.lval;
4249
convert_to_string(&restored_error_reporting);
4250
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);
4251
zendi_zval_dtor(restored_error_reporting);
4257
int zend_qm_assign_handler(ZEND_OPCODE_HANDLER_ARGS)
4259
zval *value = get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R);
4261
EX_T(opline->result.u.var).tmp_var = *value;
4262
if (!EG(free_op1)) {
4263
zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
4269
int zend_ext_stmt_handler(ZEND_OPCODE_HANDLER_ARGS)
4271
if (!EG(no_extensions)) {
4272
zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_statement_handler, op_array TSRMLS_CC);
4278
int zend_ext_fcall_begin_handler(ZEND_OPCODE_HANDLER_ARGS)
4280
if (!EG(no_extensions)) {
4281
zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_begin_handler, op_array TSRMLS_CC);
4287
int zend_ext_fcall_end_handler(ZEND_OPCODE_HANDLER_ARGS)
4289
if (!EG(no_extensions)) {
4290
zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_end_handler, op_array TSRMLS_CC);
4296
int zend_declare_class_handler(ZEND_OPCODE_HANDLER_ARGS)
4298
EX_T(opline->result.u.var).class_entry = do_bind_class(opline, EG(class_table), 0 TSRMLS_CC);
4303
int zend_declare_inherited_class_handler(ZEND_OPCODE_HANDLER_ARGS)
4305
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);
4310
int zend_declare_function_handler(ZEND_OPCODE_HANDLER_ARGS)
4312
do_bind_function(opline, EG(function_table), 0);
4317
int zend_ticks_handler(ZEND_OPCODE_HANDLER_ARGS)
4319
if (++EG(ticks_count)>=opline->op1.u.constant.value.lval) {
4321
if (zend_ticks_function) {
4322
zend_ticks_function(opline->op1.u.constant.value.lval);
4329
int zend_instanceof_handler(ZEND_OPCODE_HANDLER_ARGS)
4331
zval *expr = get_zval_ptr(&opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R);
4334
if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) {
4335
result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.u.var).class_entry TSRMLS_CC);
4339
ZVAL_BOOL(&EX_T(opline->result.u.var).tmp_var, result);
4340
FREE_OP(EX(Ts), &opline->op1, EG(free_op1));
4345
int zend_ext_nop_handler(ZEND_OPCODE_HANDLER_ARGS)
4351
int zend_nop_handler(ZEND_OPCODE_HANDLER_ARGS)
4356
int zend_add_interface_handler(ZEND_OPCODE_HANDLER_ARGS)
4358
zend_class_entry *ce = EX_T(opline->op1.u.var).class_entry;
4359
zend_class_entry *iface = EX_T(opline->op2.u.var).class_entry;
4361
if (!(iface->ce_flags & ZEND_ACC_INTERFACE)) {
4362
zend_error(E_ERROR, "%s cannot implement %s - it is not an interface", ce->name, iface->name);
4365
ce->interfaces[opline->extended_value] = iface;
4367
zend_do_implement_interface(ce, iface TSRMLS_CC);
4373
int zend_handle_exception_handler(ZEND_OPCODE_HANDLER_ARGS)
4375
zend_uint op_num = EG(opline_before_exception)-EG(active_op_array)->opcodes;
4377
int encapsulating_block=-1;
4378
zval **stack_zval_pp;
4380
stack_zval_pp = (zval **) EG(argument_stack).top_element - 1;
4381
while (*stack_zval_pp != NULL) {
4382
zval_ptr_dtor(stack_zval_pp);
4383
EG(argument_stack).top_element--;
4384
EG(argument_stack).top--;
4388
for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
4389
if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
4390
/* further blocks will not be relevant... */
4393
if (op_num >= EG(active_op_array)->try_catch_array[i].try_op
4394
&& op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
4395
encapsulating_block = i;
4401
zval_ptr_dtor(&EX(object));
4403
zend_ptr_stack_n_pop(&EG(arg_types_stack), 3, &EX(calling_scope), &EX(object), &EX(fbc));
4406
if (encapsulating_block == -1) {
4407
RETURN_FROM_EXECUTE_LOOP(execute_data);
4409
SET_OPCODE(&op_array->opcodes[EG(active_op_array)->try_catch_array[encapsulating_block].catch_op]);
4415
int zend_verify_abstract_class_handler(ZEND_OPCODE_HANDLER_ARGS)
4417
zend_verify_abstract_class(EX_T(opline->op1.u.var).class_entry TSRMLS_CC);
4422
void zend_init_opcodes_handlers()
4424
memset(zend_opcode_handlers, 0, sizeof(zend_opcode_handlers));
4425
zend_opcode_handlers[ZEND_NOP] = zend_nop_handler;
4426
zend_opcode_handlers[ZEND_ADD] = zend_add_handler;
4427
zend_opcode_handlers[ZEND_SUB] = zend_sub_handler;
4428
zend_opcode_handlers[ZEND_MUL] = zend_mul_handler;
4429
zend_opcode_handlers[ZEND_DIV] = zend_div_handler;
4430
zend_opcode_handlers[ZEND_MOD] = zend_mod_handler;
4431
zend_opcode_handlers[ZEND_SL] = zend_sl_handler;
4432
zend_opcode_handlers[ZEND_SR] = zend_sr_handler;
4433
zend_opcode_handlers[ZEND_CONCAT] = zend_concat_handler;
4434
zend_opcode_handlers[ZEND_BW_OR] = zend_bw_or_handler;
4435
zend_opcode_handlers[ZEND_BW_AND] = zend_bw_and_handler;
4436
zend_opcode_handlers[ZEND_BW_XOR] = zend_bw_xor_handler;
4437
zend_opcode_handlers[ZEND_BW_NOT] = zend_bw_not_handler;
4438
zend_opcode_handlers[ZEND_BOOL_NOT] = zend_bool_not_handler;
4439
zend_opcode_handlers[ZEND_BOOL_XOR] = zend_bool_xor_handler;
4440
zend_opcode_handlers[ZEND_IS_IDENTICAL] = zend_is_identical_handler;
4441
zend_opcode_handlers[ZEND_IS_NOT_IDENTICAL] = zend_is_not_identical_handler;
4442
zend_opcode_handlers[ZEND_IS_EQUAL] = zend_is_equal_handler;
4443
zend_opcode_handlers[ZEND_IS_NOT_EQUAL] = zend_is_not_equal_handler;
4444
zend_opcode_handlers[ZEND_IS_SMALLER] = zend_is_smaller_handler;
4445
zend_opcode_handlers[ZEND_IS_SMALLER_OR_EQUAL] = zend_is_smaller_or_equal_handler;
4446
zend_opcode_handlers[ZEND_CAST] = zend_cast_handler;
4447
zend_opcode_handlers[ZEND_QM_ASSIGN] = zend_qm_assign_handler;
4449
zend_opcode_handlers[ZEND_ASSIGN_ADD] = zend_assign_add_handler;
4450
zend_opcode_handlers[ZEND_ASSIGN_SUB] = zend_assign_sub_handler;
4451
zend_opcode_handlers[ZEND_ASSIGN_MUL] = zend_assign_mul_handler;
4452
zend_opcode_handlers[ZEND_ASSIGN_DIV] = zend_assign_div_handler;
4453
zend_opcode_handlers[ZEND_ASSIGN_MOD] = zend_assign_mod_handler;
4454
zend_opcode_handlers[ZEND_ASSIGN_SL] = zend_assign_sl_handler;
4455
zend_opcode_handlers[ZEND_ASSIGN_SR] = zend_assign_sr_handler;
4456
zend_opcode_handlers[ZEND_ASSIGN_CONCAT] = zend_assign_concat_handler;
4457
zend_opcode_handlers[ZEND_ASSIGN_BW_OR] = zend_assign_bw_or_handler;
4458
zend_opcode_handlers[ZEND_ASSIGN_BW_AND] = zend_assign_bw_and_handler;
4459
zend_opcode_handlers[ZEND_ASSIGN_BW_XOR] = zend_assign_bw_xor_handler;
4461
zend_opcode_handlers[ZEND_PRE_INC] = zend_pre_inc_handler;
4462
zend_opcode_handlers[ZEND_PRE_DEC] = zend_pre_dec_handler;
4463
zend_opcode_handlers[ZEND_POST_INC] = zend_post_inc_handler;
4464
zend_opcode_handlers[ZEND_POST_DEC] = zend_post_dec_handler;
4466
zend_opcode_handlers[ZEND_ASSIGN] = zend_assign_handler;
4467
zend_opcode_handlers[ZEND_ASSIGN_REF] = zend_assign_ref_handler;
4469
zend_opcode_handlers[ZEND_ECHO] = zend_echo_handler;
4470
zend_opcode_handlers[ZEND_PRINT] = zend_print_handler;
4472
zend_opcode_handlers[ZEND_JMP] = zend_jmp_handler;
4473
zend_opcode_handlers[ZEND_JMPZ] = zend_jmpz_handler;
4474
zend_opcode_handlers[ZEND_JMPNZ] = zend_jmpnz_handler;
4475
zend_opcode_handlers[ZEND_JMPZNZ] = zend_jmpznz_handler;
4476
zend_opcode_handlers[ZEND_JMPZ_EX] = zend_jmpz_ex_handler;
4477
zend_opcode_handlers[ZEND_JMPNZ_EX] = zend_jmpnz_ex_handler;
4478
zend_opcode_handlers[ZEND_CASE] = zend_case_handler;
4479
zend_opcode_handlers[ZEND_SWITCH_FREE] = zend_switch_free_handler;
4480
zend_opcode_handlers[ZEND_BRK] = zend_brk_handler;
4481
zend_opcode_handlers[ZEND_CONT] = zend_cont_handler;
4482
zend_opcode_handlers[ZEND_BOOL] = zend_bool_handler;
4484
zend_opcode_handlers[ZEND_INIT_STRING] = zend_init_string_handler;
4485
zend_opcode_handlers[ZEND_ADD_CHAR] = zend_add_char_handler;
4486
zend_opcode_handlers[ZEND_ADD_STRING] = zend_add_string_handler;
4487
zend_opcode_handlers[ZEND_ADD_VAR] = zend_add_var_handler;
4489
zend_opcode_handlers[ZEND_BEGIN_SILENCE] = zend_begin_silence_handler;
4490
zend_opcode_handlers[ZEND_END_SILENCE] = zend_end_silence_handler;
4492
zend_opcode_handlers[ZEND_INIT_FCALL_BY_NAME] = zend_init_fcall_by_name_handler;
4493
zend_opcode_handlers[ZEND_DO_FCALL] = zend_do_fcall_handler;
4494
zend_opcode_handlers[ZEND_DO_FCALL_BY_NAME] = zend_do_fcall_by_name_handler;
4495
zend_opcode_handlers[ZEND_RETURN] = zend_return_handler;
4497
zend_opcode_handlers[ZEND_RECV] = zend_recv_handler;
4498
zend_opcode_handlers[ZEND_RECV_INIT] = zend_recv_init_handler;
4500
zend_opcode_handlers[ZEND_SEND_VAL] = zend_send_val_handler;
4501
zend_opcode_handlers[ZEND_SEND_VAR] = zend_send_var_handler;
4502
zend_opcode_handlers[ZEND_SEND_REF] = zend_send_ref_handler;
4504
zend_opcode_handlers[ZEND_NEW] = zend_new_handler;
4505
zend_opcode_handlers[ZEND_JMP_NO_CTOR] = zend_jmp_no_ctor_handler;
4506
zend_opcode_handlers[ZEND_FREE] = zend_free_handler;
4508
zend_opcode_handlers[ZEND_INIT_ARRAY] = zend_init_array_handler;
4509
zend_opcode_handlers[ZEND_ADD_ARRAY_ELEMENT] = zend_add_array_element_handler;
4511
zend_opcode_handlers[ZEND_INCLUDE_OR_EVAL] = zend_include_or_eval_handler;
4513
zend_opcode_handlers[ZEND_UNSET_VAR] = zend_unset_var_handler;
4514
zend_opcode_handlers[ZEND_UNSET_DIM_OBJ] = zend_unset_dim_obj_handler;
4516
zend_opcode_handlers[ZEND_FE_RESET] = zend_fe_reset_handler;
4517
zend_opcode_handlers[ZEND_FE_FETCH] = zend_fe_fetch_handler;
4519
zend_opcode_handlers[ZEND_EXIT] = zend_exit_handler;
4521
zend_opcode_handlers[ZEND_FETCH_R] = zend_fetch_r_handler;
4522
zend_opcode_handlers[ZEND_FETCH_DIM_R] = zend_fetch_dim_r_handler;
4523
zend_opcode_handlers[ZEND_FETCH_OBJ_R] = zend_fetch_obj_r_handler;
4524
zend_opcode_handlers[ZEND_FETCH_W] = zend_fetch_w_handler;
4525
zend_opcode_handlers[ZEND_FETCH_DIM_W] = zend_fetch_dim_w_handler;
4526
zend_opcode_handlers[ZEND_FETCH_OBJ_W] = zend_fetch_obj_w_handler;
4527
zend_opcode_handlers[ZEND_FETCH_RW] = zend_fetch_rw_handler;
4528
zend_opcode_handlers[ZEND_FETCH_DIM_RW] = zend_fetch_dim_rw_handler;
4529
zend_opcode_handlers[ZEND_FETCH_OBJ_RW] = zend_fetch_obj_rw_handler;
4530
zend_opcode_handlers[ZEND_FETCH_IS] = zend_fetch_is_handler;
4531
zend_opcode_handlers[ZEND_FETCH_DIM_IS] = zend_fetch_dim_is_handler;
4532
zend_opcode_handlers[ZEND_FETCH_OBJ_IS] = zend_fetch_obj_is_handler;
4533
zend_opcode_handlers[ZEND_FETCH_FUNC_ARG] = zend_fetch_func_arg_handler;
4534
zend_opcode_handlers[ZEND_FETCH_DIM_FUNC_ARG] = zend_fetch_dim_func_arg_handler;
4535
zend_opcode_handlers[ZEND_FETCH_OBJ_FUNC_ARG] = zend_fetch_obj_func_arg_handler;
4536
zend_opcode_handlers[ZEND_FETCH_UNSET] = zend_fetch_unset_handler;
4537
zend_opcode_handlers[ZEND_FETCH_DIM_UNSET] = zend_fetch_dim_unset_handler;
4538
zend_opcode_handlers[ZEND_FETCH_OBJ_UNSET] = zend_fetch_obj_unset_handler;
4540
zend_opcode_handlers[ZEND_FETCH_DIM_TMP_VAR] = zend_fetch_dim_tmp_var_handler;
4541
zend_opcode_handlers[ZEND_FETCH_CONSTANT] = zend_fetch_constant_handler;
4543
zend_opcode_handlers[ZEND_EXT_STMT] = zend_ext_stmt_handler;
4544
zend_opcode_handlers[ZEND_EXT_FCALL_BEGIN] = zend_ext_fcall_begin_handler;
4545
zend_opcode_handlers[ZEND_EXT_FCALL_END] = zend_ext_fcall_end_handler;
4546
zend_opcode_handlers[ZEND_EXT_NOP] = zend_ext_nop_handler;
4548
zend_opcode_handlers[ZEND_TICKS] = zend_ticks_handler;
4550
zend_opcode_handlers[ZEND_SEND_VAR_NO_REF] = zend_send_var_no_ref_handler;
4552
zend_opcode_handlers[ZEND_CATCH] = zend_catch_handler;
4553
zend_opcode_handlers[ZEND_THROW] = zend_throw_handler;
4555
zend_opcode_handlers[ZEND_FETCH_CLASS] = zend_fetch_class_handler;
4557
zend_opcode_handlers[ZEND_CLONE] = zend_clone_handler;
4559
zend_opcode_handlers[ZEND_INIT_CTOR_CALL] = zend_init_ctor_call_handler;
4560
zend_opcode_handlers[ZEND_INIT_METHOD_CALL] = zend_init_method_call_handler;
4561
zend_opcode_handlers[ZEND_INIT_STATIC_METHOD_CALL] = zend_init_static_method_call_handler;
4563
zend_opcode_handlers[ZEND_ISSET_ISEMPTY_VAR] = zend_isset_isempty_var_handler;
4564
zend_opcode_handlers[ZEND_ISSET_ISEMPTY_DIM_OBJ] = zend_isset_isempty_dim_obj_handler;
4565
zend_opcode_handlers[ZEND_ISSET_ISEMPTY_PROP_OBJ] = zend_isset_isempty_prop_obj_handler;
4567
zend_opcode_handlers[ZEND_PRE_INC_OBJ] = zend_pre_inc_obj_handler;
4568
zend_opcode_handlers[ZEND_PRE_DEC_OBJ] = zend_pre_dec_obj_handler;
4569
zend_opcode_handlers[ZEND_POST_INC_OBJ] = zend_post_inc_obj_handler;
4570
zend_opcode_handlers[ZEND_POST_DEC_OBJ] = zend_post_dec_obj_handler;
4572
zend_opcode_handlers[ZEND_ASSIGN_OBJ] = zend_assign_obj_handler;
4573
zend_opcode_handlers[ZEND_OP_DATA] = NULL;
4575
zend_opcode_handlers[ZEND_INSTANCEOF] = zend_instanceof_handler;
4577
zend_opcode_handlers[ZEND_DECLARE_CLASS] = zend_declare_class_handler;
4578
zend_opcode_handlers[ZEND_DECLARE_INHERITED_CLASS] = zend_declare_inherited_class_handler;
4579
zend_opcode_handlers[ZEND_DECLARE_FUNCTION] = zend_declare_function_handler;
4581
zend_opcode_handlers[ZEND_RAISE_ABSTRACT_ERROR] = zend_raise_abstract_error_handler;
4583
zend_opcode_handlers[ZEND_ADD_INTERFACE] = zend_add_interface_handler;
4584
zend_opcode_handlers[ZEND_VERIFY_ABSTRACT_CLASS] = zend_verify_abstract_class_handler;
4586
zend_opcode_handlers[ZEND_ASSIGN_DIM] = zend_assign_dim_handler;
4588
zend_opcode_handlers[ZEND_HANDLE_EXCEPTION] = zend_handle_exception_handler;
4595
* indent-tabs-mode: t
added
removed
Zend/zend_execute.c
