/* {{{ 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(¶m[0]);
zval_ptr_dtor(¶m[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(©);
}
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;
}
