/*

+----------------------------------------------------------------------+

| PHP Version 5 |

+----------------------------------------------------------------------+

| Copyright (c) 1997-2013 The PHP Group |

+----------------------------------------------------------------------+

| This source file is subject to version 3.01 of the PHP license, |

| that is bundled with this package in the file LICENSE, and is |

| available through the world-wide-web at the following url: |

| http://www.php.net/license/3_01.txt |

| If you did not receive a copy of the PHP license and are unable to |

| obtain it through the world-wide-web, please send a note to |

| license@php.net so we can mail you a copy immediately. |

+----------------------------------------------------------------------+

| Authors: Marcus Boerger <helly@php.net> |

+----------------------------------------------------------------------+

*/

/* $Id$ */

#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#include "php.h"

#include "php_ini.h"

#include "ext/standard/info.h"

#include "ext/standard/php_var.h"

#include "ext/standard/php_smart_str.h"

#include "zend_interfaces.h"

#include "zend_exceptions.h"

#include "php_spl.h"

#include "spl_functions.h"

#include "spl_engine.h"

#include "spl_iterators.h"

#include "spl_array.h"

#include "spl_exceptions.h"

zend_object_handlers spl_handler_ArrayObject;

PHPAPI zend_class_entry *spl_ce_ArrayObject;

zend_object_handlers spl_handler_ArrayIterator;

PHPAPI zend_class_entry *spl_ce_ArrayIterator;

PHPAPI zend_class_entry *spl_ce_RecursiveArrayIterator;

#define SPL_ARRAY_STD_PROP_LIST 0x00000001

#define SPL_ARRAY_ARRAY_AS_PROPS 0x00000002

#define SPL_ARRAY_CHILD_ARRAYS_ONLY 0x00000004

#define SPL_ARRAY_OVERLOADED_REWIND 0x00010000

#define SPL_ARRAY_OVERLOADED_VALID 0x00020000

#define SPL_ARRAY_OVERLOADED_KEY 0x00040000

#define SPL_ARRAY_OVERLOADED_CURRENT 0x00080000

#define SPL_ARRAY_OVERLOADED_NEXT 0x00100000

#define SPL_ARRAY_IS_REF 0x01000000

#define SPL_ARRAY_IS_SELF 0x02000000

#define SPL_ARRAY_USE_OTHER 0x04000000

#define SPL_ARRAY_INT_MASK 0xFFFF0000

#define SPL_ARRAY_CLONE_MASK 0x0300FFFF

#define SPL_ARRAY_METHOD_NO_ARG 0

#define SPL_ARRAY_METHOD_USE_ARG 1

#define SPL_ARRAY_METHOD_MAY_USER_ARG 2

typedef struct _spl_array_object {

zend_object std;

zval *array;

zval *retval;

HashPosition pos;

ulong pos_h;

int ar_flags;

int is_self;

zend_function *fptr_offset_get;

zend_function *fptr_offset_set;

zend_function *fptr_offset_has;

zend_function *fptr_offset_del;

zend_function *fptr_count;

zend_class_entry* ce_get_iterator;

HashTable *debug_info;

unsigned char nApplyCount;

} spl_array_object;

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);

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) {

rebuild_object_properties(&intern->std);

}

return intern->std.properties;

} else {

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) /* {{{ */

{

Bucket *pos = intern->pos;

if (pos != NULL) {

intern->pos_h = pos->h;

}

} /* }}} */

static void spl_array_set_pos(spl_array_object* intern, HashPosition pos) /* {{{ */

{

intern->pos = pos;

spl_array_update_pos(intern);

} /* }}} */

SPL_API int spl_hash_verify_pos_ex(spl_array_object * intern, HashTable * ht TSRMLS_DC) /* {{{ */

{

Bucket *p;

/* IS_CONSISTENT(ht);*/

/* HASH_PROTECT_RECURSION(ht);*/

p = ht->arBuckets[intern->pos_h & ht->nTableMask];

while (p != NULL) {

if (p == intern->pos) {

return SUCCESS;

}

p = p->pNext;

}

/* HASH_UNPROTECT_RECURSION(ht); */

spl_array_rewind(intern TSRMLS_CC);

return FAILURE;

} /* }}} */

SPL_API int spl_hash_verify_pos(spl_array_object * intern TSRMLS_DC) /* {{{ */

{

HashTable *ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);

return spl_hash_verify_pos_ex(intern, ht TSRMLS_CC);

}

/* }}} */

/* {{{ spl_array_object_free_storage */

static void spl_array_object_free_storage(void *object TSRMLS_DC)

{

spl_array_object *intern = (spl_array_object *)object;

zend_object_std_dtor(&intern->std TSRMLS_CC);

zval_ptr_dtor(&intern->array);

zval_ptr_dtor(&intern->retval);

if (intern->debug_info != NULL) {

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)

{

zend_object_value retval;

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->ar_flags = 0;

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);

intern->ar_flags &= ~ SPL_ARRAY_CLONE_MASK;

intern->ar_flags |= (other->ar_flags & SPL_ARRAY_CLONE_MASK);

intern->ce_get_iterator = other->ce_get_iterator;

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*));

}

if (Z_OBJ_HT_P(orig) == &spl_handler_ArrayIterator) {

Z_ADDREF_P(other->array);

}

} else {

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);

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;

class_type->get_iterator = spl_array_get_iterator;

break;

} else if (parent == spl_ce_ArrayObject) {

retval.handlers = &spl_handler_ArrayObject;

break;

}

parent = parent->parent;

inherited = 1;

}

if (!parent) { /* this must never happen */

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);

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);

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);

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);

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);

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 (!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);

}

if (inherited) {

if (class_type->iterator_funcs.zf_rewind->common.scope != parent) intern->ar_flags |= SPL_ARRAY_OVERLOADED_REWIND;

if (class_type->iterator_funcs.zf_valid->common.scope != parent) intern->ar_flags |= SPL_ARRAY_OVERLOADED_VALID;

if (class_type->iterator_funcs.zf_key->common.scope != parent) intern->ar_flags |= SPL_ARRAY_OVERLOADED_KEY;

if (class_type->iterator_funcs.zf_current->common.scope != parent) intern->ar_flags |= SPL_ARRAY_OVERLOADED_CURRENT;

if (class_type->iterator_funcs.zf_next->common.scope != parent) intern->ar_flags |= SPL_ARRAY_OVERLOADED_NEXT;

}

}

spl_array_rewind(intern TSRMLS_CC);

return retval;

}

/* }}} */

/* {{{ spl_array_object_new */

static zend_object_value 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);

}

/* }}} */

/* {{{ spl_array_object_clone */

static zend_object_value 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;

zend_objects_clone_members(new_object, new_obj_val, old_object, handle TSRMLS_CC);

return new_obj_val;

}

/* }}} */

static zval **spl_array_get_dimension_ptr_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;

long index;

HashTable *ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);

if (!offset) {

return &EG(uninitialized_zval_ptr);

}

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);;

}

switch(Z_TYPE_P(offset)) {

case IS_NULL:

Z_STRVAL_P(offset) = "";

Z_STRLEN_P(offset) = 0;

case IS_STRING:

if (zend_symtable_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, (void **) &retval) == FAILURE) {

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);

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);

}

}

}

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));

case IS_DOUBLE:

case IS_BOOL:

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) {

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);

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);

}

}

}

return retval;

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);

}

} /* }}} */

static zval *spl_array_read_dimension_ex(int check_inherited, zval *object, zval *offset, int type TSRMLS_DC) /* {{{ */

{

zval **ret;

if (check_inherited) {

spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);

if (intern->fptr_offset_get) {

zval *rv;

if (!offset) {

ALLOC_INIT_ZVAL(offset);

} 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) {

zval_ptr_dtor(&intern->retval);

MAKE_STD_ZVAL(intern->retval);

ZVAL_ZVAL(intern->retval, rv, 1, 1);

return intern->retval;

}

return EG(uninitialized_zval_ptr);

}

}

ret = spl_array_get_dimension_ptr_ptr(check_inherited, object, offset, type TSRMLS_CC);

/* 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);

}

return *ret;

} /* }}} */

static zval *spl_array_read_dimension(zval *object, zval *offset, int type TSRMLS_DC) /* {{{ */

{

return spl_array_read_dimension_ex(1, object, offset, type 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);

long index;

HashTable *ht;

if (check_inherited && intern->fptr_offset_set) {

if (!offset) {

ALLOC_INIT_ZVAL(offset);

} 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);

return;

}

if (!offset) {

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;

}

Z_ADDREF_P(value);

zend_hash_next_index_insert(ht, (void**)&value, sizeof(void*), NULL);

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;

}

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");

return;

}

if (offset->type == IS_DOUBLE) {

index = (long)Z_DVAL_P(offset);

} else {

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");

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;

}

} /* }}} */

static void spl_array_write_dimension(zval *object, zval *offset, zval *value TSRMLS_DC) /* {{{ */

{

spl_array_write_dimension_ex(1, object, offset, value TSRMLS_CC);

} /* }}} */

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;

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);

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 (ht == &EG(symbol_table)) {

if (zend_delete_global_variable(Z_STRVAL_P(offset), Z_STRLEN_P(offset) TSRMLS_CC)) {

zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset));

}

} else {

if (zend_symtable_del(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);

}

} 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;

}

}

}

}

break;

case IS_DOUBLE:

case IS_RESOURCE:

case IS_BOOL:

case IS_LONG:

if (offset->type == IS_DOUBLE) {

index = (long)Z_DVAL_P(offset);

} else {

index = Z_LVAL_P(offset);

}

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 (zend_hash_index_del(ht, index) == FAILURE) {

zend_error(E_NOTICE,"Undefined offset: %ld", Z_LVAL_P(offset));

}

break;

default:

zend_error(E_WARNING, "Illegal offset type");

return;

}

spl_hash_verify_pos(intern TSRMLS_CC); /* call rewind on FAILURE */

} /* }}} */

static void spl_array_unset_dimension(zval *object, zval *offset TSRMLS_DC) /* {{{ */

{

spl_array_unset_dimension_ex(1, object, offset TSRMLS_CC);

} /* }}} */

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;

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)) {

zval_ptr_dtor(&rv);

return 1;

}

if (rv) {

zval_ptr_dtor(&rv);

}

return 0;

}

switch(Z_TYPE_P(offset)) {

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) {

switch (check_empty) {

case 0:

return Z_TYPE_PP(tmp) != IS_NULL;

case 2:

return 1;

default:

return zend_is_true(*tmp);

}

}

}

return 0;

case IS_DOUBLE:

case IS_RESOURCE:

case IS_BOOL:

case IS_LONG:

{

HashTable *ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);

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) {

switch (check_empty) {

case 0:

return Z_TYPE_PP(tmp) != IS_NULL;

case 2:

return 1;

default:

return zend_is_true(*tmp);

}

}

return 0;

}

default:

zend_error(E_WARNING, "Illegal offset type");

}

return 0;

} /* }}} */

static int spl_array_has_dimension(zval *object, zval *offset, int check_empty TSRMLS_DC) /* {{{ */

{

return spl_array_has_dimension_ex(1, object, offset, check_empty TSRMLS_CC);

} /* }}} */

/* {{{ spl_array_object_verify_pos_ex */

static inline int spl_array_object_verify_pos_ex(spl_array_object *object, HashTable *ht, const char *msg_prefix TSRMLS_DC)

{

if (!ht) {

php_error_docref(NULL TSRMLS_CC, E_NOTICE, "%sArray was modified outside object and is no longer an array", msg_prefix);

return FAILURE;

}

if (object->pos && (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;

}

return SUCCESS;

} /* }}} */

/* {{{ spl_array_object_verify_pos */

static inline int spl_array_object_verify_pos(spl_array_object *object, HashTable *ht TSRMLS_DC)

{

return spl_array_object_verify_pos_ex(object, ht, "" TSRMLS_CC);

} /* }}} */

/* {{{ proto bool ArrayObject::offsetExists(mixed $index)

proto bool ArrayIterator::offsetExists(mixed $index)

Returns whether the requested $index exists. */

SPL_METHOD(Array, offsetExists)

{

zval *index;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &index) == FAILURE) {

return;

}

RETURN_BOOL(spl_array_has_dimension_ex(0, getThis(), index, 2 TSRMLS_CC));

} /* }}} */

/* {{{ proto mixed ArrayObject::offsetGet(mixed $index)

proto mixed ArrayIterator::offsetGet(mixed $index)

Returns the value at the specified $index. */

SPL_METHOD(Array, offsetGet)

{

zval *index, *value;

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);

} /* }}} */

/* {{{ proto void ArrayObject::offsetSet(mixed $index, mixed $newval)

proto void ArrayIterator::offsetSet(mixed $index, mixed $newval)

Sets the value at the specified $index to $newval. */

SPL_METHOD(Array, offsetSet)

{

zval *index, *value;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &index, &value) == FAILURE) {

return;

}

spl_array_write_dimension_ex(0, getThis(), index, value TSRMLS_CC);

} /* }}} */

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);

HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);

if (!aht) {

php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Array was modified outside object and is no longer an array");

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);

return;

}

spl_array_write_dimension(object, NULL, append_value TSRMLS_CC);

if (!intern->pos) {

spl_array_set_pos(intern, aht->pListTail);

}

} /* }}} */

/* {{{ proto void ArrayObject::append(mixed $newval)

proto void ArrayIterator::append(mixed $newval)

Appends the value (cannot be called for objects). */

SPL_METHOD(Array, append)

{

zval *value;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &value) == FAILURE) {

return;

}

spl_array_iterator_append(getThis(), value TSRMLS_CC);

} /* }}} */

/* {{{ proto void ArrayObject::offsetUnset(mixed $index)

proto void ArrayIterator::offsetUnset(mixed $index)

Unsets the value at the specified $index. */

SPL_METHOD(Array, offsetUnset)

{

zval *index;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &index) == FAILURE) {

return;

}

spl_array_unset_dimension_ex(0, getThis(), index TSRMLS_CC);

} /* }}} */

/* {{{ proto array ArrayObject::getArrayCopy()

proto array ArrayIterator::getArrayCopy()

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);

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*));

} /* }}} */

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);

HashTable *result;

if (intern->nApplyCount > 1) {

php_error_docref(NULL TSRMLS_CC, E_ERROR, "Nesting level too deep - recursive dependency?");

}

intern->nApplyCount++;

result = spl_array_get_hash_table(intern, 1 TSRMLS_CC);

intern->nApplyCount--;

return result;

} /* }}} */

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;

zend_class_entry *base;

*is_temp = 0;

if (!intern->std.properties) {

rebuild_object_properties(&intern->std);

}

if (HASH_OF(intern->array) == intern->std.properties) {

return intern->std.properties;

} else {

if (intern->debug_info == NULL) {

ALLOC_HASHTABLE(intern->debug_info);

ZEND_INIT_SYMTABLE_EX(intern->debug_info, zend_hash_num_elements(intern->std.properties) + 1, 0);

}

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 *));

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);

}

return intern->debug_info;

}

}

/* }}} */

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);

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);

}

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);

if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0

&& !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {

spl_array_write_dimension(object, member, value TSRMLS_CC);

return;

}

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) /* {{{ */

{

spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);

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);

}

return std_object_handlers.get_property_ptr_ptr(object, member, type, key TSRMLS_CC);

} /* }}} */

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);

if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0

&& !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);

if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0

&& !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;

}

std_object_handlers.unset_property(object, member, key TSRMLS_CC);

} /* }}} */

static int spl_array_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */

{

HashTable *ht1,

*ht2;

spl_array_object *intern1,

*intern2;

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);

ht1 = spl_array_get_hash_table(intern1, 0 TSRMLS_CC);

ht2 = spl_array_get_hash_table(intern2, 0 TSRMLS_CC);

zend_compare_symbol_tables(&temp_zv, ht1, ht2 TSRMLS_CC);

result = (int)Z_LVAL(temp_zv);

/* if we just compared std.properties, don't do it again */

if (result == 0 &&

!(ht1 == intern1->std.properties && ht2 == intern2->std.properties)) {

result = std_object_handlers.compare_objects(o1, o2 TSRMLS_CC);

}

return result;

} /* }}} */

static int spl_array_skip_protected(spl_array_object *intern, HashTable *aht TSRMLS_DC) /* {{{ */

{

char *string_key;

uint string_length;

ulong num_key;

if (Z_TYPE_P(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]) {

return SUCCESS;

}

} else {

return SUCCESS;

}

if (zend_hash_has_more_elements_ex(aht, &intern->pos) != SUCCESS) {

return FAILURE;

}

zend_hash_move_forward_ex(aht, &intern->pos);

spl_array_update_pos(intern);

} while (1);

}

return FAILURE;

} /* }}} */

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) {

return spl_array_skip_protected(intern, aht TSRMLS_CC);

} else {

return zend_hash_has_more_elements_ex(aht, &intern->pos);

}

} /* }}} */

static int spl_array_next_ex(spl_array_object *intern, HashTable *aht TSRMLS_DC) /* {{{ */

{

if ((intern->ar_flags & SPL_ARRAY_IS_REF) && spl_hash_verify_pos_ex(intern, aht TSRMLS_CC) == FAILURE) {

php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Array was modified outside object and internal position is no longer valid");

return FAILURE;

}

return spl_array_next_no_verify(intern, aht TSRMLS_CC);

} /* }}} */

static int spl_array_next(spl_array_object *intern TSRMLS_DC) /* {{{ */

{

HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);

return spl_array_next_ex(intern, aht TSRMLS_CC);

} /* }}} */

/* 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);

}

/* }}} */

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);

if (object->ar_flags & SPL_ARRAY_OVERLOADED_VALID) {

return zend_user_it_valid(iter TSRMLS_CC);

} else {

if (spl_array_object_verify_pos_ex(object, aht, "ArrayIterator::valid(): " TSRMLS_CC) == FAILURE) {

return FAILURE;

}

return zend_hash_has_more_elements_ex(aht, &object->pos);