/**
* Check if a string starts with a given string
*
*<code>
* echo Phalcon\Text::startsWith("Hello", "He"); // true
* echo Phalcon\Text::startsWith("Hello", "he"); // false
* echo Phalcon\Text::startsWith("Hello", "he", false); // true
*</code>
*
* @param string $str
* @param string $start
* @param boolean $ignoreCase
* @return boolean
*/
PHP_METHOD(Phalcon_Text, startsWith){
zval *str, *start, *ignore_case = NULL;
zval *case_sensitive;
phalcon_fetch_params(0, 2, 1, &str, &start, &ignore_case);
if (!ignore_case) {
case_sensitive = PHALCON_GLOBAL(z_false);
}
else {
case_sensitive = zend_is_true(ignore_case) ? PHALCON_GLOBAL(z_false) : PHALCON_GLOBAL(z_true);
}
RETURN_BOOL(phalcon_start_with(str, start, case_sensitive));
}
/**
* Check if a string starts with a given string
*
*<code>
* echo Phalcon\Text::startsWith("Hello", "He"); // true
* echo Phalcon\Text::startsWith("Hello", "he"); // false
* echo Phalcon\Text::startsWith("Hello", "he", false); // true
*</code>
*
* @param string $str
* @param string $start
* @param boolean $ignoreCase
* @return boolean
*/
PHP_METHOD(Phalcon_Text, startsWith) {
zval *str, *start, *ignore_case = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 1, &str, &start, &ignore_case);
if (!ignore_case) {
PHALCON_INIT_VAR(ignore_case);
ZVAL_BOOL(ignore_case, 1);
}
if (phalcon_start_with(str, start, ignore_case)) {
RETURN_MM_TRUE;
}
RETURN_MM_FALSE;
}
/**
* 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();
}
/**
* 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();
}
/**
* Makes the work of autoload registered classes
*
* @param string $className
* @return boolean
*/
PHP_METHOD(Phalcon_Loader, autoLoad){
zval *class_name, *events_manager, *event_name = NULL;
zval *classes, *file_path = NULL, *extensions, *ds, *namespace_separator;
zval *empty_str, *zero, *namespaces, *directory = NULL;
zval *prefix = NULL, *prefix_namespace = NULL, *file_name = NULL;
zval *fixed_directory = NULL, *extension = NULL, *complete_path = NULL;
zval *pseudo_separator, *prefixes, *no_prefix_class = NULL;
zval *ds_class_name, *ns_class_name, *directories;
HashTable *ah0, *ah1, *ah2, *ah3, *ah4, *ah5;
HashPosition hp0, hp1, hp2, hp3, hp4, hp5;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &class_name) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_OBS_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, "loader:beforeCheckClass", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, class_name);
}
/**
* First we check for static paths for classes
*/
PHALCON_OBS_VAR(classes);
phalcon_read_property(&classes, this_ptr, SL("_classes"), PH_NOISY_CC);
if (Z_TYPE_P(classes) == IS_ARRAY) {
if (phalcon_array_isset(classes, class_name)) {
PHALCON_OBS_VAR(file_path);
phalcon_array_fetch(&file_path, classes, class_name, PH_NOISY_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:pathFound", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path);
}
if (phalcon_require(file_path TSRMLS_CC) == FAILURE) {
return;
}
RETURN_MM_TRUE;
}
}
PHALCON_OBS_VAR(extensions);
phalcon_read_property(&extensions, this_ptr, SL("_extensions"), PH_NOISY_CC);
PHALCON_INIT_VAR(ds);
zend_get_constant(SL("DIRECTORY_SEPARATOR"), ds TSRMLS_CC);
PHALCON_INIT_VAR(namespace_separator);
ZVAL_STRING(namespace_separator, "\\", 1);
PHALCON_INIT_VAR(empty_str);
ZVAL_STRING(empty_str, "", 1);
PHALCON_INIT_VAR(zero);
ZVAL_LONG(zero, 0);
/**
* Checking in namespaces
*/
PHALCON_OBS_VAR(namespaces);
phalcon_read_property(&namespaces, this_ptr, SL("_namespaces"), PH_NOISY_CC);
if (Z_TYPE_P(namespaces) == IS_ARRAY) {
if (!phalcon_is_iterable(namespaces, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(prefix, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(directory);
/**
* The class name must start with the current namespace
*/
if (phalcon_start_with(class_name, prefix, NULL)) {
/**
* Append the namespace separator to the prefix
*/
PHALCON_INIT_NVAR(prefix_namespace);
PHALCON_CONCAT_VV(prefix_namespace, prefix, namespace_separator);
PHALCON_INIT_NVAR(file_name);
phalcon_fast_str_replace(file_name, prefix_namespace, empty_str, class_name TSRMLS_CC);
if (zend_is_true(file_name)) {
/**
* Add a trailing directory separator if the user forgot to do that
*/
PHALCON_INIT_NVAR(fixed_directory);
phalcon_fix_path(&fixed_directory, directory, ds TSRMLS_CC);
if (!phalcon_is_iterable(extensions, &ah1, &hp1, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(extension);
PHALCON_INIT_NVAR(complete_path);
PHALCON_CONCAT_VVSV(complete_path, fixed_directory, file_name, ".", extension);
PHALCON_INIT_NVAR(file_path);
phalcon_fast_str_replace(file_path, namespace_separator, ds, complete_path TSRMLS_CC);
/**
* Check if a events manager is available
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_checkedPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:beforeCheckPath", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", event_name, this_ptr);
}
/**
* This is probably a good path, let's check if the file exist
*/
if (phalcon_file_exists(file_path TSRMLS_CC) == SUCCESS) {
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:pathFound", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path);
}
/**
* Simulate a require
*/
if (phalcon_require(file_path TSRMLS_CC) == FAILURE) {
return;
}
/**
* Return true mean success
*/
RETURN_MM_TRUE;
}
zend_hash_move_forward_ex(ah1, &hp1);
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
}
PHALCON_INIT_VAR(pseudo_separator);
ZVAL_STRING(pseudo_separator, "_", 1);
/**
* Checking in prefixes
*/
PHALCON_OBS_VAR(prefixes);
phalcon_read_property(&prefixes, this_ptr, SL("_prefixes"), PH_NOISY_CC);
if (Z_TYPE_P(prefixes) == IS_ARRAY) {
if (!phalcon_is_iterable(prefixes, &ah2, &hp2, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(prefix, ah2, hp2);
PHALCON_GET_FOREACH_VALUE(directory);
/**
* The class name starts with the prefix?
*/
if (phalcon_start_with(class_name, prefix, NULL)) {
/**
* Remove the prefix from the class
*/
PHALCON_INIT_NVAR(no_prefix_class);
phalcon_fast_str_replace(no_prefix_class, prefix, empty_str, class_name TSRMLS_CC);
/**
* Change the pseudo-separator '_' by the directory separator
*/
PHALCON_INIT_NVAR(file_name);
phalcon_fast_str_replace(file_name, pseudo_separator, ds, no_prefix_class TSRMLS_CC);
if (zend_is_true(file_name)) {
/**
* Add a trailing directory separator if the user forgot to do that
*/
PHALCON_INIT_NVAR(fixed_directory);
phalcon_fix_path(&fixed_directory, directory, ds TSRMLS_CC);
if (!phalcon_is_iterable(extensions, &ah3, &hp3, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(extension);
PHALCON_INIT_NVAR(complete_path);
PHALCON_CONCAT_VVSV(complete_path, fixed_directory, file_name, ".", extension);
PHALCON_INIT_NVAR(file_path);
phalcon_fast_str_replace(file_path, namespace_separator, ds, complete_path TSRMLS_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_checkedPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:beforeCheckPath", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path);
}
if (phalcon_file_exists(file_path TSRMLS_CC) == SUCCESS) {
/**
* Call 'pathFound' event
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:pathFound", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path);
}
if (phalcon_require(file_path TSRMLS_CC) == FAILURE) {
return;
}
RETURN_MM_TRUE;
}
zend_hash_move_forward_ex(ah3, &hp3);
}
}
}
zend_hash_move_forward_ex(ah2, &hp2);
}
}
/**
* Change the pseudo-separator by the directory separator in the class name
*/
PHALCON_INIT_VAR(ds_class_name);
phalcon_fast_str_replace(ds_class_name, pseudo_separator, ds, class_name TSRMLS_CC);
/**
* And change the namespace separator by directory separator too
*/
PHALCON_INIT_VAR(ns_class_name);
phalcon_fast_str_replace(ns_class_name, namespace_separator, ds, ds_class_name TSRMLS_CC);
/**
* Checking in directories
*/
PHALCON_OBS_VAR(directories);
phalcon_read_property(&directories, this_ptr, SL("_directories"), PH_NOISY_CC);
if (Z_TYPE_P(directories) == IS_ARRAY) {
if (!phalcon_is_iterable(directories, &ah4, &hp4, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(directory);
/**
* Add a trailing directory separator if the user forgot to do that
*/
PHALCON_INIT_NVAR(fixed_directory);
phalcon_fix_path(&fixed_directory, directory, ds TSRMLS_CC);
if (!phalcon_is_iterable(extensions, &ah5, &hp5, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah5, (void**) &hd, &hp5) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(extension);
/**
* Create a possible path for the file
*/
PHALCON_INIT_NVAR(file_path);
PHALCON_CONCAT_VVSV(file_path, fixed_directory, ns_class_name, ".", extension);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_checkedPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:beforeCheckPath", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path);
}
/**
* Check in every directory if the class exists here
*/
if (phalcon_file_exists(file_path TSRMLS_CC) == SUCCESS) {
/**
* Call 'pathFound' event
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:pathFound", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path);
}
/**
* Simulate a require
*/
if (phalcon_require(file_path TSRMLS_CC) == FAILURE) {
return;
}
/**
* Return true meaning success
*/
RETURN_MM_TRUE;
}
zend_hash_move_forward_ex(ah5, &hp5);
}
zend_hash_move_forward_ex(ah4, &hp4);
}
}
/**
* Call 'afterCheckClass' event
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:afterCheckClass", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, class_name);
}
/**
* Cannot find the class return false
*/
RETURN_MM_FALSE;
}
