typedef struct _spl_array_object {
zend_object std;
- zval *array;
- zval *retval;
+ zval array;
+ zval retval;
HashPosition pos;
ulong pos_h;
int ar_flags;
rebuild_object_properties(&intern->std);
}
return intern->std.properties;
- } else if ((intern->ar_flags & SPL_ARRAY_USE_OTHER) && (check_std_props == 0 || (intern->ar_flags & SPL_ARRAY_STD_PROP_LIST) == 0) && Z_TYPE_P(intern->array) == IS_OBJECT) {
- spl_array_object *other = (spl_array_object*)zend_object_store_get_object(intern->array TSRMLS_CC);
+ } else if ((intern->ar_flags & SPL_ARRAY_USE_OTHER) && (check_std_props == 0 || (intern->ar_flags & SPL_ARRAY_STD_PROP_LIST) == 0) && Z_TYPE(intern->array) == IS_OBJECT) {
+ spl_array_object *other = (spl_array_object*)Z_OBJ_P(&intern->array);
return spl_array_get_hash_table(other, check_std_props TSRMLS_CC);
} else if ((intern->ar_flags & ((check_std_props ? SPL_ARRAY_STD_PROP_LIST : 0) | SPL_ARRAY_IS_SELF)) != 0) {
if (!intern->std.properties) {
}
return intern->std.properties;
} else {
- return HASH_OF(intern->array);
+ return HASH_OF(&intern->array);
}
} /* }}} */
/* HASH_PROTECT_RECURSION(ht);*/
if (ht->flags & HASH_FLAG_PACKED) {
- if (intern->pos_h == intern->pos && ht->arData[intern->pos_h].xData) {
+ if (intern->pos_h == intern->pos && Z_TYPE(ht->arData[intern->pos_h].val) != IS_UNDEF) {
return SUCCESS;
}
} else {
- idx = ht->arHash[intern->pos_h & ht->nTableMask].idx;
+ idx = ht->arHash[intern->pos_h & ht->nTableMask];
while (idx != INVALID_IDX) {
if (idx == intern->pos) {
return SUCCESS;
}
- idx = ht->arData[idx].next;
+ idx = ht->arData[idx].val.u.next;
}
}
/* HASH_UNPROTECT_RECURSION(ht); */
zend_object_iterator *spl_array_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC);
/* {{{ spl_array_object_new_ex */
-static zend_object_value spl_array_object_new_ex(zend_class_entry *class_type, spl_array_object **obj, zval *orig, int clone_orig TSRMLS_DC)
+static zend_object *spl_array_object_new_ex(zend_class_entry *class_type, zval *orig, int clone_orig TSRMLS_DC)
{
- zend_object_value retval = {0};
spl_array_object *intern;
- zval *tmp;
zend_class_entry * parent = class_type;
int inherited = 0;
intern = emalloc(sizeof(spl_array_object));
memset(intern, 0, sizeof(spl_array_object));
- *obj = intern;
- ALLOC_INIT_ZVAL(intern->retval);
zend_object_std_init(&intern->std, class_type TSRMLS_CC);
object_properties_init(&intern->std, class_type);
intern->debug_info = NULL;
intern->ce_get_iterator = spl_ce_ArrayIterator;
if (orig) {
- spl_array_object *other = (spl_array_object*)zend_object_store_get_object(orig TSRMLS_CC);
+ spl_array_object *other = (spl_array_object*)Z_OBJ_P(orig);
intern->ar_flags &= ~ SPL_ARRAY_CLONE_MASK;
intern->ar_flags |= (other->ar_flags & SPL_ARRAY_CLONE_MASK);
if (clone_orig) {
intern->array = other->array;
if (Z_OBJ_HT_P(orig) == &spl_handler_ArrayObject) {
- MAKE_STD_ZVAL(intern->array);
- array_init(intern->array);
- zend_hash_copy(HASH_OF(intern->array), HASH_OF(other->array), (copy_ctor_func_t) zval_add_ref, &tmp, sizeof(zval*));
+ array_init(&intern->array);
+ zend_hash_copy(HASH_OF(&intern->array), HASH_OF(&other->array), (copy_ctor_func_t) zval_add_ref);
}
if (Z_OBJ_HT_P(orig) == &spl_handler_ArrayIterator) {
- Z_ADDREF_P(other->array);
+ Z_ADDREF_P(&other->array);
}
} else {
- intern->array = orig;
- Z_ADDREF_P(intern->array);
+ intern->array = *orig;
+ Z_ADDREF_P(&intern->array);
intern->ar_flags |= SPL_ARRAY_IS_REF | SPL_ARRAY_USE_OTHER;
}
} else {
- MAKE_STD_ZVAL(intern->array);
- array_init(intern->array);
+ array_init(&intern->array);
intern->ar_flags &= ~SPL_ARRAY_IS_REF;
}
- retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t) spl_array_object_free_storage, NULL TSRMLS_CC);
+ zend_objects_store_put(&intern->std TSRMLS_CC);
while (parent) {
if (parent == spl_ce_ArrayIterator || parent == spl_ce_RecursiveArrayIterator) {
- retval.handlers = &spl_handler_ArrayIterator;
+ intern->std.handlers = &spl_handler_ArrayIterator;
class_type->get_iterator = spl_array_get_iterator;
break;
} else if (parent == spl_ce_ArrayObject) {
- retval.handlers = &spl_handler_ArrayObject;
+ intern->std.handlers = &spl_handler_ArrayObject;
break;
}
parent = parent->parent;
php_error_docref(NULL TSRMLS_CC, E_COMPILE_ERROR, "Internal compiler error, Class is not child of ArrayObject or ArrayIterator");
}
if (inherited) {
- zend_hash_find(&class_type->function_table, "offsetget", sizeof("offsetget"), (void **) &intern->fptr_offset_get);
+ intern->fptr_offset_get = zend_hash_str_find_ptr(&class_type->function_table, "offsetget", sizeof("offsetget") - 1);
if (intern->fptr_offset_get->common.scope == parent) {
intern->fptr_offset_get = NULL;
}
- zend_hash_find(&class_type->function_table, "offsetset", sizeof("offsetset"), (void **) &intern->fptr_offset_set);
+ intern->fptr_offset_set = zend_hash_str_find_ptr(&class_type->function_table, "offsetset", sizeof("offsetset") - 1);
if (intern->fptr_offset_set->common.scope == parent) {
intern->fptr_offset_set = NULL;
}
- zend_hash_find(&class_type->function_table, "offsetexists", sizeof("offsetexists"), (void **) &intern->fptr_offset_has);
+ intern->fptr_offset_has = zend_hash_str_find_ptr(&class_type->function_table, "offsetexists", sizeof("offsetexists") - 1);
if (intern->fptr_offset_has->common.scope == parent) {
intern->fptr_offset_has = NULL;
}
- zend_hash_find(&class_type->function_table, "offsetunset", sizeof("offsetunset"), (void **) &intern->fptr_offset_del);
+ intern->fptr_offset_del = zend_hash_str_find_ptr(&class_type->function_table, "offsetunset", sizeof("offsetunset") - 1);
if (intern->fptr_offset_del->common.scope == parent) {
intern->fptr_offset_del = NULL;
}
- zend_hash_find(&class_type->function_table, "count", sizeof("count"), (void **) &intern->fptr_count);
+ intern->fptr_count = zend_hash_str_find_ptr(&class_type->function_table, "count", sizeof("count") - 1);
if (intern->fptr_count->common.scope == parent) {
intern->fptr_count = NULL;
}
}
/* Cache iterator functions if ArrayIterator or derived. Check current's */
/* cache since only current is always required */
- if (retval.handlers == &spl_handler_ArrayIterator) {
+ if (intern->std.handlers == &spl_handler_ArrayIterator) {
if (!class_type->iterator_funcs.zf_current) {
- zend_hash_find(&class_type->function_table, "rewind", sizeof("rewind"), (void **) &class_type->iterator_funcs.zf_rewind);
- zend_hash_find(&class_type->function_table, "valid", sizeof("valid"), (void **) &class_type->iterator_funcs.zf_valid);
- zend_hash_find(&class_type->function_table, "key", sizeof("key"), (void **) &class_type->iterator_funcs.zf_key);
- zend_hash_find(&class_type->function_table, "current", sizeof("current"), (void **) &class_type->iterator_funcs.zf_current);
- zend_hash_find(&class_type->function_table, "next", sizeof("next"), (void **) &class_type->iterator_funcs.zf_next);
+ class_type->iterator_funcs.zf_rewind = zend_hash_str_find_ptr(&class_type->function_table, "rewind", sizeof("rewind") - 1);
+ class_type->iterator_funcs.zf_valid = zend_hash_str_find_ptr(&class_type->function_table, "valid", sizeof("valid") - 1);
+ class_type->iterator_funcs.zf_key = zend_hash_str_find_ptr(&class_type->function_table, "key", sizeof("key") - 1);
+ class_type->iterator_funcs.zf_current = zend_hash_str_find_ptr(&class_type->function_table, "current", sizeof("current") - 1);
+ class_type->iterator_funcs.zf_next = zend_hash_str_find_ptr(&class_type->function_table, "next", sizeof("next") - 1);
}
if (inherited) {
if (class_type->iterator_funcs.zf_rewind->common.scope != parent) intern->ar_flags |= SPL_ARRAY_OVERLOADED_REWIND;
}
spl_array_rewind(intern TSRMLS_CC);
- return retval;
+ return &intern->std;
}
/* }}} */
/* {{{ spl_array_object_new */
-static zend_object_value spl_array_object_new(zend_class_entry *class_type TSRMLS_DC)
+static zend_object *spl_array_object_new(zend_class_entry *class_type TSRMLS_DC)
{
- spl_array_object *tmp;
- return spl_array_object_new_ex(class_type, &tmp, NULL, 0 TSRMLS_CC);
+ return spl_array_object_new_ex(class_type, NULL, 0 TSRMLS_CC);
}
/* }}} */
/* {{{ spl_array_object_clone */
-static zend_object_value spl_array_object_clone(zval *zobject TSRMLS_DC)
+static zend_object *spl_array_object_clone(zval *zobject TSRMLS_DC)
{
- zend_object_value new_obj_val;
zend_object *old_object;
zend_object *new_object;
- zend_object_handle handle = Z_OBJ_HANDLE_P(zobject);
- spl_array_object *intern;
- old_object = zend_objects_get_address(zobject TSRMLS_CC);
- new_obj_val = spl_array_object_new_ex(old_object->ce, &intern, zobject, 1 TSRMLS_CC);
- new_object = &intern->std;
+ old_object = Z_OBJ_P(zobject);
+ new_object = spl_array_object_new_ex(old_object->ce, zobject, 1 TSRMLS_CC);
- zend_objects_clone_members(new_object, new_obj_val, old_object, handle TSRMLS_CC);
+ zend_objects_clone_members(new_object, old_object TSRMLS_CC);
- return new_obj_val;
+ return new_object;
}
/* }}} */
-static zval **spl_array_get_dimension_ptr_ptr(int check_inherited, zval *object, zval *offset, int type TSRMLS_DC) /* {{{ */
+static zval *spl_array_get_dimension_ptr(int check_inherited, zval *object, zval *offset, int type TSRMLS_DC) /* {{{ */
{
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
- zval **retval;
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
+ zval *retval;
long index;
HashTable *ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
+ zend_string *offset_key;
- if (!offset) {
- return &EG(uninitialized_zval_ptr);
+ if (ZVAL_IS_UNDEF(offset)) {
+ return &EG(uninitialized_zval);
}
if ((type == BP_VAR_W || type == BP_VAR_RW) && (ht->nApplyCount > 0)) {
zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited");
- return &EG(error_zval_ptr);;
+ return &EG(error_zval);;
}
- switch(Z_TYPE_P(offset)) {
+ switch (Z_TYPE_P(offset)) {
case IS_NULL:
- Z_STRVAL_P(offset) = "";
- Z_STRLEN_P(offset) = 0;
+ offset_key = STR_EMPTY_ALLOC();
+ goto fetch_dim_string;
case IS_STRING:
- if (zend_symtable_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, (void **) &retval) == FAILURE) {
+ offset_key = Z_STR_P(offset);
+fetch_dim_string:
+ if ((retval = (zend_symtable_find(ht, offset_key))) == NULL) {
switch (type) {
case BP_VAR_R:
zend_error(E_NOTICE, "Undefined index: %s", Z_STRVAL_P(offset));
case BP_VAR_UNSET:
case BP_VAR_IS:
- retval = &EG(uninitialized_zval_ptr);
+ retval = &EG(uninitialized_zval);
break;
case BP_VAR_RW:
zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset));
case BP_VAR_W: {
- zval *value;
- ALLOC_INIT_ZVAL(value);
- zend_symtable_update(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, (void**)&value, sizeof(void*), (void **)&retval);
+ zval value;
+ ZVAL_UNDEF(&value);
+ retval = zend_symtable_update(ht, Z_STR_P(offset), &value);
}
}
}
} else {
index = Z_LVAL_P(offset);
}
- if (zend_hash_index_find(ht, index, (void **) &retval) == FAILURE) {
+ if ((retval = zend_hash_index_find(ht, index)) == NULL) {
switch (type) {
case BP_VAR_R:
zend_error(E_NOTICE, "Undefined offset: %ld", index);
case BP_VAR_UNSET:
case BP_VAR_IS:
- retval = &EG(uninitialized_zval_ptr);
+ retval = &EG(uninitialized_zval);
break;
case BP_VAR_RW:
zend_error(E_NOTICE, "Undefined offset: %ld", index);
case BP_VAR_W: {
- zval *value;
- ALLOC_INIT_ZVAL(value);
- zend_hash_index_update(ht, index, (void**)&value, sizeof(void*), (void **)&retval);
+ zval value;
+ ZVAL_UNDEF(&value);
+ retval = zend_hash_index_update(ht, index, &value);
}
}
}
default:
zend_error(E_WARNING, "Illegal offset type");
return (type == BP_VAR_W || type == BP_VAR_RW) ?
- &EG(error_zval_ptr) : &EG(uninitialized_zval_ptr);
+ &EG(error_zval) : &EG(uninitialized_zval);
}
} /* }}} */
static zval *spl_array_read_dimension_ex(int check_inherited, zval *object, zval *offset, int type TSRMLS_DC) /* {{{ */
{
- zval **ret;
+ zval *ret;
if (check_inherited) {
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
if (intern->fptr_offset_get) {
- zval *rv;
+ zval rv, tmp;
if (!offset) {
- ALLOC_INIT_ZVAL(offset);
+ ZVAL_UNDEF(&tmp);
+ offset = &tmp;
} else {
SEPARATE_ARG_IF_REF(offset);
}
- zend_call_method_with_1_params(&object, Z_OBJCE_P(object), &intern->fptr_offset_get, "offsetGet", &rv, offset);
- zval_ptr_dtor(&offset);
- if (rv) {
+ zend_call_method_with_1_params(object, Z_OBJCE_P(object), &intern->fptr_offset_get, "offsetGet", &rv, offset);
+ zval_ptr_dtor(offset);
+ if (!ZVAL_IS_UNDEF(&rv)) {
zval_ptr_dtor(&intern->retval);
- MAKE_STD_ZVAL(intern->retval);
- ZVAL_ZVAL(intern->retval, rv, 1, 1);
- return intern->retval;
+ ZVAL_ZVAL(&intern->retval, &rv, 0, 0);
+ return &intern->retval;
}
- return EG(uninitialized_zval_ptr);
+ return &EG(uninitialized_zval);
}
}
- ret = spl_array_get_dimension_ptr_ptr(check_inherited, object, offset, type TSRMLS_CC);
+ ret = spl_array_get_dimension_ptr(check_inherited, object, offset, type TSRMLS_CC);
+ //!!! FIXME?
+ // ZVAL_COPY(result, ret);
+ return ret;
/* When in a write context,
* ZE has to be fooled into thinking this is in a reference set
- * by separating (if necessary) and returning as an is_ref=1 zval (even if refcount == 1) */
+ * by separating (if necessary) and returning as an is_ref=1 zval (even if refcount == 1)
+
if ((type == BP_VAR_W || type == BP_VAR_RW || type == BP_VAR_UNSET) && !Z_ISREF_PP(ret)) {
- if (Z_REFCOUNT_PP(ret) > 1) {
- zval *newval;
-
- /* Separate */
- MAKE_STD_ZVAL(newval);
- *newval = **ret;
- zval_copy_ctor(newval);
- Z_SET_REFCOUNT_P(newval, 1);
-
- /* Replace */
- Z_DELREF_PP(ret);
- *ret = newval;
- }
- Z_SET_ISREF_PP(ret);
+ Z_SET_ISREF_P(ret);
}
-
- return *ret;
+ */
} /* }}} */
static zval *spl_array_read_dimension(zval *object, zval *offset, int type TSRMLS_DC) /* {{{ */
static void spl_array_write_dimension_ex(int check_inherited, zval *object, zval *offset, zval *value TSRMLS_DC) /* {{{ */
{
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
long index;
HashTable *ht;
if (check_inherited && intern->fptr_offset_set) {
+ zval tmp;
if (!offset) {
- ALLOC_INIT_ZVAL(offset);
+ ZVAL_UNDEF(&tmp);
+ offset = &tmp;
} else {
SEPARATE_ARG_IF_REF(offset);
}
- zend_call_method_with_2_params(&object, Z_OBJCE_P(object), &intern->fptr_offset_set, "offsetSet", NULL, offset, value);
- zval_ptr_dtor(&offset);
+ zend_call_method_with_2_params(object, Z_OBJCE_P(object), &intern->fptr_offset_set, "offsetSet", NULL, offset, value);
+ zval_ptr_dtor(offset);
return;
}
return;
}
Z_ADDREF_P(value);
- zend_hash_next_index_insert(ht, (void**)&value, sizeof(void*), NULL);
+ zend_hash_next_index_insert(ht, value);
return;
}
switch(Z_TYPE_P(offset)) {
return;
}
Z_ADDREF_P(value);
- zend_symtable_update(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, (void**)&value, sizeof(void*), NULL);
+ zend_symtable_update(ht, Z_STR_P(offset), value);
return;
case IS_DOUBLE:
case IS_RESOURCE:
index = Z_LVAL_P(offset);
}
Z_ADDREF_P(value);
- zend_hash_index_update(ht, index, (void**)&value, sizeof(void*), NULL);
+ zend_hash_index_update(ht, index, value);
return;
case IS_NULL:
ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
return;
}
Z_ADDREF_P(value);
- zend_hash_next_index_insert(ht, (void**)&value, sizeof(void*), NULL);
+ zend_hash_next_index_insert(ht, value);
return;
default:
zend_error(E_WARNING, "Illegal offset type");
static void spl_array_unset_dimension_ex(int check_inherited, zval *object, zval *offset TSRMLS_DC) /* {{{ */
{
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
long index;
HashTable *ht;
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
if (check_inherited && intern->fptr_offset_del) {
SEPARATE_ARG_IF_REF(offset);
- zend_call_method_with_1_params(&object, Z_OBJCE_P(object), &intern->fptr_offset_del, "offsetUnset", NULL, offset);
- zval_ptr_dtor(&offset);
+ zend_call_method_with_1_params(object, Z_OBJCE_P(object), &intern->fptr_offset_del, "offsetUnset", NULL, offset);
+ zval_ptr_dtor(offset);
return;
}
zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited");
return;
}
- if (ht == &EG(symbol_table)) {
- if (zend_delete_global_variable(Z_STRVAL_P(offset), Z_STRLEN_P(offset) TSRMLS_CC)) {
+ if (ht == &EG(symbol_table).ht) {
+ if (zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC)) {
zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset));
}
} else {
- if (zend_symtable_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1) == FAILURE) {
+ 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_P(obj->array) == IS_OBJECT) {
+ } else if (Z_TYPE(obj->array) == IS_OBJECT) {
if ((obj->ar_flags & SPL_ARRAY_USE_OTHER) == 0) {
- obj = (spl_array_object*)zend_object_store_get_object(obj->array TSRMLS_CC);
+ obj = (spl_array_object*)Z_OBJ_P(&obj->array);
break;
} else {
- obj = (spl_array_object*)zend_object_store_get_object(obj->array TSRMLS_CC);
+ obj = (spl_array_object*)Z_OBJ_P(&obj->array);
}
} else {
obj = NULL;
if (property_info &&
(property_info->flags & ZEND_ACC_STATIC) == 0 &&
property_info->offset >= 0) {
- obj->std.properties_table[property_info->offset] = NULL;
+ zval_ptr_dtor(&obj->std.properties_table[property_info->offset]);
+ ZVAL_UNDEF(&obj->std.properties_table[property_info->offset]);
}
}
}
static int spl_array_has_dimension_ex(int check_inherited, zval *object, zval *offset, int check_empty TSRMLS_DC) /* {{{ */
{
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
long index;
- zval *rv, **tmp;
+ zval rv, *tmp;
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
if (check_inherited && intern->fptr_offset_has) {
SEPARATE_ARG_IF_REF(offset);
- zend_call_method_with_1_params(&object, Z_OBJCE_P(object), &intern->fptr_offset_has, "offsetExists", &rv, offset);
- zval_ptr_dtor(&offset);
- if (rv && zend_is_true(rv TSRMLS_CC)) {
- zval_ptr_dtor(&rv);
+ zend_call_method_with_1_params(object, Z_OBJCE_P(object), &intern->fptr_offset_has, "offsetExists", &rv, offset);
+ zval_ptr_dtor(offset);
+ if (!ZVAL_IS_UNDEF(&rv) && zend_is_true(&rv TSRMLS_CC)) {
return 1;
}
- if (rv) {
- zval_ptr_dtor(&rv);
- }
+ zval_ptr_dtor(&rv);
return 0;
}
case IS_STRING:
{
HashTable *ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
- if (zend_symtable_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, (void **) &tmp) != FAILURE) {
+ if ((tmp = zend_symtable_find(ht, Z_STR_P(offset))) != NULL) {
switch (check_empty) {
case 0:
- return Z_TYPE_PP(tmp) != IS_NULL;
+ return Z_TYPE_P(tmp) != IS_NULL;
case 2:
return 1;
default:
- return zend_is_true(*tmp TSRMLS_CC);
+ return zend_is_true(tmp TSRMLS_CC);
}
}
}
} else {
index = Z_LVAL_P(offset);
}
- if (zend_hash_index_find(ht, index, (void **)&tmp) != FAILURE) {
+ if ((tmp = zend_hash_index_find(ht, index)) != NULL) {
switch (check_empty) {
case 0:
- return Z_TYPE_PP(tmp) != IS_NULL;
+ return Z_TYPE_P(tmp) != IS_NULL;
case 2:
return 1;
default:
- return zend_is_true(*tmp TSRMLS_CC);
+ return zend_is_true(tmp TSRMLS_CC);
}
}
return 0;
Returns the value at the specified $index. */
SPL_METHOD(Array, offsetGet)
{
- zval *index, *value;
+ zval *value, *index;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &index) == FAILURE) {
return;
}
void spl_array_iterator_append(zval *object, zval *append_value TSRMLS_DC) /* {{{ */
{
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
if (!aht) {
return;
}
- if (Z_TYPE_P(intern->array) == IS_OBJECT) {
+ if (Z_TYPE(intern->array) == IS_OBJECT) {
php_error_docref(NULL TSRMLS_CC, E_RECOVERABLE_ERROR, "Cannot append properties to objects, use %s::offsetSet() instead", Z_OBJCE_P(object)->name);
return;
}
spl_array_write_dimension(object, NULL, append_value TSRMLS_CC);
if (intern->pos == INVALID_IDX) {
- if (aht->nNumUsed && aht->arData[aht->nNumUsed-1].xData) {
+ if (aht->nNumUsed && !ZVAL_IS_UNDEF(&aht->arData[aht->nNumUsed-1].val)) {
spl_array_set_pos(intern, aht, aht->nNumUsed - 1);
}
}
SPL_METHOD(Array, getArrayCopy)
{
zval *object = getThis(), *tmp;
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
array_init(return_value);
- zend_hash_copy(HASH_OF(return_value), spl_array_get_hash_table(intern, 0 TSRMLS_CC), (copy_ctor_func_t) zval_add_ref, &tmp, sizeof(zval*));
+ zend_hash_copy(HASH_OF(return_value), spl_array_get_hash_table(intern, 0 TSRMLS_CC), (copy_ctor_func_t) zval_add_ref);
} /* }}} */
static HashTable *spl_array_get_properties(zval *object TSRMLS_DC) /* {{{ */
{
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
HashTable *result;
if (intern->nApplyCount > 1) {
static HashTable* spl_array_get_debug_info(zval *obj, int *is_temp TSRMLS_DC) /* {{{ */
{
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(obj TSRMLS_CC);
- zval *tmp, *storage;
+ zval *storage;
int name_len;
char *zname;
zend_class_entry *base;
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(obj);
*is_temp = 0;
rebuild_object_properties(&intern->std);
}
- if (HASH_OF(intern->array) == intern->std.properties) {
+ if (HASH_OF(&intern->array) == intern->std.properties) {
return intern->std.properties;
} else {
if (intern->debug_info == NULL) {
if (intern->debug_info->nApplyCount == 0) {
zend_hash_clean(intern->debug_info);
- zend_hash_copy(intern->debug_info, intern->std.properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
+ zend_hash_copy(intern->debug_info, intern->std.properties, (copy_ctor_func_t) zval_add_ref);
- storage = intern->array;
- zval_add_ref(&storage);
+ storage = &intern->array;
+ zval_add_ref(storage);
base = (Z_OBJ_HT_P(obj) == &spl_handler_ArrayIterator) ? spl_ce_ArrayIterator : spl_ce_ArrayObject;
zname = spl_gen_private_prop_name(base, "storage", sizeof("storage")-1, &name_len TSRMLS_CC);
- zend_symtable_update(intern->debug_info, zname, name_len+1, &storage, sizeof(zval *), NULL);
+ zend_symtable_str_update(intern->debug_info, zname, name_len, storage);
efree(zname);
}
static zval *spl_array_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
{
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0
- && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
+ && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
return spl_array_read_dimension(object, member, type TSRMLS_CC);
}
return std_object_handlers.read_property(object, member, type, key TSRMLS_CC);
static void spl_array_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC) /* {{{ */
{
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0
&& !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
std_object_handlers.write_property(object, member, value, key TSRMLS_CC);
} /* }}} */
-static zval **spl_array_get_property_ptr_ptr(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zval *spl_array_get_property_ptr_ptr(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
{
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0
- && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
- return spl_array_get_dimension_ptr_ptr(1, object, member, type TSRMLS_CC);
+ && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
+ return spl_array_get_dimension_ptr(1, object, member, type TSRMLS_CC);
}
- return std_object_handlers.get_property_ptr_ptr(object, member, type, key TSRMLS_CC);
+ //!!! FIXME
+ //return std_object_handlers.get_property_ptr_ptr(object, member, type, key TSRMLS_CC);
+ return NULL;
} /* }}} */
static int spl_array_has_property(zval *object, zval *member, int has_set_exists, const zend_literal *key TSRMLS_DC) /* {{{ */
{
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0
- && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
+ && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
return spl_array_has_dimension(object, member, has_set_exists TSRMLS_CC);
}
return std_object_handlers.has_property(object, member, has_set_exists, key TSRMLS_CC);
static void spl_array_unset_property(zval *object, zval *member, const zend_literal *key TSRMLS_DC) /* {{{ */
{
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0
- && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
+ && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
spl_array_unset_dimension(object, member TSRMLS_CC);
spl_array_rewind(intern TSRMLS_CC); /* because deletion might invalidate position */
return;
int result = 0;
zval temp_zv;
- intern1 = (spl_array_object*)zend_object_store_get_object(o1 TSRMLS_CC);
- intern2 = (spl_array_object*)zend_object_store_get_object(o2 TSRMLS_CC);
+ intern1 = (spl_array_object*)Z_OBJ_P(o1);
+ intern2 = (spl_array_object*)Z_OBJ_P(o2);
ht1 = spl_array_get_hash_table(intern1, 0 TSRMLS_CC);
ht2 = spl_array_get_hash_table(intern2, 0 TSRMLS_CC);
static int spl_array_skip_protected(spl_array_object *intern, HashTable *aht TSRMLS_DC) /* {{{ */
{
- char *string_key;
- uint string_length;
+ zend_string *string_key;
ulong num_key;
- if (Z_TYPE_P(intern->array) == IS_OBJECT) {
+ if (Z_TYPE(intern->array) == IS_OBJECT) {
do {
- if (zend_hash_get_current_key_ex(aht, &string_key, &string_length, &num_key, 0, &intern->pos) == HASH_KEY_IS_STRING) {
- if (!string_length || string_key[0]) {
+ 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]) {
return SUCCESS;
}
} else {
{
zend_hash_move_forward_ex(aht, &intern->pos);
spl_array_update_pos(aht, intern);
- if (Z_TYPE_P(intern->array) == IS_OBJECT) {
+ if (Z_TYPE(intern->array) == IS_OBJECT) {
return spl_array_skip_protected(intern, aht TSRMLS_CC);
} else {
return zend_hash_has_more_elements_ex(aht, &intern->pos);
spl_array_it *iterator = (spl_array_it *)iter;
zend_user_it_invalidate_current(iter TSRMLS_CC);
- zval_ptr_dtor((zval**)&iterator->intern.it.data);
+ zval_ptr_dtor((zval*)iterator->intern.it.data);
efree(iterator);
}
}
/* }}} */
-static void spl_array_it_get_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC) /* {{{ */
+static zval *spl_array_it_get_current_data(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
{
spl_array_it *iterator = (spl_array_it *)iter;
spl_array_object *object = iterator->object;
HashTable *aht = spl_array_get_hash_table(object, 0 TSRMLS_CC);
if (object->ar_flags & SPL_ARRAY_OVERLOADED_CURRENT) {
- zend_user_it_get_current_data(iter, data TSRMLS_CC);
+ return zend_user_it_get_current_data(iter TSRMLS_CC);
} else {
- if (zend_hash_get_current_data_ex(aht, (void**)data, &object->pos) == FAILURE) {
- *data = NULL;
- }
+ return zend_hash_get_current_data_ex(aht, &object->pos);
}
}
/* }}} */
/* }}} */
/* {{{ spl_array_set_array */
-static void spl_array_set_array(zval *object, spl_array_object *intern, zval **array, long ar_flags, int just_array TSRMLS_DC) {
+static void spl_array_set_array(zval *object, spl_array_object *intern, zval *array, long ar_flags, int just_array TSRMLS_DC) {
- if (Z_TYPE_PP(array) == IS_ARRAY) {
+ if (Z_TYPE_P(array) == IS_ARRAY) {
SEPARATE_ZVAL_IF_NOT_REF(array);
}
- if (Z_TYPE_PP(array) == IS_OBJECT && (Z_OBJ_HT_PP(array) == &spl_handler_ArrayObject || Z_OBJ_HT_PP(array) == &spl_handler_ArrayIterator)) {
+ if (Z_TYPE_P(array) == IS_OBJECT && (Z_OBJ_HT_P(array) == &spl_handler_ArrayObject || Z_OBJ_HT_P(array) == &spl_handler_ArrayIterator)) {
zval_ptr_dtor(&intern->array);
if (just_array) {
- spl_array_object *other = (spl_array_object*)zend_object_store_get_object(*array TSRMLS_CC);
+ spl_array_object *other = (spl_array_object*)Z_OBJ_P(array);
ar_flags = other->ar_flags & ~SPL_ARRAY_INT_MASK;
}
ar_flags |= SPL_ARRAY_USE_OTHER;
intern->array = *array;
} else {
- if (Z_TYPE_PP(array) != IS_OBJECT && Z_TYPE_PP(array) != IS_ARRAY) {
+ 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;
}
- if (object == *array) {
+ if (object == array) {
intern->ar_flags |= SPL_ARRAY_IS_SELF;
intern->ar_flags &= ~SPL_ARRAY_USE_OTHER;
} else {
intern->ar_flags &= ~SPL_ARRAY_IS_SELF;
}
intern->ar_flags |= ar_flags;
- Z_ADDREF_P(intern->array);
- if (Z_TYPE_PP(array) == IS_OBJECT) {
- zend_object_get_properties_t handler = Z_OBJ_HANDLER_PP(array, get_properties);
+ Z_ADDREF_P(&intern->array);
+ if (Z_TYPE_P(array) == IS_OBJECT) {
+ zend_object_get_properties_t handler = Z_OBJ_HANDLER_P(array, get_properties);
if ((handler != std_object_handlers.get_properties && handler != spl_array_get_properties)
|| !spl_array_get_hash_table(intern, 0 TSRMLS_CC)) {
- zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Overloaded object of type %s is not compatible with %s", Z_OBJCE_PP(array)->name, intern->std.ce->name);
+ zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Overloaded object of type %s is not compatible with %s", Z_OBJCE_P(array)->name, intern->std.ce->name);
}
}
zend_object_iterator *spl_array_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC) /* {{{ */
{
spl_array_it *iterator;
- spl_array_object *array_object = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *array_object = (spl_array_object*)Z_OBJ_P(object);
if (by_ref && (array_object->ar_flags & SPL_ARRAY_OVERLOADED_CURRENT)) {
zend_error(E_ERROR, "An iterator cannot be used with foreach by reference");
{
zval *object = getThis();
spl_array_object *intern;
- zval **array;
+ zval *array;
long ar_flags = 0;
zend_class_entry *ce_get_iterator = spl_ce_Iterator;
zend_error_handling error_handling;
zend_replace_error_handling(EH_THROW, spl_ce_InvalidArgumentException, &error_handling TSRMLS_CC);
- intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ intern = (spl_array_object*)Z_OBJ_P(object);
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z|lC", &array, &ar_flags, &ce_get_iterator) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|lC", &array, &ar_flags, &ce_get_iterator) == FAILURE) {
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
SPL_METHOD(Array, setIteratorClass)
{
zval *object = getThis();
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
zend_class_entry * ce_get_iterator = spl_ce_Iterator;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "C", &ce_get_iterator) == FAILURE) {
SPL_METHOD(Array, getIteratorClass)
{
zval *object = getThis();
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
if (zend_parse_parameters_none() == FAILURE) {
return;
}
- RETURN_STRING(intern->ce_get_iterator->name, 1);
+ RETURN_STR(intern->ce_get_iterator->name);
}
/* }}} */
SPL_METHOD(Array, getFlags)
{
zval *object = getThis();
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
if (zend_parse_parameters_none() == FAILURE) {
return;
SPL_METHOD(Array, setFlags)
{
zval *object = getThis();
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
long ar_flags = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &ar_flags) == FAILURE) {
Replace the referenced array or object with a new one and return the old one (right now copy - to be changed) */
SPL_METHOD(Array, exchangeArray)
{
- zval *object = getThis(), *tmp, **array;
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ zval *object = getThis(), *array;
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
array_init(return_value);
- zend_hash_copy(HASH_OF(return_value), spl_array_get_hash_table(intern, 0 TSRMLS_CC), (copy_ctor_func_t) zval_add_ref, &tmp, sizeof(zval*));
+ zend_hash_copy(HASH_OF(return_value), spl_array_get_hash_table(intern, 0 TSRMLS_CC), (copy_ctor_func_t)zval_add_ref);
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &array) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &array) == FAILURE) {
return;
}
spl_array_set_array(object, intern, array, 0L, 1 TSRMLS_CC);
-
}
/* }}} */
SPL_METHOD(Array, getIterator)
{
zval *object = getThis();
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
- spl_array_object *iterator;
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
if (zend_parse_parameters_none() == FAILURE) {
return;
}
- return_value->type = IS_OBJECT;
- return_value->value.obj = spl_array_object_new_ex(intern->ce_get_iterator, &iterator, object, 0 TSRMLS_CC);
+ ZVAL_OBJ(return_value, spl_array_object_new_ex(intern->ce_get_iterator, object, 0 TSRMLS_CC));
Z_SET_REFCOUNT_P(return_value, 1);
Z_SET_ISREF_P(return_value);
}
SPL_METHOD(Array, rewind)
{
zval *object = getThis();
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
if (zend_parse_parameters_none() == FAILURE) {
return;
{
long opos, position;
zval *object = getThis();
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
int result;
return FAILURE;
}
- if (Z_TYPE_P(intern->array) == IS_OBJECT) {
+ if (Z_TYPE(intern->array) == IS_OBJECT) {
/* We need to store the 'pos' since we'll modify it in the functions
* we're going to call and which do not support 'pos' as parameter. */
pos = intern->pos;
int spl_array_object_count_elements(zval *object, long *count TSRMLS_DC) /* {{{ */
{
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
if (intern->fptr_count) {
- zval *rv;
- zend_call_method_with_0_params(&object, intern->std.ce, &intern->fptr_count, "count", &rv);
- if (rv) {
+ zval rv;
+ zend_call_method_with_0_params(object, intern->std.ce, &intern->fptr_count, "count", &rv);
+ if (Z_TYPE(rv) != IS_UNDEF) {
zval_ptr_dtor(&intern->retval);
- MAKE_STD_ZVAL(intern->retval);
- ZVAL_ZVAL(intern->retval, rv, 1, 1);
- convert_to_long(intern->retval);
- *count = (long) Z_LVAL_P(intern->retval);
+ ZVAL_ZVAL(&intern->retval, &rv, 0, 0);
+ convert_to_long(&intern->retval);
+ *count = (long)Z_LVAL(intern->retval);
return SUCCESS;
}
*count = 0;
SPL_METHOD(Array, count)
{
long count;
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(getThis());
if (zend_parse_parameters_none() == FAILURE) {
return;
static void spl_array_method(INTERNAL_FUNCTION_PARAMETERS, char *fname, int fname_len, int use_arg) /* {{{ */
{
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(getThis());
HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
- zval *tmp, *arg = NULL;
- zval *retval_ptr = NULL;
+ zval tmp, *arg = NULL;
+ zval retval;
- MAKE_STD_ZVAL(tmp);
- Z_TYPE_P(tmp) = IS_ARRAY;
- Z_ARRVAL_P(tmp) = aht;
+ array_init(&tmp);
+ zend_hash_copy(Z_ARRVAL(tmp), aht, (copy_ctor_func_t)zval_add_ref);
if (!use_arg) {
aht->nApplyCount++;
- zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval_ptr, 1, tmp, NULL TSRMLS_CC);
+ zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval, 1, &tmp, NULL TSRMLS_CC);
aht->nApplyCount--;
} else if (use_arg == SPL_ARRAY_METHOD_MAY_USER_ARG) {
if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "|z", &arg) == FAILURE) {
- Z_TYPE_P(tmp) = IS_NULL;
zval_ptr_dtor(&tmp);
zend_throw_exception(spl_ce_BadMethodCallException, "Function expects one argument at most", 0 TSRMLS_CC);
return;
}
aht->nApplyCount++;
- zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval_ptr, arg? 2 : 1, tmp, arg TSRMLS_CC);
+ zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval, arg? 2 : 1, &tmp, arg TSRMLS_CC);
aht->nApplyCount--;
} else {
if (ZEND_NUM_ARGS() != 1 || zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) {
- Z_TYPE_P(tmp) = IS_NULL;
zval_ptr_dtor(&tmp);
zend_throw_exception(spl_ce_BadMethodCallException, "Function expects exactly one argument", 0 TSRMLS_CC);
return;
}
aht->nApplyCount++;
- zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval_ptr, 2, tmp, arg TSRMLS_CC);
+ zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval, 2, &tmp, arg TSRMLS_CC);
aht->nApplyCount--;
}
- Z_TYPE_P(tmp) = IS_NULL; /* we want to destroy the zval, not the hashtable */
zval_ptr_dtor(&tmp);
- if (retval_ptr) {
- COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
+ if (!ZVAL_IS_UNDEF(&retval)) {
+ COPY_PZVAL_TO_ZVAL(*return_value, &retval);
}
} /* }}} */
SPL_METHOD(Array, current)
{
zval *object = getThis();
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
- zval **entry;
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
+ zval *entry;
HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
if (zend_parse_parameters_none() == FAILURE) {
return;
}
- if (zend_hash_get_current_data_ex(aht, (void **) &entry, &intern->pos) == FAILURE) {
+ if ((entry = zend_hash_get_current_data_ex(aht, &intern->pos)) == NULL) {
return;
}
- RETVAL_ZVAL(*entry, 1, 0);
+ RETVAL_ZVAL(entry, 1, 0);
}
/* }}} */
void spl_array_iterator_key(zval *object, zval *return_value TSRMLS_DC) /* {{{ */
{
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
if (spl_array_object_verify_pos(intern, aht TSRMLS_CC) == FAILURE) {
SPL_METHOD(Array, next)
{
zval *object = getThis();
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
if (zend_parse_parameters_none() == FAILURE) {
SPL_METHOD(Array, valid)
{
zval *object = getThis();
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
if (zend_parse_parameters_none() == FAILURE) {
Check whether current element has children (e.g. is an array) */
SPL_METHOD(Array, hasChildren)
{
- zval *object = getThis(), **entry;
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ zval *object = getThis(), *entry;
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
if (zend_parse_parameters_none() == FAILURE) {
RETURN_FALSE;
}
- if (zend_hash_get_current_data_ex(aht, (void **) &entry, &intern->pos) == FAILURE) {
+ if ((entry = zend_hash_get_current_data_ex(aht, &intern->pos)) == NULL) {
RETURN_FALSE;
}
- RETURN_BOOL(Z_TYPE_PP(entry) == IS_ARRAY || (Z_TYPE_PP(entry) == IS_OBJECT && (intern->ar_flags & SPL_ARRAY_CHILD_ARRAYS_ONLY) == 0));
+ RETURN_BOOL(Z_TYPE_P(entry) == IS_ARRAY || (Z_TYPE_P(entry) == IS_OBJECT && (intern->ar_flags & SPL_ARRAY_CHILD_ARRAYS_ONLY) == 0));
}
/* }}} */
Create a sub iterator for the current element (same class as $this) */
SPL_METHOD(Array, getChildren)
{
- zval *object = getThis(), **entry, *flags;
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ zval *object = getThis(), *entry, flags;
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
if (zend_parse_parameters_none() == FAILURE) {
return;
}
- if (zend_hash_get_current_data_ex(aht, (void **) &entry, &intern->pos) == FAILURE) {
+ if ((entry = zend_hash_get_current_data_ex(aht, &intern->pos)) == NULL) {
return;
}
- if (Z_TYPE_PP(entry) == IS_OBJECT) {
+ if (Z_TYPE_P(entry) == IS_OBJECT) {
if ((intern->ar_flags & SPL_ARRAY_CHILD_ARRAYS_ONLY) != 0) {
return;
}
- if (instanceof_function(Z_OBJCE_PP(entry), Z_OBJCE_P(getThis()) TSRMLS_CC)) {
- RETURN_ZVAL(*entry, 1, 0);
+ if (instanceof_function(Z_OBJCE_P(entry), Z_OBJCE_P(getThis()) TSRMLS_CC)) {
+ RETURN_ZVAL(entry, 1, 0);
}
}
- MAKE_STD_ZVAL(flags);
- ZVAL_LONG(flags, SPL_ARRAY_USE_OTHER | intern->ar_flags);
- spl_instantiate_arg_ex2(Z_OBJCE_P(getThis()), &return_value, 0, *entry, flags TSRMLS_CC);
- zval_ptr_dtor(&flags);
+ ZVAL_LONG(&flags, SPL_ARRAY_USE_OTHER | intern->ar_flags);
+ spl_instantiate_arg_ex2(Z_OBJCE_P(getThis()), return_value, entry, &flags TSRMLS_CC);
}
/* }}} */
SPL_METHOD(Array, serialize)
{
zval *object = getThis();
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
- zval members, *pmembers;
+ zval members, flags;
php_serialize_data_t var_hash;
smart_str buf = {0};
- zval *flags;
if (zend_parse_parameters_none() == FAILURE) {
return;
PHP_VAR_SERIALIZE_INIT(var_hash);
- MAKE_STD_ZVAL(flags);
- ZVAL_LONG(flags, (intern->ar_flags & SPL_ARRAY_CLONE_MASK));
+ ZVAL_LONG(&flags, (intern->ar_flags & SPL_ARRAY_CLONE_MASK));
/* storage */
smart_str_appendl(&buf, "x:", 2);
+ //!!! php_var_serialize need to be modified
php_var_serialize(&buf, &flags, &var_hash TSRMLS_CC);
- zval_ptr_dtor(&flags);
if (!(intern->ar_flags & SPL_ARRAY_IS_SELF)) {
php_var_serialize(&buf, &intern->array, &var_hash TSRMLS_CC);
/* members */
smart_str_appendl(&buf, "m:", 2);
- INIT_PZVAL(&members);
if (!intern->std.properties) {
rebuild_object_properties(&intern->std);
}
- Z_ARRVAL(members) = intern->std.properties;
- Z_TYPE(members) = IS_ARRAY;
- pmembers = &members;
- php_var_serialize(&buf, &pmembers, &var_hash TSRMLS_CC); /* finishes the string */
+
+ array_init(&members);
+ zend_hash_copy(Z_ARRVAL(members), intern->std.properties, (copy_ctor_func_t)zval_add_ref);
+
+ php_var_serialize(&buf, &members, &var_hash TSRMLS_CC); /* finishes the string */
/* done */
PHP_VAR_SERIALIZE_DESTROY(var_hash);
if (buf.c) {
- RETURN_STRINGL(buf.c, buf.len, 0);
+ RETVAL_STRINGL(buf.c, buf.len);
+ smart_str_free(&buf);
+ return;
}
+ zval_ptr_dtor(&members);
+
RETURN_NULL();
} /* }}} */
*/
SPL_METHOD(Array, unserialize)
{
- spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+ spl_array_object *intern = (spl_array_object*)Z_OBJ_P(getThis());
char *buf;
int buf_len;
const unsigned char *p, *s;
php_unserialize_data_t var_hash;
- zval *pmembers, *pflags = NULL;
+ zval members, zflags;
long flags;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &buf, &buf_len) == FAILURE) {
}
++p;
- ALLOC_INIT_ZVAL(pflags);
- if (!php_var_unserialize(&pflags, &p, s + buf_len, &var_hash TSRMLS_CC) || Z_TYPE_P(pflags) != IS_LONG) {
- zval_ptr_dtor(&pflags);
+ if (!php_var_unserialize(&zflags, &p, s + buf_len, &var_hash TSRMLS_CC) || Z_TYPE(zflags) != IS_LONG) {
goto outexcept;
}
--p; /* for ';' */
- flags = Z_LVAL_P(pflags);
- zval_ptr_dtor(&pflags);
+ flags = Z_LVAL(zflags);
/* flags needs to be verified and we also need to verify whether the next
* thing we get is ';'. After that we require an 'm' or somethign else
* where 'm' stands for members and anything else should be an array. If
intern->ar_flags &= ~SPL_ARRAY_CLONE_MASK;
intern->ar_flags |= flags & SPL_ARRAY_CLONE_MASK;
zval_ptr_dtor(&intern->array);
- ALLOC_INIT_ZVAL(intern->array);
if (!php_var_unserialize(&intern->array, &p, s + buf_len, &var_hash TSRMLS_CC)) {
goto outexcept;
}
}
++p;
- ALLOC_INIT_ZVAL(pmembers);
- if (!php_var_unserialize(&pmembers, &p, s + buf_len, &var_hash TSRMLS_CC)) {
- zval_ptr_dtor(&pmembers);
+ if (!php_var_unserialize(&members, &p, s + buf_len, &var_hash TSRMLS_CC)) {
goto outexcept;
}
if (!intern->std.properties) {
rebuild_object_properties(&intern->std);
}
- zend_hash_copy(intern->std.properties, Z_ARRVAL_P(pmembers), (copy_ctor_func_t) zval_add_ref, (void *) NULL, sizeof(zval *));
- zval_ptr_dtor(&pmembers);
+ zend_hash_copy(intern->std.properties, Z_ARRVAL(members), (copy_ctor_func_t) zval_add_ref);
/* done reading $serialized */
spl_handler_ArrayObject.unset_property = spl_array_unset_property;
spl_handler_ArrayObject.compare_objects = spl_array_compare_objects;
+ spl_handler_ArrayObject.free_obj = spl_array_object_free_storage;
+ spl_handler_ArrayObject.dtor_obj = zend_objects_destroy_object;
REGISTER_SPL_STD_CLASS_EX(ArrayIterator, spl_array_object_new, spl_funcs_ArrayIterator);
REGISTER_SPL_IMPLEMENTS(ArrayIterator, Iterator);
projects / php / commitdiff