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