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

/* {{{ mlfi_header()*/static sfsistat mlfi_header(SMFICTX *ctx, char *headerf, char *headerv){	zval function_name, retval, *param[2];	int status;	TSRMLS_FETCH();	/* call userland */	INIT_ZVAL(function_name);		ALLOC_ZVAL(param[0]);	ALLOC_ZVAL(param[1]);	INIT_PZVAL(param[0]);	INIT_PZVAL(param[1]);		ZVAL_STRING(&function_name, "milter_header", 0);	ZVAL_STRING(param[0], headerf, 1);	ZVAL_STRING(param[1], headerv, 1);	/* set the milter context for possible use in API functions */	MG(ctx) = ctx;	MG(state) = MLFI_HEADER;		status = call_user_function(CG(function_table), NULL, &function_name, &retval, 2, param TSRMLS_CC);	MG(state) = MLFI_NONE;		zval_ptr_dtor(&param[0]);	zval_ptr_dtor(&param[1]);			if (status == SUCCESS && Z_TYPE(retval) == IS_LONG) {		return Z_LVAL(retval);	}		return SMFIS_CONTINUE;}

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

/** * Unsets zval index from array */int phalcon_array_unset(zval *arr, zval *index){	zval *copy;	if (Z_TYPE_P(arr) != IS_ARRAY) {		return 0;	}	if (Z_TYPE_P(index) == IS_NULL) {		ALLOC_ZVAL(copy);		ZVAL_ZVAL(copy, index, 1, 0);		convert_to_string(copy);		index = copy;	} else {		if (Z_TYPE_P(index) == IS_BOOL || Z_TYPE_P(index) == IS_DOUBLE) {			ALLOC_ZVAL(copy);			ZVAL_ZVAL(copy, index, 1, 0);			convert_to_long(copy);			index = copy;		}	}	if (Z_TYPE_P(index) == IS_STRING) {		return zend_hash_del(Z_ARRVAL_P(arr), Z_STRVAL_P(index), Z_STRLEN_P(index)+1);	} else {		return zend_hash_index_del(Z_ARRVAL_P(arr), Z_LVAL_P(index));	}	return 0;}

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

/* {{{ unset an object property */void pthreads_unset_property(PTHREADS_UNSET_PROPERTY_PASSTHRU_D) {	zval *mstring = NULL;	PTHREAD pthreads = PTHREADS_FETCH_FROM(object);	if (Z_TYPE_P(member) != IS_STRING) {		ALLOC_ZVAL(mstring);		*mstring = *member;		zval_copy_ctor(			mstring		);		INIT_PZVAL(mstring);		convert_to_string(mstring);		member = mstring;#if PHP_VERSION_ID > 50399		key = NULL;#endif	}	if (Z_TYPE_P(member) == IS_STRING) {		if (pthreads_store_delete(pthreads->store, Z_STRVAL_P(member), Z_STRLEN_P(member) TSRMLS_CC)!=SUCCESS){			zend_error(				E_WARNING, 				"pthreads has experienced an internal error while deleting %s::$%s", 				Z_OBJCE_P(object)->name, Z_STRVAL_P(member)			);		}	} else zend_error(E_WARNING, "pthreads detected an attempt to use an unsupported kind of key in %s", Z_OBJCE_P(object)->name);		if (mstring != NULL) {		zval_ptr_dtor(&mstring);	}}

/* {{{ check if a thread has a property set, wherever it is available */int pthreads_has_property(PTHREADS_HAS_PROPERTY_PASSTHRU_D) {	int isset = 0;	zval *mstring = NULL;	PTHREAD pthreads = PTHREADS_FETCH_FROM(object);	if (Z_TYPE_P(member) != IS_STRING) {		ALLOC_ZVAL(mstring);		*mstring = *member;		zval_copy_ctor(			mstring		);		INIT_PZVAL(mstring);		convert_to_string(mstring);		member = mstring;#if PHP_VERSION_ID > 50399		key = NULL;#endif	}	if (Z_TYPE_P(member) == IS_STRING) {		isset = pthreads_store_isset(pthreads->store, Z_STRVAL_P(member), Z_STRLEN_P(member), has_set_exists TSRMLS_CC);	} else zend_error(E_WARNING, "pthreads has detected an attempt to use an unsupported kind of key in %s", Z_OBJCE_P(object)->name);	if (mstring != NULL) {		zval_ptr_dtor(&mstring);	}	return isset;}

ZEND_API int zend_get_parameters_array(int ht, int param_count, zval **argument_array){	void **p;	int arg_count;	zval *param_ptr;	ELS_FETCH();	p = EG(argument_stack).top_element-2;	arg_count = (ulong) *p;	if (param_count>arg_count) {		return FAILURE;	}	while (param_count-->0) {		param_ptr = *(p-arg_count);		if (!PZVAL_IS_REF(param_ptr) && param_ptr->refcount>1) {			zval *new_tmp;			ALLOC_ZVAL(new_tmp);			*new_tmp = *param_ptr;			zval_copy_ctor(new_tmp);			INIT_PZVAL(new_tmp);			param_ptr = new_tmp;			((zval *) *(p-arg_count))->refcount--;			*(p-arg_count) = param_ptr;		}		*(argument_array++) = param_ptr;		arg_count--;	}	return SUCCESS;}

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

/* {{{ mlfi_envform()*/static sfsistat mlfi_envfrom(SMFICTX *ctx, char **argv){	zval function_name, retval, *param[1];	int status;	TSRMLS_FETCH();	/* call userland */	INIT_ZVAL(function_name);		ALLOC_ZVAL(param[0]);	INIT_PZVAL(param[0]);	ZVAL_STRING(&function_name, "milter_envfrom", 0);	array_init(param[0]);	while (*argv) {		add_next_index_string(param[0], *argv, 1);		argv++;	}	/* set the milter context for possible use in API functions */	MG(ctx) = ctx;	MG(state) = MLFI_ENVFROM;		status = call_user_function(CG(function_table), NULL, &function_name, &retval, 1, param TSRMLS_CC);	MG(state) = MLFI_NONE;	zval_ptr_dtor(param);		if (status == SUCCESS && Z_TYPE(retval) == IS_LONG) {		return Z_LVAL(retval);	}	return SMFIS_CONTINUE;}

zval * mysqlnd_alloc_get_zval(MYSQLND_ZVAL_CACHE * const cache){	zval *ret = NULL;#ifndef MYSQLND_SILENT	php_printf("[mysqlnd_alloc_get_zval %p] *last_added=%p free_items=%d  ", cache, cache? cache->free_list->last_added:NULL, cache->free_items);#endif	if (cache) {		if ((ret = *cache->free_list->last_added)) {			*cache->free_list->last_added++ = NULL;			--cache->free_items;			++cache->get_hits;		} else {			++cache->get_misses;		}	}	if (!ret) {		ALLOC_ZVAL(ret);	}	INIT_PZVAL(ret);#ifndef MYSQLND_SILENT	php_printf("ret=%p/n", ret);#endif	return ret;}

/* {{{ mlfi_connect()*/static sfsistat	mlfi_connect(SMFICTX *ctx, char *hostname, _SOCK_ADDR *hostaddr){	zend_file_handle file_handle;	zval function_name, retval, *param[1];	int status;	TSRMLS_FETCH();	/* request startup */	if (php_request_startup(TSRMLS_C)==FAILURE) {		SG(headers_sent) = 1;		SG(request_info).no_headers = 1;		php_request_shutdown((void *) 0);		return SMFIS_TEMPFAIL;	}		/* disable headers */	SG(headers_sent) = 1;	SG(request_info).no_headers = 1;		if (filename == NULL) {		php_printf("No input file specified");		return SMFIS_TEMPFAIL;	}		if (!(file_handle.handle.fp = VCWD_FOPEN(filename, "rb"))) {		php_printf("Could not open input file: %s/n", filename);		return SMFIS_TEMPFAIL;	}	file_handle.type = ZEND_HANDLE_FP;	file_handle.filename = filename;	file_handle.free_filename = 0;	file_handle.opened_path = NULL;	php_execute_script(&file_handle TSRMLS_CC);		/* call userland */	INIT_ZVAL(function_name);	ALLOC_ZVAL(param[0]);	INIT_PZVAL(param[0]);	ZVAL_STRING(&function_name, "milter_connect", 0);	ZVAL_STRING(param[0], hostname, 1);	/* set the milter context for possible use in API functions */	MG(ctx) = ctx;	MG(state) = MLFI_CONNECT;	status = call_user_function(CG(function_table), NULL, &function_name, &retval, 1, param TSRMLS_CC);	MG(state) = MLFI_NONE;	zval_ptr_dtor(param);	if (status == SUCCESS && Z_TYPE(retval) == IS_LONG) {		return Z_LVAL(retval);	}		return SMFIS_CONTINUE;}

/* {{{ mlfi_body()*/static sfsistat mlfi_body(SMFICTX *ctx, u_char *bodyp, size_t len){	zval function_name, retval, *param[1];	int status;	TSRMLS_FETCH();	/* call userland */	INIT_ZVAL(function_name);		ALLOC_ZVAL(param[0]);	INIT_PZVAL(param[0]);	ZVAL_STRING(&function_name, "milter_body", 0);	ZVAL_STRINGL(param[0], (char*)bodyp, len, 1); /*alex*/		/* set the milter context for possible use in API functions */	MG(ctx) = ctx;	MG(state) = MLFI_BODY;		status = call_user_function(CG(function_table), NULL, &function_name, &retval, 1, param TSRMLS_CC);	MG(state) = MLFI_NONE;		zval_ptr_dtor(param);		if (status == SUCCESS && Z_TYPE(retval) == IS_LONG) {		return Z_LVAL(retval);	}	return SMFIS_CONTINUE;}

/** * @brief Updates value in @a arr at position @a index with @a value using the precomputed hash @a key * @param[in,out] arr Array * @param index Index * @param index_length Length of the index, should include the trailing zero * @param key Precomputed hash of @c value * @param 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 @a 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_quick_string(zval **arr, const char *index, uint index_length, unsigned long key, zval **value, int flags) {    if (Z_TYPE_PP(arr) != IS_ARRAY) {        zend_error(E_WARNING, "Cannot use a scalar value as an array (3)");        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_quick_update(Z_ARRVAL_PP(arr), index, index_length, key, value, sizeof(zval *), NULL);}

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

/* {{{ spl_instantiate */PHPAPI void spl_instantiate(zend_class_entry *pce, zval **object, int alloc TSRMLS_DC){	if (alloc) {		ALLOC_ZVAL(*object);	}	object_init_ex(*object, pce);	(*object)->refcount = 1;	(*object)->is_ref = 1; /* check if this can be hold always */}

void zend_update_property_stringl(zend_class_entry *scope, zval *object, char *name, int name_length, char *value, int value_len TSRMLS_DC){	zval *tmp;		ALLOC_ZVAL(tmp);	tmp->is_ref = 0;	tmp->refcount = 0;	ZVAL_STRINGL(tmp, value, value_len, 1);	zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);}

ZEND_METHOD (Msg, __construct2){	zval *hdr = 0;	ALLOC_ZVAL (hdr);	object_init_ex (hdr, msghdr_ce);	if (zend_hash_update (Z_OBJPROP_P (getThis ()), "hdr", sizeof ("hdr"), &hdr, sizeof (hdr), 0) == FAILURE)		BUG_ON (1);}

static void add_offset_pair(zval *result, char *string, int string_len, int offset){    zval *match_pair;    ALLOC_ZVAL(match_pair);    array_init(match_pair);    INIT_PZVAL(match_pair);    add_next_index_stringl(match_pair, string, string_len, FALSE);    add_next_index_long(match_pair, offset);    zend_hash_next_index_insert(Z_ARRVAL_P(result), &match_pair, sizeof(zval *), NULL);}

	SharedString KPHPObject::DisplayString(int levels)	{		// Make a copy of our object zval* and then convert it to a string.		zval* tempObject = NULL;		ALLOC_ZVAL(tempObject);		*tempObject = *object;		INIT_PZVAL(tempObject);		zval_copy_ctor(tempObject);		convert_to_string(tempObject);		return new std::string(Z_STRVAL_P(tempObject));	}

/* {{{ phpg_read_property() */zval* phpg_read_property(zval *object, zval *member, int type PHPGTK_PROPERTY_END){	phpg_head_t *poh = NULL;	zval tmp_member;	zval result, *result_ptr = NULL;	prop_info_t *pi = NULL;	int ret; 	if (member->type != IS_STRING) {		tmp_member = *member;		zval_copy_ctor(&tmp_member);		convert_to_string(&tmp_member);		member = &tmp_member;	}	ret = FAILURE;	poh = (phpg_head_t *) zend_object_store_get_object(object TSRMLS_CC);	if (poh->pi_hash) {		ret = zend_hash_find(poh->pi_hash, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &pi);	}	if (ret == SUCCESS) {        memset(&result, 0, sizeof(zval));        ZVAL_NULL(&result);		ret = pi->read(poh, &result TSRMLS_CC);		if (ret == SUCCESS) {			ALLOC_ZVAL(result_ptr);			*result_ptr = result;            //INIT_PZVAL(result_ptr);			Z_SET_REFCOUNT_P(result_ptr, 0);			Z_UNSET_ISREF_P(result_ptr);        } else {            result_ptr = EG(uninitialized_zval_ptr);        }	} else {	#if PHP_VERSION_ID < 50399		result_ptr = zend_get_std_object_handlers()->read_property(object, member, type TSRMLS_CC);	#else			result_ptr = zend_get_std_object_handlers()->read_property(object, member, type, NULL TSRMLS_CC);	#endif	}	if (member == &tmp_member) {		zval_dtor(member);	}	return result_ptr;}

/** * Unsets zval index from array */int PHALCON_FASTCALL phalcon_array_unset(zval **arr, zval *index, int flags) {	zval *copy;	int exists, copied = 0;	if (Z_TYPE_PP(arr) != IS_ARRAY) {		return 0;	}	if (Z_TYPE_P(index) == IS_NULL) {		ALLOC_INIT_ZVAL(copy);		ZVAL_ZVAL(copy, index, 1, 0);		convert_to_string(copy);		index = copy;		copied = 1;	} else {		if (Z_TYPE_P(index) == IS_BOOL || Z_TYPE_P(index) == IS_DOUBLE) {			ALLOC_INIT_ZVAL(copy);			ZVAL_ZVAL(copy, index, 1, 0);			convert_to_long(copy);			index = copy;			copied = 1;		}	}	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 (Z_TYPE_P(index) == IS_STRING) {		exists = zend_hash_del(Z_ARRVAL_PP(arr), Z_STRVAL_P(index), Z_STRLEN_P(index) + 1);	} else {		exists = zend_hash_index_del(Z_ARRVAL_PP(arr), Z_LVAL_P(index));	}	if (copied) {		zval_ptr_dtor(&copy);	}	return exists;}

/** * @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;    }}

VALUE new_php_embed_value(zval *value) {    VALUE new_value;    zval* new_zval;    VALUE arg = INT2FIX(0);    ALLOC_ZVAL(new_zval);    *new_zval = *value;    zval_copy_ctor(new_zval);    INIT_PZVAL(new_zval);    new_value = php_value_alloc(cPhpEmbedValue);    set_zval(new_value, new_zval);    return new_value;}

/* {{{ apache_php_module_hook */int apache_php_module_hook(request_rec *r, php_handler *handler, zval **ret){	zend_file_handle file_handle;	zval *req;    char *tmp;#if PHP_SIGCHILD	signal(SIGCHLD, sigchld_handler);#endif    if(AP(current_hook) == AP_RESPONSE) {        if (php_request_startup_for_hook() == FAILURE)            return FAILURE;    }    else {        if (php_request_startup_for_hook() == FAILURE)            return FAILURE;    }    req = php_apache_request_new(r);    php_register_variable_ex("request", req, PG(http_globals)[TRACK_VARS_SERVER]);    switch(handler->type) {        case AP_HANDLER_TYPE_FILE:            php_register_variable("PHP_SELF_HOOK", handler->name, PG(http_globals)[TRACK_VARS_SERVER]);	        memset(&file_handle, 0, sizeof(file_handle));	        file_handle.type = ZEND_HANDLE_FILENAME;	        file_handle.filename = handler->name;	        (void) php_execute_simple_script(&file_handle, ret);            break;        case AP_HANDLER_TYPE_METHOD:            if( (tmp = strstr(handler->name, "::")) != NULL &&  *(tmp+2) != '/0' ) {                zval *class;                zval *method;                *tmp = '/0';                ALLOC_ZVAL(class);                ZVAL_STRING(class, handler->name, 1);                ALLOC_ZVAL(method);                ZVAL_STRING(method, tmp +2, 1);                *tmp = ':';                call_user_function_ex(EG(function_table), &class, method, ret, 0, NULL, 0, NULL);                zval_dtor(class);                zval_dtor(method);            }            else {

/** * Unsets long index from array */int PHALCON_FASTCALL phalcon_array_unset_long(zval **arr, unsigned long index, int flags) {	if (Z_TYPE_PP(arr) != IS_ARRAY) {		return 0;	}	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);		}	}	return zend_hash_index_del(Z_ARRVAL_PP(arr), index);}

/** * Push one or more elements onto the end of an array */int phalcon_array_append(zval **arr, zval *value, int flags TSRMLS_DC){	if (Z_TYPE_PP(arr) == IS_ARRAY) {		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);			}		}		Z_ADDREF_P(value);		return add_next_index_zval(*arr, value);	} else {		php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Cannot use a scalar value as an array");	}	return FAILURE;}

/* {{ reads a property from a thread, wherever it is available */zval * pthreads_read_property (PTHREADS_READ_PROPERTY_PASSTHRU_D) {	zval *value = NULL, *mstring = NULL;	PTHREAD pthreads = PTHREADS_FETCH_FROM(object);		if (Z_TYPE_P(member) != IS_STRING) {		ALLOC_ZVAL(mstring);		*mstring = *member;		zval_copy_ctor(			mstring		);		INIT_PZVAL(mstring);		zend_try {			convert_to_string(mstring);		} zend_end_try();		member = mstring;#if PHP_VERSION_ID > 50399		key = NULL;#endif	}

void mongo_util_hash_copy_to_np(void *pDest) {  zval **p = (zval**)pDest;  zval *temp = *p;  ALLOC_ZVAL(*p);  memcpy(*p, temp, sizeof(zval));  INIT_PZVAL(*p);  switch(Z_TYPE_PP(p)) {  case IS_STRING: {    Z_STRVAL_PP(p) = estrndup(Z_STRVAL_P(temp), Z_STRLEN_P(temp));    break;  }  case IS_ARRAY: {    TSRMLS_FETCH();    mongo_util_hash_to_zval(p, &temp TSRMLS_CC);    break;  }  }}

/** * Adds an option to the current options * * @param array $option * @return $this */PHP_METHOD(Phalcon_Forms_Element_Select, addOption){	zval **option, *values, *tmp;	phalcon_fetch_params_ex(1, 0, &option);	PHALCON_ENSURE_IS_ARRAY(option);	values = phalcon_fetch_nproperty_this(getThis(), SL("_optionsValues"), PH_NOISY TSRMLS_CC);		ALLOC_ZVAL(tmp);	if (Z_TYPE_P(values) != IS_ARRAY) {		MAKE_COPY_ZVAL(option, tmp);	}	else {		add_function(tmp, *option, values TSRMLS_CC);	}	Z_SET_REFCOUNT_P(tmp, 0);	phalcon_update_property_this(getThis(), SL("_optionsValues"), tmp TSRMLS_CC);	RETURN_THISW();}

/* {{{ static void yaf_config_ini_zval_deep_copy(zval **p) */static void yaf_config_ini_zval_deep_copy(zval **p) {	zval *value;	ALLOC_ZVAL(value);	*value = **p;	switch (Z_TYPE_PP(p)) {		case IS_ARRAY:			{				array_init(value);				zend_hash_copy(Z_ARRVAL_P(value), Z_ARRVAL_PP(p),						(copy_ctor_func_t)yaf_config_ini_zval_deep_copy, NULL, sizeof(zval *));			}			break;		default:			zval_copy_ctor(value);			Z_TYPE_P(value) = Z_TYPE_PP(p);	}	INIT_PZVAL(value);	*p = value;}