/**
* 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;
}
/**
* Commits the transaction
*
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction, commit){
zval *manager = NULL, *call_object = NULL, *arguments = NULL, *connection = NULL;
zval *success = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(manager);
phalcon_read_property(&manager, this_ptr, SL("_manager"), PH_NOISY_CC);
if (zend_is_true(manager)) {
PHALCON_INIT_VAR(call_object);
array_init(call_object);
phalcon_array_append(&call_object, manager, PH_SEPARATE TSRMLS_CC);
add_next_index_stringl(call_object, SL("notifyCommit"), 1);
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_array_append(&arguments, this_ptr, PH_SEPARATE TSRMLS_CC);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("call_user_func_array", call_object, arguments);
}
PHALCON_INIT_VAR(connection);
phalcon_read_property(&connection, this_ptr, SL("_connection"), PH_NOISY_CC);
PHALCON_INIT_VAR(success);
PHALCON_CALL_METHOD(success, connection, "commit", PH_NO_CHECK);
RETURN_CCTOR(success);
}
/**
* Commits the transaction
*
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction, commit){
zval *manager = NULL, *connection = NULL;
zval *a0 = NULL, *a1 = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(manager);
phalcon_read_property(&manager, this_ptr, SL("_manager"), PH_NOISY_CC);
if (zend_is_true(manager)) {
PHALCON_ALLOC_ZVAL_MM(a0);
array_init(a0);
phalcon_array_append(&a0, manager, PH_SEPARATE TSRMLS_CC);
add_next_index_stringl(a0, SL("notifyCommit"), 1);
PHALCON_ALLOC_ZVAL_MM(a1);
array_init(a1);
phalcon_array_append(&a1, this_ptr, PH_SEPARATE TSRMLS_CC);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("call_user_func_array", a0, a1);
}
PHALCON_INIT_VAR(connection);
phalcon_read_property(&connection, this_ptr, SL("_connection"), PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, connection, "commit", PH_NO_CHECK);
RETURN_CTOR(r0);
}
/**
* Commits the transaction
*
* @return boolean
*/
PHP_METHOD(Phalcon_Transaction, commit){
zval *t0 = NULL, *t1 = NULL, *t2 = NULL;
zval *a0 = NULL, *a1 = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_manager", sizeof("_manager")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
if (!PHALCON_COMPARE_STRING(t0, "")) {
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_manager", sizeof("_manager")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
Z_ADDREF_P(t1);
PHALCON_SEPARATE_ARRAY(a0);
add_next_index_zval(a0, t1);
add_next_index_stringl(a0, "notifyCommit", strlen("notifyCommit"), 1);
Z_ADDREF_P(a0);
PHALCON_INIT_VAR(a1);
array_init(a1);
Z_ADDREF_P(this_ptr);
PHALCON_SEPARATE_ARRAY(a1);
add_next_index_zval(a1, this_ptr);
Z_ADDREF_P(a1);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("call_user_func_array", a0, a1, 0x001);
Z_DELREF_P(a0);
Z_DELREF_P(a1);
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_connection", sizeof("_connection")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_CALL_METHOD(r0, t2, "commit", PHALCON_CALL_DEFAULT);
PHALCON_RETURN_DZVAL(r0);
}
/**
* 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();
}
/**
* Commits the internal transaction
*
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, commit){
zval *message = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_transaction"), PH_NOISY_CC);
if (!zend_is_true(t0)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "There is no active transaction");
return;
}
phalcon_update_property_bool(this_ptr, SL("_transaction"), 0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, SL("_quenue"), PH_NOISY_CC);
if (!phalcon_valid_foreach(t1 TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(t1);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_654f_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_654f_1;
}
PHALCON_INIT_VAR(message);
ZVAL_ZVAL(message, *hd, 1, 0);
PHALCON_INIT_VAR(t2);
phalcon_read_property(&t2, this_ptr, SL("_fileHandler"), PH_NOISY_CC);
PHALCON_INIT_VAR(r0);
PHALCON_CALL_METHOD(r0, message, "getmessage", PH_NO_CHECK);
PHALCON_INIT_VAR(r1);
PHALCON_CALL_METHOD(r1, message, "gettype", PH_NO_CHECK);
PHALCON_INIT_VAR(r2);
PHALCON_CALL_METHOD(r2, message, "gettime", PH_NO_CHECK);
PHALCON_INIT_VAR(r3);
PHALCON_CALL_METHOD_PARAMS_3(r3, this_ptr, "_applyformat", r0, r1, r2, PH_NO_CHECK);
PHALCON_INIT_VAR(t3);
zend_get_constant(SL("PHP_EOL"), t3 TSRMLS_CC);
PHALCON_INIT_VAR(r4);
PHALCON_CONCAT_VV(r4, r3, t3);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("fputs", t2, r4);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_654f_1;
fee_654f_1:
if(0){}
PHALCON_MM_RESTORE();
}
/**
* 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();
}
PHP_METHOD(Phalcon_View_Engine_Mustache, __call){
zval *method = NULL, *arguments = NULL;
zval *a0 = NULL;
zval *t0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &method, &arguments) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_mustache"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_append(&a0, t0, PHALCON_SEPARATE_PLZ TSRMLS_CC);
phalcon_array_append(&a0, method, PHALCON_SEPARATE_PLZ TSRMLS_CC);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("call_user_func_array", a0, arguments);
PHALCON_MM_RESTORE();
}
/**
* Commits the internal transaction
*
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, commit){
zval *transaction = NULL, *file_handler = NULL, *quenue = NULL, *message = NULL;
zval *message_str = NULL, *type = NULL, *time = NULL, *applied_format = NULL;
zval *applied_eol = NULL;
zval *t0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(transaction);
phalcon_read_property(&transaction, this_ptr, SL("_transaction"), PH_NOISY_CC);
if (!zend_is_true(transaction)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "There is no active transaction");
return;
}
phalcon_update_property_bool(this_ptr, SL("_transaction"), 0 TSRMLS_CC);
PHALCON_INIT_VAR(file_handler);
phalcon_read_property(&file_handler, this_ptr, SL("_fileHandler"), PH_NOISY_CC);
PHALCON_INIT_VAR(quenue);
phalcon_read_property(&quenue, this_ptr, SL("_quenue"), PH_NOISY_CC);
if (!phalcon_valid_foreach(quenue TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(quenue);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_654f_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_654f_1;
}
PHALCON_INIT_VAR(message);
ZVAL_ZVAL(message, *hd, 1, 0);
PHALCON_INIT_VAR(message_str);
PHALCON_CALL_METHOD(message_str, message, "getmessage", PH_NO_CHECK);
PHALCON_INIT_VAR(type);
PHALCON_CALL_METHOD(type, message, "gettype", PH_NO_CHECK);
PHALCON_INIT_VAR(time);
PHALCON_CALL_METHOD(time, message, "gettime", PH_NO_CHECK);
PHALCON_INIT_VAR(applied_format);
PHALCON_CALL_METHOD_PARAMS_3(applied_format, this_ptr, "_applyformat", message_str, type, time, PH_NO_CHECK);
PHALCON_INIT_VAR(t0);
zend_get_constant(SL("PHP_EOL"), t0 TSRMLS_CC);
PHALCON_INIT_VAR(applied_eol);
PHALCON_CONCAT_VV(applied_eol, applied_format, t0);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("fputs", file_handler, applied_eol);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_654f_1;
fee_654f_1:
if(0){}
PHALCON_MM_RESTORE();
}
/**
* Stores cached content into the file backend and stops the frontend
*
* @param int|string $keyName
* @param string $content
* @param long $lifetime
* @param boolean $stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_File, save){
zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL;
zval *last_key = NULL, *prefix, *filtered, *frontend, *options;
zval *cache_dir, *cache_file, *cached_content = NULL;
zval *prepared_content, *is_buffering;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zzzz", &key_name, &content, &lifetime, &stop_buffer) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!key_name) {
PHALCON_INIT_NVAR(key_name);
}
if (!content) {
PHALCON_INIT_NVAR(content);
}
if (!lifetime) {
PHALCON_INIT_NVAR(lifetime);
}
if (!stop_buffer) {
PHALCON_INIT_NVAR(stop_buffer);
ZVAL_BOOL(stop_buffer, 1);
}
if (Z_TYPE_P(key_name) == IS_NULL) {
PHALCON_INIT_VAR(last_key);
phalcon_read_property(&last_key, this_ptr, SL("_lastKey"), PH_NOISY_CC);
} else {
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_NVAR(last_key);
PHALCON_CONCAT_VV(last_key, prefix, filtered);
}
if (!zend_is_true(last_key)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache must be started first");
return;
}
PHALCON_INIT_VAR(frontend);
phalcon_read_property(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
PHALCON_INIT_VAR(options);
phalcon_read_property(&options, this_ptr, SL("_options"), PH_NOISY_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, last_key);
if (!zend_is_true(content)) {
PHALCON_INIT_VAR(cached_content);
PHALCON_CALL_METHOD(cached_content, frontend, "getcontent", PH_NO_CHECK);
} else {
PHALCON_CPY_WRT(cached_content, content);
}
/**
* We use file_put_contents to repect open-base-dir directive
*/
PHALCON_INIT_VAR(prepared_content);
PHALCON_CALL_METHOD_PARAMS_1(prepared_content, frontend, "beforestore", cached_content, PH_NO_CHECK);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("file_put_contents", cache_file, prepared_content);
PHALCON_INIT_VAR(is_buffering);
PHALCON_CALL_METHOD(is_buffering, frontend, "isbuffering", PH_NO_CHECK);
if (PHALCON_IS_TRUE(stop_buffer)) {
PHALCON_CALL_METHOD_NORETURN(frontend, "stop", PH_NO_CHECK);
}
if (PHALCON_IS_TRUE(is_buffering)) {
zend_print_zval(cached_content, 0);
}
phalcon_update_property_bool(this_ptr, SL("_started"), 0 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* 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();
}
/**
* Rollbacks the transaction
*
* @param string $rollbackMessage
* @param Phalcon\Mvc\Model $rollbackRecord
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction, rollback){
zval *rollback_message = NULL, *rollback_record = NULL;
zval *manager = NULL, *call_object = NULL, *arguments = NULL, *connection = NULL;
zval *success = NULL, *exception = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zz", &rollback_message, &rollback_record) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!rollback_message) {
PHALCON_ALLOC_ZVAL_MM(rollback_message);
ZVAL_NULL(rollback_message);
} else {
PHALCON_SEPARATE_PARAM(rollback_message);
}
if (!rollback_record) {
PHALCON_ALLOC_ZVAL_MM(rollback_record);
ZVAL_NULL(rollback_record);
} else {
PHALCON_SEPARATE_PARAM(rollback_record);
}
PHALCON_INIT_VAR(manager);
phalcon_read_property(&manager, this_ptr, SL("_manager"), PH_NOISY_CC);
if (zend_is_true(manager)) {
PHALCON_INIT_VAR(call_object);
array_init(call_object);
phalcon_array_append(&call_object, manager, PH_SEPARATE TSRMLS_CC);
add_next_index_stringl(call_object, SL("notifyRollback"), 1);
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_array_append(&arguments, this_ptr, PH_SEPARATE TSRMLS_CC);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("call_user_func_array", call_object, arguments);
}
PHALCON_INIT_VAR(connection);
phalcon_read_property(&connection, this_ptr, SL("_connection"), PH_NOISY_CC);
PHALCON_INIT_VAR(success);
PHALCON_CALL_METHOD(success, connection, "rollback", PH_NO_CHECK);
if (zend_is_true(success)) {
if (!zend_is_true(rollback_message)) {
PHALCON_INIT_VAR(rollback_message);
ZVAL_STRING(rollback_message, "Transaction aborted", 1);
}
if (zend_is_true(rollback_record)) {
phalcon_update_property_zval(this_ptr, SL("_rollbackRecord"), rollback_record TSRMLS_CC);
}
PHALCON_INIT_VAR(rollback_record);
phalcon_read_property(&rollback_record, this_ptr, SL("_rollbackRecord"), PH_NOISY_CC);
PHALCON_INIT_VAR(exception);
object_init_ex(exception, phalcon_mvc_model_transaction_failed_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(exception, "__construct", rollback_message, rollback_record, PH_CHECK);
phalcon_throw_exception(exception TSRMLS_CC);
return;
}
PHALCON_MM_RESTORE();
}
/**
* Stores cached content into the file backend
*
* @param string $keyName
* @param string $content
* @param boolean $stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_File, save){
zval *key_name = NULL, *content = NULL, *stop_buffer = NULL, *last_key = NULL;
zval *front_end = NULL, *backend = NULL, *cache_dir = NULL, *cache_file = NULL;
zval *cached_content = NULL, *prepared_content = NULL, *is_buffering = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *i0 = NULL, *i1 = NULL;
zval *c0 = NULL, *c1 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zzz", &key_name, &content, &stop_buffer) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!key_name) {
PHALCON_INIT_VAR(key_name);
ZVAL_NULL(key_name);
}
if (!content) {
PHALCON_INIT_VAR(content);
ZVAL_NULL(content);
}
if (!stop_buffer) {
PHALCON_INIT_VAR(stop_buffer);
ZVAL_BOOL(stop_buffer, 1);
}
if (Z_TYPE_P(key_name) == IS_NULL) {
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_lastKey", sizeof("_lastKey")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(last_key, t0);
} else {
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_filter_alphanum(r0, key_name);
PHALCON_CPY_WRT(last_key, r0);
}
if (!zend_is_true(last_key)) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_cache_exception_ce);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "The cache must be started first", 1);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", c0, PHALCON_CHECK);
phalcon_throw_exception(i0 TSRMLS_CC);
return;
}
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(t2);
phalcon_read_property(&t2, this_ptr, "_backendOptions", sizeof("_backendOptions")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(backend, t2);
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch_string(&r1, backend, "cacheDir", strlen("cacheDir"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(cache_dir, r1);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CALL_FUNC_PARAMS_1(r2, "is_writable", cache_dir, 0x017);
if (!zend_is_true(r2)) {
PHALCON_ALLOC_ZVAL_MM(i1);
object_init_ex(i1, phalcon_cache_exception_ce);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "The cache file is not writable", 1);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i1, "__construct", c1, PHALCON_CHECK);
phalcon_throw_exception(i1 TSRMLS_CC);
return;
}
PHALCON_ALLOC_ZVAL_MM(r3);
concat_function(r3, cache_dir, last_key TSRMLS_CC);
PHALCON_CPY_WRT(cache_file, r3);
if (!zend_is_true(content)) {
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CALL_METHOD(r4, front_end, "getcontent", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(cached_content, r4);
} else {
PHALCON_CPY_WRT(cached_content, content);
}
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_CALL_METHOD_PARAMS_1(r5, front_end, "beforestore", cached_content, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(prepared_content, r5);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("file_put_contents", cache_file, prepared_content, 0x01B);
PHALCON_ALLOC_ZVAL_MM(r6);
PHALCON_CALL_METHOD(r6, front_end, "isbuffering", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(is_buffering, r6);
if (zend_is_true(stop_buffer)) {
PHALCON_CALL_METHOD_NORETURN(front_end, "stop", PHALCON_NO_CHECK);
}
if (zend_is_true(is_buffering)) {
zend_print_zval(cached_content, 1);
}
PHALCON_MM_RESTORE();
}
/**
* Rollbacks the transaction
*
* @param string $rollbackMessage
* @param Phalcon_Model_Base $rollbackRecord
* @return boolean
*/
PHP_METHOD(Phalcon_Transaction, rollback){
zval *v0 = NULL, *v1 = NULL, *v2 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL;
zval *a0 = NULL, *a1 = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *i0 = NULL;
zval *p2[] = { NULL, NULL };
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zz", &v0, &v1) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!v0) {
PHALCON_INIT_VAR(v0);
ZVAL_STRING(v0, "", 1);
} else {
PHALCON_SEPARATE_PARAM(v0);
}
if (!v1) {
PHALCON_INIT_VAR(v1);
ZVAL_NULL(v1);
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_manager", sizeof("_manager")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
if (!PHALCON_COMPARE_STRING(t0, "")) {
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_manager", sizeof("_manager")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
Z_ADDREF_P(t1);
PHALCON_SEPARATE_ARRAY(a0);
add_next_index_zval(a0, t1);
add_next_index_stringl(a0, "notifyRollback", strlen("notifyRollback"), 1);
Z_ADDREF_P(a0);
PHALCON_INIT_VAR(a1);
array_init(a1);
Z_ADDREF_P(this_ptr);
PHALCON_SEPARATE_ARRAY(a1);
add_next_index_zval(a1, this_ptr);
Z_ADDREF_P(a1);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("call_user_func_array", a0, a1, 0x001);
Z_DELREF_P(a0);
Z_DELREF_P(a1);
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_connection", sizeof("_connection")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_CALL_METHOD(r0, t2, "rollback", PHALCON_CALL_DEFAULT);
PHALCON_CPY_WRT(v2, r0);
PHALCON_INIT_VAR(t3);
ZVAL_BOOL(t3, 1);
PHALCON_ALLOC_ZVAL_MM(r1);
is_equal_function(r1, v2, t3 TSRMLS_CC);
if (zend_is_true(r1)) {
if (PHALCON_COMPARE_STRING(v0, "")) {
PHALCON_INIT_VAR(v0);
ZVAL_STRING(v0, "Transaction aborted", 1);
}
if (zend_is_true(v1)) {
phalcon_update_property_zval(this_ptr, "_rollbackRecord", strlen("_rollbackRecord"), v1 TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_transaction_failed_class_entry);
Z_ADDREF_P(v0);
p2[0] = v0;
PHALCON_ALLOC_ZVAL_MM(t4);
phalcon_read_property(&t4, this_ptr, "_rollbackRecord", sizeof("_rollbackRecord")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
Z_ADDREF_P(t4);
p2[1] = t4;
PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 2, p2, PHALCON_CALL_CHECK);
Z_DELREF_P(p2[0]);
Z_DELREF_P(p2[1]);
zend_throw_exception_object(i0 TSRMLS_CC);
Z_ADDREF_P(i0);
PHALCON_MM_RESTORE();
return;
}
PHALCON_MM_RESTORE();
RETURN_NULL();
}
