/**
* Returns an Escaper service from the default DI
*
* @return Phalcon\EscaperInterface
*/
PHP_METHOD(Phalcon_Tag, getEscaperService){
zval *escaper = NULL, *dependency_injector = NULL, *service;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(escaper);
phalcon_read_static_property(&escaper, SL("phalcon\\tag"), SL("_escaperService") TSRMLS_CC);
if (Z_TYPE_P(escaper) != IS_OBJECT) {
PHALCON_OBS_VAR(dependency_injector);
phalcon_read_static_property(&dependency_injector, SL("phalcon\\tag"), SL("_dependencyInjector") TSRMLS_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_INIT_NVAR(dependency_injector);
PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault");
}
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "A dependency injector container is required to obtain the \"dispatcher\" service");
return;
}
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "escaper", 1);
PHALCON_INIT_NVAR(escaper);
PHALCON_CALL_METHOD_PARAMS_1(escaper, dependency_injector, "getshared", service);
phalcon_update_static_property(SL("phalcon\\tag"), SL("_escaperService"), escaper TSRMLS_CC);
}
RETURN_CCTOR(escaper);
}
/**
* Gets public URL to phalcon instance
*
* @param string $uri
* @return string
*/
PHP_METHOD(Phalcon_Utils, getUrl){
zval *uri = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &uri) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!uri) {
PHALCON_INIT_VAR(uri);
ZVAL_NULL(uri);
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CALL_STATIC(r2, "phalcon_controller_front", "getinstance");
PHALCON_CALL_METHOD(r1, r2, "getbaseuri", PHALCON_NO_CHECK);
PHALCON_CONCAT_VV(r0, r1, uri);
RETURN_CTOR(r0);
}
/**
* Return a URL service from the DI
*
* @return Phalcon\Mvc\UrlInterface
*/
PHP_METHOD(Phalcon_Tag, getUrlService){
zval *url = NULL, *dependency_injector = NULL, *service;
PHALCON_MM_GROW();
PHALCON_OBSERVE_VAR(url);
phalcon_read_static_property(&url, SL("phalcon\\tag"), SL("_urlService") TSRMLS_CC);
if (Z_TYPE_P(url) == IS_NULL) {
PHALCON_OBSERVE_VAR(dependency_injector);
phalcon_read_static_property(&dependency_injector, SL("phalcon\\tag"), SL("_dependencyInjector") TSRMLS_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_INIT_NVAR(dependency_injector);
PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault");
}
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "A dependency injector container is required to obtain the \"url\" service");
return;
}
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "url", 1);
PHALCON_INIT_NVAR(url);
PHALCON_CALL_METHOD_PARAMS_1(url, dependency_injector, "getshared", service, PH_NO_CHECK);
phalcon_update_static_property(SL("phalcon\\tag"), SL("_urlService"), url TSRMLS_CC);
}
RETURN_CCTOR(url);
}
/**
* Returns a Dispatcher service from the DI
*
* @return Phalcon\Mvc\Dispatcher
*/
PHP_METHOD(Phalcon_Tag, getDispatcherService){
zval *dependency_injector = NULL, *dispatcher = NULL;
zval *c0 = NULL;
PHALCON_MM_GROW();
PHALCON_OBSERVE_VAR(dependency_injector);
phalcon_read_static_property(&dependency_injector, SL("phalcon\\tag"), SL("_dependencyInjector") TSRMLS_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_INIT_VAR(dependency_injector);
PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault");
}
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "A dependency injector container is required to obtain the \"dispatcher\" service");
return;
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "dispatcher", 1);
PHALCON_INIT_VAR(dispatcher);
PHALCON_CALL_METHOD_PARAMS_1(dispatcher, dependency_injector, "getshared", c0, PH_NO_CHECK);
RETURN_CCTOR(dispatcher);
}
/**
* Phalcon\Mvc\Model\Transaction\Manager constructor
*
* @param Phalcon\DiInterface $dependencyInjector
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, __construct){
zval *dependency_injector = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &dependency_injector);
if (!dependency_injector) {
PHALCON_INIT_VAR(dependency_injector);
} else {
PHALCON_SEPARATE_PARAM(dependency_injector);
}
if (zend_is_true(dependency_injector)) {
phalcon_update_property_this(this_ptr, SL("_dependencyInjector"), dependency_injector TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(dependency_injector);
PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault");
phalcon_update_property_this(this_ptr, SL("_dependencyInjector"), dependency_injector TSRMLS_CC);
}
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_transaction_exception_ce, "A dependency injector container is required to obtain the services related to the ORM");
return;
}
PHALCON_MM_RESTORE();
}
/**
* Returns the internal dependency injector
*
* @return Phalcon\DiInterface
*/
PHP_METHOD(Phalcon_DI_Injectable, getDI){
zval *dependency_injector = NULL;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(dependency_injector);
phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_INIT_NVAR(dependency_injector);
PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault");
}
RETURN_CCTOR(dependency_injector);
}
/**
* Initializes the session bag. This method must not be called directly, the class calls it when its internal data is accesed
*/
PHP_METHOD(Phalcon_Session_Bag, initialize){
zval *session = NULL, *dependency_injector = NULL, *service;
zval *name, *data = NULL;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(session);
phalcon_read_property_this(&session, this_ptr, SL("_session"), PH_NOISY_CC);
if (Z_TYPE_P(session) != IS_OBJECT) {
PHALCON_OBS_VAR(dependency_injector);
phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_INIT_NVAR(dependency_injector);
PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault");
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_session_exception_ce, "A dependency injection object is required to access the 'session' service");
return;
}
}
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "session", 1);
PHALCON_INIT_NVAR(session);
phalcon_call_method_p1(session, dependency_injector, "getshared", service);
PHALCON_VERIFY_INTERFACE(session, phalcon_session_adapterinterface_ce);
phalcon_update_property_this(this_ptr, SL("_session"), session TSRMLS_CC);
}
PHALCON_OBS_VAR(name);
phalcon_read_property_this(&name, this_ptr, SL("_name"), PH_NOISY_CC);
PHALCON_INIT_VAR(data);
phalcon_call_method_p1(data, session, "get", name);
if (Z_TYPE_P(data) != IS_ARRAY) {
PHALCON_INIT_NVAR(data);
array_init(data);
}
phalcon_update_property_this(this_ptr, SL("_data"), data TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_initalized"), 1 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Returns the major framework's version
*
* @return string
*/
PHP_METHOD(Phalcon_Debug, getMajorVersion){
zval *version, *parts, *major;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(version);
PHALCON_CALL_STATIC(version, "phalcon\\version", "get");
PHALCON_INIT_VAR(parts);
phalcon_fast_explode_str(parts, SL(" "), version);
PHALCON_OBS_VAR(major);
phalcon_array_fetch_long(&major, parts, 0, PH_NOISY);
RETURN_CCTOR(major);
}
/**
* Returns the internal dependency injector
*
* @return Phalcon\DiInterface
*/
PHP_METHOD(Phalcon_Http_Response, getDI){
zval *dependency_injector = NULL;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(dependency_injector);
phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_INIT_NVAR(dependency_injector);
PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault");
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_http_request_exception_ce, "A dependency injection object is required to access the 'url' service");
return;
}
phalcon_update_property_this(this_ptr, SL("_dependencyInjector"), dependency_injector TSRMLS_CC);
}
RETURN_CCTOR(dependency_injector);
}
/**
* Gets the a value to validate in the array/object data source
*
* @param string $attribute
* @return mixed
*/
PHP_METHOD(Phalcon_Validation, getValue){
zval *attribute, *entity, *method, *value = NULL, *data, *values;
zval *filters, *field_filters, *service_name;
zval *dependency_injector = NULL, *filter_service;
zval *filtered;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &attribute);
PHALCON_OBS_VAR(entity);
phalcon_read_property_this(&entity, this_ptr, SL("_entity"), PH_NOISY_CC);
/**
* If the entity is an object use it to retrieve the values
*/
if (Z_TYPE_P(entity) == IS_OBJECT) {
PHALCON_INIT_VAR(method);
PHALCON_CONCAT_SV(method, "get", attribute);
if (phalcon_method_exists(entity, method TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(value);
phalcon_call_method_zval(value, entity, method);
} else {
if (phalcon_method_exists_ex(entity, SS("readattribute") TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_NVAR(value);
phalcon_call_method(value, entity, "readattribute");
} else {
if (phalcon_isset_property_zval(entity, attribute TSRMLS_CC)) {
PHALCON_OBS_NVAR(value);
phalcon_read_property_zval(&value, entity, attribute, PH_NOISY_CC);
} else {
PHALCON_INIT_NVAR(value);
}
}
}
RETURN_CCTOR(value);
}
PHALCON_OBS_VAR(data);
phalcon_read_property_this(&data, this_ptr, SL("_data"), PH_NOISY_CC);
if (Z_TYPE_P(data) != IS_ARRAY) {
if (Z_TYPE_P(data) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "There is no data to validate");
return;
}
}
/**
* Check if there is a calculated value
*/
PHALCON_OBS_VAR(values);
phalcon_read_property_this(&values, this_ptr, SL("_values"), PH_NOISY_CC);
if (phalcon_array_isset(values, attribute)) {
PHALCON_OBS_NVAR(value);
phalcon_array_fetch(&value, values, attribute, PH_NOISY_CC);
RETURN_CCTOR(value);
}
PHALCON_INIT_NVAR(value);
if (Z_TYPE_P(data) == IS_ARRAY) {
if (phalcon_array_isset(data, attribute)) {
PHALCON_OBS_NVAR(value);
phalcon_array_fetch(&value, data, attribute, PH_NOISY_CC);
}
} else {
if (Z_TYPE_P(data) == IS_OBJECT) {
if (phalcon_isset_property_zval(data, attribute TSRMLS_CC)) {
PHALCON_OBS_NVAR(value);
phalcon_read_property_zval(&value, data, attribute, PH_NOISY_CC);
}
}
}
if (Z_TYPE_P(value) != IS_NULL) {
PHALCON_OBS_VAR(filters);
phalcon_read_property_this(&filters, this_ptr, SL("_filters"), PH_NOISY_CC);
if (Z_TYPE_P(filters) == IS_ARRAY) {
if (phalcon_array_isset(filters, attribute)) {
PHALCON_OBS_VAR(field_filters);
phalcon_array_fetch(&field_filters, filters, attribute, PH_NOISY_CC);
if (zend_is_true(field_filters)) {
PHALCON_INIT_VAR(service_name);
ZVAL_STRING(service_name, "filter", 1);
PHALCON_INIT_VAR(dependency_injector);
phalcon_call_method(dependency_injector, this_ptr, "getdi");
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_INIT_NVAR(dependency_injector);
PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault");
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "A dependency injector is required to obtain the 'filter' service");
return;
}
}
PHALCON_INIT_VAR(filter_service);
phalcon_call_method_p1(filter_service, dependency_injector, "getshared", service_name);
if (Z_TYPE_P(filter_service) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "Returned 'filter' service is invalid");
return;
}
PHALCON_INIT_VAR(filtered);
phalcon_call_method_p2(filtered, filter_service, "sanitize", value, field_filters);
RETURN_CCTOR(filtered);
}
}
}
/**
* Cache the calculated value
*/
phalcon_update_property_array(this_ptr, SL("_values"), attribute, value TSRMLS_CC);
RETURN_CCTOR(value);
}
RETURN_MM_NULL();
}
/**
* 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();
}
/**
* Returns a PHQL statement built based on the builder parameters
*
* @return string
*/
PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql){
zval *dependency_injector = NULL, *models, *conditions = NULL;
zval *one, *number_models, *invalid_condition;
zval *model = NULL, *service_name, *meta_data, *model_instance;
zval *no_primary = NULL, *primary_keys, *first_primary_key;
zval *column_map = NULL, *attribute_field = NULL, *exception_message;
zval *primary_key_condition, *phql, *columns;
zval *selected_columns = NULL, *column = NULL, *alias = NULL, *aliased_column = NULL;
zval *joined_columns = NULL, *selected_column = NULL, *selected_models;
zval *selected_model = NULL, *joined_models, *joins;
zval *join = NULL, *join_model = NULL, *join_conditions = NULL, *join_alias = NULL;
zval *join_type = NULL, *group, *group_items, *group_item = NULL;
zval *escaped_item = NULL, *joined_items = NULL, *having, *order;
zval *order_items, *order_item = NULL, *limit, *number;
zval *offset = NULL;
HashTable *ah0, *ah1, *ah2, *ah3, *ah4, *ah5;
HashPosition hp0, hp1, hp2, hp3, hp4, hp5;
zval **hd;
zend_class_entry *ce0;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(dependency_injector);
phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_INIT_NVAR(dependency_injector);
PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault");
phalcon_update_property_zval(this_ptr, SL("_dependencyInjector"), dependency_injector TSRMLS_CC);
}
PHALCON_OBS_VAR(models);
phalcon_read_property(&models, this_ptr, SL("_models"), PH_NOISY_CC);
if (Z_TYPE_P(models) == IS_ARRAY) {
if (!phalcon_fast_count_ev(models TSRMLS_CC)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "At least one model is required to build the query");
return;
}
} else {
if (!zend_is_true(models)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "At least one model is required to build the query");
return;
}
}
PHALCON_OBS_VAR(conditions);
phalcon_read_property(&conditions, this_ptr, SL("_conditions"), PH_NOISY_CC);
if (phalcon_is_numeric(conditions)) {
/**
* If the conditions is a single numeric field. We internally create a condition
* using the related primary key
*/
if (Z_TYPE_P(models) == IS_ARRAY) {
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_INIT_VAR(number_models);
phalcon_fast_count(number_models, models TSRMLS_CC);
PHALCON_INIT_VAR(invalid_condition);
is_smaller_function(invalid_condition, one, number_models TSRMLS_CC);
if (PHALCON_IS_TRUE(invalid_condition)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Cannot build the query. Invalid condition");
return;
}
PHALCON_OBS_VAR(model);
phalcon_array_fetch_long(&model, models, 0, PH_NOISY_CC);
} else {
PHALCON_CPY_WRT(model, models);
}
PHALCON_INIT_VAR(service_name);
ZVAL_STRING(service_name, "modelsMetadata", 1);
/**
* Get the models metadata service to obtain the column names, column map and
* primary key
*/
PHALCON_INIT_VAR(meta_data);
PHALCON_CALL_METHOD_PARAMS_1(meta_data, dependency_injector, "getshared", service_name);
ce0 = phalcon_fetch_class(model TSRMLS_CC);
PHALCON_INIT_VAR(model_instance);
object_init_ex(model_instance, ce0);
if (phalcon_has_constructor(model_instance TSRMLS_CC)) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(model_instance, "__construct", dependency_injector);
}
PHALCON_INIT_VAR(no_primary);
ZVAL_BOOL(no_primary, 1);
PHALCON_INIT_VAR(primary_keys);
PHALCON_CALL_METHOD_PARAMS_1(primary_keys, meta_data, "getprimarykeyattributes", model_instance);
if (phalcon_fast_count_ev(primary_keys TSRMLS_CC)) {
if (phalcon_array_isset_long(primary_keys, 0)) {
PHALCON_OBS_VAR(first_primary_key);
phalcon_array_fetch_long(&first_primary_key, primary_keys, 0, PH_NOISY_CC);
/**
* The PHQL contains the renamed columns if available
*/
if (PHALCON_GLOBAL(orm).column_renaming) {
PHALCON_INIT_VAR(column_map);
PHALCON_CALL_METHOD_PARAMS_1(column_map, meta_data, "getcolumnmap", model_instance);
} else {
PHALCON_INIT_NVAR(column_map);
}
if (Z_TYPE_P(column_map) == IS_ARRAY) {
if (phalcon_array_isset(column_map, first_primary_key)) {
PHALCON_OBS_VAR(attribute_field);
phalcon_array_fetch(&attribute_field, column_map, first_primary_key, PH_NOISY_CC);
} else {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Column '", first_primary_key, "\" isn't part of the column map");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message);
return;
}
} else {
PHALCON_CPY_WRT(attribute_field, first_primary_key);
}
PHALCON_INIT_VAR(primary_key_condition);
PHALCON_CONCAT_SVSVSV(primary_key_condition, "[", model, "].[", attribute_field, "] = ", conditions);
PHALCON_CPY_WRT(conditions, primary_key_condition);
ZVAL_BOOL(no_primary, 0);
}
}
/**
* A primary key is mandatory in these cases
*/
if (PHALCON_IS_TRUE(no_primary)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Source related to this model does not have a primary key defined");
return;
}
}
PHALCON_INIT_VAR(phql);
ZVAL_STRING(phql, "SELECT ", 1);
PHALCON_OBS_VAR(columns);
phalcon_read_property(&columns, this_ptr, SL("_columns"), PH_NOISY_CC);
if (Z_TYPE_P(columns) != IS_NULL) {
if (Z_TYPE_P(columns) == IS_ARRAY) {
PHALCON_INIT_VAR(selected_columns);
array_init(selected_columns);
if (!phalcon_is_iterable(columns, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(alias, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(column);
if (Z_TYPE_P(alias) == IS_LONG) {
phalcon_array_append(&selected_columns, column, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(aliased_column);
PHALCON_CONCAT_VSV(aliased_column, column, " AS ", alias);
phalcon_array_append(&selected_columns, aliased_column, PH_SEPARATE TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(joined_columns);
phalcon_fast_join_str(joined_columns, SL(", "), selected_columns TSRMLS_CC);
phalcon_concat_self(&phql, joined_columns TSRMLS_CC);
} else {
phalcon_concat_self(&phql, columns TSRMLS_CC);
}
} else {
if (Z_TYPE_P(models) == IS_ARRAY) {
PHALCON_INIT_NVAR(selected_columns);
array_init(selected_columns);
if (!phalcon_is_iterable(models, &ah1, &hp1, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(alias, ah1, hp1);
PHALCON_GET_FOREACH_VALUE(model);
if (Z_TYPE_P(alias) == IS_LONG) {
PHALCON_INIT_NVAR(selected_column);
PHALCON_CONCAT_SVS(selected_column, "[", model, "].*");
} else {
PHALCON_INIT_NVAR(selected_column);
PHALCON_CONCAT_SVS(selected_column, "[", alias, "].*");
}
phalcon_array_append(&selected_columns, selected_column, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
}
PHALCON_INIT_NVAR(joined_columns);
phalcon_fast_join_str(joined_columns, SL(", "), selected_columns TSRMLS_CC);
phalcon_concat_self(&phql, joined_columns TSRMLS_CC);
} else {
PHALCON_SCONCAT_SVS(phql, "[", models, "].*");
}
}
/**
* Join multiple models or use a single one if it is a string
*/
if (Z_TYPE_P(models) == IS_ARRAY) {
PHALCON_INIT_VAR(selected_models);
array_init(selected_models);
if (!phalcon_is_iterable(models, &ah2, &hp2, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(alias, ah2, hp2);
PHALCON_GET_FOREACH_VALUE(model);
if (Z_TYPE_P(alias) == IS_STRING) {
PHALCON_INIT_NVAR(selected_model);
PHALCON_CONCAT_SVSVS(selected_model, "[", model, "] AS [", alias, "]");
} else {
PHALCON_INIT_NVAR(selected_model);
PHALCON_CONCAT_SVS(selected_model, "[", model, "]");
}
phalcon_array_append(&selected_models, selected_model, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah2, &hp2);
}
PHALCON_INIT_VAR(joined_models);
phalcon_fast_join_str(joined_models, SL(", "), selected_models TSRMLS_CC);
PHALCON_SCONCAT_SV(phql, " FROM ", joined_models);
} else {
PHALCON_SCONCAT_SVS(phql, " FROM [", models, "]");
}
/**
* Check if joins were passed to the builders
*/
PHALCON_OBS_VAR(joins);
phalcon_read_property(&joins, this_ptr, SL("_joins"), PH_NOISY_CC);
if (Z_TYPE_P(joins) == IS_ARRAY) {
if (!phalcon_is_iterable(joins, &ah3, &hp3, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(join);
/**
* The joined table is in the first place of the array
*/
PHALCON_OBS_NVAR(join_model);
phalcon_array_fetch_long(&join_model, join, 0, PH_NOISY_CC);
/**
* The join conditions are in the second place of the array
*/
PHALCON_OBS_NVAR(join_conditions);
phalcon_array_fetch_long(&join_conditions, join, 1, PH_NOISY_CC);
/**
* The join alias is in the second place of the array
*/
PHALCON_OBS_NVAR(join_alias);
phalcon_array_fetch_long(&join_alias, join, 2, PH_NOISY_CC);
/**
* Join type
*/
PHALCON_OBS_NVAR(join_type);
phalcon_array_fetch_long(&join_type, join, 3, PH_NOISY_CC);
/**
* Create the join according to the type
*/
if (zend_is_true(join_type)) {
PHALCON_SCONCAT_VSVS(phql, join_type, " JOIN [", join_model, "]");
} else {
PHALCON_SCONCAT_SVS(phql, " JOIN [", join_model, "]");
}
/**
* Alias comes first
*/
if (zend_is_true(join_alias)) {
PHALCON_SCONCAT_SVS(phql, " AS [", join_alias, "]");
}
/**
* Conditions then
*/
if (zend_is_true(join_conditions)) {
PHALCON_SCONCAT_SV(phql, " ON ", join_conditions);
}
zend_hash_move_forward_ex(ah3, &hp3);
}
}
if (Z_TYPE_P(conditions) == IS_STRING) {
PHALCON_SCONCAT_SV(phql, " WHERE ", conditions);
}
/**
* Process group parameters
*/
PHALCON_OBS_VAR(group);
phalcon_read_property(&group, this_ptr, SL("_group"), PH_NOISY_CC);
if (Z_TYPE_P(group) != IS_NULL) {
if (Z_TYPE_P(group) == IS_ARRAY) {
PHALCON_INIT_VAR(group_items);
array_init(group_items);
if (!phalcon_is_iterable(group, &ah4, &hp4, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(group_item);
if (phalcon_is_numeric(group_item)) {
phalcon_array_append(&group_items, group_item, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(group_item, SL(".") TSRMLS_CC)) {
phalcon_array_append(&group_items, group_item, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(escaped_item);
PHALCON_CONCAT_SVS(escaped_item, "[", group_item, "]");
phalcon_array_append(&group_items, escaped_item, PH_SEPARATE TSRMLS_CC);
}
}
zend_hash_move_forward_ex(ah4, &hp4);
}
PHALCON_INIT_VAR(joined_items);
phalcon_fast_join_str(joined_items, SL(", "), group_items TSRMLS_CC);
PHALCON_SCONCAT_SV(phql, " GROUP BY ", joined_items);
} else {
if (phalcon_is_numeric(group)) {
PHALCON_SCONCAT_SV(phql, " GROUP BY ", group);
} else {
if (phalcon_memnstr_str(group, SL(".") TSRMLS_CC)) {
PHALCON_SCONCAT_SV(phql, " GROUP BY ", group);
} else {
PHALCON_SCONCAT_SVS(phql, " GROUP BY [", group, "]");
}
}
}
PHALCON_OBS_VAR(having);
phalcon_read_property(&having, this_ptr, SL("_having"), PH_NOISY_CC);
if (Z_TYPE_P(having) != IS_NULL) {
PHALCON_SCONCAT_SV(phql, " HAVING ", having);
}
}
/**
* Process order clause
*/
PHALCON_OBS_VAR(order);
phalcon_read_property(&order, this_ptr, SL("_order"), PH_NOISY_CC);
if (Z_TYPE_P(order) != IS_NULL) {
if (Z_TYPE_P(order) == IS_ARRAY) {
PHALCON_INIT_VAR(order_items);
array_init(order_items);
if (!phalcon_is_iterable(order, &ah5, &hp5, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah5, (void**) &hd, &hp5) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(order_item);
if (phalcon_is_numeric(order_item)) {
phalcon_array_append(&order_items, order_item, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(order_item, SL(".") TSRMLS_CC)) {
phalcon_array_append(&order_items, order_item, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(escaped_item);
PHALCON_CONCAT_SVS(escaped_item, "[", order_item, "]");
phalcon_array_append(&order_items, escaped_item, PH_SEPARATE TSRMLS_CC);
}
}
zend_hash_move_forward_ex(ah5, &hp5);
}
PHALCON_INIT_NVAR(joined_items);
phalcon_fast_join_str(joined_items, SL(", "), order_items TSRMLS_CC);
PHALCON_SCONCAT_SV(phql, " ORDER BY ", joined_items);
} else {
PHALCON_SCONCAT_SV(phql, " ORDER BY ", order);
}
}
/**
* Process limit parameters
*/
PHALCON_OBS_VAR(limit);
phalcon_read_property(&limit, this_ptr, SL("_limit"), PH_NOISY_CC);
if (Z_TYPE_P(limit) != IS_NULL) {
if (Z_TYPE_P(limit) == IS_ARRAY) {
PHALCON_OBS_VAR(number);
phalcon_array_fetch_string(&number, limit, SL("number"), PH_NOISY_CC);
if (phalcon_array_isset_string(limit, SS("offset"))) {
PHALCON_OBS_VAR(offset);
phalcon_array_fetch_string(&offset, limit, SL("offset"), PH_NOISY_CC);
if (phalcon_is_numeric(offset)) {
PHALCON_SCONCAT_SVSV(phql, " LIMIT ", number, " OFFSET ", offset);
} else {
PHALCON_SCONCAT_SVS(phql, " LIMIT ", number, " OFFSET 0");
}
} else {
PHALCON_SCONCAT_SV(phql, " LIMIT ", number);
}
} else {
if (phalcon_is_numeric(limit)) {
PHALCON_SCONCAT_SV(phql, " LIMIT ", limit);
PHALCON_OBS_NVAR(offset);
phalcon_read_property(&offset, this_ptr, SL("_offset"), PH_NOISY_CC);
if (Z_TYPE_P(offset) != IS_NULL) {
if (phalcon_is_numeric(offset)) {
PHALCON_SCONCAT_SV(phql, " OFFSET ", offset);
} else {
phalcon_concat_self_str(&phql, SL(" OFFSET 0") TSRMLS_CC);
}
}
}
}
}
RETURN_CTOR(phql);
}
/**
* Magic method __get
*
* @param string $propertyName
*/
PHP_METHOD(Phalcon_DI_Injectable, __get){
zval *property_name, *dependency_injector = NULL;
zval *has_service, *service = NULL, *class_name, *arguments;
zval *persistent;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &property_name);
PHALCON_OBS_VAR(dependency_injector);
phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_INIT_NVAR(dependency_injector);
PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault");
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_di_exception_ce, "A dependency injection object is required to access the application services");
return;
}
}
/**
* Fallback to the PHP userland if the cache is not available
*/
PHALCON_INIT_VAR(has_service);
phalcon_call_method_p1(has_service, dependency_injector, "has", property_name);
if (zend_is_true(has_service)) {
PHALCON_INIT_VAR(service);
phalcon_call_method_p1(service, dependency_injector, "getshared", property_name);
phalcon_update_property_zval_zval(this_ptr, property_name, service TSRMLS_CC);
RETURN_CCTOR(service);
}
if (PHALCON_IS_STRING(property_name, "di")) {
phalcon_update_property_this(this_ptr, SL("di"), dependency_injector TSRMLS_CC);
RETURN_CCTOR(dependency_injector);
}
/**
* Accessing the persistent property will create a session bag in any class
*/
if (PHALCON_IS_STRING(property_name, "persistent")) {
PHALCON_INIT_VAR(class_name);
phalcon_get_class(class_name, this_ptr, 0 TSRMLS_CC);
PHALCON_INIT_VAR(arguments);
array_init_size(arguments, 1);
phalcon_array_append(&arguments, class_name, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(service);
ZVAL_STRING(service, "sessionBag", 1);
PHALCON_INIT_VAR(persistent);
phalcon_call_method_p2(persistent, dependency_injector, "get", service, arguments);
phalcon_update_property_this(this_ptr, SL("persistent"), persistent TSRMLS_CC);
RETURN_CCTOR(persistent);
}
/**
* A notice is shown if the property is not defined and isn't a valid service
*/
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Access to undefined property %s", Z_STRVAL_P(property_name));
RETURN_MM_NULL();
}
/**
* Executes the dispatch loop
*
* @return Phalcon_View
*/
PHP_METHOD(Phalcon_Controller_Front, dispatchLoop){
zval *dispatcher = NULL, *router = NULL, *base_path = NULL, *view = NULL, *model = NULL;
zval *response = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_dispatcher"), PH_NOISY_CC);
if (!zend_is_true(t0)) {
PHALCON_INIT_VAR(dispatcher);
object_init_ex(dispatcher, phalcon_dispatcher_ce);
PHALCON_CALL_METHOD_NORETURN(dispatcher, "__construct", PH_CHECK);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, SL("_controllersDir"), PH_NOISY_CC);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(dispatcher, "setcontrollersdir", t1, PH_NO_CHECK);
} else {
PHALCON_INIT_VAR(dispatcher);
phalcon_read_property(&dispatcher, this_ptr, SL("_dispatcher"), PH_NOISY_CC);
}
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, SL("_request"), PH_NOISY_CC);
if (!zend_is_true(t2)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_STATIC(r0, "phalcon\\request", "getinstance");
phalcon_update_property_zval(this_ptr, SL("_request"), r0 TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(t3);
phalcon_read_property(&t3, this_ptr, SL("_response"), PH_NOISY_CC);
if (!zend_is_true(t3)) {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_STATIC(r1, "phalcon\\response", "getinstance");
phalcon_update_property_zval(this_ptr, SL("_response"), r1 TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(t4);
phalcon_read_property(&t4, this_ptr, SL("_router"), PH_NOISY_CC);
if (!zend_is_true(t4)) {
PHALCON_INIT_VAR(router);
object_init_ex(router, phalcon_router_rewrite_ce);
PHALCON_CALL_METHOD_NORETURN(router, "__construct", PH_CHECK);
PHALCON_CALL_METHOD_NORETURN(router, "handle", PH_NO_CHECK);
} else {
PHALCON_INIT_VAR(router);
phalcon_read_property(&router, this_ptr, SL("_router"), PH_NOISY_CC);
}
PHALCON_INIT_VAR(base_path);
phalcon_read_property(&base_path, this_ptr, SL("_basePath"), PH_NOISY_CC);
PHALCON_INIT_VAR(view);
PHALCON_CALL_METHOD(view, this_ptr, "getviewcomponent", PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(view, "setbasepath", base_path, PH_NO_CHECK);
PHALCON_CALL_METHOD_NORETURN(view, "start", PH_NO_CHECK);
PHALCON_INIT_VAR(model);
PHALCON_CALL_METHOD(model, this_ptr, "getmodelcomponent", PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(model, "setbasepath", base_path, PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(dispatcher, "setbasepath", base_path, PH_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CALL_METHOD(r2, router, "getcontrollername", PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(dispatcher, "setcontrollername", r2, PH_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CALL_METHOD(r3, router, "getactionname", PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(dispatcher, "setactionname", r3, PH_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CALL_METHOD(r4, router, "getparams", PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(dispatcher, "setparams", r4, PH_NO_CHECK);
phalcon_update_property_zval(this_ptr, SL("_dispatcher"), dispatcher TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_router"), router TSRMLS_CC);
PHALCON_INIT_VAR(response);
phalcon_read_property(&response, this_ptr, SL("_response"), PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(t5);
phalcon_read_property(&t5, this_ptr, SL("_request"), PH_NOISY_CC);
PHALCON_CALL_METHOD_PARAMS_4_NORETURN(dispatcher, "dispatch", t5, response, view, model, PH_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_CALL_METHOD(r5, dispatcher, "getcontrollername", PH_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r6);
PHALCON_CALL_METHOD(r6, dispatcher, "getactionname", PH_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r7);
PHALCON_CALL_METHOD(r7, dispatcher, "getparams", PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(view, "render", r5, r6, r7, PH_NO_CHECK);
PHALCON_CALL_METHOD_NORETURN(view, "finish", PH_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r8);
PHALCON_CALL_METHOD(r8, view, "getcontent", PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(response, "setcontent", r8, PH_NO_CHECK);
PHALCON_CALL_METHOD_NORETURN(response, "sendheaders", PH_NO_CHECK);
RETURN_CCTOR(response);
}
/**
* Executes the dispatch loop
*
* @return Phalcon_View
*/
PHP_METHOD(Phalcon_Controller_Front, dispatchLoop){
zval *dispatcher = NULL, *router = NULL, *base_path = NULL, *view = NULL, *model = NULL;
zval *response = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL;
zval *t7 = NULL, *t8 = NULL, *t9 = NULL;
zval *i0 = NULL, *i1 = 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;
zval *p18[] = { NULL, NULL, NULL, NULL };
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_dispatcher", sizeof("_dispatcher")-1, PHALCON_NOISY TSRMLS_CC);
if (!zend_is_true(t0)) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_dispatcher_ce);
PHALCON_CALL_METHOD_NORETURN(i0, "__construct", PHALCON_CHECK);
PHALCON_CPY_WRT(dispatcher, i0);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_controllersDir", sizeof("_controllersDir")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(dispatcher, "setcontrollersdir", t1, PHALCON_NO_CHECK);
} else {
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_dispatcher", sizeof("_dispatcher")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(dispatcher, t2);
}
PHALCON_ALLOC_ZVAL_MM(t3);
phalcon_read_property(&t3, this_ptr, "_request", sizeof("_request")-1, PHALCON_NOISY TSRMLS_CC);
if (!zend_is_true(t3)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_STATIC(r0, "phalcon_request", "getinstance");
phalcon_update_property_zval(this_ptr, "_request", strlen("_request"), r0 TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(t4);
phalcon_read_property(&t4, this_ptr, "_response", sizeof("_response")-1, PHALCON_NOISY TSRMLS_CC);
if (!zend_is_true(t4)) {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_STATIC(r1, "phalcon_response", "getinstance");
phalcon_update_property_zval(this_ptr, "_response", strlen("_response"), r1 TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(t5);
phalcon_read_property(&t5, this_ptr, "_router", sizeof("_router")-1, PHALCON_NOISY TSRMLS_CC);
if (!zend_is_true(t5)) {
PHALCON_ALLOC_ZVAL_MM(i1);
object_init_ex(i1, phalcon_router_rewrite_ce);
PHALCON_CALL_METHOD_NORETURN(i1, "__construct", PHALCON_CHECK);
PHALCON_CPY_WRT(router, i1);
PHALCON_CALL_METHOD_NORETURN(router, "handle", PHALCON_NO_CHECK);
} else {
PHALCON_ALLOC_ZVAL_MM(t6);
phalcon_read_property(&t6, this_ptr, "_router", sizeof("_router")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(router, t6);
}
PHALCON_ALLOC_ZVAL_MM(t7);
phalcon_read_property(&t7, this_ptr, "_basePath", sizeof("_basePath")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(base_path, t7);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CALL_METHOD(r2, this_ptr, "getviewcomponent", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(view, r2);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(view, "setbasepath", base_path, PHALCON_NO_CHECK);
PHALCON_CALL_METHOD_NORETURN(view, "start", PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CALL_METHOD(r3, this_ptr, "getmodelcomponent", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(model, r3);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(model, "setbasepath", base_path, PHALCON_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(dispatcher, "setbasepath", base_path, PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CALL_METHOD(r4, router, "getcontrollername", PHALCON_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(dispatcher, "setcontrollername", r4, PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_CALL_METHOD(r5, router, "getactionname", PHALCON_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(dispatcher, "setactionname", r5, PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r6);
PHALCON_CALL_METHOD(r6, router, "getparams", PHALCON_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(dispatcher, "setparams", r6, PHALCON_NO_CHECK);
phalcon_update_property_zval(this_ptr, "_dispatcher", strlen("_dispatcher"), dispatcher TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_router", strlen("_router"), router TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t8);
phalcon_read_property(&t8, this_ptr, "_response", sizeof("_response")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(response, t8);
PHALCON_ALLOC_ZVAL_MM(t9);
phalcon_read_property(&t9, this_ptr, "_request", sizeof("_request")-1, PHALCON_NOISY TSRMLS_CC);
p18[0] = t9;
p18[1] = response;
p18[2] = view;
p18[3] = model;
PHALCON_CALL_METHOD_PARAMS_NORETURN(dispatcher, "dispatch", 4, p18, PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r7);
PHALCON_CALL_METHOD(r7, dispatcher, "getcontrollername", PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r8);
PHALCON_CALL_METHOD(r8, dispatcher, "getactionname", PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r9);
PHALCON_CALL_METHOD(r9, dispatcher, "getparams", PHALCON_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(view, "render", r7, r8, r9, PHALCON_NO_CHECK);
PHALCON_CALL_METHOD_NORETURN(view, "finish", PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r10);
PHALCON_CALL_METHOD(r10, view, "getcontent", PHALCON_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(response, "setcontent", r10, PHALCON_NO_CHECK);
PHALCON_RETURN_CHECK_CTOR(response);
}
