diff options
Diffstat (limited to 'ext/spl/spl_array.c')
| -rw-r--r-- | ext/spl/spl_array.c | 926 |
1 files changed, 480 insertions, 446 deletions
diff --git a/ext/spl/spl_array.c b/ext/spl/spl_array.c index 3e97e9448d..f83004428e 100644 --- a/ext/spl/spl_array.c +++ b/ext/spl/spl_array.c @@ -63,9 +63,8 @@ PHPAPI zend_class_entry *spl_ce_RecursiveArrayIterator; #define SPL_ARRAY_METHOD_MAY_USER_ARG 2 typedef struct _spl_array_object { - zend_object std; - zval *array; - zval *retval; + zval array; + zval retval; HashPosition pos; ulong pos_h; int ar_flags; @@ -76,18 +75,26 @@ typedef struct _spl_array_object { zend_function *fptr_offset_del; zend_function *fptr_count; zend_class_entry* ce_get_iterator; - HashTable *debug_info; - unsigned char nApplyCount; + HashTable *debug_info; + unsigned char nApplyCount; + zend_object std; } spl_array_object; +static inline spl_array_object *spl_array_from_obj(zend_object *obj) /* {{{ */ { + return (spl_array_object*)((char*)(obj) - XtOffsetOf(spl_array_object, std)); +} +/* }}} */ + +#define Z_SPLARRAY_P(zv) spl_array_from_obj(Z_OBJ_P((zv))) + static inline HashTable *spl_array_get_hash_table(spl_array_object* intern, int check_std_props TSRMLS_DC) { /* {{{ */ if ((intern->ar_flags & SPL_ARRAY_IS_SELF) != 0) { if (!intern->std.properties) { 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 = Z_SPLARRAY_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) { @@ -95,39 +102,45 @@ static inline HashTable *spl_array_get_hash_table(spl_array_object* intern, int } return intern->std.properties; } else { - return HASH_OF(intern->array); + return HASH_OF(&intern->array); } } /* }}} */ static void spl_array_rewind(spl_array_object *intern TSRMLS_DC); -static void spl_array_update_pos(spl_array_object* intern) /* {{{ */ +static void spl_array_update_pos(HashTable *ht, spl_array_object* intern) /* {{{ */ { - Bucket *pos = intern->pos; - if (pos != NULL) { - intern->pos_h = pos->h; + uint pos = intern->pos; + if (pos != INVALID_IDX) { + intern->pos_h = ht->arData[pos].h; } } /* }}} */ -static void spl_array_set_pos(spl_array_object* intern, HashPosition pos) /* {{{ */ +static void spl_array_set_pos(spl_array_object* intern, HashTable *ht, HashPosition pos) /* {{{ */ { intern->pos = pos; - spl_array_update_pos(intern); + spl_array_update_pos(ht, intern); } /* }}} */ SPL_API int spl_hash_verify_pos_ex(spl_array_object * intern, HashTable * ht TSRMLS_DC) /* {{{ */ { - Bucket *p; + uint idx; /* IS_CONSISTENT(ht);*/ /* HASH_PROTECT_RECURSION(ht);*/ - p = ht->arBuckets[intern->pos_h & ht->nTableMask]; - while (p != NULL) { - if (p == intern->pos) { + if (ht->u.flags & HASH_FLAG_PACKED) { + if (intern->pos_h == intern->pos && Z_TYPE(ht->arData[intern->pos_h].val) != IS_UNDEF) { return SUCCESS; } - p = p->pNext; + } else { + idx = ht->arHash[intern->pos_h & ht->nTableMask]; + while (idx != INVALID_IDX) { + if (idx == intern->pos) { + return SUCCESS; + } + idx = Z_NEXT(ht->arData[idx].val); + } } /* HASH_UNPROTECT_RECURSION(ht); */ spl_array_rewind(intern TSRMLS_CC); @@ -143,9 +156,9 @@ SPL_API int spl_hash_verify_pos(spl_array_object * intern TSRMLS_DC) /* {{{ */ /* }}} */ /* {{{ spl_array_object_free_storage */ -static void spl_array_object_free_storage(void *object TSRMLS_DC) +static void spl_array_object_free_storage(zend_object *object TSRMLS_DC) { - spl_array_object *intern = (spl_array_object *)object; + spl_array_object *intern = spl_array_from_obj(object); zend_object_std_dtor(&intern->std TSRMLS_CC); @@ -156,26 +169,19 @@ static void spl_array_object_free_storage(void *object TSRMLS_DC) zend_hash_destroy(intern->debug_info); efree(intern->debug_info); } - - efree(object); } /* }}} */ 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; + 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); + intern = ecalloc(1, sizeof(spl_array_object) + sizeof(zval) * (parent->default_properties_count - 1)); zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); @@ -184,7 +190,7 @@ static zend_object_value spl_array_object_new_ex(zend_class_entry *class_type, s 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 = Z_SPLARRAY_P(orig); intern->ar_flags &= ~ SPL_ARRAY_CLONE_MASK; intern->ar_flags |= (other->ar_flags & SPL_ARRAY_CLONE_MASK); @@ -192,32 +198,29 @@ static zend_object_value spl_array_object_new_ex(zend_class_entry *class_type, s 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); 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; @@ -227,36 +230,36 @@ static zend_object_value spl_array_object_new_ex(zend_class_entry *class_type, s 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; @@ -268,100 +271,124 @@ static zend_object_value spl_array_object_new_ex(zend_class_entry *class_type, s } 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; + zval *retval; long index; + zend_string *offset_key; + spl_array_object *intern = Z_SPLARRAY_P(object); HashTable *ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); - if (!offset) { - return &EG(uninitialized_zval_ptr); + if (!offset || Z_ISUNDEF_P(offset)) { + return &EG(uninitialized_zval); } - if ((type == BP_VAR_W || type == BP_VAR_RW) && (ht->nApplyCount > 0)) { + if ((type == BP_VAR_W || type == BP_VAR_RW) && (ht->u.v.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: + 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", Z_STRVAL_P(offset)); + zend_error(E_NOTICE, "Undefined index: %s", offset_key->val); 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)); + zend_error(E_NOTICE,"Undefined index: %s", offset_key->val); 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_NULL(&value); + retval = zend_symtable_update(ht, offset_key, &value); } } } return retval; case IS_RESOURCE: - zend_error(E_STRICT, "Resource ID#%ld used as offset, casting to integer (%ld)", Z_LVAL_P(offset), Z_LVAL_P(offset)); + zend_error(E_STRICT, "Resource ID#%ld used as offset, casting to integer (%ld)", Z_RES_P(offset)->handle, Z_RES_P(offset)->handle); + index = Z_RES_P(offset)->handle; + goto num_index; case IS_DOUBLE: - case IS_BOOL: + index = (long)Z_DVAL_P(offset); + goto num_index; + case IS_FALSE: + index = 0; + goto num_index; + case IS_TRUE: + index = 1; + goto num_index; case IS_LONG: - if (offset->type == IS_DOUBLE) { - index = (long)Z_DVAL_P(offset); - } else { - index = Z_LVAL_P(offset); - } - if (zend_hash_index_find(ht, index, (void **) &retval) == FAILURE) { + index = Z_LVAL_P(offset); +num_index: + 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); } } } @@ -369,131 +396,135 @@ static zval **spl_array_get_dimension_ptr_ptr(int check_inherited, zval *object, 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) /* {{{ */ +static zval *spl_array_read_dimension_ex(int check_inherited, zval *object, zval *offset, int type, zval *zv 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 = Z_SPLARRAY_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 (!Z_ISUNDEF(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); /* 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) */ - 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); + * 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_P(ret) && + EXPECTED(ret != &EG(uninitialized_zval))) { + ZVAL_NEW_REF(ret, ret); } - return *ret; + return ret; } /* }}} */ -static zval *spl_array_read_dimension(zval *object, zval *offset, int type TSRMLS_DC) /* {{{ */ +static zval *spl_array_read_dimension(zval *object, zval *offset, int type, zval *rv TSRMLS_DC) /* {{{ */ { - return spl_array_read_dimension_ex(1, object, offset, type TSRMLS_CC); + return spl_array_read_dimension_ex(1, object, offset, type, rv TSRMLS_CC); } /* }}} */ 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 = Z_SPLARRAY_P(object); long index; HashTable *ht; if (check_inherited && intern->fptr_offset_set) { + zval tmp; + if (!offset) { - ALLOC_INIT_ZVAL(offset); + ZVAL_NULL(&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; } if (!offset) { ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); - if (ht->nApplyCount > 0) { + if (ht->u.v.nApplyCount > 0) { zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited"); return; } - Z_ADDREF_P(value); - zend_hash_next_index_insert(ht, (void**)&value, sizeof(void*), NULL); + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zend_hash_next_index_insert(ht, value); return; } - switch(Z_TYPE_P(offset)) { - case IS_STRING: - ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); - if (ht->nApplyCount > 0) { - zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited"); - return; - } + + if (Z_REFCOUNTED_P(value)) { Z_ADDREF_P(value); - zend_symtable_update(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, (void**)&value, sizeof(void*), NULL); - return; - case IS_DOUBLE: - case IS_RESOURCE: - case IS_BOOL: - case IS_LONG: - ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); - if (ht->nApplyCount > 0) { - zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited"); + } + switch (Z_TYPE_P(offset)) { + case IS_STRING: + ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); + if (ht->u.v.nApplyCount > 0) { + zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited"); + return; + } + zend_symtable_update_ind(ht, Z_STR_P(offset), value); return; - } - if (offset->type == IS_DOUBLE) { + case IS_DOUBLE: index = (long)Z_DVAL_P(offset); - } else { + goto num_index; + case IS_RESOURCE: + index = Z_RES_HANDLE_P(offset); + goto num_index; + case IS_FALSE: + index = 0; + goto num_index; + case IS_TRUE: + index = 1; + goto num_index; + case IS_LONG: index = Z_LVAL_P(offset); - } - Z_ADDREF_P(value); - zend_hash_index_update(ht, index, (void**)&value, sizeof(void*), NULL); - return; - case IS_NULL: - ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); - if (ht->nApplyCount > 0) { - zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited"); +num_index: + ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); + if (ht->u.v.nApplyCount > 0) { + zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited"); + return; + } + zend_hash_index_update(ht, index, value); + return; + case IS_NULL: + ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); + if (ht->u.v.nApplyCount > 0) { + zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited"); + return; + } + zend_hash_next_index_insert(ht, value); + return; + default: + zend_error(E_WARNING, "Illegal offset type"); return; - } - Z_ADDREF_P(value); - zend_hash_next_index_insert(ht, (void**)&value, sizeof(void*), NULL); - return; - default: - zend_error(E_WARNING, "Illegal offset type"); - return; } } /* }}} */ @@ -504,77 +535,77 @@ static void spl_array_write_dimension(zval *object, zval *offset, zval *value TS 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 = Z_SPLARRAY_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; } switch(Z_TYPE_P(offset)) { case IS_STRING: ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); - if (ht->nApplyCount > 0) { + if (ht->u.v.nApplyCount > 0) { 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) { - 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) { - if ((obj->ar_flags & SPL_ARRAY_USE_OTHER) == 0) { - obj = (spl_array_object*)zend_object_store_get_object(obj->array TSRMLS_CC); - break; - } else { - obj = (spl_array_object*)zend_object_store_get_object(obj->array TSRMLS_CC); - } +//??? 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) { - obj->std.properties_table[property_info->offset] = NULL; + 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_DOUBLE: + index = (long)Z_DVAL_P(offset); + goto num_index; case IS_RESOURCE: - case IS_BOOL: + index = Z_RES_HANDLE_P(offset); + goto num_index; + case IS_FALSE: + index = 0; + goto num_index; + case IS_TRUE: + index = 1; + goto num_index; case IS_LONG: - if (offset->type == IS_DOUBLE) { - index = (long)Z_DVAL_P(offset); - } else { - index = Z_LVAL_P(offset); - } + index = Z_LVAL_P(offset); +num_index: ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); - if (ht->nApplyCount > 0) { + if (ht->u.v.nApplyCount > 0) { zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited"); return; } if (zend_hash_index_del(ht, index) == FAILURE) { - zend_error(E_NOTICE,"Undefined offset: %ld", Z_LVAL_P(offset)); + zend_error(E_NOTICE,"Undefined offset: %ld", index); } break; default: @@ -591,27 +622,29 @@ static void spl_array_unset_dimension(zval *object, zval *offset TSRMLS_DC) /* { 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); + spl_array_object *intern = Z_SPLARRAY_P(object); long index; - zval *rv, *value = NULL, **tmp; + zval rv, *value = NULL, *tmp; if (check_inherited && intern->fptr_offset_has) { - zval *offset_tmp = offset; - SEPARATE_ARG_IF_REF(offset_tmp); - zend_call_method_with_1_params(&object, Z_OBJCE_P(object), &intern->fptr_offset_has, "offsetExists", &rv, offset_tmp); - zval_ptr_dtor(&offset_tmp); +//??? zval offset_tmp; +//??? ZVAL_COPY_VALUE(&offset_tmp, offset); +//??? SEPARATE_ARG_IF_REF(&offset_tmp); +//??? zend_call_method_with_1_params(object, Z_OBJCE_P(object), &intern->fptr_offset_has, "offsetExists", &rv, &offset_tmp); +//??? zval_ptr_dtor(&offset_tmp); + 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)) { + if (!Z_ISUNDEF(rv) && zend_is_true(&rv TSRMLS_CC)) { zval_ptr_dtor(&rv); if (check_empty == 2) { return 1; } else if (intern->fptr_offset_get) { - value = spl_array_read_dimension_ex(1, object, offset, BP_VAR_R TSRMLS_CC); + value = spl_array_read_dimension_ex(1, object, offset, BP_VAR_R, &rv TSRMLS_CC); } } else { - if (rv) { - zval_ptr_dtor(&rv); - } + zval_ptr_dtor(&rv); return 0; } } @@ -621,7 +654,7 @@ static int spl_array_has_dimension_ex(int check_inherited, zval *object, zval *o switch(Z_TYPE_P(offset)) { case IS_STRING: - 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) { if (check_empty == 2) { return 1; } @@ -630,15 +663,21 @@ static int spl_array_has_dimension_ex(int check_inherited, zval *object, zval *o } break; case IS_DOUBLE: + index = (long)Z_DVAL_P(offset); + goto num_index; case IS_RESOURCE: - case IS_BOOL: + index = Z_RES_HANDLE_P(offset); + goto num_index; + case IS_FALSE: + index = 0; + goto num_index; + case IS_TRUE: + index = 1; + goto num_index; case IS_LONG: - if (offset->type == IS_DOUBLE) { - index = (long)Z_DVAL_P(offset); - } else { - index = Z_LVAL_P(offset); - } - if (zend_hash_index_find(ht, index, (void **)&tmp) != FAILURE) { + index = Z_LVAL_P(offset); +num_index: + if ((tmp = zend_hash_index_find(ht, index)) != NULL) { if (check_empty == 2) { return 1; } @@ -652,9 +691,9 @@ static int spl_array_has_dimension_ex(int check_inherited, zval *object, zval *o } if (check_inherited && intern->fptr_offset_get) { - value = spl_array_read_dimension_ex(1, object, offset, BP_VAR_R TSRMLS_CC); + value = spl_array_read_dimension_ex(1, object, offset, BP_VAR_R, &rv TSRMLS_CC); } else { - value = *tmp; + value = tmp; } } @@ -683,7 +722,7 @@ static inline int spl_array_object_verify_pos_ex(spl_array_object *object, HashT return FAILURE; } - if (object->pos && (object->ar_flags & SPL_ARRAY_IS_REF) && spl_hash_verify_pos_ex(object, ht TSRMLS_CC) == FAILURE) { + if (object->pos != INVALID_IDX && (object->ar_flags & SPL_ARRAY_IS_REF) && spl_hash_verify_pos_ex(object, ht TSRMLS_CC) == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_NOTICE, "%sArray was modified outside object and internal position is no longer valid", msg_prefix); return FAILURE; } @@ -714,12 +753,14 @@ SPL_METHOD(Array, offsetExists) 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; } - value = spl_array_read_dimension_ex(0, getThis(), index, BP_VAR_R TSRMLS_CC); - RETURN_ZVAL(value, 1, 0); + value = spl_array_read_dimension_ex(0, getThis(), index, BP_VAR_R, return_value TSRMLS_CC); + if (value != return_value) { + RETURN_ZVAL(value, 1, 0); + } } /* }}} */ /* {{{ proto void ArrayObject::offsetSet(mixed $index, mixed $newval) @@ -736,7 +777,7 @@ SPL_METHOD(Array, offsetSet) 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 = Z_SPLARRAY_P(object); HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); if (!aht) { @@ -744,14 +785,16 @@ void spl_array_iterator_append(zval *object, zval *append_value TSRMLS_DC) /* {{ return; } - if (Z_TYPE_P(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); + 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->val); return; } spl_array_write_dimension(object, NULL, append_value TSRMLS_CC); - if (!intern->pos) { - spl_array_set_pos(intern, aht->pListTail); + if (intern->pos == INVALID_IDX) { + if (aht->nNumUsed && !Z_ISUNDEF(aht->arData[aht->nNumUsed-1].val)) { + spl_array_set_pos(intern, aht, aht->nNumUsed - 1); + } } } /* }}} */ @@ -785,16 +828,16 @@ SPL_METHOD(Array, offsetUnset) Return a copy of the contained array */ SPL_METHOD(Array, getArrayCopy) { - zval *object = getThis(), *tmp; - spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC); + zval *object = getThis(); + spl_array_object *intern = Z_SPLARRAY_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(Z_ARRVAL_P(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 = Z_SPLARRAY_P(object); HashTable *result; if (intern->nApplyCount > 1) { @@ -809,11 +852,10 @@ static HashTable *spl_array_get_properties(zval *object TSRMLS_DC) /* {{{ */ 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; - int name_len; - char *zname; + zval *storage; + zend_string *zname; zend_class_entry *base; + spl_array_object *intern = Z_SPLARRAY_P(obj); *is_temp = 0; @@ -821,7 +863,7 @@ static HashTable* spl_array_get_debug_info(zval *obj, int *is_temp TSRMLS_DC) /* 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) { @@ -829,17 +871,17 @@ static HashTable* spl_array_get_debug_info(zval *obj, int *is_temp TSRMLS_DC) /* ZEND_INIT_SYMTABLE_EX(intern->debug_info, zend_hash_num_elements(intern->std.properties) + 1, 0); } - if (intern->debug_info->nApplyCount == 0) { + if (intern->debug_info->u.v.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); - efree(zname); + zname = spl_gen_private_prop_name(base, "storage", sizeof("storage")-1 TSRMLS_CC); + zend_symtable_update(intern->debug_info, zname, storage); + STR_RELEASE(zname); } return intern->debug_info; @@ -847,62 +889,64 @@ static HashTable* spl_array_get_debug_info(zval *obj, int *is_temp TSRMLS_DC) /* } /* }}} */ -static zval *spl_array_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */ +static zval *spl_array_read_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC) /* {{{ */ { - spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC); + spl_array_object *intern = Z_SPLARRAY_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_read_dimension(object, member, type TSRMLS_CC); + && !std_object_handlers.has_property(object, member, 2, cache_slot TSRMLS_CC)) { + return spl_array_read_dimension(object, member, type, rv TSRMLS_CC); } - return std_object_handlers.read_property(object, member, type, key TSRMLS_CC); + return std_object_handlers.read_property(object, member, type, cache_slot, rv TSRMLS_CC); } /* }}} */ -static void spl_array_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC) /* {{{ */ +static void spl_array_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC) /* {{{ */ { - spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC); + spl_array_object *intern = Z_SPLARRAY_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, cache_slot TSRMLS_CC)) { spl_array_write_dimension(object, member, value TSRMLS_CC); return; } - std_object_handlers.write_property(object, member, value, key TSRMLS_CC); + std_object_handlers.write_property(object, member, value, cache_slot 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, zend_uint cache_slot TSRMLS_DC) /* {{{ */ { - spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC); + spl_array_object *intern = Z_SPLARRAY_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, cache_slot 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) /* {{{ */ +static int spl_array_has_property(zval *object, zval *member, int has_set_exists, zend_uint cache_slot TSRMLS_DC) /* {{{ */ { - spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC); + spl_array_object *intern = Z_SPLARRAY_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, cache_slot 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); + return std_object_handlers.has_property(object, member, has_set_exists, cache_slot TSRMLS_CC); } /* }}} */ -static void spl_array_unset_property(zval *object, zval *member, const zend_literal *key TSRMLS_DC) /* {{{ */ +static void spl_array_unset_property(zval *object, zval *member, zend_uint cache_slot TSRMLS_DC) /* {{{ */ { - spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC); + spl_array_object *intern = Z_SPLARRAY_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, cache_slot TSRMLS_CC)) { spl_array_unset_dimension(object, member TSRMLS_CC); spl_array_rewind(intern TSRMLS_CC); /* because deletion might invalidate position */ return; } - std_object_handlers.unset_property(object, member, key TSRMLS_CC); + std_object_handlers.unset_property(object, member, cache_slot TSRMLS_CC); } /* }}} */ static int spl_array_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */ @@ -914,8 +958,8 @@ static int spl_array_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */ 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 = Z_SPLARRAY_P(o1); + intern2 = Z_SPLARRAY_P(o2); ht1 = spl_array_get_hash_table(intern1, 0 TSRMLS_CC); ht2 = spl_array_get_hash_table(intern2, 0 TSRMLS_CC); @@ -931,14 +975,18 @@ static int spl_array_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */ 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; + zval *data; - 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) { + 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 { @@ -948,7 +996,7 @@ static int spl_array_skip_protected(spl_array_object *intern, HashTable *aht TSR return FAILURE; } zend_hash_move_forward_ex(aht, &intern->pos); - spl_array_update_pos(intern); + spl_array_update_pos(aht, intern); } while (1); } return FAILURE; @@ -957,8 +1005,8 @@ static int spl_array_skip_protected(spl_array_object *intern, HashTable *aht TSR static int spl_array_next_no_verify(spl_array_object *intern, HashTable *aht TSRMLS_DC) /* {{{ */ { zend_hash_move_forward_ex(aht, &intern->pos); - spl_array_update_pos(intern); - if (Z_TYPE_P(intern->array) == IS_OBJECT) { + spl_array_update_pos(aht, intern); + 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); @@ -983,28 +1031,17 @@ static int spl_array_next(spl_array_object *intern TSRMLS_DC) /* {{{ */ } /* }}} */ -/* define an overloaded iterator structure */ -typedef struct { - zend_user_iterator intern; - spl_array_object *object; -} spl_array_it; - static void spl_array_it_dtor(zend_object_iterator *iter TSRMLS_DC) /* {{{ */ { - spl_array_it *iterator = (spl_array_it *)iter; - zend_user_it_invalidate_current(iter TSRMLS_CC); - zval_ptr_dtor((zval**)&iterator->intern.it.data); - - efree(iterator); + zval_ptr_dtor(&iter->data); } /* }}} */ static int spl_array_it_valid(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); + spl_array_object *object = Z_SPLARRAY_P(&iter->data); + HashTable *aht = spl_array_get_hash_table(object, 0 TSRMLS_CC); if (object->ar_flags & SPL_ARRAY_OVERLOADED_VALID) { return zend_user_it_valid(iter TSRMLS_CC); @@ -1018,27 +1055,27 @@ static int spl_array_it_valid(zend_object_iterator *iter TSRMLS_DC) /* {{{ */ } /* }}} */ -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); + spl_array_object *object = Z_SPLARRAY_P(&iter->data); + 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; + 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; } } /* }}} */ static void spl_array_it_get_current_key(zend_object_iterator *iter, zval *key 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); + spl_array_object *object = Z_SPLARRAY_P(&iter->data); + HashTable *aht = spl_array_get_hash_table(object, 0 TSRMLS_CC); if (object->ar_flags & SPL_ARRAY_OVERLOADED_KEY) { zend_user_it_get_current_key(iter, key TSRMLS_CC); @@ -1054,9 +1091,8 @@ static void spl_array_it_get_current_key(zend_object_iterator *iter, zval *key T static void spl_array_it_move_forward(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); + spl_array_object *object = Z_SPLARRAY_P(&iter->data); + HashTable *aht = spl_array_get_hash_table(object, 0 TSRMLS_CC); if (object->ar_flags & SPL_ARRAY_OVERLOADED_NEXT) { zend_user_it_move_forward(iter TSRMLS_CC); @@ -1080,14 +1116,14 @@ static void spl_array_rewind_ex(spl_array_object *intern, HashTable *aht TSRMLS_ { zend_hash_internal_pointer_reset_ex(aht, &intern->pos); - spl_array_update_pos(intern); + spl_array_update_pos(aht, intern); spl_array_skip_protected(intern, aht TSRMLS_CC); } /* }}} */ static void spl_array_rewind(spl_array_object *intern TSRMLS_DC) /* {{{ */ { - HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); + HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); if (!aht) { php_error_docref(NULL TSRMLS_CC, E_NOTICE, "ArrayIterator::rewind(): Array was modified outside object and is no longer an array"); @@ -1100,8 +1136,7 @@ static void spl_array_rewind(spl_array_object *intern TSRMLS_DC) /* {{{ */ static void spl_array_it_rewind(zend_object_iterator *iter TSRMLS_DC) /* {{{ */ { - spl_array_it *iterator = (spl_array_it *)iter; - spl_array_object *object = iterator->object; + spl_array_object *object = Z_SPLARRAY_P(&iter->data); if (object->ar_flags & SPL_ARRAY_OVERLOADED_REWIND) { zend_user_it_rewind(iter TSRMLS_CC); @@ -1113,41 +1148,41 @@ static void spl_array_it_rewind(zend_object_iterator *iter TSRMLS_DC) /* {{{ */ /* }}} */ /* {{{ 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 = Z_SPLARRAY_P(array); 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_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; + ZVAL_COPY_VALUE(&intern->array, array); } - if (object == *array) { + if (Z_TYPE_P(array) == IS_OBJECT && Z_OBJ_P(object) == Z_OBJ_P(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); } } @@ -1167,23 +1202,23 @@ zend_object_iterator_funcs spl_array_it_funcs = { 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); + zend_user_iterator *iterator; + spl_array_object *array_object = Z_SPLARRAY_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"); } - iterator = emalloc(sizeof(spl_array_it)); + iterator = emalloc(sizeof(zend_user_iterator)); + + zend_iterator_init(&iterator->it TSRMLS_CC); - Z_ADDREF_P(object); - iterator->intern.it.data = (void*)object; - iterator->intern.it.funcs = &spl_array_it_funcs; - iterator->intern.ce = ce; - iterator->intern.value = NULL; - iterator->object = array_object; + ZVAL_COPY(&iterator->it.data, object); + iterator->it.funcs = &spl_array_it_funcs; + iterator->ce = ce; + ZVAL_UNDEF(&iterator->value); - return (zend_object_iterator*)iterator; + return &iterator->it; } /* }}} */ @@ -1194,7 +1229,7 @@ SPL_METHOD(Array, __construct) { 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; @@ -1205,9 +1240,9 @@ SPL_METHOD(Array, __construct) 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 = Z_SPLARRAY_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; } @@ -1230,7 +1265,7 @@ SPL_METHOD(Array, __construct) 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 = Z_SPLARRAY_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) { @@ -1246,13 +1281,14 @@ SPL_METHOD(Array, setIteratorClass) 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 = Z_SPLARRAY_P(object); if (zend_parse_parameters_none() == FAILURE) { return; } - RETURN_STRING(intern->ce_get_iterator->name, 1); + STR_ADDREF(intern->ce_get_iterator->name); + RETURN_STR(intern->ce_get_iterator->name); } /* }}} */ @@ -1261,7 +1297,7 @@ SPL_METHOD(Array, getIteratorClass) 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 = Z_SPLARRAY_P(object); if (zend_parse_parameters_none() == FAILURE) { return; @@ -1276,7 +1312,7 @@ SPL_METHOD(Array, getFlags) 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 = Z_SPLARRAY_P(object); long ar_flags = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &ar_flags) == FAILURE) { @@ -1291,18 +1327,16 @@ SPL_METHOD(Array, setFlags) 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 = Z_SPLARRAY_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*)); - - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &array) == FAILURE) { + 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) { return; } spl_array_set_array(object, intern, array, 0L, 1 TSRMLS_CC); - } /* }}} */ @@ -1311,8 +1345,7 @@ SPL_METHOD(Array, exchangeArray) 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 = Z_SPLARRAY_P(object); HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); if (zend_parse_parameters_none() == FAILURE) { @@ -1324,10 +1357,9 @@ SPL_METHOD(Array, getIterator) 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); + //!!!PZ_SET_ISREF_P(return_value); } /* }}} */ @@ -1336,7 +1368,7 @@ SPL_METHOD(Array, getIterator) 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 = Z_SPLARRAY_P(object); if (zend_parse_parameters_none() == FAILURE) { return; @@ -1352,7 +1384,7 @@ SPL_METHOD(Array, seek) { 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 = Z_SPLARRAY_P(object); HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); int result; @@ -1391,16 +1423,16 @@ int static spl_array_object_count_elements_helper(spl_array_object *intern, long 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; *count = 0; spl_array_rewind(intern TSRMLS_CC); - while(intern->pos && spl_array_next(intern TSRMLS_CC) == SUCCESS) { + while(intern->pos != INVALID_IDX && spl_array_next(intern TSRMLS_CC) == SUCCESS) { (*count)++; } - spl_array_set_pos(intern, pos); + spl_array_set_pos(intern, aht, pos); return SUCCESS; } else { *count = zend_hash_num_elements(aht); @@ -1410,17 +1442,16 @@ int static spl_array_object_count_elements_helper(spl_array_object *intern, long 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 = Z_SPLARRAY_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; @@ -1435,7 +1466,7 @@ int spl_array_object_count_elements(zval *object, long *count TSRMLS_DC) /* {{{ 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 = Z_SPLARRAY_P(getThis()); if (zend_parse_parameters_none() == FAILURE) { return; @@ -1448,44 +1479,48 @@ SPL_METHOD(Array, count) 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 = Z_SPLARRAY_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; + /* A tricky way to pass "aht" by reference, copy HashTable */ + //??? It may be not safe, if user comparison handler accesses "aht" + ZVAL_NEW_ARR(&tmp); + *Z_ARRVAL(tmp) = *aht; if (!use_arg) { - aht->nApplyCount++; - zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval_ptr, 1, tmp, NULL TSRMLS_CC); - aht->nApplyCount--; + aht->u.v.nApplyCount++; + zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval, 1, &tmp, NULL TSRMLS_CC); + aht->u.v.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); - aht->nApplyCount--; + aht->u.v.nApplyCount++; + zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval, arg? 2 : 1, &tmp, arg TSRMLS_CC); + aht->u.v.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); - aht->nApplyCount--; + aht->u.v.nApplyCount++; + zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval, 2, &tmp, arg TSRMLS_CC); + aht->u.v.nApplyCount--; + } + /* A tricky way to pass "aht" by reference, copy back and cleanup */ + if (Z_ISREF(tmp) && Z_TYPE_P(Z_REFVAL(tmp))) { + *aht = *Z_ARRVAL_P(Z_REFVAL(tmp)); + GC_REMOVE_FROM_BUFFER(Z_ARR_P(Z_REFVAL(tmp))); + efree(Z_ARR_P(Z_REFVAL(tmp))); + efree(Z_REF(tmp)); } - 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 (!Z_ISUNDEF(retval)) { + ZVAL_COPY_VALUE(return_value, &retval); } } /* }}} */ @@ -1530,8 +1565,8 @@ SPL_ARRAY_METHOD(Array, natcasesort, SPL_ARRAY_METHOD_NO_ARG) /* }}} */ 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 = Z_SPLARRAY_P(object); + zval *entry; HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); if (zend_parse_parameters_none() == FAILURE) { @@ -1542,10 +1577,16 @@ SPL_METHOD(Array, current) 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); + 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); } /* }}} */ @@ -1562,7 +1603,7 @@ SPL_METHOD(Array, key) 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 = Z_SPLARRAY_P(object); HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); if (spl_array_object_verify_pos(intern, aht TSRMLS_CC) == FAILURE) { @@ -1578,7 +1619,7 @@ void spl_array_iterator_key(zval *object, zval *return_value TSRMLS_DC) /* {{{ * 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 = Z_SPLARRAY_P(object); HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); if (zend_parse_parameters_none() == FAILURE) { @@ -1598,7 +1639,7 @@ SPL_METHOD(Array, next) 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 = Z_SPLARRAY_P(object); HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); if (zend_parse_parameters_none() == FAILURE) { @@ -1617,8 +1658,8 @@ SPL_METHOD(Array, valid) 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 = Z_SPLARRAY_P(object); HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); if (zend_parse_parameters_none() == FAILURE) { @@ -1629,11 +1670,11 @@ SPL_METHOD(Array, hasChildren) 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)); } /* }}} */ @@ -1641,8 +1682,8 @@ SPL_METHOD(Array, hasChildren) 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 = Z_SPLARRAY_P(object); HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); if (zend_parse_parameters_none() == FAILURE) { @@ -1653,23 +1694,21 @@ SPL_METHOD(Array, getChildren) 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); } /* }}} */ @@ -1678,12 +1717,11 @@ SPL_METHOD(Array, getChildren) 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 = Z_SPLARRAY_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; @@ -1696,13 +1734,12 @@ SPL_METHOD(Array, serialize) 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); @@ -1711,20 +1748,22 @@ SPL_METHOD(Array, serialize) /* 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 */ + + zval_ptr_dtor(&members); /* done */ PHP_VAR_SERIALIZE_DESTROY(var_hash); - if (buf.c) { - RETURN_STRINGL(buf.c, buf.len, 0); + if (buf.s) { + RETURN_STR(buf.s); } RETURN_NULL(); @@ -1735,13 +1774,13 @@ SPL_METHOD(Array, serialize) */ SPL_METHOD(Array, unserialize) { - spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + spl_array_object *intern = Z_SPLARRAY_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) { @@ -1762,15 +1801,12 @@ SPL_METHOD(Array, unserialize) } ++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 @@ -1788,7 +1824,6 @@ SPL_METHOD(Array, unserialize) 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; } @@ -1804,18 +1839,13 @@ SPL_METHOD(Array, unserialize) } ++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; } /* copy members */ - 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); + object_properties_load(&intern->std, Z_ARRVAL(members) TSRMLS_CC); + zval_ptr_dtor(&members); /* done reading $serialized */ @@ -1947,6 +1977,8 @@ PHP_MINIT_FUNCTION(spl_array) REGISTER_SPL_IMPLEMENTS(ArrayObject, Countable); memcpy(&spl_handler_ArrayObject, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); + spl_handler_ArrayObject.offset = XtOffsetOf(spl_array_object, std); + spl_handler_ArrayObject.clone_obj = spl_array_object_clone; spl_handler_ArrayObject.read_dimension = spl_array_read_dimension; spl_handler_ArrayObject.write_dimension = spl_array_write_dimension; @@ -1963,6 +1995,8 @@ PHP_MINIT_FUNCTION(spl_array) spl_handler_ArrayObject.unset_property = spl_array_unset_property; spl_handler_ArrayObject.compare_objects = spl_array_compare_objects; + spl_handler_ArrayObject.dtor_obj = zend_objects_destroy_object; + spl_handler_ArrayObject.free_obj = spl_array_object_free_storage; REGISTER_SPL_STD_CLASS_EX(ArrayIterator, spl_array_object_new, spl_funcs_ArrayIterator); REGISTER_SPL_IMPLEMENTS(ArrayIterator, Iterator); |