indent += PRINT_ZVAL_INDENT;
zend_hash_internal_pointer_reset_ex(ht, &iterator);
while ((tmp = zend_hash_get_current_data_ex(ht, &iterator)) != NULL) {
+ if (Z_TYPE_P(tmp) == IS_INDIRECT) {
+ tmp = Z_INDIRECT_P(tmp);
+ if (Z_TYPE_P(tmp) == IS_UNDEF) {
+ zend_hash_move_forward_ex(ht, &iterator);
+ continue;
+ }
+ }
for (i = 0; i < indent; i++) {
ZEND_PUTS_EX(" ");
}
}
/* }}} */
+ZEND_API void object_properties_init_ex(zend_object *object, HashTable *properties) /* {{{ */
+{
+ object->properties = properties;
+ if (object->ce->default_properties_count) {
+ HashPosition pos;
+ zval *prop, tmp;
+ zend_string *key;
+ ulong num_key;
+ zend_property_info *property_info;
+
+ for (zend_hash_internal_pointer_reset_ex(properties, &pos);
+ (prop = zend_hash_get_current_data_ex(properties, &pos)) != NULL &&
+ zend_hash_get_current_key_ex(properties, &key, &num_key, 0, &pos) == HASH_KEY_IS_STRING;
+ zend_hash_move_forward_ex(properties, &pos)) {
+
+ ZVAL_STR(&tmp, key);
+ property_info = zend_get_property_info(object->ce, &tmp, 1 TSRMLS_CC);
+ if (property_info &&
+ (property_info->flags & ZEND_ACC_STATIC) == 0 &&
+ property_info->offset >= 0) {
+ ZVAL_COPY_VALUE(&object->properties_table[property_info->offset], prop);
+ ZVAL_INDIRECT(prop, &object->properties_table[property_info->offset]);
+ }
+ }
+ }
+}
+/* }}} */
+
+ZEND_API void object_properties_load(zend_object *object, HashTable *properties) /* {{{ */
+{
+ HashPosition pos;
+ zval *prop, tmp;
+ zend_string *key;
+ ulong num_key;
+ zend_property_info *property_info;
+
+ for (zend_hash_internal_pointer_reset_ex(properties, &pos);
+ (prop = zend_hash_get_current_data_ex(properties, &pos)) != NULL &&
+ zend_hash_get_current_key_ex(properties, &key, &num_key, 0, &pos) == HASH_KEY_IS_STRING;
+ zend_hash_move_forward_ex(properties, &pos)) {
+
+ ZVAL_STR(&tmp, key);
+ property_info = zend_get_property_info(object->ce, &tmp, 1 TSRMLS_CC);
+ if (property_info &&
+ (property_info->flags & ZEND_ACC_STATIC) == 0 &&
+ property_info->offset >= 0) {
+ zval_ptr_dtor(&object->properties_table[property_info->offset]);
+ ZVAL_COPY_VALUE(&object->properties_table[property_info->offset], prop);
+ zval_add_ref(&object->properties_table[property_info->offset]);
+ if (object->properties) {
+ ZVAL_INDIRECT(&tmp, &object->properties_table[property_info->offset]);
+ prop = zend_hash_update(object->properties, key, &tmp);
+ }
+ } else {
+ if (!object->properties) {
+ rebuild_object_properties(object);
+ }
+ prop = zend_hash_update(object->properties, key, prop);
+ zval_add_ref(prop);
+ }
+ }
+}
+/* }}} */
+
/* This function requires 'properties' to contain all props declared in the
* class and all props being public. If only a subset is given or the class
* has protected members then you need to merge the properties separately by
if (class_type->create_object == NULL) {
ZVAL_OBJ(arg, zend_objects_new(class_type TSRMLS_CC));
if (properties) {
- Z_OBJ_P(arg)->properties = properties;
-//??? Z_OBJ_P(arg)->properties_table = NULL;
+ object_properties_init_ex(Z_OBJ_P(arg), properties);
} else {
object_properties_init(Z_OBJ_P(arg), class_type);
}
ZEND_API int _object_init_ex(zval *arg, zend_class_entry *ce ZEND_FILE_LINE_DC TSRMLS_DC);
ZEND_API int _object_and_properties_init(zval *arg, zend_class_entry *ce, HashTable *properties ZEND_FILE_LINE_DC TSRMLS_DC);
ZEND_API void object_properties_init(zend_object *object, zend_class_entry *class_type);
+ZEND_API void object_properties_init_ex(zend_object *object, HashTable *properties);
+ZEND_API void object_properties_load(zend_object *object, HashTable *properties);
ZEND_API void zend_merge_properties(zval *obj, HashTable *properties, int destroy_ht TSRMLS_DC);
ZEND_API int zend_set_hash_symbol(zval *symbol, const char *name, int name_length, zend_bool is_ref, int num_symbol_tables, ...);
-ZEND_API void zend_delete_variable(zend_execute_data *ex, HashTable *ht, zend_string *name TSRMLS_DC);
-
ZEND_API int zend_delete_global_variable(zend_string *name TSRMLS_DC);
-ZEND_API void zend_reset_all_cv(zend_array *symbol_table TSRMLS_DC);
-
ZEND_API void zend_rebuild_symbol_table(TSRMLS_D);
+ZEND_API void zend_attach_symbol_table(TSRMLS_D);
+ZEND_API void zend_detach_symbol_table(TSRMLS_D);
+ZEND_API int zend_set_local_var(const char *name, int len, zval *value, int force TSRMLS_DC);
ZEND_API zend_string *zend_find_alias_name(zend_class_entry *ce, zend_string *name);
ZEND_API zend_string *zend_resolve_method_name(zend_class_entry *ce, zend_function *f);
zend_error(E_WARNING,"Variable passed to each() is not an array or object");
return;
}
- entry = zend_hash_get_current_data(target_hash);
- if (!entry) {
- RETURN_FALSE;
+ while (1) {
+ entry = zend_hash_get_current_data(target_hash);
+ if (!entry) {
+ RETURN_FALSE;
+ } else if (Z_TYPE_P(entry) == IS_INDIRECT) {
+ entry = Z_INDIRECT_P(entry);
+ if (Z_TYPE_P(entry) == IS_UNDEF) {
+ zend_hash_move_forward(target_hash);
+ continue;
+ }
+ }
+ break;
}
array_init(return_value);
zend_hash_internal_pointer_reset_ex(properties, &pos);
while ((value = zend_hash_get_current_data_ex(properties, &pos)) != NULL) {
+ if (Z_TYPE_P(value) == IS_INDIRECT) {
+ value = Z_INDIRECT_P(value);
+ if (Z_TYPE_P(value) == IS_UNDEF) {
+ zend_hash_move_forward_ex(properties, &pos);
+ continue;
+ }
+ }
if (zend_hash_get_current_key_ex(properties, &key, &num_index, 0, &pos) == HASH_KEY_IS_STRING) {
if (zend_check_property_access(zobj, key TSRMLS_CC) == SUCCESS) {
zend_unmangle_property_name_ex(key->val, key->len, &class_name, &prop_name, (int*) &prop_len);
static zend_never_inline zval *_get_zval_cv_lookup(zval *ptr, zend_uint var, int type TSRMLS_DC)
{
- zend_string *cv = CV_DEF_OF(var);
- zval *ret = NULL;
-
- if (EG(active_symbol_table)) {
- ret = zend_hash_find(&EG(active_symbol_table)->ht, cv);
- if (ret) {
- ZVAL_INDIRECT(ptr, ret);
- return ret;
- }
- }
+ zend_string *cv;
switch (type) {
case BP_VAR_R:
case BP_VAR_UNSET:
+ cv = CV_DEF_OF(var);
zend_error(E_NOTICE, "Undefined variable: %s", cv->val);
/* break missing intentionally */
case BP_VAR_IS:
- return &EG(uninitialized_zval);
+ ptr = &EG(uninitialized_zval);
+ break;
case BP_VAR_RW:
+ cv = CV_DEF_OF(var);
zend_error(E_NOTICE, "Undefined variable: %s", cv->val);
/* break missing intentionally */
case BP_VAR_W:
- if (EG(active_symbol_table)) {
- ret = zend_hash_update(&EG(active_symbol_table)->ht, cv, ret);
- ZVAL_INDIRECT(ptr, ret);
- } else {
- ZVAL_NULL(ptr);
- ret = ptr;
- }
+ ZVAL_NULL(ptr);
break;
}
- return ret;
+ return ptr;
}
static zend_never_inline zval *_get_zval_cv_lookup_BP_VAR_R(zval *ptr, zend_uint var TSRMLS_DC)
{
zend_string *cv = CV_DEF_OF(var);
- zval *ret = NULL;
-
- if (EG(active_symbol_table)) {
- ret = zend_hash_find(&EG(active_symbol_table)->ht, cv);
- if (ret) {
- ZVAL_INDIRECT(ptr, ret);
- return ret;
- }
- }
zend_error(E_NOTICE, "Undefined variable: %s", cv->val);
return &EG(uninitialized_zval);
static zend_never_inline zval *_get_zval_cv_lookup_BP_VAR_UNSET(zval *ptr, zend_uint var TSRMLS_DC)
{
zend_string *cv = CV_DEF_OF(var);
- zval *ret;
-
- if (EG(active_symbol_table)) {
- ret = zend_hash_find(&EG(active_symbol_table)->ht, cv);
- if (ret) {
- ZVAL_INDIRECT(ptr, ret);
- return ret;
- }
- }
zend_error(E_NOTICE, "Undefined variable: %s", cv->val);
return &EG(uninitialized_zval);
static zend_never_inline zval *_get_zval_cv_lookup_BP_VAR_IS(zval *ptr, zend_uint var TSRMLS_DC)
{
- zend_string *cv = CV_DEF_OF(var);
- zval *ret;
-
- if (EG(active_symbol_table)) {
- ret = zend_hash_find(&EG(active_symbol_table)->ht, cv);
- if (ret) {
- ZVAL_INDIRECT(ptr, ret);
- return ret;
- }
- }
-
return &EG(uninitialized_zval);
}
static zend_never_inline zval *_get_zval_cv_lookup_BP_VAR_RW(zval *ptr, zend_uint var TSRMLS_DC)
{
zend_string *cv = CV_DEF_OF(var);
- zval *ret;
- if (EG(active_symbol_table)) {
- ret = zend_hash_find(&EG(active_symbol_table)->ht, cv);
- if (ret) {
- ZVAL_INDIRECT(ptr, ret);
- return ret;
- }
- ret = zend_hash_update(&EG(active_symbol_table)->ht, cv, &EG(uninitialized_zval));
- ZVAL_INDIRECT(ptr, ret);
- zend_error(E_NOTICE, "Undefined variable: %s", cv->val);
- return ret;
- } else {
- ZVAL_NULL(ptr);
- zend_error(E_NOTICE, "Undefined variable: %s", cv->val);
- return ptr;
- }
+ ZVAL_NULL(ptr);
+ zend_error(E_NOTICE, "Undefined variable: %s", cv->val);
+ return ptr;
}
static zend_never_inline zval *_get_zval_cv_lookup_BP_VAR_W(zval *ptr, zend_uint var TSRMLS_DC)
{
- zend_string *cv = CV_DEF_OF(var);
- zval *ret;
-
- if (EG(active_symbol_table)) {
- ret = zend_hash_find(&EG(active_symbol_table)->ht, cv);
- if (ret) {
- ZVAL_INDIRECT(ptr, ret);
- return ret;
- }
- ret = zend_hash_update(&EG(active_symbol_table)->ht, cv, &EG(uninitialized_zval));
- ZVAL_INDIRECT(ptr, ret);
- return ret;
- } else {
- ZVAL_NULL(ptr);
- return ptr;
- }
+ ZVAL_NULL(ptr);
+ return ptr;
}
static zend_always_inline zval *_get_zval_ptr_cv(zend_uint var, int type TSRMLS_DC)
if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
return _get_zval_cv_lookup(ret, var, type TSRMLS_CC);
- } else if (UNEXPECTED(Z_TYPE_P(ret) == IS_INDIRECT)) {
- ret = Z_INDIRECT_P(ret);
}
return ret;
}
if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
return _get_zval_cv_lookup(ret, var, type TSRMLS_CC);
- } else if (UNEXPECTED(Z_TYPE_P(ret) == IS_INDIRECT)) {
- ret = Z_INDIRECT_P(ret);
}
if (UNEXPECTED(Z_TYPE_P(ret) == IS_REFERENCE)) {
ret = Z_REFVAL_P(ret);
if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
return _get_zval_cv_lookup_BP_VAR_R(ret, var TSRMLS_CC);
- } else if (UNEXPECTED(Z_TYPE_P(ret) == IS_INDIRECT)) {
- ret = Z_INDIRECT_P(ret);
}
return ret;
}
if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
return _get_zval_cv_lookup_BP_VAR_R(ret, var TSRMLS_CC);
- } else if (UNEXPECTED(Z_TYPE_P(ret) == IS_INDIRECT)) {
- ret = Z_INDIRECT_P(ret);
}
if (UNEXPECTED(Z_TYPE_P(ret) == IS_REFERENCE)) {
ret = Z_REFVAL_P(ret);
if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
return _get_zval_cv_lookup_BP_VAR_UNSET(ret, var TSRMLS_CC);
- } else if (UNEXPECTED(Z_TYPE_P(ret) == IS_INDIRECT)) {
- ret = Z_INDIRECT_P(ret);
}
return ret;
}
if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
return _get_zval_cv_lookup_BP_VAR_UNSET(ret, var TSRMLS_CC);
- } else if (UNEXPECTED(Z_TYPE_P(ret) == IS_INDIRECT)) {
- ret = Z_INDIRECT_P(ret);
}
if (UNEXPECTED(Z_TYPE_P(ret) == IS_REFERENCE)) {
ret = Z_REFVAL_P(ret);
if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
return _get_zval_cv_lookup_BP_VAR_IS(ret, var TSRMLS_CC);
- } else if (UNEXPECTED(Z_TYPE_P(ret) == IS_INDIRECT)) {
- ret = Z_INDIRECT_P(ret);
}
return ret;
}
if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
return _get_zval_cv_lookup_BP_VAR_IS(ret, var TSRMLS_CC);
- } else if (UNEXPECTED(Z_TYPE_P(ret) == IS_INDIRECT)) {
- ret = Z_INDIRECT_P(ret);
}
if (UNEXPECTED(Z_TYPE_P(ret) == IS_REFERENCE)) {
ret = Z_REFVAL_P(ret);
if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
return _get_zval_cv_lookup_BP_VAR_RW(ret, var TSRMLS_CC);
- } else if (UNEXPECTED(Z_TYPE_P(ret) == IS_INDIRECT)) {
- ret = Z_INDIRECT_P(ret);
}
return ret;
}
if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
return _get_zval_cv_lookup_BP_VAR_RW(ret, var TSRMLS_CC);
- } else if (UNEXPECTED(Z_TYPE_P(ret) == IS_INDIRECT)) {
- ret = Z_INDIRECT_P(ret);
}
if (UNEXPECTED(Z_TYPE_P(ret) == IS_REFERENCE)) {
ret = Z_REFVAL_P(ret);
if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
return _get_zval_cv_lookup_BP_VAR_W(ret, var TSRMLS_CC);
- } else if (UNEXPECTED(Z_TYPE_P(ret) == IS_INDIRECT)) {
- ret = Z_INDIRECT_P(ret);
}
return ret;
}
if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
return _get_zval_cv_lookup_BP_VAR_W(ret, var TSRMLS_CC);
- } else if (UNEXPECTED(Z_TYPE_P(ret) == IS_INDIRECT)) {
- ret = Z_INDIRECT_P(ret);
}
if (UNEXPECTED(Z_TYPE_P(ret) == IS_REFERENCE)) {
ret = Z_REFVAL_P(ret);
}
Z_ADDREF_P(object);
zend_error(E_WARNING, "Creating default object from empty value");
-//???
- if (Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
if (Z_REFCOUNT_P(object) == 1) {
/* object was removed by error handler, nothing to assign to */
zval_ptr_dtor(object);
Z_DELREF_P(object);
} else {
zend_error(E_WARNING, "Creating default object from empty value");
-//???
- if (Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
}
zval_dtor(object);
object_init(object);
}
fetch_string_dim:
retval = zend_hash_find(ht, offset_key);
- if (retval == NULL) {
+// ??? support for $GLOBALS[...]
+ if (retval) {
+ if (Z_TYPE_P(retval) == IS_INDIRECT) {
+ retval = Z_INDIRECT_P(retval);
+ if (Z_TYPE_P(retval) == IS_UNDEF) {
+ switch (type) {
+ case BP_VAR_R:
+ zend_error(E_NOTICE, "Undefined index: %s", offset_key->val);
+ /* break missing intentionally */
+ case BP_VAR_UNSET:
+ case BP_VAR_IS:
+ retval = &EG(uninitialized_zval);
+ break;
+ case BP_VAR_RW:
+ zend_error(E_NOTICE,"Undefined index: %s", offset_key->val);
+ /* break missing intentionally */
+ case BP_VAR_W:
+ ZVAL_NULL(retval);
+ break;
+ }
+ }
+ }
+ } else {
switch (type) {
case BP_VAR_R:
zend_error(E_NOTICE, "Undefined index: %s", offset_key->val);
convert_to_long(&tmp);
dim = &tmp;
}
-//??? container may became IS_INDIRECT because of symtable initialization in zend_error
- if (Z_TYPE_P(container) == IS_INDIRECT) {
- container = Z_INDIRECT_P(container);
- }
ZVAL_STR_OFFSET(result, container, Z_LVAL_P(dim));
if (!IS_INTERNED(Z_STR_P(container))) STR_ADDREF(Z_STR_P(container));
return;
op_array->run_time_cache = ecalloc(op_array->last_cache_slot, sizeof(void*));
}
+ if (EG(active_symbol_table)) {
+ zend_attach_symbol_table(TSRMLS_C);
+ }
+
if (op_array->this_var != -1 && Z_TYPE(EG(This)) != IS_UNDEF) {
- if (!EG(active_symbol_table)) {
- ZVAL_COPY(EX_VAR_NUM(op_array->this_var), &EG(This));
- } else {
- ZVAL_COPY(EX_VAR_NUM(op_array->this_var), &EG(This));
- zval *zv = zend_hash_str_add(&EG(active_symbol_table)->ht, "this", sizeof("this")-1, EX_VAR(op_array->this_var));
- if (zv) {
- ZVAL_INDIRECT(EX_VAR_NUM(op_array->this_var), zv);
- }
- }
+ ZVAL_COPY(EX_VAR_NUM(op_array->this_var), &EG(This));
}
EX(opline) = UNEXPECTED((op_array->fn_flags & ZEND_ACC_INTERACTIVE) != 0) && EG(start_op) ? EG(start_op) : op_array->opcodes;
static int zval_call_destructor(zval *zv TSRMLS_DC) /* {{{ */
{
+ if (Z_TYPE_P(zv) == IS_INDIRECT) {
+ zv = Z_INDIRECT_P(zv);
+ }
if (Z_TYPE_P(zv) == IS_OBJECT && Z_REFCOUNT_P(zv) == 1) {
return ZEND_HASH_APPLY_REMOVE;
} else {
}
/* }}} */
+static int zend_unclean_zval_ptr_dtor(zval *zv) /* {{{ */
+{
+ TSRMLS_FETCH();
+
+ if (Z_TYPE_P(zv) == IS_INDIRECT) {
+ zv = Z_INDIRECT_P(zv);
+ }
+ i_zval_ptr_dtor(zv ZEND_FILE_LINE_CC TSRMLS_CC);
+}
+/* }}} */
+
void shutdown_destructors(TSRMLS_D) /* {{{ */
{
+ if (CG(unclean_shutdown)) {
+ EG(symbol_table).ht.pDestructor = zend_unclean_zval_ptr_dtor;
+ }
zend_try {
int symbols;
do {
}
*/
zend_llist_apply(&zend_extensions, (llist_apply_func_t) zend_extension_deactivator TSRMLS_CC);
+
+ if (CG(unclean_shutdown)) {
+ EG(symbol_table).ht.pDestructor = zend_unclean_zval_ptr_dtor;
+ }
zend_hash_graceful_reverse_destroy(&EG(symbol_table).ht);
} zend_end_try();
}
/* }}} */
-ZEND_API void zend_reset_all_cv(zend_array *symbol_table TSRMLS_DC) /* {{{ */
-{
- zend_execute_data *ex;
- int i;
-
- for (ex = EG(current_execute_data); ex; ex = ex->prev_execute_data) {
- if (ex->op_array && ex->symbol_table == symbol_table) {
- for (i = 0; i < ex->op_array->last_var; i++) {
- ZVAL_UNDEF(EX_VAR_NUM_2(ex, i));
- }
- }
- }
-}
-/* }}} */
-
-ZEND_API void zend_delete_variable(zend_execute_data *ex, HashTable *ht, zend_string *name TSRMLS_DC) /* {{{ */
-{
- if (zend_hash_del(ht, name) == SUCCESS) {
- while (ex && &ex->symbol_table->ht == ht) {
- int i;
-
- if (ex->op_array) {
- for (i = 0; i < ex->op_array->last_var; i++) {
- if (ex->op_array->vars[i]->h == name->h &&
- ex->op_array->vars[i]->len == name->len &&
- !memcmp(ex->op_array->vars[i]->val, name->val, name->len)) {
- ZVAL_UNDEF(EX_VAR_NUM_2(ex, i));
- break;
- }
- }
- }
- ex = ex->prev_execute_data;
- }
- }
-}
-/* }}} */
-
ZEND_API int zend_delete_global_variable(zend_string *name TSRMLS_DC) /* {{{ */
{
- zend_execute_data *ex;
-
- if (zend_hash_del(&EG(symbol_table).ht, name) == SUCCESS) {
- for (ex = EG(current_execute_data); ex; ex = ex->prev_execute_data) {
- if (ex->op_array && ex->symbol_table == &EG(symbol_table)) {
- int i;
- for (i = 0; i < ex->op_array->last_var; i++) {
- if (ex->op_array->vars[i]->h == name->h &&
- ex->op_array->vars[i]->len == name->len &&
- !memcmp(ex->op_array->vars[i]->val, name->val, name->len)
- ) {
- ZVAL_UNDEF(EX_VAR_NUM_2(ex, i));
- break;
- }
- }
- }
- }
- return SUCCESS;
- }
- return FAILURE;
+ return zend_hash_del_ind(&EG(symbol_table).ht, name);
}
/* }}} */
ZVAL_COPY_VALUE(EX_VAR_NUM_2(ex, ex->op_array->this_var), &EG(This));
}
for (i = 0; i < ex->op_array->last_var; i++) {
- if (Z_TYPE_P(EX_VAR_NUM_2(ex, i)) != IS_UNDEF) {
- zval *zv = zend_hash_update(&EG(active_symbol_table)->ht,
- ex->op_array->vars[i],
- EX_VAR_NUM_2(ex, i));
- ZVAL_INDIRECT(EX_VAR_NUM_2(ex, i), zv);
+ zval zv;
+
+ ZVAL_INDIRECT(&zv, EX_VAR_NUM_2(ex, i));
+ zend_hash_update(&EG(active_symbol_table)->ht,
+ ex->op_array->vars[i], &zv);
+ }
+ }
+ }
+}
+/* }}} */
+
+ZEND_API void zend_attach_symbol_table(TSRMLS_D) /* {{{ */
+{
+ int i;
+ zend_execute_data *execute_data = EG(current_execute_data);
+ zend_op_array *op_array = execute_data->op_array;
+ HashTable *ht = &EG(active_symbol_table)->ht;
+
+ /* copy real values from symbol table into CV slots and create
+ INDIRECT references to CV in symbol table */
+ for (i = 0; i < op_array->last_var; i++) {
+ zval *zv = zend_hash_find(ht, op_array->vars[i]);
+
+ if (zv) {
+ if (Z_TYPE_P(zv) == IS_INDIRECT) {
+ zval *val = Z_INDIRECT_P(zv);
+ if (Z_TYPE_P(val) == IS_UNDEF) {
+ ZVAL_UNDEF(EX_VAR_NUM(i));
+ } else {
+ ZVAL_COPY_VALUE(EX_VAR_NUM(i), val);
}
+ } else {
+ ZVAL_COPY_VALUE(EX_VAR_NUM(i), zv);
}
+ } else {
+ ZVAL_UNDEF(EX_VAR_NUM(i));
+ zv = zend_hash_update(ht, op_array->vars[i], EX_VAR_NUM(i));
}
+ ZVAL_INDIRECT(zv, EX_VAR_NUM(i));
}
}
/* }}} */
+ZEND_API void zend_detach_symbol_table(TSRMLS_D) /* {{{ */
+{
+ int i;
+ zend_execute_data *execute_data = EG(current_execute_data);
+ zend_op_array *op_array = execute_data->op_array;
+ HashTable *ht = &EG(active_symbol_table)->ht;
+
+ /* copy real values from CV slots into symbol table */
+ for (i = 0; i < op_array->last_var; i++) {
+ zend_hash_update(ht, op_array->vars[i], EX_VAR_NUM(i));
+ ZVAL_UNDEF(EX_VAR_NUM(i));
+ }
+}
+/* }}} */
+
+ZEND_API int zend_set_local_var(const char *name, int len, zval *value, int force TSRMLS_DC) /* {{{ */
+{
+ if (!EG(active_symbol_table)) {
+ int i;
+ zend_execute_data *execute_data = EG(current_execute_data);
+ zend_op_array *op_array = execute_data->op_array;
+ zend_ulong h = zend_hash_func(name, len);
+
+ if (op_array) {
+ for (i = 0; i < op_array->last_var; i++) {
+ if (op_array->vars[i]->h == h &&
+ op_array->vars[i]->len == len &&
+ memcmp(op_array->vars[i]->val, name, len) == 0) {
+ ZVAL_COPY_VALUE(EX_VAR_NUM(i), value);
+ return SUCCESS;
+ }
+ }
+ }
+ if (force) {
+ zend_rebuild_symbol_table(TSRMLS_C);
+ if (EG(active_symbol_table)) {
+ zend_hash_str_update(&EG(active_symbol_table)->ht, name, len, value);
+ }
+ } else {
+ return FAILURE;
+ }
+ } else {
+ return zend_hash_str_update_ind(&EG(active_symbol_table)->ht, name, len, value);
+ }
+ return SUCCESS;
+}
+/* }}} */
+
/*
* Local variables:
* tab-width: 4
p = ht->arData + idx;
if (!Z_REFCOUNTED(p->val)) {
/* count non-refcounted for compatibilty ??? */
- if (Z_TYPE(p->val) != IS_UNDEF) {
+ if (Z_TYPE(p->val) != IS_UNDEF && Z_TYPE(p->val) != IS_INDIRECT) {
count++;
}
continue;
p = zend_hash_find_bucket(ht, key);
if (p) {
+ zval *data;
+
if (flag & HASH_ADD) {
return NULL;
}
ZEND_ASSERT(&p->val != pData);
+ data = &p->val;
+ if ((flag & HASH_UPDATE_INDIRECT) && Z_TYPE_P(data) == IS_INDIRECT) {
+ data = Z_INDIRECT_P(data);
+ }
HANDLE_BLOCK_INTERRUPTIONS();
if (ht->pDestructor) {
- ht->pDestructor(&p->val);
+ ht->pDestructor(data);
}
- ZVAL_COPY_VALUE(&p->val, pData);
+ ZVAL_COPY_VALUE(data, pData);
HANDLE_UNBLOCK_INTERRUPTIONS();
- return &p->val;
+ return data;
}
ZEND_HASH_IF_FULL_DO_RESIZE(ht); /* If the Hash table is full, resize it */
return FAILURE;
}
+ZEND_API int zend_hash_del_ind(HashTable *ht, zend_string *key)
+{
+ ulong h;
+ uint nIndex;
+ uint idx;
+ Bucket *p;
+ Bucket *prev = NULL;
+#ifdef ZEND_SIGNALS
+ TSRMLS_FETCH();
+#endif
+
+ IS_CONSISTENT(ht);
+
+ if (ht->flags & HASH_FLAG_PACKED) {
+ return FAILURE;
+ }
+
+ h = STR_HASH_VAL(key);
+ nIndex = h & ht->nTableMask;
+
+ idx = ht->arHash[nIndex];
+ while (idx != INVALID_IDX) {
+ p = ht->arData + idx;
+ if ((p->key == key) ||
+ (p->h == h &&
+ p->key &&
+ p->key->len == key->len &&
+ memcmp(p->key->val, key->val, key->len) == 0)) {
+ if (Z_TYPE(p->val) == IS_INDIRECT) {
+ zval *data = Z_INDIRECT(p->val);
+
+ if (Z_TYPE_P(data) == IS_UNDEF) {
+ return FAILURE;
+ } else {
+ if (ht->pDestructor) {
+ ht->pDestructor(data);
+ }
+ ZVAL_UNDEF(data);
+ }
+ } else {
+ HANDLE_BLOCK_INTERRUPTIONS();
+ _zend_hash_del_el_ex(ht, idx, p, prev);
+ HANDLE_UNBLOCK_INTERRUPTIONS();
+ }
+ return SUCCESS;
+ }
+ prev = p;
+ idx = p->val.u.next;
+ }
+ return FAILURE;
+}
+
ZEND_API int zend_hash_str_del(HashTable *ht, const char *str, int len)
{
ulong h;
h = zend_inline_hash_func(str, len);
nIndex = h & ht->nTableMask;
+ idx = ht->arHash[nIndex];
+ while (idx != INVALID_IDX) {
+ p = ht->arData + idx;
+ if ((p->h == h)
+ && p->key
+ && (p->key->len == len)
+ && !memcmp(p->key->val, str, len)) {
+ if (Z_TYPE(p->val) == IS_INDIRECT) {
+ zval *data = Z_INDIRECT(p->val);
+
+ if (Z_TYPE_P(data) == IS_UNDEF) {
+ return FAILURE;
+ } else {
+ if (ht->pDestructor) {
+ ht->pDestructor(data);
+ }
+ ZVAL_UNDEF(data);
+ }
+ } else {
+ HANDLE_BLOCK_INTERRUPTIONS();
+ _zend_hash_del_el_ex(ht, idx, p, prev);
+ HANDLE_UNBLOCK_INTERRUPTIONS();
+ }
+ return SUCCESS;
+ }
+ prev = p;
+ idx = p->val.u.next;
+ }
+ return FAILURE;
+}
+
+ZEND_API int zend_hash_str_del_ind(HashTable *ht, const char *str, int len)
+{
+ ulong h;
+ uint nIndex;
+ uint idx;
+ Bucket *p;
+ Bucket *prev = NULL;
+#ifdef ZEND_SIGNALS
+ TSRMLS_FETCH();
+#endif
+
+ IS_CONSISTENT(ht);
+
+ h = zend_inline_hash_func(str, len);
+ nIndex = h & ht->nTableMask;
+
idx = ht->arHash[nIndex];
while (idx != INVALID_IDX) {
p = ht->arData + idx;
{
uint idx;
Bucket *p;
- zval *new_entry;
+ zval *new_entry, *data;
zend_bool setTargetPointer;
IS_CONSISTENT(source);
if (setTargetPointer && source->nInternalPointer == idx) {
target->nInternalPointer = INVALID_IDX;
}
+//???
+ data = &p->val;
+ if (Z_TYPE_P(data) == IS_INDIRECT) {
+ data = Z_INDIRECT_P(data);
+ if (Z_TYPE_P(data) == IS_UNDEF) {
+ continue;
+ }
+ }
if (p->key) {
- new_entry = zend_hash_update(target, p->key, &p->val);
+ new_entry = zend_hash_update(target, p->key, data);
} else {
- new_entry = zend_hash_index_update(target, p->h, &p->val);
+ new_entry = zend_hash_index_update(target, p->h, data);
}
if (pCopyConstructor) {
pCopyConstructor(new_entry);
uint idx1, idx2;
Bucket *p1, *p2 = NULL;
int result;
- zval *pData2;
+ zval *pData1, *pData2;
IS_CONSISTENT(ht1);
IS_CONSISTENT(ht2);
}
}
}
- result = compar(&p1->val, pData2 TSRMLS_CC);
+ pData1 = &p1->val;
+ if (Z_TYPE_P(pData1) == IS_INDIRECT) {
+ pData1 = Z_INDIRECT_P(pData1);
+ }
+ if (Z_TYPE_P(pData2) == IS_INDIRECT) {
+ pData2 = Z_INDIRECT_P(pData2);
+ }
+ if (Z_TYPE_P(pData1) == IS_UNDEF) {
+ if (Z_TYPE_P(pData2) != IS_UNDEF) {
+ return -1;
+ }
+ } else if (Z_TYPE_P(pData2) == IS_UNDEF) {
+ return 1;
+ } else {
+ result = compar(pData1, pData2 TSRMLS_CC);
+ }
if (result != 0) {
HASH_UNPROTECT_RECURSION(ht1);
HASH_UNPROTECT_RECURSION(ht2);
#define HASH_KEY_NON_EXISTENT 3
#define HASH_KEY_NON_EXISTANT HASH_KEY_NON_EXISTENT /* Keeping old define (with typo) for backward compatibility */
-#define HASH_UPDATE (1<<0)
-#define HASH_ADD (1<<1)
-#define HASH_NEXT_INSERT (1<<2)
+#define HASH_UPDATE (1<<0)
+#define HASH_ADD (1<<1)
+#define HASH_NEXT_INSERT (1<<2)
+#define HASH_UPDATE_INDIRECT (1<<3)
#define HASH_UPDATE_KEY_IF_NONE 0
#define HASH_UPDATE_KEY_IF_BEFORE 1
ZEND_API zval *_zend_hash_add_or_update(HashTable *ht, zend_string *key, zval *pData, int flag ZEND_FILE_LINE_DC);
#define zend_hash_update(ht, key, pData) \
_zend_hash_add_or_update(ht, key, pData, HASH_UPDATE ZEND_FILE_LINE_CC)
+#define zend_hash_update_ind(ht, key, pData) \
+ _zend_hash_add_or_update(ht, key, pData, HASH_UPDATE | HASH_UPDATE_INDIRECT ZEND_FILE_LINE_CC)
#define zend_hash_add(ht, key, pData) \
_zend_hash_add_or_update(ht, key, pData, HASH_ADD ZEND_FILE_LINE_CC)
ZEND_API zval *_zend_hash_str_add_or_update(HashTable *ht, const char *key, int len, zval *pData, int flag ZEND_FILE_LINE_DC);
#define zend_hash_str_update(ht, key, len, pData) \
_zend_hash_str_add_or_update(ht, key, len, pData, HASH_UPDATE ZEND_FILE_LINE_CC)
+#define zend_hash_str_update_ind(ht, key, len, pData) \
+ _zend_hash_str_add_or_update(ht, key, len, pData, HASH_UPDATE | HASH_UPDATE_INDIRECT ZEND_FILE_LINE_CC)
#define zend_hash_str_add(ht, key, len, pData) \
_zend_hash_str_add_or_update(ht, key, len, pData, HASH_ADD ZEND_FILE_LINE_CC)
/* Deletes */
ZEND_API int zend_hash_del(HashTable *ht, zend_string *key);
+ZEND_API int zend_hash_del_ind(HashTable *ht, zend_string *key);
ZEND_API int zend_hash_str_del(HashTable *ht, const char *key, int len);
+ZEND_API int zend_hash_str_del_ind(HashTable *ht, const char *key, int len);
ZEND_API int zend_hash_index_del(HashTable *ht, ulong h);
/* Data retreival */
ZEND_HANDLE_NUMERIC_EX(key, length, idx, return func); \
} while (0)
+
+static inline zval *zend_hash_find_ind(const HashTable *ht, zend_string *key)
+{
+ zval *zv;
+
+ zv = zend_hash_find(ht, key);
+ return (zv && Z_TYPE_P(zv) == IS_INDIRECT) ? Z_INDIRECT_P(zv) : zv;
+}
+
+
+static inline zval *zend_hash_str_find_ind(const HashTable *ht, const char *str, int len)
+{
+ zval *zv;
+
+ zv = zend_hash_str_find(ht, str, len);
+ return (zv && Z_TYPE_P(zv) == IS_INDIRECT) ? Z_INDIRECT_P(zv) : zv;
+}
+
+
static inline zval *zend_symtable_update(HashTable *ht, zend_string *key, zval *pData)
{
ZEND_HANDLE_NUMERIC(key->val, key->len+1, zend_hash_index_update(ht, idx, pData));
}
+static inline zval *zend_symtable_update_ind(HashTable *ht, zend_string *key, zval *pData)
+{
+ ZEND_HANDLE_NUMERIC(key->val, key->len+1, zend_hash_index_update(ht, idx, pData));
+ return zend_hash_update_ind(ht, key, pData);
+}
+
+
static inline int zend_symtable_del(HashTable *ht, zend_string *key)
{
ZEND_HANDLE_NUMERIC(key->val, key->len+1, zend_hash_index_del(ht, idx));
}
+static inline int zend_symtable_del_ind(HashTable *ht, zend_string *key)
+{
+ ZEND_HANDLE_NUMERIC(key->val, key->len+1, zend_hash_index_del(ht, idx));
+ return zend_hash_del_ind(ht, key);
+}
+
+
static inline zval *zend_symtable_find(const HashTable *ht, zend_string *key)
{
ZEND_HANDLE_NUMERIC(key->val, key->len+1, zend_hash_index_find(ht, idx));
}
+static inline zval *zend_symtable_find_ind(const HashTable *ht, zend_string *key)
+{
+ ZEND_HANDLE_NUMERIC(key->val, key->len+1, zend_hash_index_find(ht, idx));
+ return zend_hash_find_ind(ht, key);
+}
+
+
static inline int zend_symtable_exists(HashTable *ht, zend_string *key)
{
ZEND_HANDLE_NUMERIC(key->val, key->len+1, zend_hash_index_exists(ht, idx));
return zend_hash_exists(ht, key);
}
+
static inline zval *zend_symtable_str_update(HashTable *ht, const char *str, int len, zval *pData)
{
ZEND_HANDLE_NUMERIC(str, len+1, zend_hash_index_update(ht, idx, pData));
}
+static inline zval *zend_symtable_str_update_ind(HashTable *ht, const char *str, int len, zval *pData)
+{
+ ZEND_HANDLE_NUMERIC(str, len+1, zend_hash_index_update(ht, idx, pData));
+ return zend_hash_str_update_ind(ht, str, len, pData);
+}
+
+
static inline int zend_symtable_str_del(HashTable *ht, const char *str, int len)
{
ZEND_HANDLE_NUMERIC(str, len+1, zend_hash_index_del(ht, idx));
}
+static inline int zend_symtable_str_del_ind(HashTable *ht, const char *str, int len)
+{
+ ZEND_HANDLE_NUMERIC(str, len+1, zend_hash_index_del(ht, idx));
+ return zend_hash_str_del_ind(ht, str, len);
+}
+
+
static inline zval *zend_symtable_str_find(HashTable *ht, const char *str, int len)
{
ZEND_HANDLE_NUMERIC(str, len+1, zend_hash_index_find(ht, idx));
(prop_info->flags & ZEND_ACC_STATIC) == 0 &&
prop_info->offset >= 0 &&
Z_TYPE(zobj->properties_table[prop_info->offset]) != IS_UNDEF) {
- zval *zv = zend_hash_add(zobj->properties, prop_info->name, &zobj->properties_table[prop_info->offset]);
- if (EXPECTED(zv != NULL)) {
- ZVAL_INDIRECT(&zobj->properties_table[prop_info->offset], zv);
- }
+ zval zv;
+
+ ZVAL_INDIRECT(&zv, &zobj->properties_table[prop_info->offset]);
+ zend_hash_add(zobj->properties, prop_info->name, &zv);
}
}
while (ce->parent && ce->parent->default_properties_count) {
(prop_info->flags & ZEND_ACC_PRIVATE) != 0 &&
prop_info->offset >= 0 &&
Z_TYPE(zobj->properties_table[prop_info->offset]) != IS_UNDEF) {
- zval *zv = zend_hash_add(zobj->properties, prop_info->name, &zobj->properties_table[prop_info->offset]);
- if (EXPECTED(zv != NULL)) {
- ZVAL_INDIRECT(&zobj->properties_table[prop_info->offset], zv);
- }
+ zval zv;
+
+ ZVAL_INDIRECT(&zv, &zobj->properties_table[prop_info->offset]);
+ zend_hash_add(zobj->properties, prop_info->name, &zv);
}
}
}
} else {
zend_object *zobj = Z_OBJ_P(object);
- if (zobj->properties) {
- *table = NULL;
- *n = 0;
- return zobj->properties;
- } else {
- *table = zobj->properties_table;
- *n = zobj->ce->default_properties_count;
- return NULL;
- }
+ *table = zobj->properties_table;
+ *n = zobj->ce->default_properties_count;
+ return zobj->properties;
}
}
/* }}} */
if (EXPECTED(property_info != NULL)) {
if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
- property_info->offset >= 0 &&
- Z_TYPE(zobj->properties_table[property_info->offset]) != IS_UNDEF) {
+ property_info->offset >= 0) {
retval = &zobj->properties_table[property_info->offset];
- if (Z_TYPE_P(retval) == IS_INDIRECT) {
- retval = Z_INDIRECT_P(retval);
+ if (Z_TYPE_P(retval) != IS_UNDEF) {
+ goto exit;
}
- goto exit;
- }
- if (UNEXPECTED(zobj->properties != NULL)) {
+ } else if (UNEXPECTED(zobj->properties != NULL)) {
retval = zend_hash_find(zobj->properties, property_info->name);
if (retval) goto exit;
}
}
+ /* magic get */
if (zobj->ce->__get) {
long *guard = zend_get_property_guard(zobj, property_info, member);
if (!((*guard) & IN_GET)) {
}
retval = &EG(uninitialized_zval);
}
+
exit:
if (UNEXPECTED(Z_TYPE(tmp_member) != IS_UNDEF)) {
if (Z_REFCOUNTED_P(retval)) Z_ADDREF_P(retval);
if (EXPECTED(property_info != NULL)) {
if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
- property_info->offset >= 0 &&
- Z_TYPE(zobj->properties_table[property_info->offset]) != IS_UNDEF) {
+ property_info->offset >= 0) {
variable_ptr = &zobj->properties_table[property_info->offset];
- if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
- variable_ptr = Z_INDIRECT_P(variable_ptr);
+ if (Z_TYPE_P(variable_ptr) != IS_UNDEF) {
+ goto found;
}
- goto found;
- }
- if (EXPECTED(zobj->properties != NULL)) {
+ } else if (EXPECTED(zobj->properties != NULL)) {
if ((variable_ptr = zend_hash_find(zobj->properties, property_info->name)) != NULL) {
found:
/* if we already have this value there, we don't actually need to do anything */
zval_ptr_dtor(&garbage);
}
}
- return;
+ goto exit;
}
}
}
+ /* magic set */
if (zobj->ce->__set) {
long *guard = zend_get_property_guard(zobj, property_info, member);
if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
property_info->offset >= 0) {
- if (zobj->properties) {
- zval *zv = zend_hash_update(zobj->properties, property_info->name, value);
- ZVAL_INDIRECT(&zobj->properties_table[property_info->offset], zv);
- } else {
- ZVAL_COPY_VALUE(&zobj->properties_table[property_info->offset], value);
- }
+ ZVAL_COPY_VALUE(&zobj->properties_table[property_info->offset], value);
} else {
if (!zobj->properties) {
rebuild_object_properties(zobj);
}
}
+exit:
if (UNEXPECTED(Z_TYPE(tmp_member) != IS_UNDEF)) {
zval_ptr_dtor(&tmp_member);
}
if (EXPECTED(property_info != NULL)) {
if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
- property_info->offset >= 0 &&
- Z_TYPE(zobj->properties_table[property_info->offset]) != IS_UNDEF) {
+ property_info->offset >= 0) {
retval = &zobj->properties_table[property_info->offset];
- if (Z_TYPE_P(retval) == IS_INDIRECT) {
- retval = Z_INDIRECT_P(retval);
+ if (Z_TYPE_P(retval) != IS_UNDEF) {
+ goto exit;
}
- goto exit;
- }
- if (UNEXPECTED(zobj->properties != NULL)) {
+ } else if (UNEXPECTED(zobj->properties != NULL)) {
retval = zend_hash_find(zobj->properties, property_info->name);
if (retval) goto exit;
}
ZVAL_NULL(&tmp);
if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
property_info->offset >= 0) {
- if (zobj->properties) {
- retval = zend_hash_update(zobj->properties, property_info->name, &tmp);
- ZVAL_INDIRECT(&zobj->properties_table[property_info->offset], retval);
- } else {
- retval = &zobj->properties_table[property_info->offset];
- ZVAL_NULL(retval);
- }
+ retval = &zobj->properties_table[property_info->offset];
+ ZVAL_NULL(retval);
} else {
if (!zobj->properties) {
rebuild_object_properties(zobj);
property_info = zend_get_property_info_quick(zobj->ce, member, (zobj->ce->__unset != NULL), key TSRMLS_CC);
- if (EXPECTED(property_info != NULL) &&
- EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
- property_info->offset >= 0) {
- zval_ptr_dtor(&zobj->properties_table[property_info->offset]);
- ZVAL_UNDEF(&zobj->properties_table[property_info->offset]);
- if (!zobj->properties) goto exit;
+ if (EXPECTED(property_info != NULL)) {
+ if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
+ property_info->offset >= 0) {
+ if (Z_TYPE(zobj->properties_table[property_info->offset]) != IS_UNDEF) {
+ zval_ptr_dtor(&zobj->properties_table[property_info->offset]);
+ ZVAL_UNDEF(&zobj->properties_table[property_info->offset]);
+ goto exit;
+ }
+ } else if (zobj->properties &&
+ UNEXPECTED(zend_hash_del(zobj->properties, property_info->name) != FAILURE)) {
+ goto exit;
+ }
}
- if (UNEXPECTED(!property_info) ||
- !zobj->properties ||
- UNEXPECTED(zend_hash_del(zobj->properties, property_info->name) == FAILURE)) {
- if (zobj->ce->__unset) {
- long *guard = zend_get_property_guard(zobj, property_info, member);
- if (!((*guard) & IN_UNSET)) {
- /* have unseter - try with it! */
- Z_ADDREF_P(object);
- if (Z_ISREF_P(object)) {
- SEPARATE_ZVAL(object);
- }
- (*guard) |= IN_UNSET; /* prevent circular unsetting */
- zend_std_call_unsetter(object, member TSRMLS_CC);
- (*guard) &= ~IN_UNSET;
- zval_ptr_dtor(object);
- } else {
- if (Z_STRVAL_P(member)[0] == '\0') {
- if (Z_STRLEN_P(member) == 0) {
- zend_error(E_ERROR, "Cannot access empty property");
- } else {
- zend_error(E_ERROR, "Cannot access property started with '\\0'");
- }
+ /* magic unset */
+ if (zobj->ce->__unset) {
+ long *guard = zend_get_property_guard(zobj, property_info, member);
+ if (!((*guard) & IN_UNSET)) {
+ /* have unseter - try with it! */
+ Z_ADDREF_P(object);
+ if (Z_ISREF_P(object)) {
+ SEPARATE_ZVAL(object);
+ }
+ (*guard) |= IN_UNSET; /* prevent circular unsetting */
+ zend_std_call_unsetter(object, member TSRMLS_CC);
+ (*guard) &= ~IN_UNSET;
+ zval_ptr_dtor(object);
+ } else {
+ if (Z_STRVAL_P(member)[0] == '\0') {
+ if (Z_STRLEN_P(member) == 0) {
+ zend_error(E_ERROR, "Cannot access empty property");
+ } else {
+ zend_error(E_ERROR, "Cannot access property started with '\\0'");
}
}
}
zval *p1 = &zobj1->properties_table[i];
zval *p2 = &zobj2->properties_table[i];
- if (Z_TYPE_P(p1) == IS_INDIRECT) {
- p1 = Z_INDIRECT_P(p1);
- }
- if (Z_TYPE_P(p2) == IS_INDIRECT) {
- p1 = Z_INDIRECT_P(p2);
- }
if (compare_function(&result, p1, p2 TSRMLS_CC)==FAILURE) {
Z_OBJ_UNPROTECT_RECURSION(o1);
Z_OBJ_UNPROTECT_RECURSION(o2);
if (EXPECTED(property_info != NULL)) {
if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
- property_info->offset >= 0 &&
- Z_TYPE(zobj->properties_table[property_info->offset]) != IS_UNDEF) {
+ property_info->offset >= 0) {
value = &zobj->properties_table[property_info->offset];
- if (Z_TYPE_P(value) == IS_INDIRECT) {
- value = Z_INDIRECT_P(value);
+ if (Z_TYPE_P(value) != IS_UNDEF) {
+ goto found;
}
- goto found;
- }
- if (UNEXPECTED(zobj->properties != NULL)) {
- if ((value = zend_hash_find(zobj->properties, property_info->name)) != NULL) {
+ } else if (UNEXPECTED(zobj->properties != NULL) &&
+ (value = zend_hash_find(zobj->properties, property_info->name)) != NULL) {
found:
- switch (has_set_exists) {
- case 0:
- result = (Z_TYPE_P(value) != IS_NULL);
- break;
- default:
- result = zend_is_true(value TSRMLS_CC);
- break;
- case 2:
- result = 1;
- break;
- }
- goto exit;
+ switch (has_set_exists) {
+ case 0:
+ result = (Z_TYPE_P(value) != IS_NULL);
+ break;
+ default:
+ result = zend_is_true(value TSRMLS_CC);
+ break;
+ case 2:
+ result = 1;
+ break;
}
+ goto exit;
}
}
{
int i;
- if (!old_object->properties) {
+ if (old_object->ce->default_properties_count) {
for (i = 0; i < old_object->ce->default_properties_count; i++) {
zval_ptr_dtor(&new_object->properties_table[i]);
ZVAL_COPY(&new_object->properties_table[i], &old_object->properties_table[i]);
}
- } else {
+ }
+ if (old_object->properties) {
+ HashPosition pos;
+ zval *prop, new_prop;
+ ulong num_key;
+ zend_string *key;
+
if (!new_object->properties) {
ALLOC_HASHTABLE(new_object->properties);
zend_hash_init(new_object->properties, 0, NULL, ZVAL_PTR_DTOR, 0);
}
- zend_hash_copy(new_object->properties, old_object->properties, zval_add_ref_unref);
- if (old_object->properties_table) {
- HashPosition pos;
- zval *prop;
- zend_property_info *prop_info;
-
- for (zend_hash_internal_pointer_reset_ex(&old_object->ce->properties_info, &pos);
- (prop_info = zend_hash_get_current_data_ptr_ex(&old_object->ce->properties_info, &pos)) != NULL;
- zend_hash_move_forward_ex(&old_object->ce->properties_info, &pos)) {
- if ((prop_info->flags & ZEND_ACC_STATIC) == 0) {
- if ((prop = zend_hash_find(new_object->properties, prop_info->name)) != NULL) {
- ZVAL_INDIRECT(&new_object->properties_table[prop_info->offset], prop);
- } else {
- ZVAL_UNDEF(&new_object->properties_table[prop_info->offset]);
- }
- }
+
+ for (zend_hash_internal_pointer_reset_ex(old_object->properties, &pos);
+ (prop = zend_hash_get_current_data_ex(old_object->properties, &pos)) != NULL;
+ zend_hash_move_forward_ex(old_object->properties, &pos)) {
+ if (Z_TYPE_P(prop) == IS_INDIRECT) {
+ ZVAL_INDIRECT(&new_prop, new_object->properties_table + (Z_INDIRECT_P(prop) - old_object->properties_table));
+ } else {
+ ZVAL_COPY_VALUE(&new_prop, prop);
+ zval_add_ref_unref(&new_prop);
+ }
+ switch (zend_hash_get_current_key_ex(old_object->properties, &key, &num_key, 0, &pos)) {
+ case HASH_KEY_IS_STRING:
+ zend_hash_update(new_object->properties, key, &new_prop);
+ break;
+ case HASH_KEY_IS_LONG:
+ zend_hash_index_update(new_object->properties, num_key, &new_prop);
+ break;
}
}
}
zend_error(E_NOTICE,"Undefined variable: %s", key->key->val);
}
} else {
+ if (Z_TYPE_P(p) == IS_INDIRECT) {
+ p = Z_INDIRECT_P(p);
+ if (Z_TYPE_P(p) == IS_UNDEF) {
+ if (!is_ref) {
+ zend_error(E_NOTICE,"Undefined variable: %s", key->key->val);
+ p = &tmp;
+ ZVAL_NULL(&tmp);
+ } else {
+ ZVAL_NULL(p);
+ }
+ }
+ }
if (is_ref) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(p);
Z_ADDREF_P(p);
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
}
-//???: object may become INDIRECT
- if (OP1_TYPE == IS_CV && Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
-
if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
make_real_object(object TSRMLS_CC);
-//???
- if (Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
}
if (UNEXPECTED(Z_ISREF_P(object))) {
object = Z_REFVAL_P(object);
FREE_OP1();
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (OP1_TYPE == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
/*
if (!target_symbol_table) {
CHECK_EXCEPTION();
break;
EMPTY_SWITCH_DEFAULT_CASE()
}
+//??? GLOBAL or $$name variable may be an INDIRECT pointer to CV
+ } else if (/*(opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_STATIC &&*/
+ Z_TYPE_P(retval) == IS_INDIRECT) {
+ retval = Z_INDIRECT_P(retval);
+ if (Z_TYPE_P(retval) == IS_UNDEF) {
+ switch (type) {
+ case BP_VAR_R:
+ case BP_VAR_UNSET:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_IS:
+ retval = EX_VAR(opline->result.var);
+ ZVAL_NULL(retval);
+ break;
+ case BP_VAR_RW:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_W:
+ ZVAL_NULL(retval);
+ break;
+ EMPTY_SWITCH_DEFAULT_CASE()
+ }
+ }
}
switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
case ZEND_FETCH_GLOBAL:
zend_bool nested = EX(nested);
zend_op_array *op_array = EX(op_array);
+ if ((nested && EX(prev_execute_data)->opline->opcode == ZEND_INCLUDE_OR_EVAL) ||
+ EG(active_symbol_table) == &EG(symbol_table)) {
+ zend_detach_symbol_table(TSRMLS_C);
+ }
+
EG(current_execute_data) = EX(prev_execute_data);
EG(opline_ptr) = NULL;
- if (!EG(active_symbol_table)) {
+
+ if (EG(active_symbol_table) != &EG(symbol_table)) {
i_free_compiled_variables(execute_data TSRMLS_CC);
}
LOAD_OPLINE();
if (UNEXPECTED(opline->opcode == ZEND_INCLUDE_OR_EVAL)) {
+ zend_attach_symbol_table(TSRMLS_C);
+
EX(function_state).function = (zend_function *) EX(op_array);
EX(function_state).arguments = NULL;
zval_ptr_dtor(EX_VAR_NUM(opline->op2.var));
}
ZVAL_OBJ(EX_VAR_NUM(opline->op2.var), EG(exception));
- if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op2.var);
- zval *zv = zend_hash_update(&EG(active_symbol_table)->ht, cv, EX_VAR_NUM(opline->op2.var));
- ZVAL_INDIRECT(EX_VAR_NUM(opline->op2.var), zv);
- }
if (UNEXPECTED(EG(exception) != exception)) {
EG(exception)->gc.refcount++;
HANDLE_EXCEPTION();
args = GET_OP1_ZVAL_PTR(BP_VAR_R);
arg_num = opline->op2.num + EX(call)->num_additional_args + 1;
-again:
+ZEND_VM_C_LABEL(send_again):
switch (Z_TYPE_P(args)) {
case IS_ARRAY: {
HashTable *ht = Z_ARRVAL_P(args);
}
case IS_REFERENCE:
args = Z_REFVAL_P(args);
- goto again;
+ ZEND_VM_C_GOTO(send_again);
break;
default:
zend_error(E_WARNING, "Only arrays and Traversables can be unpacked");
ZVAL_COPY_VALUE(&tmp, opline->op2.zv);
zval_update_constant(&tmp, 0 TSRMLS_CC);
-//???: var_ptr may become INDIRECT
- if (Z_TYPE_P(var_ptr) == IS_INDIRECT) {
- var_ptr = Z_INDIRECT_P(var_ptr);
- }
ZVAL_COPY_VALUE(var_ptr, &tmp);
} else {
ZVAL_COPY_VALUE(var_ptr, opline->op2.zv);
for (; arg_num <= arg_count; ++arg_num) {
zval *param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, param, opline->extended_value TSRMLS_CC);
-//??? "params" may became IS_INDIRECT because of symtable initialization in zend_error
- if (Z_TYPE_P(params) == IS_INDIRECT) {
- params = Z_INDIRECT_P(params);
- }
zend_hash_next_index_insert(Z_ARRVAL_P(params), param);
if (Z_REFCOUNTED_P(param)) {
Z_ADDREF_P(param);
zval *offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
ulong hval;
-again:
+ZEND_VM_C_LABEL(add_again):
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ ZEND_VM_C_GOTO(add_again);
break;
default:
zend_error(E_WARNING, "Illegal offset type");
}
}
-again:
+ZEND_VM_C_LABEL(cast_again):
switch (opline->extended_value) {
case IS_NULL:
convert_to_null(result);
break;
case IS_REFERENCE:
result = Z_REFVAL_P(result);
- goto again;
+ ZEND_VM_C_GOTO(cast_again);
break;
}
FREE_OP1_IF_VAR();
if (OP1_TYPE == IS_CV &&
OP2_TYPE == IS_UNUSED &&
(opline->extended_value & ZEND_QUICK_SET)) {
- if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
- zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- }
+ zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
+ ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
zend_std_unset_static_property(ce, Z_STR_P(varname), ((OP1_TYPE == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (OP1_TYPE == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
- zend_delete_variable(execute_data, target_symbol_table, Z_STR_P(varname) TSRMLS_CC);
+ zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
}
if (OP1_TYPE != IS_CONST && varname == &tmp) {
offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
if (OP1_TYPE != IS_VAR || container) {
-//???deref
-container_again:
+ZEND_VM_C_LABEL(container_again):
switch (Z_TYPE_P(container)) {
case IS_ARRAY: {
HashTable *ht = Z_ARRVAL_P(container);
-offset_again:
+ZEND_VM_C_LABEL(offset_again):
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto offset_again;
+ ZEND_VM_C_GOTO(offset_again);
break;
default:
zend_error(E_WARNING, "Illegal offset type in unset");
ZEND_VM_CONTINUE(); /* bailed out before */
case IS_REFERENCE:
container = Z_REFVAL_P(container);
- goto container_again;
+ ZEND_VM_C_GOTO(container_again);
break;
default:
FREE_OP2();
fe_ht = Z_OBJPROP_P(array);
zend_hash_set_pointer(fe_ht, (HashPointer*)EX_VAR((opline+1)->op1.var));
- do {
+ while (1) {
if ((value = zend_hash_get_current_data(fe_ht)) == NULL) {
/* reached end of iteration */
ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
}
+
+ if (Z_TYPE_P(value) == IS_INDIRECT) {
+ value = Z_INDIRECT_P(value);
+ if (Z_TYPE_P(value) == IS_UNDEF) {
+ zend_hash_move_forward(fe_ht);
+ continue;
+ }
+ }
+
key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &int_key, 0, NULL);
zend_hash_move_forward(fe_ht);
- } while (key_type != HASH_KEY_IS_LONG &&
- zend_check_property_access(zobj, str_key TSRMLS_CC) != SUCCESS);
+ if (key_type == HASH_KEY_IS_LONG ||
+ zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS) {
+ break;
+ }
+ }
if (key) {
if (key_type == HASH_KEY_IS_LONG) {
(opline->extended_value & ZEND_QUICK_SET)) {
if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
value = EX_VAR_NUM(opline->op1.var);
- if (Z_TYPE_P(value) == IS_INDIRECT) {
- value = Z_INDIRECT_P(value);
- }
if (Z_TYPE_P(value) == IS_REFERENCE) {
value = Z_REFVAL_P(value);
}
- } else if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
- isset = 0;
- }
} else {
isset = 0;
}
}
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (OP1_TYPE == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
isset = 0;
}
ht = Z_ARRVAL_P(container);
-again:
+ZEND_VM_C_LABEL(isset_again):
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
if (OP2_TYPE != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, ZEND_VM_C_GOTO(num_index_prop));
}
- if ((value = zend_hash_find(ht, Z_STR_P(offset))) != NULL) {
+ if ((value = zend_hash_find_ind(ht, Z_STR_P(offset))) != NULL) {
isset = 1;
}
break;
case IS_NULL:
- if ((value = zend_hash_find(ht, STR_EMPTY_ALLOC())) != NULL) {
+ if ((value = zend_hash_find_ind(ht, STR_EMPTY_ALLOC())) != NULL) {
isset = 1;
}
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ ZEND_VM_C_GOTO(isset_again);
break;
default:
zend_error(E_WARNING, "Illegal offset type in isset or empty");
zend_bool nested = EX(nested);
zend_op_array *op_array = EX(op_array);
+ if ((nested && EX(prev_execute_data)->opline->opcode == ZEND_INCLUDE_OR_EVAL) ||
+ EG(active_symbol_table) == &EG(symbol_table)) {
+ zend_detach_symbol_table(TSRMLS_C);
+ }
+
EG(current_execute_data) = EX(prev_execute_data);
EG(opline_ptr) = NULL;
- if (!EG(active_symbol_table)) {
+
+ if (EG(active_symbol_table) != &EG(symbol_table)) {
i_free_compiled_variables(execute_data TSRMLS_CC);
}
LOAD_OPLINE();
if (UNEXPECTED(opline->opcode == ZEND_INCLUDE_OR_EVAL)) {
+ zend_attach_symbol_table(TSRMLS_C);
+
EX(function_state).function = (zend_function *) EX(op_array);
EX(function_state).arguments = NULL;
args = get_zval_ptr(opline->op1_type, &opline->op1, execute_data, &free_op1, BP_VAR_R);
arg_num = opline->op2.num + EX(call)->num_additional_args + 1;
-again:
+send_again:
switch (Z_TYPE_P(args)) {
case IS_ARRAY: {
HashTable *ht = Z_ARRVAL_P(args);
}
case IS_REFERENCE:
args = Z_REFVAL_P(args);
- goto again;
+ goto send_again;
break;
default:
zend_error(E_WARNING, "Only arrays and Traversables can be unpacked");
for (; arg_num <= arg_count; ++arg_num) {
zval *param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, param, opline->extended_value TSRMLS_CC);
-//??? "params" may became IS_INDIRECT because of symtable initialization in zend_error
- if (Z_TYPE_P(params) == IS_INDIRECT) {
- params = Z_INDIRECT_P(params);
- }
zend_hash_next_index_insert(Z_ARRVAL_P(params), param);
if (Z_REFCOUNTED_P(param)) {
Z_ADDREF_P(param);
ZVAL_COPY_VALUE(&tmp, opline->op2.zv);
zval_update_constant(&tmp, 0 TSRMLS_CC);
-//???: var_ptr may become INDIRECT
- if (Z_TYPE_P(var_ptr) == IS_INDIRECT) {
- var_ptr = Z_INDIRECT_P(var_ptr);
- }
ZVAL_COPY_VALUE(var_ptr, &tmp);
} else {
ZVAL_COPY_VALUE(var_ptr, opline->op2.zv);
}
}
-again:
+cast_again:
switch (opline->extended_value) {
case IS_NULL:
convert_to_null(result);
break;
case IS_REFERENCE:
result = Z_REFVAL_P(result);
- goto again;
+ goto cast_again;
break;
}
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_CONST == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
/*
if (!target_symbol_table) {
CHECK_EXCEPTION();
break;
EMPTY_SWITCH_DEFAULT_CASE()
}
+//??? GLOBAL or $$name variable may be an INDIRECT pointer to CV
+ } else if (/*(opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_STATIC &&*/
+ Z_TYPE_P(retval) == IS_INDIRECT) {
+ retval = Z_INDIRECT_P(retval);
+ if (Z_TYPE_P(retval) == IS_UNDEF) {
+ switch (type) {
+ case BP_VAR_R:
+ case BP_VAR_UNSET:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_IS:
+ retval = EX_VAR(opline->result.var);
+ ZVAL_NULL(retval);
+ break;
+ case BP_VAR_RW:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_W:
+ ZVAL_NULL(retval);
+ break;
+ EMPTY_SWITCH_DEFAULT_CASE()
+ }
+ }
}
switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
case ZEND_FETCH_GLOBAL:
zval *offset = opline->op2.zv;
ulong hval;
-again:
+add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto add_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type");
if (IS_CONST == IS_CV &&
IS_CONST == IS_UNUSED &&
(opline->extended_value & ZEND_QUICK_SET)) {
- if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
- zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- }
+ zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
+ ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_CONST == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
- zend_delete_variable(execute_data, target_symbol_table, Z_STR_P(varname) TSRMLS_CC);
+ zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
}
if (IS_CONST != IS_CONST && varname == &tmp) {
(opline->extended_value & ZEND_QUICK_SET)) {
if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
value = EX_VAR_NUM(opline->op1.var);
- if (Z_TYPE_P(value) == IS_INDIRECT) {
- value = Z_INDIRECT_P(value);
- }
if (Z_TYPE_P(value) == IS_REFERENCE) {
value = Z_REFVAL_P(value);
}
- } else if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
- isset = 0;
- }
} else {
isset = 0;
}
}
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_CONST == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
isset = 0;
}
zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
ulong hval;
-again:
+add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto add_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type");
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_CONST == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
/*
if (!target_symbol_table) {
CHECK_EXCEPTION();
break;
EMPTY_SWITCH_DEFAULT_CASE()
}
+//??? GLOBAL or $$name variable may be an INDIRECT pointer to CV
+ } else if (/*(opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_STATIC &&*/
+ Z_TYPE_P(retval) == IS_INDIRECT) {
+ retval = Z_INDIRECT_P(retval);
+ if (Z_TYPE_P(retval) == IS_UNDEF) {
+ switch (type) {
+ case BP_VAR_R:
+ case BP_VAR_UNSET:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_IS:
+ retval = EX_VAR(opline->result.var);
+ ZVAL_NULL(retval);
+ break;
+ case BP_VAR_RW:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_W:
+ ZVAL_NULL(retval);
+ break;
+ EMPTY_SWITCH_DEFAULT_CASE()
+ }
+ }
}
switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
case ZEND_FETCH_GLOBAL:
zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
ulong hval;
-again:
+add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto add_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type");
if (IS_CONST == IS_CV &&
IS_VAR == IS_UNUSED &&
(opline->extended_value & ZEND_QUICK_SET)) {
- if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
- zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- }
+ zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
+ ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_CONST == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
- zend_delete_variable(execute_data, target_symbol_table, Z_STR_P(varname) TSRMLS_CC);
+ zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
}
if (IS_CONST != IS_CONST && varname == &tmp) {
(opline->extended_value & ZEND_QUICK_SET)) {
if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
value = EX_VAR_NUM(opline->op1.var);
- if (Z_TYPE_P(value) == IS_INDIRECT) {
- value = Z_INDIRECT_P(value);
- }
if (Z_TYPE_P(value) == IS_REFERENCE) {
value = Z_REFVAL_P(value);
}
- } else if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
- isset = 0;
- }
} else {
isset = 0;
}
}
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_CONST == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
isset = 0;
}
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_CONST == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
/*
if (!target_symbol_table) {
CHECK_EXCEPTION();
break;
EMPTY_SWITCH_DEFAULT_CASE()
}
+//??? GLOBAL or $$name variable may be an INDIRECT pointer to CV
+ } else if (/*(opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_STATIC &&*/
+ Z_TYPE_P(retval) == IS_INDIRECT) {
+ retval = Z_INDIRECT_P(retval);
+ if (Z_TYPE_P(retval) == IS_UNDEF) {
+ switch (type) {
+ case BP_VAR_R:
+ case BP_VAR_UNSET:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_IS:
+ retval = EX_VAR(opline->result.var);
+ ZVAL_NULL(retval);
+ break;
+ case BP_VAR_RW:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_W:
+ ZVAL_NULL(retval);
+ break;
+ EMPTY_SWITCH_DEFAULT_CASE()
+ }
+ }
}
switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
case ZEND_FETCH_GLOBAL:
zval *offset = NULL;
ulong hval;
-again:
+add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto add_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type");
if (IS_CONST == IS_CV &&
IS_UNUSED == IS_UNUSED &&
(opline->extended_value & ZEND_QUICK_SET)) {
- if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
- zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- }
+ zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
+ ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_CONST == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
- zend_delete_variable(execute_data, target_symbol_table, Z_STR_P(varname) TSRMLS_CC);
+ zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
}
if (IS_CONST != IS_CONST && varname == &tmp) {
(opline->extended_value & ZEND_QUICK_SET)) {
if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
value = EX_VAR_NUM(opline->op1.var);
- if (Z_TYPE_P(value) == IS_INDIRECT) {
- value = Z_INDIRECT_P(value);
- }
if (Z_TYPE_P(value) == IS_REFERENCE) {
value = Z_REFVAL_P(value);
}
- } else if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
- isset = 0;
- }
} else {
isset = 0;
}
}
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_CONST == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
isset = 0;
}
zval_ptr_dtor(EX_VAR_NUM(opline->op2.var));
}
ZVAL_OBJ(EX_VAR_NUM(opline->op2.var), EG(exception));
- if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op2.var);
- zval *zv = zend_hash_update(&EG(active_symbol_table)->ht, cv, EX_VAR_NUM(opline->op2.var));
- ZVAL_INDIRECT(EX_VAR_NUM(opline->op2.var), zv);
- }
if (UNEXPECTED(EG(exception) != exception)) {
EG(exception)->gc.refcount++;
HANDLE_EXCEPTION();
zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
ulong hval;
-again:
+add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto add_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type");
}
}
-again:
+cast_again:
switch (opline->extended_value) {
case IS_NULL:
convert_to_null(result);
break;
case IS_REFERENCE:
result = Z_REFVAL_P(result);
- goto again;
+ goto cast_again;
break;
}
zval_dtor(free_op1.var);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_TMP_VAR == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
/*
if (!target_symbol_table) {
CHECK_EXCEPTION();
break;
EMPTY_SWITCH_DEFAULT_CASE()
}
+//??? GLOBAL or $$name variable may be an INDIRECT pointer to CV
+ } else if (/*(opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_STATIC &&*/
+ Z_TYPE_P(retval) == IS_INDIRECT) {
+ retval = Z_INDIRECT_P(retval);
+ if (Z_TYPE_P(retval) == IS_UNDEF) {
+ switch (type) {
+ case BP_VAR_R:
+ case BP_VAR_UNSET:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_IS:
+ retval = EX_VAR(opline->result.var);
+ ZVAL_NULL(retval);
+ break;
+ case BP_VAR_RW:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_W:
+ ZVAL_NULL(retval);
+ break;
+ EMPTY_SWITCH_DEFAULT_CASE()
+ }
+ }
}
switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
case ZEND_FETCH_GLOBAL:
zval *offset = opline->op2.zv;
ulong hval;
-again:
+add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto add_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type");
if (IS_TMP_VAR == IS_CV &&
IS_CONST == IS_UNUSED &&
(opline->extended_value & ZEND_QUICK_SET)) {
- if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
- zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- }
+ zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
+ ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_TMP_VAR == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
- zend_delete_variable(execute_data, target_symbol_table, Z_STR_P(varname) TSRMLS_CC);
+ zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
}
if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
(opline->extended_value & ZEND_QUICK_SET)) {
if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
value = EX_VAR_NUM(opline->op1.var);
- if (Z_TYPE_P(value) == IS_INDIRECT) {
- value = Z_INDIRECT_P(value);
- }
if (Z_TYPE_P(value) == IS_REFERENCE) {
value = Z_REFVAL_P(value);
}
- } else if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
- isset = 0;
- }
} else {
isset = 0;
}
}
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_TMP_VAR == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
isset = 0;
}
zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
ulong hval;
-again:
+add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto add_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type");
zval_dtor(free_op1.var);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_TMP_VAR == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
/*
if (!target_symbol_table) {
CHECK_EXCEPTION();
break;
EMPTY_SWITCH_DEFAULT_CASE()
}
+//??? GLOBAL or $$name variable may be an INDIRECT pointer to CV
+ } else if (/*(opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_STATIC &&*/
+ Z_TYPE_P(retval) == IS_INDIRECT) {
+ retval = Z_INDIRECT_P(retval);
+ if (Z_TYPE_P(retval) == IS_UNDEF) {
+ switch (type) {
+ case BP_VAR_R:
+ case BP_VAR_UNSET:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_IS:
+ retval = EX_VAR(opline->result.var);
+ ZVAL_NULL(retval);
+ break;
+ case BP_VAR_RW:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_W:
+ ZVAL_NULL(retval);
+ break;
+ EMPTY_SWITCH_DEFAULT_CASE()
+ }
+ }
}
switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
case ZEND_FETCH_GLOBAL:
zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
ulong hval;
-again:
+add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto add_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type");
if (IS_TMP_VAR == IS_CV &&
IS_VAR == IS_UNUSED &&
(opline->extended_value & ZEND_QUICK_SET)) {
- if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
- zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- }
+ zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
+ ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_TMP_VAR == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
- zend_delete_variable(execute_data, target_symbol_table, Z_STR_P(varname) TSRMLS_CC);
+ zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
}
if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
(opline->extended_value & ZEND_QUICK_SET)) {
if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
value = EX_VAR_NUM(opline->op1.var);
- if (Z_TYPE_P(value) == IS_INDIRECT) {
- value = Z_INDIRECT_P(value);
- }
if (Z_TYPE_P(value) == IS_REFERENCE) {
value = Z_REFVAL_P(value);
}
- } else if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
- isset = 0;
- }
} else {
isset = 0;
}
}
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_TMP_VAR == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
isset = 0;
}
zval_dtor(free_op1.var);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_TMP_VAR == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
/*
if (!target_symbol_table) {
CHECK_EXCEPTION();
break;
EMPTY_SWITCH_DEFAULT_CASE()
}
+//??? GLOBAL or $$name variable may be an INDIRECT pointer to CV
+ } else if (/*(opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_STATIC &&*/
+ Z_TYPE_P(retval) == IS_INDIRECT) {
+ retval = Z_INDIRECT_P(retval);
+ if (Z_TYPE_P(retval) == IS_UNDEF) {
+ switch (type) {
+ case BP_VAR_R:
+ case BP_VAR_UNSET:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_IS:
+ retval = EX_VAR(opline->result.var);
+ ZVAL_NULL(retval);
+ break;
+ case BP_VAR_RW:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_W:
+ ZVAL_NULL(retval);
+ break;
+ EMPTY_SWITCH_DEFAULT_CASE()
+ }
+ }
}
switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
case ZEND_FETCH_GLOBAL:
zval *offset = NULL;
ulong hval;
-again:
+add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto add_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type");
if (IS_TMP_VAR == IS_CV &&
IS_UNUSED == IS_UNUSED &&
(opline->extended_value & ZEND_QUICK_SET)) {
- if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
- zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- }
+ zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
+ ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_TMP_VAR == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
- zend_delete_variable(execute_data, target_symbol_table, Z_STR_P(varname) TSRMLS_CC);
+ zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
}
if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
(opline->extended_value & ZEND_QUICK_SET)) {
if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
value = EX_VAR_NUM(opline->op1.var);
- if (Z_TYPE_P(value) == IS_INDIRECT) {
- value = Z_INDIRECT_P(value);
- }
if (Z_TYPE_P(value) == IS_REFERENCE) {
value = Z_REFVAL_P(value);
}
- } else if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
- isset = 0;
- }
} else {
isset = 0;
}
}
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_TMP_VAR == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
isset = 0;
}
zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
ulong hval;
-again:
+add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto add_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type");
}
}
-again:
+cast_again:
switch (opline->extended_value) {
case IS_NULL:
convert_to_null(result);
break;
case IS_REFERENCE:
result = Z_REFVAL_P(result);
- goto again;
+ goto cast_again;
break;
}
zval_ptr_dtor_nogc(free_op1.var);
fe_ht = Z_OBJPROP_P(array);
zend_hash_set_pointer(fe_ht, (HashPointer*)EX_VAR((opline+1)->op1.var));
- do {
+ while (1) {
if ((value = zend_hash_get_current_data(fe_ht)) == NULL) {
/* reached end of iteration */
ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
}
+
+ if (Z_TYPE_P(value) == IS_INDIRECT) {
+ value = Z_INDIRECT_P(value);
+ if (Z_TYPE_P(value) == IS_UNDEF) {
+ zend_hash_move_forward(fe_ht);
+ continue;
+ }
+ }
+
key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &int_key, 0, NULL);
zend_hash_move_forward(fe_ht);
- } while (key_type != HASH_KEY_IS_LONG &&
- zend_check_property_access(zobj, str_key TSRMLS_CC) != SUCCESS);
+ if (key_type == HASH_KEY_IS_LONG ||
+ zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS) {
+ break;
+ }
+ }
if (key) {
if (key_type == HASH_KEY_IS_LONG) {
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
}
-//???: object may become INDIRECT
- if (IS_VAR == IS_CV && Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
-
if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
make_real_object(object TSRMLS_CC);
-//???
- if (Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
}
if (UNEXPECTED(Z_ISREF_P(object))) {
object = Z_REFVAL_P(object);
zval_ptr_dtor_nogc(free_op1.var);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_VAR == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
/*
if (!target_symbol_table) {
CHECK_EXCEPTION();
break;
EMPTY_SWITCH_DEFAULT_CASE()
}
+//??? GLOBAL or $$name variable may be an INDIRECT pointer to CV
+ } else if (/*(opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_STATIC &&*/
+ Z_TYPE_P(retval) == IS_INDIRECT) {
+ retval = Z_INDIRECT_P(retval);
+ if (Z_TYPE_P(retval) == IS_UNDEF) {
+ switch (type) {
+ case BP_VAR_R:
+ case BP_VAR_UNSET:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_IS:
+ retval = EX_VAR(opline->result.var);
+ ZVAL_NULL(retval);
+ break;
+ case BP_VAR_RW:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_W:
+ ZVAL_NULL(retval);
+ break;
+ EMPTY_SWITCH_DEFAULT_CASE()
+ }
+ }
}
switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
case ZEND_FETCH_GLOBAL:
zval *offset = opline->op2.zv;
ulong hval;
-again:
+add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto add_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type");
if (IS_VAR == IS_CV &&
IS_CONST == IS_UNUSED &&
(opline->extended_value & ZEND_QUICK_SET)) {
- if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
- zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- }
+ zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
+ ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_VAR == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
- zend_delete_variable(execute_data, target_symbol_table, Z_STR_P(varname) TSRMLS_CC);
+ zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
}
if (IS_VAR != IS_CONST && varname == &tmp) {
offset = opline->op2.zv;
if (IS_VAR != IS_VAR || container) {
-//???deref
container_again:
switch (Z_TYPE_P(container)) {
case IS_ARRAY: {
(opline->extended_value & ZEND_QUICK_SET)) {
if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
value = EX_VAR_NUM(opline->op1.var);
- if (Z_TYPE_P(value) == IS_INDIRECT) {
- value = Z_INDIRECT_P(value);
- }
if (Z_TYPE_P(value) == IS_REFERENCE) {
value = Z_REFVAL_P(value);
}
- } else if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
- isset = 0;
- }
} else {
isset = 0;
}
}
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_VAR == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
isset = 0;
}
ht = Z_ARRVAL_P(container);
-again:
+isset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
if (IS_CONST != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
}
- if ((value = zend_hash_find(ht, Z_STR_P(offset))) != NULL) {
+ if ((value = zend_hash_find_ind(ht, Z_STR_P(offset))) != NULL) {
isset = 1;
}
break;
case IS_NULL:
- if ((value = zend_hash_find(ht, STR_EMPTY_ALLOC())) != NULL) {
+ if ((value = zend_hash_find_ind(ht, STR_EMPTY_ALLOC())) != NULL) {
isset = 1;
}
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto isset_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type in isset or empty");
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
}
-//???: object may become INDIRECT
- if (IS_VAR == IS_CV && Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
-
if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
make_real_object(object TSRMLS_CC);
-//???
- if (Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
}
if (UNEXPECTED(Z_ISREF_P(object))) {
object = Z_REFVAL_P(object);
zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
ulong hval;
-again:
+add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto add_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type");
offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
if (IS_VAR != IS_VAR || container) {
-//???deref
container_again:
switch (Z_TYPE_P(container)) {
case IS_ARRAY: {
ht = Z_ARRVAL_P(container);
-again:
+isset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
if (IS_TMP_VAR != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
}
- if ((value = zend_hash_find(ht, Z_STR_P(offset))) != NULL) {
+ if ((value = zend_hash_find_ind(ht, Z_STR_P(offset))) != NULL) {
isset = 1;
}
break;
case IS_NULL:
- if ((value = zend_hash_find(ht, STR_EMPTY_ALLOC())) != NULL) {
+ if ((value = zend_hash_find_ind(ht, STR_EMPTY_ALLOC())) != NULL) {
isset = 1;
}
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto isset_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type in isset or empty");
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
}
-//???: object may become INDIRECT
- if (IS_VAR == IS_CV && Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
-
if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
make_real_object(object TSRMLS_CC);
-//???
- if (Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
}
if (UNEXPECTED(Z_ISREF_P(object))) {
object = Z_REFVAL_P(object);
zval_ptr_dtor_nogc(free_op1.var);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_VAR == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
/*
if (!target_symbol_table) {
CHECK_EXCEPTION();
break;
EMPTY_SWITCH_DEFAULT_CASE()
}
+//??? GLOBAL or $$name variable may be an INDIRECT pointer to CV
+ } else if (/*(opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_STATIC &&*/
+ Z_TYPE_P(retval) == IS_INDIRECT) {
+ retval = Z_INDIRECT_P(retval);
+ if (Z_TYPE_P(retval) == IS_UNDEF) {
+ switch (type) {
+ case BP_VAR_R:
+ case BP_VAR_UNSET:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_IS:
+ retval = EX_VAR(opline->result.var);
+ ZVAL_NULL(retval);
+ break;
+ case BP_VAR_RW:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_W:
+ ZVAL_NULL(retval);
+ break;
+ EMPTY_SWITCH_DEFAULT_CASE()
+ }
+ }
}
switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
case ZEND_FETCH_GLOBAL:
zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
ulong hval;
-again:
+add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto add_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type");
if (IS_VAR == IS_CV &&
IS_VAR == IS_UNUSED &&
(opline->extended_value & ZEND_QUICK_SET)) {
- if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
- zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- }
+ zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
+ ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_VAR == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
- zend_delete_variable(execute_data, target_symbol_table, Z_STR_P(varname) TSRMLS_CC);
+ zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
}
if (IS_VAR != IS_CONST && varname == &tmp) {
offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
if (IS_VAR != IS_VAR || container) {
-//???deref
container_again:
switch (Z_TYPE_P(container)) {
case IS_ARRAY: {
(opline->extended_value & ZEND_QUICK_SET)) {
if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
value = EX_VAR_NUM(opline->op1.var);
- if (Z_TYPE_P(value) == IS_INDIRECT) {
- value = Z_INDIRECT_P(value);
- }
if (Z_TYPE_P(value) == IS_REFERENCE) {
value = Z_REFVAL_P(value);
}
- } else if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
- isset = 0;
- }
} else {
isset = 0;
}
}
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_VAR == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
isset = 0;
}
ht = Z_ARRVAL_P(container);
-again:
+isset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
if (IS_VAR != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
}
- if ((value = zend_hash_find(ht, Z_STR_P(offset))) != NULL) {
+ if ((value = zend_hash_find_ind(ht, Z_STR_P(offset))) != NULL) {
isset = 1;
}
break;
case IS_NULL:
- if ((value = zend_hash_find(ht, STR_EMPTY_ALLOC())) != NULL) {
+ if ((value = zend_hash_find_ind(ht, STR_EMPTY_ALLOC())) != NULL) {
isset = 1;
}
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto isset_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type in isset or empty");
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
}
-//???: object may become INDIRECT
- if (IS_VAR == IS_CV && Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
-
if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
make_real_object(object TSRMLS_CC);
-//???
- if (Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
}
if (UNEXPECTED(Z_ISREF_P(object))) {
object = Z_REFVAL_P(object);
zval_ptr_dtor_nogc(free_op1.var);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_VAR == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
/*
if (!target_symbol_table) {
CHECK_EXCEPTION();
break;
EMPTY_SWITCH_DEFAULT_CASE()
}
+//??? GLOBAL or $$name variable may be an INDIRECT pointer to CV
+ } else if (/*(opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_STATIC &&*/
+ Z_TYPE_P(retval) == IS_INDIRECT) {
+ retval = Z_INDIRECT_P(retval);
+ if (Z_TYPE_P(retval) == IS_UNDEF) {
+ switch (type) {
+ case BP_VAR_R:
+ case BP_VAR_UNSET:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_IS:
+ retval = EX_VAR(opline->result.var);
+ ZVAL_NULL(retval);
+ break;
+ case BP_VAR_RW:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_W:
+ ZVAL_NULL(retval);
+ break;
+ EMPTY_SWITCH_DEFAULT_CASE()
+ }
+ }
}
switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
case ZEND_FETCH_GLOBAL:
zval *offset = NULL;
ulong hval;
-again:
+add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto add_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type");
if (IS_VAR == IS_CV &&
IS_UNUSED == IS_UNUSED &&
(opline->extended_value & ZEND_QUICK_SET)) {
- if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
- zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- }
+ zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
+ ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_VAR == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
- zend_delete_variable(execute_data, target_symbol_table, Z_STR_P(varname) TSRMLS_CC);
+ zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
}
if (IS_VAR != IS_CONST && varname == &tmp) {
(opline->extended_value & ZEND_QUICK_SET)) {
if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
value = EX_VAR_NUM(opline->op1.var);
- if (Z_TYPE_P(value) == IS_INDIRECT) {
- value = Z_INDIRECT_P(value);
- }
if (Z_TYPE_P(value) == IS_REFERENCE) {
value = Z_REFVAL_P(value);
}
- } else if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
- isset = 0;
- }
} else {
isset = 0;
}
}
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_VAR == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
isset = 0;
}
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
}
-//???: object may become INDIRECT
- if (IS_VAR == IS_CV && Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
-
if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
make_real_object(object TSRMLS_CC);
-//???
- if (Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
}
if (UNEXPECTED(Z_ISREF_P(object))) {
object = Z_REFVAL_P(object);
zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
ulong hval;
-again:
+add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto add_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type");
offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
if (IS_VAR != IS_VAR || container) {
-//???deref
container_again:
switch (Z_TYPE_P(container)) {
case IS_ARRAY: {
ht = Z_ARRVAL_P(container);
-again:
+isset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
if (IS_CV != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
}
- if ((value = zend_hash_find(ht, Z_STR_P(offset))) != NULL) {
+ if ((value = zend_hash_find_ind(ht, Z_STR_P(offset))) != NULL) {
isset = 1;
}
break;
case IS_NULL:
- if ((value = zend_hash_find(ht, STR_EMPTY_ALLOC())) != NULL) {
+ if ((value = zend_hash_find_ind(ht, STR_EMPTY_ALLOC())) != NULL) {
isset = 1;
}
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto isset_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type in isset or empty");
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
}
-//???: object may become INDIRECT
- if (IS_UNUSED == IS_CV && Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
-
if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
make_real_object(object TSRMLS_CC);
-//???
- if (Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
}
if (UNEXPECTED(Z_ISREF_P(object))) {
object = Z_REFVAL_P(object);
offset = opline->op2.zv;
if (IS_UNUSED != IS_VAR || container) {
-//???deref
container_again:
switch (Z_TYPE_P(container)) {
case IS_ARRAY: {
ht = Z_ARRVAL_P(container);
-again:
+isset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
if (IS_CONST != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
}
- if ((value = zend_hash_find(ht, Z_STR_P(offset))) != NULL) {
+ if ((value = zend_hash_find_ind(ht, Z_STR_P(offset))) != NULL) {
isset = 1;
}
break;
case IS_NULL:
- if ((value = zend_hash_find(ht, STR_EMPTY_ALLOC())) != NULL) {
+ if ((value = zend_hash_find_ind(ht, STR_EMPTY_ALLOC())) != NULL) {
isset = 1;
}
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto isset_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type in isset or empty");
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
}
-//???: object may become INDIRECT
- if (IS_UNUSED == IS_CV && Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
-
if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
make_real_object(object TSRMLS_CC);
-//???
- if (Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
}
if (UNEXPECTED(Z_ISREF_P(object))) {
object = Z_REFVAL_P(object);
offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
if (IS_UNUSED != IS_VAR || container) {
-//???deref
container_again:
switch (Z_TYPE_P(container)) {
case IS_ARRAY: {
ht = Z_ARRVAL_P(container);
-again:
+isset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
if (IS_TMP_VAR != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
}
- if ((value = zend_hash_find(ht, Z_STR_P(offset))) != NULL) {
+ if ((value = zend_hash_find_ind(ht, Z_STR_P(offset))) != NULL) {
isset = 1;
}
break;
case IS_NULL:
- if ((value = zend_hash_find(ht, STR_EMPTY_ALLOC())) != NULL) {
+ if ((value = zend_hash_find_ind(ht, STR_EMPTY_ALLOC())) != NULL) {
isset = 1;
}
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto isset_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type in isset or empty");
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
}
-//???: object may become INDIRECT
- if (IS_UNUSED == IS_CV && Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
-
if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
make_real_object(object TSRMLS_CC);
-//???
- if (Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
}
if (UNEXPECTED(Z_ISREF_P(object))) {
object = Z_REFVAL_P(object);
offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
if (IS_UNUSED != IS_VAR || container) {
-//???deref
container_again:
switch (Z_TYPE_P(container)) {
case IS_ARRAY: {
ht = Z_ARRVAL_P(container);
-again:
+isset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
if (IS_VAR != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
}
- if ((value = zend_hash_find(ht, Z_STR_P(offset))) != NULL) {
+ if ((value = zend_hash_find_ind(ht, Z_STR_P(offset))) != NULL) {
isset = 1;
}
break;
case IS_NULL:
- if ((value = zend_hash_find(ht, STR_EMPTY_ALLOC())) != NULL) {
+ if ((value = zend_hash_find_ind(ht, STR_EMPTY_ALLOC())) != NULL) {
isset = 1;
}
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto isset_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type in isset or empty");
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
}
-//???: object may become INDIRECT
- if (IS_UNUSED == IS_CV && Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
-
if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
make_real_object(object TSRMLS_CC);
-//???
- if (Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
}
if (UNEXPECTED(Z_ISREF_P(object))) {
object = Z_REFVAL_P(object);
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
}
-//???: object may become INDIRECT
- if (IS_UNUSED == IS_CV && Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
-
if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
make_real_object(object TSRMLS_CC);
-//???
- if (Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
}
if (UNEXPECTED(Z_ISREF_P(object))) {
object = Z_REFVAL_P(object);
offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
if (IS_UNUSED != IS_VAR || container) {
-//???deref
container_again:
switch (Z_TYPE_P(container)) {
case IS_ARRAY: {
ht = Z_ARRVAL_P(container);
-again:
+isset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
if (IS_CV != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
}
- if ((value = zend_hash_find(ht, Z_STR_P(offset))) != NULL) {
+ if ((value = zend_hash_find_ind(ht, Z_STR_P(offset))) != NULL) {
isset = 1;
}
break;
case IS_NULL:
- if ((value = zend_hash_find(ht, STR_EMPTY_ALLOC())) != NULL) {
+ if ((value = zend_hash_find_ind(ht, STR_EMPTY_ALLOC())) != NULL) {
isset = 1;
}
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto isset_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type in isset or empty");
}
}
-again:
+cast_again:
switch (opline->extended_value) {
case IS_NULL:
convert_to_null(result);
break;
case IS_REFERENCE:
result = Z_REFVAL_P(result);
- goto again;
+ goto cast_again;
break;
}
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
}
-//???: object may become INDIRECT
- if (IS_CV == IS_CV && Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
-
if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
make_real_object(object TSRMLS_CC);
-//???
- if (Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
}
if (UNEXPECTED(Z_ISREF_P(object))) {
object = Z_REFVAL_P(object);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_CV == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
/*
if (!target_symbol_table) {
CHECK_EXCEPTION();
break;
EMPTY_SWITCH_DEFAULT_CASE()
}
+//??? GLOBAL or $$name variable may be an INDIRECT pointer to CV
+ } else if (/*(opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_STATIC &&*/
+ Z_TYPE_P(retval) == IS_INDIRECT) {
+ retval = Z_INDIRECT_P(retval);
+ if (Z_TYPE_P(retval) == IS_UNDEF) {
+ switch (type) {
+ case BP_VAR_R:
+ case BP_VAR_UNSET:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_IS:
+ retval = EX_VAR(opline->result.var);
+ ZVAL_NULL(retval);
+ break;
+ case BP_VAR_RW:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_W:
+ ZVAL_NULL(retval);
+ break;
+ EMPTY_SWITCH_DEFAULT_CASE()
+ }
+ }
}
switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
case ZEND_FETCH_GLOBAL:
zval *offset = opline->op2.zv;
ulong hval;
-again:
+add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto add_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type");
if (IS_CV == IS_CV &&
IS_CONST == IS_UNUSED &&
(opline->extended_value & ZEND_QUICK_SET)) {
- if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
- zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- }
+ zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
+ ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_CV == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
- zend_delete_variable(execute_data, target_symbol_table, Z_STR_P(varname) TSRMLS_CC);
+ zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
}
if (IS_CV != IS_CONST && varname == &tmp) {
offset = opline->op2.zv;
if (IS_CV != IS_VAR || container) {
-//???deref
container_again:
switch (Z_TYPE_P(container)) {
case IS_ARRAY: {
(opline->extended_value & ZEND_QUICK_SET)) {
if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
value = EX_VAR_NUM(opline->op1.var);
- if (Z_TYPE_P(value) == IS_INDIRECT) {
- value = Z_INDIRECT_P(value);
- }
if (Z_TYPE_P(value) == IS_REFERENCE) {
value = Z_REFVAL_P(value);
}
- } else if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
- isset = 0;
- }
} else {
isset = 0;
}
}
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_CV == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
isset = 0;
}
ht = Z_ARRVAL_P(container);
-again:
+isset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
if (IS_CONST != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
}
- if ((value = zend_hash_find(ht, Z_STR_P(offset))) != NULL) {
+ if ((value = zend_hash_find_ind(ht, Z_STR_P(offset))) != NULL) {
isset = 1;
}
break;
case IS_NULL:
- if ((value = zend_hash_find(ht, STR_EMPTY_ALLOC())) != NULL) {
+ if ((value = zend_hash_find_ind(ht, STR_EMPTY_ALLOC())) != NULL) {
isset = 1;
}
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto isset_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type in isset or empty");
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
}
-//???: object may become INDIRECT
- if (IS_CV == IS_CV && Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
-
if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
make_real_object(object TSRMLS_CC);
-//???
- if (Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
}
if (UNEXPECTED(Z_ISREF_P(object))) {
object = Z_REFVAL_P(object);
zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
ulong hval;
-again:
+add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto add_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type");
offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
if (IS_CV != IS_VAR || container) {
-//???deref
container_again:
switch (Z_TYPE_P(container)) {
case IS_ARRAY: {
ht = Z_ARRVAL_P(container);
-again:
+isset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
if (IS_TMP_VAR != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
}
- if ((value = zend_hash_find(ht, Z_STR_P(offset))) != NULL) {
+ if ((value = zend_hash_find_ind(ht, Z_STR_P(offset))) != NULL) {
isset = 1;
}
break;
case IS_NULL:
- if ((value = zend_hash_find(ht, STR_EMPTY_ALLOC())) != NULL) {
+ if ((value = zend_hash_find_ind(ht, STR_EMPTY_ALLOC())) != NULL) {
isset = 1;
}
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto isset_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type in isset or empty");
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
}
-//???: object may become INDIRECT
- if (IS_CV == IS_CV && Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
-
if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
make_real_object(object TSRMLS_CC);
-//???
- if (Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
}
if (UNEXPECTED(Z_ISREF_P(object))) {
object = Z_REFVAL_P(object);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_CV == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
/*
if (!target_symbol_table) {
CHECK_EXCEPTION();
break;
EMPTY_SWITCH_DEFAULT_CASE()
}
+//??? GLOBAL or $$name variable may be an INDIRECT pointer to CV
+ } else if (/*(opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_STATIC &&*/
+ Z_TYPE_P(retval) == IS_INDIRECT) {
+ retval = Z_INDIRECT_P(retval);
+ if (Z_TYPE_P(retval) == IS_UNDEF) {
+ switch (type) {
+ case BP_VAR_R:
+ case BP_VAR_UNSET:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_IS:
+ retval = EX_VAR(opline->result.var);
+ ZVAL_NULL(retval);
+ break;
+ case BP_VAR_RW:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_W:
+ ZVAL_NULL(retval);
+ break;
+ EMPTY_SWITCH_DEFAULT_CASE()
+ }
+ }
}
switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
case ZEND_FETCH_GLOBAL:
zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
ulong hval;
-again:
+add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto add_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type");
if (IS_CV == IS_CV &&
IS_VAR == IS_UNUSED &&
(opline->extended_value & ZEND_QUICK_SET)) {
- if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
- zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- }
+ zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
+ ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_CV == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
- zend_delete_variable(execute_data, target_symbol_table, Z_STR_P(varname) TSRMLS_CC);
+ zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
}
if (IS_CV != IS_CONST && varname == &tmp) {
offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
if (IS_CV != IS_VAR || container) {
-//???deref
container_again:
switch (Z_TYPE_P(container)) {
case IS_ARRAY: {
(opline->extended_value & ZEND_QUICK_SET)) {
if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
value = EX_VAR_NUM(opline->op1.var);
- if (Z_TYPE_P(value) == IS_INDIRECT) {
- value = Z_INDIRECT_P(value);
- }
if (Z_TYPE_P(value) == IS_REFERENCE) {
value = Z_REFVAL_P(value);
}
- } else if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
- isset = 0;
- }
} else {
isset = 0;
}
}
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_CV == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
isset = 0;
}
ht = Z_ARRVAL_P(container);
-again:
+isset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
if (IS_VAR != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
}
- if ((value = zend_hash_find(ht, Z_STR_P(offset))) != NULL) {
+ if ((value = zend_hash_find_ind(ht, Z_STR_P(offset))) != NULL) {
isset = 1;
}
break;
case IS_NULL:
- if ((value = zend_hash_find(ht, STR_EMPTY_ALLOC())) != NULL) {
+ if ((value = zend_hash_find_ind(ht, STR_EMPTY_ALLOC())) != NULL) {
isset = 1;
}
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto isset_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type in isset or empty");
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
}
-//???: object may become INDIRECT
- if (IS_CV == IS_CV && Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
-
if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
make_real_object(object TSRMLS_CC);
-//???
- if (Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
}
if (UNEXPECTED(Z_ISREF_P(object))) {
object = Z_REFVAL_P(object);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_CV == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
/*
if (!target_symbol_table) {
CHECK_EXCEPTION();
break;
EMPTY_SWITCH_DEFAULT_CASE()
}
+//??? GLOBAL or $$name variable may be an INDIRECT pointer to CV
+ } else if (/*(opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_STATIC &&*/
+ Z_TYPE_P(retval) == IS_INDIRECT) {
+ retval = Z_INDIRECT_P(retval);
+ if (Z_TYPE_P(retval) == IS_UNDEF) {
+ switch (type) {
+ case BP_VAR_R:
+ case BP_VAR_UNSET:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_IS:
+ retval = EX_VAR(opline->result.var);
+ ZVAL_NULL(retval);
+ break;
+ case BP_VAR_RW:
+ zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+ /* break missing intentionally */
+ case BP_VAR_W:
+ ZVAL_NULL(retval);
+ break;
+ EMPTY_SWITCH_DEFAULT_CASE()
+ }
+ }
}
switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
case ZEND_FETCH_GLOBAL:
zval *offset = NULL;
ulong hval;
-again:
+add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto add_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type");
if (IS_CV == IS_CV &&
IS_UNUSED == IS_UNUSED &&
(opline->extended_value & ZEND_QUICK_SET)) {
- if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
- zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
- ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
- }
+ zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
+ ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_CV == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
- zend_delete_variable(execute_data, target_symbol_table, Z_STR_P(varname) TSRMLS_CC);
+ zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
}
if (IS_CV != IS_CONST && varname == &tmp) {
(opline->extended_value & ZEND_QUICK_SET)) {
if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
value = EX_VAR_NUM(opline->op1.var);
- if (Z_TYPE_P(value) == IS_INDIRECT) {
- value = Z_INDIRECT_P(value);
- }
if (Z_TYPE_P(value) == IS_REFERENCE) {
value = Z_REFVAL_P(value);
}
- } else if (EG(active_symbol_table)) {
- zend_string *cv = CV_DEF_OF(opline->op1.var);
-
- if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
- isset = 0;
- }
} else {
isset = 0;
}
}
} else {
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-//???: STRING may become INDIRECT
- if (IS_CV == IS_CV && Z_TYPE_P(varname) == IS_INDIRECT) {
- varname = Z_INDIRECT_P(varname);
- }
if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
isset = 0;
}
zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
}
-//???: object may become INDIRECT
- if (IS_CV == IS_CV && Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
-
if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
make_real_object(object TSRMLS_CC);
-//???
- if (Z_TYPE_P(object) == IS_INDIRECT) {
- object = Z_INDIRECT_P(object);
- }
}
if (UNEXPECTED(Z_ISREF_P(object))) {
object = Z_REFVAL_P(object);
zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
ulong hval;
-again:
+add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto add_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type");
offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
if (IS_CV != IS_VAR || container) {
-//???deref
container_again:
switch (Z_TYPE_P(container)) {
case IS_ARRAY: {
ht = Z_ARRVAL_P(container);
-again:
+isset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
if (IS_CV != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
}
- if ((value = zend_hash_find(ht, Z_STR_P(offset))) != NULL) {
+ if ((value = zend_hash_find_ind(ht, Z_STR_P(offset))) != NULL) {
isset = 1;
}
break;
case IS_NULL:
- if ((value = zend_hash_find(ht, STR_EMPTY_ALLOC())) != NULL) {
+ if ((value = zend_hash_find_ind(ht, STR_EMPTY_ALLOC())) != NULL) {
isset = 1;
}
break;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
- goto again;
+ goto isset_again;
break;
default:
zend_error(E_WARNING, "Illegal offset type in isset or empty");
static zend_object_handlers reflection_object_handlers;
+static zval *_default_load_entry(zval *object, char *name, int name_len TSRMLS_DC) /* {{{ */
+{
+ zval *value;
+
+ if ((value = zend_hash_str_find_ind(Z_OBJPROP_P(object), name, name_len)) == NULL) {
+ return NULL;
+ }
+ return value;
+}
+
static void _default_get_entry(zval *object, char *name, int name_len, zval *return_value TSRMLS_DC) /* {{{ */
{
zval *value;
- if ((value = zend_hash_str_find(Z_OBJPROP_P(object), name, name_len)) == NULL) {
+ if ((value = _default_load_entry(object, name, name_len TSRMLS_CC)) == NULL) {
RETURN_FALSE;
}
-
ZVAL_DUP(return_value, value);
}
/* }}} */
if (zend_parse_parameters_none() == FAILURE) {
return;
}
- if ((name = zend_hash_str_find(Z_OBJPROP_P(getThis()), "name", sizeof("name")-1)) == NULL) {
+ if ((name = _default_load_entry(getThis(), "name", sizeof("name")-1) TSRMLS_CC) == NULL) {
RETURN_FALSE;
}
if (Z_TYPE_P(name) == IS_STRING
if (zend_parse_parameters_none() == FAILURE) {
return;
}
- if ((name = zend_hash_str_find(Z_OBJPROP_P(getThis()), "name", sizeof("name")-1)) == NULL) {
+ if ((name = _default_load_entry(getThis(), "name", sizeof("name")-1) TSRMLS_CC) == NULL) {
RETURN_FALSE;
}
if (Z_TYPE_P(name) == IS_STRING
if (zend_parse_parameters_none() == FAILURE) {
return;
}
- if ((name = zend_hash_str_find(Z_OBJPROP_P(getThis()), "name", sizeof("name")-1)) == NULL) {
+ if ((name = _default_load_entry(getThis(), "name", sizeof("name")-1) TSRMLS_CC) == NULL) {
RETURN_FALSE;
}
if (Z_TYPE_P(name) == IS_STRING
if (zend_parse_parameters_none() == FAILURE) {
return;
}
- if ((name = zend_hash_str_find(Z_OBJPROP_P(getThis()), "name", sizeof("name")-1)) == NULL) {
+ if ((name = _default_load_entry(getThis(), "name", sizeof("name")-1) TSRMLS_CC) == NULL) {
RETURN_FALSE;
}
if (Z_TYPE_P(name) == IS_STRING
if (zend_parse_parameters_none() == FAILURE) {
return;
}
- if ((name = zend_hash_str_find(Z_OBJPROP_P(getThis()), "name", sizeof("name")-1)) == NULL) {
+ if ((name = _default_load_entry(getThis(), "name", sizeof("name")-1) TSRMLS_CC) == NULL) {
RETURN_FALSE;
}
if (Z_TYPE_P(name) == IS_STRING
if (zend_parse_parameters_none() == FAILURE) {
return;
}
- if ((name = zend_hash_str_find(Z_OBJPROP_P(getThis()), "name", sizeof("name")-1)) == NULL) {
+ if ((name = _default_load_entry(getThis(), "name", sizeof("name")-1) TSRMLS_CC) == NULL) {
RETURN_FALSE;
}
if (Z_TYPE_P(name) == IS_STRING
{
reflection_object *intern;
property_reference *ref;
- zval *object, name;
+ zval *object, *name;
zval *member_p = NULL;
METHOD_NOTSTATIC(reflection_property_ptr);
GET_REFLECTION_OBJECT_PTR(ref);
if (!(ref->prop.flags & (ZEND_ACC_PUBLIC | ZEND_ACC_IMPLICIT_PUBLIC)) && intern->ignore_visibility == 0) {
- _default_get_entry(getThis(), "name", sizeof("name")-1, &name TSRMLS_CC);
+ name = _default_load_entry(getThis(), "name", sizeof("name")-1 TSRMLS_CC);
zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
- "Cannot access non-public member %s::%s", intern->ce->name->val, Z_STRVAL(name));
- zval_dtor(&name);
+ "Cannot access non-public member %s::%s", intern->ce->name->val, Z_STRVAL_P(name));
return;
}
reflection_object *intern;
property_reference *ref;
zval *variable_ptr;
- zval *object, name;
+ zval *object, *name;
zval *value;
zval *tmp;
GET_REFLECTION_OBJECT_PTR(ref);
if (!(ref->prop.flags & ZEND_ACC_PUBLIC) && intern->ignore_visibility == 0) {
- _default_get_entry(getThis(), "name", sizeof("name")-1, &name TSRMLS_CC);
+ name = _default_load_entry(getThis(), "name", sizeof("name")-1 TSRMLS_CC);
zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
- "Cannot access non-public member %s::%s", intern->ce->name->val, Z_STRVAL(name));
- zval_dtor(&name);
+ "Cannot access non-public member %s::%s", intern->ce->name->val, Z_STRVAL_P(name));
return;
}
case IS_STRING:
offset_key = Z_STR_P(offset);
fetch_dim_string:
- if ((retval = (zend_symtable_find(ht, offset_key))) == NULL) {
+ retval = zend_symtable_find(ht, offset_key);
+ if (retval) {
+ if (Z_TYPE_P(retval) == IS_INDIRECT) {
+ retval = Z_INDIRECT_P(retval);
+ if (Z_TYPE_P(retval) == IS_UNDEF) {
+ switch (type) {
+ case BP_VAR_R:
+ zend_error(E_NOTICE, "Undefined index: %s", offset_key->val);
+ case BP_VAR_UNSET:
+ case BP_VAR_IS:
+ retval = &EG(uninitialized_zval);
+ break;
+ case BP_VAR_RW:
+ zend_error(E_NOTICE,"Undefined index: %s", offset_key->val);
+ case BP_VAR_W: {
+ ZVAL_NULL(retval);
+ }
+ }
+ }
+ }
+ } else {
switch (type) {
case BP_VAR_R:
zend_error(E_NOTICE, "Undefined index: %s", offset_key->val);
if (check_inherited && intern->fptr_offset_set) {
zval tmp;
+
if (!offset) {
ZVAL_NULL(&tmp);
offset = &tmp;
zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited");
return;
}
- zend_symtable_update(ht, Z_STR_P(offset), value);
+ zend_symtable_update_ind(ht, Z_STR_P(offset), value);
return;
case IS_DOUBLE:
case IS_RESOURCE:
zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset));
}
} else {
- if (zend_symtable_del(ht, Z_STR_P(offset)) == FAILURE) {
- zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset));
- } else {
- spl_array_object *obj = intern;
-
- while (1) {
- if ((obj->ar_flags & SPL_ARRAY_IS_SELF) != 0) {
- break;
- } else if (Z_TYPE(obj->array) == IS_OBJECT) {
- if ((obj->ar_flags & SPL_ARRAY_USE_OTHER) == 0) {
- obj = Z_SPLARRAY_P(&obj->array);
- break;
- } else {
- obj = Z_SPLARRAY_P(&obj->array);
- }
+//??? see below
+#if 0
+ if (zend_symtable_del_ind(ht, Z_STR_P(offset)) == FAILURE) {
+#else
+ zval *data = zend_symtable_find(ht, Z_STR_P(offset));
+
+ if (data) {
+ if (Z_TYPE_P(data) == IS_INDIRECT) {
+ data = Z_INDIRECT_P(data);
+ if (Z_TYPE_P(data) == IS_UNDEF) {
+ zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset));
} else {
- obj = NULL;
- break;
- }
- }
- if (obj) {
- zend_property_info *property_info = zend_get_property_info(obj->std.ce, offset, 1 TSRMLS_CC);
-
- if (property_info &&
- (property_info->flags & ZEND_ACC_STATIC) == 0 &&
- property_info->offset >= 0) {
- zval_ptr_dtor(&obj->std.properties_table[property_info->offset]);
- ZVAL_UNDEF(&obj->std.properties_table[property_info->offset]);
+ zval_ptr_dtor(data);
+ ZVAL_UNDEF(data);
}
+//??? fix for ext/spl/tests/bug45614.phpt (may be fix is wrong)
+ spl_array_rewind(intern TSRMLS_CC);
+ } else if (zend_symtable_del(ht, Z_STR_P(offset)) == FAILURE) {
+ zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset));
}
+ } else {
+#endif
+ zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset));
}
}
break;
case IS_STRING:
{
HashTable *ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
- if ((tmp = zend_symtable_find(ht, Z_STR_P(offset))) != NULL) {
+ if ((tmp = zend_symtable_find_ind(ht, Z_STR_P(offset))) != NULL) {
switch (check_empty) {
case 0:
return Z_TYPE_P(tmp) != IS_NULL;
{
zend_string *string_key;
ulong num_key;
+ zval *data;
if (Z_TYPE(intern->array) == IS_OBJECT) {
do {
if (zend_hash_get_current_key_ex(aht, &string_key, &num_key, 0, &intern->pos) == HASH_KEY_IS_STRING) {
- if (!string_key->len || string_key->val[0]) {
+ data = zend_hash_get_current_data_ex(aht, &intern->pos);
+ if (data && Z_TYPE_P(data) == IS_INDIRECT &&
+ Z_TYPE_P(data = Z_INDIRECT_P(data)) == IS_UNDEF) {
+ /* skip */
+ } else if (!string_key->len || string_key->val[0]) {
return SUCCESS;
}
} else {
if (object->ar_flags & SPL_ARRAY_OVERLOADED_CURRENT) {
return zend_user_it_get_current_data(iter TSRMLS_CC);
} else {
- return zend_hash_get_current_data_ex(aht, &object->pos);
+ zval *data = zend_hash_get_current_data_ex(aht, &object->pos);
+ if (Z_TYPE_P(data) == IS_INDIRECT) {
+ data = Z_INDIRECT_P(data);
+ }
+ return data;
}
}
/* }}} */
ar_flags = other->ar_flags & ~SPL_ARRAY_INT_MASK;
}
ar_flags |= SPL_ARRAY_USE_OTHER;
- intern->array = *array;
+ ZVAL_COPY_VALUE(&intern->array, array);
} else {
if (Z_TYPE_P(array) != IS_OBJECT && Z_TYPE_P(array) != IS_ARRAY) {
zend_throw_exception(spl_ce_InvalidArgumentException, "Passed variable is not an array or object, using empty array instead", 0 TSRMLS_CC);
return;
}
zval_ptr_dtor(&intern->array);
- intern->array = *array;
+ ZVAL_COPY_VALUE(&intern->array, array);
}
if (Z_TYPE_P(array) == IS_OBJECT && Z_OBJ_P(object) == Z_OBJ_P(array)) {
intern->ar_flags |= SPL_ARRAY_IS_SELF;
if ((entry = zend_hash_get_current_data_ex(aht, &intern->pos)) == NULL) {
return;
}
+ if (Z_TYPE_P(entry) == IS_INDIRECT) {
+ entry = Z_INDIRECT_P(entry);
+ if (Z_TYPE_P(entry) == IS_UNDEF) {
+ return;
+ }
+ }
RETVAL_ZVAL(entry, 1, 0);
}
/* }}} */
}
/* copy members */
- if (!intern->std.properties) {
- rebuild_object_properties(&intern->std);
- }
- zend_hash_copy(intern->std.properties, Z_ARRVAL(members), (copy_ctor_func_t) zval_add_ref);
+ object_properties_load(&intern->std, Z_ARRVAL(members));
zval_ptr_dtor(&members);
/* done reading $serialized */
first = &f->val;
second = &s->val;
+ if (Z_TYPE_P(first) == IS_INDIRECT) {
+ first = Z_INDIRECT_P(first);
+ }
+ if (Z_TYPE_P(second) == IS_INDIRECT) {
+ second = Z_INDIRECT_P(second);
+ }
if (ARRAYG(compare_func)(&result, first, second TSRMLS_CC) == FAILURE) {
return 0;
}
/* Iterate through hash */
zend_hash_internal_pointer_reset(target_hash);
while (!EG(exception) && (zv = zend_hash_get_current_data(target_hash)) != NULL) {
+ if (Z_TYPE_P(zv) == IS_INDIRECT) {
+ zv = Z_INDIRECT_P(zv);
+ if (Z_TYPE_P(zv) == IS_UNDEF) {
+ zend_hash_move_forward(target_hash);
+ continue;
+ }
+ }
ZVAL_COPY(&args[0], zv);
if (recursive &&
(Z_TYPE(args[0]) == IS_ARRAY ||
while ((entry = zend_hash_get_current_data_ex(Z_ARRVAL_P(var_array), &pos)) != NULL) {
zval final_name;
+ if (Z_TYPE_P(entry) == IS_INDIRECT) {
+ entry = Z_INDIRECT_P(entry);
+ if (Z_TYPE_P(entry) == IS_UNDEF) {
+ zend_hash_move_forward_ex(Z_ARRVAL_P(var_array), &pos);
+ continue;
+ }
+ }
+
ZVAL_NULL(&final_name);
key_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(var_array), &var_name, &num_key, 0, &pos);
Z_ADDREF_P(entry);
if ((orig_var = zend_hash_find(&EG(active_symbol_table)->ht, Z_STR(final_name))) != NULL) {
+ if (Z_TYPE_P(orig_var) == IS_INDIRECT) {
+ orig_var = Z_INDIRECT_P(orig_var);
+ }
zval_ptr_dtor(orig_var);
ZVAL_COPY_VALUE(orig_var, entry);
} else {
}
} else {
ZVAL_DUP(&data, entry);
- ZEND_SET_SYMBOL_WITH_LENGTH(&EG(active_symbol_table)->ht, Z_STRVAL(final_name), Z_STRLEN(final_name), &data, 1, 0);
+ zend_set_local_var(Z_STRVAL(final_name), Z_STRLEN(final_name), &data, 1 TSRMLS_CC);
}
count++;
}
entry = Z_REFVAL_P(entry);
}
if (Z_TYPE_P(entry) == IS_STRING) {
- if ((value_ptr = zend_hash_find(eg_active_symbol_table, Z_STR_P(entry))) != NULL) {
+ if ((value_ptr = zend_hash_find_ind(eg_active_symbol_table, Z_STR_P(entry))) != NULL) {
ZVAL_DUP(&data, value_ptr);
zend_hash_update(Z_ARRVAL_P(return_value), Z_STR_P(entry), &data);
}
- }
- else if (Z_TYPE_P(entry) == IS_ARRAY) {
+ } else if (Z_TYPE_P(entry) == IS_ARRAY) {
HashPosition pos;
if ((Z_ARRVAL_P(entry)->nApplyCount > 1)) {
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(entry), &pos);
while ((value_ptr = zend_hash_get_current_data_ex(Z_ARRVAL_P(entry), &pos)) != NULL) {
+ if (Z_TYPE_P(value_ptr) == IS_INDIRECT) {
+ value_ptr = Z_INDIRECT_P(value_ptr);
+ if (Z_TYPE_P(value_ptr) == IS_UNDEF) {
+ zend_hash_move_forward_ex(Z_ARRVAL_P(entry), &pos);
+ continue;
+ }
+ }
php_compact_var(eg_active_symbol_table, return_value, value_ptr TSRMLS_CC);
zend_hash_move_forward_ex(Z_ARRVAL_P(entry), &pos);
}
} else {
zend_hash_internal_pointer_reset(Z_ARRVAL_P(stack));
}
- val = zend_hash_get_current_data(Z_ARRVAL_P(stack));
+ while (1) {
+ val = zend_hash_get_current_data(Z_ARRVAL_P(stack));
+ if (!val) {
+ return;
+ } else if (Z_TYPE_P(val) == IS_INDIRECT) {
+ val = Z_INDIRECT_P(val);
+ if (Z_TYPE_P(val) == IS_UNDEF) {
+ zend_hash_move_forward(Z_ARRVAL_P(stack));
+ continue;
+ }
+ }
+ break;
+ }
RETVAL_ZVAL_FAST(val);
/* Delete the first or last value */
* hashtable and replace it with new one */
new_hash = php_splice(Z_ARRVAL_P(stack), 0, 0, &args[0], argc, NULL);
old_hash = *Z_ARRVAL_P(stack);
- if (Z_ARRVAL_P(stack) == &EG(symbol_table).ht) {
- zend_reset_all_cv(&EG(symbol_table) TSRMLS_CC);
- }
*Z_ARRVAL_P(stack) = *new_hash;
FREE_HASHTABLE(new_hash);
zend_hash_destroy(&old_hash);
/* Replace input array's hashtable with the new one */
old_hash = *Z_ARRVAL_P(array);
- if (Z_ARRVAL_P(array) == &EG(symbol_table).ht) {
- zend_reset_all_cv(&EG(symbol_table) TSRMLS_CC);
- }
*Z_ARRVAL_P(array) = *new_hash;
FREE_HASHTABLE(new_hash);
zend_hash_destroy(&old_hash);
/* Copy the result hash into return value */
old_hash = *Z_ARRVAL_P(return_value);
- if (Z_ARRVAL_P(return_value) == &EG(symbol_table).ht) {
- zend_reset_all_cv(&EG(symbol_table) TSRMLS_CC);
- }
*Z_ARRVAL_P(return_value) = *new_hash;
FREE_HASHTABLE(new_hash);
zend_hash_destroy(&old_hash);
for (i = 0, idx = 0; idx < Z_ARRVAL_P(array)->nNumUsed; idx++) {
p = Z_ARRVAL_P(array)->arData + idx;
if (Z_TYPE(p->val) == IS_UNDEF) continue;
+ if (Z_TYPE(p->val) == IS_INDIRECT && Z_TYPE_P(Z_INDIRECT(p->val)) == IS_UNDEF) continue;
arTmp[i].b = *p;
arTmp[i].i = i;
i++;
first = a;
second = b;
+ if (Z_TYPE_P(first) == IS_INDIRECT) {
+ first = Z_INDIRECT_P(first);
+ }
+ if (Z_TYPE_P(second) == IS_INDIRECT) {
+ second = Z_INDIRECT_P(second);
+ }
if (string_compare_function(&result, first, second TSRMLS_CC) == FAILURE) {
return 0;
}
zval args[2];
zval retval;
+ if (Z_TYPE_P(a) == IS_INDIRECT) {
+ a = Z_INDIRECT_P(a);
+ }
+ if (Z_TYPE_P(b) == IS_INDIRECT) {
+ b = Z_INDIRECT_P(b);
+ }
+
ZVAL_COPY_VALUE(&args[0], a);
ZVAL_COPY_VALUE(&args[1], b);
* in order to be on the safe side, even though it is also available
* from the symbol table. */
if (Z_TYPE(PG(http_globals)[TRACK_VARS_SERVER]) != IS_UNDEF &&
- ((args = zend_hash_str_find(HASH_OF(&PG(http_globals)[TRACK_VARS_SERVER]), "argv", sizeof("argv")-1)) != NULL ||
- (args = zend_hash_str_find(&EG(symbol_table).ht, "argv", sizeof("argv")-1)) != NULL) && Z_TYPE_P(args) == IS_ARRAY
+ ((args = zend_hash_str_find_ind(HASH_OF(&PG(http_globals)[TRACK_VARS_SERVER]), "argv", sizeof("argv")-1)) != NULL ||
+ (args = zend_hash_str_find_ind(&EG(symbol_table).ht, "argv", sizeof("argv")-1)) != NULL)
) {
int pos = 0;
zval *entry;
- argc = zend_hash_num_elements(Z_ARRVAL_P(args));
+ if (Z_TYPE_P(args) != IS_ARRAY) {
+ RETURN_FALSE;
+ }
+ argc = zend_hash_num_elements(Z_ARRVAL_P(args));
/* Attempt to allocate enough memory to hold all of the arguments
* and a trailing NULL */
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error traversing form data array");
return FAILURE;
}
+ if (Z_TYPE_P(zdata) == IS_INDIRECT) {
+ zdata = Z_INDIRECT_P(zdata);
+ if (Z_TYPE_P(zdata) == IS_UNDEF) {
+ continue;
+ }
+ }
if (Z_TYPE_P(zdata) == IS_ARRAY || Z_TYPE_P(zdata) == IS_OBJECT) {
if (key_type == HASH_KEY_IS_STRING) {
zend_string *ekey;
if (header_init) {
zval ztmp;
array_init(&ztmp);
- ZEND_SET_SYMBOL(&EG(active_symbol_table)->ht, "http_response_header", &ztmp);
+ zend_set_local_var("http_response_header", sizeof("http_response_header")-1, &ztmp, 0 TSRMLS_CC);
}
response_header = zend_hash_str_find(&EG(active_symbol_table)->ht, "http_response_header", sizeof("http_response_header")-1);
#define COMMON (is_ref ? "&" : "")
/* }}} */
+static uint zend_obj_num_elements(HashTable *ht)
+{
+ Bucket *p;
+ uint idx;
+ uint num;
+
+ num = ht->nNumOfElements;
+ for (idx = 0; idx < ht->nNumUsed; idx++) {
+ p = ht->arData + idx;
+ if (Z_TYPE(p->val) == IS_UNDEF) continue;
+ if (Z_TYPE(p->val) == IS_INDIRECT) {
+ if (Z_TYPE_P(Z_INDIRECT(p->val)) == IS_UNDEF) {
+ num--;
+ }
+ }
+ }
+ return num;
+}
+
static int php_array_element_dump(zval *zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
{
int level;
level = va_arg(args, int);
+ if (Z_TYPE_P(zv) == IS_INDIRECT) {
+ zv = Z_INDIRECT_P(zv);
+ if (Z_TYPE_P(zv) == IS_UNDEF) {
+ return 0;
+ }
+ }
if (hash_key->key == NULL) { /* numeric key */
php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h);
} else { /* string key */
level = va_arg(args, int);
+ if (Z_TYPE_P(zv) == IS_INDIRECT) {
+ zv = Z_INDIRECT_P(zv);
+ if (Z_TYPE_P(zv) == IS_UNDEF) {
+ return 0;
+ }
+ }
if (hash_key->key == NULL) { /* numeric key */
php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h);
} else { /* string key */
if (Z_OBJ_HANDLER_P(struc, get_class_name)) {
class_name = Z_OBJ_HANDLER_P(struc, get_class_name)(struc, 0 TSRMLS_CC);
- php_printf("%sobject(%s)#%d (%d) {\n", COMMON, class_name->val, Z_OBJ_HANDLE_P(struc), myht ? zend_hash_num_elements(myht) : 0);
+ php_printf("%sobject(%s)#%d (%d) {\n", COMMON, class_name->val, Z_OBJ_HANDLE_P(struc), myht ? zend_obj_num_elements(myht) : 0);
STR_RELEASE(class_name);
} else {
- php_printf("%sobject(unknown class)#%d (%d) {\n", COMMON, Z_OBJ_HANDLE_P(struc), myht ? zend_hash_num_elements(myht) : 0);
+ php_printf("%sobject(unknown class)#%d (%d) {\n", COMMON, Z_OBJ_HANDLE_P(struc), myht ? zend_obj_num_elements(myht) : 0);
}
php_element_dump_func = php_object_property_dump;
head_done:
break;
}
case IS_REFERENCE:
- //??? hide references with refcount==1 (for compatibility)
+//??? hide references with refcount==1 (for compatibility)
if (Z_REFCOUNT_P(struc) > 1) {
is_ref = 1;
}
level = va_arg(args, int);
+ if (Z_TYPE_P(zv) == IS_INDIRECT) {
+ zv = Z_INDIRECT_P(zv);
+ if (Z_TYPE_P(zv) == IS_UNDEF) {
+ return 0;
+ }
+ }
if (hash_key->key == NULL) { /* numeric key */
php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h);
} else { /* string key */
level = va_arg(args, int);
+ if (Z_TYPE_P(zv) == IS_INDIRECT) {
+ zv = Z_INDIRECT_P(zv);
+ if (Z_TYPE_P(zv) == IS_UNDEF) {
+ return 0;
+ }
+ }
if (hash_key->key == NULL) { /* numeric key */
php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h);
} else { /* string key */
php_printf("%*c", level - 1, ' ');
}
- if (Z_TYPE_P(struc) == IS_REFERENCE) {
-//??? hide references with refcount==1 (for compatibility)
- if (Z_REFCOUNT_P(struc) > 1) {
- is_ref = 1;
- }
- struc = Z_REFVAL_P(struc);
- }
-
+again:
switch (Z_TYPE_P(struc)) {
case IS_BOOL:
php_printf("%sbool(%s)\n", COMMON, Z_LVAL_P(struc)?"true":"false");
return;
}
class_name = Z_OBJ_HANDLER_P(struc, get_class_name)(struc, 0 TSRMLS_CC);
- php_printf("%sobject(%s)#%d (%d) refcount(%u){\n", COMMON, class_name->val, Z_OBJ_HANDLE_P(struc), myht ? zend_hash_num_elements(myht) : 0, Z_REFCOUNT_P(struc));
+ php_printf("%sobject(%s)#%d (%d) refcount(%u){\n", COMMON, class_name->val, Z_OBJ_HANDLE_P(struc), myht ? zend_obj_num_elements(myht) : 0, Z_REFCOUNT_P(struc));
STR_RELEASE(class_name);
zval_element_dump_func = zval_object_property_dump;
head_done:
php_printf("%sresource(%ld) of type (%s) refcount(%u)\n", COMMON, Z_RES_P(struc)->handle, type_name ? type_name : "Unknown", Z_REFCOUNT_P(struc));
break;
}
+ case IS_REFERENCE:
+//??? hide references with refcount==1 (for compatibility)
+ if (Z_REFCOUNT_P(struc) > 1) {
+ is_ref = 1;
+ }
+ struc = Z_REFVAL_P(struc);
+ goto again;
default:
php_printf("%sUNKNOWN:0\n", COMMON);
break;
level = va_arg(args, int);
buf = va_arg(args, smart_str *);
+ if (Z_TYPE_P(zv) == IS_INDIRECT) {
+ zv = Z_INDIRECT_P(zv);
+ if (Z_TYPE_P(zv) == IS_UNDEF) {
+ return 0;
+ }
+ }
if (hash_key->key == NULL) { /* numeric key */
buffer_append_spaces(buf, level+1);
smart_str_append_long(buf, (long) hash_key->h);
level = va_arg(args, int);
buf = va_arg(args, smart_str *);
+ if (Z_TYPE_P(zv) == IS_INDIRECT) {
+ zv = Z_INDIRECT_P(zv);
+ if (Z_TYPE_P(zv) == IS_UNDEF) {
+ return 0;
+ }
+ }
+
buffer_append_spaces(buf, level + 2);
if (hash_key->key != NULL) {
const char *class_name; /* ignored, but must be passed to unmangle */
}
propers = Z_OBJPROP_P(struc);
if ((d = zend_hash_find(propers, Z_STR_P(name))) != NULL) {
+ if (Z_TYPE_P(d) == IS_INDIRECT) {
+ d = Z_INDIRECT_P(d);
+ if (Z_TYPE_P(d) == IS_UNDEF) {
+ continue;
+ }
+ }
php_var_serialize_string(buf, Z_STRVAL_P(name), Z_STRLEN_P(name));
php_var_serialize_intern(buf, d, var_hash TSRMLS_CC);
} else {
do {
priv_name = zend_mangle_property_name(ce->name->val, ce->name->len, Z_STRVAL_P(name), Z_STRLEN_P(name), ce->type & ZEND_INTERNAL_CLASS);
if ((d = zend_hash_find(propers, priv_name)) != NULL) {
+ if (Z_TYPE_P(d) == IS_INDIRECT) {
+ d = Z_INDIRECT_P(d);
+ if (Z_TYPE_P(d) == IS_UNDEF) {
+ STR_FREE(prot_name);
+ break;
+ }
+ }
php_var_serialize_string(buf, priv_name->val, priv_name->len);
STR_FREE(priv_name);
php_var_serialize_intern(buf, d, var_hash TSRMLS_CC);
STR_FREE(priv_name);
prot_name = zend_mangle_property_name("*", 1, Z_STRVAL_P(name), Z_STRLEN_P(name), ce->type & ZEND_INTERNAL_CLASS);
if ((d = zend_hash_find(propers, prot_name)) != NULL) {
+ if (Z_TYPE_P(d) == IS_INDIRECT) {
+ d = Z_INDIRECT_P(d);
+ if (Z_TYPE_P(d) == IS_UNDEF) {
+ STR_FREE(prot_name);
+ break;
+ }
+ }
php_var_serialize_string(buf, prot_name->val, prot_name->len);
STR_FREE(prot_name);
php_var_serialize_intern(buf, d, var_hash TSRMLS_CC);
zend_hash_internal_pointer_reset_ex(myht, &pos);
for (;; zend_hash_move_forward_ex(myht, &pos)) {
- i = zend_hash_get_current_key_ex(myht, &key, &index, 0, &pos);
- if (i == HASH_KEY_NON_EXISTENT) {
+ data = zend_hash_get_current_data_ex(myht, &pos);
+ if (!data) {
break;
+ } else if (Z_TYPE_P(data) == IS_INDIRECT) {
+ data = Z_INDIRECT_P(data);
+ if (Z_TYPE_P(data) == IS_UNDEF) {
+ continue;
+ }
}
+
+ i = zend_hash_get_current_key_ex(myht, &key, &index, 0, &pos);
if (incomplete_class && strcmp(key->val, MAGIC_MEMBER) == 0) {
continue;
}
/* we should still add element even if it's not OK,
* since we already wrote the length of the array before */
- if ((data = zend_hash_get_current_data_ex(myht, &pos)) == NULL
- || (Z_TYPE_P(data) == IS_ARRAY && Z_TYPE_P(struc) == IS_ARRAY && Z_ARR_P(data) == Z_ARR_P(struc))
+ if ((Z_TYPE_P(data) == IS_ARRAY && Z_TYPE_P(struc) == IS_ARRAY && Z_ARR_P(data) == Z_ARR_P(struc))
|| (Z_TYPE_P(data) == IS_ARRAY && Z_ARRVAL_P(data)->nApplyCount > 1)
) {
smart_str_appendl(buf, "N;", 2);
(*var_hashx)->last_dtor = var_hash;
}
- Z_ADDREF_P(rval);
+ if (Z_REFCOUNTED_P(rval)) Z_ADDREF_P(rval);
var_hash->data[var_hash->used_slots++] = rval;
}
} else {
/* object properties should include no integers */
convert_to_string(&key);
- data = zend_hash_update(ht, Z_STR(key), &d);
+//???
+#if 1
+ data = zend_hash_update_ind(ht, Z_STR(key), &d);
+#else
+ if ((data = zend_hash_find(ht, Z_STR(key))) != NULL) {
+ if (Z_TYPE_P(data) == IS_INDIRECT) {
+ data = Z_INDIRECT_P(data);
+ }
+ zval_ptr_dtor(data);
+//??? var_push_dtor(var_hash, data);
+ ZVAL_UNDEF(data);
+ } else {
+ data = zend_hash_update(ht, Z_STR(key), &d);
+ }
+#endif
}
zval_dtor(&key);
start = cursor;
-#line 432 "ext/standard/var_unserializer.c"
+#line 446 "ext/standard/var_unserializer.c"
{
YYCTYPE yych;
static const unsigned char yybm[] = {
yych = *(YYMARKER = ++YYCURSOR);
if (yych == ':') goto yy95;
yy3:
-#line 778 "ext/standard/var_unserializer.re"
+#line 792 "ext/standard/var_unserializer.re"
{ return 0; }
-#line 494 "ext/standard/var_unserializer.c"
+#line 508 "ext/standard/var_unserializer.c"
yy4:
yych = *(YYMARKER = ++YYCURSOR);
if (yych == ':') goto yy89;
goto yy3;
yy14:
++YYCURSOR;
-#line 772 "ext/standard/var_unserializer.re"
+#line 786 "ext/standard/var_unserializer.re"
{
/* this is the case where we have less data than planned */
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Unexpected end of serialized data");
return 0; /* not sure if it should be 0 or 1 here? */
}
-#line 543 "ext/standard/var_unserializer.c"
+#line 557 "ext/standard/var_unserializer.c"
yy16:
yych = *++YYCURSOR;
goto yy3;
yych = *++YYCURSOR;
if (yych != '"') goto yy18;
++YYCURSOR;
-#line 633 "ext/standard/var_unserializer.re"
+#line 647 "ext/standard/var_unserializer.re"
{
size_t len, len2, len3, maxlen;
long elements;
return object_common2(UNSERIALIZE_PASSTHRU, elements);
}
-#line 712 "ext/standard/var_unserializer.c"
+#line 726 "ext/standard/var_unserializer.c"
yy25:
yych = *++YYCURSOR;
if (yych <= ',') {
yych = *++YYCURSOR;
if (yych != '"') goto yy18;
++YYCURSOR;
-#line 625 "ext/standard/var_unserializer.re"
+#line 639 "ext/standard/var_unserializer.re"
{
//??? INIT_PZVAL(rval);
return object_common2(UNSERIALIZE_PASSTHRU,
object_common1(UNSERIALIZE_PASSTHRU, ZEND_STANDARD_CLASS_DEF_PTR));
}
-#line 745 "ext/standard/var_unserializer.c"
+#line 759 "ext/standard/var_unserializer.c"
yy32:
yych = *++YYCURSOR;
if (yych == '+') goto yy33;
yych = *++YYCURSOR;
if (yych != '{') goto yy18;
++YYCURSOR;
-#line 604 "ext/standard/var_unserializer.re"
+#line 618 "ext/standard/var_unserializer.re"
{
long elements = parse_iv(start + 2);
/* use iv() not uiv() in order to check data range */
return finish_nested_data(UNSERIALIZE_PASSTHRU);
}
-#line 787 "ext/standard/var_unserializer.c"
+#line 801 "ext/standard/var_unserializer.c"
yy39:
yych = *++YYCURSOR;
if (yych == '+') goto yy40;
yych = *++YYCURSOR;
if (yych != '"') goto yy18;
++YYCURSOR;
-#line 574 "ext/standard/var_unserializer.re"
+#line 588 "ext/standard/var_unserializer.re"
{
size_t len, maxlen;
//??? TODO: use zend_string* instead of char*
efree(str);
return 1;
}
-#line 838 "ext/standard/var_unserializer.c"
+#line 852 "ext/standard/var_unserializer.c"
yy46:
yych = *++YYCURSOR;
if (yych == '+') goto yy47;
yych = *++YYCURSOR;
if (yych != '"') goto yy18;
++YYCURSOR;
-#line 547 "ext/standard/var_unserializer.re"
+#line 561 "ext/standard/var_unserializer.re"
{
size_t len, maxlen;
char *str;
ZVAL_STRINGL(rval, str, len);
return 1;
}
-#line 886 "ext/standard/var_unserializer.c"
+#line 900 "ext/standard/var_unserializer.c"
yy53:
yych = *++YYCURSOR;
if (yych <= '/') {
}
yy63:
++YYCURSOR;
-#line 538 "ext/standard/var_unserializer.re"
+#line 552 "ext/standard/var_unserializer.re"
{
#if SIZEOF_LONG == 4
use_double:
ZVAL_DOUBLE(rval, zend_strtod((const char *)start + 2, NULL));
return 1;
}
-#line 983 "ext/standard/var_unserializer.c"
+#line 997 "ext/standard/var_unserializer.c"
yy65:
yych = *++YYCURSOR;
if (yych <= ',') {
yych = *++YYCURSOR;
if (yych != ';') goto yy18;
++YYCURSOR;
-#line 522 "ext/standard/var_unserializer.re"
+#line 536 "ext/standard/var_unserializer.re"
{
*p = YYCURSOR;
return 1;
}
-#line 1058 "ext/standard/var_unserializer.c"
+#line 1072 "ext/standard/var_unserializer.c"
yy76:
yych = *++YYCURSOR;
if (yych == 'N') goto yy73;
if (yych <= '9') goto yy79;
if (yych != ';') goto yy18;
++YYCURSOR;
-#line 496 "ext/standard/var_unserializer.re"
+#line 510 "ext/standard/var_unserializer.re"
{
#if SIZEOF_LONG == 4
int digits = YYCURSOR - start - 3;
ZVAL_LONG(rval, parse_iv(start + 2));
return 1;
}
-#line 1111 "ext/standard/var_unserializer.c"
+#line 1125 "ext/standard/var_unserializer.c"
yy83:
yych = *++YYCURSOR;
if (yych <= '/') goto yy18;
yych = *++YYCURSOR;
if (yych != ';') goto yy18;
++YYCURSOR;
-#line 490 "ext/standard/var_unserializer.re"
+#line 504 "ext/standard/var_unserializer.re"
{
*p = YYCURSOR;
ZVAL_BOOL(rval, parse_iv(start + 2));
return 1;
}
-#line 1125 "ext/standard/var_unserializer.c"
+#line 1139 "ext/standard/var_unserializer.c"
yy87:
++YYCURSOR;
-#line 484 "ext/standard/var_unserializer.re"
+#line 498 "ext/standard/var_unserializer.re"
{
*p = YYCURSOR;
ZVAL_NULL(rval);
return 1;
}
-#line 1134 "ext/standard/var_unserializer.c"
+#line 1148 "ext/standard/var_unserializer.c"
yy89:
yych = *++YYCURSOR;
if (yych <= ',') {
if (yych <= '9') goto yy91;
if (yych != ';') goto yy18;
++YYCURSOR;
-#line 461 "ext/standard/var_unserializer.re"
+#line 475 "ext/standard/var_unserializer.re"
{
long id;
return 1;
}
-#line 1180 "ext/standard/var_unserializer.c"
+#line 1194 "ext/standard/var_unserializer.c"
yy95:
yych = *++YYCURSOR;
if (yych <= ',') {
if (yych <= '9') goto yy97;
if (yych != ';') goto yy18;
++YYCURSOR;
-#line 436 "ext/standard/var_unserializer.re"
+#line 450 "ext/standard/var_unserializer.re"
{
long id;
return 1;
}
-#line 1228 "ext/standard/var_unserializer.c"
+#line 1242 "ext/standard/var_unserializer.c"
}
-#line 780 "ext/standard/var_unserializer.re"
+#line 794 "ext/standard/var_unserializer.re"
return 0;
(*var_hashx)->last_dtor = var_hash;
}
- Z_ADDREF_P(rval);
+ if (Z_REFCOUNTED_P(rval)) Z_ADDREF_P(rval);
var_hash->data[var_hash->used_slots++] = rval;
}
} else {
/* object properties should include no integers */
convert_to_string(&key);
- data = zend_hash_update(ht, Z_STR(key), &d);
+//???
+#if 1
+ data = zend_hash_update_ind(ht, Z_STR(key), &d);
+#else
+ if ((data = zend_hash_find(ht, Z_STR(key))) != NULL) {
+ if (Z_TYPE_P(data) == IS_INDIRECT) {
+ data = Z_INDIRECT_P(data);
+ }
+ zval_ptr_dtor(data);
+//??? var_push_dtor(var_hash, data);
+ ZVAL_UNDEF(data);
+ } else {
+ data = zend_hash_update(ht, Z_STR(key), &d);
+ }
+#endif
}
zval_dtor(&key);
if (PG(track_errors) && module_initialized &&
(Z_TYPE(EG(user_error_handler)) == IS_UNDEF || !(EG(user_error_handler_error_reporting) & type))) {
- if (!EG(active_symbol_table)) {
- zend_rebuild_symbol_table(TSRMLS_C);
- }
- if (EG(active_symbol_table)) {
- zval tmp;
- ZVAL_STRINGL(&tmp, buffer, buffer_len);
- zend_hash_str_update(&EG(active_symbol_table)->ht, "php_errormsg", sizeof("php_errormsg")-1, &tmp);
+ zval tmp;
+ ZVAL_STRINGL(&tmp, buffer, buffer_len);
+ if (zend_set_local_var("php_errormsg", sizeof("php_errormsg")-1, &tmp, 0 TSRMLS_CC) == FAILURE) {
+ zval_ptr_dtor(&tmp);
}
}
if (replace_buffer) {
if (EG(active_symbol_table)) {
zval tmp;
ZVAL_STRINGL(&tmp, buffer, buffer_len);
- zend_hash_str_update(&EG(active_symbol_table)->ht, "php_errormsg", sizeof("php_errormsg")-1, &tmp);
+ if (zend_set_local_var("php_errormsg", sizeof("php_errormsg")-1, &tmp, 0 TSRMLS_CC) == FAILURE) {
+ zval_ptr_dtor(&tmp);
+ }
}
}
return;
}
} else {
- if ((gpc_element_p = zend_symtable_str_find(symtable1, index, index_len)) == NULL
- || Z_TYPE_P(gpc_element_p) != IS_ARRAY) {
- array_init(&gpc_element);
- gpc_element_p = zend_symtable_str_update(symtable1, index, index_len, &gpc_element);
+ gpc_element_p = zend_symtable_str_find(symtable1, index, index_len);
+ if (!gpc_element_p) {
+ zval tmp;
+ array_init(&tmp);
+ gpc_element_p = zend_symtable_str_update_ind(symtable1, index, index_len, &tmp);
+ } else {
+ if (Z_TYPE_P(gpc_element_p) == IS_INDIRECT) {
+ gpc_element_p = Z_INDIRECT_P(gpc_element_p);
+ }
+ if (Z_TYPE_P(gpc_element_p) != IS_ARRAY) {
+ zval_ptr_dtor(gpc_element_p);
+ array_init(gpc_element_p);
+ }
}
}
symtable1 = Z_ARRVAL_P(gpc_element_p);
zend_symtable_str_exists(symtable1, index, index_len)) {
zval_ptr_dtor(&gpc_element);
} else {
- gpc_element_p = zend_symtable_str_update(symtable1, index, index_len, &gpc_element);
+ gpc_element_p = zend_symtable_str_update_ind(symtable1, index, index_len, &gpc_element);
}
}
}
projects / php / commitdiff