/**
* Checks for annotations in the public methods of the controller
*
* @param string module
* @param string namespaceName
* @param string controller
* @param string action
* @param Phalcon\Annotations\Annotation annotation
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, processActionAnnotation) {
zephir_fcall_cache_entry *_7 = NULL, *_11 = NULL;
HashTable *_5, *_9;
HashPosition _4, _8;
int ZEPHIR_LAST_CALL_STATUS;
zend_bool isRoute, _12;
zval *module_param = NULL, *namespaceName_param = NULL, *controller_param = NULL, *action_param = NULL, *annotation, *name = NULL, *actionName, *routePrefix, *paths = NULL, *value = NULL, *uri = NULL, *route = NULL, *methods = NULL, *converts = NULL, *param = NULL, *convert = NULL, *conversorParam = NULL, *routeName = NULL, *beforeMatch = NULL, *_0, *_1, _2, *_3 = NULL, **_6, **_10;
zval *module = NULL, *namespaceName = NULL, *controller = NULL, *action = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 5, 0, &module_param, &namespaceName_param, &controller_param, &action_param, &annotation);
if (unlikely(Z_TYPE_P(module_param) != IS_STRING && Z_TYPE_P(module_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'module' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(module_param) == IS_STRING)) {
zephir_get_strval(module, module_param);
} else {
ZEPHIR_INIT_VAR(module);
ZVAL_EMPTY_STRING(module);
}
if (unlikely(Z_TYPE_P(namespaceName_param) != IS_STRING && Z_TYPE_P(namespaceName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'namespaceName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(namespaceName_param) == IS_STRING)) {
zephir_get_strval(namespaceName, namespaceName_param);
} else {
ZEPHIR_INIT_VAR(namespaceName);
ZVAL_EMPTY_STRING(namespaceName);
}
if (unlikely(Z_TYPE_P(controller_param) != IS_STRING && Z_TYPE_P(controller_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'controller' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(controller_param) == IS_STRING)) {
zephir_get_strval(controller, controller_param);
} else {
ZEPHIR_INIT_VAR(controller);
ZVAL_EMPTY_STRING(controller);
}
if (unlikely(Z_TYPE_P(action_param) != IS_STRING && Z_TYPE_P(action_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'action' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(action_param) == IS_STRING)) {
zephir_get_strval(action, action_param);
} else {
ZEPHIR_INIT_VAR(action);
ZVAL_EMPTY_STRING(action);
}
isRoute = 0;
ZEPHIR_INIT_VAR(methods);
ZVAL_NULL(methods);
ZEPHIR_CALL_METHOD(&name, annotation, "getname", NULL, 0);
zephir_check_call_status();
do {
if (ZEPHIR_IS_STRING(name, "Route")) {
isRoute = 1;
break;
}
if (ZEPHIR_IS_STRING(name, "Get")) {
isRoute = 1;
ZEPHIR_INIT_NVAR(methods);
ZVAL_STRING(methods, "GET", 1);
break;
}
if (ZEPHIR_IS_STRING(name, "Post")) {
isRoute = 1;
ZEPHIR_INIT_NVAR(methods);
ZVAL_STRING(methods, "POST", 1);
break;
}
if (ZEPHIR_IS_STRING(name, "Put")) {
isRoute = 1;
ZEPHIR_INIT_NVAR(methods);
ZVAL_STRING(methods, "PUT", 1);
break;
}
if (ZEPHIR_IS_STRING(name, "Delete")) {
isRoute = 1;
ZEPHIR_INIT_NVAR(methods);
ZVAL_STRING(methods, "DELETE", 1);
break;
}
if (ZEPHIR_IS_STRING(name, "Options")) {
isRoute = 1;
ZEPHIR_INIT_NVAR(methods);
ZVAL_STRING(methods, "OPTIONS", 1);
break;
}
} while(0);
if (isRoute == 1) {
ZEPHIR_INIT_VAR(_0);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_actionSuffix"), PH_NOISY_CC);
ZEPHIR_SINIT_VAR(_2);
ZVAL_STRING(&_2, "", 0);
zephir_fast_str_replace(&_0, _1, &_2, action TSRMLS_CC);
ZEPHIR_INIT_VAR(actionName);
zephir_fast_strtolower(actionName, _0);
ZEPHIR_OBS_VAR(routePrefix);
zephir_read_property_this(&routePrefix, this_ptr, SL("_routePrefix"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_3);
ZVAL_STRING(_3, "paths", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&paths, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(paths) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(paths);
array_init(paths);
}
if (!(ZEPHIR_IS_EMPTY(module))) {
zephir_array_update_string(&paths, SL("module"), &module, PH_COPY | PH_SEPARATE);
}
if (!(ZEPHIR_IS_EMPTY(namespaceName))) {
zephir_array_update_string(&paths, SL("namespace"), &namespaceName, PH_COPY | PH_SEPARATE);
}
zephir_array_update_string(&paths, SL("controller"), &controller, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&paths, SL("action"), &actionName, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_3);
ZVAL_LONG(_3, 0);
ZEPHIR_CALL_METHOD(&value, annotation, "getargument", NULL, 0, _3);
zephir_check_call_status();
if (Z_TYPE_P(value) != IS_NULL) {
if (!ZEPHIR_IS_STRING(value, "/")) {
ZEPHIR_INIT_VAR(uri);
ZEPHIR_CONCAT_VV(uri, routePrefix, value);
} else {
if (Z_TYPE_P(routePrefix) != IS_NULL) {
ZEPHIR_CPY_WRT(uri, routePrefix);
} else {
ZEPHIR_CPY_WRT(uri, value);
}
}
} else {
ZEPHIR_INIT_NVAR(uri);
ZEPHIR_CONCAT_VV(uri, routePrefix, actionName);
}
ZEPHIR_CALL_METHOD(&route, this_ptr, "add", NULL, 0, uri, paths);
zephir_check_call_status();
if (Z_TYPE_P(methods) != IS_NULL) {
ZEPHIR_CALL_METHOD(NULL, route, "via", NULL, 0, methods);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "methods", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&methods, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(methods) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(NULL, route, "via", NULL, 0, methods);
zephir_check_call_status();
} else {
if (Z_TYPE_P(methods) == IS_STRING) {
ZEPHIR_CALL_METHOD(NULL, route, "via", NULL, 0, methods);
zephir_check_call_status();
}
}
}
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "converts", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&converts, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(converts) == IS_ARRAY) {
zephir_is_iterable(converts, &_5, &_4, 0, 0, "phalcon/mvc/router/annotations.zep", 360);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HMKEY(param, _5, _4);
ZEPHIR_GET_HVALUE(convert, _6);
ZEPHIR_CALL_METHOD(NULL, route, "convert", &_7, 0, param, convert);
zephir_check_call_status();
}
}
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "conversors", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&converts, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(converts) == IS_ARRAY) {
zephir_is_iterable(converts, &_9, &_8, 0, 0, "phalcon/mvc/router/annotations.zep", 370);
for (
; zephir_hash_get_current_data_ex(_9, (void**) &_10, &_8) == SUCCESS
; zephir_hash_move_forward_ex(_9, &_8)
) {
ZEPHIR_GET_HMKEY(conversorParam, _9, _8);
ZEPHIR_GET_HVALUE(convert, _10);
ZEPHIR_CALL_METHOD(NULL, route, "convert", &_11, 0, conversorParam, convert);
zephir_check_call_status();
}
}
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "beforeMatch", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&beforeMatch, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
_12 = Z_TYPE_P(beforeMatch) == IS_ARRAY;
if (!(_12)) {
_12 = Z_TYPE_P(beforeMatch) == IS_STRING;
}
if (_12) {
ZEPHIR_CALL_METHOD(NULL, route, "beforematch", NULL, 0, beforeMatch);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "name", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&routeName, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(routeName) == IS_STRING) {
ZEPHIR_CALL_METHOD(NULL, route, "setname", NULL, 0, routeName);
zephir_check_call_status();
}
RETURN_MM_BOOL(1);
}
ZEPHIR_MM_RESTORE();
}
/**
* Add a text to an image with a specified opacity
*/
PHP_METHOD(Phalcon_Image_Adapter, text) {
zend_bool _0;
int opacity, size, ZEPHIR_LAST_CALL_STATUS;
zval *text_param = NULL, *offsetX = NULL, *offsetY = NULL, *opacity_param = NULL, *color_param = NULL, *size_param = NULL, *fontfile_param = NULL, *colors = NULL, _1, _2, *_3, _4 = zval_used_for_init, *_5 = NULL, *_6 = NULL, *_7 = NULL, *_8, *_9, *_10;
zval *text = NULL, *color = NULL, *fontfile = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 6, &text_param, &offsetX, &offsetY, &opacity_param, &color_param, &size_param, &fontfile_param);
zephir_get_strval(text, text_param);
if (!offsetX) {
offsetX = ZEPHIR_GLOBAL(global_false);
}
if (!offsetY) {
offsetY = ZEPHIR_GLOBAL(global_false);
}
if (!opacity_param) {
opacity = 100;
} else {
opacity = zephir_get_intval(opacity_param);
}
if (!color_param) {
ZEPHIR_INIT_VAR(color);
ZVAL_STRING(color, "000000", 1);
} else {
zephir_get_strval(color, color_param);
}
if (!size_param) {
size = 12;
} else {
size = zephir_get_intval(size_param);
}
if (!fontfile_param) {
ZEPHIR_INIT_VAR(fontfile);
ZVAL_EMPTY_STRING(fontfile);
} else {
zephir_get_strval(fontfile, fontfile_param);
}
if (opacity < 0) {
opacity = 0;
} else {
if (opacity > 100) {
opacity = 100;
}
}
_0 = zephir_fast_strlen_ev(color) > 1;
if (_0) {
ZEPHIR_SINIT_VAR(_1);
ZVAL_LONG(&_1, 0);
ZEPHIR_SINIT_VAR(_2);
ZVAL_LONG(&_2, 1);
ZEPHIR_INIT_VAR(_3);
zephir_substr(_3, color, 0 , 1 , 0);
_0 = ZEPHIR_IS_STRING_IDENTICAL(_3, "#");
}
if (_0) {
ZEPHIR_SINIT_VAR(_4);
ZVAL_LONG(&_4, 1);
ZEPHIR_INIT_VAR(_5);
zephir_substr(_5, color, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
zephir_get_strval(color, _5);
}
if (zephir_fast_strlen_ev(color) == 3) {
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRING(_5, "/./", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_6);
ZVAL_STRING(_6, "$0$0", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_FUNCTION(&_7, "preg_replace", NULL, 29, _5, _6, color);
zephir_check_temp_parameter(_5);
zephir_check_temp_parameter(_6);
zephir_check_call_status();
zephir_get_strval(color, _7);
}
ZEPHIR_SINIT_NVAR(_4);
ZVAL_LONG(&_4, 2);
ZEPHIR_CALL_FUNCTION(&_7, "str_split", NULL, 69, color, &_4);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_4);
ZVAL_STRING(&_4, "hexdec", 0);
ZEPHIR_CALL_FUNCTION(&colors, "array_map", NULL, 70, &_4, _7);
zephir_check_call_status();
zephir_array_fetch_long(&_8, colors, 0, PH_NOISY | PH_READONLY, "phalcon/image/adapter.zep", 335 TSRMLS_CC);
zephir_array_fetch_long(&_9, colors, 1, PH_NOISY | PH_READONLY, "phalcon/image/adapter.zep", 335 TSRMLS_CC);
zephir_array_fetch_long(&_10, colors, 2, PH_NOISY | PH_READONLY, "phalcon/image/adapter.zep", 335 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_5);
ZVAL_LONG(_5, opacity);
ZEPHIR_INIT_NVAR(_6);
ZVAL_LONG(_6, size);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_text", NULL, 0, text, offsetX, offsetY, _5, _8, _9, _10, _6, fontfile);
zephir_check_call_status();
RETURN_THIS();
}
/**
* Handles uncaught exceptions
*
* @param \Exception $exception
* @return boolean
*/
PHP_METHOD(Phalcon_Debug, onUncaughtException){
zval *exception, *is_active = NULL, *message = NULL;
zval *class_name, *css_sources = NULL, *escaped_message = NULL;
zval *html, *version = NULL, *file = NULL, *line = NULL, *show_back_trace;
zval *data_vars, *trace = NULL, *trace_item = NULL, *n = NULL, *html_item = NULL;
zval *_REQUEST, *value = NULL, *key_request = NULL, *joined_value = NULL, *_SERVER;
zval *key_server = NULL, *files = NULL, *key_file = NULL;
zval *memory, *data_var = NULL, *key_var = NULL, *variable = NULL, *dumped_argument = NULL;
zval *js_sources = NULL, *formatted_file = NULL;
HashTable *ah0, *ah1, *ah2, *ah3, *ah4;
HashPosition hp0, hp1, hp2, hp3, hp4;
zval **hd;
char* link_format;
zend_bool ini_exists = 1;
zval z_link_format = zval_used_for_init;
zend_class_entry *ce;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &exception);
PHALCON_VERIFY_CLASS_EX(exception, zend_exception_get_default(TSRMLS_C), phalcon_exception_ce, 1);
/**
* Cancel the output buffer if active
*/
if (phalcon_ob_get_level(TSRMLS_C) > 0) {
phalcon_ob_end_clean(TSRMLS_C);
}
is_active = phalcon_fetch_static_property_ce(phalcon_debug_ce, SL("_isActive") TSRMLS_CC);
/**
* Avoid that multiple exceptions being showed
*/
if (zend_is_true(is_active)) {
PHALCON_CALL_METHOD(&message, exception, "getmessage");
zend_print_zval(message, 0);
}
/**
* Globally block the debug component to avoid other exceptions must be shown
*/
zend_update_static_property_bool(phalcon_debug_ce, SL("_isActive"), 1 TSRMLS_CC);
PHALCON_INIT_VAR(class_name);
ce = Z_OBJCE_P(exception);
ZVAL_STRINGL(class_name, ce->name, ce->name_length, !IS_INTERNED(ce->name));
PHALCON_CALL_METHOD(&message, exception, "getmessage");
/**
* CSS static sources to style the error presentation
*/
PHALCON_CALL_METHOD(&css_sources, this_ptr, "getcsssources");
/**
* Escape the exception's message avoiding possible XSS injections?
*/
PHALCON_CPY_WRT(escaped_message, message);
/**
* Use the exception info as document's title
*/
PHALCON_INIT_VAR(html);
PHALCON_CONCAT_SVSVS(html, "<html><head><meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\"/><title>", class_name, ": ", escaped_message, "</title>");
PHALCON_SCONCAT_VS(html, css_sources, "</head><body>");
/**
* Get the version link
*/
PHALCON_CALL_METHOD(&version, this_ptr, "getversion");
phalcon_concat_self(&html, version TSRMLS_CC);
PHALCON_CALL_METHOD(&file, exception, "getfile");
PHALCON_CALL_METHOD(&line, exception, "getline");
link_format = zend_ini_string_ex(SS("xdebug.file_link_format"), 0, &ini_exists);
if (!link_format || !ini_exists || !strlen(link_format)) {
link_format = "file://%f#%l";
}
ZVAL_STRING(&z_link_format, link_format, 0);
PHALCON_CALL_METHOD(&formatted_file, getThis(), "getfilelink", file, line, &z_link_format);
/**
* Main exception info
*/
phalcon_concat_self_str(&html, SL("<div align=\"center\"><div class=\"error-main\">") TSRMLS_CC);
PHALCON_SCONCAT_SVSVS(html, "<h1>", class_name, ": ", escaped_message, "</h1>");
PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-file\">", formatted_file, " (", line, ")</span>");
phalcon_concat_self_str(&html, SL("</div>") TSRMLS_CC);
PHALCON_OBS_VAR(show_back_trace);
phalcon_read_property_this(&show_back_trace, this_ptr, SL("_showBackTrace"), PH_NOISY TSRMLS_CC);
/**
* Check if the developer wants to show the backtrace or not
*/
if (zend_is_true(show_back_trace)) {
PHALCON_OBS_VAR(data_vars);
phalcon_read_property_this(&data_vars, this_ptr, SL("_data"), PH_NOISY TSRMLS_CC);
/**
* Create the tabs in the page
*/
phalcon_concat_self_str(&html, SL("<div class=\"error-info\"><div id=\"tabs\"><ul>") TSRMLS_CC);
phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-1\">Backtrace</a></li>") TSRMLS_CC);
phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-2\">Request</a></li>") TSRMLS_CC);
phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-3\">Server</a></li>") TSRMLS_CC);
phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-4\">Included Files</a></li>") TSRMLS_CC);
phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-5\">Memory</a></li>") TSRMLS_CC);
if (Z_TYPE_P(data_vars) == IS_ARRAY) {
phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-6\">Variables</a></li>") TSRMLS_CC);
}
phalcon_concat_self_str(&html, SL("</ul>") TSRMLS_CC);
/**
* Print backtrace
*/
phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-1\"><table cellspacing=\"0\" align=\"center\" width=\"100%\">") TSRMLS_CC);
PHALCON_CALL_METHOD(&trace, exception, "gettrace");
phalcon_is_iterable(trace, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(n, ah0, hp0);
PHALCON_GET_HVALUE(trace_item);
/**
* Every line in the trace is rendered using 'showTraceItem'
*/
PHALCON_CALL_METHOD(&html_item, this_ptr, "showtraceitem", n, trace_item, &z_link_format);
phalcon_concat_self(&html, html_item TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
}
phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
/**
* Print _REQUEST superglobal
*/
phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-2\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC);
phalcon_concat_self_str(&html, SL("<tr><th>Key</th><th>Value</th></tr>") TSRMLS_CC);
_REQUEST = phalcon_get_global(SS("_REQUEST") TSRMLS_CC);
if (Z_TYPE_P(_REQUEST) == IS_ARRAY) {
phalcon_is_iterable(_REQUEST, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HKEY(key_request, ah1, hp1);
PHALCON_GET_HVALUE(value);
if (Z_TYPE_P(value) == IS_ARRAY) {
PHALCON_CALL_METHOD(&joined_value, this_ptr, "_getvardump", value);
PHALCON_SCONCAT_SVSVS(html, "<tr><td class=\"key\">", key_request, "</td><td>", joined_value, "</td></tr>");
} else {
PHALCON_SCONCAT_SVSVS(html, "<tr><td class=\"key\">", key_request, "</td><td>", value, "</td></tr>");
}
zend_hash_move_forward_ex(ah1, &hp1);
}
}
phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
/**
* Print _SERVER superglobal
*/
phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-3\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC);
phalcon_concat_self_str(&html, SL("<tr><th>Key</th><th>Value</th></tr>") TSRMLS_CC);
_SERVER = phalcon_get_global(SS("_SERVER") TSRMLS_CC);
if (Z_TYPE_P(_SERVER) == IS_ARRAY) {
phalcon_is_iterable(_SERVER, &ah2, &hp2, 0, 0);
while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) {
PHALCON_GET_HKEY(key_server, ah2, hp2);
PHALCON_GET_HVALUE(value);
PHALCON_CALL_METHOD(&dumped_argument, this_ptr, "_getvardump", value);
PHALCON_SCONCAT_SVSVS(html, "<tr><td class=\"key\">", key_server, "</td><td>", dumped_argument, "</td></tr>");
zend_hash_move_forward_ex(ah2, &hp2);
}
}
phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
/**
* Show included files
*/
PHALCON_CALL_FUNCTION(&files, "get_included_files");
phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-4\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC);
phalcon_concat_self_str(&html, SL("<tr><th>#</th><th>Path</th></tr>") TSRMLS_CC);
phalcon_is_iterable(files, &ah3, &hp3, 0, 0);
while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) {
PHALCON_GET_HKEY(key_file, ah3, hp3);
PHALCON_GET_HVALUE(value);
PHALCON_SCONCAT_SVSVS(html, "<tr><td>", key_file, "</th><td>", value, "</td></tr>");
zend_hash_move_forward_ex(ah3, &hp3);
}
phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
/**
* Memory usage
*/
PHALCON_INIT_VAR(memory);
ZVAL_LONG(memory, zend_memory_usage(1 TSRMLS_CC));
phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-5\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC);
PHALCON_SCONCAT_SVS(html, "<tr><th colspan=\"2\">Memory</th></tr><tr><td>Usage</td><td>", memory, "</td></tr>");
phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
/**
* Print extra variables passed to the component
*/
if (Z_TYPE_P(data_vars) == IS_ARRAY) {
phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-6\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC);
phalcon_concat_self_str(&html, SL("<tr><th>Key</th><th>Value</th></tr>") TSRMLS_CC);
phalcon_is_iterable(data_vars, &ah4, &hp4, 0, 0);
while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) {
PHALCON_GET_HKEY(key_var, ah4, hp4);
PHALCON_GET_HVALUE(data_var);
PHALCON_OBS_NVAR(variable);
phalcon_array_fetch_long(&variable, data_var, 0, PH_NOISY);
PHALCON_CALL_METHOD(&dumped_argument, this_ptr, "_getvardump", variable);
PHALCON_SCONCAT_SVSVS(html, "<tr><td class=\"key\">", key_var, "</td><td>", dumped_argument, "</td></tr>");
zend_hash_move_forward_ex(ah4, &hp4);
}
phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
}
phalcon_concat_self_str(&html, SL("</div>") TSRMLS_CC);
}
/**
* Get Javascript sources
*/
PHALCON_CALL_METHOD(&js_sources, this_ptr, "getjssources");
PHALCON_SCONCAT_VS(html, js_sources, "</div></body></html>");
/**
* Print the HTML, @TODO, add an option to store the html
*/
zend_print_zval(html, 0);
/**
* Unlock the exception renderer
*/
zend_update_static_property_bool(phalcon_debug_ce, SL("_isActive"), 0 TSRMLS_CC);
RETURN_MM_TRUE;
}
PHP_METHOD(PhalconPlus_Db_Mysql, __construct) {
zval _9;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval name;
zval *di, di_sub, *name_param = NULL, config, dbConfig, _0, options, _3, _4, _5, _1$$3, _2$$4, _6$$5, _7$$5, _8$$5;
zval *this_ptr = getThis();
ZVAL_UNDEF(&di_sub);
ZVAL_UNDEF(&config);
ZVAL_UNDEF(&dbConfig);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&options);
ZVAL_UNDEF(&_3);
ZVAL_UNDEF(&_4);
ZVAL_UNDEF(&_5);
ZVAL_UNDEF(&_1$$3);
ZVAL_UNDEF(&_2$$4);
ZVAL_UNDEF(&_6$$5);
ZVAL_UNDEF(&_7$$5);
ZVAL_UNDEF(&_8$$5);
ZVAL_UNDEF(&name);
ZVAL_UNDEF(&_9);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &di, &name_param);
if (UNEXPECTED(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be of the type string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(name_param) == IS_STRING)) {
zephir_get_strval(&name, name_param);
} else {
ZEPHIR_INIT_VAR(&name);
ZVAL_EMPTY_STRING(&name);
}
ZEPHIR_INIT_VAR(&_0);
ZVAL_STRING(&_0, "config");
ZEPHIR_CALL_METHOD(&config, di, "get", NULL, 0, &_0);
zephir_check_call_status();
ZEPHIR_OBS_VAR(&dbConfig);
zephir_read_property_zval(&dbConfig, &config, &name, PH_NOISY_CC);
zephir_update_property_zval(this_ptr, SL("di"), di);
zephir_update_property_zval(this_ptr, SL("name"), &name);
if (zephir_isset_property(&dbConfig, SL("retryTimes"))) {
zephir_read_property(&_1$$3, &dbConfig, SL("retryTimes"), PH_NOISY_CC | PH_READONLY);
zephir_update_property_zval(this_ptr, SL("retryTimes"), &_1$$3);
}
if (zephir_isset_property(&dbConfig, SL("retryInterval"))) {
zephir_read_property(&_2$$4, &dbConfig, SL("retryInterval"), PH_NOISY_CC | PH_READONLY);
zephir_update_property_zval(this_ptr, SL("retryInterval"), &_2$$4);
}
ZEPHIR_INIT_VAR(&options);
zephir_create_array(&options, 3, 0 TSRMLS_CC);
zephir_read_property(&_3, &dbConfig, SL("charset"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_INIT_VAR(&_4);
ZEPHIR_CONCAT_SV(&_4, "SET NAMES ", &_3);
zephir_array_update_long(&options, 1002, &_4, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
ZEPHIR_OBS_VAR(&_5);
zephir_read_property(&_5, &dbConfig, SL("timeout"), PH_NOISY_CC);
zephir_array_update_long(&options, 2, &_5, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
add_index_long(&options, 3, 2);
if (zephir_isset_property(&dbConfig, SL("options"))) {
zephir_read_property(&_6$$5, &dbConfig, SL("options"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_CALL_METHOD(&_7$$5, &_6$$5, "toarray", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_8$$5);
zephir_add_function(&_8$$5, &_7$$5, &options);
zephir_update_property_zval(this_ptr, SL("options"), &_8$$5);
} else {
zephir_update_property_zval(this_ptr, SL("options"), &options);
}
ZEPHIR_INIT_VAR(&_9);
zephir_create_array(&_9, 6, 0 TSRMLS_CC);
ZEPHIR_OBS_NVAR(&_5);
zephir_read_property(&_5, &dbConfig, SL("host"), PH_NOISY_CC);
zephir_array_update_string(&_9, SL("host"), &_5, PH_COPY | PH_SEPARATE);
ZEPHIR_OBS_NVAR(&_5);
zephir_read_property(&_5, &dbConfig, SL("port"), PH_NOISY_CC);
zephir_array_update_string(&_9, SL("port"), &_5, PH_COPY | PH_SEPARATE);
ZEPHIR_OBS_NVAR(&_5);
zephir_read_property(&_5, &dbConfig, SL("username"), PH_NOISY_CC);
zephir_array_update_string(&_9, SL("username"), &_5, PH_COPY | PH_SEPARATE);
ZEPHIR_OBS_NVAR(&_5);
zephir_read_property(&_5, &dbConfig, SL("password"), PH_NOISY_CC);
zephir_array_update_string(&_9, SL("password"), &_5, PH_COPY | PH_SEPARATE);
ZEPHIR_OBS_NVAR(&_5);
zephir_read_property(&_5, &dbConfig, SL("dbname"), PH_NOISY_CC);
zephir_array_update_string(&_9, SL("dbname"), &_5, PH_COPY | PH_SEPARATE);
ZEPHIR_OBS_NVAR(&_5);
zephir_read_property(&_5, this_ptr, SL("options"), PH_NOISY_CC);
zephir_array_update_string(&_9, SL("options"), &_5, PH_COPY | PH_SEPARATE);
zephir_update_property_zval(this_ptr, SL("descriptor"), &_9);
ZEPHIR_MM_RESTORE();
}
/**
* Lists table references
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Reference[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeReferences){
zval *table = NULL, *schema = NULL, *dialect = NULL, *sql = NULL, *empty_arr = NULL, *references = NULL;
zval *fetch_assoc = NULL, *describe = NULL, *reference = NULL, *constraint_name = NULL, *constraint_id = NULL;
zval *referenced_schema = NULL, *referenced_table = NULL;
zval *reference_array = NULL, *column_name = NULL, *referenced_columns = NULL;
zval *reference_objects = NULL, *array_reference = NULL;
zval *name = NULL, *columns = NULL, *definition = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = 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|z", &table, &schema) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!schema) {
PHALCON_ALLOC_ZVAL_MM(schema);
ZVAL_NULL(schema);
}
PHALCON_INIT_VAR(dialect);
phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describereferences", table, schema, PH_NO_CHECK);
PHALCON_INIT_VAR(empty_arr);
array_init(empty_arr);
PHALCON_INIT_VAR(references);
array_init(references);
PHALCON_INIT_VAR(fetch_assoc);
phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SL("FETCH_ASSOC") TSRMLS_CC);
PHALCON_INIT_VAR(describe);
PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc, PH_NO_CHECK);
if (!phalcon_valid_foreach(describe TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(describe);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_VALUE(reference);
PHALCON_INIT_VAR(constraint_id);
PHALCON_INIT_VAR(constraint_name);
phalcon_array_fetch_string(&constraint_id, reference, SL("id"), PH_NOISY_CC);
PHALCON_CONCAT_SV(constraint_name, "foreign_key_", constraint_id);
eval_int = phalcon_array_isset(references, constraint_name);
if (!eval_int) {
PHALCON_INIT_VAR(referenced_schema);
ZVAL_STRING(referenced_schema, "main", 1);
PHALCON_INIT_VAR(referenced_table);
phalcon_array_fetch_string(&referenced_table, reference, SL("table"), PH_NOISY_CC);
PHALCON_INIT_VAR(reference_array);
array_init(reference_array);
phalcon_array_update_string(&reference_array, SL("referencedSchema"), &referenced_schema, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&reference_array, SL("referencedTable"), &referenced_table, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&reference_array, SL("columns"), &empty_arr, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&reference_array, SL("referencedColumns"), &empty_arr, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_zval(&references, constraint_name, &reference_array, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(column_name);
phalcon_array_fetch_string(&column_name, reference, SL("from"), PH_NOISY_CC);
if (Z_TYPE_P(references) == IS_ARRAY) {
PHALCON_INIT_VAR(t0);
phalcon_array_fetch(&t0, references, constraint_name, PH_SILENT_CC);
}
if (Z_REFCOUNT_P(t0) > 1) {
phalcon_array_update_zval(&references, constraint_name, &t0, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t0) != IS_ARRAY) {
convert_to_array(t0);
phalcon_array_update_zval(&references, constraint_name, &t0, PH_COPY TSRMLS_CC);
}
if (Z_TYPE_P(t0) == IS_ARRAY) {
PHALCON_INIT_VAR(t1);
phalcon_array_fetch_string(&t1, t0, SL("columns"), PH_SILENT_CC);
}
if (Z_REFCOUNT_P(t1) > 1) {
phalcon_array_update_string(&t0, SL("columns"), &t1, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t1) != IS_ARRAY) {
convert_to_array(t1);
phalcon_array_update_string(&t0, SL("columns"), &t1, PH_COPY TSRMLS_CC);
}
phalcon_array_append(&t1, column_name, 0 TSRMLS_CC);
PHALCON_INIT_VAR(referenced_columns);
phalcon_array_fetch_string(&referenced_columns, reference, SL("to"), PH_NOISY_CC);
if (Z_TYPE_P(references) == IS_ARRAY) {
PHALCON_INIT_VAR(t2);
phalcon_array_fetch(&t2, references, constraint_name, PH_SILENT_CC);
}
if (Z_REFCOUNT_P(t2) > 1) {
phalcon_array_update_zval(&references, constraint_name, &t2, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t2) != IS_ARRAY) {
convert_to_array(t2);
phalcon_array_update_zval(&references, constraint_name, &t2, PH_COPY TSRMLS_CC);
}
if (Z_TYPE_P(t2) == IS_ARRAY) {
PHALCON_INIT_VAR(t3);
phalcon_array_fetch_string(&t3, t2, SL("referencedColumns"), PH_SILENT_CC);
}
if (Z_REFCOUNT_P(t3) > 1) {
phalcon_array_update_string(&t2, SL("referencedColumns"), &t3, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t3) != IS_ARRAY) {
convert_to_array(t3);
phalcon_array_update_string(&t2, SL("referencedColumns"), &t3, PH_COPY TSRMLS_CC);
}
phalcon_array_append(&t3, referenced_columns, 0 TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
PHALCON_INIT_VAR(reference_objects);
array_init(reference_objects);
if (!phalcon_valid_foreach(references TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(references);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
ph_cycle_start_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto ph_cycle_end_1;
}
PHALCON_INIT_VAR(name);
PHALCON_GET_FOREACH_KEY(name, ah1, hp1);
PHALCON_GET_FOREACH_VALUE(array_reference);
PHALCON_INIT_VAR(referenced_schema);
phalcon_array_fetch_string(&referenced_schema, array_reference, SL("referencedSchema"), PH_NOISY_CC);
PHALCON_INIT_VAR(referenced_table);
phalcon_array_fetch_string(&referenced_table, array_reference, SL("referencedTable"), PH_NOISY_CC);
PHALCON_INIT_VAR(columns);
phalcon_array_fetch_string(&columns, array_reference, SL("columns"), PH_NOISY_CC);
PHALCON_INIT_VAR(referenced_columns);
phalcon_array_fetch_string(&referenced_columns, array_reference, SL("referencedColumns"), PH_NOISY_CC);
PHALCON_INIT_VAR(definition);
array_init(definition);
phalcon_array_update_string(&definition, SL("referencedSchema"), &referenced_schema, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("referencedTable"), &referenced_table, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("columns"), &columns, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("referencedColumns"), &referenced_columns, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(reference);
object_init_ex(reference, phalcon_db_reference_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(reference, "__construct", name, definition, PH_CHECK);
phalcon_array_update_zval(&reference_objects, name, &reference, PH_COPY | PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
goto ph_cycle_start_1;
ph_cycle_end_1:
RETURN_CTOR(reference_objects);}
/**
* Checks whether view exists on registered extensions and render it
*
* @param array $engines
* @param string $viewPath
* @param boolean $silence
* @param boolean $mustClean
* @param Phalcon\Cache\Backend $cache
*/
PHP_METHOD(Phalcon_Mvc_View, _engineRender){
zval *engines, *view_path, *silence, *must_clean;
zval *cache, *not_exists = NULL, *view_params, *views_dir;
zval *base_path, *views_dir_path, *events_manager;
zval *render_level, *cache_level, *enter_cache;
zval *is_started, *key = NULL, *view_options, *cache_options;
zval *cached_view, *is_fresh, *engine = NULL, *extension = NULL;
zval *view_engine_path = NULL, *event_name = NULL, *status = NULL;
zval *exception_message;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzzz", &engines, &view_path, &silence, &must_clean, &cache) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(not_exists);
ZVAL_BOOL(not_exists, 1);
PHALCON_INIT_VAR(view_params);
phalcon_read_property(&view_params, this_ptr, SL("_viewParams"), PH_NOISY_CC);
PHALCON_INIT_VAR(views_dir);
phalcon_read_property(&views_dir, this_ptr, SL("_viewsDir"), PH_NOISY_CC);
PHALCON_INIT_VAR(base_path);
phalcon_read_property(&base_path, this_ptr, SL("_basePath"), PH_NOISY_CC);
PHALCON_INIT_VAR(views_dir_path);
PHALCON_CONCAT_VVV(views_dir_path, base_path, views_dir, view_path);
PHALCON_INIT_VAR(events_manager);
phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(cache) == IS_OBJECT) {
PHALCON_INIT_VAR(render_level);
phalcon_read_property(&render_level, this_ptr, SL("_renderLevel"), PH_NOISY_CC);
PHALCON_INIT_VAR(cache_level);
phalcon_read_property(&cache_level, this_ptr, SL("_cacheLevel"), PH_NOISY_CC);
PHALCON_INIT_VAR(enter_cache);
is_smaller_or_equal_function(enter_cache, cache_level, render_level TSRMLS_CC);
if (zend_is_true(enter_cache)) {
PHALCON_INIT_VAR(is_started);
PHALCON_CALL_METHOD(is_started, cache, "isstarted", PH_NO_CHECK);
if (PHALCON_IS_FALSE(is_started)) {
PHALCON_INIT_VAR(key);
PHALCON_INIT_VAR(view_options);
phalcon_read_property(&view_options, this_ptr, SL("_options"), PH_NOISY_CC);
if (Z_TYPE_P(view_options) == IS_ARRAY) {
eval_int = phalcon_array_isset_string(view_options, SS("cache"));
if (eval_int) {
PHALCON_INIT_VAR(cache_options);
phalcon_array_fetch_string(&cache_options, view_options, SL("cache"), PH_NOISY_CC);
if (Z_TYPE_P(cache_options) == IS_ARRAY) {
eval_int = phalcon_array_isset_string(cache_options, SS("key"));
if (eval_int) {
phalcon_array_fetch_string(&key, cache_options, SL("key"), PH_NOISY_CC);
}
}
}
}
if (Z_TYPE_P(key) == IS_NULL) {
PHALCON_INIT_NVAR(key);
PHALCON_CALL_FUNC_PARAMS_1(key, "md5", view_path);
}
PHALCON_INIT_VAR(cached_view);
PHALCON_CALL_METHOD_PARAMS_1(cached_view, cache, "start", key, PH_NO_CHECK);
if (Z_TYPE_P(cached_view) != IS_NULL) {
phalcon_update_property_zval(this_ptr, SL("_content"), cached_view TSRMLS_CC);
PHALCON_MM_RESTORE();
RETURN_NULL();
}
}
PHALCON_INIT_VAR(is_fresh);
PHALCON_CALL_METHOD(is_fresh, cache, "isfresh", PH_NO_CHECK);
if (!zend_is_true(is_fresh)) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
}
}
if (!phalcon_valid_foreach(engines TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(engines);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) {
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_KEY(extension, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(engine);
PHALCON_INIT_NVAR(view_engine_path);
PHALCON_CONCAT_VV(view_engine_path, views_dir_path, extension);
if (phalcon_file_exists(view_engine_path TSRMLS_CC) == SUCCESS) {
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_activeRenderPath"), view_engine_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "view:beforeRenderView", 1);
PHALCON_INIT_NVAR(status);
PHALCON_CALL_METHOD_PARAMS_3(status, events_manager, "fire", event_name, this_ptr, view_engine_path, PH_NO_CHECK);
if (PHALCON_IS_FALSE(status)) {
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
}
}
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(engine, "render", view_engine_path, view_params, must_clean, PH_NO_CHECK);
PHALCON_INIT_NVAR(not_exists);
ZVAL_BOOL(not_exists, 0);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_activeRenderPath"), view_engine_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "view:afterRenderView", 1);
PHALCON_INIT_NVAR(status);
PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", event_name, this_ptr, PH_NO_CHECK);
if (PHALCON_IS_FALSE(status)) {
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
}
}
goto ph_cycle_end_0;
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
if (PHALCON_IS_TRUE(not_exists)) {
if (!zend_is_true(silence)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "View '", views_dir_path, "' was not found in the views directory");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_view_exception_ce, exception_message);
return;
}
}
PHALCON_MM_RESTORE();
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_Digit, validate) {
zend_bool _2;
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *value = NULL, *message = NULL, *label = NULL, *replacePairs, *_0 = NULL, *_1 = NULL, *_3 = NULL, *_4 = NULL, *_5;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field_param);
if (unlikely(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(field_param) == IS_STRING)) {
zephir_get_strval(field, field_param);
} else {
ZEPHIR_INIT_VAR(field);
ZVAL_EMPTY_STRING(field);
}
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "allowEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "issetoption", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
_2 = zephir_is_true(_0);
if (_2) {
_2 = ZEPHIR_IS_EMPTY(value);
}
if (_2) {
RETURN_MM_BOOL(1);
}
ZEPHIR_CALL_FUNCTION(&_3, "ctype_digit", NULL, 428, value);
zephir_check_call_status();
if (!(zephir_is_true(_3))) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
ZEPHIR_INIT_VAR(replacePairs);
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "Digit", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_1);
object_init_ex(_1, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_4, "strtr", NULL, 73, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_5);
ZVAL_STRING(_5, "Digit", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 425, _4, field, _5);
zephir_check_temp_parameter(_5);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _1);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Process a request header and return an array of values with their qualities
*
* @param string $serverIndex
* @param string $name
* @return array
*/
PHP_METHOD(Phalcon_Http_Request, _getQualityHeader){
zval *server_index = NULL, *name = NULL, *quality_one = NULL, *returned_parts = NULL;
zval *http_server = NULL, *parts = NULL, *part = NULL, *header_parts = NULL;
zval *quality_part = NULL, *quality = NULL, *header_name = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &server_index, &name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(quality_one);
ZVAL_DOUBLE(quality_one, 1);
PHALCON_INIT_VAR(returned_parts);
array_init(returned_parts);
PHALCON_INIT_VAR(http_server);
PHALCON_CALL_METHOD_PARAMS_1(http_server, this_ptr, "getserver", server_index, PH_NO_CHECK);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "/,\\s*/", 1);
PHALCON_INIT_VAR(parts);
PHALCON_CALL_FUNC_PARAMS_2(parts, "preg_split", c0, http_server);
if (!phalcon_valid_foreach(parts TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(parts);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_ac06_2:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_ac06_2;
}
PHALCON_INIT_VAR(part);
ZVAL_ZVAL(part, *hd, 1, 0);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, ";", 1);
PHALCON_INIT_VAR(header_parts);
phalcon_fast_explode(header_parts, c1, part TSRMLS_CC);
eval_int = phalcon_array_isset_long(header_parts, 1);
if (eval_int) {
PHALCON_INIT_VAR(quality_part);
phalcon_array_fetch_long(&quality_part, header_parts, 1, PH_NOISY_CC);
PHALCON_INIT_VAR(c2);
ZVAL_LONG(c2, 2);
PHALCON_INIT_VAR(quality);
PHALCON_CALL_FUNC_PARAMS_2(quality, "substr", quality_part, c2);
} else {
PHALCON_CPY_WRT(quality, quality_one);
}
PHALCON_INIT_VAR(header_name);
phalcon_array_fetch_long(&header_name, header_parts, 0, PH_NOISY_CC);
PHALCON_INIT_VAR(quality_part);
array_init(quality_part);
phalcon_array_update_zval(&quality_part, name, &header_name, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&quality_part, SL("quality"), &quality, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&returned_parts, quality_part, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_ac06_2;
fee_ac06_2:
RETURN_CTOR(returned_parts);
}
/**
* Process a request header and return the one with best quality
*
* @param array $qualityParts
* @param string $name
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, _getBestQuality){
zval *quality_parts = NULL, *name = NULL, *i = NULL, *quality = NULL, *selected_name = NULL;
zval *accept = NULL, *accept_quality = NULL;
zval *r0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &quality_parts, &name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
PHALCON_INIT_VAR(quality);
ZVAL_LONG(quality, 0);
PHALCON_INIT_VAR(selected_name);
ZVAL_STRING(selected_name, "", 1);
if (!phalcon_valid_foreach(quality_parts TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(quality_parts);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_ac06_3:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_ac06_3;
}
PHALCON_INIT_VAR(accept);
ZVAL_ZVAL(accept, *hd, 1, 0);
if (phalcon_compare_strict_long(i, 0 TSRMLS_CC)) {
PHALCON_INIT_VAR(quality);
phalcon_array_fetch_string(&quality, accept, SL("quality"), PH_NOISY_CC);
PHALCON_INIT_VAR(selected_name);
phalcon_array_fetch(&selected_name, accept, name, PH_NOISY_CC);
} else {
PHALCON_INIT_VAR(accept_quality);
phalcon_array_fetch_string(&accept_quality, accept, SL("quality"), PH_NOISY_CC);
PHALCON_INIT_VAR(r0);
is_smaller_function(r0, quality, accept_quality TSRMLS_CC);
if (zend_is_true(r0)) {
PHALCON_CPY_WRT(quality, accept_quality);
PHALCON_INIT_VAR(selected_name);
phalcon_array_fetch(&selected_name, accept, name, PH_NOISY_CC);
}
}
PHALCON_SEPARATE(i);
increment_function(i);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_ac06_3;
fee_ac06_3:
RETURN_CCTOR(selected_name);
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_Confirmation, validate) {
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *fieldWith = NULL, *value = NULL, *valueWith = NULL, *message = NULL, *label = NULL, *labelWith = NULL, *replacePairs, *_0 = NULL, *_1 = NULL, *_2 = NULL, *_3;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field_param);
if (unlikely(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(field_param) == IS_STRING)) {
zephir_get_strval(field, field_param);
} else {
ZEPHIR_INIT_VAR(field);
ZVAL_EMPTY_STRING(field);
}
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "with", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&fieldWith, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&valueWith, validation, "getvalue", NULL, 0, fieldWith);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_1, this_ptr, "compare", NULL, 439, value, valueWith);
zephir_check_call_status();
if (!(zephir_is_true(_1))) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "labelWith", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&labelWith, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(labelWith)) {
ZEPHIR_CALL_METHOD(&labelWith, validation, "getlabel", NULL, 0, fieldWith);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(replacePairs);
zephir_create_array(replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":with"), &labelWith, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "Confirmation", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_0);
object_init_ex(_0, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_2, "strtr", NULL, 54, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_3);
ZVAL_STRING(_3, "Confirmation", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 436, _2, field, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _0);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Generates a URL
*
*<code>
*
* //Generate a URL appending the URI to the base URI
* echo $url->get('products/edit/1');
*
* //Generate a URL for a predefined route
* echo $url->get(array('for' => 'blog-post', 'title' => 'some-cool-stuff', 'year' => '2012'));
*
*</code>
*
* @param string|array $uri
* @param array|object args Optional arguments to be appended to the query string
* @param bool|null $local
* @return string
*/
PHP_METHOD(Phalcon_Mvc_Url, get){
zval **uri = NULL, *base_uri = NULL, *router = NULL, *dependency_injector;
zval *service, *route_name, *route = NULL, *exception_message;
zval *pattern = NULL, *paths = NULL, *processed_uri, **args = NULL, *query_string;
zval *matched, *regexp;
zval **z_local = NULL;
int local = 1;
phalcon_fetch_params_ex(0, 3, &uri, &args, &z_local);
PHALCON_MM_GROW();
if (!uri) {
uri = &PHALCON_GLOBAL(z_null);
}
else if (z_local && Z_TYPE_PP(z_local) != IS_NULL) {
if (!zend_is_true(*z_local)) {
local = 0;
}
}
else if (Z_TYPE_PP(uri) == IS_STRING && strstr(Z_STRVAL_PP(uri), ":")) {
PHALCON_INIT_VAR(matched);
PHALCON_INIT_VAR(regexp);
ZVAL_STRING(regexp, "/^[^:\\/?#]++:/", 1);
RETURN_MM_ON_FAILURE(phalcon_preg_match(matched, regexp, *uri, NULL TSRMLS_CC));
if (zend_is_true(matched)) {
local = 0;
}
}
PHALCON_CALL_METHOD(&base_uri, this_ptr, "getbaseuri");
if (Z_TYPE_PP(uri) == IS_ARRAY) {
if (!phalcon_array_isset_string_fetch(&route_name, *uri, SS("for"))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_url_exception_ce, "It's necessary to define the route name with the parameter \"for\"");
return;
}
router = phalcon_fetch_nproperty_this(this_ptr, SL("_router"), PH_NOISY TSRMLS_CC);
/**
* Check if the router has not previously set
*/
if (Z_TYPE_P(router) != IS_OBJECT) {
dependency_injector = phalcon_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY TSRMLS_CC);
if (!zend_is_true(dependency_injector)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_url_exception_ce, "A dependency injector container is required to obtain the \"url\" service");
return;
}
PHALCON_INIT_VAR(service);
PHALCON_ZVAL_MAYBE_INTERNED_STRING(service, phalcon_interned_router);
router = NULL;
PHALCON_CALL_METHOD(&router, dependency_injector, "getshared", service);
PHALCON_VERIFY_INTERFACE(router, phalcon_mvc_routerinterface_ce);
phalcon_update_property_this(this_ptr, SL("_router"), router TSRMLS_CC);
}
/**
* Every route is uniquely identified by a name
*/
PHALCON_CALL_METHOD(&route, router, "getroutebyname", route_name);
if (Z_TYPE_P(route) != IS_OBJECT) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Cannot obtain a route using the name \"", route_name, "\"");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_url_exception_ce, exception_message);
return;
}
PHALCON_CALL_METHOD(&pattern, route, "getpattern");
/**
* Return the reversed paths
*/
PHALCON_CALL_METHOD(&paths, route, "getreversedpaths");
/**
* Replace the patterns by its variables
*/
PHALCON_INIT_VAR(processed_uri);
phalcon_replace_paths(processed_uri, pattern, paths, *uri TSRMLS_CC);
PHALCON_CONCAT_VV(return_value, base_uri, processed_uri);
}
else {
if (local) {
PHALCON_CONCAT_VV(return_value, base_uri, *uri);
}
else {
ZVAL_ZVAL(return_value, *uri, 1, 0);
}
}
if (args) {
PHALCON_INIT_VAR(query_string);
phalcon_http_build_query(query_string, *args, "&" TSRMLS_CC);
if (Z_TYPE_P(query_string) == IS_STRING && Z_STRLEN_P(query_string)) {
if (phalcon_memnstr_str(return_value, "?", 1)) {
PHALCON_SCONCAT_SV(return_value, "&", query_string);
}
else {
PHALCON_SCONCAT_SV(return_value, "?", query_string);
}
}
}
RETURN_MM();
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_StringLength, validate) {
zend_bool _1;
zephir_fcall_cache_entry *_10 = NULL, *_12 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *isSetMin = NULL, *isSetMax = NULL, *value = NULL, *length = NULL, *message = NULL, *minimum = NULL, *maximum = NULL, *label = NULL, *replacePairs = NULL, *code = NULL, *_0 = NULL, *_2$$4, *_3$$6, *_4$$9, *_5$$10, *_6$$11 = NULL, *_9$$11 = NULL, *_11$$11, *_7$$12, *_8$$13, *_13$$14, *_14$$15, *_15$$16 = NULL, *_18$$16 = NULL, *_19$$16, *_16$$17, *_17$$18;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field_param);
if (unlikely(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(field_param) == IS_STRING)) {
zephir_get_strval(field, field_param);
} else {
ZEPHIR_INIT_VAR(field);
ZVAL_EMPTY_STRING(field);
}
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "min", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&isSetMin, this_ptr, "hasoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "max", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&isSetMax, this_ptr, "hasoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
_1 = !zephir_is_true(isSetMin);
if (_1) {
_1 = !zephir_is_true(isSetMax);
}
if (_1) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "A minimum or maximum must be set", "phalcon/validation/validator/stringlength.zep", 92);
return;
}
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (Z_TYPE_P(label) == IS_ARRAY) {
zephir_array_fetch(&_2$$4, label, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/stringlength.zep", 98 TSRMLS_CC);
ZEPHIR_CPY_WRT(label, _2$$4);
}
if (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "code", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&code, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (Z_TYPE_P(code) == IS_ARRAY) {
zephir_array_fetch(&_3$$6, code, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/stringlength.zep", 106 TSRMLS_CC);
ZEPHIR_CPY_WRT(code, _3$$6);
}
if ((zephir_function_exists_ex(SS("mb_strlen") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_FUNCTION(&length, "mb_strlen", NULL, 382, value);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(length);
ZVAL_LONG(length, zephir_fast_strlen_ev(value));
}
if (zephir_is_true(isSetMax)) {
ZEPHIR_INIT_VAR(_4$$9);
ZVAL_STRING(_4$$9, "max", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&maximum, this_ptr, "getoption", NULL, 0, _4$$9);
zephir_check_temp_parameter(_4$$9);
zephir_check_call_status();
if (Z_TYPE_P(maximum) == IS_ARRAY) {
zephir_array_fetch(&_5$$10, maximum, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/stringlength.zep", 123 TSRMLS_CC);
ZEPHIR_CPY_WRT(maximum, _5$$10);
}
if (ZEPHIR_GT(length, maximum)) {
ZEPHIR_INIT_VAR(_6$$11);
ZVAL_STRING(_6$$11, "messageMaximum", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _6$$11);
zephir_check_temp_parameter(_6$$11);
zephir_check_call_status();
ZEPHIR_INIT_VAR(replacePairs);
zephir_create_array(replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":max"), &maximum, PH_COPY | PH_SEPARATE);
if (Z_TYPE_P(message) == IS_ARRAY) {
zephir_array_fetch(&_7$$12, message, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/stringlength.zep", 132 TSRMLS_CC);
ZEPHIR_CPY_WRT(message, _7$$12);
}
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_VAR(_8$$13);
ZVAL_STRING(_8$$13, "TooLong", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _8$$13);
zephir_check_temp_parameter(_8$$13);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_6$$11);
object_init_ex(_6$$11, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_9$$11, "strtr", &_10, 26, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_11$$11);
ZVAL_STRING(_11$$11, "TooLong", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _6$$11, "__construct", &_12, 466, _9$$11, field, _11$$11, code);
zephir_check_temp_parameter(_11$$11);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _6$$11);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
if (zephir_is_true(isSetMin)) {
ZEPHIR_INIT_VAR(_13$$14);
ZVAL_STRING(_13$$14, "min", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&minimum, this_ptr, "getoption", NULL, 0, _13$$14);
zephir_check_temp_parameter(_13$$14);
zephir_check_call_status();
if (Z_TYPE_P(minimum) == IS_ARRAY) {
zephir_array_fetch(&_14$$15, minimum, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/stringlength.zep", 159 TSRMLS_CC);
ZEPHIR_CPY_WRT(minimum, _14$$15);
}
if (ZEPHIR_LT(length, minimum)) {
ZEPHIR_INIT_VAR(_15$$16);
ZVAL_STRING(_15$$16, "messageMinimum", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _15$$16);
zephir_check_temp_parameter(_15$$16);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(replacePairs);
zephir_create_array(replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":min"), &minimum, PH_COPY | PH_SEPARATE);
if (Z_TYPE_P(message) == IS_ARRAY) {
zephir_array_fetch(&_16$$17, message, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/stringlength.zep", 168 TSRMLS_CC);
ZEPHIR_CPY_WRT(message, _16$$17);
}
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_VAR(_17$$18);
ZVAL_STRING(_17$$18, "TooShort", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _17$$18);
zephir_check_temp_parameter(_17$$18);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_15$$16);
object_init_ex(_15$$16, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_18$$16, "strtr", &_10, 26, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_19$$16);
ZVAL_STRING(_19$$16, "TooShort", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _15$$16, "__construct", &_12, 466, _18$$16, field, _19$$16, code);
zephir_check_temp_parameter(_19$$16);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _15$$16);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
RETURN_MM_BOOL(1);
}
/**
* Traverses a collection calling the callback to generate its HTML
*
* @param Phalcon\Assets\Collection $collection
* @param callback $callback
* @param string $type
*/
PHP_METHOD(Phalcon_Assets_Manager, output){
zval *collection, *callback, *type = NULL, *output, *use_implicit_output;
zval *resources = NULL, *filters = NULL, *prefix = NULL, *source_base_path = NULL;
zval *target_base_path = NULL, *options, *collection_source_path = NULL;
zval *complete_source_path = NULL, *collection_target_path = NULL;
zval *complete_target_path = NULL, *filtered_joined_content = NULL;
zval *join = NULL, *exception_message = NULL, *is_directory;
zval *resource = NULL, *filter_needed = NULL, *local = NULL, *source_path = NULL;
zval *target_path = NULL, *path = NULL, *prefixed_path = NULL, *attributes = NULL;
zval *parameters = NULL, *html = NULL, *content = NULL, *must_filter = NULL;
zval *filter = NULL, *filtered_content = NULL, *target_uri = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
zval *type_css;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 1, &collection, &callback, &type);
PHALCON_INIT_VAR(output);
PHALCON_OBS_VAR(use_implicit_output);
phalcon_read_property_this(&use_implicit_output, this_ptr, SL("_implicitOutput"), PH_NOISY TSRMLS_CC);
/**
* Get the resources as an array
*/
PHALCON_CALL_METHOD(&resources, collection, "getresources");
/**
* Get filters in the collection
*/
PHALCON_CALL_METHOD(&filters, collection, "getfilters");
/**
* Get the collection's prefix
*/
PHALCON_CALL_METHOD(&prefix, collection, "getprefix");
PHALCON_INIT_VAR(type_css);
ZVAL_STRING(type_css, "css", 1);
/**
* Prepare options if the collection must be filtered
*/
if (Z_TYPE_P(filters) == IS_ARRAY) {
PHALCON_INIT_VAR(source_base_path);
PHALCON_INIT_VAR(target_base_path);
PHALCON_OBS_VAR(options);
phalcon_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY TSRMLS_CC);
/**
* Check for global options in the assets manager
*/
if (Z_TYPE_P(options) == IS_ARRAY) {
/**
* The source base path is a global location where all resources are located
*/
if (phalcon_array_isset_string(options, SS("sourceBasePath"))) {
PHALCON_OBS_NVAR(source_base_path);
phalcon_array_fetch_string(&source_base_path, options, SL("sourceBasePath"), PH_NOISY);
}
/**
* The target base path is a global location where all resources are written
*/
if (phalcon_array_isset_string(options, SS("targetBasePath"))) {
PHALCON_OBS_NVAR(target_base_path);
phalcon_array_fetch_string(&target_base_path, options, SL("targetBasePath"), PH_NOISY);
}
}
/**
* Check if the collection have its own source base path
*/
PHALCON_CALL_METHOD(&collection_source_path, collection, "getsourcepath");
/**
* Concatenate the global base source path with the collection one
*/
if (PHALCON_IS_NOT_EMPTY(collection_source_path)) {
PHALCON_INIT_VAR(complete_source_path);
PHALCON_CONCAT_VV(complete_source_path, source_base_path, collection_source_path);
} else {
PHALCON_CPY_WRT(complete_source_path, source_base_path);
}
/**
* Check if the collection have its own target base path
*/
PHALCON_CALL_METHOD(&collection_target_path, collection, "gettargetpath");
/**
* Concatenate the global base source path with the collection one
*/
if (PHALCON_IS_NOT_EMPTY(collection_target_path)) {
PHALCON_INIT_VAR(complete_target_path);
PHALCON_CONCAT_VV(complete_target_path, target_base_path, collection_target_path);
} else {
PHALCON_CPY_WRT(complete_target_path, target_base_path);
}
/**
* Global filtered content
*/
PHALCON_INIT_VAR(filtered_joined_content);
/**
* Check if all the resources in the collection must be joined
*/
PHALCON_CALL_METHOD(&join, collection, "getjoin");
/**
* Check for valid target paths if the collection must be joined
*/
if (zend_is_true(join)) {
/**
* We need a valid final target path
*/
if (PHALCON_IS_EMPTY(complete_target_path)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Path '", complete_target_path, "' is not a valid target path (1)");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message);
return;
}
PHALCON_INIT_VAR(is_directory);
phalcon_is_dir(is_directory, complete_target_path TSRMLS_CC);
/**
* The targetpath needs to be a valid file
*/
if (PHALCON_IS_TRUE(is_directory)) {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Path '", complete_target_path, "' is not a valid target path (2)");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message);
return;
}
}
}
phalcon_is_iterable(resources, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(resource);
PHALCON_INIT_NVAR(filter_needed);
ZVAL_FALSE(filter_needed);
if (!type) {
PHALCON_CALL_METHOD(&type, resource, "gettype");
}
/**
* Is the resource local?
*/
PHALCON_CALL_METHOD(&local, resource, "getlocal");
/**
* If the collection must not be joined we must print a HTML for each one
*/
if (Z_TYPE_P(filters) == IS_ARRAY) {
if (zend_is_true(local)) {
/**
* Get the complete path
*/
PHALCON_CALL_METHOD(&source_path, resource, "getrealsourcepath", complete_source_path);
/**
* We need a valid source path
*/
if (!zend_is_true(source_path)) {
PHALCON_CALL_METHOD(&source_path, resource, "getpath");
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Resource '", source_path, "' does not have a valid source path");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message);
return;
}
} else {
/**
* Get the complete source path
*/
PHALCON_CALL_METHOD(&source_path, resource, "getpath");
/**
* resources paths are always filtered
*/
PHALCON_INIT_NVAR(filter_needed);
ZVAL_TRUE(filter_needed);
}
/**
* Get the target path, we need to write the filtered content to a file
*/
PHALCON_CALL_METHOD(&target_path, resource, "getrealtargetpath", complete_target_path);
/**
* We need a valid final target path
*/
if (PHALCON_IS_EMPTY(target_path)) {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Resource '", source_path, "' does not have a valid target path");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message);
return;
}
if (zend_is_true(local)) {
/**
* Make sure the target path is not the same source path
*/
if (PHALCON_IS_EQUAL(target_path, source_path)) {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Resource '", target_path, "' have the same source and target paths");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message);
return;
}
if (phalcon_file_exists(target_path TSRMLS_CC) == SUCCESS) {
if (phalcon_compare_mtime(target_path, source_path TSRMLS_CC)) {
PHALCON_INIT_NVAR(filter_needed);
ZVAL_TRUE(filter_needed);
}
} else {
PHALCON_INIT_NVAR(filter_needed);
ZVAL_TRUE(filter_needed);
}
}
}
/**
* If there are no filters, just print/buffer the HTML
*/
if (Z_TYPE_P(filters) != IS_ARRAY) {
PHALCON_CALL_METHOD(&path, resource, "getrealtargeturi");
if (Z_TYPE_P(prefix) != IS_NULL) {
PHALCON_INIT_NVAR(prefixed_path);
PHALCON_CONCAT_VV(prefixed_path, prefix, path);
} else {
PHALCON_CPY_WRT(prefixed_path, path);
}
/**
* Gets extra HTML attributes in the resource
*/
PHALCON_CALL_METHOD(&attributes, resource, "getattributes");
/**
* Prepare the parameters for the callback
*/
PHALCON_INIT_NVAR(parameters);
array_init_size(parameters, 2);
if (Z_TYPE_P(attributes) == IS_ARRAY) {
phalcon_array_update_long(&attributes, 0, prefixed_path, PH_COPY | PH_SEPARATE);
phalcon_array_append(¶meters, attributes, 0);
} else {
phalcon_array_append(¶meters, prefixed_path, 0);
}
phalcon_array_append(¶meters, local, 0);
/**
* Call the callback to generate the HTML
*/
PHALCON_INIT_NVAR(html);/**/
PHALCON_CALL_USER_FUNC_ARRAY(html, callback, parameters);
/**
* Implicit output prints the content directly
*/
if (zend_is_true(use_implicit_output)) {
zend_print_zval(html, 0);
} else {
phalcon_concat_self(&output, html TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
if (zend_is_true(filter_needed)) {
/**
* Get the resource's content
*/
PHALCON_CALL_METHOD(&content, resource, "getcontent", complete_source_path);
/**
* Check if the resource must be filtered
*/
PHALCON_CALL_METHOD(&must_filter, resource, "getfilter");
/**
* Only filter the resource if it's marked as 'filterable'
*/
if (zend_is_true(must_filter)) {
phalcon_is_iterable(filters, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HVALUE(filter);
/**
* Filters must be valid objects
*/
if (Z_TYPE_P(filter) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_assets_exception_ce, "Filter is invalid");
return;
}
/**
* Calls the method 'filter' which must return a filtered version of the content
*/
PHALCON_CALL_METHOD(&filtered_content, filter, "filter", content);
PHALCON_CPY_WRT_CTOR(content, filtered_content);
zend_hash_move_forward_ex(ah1, &hp1);
}
/**
* Update the joined filtered content
*/
if (zend_is_true(join)) {
if (PHALCON_IS_EQUAL(type, type_css)) {
if (Z_TYPE_P(filtered_joined_content) == IS_NULL) {
PHALCON_INIT_NVAR(filtered_joined_content);
PHALCON_CONCAT_VS(filtered_joined_content, content, "");
} else {
PHALCON_SCONCAT_VS(filtered_joined_content, content, "");
}
} else {
if (Z_TYPE_P(filtered_joined_content) == IS_NULL) {
PHALCON_INIT_NVAR(filtered_joined_content);
PHALCON_CONCAT_VS(filtered_joined_content, content, ";");
} else {
PHALCON_SCONCAT_VS(filtered_joined_content, content, ";");
}
}
}
} else {
/**
* Update the joined filtered content
*/
if (zend_is_true(join)) {
if (Z_TYPE_P(filtered_joined_content) == IS_NULL) {
PHALCON_CPY_WRT(filtered_joined_content, content);
} else {
phalcon_concat_self(&filtered_joined_content, content TSRMLS_CC);
}
} else {
PHALCON_CPY_WRT(filtered_content, content);
}
}
if (!zend_is_true(join)) {
/**
* Write the file using file-put-contents. This respects the openbase-dir also
* writes to streams
*/
phalcon_file_put_contents(NULL, target_path, filtered_content TSRMLS_CC);
}
}
if (!zend_is_true(join)) {
/**
* Generate the HTML using the original path in the resource
*/
PHALCON_CALL_METHOD(&path, resource, "getrealtargeturi");
if (Z_TYPE_P(prefix) != IS_NULL) {
PHALCON_INIT_NVAR(prefixed_path);
PHALCON_CONCAT_VV(prefixed_path, prefix, path);
} else {
PHALCON_CPY_WRT(prefixed_path, path);
}
/**
* Gets extra HTML attributes in the resource
*/
PHALCON_CALL_METHOD(&attributes, resource, "getattributes");
/**
* Filtered resources are always local
*/
PHALCON_INIT_NVAR(local);
ZVAL_TRUE(local);
/**
* Prepare the parameters for the callback
*/
PHALCON_INIT_NVAR(parameters);
array_init_size(parameters, 2);
if (Z_TYPE_P(attributes) == IS_ARRAY) {
phalcon_array_update_long(&attributes, 0, prefixed_path, PH_COPY | PH_SEPARATE);
phalcon_array_append(¶meters, attributes, 0);
} else {
phalcon_array_append(¶meters, prefixed_path, 0);
}
phalcon_array_append(¶meters, local, 0);
/**
* Call the callback to generate the HTML
*/
PHALCON_INIT_NVAR(html);/**/
PHALCON_CALL_USER_FUNC_ARRAY(html, callback, parameters);
/**
* Implicit output prints the content directly
*/
if (zend_is_true(use_implicit_output)) {
zend_print_zval(html, 0);
} else {
phalcon_concat_self(&output, html TSRMLS_CC);
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
if (Z_TYPE_P(filters) == IS_ARRAY) {
if (zend_is_true(join)) {
/**
* Write the file using file_put_contents. This respects the openbase-dir also
* writes to streams
*/
phalcon_file_put_contents(NULL, complete_target_path, filtered_joined_content TSRMLS_CC);
/**
* Generate the HTML using the original path in the resource
*/
PHALCON_CALL_METHOD(&target_uri, collection, "gettargeturi");
if (Z_TYPE_P(prefix) != IS_NULL) {
PHALCON_INIT_NVAR(prefixed_path);
PHALCON_CONCAT_VV(prefixed_path, prefix, target_uri);
} else {
PHALCON_CPY_WRT(prefixed_path, target_uri);
}
/**
* Gets extra HTML attributes in the resource
*/
PHALCON_CALL_METHOD(&attributes, collection, "getattributes");
PHALCON_CALL_METHOD(&local, collection, "gettargetlocal");
/**
* Prepare the parameters for the callback
*/
PHALCON_INIT_NVAR(parameters);
array_init_size(parameters, 2);
if (Z_TYPE_P(attributes) == IS_ARRAY) {
phalcon_array_update_long(&attributes, 0, prefixed_path, PH_COPY | PH_SEPARATE);
phalcon_array_append(¶meters, attributes, 0);
} else {
phalcon_array_append(¶meters, prefixed_path, 0);
}
phalcon_array_append(¶meters, local, 0);
/**
* Call the callback to generate the HTML
*/
PHALCON_INIT_NVAR(html);/**/
PHALCON_CALL_USER_FUNC_ARRAY(html, callback, parameters);
/**
* Implicit output prints the content directly
*/
if (zend_is_true(use_implicit_output)) {
zend_print_zval(html, 0);
} else {
phalcon_concat_self(&output, html TSRMLS_CC);
}
}
}
RETURN_CCTOR(output);
}
PHP_METHOD(MongoGridFS, __construct)
{
zval *zdb, *files = 0, *chunks = 0, *zchunks;
zval *z_w = NULL;
/* chunks is deprecated */
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|zz", &zdb, mongo_ce_DB, &files, &chunks) == FAILURE) {
zval *object = getThis();
ZVAL_NULL(object);
return;
}
if (!files && !chunks) {
MAKE_STD_ZVAL(files);
ZVAL_STRING(files, "fs.files", 1);
MAKE_STD_ZVAL(chunks);
ZVAL_STRING(chunks, "fs.chunks", 1);
} else {
zval *temp_file;
char *temp;
if (Z_TYPE_P(files) != IS_STRING || Z_STRLEN_P(files) == 0 ) {
zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 2 TSRMLS_CC, "MongoGridFS::__construct(): invalid prefix");
return;
}
MAKE_STD_ZVAL(chunks);
spprintf(&temp, 0, "%s.chunks", Z_STRVAL_P(files));
ZVAL_STRING(chunks, temp, 0);
MAKE_STD_ZVAL(temp_file);
spprintf(&temp, 0, "%s.files", Z_STRVAL_P(files));
ZVAL_STRING(temp_file, temp, 0);
files = temp_file;
}
/* create files collection */
MONGO_METHOD2(MongoCollection, __construct, return_value, getThis(), zdb, files);
/* create chunks collection */
MAKE_STD_ZVAL(zchunks);
object_init_ex(zchunks, mongo_ce_Collection);
MONGO_METHOD2(MongoCollection, __construct, return_value, zchunks, zdb, chunks);
/* add chunks collection as a property */
zend_update_property(mongo_ce_GridFS, getThis(), "chunks", strlen("chunks"), zchunks TSRMLS_CC);
zend_update_property(mongo_ce_GridFS, getThis(), "filesName", strlen("filesName"), files TSRMLS_CC);
zend_update_property(mongo_ce_GridFS, getThis(), "chunksName", strlen("chunksName"), chunks TSRMLS_CC);
/* GridFS is forced in our codebase to be w=1 so this property doesn't actually mean
* anything, but we can't lie to the user so we have to overwrite it if the MongoDB
* object that created this object was w=0.
* This property is initialized in the MongoCollection (which we extend) ctor */
z_w = zend_read_property(mongo_ce_GridFS, getThis(), "w", strlen("w"), NOISY TSRMLS_CC);
if (Z_TYPE_P(z_w) != IS_STRING) {
convert_to_long(z_w);
if (Z_LVAL_P(z_w) < 2) {
zend_update_property_long(mongo_ce_GridFS, getThis(), "w", strlen("w"), 1 TSRMLS_CC);
}
}
/* cleanup */
zval_ptr_dtor(&zchunks);
zval_ptr_dtor(&files);
zval_ptr_dtor(&chunks);
}
static int do_cli(int argc, char **argv) /* {{{ */
{
int c;
zend_file_handle file_handle;
int behavior = PHP_MODE_STANDARD;
char *reflection_what = NULL;
volatile int request_started = 0;
volatile int exit_status = 0;
char *php_optarg = NULL, *orig_optarg = NULL;
int php_optind = 1, orig_optind = 1;
char *exec_direct=NULL, *exec_run=NULL, *exec_begin=NULL, *exec_end=NULL;
char *arg_free=NULL, **arg_excp=&arg_free;
char *script_file=NULL, *translated_path = NULL;
int interactive=0;
int lineno = 0;
const char *param_error=NULL;
int hide_argv = 0;
zend_try {
CG(in_compilation) = 0; /* not initialized but needed for several options */
while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2)) != -1) {
switch (c) {
case 'i': /* php info & quit */
if (php_request_startup()==FAILURE) {
goto err;
}
request_started = 1;
php_print_info(0xFFFFFFFF);
php_output_end_all();
exit_status = (c == '?' && argc > 1 && !strchr(argv[1], c));
goto out;
case 'v': /* show php version & quit */
php_printf("PHP %s (%s) (built: %s %s) ( %s)\nCopyright (c) 1997-2016 The PHP Group\n%s",
PHP_VERSION, cli_sapi_module.name, __DATE__, __TIME__,
#if ZTS
"ZTS "
#else
"NTS "
#endif
#ifdef COMPILER
COMPILER
" "
#endif
#ifdef ARCHITECTURE
ARCHITECTURE
" "
#endif
#if ZEND_DEBUG
"DEBUG "
#endif
#ifdef HAVE_GCOV
"GCOV "
#endif
,
get_zend_version()
);
sapi_deactivate();
goto out;
case 'm': /* list compiled in modules */
if (php_request_startup()==FAILURE) {
goto err;
}
request_started = 1;
php_printf("[PHP Modules]\n");
print_modules();
php_printf("\n[Zend Modules]\n");
print_extensions();
php_printf("\n");
php_output_end_all();
exit_status=0;
goto out;
default:
break;
}
}
/* Set some CLI defaults */
SG(options) |= SAPI_OPTION_NO_CHDIR;
php_optind = orig_optind;
php_optarg = orig_optarg;
while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2)) != -1) {
switch (c) {
case 'a': /* interactive mode */
if (!interactive) {
if (behavior != PHP_MODE_STANDARD) {
param_error = param_mode_conflict;
break;
}
interactive=1;
}
break;
case 'C': /* don't chdir to the script directory */
/* This is default so NOP */
break;
case 'F':
if (behavior == PHP_MODE_PROCESS_STDIN) {
if (exec_run || script_file) {
param_error = "You can use -R or -F only once.\n";
break;
}
} else if (behavior != PHP_MODE_STANDARD) {
param_error = param_mode_conflict;
break;
}
behavior=PHP_MODE_PROCESS_STDIN;
script_file = php_optarg;
break;
case 'f': /* parse file */
if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) {
param_error = param_mode_conflict;
break;
} else if (script_file) {
param_error = "You can use -f only once.\n";
break;
}
script_file = php_optarg;
break;
case 'l': /* syntax check mode */
if (behavior != PHP_MODE_STANDARD) {
break;
}
behavior=PHP_MODE_LINT;
break;
case 'q': /* do not generate HTTP headers */
/* This is default so NOP */
break;
case 'r': /* run code from command line */
if (behavior == PHP_MODE_CLI_DIRECT) {
if (exec_direct || script_file) {
param_error = "You can use -r only once.\n";
break;
}
} else if (behavior != PHP_MODE_STANDARD || interactive) {
param_error = param_mode_conflict;
break;
}
behavior=PHP_MODE_CLI_DIRECT;
exec_direct=php_optarg;
break;
case 'R':
if (behavior == PHP_MODE_PROCESS_STDIN) {
if (exec_run || script_file) {
param_error = "You can use -R or -F only once.\n";
break;
}
} else if (behavior != PHP_MODE_STANDARD) {
param_error = param_mode_conflict;
break;
}
behavior=PHP_MODE_PROCESS_STDIN;
exec_run=php_optarg;
break;
case 'B':
if (behavior == PHP_MODE_PROCESS_STDIN) {
if (exec_begin) {
param_error = "You can use -B only once.\n";
break;
}
} else if (behavior != PHP_MODE_STANDARD || interactive) {
param_error = param_mode_conflict;
break;
}
behavior=PHP_MODE_PROCESS_STDIN;
exec_begin=php_optarg;
break;
case 'E':
if (behavior == PHP_MODE_PROCESS_STDIN) {
if (exec_end) {
param_error = "You can use -E only once.\n";
break;
}
} else if (behavior != PHP_MODE_STANDARD || interactive) {
param_error = param_mode_conflict;
break;
}
behavior=PHP_MODE_PROCESS_STDIN;
exec_end=php_optarg;
break;
case 's': /* generate highlighted HTML from source */
if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) {
param_error = "Source highlighting only works for files.\n";
break;
}
behavior=PHP_MODE_HIGHLIGHT;
break;
case 'w':
if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) {
param_error = "Source stripping only works for files.\n";
break;
}
behavior=PHP_MODE_STRIP;
break;
case 'z': /* load extension file */
zend_load_extension(php_optarg);
break;
case 'H':
hide_argv = 1;
break;
case 10:
behavior=PHP_MODE_REFLECTION_FUNCTION;
reflection_what = php_optarg;
break;
case 11:
behavior=PHP_MODE_REFLECTION_CLASS;
reflection_what = php_optarg;
break;
case 12:
behavior=PHP_MODE_REFLECTION_EXTENSION;
reflection_what = php_optarg;
break;
case 13:
behavior=PHP_MODE_REFLECTION_ZEND_EXTENSION;
reflection_what = php_optarg;
break;
case 14:
behavior=PHP_MODE_REFLECTION_EXT_INFO;
reflection_what = php_optarg;
break;
case 15:
behavior = PHP_MODE_SHOW_INI_CONFIG;
break;
default:
break;
}
}
if (param_error) {
PUTS(param_error);
exit_status=1;
goto err;
}
if (interactive) {
#if (HAVE_LIBREADLINE || HAVE_LIBEDIT) && !defined(COMPILE_DL_READLINE)
printf("Interactive shell\n\n");
#else
printf("Interactive mode enabled\n\n");
#endif
fflush(stdout);
}
/* only set script_file if not set already and not in direct mode and not at end of parameter list */
if (argc > php_optind
&& !script_file
&& behavior!=PHP_MODE_CLI_DIRECT
&& behavior!=PHP_MODE_PROCESS_STDIN
&& strcmp(argv[php_optind-1],"--"))
{
script_file=argv[php_optind];
php_optind++;
}
if (script_file) {
if (cli_seek_file_begin(&file_handle, script_file, &lineno) != SUCCESS) {
goto err;
} else {
char real_path[MAXPATHLEN];
if (VCWD_REALPATH(script_file, real_path)) {
translated_path = strdup(real_path);
}
script_filename = script_file;
}
} else {
/* We could handle PHP_MODE_PROCESS_STDIN in a different manner */
/* here but this would make things only more complicated. And it */
/* is consitent with the way -R works where the stdin file handle*/
/* is also accessible. */
file_handle.filename = "-";
file_handle.handle.fp = stdin;
}
file_handle.type = ZEND_HANDLE_FP;
file_handle.opened_path = NULL;
file_handle.free_filename = 0;
php_self = (char*)file_handle.filename;
/* before registering argv to module exchange the *new* argv[0] */
/* we can achieve this without allocating more memory */
SG(request_info).argc=argc-php_optind+1;
arg_excp = argv+php_optind-1;
arg_free = argv[php_optind-1];
SG(request_info).path_translated = translated_path? translated_path: (char*)file_handle.filename;
argv[php_optind-1] = (char*)file_handle.filename;
SG(request_info).argv=argv+php_optind-1;
if (php_request_startup()==FAILURE) {
*arg_excp = arg_free;
fclose(file_handle.handle.fp);
PUTS("Could not startup.\n");
goto err;
}
request_started = 1;
CG(start_lineno) = lineno;
*arg_excp = arg_free; /* reconstuct argv */
if (hide_argv) {
int i;
for (i = 1; i < argc; i++) {
memset(argv[i], 0, strlen(argv[i]));
}
}
zend_is_auto_global_str(ZEND_STRL("_SERVER"));
PG(during_request_startup) = 0;
switch (behavior) {
case PHP_MODE_STANDARD:
if (strcmp(file_handle.filename, "-")) {
cli_register_file_handles();
}
if (interactive && cli_shell_callbacks.cli_shell_run) {
exit_status = cli_shell_callbacks.cli_shell_run();
} else {
php_execute_script(&file_handle);
exit_status = EG(exit_status);
}
break;
case PHP_MODE_LINT:
exit_status = php_lint_script(&file_handle);
if (exit_status==SUCCESS) {
zend_printf("No syntax errors detected in %s\n", file_handle.filename);
} else {
zend_printf("Errors parsing %s\n", file_handle.filename);
}
break;
case PHP_MODE_STRIP:
if (open_file_for_scanning(&file_handle)==SUCCESS) {
zend_strip();
}
goto out;
break;
case PHP_MODE_HIGHLIGHT:
{
zend_syntax_highlighter_ini syntax_highlighter_ini;
if (open_file_for_scanning(&file_handle)==SUCCESS) {
php_get_highlight_struct(&syntax_highlighter_ini);
zend_highlight(&syntax_highlighter_ini);
}
goto out;
}
break;
case PHP_MODE_CLI_DIRECT:
cli_register_file_handles();
if (zend_eval_string_ex(exec_direct, NULL, "Command line code", 1) == FAILURE) {
exit_status=254;
}
break;
case PHP_MODE_PROCESS_STDIN:
{
char *input;
size_t len, index = 0;
zval argn, argi;
cli_register_file_handles();
if (exec_begin && zend_eval_string_ex(exec_begin, NULL, "Command line begin code", 1) == FAILURE) {
exit_status=254;
}
while (exit_status == SUCCESS && (input=php_stream_gets(s_in_process, NULL, 0)) != NULL) {
len = strlen(input);
while (len > 0 && len-- && (input[len]=='\n' || input[len]=='\r')) {
input[len] = '\0';
}
ZVAL_STRINGL(&argn, input, len + 1);
zend_hash_str_update(&EG(symbol_table), "argn", sizeof("argn")-1, &argn);
ZVAL_LONG(&argi, ++index);
zend_hash_str_update(&EG(symbol_table), "argi", sizeof("argi")-1, &argi);
if (exec_run) {
if (zend_eval_string_ex(exec_run, NULL, "Command line run code", 1) == FAILURE) {
exit_status=254;
}
} else {
if (script_file) {
if (cli_seek_file_begin(&file_handle, script_file, &lineno) != SUCCESS) {
exit_status = 1;
} else {
CG(start_lineno) = lineno;
php_execute_script(&file_handle);
exit_status = EG(exit_status);
}
}
}
efree(input);
}
if (exec_end && zend_eval_string_ex(exec_end, NULL, "Command line end code", 1) == FAILURE) {
exit_status=254;
}
break;
}
case PHP_MODE_REFLECTION_FUNCTION:
case PHP_MODE_REFLECTION_CLASS:
case PHP_MODE_REFLECTION_EXTENSION:
case PHP_MODE_REFLECTION_ZEND_EXTENSION:
{
zend_class_entry *pce = NULL;
zval arg, ref;
zend_execute_data execute_data;
switch (behavior) {
default:
break;
case PHP_MODE_REFLECTION_FUNCTION:
if (strstr(reflection_what, "::")) {
pce = reflection_method_ptr;
} else {
pce = reflection_function_ptr;
}
break;
case PHP_MODE_REFLECTION_CLASS:
pce = reflection_class_ptr;
break;
case PHP_MODE_REFLECTION_EXTENSION:
pce = reflection_extension_ptr;
break;
case PHP_MODE_REFLECTION_ZEND_EXTENSION:
pce = reflection_zend_extension_ptr;
break;
}
ZVAL_STRING(&arg, reflection_what);
object_init_ex(&ref, pce);
memset(&execute_data, 0, sizeof(zend_execute_data));
EG(current_execute_data) = &execute_data;
zend_call_method_with_1_params(&ref, pce, &pce->constructor, "__construct", NULL, &arg);
if (EG(exception)) {
zval tmp, *msg, rv;
ZVAL_OBJ(&tmp, EG(exception));
msg = zend_read_property(zend_ce_exception, &tmp, "message", sizeof("message")-1, 0, &rv);
zend_printf("Exception: %s\n", Z_STRVAL_P(msg));
zval_ptr_dtor(&tmp);
EG(exception) = NULL;
} else {
zend_call_method_with_1_params(NULL, reflection_ptr, NULL, "export", NULL, &ref);
}
zval_ptr_dtor(&ref);
zval_ptr_dtor(&arg);
break;
}
case PHP_MODE_REFLECTION_EXT_INFO:
{
int len = (int)strlen(reflection_what);
char *lcname = zend_str_tolower_dup(reflection_what, len);
zend_module_entry *module;
if ((module = zend_hash_str_find_ptr(&module_registry, lcname, len)) == NULL) {
if (!strcmp(reflection_what, "main")) {
display_ini_entries(NULL);
} else {
zend_printf("Extension '%s' not present.\n", reflection_what);
exit_status = 1;
}
} else {
php_info_print_module(module);
}
efree(lcname);
break;
}
case PHP_MODE_SHOW_INI_CONFIG:
{
zend_printf("Configuration File (php.ini) Path: %s\n", PHP_CONFIG_FILE_PATH);
zend_printf("Loaded Configuration File: %s\n", php_ini_opened_path ? php_ini_opened_path : "(none)");
zend_printf("Scan for additional .ini files in: %s\n", php_ini_scanned_path ? php_ini_scanned_path : "(none)");
zend_printf("Additional .ini files parsed: %s\n", php_ini_scanned_files ? php_ini_scanned_files : "(none)");
break;
}
}
} zend_end_try();
out:
if (request_started) {
php_request_shutdown((void *) 0);
}
if (translated_path) {
free(translated_path);
}
if (exit_status == 0) {
exit_status = EG(exit_status);
}
return exit_status;
err:
sapi_deactivate();
zend_ini_deactivate();
exit_status = 1;
goto out;
}
/**
* Gets information about schema, host and port used by the request
*
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getHttpHost){
zval *scheme = NULL, *name = NULL, *port = NULL, *is_std_http = NULL, *is_secure_http = NULL;
zval *is_http_normal = NULL, *name_port = NULL;
zval *c0 = NULL, *c1 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(scheme);
PHALCON_CALL_METHOD(scheme, this_ptr, "getscheme", PH_NO_CHECK);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "HTTP_SERVER_NAME", 1);
PHALCON_INIT_VAR(name);
PHALCON_CALL_METHOD_PARAMS_1(name, this_ptr, "getserver", c0, PH_NO_CHECK);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "HTTP_SERVER_PORT", 1);
PHALCON_INIT_VAR(port);
PHALCON_CALL_METHOD_PARAMS_1(port, this_ptr, "getserver", c1, PH_NO_CHECK);
PHALCON_INIT_VAR(t0);
ZVAL_STRING(t0, "http", 1);
PHALCON_ALLOC_ZVAL_MM(r0);
is_equal_function(r0, scheme, t0 TSRMLS_CC);
PHALCON_INIT_VAR(t1);
ZVAL_LONG(t1, 80);
PHALCON_ALLOC_ZVAL_MM(r1);
is_equal_function(r1, port, t1 TSRMLS_CC);
PHALCON_INIT_VAR(is_std_http);
phalcon_and_function(is_std_http, r0, r1);
PHALCON_INIT_VAR(t2);
ZVAL_STRING(t2, "https", 1);
PHALCON_ALLOC_ZVAL_MM(r2);
is_equal_function(r2, scheme, t2 TSRMLS_CC);
PHALCON_INIT_VAR(t3);
ZVAL_LONG(t3, 443);
PHALCON_ALLOC_ZVAL_MM(r3);
is_equal_function(r3, port, t3 TSRMLS_CC);
PHALCON_INIT_VAR(is_secure_http);
phalcon_and_function(is_secure_http, r2, r3);
PHALCON_INIT_VAR(is_http_normal);
ZVAL_BOOL(is_http_normal, zend_is_true(is_std_http) || zend_is_true(is_secure_http));
if (zend_is_true(is_http_normal)) {
RETURN_CCTOR(name);
}
PHALCON_INIT_VAR(name_port);
PHALCON_CONCAT_VSV(name_port, name, ":", port);
RETURN_CTOR(name_port);
}
/**
* Phalcon\Config\Adapter\Yaml constructor
*
* @throws \Phalcon\Config\Exception
*/
PHP_METHOD(Phalcon_Config_Adapter_Yaml, __construct) {
zephir_fcall_cache_entry *_4 = NULL, *_6 = NULL;
int ndocs = 0, ZEPHIR_LAST_CALL_STATUS;
zval *callbacks = NULL;
zval *filePath_param = NULL, *callbacks_param = NULL, *yamlConfig = NULL, _0, *_1 = NULL, *_2 = NULL, *_3 = NULL, *_5;
zval *filePath = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &filePath_param, &callbacks_param);
if (unlikely(Z_TYPE_P(filePath_param) != IS_STRING && Z_TYPE_P(filePath_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'filePath' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(filePath_param) == IS_STRING)) {
zephir_get_strval(filePath, filePath_param);
} else {
ZEPHIR_INIT_VAR(filePath);
ZVAL_EMPTY_STRING(filePath);
}
if (!callbacks_param) {
ZEPHIR_INIT_VAR(callbacks);
array_init(callbacks);
} else {
callbacks = callbacks_param;
}
ZEPHIR_SINIT_VAR(_0);
ZVAL_STRING(&_0, "yaml", 0);
ZEPHIR_CALL_FUNCTION(&_1, "extension_loaded", NULL, 63, &_0);
zephir_check_call_status();
if (!(zephir_is_true(_1))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_config_exception_ce, "Yaml extension not loaded", "phalcon/config/adapter/yaml.zep", 62);
return;
}
if (!ZEPHIR_IS_STRING_IDENTICAL(callbacks, "")) {
ZEPHIR_INIT_VAR(_2);
ZVAL_LONG(_2, 0);
ZEPHIR_INIT_VAR(_3);
ZVAL_LONG(_3, ndocs);
Z_SET_ISREF_P(_3);
ZEPHIR_CALL_FUNCTION(&yamlConfig, "yaml_parse_file", &_4, 64, filePath, _2, _3, callbacks);
Z_UNSET_ISREF_P(_3);
zephir_check_call_status();
} else {
ZEPHIR_CALL_FUNCTION(&yamlConfig, "yaml_parse_file", &_4, 64, filePath);
zephir_check_call_status();
}
if (ZEPHIR_IS_FALSE_IDENTICAL(yamlConfig)) {
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_config_exception_ce);
ZEPHIR_INIT_NVAR(_3);
zephir_basename(_3, filePath TSRMLS_CC);
ZEPHIR_INIT_VAR(_5);
ZEPHIR_CONCAT_SVS(_5, "Configuration file ", _3, " can't be loaded");
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", NULL, 2, _5);
zephir_check_call_status();
zephir_throw_exception_debug(_2, "phalcon/config/adapter/yaml.zep", 72 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_CALL_PARENT(NULL, phalcon_config_adapter_yaml_ce, this_ptr, "__construct", &_6, 58, yamlConfig);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Returns current row in the resultset
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, current) {
zend_class_entry *_5$$6;
zval *row = NULL, *hydrateMode = NULL, *columnMap = NULL, *activeRow = NULL, *modelName = NULL, *_0$$6, *_2$$6, *_3$$6, *_4$$6, *_1$$7, *_7$$9, *_8$$9, *_9$$9;
zephir_fcall_cache_entry *_6 = NULL, *_10 = NULL;
zend_long ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(activeRow);
zephir_read_property_this(&activeRow, this_ptr, SL("_activeRow"), PH_NOISY_CC);
if (Z_TYPE_P(activeRow) != IS_NULL) {
RETURN_CCTOR(activeRow);
}
ZEPHIR_OBS_VAR(row);
zephir_read_property_this(&row, this_ptr, SL("_row"), PH_NOISY_CC);
if (Z_TYPE_P(row) != IS_ARRAY) {
if (0) {
zephir_update_property_this(getThis(), SL("_activeRow"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(getThis(), SL("_activeRow"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
RETURN_MM_BOOL(0);
}
ZEPHIR_OBS_VAR(hydrateMode);
zephir_read_property_this(&hydrateMode, this_ptr, SL("_hydrateMode"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(columnMap);
zephir_read_property_this(&columnMap, this_ptr, SL("_columnMap"), PH_NOISY_CC);
do {
if (ZEPHIR_IS_LONG(hydrateMode, 0)) {
if (ZEPHIR_GLOBAL(orm).late_state_binding) {
ZEPHIR_OBS_VAR(_0$$6);
zephir_read_property_this(&_0$$6, this_ptr, SL("_model"), PH_NOISY_CC);
if (zephir_instance_of_ev(_0$$6, phalcon_mvc_model_ce TSRMLS_CC)) {
_1$$7 = zephir_fetch_nproperty_this(this_ptr, SL("_model"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(modelName);
zephir_get_class(modelName, _1$$7, 0 TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(modelName);
ZVAL_STRING(modelName, "Phalcon\\Mvc\\Model", 1);
}
_2$$6 = zephir_fetch_nproperty_this(this_ptr, SL("_model"), PH_NOISY_CC);
_3$$6 = zephir_fetch_nproperty_this(this_ptr, SL("_keepSnapshots"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_4$$6);
ZVAL_LONG(_4$$6, 0);
_5$$6 = zephir_fetch_class(modelName TSRMLS_CC);
ZEPHIR_CALL_CE_STATIC(&activeRow, _5$$6, "cloneresultmap", NULL, 0, _2$$6, row, columnMap, _4$$6, _3$$6);
zephir_check_call_status();
} else {
_7$$9 = zephir_fetch_nproperty_this(this_ptr, SL("_model"), PH_NOISY_CC);
_8$$9 = zephir_fetch_nproperty_this(this_ptr, SL("_keepSnapshots"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_9$$9);
ZVAL_LONG(_9$$9, 0);
ZEPHIR_CALL_CE_STATIC(&activeRow, phalcon_mvc_model_ce, "cloneresultmap", &_6, 388, _7$$9, row, columnMap, _9$$9, _8$$9);
zephir_check_call_status();
}
break;
}
ZEPHIR_CALL_CE_STATIC(&activeRow, phalcon_mvc_model_ce, "cloneresultmaphydrate", &_10, 389, row, columnMap, hydrateMode);
zephir_check_call_status();
break;
} while(0);
zephir_update_property_this(getThis(), SL("_activeRow"), activeRow TSRMLS_CC);
RETURN_CCTOR(activeRow);
}
/**
* Executes render process from dispatching data
*
*<code>
* $view->start();
* //Shows recent posts view (app/views/posts/recent.phtml)
* $view->render('posts', 'recent');
* $view->finish();
*</code>
*
* @param string $controllerName
* @param string $actionName
* @param array $params
*/
PHP_METHOD(Phalcon_Mvc_View, render){
zval *controller_name, *action_name, *params = NULL;
zval *disabled, *layouts_dir = NULL, *engines, *pick_view;
zval *render_view = NULL, *render_controller = NULL, *pick_view_action;
zval *cache = NULL, *cache_level, *events_manager, *event_name = NULL;
zval *status, *contents, *must_clean, *silence = NULL;
zval *render_level, *enter_level = NULL, *templates_before;
zval *template_before = NULL, *view_temp_path = NULL, *templates_after;
zval *template_after = NULL, *main_view, *is_started;
zval *is_fresh;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &controller_name, &action_name, ¶ms) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!params) {
PHALCON_INIT_NVAR(params);
array_init(params);
}
PHALCON_INIT_VAR(disabled);
phalcon_read_property(&disabled, this_ptr, SL("_disabled"), PH_NOISY_CC);
if (PHALCON_IS_NOT_FALSE(disabled)) {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
PHALCON_INIT_VAR(layouts_dir);
phalcon_read_property(&layouts_dir, this_ptr, SL("_layoutsDir"), PH_NOISY_CC);
if (!zend_is_true(layouts_dir)) {
PHALCON_INIT_NVAR(layouts_dir);
ZVAL_STRING(layouts_dir, "layouts/", 1);
}
phalcon_update_property_zval(this_ptr, SL("_controllerName"), controller_name TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_actionName"), action_name TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_params"), params TSRMLS_CC);
PHALCON_INIT_VAR(engines);
PHALCON_CALL_METHOD(engines, this_ptr, "_loadtemplateengines", PH_NO_CHECK);
PHALCON_INIT_VAR(pick_view);
phalcon_read_property(&pick_view, this_ptr, SL("_pickView"), PH_NOISY_CC);
if (Z_TYPE_P(pick_view) == IS_NULL) {
PHALCON_INIT_VAR(render_view);
PHALCON_CONCAT_VSV(render_view, controller_name, "/", action_name);
PHALCON_CPY_WRT(render_controller, controller_name);
} else {
PHALCON_INIT_NVAR(render_view);
phalcon_array_fetch_long(&render_view, pick_view, 0, PH_NOISY_CC);
eval_int = phalcon_array_isset_long(pick_view, 1);
if (eval_int) {
PHALCON_INIT_VAR(pick_view_action);
phalcon_array_fetch_long(&pick_view_action, pick_view, 1, PH_NOISY_CC);
PHALCON_CPY_WRT(render_controller, pick_view_action);
} else {
PHALCON_CPY_WRT(render_controller, controller_name);
}
}
PHALCON_INIT_VAR(cache);
PHALCON_INIT_VAR(cache_level);
phalcon_read_property(&cache_level, this_ptr, SL("_cacheLevel"), PH_NOISY_CC);
if (zend_is_true(cache_level)) {
PHALCON_CALL_METHOD(cache, this_ptr, "getcache", PH_NO_CHECK);
}
PHALCON_INIT_VAR(events_manager);
phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "view:beforeRender", 1);
PHALCON_INIT_VAR(status);
PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", event_name, this_ptr, PH_NO_CHECK);
if (PHALCON_IS_FALSE(status)) {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_INIT_VAR(contents);
PHALCON_CALL_FUNC(contents, "ob_get_contents");
phalcon_update_property_zval(this_ptr, SL("_content"), contents TSRMLS_CC);
PHALCON_INIT_VAR(must_clean);
ZVAL_BOOL(must_clean, 1);
PHALCON_INIT_VAR(silence);
ZVAL_BOOL(silence, 1);
PHALCON_INIT_VAR(render_level);
phalcon_read_property(&render_level, this_ptr, SL("_renderLevel"), PH_NOISY_CC);
if (zend_is_true(render_level)) {
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 1);
PHALCON_INIT_VAR(enter_level);
is_smaller_or_equal_function(enter_level, t0, render_level TSRMLS_CC);
if (PHALCON_IS_TRUE(enter_level)) {
PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, render_view, silence, must_clean, cache, PH_NO_CHECK);
}
PHALCON_INIT_VAR(t1);
ZVAL_LONG(t1, 2);
PHALCON_INIT_NVAR(enter_level);
is_smaller_or_equal_function(enter_level, t1, render_level TSRMLS_CC);
if (PHALCON_IS_TRUE(enter_level)) {
PHALCON_INIT_VAR(templates_before);
phalcon_read_property(&templates_before, this_ptr, SL("_templatesBefore"), PH_NOISY_CC);
if (Z_TYPE_P(templates_before) == IS_ARRAY) {
ZVAL_BOOL(silence, 0);
if (!phalcon_valid_foreach(templates_before TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(templates_before);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) {
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_VALUE(template_before);
PHALCON_INIT_NVAR(view_temp_path);
PHALCON_CONCAT_VV(view_temp_path, layouts_dir, template_before);
PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache, PH_NO_CHECK);
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
ZVAL_BOOL(silence, 1);
}
}
PHALCON_INIT_VAR(t2);
ZVAL_LONG(t2, 3);
PHALCON_INIT_NVAR(enter_level);
is_smaller_or_equal_function(enter_level, t2, render_level TSRMLS_CC);
if (PHALCON_IS_TRUE(enter_level)) {
PHALCON_INIT_NVAR(view_temp_path);
PHALCON_CONCAT_VV(view_temp_path, layouts_dir, render_controller);
PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache, PH_NO_CHECK);
}
PHALCON_INIT_VAR(t3);
ZVAL_LONG(t3, 4);
PHALCON_INIT_NVAR(enter_level);
is_smaller_or_equal_function(enter_level, t3, render_level TSRMLS_CC);
if (PHALCON_IS_TRUE(enter_level)) {
PHALCON_INIT_VAR(templates_after);
phalcon_read_property(&templates_after, this_ptr, SL("_templatesAfter"), PH_NOISY_CC);
if (Z_TYPE_P(templates_after) == IS_ARRAY) {
ZVAL_BOOL(silence, 0);
if (!phalcon_valid_foreach(templates_after TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(templates_after);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
ph_cycle_start_1:
if (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS) {
goto ph_cycle_end_1;
}
PHALCON_GET_FOREACH_VALUE(template_after);
PHALCON_INIT_NVAR(view_temp_path);
PHALCON_CONCAT_VV(view_temp_path, layouts_dir, template_after);
PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache, PH_NO_CHECK);
zend_hash_move_forward_ex(ah1, &hp1);
goto ph_cycle_start_1;
ph_cycle_end_1:
ZVAL_BOOL(silence, 1);
}
}
PHALCON_INIT_VAR(t4);
ZVAL_LONG(t4, 5);
PHALCON_INIT_NVAR(enter_level);
is_smaller_or_equal_function(enter_level, t4, render_level TSRMLS_CC);
if (PHALCON_IS_TRUE(enter_level)) {
PHALCON_INIT_VAR(main_view);
phalcon_read_property(&main_view, this_ptr, SL("_mainView"), PH_NOISY_CC);
PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, main_view, silence, must_clean, cache, PH_NO_CHECK);
}
if (Z_TYPE_P(cache) == IS_OBJECT) {
PHALCON_INIT_VAR(is_started);
PHALCON_CALL_METHOD(is_started, cache, "isstarted", PH_NO_CHECK);
if (PHALCON_IS_TRUE(is_started)) {
PHALCON_INIT_VAR(is_fresh);
PHALCON_CALL_METHOD(is_fresh, cache, "isfresh", PH_NO_CHECK);
if (PHALCON_IS_TRUE(is_fresh)) {
PHALCON_CALL_METHOD_NORETURN(cache, "save", PH_NO_CHECK);
} else {
PHALCON_CALL_METHOD_NORETURN(cache, "stop", PH_NO_CHECK);
}
} else {
PHALCON_CALL_METHOD_NORETURN(cache, "stop", PH_NO_CHECK);
}
}
}
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "view:afterRender", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", event_name, this_ptr, PH_NO_CHECK);
}
PHALCON_MM_RESTORE();
}
/**
* Builds a SELECT statement
*
* @param array $definition
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect, select){
zval *definition = NULL, *columns = NULL, *comma = NULL, *columns_sql = NULL;
zval *tables = NULL, *tables_sql = NULL, *sql = NULL, *joins = NULL, *join = NULL, *type = NULL;
zval *source = NULL, *sql_join = NULL, *and_word = NULL, *join_conditions_array = NULL;
zval *join_conditions = NULL, *on_join = NULL, *where_conditions = NULL;
zval *where_clause = NULL, *group_fields = NULL, *group_clause = NULL;
zval *having_conditions = NULL, *having_clause = NULL, *order_fields = NULL;
zval *order_clause = NULL, *limit_value = NULL, *limit_clause = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &definition) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
eval_int = phalcon_array_isset_string(definition, SL("tables")+1);
if (!eval_int) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The index 'tables' is required in the definition array");
return;
}
eval_int = phalcon_array_isset_string(definition, SL("columns")+1);
if (!eval_int) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The index 'columns' is required in the definition array");
return;
}
PHALCON_INIT_VAR(columns);
phalcon_array_fetch_string(&columns, definition, SL("columns"), PH_NOISY_CC);
if (Z_TYPE_P(columns) == IS_ARRAY) {
PHALCON_INIT_VAR(comma);
ZVAL_STRING(comma, ",", 1);
PHALCON_INIT_VAR(columns_sql);
phalcon_fast_join(columns_sql, comma, columns TSRMLS_CC);
} else {
PHALCON_CPY_WRT(columns_sql, columns);
}
PHALCON_INIT_VAR(tables);
phalcon_array_fetch_string(&tables, definition, SL("tables"), PH_NOISY_CC);
if (Z_TYPE_P(tables) == IS_ARRAY) {
PHALCON_INIT_VAR(comma);
ZVAL_STRING(comma, ",", 1);
PHALCON_INIT_VAR(tables_sql);
phalcon_fast_join(tables_sql, comma, tables TSRMLS_CC);
} else {
PHALCON_CPY_WRT(tables_sql, tables);
}
PHALCON_INIT_VAR(sql);
PHALCON_CONCAT_SVSV(sql, "SELECT ", columns_sql, " FROM ", tables_sql);
eval_int = phalcon_array_isset_string(definition, SL("joins")+1);
if (eval_int) {
PHALCON_INIT_VAR(joins);
phalcon_array_fetch_string(&joins, definition, SL("joins"), PH_NOISY_CC);
if (!phalcon_valid_foreach(joins TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(joins);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_62b2_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_62b2_0;
}
PHALCON_INIT_VAR(join);
ZVAL_ZVAL(join, *hd, 1, 0);
PHALCON_INIT_VAR(type);
phalcon_array_fetch_string(&type, join, SL("type"), PH_NOISY_CC);
PHALCON_INIT_VAR(source);
phalcon_array_fetch_string(&source, join, SL("source"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql_join);
PHALCON_CONCAT_SVSV(sql_join, " ", type, " JOIN ", source);
eval_int = phalcon_array_isset_string(join, SL("conditions")+1);
if (eval_int) {
PHALCON_INIT_VAR(and_word);
ZVAL_STRING(and_word, " AND ", 1);
PHALCON_INIT_VAR(join_conditions_array);
phalcon_array_fetch_string(&join_conditions_array, join, SL("conditions"), PH_NOISY_CC);
PHALCON_INIT_VAR(join_conditions);
phalcon_fast_join(join_conditions, and_word, join_conditions_array TSRMLS_CC);
PHALCON_INIT_VAR(on_join);
PHALCON_CONCAT_SV(on_join, " ON ", join_conditions);
phalcon_concat_self(&sql_join, on_join TSRMLS_CC);
}
phalcon_concat_self(&sql, sql_join TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_62b2_0;
fee_62b2_0:
if(0){}
}
eval_int = phalcon_array_isset_string(definition, SL("where")+1);
if (eval_int) {
PHALCON_INIT_VAR(where_conditions);
phalcon_array_fetch_string(&where_conditions, definition, SL("where"), PH_NOISY_CC);
PHALCON_INIT_VAR(where_clause);
PHALCON_CONCAT_SV(where_clause, " WHERE ", where_conditions);
phalcon_concat_self(&sql, where_clause TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(definition, SL("group")+1);
if (eval_int) {
PHALCON_INIT_VAR(group_fields);
phalcon_array_fetch_string(&group_fields, definition, SL("group"), PH_NOISY_CC);
PHALCON_INIT_VAR(group_clause);
PHALCON_CONCAT_SV(group_clause, " GROUP BY ", group_fields);
phalcon_concat_self(&sql, group_clause TSRMLS_CC);
eval_int = phalcon_array_isset_string(definition, SL("having")+1);
if (eval_int) {
PHALCON_INIT_VAR(having_conditions);
phalcon_array_fetch_string(&having_conditions, definition, SL("having"), PH_NOISY_CC);
PHALCON_INIT_VAR(having_clause);
PHALCON_CONCAT_SV(having_clause, " HAVING ", having_conditions);
phalcon_concat_self(&sql, having_clause TSRMLS_CC);
}
}
eval_int = phalcon_array_isset_string(definition, SL("order")+1);
if (eval_int) {
PHALCON_INIT_VAR(order_fields);
phalcon_array_fetch_string(&order_fields, definition, SL("order"), PH_NOISY_CC);
PHALCON_INIT_VAR(order_clause);
PHALCON_CONCAT_SV(order_clause, " ORDER BY ", order_fields);
phalcon_concat_self(&sql, order_clause TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(definition, SL("limit")+1);
if (eval_int) {
PHALCON_INIT_VAR(limit_value);
phalcon_array_fetch_string(&limit_value, definition, SL("limit"), PH_NOISY_CC);
PHALCON_INIT_VAR(limit_clause);
PHALCON_CONCAT_SV(limit_clause, " LIMIT ", limit_value);
phalcon_concat_self(&sql, limit_clause TSRMLS_CC);
}
RETURN_CTOR(sql);
}
static void call_php(char *name, PARAMDSC *r, int argc, PARAMDSC **argv)
{
do {
zval callback, args[4], *argp[4], return_value;
PARAMVARY *res = (PARAMVARY*)r->dsc_address;
int i;
INIT_ZVAL(callback);
ZVAL_STRING(&callback,name,0);
LOCK();
/* check if the requested function exists */
if (!zend_is_callable(&callback, 0, NULL TSRMLS_CC)) {
break;
}
UNLOCK();
/* create the argument array */
for (i = 0; i < argc; ++i) {
INIT_ZVAL(args[i]);
argp[i] = &args[i];
/* test arg for null */
if (argv[i]->dsc_flags & DSC_null) {
ZVAL_NULL(argp[i]);
continue;
}
switch (argv[i]->dsc_dtype) {
ISC_INT64 l;
struct tm t;
char const *fmt;
char d[64];
case dtype_cstring:
ZVAL_STRING(argp[i], (char*)argv[i]->dsc_address,0);
break;
case dtype_text:
ZVAL_STRINGL(argp[i], (char*)argv[i]->dsc_address, argv[i]->dsc_length,0);
break;
case dtype_varying:
ZVAL_STRINGL(argp[i], ((PARAMVARY*)argv[i]->dsc_address)->vary_string,
((PARAMVARY*)argv[i]->dsc_address)->vary_length,0);
break;
case dtype_short:
if (argv[i]->dsc_scale == 0) {
ZVAL_LONG(argp[i], *(short*)argv[i]->dsc_address);
} else {
ZVAL_DOUBLE(argp[i],
((double)*(short*)argv[i]->dsc_address)/scales[-argv[i]->dsc_scale]);
}
break;
case dtype_long:
if (argv[i]->dsc_scale == 0) {
ZVAL_LONG(argp[i], *(ISC_LONG*)argv[i]->dsc_address);
} else {
ZVAL_DOUBLE(argp[i],
((double)*(ISC_LONG*)argv[i]->dsc_address)/scales[-argv[i]->dsc_scale]);
}
break;
case dtype_int64:
l = *(ISC_INT64*)argv[i]->dsc_address;
if (argv[i]->dsc_scale == 0 && l <= LONG_MAX && l >= LONG_MIN) {
ZVAL_LONG(argp[i], (long)l);
} else {
ZVAL_DOUBLE(argp[i], ((double)l)/scales[-argv[i]->dsc_scale]);
}
break;
case dtype_real:
ZVAL_DOUBLE(argp[i], *(float*)argv[i]->dsc_address);
break;
case dtype_double:
ZVAL_DOUBLE(argp[i], *(double*)argv[i]->dsc_address);
break;
case dtype_sql_date:
isc_decode_sql_date((ISC_DATE*)argv[i]->dsc_address, &t);
ZVAL_STRINGL(argp[i], d, strftime(d, sizeof(d), INI_STR("ibase.dateformat"), &t),1);
break;
case dtype_sql_time:
isc_decode_sql_time((ISC_TIME*)argv[i]->dsc_address, &t);
ZVAL_STRINGL(argp[i], d, strftime(d, sizeof(d), INI_STR("ibase.timeformat"), &t),1);
break;
case dtype_timestamp:
isc_decode_timestamp((ISC_TIMESTAMP*)argv[i]->dsc_address, &t);
ZVAL_STRINGL(argp[i], d, strftime(d, sizeof(d), INI_STR("ibase.timestampformat"), &t),1);
break;
}
}
LOCK();
/* now call the function */
if (FAILURE == call_user_function(EG(function_table), NULL,
&callback, &return_value, argc, argp TSRMLS_CC)) {
UNLOCK();
break;
}
UNLOCK();
for (i = 0; i < argc; ++i) {
switch (argv[i]->dsc_dtype) {
case dtype_sql_date:
case dtype_sql_time:
case dtype_timestamp:
zval_dtor(argp[i]);
}
}
/* return whatever type we got back from the callback: let DB handle conversion */
switch (Z_TYPE(return_value)) {
case IS_LONG:
r->dsc_dtype = dtype_long;
*(long*)r->dsc_address = Z_LVAL(return_value);
r->dsc_length = sizeof(long);
break;
case IS_DOUBLE:
r->dsc_dtype = dtype_double;
*(double*)r->dsc_address = Z_DVAL(return_value);
r->dsc_length = sizeof(double);
break;
case IS_NULL:
r->dsc_flags |= DSC_null;
break;
default:
convert_to_string(&return_value);
case IS_STRING:
r->dsc_dtype = dtype_varying;
memcpy(res->vary_string, Z_STRVAL(return_value),
(res->vary_length = min(r->dsc_length-2,Z_STRLEN(return_value))));
r->dsc_length = res->vary_length+2;
break;
}
zval_dtor(&return_value);
return;
} while (0);
/**
* If we end up here, we should report an error back to the DB engine, but
* that's not possible. We can however report it back to PHP.
*/
LOCK();
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error calling function '%s' from database", name);
UNLOCK();
}
/**
* Internal sanizite wrapper to filter_var
*
* @param mixed $value
* @param mixed $filters
* @param boolean $silent
* @return mixed
*/
PHP_METHOD(Phalcon_Filter, _sanitize){
zval *v0 = NULL, *v1 = NULL, *v2 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL;
zval *t7 = NULL, *t8 = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
zval *a0 = NULL;
zval *i0 = NULL;
zval *p3[] = { NULL, NULL, NULL }, *p4[] = { NULL };
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &v0, &v1, &v2) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!v2) {
PHALCON_INIT_VAR(v2);
ZVAL_BOOL(v2, 0);
}
PHALCON_INIT_VAR(t0);
ZVAL_STRING(t0, "email", 1);
PHALCON_ALLOC_ZVAL_MM(r0);
is_equal_function(r0, v1, t0 TSRMLS_CC);
if (zend_is_true(r0)) {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_INIT_VAR(t1);
ZVAL_LONG(t1, 517);
PHALCON_CALL_FUNC_PARAMS_2(r1, "filter_var", v0, t1, 0x03D);
PHALCON_RETURN_DZVAL(r1);
}
PHALCON_INIT_VAR(t2);
ZVAL_STRING(t2, "int", 1);
PHALCON_ALLOC_ZVAL_MM(r2);
is_equal_function(r2, v1, t2 TSRMLS_CC);
if (zend_is_true(r2)) {
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_INIT_VAR(t3);
ZVAL_LONG(t3, 519);
PHALCON_CALL_FUNC_PARAMS_2(r3, "filter_var", v0, t3, 0x03D);
PHALCON_RETURN_DZVAL(r3);
}
PHALCON_INIT_VAR(t4);
ZVAL_STRING(t4, "string", 1);
PHALCON_ALLOC_ZVAL_MM(r4);
is_equal_function(r4, v1, t4 TSRMLS_CC);
if (zend_is_true(r4)) {
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_INIT_VAR(t5);
ZVAL_LONG(t5, 513);
PHALCON_CALL_FUNC_PARAMS_2(r5, "filter_var", v0, t5, 0x03D);
PHALCON_RETURN_DZVAL(r5);
}
PHALCON_INIT_VAR(t6);
ZVAL_STRING(t6, "float", 1);
PHALCON_ALLOC_ZVAL_MM(r6);
is_equal_function(r6, v1, t6 TSRMLS_CC);
if (zend_is_true(r6)) {
PHALCON_ALLOC_ZVAL_MM(r7);
p3[0] = v0;
PHALCON_INIT_VAR(t7);
ZVAL_LONG(t7, 520);
p3[1] = t7;
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_INIT_VAR(t8);
ZVAL_LONG(t8, 4096);
Z_ADDREF_P(t8);
PHALCON_SEPARATE_ARRAY(a0);
add_assoc_zval(a0, "flags", t8);
p3[2] = a0;
PHALCON_CALL_FUNC_PARAMS(r7, "filter_var", 3, p3, 0x03D);
PHALCON_RETURN_DZVAL(r7);
}
if (!zend_is_true(v2)) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_exception_class_entry);
PHALCON_ALLOC_ZVAL_MM(r8);
PHALCON_CONCAT_BOTH(r8, "Sanitize filter ", v1, " is not supported");
Z_ADDREF_P(r8);
p4[0] = r8;
PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 1, p4, PHALCON_CALL_CHECK);
Z_DELREF_P(p4[0]);
zend_throw_exception_object(i0 TSRMLS_CC);
Z_ADDREF_P(i0);
PHALCON_MM_RESTORE();
return;
} else {
PHALCON_RETURN_CHECK_CTOR(v0);
}
se_e618_2:
if(0) { };
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* Returns an array of Phalcon\Db\Column objects describing a table
*
* <code>print_r($connection->describeColumns("posts")); ?></code>
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Column[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeColumns){
zval *table = NULL, *schema = NULL, *columns = NULL, *sql = NULL, *fetch_assoc = NULL;
zval *describe = NULL, *old_column = NULL, *field = NULL, *definition = NULL;
zval *column_type = NULL;
zval *status = NULL, *matches = NULL, *pattern = NULL, *attribute = NULL, *column_name = NULL;
zval *column = NULL, *dialect = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *status2 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!schema) {
PHALCON_ALLOC_ZVAL_MM(schema);
ZVAL_NULL(schema);
}
PHALCON_INIT_VAR(columns);
array_init(columns);
PHALCON_ALLOC_ZVAL_MM(dialect);
phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describecolumns", table, schema, PH_NO_CHECK);
PHALCON_INIT_VAR(fetch_assoc);
phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SL("FETCH_ASSOC") TSRMLS_CC);
PHALCON_INIT_VAR(describe);
PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc, PH_NO_CHECK);
PHALCON_INIT_VAR(old_column);
ZVAL_NULL(old_column);
if (!phalcon_valid_foreach(describe TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(describe);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_VALUE(field);
PHALCON_INIT_VAR(definition);
array_init(definition);
add_assoc_long_ex(definition, SS("bindType"), 2);
PHALCON_INIT_VAR(column_type);
phalcon_array_fetch_string(&column_type, field, SL("type"), PH_NOISY_CC);
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("int") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
add_assoc_long_ex(definition, SS("type"), 0);
add_assoc_bool_ex(definition, SS("isNumeric"), 1);
add_assoc_long_ex(definition, SS("size"), 32); // default 4byte
add_assoc_long_ex(definition, SS("bindType"), 1);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("varchar") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_long(&definition, SL("size"), 255, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("date") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_long(&definition, SL("type"), 1, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_long(&definition, SL("size"), 0, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
PHALCON_INIT_VAR(status2);
phalcon_fast_strpos_str(status, column_type, SL("numeric") TSRMLS_CC);
phalcon_fast_strpos_str(status2, column_type, SL("decimal") TSRMLS_CC);
if ( (PHALCON_IS_NOT_FALSE(status)) || (PHALCON_IS_NOT_FALSE(status2)) ) {
add_assoc_long_ex(definition, SS("type"), 3);
add_assoc_bool_ex(definition, SS("isNumeric"), 1);
add_assoc_long_ex(definition, SS("size"), 32); // default 4byte
add_assoc_long_ex(definition, SS("bindType"), 32);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("char") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
add_assoc_long_ex(definition, SS("type"), 5);
phalcon_array_update_string_long(&definition, SL("size"), 255, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("timestamp") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
add_assoc_long_ex(definition, SS("type"), 4);
phalcon_array_update_string_long(&definition, SL("size"), 0, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("text") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
add_assoc_long_ex(definition, SS("type"), 6);
phalcon_array_update_string_long(&definition, SL("size"), 2147483647, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("float") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
add_assoc_long_ex(definition, SS("type"), 7);
add_assoc_bool_ex(definition, SS("isNumeric"), 1);
add_assoc_long_ex(definition, SS("size"), 64); // default 4byte
add_assoc_long_ex(definition, SS("bindType"), 32);
} else {
add_assoc_long_ex(definition, SS("type"), 5);
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("uuid") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_long(&definition, SL("size"), 36, PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_update_string_long(&definition, SL("size"), 255, PH_SEPARATE TSRMLS_CC);
}
}
}
}
}
}
}
}
}
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("(") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
PHALCON_INIT_VAR(matches);
array_init(matches);
PHALCON_INIT_VAR(pattern);
ZVAL_STRING(pattern, "#\\(([0-9]+)(,[0-9]+)*\\)#", 1);
Z_SET_ISREF_P(matches);
PHALCON_INIT_VAR(r0);
PHALCON_CALL_FUNC_PARAMS_3(r0, "preg_match", pattern, column_type, matches);
Z_UNSET_ISREF_P(matches);
if (zend_is_true(r0)) {
eval_int = phalcon_array_isset_long(matches, 1);
if (eval_int) {
PHALCON_INIT_VAR(r1);
phalcon_array_fetch_long(&r1, matches, 1, PH_NOISY_CC);
phalcon_array_update_string(&definition, SL("size"), &r1, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
}
}
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("unsigned") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_bool(&definition, SL("unsigned"), 1, PH_SEPARATE TSRMLS_CC);
}
if (Z_TYPE_P(old_column) == IS_NULL) {
phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_update_string(&definition, SL("after"), &old_column, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(attribute);
phalcon_array_fetch_string(&attribute, field, SL("pk"), PH_NOISY_CC);
if (PHALCON_COMPARE_STRING(attribute, "1")) {
phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_SEPARATE TSRMLS_CC);
}else {
phalcon_array_update_string_bool(&definition, SL("primary"), 0, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(attribute);
phalcon_array_fetch_string(&attribute, field, SL("notnull"), PH_NOISY_CC);
if (PHALCON_COMPARE_STRING(attribute, "1")) {
phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(r0);
phalcon_fast_strpos_str(r0, column_type, SL("integer") TSRMLS_CC);
PHALCON_INIT_VAR(r1);
phalcon_array_fetch_string(&r1, definition, SL("primary"), PH_NOISY_CC);
if ((PHALCON_IS_NOT_FALSE(r0)) && (PHALCON_IS_NOT_FALSE(r1))) {
phalcon_array_update_string_bool(&definition, SL("autoIncrement"), 1, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(column_name);
phalcon_array_fetch_string(&column_name, field, SL("name"), PH_NOISY_CC);
PHALCON_INIT_VAR(column);
object_init_ex(column, phalcon_db_column_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(column, "__construct", column_name, definition, PH_CHECK);
phalcon_array_append(&columns, column, PH_SEPARATE TSRMLS_CC);
PHALCON_CPY_WRT(old_column, column_name);
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
RETURN_CTOR(columns);}
/**
* Internal filter function
*
* @parammixed $value
* @paramarray $filters
* @param boolean $silent
* @returnmixed
*/
PHP_METHOD(Phalcon_Filter, _filter){
zval *v0 = NULL, *v1 = NULL, *v2 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL;
zval *t0 = NULL, *t1 = NULL;
zval *i0 = NULL;
zval *p2[] = { NULL };
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &v0, &v1, &v2) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!v2) {
PHALCON_INIT_VAR(v2);
ZVAL_BOOL(v2, 0);
}
PHALCON_INIT_VAR(t0);
ZVAL_STRING(t0, "extraspaces", 1);
PHALCON_ALLOC_ZVAL_MM(r0);
is_equal_function(r0, v1, t0 TSRMLS_CC);
if (zend_is_true(r0)) {
PHALCON_ALLOC_ZVAL_MM(r1);
Z_ADDREF_P(v0);
PHALCON_CALL_FUNC_PARAMS_1(r1, "trim", v0, 0x020);
Z_DELREF_P(v0);
PHALCON_RETURN_DZVAL(r1);
}
PHALCON_INIT_VAR(t1);
ZVAL_STRING(t1, "striptags", 1);
PHALCON_ALLOC_ZVAL_MM(r2);
is_equal_function(r2, v1, t1 TSRMLS_CC);
if (zend_is_true(r2)) {
PHALCON_ALLOC_ZVAL_MM(r3);
Z_ADDREF_P(v0);
PHALCON_CALL_FUNC_PARAMS_1(r3, "strip_tags", v0, 0x03E);
Z_DELREF_P(v0);
PHALCON_RETURN_DZVAL(r3);
}
if (!zend_is_true(v2)) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_exception_class_entry);
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CONCAT_BOTH(r4, "Filter ", v1, " is not supported");
Z_ADDREF_P(r4);
p2[0] = r4;
PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 1, p2, PHALCON_CALL_CHECK);
Z_DELREF_P(p2[0]);
zend_throw_exception_object(i0 TSRMLS_CC);
Z_ADDREF_P(i0);
PHALCON_MM_RESTORE();
return;
} else {
PHALCON_RETURN_CHECK_CTOR(v0);
}
se_e618_3:
if(0) { };
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* Throws an internal exception
*/
PHP_METHOD(Phalcon_Mvc_Dispatcher, _throwDispatchException) {
zend_long exceptionCode, ZEPHIR_LAST_CALL_STATUS;
zval *message_param = NULL, *exceptionCode_param = NULL, *dependencyInjector = NULL, *response = NULL, *exception = NULL, *_3 = NULL, *_4 = NULL, *_5, *_0$$3, *_1$$3, *_2$$3;
zval *message = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &message_param, &exceptionCode_param);
if (UNEXPECTED(Z_TYPE_P(message_param) != IS_STRING && Z_TYPE_P(message_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'message' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(message_param) == IS_STRING)) {
zephir_get_strval(message, message_param);
} else {
ZEPHIR_INIT_VAR(message);
ZVAL_EMPTY_STRING(message);
}
if (!exceptionCode_param) {
exceptionCode = 0;
} else {
exceptionCode = zephir_get_intval(exceptionCode_param);
}
ZEPHIR_OBS_VAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_INIT_VAR(_0$$3);
object_init_ex(_0$$3, phalcon_mvc_dispatcher_exception_ce);
ZEPHIR_INIT_VAR(_1$$3);
ZVAL_STRING(_1$$3, "A dependency injection container is required to access the 'response' service", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_2$$3);
ZVAL_LONG(_2$$3, 0);
ZEPHIR_CALL_METHOD(NULL, _0$$3, "__construct", NULL, 9, _1$$3, _2$$3);
zephir_check_temp_parameter(_1$$3);
zephir_check_call_status();
zephir_throw_exception_debug(_0$$3, "phalcon/mvc/dispatcher.zep", 127 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_INIT_VAR(_4);
ZVAL_STRING(_4, "response", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_3, dependencyInjector, "getshared", NULL, 0, _4);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
ZEPHIR_CPY_WRT(response, _3);
ZEPHIR_INIT_NVAR(_4);
ZVAL_LONG(_4, 404);
ZEPHIR_INIT_VAR(_5);
ZVAL_STRING(_5, "Not Found", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, response, "setstatuscode", NULL, 0, _4, _5);
zephir_check_temp_parameter(_5);
zephir_check_call_status();
ZEPHIR_INIT_VAR(exception);
object_init_ex(exception, phalcon_mvc_dispatcher_exception_ce);
ZEPHIR_INIT_NVAR(_4);
ZVAL_LONG(_4, exceptionCode);
ZEPHIR_CALL_METHOD(NULL, exception, "__construct", NULL, 9, message, _4);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_3, this_ptr, "_handleexception", NULL, 0, exception);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_3)) {
RETURN_MM_BOOL(0);
}
zephir_throw_exception_debug(exception, "phalcon/mvc/dispatcher.zep", 149 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
/* {{{ length unsigned long
readonly=yes
URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#DOMImplementationList-length
Since:
*/
int dom_domimplementationlist_length_read(dom_object *obj, zval *retval)
{
ZVAL_STRING(retval, "TEST");
return SUCCESS;
}
/**
* Set the background color of an image
*/
PHP_METHOD(Phalcon_Image_Adapter, background) {
zend_bool _0;
int opacity, ZEPHIR_LAST_CALL_STATUS;
zval *color_param = NULL, *opacity_param = NULL, *colors = NULL, _1, _2, *_3, _4 = zval_used_for_init, *_5 = NULL, *_6, *_7 = NULL, *_8, *_9, *_10;
zval *color = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &color_param, &opacity_param);
zephir_get_strval(color, color_param);
if (!opacity_param) {
opacity = 100;
} else {
opacity = zephir_get_intval(opacity_param);
}
_0 = zephir_fast_strlen_ev(color) > 1;
if (_0) {
ZEPHIR_SINIT_VAR(_1);
ZVAL_LONG(&_1, 0);
ZEPHIR_SINIT_VAR(_2);
ZVAL_LONG(&_2, 1);
ZEPHIR_INIT_VAR(_3);
zephir_substr(_3, color, 0 , 1 , 0);
_0 = ZEPHIR_IS_STRING_IDENTICAL(_3, "#");
}
if (_0) {
ZEPHIR_SINIT_VAR(_4);
ZVAL_LONG(&_4, 1);
ZEPHIR_INIT_VAR(_5);
zephir_substr(_5, color, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
zephir_get_strval(color, _5);
}
if (zephir_fast_strlen_ev(color) == 3) {
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRING(_5, "/./", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_6);
ZVAL_STRING(_6, "$0$0", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_FUNCTION(&_7, "preg_replace", NULL, 29, _5, _6, color);
zephir_check_temp_parameter(_5);
zephir_check_temp_parameter(_6);
zephir_check_call_status();
zephir_get_strval(color, _7);
}
ZEPHIR_SINIT_NVAR(_4);
ZVAL_LONG(&_4, 2);
ZEPHIR_CALL_FUNCTION(&_7, "str_split", NULL, 69, color, &_4);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_4);
ZVAL_STRING(&_4, "hexdec", 0);
ZEPHIR_CALL_FUNCTION(&colors, "array_map", NULL, 70, &_4, _7);
zephir_check_call_status();
zephir_array_fetch_long(&_8, colors, 0, PH_NOISY | PH_READONLY, "phalcon/image/adapter.zep", 366 TSRMLS_CC);
zephir_array_fetch_long(&_9, colors, 1, PH_NOISY | PH_READONLY, "phalcon/image/adapter.zep", 366 TSRMLS_CC);
zephir_array_fetch_long(&_10, colors, 2, PH_NOISY | PH_READONLY, "phalcon/image/adapter.zep", 366 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_5);
ZVAL_LONG(_5, opacity);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_background", NULL, 0, _8, _9, _10, _5);
zephir_check_call_status();
RETURN_THIS();
}
PHPAPI int php_var_unserialize(UNSERIALIZE_PARAMETER)
{
const unsigned char *cursor, *limit, *marker, *start;
zval **rval_ref;
limit = max;
cursor = *p;
if (YYCURSOR >= YYLIMIT) {
return 0;
}
if (var_hash && cursor[0] != 'R') {
var_push(var_hash, rval);
}
start = cursor;
{
YYCTYPE yych;
static const unsigned char yybm[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
};
if ((YYLIMIT - YYCURSOR) < 7) YYFILL(7);
yych = *YYCURSOR;
switch (yych) {
case 'C':
case 'O': goto yy13;
case 'N': goto yy5;
case 'R': goto yy2;
case 'S': goto yy10;
case 'a': goto yy11;
case 'b': goto yy6;
case 'd': goto yy8;
case 'i': goto yy7;
case 'o': goto yy12;
case 'r': goto yy4;
case 's': goto yy9;
case '}': goto yy14;
default: goto yy16;
}
yy2:
yych = *(YYMARKER = ++YYCURSOR);
if (yych == ':') goto yy95;
yy3:
{ return 0; }
yy4:
yych = *(YYMARKER = ++YYCURSOR);
if (yych == ':') goto yy89;
goto yy3;
yy5:
yych = *++YYCURSOR;
if (yych == ';') goto yy87;
goto yy3;
yy6:
yych = *(YYMARKER = ++YYCURSOR);
if (yych == ':') goto yy83;
goto yy3;
yy7:
yych = *(YYMARKER = ++YYCURSOR);
if (yych == ':') goto yy77;
goto yy3;
yy8:
yych = *(YYMARKER = ++YYCURSOR);
if (yych == ':') goto yy53;
goto yy3;
yy9:
yych = *(YYMARKER = ++YYCURSOR);
if (yych == ':') goto yy46;
goto yy3;
yy10:
yych = *(YYMARKER = ++YYCURSOR);
if (yych == ':') goto yy39;
goto yy3;
yy11:
yych = *(YYMARKER = ++YYCURSOR);
if (yych == ':') goto yy32;
goto yy3;
yy12:
yych = *(YYMARKER = ++YYCURSOR);
if (yych == ':') goto yy25;
goto yy3;
yy13:
yych = *(YYMARKER = ++YYCURSOR);
if (yych == ':') goto yy17;
goto yy3;
yy14:
++YYCURSOR;
{
/* this is the case where we have less data than planned */
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Unexpected end of serialized data");
return 0; /* not sure if it should be 0 or 1 here? */
}
yy16:
yych = *++YYCURSOR;
goto yy3;
yy17:
yych = *++YYCURSOR;
if (yybm[0+yych] & 128) {
goto yy20;
}
if (yych == '+') goto yy19;
yy18:
YYCURSOR = YYMARKER;
goto yy3;
yy19:
yych = *++YYCURSOR;
if (yybm[0+yych] & 128) {
goto yy20;
}
goto yy18;
yy20:
++YYCURSOR;
if ((YYLIMIT - YYCURSOR) < 2) YYFILL(2);
yych = *YYCURSOR;
if (yybm[0+yych] & 128) {
goto yy20;
}
if (yych != ':') goto yy18;
yych = *++YYCURSOR;
if (yych != '"') goto yy18;
++YYCURSOR;
{
size_t len, len2, len3, maxlen;
long elements;
char *class_name;
zend_class_entry *ce;
zend_class_entry **pce;
int incomplete_class = 0;
int custom_object = 0;
zval *user_func;
zval *retval_ptr;
zval **args[1];
zval *arg_func_name;
if (*start == 'C') {
custom_object = 1;
}
INIT_PZVAL(*rval);
len2 = len = parse_uiv(start + 2);
maxlen = max - YYCURSOR;
if (maxlen < len || len == 0) {
*p = start + 2;
return 0;
}
class_name = (char*)YYCURSOR;
YYCURSOR += len;
if (*(YYCURSOR) != '"') {
*p = YYCURSOR;
return 0;
}
if (*(YYCURSOR+1) != ':') {
*p = YYCURSOR+1;
return 0;
}
len3 = strspn(class_name, "0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377\\");
if (len3 != len)
{
*p = YYCURSOR + len3 - len;
return 0;
}
class_name = estrndup(class_name, len);
do {
/* Try to find class directly */
BG(serialize_lock)++;
if (zend_lookup_class(class_name, len2, &pce TSRMLS_CC) == SUCCESS) {
BG(serialize_lock)--;
if (EG(exception)) {
efree(class_name);
return 0;
}
ce = *pce;
break;
}
BG(serialize_lock)--;
if (EG(exception)) {
efree(class_name);
return 0;
}
/* Check for unserialize callback */
if ((PG(unserialize_callback_func) == NULL) || (PG(unserialize_callback_func)[0] == '\0')) {
incomplete_class = 1;
ce = PHP_IC_ENTRY;
break;
}
/* Call unserialize callback */
MAKE_STD_ZVAL(user_func);
ZVAL_STRING(user_func, PG(unserialize_callback_func), 1);
args[0] = &arg_func_name;
MAKE_STD_ZVAL(arg_func_name);
ZVAL_STRING(arg_func_name, class_name, 1);
BG(serialize_lock)++;
if (call_user_function_ex(CG(function_table), NULL, user_func, &retval_ptr, 1, args, 0, NULL TSRMLS_CC) != SUCCESS) {
BG(serialize_lock)--;
if (EG(exception)) {
efree(class_name);
zval_ptr_dtor(&user_func);
zval_ptr_dtor(&arg_func_name);
return 0;
}
php_error_docref(NULL TSRMLS_CC, E_WARNING, "defined (%s) but not found", user_func->value.str.val);
incomplete_class = 1;
ce = PHP_IC_ENTRY;
zval_ptr_dtor(&user_func);
zval_ptr_dtor(&arg_func_name);
break;
}
BG(serialize_lock)--;
if (retval_ptr) {
zval_ptr_dtor(&retval_ptr);
}
if (EG(exception)) {
efree(class_name);
zval_ptr_dtor(&user_func);
zval_ptr_dtor(&arg_func_name);
return 0;
}
/* The callback function may have defined the class */
if (zend_lookup_class(class_name, len2, &pce TSRMLS_CC) == SUCCESS) {
ce = *pce;
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Function %s() hasn't defined the class it was called for", user_func->value.str.val);
incomplete_class = 1;
ce = PHP_IC_ENTRY;
}
zval_ptr_dtor(&user_func);
zval_ptr_dtor(&arg_func_name);
break;
} while (1);
*p = YYCURSOR;
if (custom_object) {
int ret;
ret = object_custom(UNSERIALIZE_PASSTHRU, ce);
if (ret && incomplete_class) {
php_store_class_name(*rval, class_name, len2);
}
efree(class_name);
return ret;
}
elements = object_common1(UNSERIALIZE_PASSTHRU, ce);
if (incomplete_class) {
php_store_class_name(*rval, class_name, len2);
}
efree(class_name);
return object_common2(UNSERIALIZE_PASSTHRU, elements);
}
yy25:
yych = *++YYCURSOR;
if (yych <= ',') {
if (yych != '+') goto yy18;
} else {
if (yych <= '-') goto yy26;
if (yych <= '/') goto yy18;
if (yych <= '9') goto yy27;
goto yy18;
}
yy26:
yych = *++YYCURSOR;
if (yych <= '/') goto yy18;
if (yych >= ':') goto yy18;
yy27:
++YYCURSOR;
if ((YYLIMIT - YYCURSOR) < 2) YYFILL(2);
yych = *YYCURSOR;
if (yych <= '/') goto yy18;
if (yych <= '9') goto yy27;
if (yych >= ';') goto yy18;
yych = *++YYCURSOR;
if (yych != '"') goto yy18;
++YYCURSOR;
{
INIT_PZVAL(*rval);
return object_common2(UNSERIALIZE_PASSTHRU,
object_common1(UNSERIALIZE_PASSTHRU, ZEND_STANDARD_CLASS_DEF_PTR));
}
yy32:
yych = *++YYCURSOR;
if (yych == '+') goto yy33;
if (yych <= '/') goto yy18;
if (yych <= '9') goto yy34;
goto yy18;
yy33:
yych = *++YYCURSOR;
if (yych <= '/') goto yy18;
if (yych >= ':') goto yy18;
yy34:
++YYCURSOR;
if ((YYLIMIT - YYCURSOR) < 2) YYFILL(2);
yych = *YYCURSOR;
if (yych <= '/') goto yy18;
if (yych <= '9') goto yy34;
if (yych >= ';') goto yy18;
yych = *++YYCURSOR;
if (yych != '{') goto yy18;
++YYCURSOR;
{
long elements = parse_iv(start + 2);
/* use iv() not uiv() in order to check data range */
*p = YYCURSOR;
if (elements < 0) {
return 0;
}
INIT_PZVAL(*rval);
array_init_size(*rval, elements);
if (!process_nested_data(UNSERIALIZE_PASSTHRU, Z_ARRVAL_PP(rval), elements, 0)) {
return 0;
}
return finish_nested_data(UNSERIALIZE_PASSTHRU);
}
yy39:
yych = *++YYCURSOR;
if (yych == '+') goto yy40;
if (yych <= '/') goto yy18;
if (yych <= '9') goto yy41;
goto yy18;
yy40:
yych = *++YYCURSOR;
if (yych <= '/') goto yy18;
if (yych >= ':') goto yy18;
yy41:
++YYCURSOR;
if ((YYLIMIT - YYCURSOR) < 2) YYFILL(2);
yych = *YYCURSOR;
if (yych <= '/') goto yy18;
if (yych <= '9') goto yy41;
if (yych >= ';') goto yy18;
yych = *++YYCURSOR;
if (yych != '"') goto yy18;
++YYCURSOR;
{
size_t len, maxlen;
char *str;
len = parse_uiv(start + 2);
maxlen = max - YYCURSOR;
if (maxlen < len) {
*p = start + 2;
return 0;
}
if ((str = unserialize_str(&YYCURSOR, &len, maxlen)) == NULL) {
return 0;
}
if (*(YYCURSOR) != '"') {
efree(str);
*p = YYCURSOR;
return 0;
}
YYCURSOR += 2;
*p = YYCURSOR;
INIT_PZVAL(*rval);
ZVAL_STRINGL(*rval, str, len, 0);
return 1;
}
yy46:
yych = *++YYCURSOR;
if (yych == '+') goto yy47;
if (yych <= '/') goto yy18;
if (yych <= '9') goto yy48;
goto yy18;
yy47:
yych = *++YYCURSOR;
if (yych <= '/') goto yy18;
if (yych >= ':') goto yy18;
yy48:
++YYCURSOR;
if ((YYLIMIT - YYCURSOR) < 2) YYFILL(2);
yych = *YYCURSOR;
if (yych <= '/') goto yy18;
if (yych <= '9') goto yy48;
if (yych >= ';') goto yy18;
yych = *++YYCURSOR;
if (yych != '"') goto yy18;
++YYCURSOR;
{
size_t len, maxlen;
char *str;
len = parse_uiv(start + 2);
maxlen = max - YYCURSOR;
if (maxlen < len) {
*p = start + 2;
return 0;
}
str = (char*)YYCURSOR;
YYCURSOR += len;
if (*(YYCURSOR) != '"') {
*p = YYCURSOR;
return 0;
}
YYCURSOR += 2;
*p = YYCURSOR;
INIT_PZVAL(*rval);
ZVAL_STRINGL(*rval, str, len, 1);
return 1;
}
yy53:
yych = *++YYCURSOR;
if (yych <= '/') {
if (yych <= ',') {
if (yych == '+') goto yy57;
goto yy18;
} else {
if (yych <= '-') goto yy55;
if (yych <= '.') goto yy60;
goto yy18;
}
} else {
if (yych <= 'I') {
if (yych <= '9') goto yy58;
if (yych <= 'H') goto yy18;
goto yy56;
} else {
if (yych != 'N') goto yy18;
}
}
yych = *++YYCURSOR;
if (yych == 'A') goto yy76;
goto yy18;
yy55:
yych = *++YYCURSOR;
if (yych <= '/') {
if (yych == '.') goto yy60;
goto yy18;
} else {
if (yych <= '9') goto yy58;
if (yych != 'I') goto yy18;
}
yy56:
yych = *++YYCURSOR;
if (yych == 'N') goto yy72;
goto yy18;
yy57:
yych = *++YYCURSOR;
if (yych == '.') goto yy60;
if (yych <= '/') goto yy18;
if (yych >= ':') goto yy18;
yy58:
++YYCURSOR;
if ((YYLIMIT - YYCURSOR) < 4) YYFILL(4);
yych = *YYCURSOR;
if (yych <= ':') {
if (yych <= '.') {
if (yych <= '-') goto yy18;
goto yy70;
} else {
if (yych <= '/') goto yy18;
if (yych <= '9') goto yy58;
goto yy18;
}
} else {
if (yych <= 'E') {
if (yych <= ';') goto yy63;
if (yych <= 'D') goto yy18;
goto yy65;
} else {
if (yych == 'e') goto yy65;
goto yy18;
}
}
yy60:
yych = *++YYCURSOR;
if (yych <= '/') goto yy18;
if (yych >= ':') goto yy18;
yy61:
++YYCURSOR;
if ((YYLIMIT - YYCURSOR) < 4) YYFILL(4);
yych = *YYCURSOR;
if (yych <= ';') {
if (yych <= '/') goto yy18;
if (yych <= '9') goto yy61;
if (yych <= ':') goto yy18;
} else {
if (yych <= 'E') {
if (yych <= 'D') goto yy18;
goto yy65;
} else {
if (yych == 'e') goto yy65;
goto yy18;
}
}
yy63:
++YYCURSOR;
{
#if SIZEOF_LONG == 4
use_double:
#endif
*p = YYCURSOR;
INIT_PZVAL(*rval);
ZVAL_DOUBLE(*rval, zend_strtod((const char *)start + 2, NULL));
return 1;
}
yy65:
yych = *++YYCURSOR;
if (yych <= ',') {
if (yych != '+') goto yy18;
} else {
if (yych <= '-') goto yy66;
if (yych <= '/') goto yy18;
if (yych <= '9') goto yy67;
goto yy18;
}
yy66:
yych = *++YYCURSOR;
if (yych <= ',') {
if (yych == '+') goto yy69;
goto yy18;
} else {
if (yych <= '-') goto yy69;
if (yych <= '/') goto yy18;
if (yych >= ':') goto yy18;
}
yy67:
++YYCURSOR;
if (YYLIMIT <= YYCURSOR) YYFILL(1);
yych = *YYCURSOR;
if (yych <= '/') goto yy18;
if (yych <= '9') goto yy67;
if (yych == ';') goto yy63;
goto yy18;
yy69:
yych = *++YYCURSOR;
if (yych <= '/') goto yy18;
if (yych <= '9') goto yy67;
goto yy18;
yy70:
++YYCURSOR;
if ((YYLIMIT - YYCURSOR) < 4) YYFILL(4);
yych = *YYCURSOR;
if (yych <= ';') {
if (yych <= '/') goto yy18;
if (yych <= '9') goto yy70;
if (yych <= ':') goto yy18;
goto yy63;
} else {
if (yych <= 'E') {
if (yych <= 'D') goto yy18;
goto yy65;
} else {
if (yych == 'e') goto yy65;
goto yy18;
}
}
yy72:
yych = *++YYCURSOR;
if (yych != 'F') goto yy18;
yy73:
yych = *++YYCURSOR;
if (yych != ';') goto yy18;
++YYCURSOR;
{
*p = YYCURSOR;
INIT_PZVAL(*rval);
if (!strncmp(start + 2, "NAN", 3)) {
ZVAL_DOUBLE(*rval, php_get_nan());
} else if (!strncmp(start + 2, "INF", 3)) {
ZVAL_DOUBLE(*rval, php_get_inf());
} else if (!strncmp(start + 2, "-INF", 4)) {
ZVAL_DOUBLE(*rval, -php_get_inf());
}
return 1;
}
yy76:
yych = *++YYCURSOR;
if (yych == 'N') goto yy73;
goto yy18;
yy77:
yych = *++YYCURSOR;
if (yych <= ',') {
if (yych != '+') goto yy18;
} else {
if (yych <= '-') goto yy78;
if (yych <= '/') goto yy18;
if (yych <= '9') goto yy79;
goto yy18;
}
yy78:
yych = *++YYCURSOR;
if (yych <= '/') goto yy18;
if (yych >= ':') goto yy18;
yy79:
++YYCURSOR;
if (YYLIMIT <= YYCURSOR) YYFILL(1);
yych = *YYCURSOR;
if (yych <= '/') goto yy18;
if (yych <= '9') goto yy79;
if (yych != ';') goto yy18;
++YYCURSOR;
{
#if SIZEOF_LONG == 4
int digits = YYCURSOR - start - 3;
if (start[2] == '-' || start[2] == '+') {
digits--;
}
/* Use double for large long values that were serialized on a 64-bit system */
if (digits >= MAX_LENGTH_OF_LONG - 1) {
if (digits == MAX_LENGTH_OF_LONG - 1) {
int cmp = strncmp(YYCURSOR - MAX_LENGTH_OF_LONG, long_min_digits, MAX_LENGTH_OF_LONG - 1);
if (!(cmp < 0 || (cmp == 0 && start[2] == '-'))) {
goto use_double;
}
} else {
goto use_double;
}
}
#endif
*p = YYCURSOR;
INIT_PZVAL(*rval);
ZVAL_LONG(*rval, parse_iv(start + 2));
return 1;
}
yy83:
yych = *++YYCURSOR;
if (yych <= '/') goto yy18;
if (yych >= '2') goto yy18;
yych = *++YYCURSOR;
if (yych != ';') goto yy18;
++YYCURSOR;
{
*p = YYCURSOR;
INIT_PZVAL(*rval);
ZVAL_BOOL(*rval, parse_iv(start + 2));
return 1;
}
yy87:
++YYCURSOR;
{
*p = YYCURSOR;
INIT_PZVAL(*rval);
ZVAL_NULL(*rval);
return 1;
}
yy89:
yych = *++YYCURSOR;
if (yych <= ',') {
if (yych != '+') goto yy18;
} else {
if (yych <= '-') goto yy90;
if (yych <= '/') goto yy18;
if (yych <= '9') goto yy91;
goto yy18;
}
yy90:
yych = *++YYCURSOR;
if (yych <= '/') goto yy18;
if (yych >= ':') goto yy18;
yy91:
++YYCURSOR;
if (YYLIMIT <= YYCURSOR) YYFILL(1);
yych = *YYCURSOR;
if (yych <= '/') goto yy18;
if (yych <= '9') goto yy91;
if (yych != ';') goto yy18;
++YYCURSOR;
{
long id;
*p = YYCURSOR;
if (!var_hash) return 0;
id = parse_iv(start + 2) - 1;
if (id == -1 || var_access(var_hash, id, &rval_ref) != SUCCESS) {
return 0;
}
if (*rval == *rval_ref) return 0;
if (*rval != NULL) {
var_push_dtor_no_addref(var_hash, rval);
}
*rval = *rval_ref;
Z_ADDREF_PP(rval);
Z_UNSET_ISREF_PP(rval);
return 1;
}
yy95:
yych = *++YYCURSOR;
if (yych <= ',') {
if (yych != '+') goto yy18;
} else {
if (yych <= '-') goto yy96;
if (yych <= '/') goto yy18;
if (yych <= '9') goto yy97;
goto yy18;
}
yy96:
yych = *++YYCURSOR;
if (yych <= '/') goto yy18;
if (yych >= ':') goto yy18;
yy97:
++YYCURSOR;
if (YYLIMIT <= YYCURSOR) YYFILL(1);
yych = *YYCURSOR;
if (yych <= '/') goto yy18;
if (yych <= '9') goto yy97;
if (yych != ';') goto yy18;
++YYCURSOR;
{
long id;
*p = YYCURSOR;
if (!var_hash) return 0;
id = parse_iv(start + 2) - 1;
if (id == -1 || var_access(var_hash, id, &rval_ref) != SUCCESS) {
return 0;
}
if (*rval != NULL) {
zval_ptr_dtor(rval);
}
*rval = *rval_ref;
Z_ADDREF_PP(rval);
Z_SET_ISREF_PP(rval);
return 1;
}
}
return 0;
}
/**
* 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);
}
/**
* Produce the routing parameters from the rewrite information
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, handle) {
zephir_fcall_cache_entry *_9 = NULL, *_17 = NULL, *_18 = NULL;
HashTable *_2, *_7, *_11, *_15;
HashPosition _1, _6, _10, _14;
int ZEPHIR_LAST_CALL_STATUS;
zval *uri_param = NULL, *realUri = NULL, *annotationsService = NULL, *handlers, *controllerSuffix, *scope = NULL, *prefix = NULL, *dependencyInjector = NULL, *handler = NULL, *controllerName = NULL, *lowerControllerName = NULL, *namespaceName = NULL, *moduleName = NULL, *sufixed = NULL, *handlerAnnotations = NULL, *classAnnotations = NULL, *annotations = NULL, *annotation = NULL, *methodAnnotations = NULL, *lowercased = NULL, *method = NULL, *collection = NULL, *_0, **_3, *_4, *_5 = NULL, **_8, **_12, *_13 = NULL, **_16;
zval *uri = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &uri_param);
if (!uri_param) {
ZEPHIR_INIT_VAR(uri);
ZVAL_EMPTY_STRING(uri);
} else {
if (unlikely(Z_TYPE_P(uri_param) != IS_STRING && Z_TYPE_P(uri_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'uri' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(uri_param) == IS_STRING)) {
zephir_get_strval(uri, uri_param);
} else {
ZEPHIR_INIT_VAR(uri);
ZVAL_EMPTY_STRING(uri);
}
}
if (!(uri && Z_STRLEN_P(uri))) {
ZEPHIR_CALL_METHOD(&realUri, this_ptr, "getrewriteuri", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(realUri, uri);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_processed"), PH_NOISY_CC);
if (!(zephir_is_true(_0))) {
ZEPHIR_INIT_VAR(annotationsService);
ZVAL_NULL(annotationsService);
ZEPHIR_OBS_VAR(handlers);
zephir_read_property_this(&handlers, this_ptr, SL("_handlers"), PH_NOISY_CC);
if (Z_TYPE_P(handlers) == IS_ARRAY) {
ZEPHIR_OBS_VAR(controllerSuffix);
zephir_read_property_this(&controllerSuffix, this_ptr, SL("_controllerSuffix"), PH_NOISY_CC);
zephir_is_iterable(handlers, &_2, &_1, 0, 0, "phalcon/mvc/router/annotations.zep", 208);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(scope, _3);
if (Z_TYPE_P(scope) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(prefix);
zephir_array_fetch_long(&prefix, scope, 0, PH_NOISY, "phalcon/mvc/router/annotations.zep", 117 TSRMLS_CC);
if (!(ZEPHIR_IS_EMPTY(prefix))) {
if (!(zephir_start_with(realUri, prefix, NULL))) {
continue;
}
}
if (Z_TYPE_P(annotationsService) != IS_OBJECT) {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(dependencyInjector, _4);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_router_exception_ce, "A dependency injection container is required to access the 'annotations' service", "phalcon/mvc/router/annotations.zep", 129);
return;
}
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRING(_5, "annotations", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&annotationsService, dependencyInjector, "getshared", NULL, 0, _5);
zephir_check_temp_parameter(_5);
zephir_check_call_status();
}
ZEPHIR_OBS_NVAR(handler);
zephir_array_fetch_long(&handler, scope, 1, PH_NOISY, "phalcon/mvc/router/annotations.zep", 138 TSRMLS_CC);
if (zephir_memnstr_str(handler, SL("\\"), "phalcon/mvc/router/annotations.zep", 140)) {
ZEPHIR_INIT_NVAR(controllerName);
zephir_get_class_ns(controllerName, handler, 0 TSRMLS_CC);
ZEPHIR_INIT_NVAR(lowerControllerName);
zephir_uncamelize(lowerControllerName, controllerName);
ZEPHIR_INIT_NVAR(namespaceName);
zephir_get_ns_class(namespaceName, handler, 0 TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(controllerName, handler);
ZEPHIR_INIT_NVAR(lowerControllerName);
zephir_uncamelize(lowerControllerName, controllerName);
ZEPHIR_INIT_NVAR(namespaceName);
ZVAL_NULL(namespaceName);
}
zephir_update_property_this(this_ptr, SL("_routePrefix"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
ZEPHIR_OBS_NVAR(moduleName);
zephir_array_isset_long_fetch(&moduleName, scope, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_NVAR(sufixed);
ZEPHIR_CONCAT_VV(sufixed, handler, controllerSuffix);
ZEPHIR_CALL_METHOD(&handlerAnnotations, annotationsService, "get", NULL, 0, sufixed);
zephir_check_call_status();
if (Z_TYPE_P(handlerAnnotations) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&classAnnotations, handlerAnnotations, "getclassannotations", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(classAnnotations) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&annotations, classAnnotations, "getannotations", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(annotations) == IS_ARRAY) {
zephir_is_iterable(annotations, &_7, &_6, 0, 0, "phalcon/mvc/router/annotations.zep", 187);
for (
; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS
; zephir_hash_move_forward_ex(_7, &_6)
) {
ZEPHIR_GET_HVALUE(annotation, _8);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "processcontrollerannotation", &_9, 0, controllerName, annotation);
zephir_check_call_status();
}
}
}
ZEPHIR_CALL_METHOD(&methodAnnotations, handlerAnnotations, "getmethodsannotations", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(methodAnnotations) == IS_ARRAY) {
ZEPHIR_INIT_NVAR(lowercased);
zephir_uncamelize(lowercased, handler);
zephir_is_iterable(methodAnnotations, &_11, &_10, 0, 0, "phalcon/mvc/router/annotations.zep", 203);
for (
; zephir_hash_get_current_data_ex(_11, (void**) &_12, &_10) == SUCCESS
; zephir_hash_move_forward_ex(_11, &_10)
) {
ZEPHIR_GET_HMKEY(method, _11, _10);
ZEPHIR_GET_HVALUE(collection, _12);
if (Z_TYPE_P(collection) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&_13, collection, "getannotations", NULL, 0);
zephir_check_call_status();
zephir_is_iterable(_13, &_15, &_14, 0, 0, "phalcon/mvc/router/annotations.zep", 201);
for (
; zephir_hash_get_current_data_ex(_15, (void**) &_16, &_14) == SUCCESS
; zephir_hash_move_forward_ex(_15, &_14)
) {
ZEPHIR_GET_HVALUE(annotation, _16);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "processactionannotation", &_17, 0, moduleName, namespaceName, lowerControllerName, method, annotation);
zephir_check_call_status();
}
}
}
}
}
}
}
}
zephir_update_property_this(this_ptr, SL("_processed"), (1) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
ZEPHIR_CALL_PARENT(NULL, phalcon_mvc_router_annotations_ce, this_ptr, "handle", &_18, 367, realUri);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}