AC_DEFUN(LIBZEND_OTHER_CHECKS,[
+PHP_ARG_WITH(zend-vm,[virtual machine dispatch method],
+[ --with-zend-vm=TYPE Sets virtual machine dispatch methos. Type is
+ one of "CALL" (default), "SWITCH" or "GOTO"], CALL, no)
+
+case $PHP_ZEND_VM in
+ SWITCH)
+ AC_DEFINE(ZEND_VM_KIND,ZEND_VM_KIND_SWITCH,[virtual machine dispatch method])
+ ;;
+ GOTO)
+ AC_DEFINE(ZEND_VM_KIND,ZEND_VM_KIND_GOTO,[virtual machine dispatch method])
+ ;;
+ *)
+ AC_DEFINE(ZEND_VM_KIND,ZEND_VM_KIND_CALL,[virtual machine dispatch method])
+ ;;
+esac
+
AC_ARG_ENABLE(maintainer-zts,
[ --enable-maintainer-zts Enable thread safety - for code maintainers only],[
ZEND_MAINTAINER_ZTS=$enableval
ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
zend_bool is_ref, int num_symbol_tables, ...);
+ZEND_API int delete_global_variable(char *name, int name_len TSRMLS_DC);
+
#define add_method(arg, key, method) add_assoc_function((arg), (key), (method))
ZEND_API ZEND_FUNCTION(display_disabled_function);
return (op_array->T)++ * sizeof(temp_variable);
}
+static int lookup_cv(zend_op_array *op_array, char* name, int name_len)
+{
+ int i = 0;
+ ulong hash_value = zend_inline_hash_func(name, name_len+1);
+
+ while (i < op_array->last_var) {
+ if (op_array->vars[i].hash_value == hash_value &&
+ op_array->vars[i].name_len == name_len &&
+ strcmp(op_array->vars[i].name, name) == 0) {
+ efree(name);
+ return i;
+ }
+ i++;
+ }
+ i = op_array->last_var;
+ op_array->last_var++;
+ if (op_array->last_var > op_array->size_var) {
+ op_array->size_var += 16; /* FIXME */
+ op_array->vars = erealloc(op_array->vars, op_array->size_var*sizeof(zend_compiled_variable));
+ }
+ op_array->vars[i].name = name; //estrndup(name, name_len);
+ op_array->vars[i].name_len = name_len;
+ op_array->vars[i].hash_value = hash_value;
+ return i;
+}
+
void zend_do_binary_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC)
{
}
}
-
void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar op TSRMLS_DC)
{
zend_op opline;
zend_op *opline_ptr;
zend_llist *fetch_list_ptr;
+ if (varname->op_type == IS_CONST && varname->u.constant.type == IS_STRING &&
+ !zend_is_auto_global(varname->u.constant.value.str.val, varname->u.constant.value.str.len TSRMLS_CC) &&
+ !(varname->u.constant.value.str.len == (sizeof("this")-1) &&
+ !memcmp(varname->u.constant.value.str.val, "this", sizeof("this")))) {
+ result->op_type = IS_CV;
+ result->u.var = lookup_cv(CG(active_op_array), varname->u.constant.value.str.val, varname->u.constant.value.str.len);
+ result->u.EA.type = 0;
+ return;
+ }
+
if (bp) {
opline_ptr = &opline;
init_op(opline_ptr TSRMLS_CC);
fetch_simple_variable_ex(result, varname, bp, ZEND_FETCH_W TSRMLS_CC);
}
-void zend_do_fetch_static_member(znode *class_znode TSRMLS_DC)
+void zend_do_fetch_static_member(znode *result, znode *class_znode TSRMLS_DC)
{
zend_llist *fetch_list_ptr;
zend_llist_element *le;
zend_op *opline_ptr;
+ zend_op opline;
zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
- le = fetch_list_ptr->head;
+ if (result->op_type == IS_CV) {
+ init_op(&opline TSRMLS_CC);
+
+ opline.opcode = ZEND_FETCH_W;
+ opline.result.op_type = IS_VAR;
+ opline.result.u.EA.type = 0;
+ opline.result.u.var = get_temporary_variable(CG(active_op_array));
+ opline.op1.op_type = IS_CONST;
+ opline.op1.u.constant.type = IS_STRING;
+ opline.op1.u.constant.value.str.val = estrdup(CG(active_op_array)->vars[result->u.var].name);
+ opline.op1.u.constant.value.str.len = CG(active_op_array)->vars[result->u.var].name_len;
+ SET_UNUSED(opline.op2);
+ opline.op2 = *class_znode;
+ opline.op2.u.EA.type = ZEND_FETCH_STATIC_MEMBER;
+ *result = opline.result;
+
+ zend_llist_add_element(fetch_list_ptr, &opline);
+ } else {
+ le = fetch_list_ptr->head;
- opline_ptr = (zend_op *)le->data;
- opline_ptr->op2 = *class_znode;
- opline_ptr->op2.u.EA.type = ZEND_FETCH_STATIC_MEMBER;
+ opline_ptr = (zend_op *)le->data;
+ if (opline_ptr->opcode != ZEND_FETCH_W && opline_ptr->op1.op_type == IS_CV) {
+ init_op(&opline TSRMLS_CC);
+ opline.opcode = ZEND_FETCH_W;
+ opline.result.op_type = IS_VAR;
+ opline.result.u.EA.type = 0;
+ opline.result.u.var = get_temporary_variable(CG(active_op_array));
+ opline.op1.op_type = IS_CONST;
+ opline.op1.u.constant.type = IS_STRING;
+ opline.op1.u.constant.value.str.val = estrdup(CG(active_op_array)->vars[opline_ptr->op1.u.var].name);
+ opline.op1.u.constant.value.str.len = CG(active_op_array)->vars[opline_ptr->op1.u.var].name_len;
+ SET_UNUSED(opline.op2);
+ opline.op2 = *class_znode;
+ opline.op2.u.EA.type = ZEND_FETCH_STATIC_MEMBER;
+ opline_ptr->op1 = opline.result;
+
+ zend_llist_prepend_element(fetch_list_ptr, &opline);
+ } else {
+ opline_ptr->op2 = *class_znode;
+ opline_ptr->op2.u.EA.type = ZEND_FETCH_STATIC_MEMBER;
+ }
+ }
}
void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC)
*result = opline->result;
}
-static void zend_lowercase_znode_if_const(znode *z)
-{
- if (z->op_type == IS_CONST) {
- zend_str_tolower(z->u.constant.value.str.val, z->u.constant.value.str.len);
- }
-}
-
void zend_do_free(znode *op1 TSRMLS_DC)
{
if (op1->op_type==IS_TMP_VAR) {
if (op == ZEND_SEND_VAR && zend_is_function_or_method_call(param)) {
/* Method call */
op = ZEND_SEND_VAR_NO_REF;
- } else if (op == ZEND_SEND_VAL && param->op_type == IS_VAR) {
+ } else if (op == ZEND_SEND_VAL && (param->op_type & (IS_VAR|IS_CV))) {
op = ZEND_SEND_VAR_NO_REF;
}
/* change to passing by reference */
switch (param->op_type) {
case IS_VAR:
+ case IS_CV:
op = ZEND_SEND_REF;
break;
default:
last_container = *expr;
switch (expr->op_type) {
case IS_VAR:
+ case IS_CV:
opline->opcode = ZEND_FETCH_DIM_R;
break;
case IS_TMP_VAR:
zend_check_writable_variable(variable);
- last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1];
+ if (variable->op_type == IS_CV) {
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+ opline->opcode = ZEND_UNSET_VAR;
+ opline->op1.op_type = IS_CONST;
+ opline->op1.u.constant.type = IS_STRING;
+ opline->op1.u.constant.value.str.len = CG(active_op_array)->vars[variable->u.var].name_len;
+ opline->op1.u.constant.value.str.val = estrdup(CG(active_op_array)->vars[variable->u.var].name);
+ SET_UNUSED(opline->op2);
+ opline->op2.u.EA.type = ZEND_FETCH_LOCAL;
+ SET_UNUSED(opline->result);
+ } else {
+ last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1];
- switch (last_op->opcode) {
- case ZEND_FETCH_UNSET:
- last_op->opcode = ZEND_UNSET_VAR;
- break;
- case ZEND_FETCH_DIM_UNSET:
- last_op->opcode = ZEND_UNSET_DIM_OBJ;
- last_op->extended_value = ZEND_UNSET_DIM;
- break;
- case ZEND_FETCH_OBJ_UNSET:
- last_op->opcode = ZEND_UNSET_DIM_OBJ;
- last_op->extended_value = ZEND_UNSET_OBJ;
- break;
+ switch (last_op->opcode) {
+ case ZEND_FETCH_UNSET:
+ last_op->opcode = ZEND_UNSET_VAR;
+ break;
+ case ZEND_FETCH_DIM_UNSET:
+ last_op->opcode = ZEND_UNSET_DIM_OBJ;
+ last_op->extended_value = ZEND_UNSET_DIM;
+ break;
+ case ZEND_FETCH_OBJ_UNSET:
+ last_op->opcode = ZEND_UNSET_DIM_OBJ;
+ last_op->extended_value = ZEND_UNSET_OBJ;
+ break;
- }
+ }
+ }
}
zend_check_writable_variable(variable);
- last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1];
+ if (variable->op_type == IS_CV) {
+ last_op = get_next_op(CG(active_op_array) TSRMLS_CC);
+ last_op->opcode = ZEND_ISSET_ISEMPTY_VAR;
+ last_op->op1.op_type = IS_CONST;
+ last_op->op1.u.constant.type = IS_STRING;
+ last_op->op1.u.constant.value.str.len = CG(active_op_array)->vars[variable->u.var].name_len;
+ last_op->op1.u.constant.value.str.val = estrdup(CG(active_op_array)->vars[variable->u.var].name);
+ SET_UNUSED(last_op->op2);
+ last_op->op2.u.EA.type = ZEND_FETCH_LOCAL;
+ } else {
+ last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1];
- switch (last_op->opcode) {
- case ZEND_FETCH_IS:
- last_op->opcode = ZEND_ISSET_ISEMPTY_VAR;
- break;
- case ZEND_FETCH_DIM_IS:
- last_op->opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ;
- break;
- case ZEND_FETCH_OBJ_IS:
- last_op->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ;
- break;
+ switch (last_op->opcode) {
+ case ZEND_FETCH_IS:
+ last_op->opcode = ZEND_ISSET_ISEMPTY_VAR;
+ break;
+ case ZEND_FETCH_DIM_IS:
+ last_op->opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ;
+ break;
+ case ZEND_FETCH_OBJ_IS:
+ last_op->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ;
+ break;
+ }
}
last_op->result.op_type = IS_TMP_VAR;
last_op->extended_value = type;
int required_num_args;
} zend_arg_info;
+typedef struct _zend_compiled_variable {
+ char *name;
+ int name_len;
+ ulong hash_value;
+} zend_compiled_variable;
+
struct _zend_op_array {
/* Common elements */
zend_uchar type;
zend_op *opcodes;
zend_uint last, size;
+ zend_compiled_variable *vars;
+ int last_var, size_var;
+
zend_uint T;
zend_brk_cont_element *brk_cont_array;
zend_op_array *op_array;
zval *object;
union _temp_variable *Ts;
+ zval ***CVs;
zend_bool original_in_execution;
zend_class_entry *calling_scope;
+ HashTable *symbol_table;
struct _zend_execute_data *prev_execute_data;
};
#define IS_TMP_VAR (1<<1)
#define IS_VAR (1<<2)
#define IS_UNUSED (1<<3) /* Unused variable */
+#define IS_CV (1<<4) /* Compiled variable */
#define EXT_TYPE_UNUSED (1<<0)
void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC);
void fetch_array_dim(znode *result, znode *parent, znode *dim TSRMLS_DC);
void fetch_string_offset(znode *result, znode *parent, znode *offset TSRMLS_DC);
-void zend_do_fetch_static_member(znode *class_znode TSRMLS_DC);
+void zend_do_fetch_static_member(znode *result, znode *class_znode TSRMLS_DC);
void zend_do_print(znode *result, znode *arg TSRMLS_DC);
void zend_do_echo(znode *arg TSRMLS_DC);
typedef int (*unary_op_type)(zval *, zval *);
typedef int (*incdec_t)(zval *);
-#define get_zval_ptr(node, Ts, should_free, type) _get_zval_ptr(node, Ts, should_free TSRMLS_CC)
-#define get_zval_ptr_ptr(node, Ts, should_free, type) _get_zval_ptr_ptr(node, Ts, should_free TSRMLS_CC)
-#define get_obj_zval_ptr(node, Ts, should_free, type) _get_obj_zval_ptr(node, Ts, should_free TSRMLS_CC)
-#define get_obj_zval_ptr_ptr(node, Ts, should_free, type) _get_obj_zval_ptr_ptr(node, Ts, should_free TSRMLS_CC)
+#define get_zval_ptr(node, Ts, should_free, type) _get_zval_ptr(node, Ts, should_free, type TSRMLS_CC)
+#define get_zval_ptr_ptr(node, Ts, should_free, type) _get_zval_ptr_ptr(node, Ts, should_free, type TSRMLS_CC)
+#define get_obj_zval_ptr(node, Ts, should_free, type) _get_obj_zval_ptr(node, Ts, should_free, type TSRMLS_CC)
+#define get_obj_zval_ptr_ptr(node, Ts, should_free, type) _get_obj_zval_ptr_ptr(node, Ts, should_free, type TSRMLS_CC)
/* Prototypes */
static void zend_extension_statement_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC);
/* End of zend_execute_locks.h */
-static inline zval *_get_zval_ptr(znode *node, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC)
+#define CV_OF(i) (EG(current_execute_data)->CVs[i])
+#define CV_DEF_OF(i) (EG(active_op_array)->vars[i])
+
+static inline void zend_get_cv_address(zend_compiled_variable *cv, zval ***ptr, temp_variable *Ts TSRMLS_DC)
+{
+ zval *new_zval = &EG(uninitialized_zval);
+
+ new_zval->refcount++;
+ zend_hash_quick_update(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, &new_zval, sizeof(zval *), (void **)ptr);
+}
+
+static inline zval *_get_zval_ptr(znode *node, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC)
{
/* should_free->is_var = 0; */
switch (node->op_type) {
should_free->var = 0;
return NULL;
break;
+ case IS_CV: {
+ zval ***ptr = &CV_OF(node->u.var);
+
+ should_free->var = 0;
+ if (!*ptr) {
+ zend_compiled_variable *cv = &CV_DEF_OF(node->u.var);
+ if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **)ptr)==FAILURE) {
+ switch (type) {
+ case BP_VAR_R:
+ zend_error(E_NOTICE, "Undefined variable: %s", cv->name);
+ /* break missing intentionally */
+ case BP_VAR_IS:
+ return &EG(uninitialized_zval);
+ break;
+ case BP_VAR_RW:
+ zend_error(E_NOTICE, "Undefined variable: %s", cv->name);
+ /* break missing intentionally */
+ case BP_VAR_W:
+ zend_get_cv_address(cv, ptr, Ts TSRMLS_CC);
+ break;
+ }
+ }
+ }
+ return **ptr;
+ break;
+ }
EMPTY_SWITCH_DEFAULT_CASE()
}
return NULL;
}
-static inline zval **_get_zval_ptr_ptr(znode *node, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC)
+static inline zval **_get_zval_ptr_ptr(znode *node, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC)
{
- if (node->op_type==IS_VAR) {
+ if (node->op_type == IS_CV) {
+ zval ***ptr = &CV_OF(node->u.var);
+
+ should_free->var = 0;
+ if (!*ptr) {
+ zend_compiled_variable *cv = &CV_DEF_OF(node->u.var);
+ if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **)ptr)==FAILURE) {
+ switch (type) {
+ case BP_VAR_R:
+ zend_error(E_NOTICE, "Undefined variable: %s", cv->name);
+ /* break missing intentionally */
+ case BP_VAR_IS:
+ return &EG(uninitialized_zval_ptr);
+ break;
+ case BP_VAR_RW:
+ zend_error(E_NOTICE, "Undefined variable: %s", cv->name);
+ /* break missing intentionally */
+ case BP_VAR_W:
+ zend_get_cv_address(cv, ptr, Ts TSRMLS_CC);
+ break;
+ }
+ }
+ }
+ return *ptr;
+ } else if (node->op_type == IS_VAR) {
if (T(node->u.var).var.ptr_ptr) {
PZVAL_UNLOCK(*T(node->u.var).var.ptr_ptr, should_free);
return T(node->u.var).var.ptr_ptr;
}
}
+static inline zval *_get_zval_ptr_cv(znode *node, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC)
+{
+ zval ***ptr = &CV_OF(node->u.var);
+
+ should_free->var = 0;
+ if (!*ptr) {
+ zend_compiled_variable *cv = &CV_DEF_OF(node->u.var);
+ if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **)ptr)==FAILURE) {
+ switch (type) {
+ case BP_VAR_R:
+ zend_error(E_NOTICE, "Undefined variable: %s", cv->name);
+ /* break missing intentionally */
+ case BP_VAR_IS:
+ return &EG(uninitialized_zval);
+ break;
+ case BP_VAR_RW:
+ zend_error(E_NOTICE, "Undefined variable: %s", cv->name);
+ /* break missing intentionally */
+ case BP_VAR_W:
+ zend_get_cv_address(cv, ptr, Ts TSRMLS_CC);
+ break;
+ }
+ }
+ }
+ return **ptr;
+}
+
static inline zval *_get_zval_ptr_unused(znode *node, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC)
{
return NULL;
return NULL;
}
+static inline zval **_get_zval_ptr_ptr_cv(znode *node, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC)
+{
+ zval ***ptr = &CV_OF(node->u.var);
+
+ should_free->var = 0;
+ if (!*ptr) {
+ zend_compiled_variable *cv = &CV_DEF_OF(node->u.var);
+ if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **)ptr)==FAILURE) {
+ switch (type) {
+ case BP_VAR_R:
+ zend_error(E_NOTICE, "Undefined variable: %s", cv->name);
+ /* break missing intentionally */
+ case BP_VAR_IS:
+ return &EG(uninitialized_zval_ptr);
+ break;
+ case BP_VAR_RW:
+ zend_error(E_NOTICE, "Undefined variable: %s", cv->name);
+ /* break missing intentionally */
+ case BP_VAR_W:
+ zend_get_cv_address(cv, ptr, Ts TSRMLS_CC);
+ break;
+ }
+ }
+ }
+ return *ptr;
+}
+
static inline zval *_get_obj_zval_ptr_const(znode *op, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC)
{
return _get_zval_ptr_const(op, Ts, should_free TSRMLS_CC);
return _get_zval_ptr_var(op, Ts, should_free TSRMLS_CC);
}
+static inline zval *_get_obj_zval_ptr_cv(znode *op, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC)
+{
+ return _get_zval_ptr_cv(op, Ts, should_free, type TSRMLS_CC);
+}
+
static inline zval *_get_obj_zval_ptr_unused(znode *op, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC)
{
if (EG(This)) {
return _get_zval_ptr_ptr_var(op, Ts, should_free TSRMLS_CC);
}
+static inline zval **_get_obj_zval_ptr_ptr_cv(znode *op, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC)
+{
+ return _get_zval_ptr_ptr_cv(op, Ts, should_free, type TSRMLS_CC);
+}
+
static inline zval **_get_obj_zval_ptr_ptr_unused(znode *op, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC)
{
if (EG(This)) {
}
}
-static inline zval **_get_obj_zval_ptr_ptr(znode *op, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC)
+static inline zval **_get_obj_zval_ptr_ptr(znode *op, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC)
{
if (op->op_type == IS_UNUSED) {
if (EG(This)) {
zend_error_noreturn(E_ERROR, "Using $this when not in object context");
}
}
- return _get_zval_ptr_ptr(op, Ts, should_free TSRMLS_CC);
+ return get_zval_ptr_ptr(op, Ts, should_free, type);
}
-static inline zval *_get_obj_zval_ptr(znode *op, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC)
+static inline zval *_get_obj_zval_ptr(znode *op, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC)
{
if (op->op_type == IS_UNUSED) {
if (EG(This)) {
zend_error_noreturn(E_ERROR, "Using $this when not in object context");
}
}
- return _get_zval_ptr(op, Ts, should_free TSRMLS_CC);
+ return get_zval_ptr(op, Ts, should_free, type);
}
case IS_CONST:
/* already a constant string */
break;
+ case IS_CV:
case IS_VAR:
tmp = *property_name;
zval_copy_ctor(&tmp);
if (value->type!=IS_STRING) {
tmp = *value;
- if (op2->op_type == IS_VAR) {
+ if (op2->op_type & (IS_VAR|IS_CV)) {
zval_copy_ctor(&tmp);
}
convert_to_string(&tmp);
variable_ptr->refcount--;
if (variable_ptr->refcount==0) {
switch (type) {
+ case IS_CV:
case IS_VAR:
/* break missing intentionally */
case IS_CONST:
}
} else { /* we need to split */
switch (type) {
+ case IS_CV:
case IS_VAR:
/* break missing intentionally */
case IS_CONST:
case IS_CONST:
/* already a constant string */
break;
+ case IS_CV:
case IS_VAR:
tmp = *prop_ptr;
zval_copy_ctor(&tmp);
} else {
EX(Ts) = (temp_variable *) safe_emalloc(sizeof(temp_variable), op_array->T, 0);
}
+ EX(CVs) = (zval***)do_alloca(sizeof(zval**) * op_array->last_var);
+ memset(EX(CVs), 0, sizeof(zval**) * op_array->last_var);
EX(op_array) = op_array;
EX(original_in_execution) = EG(in_execution);
+ EX(symbol_table) = EG(active_symbol_table);
EX(prev_execute_data) = EG(current_execute_data);
EG(current_execute_data) = &execute_data;
# undef ZEND_VM_NULL_LABEL
# undef ZEND_VM_SPEC_LABEL
# undef ZEND_VM_SPEC_NULL_LABEL
+# undef ZEND_VM_CONTINUE_LABEL
# include "zend_vm.h"
EX(Ts) = (temp_variable *) do_alloca(sizeof(temp_variable) * op_array->T);
} else {
EX(Ts) = (temp_variable *) safe_emalloc(sizeof(temp_variable), op_array->T, 0);
- }
+ }
+ EX(CVs) = (zval***)do_alloca(sizeof(zval**) * op_array->last_var);
+ memset(EX(CVs), 0, sizeof(zval**) * op_array->last_var);
EX(op_array) = op_array;
EX(original_in_execution) = EG(in_execution);
+ EX(symbol_table) = EG(active_symbol_table);
EX(prev_execute_data) = EG(current_execute_data);
EG(current_execute_data) = &execute_data;
_UNUSED_CODE, /* 5 */
_UNUSED_CODE, /* 6 */
_UNUSED_CODE, /* 7 */
- _UNUSED_CODE /* 8 = IS_UNUSED */
+ _UNUSED_CODE, /* 8 = IS_UNUSED */
+ _UNUSED_CODE, /* 9 */
+ _UNUSED_CODE, /* 10 */
+ _UNUSED_CODE, /* 11 */
+ _UNUSED_CODE, /* 12 */
+ _UNUSED_CODE, /* 13 */
+ _UNUSED_CODE, /* 14 */
+ _UNUSED_CODE, /* 15 */
+ _CV_CODE /* 16 = IS_CV */
};
- op->handler = zend_opcode_handlers[op->opcode * 16 + zend_vm_decode[op->op1.op_type] * 4 + zend_vm_decode[op->op2.op_type]];
+ op->handler = zend_opcode_handlers[op->opcode * 25 + zend_vm_decode[op->op1.op_type] * 5 + zend_vm_decode[op->op2.op_type]];
}
}
}
}
+ZEND_API int delete_global_variable(char *name, int name_len TSRMLS_DC)
+{
+ zend_execute_data *ex;
+
+ if (zend_symtable_del(&EG(symbol_table), name, name_len+1) == SUCCESS) {
+ for (ex = EG(current_execute_data); ex; ex = ex->prev_execute_data) {
+ if (ex->symbol_table == &EG(symbol_table)) {
+ int i;
+ for (i = 0; i < ex->op_array->last_var; i++) {
+ if (ex->op_array->vars[i].name_len == name_len &&
+ !memcmp(ex->op_array->vars[i].name, name, name_len)) {
+ ex->CVs[i] = NULL;
+ break;
+ }
+ }
+ }
+ }
+ return SUCCESS;
+ }
+ return FAILURE;
+}
/*
* Local variables:
;
static_member:
- fully_qualified_class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects { $$ = $3; zend_do_fetch_static_member(&$1 TSRMLS_CC); }
+ fully_qualified_class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects { $$ = $3; zend_do_fetch_static_member(&$$, &$1 TSRMLS_CC); }
;
op_array->opcodes = NULL;
op_array_alloc_ops(op_array);
+ op_array->size_var = 0; /* FIXME:??? */
+ op_array->last_var = 0;
+ op_array->vars = NULL;
+
op_array->T = 0;
op_array->function_name = NULL;
efree(op_array->refcount);
+ if (op_array->vars) {
+ i = op_array->last_var;
+ while (i > 0) {
+ i--;
+ efree(op_array->vars[i].name);
+ }
+ efree(op_array->vars);
+ }
+
while (opline<end) {
if (opline->op1.op_type==IS_CONST) {
#if DEBUG_ZEND>2
#define _TMP_CODE 1
#define _VAR_CODE 2
#define _UNUSED_CODE 3
+#define _CV_CODE 4
#ifndef ZEND_VM_KIND
# ifdef __GNUC__
_UNUSED_CODE, /* 5 */
_UNUSED_CODE, /* 6 */
_UNUSED_CODE, /* 7 */
- _UNUSED_CODE /* 8 = IS_UNUSED */
+ _UNUSED_CODE, /* 8 = IS_UNUSED */
+ _UNUSED_CODE, /* 9 */
+ _UNUSED_CODE, /* 10 */
+ _UNUSED_CODE, /* 11 */
+ _UNUSED_CODE, /* 12 */
+ _UNUSED_CODE, /* 13 */
+ _UNUSED_CODE, /* 14 */
+ _UNUSED_CODE, /* 15 */
+ _CV_CODE /* 16 = IS_CV */
};
# define ZEND_VM_CODE(opcode, op1, op2) \
- opcode * 16 + op1 * 4 + op2
+ opcode * 25 + op1 * 5 + op2
# define ZEND_VM_SPEC_OPCODE(opcode, op1, op2) \
ZEND_VM_CODE(opcode, zend_vm_decode[op1], zend_vm_decode[op2])
# ifdef ZEND_VM_HAVE_OLD_EXECUTOR
}
# define ZEND_VM_RETURN_FROM_EXECUTE_LOOP() \
+ free_alloca(EX(CVs)); \
if (EX(op_array)->T < TEMP_VAR_STACK_LIMIT) { \
free_alloca(EX(Ts)); \
} else { \
}
# define ZEND_VM_RETURN_FROM_EXECUTE_LOOP() \
+ free_alloca(EX(CVs)); \
if (EX(op_array)->T < TEMP_VAR_STACK_LIMIT) { \
free_alloca(EX(Ts)); \
} else { \
}
# define ZEND_VM_RETURN_FROM_EXECUTE_LOOP() \
+ free_alloca(EX(CVs)); \
if (EX(op_array)->T < TEMP_VAR_STACK_LIMIT) { \
free_alloca(EX(Ts)); \
} else { \
# define OP1_TYPE_PREFIX _VAR
#elif OP1 == IS_UNUSED
# define OP1_TYPE_PREFIX _UNUSED
+#elif OP1 == IS_CV
+# define OP1_TYPE_PREFIX _CV
#elif OP1 == IS_ANY
# define OP1_TYPE_PREFIX _ANY
#else
# define OP2_TYPE_PREFIX _VAR
#elif OP2 == IS_UNUSED
# define OP2_TYPE_PREFIX _UNUSED
+#elif OP2 == IS_CV
+# define OP2_TYPE_PREFIX _CV
#elif OP2 == IS_ANY
# define OP2_TYPE_PREFIX _ANY
#else
/* opcode handlers and helpers */
-#define ZEND_ADD_SPEC() OPDEF(ZEND_ADD, M_CONST_TMP_VAR, M_CONST_TMP_VAR)
+#define ZEND_ADD_SPEC() OPDEF(ZEND_ADD, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_ADD)
ZEND_VM_HANDLER(ZEND_ADD)
{
}
#endif
-#define ZEND_SUB_SPEC() OPDEF(ZEND_SUB, M_CONST_TMP_VAR, M_CONST_TMP_VAR)
+#define ZEND_SUB_SPEC() OPDEF(ZEND_SUB, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_SUB)
ZEND_VM_HANDLER(ZEND_SUB)
{
}
#endif
-#define ZEND_MUL_SPEC() OPDEF(ZEND_MUL, M_CONST_TMP_VAR, M_CONST_TMP_VAR)
+#define ZEND_MUL_SPEC() OPDEF(ZEND_MUL, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_MUL)
ZEND_VM_HANDLER(ZEND_MUL)
{
}
#endif
-#define ZEND_DIV_SPEC() OPDEF(ZEND_DIV, M_CONST_TMP_VAR, M_CONST_TMP_VAR)
+#define ZEND_DIV_SPEC() OPDEF(ZEND_DIV, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_DIV)
ZEND_VM_HANDLER(ZEND_DIV)
{
}
#endif
-#define ZEND_MOD_SPEC() OPDEF(ZEND_MOD, M_CONST_TMP_VAR, M_CONST_TMP_VAR)
+#define ZEND_MOD_SPEC() OPDEF(ZEND_MOD, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_MOD)
ZEND_VM_HANDLER(ZEND_MOD)
{
}
#endif
-#define ZEND_SL_SPEC() OPDEF(ZEND_SL, M_CONST_TMP_VAR, M_CONST_TMP_VAR)
+#define ZEND_SL_SPEC() OPDEF(ZEND_SL, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_SL)
ZEND_VM_HANDLER(ZEND_SL)
{
}
#endif
-#define ZEND_SR_SPEC() OPDEF(ZEND_SR, M_CONST_TMP_VAR, M_CONST_TMP_VAR)
+#define ZEND_SR_SPEC() OPDEF(ZEND_SR, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_SR)
ZEND_VM_HANDLER(ZEND_SR)
{
}
#endif
-#define ZEND_CONCAT_SPEC() OPDEF(ZEND_CONCAT, M_CONST_TMP_VAR, M_CONST_TMP_VAR)
+#define ZEND_CONCAT_SPEC() OPDEF(ZEND_CONCAT, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_CONCAT)
ZEND_VM_HANDLER(ZEND_CONCAT)
{
}
#endif
-#define ZEND_IS_IDENTICAL_SPEC() OPDEF(ZEND_IS_IDENTICAL, M_CONST_TMP_VAR, M_CONST_TMP_VAR)
+#define ZEND_IS_IDENTICAL_SPEC() OPDEF(ZEND_IS_IDENTICAL, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_IS_IDENTICAL)
ZEND_VM_HANDLER(ZEND_IS_IDENTICAL)
{
}
#endif
-#define ZEND_IS_NOT_IDENTICAL_SPEC() OPDEF(ZEND_IS_NOT_IDENTICAL, M_CONST_TMP_VAR, M_CONST_TMP_VAR)
+#define ZEND_IS_NOT_IDENTICAL_SPEC() OPDEF(ZEND_IS_NOT_IDENTICAL, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_IS_NOT_IDENTICAL)
ZEND_VM_HANDLER(ZEND_IS_NOT_IDENTICAL)
{
}
#endif
-#define ZEND_IS_EQUAL_SPEC() OPDEF(ZEND_IS_EQUAL, M_CONST_TMP_VAR, M_CONST_TMP_VAR)
+#define ZEND_IS_EQUAL_SPEC() OPDEF(ZEND_IS_EQUAL, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_IS_EQUAL)
ZEND_VM_HANDLER(ZEND_IS_EQUAL)
{
}
#endif
-#define ZEND_IS_NOT_EQUAL_SPEC() OPDEF(ZEND_IS_NOT_EQUAL, M_CONST_TMP_VAR, M_CONST_TMP_VAR)
+#define ZEND_IS_NOT_EQUAL_SPEC() OPDEF(ZEND_IS_NOT_EQUAL, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_IS_NOT_EQUAL)
ZEND_VM_HANDLER(ZEND_IS_NOT_EQUAL)
{
}
#endif
-#define ZEND_IS_SMALLER_SPEC() OPDEF(ZEND_IS_SMALLER, M_CONST_TMP_VAR, M_CONST_TMP_VAR)
+#define ZEND_IS_SMALLER_SPEC() OPDEF(ZEND_IS_SMALLER, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_IS_SMALLER)
ZEND_VM_HANDLER(ZEND_IS_SMALLER)
{
}
#endif
-#define ZEND_IS_SMALLER_OR_EQUAL_SPEC() OPDEF(ZEND_IS_SMALLER_OR_EQUAL, M_CONST_TMP_VAR, M_CONST_TMP_VAR)
+#define ZEND_IS_SMALLER_OR_EQUAL_SPEC() OPDEF(ZEND_IS_SMALLER_OR_EQUAL, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_IS_SMALLER_OR_EQUAL)
ZEND_VM_HANDLER(ZEND_IS_SMALLER_OR_EQUAL)
{
}
#endif
-#define ZEND_BW_OR_SPEC() OPDEF(ZEND_BW_OR, M_CONST_TMP_VAR, M_CONST_TMP_VAR)
+#define ZEND_BW_OR_SPEC() OPDEF(ZEND_BW_OR, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_BW_OR)
ZEND_VM_HANDLER(ZEND_BW_OR)
{
}
#endif
-#define ZEND_BW_AND_SPEC() OPDEF(ZEND_BW_AND, M_CONST_TMP_VAR, M_CONST_TMP_VAR)
+#define ZEND_BW_AND_SPEC() OPDEF(ZEND_BW_AND, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_BW_AND)
ZEND_VM_HANDLER(ZEND_BW_AND)
{
}
#endif
-#define ZEND_BW_XOR_SPEC() OPDEF(ZEND_BW_XOR, M_CONST_TMP_VAR, M_CONST_TMP_VAR)
+#define ZEND_BW_XOR_SPEC() OPDEF(ZEND_BW_XOR, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_BW_XOR)
ZEND_VM_HANDLER(ZEND_BW_XOR)
{
}
#endif
-#define ZEND_BOOL_XOR_SPEC() OPDEF(ZEND_BOOL_XOR, M_CONST_TMP_VAR, M_CONST_TMP_VAR)
+#define ZEND_BOOL_XOR_SPEC() OPDEF(ZEND_BOOL_XOR, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_BOOL_XOR)
ZEND_VM_HANDLER(ZEND_BOOL_XOR)
{
}
#endif
-#define ZEND_BW_NOT_SPEC() OPDEF(ZEND_BW_NOT, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_BW_NOT_SPEC() OPDEF(ZEND_BW_NOT, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_BW_NOT)
ZEND_VM_HANDLER(ZEND_BW_NOT)
{
}
#endif
-#define ZEND_BOOL_NOT_SPEC() OPDEF(ZEND_BOOL_NOT, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_BOOL_NOT_SPEC() OPDEF(ZEND_BOOL_NOT, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_BOOL_NOT)
ZEND_VM_HANDLER(ZEND_BOOL_NOT)
{
}
#endif
-#if OP1_OP2_MASK(M_VAR_UNUSED, M_CONST_TMP_VAR)
+#if OP1_OP2_MASK(M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC))
{
zend_op *opline = EX(opline);
case IS_CONST:
/* already a constant string */
break;
+ case IS_CV:
case IS_VAR:
tmp = *property;
zval_copy_ctor(&tmp);
case ZEND_ASSIGN_DIM: {
zval **object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
- (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
+ if(OP1_TYPE != IS_CV) {
+ (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
+ }
if ((*object_ptr)->type == IS_OBJECT) {
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, binary_op);
}
#endif
-#define ZEND_ASSIGN_ADD_SPEC() OPDEF(ZEND_ASSIGN_ADD, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_ASSIGN_ADD_SPEC() OPDEF(ZEND_ASSIGN_ADD, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_ASSIGN_ADD)
ZEND_VM_HANDLER(ZEND_ASSIGN_ADD)
{
}
#endif
-#define ZEND_ASSIGN_SUB_SPEC() OPDEF(ZEND_ASSIGN_SUB, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_ASSIGN_SUB_SPEC() OPDEF(ZEND_ASSIGN_SUB, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_ASSIGN_SUB)
ZEND_VM_HANDLER(ZEND_ASSIGN_SUB)
{
}
#endif
-#define ZEND_ASSIGN_MUL_SPEC() OPDEF(ZEND_ASSIGN_MUL, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_ASSIGN_MUL_SPEC() OPDEF(ZEND_ASSIGN_MUL, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_ASSIGN_MUL)
ZEND_VM_HANDLER(ZEND_ASSIGN_MUL)
{
}
#endif
-#define ZEND_ASSIGN_DIV_SPEC() OPDEF(ZEND_ASSIGN_DIV, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_ASSIGN_DIV_SPEC() OPDEF(ZEND_ASSIGN_DIV, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_ASSIGN_DIV)
ZEND_VM_HANDLER(ZEND_ASSIGN_DIV)
{
}
#endif
-#define ZEND_ASSIGN_MOD_SPEC() OPDEF(ZEND_ASSIGN_MOD, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_ASSIGN_MOD_SPEC() OPDEF(ZEND_ASSIGN_MOD, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_ASSIGN_MOD)
ZEND_VM_HANDLER(ZEND_ASSIGN_MOD)
{
}
#endif
-#define ZEND_ASSIGN_SL_SPEC() OPDEF(ZEND_ASSIGN_SL, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_ASSIGN_SL_SPEC() OPDEF(ZEND_ASSIGN_SL, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_ASSIGN_SL)
ZEND_VM_HANDLER(ZEND_ASSIGN_SL)
{
}
#endif
-#define ZEND_ASSIGN_SR_SPEC() OPDEF(ZEND_ASSIGN_SR, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_ASSIGN_SR_SPEC() OPDEF(ZEND_ASSIGN_SR, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_ASSIGN_SR)
ZEND_VM_HANDLER(ZEND_ASSIGN_SR)
{
}
#endif
-#define ZEND_ASSIGN_CONCAT_SPEC() OPDEF(ZEND_ASSIGN_CONCAT, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_ASSIGN_CONCAT_SPEC() OPDEF(ZEND_ASSIGN_CONCAT, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_ASSIGN_CONCAT)
ZEND_VM_HANDLER(ZEND_ASSIGN_CONCAT)
{
}
#endif
-#define ZEND_ASSIGN_BW_OR_SPEC() OPDEF(ZEND_ASSIGN_BW_OR, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_ASSIGN_BW_OR_SPEC() OPDEF(ZEND_ASSIGN_BW_OR, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_ASSIGN_BW_OR)
ZEND_VM_HANDLER(ZEND_ASSIGN_BW_OR)
{
}
#endif
-#define ZEND_ASSIGN_BW_AND_SPEC() OPDEF(ZEND_ASSIGN_BW_AND, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_ASSIGN_BW_AND_SPEC() OPDEF(ZEND_ASSIGN_BW_AND, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_ASSIGN_BW_AND)
ZEND_VM_HANDLER(ZEND_ASSIGN_BW_AND)
{
}
#endif
-#define ZEND_ASSIGN_BW_XOR_SPEC() OPDEF(ZEND_ASSIGN_BW_XOR, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_ASSIGN_BW_XOR_SPEC() OPDEF(ZEND_ASSIGN_BW_XOR, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_ASSIGN_BW_XOR)
ZEND_VM_HANDLER(ZEND_ASSIGN_BW_XOR)
{
}
#endif
-#if OP1_OP2_MASK(M_VAR_UNUSED, M_CONST_TMP_VAR)
+#if OP1_OP2_MASK(M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
ZEND_VM_HELPER_EX(zend_pre_incdec_property_helper, incdec_t incdec_op)
{
zend_op *opline = EX(opline);
}
#endif
-#define ZEND_PRE_INC_OBJ_SPEC() OPDEF(ZEND_PRE_INC_OBJ, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_PRE_INC_OBJ_SPEC() OPDEF(ZEND_PRE_INC_OBJ, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_PRE_INC_OBJ)
ZEND_VM_HANDLER(ZEND_PRE_INC_OBJ)
{
}
#endif
-#define ZEND_PRE_DEC_OBJ_SPEC() OPDEF(ZEND_PRE_DEC_OBJ, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_PRE_DEC_OBJ_SPEC() OPDEF(ZEND_PRE_DEC_OBJ, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_PRE_DEC_OBJ)
ZEND_VM_HANDLER(ZEND_PRE_DEC_OBJ)
{
}
#endif
-#if OP1_OP2_MASK(M_VAR_UNUSED, M_CONST_TMP_VAR)
+#if OP1_OP2_MASK(M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
ZEND_VM_HELPER_EX(zend_post_incdec_property_helper, incdec_t incdec_op)
{
zend_op *opline = EX(opline);
}
#endif
-#define ZEND_POST_INC_OBJ_SPEC() OPDEF(ZEND_POST_INC_OBJ, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_POST_INC_OBJ_SPEC() OPDEF(ZEND_POST_INC_OBJ, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_POST_INC_OBJ)
ZEND_VM_HANDLER(ZEND_POST_INC_OBJ)
{
}
#endif
-#define ZEND_POST_DEC_OBJ_SPEC() OPDEF(ZEND_POST_DEC_OBJ, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_POST_DEC_OBJ_SPEC() OPDEF(ZEND_POST_DEC_OBJ, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_POST_DEC_OBJ)
ZEND_VM_HANDLER(ZEND_POST_DEC_OBJ)
{
}
#endif
-#define ZEND_PRE_INC_SPEC() OPDEF(ZEND_PRE_INC, M_VAR, M_ANY)
+#define ZEND_PRE_INC_SPEC() OPDEF(ZEND_PRE_INC, M_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_PRE_INC)
ZEND_VM_HANDLER(ZEND_PRE_INC)
{
}
#endif
-#define ZEND_PRE_DEC_SPEC() OPDEF(ZEND_PRE_DEC, M_VAR, M_ANY)
+#define ZEND_PRE_DEC_SPEC() OPDEF(ZEND_PRE_DEC, M_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_PRE_DEC)
ZEND_VM_HANDLER(ZEND_PRE_DEC)
{
}
#endif
-#define ZEND_POST_INC_SPEC() OPDEF(ZEND_POST_INC, M_VAR, M_ANY)
+#define ZEND_POST_INC_SPEC() OPDEF(ZEND_POST_INC, M_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_POST_INC)
ZEND_VM_HANDLER(ZEND_POST_INC)
{
}
#endif
-#define ZEND_POST_DEC_SPEC() OPDEF(ZEND_POST_DEC, M_VAR, M_ANY)
+#define ZEND_POST_DEC_SPEC() OPDEF(ZEND_POST_DEC, M_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_POST_DEC)
ZEND_VM_HANDLER(ZEND_POST_DEC)
{
}
#endif
-#define ZEND_ECHO_SPEC() OPDEF(ZEND_ECHO, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_ECHO_SPEC() OPDEF(ZEND_ECHO, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_ECHO)
ZEND_VM_HANDLER_EX(ZEND_ECHO)
{
}
#endif
-#define ZEND_PRINT_SPEC() OPDEF(ZEND_PRINT, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_PRINT_SPEC() OPDEF(ZEND_PRINT, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_PRINT)
ZEND_VM_HANDLER(ZEND_PRINT)
{
}
#endif
-#if OP1_OP2_MASK(M_CONST_TMP_VAR, M_ANY)
+#if OP1_OP2_MASK(M_CONST_TMP_VAR_CV, M_ANY)
ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, int type)
{
zend_op *opline = EX(opline);
}
#endif
-#define ZEND_FETCH_R_SPEC() OPDEF(ZEND_FETCH_R, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_FETCH_R_SPEC() OPDEF(ZEND_FETCH_R, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_FETCH_R)
ZEND_VM_HANDLER(ZEND_FETCH_R)
{
}
#endif
-#define ZEND_FETCH_W_SPEC() OPDEF(ZEND_FETCH_W, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_FETCH_W_SPEC() OPDEF(ZEND_FETCH_W, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_FETCH_W)
ZEND_VM_HANDLER(ZEND_FETCH_W)
{
}
#endif
-#define ZEND_FETCH_RW_SPEC() OPDEF(ZEND_FETCH_RW, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_FETCH_RW_SPEC() OPDEF(ZEND_FETCH_RW, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_FETCH_RW)
ZEND_VM_HANDLER(ZEND_FETCH_RW)
{
}
#endif
-#define ZEND_FETCH_FUNC_ARG_SPEC() OPDEF(ZEND_FETCH_FUNC_ARG, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_FETCH_FUNC_ARG_SPEC() OPDEF(ZEND_FETCH_FUNC_ARG, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_FETCH_FUNC_ARG)
ZEND_VM_HANDLER(ZEND_FETCH_FUNC_ARG)
{
}
#endif
-#define ZEND_FETCH_UNSET_SPEC() OPDEF(ZEND_FETCH_UNSET, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_FETCH_UNSET_SPEC() OPDEF(ZEND_FETCH_UNSET, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_FETCH_UNSET)
ZEND_VM_HANDLER(ZEND_FETCH_UNSET)
{
}
#endif
-#define ZEND_FETCH_IS_SPEC() OPDEF(ZEND_FETCH_IS, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_FETCH_IS_SPEC() OPDEF(ZEND_FETCH_IS, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_FETCH_IS)
ZEND_VM_HANDLER(ZEND_FETCH_IS)
{
}
#endif
-#define ZEND_FETCH_DIM_R_SPEC() OPDEF(ZEND_FETCH_DIM_R, M_VAR, M_CONST_TMP_VAR)
+#define ZEND_FETCH_DIM_R_SPEC() OPDEF(ZEND_FETCH_DIM_R, M_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_FETCH_DIM_R)
ZEND_VM_HANDLER(ZEND_FETCH_DIM_R)
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
- if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
+ if (opline->extended_value == ZEND_FETCH_ADD_LOCK && OP1_TYPE != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
}
zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), GET_OP1_ZVAL_PTR_PTR(BP_VAR_R), GET_OP2_ZVAL_PTR(BP_VAR_R), BP_VAR_R TSRMLS_CC);
}
#endif
-#define ZEND_FETCH_DIM_W_SPEC() OPDEF(ZEND_FETCH_DIM_W, M_VAR, M_CONST_TMP_VAR_UNUSED)
+#define ZEND_FETCH_DIM_W_SPEC() OPDEF(ZEND_FETCH_DIM_W, M_VAR_CV, M_CONST_TMP_VAR_UNUSED_CV)
#if HAVE_OP(ZEND_FETCH_DIM_W)
ZEND_VM_HANDLER(ZEND_FETCH_DIM_W)
{
}
#endif
-#define ZEND_FETCH_DIM_RW_SPEC() OPDEF(ZEND_FETCH_DIM_RW, M_VAR, M_CONST_TMP_VAR)
+#define ZEND_FETCH_DIM_RW_SPEC() OPDEF(ZEND_FETCH_DIM_RW, M_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_FETCH_DIM_RW)
ZEND_VM_HANDLER(ZEND_FETCH_DIM_RW)
{
}
#endif
-#define ZEND_FETCH_DIM_IS_SPEC() OPDEF(ZEND_FETCH_DIM_IS, M_VAR, M_CONST_TMP_VAR)
+#define ZEND_FETCH_DIM_IS_SPEC() OPDEF(ZEND_FETCH_DIM_IS, M_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_FETCH_DIM_IS)
ZEND_VM_HANDLER(ZEND_FETCH_DIM_IS)
{
}
#endif
-#define ZEND_FETCH_DIM_FUNC_ARG_SPEC() OPDEF(ZEND_FETCH_DIM_FUNC_ARG, M_VAR, M_CONST_TMP_VAR)
+#define ZEND_FETCH_DIM_FUNC_ARG_SPEC() OPDEF(ZEND_FETCH_DIM_FUNC_ARG, M_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_FETCH_DIM_FUNC_ARG)
ZEND_VM_HANDLER(ZEND_FETCH_DIM_FUNC_ARG)
{
}
#endif
-#define ZEND_FETCH_DIM_UNSET_SPEC() OPDEF(ZEND_FETCH_DIM_UNSET, M_VAR, M_CONST_TMP_VAR)
+#define ZEND_FETCH_DIM_UNSET_SPEC() OPDEF(ZEND_FETCH_DIM_UNSET, M_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_FETCH_DIM_UNSET)
ZEND_VM_HANDLER(ZEND_FETCH_DIM_UNSET)
{
}
#endif
-#if OP1_OP2_MASK(M_VAR_UNUSED, M_CONST_TMP_VAR)
+#if OP1_OP2_MASK(M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
ZEND_VM_HELPER_EX(zend_fetch_property_address_read_helper, int type)
{
zend_op *opline = EX(opline);
case IS_CONST:
/* already a constant string */
break;
+ case IS_CV:
case IS_VAR:
tmp = *offset;
zval_copy_ctor(&tmp);
}
#endif
-#define ZEND_FETCH_OBJ_R_SPEC() OPDEF(ZEND_FETCH_OBJ_R, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_FETCH_OBJ_R_SPEC() OPDEF(ZEND_FETCH_OBJ_R, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_FETCH_OBJ_R)
ZEND_VM_HANDLER(ZEND_FETCH_OBJ_R)
{
}
#endif
-#define ZEND_FETCH_OBJ_W_SPEC() OPDEF(ZEND_FETCH_OBJ_W, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_FETCH_OBJ_W_SPEC() OPDEF(ZEND_FETCH_OBJ_W, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_FETCH_OBJ_W)
ZEND_VM_HANDLER(ZEND_FETCH_OBJ_W)
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
- if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
+ if (opline->extended_value == ZEND_FETCH_ADD_LOCK && OP1_TYPE != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
}
}
#endif
-#define ZEND_FETCH_OBJ_RW_SPEC() OPDEF(ZEND_FETCH_OBJ_RW, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_FETCH_OBJ_RW_SPEC() OPDEF(ZEND_FETCH_OBJ_RW, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_FETCH_OBJ_RW)
ZEND_VM_HANDLER(ZEND_FETCH_OBJ_RW)
{
}
#endif
-#define ZEND_FETCH_OBJ_IS_SPEC() OPDEF(ZEND_FETCH_OBJ_IS, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_FETCH_OBJ_IS_SPEC() OPDEF(ZEND_FETCH_OBJ_IS, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_FETCH_OBJ_IS)
ZEND_VM_HANDLER(ZEND_FETCH_OBJ_IS)
{
}
#endif
-#define ZEND_FETCH_OBJ_FUNC_ARG_SPEC() OPDEF(ZEND_FETCH_OBJ_FUNC_ARG, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_FETCH_OBJ_FUNC_ARG_SPEC() OPDEF(ZEND_FETCH_OBJ_FUNC_ARG, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_FETCH_OBJ_FUNC_ARG)
ZEND_VM_HANDLER(ZEND_FETCH_OBJ_FUNC_ARG)
{
}
#endif
-#define ZEND_FETCH_OBJ_UNSET_SPEC() OPDEF(ZEND_FETCH_OBJ_UNSET, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_FETCH_OBJ_UNSET_SPEC() OPDEF(ZEND_FETCH_OBJ_UNSET, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_FETCH_OBJ_UNSET)
ZEND_VM_HANDLER(ZEND_FETCH_OBJ_UNSET)
{
}
#endif
-#define ZEND_ASSIGN_OBJ_SPEC() OPDEF(ZEND_ASSIGN_OBJ, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_ASSIGN_OBJ_SPEC() OPDEF(ZEND_ASSIGN_OBJ, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_ASSIGN_OBJ)
ZEND_VM_HANDLER(ZEND_ASSIGN_OBJ)
{
}
#endif
-#define ZEND_ASSIGN_DIM_SPEC() OPDEF(ZEND_ASSIGN_DIM, M_VAR_UNUSED, M_CONST_TMP_VAR_UNUSED)
+#define ZEND_ASSIGN_DIM_SPEC() OPDEF(ZEND_ASSIGN_DIM, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_UNUSED_CV)
#if HAVE_OP(ZEND_ASSIGN_DIM)
ZEND_VM_HANDLER(ZEND_ASSIGN_DIM)
{
zend_free_op free_op1;
zval **object_ptr;
- if (EX_T(opline->op1.u.var).var.ptr_ptr) {
+ if (OP1_TYPE == IS_CV || EX_T(opline->op1.u.var).var.ptr_ptr) {
/* not an array offset */
object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
} else {
zend_free_op free_op2, free_op_data1;
zval *value;
- if (object_ptr) {
+ if (object_ptr && OP1_TYPE != IS_CV) {
(*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
}
zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), GET_OP1_ZVAL_PTR_PTR(BP_VAR_W), GET_OP2_ZVAL_PTR(BP_VAR_R), BP_VAR_W TSRMLS_CC);
}
#endif
-#define ZEND_ASSIGN_SPEC() OPDEF(ZEND_ASSIGN, M_VAR, M_CONST_TMP_VAR)
+#define ZEND_ASSIGN_SPEC() OPDEF(ZEND_ASSIGN, M_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_ASSIGN)
ZEND_VM_HANDLER(ZEND_ASSIGN)
{
}
#endif
-#define ZEND_ASSIGN_REF_SPEC() OPDEF(ZEND_ASSIGN_REF, M_VAR, M_VAR)
+#define ZEND_ASSIGN_REF_SPEC() OPDEF(ZEND_ASSIGN_REF, M_VAR_CV, M_VAR_CV)
#if HAVE_OP(ZEND_ASSIGN_REF)
ZEND_VM_HANDLER(ZEND_ASSIGN_REF)
{
}
#endif
-#define ZEND_JMPZ_SPEC() OPDEF(ZEND_JMPZ, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_JMPZ_SPEC() OPDEF(ZEND_JMPZ, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_JMPZ)
ZEND_VM_HANDLER(ZEND_JMPZ)
{
}
#endif
-#define ZEND_JMPNZ_SPEC() OPDEF(ZEND_JMPNZ, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_JMPNZ_SPEC() OPDEF(ZEND_JMPNZ, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_JMPNZ)
ZEND_VM_HANDLER(ZEND_JMPNZ)
{
}
#endif
-#define ZEND_JMPZNZ_SPEC() OPDEF(ZEND_JMPZNZ, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_JMPZNZ_SPEC() OPDEF(ZEND_JMPZNZ, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_JMPZNZ)
ZEND_VM_HANDLER(ZEND_JMPZNZ)
{
}
#endif
-#define ZEND_JMPZ_EX_SPEC() OPDEF(ZEND_JMPZ_EX, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_JMPZ_EX_SPEC() OPDEF(ZEND_JMPZ_EX, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_JMPZ_EX)
ZEND_VM_HANDLER(ZEND_JMPZ_EX)
{
}
#endif
-#define ZEND_JMPNZ_EX_SPEC() OPDEF(ZEND_JMPNZ_EX, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_JMPNZ_EX_SPEC() OPDEF(ZEND_JMPNZ_EX, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_JMPNZ_EX)
ZEND_VM_HANDLER(ZEND_JMPNZ_EX)
{
}
#endif
-#define ZEND_ADD_VAR_SPEC() OPDEF(ZEND_ADD_VAR, M_TMP, M_TMP_VAR)
+#define ZEND_ADD_VAR_SPEC() OPDEF(ZEND_ADD_VAR, M_TMP, M_TMP_VAR_CV)
#if HAVE_OP(ZEND_ADD_VAR)
ZEND_VM_HANDLER(ZEND_ADD_VAR)
{
}
#endif
-#define ZEND_FETCH_CLASS_SPEC() OPDEF(ZEND_FETCH_CLASS, M_ANY, M_CONST_TMP_VAR_UNUSED)
+#define ZEND_FETCH_CLASS_SPEC() OPDEF(ZEND_FETCH_CLASS, M_ANY, M_CONST_TMP_VAR_UNUSED_CV)
#if HAVE_OP(ZEND_FETCH_CLASS)
ZEND_VM_HANDLER(ZEND_FETCH_CLASS)
{
}
#endif
-#define ZEND_INIT_CTOR_CALL_SPEC() OPDEF(ZEND_INIT_CTOR_CALL, M_TMP_VAR, M_ANY)
+#define ZEND_INIT_CTOR_CALL_SPEC() OPDEF(ZEND_INIT_CTOR_CALL, M_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_INIT_CTOR_CALL)
ZEND_VM_HANDLER(ZEND_INIT_CTOR_CALL)
{
}
#endif
-#define ZEND_INIT_METHOD_CALL_SPEC() OPDEF(ZEND_INIT_METHOD_CALL, M_TMP_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_INIT_METHOD_CALL_SPEC() OPDEF(ZEND_INIT_METHOD_CALL, M_TMP_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_INIT_METHOD_CALL)
ZEND_VM_HANDLER(ZEND_INIT_METHOD_CALL)
{
}
#endif
-#define ZEND_INIT_STATIC_METHOD_CALL_SPEC() OPDEF(ZEND_INIT_STATIC_METHOD_CALL, M_ANY, M_CONST_TMP_VAR_UNUSED)
+#define ZEND_INIT_STATIC_METHOD_CALL_SPEC() OPDEF(ZEND_INIT_STATIC_METHOD_CALL, M_ANY, M_CONST_TMP_VAR_UNUSED_CV)
#if HAVE_OP(ZEND_INIT_STATIC_METHOD_CALL)
ZEND_VM_HANDLER(ZEND_INIT_STATIC_METHOD_CALL)
{
}
#endif
-#define ZEND_INIT_FCALL_BY_NAME_SPEC() OPDEF(ZEND_INIT_FCALL_BY_NAME, M_ANY, M_CONST_TMP_VAR)
+#define ZEND_INIT_FCALL_BY_NAME_SPEC() OPDEF(ZEND_INIT_FCALL_BY_NAME, M_ANY, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_INIT_FCALL_BY_NAME)
ZEND_VM_HANDLER(ZEND_INIT_FCALL_BY_NAME)
{
}
#endif
-#define ZEND_RETURN_SPEC() OPDEF(ZEND_RETURN, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_RETURN_SPEC() OPDEF(ZEND_RETURN, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_RETURN)
ZEND_VM_HANDLER(ZEND_RETURN)
{
}
#endif
-#define ZEND_THROW_SPEC() OPDEF(ZEND_THROW, M_VAR, M_ANY)
+#define ZEND_THROW_SPEC() OPDEF(ZEND_THROW, M_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_THROW)
ZEND_VM_HANDLER(ZEND_THROW)
{
}
#endif
-#define ZEND_SEND_VAL_SPEC() OPDEF(ZEND_SEND_VAL, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_SEND_VAL_SPEC() OPDEF(ZEND_SEND_VAL, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_SEND_VAL)
ZEND_VM_HANDLER(ZEND_SEND_VAL)
{
}
#endif
-#if OP1_OP2_MASK(M_VAR, M_ANY)
+#if OP1_OP2_MASK(M_VAR_CV, M_ANY)
ZEND_VM_HELPER(zend_send_by_var_helper)
{
zend_op *opline = EX(opline);
}
#endif
-#define ZEND_SEND_VAR_NO_REF_SPEC() OPDEF(ZEND_SEND_VAR_NO_REF, M_VAR, M_ANY)
+#define ZEND_SEND_VAR_NO_REF_SPEC() OPDEF(ZEND_SEND_VAR_NO_REF, M_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_SEND_VAR_NO_REF)
ZEND_VM_HANDLER(ZEND_SEND_VAR_NO_REF)
{
}
#endif
-#define ZEND_SEND_REF_SPEC() OPDEF(ZEND_SEND_REF, M_VAR, M_ANY)
+#define ZEND_SEND_REF_SPEC() OPDEF(ZEND_SEND_REF, M_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_SEND_REF)
ZEND_VM_HANDLER_EX(ZEND_SEND_REF)
{
}
#endif
-#define ZEND_SEND_VAR_SPEC() OPDEF(ZEND_SEND_VAR, M_VAR, M_ANY)
+#define ZEND_SEND_VAR_SPEC() OPDEF(ZEND_SEND_VAR, M_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_SEND_VAR)
ZEND_VM_HANDLER(ZEND_SEND_VAR)
{
}
#endif
-#define ZEND_BOOL_SPEC() OPDEF(ZEND_BOOL, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_BOOL_SPEC() OPDEF(ZEND_BOOL, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_BOOL)
ZEND_VM_HANDLER(ZEND_BOOL)
{
}
#endif
-#define ZEND_BRK_SPEC() OPDEF(ZEND_BRK, M_ANY, M_CONST_TMP_VAR)
+#define ZEND_BRK_SPEC() OPDEF(ZEND_BRK, M_ANY, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_BRK)
ZEND_VM_HANDLER(ZEND_BRK)
{
}
#endif
-#define ZEND_CONT_SPEC() OPDEF(ZEND_CONT, M_ANY, M_CONST_TMP_VAR)
+#define ZEND_CONT_SPEC() OPDEF(ZEND_CONT, M_ANY, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_CONT)
ZEND_VM_HANDLER(ZEND_CONT)
{
}
#endif
-#define ZEND_CASE_SPEC() OPDEF(ZEND_CASE, M_CONST_TMP_VAR, M_CONST_TMP_VAR)
+#define ZEND_CASE_SPEC() OPDEF(ZEND_CASE, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_CASE)
ZEND_VM_HANDLER(ZEND_CASE)
{
}
#endif
-#define ZEND_CLONE_SPEC() OPDEF(ZEND_CLONE, M_CONST_TMP_VAR_UNUSED, M_ANY)
+#define ZEND_CLONE_SPEC() OPDEF(ZEND_CLONE, M_CONST_TMP_VAR_UNUSED_CV, M_ANY)
#if HAVE_OP(ZEND_CLONE)
ZEND_VM_HANDLER(ZEND_CLONE)
{
}
#endif
-#if OP1_OP2_MASK(M_CONST_TMP_VAR_UNUSED, M_CONST_TMP_VAR_UNUSED)
+#if OP1_OP2_MASK(M_CONST_TMP_VAR_UNUSED_CV, M_CONST_TMP_VAR_UNUSED_CV)
ZEND_VM_HELPER(zend_init_add_array_helper)
{
zend_op *opline = EX(opline);
zval *offset=GET_OP2_ZVAL_PTR(BP_VAR_R);
if (opline->extended_value) {
- expr_ptr_ptr=GET_OP1_ZVAL_PTR_PTR(BP_VAR_R);
+ expr_ptr_ptr=GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
expr_ptr = *expr_ptr_ptr;
} else {
expr_ptr=GET_OP1_ZVAL_PTR(BP_VAR_R);
}
#endif
-#define ZEND_INIT_ARRAY_SPEC() OPDEF(ZEND_INIT_ARRAY, M_CONST_TMP_VAR_UNUSED, M_CONST_TMP_VAR_UNUSED)
+#define ZEND_INIT_ARRAY_SPEC() OPDEF(ZEND_INIT_ARRAY, M_CONST_TMP_VAR_UNUSED_CV, M_CONST_TMP_VAR_UNUSED_CV)
#if HAVE_OP(ZEND_INIT_ARRAY)
ZEND_VM_HANDLER(ZEND_INIT_ARRAY)
{
}
#endif
-#define ZEND_ADD_ARRAY_ELEMENT_SPEC() OPDEF(ZEND_ADD_ARRAY_ELEMENT, M_CONST_TMP_VAR_UNUSED, M_CONST_TMP_VAR_UNUSED)
+#define ZEND_ADD_ARRAY_ELEMENT_SPEC() OPDEF(ZEND_ADD_ARRAY_ELEMENT, M_CONST_TMP_VAR_UNUSED_CV, M_CONST_TMP_VAR_UNUSED_CV)
#if HAVE_OP(ZEND_ADD_ARRAY_ELEMENT)
ZEND_VM_HANDLER(ZEND_ADD_ARRAY_ELEMENT)
{
}
#endif
-#define ZEND_CAST_SPEC() OPDEF(ZEND_CAST, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_CAST_SPEC() OPDEF(ZEND_CAST, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_CAST)
ZEND_VM_HANDLER(ZEND_CAST)
{
}
#endif
-#define ZEND_INCLUDE_OR_EVAL_SPEC() OPDEF(ZEND_INCLUDE_OR_EVAL, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_INCLUDE_OR_EVAL_SPEC() OPDEF(ZEND_INCLUDE_OR_EVAL, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_INCLUDE_OR_EVAL)
ZEND_VM_HANDLER(ZEND_INCLUDE_OR_EVAL)
{
}
#endif
-#define ZEND_UNSET_VAR_SPEC() OPDEF(ZEND_UNSET_VAR, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_UNSET_VAR_SPEC() OPDEF(ZEND_UNSET_VAR, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_UNSET_VAR)
ZEND_VM_HANDLER(ZEND_UNSET_VAR)
{
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
zend_std_unset_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname) TSRMLS_CC);
} else {
- target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
- zend_hash_del(target_symbol_table, varname->value.str.val, varname->value.str.len+1);
+ target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
+ if (zend_hash_del(target_symbol_table, varname->value.str.val, varname->value.str.len+1) == SUCCESS) {
+ zend_execute_data *ex = EXECUTE_DATA;
+ do {
+ int i;
+
+ for (i = 0; i < ex->op_array->last_var; i++) {
+ if (ex->op_array->vars[i].name_len == varname->value.str.len &&
+ !memcmp(ex->op_array->vars[i].name, varname->value.str.val, varname->value.str.len)) {
+ ex->CVs[i] = NULL;
+ break;
+ }
+ }
+ ex = ex->prev_execute_data;
+ } while (ex && ex->symbol_table == target_symbol_table);
+ }
}
if (varname == &tmp) {
}
#endif
-#define ZEND_UNSET_DIM_OBJ_SPEC() OPDEF(ZEND_UNSET_DIM_OBJ, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_UNSET_DIM_OBJ_SPEC() OPDEF(ZEND_UNSET_DIM_OBJ, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_UNSET_DIM_OBJ)
ZEND_VM_HANDLER(ZEND_UNSET_DIM_OBJ)
{
zend_hash_index_del(ht, index);
break;
case IS_STRING:
- zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1);
+ if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
+ ht == &EG(symbol_table)) {
+ zend_execute_data *ex;
+ for (ex = EXECUTE_DATA; ex; ex = ex->prev_execute_data) {
+ if (ex->symbol_table == ht) {
+ int i;
+
+ for (i = 0; i < ex->op_array->last_var; i++) {
+ if (ex->op_array->vars[i].name_len == offset->value.str.len &&
+ !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
+ ex->CVs[i] = NULL;
+ break;
+ }
+ }
+ }
+ }
+ }
break;
case IS_NULL:
zend_hash_del(ht, "", sizeof(""));
}
#endif
-#define ZEND_FE_RESET_SPEC() OPDEF(ZEND_FE_RESET, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_FE_RESET_SPEC() OPDEF(ZEND_FE_RESET, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_FE_RESET)
ZEND_VM_HANDLER(ZEND_FE_RESET)
{
}
#endif
-#define ZEND_FE_FETCH_SPEC() OPDEF(ZEND_FE_FETCH, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_FE_FETCH_SPEC() OPDEF(ZEND_FE_FETCH, M_VAR, M_ANY)
#if HAVE_OP(ZEND_FE_FETCH)
ZEND_VM_HANDLER(ZEND_FE_FETCH)
{
}
#endif
-#define ZEND_JMP_NO_CTOR_SPEC() OPDEF(ZEND_JMP_NO_CTOR, M_TMP_VAR, M_ANY)
+#define ZEND_JMP_NO_CTOR_SPEC() OPDEF(ZEND_JMP_NO_CTOR, M_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_JMP_NO_CTOR)
ZEND_VM_HANDLER(ZEND_JMP_NO_CTOR)
{
}
#endif
-#define ZEND_ISSET_ISEMPTY_VAR_SPEC() OPDEF(ZEND_ISSET_ISEMPTY_VAR, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_ISSET_ISEMPTY_VAR_SPEC() OPDEF(ZEND_ISSET_ISEMPTY_VAR, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_ISSET_ISEMPTY_VAR)
ZEND_VM_HANDLER(ZEND_ISSET_ISEMPTY_VAR)
{
zend_op *opline = EX(opline);
zend_free_op free_op1;
- zval tmp, *varname = GET_OP1_ZVAL_PTR(BP_VAR_R);
+ zval tmp, *varname = GET_OP1_ZVAL_PTR(BP_VAR_IS);
zval **value;
zend_bool isset = 1;
HashTable *target_symbol_table;
}
#endif
-#if OP1_OP2_MASK(M_VAR_UNUSED, M_CONST_TMP_VAR)
+#if OP1_OP2_MASK(M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
ZEND_VM_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, int prop_dim)
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
- zval **container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_R);
+ zval **container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_IS);
zval *offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
zval **value = NULL;
int result = 0;
}
#endif
-#define ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC() OPDEF(ZEND_ISSET_ISEMPTY_DIM_OBJ, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC() OPDEF(ZEND_ISSET_ISEMPTY_DIM_OBJ, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_ISSET_ISEMPTY_DIM_OBJ)
ZEND_VM_HANDLER(ZEND_ISSET_ISEMPTY_DIM_OBJ)
{
}
#endif
-#define ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC() OPDEF(ZEND_ISSET_ISEMPTY_PROP_OBJ, M_VAR_UNUSED, M_CONST_TMP_VAR)
+#define ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC() OPDEF(ZEND_ISSET_ISEMPTY_PROP_OBJ, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV)
#if HAVE_OP(ZEND_ISSET_ISEMPTY_PROP_OBJ)
ZEND_VM_HANDLER(ZEND_ISSET_ISEMPTY_PROP_OBJ)
{
}
#endif
-#define ZEND_EXIT_SPEC() OPDEF(ZEND_EXIT, M_CONST_TMP_VAR_UNUSED, M_ANY)
+#define ZEND_EXIT_SPEC() OPDEF(ZEND_EXIT, M_CONST_TMP_VAR_UNUSED_CV, M_ANY)
#if HAVE_OP(ZEND_EXIT)
ZEND_VM_HANDLER(ZEND_EXIT)
{
}
#endif
-#define ZEND_QM_ASSIGN_SPEC() OPDEF(ZEND_QM_ASSIGN, M_CONST_TMP_VAR, M_ANY)
+#define ZEND_QM_ASSIGN_SPEC() OPDEF(ZEND_QM_ASSIGN, M_CONST_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_QM_ASSIGN)
ZEND_VM_HANDLER(ZEND_QM_ASSIGN)
{
}
#endif
-#define ZEND_INSTANCEOF_SPEC() OPDEF(ZEND_INSTANCEOF, M_TMP_VAR, M_ANY)
+#define ZEND_INSTANCEOF_SPEC() OPDEF(ZEND_INSTANCEOF, M_TMP_VAR_CV, M_ANY)
#if HAVE_OP(ZEND_INSTANCEOF)
ZEND_VM_HANDLER(ZEND_INSTANCEOF)
{
#define SPEC__TMP_CODE _TMP_CODE
#define SPEC__VAR_CODE _VAR_CODE
#define SPEC__UNUSED_CODE _UNUSED_CODE
+#define SPEC__CV_CODE _CV_CODE
#define SPEC_OP1_TYPE_ANY opline->op1.op_type
#define SPEC_OP1_TYPE_CONST IS_CONST
#define SPEC_OP1_TYPE_TMP IS_TMP_VAR
#define SPEC_OP1_TYPE_VAR IS_VAR
#define SPEC_OP1_TYPE_UNUSED IS_UNUSED
+#define SPEC_OP1_TYPE_CV IS_CV
-#define SPEC_GET_OP1_ZVAL_PTR_ANY(T) _get_zval_ptr(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)
+#define SPEC_GET_OP1_ZVAL_PTR_ANY(T) get_zval_ptr(&opline->op1, EX(Ts), &free_op1, T)
#define SPEC_GET_OP1_ZVAL_PTR_CONST(T) _get_zval_ptr_const(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)
#define SPEC_GET_OP1_ZVAL_PTR_TMP(T) _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)
#define SPEC_GET_OP1_ZVAL_PTR_VAR(T) _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)
#define SPEC_GET_OP1_ZVAL_PTR_UNUSED(T) _get_zval_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)
+#define SPEC_GET_OP1_ZVAL_PTR_CV(T) _get_zval_ptr_cv(&opline->op1, EX(Ts), &free_op1, T TSRMLS_CC)
-#define SPEC_GET_OP1_ZVAL_PTR_PTR_ANY(T) _get_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)
+#define SPEC_GET_OP1_ZVAL_PTR_PTR_ANY(T) get_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, T)
#define SPEC_GET_OP1_ZVAL_PTR_PTR_CONST(T) _get_zval_ptr_ptr_const(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)
#define SPEC_GET_OP1_ZVAL_PTR_PTR_TMP(T) _get_zval_ptr_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)
#define SPEC_GET_OP1_ZVAL_PTR_PTR_VAR(T) _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)
#define SPEC_GET_OP1_ZVAL_PTR_PTR_UNUSED(T) _get_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)
+#define SPEC_GET_OP1_ZVAL_PTR_PTR_CV(T) _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, T TSRMLS_CC)
-#define SPEC_GET_OP1_OBJ_ZVAL_PTR_ANY(T) _get_obj_zval_ptr(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)
+#define SPEC_GET_OP1_OBJ_ZVAL_PTR_ANY(T) get_obj_zval_ptr(&opline->op1, EX(Ts), &free_op1, T)
#define SPEC_GET_OP1_OBJ_ZVAL_PTR_CONST(T) _get_obj_zval_ptr_const(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)
#define SPEC_GET_OP1_OBJ_ZVAL_PTR_TMP(T) _get_obj_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)
#define SPEC_GET_OP1_OBJ_ZVAL_PTR_VAR(T) _get_obj_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)
#define SPEC_GET_OP1_OBJ_ZVAL_PTR_UNUSED(T) _get_obj_zval_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)
+#define SPEC_GET_OP1_OBJ_ZVAL_PTR_CV(T) _get_obj_zval_ptr_cv(&opline->op1, EX(Ts), &free_op1, T TSRMLS_CC)
-#define SPEC_GET_OP1_OBJ_ZVAL_PTR_PTR_ANY(T) _get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)
+#define SPEC_GET_OP1_OBJ_ZVAL_PTR_PTR_ANY(T) get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, T)
#define SPEC_GET_OP1_OBJ_ZVAL_PTR_PTR_CONST(T) _get_obj_zval_ptr_ptr_const(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)
#define SPEC_GET_OP1_OBJ_ZVAL_PTR_PTR_TMP(T) _get_obj_zval_ptr_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)
#define SPEC_GET_OP1_OBJ_ZVAL_PTR_PTR_VAR(T) _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)
#define SPEC_GET_OP1_OBJ_ZVAL_PTR_PTR_UNUSED(T) _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC)
+#define SPEC_GET_OP1_OBJ_ZVAL_PTR_PTR_CV(T) _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, T TSRMLS_CC)
#define SPEC_IS_OP1_TMP_FREE_ANY() IS_TMP_FREE(free_op1)
#define SPEC_IS_OP1_TMP_FREE_CONST() 0
#define SPEC_IS_OP1_TMP_FREE_TMP() 1
#define SPEC_IS_OP1_TMP_FREE_VAR() 0
#define SPEC_IS_OP1_TMP_FREE_UNUSED() 0
+#define SPEC_IS_OP1_TMP_FREE_CV() 0
#define SPEC_FREE_OP1_ANY() FREE_OP(free_op1);
#define SPEC_FREE_OP1_CONST()
#define SPEC_FREE_OP1_TMP() zval_dtor(free_op1.var)
#define SPEC_FREE_OP1_VAR() FREE_OP_VAR_PTR(free_op1);
#define SPEC_FREE_OP1_UNUSED()
+#define SPEC_FREE_OP1_CV()
#define SPEC_FREE_OP1_IF_VAR_ANY() FREE_OP_IF_VAR(free_op1);
#define SPEC_FREE_OP1_IF_VAR_CONST()
#define SPEC_FREE_OP1_IF_VAR_TMP()
#define SPEC_FREE_OP1_IF_VAR_VAR() FREE_OP_VAR_PTR(free_op1);
#define SPEC_FREE_OP1_IF_VAR_UNUSED()
+#define SPEC_FREE_OP1_IF_VAR_CV()
#define SPEC_FREE_OP1_VAR_PTR_ANY() FREE_OP_VAR_PTR(free_op1);
#define SPEC_FREE_OP1_VAR_PTR_CONST()
#define SPEC_FREE_OP1_VAR_PTR_TMP()
#define SPEC_FREE_OP1_VAR_PTR_VAR() FREE_OP_VAR_PTR(free_op1);
#define SPEC_FREE_OP1_VAR_PTR_UNUSED()
+#define SPEC_FREE_OP1_VAR_PTR_CV()
#define SPEC_OP2_TYPE_ANY opline->op2.op_type
#define SPEC_OP2_TYPE_CONST IS_CONST
#define SPEC_OP2_TYPE_TMP IS_TMP_VAR
#define SPEC_OP2_TYPE_VAR IS_VAR
#define SPEC_OP2_TYPE_UNUSED IS_UNUSED
+#define SPEC_OP2_TYPE_CV IS_CV
-#define SPEC_GET_OP2_ZVAL_PTR_ANY(T) _get_zval_ptr(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)
+#define SPEC_GET_OP2_ZVAL_PTR_ANY(T) get_zval_ptr(&opline->op2, EX(Ts), &free_op2, T)
#define SPEC_GET_OP2_ZVAL_PTR_CONST(T) _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)
#define SPEC_GET_OP2_ZVAL_PTR_TMP(T) _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)
#define SPEC_GET_OP2_ZVAL_PTR_VAR(T) _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)
#define SPEC_GET_OP2_ZVAL_PTR_UNUSED(T) _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)
+#define SPEC_GET_OP2_ZVAL_PTR_CV(T) _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, T TSRMLS_CC)
-#define SPEC_GET_OP2_ZVAL_PTR_PTR_ANY(T) _get_zval_ptr_ptr(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)
+#define SPEC_GET_OP2_ZVAL_PTR_PTR_ANY(T) get_zval_ptr_ptr(&opline->op2, EX(Ts), &free_op2, T)
#define SPEC_GET_OP2_ZVAL_PTR_PTR_CONST(T) _get_zval_ptr_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)
#define SPEC_GET_OP2_ZVAL_PTR_PTR_TMP(T) _get_zval_ptr_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)
#define SPEC_GET_OP2_ZVAL_PTR_PTR_VAR(T) _get_zval_ptr_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)
#define SPEC_GET_OP2_ZVAL_PTR_PTR_UNUSED(T) _get_zval_ptr_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)
+#define SPEC_GET_OP2_ZVAL_PTR_PTR_CV(T) _get_zval_ptr_ptr_cv(&opline->op2, EX(Ts), &free_op2, T TSRMLS_CC)
-#define SPEC_GET_OP2_OBJ_ZVAL_PTR_ANY(T) _get_obj_zval_ptr(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)
+#define SPEC_GET_OP2_OBJ_ZVAL_PTR_ANY(T) get_obj_zval_ptr(&opline->op2, EX(Ts), &free_op2, T)
#define SPEC_GET_OP2_OBJ_ZVAL_PTR_CONST(T) _get_obj_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)
#define SPEC_GET_OP2_OBJ_ZVAL_PTR_TMP(T) _get_obj_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)
#define SPEC_GET_OP2_OBJ_ZVAL_PTR_VAR(T) _get_obj_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)
#define SPEC_GET_OP2_OBJ_ZVAL_PTR_UNUSED(T) _get_obj_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)
+#define SPEC_GET_OP2_OBJ_ZVAL_PTR_CV(T) _get_obj_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, T TSRMLS_CC)
-#define SPEC_GET_OP2_OBJ_ZVAL_PTR_PTR_ANY(T) _get_obj_zval_ptr_ptr(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)
+#define SPEC_GET_OP2_OBJ_ZVAL_PTR_PTR_ANY(T) get_obj_zval_ptr_ptr(&opline->op2, EX(Ts), &free_op2, T)
#define SPEC_GET_OP2_OBJ_ZVAL_PTR_PTR_CONST(T) _get_obj_zval_ptr_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)
#define SPEC_GET_OP2_OBJ_ZVAL_PTR_PTR_TMP(T) _get_obj_zval_ptr_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)
#define SPEC_GET_OP2_OBJ_ZVAL_PTR_PTR_VAR(T) _get_obj_zval_ptr_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)
#define SPEC_GET_OP2_OBJ_ZVAL_PTR_PTR_UNUSED(T) _get_obj_zval_ptr_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC)
+#define SPEC_GET_OP2_OBJ_ZVAL_PTR_PTR_CV(T) _get_obj_zval_ptr_ptr_cv(&opline->op2, EX(Ts), &free_op2, T TSRMLS_CC)
#define SPEC_IS_OP2_TMP_FREE_ANY() IS_TMP_FREE(free_op2)
#define SPEC_IS_OP2_TMP_FREE_CONST() 0
#define SPEC_IS_OP2_TMP_FREE_TMP() 1
#define SPEC_IS_OP2_TMP_FREE_VAR() 0
#define SPEC_IS_OP2_TMP_FREE_UNUSED() 0
+#define SPEC_IS_OP2_TMP_FREE_CV() 0
#define SPEC_FREE_OP2_ANY() FREE_OP(free_op2);
#define SPEC_FREE_OP2_CONST()
#define SPEC_FREE_OP2_TMP() zval_dtor(free_op2.var)
#define SPEC_FREE_OP2_VAR() FREE_OP_VAR_PTR(free_op2);
#define SPEC_FREE_OP2_UNUSED()
+#define SPEC_FREE_OP2_CV()
#define SPEC_FREE_OP2_IF_VAR_ANY() FREE_OP_IF_VAR(free_op2);
#define SPEC_FREE_OP2_IF_VAR_CONST()
#define SPEC_FREE_OP2_IF_VAR_TMP()
#define SPEC_FREE_OP2_IF_VAR_VAR() FREE_OP_VAR_PTR(free_op2);
#define SPEC_FREE_OP2_IF_VAR_UNUSED()
+#define SPEC_FREE_OP2_IF_VAR_CV()
#define SPEC_FREE_OP2_VAR_PTR_ANY() FREE_OP_VAR_PTR(free_op2);
#define SPEC_FREE_OP2_VAR_PTR_CONST()
#define SPEC_FREE_OP2_VAR_PTR_TMP()
#define SPEC_FREE_OP2_VAR_PTR_VAR() FREE_OP_VAR_PTR(free_op2);
#define SPEC_FREE_OP2_VAR_PTR_UNUSED()
+#define SPEC_FREE_OP2_VAR_PTR_CV()
#ifndef ZEND_VM_SPEC
#else
-# define M_ANY (IS_ANY)
-# define M_CONST (IS_CONST)
-# define M_TMP (IS_TMP_VAR)
-# define M_VAR (IS_VAR)
-# define M_UNUSED (IS_UNUSED)
-# define M_CONST_TMP (IS_CONST|IS_TMP_VAR)
-# define M_CONST_VAR (IS_CONST|IS_VAR)
-# define M_CONST_UNUSED (IS_CONST|IS_UNUSED)
-# define M_CONST_TMP_VAR (IS_CONST|IS_TMP_VAR|IS_VAR)
-# define M_CONST_TMP_UNUSED (IS_CONST|IS_TMP_VAR|IS_UNUSED)
-# define M_CONST_VAR_UNUSED (IS_CONST|IS_VAR|IS_UNUSED)
-# define M_CONST_TMP_VAR_UNUSED (IS_CONST|IS_TMP_VAR|IS_VAR|IS_UNUSED)
-# define M_TMP_VAR (IS_TMP_VAR|IS_VAR)
-# define M_TMP_UNUSED (IS_TMP_VAR|IS_UNUSED)
-# define M_TMP_VAR_UNUSED (IS_TMP_VAR|IS_VAR|IS_UNUSED)
-# define M_VAR_UNUSED (IS_VAR|IS_UNUSED)
+# define M_ANY (IS_ANY)
+# define M_CONST (IS_CONST)
+# define M_TMP (IS_TMP_VAR)
+# define M_VAR (IS_VAR)
+# define M_UNUSED (IS_UNUSED)
+# define M_CONST_TMP (IS_CONST|IS_TMP_VAR)
+# define M_CONST_VAR (IS_CONST|IS_VAR)
+# define M_CONST_UNUSED (IS_CONST|IS_UNUSED)
+# define M_CONST_TMP_VAR (IS_CONST|IS_TMP_VAR|IS_VAR)
+# define M_CONST_TMP_UNUSED (IS_CONST|IS_TMP_VAR|IS_UNUSED)
+# define M_CONST_VAR_UNUSED (IS_CONST|IS_VAR|IS_UNUSED)
+# define M_CONST_TMP_VAR_UNUSED (IS_CONST|IS_TMP_VAR|IS_VAR|IS_UNUSED)
+# define M_TMP_VAR (IS_TMP_VAR|IS_VAR)
+# define M_TMP_UNUSED (IS_TMP_VAR|IS_UNUSED)
+# define M_TMP_VAR_UNUSED (IS_TMP_VAR|IS_VAR|IS_UNUSED)
+# define M_VAR_UNUSED (IS_VAR|IS_UNUSED)
+# define M_CV (IS_CV)
+# define M_CONST_CV (IS_CONST|IS_CV)
+# define M_TMP_CV (IS_TMP_VAR|IS_CV)
+# define M_VAR_CV (IS_VAR|IS_CV)
+# define M_UNUSED_CV (IS_UNUSED|IS_CV)
+# define M_CONST_TMP_CV (IS_CONST|IS_TMP_VAR|IS_CV)
+# define M_CONST_VAR_CV (IS_CONST|IS_VAR|IS_CV)
+# define M_CONST_UNUSED_CV (IS_CONST|IS_UNUSED|IS_CV)
+# define M_CONST_TMP_VAR_CV (IS_CONST|IS_TMP_VAR|IS_VAR|IS_CV)
+# define M_CONST_TMP_UNUSED_CV (IS_CONST|IS_TMP_VAR|IS_UNUSED|IS_CV)
+# define M_CONST_VAR_UNUSED_CV (IS_CONST|IS_VAR|IS_UNUSED|IS_CV)
+# define M_CONST_TMP_VAR_UNUSED_CV (IS_CONST|IS_TMP_VAR|IS_VAR|IS_UNUSED|IS_CV)
+# define M_TMP_VAR_CV (IS_TMP_VAR|IS_VAR|IS_CV)
+# define M_TMP_UNUSED_CV (IS_TMP_VAR|IS_UNUSED|IS_CV)
+# define M_TMP_VAR_UNUSED_CV (IS_TMP_VAR|IS_VAR|IS_UNUSED|IS_CV)
+# define M_VAR_UNUSED_CV (IS_VAR|IS_UNUSED|IS_CV)
# define OP1_OP2_MASK(OP1T, OP2T) \
((OP1 & (OP1T)) && (OP2 & (OP2T)))
# define OP2 IS_ANY
# include "zend_vm_handlers.h"
+# undef OP1
+# undef OP2
+# define OP1 IS_CV
+# define OP2 IS_ANY
+# include "zend_vm_handlers.h"
+
# undef OP1
# undef OP2
# define OP1 IS_ANY
# define OP2 IS_UNUSED
# include "zend_vm_handlers.h"
+# undef OP1
+# undef OP2
+# define OP1 IS_ANY
+# define OP2 IS_CV
+# include "zend_vm_handlers.h"
+
# undef OP1
# undef OP2
# define OP1 IS_UNUSED
# define OP2 IS_VAR
# include "zend_vm_handlers.h"
+# undef OP1
+# undef OP2
+# define OP1 IS_UNUSED
+# define OP2 IS_CV
+# include "zend_vm_handlers.h"
+
# undef OP1
# undef OP2
# define OP1 IS_CONST
# define OP2 IS_UNUSED
# include "zend_vm_handlers.h"
+# undef OP1
+# undef OP2
+# define OP1 IS_CV
+# define OP2 IS_UNUSED
+# include "zend_vm_handlers.h"
+
# undef OP1
# undef OP2
# define OP1 IS_CONST
# define OP2 IS_VAR
# include "zend_vm_handlers.h"
+# undef OP1
+# undef OP2
+# define OP1 IS_CONST
+# define OP2 IS_CV
+# include "zend_vm_handlers.h"
+
# undef OP1
# undef OP2
# define OP1 IS_TMP_VAR
# define OP2 IS_VAR
# include "zend_vm_handlers.h"
+# undef OP1
+# undef OP2
+# define OP1 IS_TMP_VAR
+# define OP2 IS_CV
+# include "zend_vm_handlers.h"
+
# undef OP1
# undef OP2
# define OP1 IS_VAR
# define OP2 IS_VAR
# include "zend_vm_handlers.h"
+# undef OP1
+# undef OP2
+# define OP1 IS_VAR
+# define OP2 IS_CV
+# include "zend_vm_handlers.h"
+
+# undef OP1
+# undef OP2
+# define OP1 IS_CV
+# define OP2 IS_CONST
+# include "zend_vm_handlers.h"
+
+# undef OP1
+# undef OP2
+# define OP1 IS_CV
+# define OP2 IS_TMP_VAR
+# include "zend_vm_handlers.h"
+
+# undef OP1
+# undef OP2
+# define OP1 IS_CV
+# define OP2 IS_VAR
+# include "zend_vm_handlers.h"
+
+# undef OP1
+# undef OP2
+# define OP1 IS_CV
+# define OP2 IS_CV
+# include "zend_vm_handlers.h"
+
/* LABELS */
# undef M_ANY
# undef M_TMP_UNUSED
# undef M_TMP_VAR_UNUSED
# undef M_VAR_UNUSED
+# undef M_CV
+# undef M_CONST_CV
+# undef M_TMP_CV
+# undef M_VAR_CV
+# undef M_UNUSED_CV
+# undef M_CONST_TMP_CV
+# undef M_CONST_VAR_CV
+# undef M_CONST_UNUSED_CV
+# undef M_CONST_TMP_VAR_CV
+# undef M_CONST_TMP_UNUSED_CV
+# undef M_CONST_VAR_UNUSED_CV
+# undef M_CONST_TMP_VAR_UNUSED_CV
+# undef M_TMP_VAR_CV
+# undef M_TMP_UNUSED_CV
+# undef M_TMP_VAR_UNUSED_CV
+# undef M_VAR_UNUSED_CV
# undef OPDEF
SPEC_LABELS1_##OP1M(OP##_SPEC, OP, OP2M)
# define SPEC_LABELS1_M_ANY(OP, CODE, OP2M) \
- SPEC_LABELS2_##OP2M(OP, CODE, _ANY, _ANY, _ANY, _ANY)
+ SPEC_LABELS2_##OP2M(OP, CODE, _ANY, _ANY, _ANY, _ANY, _ANY)
# define SPEC_LABELS1_M_UNUSED(OP, CODE, OP2M) \
- SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _NULL, _NULL, _UNUSED)
+ SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _NULL, _NULL, _UNUSED, _NULL)
# define SPEC_LABELS1_M_VAR(OP, CODE, OP2M) \
- SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _NULL, _VAR, _NULL)
+ SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _NULL, _VAR, _NULL, _NULL)
# define SPEC_LABELS1_M_VAR_UNUSED(OP, CODE, OP2M) \
- SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _NULL, _VAR, _UNUSED)
+ SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _NULL, _VAR, _UNUSED, _NULL)
# define SPEC_LABELS1_M_TMP(OP, CODE, OP2M) \
- SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _NULL, _NULL)
+ SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _NULL, _NULL, _NULL)
# define SPEC_LABELS1_M_TMP_UNUSED(OP, CODE, OP2M) \
- SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _NULL, _UNUSED)
+ SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _NULL, _UNUSED, _NULL)
# define SPEC_LABELS1_M_TMP_VAR(OP, CODE, OP2M) \
- SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _VAR, _NULL)
+ SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _VAR, _NULL, _NULL)
# define SPEC_LABELS1_M_TMP_VAR_UNUSED(OP, CODE, OP2M) \
- SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _VAR, _UNUSED)
+ SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _VAR, _UNUSED, _NULL)
# define SPEC_LABELS1_M_CONST(OP, CODE, OP2M) \
- SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _NULL, _NULL)
+ SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _NULL, _NULL, _NULL)
# define SPEC_LABELS1_M_CONST_UNUSED(OP, CODE, OP2M) \
- SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _NULL, _UNUSED)
+ SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _NULL, _UNUSED, _NULL)
# define SPEC_LABELS1_M_CONST_VAR(OP, CODE, OP2M) \
- SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _VAR, _NULL)
+ SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _VAR, _NULL, _NULL)
# define SPEC_LABELS1_M_CONST_VAR_UNUSED(OP, CODE, OP2M) \
- SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _VAR, _UNUSED)
+ SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _VAR, _UNUSED, _NULL)
# define SPEC_LABELS1_M_CONST_TMP(OP, CODE, OP2M) \
- SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _NULL, _NULL)
+ SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _NULL, _NULL, _NULL)
# define SPEC_LABELS1_M_CONST_TMP_UNUSED(OP, CODE, OP2M) \
- SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _NULL, _UNUSED)
+ SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _NULL, _UNUSED, _NULL)
# define SPEC_LABELS1_M_CONST_TMP_VAR(OP, CODE, OP2M) \
- SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _VAR, _NULL)
+ SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _VAR, _NULL, _NULL)
# define SPEC_LABELS1_M_CONST_TMP_VAR_UNUSED(OP, CODE, OP2M) \
- SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _VAR, _UNUSED)
-
-# define SPEC_LABELS2_M_ANY(OP, CODE, OP1C, OP1T, OP1V, OP1U) \
- SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _ANY, _ANY, _ANY, _ANY)
-# define SPEC_LABELS2_M_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U) \
- SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _NULL, _NULL, _UNUSED)
-# define SPEC_LABELS2_M_VAR(OP, CODE, OP1C, OP1T, OP1V, OP1U) \
- SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _NULL, _VAR, _NULL)
-# define SPEC_LABELS2_M_VAR_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U) \
- SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _NULL, _VAR, _UNUSED)
-# define SPEC_LABELS2_M_TMP(OP, CODE, OP1C, OP1T, OP1V, OP1U) \
- SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _TMP, _NULL, _NULL)
-# define SPEC_LABELS2_M_TMP_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U) \
- SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _TMP, _NULL, _UNUSED)
-# define SPEC_LABELS2_M_TMP_VAR(OP, CODE, OP1C, OP1T, OP1V, OP1U) \
- SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _TMP, _VAR, _NULL)
-# define SPEC_LABELS2_M_TMP_VAR_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U) \
- SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _TMP, _VAR, _UNUSED)
-# define SPEC_LABELS2_M_CONST(OP, CODE, OP1C, OP1T, OP1V, OP1U) \
- SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _NULL, _NULL, _NULL)
-# define SPEC_LABELS2_M_CONST_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U) \
- SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _NULL, _NULL, _UNUSED)
-# define SPEC_LABELS2_M_CONST_VAR(OP, CODE, OP1C, OP1T, OP1V, OP1U) \
- SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _NULL, _VAR, _NULL)
-# define SPEC_LABELS2_M_CONST_VAR_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U) \
- SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _NULL, _VAR, _UNUSED)
-# define SPEC_LABELS2_M_CONST_TMP(OP, CODE, OP1C, OP1T, OP1V, OP1U) \
- SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _TMP, _NULL, _NULL)
-# define SPEC_LABELS2_M_CONST_TMP_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U) \
- SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _TMP, _NULL, _UNUSED)
-# define SPEC_LABELS2_M_CONST_TMP_VAR(OP, CODE, OP1C, OP1T, OP1V, OP1U) \
- SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _TMP, _VAR, _NULL)
-# define SPEC_LABELS2_M_CONST_TMP_VAR_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U) \
- SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _TMP, _VAR, _UNUSED)
-
-# define LABELS_1(OP,CODE,OP1,OP2C,OP2T,OP2V,OP2U) \
+ SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _VAR, _UNUSED, _NULL)
+# define SPEC_LABELS1_M_CV(OP, CODE, OP2M) \
+ SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _NULL, _NULL, _NULL, _CV)
+# define SPEC_LABELS1_M_UNUSED_CV(OP, CODE, OP2M) \
+ SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _NULL, _NULL, _UNUSED, _CV)
+# define SPEC_LABELS1_M_VAR_CV(OP, CODE, OP2M) \
+ SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _NULL, _VAR, _NULL, _CV)
+# define SPEC_LABELS1_M_VAR_UNUSED_CV(OP, CODE, OP2M) \
+ SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _NULL, _VAR, _UNUSED, _CV)
+# define SPEC_LABELS1_M_TMP_CV(OP, CODE, OP2M) \
+ SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _NULL, _NULL, _CV)
+# define SPEC_LABELS1_M_TMP_UNUSED_CV(OP, CODE, OP2M) \
+ SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _NULL, _UNUSED, _CV)
+# define SPEC_LABELS1_M_TMP_VAR_CV(OP, CODE, OP2M) \
+ SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _VAR, _NULL, _CV)
+# define SPEC_LABELS1_M_TMP_VAR_UNUSED_CV(OP, CODE, OP2M) \
+ SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _VAR, _UNUSED, _CV)
+# define SPEC_LABELS1_M_CONST_CV(OP, CODE, OP2M) \
+ SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _NULL, _NULL, _CV)
+# define SPEC_LABELS1_M_CONST_UNUSED_CV(OP, CODE, OP2M) \
+ SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _NULL, _UNUSED, _CV)
+# define SPEC_LABELS1_M_CONST_VAR_CV(OP, CODE, OP2M) \
+ SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _VAR, _NULL, _CV)
+# define SPEC_LABELS1_M_CONST_VAR_UNUSED_CV(OP, CODE, OP2M) \
+ SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _VAR, _UNUSED, _CV)
+# define SPEC_LABELS1_M_CONST_TMP_CV(OP, CODE, OP2M) \
+ SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _NULL, _NULL, _CV)
+# define SPEC_LABELS1_M_CONST_TMP_UNUSED_CV(OP, CODE, OP2M) \
+ SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _NULL, _UNUSED, _CV)
+# define SPEC_LABELS1_M_CONST_TMP_VAR_CV(OP, CODE, OP2M) \
+ SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _VAR, _NULL, _CV)
+# define SPEC_LABELS1_M_CONST_TMP_VAR_UNUSED_CV(OP, CODE, OP2M) \
+ SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _VAR, _UNUSED, _CV)
+
+# define SPEC_LABELS2_M_ANY(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _ANY, _ANY, _ANY, _ANY, _NULL)
+# define SPEC_LABELS2_M_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _NULL, _NULL, _UNUSED, _NULL)
+# define SPEC_LABELS2_M_VAR(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _NULL, _VAR, _NULL, _NULL)
+# define SPEC_LABELS2_M_VAR_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _NULL, _VAR, _UNUSED, _NULL)
+# define SPEC_LABELS2_M_TMP(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _TMP, _NULL, _NULL, _NULL)
+# define SPEC_LABELS2_M_TMP_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _TMP, _NULL, _UNUSED, _NULL)
+# define SPEC_LABELS2_M_TMP_VAR(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _TMP, _VAR, _NULL, _NULL)
+# define SPEC_LABELS2_M_TMP_VAR_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _TMP, _VAR, _UNUSED, _NULL)
+# define SPEC_LABELS2_M_CONST(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _NULL, _NULL, _NULL, _NULL)
+# define SPEC_LABELS2_M_CONST_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _NULL, _NULL, _UNUSED, _NULL)
+# define SPEC_LABELS2_M_CONST_VAR(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _NULL, _VAR, _NULL, _NULL)
+# define SPEC_LABELS2_M_CONST_VAR_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _NULL, _VAR, _UNUSED, _NULL)
+# define SPEC_LABELS2_M_CONST_TMP(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _TMP, _NULL, _NULL, _NULL)
+# define SPEC_LABELS2_M_CONST_TMP_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _TMP, _NULL, _UNUSED, _NULL)
+# define SPEC_LABELS2_M_CONST_TMP_VAR(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _TMP, _VAR, _NULL, _NULL)
+# define SPEC_LABELS2_M_CONST_TMP_VAR_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _TMP, _VAR, _UNUSED, _NULL)
+# define SPEC_LABELS2_M_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _NULL, _NULL, _NULL, _CV)
+# define SPEC_LABELS2_M_UNUSED_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _NULL, _NULL, _UNUSED, _CV)
+# define SPEC_LABELS2_M_VAR_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _NULL, _VAR, _NULL, _CV)
+# define SPEC_LABELS2_M_VAR_UNUSED_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _NULL, _VAR, _UNUSED, _CV)
+# define SPEC_LABELS2_M_TMP_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _TMP, _NULL, _NULL, _CV)
+# define SPEC_LABELS2_M_TMP_UNUSED_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _TMP, _NULL, _UNUSED, _CV)
+# define SPEC_LABELS2_M_TMP_VAR_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _TMP, _VAR, _NULL, _CV)
+# define SPEC_LABELS2_M_TMP_VAR_UNUSED_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _TMP, _VAR, _UNUSED, _CV)
+# define SPEC_LABELS2_M_CONST_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _NULL, _NULL, _NULL, _CV)
+# define SPEC_LABELS2_M_CONST_UNUSED_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _NULL, _NULL, _UNUSED, _CV)
+# define SPEC_LABELS2_M_CONST_VAR_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _NULL, _VAR, _NULL, _CV)
+# define SPEC_LABELS2_M_CONST_VAR_UNUSED_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _NULL, _VAR, _UNUSED, _CV)
+# define SPEC_LABELS2_M_CONST_TMP_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _TMP, _NULL, _NULL, _CV)
+# define SPEC_LABELS2_M_CONST_TMP_UNUSED_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _TMP, _NULL, _UNUSED, _CV)
+# define SPEC_LABELS2_M_CONST_TMP_VAR_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _TMP, _VAR, _NULL, _CV)
+# define SPEC_LABELS2_M_CONST_TMP_VAR_UNUSED_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
+ SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _TMP, _VAR, _UNUSED, _CV)
+
+# define LABELS_1(OP,CODE,OP1,OP2C,OP2T,OP2V,OP2U,OP2X) \
OP1##OP2C(OP,CODE), \
OP1##OP2T(OP,CODE), \
OP1##OP2V(OP,CODE), \
- OP1##OP2U(OP,CODE)
+ OP1##OP2U(OP,CODE), \
+ OP1##OP2X(OP,CODE)
-# define SPEC_LABELS(OP,CODE,OP1C,OP1T,OP1V,OP1U,OP2C,OP2T,OP2V,OP2U) \
- LABELS_1(OP,CODE,SPEC_LABEL##OP1C,OP2C,OP2T,OP2V,OP2U), \
- LABELS_1(OP,CODE,SPEC_LABEL##OP1T,OP2C,OP2T,OP2V,OP2U), \
- LABELS_1(OP,CODE,SPEC_LABEL##OP1V,OP2C,OP2T,OP2V,OP2U), \
- LABELS_1(OP,CODE,SPEC_LABEL##OP1U,OP2C,OP2T,OP2V,OP2U)
+# define SPEC_LABELS(OP,CODE,OP1C,OP1T,OP1V,OP1U,OP1X,OP2C,OP2T,OP2V,OP2U,OP2X) \
+ LABELS_1(OP,CODE,SPEC_LABEL##OP1C,OP2C,OP2T,OP2V,OP2U,OP2X), \
+ LABELS_1(OP,CODE,SPEC_LABEL##OP1T,OP2C,OP2T,OP2V,OP2U,OP2X), \
+ LABELS_1(OP,CODE,SPEC_LABEL##OP1V,OP2C,OP2T,OP2V,OP2U,OP2X), \
+ LABELS_1(OP,CODE,SPEC_LABEL##OP1U,OP2C,OP2T,OP2V,OP2U,OP2X), \
+ LABELS_1(OP,CODE,SPEC_LABEL##OP1X,OP2C,OP2T,OP2V,OP2U,OP2X)
# define SPEC_LABEL_CONST_NULL(OP,CODE) ZEND_VM_SPEC_NULL_LABEL
# define SPEC_LABEL_TMP_NULL(OP,CODE) ZEND_VM_SPEC_NULL_LABEL
# define SPEC_LABEL_VAR_NULL(OP,CODE) ZEND_VM_SPEC_NULL_LABEL
# define SPEC_LABEL_UNUSED_NULL(OP,CODE) ZEND_VM_SPEC_NULL_LABEL
+# define SPEC_LABEL_CV_NULL(OP,CODE) ZEND_VM_SPEC_NULL_LABEL
# define SPEC_LABEL_ANY_NULL(OP,CODE) ZEND_VM_SPEC_NULL_LABEL
# define SPEC_LABEL_NULL_CONST(OP,CODE) ZEND_VM_SPEC_NULL_LABEL
# define SPEC_LABEL_NULL_TMP(OP,CODE) ZEND_VM_SPEC_NULL_LABEL
# define SPEC_LABEL_NULL_VAR(OP,CODE) ZEND_VM_SPEC_NULL_LABEL
# define SPEC_LABEL_NULL_UNUSED(OP,CODE) ZEND_VM_SPEC_NULL_LABEL
+# define SPEC_LABEL_NULL_CV(OP,CODE) ZEND_VM_SPEC_NULL_LABEL
# define SPEC_LABEL_NULL_ANY(OP,CODE) ZEND_VM_SPEC_NULL_LABEL
# define SPEC_LABEL_NULL_NULL(OP,CODE) ZEND_VM_SPEC_NULL_LABEL
# define SPEC_LABEL_ANY_ANY(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_ANY_VAR, ZEND_VM_CODE(CODE, _ANY_CODE, _VAR_CODE))
# define SPEC_LABEL_ANY_UNUSED(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_ANY_UNUSED, ZEND_VM_CODE(CODE, _ANY_CODE, _UNUSED_CODE))
+# define SPEC_LABEL_ANY_CV(OP,CODE) \
+ ZEND_VM_SPEC_LABEL(OP##_ANY_CV, ZEND_VM_CODE(CODE, _ANY_CODE, _CV_CODE))
# define SPEC_LABEL_CONST_ANY(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_CONST_ANY, ZEND_VM_CODE(CODE, _CONST_CODE, _ANY_CODE))
# define SPEC_LABEL_CONST_CONST(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_CONST_VAR, ZEND_VM_CODE(CODE, _CONST_CODE, _VAR_CODE))
# define SPEC_LABEL_CONST_UNUSED(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_CONST_UNUSED, ZEND_VM_CODE(CODE, _CONST_CODE, _UNUSED_CODE))
+# define SPEC_LABEL_CONST_CV(OP,CODE) \
+ ZEND_VM_SPEC_LABEL(OP##_CONST_CV, ZEND_VM_CODE(CODE, _CONST_CODE, _CV_CODE))
# define SPEC_LABEL_TMP_ANY(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_TMP_ANY, ZEND_VM_CODE(CODE, _TMP_CODE, _ANY_CODE))
# define SPEC_LABEL_TMP_CONST(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_TMP_VAR, ZEND_VM_CODE(CODE, _TMP_CODE, _VAR_CODE))
# define SPEC_LABEL_TMP_UNUSED(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_TMP_UNUSED, ZEND_VM_CODE(CODE, _TMP_CODE, _UNUSED_CODE))
+# define SPEC_LABEL_TMP_CV(OP,CODE) \
+ ZEND_VM_SPEC_LABEL(OP##_TMP_CV, ZEND_VM_CODE(CODE, _TMP_CODE, _CV_CODE))
# define SPEC_LABEL_VAR_ANY(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_VAR_ANY, ZEND_VM_CODE(CODE, _VAR_CODE, _ANY_CODE))
# define SPEC_LABEL_VAR_CONST(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_VAR_VAR, ZEND_VM_CODE(CODE, _VAR_CODE, _VAR_CODE))
# define SPEC_LABEL_VAR_UNUSED(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_VAR_UNUSED, ZEND_VM_CODE(CODE, _VAR_CODE, _UNUSED_CODE))
+# define SPEC_LABEL_VAR_CV(OP,CODE) \
+ ZEND_VM_SPEC_LABEL(OP##_VAR_CV, ZEND_VM_CODE(CODE, _VAR_CODE, _CV_CODE))
# define SPEC_LABEL_UNUSED_ANY(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_UNUSED_ANY, ZEND_VM_CODE(CODE, _UNUSED_CODE, _ANY_CODE))
# define SPEC_LABEL_UNUSED_CONST(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_UNUSED_VAR, ZEND_VM_CODE(CODE, _UNUSED_CODE, _VAR_CODE))
# define SPEC_LABEL_UNUSED_UNUSED(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_UNUSED_UNUSED, ZEND_VM_CODE(CODE, _UNUSED_CODE, _UNUSED_CODE))
+# define SPEC_LABEL_UNUSED_CV(OP,CODE) \
+ ZEND_VM_SPEC_LABEL(OP##_UNUSED_CV, ZEND_VM_CODE(CODE, _UNUSED_CODE, _CV_CODE))
+# define SPEC_LABEL_CV_ANY(OP,CODE) \
+ ZEND_VM_SPEC_LABEL(OP##_CV_ANY, ZEND_VM_CODE(CODE, _CV_CODE, _ANY_CODE))
+# define SPEC_LABEL_CV_CONST(OP,CODE) \
+ ZEND_VM_SPEC_LABEL(OP##_CV_CONST, ZEND_VM_CODE(CODE, _CV_CODE, _CONST_CODE))
+# define SPEC_LABEL_CV_TMP(OP,CODE) \
+ ZEND_VM_SPEC_LABEL(OP##_CV_TMP, ZEND_VM_CODE(CODE, _CV_CODE, _TMP_CODE))
+# define SPEC_LABEL_CV_VAR(OP,CODE) \
+ ZEND_VM_SPEC_LABEL(OP##_CV_VAR, ZEND_VM_CODE(CODE, _CV_CODE, _VAR_CODE))
+# define SPEC_LABEL_CV_UNUSED(OP,CODE) \
+ ZEND_VM_SPEC_LABEL(OP##_CV_UNUSED, ZEND_VM_CODE(CODE, _CV_CODE, _UNUSED_CODE))
+# define SPEC_LABEL_CV_CV(OP,CODE) \
+ ZEND_VM_SPEC_LABEL(OP##_CV_CV, ZEND_VM_CODE(CODE, _CV_CODE, _CV_CODE))
# undef ZEND_VM_NULL_LABEL
# define ZEND_VM_NULL_LABEL \
ZEND_VM_SPEC_NULL_LABEL, \
ZEND_VM_SPEC_NULL_LABEL, \
ZEND_VM_SPEC_NULL_LABEL, \
+ ZEND_VM_SPEC_NULL_LABEL, \
+ ZEND_VM_SPEC_NULL_LABEL, \
+ ZEND_VM_SPEC_NULL_LABEL, \
+ ZEND_VM_SPEC_NULL_LABEL, \
+ ZEND_VM_SPEC_NULL_LABEL, \
+ ZEND_VM_SPEC_NULL_LABEL, \
+ ZEND_VM_SPEC_NULL_LABEL, \
+ ZEND_VM_SPEC_NULL_LABEL, \
+ ZEND_VM_SPEC_NULL_LABEL, \
ZEND_VM_SPEC_NULL_LABEL
# undef ZEND_VM_LABEL
#endif
-#if defined(ZEND_VM_SPEC) && (ZEND_VM_KIND == ZEND_VM_KIND_CALL)
+#if defined(ZEND_VM_HAVE_OLD_EXECUTOR) && defined(ZEND_VM_SPEC) && (ZEND_VM_KIND == ZEND_VM_KIND_CALL)
ZEND_VM_NULL_HANDLER();
#else
ZEND_VM_NULL_HANDLER()
zval *session_vars = NULL;
/* Unconditionally destroy existing arrays -- possible dirty data */
- zend_hash_del(&EG(symbol_table), "HTTP_SESSION_VARS",
- sizeof("HTTP_SESSION_VARS"));
- zend_hash_del(&EG(symbol_table), "_SESSION", sizeof("_SESSION"));
+ delete_global_variable("HTTP_SESSION_VARS", sizeof("HTTP_SESSION_VARS")-1 TSRMLS_CC);
+ delete_global_variable("_SESSION", sizeof("_SESSION")-1 TSRMLS_CC);
MAKE_STD_ZVAL(session_vars);
array_init(session_vars);
while (zend_hash_get_current_key_ex(ht, &str, &str_len, &num_key,
0, &pos) == HASH_KEY_IS_STRING) {
- zend_hash_del(&EG(symbol_table), str, str_len);
+ delete_global_variable(str, str_len-1 TSRMLS_CC);
zend_hash_move_forward_ex(ht, &pos);
}
}
switch(Z_TYPE_P(offset)) {
case IS_STRING:
- if (zend_symtable_del(HASH_OF(intern->array), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1) == FAILURE) {
- zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset));
+ if (HASH_OF(intern->array) == &EG(symbol_table)) {
+ if (delete_global_variable(Z_STRVAL_P(offset), Z_STRLEN_P(offset) TSRMLS_CC)) {
+ zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset));
+ }
+ } else {
+ if (zend_symtable_del(HASH_OF(intern->array), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1) == FAILURE) {
+ zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset));
+ }
}
return;
case IS_DOUBLE:
/* Delete the first or last value */
zend_hash_get_current_key_ex(Z_ARRVAL_PP(stack), &key, &key_len, &index, 0, NULL);
- zend_hash_del_key_or_index(Z_ARRVAL_PP(stack), key, key_len, index, (key) ? HASH_DEL_KEY : HASH_DEL_INDEX);
+ if (key && Z_ARRVAL_PP(stack) == &EG(symbol_table)) {
+ delete_global_variable(key, key_len-1 TSRMLS_CC);
+ } else {
+ zend_hash_del_key_or_index(Z_ARRVAL_PP(stack), key, key_len, index, (key) ? HASH_DEL_KEY : HASH_DEL_INDEX);
+ }
/* If we did a shift... re-index like it did before */
if (!off_the_end) {
p = cmpdata->b;
}
if (p->nKeyLength) {
- zend_hash_del(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength);
+ if (Z_ARRVAL_P(return_value) == &EG(symbol_table)) {
+ delete_global_variable(p->arKey, p->nKeyLength-1 TSRMLS_CC);
+ } else {
+ zend_hash_del(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength);
+ }
} else {
zend_hash_index_del(Z_ARRVAL_P(return_value), p->h);
}
memcpy(new_key, prefix, prefix_len);
memcpy(new_key+prefix_len, hash_key->arKey, hash_key->nKeyLength);
- zend_hash_del(&EG(symbol_table), new_key, new_key_len);
+ delete_global_variable(new_key, new_key_len-1 TSRMLS_CC);
ZEND_SET_SYMBOL_WITH_LENGTH(&EG(symbol_table), new_key, new_key_len, *var, (*var)->refcount+1, 0);
efree(new_key);
projects / php / commitdiff