/**
* Sends the headers to the client
*
* @return boolean
*/
PHP_METHOD(Phalcon_Http_Response_Headers, send){
zval *headers_was_sent, *t, *headers, *value = NULL, *header = NULL;
zval *http_header = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(headers_was_sent);
PHALCON_CALL_FUNC(headers_was_sent, "headers_sent");
if (!zend_is_true(headers_was_sent)) {
PHALCON_INIT_VAR(t);
ZVAL_BOOL(t, 1);
PHALCON_INIT_VAR(headers);
phalcon_read_property(&headers, this_ptr, SL("_headers"), PH_NOISY_CC);
if (!phalcon_valid_foreach(headers TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(headers);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) {
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_KEY(header, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (zend_is_true(value)) {
PHALCON_INIT_NVAR(http_header);
PHALCON_CONCAT_VSV(http_header, header, ": ", value);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("header", http_header, t);
} else {
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("header", header, t);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
/**
* Sends/Writes messages to the file log
*
* @param string $message
* @param int $type
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, log){
zval *message = NULL, *type = NULL, *msg = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL;
zval *c0 = NULL;
zval *i0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &message, &type) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_fileHandler", sizeof("_fileHandler")-1, PHALCON_NOISY TSRMLS_CC);
if (!zend_is_true(t0)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "Cannot send message to the log because it is invalid");
return;
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_FUNC_PARAMS_1(r0, "is_scalar", message, 0x045);
if (zend_is_true(r0)) {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_INIT_VAR(c0);
ZVAL_BOOL(c0, 1);
PHALCON_CALL_FUNC_PARAMS_2(r1, "print_r", message, c0, 0x008);
PHALCON_CPY_WRT(msg, r1);
}
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_transaction", sizeof("_transaction")-1, PHALCON_NOISY TSRMLS_CC);
if (zend_is_true(t1)) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_logger_item_ce);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CALL_FUNC(r2, "time", 0x018);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(i0, "__construct", message, type, r2, PHALCON_CHECK);
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_quenue", sizeof("_quenue")-1, PHALCON_NOISY TSRMLS_CC);
phalcon_array_append(&t2, i0, PHALCON_NO_SEPARATE_THX TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_quenue", strlen("_quenue"), t2 TSRMLS_CC);
} else {
PHALCON_ALLOC_ZVAL_MM(t3);
phalcon_read_property(&t3, this_ptr, "_fileHandler", sizeof("_fileHandler")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CALL_METHOD_PARAMS_2(r4, this_ptr, "_applyformat", message, type, PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(t4);
zend_get_constant("PHP_EOL", strlen("PHP_EOL"), t4 TSRMLS_CC);
PHALCON_CONCAT_VV(r3, r4, t4);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("fputs", t3, r3, 0x04F);
}
PHALCON_MM_RESTORE();
}
/**
* Renders a view using the template engine
*
* @param string $path
* @param array $params
* @param bool $mustClean
*/
PHP_METHOD(Phalcon_Mvc_View_Engine_Php, render){
zval *path = NULL, *params = NULL, *must_clean = NULL, *value = NULL, *key = NULL, *contents = NULL;
zval *view = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &path, ¶ms, &must_clean) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(must_clean) == IS_BOOL && Z_BVAL_P(must_clean)) {
PHALCON_CALL_FUNC_NORETURN("ob_clean");
}
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_1897_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_1897_0;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
if (phalcon_set_symbol(key, value TSRMLS_CC) == FAILURE){
return;
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_1897_0;
fee_1897_0:
if (phalcon_require(path TSRMLS_CC) == FAILURE) {
return;
}
if (Z_TYPE_P(must_clean) == IS_BOOL && Z_BVAL_P(must_clean)) {
PHALCON_INIT_VAR(contents);
PHALCON_CALL_FUNC(contents, "ob_get_contents");
PHALCON_INIT_VAR(view);
phalcon_read_property(&view, this_ptr, SL("_view"), PH_NOISY_CC);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(view, "setcontent", contents, PH_NO_CHECK);
}
PHALCON_MM_RESTORE();
}
/**
* Applies the internal format to the message
*
* @param string $message
* @param int $type
* @param int $time
* @return string
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, _applyFormat){
zval *message = NULL, *type = NULL, *time = NULL, *format = NULL, *date_format = NULL;
zval *date = NULL, *new_format = NULL, *type_string = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &message, &type, &time) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!time) {
PHALCON_ALLOC_ZVAL_MM(time);
ZVAL_LONG(time, 0);
} else {
PHALCON_SEPARATE_PARAM(time);
}
if (!zend_is_true(time)) {
PHALCON_INIT_VAR(time);
PHALCON_CALL_FUNC(time, "time");
}
PHALCON_INIT_VAR(format);
phalcon_read_property(&format, this_ptr, SL("_format"), PH_NOISY_CC);
PHALCON_INIT_VAR(date_format);
phalcon_read_property(&date_format, this_ptr, SL("_dateFormat"), PH_NOISY_CC);
PHALCON_INIT_VAR(date);
PHALCON_CALL_FUNC_PARAMS_2(date, "date", date_format, time);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "%date%", 1);
PHALCON_INIT_VAR(new_format);
phalcon_fast_str_replace(new_format, c0, date, format TSRMLS_CC);
PHALCON_INIT_VAR(type_string);
PHALCON_CALL_METHOD_PARAMS_1(type_string, this_ptr, "gettypestring", type, PH_NO_CHECK);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "%type%", 1);
PHALCON_INIT_VAR(format);
phalcon_fast_str_replace(format, c1, type_string, new_format TSRMLS_CC);
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, "%message%", 1);
PHALCON_INIT_VAR(new_format);
phalcon_fast_str_replace(new_format, c2, message, format TSRMLS_CC);
RETURN_CTOR(new_format);
}
/**
* Renders a view using the template engine
*
* @param string $path
* @param array $params
* @param boolean $mustClean
*/
PHP_METHOD(Phalcon_Mvc_View_Engine_Php, render){
zval *path, *params, *must_clean = NULL, *value = NULL, *key = NULL, *contents;
zval *view;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &path, ¶ms, &must_clean) == FAILURE) {
RETURN_MM_NULL();
}
if (!must_clean) {
PHALCON_INIT_VAR(must_clean);
ZVAL_BOOL(must_clean, 0);
}
if (PHALCON_IS_TRUE(must_clean)) {
PHALCON_CALL_FUNC_NORETURN("ob_clean");
}
if (Z_TYPE_P(params) == IS_ARRAY) {
if (!phalcon_is_iterable(params, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (phalcon_set_symbol(key, value TSRMLS_CC) == FAILURE){
return;
}
zend_hash_move_forward_ex(ah0, &hp0);
}
}
if (phalcon_require(path TSRMLS_CC) == FAILURE) {
return;
}
if (PHALCON_IS_TRUE(must_clean)) {
PHALCON_INIT_VAR(contents);
PHALCON_CALL_FUNC(contents, "ob_get_contents");
PHALCON_OBS_VAR(view);
phalcon_read_property(&view, this_ptr, SL("_view"), PH_NOISY_CC);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(view, "setcontent", contents);
}
PHALCON_MM_RESTORE();
}
/**
* Returns active session id
*
* @return string
*/
PHP_METHOD(Phalcon_Session, getId){
zval *session_id = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(session_id);
PHALCON_CALL_FUNC(session_id, "session_id");
RETURN_CCTOR(session_id);
}
PHP_METHOD(Phalcon_Session, destroy){
zval *destroyed = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(destroyed);
PHALCON_CALL_FUNC(destroyed, "session_destroy");
phalcon_update_property_bool(this_ptr, SL("_started"), 0 TSRMLS_CC);
RETURN_CCTOR(destroyed);
}
/**
* Sends/Writes messages to the file log
*
* @param string $message
* @param int $type
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, log){
zval *message, *type = NULL, *file_handler, *transaction;
zval *time, *quenue_item, *applied_format, *eol;
zval *applied_eol;
zval *t0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &message, &type) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!type) {
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 7);
}
PHALCON_INIT_VAR(file_handler);
phalcon_read_property(&file_handler, this_ptr, SL("_fileHandler"), PH_NOISY_CC);
if (!zend_is_true(file_handler)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "Cannot send message to the log because it is invalid");
return;
}
PHALCON_INIT_VAR(transaction);
phalcon_read_property(&transaction, this_ptr, SL("_transaction"), PH_NOISY_CC);
if (zend_is_true(transaction)) {
PHALCON_INIT_VAR(time);
PHALCON_CALL_FUNC(time, "time");
PHALCON_INIT_VAR(quenue_item);
object_init_ex(quenue_item, phalcon_logger_item_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(quenue_item, "__construct", message, type, time, PH_CHECK);
PHALCON_INIT_VAR(t0);
phalcon_read_property(&t0, this_ptr, SL("_quenue"), PH_NOISY_CC);
phalcon_array_append(&t0, quenue_item, 0 TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_quenue"), t0 TSRMLS_CC);
} else {
PHALCON_INIT_VAR(applied_format);
PHALCON_CALL_METHOD_PARAMS_2(applied_format, this_ptr, "_applyformat", message, type, PH_NO_CHECK);
PHALCON_INIT_VAR(eol);
zend_get_constant(SL("PHP_EOL"), eol TSRMLS_CC);
PHALCON_INIT_VAR(applied_eol);
PHALCON_CONCAT_VV(applied_eol, applied_format, eol);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("fwrite", file_handler, applied_eol);
}
PHALCON_MM_RESTORE();
}
/**
* Every helper calls this function to check whether a component has a predefined
* value using Phalcon\Tag::setDefault or value from $_POST
*
* @param string $name
* @return mixed
*/
PHP_METHOD(Phalcon_Tag, getValue){
zval *name = NULL, *display_values = NULL, *default_value = NULL;
zval *post = NULL, *le_post_name = NULL, *have_magic_quotes = NULL;
zval *post_name = NULL, *striped = NULL;
zval *g0 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_OBSERVE_VAR(display_values);
phalcon_read_static_property(&display_values, SL("phalcon\\tag"), SL("_displayValues") TSRMLS_CC);
eval_int = phalcon_array_isset(display_values, name);
if (eval_int) {
PHALCON_INIT_VAR(default_value);
phalcon_array_fetch(&default_value, display_values, name, PH_NOISY_CC);
RETURN_CCTOR(default_value);
} else {
phalcon_get_global(&g0, SL("_POST")+1 TSRMLS_CC);
PHALCON_CPY_WRT(post, g0);
eval_int = phalcon_array_isset(post, name);
if (eval_int) {
PHALCON_INIT_VAR(le_post_name);
phalcon_array_fetch(&le_post_name, post, name, PH_NOISY_CC);
PHALCON_INIT_VAR(have_magic_quotes);
PHALCON_CALL_FUNC(have_magic_quotes, "get_magic_quotes_gpc");
if (!zend_is_true(have_magic_quotes)) {
PHALCON_CPY_WRT(post_name, le_post_name);
RETURN_CCTOR(post_name);
} else {
PHALCON_INIT_VAR(striped);
PHALCON_CALL_FUNC_PARAMS_1(striped, "stripslashes", le_post_name);
RETURN_CCTOR(striped);
}
}
}
PHALCON_MM_RESTORE();
}
/**
* Starts the session (if headers are already sent the session will not started)
*
* @return boolean
*/
PHP_METHOD(Phalcon_Session_Adapter, start){
zval *headers_sent;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(headers_sent);
PHALCON_CALL_FUNC(headers_sent, "headers_sent");
if (PHALCON_IS_FALSE(headers_sent)) {
PHALCON_CALL_FUNC_NORETURN("session_start");
phalcon_update_property_bool(this_ptr, SL("_started"), 1 TSRMLS_CC);
RETURN_MM_TRUE;
}
RETURN_MM_FALSE;
}
/**
* Starts session, optionally using an adapter
*
* @param array $options
*/
PHP_METHOD(Phalcon_Session, start){
zval *headers_sent = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(headers_sent);
PHALCON_CALL_FUNC(headers_sent, "headers_sent");
if (Z_TYPE_P(headers_sent) == IS_BOOL && !Z_BVAL_P(headers_sent)) {
PHALCON_CALL_FUNC_NORETURN("session_start");
phalcon_update_property_bool(this_ptr, SL("_started"), 1 TSRMLS_CC);
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
/**
* Returns connection related to transaction
*
* @return Phalcon_Db
*/
PHP_METHOD(Phalcon_Transaction, getConnection){
zval *t0 = NULL, *t1 = NULL;
zval *r0 = NULL;
zval *p1[] = { NULL };
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_rollbackOnAbort", sizeof("_rollbackOnAbort")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
if (zend_is_true(t0)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_FUNC(r0, "connection_aborted", 0x043);
if (zend_is_true(r0)) {
PHALCON_INIT_VAR(p1[0]);
ZVAL_STRING(p1[0], "The request was aborted", 1);
PHALCON_CALL_METHOD_PARAMS_NORETURN(this_ptr, "rollback", 1, p1, PHALCON_CALL_DEFAULT);
}
}
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_connection", sizeof("_connection")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_RETURN_CHECK_CTOR(t1);
}
/**
* Returns connection related to transaction
*
* @return string
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction, getConnection){
zval *rollback_on_abort = NULL, *was_aborted = NULL, *connection = NULL;
zval *c0 = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(rollback_on_abort);
phalcon_read_property(&rollback_on_abort, this_ptr, SL("_rollbackOnAbort"), PH_NOISY_CC);
if (zend_is_true(rollback_on_abort)) {
PHALCON_INIT_VAR(was_aborted);
PHALCON_CALL_FUNC(was_aborted, "connection_aborted");
if (zend_is_true(was_aborted)) {
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "The request was aborted", 1);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "rollback", c0, PH_NO_CHECK);
}
}
PHALCON_INIT_VAR(connection);
phalcon_read_property(&connection, this_ptr, SL("_connection"), PH_NOISY_CC);
RETURN_CCTOR(connection);
}
/**
* Returns connection related to transaction
*
* @return string
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction, getConnection){
zval *t0 = NULL, *t1 = NULL;
zval *r0 = NULL;
zval *c0 = NULL;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_rollbackOnAbort"), PH_NOISY_CC);
if (zend_is_true(t0)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_FUNC(r0, "connection_aborted");
if (zend_is_true(r0)) {
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "The request was aborted", 1);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "rollback", c0, PH_NO_CHECK);
}
}
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, SL("_connection"), PH_NOISY_CC);
RETURN_CCTOR(t1);
}
/**
* This method is automatically called in Phalcon_Db_Mysql constructor.
* Call it when you need to restore a database connection
*
* @param stdClass $descriptor
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Mysql, connect){
zval *descriptor = NULL, *host = NULL, *username = NULL, *password = NULL, *port = NULL;
zval *socket = NULL, *dbname = NULL, *client_flags = NULL, *persistent = NULL;
zval *link = NULL, *autocommit = NULL, *success = NULL, *collation = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL;
zval *t7 = NULL, *t8 = NULL, *t9 = NULL, *t10 = NULL, *t11 = NULL, *t12 = NULL, *t13 = NULL;
zval *t14 = NULL, *t15 = NULL, *t16 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *p0[] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &descriptor) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!descriptor) {
PHALCON_INIT_VAR(descriptor);
ZVAL_NULL(descriptor);
} else {
PHALCON_SEPARATE_PARAM(descriptor);
}
if (!zend_is_true(descriptor)) {
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_descriptor"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(descriptor, t0);
}
eval_int = phalcon_isset_property(descriptor, SL("host") TSRMLS_CC);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, descriptor, SL("host"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(host, t1);
} else {
PHALCON_INIT_VAR(host);
ZVAL_NULL(host);
}
eval_int = phalcon_isset_property(descriptor, SL("username") TSRMLS_CC);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, descriptor, SL("username"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(username, t2);
} else {
PHALCON_INIT_VAR(username);
ZVAL_NULL(username);
}
eval_int = phalcon_isset_property(descriptor, SL("password") TSRMLS_CC);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(t3);
phalcon_read_property(&t3, descriptor, SL("password"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(password, t3);
} else {
PHALCON_INIT_VAR(password);
ZVAL_NULL(password);
}
eval_int = phalcon_isset_property(descriptor, SL("port") TSRMLS_CC);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(t4);
phalcon_read_property(&t4, descriptor, SL("port"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(port, t4);
} else {
PHALCON_INIT_VAR(port);
ZVAL_NULL(port);
}
eval_int = phalcon_isset_property(descriptor, SL("socket") TSRMLS_CC);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(t5);
phalcon_read_property(&t5, descriptor, SL("socket"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(socket, t5);
} else {
PHALCON_INIT_VAR(socket);
ZVAL_NULL(socket);
}
eval_int = phalcon_isset_property(descriptor, SL("name") TSRMLS_CC);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(t6);
phalcon_read_property(&t6, descriptor, SL("name"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(dbname, t6);
} else {
PHALCON_INIT_VAR(dbname);
ZVAL_STRING(dbname, "", 1);
}
PHALCON_INIT_VAR(client_flags);
ZVAL_NULL(client_flags);
eval_int = phalcon_isset_property(descriptor, SL("compression") TSRMLS_CC);
if (eval_int) {
PHALCON_INIT_VAR(t7);
ZVAL_LONG(t7, 32);
PHALCON_CPY_WRT(client_flags, t7);
}
eval_int = phalcon_isset_property(descriptor, SL("ssl") TSRMLS_CC);
if (eval_int) {
if (!zend_is_true(client_flags)) {
PHALCON_INIT_VAR(t8);
ZVAL_LONG(t8, 2048);
PHALCON_CPY_WRT(client_flags, t8);
} else {
PHALCON_INIT_VAR(t9);
ZVAL_LONG(t9, 2048);
PHALCON_ALLOC_ZVAL_MM(r0);
bitwise_or_function(r0, client_flags, t9 TSRMLS_CC);
PHALCON_CPY_WRT(client_flags, r0);
}
}
eval_int = phalcon_isset_property(descriptor, SL("interactive") TSRMLS_CC);
if (eval_int) {
if (!zend_is_true(client_flags)) {
PHALCON_INIT_VAR(t10);
ZVAL_LONG(t10, 1024);
PHALCON_CPY_WRT(client_flags, t10);
} else {
PHALCON_INIT_VAR(t11);
ZVAL_LONG(t11, 1024);
PHALCON_ALLOC_ZVAL_MM(r1);
bitwise_or_function(r1, client_flags, t11 TSRMLS_CC);
PHALCON_CPY_WRT(client_flags, r1);
}
}
PHALCON_INIT_VAR(persistent);
ZVAL_BOOL(persistent, 0);
eval_int = phalcon_isset_property(descriptor, SL("persistent") TSRMLS_CC);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(t12);
phalcon_read_property(&t12, descriptor, SL("persistent"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(persistent, t12);
}
PHALCON_INIT_VAR(link);
PHALCON_CALL_FUNC(link, "mysqli_init");
eval_int = phalcon_isset_property(descriptor, SL("autocommit") TSRMLS_CC);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(t13);
phalcon_read_property(&t13, descriptor, SL("autocommit"), PHALCON_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(autocommit);
PHALCON_CALL_FUNC_PARAMS_1(autocommit, "intval", t13);
phalcon_update_property_zval(this_ptr, SL("_autoCommit"), autocommit TSRMLS_CC);
PHALCON_INIT_VAR(t14);
ZVAL_LONG(t14, 3);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CONCAT_SV(r2, "SET AUTOCOMMIT = ", autocommit);
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CALL_FUNC_PARAMS_3(r3, "mysqli_options", link, t14, r2);
if (!zend_is_true(r3)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Setting MYSQLI_INIT_COMMAND failed");
return;
}
}
p0[0] = link;
p0[1] = host;
p0[2] = username;
p0[3] = password;
p0[4] = dbname;
p0[5] = port;
p0[6] = socket;
p0[7] = client_flags;
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CALL_FUNC_PARAMS(r4, "mysqli_real_connect", 8, p0);
PHALCON_CPY_WRT(success, r4);
if (zend_is_true(success)) {
phalcon_update_property_zval(this_ptr, SL("_idConnection"), link TSRMLS_CC);
PHALCON_CALL_PARENT_PARAMS_1_NORETURN(this_ptr, "Phalcon_Db_Adapter_Mysql", "__construct", descriptor);
eval_int = phalcon_isset_property(descriptor, SL("charset") TSRMLS_CC);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(t15);
phalcon_read_property(&t15, descriptor, SL("charset"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("mysqli_set_charset", link, t15);
}
eval_int = phalcon_isset_property(descriptor, SL("collation") TSRMLS_CC);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(t16);
phalcon_read_property(&t16, descriptor, SL("collation"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(collation, t16);
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_CONCAT_SV(r5, "SET collation_connection=", collation);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "query", r5, PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r6);
PHALCON_CONCAT_SV(r6, "SET collation_database=", collation);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "query", r6, PHALCON_NO_CHECK);
}
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Connection to MySQL failed");
return;
}
PHALCON_MM_RESTORE();
}
/**
* Executes render process from request data
*
* @param string $controllerName
* @param string $actionName
* @param array $params
*/
PHP_METHOD(Phalcon_View, render){
zval *controller_name = NULL, *action_name = NULL, *params = NULL;
zval *layouts_dir = NULL, *engines = NULL, *pick_view = NULL, *render_view = NULL;
zval *render_controller = NULL, *silence = NULL, *render_level = NULL;
zval *templates_before = NULL, *template_before = NULL;
zval *templates_after = NULL, *template_after = NULL;
zval *a0 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL;
zval *t7 = NULL, *t8 = NULL, *t9 = NULL, *t10 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL;
zval *r14 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &controller_name, &action_name, ¶ms) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!params) {
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(params, a0);
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_layoutsDir", sizeof("_layoutsDir")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(layouts_dir, t0);
if (!zend_is_true(layouts_dir)) {
PHALCON_INIT_VAR(layouts_dir);
ZVAL_STRING(layouts_dir, "layouts/", 1);
}
phalcon_update_property_zval(this_ptr, "_controllerName", strlen("_controllerName"), controller_name TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_actionName", strlen("_actionName"), action_name TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_params", strlen("_params"), params TSRMLS_CC);
phalcon_update_property_bool(this_ptr, "_initEngines", strlen("_initEngines"), 0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, this_ptr, "_loadtemplateengines", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(engines, r0);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_pickView", sizeof("_pickView")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(pick_view, t1);
if (!zend_is_true(pick_view)) {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CONCAT_VSV(r1, controller_name, "/", action_name);
PHALCON_CPY_WRT(render_view, r1);
PHALCON_CPY_WRT(render_controller, controller_name);
} else {
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_long(&r2, pick_view, 0, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(render_view, r2);
eval_int = phalcon_array_isset_long(pick_view, 1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_array_fetch_long(&r3, pick_view, 1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(render_controller, r3);
} else {
PHALCON_CPY_WRT(render_controller, controller_name);
}
}
PHALCON_INIT_VAR(silence);
ZVAL_BOOL(silence, 1);
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_renderLevel", sizeof("_renderLevel")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(render_level, t2);
if (zend_is_true(render_level)) {
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CALL_FUNC(r4, "ob_get_contents", 0x015);
phalcon_update_property_zval(this_ptr, "_content", strlen("_content"), r4 TSRMLS_CC);
PHALCON_INIT_VAR(t3);
ZVAL_LONG(t3, 1);
PHALCON_INIT_VAR(r5);
is_smaller_or_equal_function(r5, t3, render_level TSRMLS_CC);
if (zend_is_true(r5)) {
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "_enginerender", engines, render_view, silence, PHALCON_NO_CHECK);
}
PHALCON_INIT_VAR(t4);
ZVAL_LONG(t4, 2);
PHALCON_INIT_VAR(r6);
is_smaller_or_equal_function(r6, t4, render_level TSRMLS_CC);
if (zend_is_true(r6)) {
PHALCON_ALLOC_ZVAL_MM(t5);
phalcon_read_property(&t5, this_ptr, "_templatesBefore", sizeof("_templatesBefore")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(templates_before, t5);
if (zend_is_true(templates_before)) {
PHALCON_INIT_VAR(silence);
ZVAL_BOOL(silence, 0);
if (Z_TYPE_P(templates_before) == IS_ARRAY) {
if (phalcon_valid_foreach(templates_before TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(templates_before);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_b0d8_2:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_b0d8_2;
}
PHALCON_INIT_VAR(template_before);
ZVAL_ZVAL(template_before, *hd, 1, 0);
PHALCON_INIT_VAR(r7);
PHALCON_CONCAT_VV(r7, layouts_dir, template_before);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "_enginerender", engines, r7, silence, PHALCON_NO_CHECK);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_b0d8_2;
fee_b0d8_2:
if(0){}
} else {
return;
}
} else {
PHALCON_ALLOC_ZVAL_MM(r8);
PHALCON_CONCAT_VV(r8, layouts_dir, template_before);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "_enginerender", engines, r8, silence, PHALCON_NO_CHECK);
}
PHALCON_INIT_VAR(silence);
ZVAL_BOOL(silence, 1);
}
}
PHALCON_INIT_VAR(t6);
ZVAL_LONG(t6, 3);
PHALCON_INIT_VAR(r9);
is_smaller_or_equal_function(r9, t6, render_level TSRMLS_CC);
if (zend_is_true(r9)) {
PHALCON_ALLOC_ZVAL_MM(r10);
PHALCON_CONCAT_VV(r10, layouts_dir, render_controller);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "_enginerender", engines, r10, silence, PHALCON_NO_CHECK);
}
PHALCON_INIT_VAR(t7);
ZVAL_LONG(t7, 4);
PHALCON_INIT_VAR(r11);
is_smaller_or_equal_function(r11, t7, render_level TSRMLS_CC);
if (zend_is_true(r11)) {
PHALCON_ALLOC_ZVAL_MM(t8);
phalcon_read_property(&t8, this_ptr, "_templatesAfter", sizeof("_templatesAfter")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(templates_after, t8);
if (zend_is_true(templates_after)) {
PHALCON_INIT_VAR(silence);
ZVAL_BOOL(silence, 0);
if (Z_TYPE_P(templates_after) == IS_ARRAY) {
if (phalcon_valid_foreach(templates_after TSRMLS_CC)) {
ah1 = Z_ARRVAL_P(templates_after);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_b0d8_3:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_b0d8_3;
}
PHALCON_INIT_VAR(template_after);
ZVAL_ZVAL(template_after, *hd, 1, 0);
PHALCON_INIT_VAR(r12);
PHALCON_CONCAT_VV(r12, layouts_dir, template_after);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "_enginerender", engines, r12, silence, PHALCON_NO_CHECK);
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_b0d8_3;
fee_b0d8_3:
if(0){}
} else {
return;
}
} else {
PHALCON_ALLOC_ZVAL_MM(r13);
PHALCON_CONCAT_VV(r13, layouts_dir, templates_after);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "_enginerender", engines, r13, silence, PHALCON_NO_CHECK);
}
PHALCON_INIT_VAR(silence);
ZVAL_BOOL(silence, 1);
}
}
PHALCON_INIT_VAR(t9);
ZVAL_LONG(t9, 5);
PHALCON_INIT_VAR(r14);
is_smaller_or_equal_function(r14, t9, render_level TSRMLS_CC);
if (zend_is_true(r14)) {
PHALCON_ALLOC_ZVAL_MM(t10);
phalcon_read_property(&t10, this_ptr, "_mainView", sizeof("_mainView")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "_enginerender", engines, t10, silence, PHALCON_NO_CHECK);
}
}
PHALCON_MM_RESTORE();
}
/**
* Executes render process from dispatching data
*
*<code>
* $view->start();
* //Shows recent posts view (app/views/posts/recent.phtml)
* $view->render('posts', 'recent');
* $view->finish();
*</code>
*
* @param string $controllerName
* @param string $actionName
* @param array $params
*/
PHP_METHOD(Phalcon_Mvc_View, render){
zval *controller_name, *action_name, *params = NULL;
zval *disabled, *contents = NULL, *layouts_dir = NULL, *layout;
zval *layout_name = NULL, *engines, *pick_view, *render_view = NULL;
zval *pick_view_action, *cache = NULL, *cache_level;
zval *events_manager, *event_name = NULL, *status, *must_clean;
zval *silence = NULL, *disabled_levels, *render_level;
zval *enter_level = NULL, *templates_before, *template_before = NULL;
zval *view_temp_path = NULL, *templates_after, *template_after = NULL;
zval *main_view, *is_started, *is_fresh;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 1, &controller_name, &action_name, ¶ms);
if (!params) {
PHALCON_INIT_VAR(params);
}
/**
* If the view is disabled we simply update the buffer from any output produced in
* the controller
*/
PHALCON_OBS_VAR(disabled);
phalcon_read_property_this(&disabled, this_ptr, SL("_disabled"), PH_NOISY_CC);
if (PHALCON_IS_NOT_FALSE(disabled)) {
PHALCON_INIT_VAR(contents);
PHALCON_CALL_FUNC(contents, "ob_get_contents");
phalcon_update_property_this(this_ptr, SL("_content"), contents TSRMLS_CC);
RETURN_MM_FALSE;
}
phalcon_update_property_this(this_ptr, SL("_controllerName"), controller_name TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_actionName"), action_name TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_params"), params TSRMLS_CC);
/**
* Check if there is a layouts directory set
*/
PHALCON_OBS_VAR(layouts_dir);
phalcon_read_property_this(&layouts_dir, this_ptr, SL("_layoutsDir"), PH_NOISY_CC);
if (!zend_is_true(layouts_dir)) {
PHALCON_INIT_NVAR(layouts_dir);
ZVAL_STRING(layouts_dir, "layouts/", 1);
}
/**
* Check if the user has defined a custom layout
*/
PHALCON_OBS_VAR(layout);
phalcon_read_property_this(&layout, this_ptr, SL("_layout"), PH_NOISY_CC);
if (zend_is_true(layout)) {
PHALCON_CPY_WRT(layout_name, layout);
} else {
PHALCON_CPY_WRT(layout_name, controller_name);
}
/**
* Load the template engines
*/
PHALCON_INIT_VAR(engines);
PHALCON_CALL_METHOD(engines, this_ptr, "_loadtemplateengines");
/**
* Check if the user has picked a view diferent than the automatic
*/
PHALCON_OBS_VAR(pick_view);
phalcon_read_property_this(&pick_view, this_ptr, SL("_pickView"), PH_NOISY_CC);
if (Z_TYPE_P(pick_view) == IS_NULL) {
PHALCON_INIT_VAR(render_view);
PHALCON_CONCAT_VSV(render_view, controller_name, "/", action_name);
} else {
/**
* The 'picked' view is an array, where the first element is controller and the
* second the action
*/
PHALCON_OBS_NVAR(render_view);
phalcon_array_fetch_long(&render_view, pick_view, 0, PH_NOISY_CC);
if (phalcon_array_isset_long(pick_view, 1)) {
PHALCON_OBS_VAR(pick_view_action);
phalcon_array_fetch_long(&pick_view_action, pick_view, 1, PH_NOISY_CC);
PHALCON_CPY_WRT(layout_name, pick_view_action);
}
}
PHALCON_INIT_VAR(cache);
/**
* Start the cache if there is a cache level enabled
*/
PHALCON_OBS_VAR(cache_level);
phalcon_read_property_this(&cache_level, this_ptr, SL("_cacheLevel"), PH_NOISY_CC);
if (zend_is_true(cache_level)) {
PHALCON_CALL_METHOD(cache, this_ptr, "getcache");
}
PHALCON_OBS_VAR(events_manager);
phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
/**
* Create a virtual symbol table
*/
phalcon_create_symbol_table(TSRMLS_C);
/**
* Call beforeRender if there is an events manager
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "view:beforeRender", 1);
PHALCON_INIT_VAR(status);
PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", event_name, this_ptr);
if (PHALCON_IS_FALSE(status)) {
RETURN_MM_FALSE;
}
}
/**
* Get the current content in the buffer maybe some output from the controller
*/
PHALCON_INIT_NVAR(contents);
PHALCON_CALL_FUNC(contents, "ob_get_contents");
phalcon_update_property_this(this_ptr, SL("_content"), contents TSRMLS_CC);
PHALCON_INIT_VAR(must_clean);
ZVAL_BOOL(must_clean, 1);
PHALCON_INIT_VAR(silence);
ZVAL_BOOL(silence, 1);
/**
* Disabled levels allow to avoid an specific level of rendering
*/
PHALCON_OBS_VAR(disabled_levels);
phalcon_read_property_this(&disabled_levels, this_ptr, SL("_disabledLevels"), PH_NOISY_CC);
/**
* Render level will tell use when to stop
*/
PHALCON_OBS_VAR(render_level);
phalcon_read_property_this(&render_level, this_ptr, SL("_renderLevel"), PH_NOISY_CC);
if (zend_is_true(render_level)) {
/**
* Inserts view related to action
*/
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 1);
PHALCON_INIT_VAR(enter_level);
is_smaller_or_equal_function(enter_level, t0, render_level TSRMLS_CC);
if (PHALCON_IS_TRUE(enter_level)) {
if (!phalcon_array_isset_long(disabled_levels, 1)) {
PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, render_view, silence, must_clean, cache);
}
}
/**
* Inserts templates before layout
*/
PHALCON_INIT_VAR(t1);
ZVAL_LONG(t1, 2);
PHALCON_INIT_NVAR(enter_level);
is_smaller_or_equal_function(enter_level, t1, render_level TSRMLS_CC);
if (PHALCON_IS_TRUE(enter_level)) {
if (!phalcon_array_isset_long(disabled_levels, 2)) {
PHALCON_OBS_VAR(templates_before);
phalcon_read_property_this(&templates_before, this_ptr, SL("_templatesBefore"), PH_NOISY_CC);
/**
* Templates before must be an array
*/
if (Z_TYPE_P(templates_before) == IS_ARRAY) {
ZVAL_BOOL(silence, 0);
if (!phalcon_is_iterable(templates_before, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(template_before);
PHALCON_INIT_NVAR(view_temp_path);
PHALCON_CONCAT_VV(view_temp_path, layouts_dir, template_before);
PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache);
zend_hash_move_forward_ex(ah0, &hp0);
}
ZVAL_BOOL(silence, 1);
}
}
}
/**
* Inserts controller layout
*/
PHALCON_INIT_VAR(t2);
ZVAL_LONG(t2, 3);
PHALCON_INIT_NVAR(enter_level);
is_smaller_or_equal_function(enter_level, t2, render_level TSRMLS_CC);
if (PHALCON_IS_TRUE(enter_level)) {
if (!phalcon_array_isset_long(disabled_levels, 3)) {
PHALCON_INIT_NVAR(view_temp_path);
PHALCON_CONCAT_VV(view_temp_path, layouts_dir, layout_name);
PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache);
}
}
/**
* Inserts templates after layout
*/
PHALCON_INIT_VAR(t3);
ZVAL_LONG(t3, 4);
PHALCON_INIT_NVAR(enter_level);
is_smaller_or_equal_function(enter_level, t3, render_level TSRMLS_CC);
if (PHALCON_IS_TRUE(enter_level)) {
if (!phalcon_array_isset_long(disabled_levels, 4)) {
/**
* Templates after must be an array
*/
PHALCON_OBS_VAR(templates_after);
phalcon_read_property_this(&templates_after, this_ptr, SL("_templatesAfter"), PH_NOISY_CC);
if (Z_TYPE_P(templates_after) == IS_ARRAY) {
ZVAL_BOOL(silence, 0);
if (!phalcon_is_iterable(templates_after, &ah1, &hp1, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(template_after);
PHALCON_INIT_NVAR(view_temp_path);
PHALCON_CONCAT_VV(view_temp_path, layouts_dir, template_after);
PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache);
zend_hash_move_forward_ex(ah1, &hp1);
}
ZVAL_BOOL(silence, 1);
}
}
}
/**
* Inserts main view
*/
PHALCON_INIT_VAR(t4);
ZVAL_LONG(t4, 5);
PHALCON_INIT_NVAR(enter_level);
is_smaller_or_equal_function(enter_level, t4, render_level TSRMLS_CC);
if (PHALCON_IS_TRUE(enter_level)) {
if (!phalcon_array_isset_long(disabled_levels, 5)) {
PHALCON_OBS_VAR(main_view);
phalcon_read_property_this(&main_view, this_ptr, SL("_mainView"), PH_NOISY_CC);
PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, main_view, silence, must_clean, cache);
}
}
/**
* Store the data in the cache
*/
if (Z_TYPE_P(cache) == IS_OBJECT) {
PHALCON_INIT_VAR(is_started);
PHALCON_CALL_METHOD(is_started, cache, "isstarted");
if (PHALCON_IS_TRUE(is_started)) {
PHALCON_INIT_VAR(is_fresh);
PHALCON_CALL_METHOD(is_fresh, cache, "isfresh");
if (PHALCON_IS_TRUE(is_fresh)) {
PHALCON_CALL_METHOD_NORETURN(cache, "save");
} else {
PHALCON_CALL_METHOD_NORETURN(cache, "stop");
}
} else {
PHALCON_CALL_METHOD_NORETURN(cache, "stop");
}
}
}
/**
* Call afterRender event
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "view:afterRender", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", event_name, this_ptr);
}
RETURN_MM_NULL();
}
/**
* Executes render process from dispatching data
*
*<code>
* $view->start();
* //Shows recent posts view (app/views/posts/recent.phtml)
* $view->render('posts', 'recent');
* $view->finish();
*</code>
*
* @param string $controllerName
* @param string $actionName
* @param array $params
*/
PHP_METHOD(Phalcon_Mvc_View, render){
zval *controller_name = NULL, *action_name = NULL, *params = NULL;
zval *layouts_dir = NULL, *engines = NULL, *pick_view = NULL, *render_view = NULL;
zval *render_controller = NULL, *pick_view_action = NULL;
zval *cache = NULL, *cache_level = NULL, *events_manager = NULL, *event_name = NULL;
zval *status = NULL, *contents = NULL, *must_clean = NULL, *silence = NULL;
zval *render_level = NULL, *enter_level = NULL, *templates_before = NULL;
zval *template_before = NULL, *view_temp_path = NULL, *templates_after = NULL;
zval *template_after = NULL, *main_view = NULL, *is_started = NULL;
zval *is_fresh = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &controller_name, &action_name, ¶ms) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!params) {
PHALCON_INIT_VAR(params);
array_init(params);
}
PHALCON_INIT_VAR(layouts_dir);
phalcon_read_property(&layouts_dir, this_ptr, SL("_layoutsDir"), PH_NOISY_CC);
if (!zend_is_true(layouts_dir)) {
PHALCON_INIT_VAR(layouts_dir);
ZVAL_STRING(layouts_dir, "layouts/", 1);
}
phalcon_update_property_zval(this_ptr, SL("_controllerName"), controller_name TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_actionName"), action_name TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_params"), params TSRMLS_CC);
PHALCON_INIT_VAR(engines);
PHALCON_CALL_METHOD(engines, this_ptr, "_loadtemplateengines", PH_NO_CHECK);
PHALCON_INIT_VAR(pick_view);
phalcon_read_property(&pick_view, this_ptr, SL("_pickView"), PH_NOISY_CC);
if (Z_TYPE_P(pick_view) == IS_NULL) {
PHALCON_INIT_VAR(render_view);
PHALCON_CONCAT_VSV(render_view, controller_name, "/", action_name);
PHALCON_CPY_WRT(render_controller, controller_name);
} else {
PHALCON_INIT_VAR(render_view);
phalcon_array_fetch_long(&render_view, pick_view, 0, PH_NOISY_CC);
eval_int = phalcon_array_isset_long(pick_view, 1);
if (eval_int) {
PHALCON_INIT_VAR(pick_view_action);
phalcon_array_fetch_long(&pick_view_action, pick_view, 1, PH_NOISY_CC);
PHALCON_CPY_WRT(render_controller, pick_view_action);
} else {
PHALCON_CPY_WRT(render_controller, controller_name);
}
}
PHALCON_INIT_VAR(cache);
ZVAL_NULL(cache);
PHALCON_INIT_VAR(cache_level);
phalcon_read_property(&cache_level, this_ptr, SL("_cacheLevel"), PH_NOISY_CC);
if (zend_is_true(cache_level)) {
PHALCON_INIT_VAR(cache);
PHALCON_CALL_METHOD(cache, this_ptr, "getcache", PH_NO_CHECK);
}
PHALCON_INIT_VAR(events_manager);
phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "view:beforeRender", 1);
PHALCON_INIT_VAR(status);
PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", event_name, this_ptr, PH_NO_CHECK);
if (Z_TYPE_P(status) == IS_BOOL && !Z_BVAL_P(status)) {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_INIT_VAR(contents);
PHALCON_CALL_FUNC(contents, "ob_get_contents");
phalcon_update_property_zval(this_ptr, SL("_content"), contents TSRMLS_CC);
PHALCON_INIT_VAR(must_clean);
ZVAL_BOOL(must_clean, 1);
PHALCON_INIT_VAR(silence);
ZVAL_BOOL(silence, 1);
PHALCON_INIT_VAR(render_level);
phalcon_read_property(&render_level, this_ptr, SL("_renderLevel"), PH_NOISY_CC);
if (zend_is_true(render_level)) {
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 1);
PHALCON_INIT_VAR(enter_level);
is_smaller_or_equal_function(enter_level, t0, render_level TSRMLS_CC);
if (Z_TYPE_P(enter_level) == IS_BOOL && Z_BVAL_P(enter_level)) {
PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, render_view, silence, must_clean, cache, PH_NO_CHECK);
}
PHALCON_INIT_VAR(t1);
ZVAL_LONG(t1, 2);
PHALCON_INIT_VAR(enter_level);
is_smaller_or_equal_function(enter_level, t1, render_level TSRMLS_CC);
if (Z_TYPE_P(enter_level) == IS_BOOL && Z_BVAL_P(enter_level)) {
PHALCON_INIT_VAR(templates_before);
phalcon_read_property(&templates_before, this_ptr, SL("_templatesBefore"), PH_NOISY_CC);
if (Z_TYPE_P(templates_before) == IS_ARRAY) {
PHALCON_INIT_VAR(silence);
ZVAL_BOOL(silence, 0);
if (!phalcon_valid_foreach(templates_before TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(templates_before);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_ecde_2:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_ecde_2;
}
PHALCON_INIT_VAR(template_before);
ZVAL_ZVAL(template_before, *hd, 1, 0);
PHALCON_INIT_VAR(view_temp_path);
PHALCON_CONCAT_VV(view_temp_path, layouts_dir, template_before);
PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache, PH_NO_CHECK);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_ecde_2;
fee_ecde_2:
PHALCON_INIT_VAR(silence);
ZVAL_BOOL(silence, 1);
}
}
PHALCON_INIT_VAR(t2);
ZVAL_LONG(t2, 3);
PHALCON_INIT_VAR(enter_level);
is_smaller_or_equal_function(enter_level, t2, render_level TSRMLS_CC);
if (Z_TYPE_P(enter_level) == IS_BOOL && Z_BVAL_P(enter_level)) {
PHALCON_INIT_VAR(view_temp_path);
PHALCON_CONCAT_VV(view_temp_path, layouts_dir, render_controller);
PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache, PH_NO_CHECK);
}
PHALCON_INIT_VAR(t3);
ZVAL_LONG(t3, 4);
PHALCON_INIT_VAR(enter_level);
is_smaller_or_equal_function(enter_level, t3, render_level TSRMLS_CC);
if (Z_TYPE_P(enter_level) == IS_BOOL && Z_BVAL_P(enter_level)) {
PHALCON_INIT_VAR(templates_after);
phalcon_read_property(&templates_after, this_ptr, SL("_templatesAfter"), PH_NOISY_CC);
if (Z_TYPE_P(templates_after) == IS_ARRAY) {
PHALCON_INIT_VAR(silence);
ZVAL_BOOL(silence, 0);
if (!phalcon_valid_foreach(templates_after TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(templates_after);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_ecde_3:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_ecde_3;
}
PHALCON_INIT_VAR(template_after);
ZVAL_ZVAL(template_after, *hd, 1, 0);
PHALCON_INIT_VAR(view_temp_path);
PHALCON_CONCAT_VV(view_temp_path, layouts_dir, template_after);
PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache, PH_NO_CHECK);
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_ecde_3;
fee_ecde_3:
PHALCON_INIT_VAR(silence);
ZVAL_BOOL(silence, 1);
}
}
PHALCON_INIT_VAR(t4);
ZVAL_LONG(t4, 5);
PHALCON_INIT_VAR(enter_level);
is_smaller_or_equal_function(enter_level, t4, render_level TSRMLS_CC);
if (Z_TYPE_P(enter_level) == IS_BOOL && Z_BVAL_P(enter_level)) {
PHALCON_INIT_VAR(main_view);
phalcon_read_property(&main_view, this_ptr, SL("_mainView"), PH_NOISY_CC);
PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, main_view, silence, must_clean, cache, PH_NO_CHECK);
}
if (Z_TYPE_P(cache) == IS_OBJECT) {
PHALCON_INIT_VAR(is_started);
PHALCON_CALL_METHOD(is_started, cache, "isstarted", PH_NO_CHECK);
if (zend_is_true(is_started)) {
PHALCON_INIT_VAR(is_fresh);
PHALCON_CALL_METHOD(is_fresh, cache, "isfresh", PH_NO_CHECK);
if (zend_is_true(is_fresh)) {
PHALCON_CALL_METHOD_NORETURN(cache, "save", PH_NO_CHECK);
}
}
}
}
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "view:afterRender", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", event_name, this_ptr, PH_NO_CHECK);
}
PHALCON_MM_RESTORE();
}
/**
* Returns a cached content
*
* @param string $keyName
* @return mixed
*/
PHP_METHOD(Phalcon_Cache_Backend_File, get){
zval *key_name = NULL, *backend = NULL, *front_end = NULL, *sanitize_key = NULL;
zval *cache_file = NULL, *time = NULL, *lifetime = NULL, *cached_content = NULL;
zval *t0 = NULL, *t1 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &key_name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_backendOptions", sizeof("_backendOptions")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(backend, t0);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_frontendObject", sizeof("_frontendObject")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(front_end, t1);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_filter_alphanum(r0, key_name);
PHALCON_CPY_WRT(sanitize_key, r0);
phalcon_update_property_zval(this_ptr, "_lastKey", strlen("_lastKey"), sanitize_key TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch_string(&r1, backend, "cacheDir", strlen("cacheDir"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r2);
concat_function(r2, r1, sanitize_key TSRMLS_CC);
PHALCON_CPY_WRT(cache_file, r2);
if (phalcon_file_exists(cache_file TSRMLS_CC) == SUCCESS) {
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CALL_FUNC(r3, "time", 0x018);
PHALCON_CPY_WRT(time, r3);
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CALL_METHOD(r4, front_end, "getlifetime", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(lifetime, r4);
PHALCON_ALLOC_ZVAL_MM(r5);
sub_function(r5, time, lifetime TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r6);
PHALCON_CALL_FUNC_PARAMS_1(r6, "filemtime", cache_file, 0x019);
PHALCON_INIT_VAR(r7);
is_smaller_function(r7, r5, r6 TSRMLS_CC);
if (zend_is_true(r7)) {
PHALCON_ALLOC_ZVAL_MM(r8);
PHALCON_CALL_FUNC_PARAMS_1(r8, "file_get_contents", cache_file, 0x01A);
PHALCON_CPY_WRT(cached_content, r8);
PHALCON_ALLOC_ZVAL_MM(r9);
PHALCON_CALL_METHOD_PARAMS_1(r9, front_end, "afterretrieve", cached_content, PHALCON_NO_CHECK);
PHALCON_RETURN_DZVAL(r9);
}
}
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* Returns a cached content
*
* @param int|string $keyName
* @param long $lifetime
* @return mixed
*/
PHP_METHOD(Phalcon_Cache_Backend_File, get){
zval *key_name, *lifetime = NULL, *options, *prefix, *filtered;
zval *prefixed_key, *cache_dir, *cache_file;
zval *frontend, *time, *ttl = NULL, *modified_time, *difference;
zval *not_expired, *cached_content, *processed;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &key_name, &lifetime) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!lifetime) {
PHALCON_INIT_NVAR(lifetime);
}
PHALCON_INIT_VAR(options);
phalcon_read_property(&options, this_ptr, SL("_options"), PH_NOISY_CC);
PHALCON_INIT_VAR(prefix);
phalcon_read_property(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC);
PHALCON_INIT_VAR(filtered);
phalcon_filter_alphanum(filtered, key_name);
PHALCON_INIT_VAR(prefixed_key);
PHALCON_CONCAT_VV(prefixed_key, prefix, filtered);
phalcon_update_property_zval(this_ptr, SL("_lastKey"), prefixed_key TSRMLS_CC);
PHALCON_INIT_VAR(cache_dir);
phalcon_array_fetch_string(&cache_dir, options, SL("cacheDir"), PH_NOISY_CC);
PHALCON_INIT_VAR(cache_file);
PHALCON_CONCAT_VV(cache_file, cache_dir, prefixed_key);
if (phalcon_file_exists(cache_file TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(frontend);
phalcon_read_property(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
/**
* Check if the file has expired
*/
PHALCON_INIT_VAR(time);
PHALCON_CALL_FUNC(time, "time");
if (Z_TYPE_P(lifetime) == IS_NULL) {
PHALCON_INIT_VAR(ttl);
PHALCON_CALL_METHOD(ttl, frontend, "getlifetime", PH_NO_CHECK);
} else {
PHALCON_CPY_WRT(ttl, lifetime);
}
PHALCON_INIT_VAR(modified_time);
PHALCON_CALL_FUNC_PARAMS_1(modified_time, "filemtime", cache_file);
PHALCON_INIT_VAR(difference);
sub_function(difference, time, ttl TSRMLS_CC);
PHALCON_INIT_VAR(not_expired);
is_smaller_function(not_expired, difference, modified_time TSRMLS_CC);
/**
* The content is only retrieved if the content has not expired
*/
if (PHALCON_IS_TRUE(not_expired)) {
PHALCON_INIT_VAR(cached_content);
PHALCON_CALL_FUNC_PARAMS_1(cached_content, "file_get_contents", cache_file);
PHALCON_INIT_VAR(processed);
PHALCON_CALL_METHOD_PARAMS_1(processed, frontend, "afterretrieve", cached_content, PH_NO_CHECK);
RETURN_CCTOR(processed);
}
}
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* Helper method to query records based on a relation definition
*
* @param array $relation
* @param string $method
* @param Phalcon\Mvc\Model $record
*/
PHP_METHOD(Phalcon_Mvc_Model_Manager, _getRelationRecords){
zval *relation = NULL, *method = NULL, *record = NULL, *conditions = NULL, *placeholders = NULL;
zval *field = NULL, *value = NULL, *referenced_field = NULL, *condition = NULL;
zval *i = NULL, *fields = NULL, *number_args = NULL, *function_arguments = NULL;
zval *key = NULL, *join_conditions = NULL, *find_params = NULL, *arguments = NULL;
zval *reference_table = NULL, *referenced_entity = NULL;
zval *call_object = NULL, *records = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL;
zval *c0 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
zend_class_entry *ce0;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &relation, &method, &record) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(conditions);
array_init(conditions);
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, relation, SL("fi"), PH_NOISY_CC);
if (Z_TYPE_P(r0) != IS_ARRAY) {
PHALCON_INIT_VAR(field);
phalcon_array_fetch_string(&field, relation, SL("fi"), PH_NOISY_CC);
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK);
PHALCON_INIT_VAR(referenced_field);
phalcon_array_fetch_string(&referenced_field, relation, SL("rf"), PH_NOISY_CC);
PHALCON_INIT_VAR(condition);
PHALCON_CONCAT_VS(condition, referenced_field, " = ?0");
phalcon_array_update_long(&conditions, 0, &condition, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
PHALCON_INIT_VAR(fields);
phalcon_array_fetch_string(&fields, relation, SL("fi"), PH_NOISY_CC);
if (!phalcon_valid_foreach(fields TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(fields);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_74b5_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_74b5_0;
}
PHALCON_INIT_VAR(field);
ZVAL_ZVAL(field, *hd, 1, 0);
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK);
PHALCON_INIT_VAR(r1);
phalcon_array_fetch_string(&r1, relation, SL("rf"), PH_NOISY_CC);
PHALCON_INIT_VAR(referenced_field);
phalcon_array_fetch(&referenced_field, r1, i, PH_NOISY_CC);
PHALCON_INIT_VAR(condition);
PHALCON_CONCAT_VSV(condition, referenced_field, " = ?", i);
phalcon_array_append(&conditions, condition, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC);
PHALCON_SEPARATE(i);
increment_function(i);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_74b5_0;
fee_74b5_0:
if(0){}
}
PHALCON_INIT_VAR(number_args);
PHALCON_CALL_FUNC(number_args, "func_num_args");
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 4);
PHALCON_ALLOC_ZVAL_MM(r2);
is_smaller_function(r2, t0, number_args TSRMLS_CC);
if (zend_is_true(r2)) {
PHALCON_INIT_VAR(function_arguments);
PHALCON_CALL_FUNC(function_arguments, "func_get_args");
if (!phalcon_valid_foreach(function_arguments TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(function_arguments);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_74b5_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_74b5_1;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah1, hp1);
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
PHALCON_INIT_VAR(t1);
ZVAL_LONG(t1, 0);
PHALCON_INIT_VAR(r3);
is_equal_function(r3, key, t1 TSRMLS_CC);
PHALCON_INIT_VAR(t2);
ZVAL_STRING(t2, "conditions", 1);
PHALCON_INIT_VAR(r4);
is_equal_function(r4, key, t2 TSRMLS_CC);
PHALCON_INIT_VAR(r5);
ZVAL_BOOL(r5, zend_is_true(r3) || zend_is_true(r4));
if (zend_is_true(r5)) {
phalcon_array_append(&conditions, value, PH_SEPARATE TSRMLS_CC);
}
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_74b5_1;
fee_74b5_1:
if(0){}
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, " AND ", 1);
PHALCON_INIT_VAR(join_conditions);
phalcon_fast_join(join_conditions, c0, conditions TSRMLS_CC);
PHALCON_INIT_VAR(find_params);
array_init(find_params);
phalcon_array_append(&find_params, join_conditions, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&find_params, SL("bind"), &placeholders, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_array_append(&arguments, find_params, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(reference_table);
phalcon_array_fetch_string(&reference_table, relation, SL("rt"), PH_NOISY_CC);
ce0 = phalcon_fetch_class(reference_table TSRMLS_CC);
PHALCON_INIT_VAR(referenced_entity);
object_init_ex(referenced_entity, ce0);
PHALCON_CALL_METHOD_NORETURN(referenced_entity, "__construct", PH_CHECK);
PHALCON_ALLOC_ZVAL_MM(r6);
PHALCON_CALL_METHOD(r6, record, "getconnectionservice", PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(referenced_entity, "setconnectionservice", r6, PH_NO_CHECK);
PHALCON_INIT_VAR(call_object);
array_init(call_object);
phalcon_array_append(&call_object, referenced_entity, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&call_object, method, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(records);
PHALCON_CALL_FUNC_PARAMS_2(records, "call_user_func_array", call_object, arguments);
RETURN_CCTOR(records);
}
/**
* Applies the internal format to the message
*
* @param string $message
* @param int $type
* @param int $time
* @return string
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, _applyFormat){
zval *message = NULL, *type = NULL, *time = NULL, *format = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL;
zval *t0 = NULL, *t1 = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &message, &type, &time) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!time) {
PHALCON_INIT_VAR(time);
ZVAL_LONG(time, 0);
} else {
PHALCON_SEPARATE_PARAM(time);
}
if (!zend_is_true(time)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_FUNC(r0, "time", 0x018);
PHALCON_CPY_WRT(time, r0);
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_format", sizeof("_format")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(format, t0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "%date%", 1);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_dateFormat", sizeof("_dateFormat")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_FUNC_PARAMS_2(r2, "date", t1, time, 0x04E);
PHALCON_CALL_FUNC_PARAMS_3(r1, "str_replace", c0, r2, format, 0x003);
PHALCON_CPY_WRT(format, r1);
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "%type%", 1);
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CALL_METHOD_PARAMS_1(r4, this_ptr, "gettypestring", type, PHALCON_NO_CHECK);
PHALCON_CALL_FUNC_PARAMS_3(r3, "str_replace", c1, r4, format, 0x003);
PHALCON_CPY_WRT(format, r3);
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, "%message%", 1);
PHALCON_CALL_FUNC_PARAMS_3(r5, "str_replace", c2, message, format, 0x003);
PHALCON_CPY_WRT(format, r5);
PHALCON_RETURN_CHECK_CTOR(format);
}
