/* {{{ 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;
}
/**
* Sets values
*
* @param array $arrayConfig
*/
PHP_METHOD(Phalcon_Config, val){
zval *array_config, *value;
zend_string *str_key;
ulong idx;
phalcon_fetch_params(0, 1, 0, &array_config);
/**
* Throw exceptions if bad parameters are passed
*/
if (Z_TYPE_P(array_config) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_config_exception_ce, "The configuration must be an Array");
return;
}
ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(array_config), idx, str_key, value) {
zval key;
if (str_key) {
ZVAL_STR(&key, str_key);
} else {
ZVAL_LONG(&key, idx);
}
PHALCON_CALL_SELFW(NULL, "offsetset", &key, value);
} ZEND_HASH_FOREACH_END();
/* {{{ 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;
}
static inline void drop_leading_backslash(zval *val) {
if (Z_STRVAL_P(val)[0] == '\\') {
zend_string *str = zend_string_init(Z_STRVAL_P(val) + 1, Z_STRLEN_P(val) - 1, 0);
zval_dtor(val);
ZVAL_STR(val, str);
}
}
/* {{{ 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_STR(&tmp_member, zval_get_string_func(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 {
retval = zend_std_read_property(object, member, type, cache_slot, rv);
}
if (member == &tmp_member) {
zval_ptr_dtor_str(&tmp_member);
}
return retval;
}
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Apc, reset)
{
zval *real_key = NULL, *meta;
zend_string *str_key;
ulong idx;
PHALCON_MM_GROW();
meta = phalcon_read_property(getThis(), SL("_metaData"), PH_NOISY);
if (Z_TYPE_P(meta) == IS_ARRAY) {
zval *prefix = phalcon_read_property(getThis(), SL("_prefix"), PH_NOISY);
ZEND_HASH_FOREACH_KEY(Z_ARRVAL_P(meta), idx, str_key) {
zval key;
if (str_key) {
ZVAL_STR(&key, str_key);
} else {
ZVAL_LONG(&key, idx);
}
PHALCON_INIT_NVAR(real_key);
phalcon_concat_svsv(real_key, SL("$PMM$"), prefix, SL("meta-"), &key, 0);
PHALCON_CALL_FUNCTION(NULL, "apc_delete", real_key);
} ZEND_HASH_FOREACH_END();
static inline void ast_update_property(zval *object, zend_string *name, zval *value, void **cache_slot) {
zval name_zv;
ZVAL_STR(&name_zv, name);
Z_TRY_DELREF_P(value);
Z_OBJ_HT_P(object)->write_property(object, &name_zv, value, cache_slot);
}
static
void binary_serialize_hashtable_key(int8_t keytype, PHPOutputTransport& transport, HashTable* ht, HashPosition& ht_pos) {
bool keytype_is_numeric = (!((keytype == T_STRING) || (keytype == T_UTF8) || (keytype == T_UTF16)));
zend_string* key;
uint key_len;
long index = 0;
zval z;
int res = zend_hash_get_current_key_ex(ht, &key, (zend_ulong*)&index, &ht_pos);
if (keytype_is_numeric) {
if (res == HASH_KEY_IS_STRING) {
index = strtol(ZSTR_VAL(key), nullptr, 10);
}
ZVAL_LONG(&z, index);
} else {
char buf[64];
if (res == HASH_KEY_IS_STRING) {
ZVAL_STR(&z, key);
} else {
snprintf(buf, 64, "%ld", index);
ZVAL_STRING(&z, buf);
}
}
binary_serialize(keytype, transport, &z, nullptr);
zval_dtor(&z);
}
/* {{{ 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;
}
/* {{{ property link_stat_read */
static zval *link_stat_read(mysqli_object *obj, zval *retval)
{
MY_MYSQL *mysql;
ZVAL_NULL(retval);
#if defined(MYSQLI_USE_MYSQLND)
CHECK_STATUS(MYSQLI_STATUS_INITIALIZED);
#else
CHECK_STATUS(MYSQLI_STATUS_VALID);
#endif
mysql = (MY_MYSQL *)((MYSQLI_RESOURCE *)(obj->ptr))->ptr;
if (mysql) {
#if defined(MYSQLI_USE_MYSQLND)
zend_string * stat_msg;
if (mysqlnd_stat(mysql->mysql, &stat_msg) == PASS) {
ZVAL_STR(retval, stat_msg);
}
#else
char * stat_msg;
if ((stat_msg = (char *)mysql_stat(mysql->mysql))) {
ZVAL_STRING(retval, stat_msg);
}
#endif
}
return retval;
}
static void zend_closure_call_magic(INTERNAL_FUNCTION_PARAMETERS) /* {{{ */ {
zend_fcall_info fci;
zend_fcall_info_cache fcc;
zval params[2];
memset(&fci, 0, sizeof(zend_fcall_info));
memset(&fci, 0, sizeof(zend_fcall_info_cache));
fci.size = sizeof(zend_fcall_info);
fci.retval = return_value;
fcc.initialized = 1;
fcc.function_handler = (zend_function *) EX(func)->common.arg_info;
fci.params = params;
fci.param_count = 2;
ZVAL_STR(&fci.params[0], EX(func)->common.function_name);
array_init(&fci.params[1]);
zend_copy_parameters_array(ZEND_NUM_ARGS(), &fci.params[1]);
fci.object = Z_OBJ(EX(This));
fcc.object = Z_OBJ(EX(This));
fcc.calling_scope = zend_get_executed_scope();
zend_call_function(&fci, &fcc);
zval_ptr_dtor(&fci.params[0]);
zval_ptr_dtor(&fci.params[1]);
}
static inline int msgpack_convert_string_to_properties(zval *object, zend_string *key, zval *val, HashTable *var)/* {{{ */ {
zend_class_entry *ce = Z_OBJCE_P(object);
HashTable *propers = Z_OBJPROP_P(object);
zend_string *prot_name, *priv_name;
zval pub_name;
int return_code;
ZVAL_STR(&pub_name, key);
priv_name = zend_mangle_property_name(ZSTR_VAL(ce->name), ZSTR_LEN(ce->name), ZSTR_VAL(key), ZSTR_LEN(key), 1);
prot_name = zend_mangle_property_name("*", 1, ZSTR_VAL(key), ZSTR_LEN(key), 1);
if (zend_hash_find(propers, priv_name) != NULL) {
zend_update_property_ex(ce, object, key, val);
return_code = SUCCESS;
} else if (zend_hash_find(propers, prot_name) != NULL) {
zend_update_property_ex(ce, object, key, val);
return_code = SUCCESS;
} else {
zend_std_write_property(object, &pub_name, val, NULL);
return_code = FAILURE;
}
zend_hash_add(var, Z_STR(pub_name), val);
zend_string_release(priv_name);
zend_string_release(prot_name);
return return_code;
}
/* {{{ */
zend_bool pthreads_globals_init(){
if (!PTHREADS_G(init)&&!PTHREADS_G(failed)) {
PTHREADS_G(init)=1;
if (!(PTHREADS_G(monitor)=pthreads_monitor_alloc()))
PTHREADS_G(failed)=1;
if (PTHREADS_G(failed)) {
PTHREADS_G(init)=0;
} else {
zend_hash_init(
&PTHREADS_G(objects), 64, NULL, (dtor_func_t) NULL, 1);
zend_hash_init(
&PTHREADS_G(gstrings), 64, NULL, (dtor_func_t) NULL, 1);
}
#define INIT_STRING(n, v) PTHREADS_G(strings).n = zend_string_init(v, 1)
INIT_STRING(run, ZEND_STRL("run"));
INIT_STRING(session.cache_limiter, ZEND_STRL("cache_limiter"));
INIT_STRING(session.use_cookies, ZEND_STRL("use_cookies"));
#undef INIT_STRING
ZVAL_STR(&PTHREADS_G(strings).worker, zend_string_init(ZEND_STRL("worker"), 1));
return PTHREADS_G(init);
} else return 0;
} /* }}} */
static HashTable *browscap_entry_to_array(browser_data *bdata, browscap_entry *entry) {
zval tmp;
uint32_t i;
HashTable *ht;
ALLOC_HASHTABLE(ht);
zend_hash_init(ht, 8, NULL, ZVAL_PTR_DTOR, 0);
ZVAL_STR(&tmp, browscap_convert_pattern(entry->pattern, 0));
zend_hash_str_add(ht, "browser_name_regex", sizeof("browser_name_regex")-1, &tmp);
ZVAL_STR_COPY(&tmp, entry->pattern);
zend_hash_str_add(ht, "browser_name_pattern", sizeof("browser_name_pattern")-1, &tmp);
if (entry->parent) {
ZVAL_STR_COPY(&tmp, entry->parent);
zend_hash_str_add(ht, "parent", sizeof("parent")-1, &tmp);
}
for (i = entry->kv_start; i < entry->kv_end; i++) {
ZVAL_STR_COPY(&tmp, bdata->kv[i].value);
zend_hash_add(ht, bdata->kv[i].key, &tmp);
}
return ht;
}
static ZEND_NAMED_FUNCTION(zend_closure_call_magic) /* {{{ */ {
zend_fcall_info fci;
zend_fcall_info_cache fcc;
zval params[2];
memset(&fci, 0, sizeof(zend_fcall_info));
memset(&fcc, 0, sizeof(zend_fcall_info_cache));
fci.size = sizeof(zend_fcall_info);
fci.retval = return_value;
fcc.function_handler = (zend_function *) EX(func)->common.arg_info;
fci.params = params;
fci.param_count = 2;
ZVAL_STR(&fci.params[0], EX(func)->common.function_name);
if (ZEND_NUM_ARGS()) {
array_init_size(&fci.params[1], ZEND_NUM_ARGS());
zend_copy_parameters_array(ZEND_NUM_ARGS(), &fci.params[1]);
} else {
ZVAL_EMPTY_ARRAY(&fci.params[1]);
}
fci.object = Z_OBJ(EX(This));
fcc.object = Z_OBJ(EX(This));
zend_call_function(&fci, &fcc);
zval_ptr_dtor(&fci.params[0]);
zval_ptr_dtor(&fci.params[1]);
}
/* {{{ 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;
}
/**
* Writes parsed annotations to files
*
* @param string $key
* @param Phalcon\Annotations\Reflection $data
*/
PHP_METHOD(Phalcon_Annotations_Adapter_Files, write){
zval *key, *data, annotations_dir = {}, virtual_key = {}, path = {}, php_export = {}, status = {};
smart_str exp = { 0 };
phalcon_fetch_params(0, 2, 0, &key, &data);
PHALCON_ENSURE_IS_STRING(key);
phalcon_return_property(&annotations_dir, getThis(), SL("_annotationsDir"));
/**
* Paths must be normalized before be used as keys
*/
phalcon_prepare_virtual_path_ex(&virtual_key, Z_STRVAL_P(key), Z_STRLEN_P(key), '_');
PHALCON_CONCAT_VVS(&path, &annotations_dir, &virtual_key, ".php");
smart_str_appends(&exp, "<?php return ");
php_var_export_ex(data, 0, &exp);
smart_str_appendc(&exp, ';');
smart_str_0(&exp);
ZVAL_STR(&php_export, exp.s);
phalcon_file_put_contents(&status, &path, &php_export);
if (PHALCON_IS_FALSE(&status)) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_annotations_exception_ce, "Annotations directory cannot be written");
return;
}
}
/* {{{ my_serialize_object */
static zval* my_serialize_object(zval* dst, const zval* src, apc_context_t* ctxt)
{
unsigned char *buf = NULL;
size_t buf_len = 0;
apc_pool* pool = ctxt->pool;
apc_serialize_t serialize = APC_SERIALIZER_NAME(php);
void *config = NULL;
zend_string *serial = NULL;
if(ctxt->serializer) {
serialize = ctxt->serializer->serialize;
config =
(ctxt->serializer->config != NULL) ?
ctxt->serializer->config : ctxt;
}
ZVAL_NULL(dst);
if(serialize((unsigned char**)&buf, &buf_len, src, config)) {
if (!(serial = apc_pstrnew(buf, buf_len, pool))) {
efree(buf);
return dst;
}
ZVAL_STR(dst, serial);
Z_TYPE_INFO_P(dst) = IS_OBJECT;
efree(buf);
}
return dst;
}
/**
* var_export returns php variables without using the PHP userland
*/
void phalcon_var_export_ex(zval *return_value, zval *var) {
smart_str buf = { 0 };
php_var_export_ex(var, 1, &buf);
smart_str_0(&buf);
ZVAL_STR(return_value, buf.s);
}
ZEND_API void zend_register_stringl_constant(const char *name, size_t name_len, char *strval, size_t strlen, int flags, int module_number)
{
zend_constant c;
ZVAL_STR(&c.value, zend_string_init_interned(strval, strlen, flags & CONST_PERSISTENT));
ZEND_CONSTANT_SET_FLAGS(&c, flags, module_number);
c.name = zend_string_init_interned(name, name_len, flags & CONST_PERSISTENT);
zend_register_constant(&c);
}
ZEND_API int zend_make_printable_zval(zval *expr, zval *expr_copy) /* {{{ */
{
if (Z_TYPE_P(expr) == IS_STRING) {
return 0;
} else {
ZVAL_STR(expr_copy, _zval_get_string_func(expr));
return 1;
}
}
void zephir_basename(zval *return_value, zval *path)
{
if (EXPECTED(Z_TYPE_P(path) == IS_STRING)) {
zend_string *ret;
ret = php_basename(Z_STRVAL_P(path), Z_STRLEN_P(path), NULL, 0);
ZVAL_STR(return_value, ret);
} else {
ZVAL_FALSE(return_value);
}
}
static void _xml_xmlchar_zval(const XML_Char *s, int len, const XML_Char *encoding, zval *ret)
{
if (s == NULL) {
ZVAL_FALSE(ret);
return;
}
if (len == 0) {
len = _xml_xmlcharlen(s);
}
ZVAL_STR(ret, xml_utf8_decode(s, len, encoding));
}
static void phalcon_mvc_router_group_add_helper(INTERNAL_FUNCTION_PARAMETERS, zend_string *method)
{
zval *pattern, *paths = NULL, http_method = {};
phalcon_fetch_params(0, 1, 1, &pattern, &paths);
if (!paths) {
paths = &PHALCON_GLOBAL(z_null);
}
ZVAL_STR(&http_method, method);
PHALCON_RETURN_CALL_METHODW(getThis(), "_addroute", pattern, paths, &http_method);
}
static int http_on_message_complete(http_parser *parser)
{
skyray_http_protocol_t *protocol = (skyray_http_protocol_t *)parser;
skyray_http_request_t *req = skyray_http_request_from_obj(protocol->req);
if (skyray_buffer_initialized(&protocol->body)) {
ZVAL_STR(&req->message.raw_body, protocol->body.buf);
}
skyray_http_protocol_on_request(protocol);
return 0;
}
HashTable *mysqli_object_get_debug_info(zval *object, int *is_temp)
{
mysqli_object *obj = Z_MYSQLI_P(object);
HashTable *retval, *props = obj->prop_handler;
mysqli_prop_handler *entry;
retval = zend_new_array(zend_hash_num_elements(props) + 1);
ZEND_HASH_FOREACH_PTR(props, entry) {
zval rv, member;
zval *value;
ZVAL_STR(&member, entry->name);
value = mysqli_read_property(object, &member, BP_VAR_IS, 0, &rv);
if (value != &EG(uninitialized_zval)) {
zend_hash_add(retval, Z_STR(member), value);
}
} ZEND_HASH_FOREACH_END();
SKYRAY_METHOD(HttpRequest, setUri)
{
zend_string *uri;
int i;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &uri) == FAILURE) {
return;
}
skyray_http_request_t *intern = skyray_http_request_from_obj(Z_OBJ_P(getThis()));
zval_dtor(&intern->uri);
ZVAL_STR(&intern->uri, uri);
zval_addref_p(&intern->uri);
RETURN_ZVAL(getThis(), 1, 0);
}
int php_ds_default_cast_object(zval *obj, zval *return_value, int type)
{
switch (type) {
case IS_STRING: {
smart_str buffer = {0};
smart_str_appendl(&buffer, "object(", 7);
smart_str_append (&buffer, Z_OBJCE_P(obj)->name);
smart_str_appendc(&buffer, ')');
smart_str_0(&buffer);
ZVAL_STR(return_value, buffer.s);
return SUCCESS;
}
}
return FAILURE;
}
void skyray_promise_then(skyray_promise_t *self, zval *on_fulfilled, zval *on_rejected, zval *retval)
{
zval *result, params[2], function_name;
if (Z_TYPE(self->result) != IS_UNDEF) {
result = skyray_promise_unwrap(self);
ZVAL_NULL(¶ms[0]);
ZVAL_NULL(¶ms[1]);
ZVAL_STR(&function_name, intern_str_then);
if (on_fulfilled) {
ZVAL_COPY_VALUE(¶ms[0], on_fulfilled);
}
if (on_rejected) {
ZVAL_COPY_VALUE(¶ms[1], on_rejected);
}
call_user_function(NULL, result, &function_name, retval, 2, params);
assert(EG(exception) == NULL);
} else {
object_init_ex(retval, skyray_ce_Promise);
skyray_promise_t *promise = skyray_promise_from_obj(Z_OBJ_P(retval));
promise_resolve_context_t *context;
if (on_fulfilled != NULL && !ZVAL_IS_NULL(on_fulfilled)) {
context = promise_resolve_context_create(promise, on_fulfilled, NULL);
} else {
context = promise_resolve_context_create(promise, NULL, self);
}
zend_hash_next_index_insert_ptr(&self->on_fulfilled, context);
if (on_rejected != NULL && !ZVAL_IS_NULL(on_rejected)) {
context = promise_resolve_context_create(promise, on_rejected, NULL);
} else {
context = promise_resolve_context_create(promise, NULL, self);
}
zend_hash_next_index_insert_ptr(&self->on_rejcted, context);
}
}
static int http_on_headers_complete(http_parser *parser)
{
skyray_http_protocol_t *protocol = (skyray_http_protocol_t *)parser;
skyray_http_request_t *req = skyray_http_request_from_obj(protocol->req);
if (skyray_buffer_initialized(&protocol->header_value)) {
skyray_http_message_add_header(&req->message, protocol->header_name.buf, protocol->header_value.buf, 0);
skyray_buffer_release(&protocol->header_name);
skyray_buffer_reset(&protocol->header_value);
}
ZVAL_STR(&req->uri, protocol->uri.buf);
req->method = parser->method;
req->message.version_major = parser->http_major;
req->message.version_minor = parser->http_minor;
return 0;
}
