/**
* Executes the validator
*
* @return boolean
*/
PHP_METHOD(Phalcon_Model_Validator_Email, validate){
zval *regs = NULL, *field_name = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = 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_INIT_VAR(regs);
ZVAL_NULL(regs);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_METHOD(r1, this_ptr, "getfieldname", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(field_name, r1);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "/^[a-zA-Z0-9_\\.\\+]+@[a-zA-Z0-9_]+(\\.[a-zA-Z0-9_]+)*$/", 1);
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CALL_METHOD(r3, this_ptr, "getvalue", PHALCON_NO_CHECK);
Z_SET_ISREF_P(regs);
PHALCON_CALL_FUNC_PARAMS_3(r2, "preg_match", c0, r3, regs, 0x006);
Z_UNSET_ISREF_P(regs);
if (zend_is_true(r2)) {
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_array_fetch_long(&r4, regs, 0, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_CALL_METHOD(r5, this_ptr, "getvalue", PHALCON_NO_CHECK);
PHALCON_INIT_VAR(r6);
is_not_equal_function(r6, r4, r5 TSRMLS_CC);
if (zend_is_true(r6)) {
PHALCON_ALLOC_ZVAL_MM(r7);
PHALCON_CONCAT_SVS(r7, "Value of field '", field_name, "' should be a valid e-mail");
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "email", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", r7, field_name, c1, PHALCON_NO_CHECK);
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
} else {
PHALCON_ALLOC_ZVAL_MM(r8);
PHALCON_CONCAT_SVS(r8, "Value of field '", field_name, "' should be a valid e-mail");
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, "email", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", r8, field_name, c2, PHALCON_NO_CHECK);
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* Magic __set_state helps to recover messsages from serialization
*
* @param array $message
* @return Phalcon_Model_Message
*/
PHP_METHOD(Phalcon_Model_Message, __set_state){
zval *message = NULL;
zval *i0 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &message) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_model_message_ce);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, message, "_message", strlen("_message"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch_string(&r1, message, "_field", strlen("_field"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_string(&r2, message, "_type", strlen("_type"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(i0, "__construct", r0, r1, r2, PHALCON_CHECK);
PHALCON_RETURN_CTOR(i0);
}
/**
* Attempts to register a service in the services container
* Only is successful if a service hasn't been registered previously
* with the same name
*
* @param string $name
* @param mixed $definition
* @param boolean $shared
* @return Phalcon\DI\ServiceInterface
*/
PHP_METHOD(Phalcon_DI, attempt){
zval *name, *definition, *shared = NULL, *services, *service;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 1, &name, &definition, &shared);
if (!shared) {
PHALCON_INIT_VAR(shared);
ZVAL_BOOL(shared, 0);
}
if (Z_TYPE_P(name) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_di_exception_ce, "The service name must be a string");
return;
}
PHALCON_OBS_VAR(services);
phalcon_read_property_this(&services, this_ptr, SL("_services"), PH_NOISY_CC);
if (!phalcon_array_isset(services, name)) {
PHALCON_INIT_VAR(service);
object_init_ex(service, phalcon_di_service_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(service, "__construct", name, definition, shared);
phalcon_update_property_array(this_ptr, SL("_services"), name, service TSRMLS_CC);
RETURN_CTOR(service);
}
RETURN_MM_NULL();
}
/**
* Add a route to the router on any HTTP method
*
* @param string $pattern
* @param string/array $paths
* @param string $httpMethods
* @return Phalcon\Mvc\Router\Route
*/
PHP_METHOD(Phalcon_Mvc_Router, add){
zval *pattern = NULL, *paths = NULL, *http_methods = NULL, *route = NULL;
zval *t0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|zz", &pattern, &paths, &http_methods) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!paths) {
PHALCON_ALLOC_ZVAL_MM(paths);
ZVAL_NULL(paths);
}
if (!http_methods) {
PHALCON_ALLOC_ZVAL_MM(http_methods);
ZVAL_NULL(http_methods);
}
PHALCON_INIT_VAR(route);
object_init_ex(route, phalcon_mvc_router_route_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(route, "__construct", pattern, paths, http_methods, PH_CHECK);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_routes"), PH_NOISY_CC);
phalcon_array_append(&t0, route, 0 TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_routes"), t0 TSRMLS_CC);
RETURN_CTOR(route);
}
/**
* Returns the name of identity field (if one is present)
*
* @param Phalcon\Mvc\Model $model
* @return array
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, getIdentityField){
zval *model = NULL, *table = NULL, *schema = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
zval *t0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &model) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(table);
PHALCON_CALL_METHOD(table, model, "getsource", PH_NO_CHECK);
PHALCON_INIT_VAR(schema);
PHALCON_CALL_METHOD(schema, model, "getschema", PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "_initializemetadata", model, table, schema, PH_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CONCAT_VV(r0, schema, table);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_metaData"), PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch(&r1, t0, r0, PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_long(&r2, r1, 8, PH_NOISY_CC);
RETURN_CCTOR(r2);
}
/**
* Magic __set_state helps to re-build messages variable exporting
*
* @param array $message
* @return Phalcon\Mvc\Model\Message
*/
PHP_METHOD(Phalcon_Mvc_Model_Message, __set_state){
zval *message, *message_text, *field, *type, *message_object;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &message) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_OBS_VAR(message_text);
phalcon_array_fetch_string(&message_text, message, SL("_message"), PH_NOISY_CC);
PHALCON_OBS_VAR(field);
phalcon_array_fetch_string(&field, message, SL("_field"), PH_NOISY_CC);
PHALCON_OBS_VAR(type);
phalcon_array_fetch_string(&type, message, SL("_type"), PH_NOISY_CC);
PHALCON_INIT_VAR(message_object);
object_init_ex(message_object, phalcon_mvc_model_message_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(message_object, "__construct", message_text, field, type);
RETURN_CTOR(message_object);
}
/**
* 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);
}
/**
* 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();
}
/**
* Executes the validation
*
* @param Phalcon\Validation $validator
* @param string $attribute
* @return boolean
*/
PHP_METHOD(Phalcon_Validation_Validator_InclusionIn, validate){
zval *validator, *attribute, *value, *option = NULL, *domain;
zval *message_str = NULL, *joined_domain, *type, *message;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &validator, &attribute) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, validator, "getvalue", attribute);
/**
* A domain is an array with a list of valid values
*/
PHALCON_INIT_VAR(option);
ZVAL_STRING(option, "domain", 1);
PHALCON_INIT_VAR(domain);
PHALCON_CALL_METHOD_PARAMS_1(domain, this_ptr, "getoption", option);
if (Z_TYPE_P(domain) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "Option 'domain' must be an array");
return;
}
/**
* Check if the value is contained by the array
*/
if (!phalcon_fast_in_array(value, domain TSRMLS_CC)) {
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "message", 1);
PHALCON_INIT_VAR(message_str);
PHALCON_CALL_METHOD_PARAMS_1(message_str, this_ptr, "getoption", option);
if (!zend_is_true(message_str)) {
PHALCON_INIT_VAR(joined_domain);
phalcon_fast_join_str(joined_domain, SL(", "), domain TSRMLS_CC);
PHALCON_INIT_NVAR(message_str);
PHALCON_CONCAT_SVSV(message_str, "Value of field '", attribute, "' must be part of list: ", joined_domain);
}
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "InclusionIn", 1);
PHALCON_INIT_VAR(message);
object_init_ex(message, phalcon_validation_message_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(message, "__construct", message_str, attribute, type);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(validator, "appendmessage", message);
RETURN_MM_FALSE;
}
RETURN_MM_TRUE;
}
/**
* 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();
}
/**
* Executes the validator
*
* @param Phalcon\Mvc\ModelInterface $record
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator_Numericality, validate){
zval *record, *option = NULL, *field, *value, *is_numeric;
zval *message = NULL, *type;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &record) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(option);
ZVAL_STRING(option, "field", 1);
PHALCON_INIT_VAR(field);
PHALCON_CALL_METHOD_PARAMS_1(field, this_ptr, "getoption", option, PH_NO_CHECK);
if (Z_TYPE_P(field) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Field name must be a string");
return;
}
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK);
/**
* Check if the value is numeric using is_numeric in the PHP userland
*/
PHALCON_INIT_VAR(is_numeric);
PHALCON_CALL_FUNC_PARAMS_1(is_numeric, "is_numeric", value);
if (!zend_is_true(is_numeric)) {
/**
* Check if the developer has defined a custom message
*/
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "message", 1);
PHALCON_INIT_VAR(message);
PHALCON_CALL_METHOD_PARAMS_1(message, this_ptr, "getoption", option, PH_NO_CHECK);
if (!zend_is_true(message)) {
PHALCON_INIT_NVAR(message);
PHALCON_CONCAT_SVS(message, "Value of field '", field, "' must be numeric");
}
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "Numericality", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", message, field, type, PH_NO_CHECK);
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* 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;
}
/**
* Executes the validator
*
* @param Phalcon\Mvc\ModelInterface $record
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator_PresenceOf, validate){
zval *record, *option = NULL, *field_name, *value, *message = NULL;
zval *type;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &record) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(option);
ZVAL_STRING(option, "field", 1);
PHALCON_INIT_VAR(field_name);
PHALCON_CALL_METHOD_PARAMS_1(field_name, this_ptr, "getoption", option, PH_NO_CHECK);
if (Z_TYPE_P(field_name) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Field name must be a string");
return;
}
/**
* A value is null when it is identical to null or a empty string
*/
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field_name, PH_NO_CHECK);
if (PHALCON_IS_EMPTY(value)) {
/**
* Check if the developer has defined a custom message
*/
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "message", 1);
PHALCON_INIT_VAR(message);
PHALCON_CALL_METHOD_PARAMS_1(message, this_ptr, "getoption", option, PH_NO_CHECK);
if (!zend_is_true(message)) {
PHALCON_INIT_NVAR(message);
PHALCON_CONCAT_SVS(message, "'", field_name, "' is required");
}
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "PresenceOf", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", message, field_name, type, PH_NO_CHECK);
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* Appends a message to the validator
*
* @param string $message
* @param string $field
* @param string $type
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator, appendMessage){
zval *message = NULL, *field = NULL, *type = NULL, *class_name = NULL, *suffix = NULL;
zval *empty_string = NULL, *model_message = NULL;
zval *t0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|zz", &message, &field, &type) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!field) {
PHALCON_ALLOC_ZVAL_MM(field);
ZVAL_NULL(field);
}
if (!type) {
PHALCON_ALLOC_ZVAL_MM(type);
ZVAL_NULL(type);
} else {
PHALCON_SEPARATE_PARAM(type);
}
if (!zend_is_true(type)) {
PHALCON_INIT_VAR(class_name);
phalcon_get_class(class_name, this_ptr TSRMLS_CC);
PHALCON_INIT_VAR(suffix);
ZVAL_STRING(suffix, "Validator", 1);
PHALCON_INIT_VAR(empty_string);
ZVAL_STRING(empty_string, "", 1);
PHALCON_INIT_VAR(type);
phalcon_fast_str_replace(type, suffix, empty_string, class_name TSRMLS_CC);
}
PHALCON_INIT_VAR(model_message);
object_init_ex(model_message, phalcon_mvc_model_message_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(model_message, "__construct", message, field, type, PH_CHECK);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_messages"), PH_NOISY_CC);
phalcon_array_append(&t0, model_message, 0 TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_messages"), t0 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Set the attributes that must be ignored from the UPDATE SQL generation
*
*<code>
* $metaData->setAutomaticUpdateAttributes(new Robots(), array('modified_at' => true));
*</code>
*
* @param Phalcon\Mvc\ModelInterface $model
* @param array $attributes
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, setAutomaticUpdateAttributes){
zval *model, *attributes, *create_index;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &model, &attributes) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(create_index);
ZVAL_LONG(create_index, 11);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "writemetadataindex", model, create_index, attributes);
PHALCON_MM_RESTORE();
}
/**
* Executes the validation
*
* @param Phalcon\Validation $validator
* @param string $attribute
* @return boolean
*/
PHP_METHOD(Phalcon_Validation_Validator_Identical, validate){
zval *validator, *attribute, *value, *option = NULL, *identical_value;
zval *message_str = NULL, *type, *message;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &validator, &attribute) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, validator, "getvalue", attribute);
PHALCON_INIT_VAR(option);
ZVAL_STRING(option, "value", 1);
PHALCON_INIT_VAR(identical_value);
PHALCON_CALL_METHOD_PARAMS_1(identical_value, this_ptr, "getoption", option);
if (!PHALCON_IS_EQUAL(value, identical_value)) {
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "message", 1);
PHALCON_INIT_VAR(message_str);
PHALCON_CALL_METHOD_PARAMS_1(message_str, this_ptr, "getoption", option);
if (!zend_is_true(message_str)) {
PHALCON_INIT_NVAR(message_str);
PHALCON_CONCAT_VS(message_str, attribute, " does not have the expected value");
}
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "Identical", 1);
PHALCON_INIT_VAR(message);
object_init_ex(message, phalcon_validation_message_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(message, "__construct", message_str, attribute, type);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(validator, "appendmessage", message);
RETURN_MM_FALSE;
}
RETURN_MM_TRUE;
}
/**
* Renders a partial view
*
*
*
* @param string $partialPath
*/
PHP_METHOD(Phalcon_View, partial){
zval *partial_path = NULL;
zval *r0 = NULL;
zval *c0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &partial_path) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, this_ptr, "_loadtemplateengines", PHALCON_NO_CHECK);
PHALCON_INIT_VAR(c0);
ZVAL_BOOL(c0, 0);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "_enginerender", r0, partial_path, c0, PHALCON_NO_CHECK);
PHALCON_MM_RESTORE();
}
/**
* Restore the internal state of a service
*
* @param array $attributes
* @return Phalcon\DI\Service
*/
PHP_METHOD(Phalcon_DI_Service, __set_state){
zval *attributes, *name, *definition, *shared, *service;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &attributes) == FAILURE) {
RETURN_MM_NULL();
}
if (phalcon_array_isset_string(attributes, SS("_name"))) {
PHALCON_OBS_VAR(name);
phalcon_array_fetch_string(&name, attributes, SL("_name"), PH_NOISY_CC);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_di_exception_ce, "The attribute '_name' is required");
return;
}
if (phalcon_array_isset_string(attributes, SS("_definition"))) {
PHALCON_OBS_VAR(definition);
phalcon_array_fetch_string(&definition, attributes, SL("_definition"), PH_NOISY_CC);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_di_exception_ce, "The attribute '_name' is required");
return;
}
if (phalcon_array_isset_string(attributes, SS("_shared"))) {
PHALCON_OBS_VAR(shared);
phalcon_array_fetch_string(&shared, attributes, SL("_shared"), PH_NOISY_CC);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_di_exception_ce, "The attribute '_shared' is required");
return;
}
PHALCON_INIT_VAR(service);
object_init_ex(service, phalcon_di_service_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(service, "__construct", name, definition, shared);
RETURN_CTOR(service);
}
/**
* Executes the validation
*
* @param Phalcon\Validation $validator
* @param string $attribute
* @return boolean
*/
PHP_METHOD(Phalcon_Validation_Validator_PresenceOf, validate){
zval *validator, *attribute, *value, *type, *option;
zval *message_str = NULL, *message;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &validator, &attribute) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, validator, "getvalue", attribute);
if (PHALCON_IS_EMPTY(value)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "PresenceOf", 1);
PHALCON_INIT_VAR(option);
ZVAL_STRING(option, "message", 1);
PHALCON_INIT_VAR(message_str);
PHALCON_CALL_METHOD_PARAMS_1(message_str, this_ptr, "getoption", option);
if (!zend_is_true(message_str)) {
PHALCON_INIT_NVAR(message_str);
PHALCON_CONCAT_VS(message_str, attribute, " is required");
}
PHALCON_INIT_VAR(message);
object_init_ex(message, phalcon_validation_message_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(message, "__construct", message_str, attribute, type);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(validator, "appendmessage", message);
RETURN_MM_FALSE;
}
RETURN_MM_TRUE;
}
/**
* Magic __set_state helps to recover messsages from serialization
*
* @param array $message
* @return Phalcon\Mvc\Model\Message
*/
PHP_METHOD(Phalcon_Validation_Message, __set_state){
zval *message, *message_text, *field, *type, *message_object;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &message);
PHALCON_OBS_VAR(message_text);
phalcon_array_fetch_string(&message_text, message, SL("_message"), PH_NOISY_CC);
PHALCON_OBS_VAR(field);
phalcon_array_fetch_string(&field, message, SL("_field"), PH_NOISY_CC);
PHALCON_OBS_VAR(type);
phalcon_array_fetch_string(&type, message, SL("_type"), PH_NOISY_CC);
PHALCON_INIT_VAR(message_object);
object_init_ex(message_object, phalcon_validation_message_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(message_object, "__construct", message_text, field, type);
RETURN_CTOR(message_object);
}
/**
* Registers an "always shared" service in the services container
*
* @param string $name
* @param mixed $definition
* @return Phalcon\DI\ServiceInterface
*/
PHP_METHOD(Phalcon_DI, setShared){
zval *name, *definition, *shared, *service;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &name, &definition);
if (Z_TYPE_P(name) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_di_exception_ce, "The service name must be a string");
return;
}
PHALCON_INIT_VAR(shared);
ZVAL_BOOL(shared, 1);
PHALCON_INIT_VAR(service);
object_init_ex(service, phalcon_di_service_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(service, "__construct", name, definition, shared);
phalcon_update_property_array(this_ptr, SL("_services"), name, service TSRMLS_CC);
RETURN_CTOR(service);
}
/**
* Returns attributes which types are numerical
*
* @param Phalcon_Model_Base $model
* @return array
*/
PHP_METHOD(Phalcon_Model_MetaData, getDataTypesNumeric){
zval *model = NULL, *table = NULL, *schema = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL;
zval *t0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &model) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, model, "getsource", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(table, r0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_METHOD(r1, model, "getschema", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(schema, r1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "_initializemetadata", model, table, schema, PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CONCAT_VV(r2, schema, table);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_metaData"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_array_fetch(&r3, t0, r2, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_array_fetch_long(&r4, r3, 5, PHALCON_NOISY TSRMLS_CC);
RETURN_CHECK_CTOR(r4);
}
/**
* Executes render process from request data
*
* @param string $controllerName
* @param string $actionName
* @param array $params
*/
PHP_METHOD(Phalcon_View, render){
zval *controller_name = NULL, *action_name = NULL, *params = NULL;
zval *layouts_dir = NULL, *engines = NULL, *pick_view = NULL, *render_view = NULL;
zval *render_controller = NULL, *silence = NULL, *render_level = NULL;
zval *templates_before = NULL, *template_before = NULL;
zval *templates_after = NULL, *template_after = NULL;
zval *a0 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL;
zval *t7 = NULL, *t8 = NULL, *t9 = NULL, *t10 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL;
zval *r14 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &controller_name, &action_name, ¶ms) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!params) {
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(params, a0);
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_layoutsDir", sizeof("_layoutsDir")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(layouts_dir, t0);
if (!zend_is_true(layouts_dir)) {
PHALCON_INIT_VAR(layouts_dir);
ZVAL_STRING(layouts_dir, "layouts/", 1);
}
phalcon_update_property_zval(this_ptr, "_controllerName", strlen("_controllerName"), controller_name TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_actionName", strlen("_actionName"), action_name TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_params", strlen("_params"), params TSRMLS_CC);
phalcon_update_property_bool(this_ptr, "_initEngines", strlen("_initEngines"), 0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, this_ptr, "_loadtemplateengines", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(engines, r0);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_pickView", sizeof("_pickView")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(pick_view, t1);
if (!zend_is_true(pick_view)) {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CONCAT_VSV(r1, controller_name, "/", action_name);
PHALCON_CPY_WRT(render_view, r1);
PHALCON_CPY_WRT(render_controller, controller_name);
} else {
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_long(&r2, pick_view, 0, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(render_view, r2);
eval_int = phalcon_array_isset_long(pick_view, 1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_array_fetch_long(&r3, pick_view, 1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(render_controller, r3);
} else {
PHALCON_CPY_WRT(render_controller, controller_name);
}
}
PHALCON_INIT_VAR(silence);
ZVAL_BOOL(silence, 1);
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_renderLevel", sizeof("_renderLevel")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(render_level, t2);
if (zend_is_true(render_level)) {
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CALL_FUNC(r4, "ob_get_contents", 0x015);
phalcon_update_property_zval(this_ptr, "_content", strlen("_content"), r4 TSRMLS_CC);
PHALCON_INIT_VAR(t3);
ZVAL_LONG(t3, 1);
PHALCON_INIT_VAR(r5);
is_smaller_or_equal_function(r5, t3, render_level TSRMLS_CC);
if (zend_is_true(r5)) {
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "_enginerender", engines, render_view, silence, PHALCON_NO_CHECK);
}
PHALCON_INIT_VAR(t4);
ZVAL_LONG(t4, 2);
PHALCON_INIT_VAR(r6);
is_smaller_or_equal_function(r6, t4, render_level TSRMLS_CC);
if (zend_is_true(r6)) {
PHALCON_ALLOC_ZVAL_MM(t5);
phalcon_read_property(&t5, this_ptr, "_templatesBefore", sizeof("_templatesBefore")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(templates_before, t5);
if (zend_is_true(templates_before)) {
PHALCON_INIT_VAR(silence);
ZVAL_BOOL(silence, 0);
if (Z_TYPE_P(templates_before) == IS_ARRAY) {
if (phalcon_valid_foreach(templates_before TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(templates_before);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_b0d8_2:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_b0d8_2;
}
PHALCON_INIT_VAR(template_before);
ZVAL_ZVAL(template_before, *hd, 1, 0);
PHALCON_INIT_VAR(r7);
PHALCON_CONCAT_VV(r7, layouts_dir, template_before);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "_enginerender", engines, r7, silence, PHALCON_NO_CHECK);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_b0d8_2;
fee_b0d8_2:
if(0){}
} else {
return;
}
} else {
PHALCON_ALLOC_ZVAL_MM(r8);
PHALCON_CONCAT_VV(r8, layouts_dir, template_before);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "_enginerender", engines, r8, silence, PHALCON_NO_CHECK);
}
PHALCON_INIT_VAR(silence);
ZVAL_BOOL(silence, 1);
}
}
PHALCON_INIT_VAR(t6);
ZVAL_LONG(t6, 3);
PHALCON_INIT_VAR(r9);
is_smaller_or_equal_function(r9, t6, render_level TSRMLS_CC);
if (zend_is_true(r9)) {
PHALCON_ALLOC_ZVAL_MM(r10);
PHALCON_CONCAT_VV(r10, layouts_dir, render_controller);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "_enginerender", engines, r10, silence, PHALCON_NO_CHECK);
}
PHALCON_INIT_VAR(t7);
ZVAL_LONG(t7, 4);
PHALCON_INIT_VAR(r11);
is_smaller_or_equal_function(r11, t7, render_level TSRMLS_CC);
if (zend_is_true(r11)) {
PHALCON_ALLOC_ZVAL_MM(t8);
phalcon_read_property(&t8, this_ptr, "_templatesAfter", sizeof("_templatesAfter")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(templates_after, t8);
if (zend_is_true(templates_after)) {
PHALCON_INIT_VAR(silence);
ZVAL_BOOL(silence, 0);
if (Z_TYPE_P(templates_after) == IS_ARRAY) {
if (phalcon_valid_foreach(templates_after TSRMLS_CC)) {
ah1 = Z_ARRVAL_P(templates_after);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_b0d8_3:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_b0d8_3;
}
PHALCON_INIT_VAR(template_after);
ZVAL_ZVAL(template_after, *hd, 1, 0);
PHALCON_INIT_VAR(r12);
PHALCON_CONCAT_VV(r12, layouts_dir, template_after);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "_enginerender", engines, r12, silence, PHALCON_NO_CHECK);
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_b0d8_3;
fee_b0d8_3:
if(0){}
} else {
return;
}
} else {
PHALCON_ALLOC_ZVAL_MM(r13);
PHALCON_CONCAT_VV(r13, layouts_dir, templates_after);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "_enginerender", engines, r13, silence, PHALCON_NO_CHECK);
}
PHALCON_INIT_VAR(silence);
ZVAL_BOOL(silence, 1);
}
}
PHALCON_INIT_VAR(t9);
ZVAL_LONG(t9, 5);
PHALCON_INIT_VAR(r14);
is_smaller_or_equal_function(r14, t9, render_level TSRMLS_CC);
if (zend_is_true(r14)) {
PHALCON_ALLOC_ZVAL_MM(t10);
phalcon_read_property(&t10, this_ptr, "_mainView", sizeof("_mainView")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "_enginerender", engines, t10, silence, PHALCON_NO_CHECK);
}
}
PHALCON_MM_RESTORE();
}
/**
* Checks whether view exists on registered extensions and render it
*
* @param array $engines
* @param string $viewPath
* @param boolean $silence
* @param boolean $mustClean
* @param Phalcon\Cache\Backend $cache
*/
PHP_METHOD(Phalcon_Mvc_View, _engineRender){
zval *engines = NULL, *view_path = NULL, *silence = NULL, *must_clean = NULL;
zval *cache = NULL, *not_exists = NULL, *view_params = NULL, *views_dir = NULL;
zval *base_path = NULL, *views_dir_path = NULL, *events_manager = NULL;
zval *render_level = NULL, *cache_level = NULL, *is_started = NULL;
zval *key = NULL, *view_options = NULL, *cache_options = NULL, *cached_view = NULL;
zval *is_fresh = NULL, *engine = NULL, *extension = NULL, *view_engine_path = NULL;
zval *event_name = NULL, *status = NULL, *exception_message = NULL;
zval *exception = NULL;
zval *r0 = NULL;
HashTable *ah0;
HashPosition hp0;
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, "zzzzz", &engines, &view_path, &silence, &must_clean, &cache) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(not_exists);
ZVAL_BOOL(not_exists, 1);
PHALCON_INIT_VAR(view_params);
phalcon_read_property(&view_params, this_ptr, SL("_viewParams"), PH_NOISY_CC);
PHALCON_INIT_VAR(views_dir);
phalcon_read_property(&views_dir, this_ptr, SL("_viewsDir"), PH_NOISY_CC);
PHALCON_INIT_VAR(base_path);
phalcon_read_property(&base_path, this_ptr, SL("_basePath"), PH_NOISY_CC);
PHALCON_INIT_VAR(views_dir_path);
PHALCON_CONCAT_VVV(views_dir_path, base_path, views_dir, view_path);
PHALCON_INIT_VAR(events_manager);
phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(cache) == IS_OBJECT) {
PHALCON_INIT_VAR(render_level);
phalcon_read_property(&render_level, this_ptr, SL("_renderLevel"), PH_NOISY_CC);
PHALCON_INIT_VAR(cache_level);
phalcon_read_property(&cache_level, this_ptr, SL("_cacheLevel"), PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r0);
is_smaller_or_equal_function(r0, cache_level, render_level TSRMLS_CC);
if (zend_is_true(r0)) {
PHALCON_INIT_VAR(is_started);
PHALCON_CALL_METHOD(is_started, cache, "isstarted", PH_NO_CHECK);
if (!zend_is_true(is_started)) {
PHALCON_INIT_VAR(key);
ZVAL_NULL(key);
PHALCON_INIT_VAR(view_options);
phalcon_read_property(&view_options, this_ptr, SL("_options"), PH_NOISY_CC);
eval_int = phalcon_array_isset_string(view_options, SL("cache")+1);
if (eval_int) {
PHALCON_INIT_VAR(cache_options);
phalcon_array_fetch_string(&cache_options, view_options, SL("cache"), PH_NOISY_CC);
if (Z_TYPE_P(cache_options) == IS_ARRAY) {
eval_int = phalcon_array_isset_string(cache_options, SL("key")+1);
if (eval_int) {
PHALCON_INIT_VAR(key);
phalcon_array_fetch_string(&key, cache_options, SL("key"), PH_NOISY_CC);
}
}
}
if (Z_TYPE_P(key) == IS_NULL) {
PHALCON_INIT_VAR(key);
PHALCON_CALL_FUNC_PARAMS_1(key, "md5", view_path);
}
PHALCON_INIT_VAR(cached_view);
PHALCON_CALL_METHOD_PARAMS_1(cached_view, cache, "start", key, PH_NO_CHECK);
if (Z_TYPE_P(cached_view) != IS_NULL) {
phalcon_update_property_zval(this_ptr, SL("_content"), cached_view TSRMLS_CC);
PHALCON_MM_RESTORE();
RETURN_NULL();
}
}
PHALCON_INIT_VAR(is_fresh);
PHALCON_CALL_METHOD(is_fresh, cache, "isfresh", PH_NO_CHECK);
if (!zend_is_true(is_fresh)) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
}
}
if (!phalcon_valid_foreach(engines TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(engines);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_ecde_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_ecde_1;
}
PHALCON_INIT_VAR(extension);
PHALCON_GET_FOREACH_KEY(extension, ah0, hp0);
PHALCON_INIT_VAR(engine);
ZVAL_ZVAL(engine, *hd, 1, 0);
PHALCON_INIT_VAR(view_engine_path);
PHALCON_CONCAT_VV(view_engine_path, views_dir_path, extension);
if (phalcon_file_exists(view_engine_path TSRMLS_CC) == SUCCESS) {
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_activeRenderPath"), view_engine_path TSRMLS_CC);
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "view:beforeRenderView", 1);
PHALCON_INIT_VAR(status);
PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", event_name, this_ptr, PH_NO_CHECK);
if (Z_TYPE_P(status) == IS_BOOL && !Z_BVAL_P(status)) {
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_ecde_1;
}
}
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(engine, "render", view_engine_path, view_params, must_clean, PH_NO_CHECK);
PHALCON_INIT_VAR(not_exists);
ZVAL_BOOL(not_exists, 0);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_activeRenderPath"), view_engine_path TSRMLS_CC);
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "view:afterRenderView", 1);
PHALCON_INIT_VAR(status);
PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", event_name, this_ptr, PH_NO_CHECK);
if (Z_TYPE_P(status) == IS_BOOL && !Z_BVAL_P(status)) {
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_ecde_1;
}
}
goto fee_ecde_1;
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_ecde_1;
fee_ecde_1:
if (Z_TYPE_P(not_exists) == IS_BOOL && Z_BVAL_P(not_exists)) {
if (!zend_is_true(silence)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "View '", views_dir_path, "' was not found in the views directory");
PHALCON_INIT_VAR(exception);
object_init_ex(exception, phalcon_mvc_view_exception_ce);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(exception, "__construct", exception_message, PH_CHECK);
phalcon_throw_exception(exception TSRMLS_CC);
return;
}
}
PHALCON_MM_RESTORE();
}
/**
* Executes the validator
*
* @param Phalcon\Mvc\ModelInterface $record
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator_Regex, validate) {
zval *record, *option = NULL, *field_name, *is_set, *value;
zval *failed = NULL, *matches, *pattern, *match_pattern;
zval *match_zero, *message = NULL, *type;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &record) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(option);
ZVAL_STRING(option, "field", 1);
PHALCON_INIT_VAR(field_name);
PHALCON_CALL_METHOD_PARAMS_1(field_name, this_ptr, "getoption", option, PH_NO_CHECK);
if (Z_TYPE_P(field_name) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Field name must be a string");
return;
}
/**
* The 'pattern' option must be a valid regular expression
*/
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "pattern", 1);
PHALCON_INIT_VAR(is_set);
PHALCON_CALL_METHOD_PARAMS_1(is_set, this_ptr, "issetoption", option, PH_NO_CHECK);
if (!zend_is_true(is_set)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Validator requires a perl-compatible regex pattern");
return;
}
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field_name, PH_NO_CHECK);
PHALCON_INIT_VAR(failed);
ZVAL_BOOL(failed, 0);
PHALCON_INIT_VAR(matches);
PHALCON_INIT_VAR(pattern);
PHALCON_CALL_METHOD_PARAMS_1(pattern, this_ptr, "getoption", option, PH_NO_CHECK);
/**
* Check if the value match using preg_match in the PHP userland
*/
Z_SET_ISREF_P(matches);
PHALCON_INIT_VAR(match_pattern);
PHALCON_CALL_FUNC_PARAMS_3(match_pattern, "preg_match", pattern, value, matches);
Z_UNSET_ISREF_P(matches);
if (zend_is_true(match_pattern)) {
PHALCON_INIT_VAR(match_zero);
phalcon_array_fetch_long(&match_zero, matches, 0, PH_NOISY_CC);
is_not_equal_function(failed, match_zero, value TSRMLS_CC);
} else {
ZVAL_BOOL(failed, 1);
}
if (PHALCON_IS_TRUE(failed)) {
/**
* Check if the developer has defined a custom message
*/
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "message", 1);
PHALCON_INIT_VAR(message);
PHALCON_CALL_METHOD_PARAMS_1(message, this_ptr, "getoption", option, PH_NO_CHECK);
if (!zend_is_true(message)) {
PHALCON_INIT_NVAR(message);
PHALCON_CONCAT_SVS(message, "Value of field '", field_name, "' doesn't match regular expression");
}
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "Regex", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", message, field_name, type, PH_NO_CHECK);
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* 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);
}
/**
* Executes a prepared statement binding
*
* @param PDOStatement $statement
* @param array $placeholders
* @param array $dataTypes
* @return PDOStatement
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, _executePrepared){
zval *statement = NULL, *placeholders = NULL, *data_types = NULL;
zval *one = NULL, *value = NULL, *wildcard = NULL, *parameter = NULL, *type = NULL, *cast_value = NULL;
HashTable *ah0;
HashPosition hp0;
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, "zzz", &statement, &placeholders, &data_types) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
if (!phalcon_valid_foreach(placeholders TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(placeholders);
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_INIT_VAR(wildcard);
PHALCON_GET_FOREACH_KEY(wildcard, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (Z_TYPE_P(wildcard) == IS_LONG) {
PHALCON_INIT_VAR(parameter);
phalcon_add_function(parameter, wildcard, one TSRMLS_CC);
} else {
if (Z_TYPE_P(wildcard) == IS_STRING) {
PHALCON_CPY_WRT(parameter, wildcard);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter");
return;
}
}
if (Z_TYPE_P(data_types) == IS_ARRAY) {
eval_int = phalcon_array_isset(data_types, wildcard);
if (eval_int) {
PHALCON_INIT_VAR(type);
phalcon_array_fetch(&type, data_types, wildcard, PH_NOISY_CC);
if (phalcon_compare_strict_long(type, 32 TSRMLS_CC)) {
PHALCON_INIT_VAR(cast_value);
PHALCON_CALL_FUNC_PARAMS_1(cast_value, "doubleval", value);
PHALCON_INIT_VAR(type);
ZVAL_LONG(type, 2);
} else {
PHALCON_CPY_WRT(cast_value, value);
}
Z_SET_ISREF_P(cast_value);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(statement, "bindparam", parameter, cast_value, type, PH_NO_CHECK);
Z_UNSET_ISREF_P(cast_value);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind type parameter");
return;
}
} else {
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(statement, "bindparam", parameter, value, PH_NO_CHECK);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
PHALCON_CALL_METHOD_NORETURN(statement, "execute", PH_NO_CHECK);
RETURN_CCTOR(statement);}
/**
* Executes the validator
*
* @param Phalcon\Mvc\Model $record
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator_Email, validate){
zval *record, *option, *field_name, *regs, *invalid = NULL;
zval *value, *pattern, *match_pattern, *match_zero;
zval *type, *message;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &record) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(option);
ZVAL_STRING(option, "field", 1);
PHALCON_INIT_VAR(field_name);
PHALCON_CALL_METHOD_PARAMS_1(field_name, this_ptr, "getoption", option, PH_NO_CHECK);
if (Z_TYPE_P(field_name) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Field name must be a string");
return;
}
PHALCON_INIT_VAR(regs);
PHALCON_INIT_VAR(invalid);
ZVAL_BOOL(invalid, 0);
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field_name, PH_NO_CHECK);
PHALCON_INIT_VAR(pattern);
ZVAL_STRING(pattern, "/^[a-zA-Z0-9\\-_\\.\\+]+@[a-zA-Z0-9_]+(\\.[a-zA-Z0-9_]+)*$/", 1);
Z_SET_ISREF_P(regs);
PHALCON_INIT_VAR(match_pattern);
PHALCON_CALL_FUNC_PARAMS_3(match_pattern, "preg_match", pattern, value, regs);
Z_UNSET_ISREF_P(regs);
if (zend_is_true(match_pattern)) {
PHALCON_INIT_VAR(match_zero);
phalcon_array_fetch_long(&match_zero, regs, 0, PH_NOISY_CC);
is_not_equal_function(invalid, match_zero, value TSRMLS_CC);
} else {
ZVAL_BOOL(invalid, 1);
}
if (PHALCON_IS_TRUE(invalid)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "email", 1);
PHALCON_INIT_VAR(message);
PHALCON_CONCAT_SVS(message, "Value of field '", field_name, "' must have a valid e-mail format");
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", message, field_name, type, PH_NO_CHECK);
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* Executes the validator
*
* @return boolean
*/
PHP_METHOD(Phalcon_Model_Validator_Uniqueness, validate){
zval *record = NULL, *field = NULL, *conditions = NULL, *compose_field = NULL;
zval *value = NULL, *manager = NULL, *meta_data = NULL, *primary_fields = NULL;
zval *primary_field = NULL, *options = 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, *r19 = NULL, *r20 = NULL;
zval *i0 = NULL;
zval *a0 = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
zval *t0 = 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_NO_CHECK);
if (zend_is_true(r0)) {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_METHOD(r1, this_ptr, "getrecord", PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(i0);
if (phalcon_clone(i0, r1 TSRMLS_CC) == FAILURE){
return;
}
PHALCON_CPY_WRT(record, i0);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CALL_METHOD(r2, this_ptr, "getfieldname", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(field, r2);
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(conditions, a0);
if (Z_TYPE_P(field) == IS_ARRAY) {
if (phalcon_valid_foreach(field TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(field);
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(compose_field);
ZVAL_ZVAL(compose_field, *hd, 1, 0);
PHALCON_INIT_VAR(r3);
PHALCON_INIT_VAR(r4);
PHALCON_CALL_METHOD_PARAMS_1(r4, record, "readattribute", compose_field, PHALCON_NO_CHECK);
PHALCON_CALL_FUNC_PARAMS_1(r3, "addslashes", r4, 0x00F);
PHALCON_CPY_WRT(value, r3);
PHALCON_INIT_VAR(r5);
PHALCON_CONCAT_VSVS(r5, compose_field, "='", value, "'");
phalcon_array_append(&conditions, r5, PHALCON_SEPARATE_PLZ TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_d73d_0;
fee_d73d_0:
if(0){}
} else {
return;
}
} else {
PHALCON_ALLOC_ZVAL_MM(r6);
PHALCON_ALLOC_ZVAL_MM(r7);
PHALCON_CALL_METHOD(r7, this_ptr, "getvalue", PHALCON_NO_CHECK);
PHALCON_CALL_FUNC_PARAMS_1(r6, "addslashes", r7, 0x00F);
PHALCON_CPY_WRT(value, r6);
PHALCON_ALLOC_ZVAL_MM(r8);
PHALCON_CONCAT_VSVS(r8, field, "='", value, "'");
phalcon_array_append(&conditions, r8, PHALCON_SEPARATE_PLZ TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(r9);
PHALCON_CALL_METHOD(r9, record, "getmanager", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(manager, r9);
PHALCON_ALLOC_ZVAL_MM(r10);
PHALCON_CALL_METHOD(r10, manager, "getmetadata", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(meta_data, r10);
PHALCON_ALLOC_ZVAL_MM(r11);
PHALCON_CALL_METHOD_PARAMS_1(r11, meta_data, "getprimarykeyattributes", record, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(primary_fields, r11);
if (phalcon_valid_foreach(primary_fields TSRMLS_CC)) {
ah1 = Z_ARRVAL_P(primary_fields);
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(primary_field);
ZVAL_ZVAL(primary_field, *hd, 1, 0);
PHALCON_INIT_VAR(r12);
PHALCON_INIT_VAR(r13);
PHALCON_INIT_VAR(r14);
PHALCON_CALL_METHOD_PARAMS_1(r14, record, "readattribute", primary_field, PHALCON_NO_CHECK);
PHALCON_CALL_FUNC_PARAMS_1(r13, "addslashes", r14, 0x00F);
PHALCON_CONCAT_VSVS(r12, primary_field, "<>'", r13, "'");
phalcon_array_append(&conditions, r12, PHALCON_SEPARATE_PLZ TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_d73d_1;
fee_d73d_1:
if(0){}
} else {
return;
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, " AND ", 1);
PHALCON_ALLOC_ZVAL_MM(r15);
phalcon_fast_join(r15, c0, conditions TSRMLS_CC);
PHALCON_CPY_WRT(conditions, r15);
PHALCON_ALLOC_ZVAL_MM(r16);
PHALCON_CALL_STATIC_ZVAL_PARAMS_1(r16, record, "count", conditions);
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 0);
PHALCON_INIT_VAR(r17);
is_smaller_function(r17, t0, r16 TSRMLS_CC);
if (zend_is_true(r17)) {
PHALCON_ALLOC_ZVAL_MM(r18);
PHALCON_CALL_METHOD(r18, this_ptr, "getoptions", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(options, r18);
eval_int = phalcon_array_isset_string(options, "message", strlen("message")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r19);
phalcon_array_fetch_string(&r19, options, "message", strlen("message"), PHALCON_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "unique", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", r19, field, c1, PHALCON_NO_CHECK);
} else {
PHALCON_ALLOC_ZVAL_MM(r20);
PHALCON_CONCAT_SVS(r20, "Value of field '", field, "' is already present in another record");
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, "unique", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", r20, field, c2, PHALCON_NO_CHECK);
}
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* Sends SQL statements to the database server returning the success state.
* Use this method only when the SQL statement sent to the server don't return any row
*
*<code>
* //Inserting data
* $success = $connection->execute("INSERT INTO robots VALUES (1, 'Astro Boy')");
* $success = $connection->execute("INSERT INTO robots VALUES (?, ?)", array(1, 'Astro Boy'));
*</code>
*
* @param string $sqlStatement
* @param array $placeholders
* @param array $dataTypes
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, execute){
zval *sql_statement = NULL, *placeholders = NULL, *data_types = NULL;
zval *events_manager = NULL, *event_name = NULL, *status = NULL, *pdo = NULL;
zval *statement = NULL, *affected_rows = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|zz", &sql_statement, &placeholders, &data_types) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!placeholders) {
PHALCON_ALLOC_ZVAL_MM(placeholders);
ZVAL_NULL(placeholders);
}
if (!data_types) {
PHALCON_ALLOC_ZVAL_MM(data_types);
ZVAL_NULL(data_types);
}
PHALCON_INIT_VAR(events_manager);
phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "db:beforeQuery", 1);
phalcon_update_property_zval(this_ptr, SL("_sqlStatement"), sql_statement TSRMLS_CC);
PHALCON_INIT_VAR(status);
PHALCON_CALL_METHOD_PARAMS_3(status, events_manager, "fire", event_name, this_ptr, placeholders, PH_NO_CHECK);
if (PHALCON_IS_FALSE(status)) {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_INIT_VAR(pdo);
phalcon_read_property(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC);
if (Z_TYPE_P(placeholders) == IS_ARRAY) {
PHALCON_INIT_VAR(statement);
PHALCON_CALL_METHOD_PARAMS_1(statement, pdo, "prepare", sql_statement, PH_NO_CHECK);
if (Z_TYPE_P(statement) == IS_OBJECT) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD_PARAMS_3(r0, this_ptr, "_executeprepared", statement, placeholders, data_types, PH_NO_CHECK);
PHALCON_CPY_WRT(statement, r0);
PHALCON_INIT_VAR(affected_rows);
PHALCON_CALL_METHOD(affected_rows, statement, "rowcount", PH_NO_CHECK);
}
} else {
PHALCON_INIT_VAR(affected_rows);
PHALCON_CALL_METHOD_PARAMS_1(affected_rows, pdo, "exec", sql_statement, PH_NO_CHECK);
}
if (Z_TYPE_P(affected_rows) == IS_LONG) {
phalcon_update_property_zval(this_ptr, SL("_affectedRows"), affected_rows TSRMLS_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "db:afterQuery", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, placeholders, PH_NO_CHECK);
}
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
