自学教程：C++ zend_hash_index_update函数代码示例

static HashTable* spl_fixedarray_object_get_properties(zval *obj) /* {{{{ */{	spl_fixedarray_object *intern  = Z_SPLFIXEDARRAY_P(obj);	HashTable *ht = zend_std_get_properties(obj);	zend_long  i = 0;	if (intern->array) {		zend_long j = zend_hash_num_elements(ht);		for (i = 0; i < intern->array->size; i++) {			if (!Z_ISUNDEF(intern->array->elements[i])) {				zend_hash_index_update(ht, i, &intern->array->elements[i]);				if (Z_REFCOUNTED(intern->array->elements[i])){					Z_ADDREF(intern->array->elements[i]);				}			} else {				zend_hash_index_update(ht, i, &EG(uninitialized_zval));			}		}		if (j > intern->array->size) {			for (i = intern->array->size; i < j; ++i) {				zend_hash_index_del(ht, i);			}		}	}	return ht;}

/** * @brief Updates value in @a arr at position @a index with @a value * @param[in,out] arr Array * @param index Index * @param[in,out] value Value * @param flags Flags * @return Whether the operation succeeded * @retval @c FAILURE Failure, @a arr is not an array or @a index is of not supported type * @retval @c SUCCESS Success * @note @c index will be handled as follows: @c NULL is treated as an empty string, @c double values are cast to @c integer, @c bool or @c resource are treated as @c integer * @throw @c E_WARNING if @a offset is not a scalar or @c arr is not an array * * Equivalent to <tt>$arr[$index] = $value</tt> in PHP. * Flags may be a bitwise OR of the following values: * @arg @c PH_CTOR: create a copy of @a value and work with that copy; @c *value will be updated with the newly constructed value * @arg @c PH_SEPARATE: separate @a arr if its reference count is greater than 1; @c *arr will contain the separated version * @arg @c PH_COPY: increment the reference count on @c **value */int zephir_array_update_zval(zval **arr, zval *index, zval **value, int flags) {    HashTable *ht;    if (Z_TYPE_PP(arr) != IS_ARRAY) {        zend_error(E_WARNING, "Cannot use a scalar value as an array (2)");        return FAILURE;    }    if ((flags & PH_CTOR) == PH_CTOR) {        zval *new_zv;        Z_DELREF_PP(value);        ALLOC_ZVAL(new_zv);        INIT_PZVAL_COPY(new_zv, *value);        *value = new_zv;        zval_copy_ctor(new_zv);    }    if ((flags & PH_SEPARATE) == PH_SEPARATE) {        SEPARATE_ZVAL_IF_NOT_REF(arr);    }    if ((flags & PH_COPY) == PH_COPY) {        Z_ADDREF_PP(value);    }    ht = Z_ARRVAL_PP(arr);    switch (Z_TYPE_P(index)) {    case IS_NULL:        return zend_symtable_update(ht, "", 1, value, sizeof(zval*), NULL);    case IS_DOUBLE:        return zend_hash_index_update(ht, (ulong)Z_DVAL_P(index), value, sizeof(zval*), NULL);    case IS_LONG:    case IS_BOOL:    case IS_RESOURCE:        return zend_hash_index_update(ht, Z_LVAL_P(index), value, sizeof(zval*), NULL);    case IS_STRING:        return zend_symtable_update(ht, Z_STRVAL_P(index), Z_STRLEN_P(index)+1, value, sizeof(zval*), NULL);    default:        zend_error(E_WARNING, "Illegal offset type");        return FAILURE;    }}

static inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, long elements, int objprops){	while (elements-- > 0) {		zval *key, *data, **old_data;		ALLOC_INIT_ZVAL(key);		if (!php_var_unserialize2(&key, p, max, NULL TSRMLS_CC)) {			zval_dtor(key);			FREE_ZVAL(key);			return 0;		}		if (Z_TYPE_P(key) != IS_LONG && Z_TYPE_P(key) != IS_STRING) {			zval_dtor(key);			FREE_ZVAL(key);			return 0;		}		ALLOC_INIT_ZVAL(data);		if (!php_var_unserialize2(&data, p, max, var_hash TSRMLS_CC)) {			zval_dtor(key);			FREE_ZVAL(key);			zval_dtor(data);			FREE_ZVAL(data);			return 0;		}		switch (Z_TYPE_P(key)) {		case IS_LONG:            if (objprops) {                /* show a warning for not compatible */                php_error_docref(NULL TSRMLS_CC, E_WARNING, "got integer prop. %d", Z_LVAL_P(key));            }			if (zend_hash_index_find(ht, Z_LVAL_P(key), (void **)&old_data)==SUCCESS) {				var_push_dtor(var_hash, old_data);			}			zend_hash_index_update(ht, Z_LVAL_P(key), &data, sizeof(data), NULL);			break;		case IS_STRING:			if (zend_symtable_find(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, (void **)&old_data)==SUCCESS) {				var_push_dtor(var_hash, old_data);			}			zend_symtable_update(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &data, sizeof(data), NULL);			break;		}						zval_dtor(key);		FREE_ZVAL(key);		if (elements && *(*p-1) != ';' && *(*p-1) != '}') {			(*p)--;			return 0;		}	}	return 1;}

static inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, long elements, int objprops){	while (elements-- > 0) {		zval *key, *data, **old_data;		ALLOC_INIT_ZVAL(key);		if (!php_var_unserialize(&key, p, max, NULL TSRMLS_CC)) {            var_push_dtor_no_addref(var_hash, &key);			return 0;		}		if (Z_TYPE_P(key) != IS_LONG && Z_TYPE_P(key) != IS_STRING) {            var_push_dtor_no_addref(var_hash, &key);			return 0;		}		ALLOC_INIT_ZVAL(data);		if (!php_var_unserialize(&data, p, max, var_hash TSRMLS_CC)) {            var_push_dtor_no_addref(var_hash, &key);            var_push_dtor_no_addref(var_hash, &data);			return 0;		}		if (!objprops) {			switch (Z_TYPE_P(key)) {			case IS_LONG:				if (zend_hash_index_find(ht, Z_LVAL_P(key), (void **)&old_data)==SUCCESS) {					var_push_dtor(var_hash, old_data);				}				zend_hash_index_update(ht, Z_LVAL_P(key), &data, sizeof(data), NULL);				break;			case IS_STRING:				if (zend_symtable_find(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, (void **)&old_data)==SUCCESS) {					var_push_dtor(var_hash, old_data);				}				zend_symtable_update(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &data, sizeof(data), NULL);				break;			}		} else {			/* object properties should include no integers */			convert_to_string(key);			if (zend_hash_find(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, (void **)&old_data)==SUCCESS) {				var_push_dtor(var_hash, old_data);			}			zend_hash_update(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &data,					sizeof data, NULL);		}		var_push_dtor(var_hash, &data);        var_push_dtor_no_addref(var_hash, &key);		if (elements && *(*p-1) != ';' && *(*p-1) != '}') {			(*p)--;			return 0;		}	}	return 1;}

/** * Updates values on arrays by long indexes only */int phalcon_array_update_long(zval **arr, ulong index, zval **value, int flags TSRMLS_DC){	if (Z_TYPE_PP(arr) != IS_ARRAY) {		php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Cannot use a scalar value as an array");		return FAILURE;	}	if ((flags & PH_CTOR) == PH_CTOR) {		zval *new_zv;		Z_DELREF_PP(value);		ALLOC_ZVAL(new_zv);		INIT_PZVAL_COPY(new_zv, *value);		*value = new_zv;		zval_copy_ctor(new_zv);	}	if ((flags & PH_SEPARATE) == PH_SEPARATE) {		if (Z_REFCOUNT_PP(arr) > 1) {			zval *new_zv;			Z_DELREF_PP(arr);			ALLOC_ZVAL(new_zv);			INIT_PZVAL_COPY(new_zv, *arr);			*arr = new_zv;			zval_copy_ctor(new_zv);	    }	}	if ((flags & PH_COPY) == PH_COPY) {		Z_ADDREF_PP(value);	}	return zend_hash_index_update(Z_ARRVAL_PP(arr), index, value, sizeof(zval *), NULL);}

/* }}} */static void xc_coverager_clean(TSRMLS_D) /* {{{ */{	if (XG(coverages)) {		HashPosition pos;		coverager_t *pcov;		zend_hash_internal_pointer_reset_ex(XG(coverages), &pos);		while (zend_hash_get_current_data_ex(XG(coverages), (void **) &pcov, &pos) == SUCCESS) {			long *phits;			coverager_t cov;			HashPosition pos2;			cov = *pcov;			zend_hash_internal_pointer_reset_ex(cov, &pos2);			while (zend_hash_get_current_data_ex(cov, (void**)&phits, &pos2) == SUCCESS) {				long hits = *phits;				if (hits != -1) {					hits = -1;					zend_hash_index_update(cov, pos2->h, &hits, sizeof(hits), NULL);				}				zend_hash_move_forward_ex(cov, &pos2);			}			zend_hash_move_forward_ex(XG(coverages), &pos);		}	}}

/* {{{ php_autoglobal_merge */static void php_autoglobal_merge(HashTable *dest, HashTable *src){	zval *src_entry, *dest_entry;	zend_string *string_key;	zend_ulong num_key;	int globals_check = (dest == (&EG(symbol_table)));	ZEND_HASH_FOREACH_KEY_VAL(src, num_key, string_key, src_entry) {		if (Z_TYPE_P(src_entry) != IS_ARRAY			|| (string_key && (dest_entry = zend_hash_find(dest, string_key)) == NULL)			|| (string_key == NULL && (dest_entry = zend_hash_index_find(dest, num_key)) == NULL)			|| Z_TYPE_P(dest_entry) != IS_ARRAY) {			if (Z_REFCOUNTED_P(src_entry)) {				Z_ADDREF_P(src_entry);			}			if (string_key) {				if (!globals_check || string_key->len != sizeof("GLOBALS") - 1						|| memcmp(string_key->val, "GLOBALS", sizeof("GLOBALS") - 1)) {					zend_hash_update(dest, string_key, src_entry);				} else if (Z_REFCOUNTED_P(src_entry)) {					Z_DELREF_P(src_entry);				}			} else {				zend_hash_index_update(dest, num_key, src_entry);			}		} else {			SEPARATE_ZVAL(dest_entry);			php_autoglobal_merge(Z_ARRVAL_P(dest_entry), Z_ARRVAL_P(src_entry));		}	} ZEND_HASH_FOREACH_END();}

void _php_import_environment_variables(zval *array_ptr){	char **env, *p;	size_t name_len, len;	zval val;	zend_ulong idx;	for (env = environ; env != NULL && *env != NULL; env++) {		p = strchr(*env, '=');		if (!p		 || p == *env		 || !valid_environment_name(*env, p)) {			/* malformed entry? */			continue;		}		name_len = p - *env;		p++;		len = strlen(p);		if (len == 0) {			ZVAL_EMPTY_STRING(&val);		} else if (len == 1) {			ZVAL_INTERNED_STR(&val, ZSTR_CHAR((zend_uchar)*p));		} else {			ZVAL_NEW_STR(&val, zend_string_init(p, len, 0));		}		if (ZEND_HANDLE_NUMERIC_STR(*env, name_len, idx)) {			zend_hash_index_update(Z_ARRVAL_P(array_ptr), idx, &val);		} else {			php_register_variable_quick(*env, name_len, &val, Z_ARRVAL_P(array_ptr));		}	}}

/* * save a corba object to a php object */void orbit_save_data(zval * php_object, int type, void * data){    pval * orbit_data_handle = NULL;    long id = zend_list_insert(                  data, 										/* data */                  type								/* type */              );    /*     * do it like they do in php_COM_call_function_handler     * (insert into some magic hash index)     */    ALLOC_ZVAL(orbit_data_handle);	/* allocate memory for value */    orbit_data_handle->type = IS_LONG;    orbit_data_handle->value.lval = id;    pval_copy_constructor(orbit_data_handle);	/* why? */    INIT_PZVAL(orbit_data_handle);	/* set reference count */    zend_hash_index_update(        php_object->value.obj.properties, /* hashtable */        0, 																/* hash??? */        &orbit_data_handle,								/* data */        sizeof(pval *),										/* data size */        NULL															/* destination */    );}

/** * @brief Updates value in @a arr at position @a index with @a value * @param[in,out] arr Array * @param index Index * @param[in,out] value Value * @param flags Flags * @return Whether the operation succeeded * @retval @c FAILURE Failure, @a arr is not an array * @retval @c SUCCESS Success * @throw @c E_WARNING if @c arr is not an array * * Equivalent to <tt>$arr[$index] = $value</tt> in PHP where @c $index is an integer. * Flags may be a bitwise OR of the following values: * @arg @c PH_CTOR: create a copy of @a value and work with that copy; @c *value will be updated with the newly constructed value * @arg @c PH_SEPARATE: separate @a arr if its reference count is greater than 1; @c *arr will contain the separated version * @arg @c PH_COPY: increment the reference count on @c **value */int zephir_array_update_long(zval **arr, unsigned long index, zval **value, int flags ZEPHIR_DEBUG_PARAMS) {    if (Z_TYPE_PP(arr) != IS_ARRAY) {        zend_error(E_WARNING, "Cannot use a scalar value as an array in %s on line %d", file, line);        return FAILURE;    }    if ((flags & PH_CTOR) == PH_CTOR) {        zval *new_zv;        Z_DELREF_PP(value);        ALLOC_ZVAL(new_zv);        INIT_PZVAL_COPY(new_zv, *value);        *value = new_zv;        zval_copy_ctor(new_zv);    }    if ((flags & PH_SEPARATE) == PH_SEPARATE) {        SEPARATE_ZVAL_IF_NOT_REF(arr);    }    if ((flags & PH_COPY) == PH_COPY) {        Z_ADDREF_PP(value);    }    return zend_hash_index_update(Z_ARRVAL_PP(arr), index, value, sizeof(zval *), NULL);}

static int full_user_list(struct user_info *uentp, struct fulluserlistarg* arg,int count){    struct user_info userinfo=*uentp;    struct userec *lookupuser;    zval* element;    if (!userinfo.active || !userinfo.pid) {        return 0;    }    if (!HAS_PERM(getCurrentUser(), PERM_SEECLOAK) && userinfo.invisible && strcmp(userinfo.userid, getCurrentUser()->userid)) {        /*Haohmaru.99.4.24.让隐身者能看见自己 */        return 0;    }    if (count+1<arg->start)        return COUNT;    if (count+1-arg->start>=arg->num)        return QUIT;    MAKE_STD_ZVAL ( element );    array_init ( element );    add_assoc_bool ( element, "invisible", userinfo.invisible );    add_assoc_long ( element, "pid", userinfo.pid );    add_assoc_bool ( element, "isfriend", isfriend(userinfo.userid) );    add_assoc_string ( element, "userid", userinfo.userid, 1 );    add_assoc_string ( element, "username", userinfo.username, 1 );    if( getuser(userinfo.userid, &lookupuser) == 0 ) lookupuser=NULL;    add_assoc_string ( element, "userfrom", HAS_PERM(getCurrentUser(), PERM_SYSOP)? userinfo.from: SHOW_USERIP(lookupuser, userinfo.from), 1 );    add_assoc_string ( element, "mode", ModeType(userinfo.mode), 1 );    add_assoc_long ( element, "idle", (long)(time(0) - userinfo.freshtime)/60 );        zend_hash_index_update(Z_ARRVAL_P(arg->return_value), count+1-arg->start, (void *) &element, sizeof(zval *), NULL);    return COUNT;}

/* {{{ php_oci_lob_create() Create LOB descriptor and allocate all the resources needed */php_oci_descriptor *php_oci_lob_create (php_oci_connection *connection, long type TSRMLS_DC){	php_oci_descriptor *descriptor;	switch (type) {		case OCI_DTYPE_FILE:		case OCI_DTYPE_LOB:		case OCI_DTYPE_ROWID:			/* these three are allowed */			break;		default:			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown descriptor type %ld", type);			return NULL;			break;	}	descriptor = ecalloc(1, sizeof(php_oci_descriptor));	descriptor->type = type;	descriptor->connection = connection;	zend_list_addref(descriptor->connection->rsrc_id);	PHP_OCI_CALL_RETURN(OCI_G(errcode), OCIDescriptorAlloc, (connection->env, (dvoid*)&(descriptor->descriptor), descriptor->type, (size_t) 0, (dvoid **) 0));	if (OCI_G(errcode) != OCI_SUCCESS) {		OCI_G(errcode) = php_oci_error(OCI_G(err), OCI_G(errcode) TSRMLS_CC);		PHP_OCI_HANDLE_ERROR(connection, OCI_G(errcode));		efree(descriptor);		return NULL;	}	PHP_OCI_REGISTER_RESOURCE(descriptor, le_descriptor);		descriptor->lob_current_position = 0;	descriptor->lob_size = -1;				/* we should set it to -1 to know, that it's just not initialized */	descriptor->buffering = PHP_OCI_LOB_BUFFER_DISABLED;				/* buffering is off by default */	descriptor->charset_form = SQLCS_IMPLICIT;	/* default value */	descriptor->charset_id = connection->charset;	descriptor->is_open = 0;	if (descriptor->type == OCI_DTYPE_LOB || descriptor->type == OCI_DTYPE_FILE) {		/* add Lobs & Files to hash. we'll flush them at the end */		if (!connection->descriptors) {			ALLOC_HASHTABLE(connection->descriptors);			zend_hash_init(connection->descriptors, 0, NULL, php_oci_descriptor_flush_hash_dtor, 0);			connection->descriptor_count = 0;		}				descriptor->index = (connection->descriptor_count)++;		if (connection->descriptor_count == LONG_MAX) {			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Internal descriptor counter has reached limit");			php_oci_connection_descriptors_free(connection TSRMLS_CC);			return NULL;		}		zend_hash_index_update(connection->descriptors,descriptor->index,&descriptor,sizeof(php_oci_descriptor *),NULL);	}	return descriptor;} /* }}} */

BUESSION_API int buession_hash_index_add_null(HashTable *ht, ulong index TSRMLS_DC){	zval *value;	MAKE_STD_ZVAL(value);	ZVAL_NULL(value);	return zend_hash_index_update(ht, index, (void *) &value, sizeof(zval *), NULL);}

static int hash_to_zval(VALUE key, VALUE value, VALUE zval_array) {    zval *v;    zval *ary;    if (key == Qundef) {        return ST_CONTINUE;    }    ary = (zval *)zval_array;    v = value_to_zval(value);    if (key == Qtrue) {        zend_hash_index_update(Z_ARRVAL_P(ary), 1, &v, sizeof(zval *), NULL);        return ST_CONTINUE;    }    if (key == Qfalse || key == Qnil) {        zend_hash_index_update(Z_ARRVAL_P(ary), 0, &v, sizeof(zval *), NULL);        return ST_CONTINUE;    }    if (TYPE(key) == T_FIXNUM) {        int idx = FIX2INT(key);        zend_hash_index_update(Z_ARRVAL_P(ary), idx, &v, sizeof(zval *), NULL);        return ST_CONTINUE;    }    switch (TYPE(key)) {        case T_BIGNUM:            key = rb_big2str(key, 10);            break;        case T_SYMBOL:            key = rb_sym_to_s(key);            break;        case T_STRING:            key = rb_string_value(&key);            break;        default:            rb_raise(rb_eRuntimeError, "invalid key (%d)", TYPE(key));    }    //ZEND_HANDLE_NUMERIC(RSTRING_PTR(key), RSTRING_LEN(key), zend_hash_index_update(Z_ARRVAL_P(ary), idx, &v, sizeof(zval *), NULL));    zend_symtable_update(Z_ARRVAL_P(ary), RSTRING_PTR(key), RSTRING_LEN(key) + 1, &v, sizeof(zval *), NULL);    return ST_CONTINUE;}

int dbx_odbc_getrow(zval ** rv, zval ** result_handle, long row_number, INTERNAL_FUNCTION_PARAMETERS) {    /*/ returns array[0..columncount-1] as strings on success or 0 as long on failure /*/    int number_of_arguments;    zval ** arguments[2];    zval * num_fields_zval=NULL;    zval * fetch_row_result_zval=NULL;    zval * field_result_zval=NULL;    zval * field_index_zval;    zval * returned_zval=NULL;    long field_index;    long field_count=-1;    /*/ get # fields /*/    MAKE_STD_ZVAL(num_fields_zval);    ZVAL_LONG(num_fields_zval, 0);    if (!dbx_odbc_getcolumncount(&num_fields_zval, result_handle, INTERNAL_FUNCTION_PARAM_PASSTHRU)) {        return 0;        }    field_count=num_fields_zval->value.lval;    FREE_ZVAL(num_fields_zval);    /*/ fetch row /*/    number_of_arguments=1;    arguments[0]=result_handle;    dbx_call_any_function(INTERNAL_FUNCTION_PARAM_PASSTHRU, "odbc_fetch_row", &fetch_row_result_zval, number_of_arguments, arguments);    if (!fetch_row_result_zval || fetch_row_result_zval->type!=IS_BOOL) {        if (fetch_row_result_zval) zval_ptr_dtor(&fetch_row_result_zval);        return 0;        }    if (fetch_row_result_zval->value.lval==0) {        (*rv)->type=IS_LONG;        (*rv)->value.lval=0; /*/ ok, no more rows /*/        zval_ptr_dtor(&fetch_row_result_zval);        return 0;        }    zval_ptr_dtor(&fetch_row_result_zval);    /*/ fill array with field results... /*/    MAKE_STD_ZVAL(returned_zval);    if (array_init(returned_zval) != SUCCESS) {        zend_error(E_ERROR, "dbx_odbc_getrow: unable to create result-array...");        FREE_ZVAL(returned_zval);        return 0;        }    MAKE_STD_ZVAL(field_index_zval);    ZVAL_LONG(field_index_zval, 0);    number_of_arguments=2;    for (field_index=0; field_index<field_count; ++field_index) {        ZVAL_LONG(field_index_zval, field_index+1);        arguments[0]=result_handle;        arguments[1]=&field_index_zval;        dbx_call_any_function(INTERNAL_FUNCTION_PARAM_PASSTHRU, "odbc_result", &field_result_zval, number_of_arguments, arguments);        zend_hash_index_update(returned_zval->value.ht, field_index, (void *)&(field_result_zval), sizeof(zval *), NULL);        }    FREE_ZVAL(field_index_zval);    MOVE_RETURNED_TO_RV(rv, returned_zval);    return 1;    }

/** * Updates an array property */int zephir_update_property_array(zval *object, const char *property, zend_uint property_length, const zval *index, zval *value){	zval tmp;	int separated = 0;	if (Z_TYPE_P(object) == IS_OBJECT) {		zephir_read_property(&tmp, object, property, property_length, PH_NOISY | PH_READONLY);		/** Separation only when refcount > 1 */		if (Z_REFCOUNTED(tmp)) {			if (Z_REFCOUNT(tmp) > 1) {				if (!Z_ISREF(tmp)) {					zval new_zv;					ZVAL_DUP(&new_zv, &tmp);					ZVAL_COPY_VALUE(&tmp, &new_zv);					Z_TRY_DELREF(new_zv);					separated = 1;				}			}		} else {			zval new_zv;			ZVAL_DUP(&new_zv, &tmp);			ZVAL_COPY_VALUE(&tmp, &new_zv);			Z_TRY_DELREF(new_zv);			separated = 1;		}		/** Convert the value to array if not is an array */		if (Z_TYPE(tmp) != IS_ARRAY) {			if (separated) {				convert_to_array(&tmp);			} else {				array_init(&tmp);				separated = 1;			}			Z_DELREF(tmp);		}		Z_TRY_ADDREF_P(value);		if (Z_TYPE_P(index) == IS_STRING) {			zend_symtable_str_update(Z_ARRVAL(tmp), Z_STRVAL_P(index), Z_STRLEN_P(index), value);		} else if (Z_TYPE_P(index) == IS_LONG) {			zend_hash_index_update(Z_ARRVAL(tmp), Z_LVAL_P(index), value);		} else if (Z_TYPE_P(index) == IS_NULL) {			zend_hash_next_index_insert(Z_ARRVAL(tmp), value);		}		if (separated) {			zephir_update_property_zval(object, property, property_length, &tmp);		}	}	return SUCCESS;}

/** * Updates values on arrays by string or long indexes */int phalcon_array_update_zval(zval **arr, zval *index, zval **value, int flags TSRMLS_DC){	if (Z_TYPE_PP(arr) != IS_ARRAY) {		php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Cannot use a scalar value as an array");		return FAILURE;	}	if (Z_TYPE_P(index) == IS_NULL) {		convert_to_string(index);	} else {		if (Z_TYPE_P(index) == IS_BOOL || Z_TYPE_P(index) == IS_DOUBLE) {			convert_to_long(index);		}	}	if ((flags & PH_CTOR) == PH_CTOR) {		zval *new_zv;		Z_DELREF_PP(value);		ALLOC_ZVAL(new_zv);		INIT_PZVAL_COPY(new_zv, *value);		*value = new_zv;		zval_copy_ctor(new_zv);	}	if ((flags & PH_SEPARATE) == PH_SEPARATE) {		if (Z_REFCOUNT_PP(arr) > 1) {			zval *new_zv;			Z_DELREF_PP(arr);			ALLOC_ZVAL(new_zv);			INIT_PZVAL_COPY(new_zv, *arr);			*arr = new_zv;			zval_copy_ctor(new_zv);	    }	}	if ((flags & PH_COPY) == PH_COPY) {		Z_ADDREF_PP(value);	} 	if(Z_TYPE_P(index) == IS_STRING){		return zend_hash_update(Z_ARRVAL_PP(arr), Z_STRVAL_P(index), Z_STRLEN_P(index)+1, value, sizeof(zval *), NULL);	} else {		if (Z_TYPE_P(index) == IS_LONG) {			return zend_hash_index_update(Z_ARRVAL_PP(arr), Z_LVAL_P(index), value, sizeof(zval *), NULL);		} else {			php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Illegal offset type");		}	}	return FAILURE;}

ZEND_API int zend_list_insert(void *ptr, int type TSRMLS_DC){	int index;	zend_rsrc_list_entry le;	le.ptr=ptr;	le.type=type;	le.refcount=1;	index = zend_hash_next_free_element(&EG(regular_list));	zend_hash_index_update(&EG(regular_list), index, (void *) &le, sizeof(zend_rsrc_list_entry), NULL);	return index;}

PHP_METHOD(SolrCollapseFunction, __construct){    long int index = SOLR_UNIQUE_FUNCTION_INDEX();    uint nSize = SOLR_INITIAL_HASH_TABLE_SIZE;    solr_function_t *solr_function_dest = NULL;    solr_function_t solr_function;    zval *index_prop, *zvfield = NULL;    solr_char_t *param_name = (solr_char_t *)"field";    int param_name_len = sizeof("field");    solr_string_t field_str;    solr_char_t *field_name = NULL;    int field_name_len = 0;    memset(&solr_function, 0, sizeof(solr_function_t));    if (zend_hash_index_update(SOLR_GLOBAL(functions),index,(void *) &solr_function, sizeof(solr_function_t), (void **) &solr_function_dest) == FAILURE)    {        php_error_docref(NULL TSRMLS_CC, E_ERROR, "Error while registering query parameters in HashTable");        return ;    }    index_prop = zend_read_property(Z_OBJCE_P(getThis()), getThis(), SOLR_INDEX_PROPERTY_NAME, sizeof(SOLR_INDEX_PROPERTY_NAME) - 1, 1 TSRMLS_CC);    Z_LVAL_P(index_prop) = index;    solr_function_dest->function_index = index;    solr_function_dest->name = (solr_char_t *)"collapse";    solr_function_dest->name_length = sizeof(solr_function_dest->name);    /* Allocated memory for the params HashTable using fast cache for HashTables */    ALLOC_HASHTABLE(solr_function_dest->params);    zend_hash_init(solr_function_dest->params, nSize, NULL, (dtor_func_t) solr_string_free_ex, SOLR_FUNCTIONS_PERSISTENT);    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &field_name, &field_name_len) == FAILURE)    {        php_error_docref(NULL TSRMLS_CC, E_ERROR, "Error Parsing Parameters");        return;    }    if (field_name_len > 0 ) {        memset(&field_str, 0, sizeof(solr_string_t));        solr_string_set(&field_str, (solr_char_t *)field_name, field_name_len);        if(zend_hash_update(solr_function_dest->params, param_name, param_name_len, (void **)&field_str, sizeof(solr_string_t), NULL) == FAILURE)        {            php_error_docref(NULL TSRMLS_CC, E_ERROR, "Error assigning field");        }    }}

void php_functional_append_array_value(int hash_key_type, zval **return_value, zval **value, char *string_key, uint string_key_len, int int_key){	zval_add_ref(return_value);	zval_add_ref(value);	switch (hash_key_type) {		case HASH_KEY_IS_LONG:			zend_hash_index_update(Z_ARRVAL_PP(return_value), int_key, (void *)value, sizeof(zval *), NULL);			break;		case HASH_KEY_IS_STRING:			zend_hash_update(Z_ARRVAL_PP(return_value), string_key, string_key_len, (void *)value, sizeof(zval *), NULL);			break;	}}

static void add_zval(zval* list, const char* id, zval* val){	if (list && val) {		if (id) {			int id_len = strlen(id);			if (!(id_len > 1 && id[0] == '0') && is_numeric_string((char *)id, id_len, NULL, NULL, 0) == IS_LONG) {				long index = strtol(id, NULL, 0);				zend_hash_index_update(Z_ARRVAL_P(list), index, val);			} else {				zend_hash_str_update(Z_ARRVAL_P(list), (char*)id, strlen(id), val);			}		} else {			zend_hash_next_index_insert(Z_ARRVAL_P(list), val);		}	}}

/* {{{ proto void SolrInputDocument::__construct()	SolrInputDocument constructor */PHP_METHOD(SolrInputDocument, __construct){	zval *objptr = getThis();	uint nSize = SOLR_INITIAL_HASH_TABLE_SIZE;	ulong document_index = SOLR_UNIQUE_DOCUMENT_INDEX();	auto solr_document_t solr_doc;	solr_document_t *doc_entry = NULL, *doc_ptr = NULL;	memset(&solr_doc, 0, sizeof(solr_document_t));	doc_entry = &solr_doc;	doc_entry->document_index  = document_index;	doc_entry->field_count     = 0L;	doc_entry->document_boost  = 0.0f;	/* Allocated memory for the fields HashTable using fast cache for HashTables */	ALLOC_HASHTABLE(doc_entry->fields);	ALLOC_HASHTABLE(doc_entry->children);	/* Initializing the hash table used for storing fields in this SolrDocument */	zend_hash_init(doc_entry->fields, nSize, NULL, (dtor_func_t) solr_destroy_field_list, SOLR_DOCUMENT_FIELD_PERSISTENT);	zend_hash_init(doc_entry->children, nSize, NULL, ZVAL_PTR_DTOR, SOLR_DOCUMENT_FIELD_PERSISTENT);	/* Let's check one more time before insert into the HashTable */	if (zend_hash_index_exists(SOLR_GLOBAL(documents), document_index)) {		pefree(doc_entry->fields, SOLR_DOCUMENT_FIELD_PERSISTENT);		pefree(doc_entry->children, SOLR_DOCUMENT_FIELD_PERSISTENT);		return;	}	/* Add the document entry to the directory of documents */	zend_hash_index_update(SOLR_GLOBAL(documents), document_index, (void *) doc_entry, sizeof(solr_document_t), (void **) &doc_ptr);	/* Set the value of the internal id property */	zend_update_property_long(solr_ce_SolrInputDocument, objptr, SOLR_INDEX_PROPERTY_NAME, sizeof(SOLR_INDEX_PROPERTY_NAME) - 1, document_index TSRMLS_CC);	/* Keep track of how many SolrDocument instances we currently have */	SOLR_GLOBAL(document_count)++;	/* Overriding the default object handlers */	Z_OBJ_HT_P(objptr) = &solr_input_document_object_handlers;}

void php_functional_prepare_array_key(int hash_key_type, zval **key, zval ***value, char *string_key, uint string_key_len, int int_key, zval **return_value, int collect){	switch (hash_key_type) {		case HASH_KEY_IS_LONG:			Z_TYPE_PP(key) = IS_LONG;			Z_LVAL_PP(key) = int_key;			if (collect) {				zend_hash_index_update(Z_ARRVAL_PP(return_value), int_key, *value, sizeof(zval *), NULL);			}			break;		case HASH_KEY_IS_STRING:			ZVAL_STRINGL(*key, string_key, string_key_len - 1, 1);			if (collect) {				zend_hash_update(Z_ARRVAL_PP(return_value), string_key, string_key_len, *value, sizeof(zval *), NULL);			}			break;	}}

PHP_METHOD(Type, of) {	long ztype = 0;	zval *zcache = NULL;	php_jit_type_t *ptype;		if (php_jit_parameters("l", &ztype) != SUCCESS || !ztype) {		php_jit_exception("unexpected parameters, expected (int type)");		return;	}		if (!(zcache = zend_hash_index_find(&JG(types), ztype))) {	 	object_init_ex(return_value, jit_type_ce);	 	ptype = PHP_JIT_FETCH_TYPE(return_value);	 	ptype->id = ztype;	 	ptype->type = php_jit_type(ztype);	 	zend_hash_index_update(	 		&JG(types), ztype, return_value);	 	Z_ADDREF_P(return_value);	 } else ZVAL_COPY(return_value, zcache);}

/* {{{ pip_pyobject_to_zobject(PyObject *obj)   Convert Python object to a PHP (Zend) object */zval *pip_pyobject_to_zobject(PyObject *obj){	pval *ret;	zval *handle;	TSRMLS_FETCH();	/* Create a PHP Python object */	MAKE_STD_ZVAL(ret);	object_init_ex(ret, &python_class_entry);	ret->is_ref = 1;	ret->refcount = 1;	/* Assign the current PyObject to the new PHP Python object */	ALLOC_ZVAL(handle);	ZVAL_RESOURCE(handle, zend_list_insert(obj, le_pyobject));	zval_copy_ctor(handle);	INIT_PZVAL(handle);	zend_hash_index_update(Z_OBJPROP_P(ret), 0, &handle, sizeof(zval *), NULL);	return ret;}

inline int msgpack_convert_long_to_properties(    HashTable *ht, HashTable **properties, HashPosition *prop_pos,    uint key_index, zval *val, HashTable *var){    if (*properties != NULL)    {        char *prop_key;        uint prop_key_len;        ulong prop_key_index;        for (;; zend_hash_move_forward_ex(*properties, prop_pos))        {            if (zend_hash_get_current_key_ex(                    *properties, &prop_key, &prop_key_len,                    &prop_key_index, 0, prop_pos) == HASH_KEY_IS_STRING)            {                if (var == NULL ||                    !zend_hash_exists(var, prop_key, prop_key_len))                {                    zend_hash_move_forward_ex(*properties, prop_pos);                    return zend_symtable_update(                        ht, prop_key, prop_key_len,                        &val, sizeof(val), NULL);                }            }            else            {                break;            }        }        *properties = NULL;    }    return zend_hash_index_update(ht, key_index, &val, sizeof(val), NULL);}

long tw_span_create(char *category, size_t category_len TSRMLS_DC){	zval span, starts, stops, annotations;	int idx;	long parent = 0;	if (TWG(spans) == NULL) {		return -1;	}	idx = zend_hash_num_elements(Z_ARRVAL_P(TWG(spans)));	// Hardcode a limit of 1500 spans for now, Daemon will re-filter again to 1000.	// We assume web-requests and non-spammy worker/crons here, need a way to support	// very long running scripts at some point.	if (idx >= 1500) {		return -1;	}	array_init(&span);	array_init(&starts);	array_init(&stops);	array_init(&annotations);	add_assoc_stringl(&span, "n", category, category_len);	add_assoc_zval(&span, "b", &starts);	add_assoc_zval(&span, "e", &stops);	if (parent > 0) {		add_assoc_long(&span, "p", parent);	}	zend_hash_index_update(Z_ARRVAL_P(TWG(spans)), idx, &span);	return idx;}

static zend_always_inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, zend_long elements, int objprops){	while (elements-- > 0) {		zval key, *data, d, *old_data;		zend_ulong idx;		ZVAL_UNDEF(&key);		if (!php_var_unserialize_ex(&key, p, max, NULL, classes)) {			zval_dtor(&key);			return 0;		}		data = NULL;		ZVAL_UNDEF(&d);		if (!objprops) {			if (Z_TYPE(key) == IS_LONG) {				idx = Z_LVAL(key);numeric_key:				if (UNEXPECTED((old_data = zend_hash_index_find(ht, idx)) != NULL)) {					//??? update hash					var_push_dtor(var_hash, old_data);					data = zend_hash_index_update(ht, idx, &d);				} else {					data = zend_hash_index_add_new(ht, idx, &d);				}			} else if (Z_TYPE(key) == IS_STRING) {				if (UNEXPECTED(ZEND_HANDLE_NUMERIC(Z_STR(key), idx))) {					goto numeric_key;				}				if (UNEXPECTED((old_data = zend_hash_find(ht, Z_STR(key))) != NULL)) {					//??? update hash					var_push_dtor(var_hash, old_data);					data = zend_hash_update(ht, Z_STR(key), &d);				} else {					data = zend_hash_add_new(ht, Z_STR(key), &d);				}			} else {				zval_dtor(&key);				return 0;			}		} else {			if (EXPECTED(Z_TYPE(key) == IS_STRING)) {string_key:				if ((old_data = zend_hash_find(ht, Z_STR(key))) != NULL) {					if (Z_TYPE_P(old_data) == IS_INDIRECT) {						old_data = Z_INDIRECT_P(old_data);					}					var_push_dtor(var_hash, old_data);					data = zend_hash_update_ind(ht, Z_STR(key), &d);				} else {					data = zend_hash_add_new(ht, Z_STR(key), &d);				}			} else if (Z_TYPE(key) == IS_LONG) {				/* object properties should include no integers */				convert_to_string(&key);				goto string_key;			} else {				zval_dtor(&key);				return 0;			}		}		if (!php_var_unserialize_ex(data, p, max, var_hash, classes)) {			zval_dtor(&key);			return 0;		}		if (UNEXPECTED(Z_ISUNDEF_P(data))) {			if (Z_TYPE(key) == IS_LONG) {				zend_hash_index_del(ht, Z_LVAL(key));			} else {				zend_hash_del_ind(ht, Z_STR(key));			}		} else {			var_push_dtor(var_hash, data);		}		zval_dtor(&key);		if (elements && *(*p-1) != ';' && *(*p-1) != '}') {			(*p)--;			return 0;		}	}	return 1;}

ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC){    uint nIndex;    Bucket *p;#ifdef ZEND_SIGNALS    TSRMLS_FETCH();#endif    IS_CONSISTENT(ht);    if (nKeyLength == 0) {        return zend_hash_index_update(ht, h, pData, nDataSize, pDest);    }    CHECK_INIT(ht);    nIndex = h & ht->nTableMask;    p = ht->arBuckets[nIndex];    while (p != NULL) {        if (p->arKey == arKey ||                ((p->h == h) && (p->nKeyLength == nKeyLength) && !memcmp(p->arKey, arKey, nKeyLength))) {            if (flag & HASH_ADD) {                return FAILURE;            }            HANDLE_BLOCK_INTERRUPTIONS();#if ZEND_DEBUG            if (p->pData == pData) {                ZEND_PUTS("Fatal error in zend_hash_update: p->pData == pData/n");                HANDLE_UNBLOCK_INTERRUPTIONS();                return FAILURE;            }#endif            if (ht->pDestructor) {                ht->pDestructor(p->pData);            }            UPDATE_DATA(ht, p, pData, nDataSize);            if (pDest) {                *pDest = p->pData;            }            HANDLE_UNBLOCK_INTERRUPTIONS();            return SUCCESS;        }        p = p->pNext;    }    if (IS_INTERNED(arKey)) {        p = (Bucket *) pemalloc(sizeof(Bucket), ht->persistent);        if (!p) {            return FAILURE;        }        p->arKey = arKey;    } else {        p = (Bucket *) pemalloc(sizeof(Bucket) + nKeyLength, ht->persistent);        if (!p) {            return FAILURE;        }        p->arKey = (const char*)(p + 1);        memcpy((char*)p->arKey, arKey, nKeyLength);    }    p->nKeyLength = nKeyLength;    INIT_DATA(ht, p, pData, nDataSize);    p->h = h;    CONNECT_TO_BUCKET_DLLIST(p, ht->arBuckets[nIndex]);    if (pDest) {        *pDest = p->pData;    }    HANDLE_BLOCK_INTERRUPTIONS();    ht->arBuckets[nIndex] = p;    CONNECT_TO_GLOBAL_DLLIST(p, ht);    HANDLE_UNBLOCK_INTERRUPTIONS();    ht->nNumOfElements++;    ZEND_HASH_IF_FULL_DO_RESIZE(ht);		/* If the Hash table is full, resize it */    return SUCCESS;}