/**
* Reads parsed annotations from XCache
*
* @param string $key
* @return Phalcon\Annotations\Reflection
*/
PHP_METHOD(Phalcon_Annotations_Adapter_Xcache, read){
zval *key, *prefixed_key, *prefixed_lower, *serialized;
zval *data;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &key);
PHALCON_INIT_VAR(prefixed_key);
PHALCON_CONCAT_SV(prefixed_key, "_PHAN", key);
PHALCON_INIT_VAR(prefixed_lower);
phalcon_fast_strtolower(prefixed_lower, prefixed_key);
PHALCON_INIT_VAR(serialized);
phalcon_call_func_p1(serialized, "xcache_get", prefixed_lower);
if (Z_TYPE_P(serialized) == IS_STRING) {
PHALCON_INIT_VAR(data);
phalcon_unserialize(data, serialized TSRMLS_CC);
if (Z_TYPE_P(data) == IS_OBJECT) {
RETURN_CTOR(data);
}
}
RETURN_MM_NULL();
}
/**
* Checks for annotations in the controller docblock
*
* @param string $handler
* @param Phalcon\Annotations\AdapterInterface
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, processControllerAnnotation){
zval *handler, *annotation, *lowercased, *name;
zval *position, *value;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &handler, &annotation) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(lowercased);
phalcon_fast_strtolower(lowercased, handler);
PHALCON_INIT_VAR(name);
PHALCON_CALL_METHOD(name, annotation, "getname");
/**
* @RoutePrefix add a prefix for all the routes defined in the model
*/
if (PHALCON_IS_STRING(name, "RoutePrefix")) {
PHALCON_INIT_VAR(position);
ZVAL_LONG(position, 0);
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, annotation, "getargument", position);
phalcon_update_property_zval(this_ptr, SL("_routePrefix"), value TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}
/**
* Execute a render.
*
* @param string $type
* @param int $quality
* @return string
*/
PHP_METHOD(Phalcon_Image_Adapter_GD, _render) {
zval *extension, *quality = NULL, *interlacing = NULL, ret = {}, type = {}, mime = {}, image = {}, tmp = {};
const char *func_name = "imagegif";
char *ext;
phalcon_fetch_params(0, 1, 2, &extension, &quality, &interlacing);
phalcon_fast_strtolower(&ret, extension);
ext = Z_STRVAL(ret);
if (strcmp(ext, "gif") == 0) {
ZVAL_LONG(&type, 1);
func_name = "imagegif";
} else if (strcmp(ext, "jpg") == 0 || strcmp(ext, "jpeg") == 0) {
ZVAL_LONG(&type, 2);
func_name = "imagejpeg";
} else if (strcmp(ext, "png") == 0) {
ZVAL_LONG(&type, 3);
func_name = "imagepng";
} else {
zend_throw_exception_ex(phalcon_image_exception_ce, 0, "Installed GD does not support '%s' images", Z_STRVAL_P(extension));
return;
}
phalcon_return_property(&image, getThis(), SL("_image"));
if (interlacing && Z_TYPE_P(interlacing) >= IS_NULL && Z_LVAL(type) > 1) {
if (zend_is_true(interlacing)) {
PHALCON_CALL_FUNCTIONW(NULL, "imageinterlace", &image, &PHALCON_GLOBAL(z_one));
} else {
PHALCON_CALL_FUNCTIONW(NULL, "imageinterlace", &image, &PHALCON_GLOBAL(z_zero));
}
}
phalcon_ob_start();
if (Z_LVAL(type) == 1 || !quality || Z_TYPE_P(quality) == IS_NULL) {
PHALCON_CALL_FUNCTIONW(&ret, func_name, &image);
} else {
if (Z_LVAL(type) == 3) {
ZVAL_LONG(&tmp, ceil(Z_LVAL_P(quality)/100*9));
PHALCON_CALL_FUNCTIONW(&ret, func_name, &image, &PHALCON_GLOBAL(z_null), &tmp);
} else {
PHALCON_CALL_FUNCTIONW(&ret, func_name, &image, &PHALCON_GLOBAL(z_null), quality);
}
}
phalcon_ob_get_contents(return_value);
phalcon_ob_end_clean();
if (zend_is_true(&ret)) {
phalcon_update_property_zval(getThis(), SL("_type"), &type);
PHALCON_CALL_FUNCTIONW(&mime, "image_type_to_mime_type", &type);
phalcon_update_property_zval(getThis(), SL("_mime"), &mime);
}
return;
}
/**
* Converts texts into URL-friendly titles
*
*<code>
* echo Phalcon\Tag::friendlyTitle('Thiese are big important news', '-')
*</code>
*
* @param string $text
* @param string $separator
* @param boolean $lowercase
* @return text
*/
PHP_METHOD(Phalcon_Tag, friendlyTitle){
zval *text, *separator = NULL, *lowercase = NULL, *pattern, *friendly;
zval *friendly_text = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 2, &text, &separator, &lowercase);
if (!separator) {
PHALCON_INIT_VAR(separator);
ZVAL_STRING(separator, "-", 1);
}
if (!lowercase) {
PHALCON_INIT_VAR(lowercase);
ZVAL_BOOL(lowercase, 1);
}
PHALCON_INIT_VAR(pattern);
ZVAL_STRING(pattern, "~[^a-z0-9A-Z]+~", 1);
PHALCON_INIT_VAR(friendly);
PHALCON_CALL_FUNC_PARAMS_3(friendly, "preg_replace", pattern, separator, text);
if (zend_is_true(lowercase)) {
PHALCON_INIT_VAR(friendly_text);
phalcon_fast_strtolower(friendly_text, friendly);
} else {
PHALCON_CPY_WRT(friendly_text, friendly);
}
RETURN_CTOR(friendly_text);
}
/**
* Writes parsed annotations to memory
*
* @param string $key
* @param Phalcon\Annotations\Reflection $data
*/
PHP_METHOD(Phalcon_Annotations_Adapter_Memory, write){
zval *key, *data, *lowercased_key;
phalcon_fetch_params(0, 2, 0, &key, &data);
MAKE_STD_ZVAL(lowercased_key);
phalcon_fast_strtolower(lowercased_key, key);
phalcon_update_property_array(this_ptr, SL("_data"), lowercased_key, data TSRMLS_CC);
zval_ptr_dtor(&lowercased_key);
}
/**
* Check whether a model is already initialized
*
* @param string $modelName
* @return bool
*/
PHP_METHOD(Phalcon_Mvc_Collection_Manager, isInitialized){
zval *model_name, *initialized, *lowercased;
phalcon_fetch_params(0, 1, 0, &model_name);
initialized = phalcon_fetch_nproperty_this(this_ptr, SL("_initialized"), PH_NOISY TSRMLS_CC);
ALLOC_INIT_ZVAL(lowercased);
phalcon_fast_strtolower(lowercased, model_name);
RETVAL_BOOL(phalcon_array_isset(initialized, lowercased));
zval_ptr_dtor(&lowercased);
}
/**
* Writes parsed annotations to memory
*
* @param string $key
* @param Phalcon\Annotations\Reflection $data
*/
PHP_METHOD(Phalcon_Annotations_Adapter_Memory, write){
zval *key, *data, *lowercased_key;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &key, &data);
PHALCON_INIT_VAR(lowercased_key);
phalcon_fast_strtolower(lowercased_key, key);
phalcon_update_property_array(this_ptr, SL("_data"), lowercased_key, data TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Lowercases a string, this function makes use of the mbstring extension if available
*
* @param string $str
* @return string
*/
PHP_METHOD(Phalcon_Text, lower){
zval *str;
phalcon_fetch_params(0, 1, 0, &str);
/**
* 'lower' checks for the mbstring extension to make a correct lowercase
* transformation
*/
if (phalcon_function_exists_ex(SS("mb_strtolower") TSRMLS_CC) == SUCCESS) {
PHALCON_MM_GROW();
PHALCON_RETURN_CALL_FUNCTION("mb_strtolower", str);
RETURN_MM();
}
phalcon_fast_strtolower(return_value, str);
}
/**
* Reads parsed annotations from memory
*
* @param string $key
* @return Phalcon\Annotations\Reflection
*/
PHP_METHOD(Phalcon_Annotations_Adapter_Memory, read){
zval *key, *data, *lowercased_key, *annotations;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &key);
data = phalcon_fetch_nproperty_this(this_ptr, SL("_data"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(lowercased_key);
phalcon_fast_strtolower(lowercased_key, key);
if (phalcon_array_isset_fetch(&annotations, data, lowercased_key)) {
RETURN_CTOR(annotations);
}
RETURN_MM_NULL();
}
/**
* Reads column-map information for certain model using a MODEL_* constant
*
*<code>
* print_r($metaData->readColumnMapIndex(new Robots(), MetaData::MODELS_REVERSE_COLUMN_MAP));
*</code>
*
* @param Phalcon\Mvc\ModelInterface $model
* @param int $index
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, readColumnMapIndex){
zval *model, *index, *class_name, *key_name, *column_map = NULL;
zval *null_value, *column_map_model, *attributes;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &model, &index) == FAILURE) {
RETURN_MM_NULL();
}
if (Z_TYPE_P(model) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "A model instance is required to retrieve the meta-data");
return;
}
if (Z_TYPE_P(index) != IS_LONG) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Index must be a valid integer constant");
return;
}
PHALCON_INIT_VAR(class_name);
phalcon_get_class(class_name, model, 0 TSRMLS_CC);
PHALCON_INIT_VAR(key_name);
phalcon_fast_strtolower(key_name, class_name);
PHALCON_OBS_VAR(column_map);
phalcon_read_property(&column_map, this_ptr, SL("_columnMap"), PH_NOISY_CC);
if (!phalcon_array_isset(column_map, key_name)) {
PHALCON_INIT_VAR(null_value);
PHALCON_CALL_METHOD_PARAMS_4_NORETURN(this_ptr, "_initialize", model, null_value, null_value, null_value);
PHALCON_OBS_NVAR(column_map);
phalcon_read_property(&column_map, this_ptr, SL("_columnMap"), PH_NOISY_CC);
}
PHALCON_OBS_VAR(column_map_model);
phalcon_array_fetch(&column_map_model, column_map, key_name, PH_NOISY_CC);
PHALCON_OBS_VAR(attributes);
phalcon_array_fetch(&attributes, column_map_model, index, PH_NOISY_CC);
RETURN_CCTOR(attributes);
}
/**
* Writes parsed annotations to XCache
*
* @param string $key
* @param Phalcon\Annotations\Reflection $data
*/
PHP_METHOD(Phalcon_Annotations_Adapter_Xcache, write){
zval *key, *data, *prefixed_key, *prefixed_lower;
zval *serialized;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &key, &data);
PHALCON_INIT_VAR(prefixed_key);
PHALCON_CONCAT_SV(prefixed_key, "_PHAN", key);
PHALCON_INIT_VAR(prefixed_lower);
phalcon_fast_strtolower(prefixed_lower, prefixed_key);
PHALCON_INIT_VAR(serialized);
phalcon_serialize(serialized, &data TSRMLS_CC);
phalcon_call_func_p2_noret("xcache_set", prefixed_lower, serialized);
PHALCON_MM_RESTORE();
}
/**
* Check whether a model is already initialized
*
* @param string $modelName
* @return bool
*/
PHP_METHOD(Phalcon_Mvc_Collection_Manager, isInitialized){
zval *model_name, *initialized, *lowercased;
zval *is_intitialized = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &model_name);
PHALCON_OBS_VAR(initialized);
phalcon_read_property_this(&initialized, this_ptr, SL("_initialized"), PH_NOISY_CC);
PHALCON_INIT_VAR(lowercased);
phalcon_fast_strtolower(lowercased, model_name);
PHALCON_INIT_VAR(r0);
ZVAL_BOOL(r0, phalcon_array_isset(initialized, lowercased));
PHALCON_CPY_WRT(is_intitialized, r0);
RETURN_NCTOR(is_intitialized);
}
/**
* Execute a save.
*
* @param string $file
* @param int $quality
* @return boolean
*/
PHP_METHOD(Phalcon_Image_Adapter_GD, _save) {
zval *file, *quality = NULL, *interlacing = NULL, ret = {}, extension = {}, type = {}, mime = {}, constant = {}, image = {}, tmp = {};
const char *func_name = "imagegif";
char *ext;
phalcon_fetch_params(0, 1, 2, &file, &quality, &interlacing);
if (!phalcon_get_constant(&constant, SL("PATHINFO_EXTENSION"))) {
return;
}
PHALCON_CALL_FUNCTIONW(&ret, "pathinfo", file, &constant);
phalcon_fast_strtolower(&extension, &ret);
ext = Z_STRVAL(extension);
phalcon_return_property(&image, getThis(), SL("_image"));
if (strcmp(ext, "gif") == 0) {
ZVAL_LONG(&type, 1);
func_name = "imagegif";
} else if (strcmp(ext, "jpg") == 0 || strcmp(ext, "jpeg") == 0) {
ZVAL_LONG(&type, 2);
func_name = "imagejpeg";
} else if (strcmp(ext, "png") == 0) {
ZVAL_LONG(&type, 3);
func_name = "imagepng";
} else {
zend_throw_exception_ex(phalcon_image_exception_ce, 0, "Installed GD does not support '%s' images", Z_STRVAL(extension));
return;
}
if (interlacing && Z_TYPE_P(interlacing) >= IS_NULL && Z_LVAL(type) > 1) {
if (zend_is_true(interlacing)) {
PHALCON_CALL_FUNCTIONW(&ret, "imageinterlace", &image, &PHALCON_GLOBAL(z_one));
} else {
PHALCON_CALL_FUNCTIONW(&ret, "imageinterlace", &image, &PHALCON_GLOBAL(z_zero));
}
}
if (!quality || Z_TYPE_P(quality) == IS_NULL) {
PHALCON_CALL_FUNCTIONW(NULL, func_name, &image, file);
} else {
if (Z_LVAL(type) == 3) {
ZVAL_LONG(&tmp, ceil(Z_LVAL_P(quality)/100*9));
PHALCON_CALL_FUNCTIONW(&ret, func_name, &image, file, &tmp);
} else {
PHALCON_CALL_FUNCTIONW(&ret, func_name, &image, file, quality);
}
}
if (zend_is_true(&ret)) {
phalcon_update_property_zval(getThis(), SL("_type"), &type);
PHALCON_CALL_FUNCTIONW(&mime, "image_type_to_mime_type", &type);
phalcon_update_property_zval(getThis(), SL("_mime"), &mime);
RETVAL_TRUE;
} else {
RETVAL_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_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();
}
/**
* Checks for annotations in the public methods of the controller
*
* @param string $controller
* @param string $action
* @param Phalcon\Annotations\Annotation $annotation
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, processActionAnnotation){
zval *controller, *action, *annotation, *is_route = NULL;
zval *methods = NULL, *name, *action_sufix, *empty_str;
zval *real_action_name, *action_name, *route_prefix;
zval *parameter = NULL, *paths = NULL, *position, *value, *uri = NULL, *route;
zval *converts, *convert = NULL, *param = NULL, *route_name;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &controller, &action, &annotation) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(is_route);
ZVAL_BOOL(is_route, 0);
PHALCON_INIT_VAR(methods);
PHALCON_INIT_VAR(name);
PHALCON_CALL_METHOD(name, annotation, "getname");
/**
* Find if the route is for adding routes
*/
if (PHALCON_IS_STRING(name, "Route")) {
ZVAL_BOOL(is_route, 1);
} else {
if (PHALCON_IS_STRING(name, "Get")) {
ZVAL_BOOL(is_route, 1);
ZVAL_STRING(methods, "GET", 1);
} else {
if (PHALCON_IS_STRING(name, "Post")) {
ZVAL_BOOL(is_route, 1);
PHALCON_INIT_NVAR(methods);
ZVAL_STRING(methods, "POST", 1);
} else {
if (PHALCON_IS_STRING(name, "Put")) {
ZVAL_BOOL(is_route, 1);
PHALCON_INIT_NVAR(methods);
ZVAL_STRING(methods, "PUT", 1);
} else {
if (PHALCON_IS_STRING(name, "Options")) {
ZVAL_BOOL(is_route, 1);
PHALCON_INIT_NVAR(methods);
ZVAL_STRING(methods, "OPTIONS", 1);
}
}
}
}
}
if (PHALCON_IS_TRUE(is_route)) {
PHALCON_OBS_VAR(action_sufix);
phalcon_read_property(&action_sufix, this_ptr, SL("_actionSufix"), PH_NOISY_CC);
PHALCON_INIT_VAR(empty_str);
ZVAL_STRING(empty_str, "", 1);
PHALCON_INIT_VAR(real_action_name);
phalcon_fast_str_replace(real_action_name, action_sufix, empty_str, action TSRMLS_CC);
PHALCON_INIT_VAR(action_name);
phalcon_fast_strtolower(action_name, real_action_name);
PHALCON_OBS_VAR(route_prefix);
phalcon_read_property(&route_prefix, this_ptr, SL("_routePrefix"), PH_NOISY_CC);
PHALCON_INIT_VAR(parameter);
ZVAL_STRING(parameter, "paths", 1);
/**
* Check for existing paths in the annotation
*/
PHALCON_INIT_VAR(paths);
PHALCON_CALL_METHOD_PARAMS_1(paths, annotation, "getnamedparameter", parameter);
if (Z_TYPE_P(paths) != IS_ARRAY) {
PHALCON_INIT_NVAR(paths);
array_init(paths);
}
phalcon_array_update_string(&paths, SL("controller"), &controller, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&paths, SL("action"), &action_name, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(position);
ZVAL_LONG(position, 0);
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, annotation, "getargument", position);
/**
* Create the route using the prefix
*/
if (Z_TYPE_P(value) != IS_NULL) {
if (!PHALCON_IS_STRING(value, "/")) {
PHALCON_INIT_VAR(uri);
PHALCON_CONCAT_VV(uri, route_prefix, value);
} else {
PHALCON_CPY_WRT(uri, route_prefix);
}
} else {
PHALCON_INIT_NVAR(uri);
PHALCON_CONCAT_VV(uri, route_prefix, action_name);
}
/**
* Add the route to the router
*/
PHALCON_INIT_VAR(route);
PHALCON_CALL_METHOD_PARAMS_2(route, this_ptr, "add", uri, paths);
if (Z_TYPE_P(methods) == IS_NULL) {
PHALCON_INIT_NVAR(parameter);
ZVAL_STRING(parameter, "methods", 1);
PHALCON_INIT_NVAR(methods);
PHALCON_CALL_METHOD_PARAMS_1(methods, annotation, "getnamedparameter", parameter);
if (Z_TYPE_P(methods) == IS_ARRAY) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(route, "via", methods);
} else {
if (Z_TYPE_P(methods) == IS_STRING) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(route, "via", methods);
}
}
} else {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(route, "via", methods);
}
PHALCON_INIT_NVAR(parameter);
ZVAL_STRING(parameter, "converts", 1);
PHALCON_INIT_VAR(converts);
PHALCON_CALL_METHOD_PARAMS_1(converts, annotation, "getnamedparameter", parameter);
if (Z_TYPE_P(converts) == IS_ARRAY) {
if (!phalcon_is_iterable(converts, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(param, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(convert);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(route, "convert", param, convert);
zend_hash_move_forward_ex(ah0, &hp0);
}
}
PHALCON_INIT_NVAR(parameter);
ZVAL_STRING(parameter, "name", 1);
PHALCON_INIT_VAR(route_name);
PHALCON_CALL_METHOD_PARAMS_1(route_name, annotation, "getnamedparameter", parameter);
if (Z_TYPE_P(route_name) == IS_STRING) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(route, "setname", route_name);
}
RETURN_MM_TRUE;
}
PHALCON_MM_RESTORE();
}
/**
* Initialize the metadata for certain table
*
* @param Phalcon\Mvc\ModelInterface $model
* @param string $key
* @param string $table
* @param string $schema
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, _initialize){
zval *model, *key, *table, *schema, *strategy = NULL, *class_name;
zval *meta_data = NULL, *prefix_key = NULL, *data = NULL, *model_metadata = NULL;
zval *exception_message, *dependency_injector;
zval *key_name, *column_map = NULL, *model_column_map = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 4, 0, &model, &key, &table, &schema);
dependency_injector = phalcon_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(strategy);
PHALCON_INIT_VAR(class_name);
phalcon_get_class(class_name, model, 0 TSRMLS_CC);
if (Z_TYPE_P(key) != IS_NULL) {
PHALCON_OBS_VAR(meta_data);
phalcon_read_property_this(&meta_data, this_ptr, SL("_metaData"), PH_NOISY TSRMLS_CC);
if (!phalcon_array_isset(meta_data, key)) {
PHALCON_INIT_VAR(prefix_key);
PHALCON_CONCAT_SV(prefix_key, "meta-", key);
/**
* The meta-data is read from the adapter always
*/
PHALCON_CALL_METHOD(&data, this_ptr, "read", prefix_key);
if (Z_TYPE_P(data) != IS_NULL) {
if (Z_TYPE_P(meta_data) != IS_ARRAY) {
PHALCON_INIT_NVAR(meta_data);
array_init(meta_data);
}
phalcon_array_update_zval(&meta_data, key, data, PH_COPY | PH_SEPARATE);
phalcon_update_property_this(this_ptr, SL("_metaData"), meta_data TSRMLS_CC);
} else {
/**
* Check if there is a method 'metaData' in the model to retrieve meta-data from it
*/
if (phalcon_method_exists_ex(model, SS("metadata") TSRMLS_CC) == SUCCESS) {
PHALCON_CALL_METHOD(&model_metadata, model, "metadata");
if (Z_TYPE_P(model_metadata) != IS_ARRAY) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SV(exception_message, "Invalid meta-data for model ", class_name);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message);
return;
}
} else {
/**
* Get the meta-data extraction strategy
*/
PHALCON_CALL_METHOD(&strategy, this_ptr, "getstrategy");
/**
* Get the meta-data
*/
PHALCON_CALL_METHOD(&model_metadata, strategy, "getmetadata", model, dependency_injector);
}
/**
* Store the meta-data locally
*/
phalcon_update_property_array(this_ptr, SL("_metaData"), key, model_metadata TSRMLS_CC);
/**
* Store the meta-data in the adapter
*/
PHALCON_CALL_METHOD(NULL, this_ptr, "write", prefix_key, model_metadata);
}
}
}
/**
* Check for a column map, store in _columnMap in order and reversed order
*/
if (!PHALCON_GLOBAL(orm).column_renaming) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(key_name);
phalcon_fast_strtolower(key_name, class_name);
PHALCON_OBS_VAR(column_map);
phalcon_read_property_this(&column_map, this_ptr, SL("_columnMap"), PH_NOISY TSRMLS_CC);
if (phalcon_array_isset(column_map, key_name)) {
RETURN_MM_NULL();
}
if (Z_TYPE_P(column_map) != IS_ARRAY) {
PHALCON_INIT_NVAR(column_map);
array_init(column_map);
}
/**
* Create the map key name
*/
PHALCON_INIT_NVAR(prefix_key);
PHALCON_CONCAT_SV(prefix_key, "map-", key_name);
/**
* Check if the meta-data is already in the adapter
*/
PHALCON_CALL_METHOD(&data, this_ptr, "read", prefix_key);
if (Z_TYPE_P(data) != IS_NULL) {
phalcon_array_update_zval(&column_map, key_name, data, PH_COPY | PH_SEPARATE);
phalcon_update_property_this(this_ptr, SL("_columnMap"), column_map TSRMLS_CC);
RETURN_MM_NULL();
}
/**
* Get the meta-data extraction strategy
*/
if (Z_TYPE_P(strategy) != IS_OBJECT) {
PHALCON_CALL_METHOD(&strategy, this_ptr, "getstrategy");
}
/**
* Get the meta-data
*/
PHALCON_CALL_METHOD(&model_column_map, strategy, "getcolumnmaps", model, dependency_injector);
/**
* Update the column map locally
*/
phalcon_update_property_array(this_ptr, SL("_columnMap"), key_name, model_column_map TSRMLS_CC);
/**
* Write the data to the adapter
*/
PHALCON_CALL_METHOD(NULL, this_ptr, "write", prefix_key, model_column_map);
PHALCON_MM_RESTORE();
}
/**
* Shows a backtrace item
*
* @param int $n
* @param array $trace
*/
PHP_METHOD(Phalcon_Debug, showTraceItem){
zval *n, *trace, *link_format, *space, *two_spaces, *underscore;
zval *minus, *html, *class_name;
zval *namespace_separator, *prepare_uri_class;
zval *lower_class_name, *prepared_function_name;
zval *prepare_internal_class, *type, *function_name = NULL;
zval *trace_args, *arguments, *argument = NULL, *dumped_argument = NULL;
zval *span_argument = NULL, *joined_arguments, *z_one;
zval *file, *line, *show_files, *lines = NULL, *number_lines;
zval *show_file_fragment, *before_context, *before_line;
zval *first_line = NULL, *after_context, *after_line, *last_line = NULL;
zval *comment_pattern, *charset, *tab;
zval *comment, *i = NULL, *line_position = NULL, *current_line = NULL;
zval *trimmed = NULL, *is_comment = NULL, *spaced_current_line = NULL;
zval *escaped_line = NULL, *formatted_file = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 3, 0, &n, &trace, &link_format);
PHALCON_INIT_VAR(space);
ZVAL_STRING(space, " ", 1);
PHALCON_INIT_VAR(two_spaces);
ZVAL_STRING(two_spaces, " ", 1);
PHALCON_INIT_VAR(underscore);
ZVAL_STRING(underscore, "_", 1);
PHALCON_INIT_VAR(minus);
ZVAL_STRING(minus, "-", 1);
/**
* Every trace in the backtrace have a unique number
*/
PHALCON_INIT_VAR(html);
PHALCON_CONCAT_SVS(html, "<tr><td align=\"right\" valign=\"top\" class=\"error-number\">#", n, "</td><td>");
if (phalcon_array_isset_string(trace, SS("class"))) {
zend_class_entry *class_ce;
PHALCON_OBS_VAR(class_name);
phalcon_array_fetch_string(&class_name, trace, SL("class"), PH_NOISY);
class_ce = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_SILENT TSRMLS_CC);
if (!class_ce) {
/* Unable to load the class, should never happen */
}
else if (is_phalcon_class(class_ce)) {
PHALCON_INIT_VAR(namespace_separator);
ZVAL_STRING(namespace_separator, "\\", 1);
/* Prepare the class name according to the Phalcon's conventions */
PHALCON_INIT_VAR(prepare_uri_class);
phalcon_fast_str_replace(prepare_uri_class, namespace_separator, underscore, class_name);
/* Generate a link to the official docs */
PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-class\"><a target=\"_new\" href=\"http://docs.phalconphp.com/en/latest/api/", prepare_uri_class, ".html\">", class_name, "</a></span>");
} else if (class_ce->type == ZEND_INTERNAL_CLASS) {
PHALCON_INIT_VAR(lower_class_name);
phalcon_fast_strtolower(lower_class_name, class_name);
PHALCON_INIT_VAR(prepare_internal_class);
phalcon_fast_str_replace(prepare_internal_class, underscore, minus, lower_class_name);
/* Generate a link to the official docs */
PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-class\"><a target=\"_new\" href=\"http://php.net/manual/en/class.", prepare_internal_class, ".php\">", class_name, "</a></span>");
} else {
PHALCON_SCONCAT_SVS(html, "<span class=\"error-class\">", class_name, "</span>");
}
/**
* Object access operator: static/instance
*/
PHALCON_OBS_VAR(type);
phalcon_array_fetch_string(&type, trace, SL("type"), PH_NOISY);
phalcon_concat_self(&html, type TSRMLS_CC);
}
/**
* Normally the backtrace contains only classes
*/
if (phalcon_array_isset_string(trace, SS("class"))) {
PHALCON_OBS_VAR(function_name);
phalcon_array_fetch_string(&function_name, trace, SL("function"), PH_NOISY);
PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>");
} else {
zend_function *func;
PHALCON_OBS_NVAR(function_name);
phalcon_array_fetch_string(&function_name, trace, SL("function"), PH_NOISY);
convert_to_string(function_name);
/**
* Check if the function exists
*/
if (phalcon_fetch_function(&func, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name) TSRMLS_CC) == SUCCESS) {
/**
* Internal functions links to the PHP documentation
*/
if (func->type == ZEND_INTERNAL_FUNCTION) {
/**
* Prepare function's name according to the conventions in the docs
*/
PHALCON_INIT_VAR(prepared_function_name);
phalcon_fast_str_replace(prepared_function_name, underscore, minus, function_name);
PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-function\"><a target=\"_new\" href=\"http://php.net/manual/en/function.", prepared_function_name, ".php\">", function_name, "</a></span>");
} else {
PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>");
}
} else {
PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>");
}
}
/**
* Check for arguments in the function
*/
if (phalcon_array_isset_string(trace, SS("args"))) {
PHALCON_OBS_VAR(trace_args);
phalcon_array_fetch_string(&trace_args, trace, SL("args"), PH_NOISY);
if (phalcon_fast_count_ev(trace_args TSRMLS_CC)) {
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_is_iterable(trace_args, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(argument);
/**
* Every argument is generated using _getVarDump
*/
PHALCON_CALL_METHOD(&dumped_argument, this_ptr, "_getvardump", argument);
PHALCON_INIT_NVAR(span_argument);
PHALCON_CONCAT_SVS(span_argument, "<span class=\"error-parameter\">", dumped_argument, "</span>");
/**
* Append the HTML generated to the argument's list
*/
phalcon_array_append(&arguments, span_argument, PH_COPY);
zend_hash_move_forward_ex(ah0, &hp0);
}
/**
* Join all the arguments
*/
PHALCON_INIT_VAR(joined_arguments);
phalcon_fast_join_str(joined_arguments, SL(", "), arguments TSRMLS_CC);
PHALCON_SCONCAT_SVS(html, "(", joined_arguments, ")");
} else {
phalcon_concat_self_str(&html, SL("()") TSRMLS_CC);
}
}
/**
* When 'file' is present, it usually means the function is provided by the user
*/
if (phalcon_array_isset_string(trace, SS("file"))) {
z_one = PHALCON_GLOBAL(z_one);
PHALCON_OBS_VAR(file);
phalcon_array_fetch_string(&file, trace, SL("file"), PH_NOISY);
PHALCON_OBS_VAR(line);
phalcon_array_fetch_string(&line, trace, SL("line"), PH_NOISY);
PHALCON_CALL_METHOD(&formatted_file, getThis(), "getfilelink", file, line, link_format);
/**
* Realpath to the file and its line using a special header
*/
PHALCON_SCONCAT_SVSVS(html, "<br/><div class=\"error-file\">", formatted_file, " (", line, ")</div>");
PHALCON_OBS_VAR(show_files);
phalcon_read_property_this(&show_files, this_ptr, SL("_showFiles"), PH_NOISY TSRMLS_CC);
/**
* The developer can change if the files must be opened or not
*/
if (zend_is_true(show_files)) {
/**
* Open the file to an array using 'file', this respects the openbase-dir directive
*/
PHALCON_CALL_FUNCTION(&lines, "file", file);
PHALCON_INIT_VAR(number_lines);
phalcon_fast_count(number_lines, lines TSRMLS_CC);
PHALCON_OBS_VAR(show_file_fragment);
phalcon_read_property_this(&show_file_fragment, this_ptr, SL("_showFileFragment"), PH_NOISY TSRMLS_CC);
/**
* File fragments just show a piece of the file where the exception is located
*/
if (zend_is_true(show_file_fragment)) {
/**
* Take lines back to the current exception's line
*/
before_context = phalcon_fetch_nproperty_this(getThis(), SL("_beforeContext"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(before_line);
phalcon_sub_function(before_line, line, before_context);
/**
* Check for overflows
*/
if (PHALCON_LT_LONG(before_line, 1)) {
PHALCON_CPY_WRT_CTOR(first_line, z_one);
} else {
PHALCON_CPY_WRT(first_line, before_line);
}
/**
* Take lines after the current exception's line
*/
after_context = phalcon_fetch_nproperty_this(getThis(), SL("_afterContext"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(after_line);
phalcon_add_function(after_line, line, after_context);
/**
* Check for overflows
*/
if (PHALCON_GT(after_line, number_lines)) {
PHALCON_CPY_WRT(last_line, number_lines);
} else {
PHALCON_CPY_WRT(last_line, after_line);
}
PHALCON_SCONCAT_SVSVSVS(html, "<pre class='prettyprint highlight:", first_line, ":", line, " linenums:", first_line, "'>");
} else {
PHALCON_CPY_WRT_CTOR(first_line, z_one);
PHALCON_CPY_WRT(last_line, number_lines);
PHALCON_SCONCAT_SVSVS(html, "<pre class='prettyprint highlight:", first_line, ":", line, " linenums error-scroll'>");
}
PHALCON_INIT_VAR(comment_pattern);
ZVAL_STRING(comment_pattern, "#\\*\\/$#", 1);
charset = phalcon_fetch_static_property_ce(phalcon_debug_ce, SL("_charset") TSRMLS_CC);
PHALCON_INIT_VAR(tab);
ZVAL_STRING(tab, "\t", 1);
PHALCON_INIT_VAR(comment);
ZVAL_STRING(comment, "* /", 1);
PHALCON_CPY_WRT(i, first_line);
while (PHALCON_LE(i, last_line)) {
/**
* Current line in the file
*/
PHALCON_INIT_NVAR(line_position);
phalcon_sub_function(line_position, i, z_one);
/**
* Current line content in the piece of file
*/
PHALCON_OBS_NVAR(current_line);
phalcon_array_fetch(¤t_line, lines, line_position, PH_NOISY);
/**
* File fragments are cleaned, removing tabs and comments
*/
if (zend_is_true(show_file_fragment)) {
if (PHALCON_IS_EQUAL(i, first_line)) {
PHALCON_INIT_NVAR(trimmed);
phalcon_fast_trim(trimmed, current_line, NULL, PHALCON_TRIM_RIGHT TSRMLS_CC);
PHALCON_INIT_NVAR(is_comment);
RETURN_MM_ON_FAILURE(phalcon_preg_match(is_comment, comment_pattern, current_line, NULL TSRMLS_CC));
if (zend_is_true(is_comment)) {
PHALCON_INIT_NVAR(spaced_current_line);
phalcon_fast_str_replace(spaced_current_line, comment, space, current_line);
PHALCON_CPY_WRT(current_line, spaced_current_line);
}
}
}
/**
* Print a non break space if the current line is a line break, this allows to show
* the html zebra properly
*/
if (PHALCON_IS_STRING(current_line, "\n")) {
phalcon_concat_self_str(&html, SL(" \n") TSRMLS_CC);
} else {
if (PHALCON_IS_STRING(current_line, "\r\n")) {
phalcon_concat_self_str(&html, SL(" \n") TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(spaced_current_line);
phalcon_fast_str_replace(spaced_current_line, tab, two_spaces, current_line);
PHALCON_INIT_NVAR(escaped_line);
phalcon_htmlentities(escaped_line, spaced_current_line, NULL, charset TSRMLS_CC);
phalcon_concat_self(&html, escaped_line TSRMLS_CC);
}
}
phalcon_increment(i);
}
phalcon_concat_self_str(&html, SL("</pre>") TSRMLS_CC);
}
}
phalcon_concat_self_str(&html, SL("</td></tr>") TSRMLS_CC);
RETURN_CTOR(html);
}
/**
* Shows a backtrace item
*
* @param int $n
* @param array $trace
*/
PHP_METHOD(Phalcon_Debug, showTraceItem){
zval *n, *trace, *space, *two_spaces, *underscore;
zval *minus, *html, *class_name, *pattern, *is_phalcon_class;
zval *namespace_separator, *prepare_uri_class;
zval *class_reflection, *is_internal = NULL, *lower_class_name;
zval *prepare_internal_class, *type, *function_name = NULL;
zval *function_reflection, *prepared_function_name;
zval *trace_args, *arguments, *argument = NULL, *dumped_argument = NULL;
zval *span_argument = NULL, *joined_arguments, *one;
zval *file, *line, *show_files, *lines, *number_lines;
zval *show_file_fragment, *seven, *before_line;
zval *first_line = NULL, *five, *after_line, *last_line = NULL;
zval *comment_pattern, *utf8, *ent_compat, *tab;
zval *comment, *i = NULL, *line_position = NULL, *current_line = NULL;
zval *trimmed = NULL, *is_comment = NULL, *spaced_current_line = NULL;
zval *escaped_line = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
zend_class_entry *ce0, *ce1;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &n, &trace);
PHALCON_INIT_VAR(space);
ZVAL_STRING(space, " ", 1);
PHALCON_INIT_VAR(two_spaces);
ZVAL_STRING(two_spaces, " ", 1);
PHALCON_INIT_VAR(underscore);
ZVAL_STRING(underscore, "_", 1);
PHALCON_INIT_VAR(minus);
ZVAL_STRING(minus, "-", 1);
/**
* Every trace in the backtrace have a unique number
*/
PHALCON_INIT_VAR(html);
PHALCON_CONCAT_SVS(html, "<tr><td align=\"right\" valign=\"top\" class=\"error-number\">#", n, "</td><td>");
if (phalcon_array_isset_string(trace, SS("class"))) {
PHALCON_OBS_VAR(class_name);
phalcon_array_fetch_string(&class_name, trace, SL("class"), PH_NOISY);
PHALCON_INIT_VAR(pattern);
ZVAL_STRING(pattern, "/^Phalcon/", 1);
PHALCON_INIT_VAR(is_phalcon_class);
phalcon_preg_match(is_phalcon_class, pattern, class_name, NULL TSRMLS_CC);
/**
* We assume that classes starting by Phalcon are framework's classes
*/
if (zend_is_true(is_phalcon_class)) {
PHALCON_INIT_VAR(namespace_separator);
ZVAL_STRING(namespace_separator, "\\", 1);
/**
* Prepare the class name according to the Phalcon's conventions
*/
PHALCON_INIT_VAR(prepare_uri_class);
phalcon_fast_str_replace(prepare_uri_class, namespace_separator, underscore, class_name);
/**
* Generate a link to the official docs
*/
PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-class\"><a target=\"_new\" href=\"http://docs.phalconphp.com/en/latest/api/", prepare_uri_class, ".html\">", class_name, "</a></span>");
} else {
ce0 = zend_fetch_class(SL("ReflectionClass"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_VAR(class_reflection);
object_init_ex(class_reflection, ce0);
if (phalcon_has_constructor(class_reflection TSRMLS_CC)) {
phalcon_call_method_p1_noret(class_reflection, "__construct", class_name);
}
/**
* Check if classes are PHP's classes
*/
PHALCON_INIT_VAR(is_internal);
phalcon_call_method(is_internal, class_reflection, "isinternal");
if (zend_is_true(is_internal)) {
PHALCON_INIT_VAR(lower_class_name);
phalcon_fast_strtolower(lower_class_name, class_name);
PHALCON_INIT_VAR(prepare_internal_class);
phalcon_fast_str_replace(prepare_internal_class, underscore, minus, lower_class_name);
/**
* Generate a link to the official docs
*/
PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-class\"><a target=\"_new\" href=\"http://php.net/manual/en/class.", prepare_internal_class, ".php\">", class_name, "</a></span>");
} else {
PHALCON_SCONCAT_SVS(html, "<span class=\"error-class\">", class_name, "</span>");
}
}
/**
* Object access operator: static/instance
*/
PHALCON_OBS_VAR(type);
phalcon_array_fetch_string(&type, trace, SL("type"), PH_NOISY);
phalcon_concat_self(&html, type TSRMLS_CC);
}
/**
* Normally the backtrace contains only classes
*/
if (phalcon_array_isset_string(trace, SS("class"))) {
PHALCON_OBS_VAR(function_name);
phalcon_array_fetch_string(&function_name, trace, SL("function"), PH_NOISY);
PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>");
} else {
PHALCON_OBS_NVAR(function_name);
phalcon_array_fetch_string(&function_name, trace, SL("function"), PH_NOISY);
/**
* Check if the function exists
*/
if (phalcon_function_exists(function_name TSRMLS_CC) == SUCCESS) {
ce1 = zend_fetch_class(SL("ReflectionFunction"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_VAR(function_reflection);
object_init_ex(function_reflection, ce1);
if (phalcon_has_constructor(function_reflection TSRMLS_CC)) {
phalcon_call_method_p1_noret(function_reflection, "__construct", function_name);
}
PHALCON_INIT_NVAR(is_internal);
phalcon_call_method(is_internal, function_reflection, "isinternal");
/**
* Internal functions links to the PHP documentation
*/
if (zend_is_true(is_internal)) {
/**
* Prepare function's name according to the conventions in the docs
*/
PHALCON_INIT_VAR(prepared_function_name);
phalcon_fast_str_replace(prepared_function_name, underscore, minus, function_name);
PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-function\"><a target=\"_new\" href=\"http://php.net/manual/en/function.", prepared_function_name, ".php\">", function_name, "</a></span>");
} else {
PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>");
}
} else {
PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>");
}
}
/**
* Check for arguments in the function
*/
if (phalcon_array_isset_string(trace, SS("args"))) {
PHALCON_OBS_VAR(trace_args);
phalcon_array_fetch_string(&trace_args, trace, SL("args"), PH_NOISY);
if (phalcon_fast_count_ev(trace_args TSRMLS_CC)) {
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_is_iterable(trace_args, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(argument);
/**
* Every argument is generated using _getVarDump
*/
PHALCON_INIT_NVAR(dumped_argument);
phalcon_call_method_p1(dumped_argument, this_ptr, "_getvardump", argument);
PHALCON_INIT_NVAR(span_argument);
PHALCON_CONCAT_SVS(span_argument, "<span class=\"error-parameter\">", dumped_argument, "</span>");
/**
* Append the HTML generated to the argument's list
*/
phalcon_array_append(&arguments, span_argument, PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
}
/**
* Join all the arguments
*/
PHALCON_INIT_VAR(joined_arguments);
phalcon_fast_join_str(joined_arguments, SL(", "), arguments TSRMLS_CC);
PHALCON_SCONCAT_SVS(html, "(", joined_arguments, ")");
} else {
phalcon_concat_self_str(&html, SL("()") TSRMLS_CC);
}
}
/**
* When 'file' is present, it usually means the function is provided by the user
*/
if (phalcon_array_isset_string(trace, SS("file"))) {
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_OBS_VAR(file);
phalcon_array_fetch_string(&file, trace, SL("file"), PH_NOISY);
PHALCON_OBS_VAR(line);
phalcon_array_fetch_string(&line, trace, SL("line"), PH_NOISY);
/**
* Realpath to the file and its line using a special header
*/
PHALCON_SCONCAT_SVSVS(html, "<br/><div class=\"error-file\">", file, " (", line, ")</div>");
PHALCON_OBS_VAR(show_files);
phalcon_read_property_this(&show_files, this_ptr, SL("_showFiles"), PH_NOISY_CC);
/**
* The developer can change if the files must be opened or not
*/
if (zend_is_true(show_files)) {
/**
* Open the file to an array using 'file', this respects the openbase-dir directive
*/
PHALCON_INIT_VAR(lines);
phalcon_call_func_p1(lines, "file", file);
PHALCON_INIT_VAR(number_lines);
phalcon_fast_count(number_lines, lines TSRMLS_CC);
PHALCON_OBS_VAR(show_file_fragment);
phalcon_read_property_this(&show_file_fragment, this_ptr, SL("_showFileFragment"), PH_NOISY_CC);
/**
* File fragments just show a piece of the file where the exception is located
*/
if (zend_is_true(show_file_fragment)) {
/**
* Take seven lines back to the current exception's line, @TODO add an option for
* this
*/
PHALCON_INIT_VAR(seven);
ZVAL_LONG(seven, 7);
PHALCON_INIT_VAR(before_line);
sub_function(before_line, line, seven TSRMLS_CC);
/**
* Check for overflows
*/
if (PHALCON_LT_LONG(before_line, 1)) {
PHALCON_CPY_WRT(first_line, one);
} else {
PHALCON_CPY_WRT(first_line, before_line);
}
/**
* Take five lines after the current exception's line, @TODO add an option for this
*/
PHALCON_INIT_VAR(five);
ZVAL_LONG(five, 5);
PHALCON_INIT_VAR(after_line);
phalcon_add_function(after_line, line, five TSRMLS_CC);
/**
* Check for overflows
*/
if (PHALCON_GT(after_line, number_lines)) {
PHALCON_CPY_WRT(last_line, number_lines);
} else {
PHALCON_CPY_WRT(last_line, after_line);
}
PHALCON_SCONCAT_SVSVSVS(html, "<pre class='prettyprint highlight:", first_line, ":", line, " linenums:", first_line, "'>");
} else {
PHALCON_CPY_WRT(first_line, one);
PHALCON_CPY_WRT(last_line, number_lines);
PHALCON_SCONCAT_SVSVS(html, "<pre class='prettyprint highlight:", first_line, ":", line, " linenums error-scroll'>");
}
PHALCON_INIT_VAR(comment_pattern);
ZVAL_STRING(comment_pattern, "#\\*\\/$#", 1);
/**
* We assume the file is utf-8 encoded, @TODO add an option for this
*/
PHALCON_INIT_VAR(utf8);
ZVAL_STRING(utf8, "UTF-8", 1);
/**
* Don't escape quotes
*/
PHALCON_INIT_VAR(ent_compat);
ZVAL_LONG(ent_compat, 2);
PHALCON_INIT_VAR(tab);
ZVAL_STRING(tab, "\t", 1);
PHALCON_INIT_VAR(comment);
ZVAL_STRING(comment, "* /", 1);
PHALCON_CPY_WRT(i, first_line);
while (1) {
if (PHALCON_LE(i, last_line)) {
} else {
break;
}
/**
* Current line in the file
*/
PHALCON_INIT_NVAR(line_position);
sub_function(line_position, i, one TSRMLS_CC);
/**
* Current line content in the piece of file
*/
PHALCON_OBS_NVAR(current_line);
phalcon_array_fetch(¤t_line, lines, line_position, PH_NOISY);
/**
* File fragments are cleaned, removing tabs and comments
*/
if (zend_is_true(show_file_fragment)) {
if (PHALCON_IS_EQUAL(i, first_line)) {
PHALCON_INIT_NVAR(trimmed);
phalcon_fast_trim(trimmed, current_line, PHALCON_TRIM_RIGHT TSRMLS_CC);
PHALCON_INIT_NVAR(is_comment);
phalcon_preg_match(is_comment, comment_pattern, current_line, NULL TSRMLS_CC);
if (zend_is_true(is_comment)) {
PHALCON_INIT_NVAR(spaced_current_line);
phalcon_fast_str_replace(spaced_current_line, comment, space, current_line);
PHALCON_CPY_WRT(current_line, spaced_current_line);
}
}
}
/**
* Print a non break space if the current line is a line break, this allows to show
* the html zebra properly
*/
if (PHALCON_IS_STRING(current_line, "\n")) {
phalcon_concat_self_str(&html, SL(" \n") TSRMLS_CC);
} else {
if (PHALCON_IS_STRING(current_line, "\r\n")) {
phalcon_concat_self_str(&html, SL(" \n") TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(spaced_current_line);
phalcon_fast_str_replace(spaced_current_line, tab, two_spaces, current_line);
PHALCON_INIT_NVAR(escaped_line);
phalcon_call_func_p3(escaped_line, "htmlentities", spaced_current_line, ent_compat, utf8);
phalcon_concat_self(&html, escaped_line TSRMLS_CC);
}
}
PHALCON_SEPARATE(i);
phalcon_increment(i);
}
phalcon_concat_self_str(&html, SL("</pre>") TSRMLS_CC);
}
}
phalcon_concat_self_str(&html, SL("</td></tr>") TSRMLS_CC);
RETURN_CTOR(html);
}
/**
* Internal sanitize wrapper to filter_var
*
* @param mixed $value
* @param string $filter
* @return mixed
*/
PHP_METHOD(Phalcon_Filter, _sanitize){
zval *value, *filter, *filters, *filter_object;
zval *arguments, *filtered = NULL, *type = NULL, *quote, *empty_str;
zval *escaped, *allow_fraction, *options, *exception_message;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &value, &filter) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_OBS_VAR(filters);
phalcon_read_property(&filters, this_ptr, SL("_filters"), PH_NOISY_CC);
if (phalcon_array_isset(filters, filter)) {
PHALCON_OBS_VAR(filter_object);
phalcon_array_fetch(&filter_object, filters, filter, PH_NOISY_CC);
/**
* If the filter is a closure we call it in the PHP userland
*/
if (phalcon_is_instance_of(filter_object, SL("Closure") TSRMLS_CC)) {
PHALCON_INIT_VAR(arguments);
array_init_size(arguments, 1);
phalcon_array_append(&arguments, value, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(filtered);
PHALCON_CALL_USER_FUNC_ARRAY(filtered, filter_object, arguments);
} else {
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_METHOD_PARAMS_1(filtered, filter_object, "filter", value);
}
RETURN_CCTOR(filtered);
}
if (PHALCON_IS_STRING(filter, "email")) {
/**
* The 'email' filter uses the filter extension
*/
PHALCON_INIT_VAR(type);
ZVAL_LONG(type, 517);
PHALCON_INIT_VAR(quote);
ZVAL_STRING(quote, "'", 1);
PHALCON_INIT_VAR(empty_str);
ZVAL_STRING(empty_str, "", 1);
PHALCON_INIT_VAR(escaped);
phalcon_fast_str_replace(escaped, quote, empty_str, value TSRMLS_CC);
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", escaped, type);
goto ph_end_0;
}
if (PHALCON_IS_STRING(filter, "int")) {
/**
* 'int' filter sanitizes a numeric input
*/
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 519);
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", value, type);
goto ph_end_0;
}
if (PHALCON_IS_STRING(filter, "string")) {
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 513);
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", value, type);
goto ph_end_0;
}
if (PHALCON_IS_STRING(filter, "float")) {
/**
* The 'float' filter uses the filter extension
*/
PHALCON_INIT_VAR(allow_fraction);
ZVAL_LONG(allow_fraction, 4096);
PHALCON_INIT_VAR(options);
array_init_size(options, 1);
phalcon_array_update_string(&options, SL("flags"), &allow_fraction, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 520);
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_3(filtered, "filter_var", value, type, options);
goto ph_end_0;
}
if (PHALCON_IS_STRING(filter, "alphanum")) {
PHALCON_INIT_NVAR(filtered);
phalcon_filter_alphanum(filtered, value);
goto ph_end_0;
}
if (PHALCON_IS_STRING(filter, "trim")) {
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_1(filtered, "trim", value);
goto ph_end_0;
}
if (PHALCON_IS_STRING(filter, "striptags")) {
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_1(filtered, "strip_tags", value);
goto ph_end_0;
}
if (PHALCON_IS_STRING(filter, "lower")) {
if (phalcon_function_exists_ex(SS("mb_strtolower") TSRMLS_CC) == SUCCESS) {
/**
* 'lower' checks for the mbstring extension to make a correct lowercase
* transformation
*/
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_1(filtered, "mb_strtolower", value);
} else {
PHALCON_INIT_NVAR(filtered);
phalcon_fast_strtolower(filtered, value);
}
goto ph_end_0;
}
if (PHALCON_IS_STRING(filter, "upper")) {
if (phalcon_function_exists_ex(SS("mb_strtoupper") TSRMLS_CC) == SUCCESS) {
/**
* 'upper' checks for the mbstring extension to make a correct lowercase
* transformation
*/
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_1(filtered, "mb_strtoupper", value);
} else {
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_1(filtered, "strtoupper", value);
}
goto ph_end_0;
}
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Sanitize filter ", filter, " is not supported");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_filter_exception_ce, exception_message);
return;
ph_end_0:
RETURN_CCTOR(filtered);
}