/**
* Merge modules with the existing ones
*
* @param array $modules
*/
PHP_METHOD(Phalcon_CLI_Console, addModules){
zval *modules, *original_modules, *register_modules;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &modules) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(modules) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cli_console_exception_ce, "Modules must be an Array");
return;
}
PHALCON_INIT_VAR(original_modules);
phalcon_read_property(&original_modules, this_ptr, SL("_modules"), PH_NOISY_CC);
PHALCON_INIT_VAR(register_modules);
PHALCON_CALL_FUNC_PARAMS_2(register_modules, "array_merge", modules, original_modules);
phalcon_update_property_zval(this_ptr, SL("_modules"), register_modules TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Pass any call to the internal adapter object
*
* @param string $method
* @param array $arguments
* @return mixed
*/
PHP_METHOD(Phalcon_Logger, __call){
zval *method = NULL, *arguments = NULL;
zval *a0 = NULL, *a1 = NULL;
zval *r0 = NULL;
zval *t0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &method, &arguments) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!arguments) {
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(arguments, a0);
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_INIT_VAR(a1);
array_init(a1);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_adapter", sizeof("_adapter")-1, PHALCON_NOISY TSRMLS_CC);
phalcon_array_append(&a1, t0, PHALCON_SEPARATE_PLZ TSRMLS_CC);
phalcon_array_append(&a1, method, PHALCON_SEPARATE_PLZ TSRMLS_CC);
PHALCON_CALL_FUNC_PARAMS_2(r0, "call_user_func_array", a1, arguments, 0x013);
PHALCON_RETURN_DZVAL(r0);
}
/**
* Opens the internal file handler after unserialization
*
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, __wakeup){
zval *path = NULL, *options = NULL, *mode = NULL, *file_handler = NULL;
int eval_int;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(path);
phalcon_read_property(&path, this_ptr, SL("_path"), PH_NOISY_CC);
PHALCON_INIT_VAR(options);
phalcon_read_property(&options, this_ptr, SL("_options"), PH_NOISY_CC);
eval_int = phalcon_array_isset_string(options, SL("mode")+1);
if (eval_int) {
PHALCON_INIT_VAR(mode);
phalcon_array_fetch_string(&mode, options, SL("mode"), PH_NOISY_CC);
} else {
PHALCON_INIT_VAR(mode);
ZVAL_STRING(mode, "ab", 1);
}
PHALCON_INIT_VAR(file_handler);
PHALCON_CALL_FUNC_PARAMS_2(file_handler, "fopen", path, mode);
phalcon_update_property_zval(this_ptr, SL("_fileHandler"), file_handler TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Register classes and their locations
*
* @param array $classes
* @param boolean $merge
* @return Phalcon\Loader
*/
PHP_METHOD(Phalcon_Loader, registerClasses){
zval *classes, *merge = NULL, *current_classes, *merged_classes;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &classes, &merge) == FAILURE) {
RETURN_MM_NULL();
}
if (!merge) {
PHALCON_INIT_VAR(merge);
ZVAL_BOOL(merge, 0);
}
if (Z_TYPE_P(classes) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_loader_exception_ce, "Parameter $classes must be an Array");
return;
}
if (zend_is_true(merge)) {
PHALCON_OBS_VAR(current_classes);
phalcon_read_property(¤t_classes, this_ptr, SL("_classes"), PH_NOISY_CC);
PHALCON_INIT_VAR(merged_classes);
PHALCON_CALL_FUNC_PARAMS_2(merged_classes, "array_merge", current_classes, classes);
phalcon_update_property_zval(this_ptr, SL("_classes"), merged_classes TSRMLS_CC);
} else {
phalcon_update_property_zval(this_ptr, SL("_classes"), classes TSRMLS_CC);
}
RETURN_THIS();
}
/**
* Checks whether request has been made using SOAP
*
* @return boolean
*/
PHP_METHOD(Phalcon_Request, isSoapRequested){
zval *g0 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
zval *c0 = NULL;
zval *t0 = NULL;
int eval_int;
PHALCON_MM_GROW();
phalcon_get_global(&g0, "_SERVER", sizeof("_SERVER") TSRMLS_CC);
eval_int = phalcon_array_isset_string(g0, "HTTP_SOAPACTION", strlen("HTTP_SOAPACTION")+1);
if (eval_int) {
PHALCON_MM_RESTORE();
RETURN_TRUE;
} else {
eval_int = phalcon_array_isset_string(g0, "CONTENT_TYPE", strlen("CONTENT_TYPE")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch_string(&r1, g0, "CONTENT_TYPE", strlen("CONTENT_TYPE"), PHALCON_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "application/soap+xml", 1);
PHALCON_CALL_FUNC_PARAMS_2(r0, "strpos", r1, c0, 0x00E);
PHALCON_INIT_VAR(t0);
ZVAL_BOOL(t0, 0);
PHALCON_INIT_VAR(r2);
is_not_identical_function(r2, t0, r0 TSRMLS_CC);
PHALCON_RETURN_NCTOR(r2);
}
}
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
/**
* Adds a route applying the common attributes
*
* @param string $patten
* @param array $paths
* @param array $httpMethods
* @return Phalcon\Mvc\Router\Route
*/
PHP_METHOD(Phalcon_Mvc_Router_Group, _addRoute){
zval *pattern, *paths = NULL, *http_methods = NULL, *prefix, *prefix_pattern;
zval *default_paths, *merged_paths = NULL, *route;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|zz", &pattern, &paths, &http_methods) == FAILURE) {
RETURN_MM_NULL();
}
if (!paths) {
PHALCON_INIT_VAR(paths);
}
if (!http_methods) {
PHALCON_INIT_VAR(http_methods);
}
PHALCON_OBS_VAR(prefix);
phalcon_read_property(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC);
/**
* Add the prefix to the pattern
*/
PHALCON_INIT_VAR(prefix_pattern);
PHALCON_CONCAT_VV(prefix_pattern, prefix, pattern);
PHALCON_OBS_VAR(default_paths);
phalcon_read_property(&default_paths, this_ptr, SL("_paths"), PH_NOISY_CC);
/**
* Check if the paths need to be merged with current paths
*/
if (Z_TYPE_P(default_paths) == IS_ARRAY) {
if (Z_TYPE_P(paths) == IS_ARRAY) {
/**
* Merge the paths with the default paths
*/
PHALCON_INIT_VAR(merged_paths);
PHALCON_CALL_FUNC_PARAMS_2(merged_paths, "array_merge", default_paths, paths);
} else {
PHALCON_CPY_WRT(merged_paths, default_paths);
}
} else {
PHALCON_CPY_WRT(merged_paths, paths);
}
/**
* Every route is internally stored as a Phalcon\Mvc\Router\Route
*/
PHALCON_INIT_VAR(route);
object_init_ex(route, phalcon_mvc_router_route_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(route, "__construct", prefix_pattern, merged_paths, http_methods);
phalcon_update_property_array_append(this_ptr, SL("_routes"), route TSRMLS_CC);
RETURN_CTOR(route);
}
/**
* Uncamelize strings which are camelized
*
*<code>
* echo Phalcon\Text::camelize('CocoBongo'); //coco_bongo
*</code>
*
* @param string $str
* @return string
*/
PHP_METHOD(Phalcon_Text, uncamelize){
zval *str = NULL, *patterns = NULL, *replacement = NULL, *pattern = NULL, *match_pattern = NULL;
zval *pattern_replace = NULL, *lower_pattern = NULL, *lower_str = 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, "z", &str) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(patterns);
array_init(patterns);
add_assoc_stringl_ex(patterns, SL("/(?<=(?:[A-Z]))([A-Z]+)([A-Z][A-z])/")+1, SL("\\1_\\2"), 1);
add_assoc_stringl_ex(patterns, SL("/(?<=(?:[a-z]))([A-Z])/")+1, SL("_\\1"), 1);
if (!phalcon_valid_foreach(patterns TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(patterns);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_f8ee_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_f8ee_0;
}
PHALCON_INIT_VAR(pattern);
PHALCON_GET_FOREACH_KEY(pattern, ah0, hp0);
PHALCON_INIT_VAR(replacement);
ZVAL_ZVAL(replacement, *hd, 1, 0);
PHALCON_INIT_VAR(match_pattern);
PHALCON_CALL_FUNC_PARAMS_2(match_pattern, "preg_match", pattern, str);
if (zend_is_true(match_pattern)) {
PHALCON_INIT_VAR(pattern_replace);
PHALCON_CALL_FUNC_PARAMS_3(pattern_replace, "preg_replace", pattern, replacement, str);
PHALCON_INIT_VAR(lower_pattern);
PHALCON_CALL_FUNC_PARAMS_1(lower_pattern, "strtolower", pattern_replace);
RETURN_CTOR(lower_pattern);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_f8ee_0;
fee_f8ee_0:
PHALCON_INIT_VAR(lower_str);
PHALCON_CALL_FUNC_PARAMS_1(lower_str, "strtolower", str);
RETURN_CTOR(lower_str);
}
/**
* 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();
}
/**
* Appends an array of messages to the group
*
*<code>
* $messages->appendMessages($messagesArray);
*</code>
*
* @param Phalcon\Validation\MessageInterface[] $messages
*/
PHP_METHOD(Phalcon_Validation_Message_Group, appendMessages){
zval *messages, *current_messages, *final_messages = NULL;
zval *message = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &messages) == FAILURE) {
RETURN_MM_NULL();
}
if (Z_TYPE_P(messages) != IS_ARRAY) {
if (Z_TYPE_P(messages) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "The messages must be array or object");
return;
}
}
PHALCON_OBS_VAR(current_messages);
phalcon_read_property(¤t_messages, this_ptr, SL("_messages"), PH_NOISY_CC);
if (Z_TYPE_P(messages) == IS_ARRAY) {
/**
* An array of messages is simply merged into the current one
*/
if (Z_TYPE_P(current_messages) == IS_ARRAY) {
PHALCON_INIT_VAR(final_messages);
PHALCON_CALL_FUNC_PARAMS_2(final_messages, "array_merge", current_messages, messages);
} else {
PHALCON_CPY_WRT(final_messages, messages);
}
phalcon_update_property_zval(this_ptr, SL("_messages"), final_messages TSRMLS_CC);
} else {
/**
* A group of messages is iterated and appended one-by-one to the current list
*/
PHALCON_CALL_METHOD_NORETURN(messages, "rewind");
while (1) {
PHALCON_INIT_NVAR(r0);
PHALCON_CALL_METHOD(r0, messages, "valid");
if (PHALCON_IS_NOT_FALSE(r0)) {
} else {
break;
}
PHALCON_INIT_NVAR(message);
PHALCON_CALL_METHOD(message, messages, "current");
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "appendmessage", message);
PHALCON_CALL_METHOD_NORETURN(messages, "next");
}
}
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);
}
/**
* Phalcon_Logger_Adapter_File constructor
*
* @param string $name
* @param array $options
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, __construct){
zval *name = NULL, *options = NULL, *mode = NULL;
zval *a0 = NULL, *a1 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
zval *t0 = NULL;
zval *i0 = NULL;
int eval_int;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(a0);
array_init(a0);
zend_update_property(phalcon_logger_adapter_file_ce, this_ptr, "_quenue", strlen("_quenue"), a0 TSRMLS_CC);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &name, &options) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!options) {
PHALCON_INIT_VAR(a1);
array_init(a1);
PHALCON_CPY_WRT(options, a1);
}
eval_int = phalcon_array_isset_string(options, "mode", strlen("mode")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, options, "mode", strlen("mode"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(mode, r0);
} else {
PHALCON_INIT_VAR(mode);
ZVAL_STRING(mode, "ab", 1);
}
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_FUNC_PARAMS_2(r1, "fopen", name, mode, 0x025);
phalcon_update_property_zval(this_ptr, "_fileHandler", strlen("_fileHandler"), r1 TSRMLS_CC);
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_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_logger_exception_ce);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CONCAT_SVS(r2, "Can't open log file at '", name, "'");
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", r2, PHALCON_CHECK);
phalcon_throw_exception(i0 TSRMLS_CC);
return;
}
PHALCON_MM_RESTORE();
}
/**
* Sends SQL statements to the MySQL database server returning success state.
* When the SQL sent have returned any row, the result is a PHP resource.
*
*
* $resultset = $connection->query("SELECT * FROM robots WHERE type=?", array("mechanical"));
*
* @param string $sqlStatement
* @return Phalcon_Db_Result_Mysql|boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Mysql, query){
zval *sql_statement = NULL, *id_connection = NULL, *result = NULL;
zval *number_error = NULL, *error_message = NULL;
zval *t0 = NULL;
zval *i0 = NULL, *i1 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &sql_statement) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "_beforequery", sql_statement, PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_idConnection"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(id_connection, t0);
PHALCON_INIT_VAR(result);
PHALCON_CALL_FUNC_PARAMS_2(result, "mysqli_query", id_connection, sql_statement);
if (zend_is_true(result)) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "_afterquery", sql_statement, PHALCON_NO_CHECK);
if (Z_TYPE_P(result) == IS_OBJECT) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_db_result_mysql_ce);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", result, PHALCON_CHECK);
RETURN_CTOR(i0);
}
RETURN_CHECK_CTOR(result);
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, this_ptr, "noerror", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(number_error, r0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CONCAT_SVS(r2, " when executing \"", sql_statement, "\"");
PHALCON_CALL_METHOD_PARAMS_1(r1, this_ptr, "error", r2, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(error_message, r1);
PHALCON_ALLOC_ZVAL_MM(i1);
object_init_ex(i1, phalcon_db_exception_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(i1, "__construct", error_message, number_error, PHALCON_CHECK);
phalcon_throw_exception(i1 TSRMLS_CC);
return;
}
/**
* Executes validator
*
* @return boolean
*/
PHP_METHOD(Phalcon_Model_Validator_Exclusionin, validate) {
zval *domain = NULL, *field_name = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL, *c3 = NULL;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, this_ptr, "isrequired", PHALCON_NO_CHECK);
if (zend_is_true(r0)) {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "domain", 1);
PHALCON_CALL_METHOD_PARAMS_1(r1, this_ptr, "issetoption", c0, PHALCON_NO_CHECK);
if (zend_is_true(r1)) {
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "domain", 1);
PHALCON_CALL_METHOD_PARAMS_1(r2, this_ptr, "getoption", c1, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(domain, r2);
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CALL_METHOD(r4, this_ptr, "getvalue", PHALCON_NO_CHECK);
PHALCON_CALL_FUNC_PARAMS_2(r3, "in_array", r4, domain, 0x03E);
if (zend_is_true(r3)) {
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_CALL_METHOD(r5, this_ptr, "getfieldname", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(field_name, r5);
PHALCON_ALLOC_ZVAL_MM(r6);
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, ", ", 1);
PHALCON_ALLOC_ZVAL_MM(r7);
phalcon_fast_join(r7, c2, domain TSRMLS_CC);
PHALCON_CONCAT_SVSV(r6, "Value of field '", field_name, "' must not be part of list: ", r7);
PHALCON_INIT_VAR(c3);
ZVAL_STRING(c3, "exclusion", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", r6, field_name, c3, PHALCON_NO_CHECK);
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* Returns the numeric active version
*
* @return int
*/
PHP_METHOD(Phalcon_Version, getId){
zval *version = NULL, *major, *medium, *minor, *special, *special_number;
zval *format, *real_medium, *real_minor;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(version);
PHALCON_CALL_SELF(version, this_ptr, "_getversion");
PHALCON_INIT_VAR(major);
phalcon_array_fetch_long(&major, version, 0, PH_NOISY_CC);
PHALCON_INIT_VAR(medium);
phalcon_array_fetch_long(&medium, version, 1, PH_NOISY_CC);
PHALCON_INIT_VAR(minor);
phalcon_array_fetch_long(&minor, version, 2, PH_NOISY_CC);
PHALCON_INIT_VAR(special);
phalcon_array_fetch_long(&special, version, 3, PH_NOISY_CC);
PHALCON_INIT_VAR(special_number);
phalcon_array_fetch_long(&special_number, version, 4, PH_NOISY_CC);
PHALCON_INIT_VAR(format);
ZVAL_STRING(format, "%02s", 1);
PHALCON_INIT_VAR(real_medium);
PHALCON_CALL_FUNC_PARAMS_2(real_medium, "sprintf", format, medium);
PHALCON_INIT_VAR(real_minor);
PHALCON_CALL_FUNC_PARAMS_2(real_minor, "sprintf", format, minor);
PHALCON_INIT_NVAR(version);
PHALCON_CONCAT_VVVVV(version, major, real_medium, real_minor, special, special_number);
RETURN_CCTOR(version);
}
/**
* Phalcon\Logger\Adapter\File constructor
*
* @param string $name
* @param array $options
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, __construct){
zval *name = NULL, *options = NULL, *mode = NULL, *handler = NULL, *exception_message = NULL;
zval *exception = NULL;
zval *a0 = NULL;
int eval_int;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(a0);
array_init(a0);
zend_update_property(phalcon_logger_adapter_file_ce, this_ptr, SL("_quenue"), a0 TSRMLS_CC);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &name, &options) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!options) {
PHALCON_INIT_VAR(options);
array_init(options);
}
eval_int = phalcon_array_isset_string(options, SL("mode")+1);
if (eval_int) {
PHALCON_INIT_VAR(mode);
phalcon_array_fetch_string(&mode, options, SL("mode"), PH_NOISY_CC);
} else {
PHALCON_INIT_VAR(mode);
ZVAL_STRING(mode, "ab", 1);
}
PHALCON_INIT_VAR(handler);
PHALCON_CALL_FUNC_PARAMS_2(handler, "fopen", name, mode);
if (!zend_is_true(handler)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Can't open log file at '", name, "'");
PHALCON_INIT_VAR(exception);
object_init_ex(exception, phalcon_logger_exception_ce);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(exception, "__construct", exception_message, PH_CHECK);
phalcon_throw_exception(exception TSRMLS_CC);
return;
}
phalcon_update_property_zval(this_ptr, SL("_path"), name TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_options"), options TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_fileHandler"), handler TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Phalcon\Logger\Adapter\File constructor
*
* @param string $name
* @param array $options
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, __construct){
zval *name, *options = NULL, *mode = NULL, *handler, *exception_message;
zval *a0 = NULL;
int eval_int;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(a0);
array_init(a0);
zend_update_property(phalcon_logger_adapter_file_ce, this_ptr, SL("_quenue"), a0 TSRMLS_CC);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &name, &options) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!options) {
PHALCON_INIT_NVAR(options);
array_init(options);
}
eval_int = phalcon_array_isset_string(options, SS("mode"));
if (eval_int) {
PHALCON_INIT_VAR(mode);
phalcon_array_fetch_string(&mode, options, SL("mode"), PH_NOISY_CC);
} else {
PHALCON_INIT_NVAR(mode);
ZVAL_STRING(mode, "ab", 1);
}
if (phalcon_memnstr_str(mode, SL("r") TSRMLS_CC)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "Logger must be opened in append or write mode");
return;
}
PHALCON_INIT_VAR(handler);
PHALCON_CALL_FUNC_PARAMS_2(handler, "fopen", name, mode);
if (!zend_is_true(handler)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Can't open log file at '", name, "'");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_logger_exception_ce, exception_message);
return;
}
phalcon_update_property_zval(this_ptr, SL("_path"), name TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_options"), options TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_fileHandler"), handler TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Opens the internal file handler after unserialization
*
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, __wakeup){
zval *t0 = NULL;
zval *c0 = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_path"), PH_NOISY_CC);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "ab", 1);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_FUNC_PARAMS_2(r0, "fopen", t0, c0);
phalcon_update_property_zval(this_ptr, SL("_fileHandler"), r0 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Opens the internal file handler after unserialization
*
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, __wakeup){
zval *path = NULL, *file_handler = NULL;
zval *c0 = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(path);
phalcon_read_property(&path, this_ptr, SL("_path"), PH_NOISY_CC);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "ab", 1);
PHALCON_INIT_VAR(file_handler);
PHALCON_CALL_FUNC_PARAMS_2(file_handler, "fopen", path, c0);
phalcon_update_property_zval(this_ptr, SL("_fileHandler"), file_handler TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Escapes a value to avoid SQL injections
*
* @param string $str
* @return string
*/
PHP_METHOD(Phalcon_Db_Adapter_Mysql, escapeString){
zval *str = NULL;
zval *t0 = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &str) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_idConnection"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_FUNC_PARAMS_2(r0, "mysqli_real_escape_string", t0, str);
RETURN_DZVAL(r0);
}
/**
* Writes parsed annotations to files
*
* @param string $key
* @param array $data
*/
PHP_METHOD(Phalcon_Annotations_Adapter_Files, write){
zval *key, *data, *annotations_dir, *separator;
zval *virtual_key, *path, *to_string, *export, *php_export;
zval *status;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &key, &data) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_OBS_VAR(annotations_dir);
phalcon_read_property_this(&annotations_dir, this_ptr, SL("_annotationsDir"), PH_NOISY_CC);
PHALCON_INIT_VAR(separator);
ZVAL_STRING(separator, "_", 1);
PHALCON_INIT_VAR(virtual_key);
phalcon_prepare_virtual_path(virtual_key, key, separator TSRMLS_CC);
PHALCON_INIT_VAR(path);
PHALCON_CONCAT_VVS(path, annotations_dir, virtual_key, ".php");
PHALCON_INIT_VAR(to_string);
ZVAL_BOOL(to_string, 1);
PHALCON_INIT_VAR(export);
PHALCON_CALL_FUNC_PARAMS_2(export, "var_export", data, to_string);
PHALCON_INIT_VAR(php_export);
PHALCON_CONCAT_SVS(php_export, "<?php return ", export, "; ");
PHALCON_INIT_VAR(status);
PHALCON_CALL_FUNC_PARAMS_2(status, "file_put_contents", path, php_export);
if (PHALCON_IS_FALSE(status)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_annotations_exception_ce, "Annotations directory cannot be written");
return;
}
PHALCON_MM_RESTORE();
}
/**
* Gets hasOne relations defined on a model
*
* @param Phalcon\Mvc\Model $model
* @return array
*/
PHP_METHOD(Phalcon_Mvc_Model_Manager, getHasOneAndHasMany){
zval *model = NULL, *has_one = NULL, *has_many = NULL, *merge = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &model) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(has_one);
PHALCON_CALL_METHOD_PARAMS_1(has_one, this_ptr, "gethasone", model, PH_NO_CHECK);
PHALCON_INIT_VAR(has_many);
PHALCON_CALL_METHOD_PARAMS_1(has_many, this_ptr, "gethasmany", model, PH_NO_CHECK);
PHALCON_INIT_VAR(merge);
PHALCON_CALL_FUNC_PARAMS_2(merge, "array_merge", has_one, has_many);
RETURN_CCTOR(merge);
}
/**
* Helper method to query records based on a relation definition
*
* @param array $relation
* @param string $method
* @param Phalcon\Mvc\Model $record
* @param array $parameters
* @return Phalcon\Mvc\Model\Resultset\Simple
*/
PHP_METHOD(Phalcon_Mvc_Model_Manager, _getRelationRecords){
zval *relation = NULL, *method = NULL, *record = NULL, *parameters = NULL, *placeholders = NULL;
zval *pre_conditions = NULL, *conditions = NULL, *fields = NULL, *field = NULL;
zval *value = NULL, *referenced_field = NULL, *condition = NULL, *i = NULL;
zval *referenced_fields = NULL, *join_conditions = NULL;
zval *find_params = NULL, *find_arguments = NULL, *arguments = NULL;
zval *reference_table = NULL, *referenced_entity = NULL;
zval *connection_service = NULL, *call_object = NULL, *records = NULL;
zval *c0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
zend_class_entry *ce0;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|z", &relation, &method, &record, ¶meters) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!parameters) {
PHALCON_ALLOC_ZVAL_MM(parameters);
ZVAL_NULL(parameters);
} else {
PHALCON_SEPARATE_PARAM(parameters);
}
if (Z_TYPE_P(parameters) == IS_ARRAY) {
eval_int = phalcon_array_isset_string(parameters, SL("bind")+1);
if (eval_int) {
PHALCON_INIT_VAR(placeholders);
phalcon_array_fetch_string(&placeholders, parameters, SL("bind"), PH_NOISY_CC);
PHALCON_SEPARATE_PARAM(parameters);
phalcon_array_unset_string(parameters, SL("bind")+1);
} else {
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
}
} else {
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
}
PHALCON_INIT_VAR(pre_conditions);
ZVAL_NULL(pre_conditions);
if (Z_TYPE_P(parameters) == IS_ARRAY) {
eval_int = phalcon_array_isset_long(parameters, 0);
if (eval_int) {
PHALCON_INIT_VAR(pre_conditions);
phalcon_array_fetch_long(&pre_conditions, parameters, 0, PH_NOISY_CC);
PHALCON_SEPARATE_PARAM(parameters);
phalcon_array_unset_long(parameters, 0);
} else {
eval_int = phalcon_array_isset_string(parameters, SL("conditions")+1);
if (eval_int) {
PHALCON_INIT_VAR(pre_conditions);
phalcon_array_fetch_string(&pre_conditions, parameters, SL("conditions"), PH_NOISY_CC);
PHALCON_SEPARATE_PARAM(parameters);
phalcon_array_unset_string(parameters, SL("conditions")+1);
}
}
} else {
if (Z_TYPE_P(parameters) == IS_STRING) {
PHALCON_CPY_WRT(pre_conditions, parameters);
}
}
if (Z_TYPE_P(pre_conditions) != IS_NULL) {
PHALCON_INIT_VAR(conditions);
array_init(conditions);
phalcon_array_append(&conditions, pre_conditions, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(conditions);
array_init(conditions);
}
PHALCON_INIT_VAR(fields);
phalcon_array_fetch_string(&fields, relation, SL("fi"), PH_NOISY_CC);
if (Z_TYPE_P(fields) != IS_ARRAY) {
PHALCON_CPY_WRT(field, fields);
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_append(&conditions, condition, 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(referenced_fields);
phalcon_array_fetch_string(&referenced_fields, relation, SL("rf"), 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(referenced_field);
phalcon_array_fetch(&referenced_field, referenced_fields, 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(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);
if (Z_TYPE_P(parameters) == IS_ARRAY) {
PHALCON_INIT_VAR(find_arguments);
PHALCON_CALL_FUNC_PARAMS_2(find_arguments, "array_merge", find_params, parameters);
} else {
PHALCON_CPY_WRT(find_arguments, find_params);
}
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_array_append(&arguments, find_arguments, 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_INIT_VAR(connection_service);
PHALCON_CALL_METHOD(connection_service, record, "getconnectionservice", PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(referenced_entity, "setconnectionservice", connection_service, 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);
}
/**
* 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 a format to a message before sent it to the internal log
*
* @param string $message
* @param int $type
* @param int $timestamp
*/
PHP_METHOD(Phalcon_Logger_Formatter_Line, format) {
zval *message, *type, *timestamp, *format = NULL, *date_format;
zval *date, *date_wildcard, *new_format = NULL, *type_string;
zval *type_wildcard, *message_wildcard, *eol = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &message, &type, ×tamp) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_OBS_VAR(format);
phalcon_read_property(&format, this_ptr, SL("_format"), PH_NOISY_CC);
/**
* Check if the format has the %date% placeholder
*/
if (phalcon_memnstr_str(format, SL("%date%") TSRMLS_CC)) {
PHALCON_OBS_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, timestamp);
PHALCON_INIT_VAR(date_wildcard);
ZVAL_STRING(date_wildcard, "%date%", 1);
PHALCON_INIT_VAR(new_format);
phalcon_fast_str_replace(new_format, date_wildcard, date, format TSRMLS_CC);
} else {
PHALCON_CPY_WRT(new_format, format);
}
/**
* Check if the format has the %type% placeholder
*/
if (phalcon_memnstr_str(format, SL("%type%") TSRMLS_CC)) {
PHALCON_INIT_VAR(type_string);
PHALCON_CALL_METHOD_PARAMS_1(type_string, this_ptr, "gettypestring", type);
PHALCON_INIT_VAR(type_wildcard);
ZVAL_STRING(type_wildcard, "%type%", 1);
PHALCON_INIT_NVAR(format);
phalcon_fast_str_replace(format, type_wildcard, type_string, new_format TSRMLS_CC);
} else {
PHALCON_CPY_WRT(format, new_format);
}
PHALCON_INIT_VAR(message_wildcard);
ZVAL_STRING(message_wildcard, "%message%", 1);
PHALCON_INIT_NVAR(new_format);
phalcon_fast_str_replace(new_format, message_wildcard, message, format TSRMLS_CC);
PHALCON_INIT_VAR(eol);
PHALCON_INIT_NVAR(eol);
ZVAL_STRING(eol, PHP_EOL, 1);
PHALCON_INIT_NVAR(format);
PHALCON_CONCAT_VV(format, new_format, eol);
RETURN_CCTOR(format);
}
/**
* Handles routing information received from the rewrite engine
*
* @param string $uri
*/
PHP_METHOD(Phalcon_Mvc_Router, handle){
zval *uri = NULL, *real_uri = NULL, *request = NULL, *route_found = NULL, *parts = NULL;
zval *params = NULL, *matches = NULL, *routes = NULL, *reversed_routes = NULL;
zval *route = NULL, *methods = NULL, *dependency_injector = NULL;
zval *match_method = NULL, *pattern = NULL, *paths = NULL, *position = NULL;
zval *part = NULL, *match_position = NULL, *module = NULL, *default_module = NULL;
zval *controller = NULL, *default_controller = NULL, *action = NULL;
zval *default_action = NULL, *params_str = NULL, *str_params = NULL;
zval *params_merge = NULL, *default_params = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &uri) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!uri) {
PHALCON_ALLOC_ZVAL_MM(uri);
ZVAL_NULL(uri);
}
if (!zend_is_true(uri)) {
PHALCON_INIT_VAR(real_uri);
PHALCON_CALL_METHOD(real_uri, this_ptr, "_getrewriteuri", PH_NO_CHECK);
} else {
PHALCON_CPY_WRT(real_uri, uri);
}
PHALCON_INIT_VAR(request);
ZVAL_NULL(request);
PHALCON_INIT_VAR(route_found);
ZVAL_BOOL(route_found, 0);
PHALCON_INIT_VAR(parts);
array_init(parts);
PHALCON_INIT_VAR(params);
array_init(params);
PHALCON_INIT_VAR(matches);
array_init(matches);
phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 0 TSRMLS_CC);
PHALCON_INIT_VAR(routes);
phalcon_read_property(&routes, this_ptr, SL("_routes"), PH_NOISY_CC);
PHALCON_INIT_VAR(reversed_routes);
PHALCON_CALL_FUNC_PARAMS_1(reversed_routes, "array_reverse", routes);
if (!phalcon_valid_foreach(reversed_routes TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(reversed_routes);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_c9ff_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_c9ff_0;
}
PHALCON_INIT_VAR(route);
ZVAL_ZVAL(route, *hd, 1, 0);
PHALCON_INIT_VAR(methods);
PHALCON_CALL_METHOD(methods, route, "gethttpmethods", PH_NO_CHECK);
if (Z_TYPE_P(methods) != IS_NULL) {
if (Z_TYPE_P(request) == IS_NULL) {
PHALCON_INIT_VAR(dependency_injector);
phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_dispatcher_exception_ce, "A dependency injection container is required to access the 'request' service");
return;
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "request", 1);
PHALCON_INIT_VAR(request);
PHALCON_CALL_METHOD_PARAMS_1(request, dependency_injector, "getshared", c0, PH_NO_CHECK);
}
PHALCON_INIT_VAR(match_method);
PHALCON_CALL_METHOD_PARAMS_1(match_method, request, "ismethod", methods, PH_NO_CHECK);
if (!zend_is_true(match_method)) {
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_c9ff_0;
}
}
PHALCON_INIT_VAR(pattern);
PHALCON_CALL_METHOD(pattern, route, "getcompiledpattern", PH_NO_CHECK);
Z_SET_ISREF_P(matches);
PHALCON_INIT_VAR(route_found);
PHALCON_CALL_FUNC_PARAMS_3(route_found, "preg_match", pattern, real_uri, matches);
Z_UNSET_ISREF_P(matches);
if (zend_is_true(route_found)) {
PHALCON_INIT_VAR(paths);
PHALCON_CALL_METHOD(paths, route, "getpaths", PH_NO_CHECK);
PHALCON_CPY_WRT(parts, paths);
if (!phalcon_valid_foreach(paths TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(paths);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_c9ff_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_c9ff_1;
}
PHALCON_INIT_VAR(part);
PHALCON_GET_FOREACH_KEY(part, ah1, hp1);
PHALCON_INIT_VAR(position);
ZVAL_ZVAL(position, *hd, 1, 0);
eval_int = phalcon_array_isset(matches, position);
if (eval_int) {
PHALCON_INIT_VAR(match_position);
phalcon_array_fetch(&match_position, matches, position, PH_NOISY_CC);
phalcon_array_update_zval(&parts, part, &match_position, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_c9ff_1;
fee_c9ff_1:
phalcon_update_property_zval(this_ptr, SL("_matches"), matches TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_matchedRoute"), route TSRMLS_CC);
goto fee_c9ff_0;
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_c9ff_0;
fee_c9ff_0:
if (zend_is_true(route_found)) {
eval_int = phalcon_array_isset_string(parts, SL("module")+1);
if (eval_int) {
PHALCON_INIT_VAR(module);
phalcon_array_fetch_string(&module, parts, SL("module"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_module"), module TSRMLS_CC);
PHALCON_SEPARATE(parts);
phalcon_array_unset_string(parts, SL("module")+1);
} else {
PHALCON_INIT_VAR(default_module);
phalcon_read_property(&default_module, this_ptr, SL("_defaultModule"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_module"), default_module TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(parts, SL("controller")+1);
if (eval_int) {
PHALCON_INIT_VAR(controller);
phalcon_array_fetch_string(&controller, parts, SL("controller"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_controller"), controller TSRMLS_CC);
PHALCON_SEPARATE(parts);
phalcon_array_unset_string(parts, SL("controller")+1);
} else {
PHALCON_INIT_VAR(default_controller);
phalcon_read_property(&default_controller, this_ptr, SL("_defaultController"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_controller"), default_controller TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(parts, SL("action")+1);
if (eval_int) {
PHALCON_INIT_VAR(action);
phalcon_array_fetch_string(&action, parts, SL("action"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_action"), action TSRMLS_CC);
PHALCON_SEPARATE(parts);
phalcon_array_unset_string(parts, SL("action")+1);
} else {
PHALCON_INIT_VAR(default_action);
phalcon_read_property(&default_action, this_ptr, SL("_defaultAction"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_action"), default_action TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(parts, SL("params")+1);
if (eval_int) {
PHALCON_INIT_VAR(params_str);
phalcon_array_fetch_string(¶ms_str, parts, SL("params"), PH_NOISY_CC);
PHALCON_INIT_VAR(c1);
ZVAL_LONG(c1, 1);
PHALCON_INIT_VAR(str_params);
PHALCON_CALL_FUNC_PARAMS_2(str_params, "substr", params_str, c1);
if (zend_is_true(str_params)) {
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, "/", 1);
PHALCON_INIT_VAR(params);
phalcon_fast_explode(params, c2, str_params TSRMLS_CC);
}
PHALCON_SEPARATE(parts);
phalcon_array_unset_string(parts, SL("params")+1);
}
PHALCON_INIT_VAR(params_merge);
PHALCON_CALL_FUNC_PARAMS_2(params_merge, "array_merge", params, parts);
phalcon_update_property_zval(this_ptr, SL("_params"), params_merge TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 1 TSRMLS_CC);
} else {
PHALCON_INIT_VAR(default_module);
phalcon_read_property(&default_module, this_ptr, SL("_defaultModule"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_module"), default_module TSRMLS_CC);
PHALCON_INIT_VAR(default_controller);
phalcon_read_property(&default_controller, this_ptr, SL("_defaultController"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_controller"), default_controller TSRMLS_CC);
PHALCON_INIT_VAR(default_action);
phalcon_read_property(&default_action, this_ptr, SL("_defaultAction"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_action"), default_action TSRMLS_CC);
PHALCON_INIT_VAR(default_params);
phalcon_read_property(&default_params, this_ptr, SL("_defaultParams"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_params"), default_params TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 0 TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}
/**
* Get the conditions of query
*
* @return string $query
*/
PHP_METHOD(Phalcon_Model_Query, getConditions){
zval *controller_front = NULL, *model_manager = NULL, *model_name = NULL;
zval *entity = NULL, *meta_data = NULL, *attributes = NULL, *numeric_types = NULL;
zval *i = NULL, *parameters = NULL, *conditions = NULL, *value = NULL, *param = NULL;
zval *condition = NULL, *index = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL;
zval *t7 = 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, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL;
zval *i0 = NULL;
zval *a0 = NULL, *a1 = NULL;
zval *c0 = NULL;
HashTable *ah0, *ah1, *ah2;
HashPosition hp0, hp1, hp2;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_manager", sizeof("_manager")-1, PHALCON_NOISY TSRMLS_CC);
if (!zend_is_true(t0)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_STATIC(r0, "phalcon_controller_front", "getinstance");
PHALCON_CPY_WRT(controller_front, r0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_METHOD(r1, controller_front, "getmodelcomponent", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(model_manager, r1);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "setmanager", model_manager, PHALCON_NO_CHECK);
} else {
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_manager", sizeof("_manager")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(model_manager, t1);
}
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_models", sizeof("_models")-1, PHALCON_NOISY TSRMLS_CC);
if (phalcon_valid_foreach(t2 TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(t2);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_a355_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_a355_0;
}
PHALCON_INIT_VAR(model_name);
ZVAL_ZVAL(model_name, *hd, 1, 0);
PHALCON_INIT_VAR(r2);
PHALCON_CALL_METHOD_PARAMS_1(r2, model_manager, "getmodel", model_name, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(entity, r2);
if (!zend_is_true(entity)) {
PHALCON_INIT_VAR(i0);
object_init_ex(i0, phalcon_model_exception_ce);
PHALCON_INIT_VAR(r3);
PHALCON_CONCAT_BOTH(r3, "The model ", model_name, " does not exist");
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", r3, PHALCON_CHECK);
phalcon_throw_exception(i0 TSRMLS_CC);
return;
}
PHALCON_INIT_VAR(r4);
PHALCON_CALL_METHOD(r4, model_manager, "getmetadata", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(meta_data, r4);
PHALCON_INIT_VAR(r5);
PHALCON_CALL_METHOD_PARAMS_1(r5, meta_data, "getattributes", entity, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(attributes, r5);
PHALCON_INIT_VAR(r6);
PHALCON_CALL_METHOD_PARAMS_1(r6, meta_data, "getdatatypesnumeric", entity, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(numeric_types, r6);
PHALCON_INIT_VAR(t3);
phalcon_read_property(&t3, this_ptr, "_data", sizeof("_data")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(r7);
phalcon_fast_count(r7, t3 TSRMLS_CC);
if (zend_is_true(r7)) {
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(parameters, a0);
PHALCON_INIT_VAR(a1);
array_init(a1);
PHALCON_CPY_WRT(conditions, a1);
PHALCON_INIT_VAR(t4);
phalcon_read_property(&t4, this_ptr, "_data", sizeof("_data")-1, PHALCON_NOISY TSRMLS_CC);
if (phalcon_valid_foreach(t4 TSRMLS_CC)) {
ah1 = Z_ARRVAL_P(t4);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_a355_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_a355_1;
} else {
PHALCON_INIT_VAR(param);
PHALCON_GET_FOREACH_KEY(param, ah1, hp1);
}
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
PHALCON_INIT_VAR(r8);
PHALCON_CALL_FUNC_PARAMS_2(r8, "in_array", param, attributes, 0x03E);
if (zend_is_true(r8)) {
PHALCON_INIT_VAR(t5);
ZVAL_STRING(t5, "", 1);
PHALCON_INIT_VAR(r9);
is_not_identical_function(r9, t5, value TSRMLS_CC);
PHALCON_INIT_VAR(r11);
PHALCON_CALL_FUNC_PARAMS_1(r11, "is_null", value, 0x041);
PHALCON_INIT_VAR(r10);
boolean_not_function(r10, r11 TSRMLS_CC);
PHALCON_INIT_VAR(r12);
phalcon_and_function(r12, r9, r10);
if (zend_is_true(r12)) {
if (!PHALCON_COMPARE_STRING(value, "@")) {
eval_int = phalcon_array_isset(numeric_types, param);
if (eval_int) {
PHALCON_INIT_VAR(r13);
PHALCON_CONCAT_VBOTH(r13, param, " = ?", i);
PHALCON_CPY_WRT(condition, r13);
phalcon_array_update(¶meters, i, &value, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
} else {
PHALCON_INIT_VAR(r14);
PHALCON_CONCAT_VBOTH(r14, param, " LIKE ?", i);
PHALCON_CPY_WRT(condition, r14);
PHALCON_INIT_VAR(r15);
PHALCON_CONCAT_BOTH(r15, "%", value, "%");
phalcon_array_update(¶meters, i, &r15, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
phalcon_array_append(&conditions, condition, PHALCON_SEPARATE_PLZ TSRMLS_CC);
}
}
}
PHALCON_SEPARATE(i);
increment_function(i);
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_a355_1;
fee_a355_1:
if(0){}
} else {
return;
}
} else {
PHALCON_INIT_VAR(t6);
phalcon_read_property(&t6, this_ptr, "_parameters", sizeof("_parameters")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(parameters, t6);
PHALCON_INIT_VAR(t7);
phalcon_read_property(&t7, this_ptr, "_conditions", sizeof("_conditions")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(conditions, t7);
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, " AND ", 1);
PHALCON_INIT_VAR(r16);
phalcon_fast_join(r16, c0, conditions TSRMLS_CC);
PHALCON_CPY_WRT(conditions, r16);
if (phalcon_valid_foreach(parameters TSRMLS_CC)) {
ah2 = Z_ARRVAL_P(parameters);
zend_hash_internal_pointer_reset_ex(ah2, &hp2);
fes_a355_2:
if(zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) != SUCCESS){
goto fee_a355_2;
} else {
PHALCON_INIT_VAR(index);
PHALCON_GET_FOREACH_KEY(index, ah2, hp2);
}
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
PHALCON_INIT_VAR(r17);
PHALCON_INIT_VAR(r18);
PHALCON_CONCAT_LEFT(r18, "?", index);
PHALCON_CALL_FUNC_PARAMS_3(r17, "str_replace", r18, value, conditions, 0x003);
PHALCON_CPY_WRT(conditions, r17);
zend_hash_move_forward_ex(ah2, &hp2);
goto fes_a355_2;
fee_a355_2:
if(0){}
} else {
return;
}
if (PHALCON_COMPARE_STRING(conditions, "")) {
PHALCON_INIT_VAR(conditions);
ZVAL_STRING(conditions, "1=1", 1);
}
PHALCON_RETURN_CHECK_CTOR(conditions);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_a355_0;
fee_a355_0:
if(0){}
} else {
return;
}
PHALCON_MM_RESTORE();
}
/**
* Dispatches a controller action taking into account the routing parameters
*
* @param Phalcon_Request $request
* @param Phalcon_Response $response
* @param Phalcon_View $view
* @param Phalcon_Model_Manager $model
* @return Phalcon_Controller
*/
PHP_METHOD(Phalcon_Dispatcher, dispatch){
zval *request = NULL, *response = NULL, *view = NULL, *model = NULL, *controllers_dir = NULL;
zval *value = NULL, *controller = NULL, *number_dispatches = NULL;
zval *controller_name = NULL, *controllers = NULL, *controller_class = NULL;
zval *controller_path = NULL, *params = NULL, *action_name = NULL;
zval *action_method = 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;
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 *c0 = NULL, *c1 = NULL, *c2 = NULL;
zval *i0 = NULL;
zval *a0 = NULL, *a1 = NULL;
zval *p0[] = { NULL, NULL, NULL, NULL, NULL };
int eval_int;
zend_class_entry *ce0;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|zz", &request, &response, &view, &model) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!view) {
PHALCON_INIT_VAR(view);
ZVAL_NULL(view);
}
if (!model) {
PHALCON_INIT_VAR(model);
ZVAL_NULL(model);
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_basePath"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, SL("_controllersDir"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CONCAT_VV(r0, t0, t1);
PHALCON_CPY_WRT(controllers_dir, r0);
PHALCON_INIT_VAR(value);
ZVAL_NULL(value);
PHALCON_INIT_VAR(controller);
ZVAL_NULL(controller);
PHALCON_INIT_VAR(number_dispatches);
ZVAL_LONG(number_dispatches, 0);
phalcon_update_property_bool(this_ptr, SL("_finished"), 0 TSRMLS_CC);
ws_e10f_0:
PHALCON_INIT_VAR(t2);
phalcon_read_property(&t2, this_ptr, SL("_finished"), PHALCON_NOISY TSRMLS_CC);
if (zend_is_true(t2)) {
goto we_e10f_0;
}
phalcon_update_property_bool(this_ptr, SL("_finished"), 1 TSRMLS_CC);
PHALCON_INIT_VAR(t3);
phalcon_read_property(&t3, this_ptr, SL("_controllerName"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(controller_name, t3);
if (!zend_is_true(controller_name)) {
PHALCON_INIT_VAR(t4);
phalcon_read_property(&t4, this_ptr, SL("_defaultController"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(controller_name, t4);
phalcon_update_property_zval(this_ptr, SL("_controllerName"), controller_name TSRMLS_CC);
}
PHALCON_INIT_VAR(t5);
phalcon_read_property(&t5, this_ptr, SL("_controllers"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(controllers, t5);
PHALCON_INIT_VAR(r1);
PHALCON_INIT_VAR(r2);
PHALCON_CALL_STATIC_PARAMS_1(r2, "phalcon_text", "camelize", controller_name);
PHALCON_CONCAT_VS(r1, r2, "Controller");
PHALCON_CPY_WRT(controller_class, r1);
eval_int = phalcon_array_isset(controllers, controller_class);
if (!eval_int) {
PHALCON_INIT_VAR(c0);
ZVAL_BOOL(c0, 0);
PHALCON_INIT_VAR(r3);
PHALCON_CALL_FUNC_PARAMS_2(r3, "class_exists", controller_class, c0);
if (!zend_is_true(r3)) {
PHALCON_INIT_VAR(r4);
PHALCON_CONCAT_VVS(r4, controllers_dir, controller_class, ".php");
PHALCON_CPY_WRT(controller_path, r4);
if (phalcon_file_exists(controller_path TSRMLS_CC) == SUCCESS) {
if (phalcon_require(controller_path TSRMLS_CC) == FAILURE) {
return;
}
} else {
PHALCON_INIT_VAR(r5);
PHALCON_CONCAT_SVS(r5, "File for controller class ", controller_class, " doesn't exist");
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, r5, PHALCON_NO_CHECK);
}
PHALCON_INIT_VAR(c1);
ZVAL_BOOL(c1, 0);
PHALCON_INIT_VAR(r6);
PHALCON_CALL_FUNC_PARAMS_2(r6, "class_exists", controller_class, c1);
if (!zend_is_true(r6)) {
PHALCON_INIT_VAR(r7);
PHALCON_CONCAT_SVS(r7, "Class ", controller_class, " was not found on controller file");
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, r7, PHALCON_NO_CHECK);
}
}
ce0 = phalcon_fetch_class(controller_class TSRMLS_CC);
PHALCON_INIT_VAR(i0);
object_init_ex(i0, ce0);
p0[0] = this_ptr;
p0[1] = request;
p0[2] = response;
p0[3] = view;
p0[4] = model;
PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 5, p0, PHALCON_CHECK);
PHALCON_CPY_WRT(controller, i0);
if (phalcon_method_exists_ex(controller, SL("initialize") TSRMLS_CC) == SUCCESS) {
PHALCON_CALL_METHOD_NORETURN(controller, "initialize", PHALCON_NO_CHECK);
}
PHALCON_INIT_VAR(t6);
phalcon_read_property(&t6, this_ptr, SL("_controllers"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update(&t6, controller_class, &controller, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_controllers"), t6 TSRMLS_CC);
} else {
PHALCON_INIT_VAR(r8);
phalcon_array_fetch(&r8, controllers, controller_class, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(controller, r8);
}
PHALCON_INIT_VAR(t7);
phalcon_read_property(&t7, this_ptr, SL("_params"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(params, t7);
PHALCON_INIT_VAR(t8);
phalcon_read_property(&t8, this_ptr, SL("_actionName"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(action_name, t8);
if (!zend_is_true(action_name)) {
PHALCON_INIT_VAR(t9);
phalcon_read_property(&t9, this_ptr, SL("_defaultAction"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(action_name, t9);
phalcon_update_property_zval(this_ptr, SL("_actionName"), action_name TSRMLS_CC);
}
if (phalcon_method_exists_ex(controller, SL("beforedispatch") TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(r9);
PHALCON_CALL_METHOD_PARAMS_3(r9, controller, "beforedispatch", controller_name, action_name, params, PHALCON_NO_CHECK);
if (Z_TYPE_P(r9) == IS_BOOL && !Z_BVAL_P(r9)) {
PHALCON_INIT_VAR(value);
ZVAL_BOOL(value, 0);
goto we_e10f_0;
}
}
PHALCON_INIT_VAR(r10);
PHALCON_CONCAT_VS(r10, action_name, "Action");
PHALCON_CPY_WRT(action_method, r10);
if (phalcon_method_exists(controller, action_method TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(a0);
array_init(a0);
phalcon_array_append(&a0, controller, PHALCON_SEPARATE_PLZ TSRMLS_CC);
phalcon_array_append(&a0, action_method, PHALCON_SEPARATE_PLZ TSRMLS_CC);
PHALCON_INIT_VAR(value);
PHALCON_CALL_FUNC_PARAMS_2(value, "call_user_func_array", a0, params);
} else {
if (phalcon_method_exists_ex(controller, SL("notfoundaction") TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(a1);
array_init(a1);
phalcon_array_append(&a1, controller, PHALCON_SEPARATE_PLZ TSRMLS_CC);
add_next_index_stringl(a1, SL("notFoundAction"), 1);
PHALCON_INIT_VAR(value);
PHALCON_CALL_FUNC_PARAMS_2(value, "call_user_func_array", a1, params);
} else {
PHALCON_INIT_VAR(r11);
PHALCON_CONCAT_SVSVS(r11, "Action '", action_name, "' was not found on controller '", controller_name, "'");
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, r11, PHALCON_NO_CHECK);
}
}
if (phalcon_method_exists_ex(controller, SL("afterdispatch") TSRMLS_CC) == SUCCESS) {
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(controller, "afterdispatch", controller_name, action_name, params, PHALCON_NO_CHECK);
}
PHALCON_SEPARATE(number_dispatches);
increment_function(number_dispatches);
PHALCON_INIT_VAR(t10);
ZVAL_LONG(t10, 256);
PHALCON_INIT_VAR(r12);
is_smaller_function(r12, t10, number_dispatches TSRMLS_CC);
if (zend_is_true(r12)) {
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, "Dispatcher has detected a cyclic routing causing stability problems", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, c2, PHALCON_NO_CHECK);
}
goto ws_e10f_0;
we_e10f_0:
phalcon_update_property_zval(this_ptr, SL("_returnedValue"), value TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_lastController"), controller TSRMLS_CC);
RETURN_CHECK_CTOR(controller);
}
/**
* Internal sanizite wrapper to filter_var
*
* @param mixed $value
* @param string $filter
* @return mixed
*/
PHP_METHOD(Phalcon_Filter, _sanitize){
zval *value, *filter, *filters, *filter_object;
zval *arguments, *filtered = NULL, *type = NULL, *quote, *empty_str;
zval *escaped, *allow_fraction, *options, *exception_message;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &value, &filter) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(filters);
phalcon_read_property(&filters, this_ptr, SL("_filters"), PH_NOISY_CC);
eval_int = phalcon_array_isset(filters, filter);
if (eval_int) {
PHALCON_INIT_VAR(filter_object);
phalcon_array_fetch(&filter_object, filters, filter, PH_NOISY_CC);
/**
* If the filter is a closure we call it in the PHP userland
*/
if (phalcon_is_instance_of(filter_object, SL("Closure") TSRMLS_CC)) {
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_array_append(&arguments, value, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(filtered);
PHALCON_CALL_USER_FUNC_ARRAY(filtered, filter_object, arguments);
} else {
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_METHOD_PARAMS_1(filtered, filter_object, "filter", value, PH_NO_CHECK);
}
RETURN_CCTOR(filtered);
}
PHALCON_INIT_NVAR(filtered);
if (PHALCON_COMPARE_STRING(filter, "email")) {
/**
* The 'email' filter uses the filter extension
*/
PHALCON_INIT_VAR(type);
ZVAL_LONG(type, 517);
PHALCON_INIT_VAR(quote);
ZVAL_STRING(quote, "'", 1);
PHALCON_INIT_VAR(empty_str);
ZVAL_STRING(empty_str, "", 1);
PHALCON_INIT_VAR(escaped);
phalcon_fast_str_replace(escaped, quote, empty_str, value TSRMLS_CC);
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", escaped, type);
goto ph_end_0;
}
if (PHALCON_COMPARE_STRING(filter, "int")) {
/**
* 'int' filter sanitizes a numeric input
*/
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 519);
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", value, type);
goto ph_end_0;
}
if (PHALCON_COMPARE_STRING(filter, "string")) {
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 513);
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", value, type);
goto ph_end_0;
}
if (PHALCON_COMPARE_STRING(filter, "float")) {
/**
* The 'float' filter uses the filter extension
*/
PHALCON_INIT_VAR(allow_fraction);
ZVAL_LONG(allow_fraction, 4096);
PHALCON_INIT_VAR(options);
array_init(options);
phalcon_array_update_string(&options, SL("flags"), &allow_fraction, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 520);
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_3(filtered, "filter_var", value, type, options);
goto ph_end_0;
}
if (PHALCON_COMPARE_STRING(filter, "alphanum")) {
PHALCON_INIT_NVAR(filtered);
phalcon_filter_alphanum(filtered, value);
goto ph_end_0;
}
if (PHALCON_COMPARE_STRING(filter, "trim")) {
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_1(filtered, "trim", value);
goto ph_end_0;
}
if (PHALCON_COMPARE_STRING(filter, "striptags")) {
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_1(filtered, "strip_tags", value);
goto ph_end_0;
}
if (PHALCON_COMPARE_STRING(filter, "lower")) {
if (phalcon_function_exists_ex(SS("mb_strtolower") TSRMLS_CC) == SUCCESS) {
/**
* 'lower' checks for the mbstring extension to make a correct lowercase
* transformation
*/
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_1(filtered, "mb_strtolower", value);
} else {
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_1(filtered, "strtolower", value);
}
goto ph_end_0;
}
if (PHALCON_COMPARE_STRING(filter, "upper")) {
if (phalcon_function_exists_ex(SS("mb_strtoupper") TSRMLS_CC) == SUCCESS) {
/**
* 'upper' checks for the mbstring extension to make a correct lowercase
* transformation
*/
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_1(filtered, "mb_strtoupper", value);
} else {
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_1(filtered, "strtoupper", value);
}
goto ph_end_0;
}
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Sanitize filter ", filter, " is not supported");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_filter_exception_ce, exception_message);
return;
ph_end_0:
RETURN_CCTOR(filtered);
}
/**
* Bind params to SQL select
*
* @param string $sqlSelect
* @param array $params
*/
PHP_METHOD(Phalcon_Db_Adapter_Mysql, bindParams){
zval *sql_select = NULL, *params = NULL, *select = NULL, *id_connection = NULL;
zval *bind_value = NULL, *index = NULL, *value = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL;
zval *t0 = NULL;
zval *c0 = NULL, *c1 = 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, "zz", &sql_select, ¶ms) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_fast_count(r0, params TSRMLS_CC);
if (zend_is_true(r0)) {
PHALCON_CPY_WRT(select, sql_select);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_idConnection"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(id_connection, t0);
if (phalcon_valid_foreach(params TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_321f_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_321f_0;
} else {
PHALCON_INIT_VAR(index);
PHALCON_GET_FOREACH_KEY(index, ah0, hp0);
}
PHALCON_INIT_VAR(bind_value);
ZVAL_ZVAL(bind_value, *hd, 1, 0);
PHALCON_INIT_VAR(r1);
PHALCON_CALL_FUNC_PARAMS_1(r1, "is_numeric", bind_value);
if (zend_is_true(r1)) {
PHALCON_CPY_WRT(value, bind_value);
} else {
PHALCON_INIT_VAR(r2);
PHALCON_INIT_VAR(value);
PHALCON_CALL_FUNC_PARAMS_2(value, "mysqli_real_escape_string", id_connection, bind_value);
PHALCON_CONCAT_SVS(r2, "!¡", value, "!¡");
PHALCON_CPY_WRT(value, r2);
}
if (Z_TYPE_P(index) == IS_LONG) {
PHALCON_INIT_VAR(r3);
PHALCON_CONCAT_SV(r3, "?", index);
PHALCON_INIT_VAR(r4);
phalcon_fast_str_replace(r4, r3, value, select TSRMLS_CC);
PHALCON_CPY_WRT(select, r4);
} else {
if (Z_TYPE_P(index) == IS_STRING) {
PHALCON_INIT_VAR(r5);
PHALCON_CONCAT_SVS(r5, ":", index, ":");
PHALCON_INIT_VAR(r6);
phalcon_fast_str_replace(r6, r5, value, select TSRMLS_CC);
PHALCON_CPY_WRT(select, r6);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter");
return;
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_321f_0;
fee_321f_0:
if(0){}
} else {
return;
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "!¡", 1);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "'", 1);
PHALCON_ALLOC_ZVAL_MM(r7);
phalcon_fast_str_replace(r7, c0, c1, select TSRMLS_CC);
RETURN_DZVAL(r7);
}
RETURN_CHECK_CTOR(sql_select);
}
/**
* Executes the validator
*
* @return boolean
*/
PHP_METHOD(Phalcon_Model_Validator_Uniqueness, validate){
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, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL, *r19 = NULL, *r20 = NULL;
zval *r21 = NULL, *r22 = NULL, *r23 = NULL;
zval *v0 = NULL, *v1 = NULL, *v2 = NULL, *v3 = NULL, *v4 = NULL, *v5 = NULL, *v6 = NULL;
zval *v7 = NULL, *v8 = NULL, *v9 = NULL;
zval *i0 = NULL;
zval *a0 = NULL;
zval *c0 = NULL;
zval *t0 = NULL;
zval *p4[] = { NULL }, *p9[] = { NULL }, *p11[] = { NULL }, *p13[] = { NULL }, *p15[] = { NULL, NULL, NULL }, *p16[] = { NULL, NULL, NULL };
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, this_ptr, "isrequired", PHALCON_CALL_DEFAULT);
if (zend_is_true(r0)) {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_METHOD(r1, this_ptr, "getrecord", PHALCON_CALL_DEFAULT);
PHALCON_ALLOC_ZVAL_MM(i0);
phalcon_clone(i0, r1 TSRMLS_CC);
PHALCON_CPY_WRT(v0, i0);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CALL_METHOD(r2, this_ptr, "getfieldname", PHALCON_CALL_DEFAULT);
PHALCON_CPY_WRT(v1, r2);
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(v2, a0);
if (Z_TYPE_P(v1) == IS_ARRAY) {
if (Z_TYPE_P(v1) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid argument supplied for foreach()");
} else {
ah0 = Z_ARRVAL_P(v1);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_d73d_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_d73d_0;
}
PHALCON_INIT_VAR(v3);
ZVAL_ZVAL(v3, *hd, 1, 0);
PHALCON_INIT_VAR(r3);
PHALCON_INIT_VAR(r4);
Z_ADDREF_P(v3);
p4[0] = v3;
PHALCON_CALL_METHOD_PARAMS(r4, v0, "readattribute", 1, p4, PHALCON_CALL_DEFAULT);
Z_DELREF_P(p4[0]);
Z_ADDREF_P(r4);
PHALCON_CALL_FUNC_PARAMS_1(r3, "addslashes", r4, 0x01F);
Z_DELREF_P(r4);
PHALCON_CPY_WRT(v4, r3);
PHALCON_INIT_VAR(r5);
PHALCON_CONCAT_VBOTH(r5, v3, "='", v4);
PHALCON_INIT_VAR(r6);
PHALCON_CONCAT_RIGHT(r6, r5, "'");
Z_ADDREF_P(r6);
PHALCON_SEPARATE_ARRAY(v2);
phalcon_array_append(v2, r6 TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_d73d_0;
fee_d73d_0:
if(0){ };
}
} else {
PHALCON_ALLOC_ZVAL_MM(r7);
PHALCON_ALLOC_ZVAL_MM(r8);
PHALCON_CALL_METHOD(r8, this_ptr, "getvalue", PHALCON_CALL_DEFAULT);
Z_ADDREF_P(r8);
PHALCON_CALL_FUNC_PARAMS_1(r7, "addslashes", r8, 0x01F);
Z_DELREF_P(r8);
PHALCON_CPY_WRT(v4, r7);
PHALCON_ALLOC_ZVAL_MM(r9);
PHALCON_CONCAT_VBOTH(r9, v1, "='", v4);
PHALCON_ALLOC_ZVAL_MM(r10);
PHALCON_CONCAT_RIGHT(r10, r9, "'");
Z_ADDREF_P(r10);
PHALCON_SEPARATE_ARRAY(v2);
phalcon_array_append(v2, r10 TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(r11);
PHALCON_CALL_METHOD(r11, v0, "getmanager", PHALCON_CALL_DEFAULT);
PHALCON_CPY_WRT(v5, r11);
PHALCON_ALLOC_ZVAL_MM(r12);
PHALCON_CALL_METHOD(r12, v5, "getmetadata", PHALCON_CALL_DEFAULT);
PHALCON_CPY_WRT(v6, r12);
PHALCON_ALLOC_ZVAL_MM(r13);
Z_ADDREF_P(v0);
p9[0] = v0;
PHALCON_CALL_METHOD_PARAMS(r13, v6, "getprimarykeyattributes", 1, p9, PHALCON_CALL_DEFAULT);
Z_DELREF_P(p9[0]);
PHALCON_CPY_WRT(v7, r13);
if (Z_TYPE_P(v7) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid argument supplied for foreach()");
} else {
ah1 = Z_ARRVAL_P(v7);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_d73d_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_d73d_1;
}
PHALCON_INIT_VAR(v8);
ZVAL_ZVAL(v8, *hd, 1, 0);
PHALCON_INIT_VAR(r15);
PHALCON_INIT_VAR(r16);
Z_ADDREF_P(v8);
p11[0] = v8;
PHALCON_CALL_METHOD_PARAMS(r16, v0, "readattribute", 1, p11, PHALCON_CALL_DEFAULT);
Z_DELREF_P(p11[0]);
Z_ADDREF_P(r16);
PHALCON_CALL_FUNC_PARAMS_1(r15, "addslashes", r16, 0x01F);
Z_DELREF_P(r16);
PHALCON_INIT_VAR(r14);
PHALCON_CONCAT_VBOTH(r14, v8, "<>'", r15);
PHALCON_INIT_VAR(r17);
PHALCON_CONCAT_RIGHT(r17, r14, "'");
Z_ADDREF_P(r17);
PHALCON_SEPARATE_ARRAY(v2);
phalcon_array_append(v2, r17 TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_d73d_1;
fee_d73d_1:
if(0){ };
}
PHALCON_ALLOC_ZVAL_MM(r18);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, " AND ", 1);
PHALCON_CALL_FUNC_PARAMS_2(r18, "join", c0, v2, 0x00F);
PHALCON_CPY_WRT(v2, r18);
PHALCON_ALLOC_ZVAL_MM(r19);
Z_ADDREF_P(v2);
p13[0] = v2;
PHALCON_CALL_STATIC_ZVAL_PARAMS(r19, v0, "count", 1, p13);
Z_DELREF_P(p13[0]);
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 0);
PHALCON_INIT_VAR(r20);
is_smaller_function(r20, t0, r19 TSRMLS_CC);
if (zend_is_true(r20)) {
PHALCON_ALLOC_ZVAL_MM(r21);
PHALCON_CALL_METHOD(r21, this_ptr, "getoptions", PHALCON_CALL_DEFAULT);
PHALCON_CPY_WRT(v9, r21);
eval_int = phalcon_array_isset_string(v9, "message", strlen("message")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r22);
phalcon_array_fetch_string(&r22, v9, "message", strlen("message"), PHALCON_NOISY_FETCH TSRMLS_CC);
Z_ADDREF_P(r22);
p15[0] = r22;
Z_ADDREF_P(v1);
p15[1] = v1;
PHALCON_INIT_VAR(p15[2]);
ZVAL_STRING(p15[2], "unique", 1);
PHALCON_CALL_METHOD_PARAMS_NORETURN(this_ptr, "appendmessage", 3, p15, PHALCON_CALL_DEFAULT);
Z_DELREF_P(p15[0]);
Z_DELREF_P(p15[1]);
} else {
PHALCON_ALLOC_ZVAL_MM(r23);
PHALCON_CONCAT_BOTH(r23, "Value of field '", v1, "' is already present in another record");
Z_ADDREF_P(r23);
p16[0] = r23;
Z_ADDREF_P(v1);
p16[1] = v1;
PHALCON_INIT_VAR(p16[2]);
ZVAL_STRING(p16[2], "unique", 1);
PHALCON_CALL_METHOD_PARAMS_NORETURN(this_ptr, "appendmessage", 3, p16, PHALCON_CALL_DEFAULT);
Z_DELREF_P(p16[0]);
Z_DELREF_P(p16[1]);
}
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}