void phalcon_make_printable_zval(zval *expr, zval *expr_copy, int *use_copy){
zend_make_printable_zval(expr, expr_copy, use_copy);
if (use_copy) {
Z_SET_REFCOUNT_P(expr_copy, 1);
Z_UNSET_ISREF_P(expr_copy);
}
}
static zval *com_property_read(zval *object, zval *member, int type TSRMLS_DC)
{
zval *return_value;
php_com_dotnet_object *obj;
VARIANT v;
HRESULT res;
MAKE_STD_ZVAL(return_value);
ZVAL_NULL(return_value);
Z_SET_REFCOUNT_P(return_value, 0);
Z_UNSET_ISREF_P(return_value);
obj = CDNO_FETCH(object);
if (V_VT(&obj->v) == VT_DISPATCH) {
VariantInit(&v);
convert_to_string_ex(&member);
res = php_com_do_invoke(obj, Z_STRVAL_P(member), Z_STRLEN_P(member),
DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v, 0, NULL, 1 TSRMLS_CC);
if (res == SUCCESS) {
php_com_zval_from_variant(return_value, &v, obj->code_page TSRMLS_CC);
VariantClear(&v);
} else if (res == DISP_E_BADPARAMCOUNT) {
php_com_saproxy_create(object, return_value, member TSRMLS_CC);
}
} else {
php_com_throw_exception(E_INVALIDARG, "this variant has no properties" TSRMLS_CC);
}
return return_value;
}
/**
* @brief Appends a string @a value to @a arr
* @param[in,out] arr Array
* @param value Value
* @param value_length Length of the value (usually <tt>strlen(value)</tt>)
* @param separate Flags (@c PH_SEPARATE: separate array if its reference count is greater than 1; @c arr will contain the separated array)
* @return Whether the operation succeeded
* @retval @c FAILURE Failure or @a arr is not an array
* @retval @c SUCCESS Success
* @throw @c E_WARNING if @a is not an array
* @see zephir_array_append()
*
* Equivalent to <tt>$arr[] = $value</tt> in PHP, where @c $value is a string.
*/
int zephir_array_append_string(zval **arr, char *value, uint value_length, int separate) {
zval *zvalue;
ALLOC_INIT_ZVAL(zvalue);
Z_SET_REFCOUNT_P(zvalue, 0);
ZVAL_STRINGL(zvalue, value, value_length, 1);
return zephir_array_append(arr, zvalue, separate ZEPHIR_DEBUG_PARAMS_DUMMY);
}
int phalcon_array_append_long(zval **arr, long value, int separate TSRMLS_DC){
zval *zvalue;
ALLOC_INIT_ZVAL(zvalue);
Z_SET_REFCOUNT_P(zvalue, 0);
ZVAL_LONG(zvalue, value);
return phalcon_array_append(arr, zvalue, separate TSRMLS_CC);
}
/**
* @brief Appends a long integer @a value to @a arr
* @param[in,out] arr Array
* @param value Value
* @param separate Flags (@c PH_SEPARATE: separate array if its reference count is greater than 1; @c arr will contain the separated array)
* @return Whether the operation succeeded
* @retval @c FAILURE Failure or @a arr is not an array
* @retval @c SUCCESS Success
* @throw @c E_WARNING if @a is not an array
* @see zephir_array_append()
*
* Equivalent to <tt>$arr[] = $value</tt> in PHP, where @c $value is an integer.
*/
int zephir_array_append_long(zval **arr, long value, int separate) {
zval *zvalue;
ALLOC_INIT_ZVAL(zvalue);
Z_SET_REFCOUNT_P(zvalue, 0);
ZVAL_LONG(zvalue, value);
return zephir_array_append(arr, zvalue, separate ZEPHIR_DEBUG_PARAMS_DUMMY);
}
int phalcon_array_append_string(zval **arr, char *value, int value_length, int separate TSRMLS_DC){
zval *zvalue;
ALLOC_INIT_ZVAL(zvalue);
Z_SET_REFCOUNT_P(zvalue, 0);
ZVAL_STRINGL(zvalue, value, value_length, 1);
return phalcon_array_append(arr, zvalue, separate TSRMLS_CC);
}
/* {{{ mysqlnd_stmt_copy_it */
static void
mysqlnd_stmt_copy_it(zval *** copies, zval *original, unsigned int param_count, unsigned int current TSRMLS_DC)
{
if (!*copies) {
*copies = mnd_ecalloc(param_count, sizeof(zval *));
}
MAKE_STD_ZVAL((*copies)[current]);
*(*copies)[current] = *original;
Z_SET_REFCOUNT_P((*copies)[current], 1);
zval_copy_ctor((*copies)[current]);
}
static void
SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject TSRMLS_DC) {
swig_object_wrapper *value=NULL;
/*
* First test for Null pointers. Return those as PHP native NULL
*/
if (!ptr ) {
ZVAL_NULL(z);
return;
}
if (type->clientdata) {
if (! (*(int *)(type->clientdata)))
zend_error(E_ERROR, "Type: %s failed to register with zend",type->name);
value=(swig_object_wrapper *)emalloc(sizeof(swig_object_wrapper));
value->ptr=ptr;
value->newobject=newobject;
if (newobject <= 1) {
/* Just register the pointer as a resource. */
ZEND_REGISTER_RESOURCE(z, value, *(int *)(type->clientdata));
} else {
/*
* Wrap the resource in an object, the resource will be accessible
* via the "_cPtr" member. This is currently only used by
* directorin typemaps.
*/
value->newobject = 0;
zval *resource;
MAKE_STD_ZVAL(resource);
ZEND_REGISTER_RESOURCE(resource, value, *(int *)(type->clientdata));
zend_class_entry **ce = NULL;
zval *classname;
MAKE_STD_ZVAL(classname);
/* _p_Foo -> Foo */
ZVAL_STRING(classname, (char*)type->name+3, 1);
/* class names are stored in lowercase */
php_strtolower(Z_STRVAL_PP(&classname), Z_STRLEN_PP(&classname));
if (zend_lookup_class(Z_STRVAL_P(classname), Z_STRLEN_P(classname), &ce TSRMLS_CC) != SUCCESS) {
/* class does not exist */
object_init(z);
} else {
object_init_ex(z, *ce);
}
Z_SET_REFCOUNT_P(z, 1);
Z_SET_ISREF_P(z);
zend_hash_update(HASH_OF(z), (char*)"_cPtr", sizeof("_cPtr"), (void*)&resource, sizeof(zval), NULL);
FREE_ZVAL(classname);
}
return;
}
zend_error(E_ERROR, "Type: %s not registered with zend",type->name);
}
/* {{{ my_copy_zval */
zval* my_copy_zval(zval* dst, const zval* src, int persistent TSRMLS_DC)
{
zval **tmp;
assert(dst != NULL);
assert(src != NULL);
memcpy(dst, src, sizeof(zval));
/* deep copies are refcount(1), but moved up for recursive
* arrays, which end up being add_ref'd during its copy. */
Z_SET_REFCOUNT_P(dst, 1);
Z_UNSET_ISREF_P(dst);
switch (src->type & IS_CONSTANT_TYPE_MASK) {
case IS_RESOURCE:
php_error(E_ERROR, "Cannot copy resource");
break;
case IS_BOOL:
case IS_LONG:
case IS_DOUBLE:
case IS_NULL:
break;
case IS_CONSTANT:
case IS_STRING:
if (src->value.str.val) {
dst->value.str.val = pestrndup(src->value.str.val, src->value.str.len, persistent);
}
break;
#if ZEND_EXTENSION_API_NO < PHP_5_5_X_API_NO
case IS_CONSTANT_ARRAY:
#endif
case IS_ARRAY:
dst->value.ht = my_copy_hashtable(NULL, src->value.ht, (ht_copy_fun_t) my_copy_zval_ptr, (void*) &tmp, sizeof(zval *), persistent TSRMLS_CC);
break;
// XXX: we don't serialize object.
case IS_OBJECT:
php_error(E_ERROR, "Cannot copy Object.");
break;
#ifdef ZEND_ENGINE_2_4
case IS_CALLABLE:
php_error(E_ERROR, "Cannot copy Callable.");
// XXX: we don't serialize callbable object.
break;
#endif
default:
assert(0);
}
return dst;
}
/* {{{ 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;
}
static zend_always_inline void zend_pzval_unlock_func(zval *z, zend_free_op *should_free, int unref TSRMLS_DC)
{
if (!Z_DELREF_P(z)) {
Z_SET_REFCOUNT_P(z, 1);
Z_UNSET_ISREF_P(z);
should_free->var = z;
/* should_free->is_var = 1; */
} else {
should_free->var = 0;
if (unref && Z_ISREF_P(z) && Z_REFCOUNT_P(z) == 1) {
Z_UNSET_ISREF_P(z);
}
GC_ZVAL_CHECK_POSSIBLE_ROOT(z);
}
}
/* {{{ mysqlnd_stmt_copy_it */
static enum_func_status
mysqlnd_stmt_copy_it(zval *** copies, zval *original, unsigned int param_count, unsigned int current TSRMLS_DC)
{
if (!*copies) {
*copies = mnd_ecalloc(param_count, sizeof(zval *));
}
if (*copies) {
MAKE_STD_ZVAL((*copies)[current]);
*(*copies)[current] = *original;
Z_SET_REFCOUNT_P((*copies)[current], 1);
zval_copy_ctor((*copies)[current]);
return PASS;
}
return FAIL;
}
/**
* 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();
}
/* {{{ php_parsekit_derive_arginfo
ZE1 Func Arg loading is done via opcodes "RECV"ing from the caller */
static void php_parsekit_derive_arginfo(zval *return_value, zend_op_array *op_array, long options TSRMLS_DC)
{
int i;
zend_op *opcodes = op_array->opcodes;
array_init(return_value);
/* Received vars come in pairs:
A ZEND_FETCH_W, and a ZEND_RECV */
for(i = 0; i < op_array->arg_types[0]; i++) {
if (opcodes[i*2].opcode == ZEND_FETCH_W &&
opcodes[i*2].op1.op_type == IS_CONST &&
opcodes[i*2].op1.u.constant.type == IS_STRING &&
(opcodes[(i*2)+1].opcode == ZEND_RECV || opcodes[(i*2)+1].opcode == ZEND_RECV_INIT)) {
zval *tmpzval;
MAKE_STD_ZVAL(tmpzval);
array_init(tmpzval);
add_assoc_stringl(tmpzval, "name", opcodes[i*2].op1.u.constant.value.str.val, opcodes[i*2].op1.u.constant.value.str.len, 1);
add_assoc_bool(tmpzval, "pass_by_reference", op_array->arg_types[i+1]);
if (opcodes[(i*2)+1].opcode == ZEND_RECV_INIT &&
opcodes[(i*2)+1].op2.op_type == IS_CONST) {
zval *def;
MAKE_STD_ZVAL(def);
*def = opcodes[(i*2)+1].op2.u.constant;
zval_copy_ctor(def);
add_assoc_zval(tmpzval, "default", def);
Z_SET_REFCOUNT_P(tmpzval, 1);
}
add_next_index_zval(return_value, tmpzval);
}
}
}
static PHP_RINIT_FUNCTION(phalcon){
phalcon_memory_entry *start;
zend_phalcon_globals *phalcon_globals_ptr = PHALCON_VGLOBAL;
size_t i;
php_phalcon_init_globals(phalcon_globals_ptr TSRMLS_CC);
phalcon_init_interned_strings(TSRMLS_C);
start = (phalcon_memory_entry *) pecalloc(num_preallocated_frames, sizeof(phalcon_memory_entry), 1);
/* pecalloc() will take care of these members for every frame
start->pointer = 0;
start->hash_pointer = 0;
start->prev = NULL;
start->next = NULL;
*/
for (i = 0; i < num_preallocated_frames; ++i) {
start[i].addresses = pecalloc(24, sizeof(zval*), 1);
start[i].capacity = 24;
start[i].hash_addresses = pecalloc(8, sizeof(zval*), 1);
start[i].hash_capacity = 8;
#ifndef PHALCON_RELEASE
start[i].permanent = 1;
#endif
}
start[0].next = &start[1];
start[num_preallocated_frames - 1].prev = &start[num_preallocated_frames - 2];
for (i = 1; i < num_preallocated_frames - 1; ++i) {
start[i].next = &start[i + 1];
start[i].prev = &start[i - 1];
}
phalcon_globals_ptr->start_memory = start;
phalcon_globals_ptr->end_memory = start + num_preallocated_frames;
phalcon_globals_ptr->fcache = pemalloc(sizeof(HashTable), 1);
#ifndef PHALCON_RELEASE
zend_hash_init(phalcon_globals_ptr->fcache, 128, NULL, phalcon_fcall_cache_dtor, 1);
#else
zend_hash_init(phalcon_globals_ptr->fcache, 128, NULL, NULL, 1);
#endif
/* 'Allocator sizeof operand mismatch' warning can be safely ignored */
ALLOC_INIT_ZVAL(phalcon_globals_ptr->z_null);
Z_SET_REFCOUNT_P(phalcon_globals_ptr->z_null, 2);
/* 'Allocator sizeof operand mismatch' warning can be safely ignored */
ALLOC_INIT_ZVAL(phalcon_globals_ptr->z_false);
Z_SET_REFCOUNT_P(phalcon_globals_ptr->z_false, 2);
ZVAL_FALSE(phalcon_globals_ptr->z_false);
/* 'Allocator sizeof operand mismatch' warning can be safely ignored */
ALLOC_INIT_ZVAL(phalcon_globals_ptr->z_true);
Z_SET_REFCOUNT_P(phalcon_globals_ptr->z_true, 2);
ZVAL_TRUE(phalcon_globals_ptr->z_true);
/* 'Allocator sizeof operand mismatch' warning can be safely ignored */
ALLOC_INIT_ZVAL(phalcon_globals_ptr->z_zero);
Z_SET_REFCOUNT_P(phalcon_globals_ptr->z_zero, 2);
ZVAL_LONG(phalcon_globals_ptr->z_zero, 0);
/* 'Allocator sizeof operand mismatch' warning can be safely ignored */
ALLOC_INIT_ZVAL(phalcon_globals_ptr->z_one);
Z_SET_REFCOUNT_P(phalcon_globals_ptr->z_one, 2);
ZVAL_LONG(phalcon_globals_ptr->z_one, 1);
return SUCCESS;
}
static void
SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject TSRMLS_DC) {
/*
* First test for Null pointers. Return those as PHP native NULL
*/
if (!ptr ) {
ZVAL_NULL(z);
return;
}
if (type->clientdata) {
swig_object_wrapper *value;
if (! (*(int *)(type->clientdata)))
zend_error(E_ERROR, "Type: %s failed to register with zend",type->name);
value=(swig_object_wrapper *)emalloc(sizeof(swig_object_wrapper));
value->ptr=ptr;
value->newobject=(newobject & 1);
if ((newobject & 2) == 0) {
/* Just register the pointer as a resource. */
ZEND_REGISTER_RESOURCE(z, value, *(int *)(type->clientdata));
} else {
/*
* Wrap the resource in an object, the resource will be accessible
* via the "_cPtr" member. This is currently only used by
* directorin typemaps.
*/
zval *resource;
zend_class_entry **ce = NULL;
const char *type_name = type->name+3; /* +3 so: _p_Foo -> Foo */
size_t type_name_len;
int result;
const char * p;
/* Namespace__Foo -> Foo */
/* FIXME: ugly and goes wrong for classes with __ in their names. */
while ((p = strstr(type_name, "__")) != NULL) {
type_name = p + 2;
}
type_name_len = strlen(type_name);
MAKE_STD_ZVAL(resource);
ZEND_REGISTER_RESOURCE(resource, value, *(int *)(type->clientdata));
if (SWIG_PREFIX_LEN > 0) {
char * classname = (char*)emalloc(SWIG_PREFIX_LEN + type_name_len + 1);
strcpy(classname, SWIG_PREFIX);
strcpy(classname + SWIG_PREFIX_LEN, type_name);
result = zend_lookup_class(classname, SWIG_PREFIX_LEN + type_name_len, &ce TSRMLS_CC);
efree(classname);
} else {
result = zend_lookup_class((char *)type_name, type_name_len, &ce TSRMLS_CC);
}
if (result != SUCCESS) {
/* class does not exist */
object_init(z);
} else {
object_init_ex(z, *ce);
}
Z_SET_REFCOUNT_P(z, 1);
Z_SET_ISREF_P(z);
zend_hash_update(HASH_OF(z), (char*)"_cPtr", sizeof("_cPtr"), (void*)&resource, sizeof(zval), NULL);
}
return;
}
zend_error(E_ERROR, "Type: %s not registered with zend",type->name);
}
/* {{{ php_parsekit_parse_node */
static void php_parsekit_parse_node(zval *return_value, zend_op_array *op_array, znode *node, long flags, long options TSRMLS_DC)
{
array_init(return_value);
add_assoc_long(return_value, "type", node->op_type);
add_assoc_string(return_value, "type_name", php_parsekit_define_name(node->op_type, php_parsekit_nodetype_names, PHP_PARSEKIT_NODETYPE_UNKNOWN), 1);
if (node->op_type == IS_CONST) {
zval *tmpzval;
MAKE_STD_ZVAL(tmpzval);
*tmpzval = node->u.constant;
zval_copy_ctor(tmpzval);
Z_SET_REFCOUNT_P(tmpzval, 1);
add_assoc_zval(return_value, "constant", tmpzval);
#ifdef IS_CV
/* PHP >= 5.1 */
} else if (node->op_type == IS_CV) {
add_assoc_long(return_value, "var", node->u.var);
add_assoc_stringl(return_value, "varname", op_array->vars[node->u.var].name, op_array->vars[node->u.var].name_len, 1);
#endif
} else {
/* IS_VAR || IS_TMP_VAR || IS_UNUSED */
char sop[(sizeof(void *) * 2) + 1];
snprintf(sop, (sizeof(void *) * 2) + 1, "%X", (unsigned int)node->u.var);
if ((flags & PHP_PARSEKIT_VAR) ||
(options & PHP_PARSEKIT_ALL_ELEMENTS)) {
add_assoc_long(return_value, "var", node->u.var / sizeof(temp_variable));
} else if (options & PHP_PARSEKIT_ALWAYS_SET) {
add_assoc_null(return_value, "var");
}
if ((flags & PHP_PARSEKIT_OPLINE) ||
(options & PHP_PARSEKIT_ALL_ELEMENTS)) {
add_assoc_string(return_value, "opline_num", sop, 1);
} else if (options & PHP_PARSEKIT_ALWAYS_SET) {
add_assoc_null(return_value, "opline_num");
}
if ((flags & PHP_PARSEKIT_OPARRAY) ||
(options & PHP_PARSEKIT_ALL_ELEMENTS)) {
add_assoc_string(return_value, "op_array", sop, 1);
} else if (options & PHP_PARSEKIT_ALWAYS_SET) {
add_assoc_null(return_value, "op_array");
}
#ifdef ZEND_ENGINE_2
/* ZE2 Only */
if ((flags & PHP_PARSEKIT_JMP_ADDR) ||
(options & PHP_PARSEKIT_ALL_ELEMENTS)) {
add_assoc_string(return_value, "jmp_addr", sop, 1);
snprintf(sop, sizeof(sop)-1, "%u",
((unsigned int)((char*)node->u.var - (char*)op_array->opcodes))/sizeof(zend_op));
add_assoc_string(return_value, "jmp_offset", sop, 1);
} else if (options & PHP_PARSEKIT_ALWAYS_SET) {
add_assoc_null(return_value, "jmp_addr");
}
#endif
if ((flags & PHP_PARSEKIT_EA_TYPE) ||
(options & PHP_PARSEKIT_ALL_ELEMENTS)) {
add_assoc_long(return_value, "EA.type", node->u.EA.type);
} else if (options & PHP_PARSEKIT_ALWAYS_SET) {
add_assoc_null(return_value, "EA.type");
}
}
}
