/** {{{ int yaf_route_simple_route(yaf_route_t *route, yaf_request_t *request)
*/
int yaf_route_simple_route(yaf_route_t *route, yaf_request_t *request) {
zval *module, *controller, *action;
zval *nmodule, *ncontroller, *naction;
nmodule = zend_read_property(yaf_route_simple_ce,
route, ZEND_STRL(YAF_ROUTE_SIMPLE_VAR_NAME_MODULE), 1, NULL);
ncontroller = zend_read_property(yaf_route_simple_ce,
route, ZEND_STRL(YAF_ROUTE_SIMPLE_VAR_NAME_CONTROLLER), 1, NULL);
naction = zend_read_property(yaf_route_simple_ce,
route, ZEND_STRL(YAF_ROUTE_SIMPLE_VAR_NAME_ACTION), 1, NULL);
/* if there is no expect parameter in supervars, then null will be return */
module = yaf_request_query(YAF_GLOBAL_VARS_GET, Z_STR_P(nmodule));
controller = yaf_request_query(YAF_GLOBAL_VARS_GET, Z_STR_P(ncontroller));
action = yaf_request_query(YAF_GLOBAL_VARS_GET, Z_STR_P(naction));
if (!module && !controller && !action) {
return 0;
}
if (module && Z_TYPE_P(module) == IS_STRING && yaf_application_is_module_name(Z_STR_P(module))) {
zend_update_property(yaf_request_ce, request, ZEND_STRL(YAF_REQUEST_PROPERTY_NAME_MODULE), module);
}
if (controller) {
zend_update_property(yaf_request_ce, request, ZEND_STRL(YAF_REQUEST_PROPERTY_NAME_CONTROLLER), controller);
}
if (action) {
zend_update_property(yaf_request_ce, request, ZEND_STRL(YAF_REQUEST_PROPERTY_NAME_ACTION), action);
}
return 1;
}
/* {{{ proto mixed uopz_get_property(object instance, string property)
proto mixed uopz_get_property(string class, string property) */
static PHP_FUNCTION(uopz_get_property) {
zval *scope = NULL;
zval *prop = NULL;
if (uopz_parse_parameters("zz", &scope, &prop) != SUCCESS ||
!scope || !prop ||
(Z_TYPE_P(scope) != IS_OBJECT && Z_TYPE_P(scope) != IS_STRING) ||
Z_TYPE_P(prop) != IS_STRING) {
uopz_refuse_parameters(
"unexpected paramter combination, expected "
"(class, property) or (object, property)");
return;
}
if (Z_TYPE_P(scope) == IS_OBJECT) {
uopz_get_property(scope, prop, return_value);
} else {
zend_class_entry *ce = zend_lookup_class(Z_STR_P(scope));
if (!ce) {
return;
}
uopz_get_static_property(ce, Z_STR_P(prop), return_value);
}
} /* }}} */
int uopz_add_class_handler(UOPZ_OPCODE_HANDLER_ARGS) { /* {{{ */
zval *name = EX_CONSTANT(EX(opline)->op2);
zend_string *key = zend_string_tolower(Z_STR_P(name));
zval *mock = NULL;
if ((mock = zend_hash_find(&UOPZ(mocks), key))) {
if (Z_TYPE_P(mock) == IS_STRING) {
zend_class_entry *ce = zend_lookup_class(Z_STR_P(mock));
if (ce) {
CACHE_PTR(Z_CACHE_SLOT_P(name), ce);
}
} else {
CACHE_PTR(Z_CACHE_SLOT_P(name), Z_OBJCE_P(mock));
}
}
zend_string_release(key);
if (uopz_add_trait_handler || uopz_add_interface_handler) {
switch (EX(opline)->opcode) {
case ZEND_ADD_INTERFACE:
return uopz_add_interface_handler(UOPZ_OPCODE_HANDLER_ARGS_PASSTHRU);
case ZEND_ADD_TRAIT:
return uopz_add_trait_handler(UOPZ_OPCODE_HANDLER_ARGS_PASSTHRU);
}
}
return ZEND_USER_OPCODE_DISPATCH;
} /* }}} */
int uopz_class_constant_handler(UOPZ_OPCODE_HANDLER_ARGS) { /* {{{ */
if (EX(opline)->op1_type == IS_CONST) {
zval *name = EX_CONSTANT(EX(opline)->op1);
zend_string *key = Z_STR_P(name);
zval *mock = NULL;
zend_class_entry *poser = NULL;
key = zend_string_tolower(key);
if ((mock = zend_hash_find(&UOPZ(mocks), key))) {
if (Z_TYPE_P(mock) == IS_OBJECT) {
poser = Z_OBJCE_P(mock);
} else poser = zend_lookup_class(Z_STR_P(mock));
if (poser) {
CACHE_PTR(Z_CACHE_SLOT_P(name), poser);
}
}
zend_string_release(key);
}
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(EX(opline)->op2)), NULL);
if (uopz_fetch_class_constant_handler) {
return uopz_fetch_class_constant_handler(UOPZ_OPCODE_HANDLER_ARGS_PASSTHRU);
}
return ZEND_USER_OPCODE_DISPATCH;
} /* }}} */
ZEND_API zend_constant* ZEND_FASTCALL zend_quick_get_constant(const zval *key, uint32_t flags)
{
zval *zv;
zend_constant *c = NULL;
zv = zend_hash_find_ex(EG(zend_constants), Z_STR_P(key), 1);
if (zv) {
c = (zend_constant*)Z_PTR_P(zv);
} else {
key++;
zv = zend_hash_find_ex(EG(zend_constants), Z_STR_P(key), 1);
if (zv && (((zend_constant*)Z_PTR_P(zv))->flags & CONST_CS) == 0) {
c = (zend_constant*)Z_PTR_P(zv);
} else {
if ((flags & (IS_CONSTANT_IN_NAMESPACE|IS_CONSTANT_UNQUALIFIED)) == (IS_CONSTANT_IN_NAMESPACE|IS_CONSTANT_UNQUALIFIED)) {
key++;
zv = zend_hash_find_ex(EG(zend_constants), Z_STR_P(key), 1);
if (zv) {
c = (zend_constant*)Z_PTR_P(zv);
} else {
key++;
zv = zend_hash_find_ex(EG(zend_constants), Z_STR_P(key), 1);
if (zv && (((zend_constant*)Z_PTR_P(zv))->flags & CONST_CS) == 0) {
c = (zend_constant*)Z_PTR_P(zv);
}
}
}
}
}
return c;
}
static inline zend_long *pthreads_get_guard(zend_object *zobj, zval *member) /* {{{ */
{
HashTable *guards;
zend_long stub, *guard;
zval tmp;
ZEND_ASSERT(GC_FLAGS(zobj) & IS_OBJ_USE_GUARDS);
if (GC_FLAGS(zobj) & IS_OBJ_HAS_GUARDS) {
guards = Z_PTR(zobj->properties_table[zobj->ce->default_properties_count]);
ZEND_ASSERT(guards != NULL);
if (Z_TYPE_P(member) == IS_LONG) {
if ((guard = (zend_long *)zend_hash_index_find_ptr(guards, Z_LVAL_P(member))) != NULL) {
return guard;
}
} else {
if ((guard = (zend_long *)zend_hash_find_ptr(guards, Z_STR_P(member))) != NULL) {
return guard;
}
}
} else {
ALLOC_HASHTABLE(guards);
zend_hash_init(guards, 8, NULL, pthreads_guard_dtor, 0);
ZVAL_PTR(&tmp, guards);
Z_PTR(zobj->properties_table[zobj->ce->default_properties_count]) = guards;
GC_FLAGS(zobj) |= IS_OBJ_HAS_GUARDS;
}
stub = 0;
if (Z_TYPE_P(member) == IS_LONG) {
return (zend_long *)zend_hash_index_add_mem(guards, Z_LVAL_P(member), &stub, sizeof(zend_ulong));
} else return (zend_long *)zend_hash_add_mem(guards, Z_STR_P(member), &stub, sizeof(zend_ulong));
}
zend_constant *zend_quick_get_constant(const zval *key, zend_ulong flags)
{
zend_constant *c;
if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL) {
key++;
if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL ||
(c->flags & CONST_CS) != 0) {
if ((flags & (IS_CONSTANT_IN_NAMESPACE|IS_CONSTANT_UNQUALIFIED)) == (IS_CONSTANT_IN_NAMESPACE|IS_CONSTANT_UNQUALIFIED)) {
key++;
if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL) {
key++;
if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL ||
(c->flags & CONST_CS) != 0) {
key--;
c = NULL;
}
}
} else {
key--;
c = NULL;
}
}
}
return c;
}
static inline void zend_clone_zval(zval *src, int bind)
{
void *ptr;
if (Z_IMMUTABLE_P(src)) {
return;
}
switch (Z_TYPE_P(src)) {
case IS_STRING:
case IS_CONSTANT:
Z_STR_P(src) = zend_clone_str(Z_STR_P(src));
break;
case IS_ARRAY:
if (Z_ARR_P(src) != &EG(symbol_table)) {
if (bind && Z_REFCOUNT_P(src) > 1 && (ptr = accel_xlat_get(Z_ARR_P(src))) != NULL) {
Z_ARR_P(src) = ptr;
} else {
zend_array *old = Z_ARR_P(src);
Z_ARR_P(src) = emalloc(sizeof(zend_array));
Z_ARR_P(src)->gc = old->gc;
if (bind && Z_REFCOUNT_P(src) > 1) {
accel_xlat_set(old, Z_ARR_P(src));
}
zend_hash_clone_zval(Z_ARRVAL_P(src), old, 0);
}
}
break;
case IS_REFERENCE:
if (bind && Z_REFCOUNT_P(src) > 1 && (ptr = accel_xlat_get(Z_REF_P(src))) != NULL) {
Z_REF_P(src) = ptr;
} else {
zend_reference *old = Z_REF_P(src);
ZVAL_NEW_REF(src, &old->val);
Z_REF_P(src)->gc = old->gc;
if (bind && Z_REFCOUNT_P(src) > 1) {
accel_xlat_set(old, Z_REF_P(src));
}
zend_clone_zval(Z_REFVAL_P(src), bind);
}
break;
case IS_CONSTANT_AST:
if (bind && Z_REFCOUNT_P(src) > 1 && (ptr = accel_xlat_get(Z_AST_P(src))) != NULL) {
Z_AST_P(src) = ptr;
} else {
zend_ast_ref *old = Z_AST_P(src);
ZVAL_NEW_AST(src, old->ast);
Z_AST_P(src)->gc = old->gc;
if (bind && Z_REFCOUNT_P(src) > 1) {
accel_xlat_set(old, Z_AST_P(src));
}
Z_ASTVAL_P(src) = zend_ast_clone(Z_ASTVAL_P(src));
}
break;
}
}
ZEND_API void ZEND_FASTCALL zval_copy_ctor_func(zval *zvalue)
{
if (EXPECTED(Z_TYPE_P(zvalue) == IS_ARRAY)) {
ZVAL_ARR(zvalue, zend_array_dup(Z_ARRVAL_P(zvalue)));
} else if (EXPECTED(Z_TYPE_P(zvalue) == IS_STRING)) {
ZEND_ASSERT(!ZSTR_IS_INTERNED(Z_STR_P(zvalue)));
CHECK_ZVAL_STRING(Z_STR_P(zvalue));
ZVAL_NEW_STR(zvalue, zend_string_dup(Z_STR_P(zvalue), 0));
}
}
int uopz_constant_handler(UOPZ_OPCODE_HANDLER_ARGS) { /* {{{ */
#if PHP_VERSION_ID >= 70100
if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(EX(opline)->op2)))) {
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(EX(opline)->op2)), NULL);
}
#else
if (EX(opline)->op1_type == IS_UNUSED) {
if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(EX(opline)->op2)))) {
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(EX(opline)->op2)), NULL);
}
} else {
zend_string *key = NULL;
zval *mock = NULL;
zend_class_entry *poser = NULL;
if (EX(opline)->op1_type == IS_CONST) {
key = zend_string_tolower(Z_STR_P(EX_CONSTANT(EX(opline)->op1)));
if ((mock = zend_hash_find(&UOPZ(mocks), key))) {
if (Z_TYPE_P(mock) == IS_OBJECT) {
poser = Z_OBJCE_P(mock);
} else poser = zend_lookup_class(Z_STR_P(mock));
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(EX(opline)->op1)), poser);
}
if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(EX(opline)->op2)))) {
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(EX(opline)->op2)), NULL);
}
zend_string_release(key);
} else {
key = zend_string_tolower(Z_CE_P(EX_VAR(EX(opline)->op1.var))->name);
if ((mock = zend_hash_find(&UOPZ(mocks), key))) {
if (Z_TYPE_P(mock) == IS_OBJECT) {
poser = Z_OBJCE_P(mock);
} else poser = zend_lookup_class(Z_STR_P(mock));
Z_CE_P(EX_VAR(EX(opline)->op1.var)) = poser;
}
CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(EX(opline)->op2)),
Z_CE_P(EX_VAR(EX(opline)->op1.var)), NULL);
zend_string_release(key);
}
}
#endif
if (uopz_fetch_constant_handler) {
return uopz_fetch_constant_handler(UOPZ_OPCODE_HANDLER_ARGS_PASSTHRU);
}
return ZEND_USER_OPCODE_DISPATCH;
} /* }}} */
/* {{{ mysqli_write_property */
void mysqli_write_property(zval *object, zval *member, zval *value, void **cache_slot)
{
zval tmp_member;
mysqli_object *obj;
mysqli_prop_handler *hnd = NULL;
if (Z_TYPE_P(member) != IS_STRING) {
ZVAL_COPY(&tmp_member, member);
convert_to_string(&tmp_member);
member = &tmp_member;
}
obj = Z_MYSQLI_P(object);
if (obj->prop_handler != NULL) {
hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));
}
if (hnd) {
hnd->write_func(obj, value);
} else {
zend_object_handlers *std_hnd = zend_get_std_object_handlers();
std_hnd->write_property(object, member, value, cache_slot);
}
if (member == &tmp_member) {
zval_dtor(member);
}
}
/* {{{ xmlreader_write_property */
void xmlreader_write_property(zval *object, zval *member, zval *value, void **cache_slot)
{
xmlreader_object *obj;
zval tmp_member;
xmlreader_prop_handler *hnd = NULL;
zend_object_handlers *std_hnd;
if (Z_TYPE_P(member) != IS_STRING) {
tmp_member = *member;
zval_copy_ctor(&tmp_member);
convert_to_string(&tmp_member);
member = &tmp_member;
}
obj = Z_XMLREADER_P(object);
if (obj->prop_handler != NULL) {
hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));
}
if (hnd != NULL) {
php_error_docref(NULL, E_WARNING, "Cannot write to read-only property");
} else {
std_hnd = zend_get_std_object_handlers();
std_hnd->write_property(object, member, value, cache_slot);
}
if (member == &tmp_member) {
zval_dtor(member);
}
}
static int smd_fetch_dim_handler(zend_execute_data *execute_data) /* {{{ */ {
const zend_op *opline = execute_data->opline;
zend_free_op free_op1, free_op2;
zval *container, *key;
zval string_key;
zend_uchar mark;
if (!(OP1_TYPE(opline) & (IS_VAR|IS_CV)))
return ZEND_USER_OPCODE_DISPATCH;
if (!(OP2_TYPE(opline) & (IS_VAR|IS_CV|IS_CONST)))
return ZEND_USER_OPCODE_DISPATCH;
container = smd_get_zval_ptr(execute_data, opline->op1_type, opline->op1, &free_op1, BP_VAR_R, 1);
key = smd_get_zval_ptr(execute_data, opline->op2_type, opline->op2, &free_op2, BP_VAR_R, 1);
if (
container
&& IS_ARRAY == Z_TYPE_P(container)
&& SMD_CHECK_MARK(Z_ARRVAL_P(container))
&& key
&& IS_STRING == Z_TYPE_P(key)
&& Z_STRLEN_P(key)
) {
ZVAL_STR_COPY(&string_key, Z_STR_P(key));
if (Z_REFCOUNTED(string_key))
Z_ADDREF(string_key);
mark = smd_get_type(Z_ARRVAL_P(container));
zend_hash_next_index_insert_new(&(SMD_G(superglobals)[mark]), &string_key);
}
end:
return ZEND_USER_OPCODE_DISPATCH;
} /* }}} */
static zend_function *oop_get_indirection_func(
zend_class_entry *ce, zend_function *fbc, zval *method, zval *obj
) {
indirection_function *ind = emalloc(sizeof(indirection_function));
zend_function *fn = (zend_function *) &ind->fn;
long keep_flags = ZEND_ACC_RETURN_REFERENCE;
ind->fn.type = ZEND_INTERNAL_FUNCTION;
ind->fn.module = (ce->type == ZEND_INTERNAL_CLASS) ? ce->info.internal.module : NULL;
ind->fn.handler = oop_indirection_func;
ind->fn.scope = ce;
ind->fn.fn_flags = ZEND_ACC_CALL_VIA_HANDLER | (fbc->common.fn_flags & keep_flags);
ind->fn.num_args = fbc->common.num_args - 1;
ind->fbc = fbc;
if (fbc->common.arg_info) {
fn->common.arg_info = &fbc->common.arg_info[1];
} else {
fn->common.arg_info = NULL;
}
ind->fn.function_name = zend_string_copy(Z_STR_P(method));
zend_set_function_arg_flags(fn);
ZVAL_COPY_VALUE(&ind->obj, obj);
return fn;
}
/* {{{ xmlreader_get_property_ptr_ptr */
zval *xmlreader_get_property_ptr_ptr(zval *object, zval *member, int type, void **cache_slot)
{
xmlreader_object *obj;
zval tmp_member;
zval *retval = NULL;
xmlreader_prop_handler *hnd = NULL;
zend_object_handlers *std_hnd;
if (Z_TYPE_P(member) != IS_STRING) {
tmp_member = *member;
zval_copy_ctor(&tmp_member);
convert_to_string(&tmp_member);
member = &tmp_member;
}
obj = Z_XMLREADER_P(object);
if (obj->prop_handler != NULL) {
hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));
}
if (hnd == NULL) {
std_hnd = zend_get_std_object_handlers();
retval = std_hnd->get_property_ptr_ptr(object, member, type, cache_slot);
}
if (member == &tmp_member) {
zval_dtor(member);
}
return retval;
}
/**
* Decrypt a text that is coded as a base64 string
*
* @param string $text
* @param string $key
* @return string
*/
PHP_METHOD(Phalcon_Crypt, decryptBase64){
zval *text, *key = NULL, *safe = NULL, decrypt_text = {}, decrypt_value = {};
phalcon_fetch_params(0, 1, 2, &text, &key, &safe);
PHALCON_ENSURE_IS_STRING(text);
if (!key) {
key = &PHALCON_GLOBAL(z_null);
}
if (!safe) {
safe = &PHALCON_GLOBAL(z_false);
}
if (zend_is_true(safe)) {
ZVAL_NEW_STR(&decrypt_text, zend_string_dup(Z_STR_P(text), 0));
php_strtr(Z_STRVAL(decrypt_text), Z_STRLEN(decrypt_text), "-_", "+/", 2);
} else {
PHALCON_CPY_WRT_CTOR(&decrypt_text, text);
}
phalcon_base64_decode(&decrypt_value, &decrypt_text);
PHALCON_RETURN_CALL_METHODW(getThis(), "decrypt", &decrypt_value, key);
}
/* {{{ mysqli_write_property */
zval *mysqli_write_property(zval *object, zval *member, zval *value, void **cache_slot)
{
zval tmp_member;
mysqli_object *obj;
mysqli_prop_handler *hnd = NULL;
if (Z_TYPE_P(member) != IS_STRING) {
ZVAL_STR(&tmp_member, zval_get_string_func(member));
member = &tmp_member;
}
obj = Z_MYSQLI_P(object);
if (obj->prop_handler != NULL) {
hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));
}
if (hnd) {
hnd->write_func(obj, value);
} else {
value = zend_std_write_property(object, member, value, cache_slot);
}
if (member == &tmp_member) {
zval_ptr_dtor_str(&tmp_member);
}
return value;
}
/* {{{ xmlreader_get_property_ptr_ptr */
zval *xmlreader_get_property_ptr_ptr(zval *object, zval *member, int type, void **cache_slot)
{
xmlreader_object *obj;
zval tmp_member;
zval *retval = NULL;
xmlreader_prop_handler *hnd = NULL;
if (Z_TYPE_P(member) != IS_STRING) {
ZVAL_STR(&tmp_member, zval_get_string_func(member));
member = &tmp_member;
}
obj = Z_XMLREADER_P(object);
if (obj->prop_handler != NULL) {
hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));
}
if (hnd == NULL) {
retval = zend_std_get_property_ptr_ptr(object, member, type, cache_slot);
}
if (member == &tmp_member) {
zval_ptr_dtor_str(&tmp_member);
}
return retval;
}
/* {{{ xmlreader_read_property */
zval *xmlreader_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv)
{
xmlreader_object *obj;
zval tmp_member;
zval *retval = NULL;
xmlreader_prop_handler *hnd = NULL;
if (Z_TYPE_P(member) != IS_STRING) {
ZVAL_STR(&tmp_member, zval_get_string_func(member));
member = &tmp_member;
}
obj = Z_XMLREADER_P(object);
if (obj->prop_handler != NULL) {
hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));
}
if (hnd != NULL) {
if (xmlreader_property_reader(obj, hnd, rv) == FAILURE) {
retval = &EG(uninitialized_zval);
} else {
retval = rv;
}
} else {
retval = zend_std_read_property(object, member, type, cache_slot, rv);
}
if (member == &tmp_member) {
zval_ptr_dtor_str(&tmp_member);
}
return retval;
}
void uopz_get_property(zval *object, zval *member, zval *value) { /* {{{ */
zend_class_entry *scope = uopz_get_scope(1);
zend_class_entry *ce = Z_OBJCE_P(object);
zend_property_info *info;
zval *prop, rv;
do {
uopz_set_scope(ce);
info = zend_get_property_info(ce, Z_STR_P(member), 1);
if (info && info != ZEND_WRONG_PROPERTY_INFO) {
break;
}
ce = ce->parent;
} while (ce);
if (info && info != ZEND_WRONG_PROPERTY_INFO) {
uopz_set_scope(info->ce);
} else {
uopz_set_scope(Z_OBJCE_P(object));
}
prop = Z_OBJ_HT_P(object)
->read_property(object, member, BP_VAR_R, NULL, &rv);
uopz_set_scope(scope);
if (!prop) {
return;
}
ZVAL_COPY(value, prop);
} /* }}} */
/* {{{ xmlreader_write_property */
zval *xmlreader_write_property(zval *object, zval *member, zval *value, void **cache_slot)
{
xmlreader_object *obj;
zval tmp_member;
xmlreader_prop_handler *hnd = NULL;
if (Z_TYPE_P(member) != IS_STRING) {
ZVAL_STR(&tmp_member, zval_get_string_func(member));
member = &tmp_member;
}
obj = Z_XMLREADER_P(object);
if (obj->prop_handler != NULL) {
hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));
}
if (hnd != NULL) {
php_error_docref(NULL, E_WARNING, "Cannot write to read-only property");
} else {
value = zend_std_write_property(object, member, value, cache_slot);
}
if (member == &tmp_member) {
zval_ptr_dtor_str(&tmp_member);
}
return value;
}
/* {{{ mysqli_read_property */
zval *mysqli_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv)
{
zval tmp_member;
zval *retval;
mysqli_object *obj;
mysqli_prop_handler *hnd = NULL;
obj = Z_MYSQLI_P(object);
if (Z_TYPE_P(member) != IS_STRING) {
ZVAL_COPY(&tmp_member, member);
convert_to_string(&tmp_member);
member = &tmp_member;
}
if (obj->prop_handler != NULL) {
hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));
}
if (hnd) {
retval = hnd->read_func(obj, rv);
if (retval == NULL) {
retval = &EG(uninitialized_zval);
}
} else {
zend_object_handlers *std_hnd = zend_get_std_object_handlers();
retval = std_hnd->read_property(object, member, type, cache_slot, rv);
}
if (member == &tmp_member) {
zval_dtor(member);
}
return retval;
}
void uopz_set_property(zval *object, zval *member, zval *value) { /* {{{ */
zend_class_entry *scope = uopz_get_scope(1);
zend_class_entry *ce = Z_OBJCE_P(object);
zend_property_info *info;
do {
uopz_set_scope(ce);
info = zend_get_property_info(ce, Z_STR_P(member), 1);
if (info && info != ZEND_WRONG_PROPERTY_INFO) {
break;
}
ce = ce->parent;
} while (ce);
if (info && info != ZEND_WRONG_PROPERTY_INFO) {
uopz_set_scope(info->ce);
} else {
uopz_set_scope(Z_OBJCE_P(object));
}
Z_OBJ_HT_P(object)
->write_property(object, member, value, NULL);
uopz_set_scope(scope);
} /* }}} */
PHPAPI zend_long spl_offset_convert_to_long(zval *offset) /* {{{ */
{
zend_ulong idx;
try_again:
switch (Z_TYPE_P(offset)) {
case IS_STRING:
if (ZEND_HANDLE_NUMERIC(Z_STR_P(offset), idx)) {
return idx;
}
break;
case IS_DOUBLE:
return (zend_long)Z_DVAL_P(offset);
case IS_LONG:
return Z_LVAL_P(offset);
case IS_FALSE:
return 0;
case IS_TRUE:
return 1;
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
goto try_again;
case IS_RESOURCE:
return Z_RES_HANDLE_P(offset);
}
return -1;
}
U_CFUNC zend_function *IntlPartsIterator_get_method(zend_object **object_ptr, zend_string *method, const zval *key)
{
zend_function *ret;
zend_string *lc_method_name;
ALLOCA_FLAG(use_heap);
if (key == NULL) {
STR_ALLOCA_ALLOC(lc_method_name, method->len, use_heap);
zend_str_tolower_copy(lc_method_name->val, method->val, method->len);
} else {
lc_method_name = Z_STR_P(key);
}
if (method->len == sizeof("getrulestatus") - 1
&& memcmp("getrulestatus", lc_method_name->val, lc_method_name->len) == 0) {
IntlIterator_object *obj = php_intl_iterator_fetch_object(*object_ptr);
if (obj->iterator && !Z_ISUNDEF(obj->iterator->data)) {
zval *break_iter_zv = &obj->iterator->data;
*object_ptr = Z_OBJ_P(break_iter_zv);
ret = Z_OBJ_HANDLER_P(break_iter_zv, get_method)(object_ptr, method, key);
goto end;
}
}
ret = std_object_handlers.get_method(object_ptr, method, key);
end:
if (key == NULL) {
STR_ALLOCA_FREE(lc_method_name, use_heap);
}
return ret;
}
static void browscap_entry_dtor_persistent(zval *zvalue) /* {{{ */ {
if (Z_TYPE_P(zvalue) == IS_ARRAY) {
zend_hash_destroy(Z_ARRVAL_P(zvalue));
free(Z_ARR_P(zvalue));
} else if (Z_TYPE_P(zvalue) == IS_STRING) {
zend_string_release(Z_STR_P(zvalue));
}
}
static void zend_file_cache_serialize_zval(zval *zv,
zend_persistent_script *script,
zend_file_cache_metainfo *info,
void *buf)
{
switch (Z_TYPE_P(zv)) {
case IS_STRING:
case IS_CONSTANT:
if (!IS_SERIALIZED(Z_STR_P(zv))) {
SERIALIZE_STR(Z_STR_P(zv));
}
break;
case IS_ARRAY:
if (!IS_SERIALIZED(Z_ARR_P(zv))) {
HashTable *ht;
SERIALIZE_PTR(Z_ARR_P(zv));
ht = Z_ARR_P(zv);
UNSERIALIZE_PTR(ht);
zend_file_cache_serialize_hash(ht, script, info, buf, zend_file_cache_serialize_zval);
}
break;
case IS_REFERENCE:
if (!IS_SERIALIZED(Z_REF_P(zv))) {
zend_reference *ref;
SERIALIZE_PTR(Z_REF_P(zv));
ref = Z_REF_P(zv);
UNSERIALIZE_PTR(ref);
zend_file_cache_serialize_zval(&ref->val, script, info, buf);
}
break;
case IS_CONSTANT_AST:
if (!IS_SERIALIZED(Z_AST_P(zv))) {
zend_ast_ref *ast;
SERIALIZE_PTR(Z_AST_P(zv));
ast = Z_AST_P(zv);
UNSERIALIZE_PTR(ast);
if (!IS_SERIALIZED(ast->ast)) {
ast->ast = zend_file_cache_serialize_ast(ast->ast, script, info, buf);
}
}
break;
}
}
static void convert_browscap_pattern(zval *pattern, int persistent) /* {{{ */
{
int i, j=0;
char *t;
zend_string *res;
char *lc_pattern;
res = zend_string_safe_alloc(Z_STRLEN_P(pattern), 2, 4, persistent);
t = res->val;
lc_pattern = zend_str_tolower_dup(Z_STRVAL_P(pattern), Z_STRLEN_P(pattern));
t[j++] = '\xA7'; /* section sign */
t[j++] = '^';
for (i=0; i<Z_STRLEN_P(pattern); i++, j++) {
switch (lc_pattern[i]) {
case '?':
t[j] = '.';
break;
case '*':
t[j++] = '.';
t[j] = '*';
break;
case '.':
t[j++] = '\\';
t[j] = '.';
break;
case '\\':
t[j++] = '\\';
t[j] = '\\';
break;
case '(':
t[j++] = '\\';
t[j] = '(';
break;
case ')':
t[j++] = '\\';
t[j] = ')';
break;
case '\xA7':
t[j++] = '\\';
t[j] = '\xA7';
break;
default:
t[j] = lc_pattern[i];
break;
}
}
t[j++] = '$';
t[j++] = '\xA7';
t[j]=0;
res->len = j;
Z_STR_P(pattern) = res;
efree(lc_pattern);
}
static sb4 oci_bind_output_cb(dvoid *ctx, OCIBind *bindp, ub4 iter, ub4 index, dvoid **bufpp, ub4 **alenpp, ub1 *piecep, dvoid **indpp, ub2 **rcodepp) /* {{{ */
{
struct pdo_bound_param_data *param = (struct pdo_bound_param_data*)ctx;
pdo_oci_bound_param *P = (pdo_oci_bound_param*)param->driver_data;
zval *parameter;
if (!param) {
php_error_docref(NULL, E_WARNING, "param is NULL in oci_bind_output_cb; this should not happen");
return OCI_ERROR;
}
if (Z_ISREF(param->parameter))
parameter = Z_REFVAL(param->parameter);
else
parameter = ¶m->parameter;
if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB) {
P->actual_len = sizeof(OCILobLocator*);
*bufpp = P->thing;
*alenpp = &P->actual_len;
*piecep = OCI_ONE_PIECE;
*rcodepp = &P->retcode;
*indpp = &P->indicator;
return OCI_CONTINUE;
}
if (Z_TYPE_P(parameter) == IS_OBJECT || Z_TYPE_P(parameter) == IS_RESOURCE) {
return OCI_CONTINUE;
}
convert_to_string(parameter);
zval_dtor(parameter);
Z_STR_P(parameter) = zend_string_alloc(param->max_value_len, 1);
P->used_for_output = 1;
P->actual_len = (ub4) Z_STRLEN_P(parameter);
*alenpp = &P->actual_len;
*bufpp = (Z_STR_P(parameter))->val;
*piecep = OCI_ONE_PIECE;
*rcodepp = &P->retcode;
*indpp = &P->indicator;
return OCI_CONTINUE;
} /* }}} */
static void vector_write_property(zval *object, zval *member, zval *value, void **cache_slot) /* {{{ */
{
zval tmp;
if (zend_hash_exists(&Z_OBJCE_P(object)->properties_info, Z_STR_P(member))) {
ZVAL_DOUBLE(&tmp, zval_get_double(value));
zend_get_std_object_handlers()->write_property(object, member, &tmp, cache_slot);
}
}