/**
* Resets the view component to its factory default values
*
*/
PHP_METHOD(Phalcon_Mvc_View, reset){
phalcon_update_property_bool(this_ptr, SL("_disabled"), 0 TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_engines"), 0 TSRMLS_CC);
phalcon_update_property_null(this_ptr, SL("_cache") TSRMLS_CC);
phalcon_update_property_long(this_ptr, SL("_renderLevel"), 5 TSRMLS_CC);
phalcon_update_property_long(this_ptr, SL("_cacheLevel"), 0 TSRMLS_CC);
phalcon_update_property_null(this_ptr, SL("_content") TSRMLS_CC);
}
/**
* Remove all the transactions from the manager
*
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, collectTransactions){
zval *transactions, *managed_transaction = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(transactions);
phalcon_read_property_this(&transactions, this_ptr, SL("_transactions"), PH_NOISY_CC);
if (phalcon_fast_count_ev(transactions TSRMLS_CC)) {
phalcon_is_iterable(transactions, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(managed_transaction);
phalcon_property_decr(this_ptr, SL("_number") TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
}
phalcon_update_property_null(this_ptr, SL("_transactions") TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}
/**
* Resets any template before layouts
*
*/
PHP_METHOD(Phalcon_View, cleanTemplateAfter){
PHALCON_MM_GROW();
phalcon_update_property_null(this_ptr, "_templatesAfter", strlen("_templatesAfter") TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Resets any template before layouts
*
*/
PHP_METHOD(Phalcon_Mvc_View, cleanTemplateBefore){
PHALCON_MM_GROW();
phalcon_update_property_null(this_ptr, SL("_templatesBefore") TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Starts rendering process enabling the output buffering
*/
PHP_METHOD(Phalcon_View, start){
PHALCON_MM_GROW();
phalcon_update_property_null(this_ptr, "_content", strlen("_content") TSRMLS_CC);
PHALCON_CALL_FUNC_NORETURN("ob_start", 0x014);
PHALCON_MM_RESTORE();
}
/**
* Closes the active connection returning success. Phalcon automatically closes and destroys
* active connections when the request ends
*
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, close){
zval *pdo;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(pdo);
phalcon_read_property_this(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC);
if (likely(Z_TYPE_P(pdo) == IS_OBJECT)) {
phalcon_update_property_null(this_ptr, SL("_pdo") TSRMLS_CC);
RETURN_MM_TRUE;
}
RETURN_MM_TRUE;
}
/**
* Closes active connection returning success. Phalcon automatically closes and destroys active connections within Phalcon\Db\Pool
*
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, close){
zval *t0 = NULL;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_pdo"), PH_NOISY_CC);
if (zend_is_true(t0)) {
phalcon_update_property_null(this_ptr, SL("_pdo") TSRMLS_CC);
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* Closes active connection returning success. Phalcon automatically closes and destroys active connections within Phalcon\Db\Pool
*
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, close){
zval *pdo = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(pdo);
phalcon_read_property(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC);
if (Z_TYPE_P(pdo) == IS_OBJECT) {
phalcon_update_property_null(this_ptr, SL("_pdo") TSRMLS_CC);
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* Closes active connection returning success. Phalcon automatically closes and destroys active connections within Phalcon_Db_Pool
*
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Mysql, close){
zval *id_connection = NULL, *success = NULL;
zval *t0 = NULL;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_idConnection"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(id_connection, t0);
if (zend_is_true(id_connection)) {
PHALCON_INIT_VAR(success);
PHALCON_CALL_FUNC_PARAMS_1(success, "mysqli_close", id_connection);
phalcon_update_property_null(this_ptr, SL("_idConnection") TSRMLS_CC);
RETURN_CHECK_CTOR(success);
} else {
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
PHALCON_MM_RESTORE();
}
/**
* Produce the routing parameters from the rewrite information
*
* @param string $uri
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, handle){
zval *uri = NULL, *real_uri = NULL, *processed, *annotations_service = NULL;
zval *handlers, *controller_suffix, *scope = NULL, *prefix = NULL;
zval *dependency_injector = NULL, *service = NULL, *handler = NULL;
zval *controller_name = NULL;
zval *namespace_name = NULL, *module_name = NULL, *suffixed = NULL;
zval *handler_annotations = NULL, *class_annotations = NULL;
zval *annotations = NULL, *annotation = NULL, *method_annotations = NULL;
zval *collection = NULL, *method = NULL;
HashTable *ah0, *ah1, *ah2, *ah3;
HashPosition hp0, hp1, hp2, hp3;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &uri);
if (!uri) {
uri = PHALCON_GLOBAL(z_null);
}
if (!zend_is_true(uri)) {
/**
* If 'uri' isn't passed as parameter it reads $_GET['_url']
*/
PHALCON_CALL_METHOD(&real_uri, this_ptr, "getrewriteuri");
} else {
PHALCON_CPY_WRT(real_uri, uri);
}
PHALCON_OBS_VAR(processed);
phalcon_read_property_this(&processed, this_ptr, SL("_processed"), PH_NOISY TSRMLS_CC);
if (!zend_is_true(processed)) {
PHALCON_INIT_VAR(annotations_service);
PHALCON_OBS_VAR(handlers);
phalcon_read_property_this(&handlers, this_ptr, SL("_handlers"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(handlers) == IS_ARRAY) {
PHALCON_OBS_VAR(controller_suffix);
phalcon_read_property_this(&controller_suffix, this_ptr, SL("_controllerSuffix"), PH_NOISY TSRMLS_CC);
phalcon_is_iterable(handlers, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(scope);
if (Z_TYPE_P(scope) == IS_ARRAY) {
/**
* A prefix (if any) must be in position 0
*/
PHALCON_OBS_NVAR(prefix);
phalcon_array_fetch_long(&prefix, scope, 0, PH_NOISY);
if (Z_TYPE_P(prefix) == IS_STRING) {
if (!phalcon_start_with(real_uri, prefix, NULL)) {
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
}
if (Z_TYPE_P(annotations_service) != IS_OBJECT) {
PHALCON_OBS_NVAR(dependency_injector);
phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_router_exception_ce, "A dependency injection container is required to access the 'annotations' service");
return;
}
PHALCON_INIT_NVAR(service);
ZVAL_STRING(service, "annotations", 1);
PHALCON_CALL_METHOD(&annotations_service, dependency_injector, "getshared", service);
PHALCON_VERIFY_INTERFACE(annotations_service, phalcon_annotations_adapterinterface_ce);
}
/**
* The controller must be in position 1
*/
PHALCON_OBS_NVAR(handler);
phalcon_array_fetch_long(&handler, scope, 1, PH_NOISY);
if (phalcon_memnstr_str(handler, SL("\\"))) {
/**
* Extract the real class name from the namespaced class
*/
PHALCON_INIT_NVAR(controller_name);
phalcon_get_class_ns(controller_name, handler, 0 TSRMLS_CC);
/**
* Extract the namespace from the namespaced class
*/
PHALCON_INIT_NVAR(namespace_name);
phalcon_get_ns_class(namespace_name, handler, 0 TSRMLS_CC);
} else {
PHALCON_CPY_WRT(controller_name, handler);
PHALCON_INIT_NVAR(namespace_name);
}
phalcon_update_property_null(this_ptr, SL("_routePrefix") TSRMLS_CC);
/**
* Check if the scope has a module associated
*/
if (phalcon_array_isset_long(scope, 2)) {
PHALCON_OBS_NVAR(module_name);
phalcon_array_fetch_long(&module_name, scope, 2, PH_NOISY);
} else {
PHALCON_INIT_NVAR(module_name);
}
PHALCON_INIT_NVAR(suffixed);
PHALCON_CONCAT_VV(suffixed, handler, controller_suffix);
/**
* Get the annotations from the class
*/
PHALCON_CALL_METHOD(&handler_annotations, annotations_service, "get", suffixed);
/**
* Process class annotations
*/
PHALCON_CALL_METHOD(&class_annotations, handler_annotations, "getclassannotations");
if (Z_TYPE_P(class_annotations) == IS_OBJECT) {
/**
* Process class annotations
*/
PHALCON_CALL_METHOD(&annotations, class_annotations, "getannotations");
if (Z_TYPE_P(annotations) == IS_ARRAY) {
phalcon_is_iterable(annotations, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HVALUE(annotation);
PHALCON_CALL_METHOD(NULL, this_ptr, "processcontrollerannotation", controller_name, annotation);
zend_hash_move_forward_ex(ah1, &hp1);
}
}
}
/**
* Process method annotations
*/
PHALCON_CALL_METHOD(&method_annotations, handler_annotations, "getmethodsannotations");
if (Z_TYPE_P(method_annotations) == IS_ARRAY) {
phalcon_is_iterable(method_annotations, &ah2, &hp2, 0, 0);
while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) {
PHALCON_GET_HKEY(method, ah2, hp2);
PHALCON_GET_HVALUE(collection);
if (Z_TYPE_P(collection) == IS_OBJECT) {
PHALCON_CALL_METHOD(&annotations, collection, "getannotations");
phalcon_is_iterable(annotations, &ah3, &hp3, 0, 0);
while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) {
PHALCON_GET_HVALUE(annotation);
PHALCON_CALL_METHOD(NULL, this_ptr, "processactionannotation", module_name, namespace_name, controller_name, method, annotation);
zend_hash_move_forward_ex(ah3, &hp3);
}
}
zend_hash_move_forward_ex(ah2, &hp2);
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
}
phalcon_update_property_bool(this_ptr, SL("_processed"), 1 TSRMLS_CC);
}
/**
* Call the parent handle method()
*/
PHALCON_CALL_PARENT(NULL, phalcon_mvc_router_annotations_ce, this_ptr, "handle", real_uri);
PHALCON_MM_RESTORE();
}
/**
* Handles routing information received from the rewrite engine
*
* @param string $uri
*/
PHP_METHOD(Phalcon_Mvc_Router, handle){
zval *uri = NULL, *real_uri = NULL, *route_found = NULL, *parts = NULL, *params = NULL;
zval *matches = NULL, *route = NULL, *position = NULL, *part = NULL, *str_params = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL;
zval *c0 = NULL, *c1 = NULL;
zval *a0 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &uri) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!uri) {
PHALCON_ALLOC_ZVAL_MM(uri);
ZVAL_NULL(uri);
}
if (!zend_is_true(uri)) {
PHALCON_INIT_VAR(real_uri);
PHALCON_CALL_METHOD(real_uri, this_ptr, "_getrewriteuri", PH_NO_CHECK);
} else {
PHALCON_CPY_WRT(real_uri, uri);
}
PHALCON_INIT_VAR(route_found);
ZVAL_BOOL(route_found, 0);
PHALCON_INIT_VAR(parts);
array_init(parts);
PHALCON_INIT_VAR(params);
array_init(params);
PHALCON_INIT_VAR(matches);
array_init(matches);
phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_routes"), PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_FUNC_PARAMS_1(r0, "array_reverse", t0);
if (!phalcon_valid_foreach(r0 TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(r0);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_c9ff_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_c9ff_1;
}
PHALCON_INIT_VAR(route);
ZVAL_ZVAL(route, *hd, 1, 0);
PHALCON_INIT_VAR(parts);
phalcon_array_fetch_string(&parts, route, SL("paths"), PH_NOISY_CC);
PHALCON_INIT_VAR(r1);
phalcon_array_fetch_string(&r1, route, SL("pattern"), PH_NOISY_CC);
Z_SET_ISREF_P(matches);
PHALCON_INIT_VAR(r2);
PHALCON_CALL_FUNC_PARAMS_3(r2, "preg_match", r1, real_uri, matches);
Z_UNSET_ISREF_P(matches);
if (zend_is_true(r2)) {
PHALCON_INIT_VAR(r3);
phalcon_array_fetch_string(&r3, route, SL("paths"), PH_NOISY_CC);
if (!phalcon_valid_foreach(r3 TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(r3);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_c9ff_2:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_c9ff_2;
}
PHALCON_INIT_VAR(part);
PHALCON_GET_FOREACH_KEY(part, ah1, hp1);
PHALCON_INIT_VAR(position);
ZVAL_ZVAL(position, *hd, 1, 0);
eval_int = phalcon_array_isset(matches, position);
if (eval_int) {
PHALCON_INIT_VAR(r4);
phalcon_array_fetch(&r4, matches, position, PH_NOISY_CC);
phalcon_array_update_zval(&parts, part, &r4, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_c9ff_2;
fee_c9ff_2:
if(0){}
phalcon_update_property_zval(this_ptr, SL("_matches"), matches TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_currentRoute"), route TSRMLS_CC);
PHALCON_INIT_VAR(route_found);
ZVAL_BOOL(route_found, 1);
goto fee_c9ff_1;
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_c9ff_1;
fee_c9ff_1:
if(0){}
if (zend_is_true(route_found)) {
eval_int = phalcon_array_isset_string(parts, SL("module")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r5);
phalcon_array_fetch_string(&r5, parts, SL("module"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_module"), r5 TSRMLS_CC);
PHALCON_SEPARATE(parts);
phalcon_array_unset_string(parts, SL("module")+1);
} else {
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, SL("_defaultModule"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_module"), t1 TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(parts, SL("controller")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r6);
phalcon_array_fetch_string(&r6, parts, SL("controller"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_controller"), r6 TSRMLS_CC);
PHALCON_SEPARATE(parts);
phalcon_array_unset_string(parts, SL("controller")+1);
} else {
phalcon_update_property_null(this_ptr, SL("_controller") TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(parts, SL("action")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r7);
phalcon_array_fetch_string(&r7, parts, SL("action"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_action"), r7 TSRMLS_CC);
PHALCON_SEPARATE(parts);
phalcon_array_unset_string(parts, SL("action")+1);
} else {
phalcon_update_property_null(this_ptr, SL("_action") TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(parts, SL("params")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r8);
phalcon_array_fetch_string(&r8, parts, SL("params"), PH_NOISY_CC);
PHALCON_INIT_VAR(c0);
ZVAL_LONG(c0, 1);
PHALCON_INIT_VAR(str_params);
PHALCON_CALL_FUNC_PARAMS_2(str_params, "substr", r8, c0);
if (zend_is_true(str_params)) {
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "/", 1);
PHALCON_INIT_VAR(params);
phalcon_fast_explode(params, c1, str_params TSRMLS_CC);
}
PHALCON_SEPARATE(parts);
phalcon_array_unset_string(parts, SL("params")+1);
}
PHALCON_ALLOC_ZVAL_MM(r9);
PHALCON_CALL_FUNC_PARAMS_2(r9, "array_merge", params, parts);
phalcon_update_property_zval(this_ptr, SL("_params"), r9 TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 1 TSRMLS_CC);
} else {
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, SL("_defaultModule"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_module"), t2 TSRMLS_CC);
phalcon_update_property_null(this_ptr, SL("_controller") TSRMLS_CC);
phalcon_update_property_null(this_ptr, SL("_action") TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(a0);
array_init(a0);
phalcon_update_property_zval(this_ptr, SL("_params"), a0 TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 0 TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}
/**
* Resets any template before layouts
*
*/
PHP_METHOD(Phalcon_Mvc_View, cleanTemplateAfter){
phalcon_update_property_null(this_ptr, SL("_templatesAfter") TSRMLS_CC);
}
/**
* Produce the routing parameters from the rewrite information
*
* @param string $uri
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, handle){
zval *uri = NULL, *real_uri = NULL, *processed, *annotations_service = NULL;
zval *handlers, *controller_sufix, *scope = NULL, *prefix = NULL;
zval *dependency_injector = NULL, *service = NULL, *handler = NULL;
zval *sufixed = NULL, *handler_annotations = NULL, *class_annotations = NULL;
zval *annotations = NULL, *annotation = NULL, *method_annotations = NULL;
zval *lowercased = NULL, *collection = NULL, *method = NULL;
HashTable *ah0, *ah1, *ah2, *ah3;
HashPosition hp0, hp1, hp2, hp3;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &uri) == FAILURE) {
RETURN_MM_NULL();
}
if (!uri) {
PHALCON_INIT_VAR(uri);
}
if (!zend_is_true(uri)) {
/**
* If 'uri' isn't passed as parameter it reads $_GET['_url']
*/
PHALCON_INIT_VAR(real_uri);
PHALCON_CALL_METHOD(real_uri, this_ptr, "_getrewriteuri");
} else {
PHALCON_CPY_WRT(real_uri, uri);
}
PHALCON_OBS_VAR(processed);
phalcon_read_property(&processed, this_ptr, SL("_processed"), PH_NOISY_CC);
if (!zend_is_true(processed)) {
PHALCON_INIT_VAR(annotations_service);
PHALCON_OBS_VAR(handlers);
phalcon_read_property(&handlers, this_ptr, SL("_handlers"), PH_NOISY_CC);
PHALCON_OBS_VAR(controller_sufix);
phalcon_read_property(&controller_sufix, this_ptr, SL("_controllerSufix"), PH_NOISY_CC);
if (!phalcon_is_iterable(handlers, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(scope);
if (Z_TYPE_P(scope) == IS_ARRAY) {
/**
* A prefix (if any) must be in position 0
*/
PHALCON_OBS_NVAR(prefix);
phalcon_array_fetch_long(&prefix, scope, 0, PH_NOISY_CC);
if (Z_TYPE_P(prefix) == IS_STRING) {
if (!phalcon_start_with(real_uri, prefix, NULL)) {
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
}
if (Z_TYPE_P(annotations_service) != IS_OBJECT) {
PHALCON_OBS_NVAR(dependency_injector);
phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_router_exception_ce, "A dependency injection container is required to access the 'annotations' service");
return;
}
PHALCON_INIT_NVAR(service);
ZVAL_STRING(service, "annotations", 1);
PHALCON_INIT_NVAR(annotations_service);
PHALCON_CALL_METHOD_PARAMS_1(annotations_service, dependency_injector, "getshared", service);
}
/**
* The controller must be in position 1
*/
PHALCON_OBS_NVAR(handler);
phalcon_array_fetch_long(&handler, scope, 1, PH_NOISY_CC);
phalcon_update_property_null(this_ptr, SL("_routePrefix") TSRMLS_CC);
PHALCON_INIT_NVAR(sufixed);
PHALCON_CONCAT_VV(sufixed, handler, controller_sufix);
PHALCON_INIT_NVAR(handler_annotations);
PHALCON_CALL_METHOD_PARAMS_1(handler_annotations, annotations_service, "get", sufixed);
/**
* Process class annotations
*/
PHALCON_INIT_NVAR(class_annotations);
PHALCON_CALL_METHOD(class_annotations, handler_annotations, "getclassannotations");
if (Z_TYPE_P(class_annotations) == IS_OBJECT) {
PHALCON_INIT_NVAR(annotations);
PHALCON_CALL_METHOD(annotations, class_annotations, "getannotations");
if (Z_TYPE_P(annotations) == IS_ARRAY) {
if (!phalcon_is_iterable(annotations, &ah1, &hp1, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(annotation);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "processcontrollerannotation", handler, annotation);
zend_hash_move_forward_ex(ah1, &hp1);
}
}
}
/**
* Process method annotations
*/
PHALCON_INIT_NVAR(method_annotations);
PHALCON_CALL_METHOD(method_annotations, handler_annotations, "getmethodsannotations");
if (Z_TYPE_P(method_annotations) == IS_ARRAY) {
PHALCON_INIT_NVAR(lowercased);
phalcon_fast_strtolower(lowercased, handler);
if (!phalcon_is_iterable(method_annotations, &ah2, &hp2, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(method, ah2, hp2);
PHALCON_GET_FOREACH_VALUE(collection);
if (Z_TYPE_P(collection) == IS_OBJECT) {
PHALCON_INIT_NVAR(annotations);
PHALCON_CALL_METHOD(annotations, collection, "getannotations");
if (!phalcon_is_iterable(annotations, &ah3, &hp3, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(annotation);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "processactionannotation", lowercased, method, annotation);
zend_hash_move_forward_ex(ah3, &hp3);
}
}
zend_hash_move_forward_ex(ah2, &hp2);
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
phalcon_update_property_bool(this_ptr, SL("_processed"), 1 TSRMLS_CC);
}
/**
* Call the parent handle method()
*/
PHALCON_CALL_PARENT_PARAMS_1_NORETURN(this_ptr, "Phalcon\\Mvc\\Router\\Annotations", "handle", real_uri);
PHALCON_MM_RESTORE();
}
/**
* Handles routing information received from the rewrite engine
*
* @param string $uri
*/
PHP_METHOD(Phalcon_Router_Rewrite, handle) {
zval *uri = NULL, *parts = NULL, *params = NULL, *number_parts = NULL, *i = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL;
zval *c0 = NULL;
zval *t0 = NULL, *t1 = NULL;
zval *a0 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &uri) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!uri) {
PHALCON_INIT_VAR(uri);
ZVAL_NULL(uri);
} else {
PHALCON_SEPARATE_PARAM(uri);
}
if (!zend_is_true(uri)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, this_ptr, "_getrewriteuri", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(uri, r0);
}
if (zend_is_true(uri)) {
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "/", 1);
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_fast_explode(r1, c0, uri TSRMLS_CC);
PHALCON_CPY_WRT(parts, r1);
eval_int = phalcon_array_isset_long(parts, 0);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_long(&r2, parts, 0, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_filter_alphanum(r3, r2);
phalcon_update_property_zval(this_ptr, "_controller", strlen("_controller"), r3 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_controller", sizeof("_controller")-1, PHALCON_NOISY TSRMLS_CC);
if (!zend_is_true(t0)) {
phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC);
}
} else {
phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC);
}
eval_int = phalcon_array_isset_long(parts, 1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_array_fetch_long(&r4, parts, 1, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r5);
phalcon_filter_alphanum(r5, r4);
phalcon_update_property_zval(this_ptr, "_action", strlen("_action"), r5 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_action", sizeof("_action")-1, PHALCON_NOISY TSRMLS_CC);
if (!zend_is_true(t1)) {
phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC);
}
} else {
phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC);
}
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(params, a0);
PHALCON_ALLOC_ZVAL_MM(r6);
phalcon_fast_count(r6, parts TSRMLS_CC);
PHALCON_CPY_WRT(number_parts, r6);
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 2);
fs_ef57_0:
PHALCON_INIT_VAR(r7);
is_smaller_function(r7, i, number_parts TSRMLS_CC);
if (!zend_is_true(r7)) {
goto fe_ef57_0;
}
PHALCON_INIT_VAR(r8);
phalcon_array_fetch(&r8, parts, i, PHALCON_NOISY TSRMLS_CC);
phalcon_array_append(¶ms, r8, PHALCON_SEPARATE_PLZ TSRMLS_CC);
PHALCON_SEPARATE(i);
increment_function(i);
goto fs_ef57_0;
fe_ef57_0:
phalcon_update_property_zval(this_ptr, "_params", strlen("_params"), params TSRMLS_CC);
} else {
phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC);
phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}
/**
* Clears are variables added previously
*
* @return Phalcon\Debug
*/
PHP_METHOD(Phalcon_Debug, clearVars) {
phalcon_update_property_null(getThis(), SL("_data"));
RETURN_THISW();
}
/**
* Clears are variables added previously
*
* @return Phalcon\Debug
*/
PHP_METHOD(Phalcon_Debug, clearVars){
phalcon_update_property_null(this_ptr, SL("_data") TSRMLS_CC);
RETURN_THISW();
}
/**
* Validate a set of data according to a set of rules
*
* @param array|object $data
* @param object $entity
* @return Phalcon\Validation\Message\Group
*/
PHP_METHOD(Phalcon_Validation, validate){
zval *data = NULL, *entity = NULL, *validators, *messages = NULL, *status = NULL;
zval *cancel_on_fail, *scope = NULL, *attribute = NULL, *validator = NULL;
zval *must_cancel = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 2, &data, &entity);
if (!data) {
PHALCON_INIT_VAR(data);
}
if (!entity) {
PHALCON_INIT_VAR(entity);
}
PHALCON_OBS_VAR(validators);
phalcon_read_property_this(&validators, this_ptr, SL("_validators"), PH_NOISY_CC);
if (Z_TYPE_P(validators) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "There are no validators to validate");
return;
}
/**
* Clear pre-calculated values
*/
phalcon_update_property_null(this_ptr, SL("_values") TSRMLS_CC);
/**
* Implicitly creates a Phalcon\Validation\Message\Group object
*/
PHALCON_INIT_VAR(messages);
object_init_ex(messages, phalcon_validation_message_group_ce);
phalcon_call_method_noret(messages, "__construct");
/**
* Validation classes can implement the 'beforeValidation' callback
*/
if (phalcon_method_exists_ex(this_ptr, SS("beforevalidation") TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(status);
phalcon_call_method_p3(status, this_ptr, "beforevalidation", data, entity, messages);
if (PHALCON_IS_FALSE(status)) {
RETURN_CCTOR(status);
}
}
phalcon_update_property_this(this_ptr, SL("_messages"), messages TSRMLS_CC);
if (Z_TYPE_P(data) == IS_ARRAY) {
phalcon_update_property_this(this_ptr, SL("_data"), data TSRMLS_CC);
} else {
if (Z_TYPE_P(data) == IS_OBJECT) {
phalcon_update_property_this(this_ptr, SL("_data"), data TSRMLS_CC);
}
}
PHALCON_INIT_VAR(cancel_on_fail);
ZVAL_STRING(cancel_on_fail, "cancelOnFail", 1);
phalcon_is_iterable(validators, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(scope);
if (Z_TYPE_P(scope) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "The validator scope is not valid");
return;
}
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, scope, 0, PH_NOISY_CC);
PHALCON_OBS_NVAR(validator);
phalcon_array_fetch_long(&validator, scope, 1, PH_NOISY_CC);
if (Z_TYPE_P(validator) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "One of the validators is not valid");
return;
}
PHALCON_INIT_NVAR(status);
phalcon_call_method_p2(status, validator, "validate", this_ptr, attribute);
/**
* Check if the validation must be canceled if this validator fails
*/
if (PHALCON_IS_FALSE(status)) {
PHALCON_INIT_NVAR(must_cancel);
phalcon_call_method_p1(must_cancel, validator, "getoption", cancel_on_fail);
if (zend_is_true(must_cancel)) {
break;
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
/**
* Get the messages generated by the validators
*/
PHALCON_OBS_NVAR(messages);
phalcon_read_property_this(&messages, this_ptr, SL("_messages"), PH_NOISY_CC);
if (phalcon_method_exists_ex(this_ptr, SS("aftervalidation") TSRMLS_CC) == SUCCESS) {
phalcon_call_method_p3_noret(this_ptr, "aftervalidation", data, entity, messages);
}
RETURN_CCTOR(messages);
}
/**
* Fires an event in the events manager causing that active listeners be notified about it
*
*<code>
* $eventsManager->fire('db', $connection);
*</code>
*
* @param string $eventType
* @param object $source
* @param mixed $data
* @param int $cancelable
* @return mixed
*/
PHP_METHOD(Phalcon_Events_Manager, fire){
zval *event_type, *source, *data = NULL, *cancelable = NULL, *events;
zval *exception_message, *event_parts, *type;
zval *event_name, *status = NULL, *collect, *event = NULL, *fire_events = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 2, &event_type, &source, &data, &cancelable);
if (!data) {
PHALCON_INIT_VAR(data);
}
if (!cancelable) {
PHALCON_INIT_VAR(cancelable);
ZVAL_BOOL(cancelable, 1);
}
if (unlikely(Z_TYPE_P(event_type) != IS_STRING)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "Event type must be a string");
return;
}
PHALCON_OBS_VAR(events);
phalcon_read_property_this(&events, this_ptr, SL("_events"), PH_NOISY_CC);
if (Z_TYPE_P(events) != IS_ARRAY) {
RETURN_MM_NULL();
}
/**
* All valid events must have a colon separator
*/
if (!phalcon_memnstr_str(event_type, SL(":"))) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SV(exception_message, "Invalid event type ", event_type);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_events_exception_ce, exception_message);
return;
}
PHALCON_INIT_VAR(event_parts);
phalcon_fast_explode_str(event_parts, SL(":"), event_type);
PHALCON_OBS_VAR(type);
phalcon_array_fetch_long(&type, event_parts, 0, PH_NOISY);
PHALCON_OBS_VAR(event_name);
phalcon_array_fetch_long(&event_name, event_parts, 1, PH_NOISY);
PHALCON_INIT_VAR(status);
/**
* Responses must be traced?
*/
PHALCON_OBS_VAR(collect);
phalcon_read_property_this(&collect, this_ptr, SL("_collect"), PH_NOISY_CC);
if (zend_is_true(collect)) {
phalcon_update_property_null(this_ptr, SL("_responses") TSRMLS_CC);
}
PHALCON_INIT_VAR(event);
/**
* Check if events are grouped by type
*/
if (phalcon_array_isset(events, type)) {
PHALCON_OBS_VAR(fire_events);
phalcon_array_fetch(&fire_events, events, type, PH_NOISY);
if (Z_TYPE_P(fire_events) == IS_ARRAY || Z_TYPE_P(fire_events) == IS_OBJECT) {
/**
* Create the event context
*/
object_init_ex(event, phalcon_events_event_ce);
phalcon_call_method_p4_noret(event, "__construct", event_name, source, data, cancelable);
/**
* Call the events queue
*/
phalcon_call_method_p2(status, this_ptr, "firequeue", fire_events, event);
}
}
/**
* Check if there are listeners for the event type itself
*/
if (phalcon_array_isset(events, event_type)) {
PHALCON_OBS_NVAR(fire_events);
phalcon_array_fetch(&fire_events, events, event_type, PH_NOISY);
if (Z_TYPE_P(fire_events) == IS_ARRAY || Z_TYPE_P(fire_events) == IS_OBJECT) {
/**
* Create the event if it wasn't created before
*/
if (Z_TYPE_P(event) == IS_NULL) {
PHALCON_INIT_NVAR(event);
object_init_ex(event, phalcon_events_event_ce);
phalcon_call_method_p4_noret(event, "__construct", event_name, source, data, cancelable);
}
/**
* Call the events queue
*/
PHALCON_INIT_NVAR(status);
phalcon_call_method_p2(status, this_ptr, "firequeue", fire_events, event);
}
}
RETURN_CCTOR(status);
}