/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_StringLength, validate) {
zend_bool _1, _3;
zephir_fcall_cache_entry *_8 = NULL, *_10 = 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, *_0 = NULL, *_2 = NULL, *_4$$8, *_5$$9 = NULL, *_7$$9 = NULL, *_9$$9, *_6$$10, *_11$$11, *_12$$12 = NULL, *_14$$12 = NULL, *_15$$12, *_13$$13;
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, "issetoption", 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, "issetoption", 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", 62);
return;
}
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "allowEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_2, this_ptr, "issetoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
_3 = zephir_is_true(_2);
if (_3) {
_3 = ZEPHIR_IS_EMPTY(value);
}
if (_3) {
RETURN_MM_BOOL(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();
}
if ((zephir_function_exists_ex(SS("mb_strlen") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_FUNCTION(&length, "mb_strlen", NULL, 357, 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$$8);
ZVAL_STRING(_4$$8, "max", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&maximum, this_ptr, "getoption", NULL, 0, _4$$8);
zephir_check_temp_parameter(_4$$8);
zephir_check_call_status();
if (ZEPHIR_GT(length, maximum)) {
ZEPHIR_INIT_VAR(_5$$9);
ZVAL_STRING(_5$$9, "messageMaximum", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _5$$9);
zephir_check_temp_parameter(_5$$9);
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 (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_VAR(_6$$10);
ZVAL_STRING(_6$$10, "TooLong", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _6$$10);
zephir_check_temp_parameter(_6$$10);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_5$$9);
object_init_ex(_5$$9, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_7$$9, "strtr", &_8, 55, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_9$$9);
ZVAL_STRING(_9$$9, "TooLong", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _5$$9, "__construct", &_10, 435, _7$$9, field, _9$$9);
zephir_check_temp_parameter(_9$$9);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _5$$9);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
if (zephir_is_true(isSetMin)) {
ZEPHIR_INIT_VAR(_11$$11);
ZVAL_STRING(_11$$11, "min", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&minimum, this_ptr, "getoption", NULL, 0, _11$$11);
zephir_check_temp_parameter(_11$$11);
zephir_check_call_status();
if (ZEPHIR_LT(length, minimum)) {
ZEPHIR_INIT_VAR(_12$$12);
ZVAL_STRING(_12$$12, "messageMinimum", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _12$$12);
zephir_check_temp_parameter(_12$$12);
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 (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_VAR(_13$$13);
ZVAL_STRING(_13$$13, "TooShort", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _13$$13);
zephir_check_temp_parameter(_13$$13);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_12$$12);
object_init_ex(_12$$12, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_14$$12, "strtr", &_8, 55, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_15$$12);
ZVAL_STRING(_15$$12, "TooShort", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _12$$12, "__construct", &_10, 435, _14$$12, field, _15$$12);
zephir_check_temp_parameter(_15$$12);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _12$$12);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
RETURN_MM_BOOL(1);
}
/**
* Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php
*
* @return array
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, _loadTemplateEngines) {
HashTable *_2$$5;
HashPosition _1$$5;
zval *engines = NULL, *dependencyInjector = NULL, *registeredEngines = NULL, *arguments = NULL, *extension = NULL, *engineService = NULL, *engineObject = NULL, *_0$$4, **_3$$5, *_5$$13 = NULL, *_6$$13 = NULL;
zephir_fcall_cache_entry *_4 = NULL, *_7 = NULL;
zend_long ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(engines);
zephir_read_property_this(&engines, this_ptr, SL("_engines"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(engines)) {
ZEPHIR_OBS_VAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(engines);
array_init(engines);
ZEPHIR_OBS_VAR(registeredEngines);
zephir_read_property_this(®isteredEngines, this_ptr, SL("_registeredEngines"), PH_NOISY_CC);
if (Z_TYPE_P(registeredEngines) != IS_ARRAY) {
ZEPHIR_INIT_VAR(_0$$4);
object_init_ex(_0$$4, phalcon_mvc_view_engine_php_ce);
ZEPHIR_CALL_METHOD(NULL, _0$$4, "__construct", NULL, 391, this_ptr, dependencyInjector);
zephir_check_call_status();
zephir_array_update_string(&engines, SL(".phtml"), &_0$$4, PH_COPY | PH_SEPARATE);
} else {
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_view_exception_ce, "A dependency injector container is required to obtain the application services", "phalcon/mvc/view/simple.zep", 159);
return;
}
ZEPHIR_INIT_VAR(arguments);
zephir_create_array(arguments, 2, 0 TSRMLS_CC);
zephir_array_fast_append(arguments, this_ptr);
zephir_array_fast_append(arguments, dependencyInjector);
zephir_is_iterable(registeredEngines, &_2$$5, &_1$$5, 0, 0, "phalcon/mvc/view/simple.zep", 191);
for (
; zend_hash_get_current_data_ex(_2$$5, (void**) &_3$$5, &_1$$5) == SUCCESS
; zend_hash_move_forward_ex(_2$$5, &_1$$5)
) {
ZEPHIR_GET_HMKEY(extension, _2$$5, _1$$5);
ZEPHIR_GET_HVALUE(engineService, _3$$5);
if (Z_TYPE_P(engineService) == IS_OBJECT) {
if (zephir_instance_of_ev(engineService, zend_ce_closure TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(engineObject);
ZEPHIR_CALL_USER_FUNC_ARRAY(engineObject, engineService, arguments);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(engineObject, engineService);
}
} else {
if (Z_TYPE_P(engineService) == IS_STRING) {
ZEPHIR_CALL_METHOD(&engineObject, dependencyInjector, "getshared", &_4, 0, engineService, arguments);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(_5$$13);
object_init_ex(_5$$13, phalcon_mvc_view_exception_ce);
ZEPHIR_INIT_LNVAR(_6$$13);
ZEPHIR_CONCAT_SV(_6$$13, "Invalid template engine registration for extension: ", extension);
ZEPHIR_CALL_METHOD(NULL, _5$$13, "__construct", &_7, 9, _6$$13);
zephir_check_call_status();
zephir_throw_exception_debug(_5$$13, "phalcon/mvc/view/simple.zep", 185 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
zephir_array_update_zval(&engines, extension, &engineObject, PH_COPY | PH_SEPARATE);
}
}
zephir_update_property_this(getThis(), SL("_engines"), engines TSRMLS_CC);
} else {
ZEPHIR_OBS_NVAR(engines);
zephir_read_property_this(&engines, this_ptr, SL("_engines"), PH_NOISY_CC);
}
RETURN_CCTOR(engines);
}
/**
* Renders a view
*
* @param string path
* @param array params
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, render) {
zend_bool _3$$12;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *path_param = NULL, *params = NULL, *cache = NULL, *key = NULL, *lifetime = NULL, *cacheOptions = NULL, *content = NULL, *viewParams = NULL, *mergedParams = NULL, *_1, *_0$$3 = NULL, *_2$$12 = NULL, *_4$$12 = NULL;
zval *path = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &path_param, ¶ms);
if (UNEXPECTED(Z_TYPE_P(path_param) != IS_STRING && Z_TYPE_P(path_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'path' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(path_param) == IS_STRING)) {
zephir_get_strval(path, path_param);
} else {
ZEPHIR_INIT_VAR(path);
ZVAL_EMPTY_STRING(path);
}
if (!params) {
params = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_CALL_METHOD(&cache, this_ptr, "getcache", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(cache) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&_0$$3, cache, "isstarted", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_0$$3)) {
ZEPHIR_INIT_VAR(key);
ZVAL_NULL(key);
ZEPHIR_INIT_VAR(lifetime);
ZVAL_NULL(lifetime);
ZEPHIR_OBS_VAR(cacheOptions);
zephir_read_property_this(&cacheOptions, this_ptr, SL("_cacheOptions"), PH_NOISY_CC);
if (Z_TYPE_P(cacheOptions) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(key);
zephir_array_isset_string_fetch(&key, cacheOptions, SS("key"), 0 TSRMLS_CC);
ZEPHIR_OBS_NVAR(lifetime);
zephir_array_isset_string_fetch(&lifetime, cacheOptions, SS("lifetime"), 0 TSRMLS_CC);
}
if (Z_TYPE_P(key) == IS_NULL) {
ZEPHIR_INIT_NVAR(key);
zephir_md5(key, path);
}
ZEPHIR_CALL_METHOD(&content, cache, "start", NULL, 0, key, lifetime);
zephir_check_call_status();
if (Z_TYPE_P(content) != IS_NULL) {
zephir_update_property_this(getThis(), SL("_content"), content TSRMLS_CC);
RETURN_CCTOR(content);
}
}
}
ZEPHIR_INIT_VAR(_1);
zephir_create_symbol_table(TSRMLS_C);
ZEPHIR_CALL_FUNCTION(NULL, "ob_start", NULL, 134);
zephir_check_call_status();
ZEPHIR_OBS_VAR(viewParams);
zephir_read_property_this(&viewParams, this_ptr, SL("_viewParams"), PH_NOISY_CC);
if (Z_TYPE_P(params) == IS_ARRAY) {
if (Z_TYPE_P(viewParams) == IS_ARRAY) {
ZEPHIR_INIT_VAR(mergedParams);
zephir_fast_array_merge(mergedParams, &(viewParams), &(params) TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(mergedParams, params);
}
} else {
ZEPHIR_CPY_WRT(mergedParams, viewParams);
}
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_internalrender", NULL, 412, path, mergedParams);
zephir_check_call_status();
if (Z_TYPE_P(cache) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&_2$$12, cache, "isstarted", NULL, 0);
zephir_check_call_status();
_3$$12 = zephir_is_true(_2$$12);
if (_3$$12) {
ZEPHIR_CALL_METHOD(&_4$$12, cache, "isfresh", NULL, 0);
zephir_check_call_status();
_3$$12 = zephir_is_true(_4$$12);
}
if (_3$$12) {
ZEPHIR_CALL_METHOD(NULL, cache, "save", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(NULL, cache, "stop", NULL, 0);
zephir_check_call_status();
}
}
ZEPHIR_CALL_FUNCTION(NULL, "ob_end_clean", NULL, 136);
zephir_check_call_status();
RETURN_MM_MEMBER(getThis(), "_content");
}
/**
* Replaces placeholders from pattern returning a valid PCRE regular expression
*
* @param string pattern
* @return string
*/
PHP_METHOD(Test_Router_Route, compilePattern) {
zval *pattern = NULL, *idPattern, *_0 = NULL, _1 = zval_used_for_init, _2 = zval_used_for_init;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &pattern);
ZEPHIR_SEPARATE_PARAM(pattern);
if (zephir_memnstr_str(pattern, SL(":"), "test/router/route.zep", 56)) {
ZEPHIR_INIT_VAR(idPattern);
ZVAL_STRING(idPattern, "/([a-zA-Z0-9\\_\\-]+)", 1);
if (zephir_memnstr_str(pattern, SL("/:module"), "test/router/route.zep", 62)) {
ZEPHIR_INIT_VAR(_0);
ZEPHIR_SINIT_VAR(_1);
ZVAL_STRING(&_1, "/:module", 0);
zephir_fast_str_replace(_0, &_1, idPattern, pattern);
ZEPHIR_CPY_WRT(pattern, _0);
}
if (zephir_memnstr_str(pattern, SL("/:controller"), "test/router/route.zep", 67)) {
ZEPHIR_INIT_NVAR(_0);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_STRING(&_1, "/:controller", 0);
zephir_fast_str_replace(_0, &_1, idPattern, pattern);
ZEPHIR_CPY_WRT(pattern, _0);
}
if (zephir_memnstr_str(pattern, SL("/:namespace"), "test/router/route.zep", 72)) {
ZEPHIR_INIT_NVAR(_0);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_STRING(&_1, "/:namespace", 0);
zephir_fast_str_replace(_0, &_1, idPattern, pattern);
ZEPHIR_CPY_WRT(pattern, _0);
}
if (zephir_memnstr_str(pattern, SL("/:action"), "test/router/route.zep", 77)) {
ZEPHIR_INIT_NVAR(_0);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_STRING(&_1, "/:action", 0);
zephir_fast_str_replace(_0, &_1, idPattern, pattern);
ZEPHIR_CPY_WRT(pattern, _0);
}
if (zephir_memnstr_str(pattern, SL("/:params"), "test/router/route.zep", 82)) {
ZEPHIR_INIT_NVAR(_0);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_STRING(&_1, "/:params", 0);
ZEPHIR_SINIT_VAR(_2);
ZVAL_STRING(&_2, "(/.*)*", 0);
zephir_fast_str_replace(_0, &_1, &_2, pattern);
ZEPHIR_CPY_WRT(pattern, _0);
}
if (zephir_memnstr_str(pattern, SL("/:int"), "test/router/route.zep", 87)) {
ZEPHIR_INIT_NVAR(_0);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_STRING(&_1, "/:int", 0);
ZEPHIR_SINIT_NVAR(_2);
ZVAL_STRING(&_2, "/([0-9]+)", 0);
zephir_fast_str_replace(_0, &_1, &_2, pattern);
ZEPHIR_CPY_WRT(pattern, _0);
}
}
if (zephir_memnstr_str(pattern, SL("("), "test/router/route.zep", 93)) {
ZEPHIR_CONCAT_SVS(return_value, "#^", pattern, "$#");
RETURN_MM();
}
if (zephir_memnstr_str(pattern, SL("["), "test/router/route.zep", 98)) {
ZEPHIR_CONCAT_SVS(return_value, "#^", pattern, "$#");
RETURN_MM();
}
RETVAL_ZVAL(pattern, 1, 0);
RETURN_MM();
}
/**
* Matches a user submitted path with a previously defined route.
* Assigns and returns an array of defaults on a successful match.
*
* @param string $path Path used to match against this routing map
* @return array|false An array of assigned values or a false on a mismatch
*/
PHP_METHOD(Yaf_Route_Rewrite, route) {
zephir_nts_static zephir_fcall_cache_entry *_3 = NULL, *_6 = NULL;
zend_bool _0, _1;
int ZEPHIR_LAST_CALL_STATUS;
zval *request, *requestUri = NULL, *baseuri = NULL, *path = NULL, *values = NULL, *_2 = NULL, _4 = zval_used_for_init, *_5 = NULL, *_7, *_8, *_9, *_10;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &request);
ZEPHIR_CALL_METHOD(&requestUri, request, "getrequesturi", NULL);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&baseuri, request, "getbaseuri", NULL);
zephir_check_call_status();
_0 = !ZEPHIR_IS_STRING(requestUri, "");
if (_0) {
_0 = !ZEPHIR_IS_STRING(baseuri, "");
}
_1 = _0;
if (_1) {
ZEPHIR_CALL_FUNCTION(&_2, "stripos", &_3, requestUri, baseuri);
zephir_check_call_status();
_1 = !ZEPHIR_IS_FALSE_IDENTICAL(_2);
}
if (_1) {
ZEPHIR_SINIT_VAR(_4);
ZVAL_LONG(&_4, zephir_fast_strlen_ev(baseuri));
ZEPHIR_INIT_VAR(path);
zephir_substr(path, requestUri, zephir_get_intval(&_4), 0, ZEPHIR_SUBSTR_NO_LENGTH);
} else {
ZEPHIR_CPY_WRT(path, requestUri);
}
ZEPHIR_INIT_NVAR(path);
ZEPHIR_CALL_FUNCTION(&_5, "urldecode", &_6, path);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_4);
ZVAL_STRING(&_4, "/", 0);
zephir_fast_trim(path, _5, &_4, ZEPHIR_TRIM_BOTH TSRMLS_CC);
ZEPHIR_CALL_METHOD(&values, this_ptr, "_match", NULL, path);
zephir_check_call_status();
if (Z_TYPE_P(values) == IS_NULL) {
RETURN_MM_BOOL(0);
}
_7 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC);
if (zephir_array_isset_string(_7, SS("module"))) {
_8 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC);
zephir_array_fetch_string(&_9, _8, SL("module"), PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 77 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, request, "setmodulename", NULL, _9);
zephir_check_call_status();
}
_8 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC);
if (zephir_array_isset_string(_8, SS("controller"))) {
_10 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC);
zephir_array_fetch_string(&_9, _10, SL("controller"), PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 81 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, request, "setcontrollername", NULL, _9);
zephir_check_call_status();
}
_8 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC);
if (zephir_array_isset_string(_8, SS("action"))) {
_10 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC);
zephir_array_fetch_string(&_9, _10, SL("action"), PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 85 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, request, "setactionname", NULL, _9);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(NULL, request, "setparam", NULL, values);
zephir_check_call_status();
RETURN_MM_BOOL(1);
}
/**
* Moves internal resultset cursor to another position letting us to fetch a certain row
*
*<code>
* $result = $connection->query("SELECT * FROM robots ORDER BY name");
* $result->dataSeek(2); // Move to third row on result
* $row = $result->fetch(); // Fetch third row
*</code>
*/
PHP_METHOD(Phalcon_Db_Result_Pdo, dataSeek) {
int ZEPHIR_LAST_CALL_STATUS;
zval *number_param = NULL, *connection = NULL, *pdo = NULL, *sqlStatement = NULL, *bindParams = NULL, *statement = NULL, *_0$$4 = NULL, *_1$$4;
long number;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &number_param);
number = zephir_get_intval(number_param);
{ pdo_stmt_t *stmt; long n;
ZEPHIR_OBS_VAR(connection);
zephir_read_property_this(&connection, this_ptr, SL("_connection"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&pdo, connection, "getinternalhandler", NULL, 0);
zephir_check_call_status();
ZEPHIR_OBS_VAR(sqlStatement);
zephir_read_property_this(&sqlStatement, this_ptr, SL("_sqlStatement"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(bindParams);
zephir_read_property_this(&bindParams, this_ptr, SL("_bindParams"), PH_NOISY_CC);
if (Z_TYPE_P(bindParams) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&statement, pdo, "prepare", NULL, 0, sqlStatement);
zephir_check_call_status();
if (Z_TYPE_P(statement) == IS_OBJECT) {
_1$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_bindTypes"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_0$$4, connection, "executeprepared", NULL, 0, statement, bindParams, _1$$4);
zephir_check_call_status();
ZEPHIR_CPY_WRT(statement, _0$$4);
}
} else {
ZEPHIR_CALL_METHOD(&statement, pdo, "query", NULL, 0, sqlStatement);
zephir_check_call_status();
}
zephir_update_property_this(this_ptr, SL("_pdoStatement"), statement TSRMLS_CC);
/**
* This a fetch scroll to reach the desired position, however with a big number of records
* maybe it may be very slow
*/
stmt = (pdo_stmt_t*) zend_object_store_get_object(statement TSRMLS_CC);
if (!stmt->dbh) {
ZEPHIR_MM_RESTORE();
RETURN_FALSE;
}
n = -1;
number--;
while (n != number) {
if (!stmt->methods->fetcher(stmt, PDO_FETCH_ORI_NEXT, 0 TSRMLS_CC)) {
ZEPHIR_MM_RESTORE();
RETURN_NULL();
}
n++;
}
}
ZEPHIR_MM_RESTORE();
}
/**
* Extracts parameters from a string
*
* @param string pattern
*/
PHP_METHOD(Test_Router_Route, extractNamedParams) {
zephir_nts_static zephir_fcall_cache_entry *_4 = NULL;
long _0, _6, _23;
zend_bool notValid = 0, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18;
int tmp, cursor, cursorVar, marker, bracketCount = 0, parenthesesCount = 0, foundPattern = 0, intermediate = 0, numberMatches = 0, ZEPHIR_LAST_CALL_STATUS;
char ch;
zval *pattern_param = NULL, *matches, _1 = zval_used_for_init, _2 = zval_used_for_init, *_3 = NULL, *_19 = NULL, *_21 = NULL, *_24 = NULL;
zval *pattern = NULL, *route, *item = NULL, *variable = NULL, *regexp = NULL, *_5 = NULL, *_20 = NULL, *_22 = NULL, *_25 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &pattern_param);
zephir_get_strval(pattern, pattern_param);
if (zephir_fast_strlen_ev(pattern) <= 0) {
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_VAR(matches);
array_init(matches);
ZEPHIR_INIT_VAR(route);
ZVAL_EMPTY_STRING(route);
for (_0 = 0; _0 < Z_STRLEN_P(pattern); _0++) {
cursor = _0;
ch = ZEPHIR_STRING_OFFSET(pattern, _0);
if (parenthesesCount == 0) {
if (ch == '{') {
if (bracketCount == 0) {
marker = (cursor + 1);
intermediate = 0;
notValid = 0;
}
bracketCount++;
} else {
if (ch == '}') {
bracketCount--;
if (intermediate > 0) {
if (bracketCount == 0) {
numberMatches++;
ZEPHIR_INIT_NVAR(variable);
ZVAL_EMPTY_STRING(variable);
ZEPHIR_INIT_NVAR(regexp);
ZVAL_EMPTY_STRING(regexp);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, marker);
ZEPHIR_SINIT_NVAR(_2);
ZVAL_LONG(&_2, (cursor - marker));
ZEPHIR_CALL_FUNCTION(&_3, "substr", &_4, pattern, &_1, &_2);
zephir_check_call_status();
zephir_get_strval(_5, _3);
ZEPHIR_CPY_WRT(item, _5);
for (_6 = 0; _6 < Z_STRLEN_P(item); _6++) {
cursorVar = _6;
ch = ZEPHIR_STRING_OFFSET(item, _6);
if (ch == '\0') {
break;
}
_7 = cursorVar == 0;
if (_7) {
_8 = ch >= 'a';
if (_8) {
_8 = ch <= 'z';
}
_9 = _8;
if (!(_9)) {
_10 = ch >= 'A';
if (_10) {
_10 = ch <= 'Z';
}
_9 = _10;
}
_7 = !_9;
}
if (_7) {
notValid = 1;
break;
}
_11 = ch >= 'a';
if (_11) {
_11 = ch <= 'z';
}
_12 = _11;
if (!(_12)) {
_13 = ch >= 'A';
if (_13) {
_13 = ch <= 'Z';
}
_12 = _13;
}
_14 = _12;
if (!(_14)) {
_15 = ch >= '0';
if (_15) {
_15 = ch <= '9';
}
_14 = _15;
}
_16 = _14;
if (!(_16)) {
_16 = ch == '-';
}
_17 = _16;
if (!(_17)) {
_17 = ch == '_';
}
_18 = _17;
if (!(_18)) {
_18 = ch == ':';
}
if (_18) {
if (ch == ':') {
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, 0);
ZEPHIR_SINIT_NVAR(_2);
ZVAL_LONG(&_2, cursorVar);
ZEPHIR_CALL_FUNCTION(&_19, "substr", &_4, item, &_1, &_2);
zephir_check_call_status();
zephir_get_strval(_20, _19);
ZEPHIR_CPY_WRT(variable, _20);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, (cursorVar + 1));
ZEPHIR_CALL_FUNCTION(&_21, "substr", &_4, item, &_1);
zephir_check_call_status();
zephir_get_strval(_22, _21);
ZEPHIR_CPY_WRT(regexp, _22);
break;
}
} else {
notValid = 1;
break;
}
}
if (!(notValid)) {
tmp = numberMatches;
_7 = zephir_is_true(variable);
if (_7) {
_7 = zephir_is_true(regexp);
}
if (_7) {
foundPattern = 0;
for (_23 = 0; _23 < Z_STRLEN_P(regexp); _23++) {
ch = ZEPHIR_STRING_OFFSET(regexp, _23);
if (ch == '\0') {
break;
}
if (!(foundPattern)) {
if (ch == '(') {
foundPattern = 1;
}
} else {
if (ch == ')') {
foundPattern = 2;
break;
}
}
}
if (foundPattern != 2) {
zephir_concat_self_str(&route, "(", sizeof("(")-1 TSRMLS_CC);
zephir_concat_self(&route, regexp TSRMLS_CC);
zephir_concat_self_str(&route, ")", sizeof(")")-1 TSRMLS_CC);
} else {
zephir_concat_self(&route, regexp TSRMLS_CC);
}
ZEPHIR_INIT_NVAR(_24);
ZVAL_LONG(_24, tmp);
zephir_array_update_zval(&matches, variable, &_24, PH_COPY | PH_SEPARATE);
} else {
zephir_concat_self_str(&route, "([^/]*)", sizeof("([^/]*)")-1 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_24);
ZVAL_LONG(_24, tmp);
zephir_array_update_zval(&matches, item, &_24, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_INIT_LNVAR(_25);
ZEPHIR_CONCAT_SVS(_25, "{", item, "}");
zephir_concat_self(&route, _25 TSRMLS_CC);
}
continue;
}
}
}
}
}
if (bracketCount == 0) {
if (ch == '(') {
parenthesesCount++;
} else {
if (ch == ')') {
parenthesesCount--;
if (parenthesesCount == 0) {
numberMatches++;
}
}
}
}
if (bracketCount > 0) {
intermediate++;
} else {
zephir_concat_self_char(&route, ch TSRMLS_CC);
}
}
array_init_size(return_value, 3);
zephir_array_fast_append(return_value, route);
zephir_array_fast_append(return_value, matches);
RETURN_MM();
}
/**
* Stores cached content into the file backend and stops the frontend
*
* @param int|string keyName
* @param string content
* @param long lifetime
* @param boolean stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_Xcache, save) {
zephir_fcall_cache_entry *_1 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zend_bool stopBuffer;
zval *keyName = NULL, *content = NULL, *lifetime = NULL, *stopBuffer_param = NULL, *lastKey = NULL, *frontend, *cachedContent = NULL, *preparedContent = NULL, *tmp, *tt1 = NULL, *success = NULL, *isBuffering = NULL, *options, *keys = NULL, *specialKey, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 4, &keyName, &content, &lifetime, &stopBuffer_param);
if (!keyName) {
keyName = ZEPHIR_GLOBAL(global_null);
}
if (!content) {
content = ZEPHIR_GLOBAL(global_null);
}
if (!lifetime) {
lifetime = ZEPHIR_GLOBAL(global_null);
}
if (!stopBuffer_param) {
stopBuffer = 1;
} else {
stopBuffer = zephir_get_boolval(stopBuffer_param);
}
if (!(zephir_is_true(keyName))) {
ZEPHIR_OBS_VAR(lastKey);
zephir_read_property_this(&lastKey, this_ptr, SL("_lastKey"), PH_NOISY_CC);
} else {
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(lastKey);
ZEPHIR_CONCAT_SVV(lastKey, "_PHCX", _0, keyName);
}
if (!(zephir_is_true(lastKey))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cache must be started first", "phalcon/cache/backend/xcache.zep", 119);
return;
}
ZEPHIR_OBS_VAR(frontend);
zephir_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
if (!(zephir_is_true(content))) {
ZEPHIR_CALL_METHOD(&cachedContent, frontend, "getcontent", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(cachedContent, content);
}
if (!(zephir_is_numeric(cachedContent))) {
ZEPHIR_CALL_METHOD(&preparedContent, frontend, "beforestore", NULL, 0, cachedContent);
zephir_check_call_status();
}
if (!(zephir_is_true(lifetime))) {
ZEPHIR_OBS_VAR(tmp);
zephir_read_property_this(&tmp, this_ptr, SL("_lastLifetime"), PH_NOISY_CC);
if (!(zephir_is_true(tmp))) {
ZEPHIR_CALL_METHOD(&tt1, frontend, "getlifetime", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(tt1, tmp);
}
} else {
ZEPHIR_CPY_WRT(tt1, lifetime);
}
if (zephir_is_numeric(cachedContent)) {
ZEPHIR_CALL_FUNCTION(&success, "xcache_set", &_1, 85, lastKey, cachedContent, tt1);
zephir_check_call_status();
} else {
ZEPHIR_CALL_FUNCTION(&success, "xcache_set", &_1, 85, lastKey, preparedContent, tt1);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&isBuffering, frontend, "isbuffering", NULL, 0);
zephir_check_call_status();
if (stopBuffer == 1) {
ZEPHIR_CALL_METHOD(NULL, frontend, "stop", NULL, 0);
zephir_check_call_status();
}
if (ZEPHIR_IS_TRUE_IDENTICAL(isBuffering)) {
zend_print_zval(cachedContent, 0);
}
if (0) {
zephir_update_property_this(this_ptr, SL("_started"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_started"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
if (zephir_is_true(success)) {
ZEPHIR_OBS_VAR(options);
zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(specialKey);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY_CC);
if (!(zephir_array_isset_string_fetch(&specialKey, _0, SS("statsKey"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/xcache.zep", 169);
return;
}
ZEPHIR_CALL_FUNCTION(&keys, "xcache_get", NULL, 84, specialKey);
zephir_check_call_status();
if (Z_TYPE_P(keys) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(keys);
array_init(keys);
}
zephir_array_update_zval(&keys, lastKey, &tt1, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_FUNCTION(NULL, "xcache_set", &_1, 85, specialKey, keys);
zephir_check_call_status();
}
ZEPHIR_MM_RESTORE();
}
/**
* Phalcon\Session\Adapter\Memcache constructor
*/
PHP_METHOD(Phalcon_Session_Adapter_Memcache, __construct) {
zephir_fcall_cache_entry *_14 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *options_param = NULL, *lifetime = NULL, *_3, *_4, *_6, *_8 = NULL, *_0$$3, *_1$$4, *_2$$5;
zval *options = NULL, *_5, *_7, *_9, *_10, *_11, *_12, *_13;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &options_param);
if (!options_param) {
ZEPHIR_INIT_VAR(options);
array_init(options);
} else {
zephir_get_arrval(options, options_param);
}
if (!(zephir_array_isset_string(options, SS("host")))) {
ZEPHIR_INIT_VAR(_0$$3);
ZVAL_STRING(_0$$3, "127.0.0.1", 1);
zephir_array_update_string(&options, SL("host"), &_0$$3, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("port")))) {
ZEPHIR_INIT_VAR(_1$$4);
ZVAL_LONG(_1$$4, 11211);
zephir_array_update_string(&options, SL("port"), &_1$$4, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("persistent")))) {
ZEPHIR_INIT_VAR(_2$$5);
ZVAL_LONG(_2$$5, 0);
zephir_array_update_string(&options, SL("persistent"), &_2$$5, PH_COPY | PH_SEPARATE);
}
ZEPHIR_OBS_VAR(lifetime);
if (zephir_array_isset_string_fetch(&lifetime, options, SS("lifetime"), 0 TSRMLS_CC)) {
zephir_update_property_this(this_ptr, SL("_lifetime"), lifetime TSRMLS_CC);
}
ZEPHIR_INIT_VAR(_3);
object_init_ex(_3, phalcon_cache_backend_memcache_ce);
ZEPHIR_INIT_VAR(_4);
object_init_ex(_4, phalcon_cache_frontend_data_ce);
ZEPHIR_INIT_VAR(_5);
zephir_create_array(_5, 1, 0 TSRMLS_CC);
ZEPHIR_OBS_VAR(_6);
zephir_read_property_this(&_6, this_ptr, SL("_lifetime"), PH_NOISY_CC);
zephir_array_update_string(&_5, SL("lifetime"), &_6, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, _4, "__construct", NULL, 313, _5);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, _3, "__construct", NULL, 316, _4, options);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_memcache"), _3 TSRMLS_CC);
ZEPHIR_INIT_VAR(_7);
zephir_create_array(_7, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_7, this_ptr);
ZEPHIR_INIT_VAR(_8);
ZVAL_STRING(_8, "open", 1);
zephir_array_fast_append(_7, _8);
ZEPHIR_INIT_VAR(_9);
zephir_create_array(_9, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_9, this_ptr);
ZEPHIR_INIT_NVAR(_8);
ZVAL_STRING(_8, "close", 1);
zephir_array_fast_append(_9, _8);
ZEPHIR_INIT_VAR(_10);
zephir_create_array(_10, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_10, this_ptr);
ZEPHIR_INIT_NVAR(_8);
ZVAL_STRING(_8, "read", 1);
zephir_array_fast_append(_10, _8);
ZEPHIR_INIT_VAR(_11);
zephir_create_array(_11, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_11, this_ptr);
ZEPHIR_INIT_NVAR(_8);
ZVAL_STRING(_8, "write", 1);
zephir_array_fast_append(_11, _8);
ZEPHIR_INIT_VAR(_12);
zephir_create_array(_12, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_12, this_ptr);
ZEPHIR_INIT_NVAR(_8);
ZVAL_STRING(_8, "destroy", 1);
zephir_array_fast_append(_12, _8);
ZEPHIR_INIT_VAR(_13);
zephir_create_array(_13, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_13, this_ptr);
ZEPHIR_INIT_NVAR(_8);
ZVAL_STRING(_8, "gc", 1);
zephir_array_fast_append(_13, _8);
ZEPHIR_CALL_FUNCTION(NULL, "session_set_save_handler", NULL, 410, _7, _9, _10, _11, _12, _13);
zephir_check_call_status();
ZEPHIR_CALL_PARENT(NULL, phalcon_session_adapter_memcache_ce, this_ptr, "__construct", &_14, 411, options);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Handles routing information received from command-line arguments
*
* @param array arguments
*/
PHP_METHOD(Phalcon_Cli_Router, handle) {
zval *_16 = NULL;
zval *_6 = NULL, *_11 = NULL;
zephir_nts_static zephir_fcall_cache_entry *_5 = NULL, *_19 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_3, *_8;
HashPosition _2, _7;
zend_bool _0;
zval *arguments = NULL, *moduleName = NULL, *taskName = NULL, *actionName = NULL, *params = NULL, *route = NULL, *parts = NULL, *pattern = NULL, *routeFound = NULL, *matches, *paths = NULL, *beforeMatch = NULL, *converters = NULL, *converter = NULL, *part = NULL, *position = NULL, *matchPosition = NULL, *strParams, *_1, **_4, **_9, *_10 = NULL, *_12, *_13, *_14, *_15, _17, *_18 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &arguments);
if (!arguments) {
arguments = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_INIT_VAR(routeFound);
ZVAL_BOOL(routeFound, 0);
ZEPHIR_INIT_VAR(parts);
array_init(parts);
ZEPHIR_INIT_VAR(params);
array_init(params);
ZEPHIR_INIT_VAR(matches);
ZVAL_NULL(matches);
zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_matchedRoute"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
if (Z_TYPE_P(arguments) != IS_ARRAY) {
_0 = Z_TYPE_P(arguments) != IS_STRING;
if (_0) {
_0 = Z_TYPE_P(arguments) != IS_NULL;
}
if (_0) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_router_exception_ce, "Arguments must be an array or string", "phalcon/cli/router.zep", 223);
return;
}
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_routes"), PH_NOISY_CC);
zephir_is_iterable(_1, &_3, &_2, 0, 1, "phalcon/cli/router.zep", 323);
for (
; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS
; zephir_hash_move_backwards_ex(_3, &_2)
) {
ZEPHIR_GET_HVALUE(route, _4);
ZEPHIR_CALL_METHOD(&pattern, route, "getcompiledpattern", NULL);
zephir_check_call_status();
if (zephir_memnstr_str(pattern, SL("^"), "phalcon/cli/router.zep", 233)) {
Z_SET_ISREF_P(matches);
ZEPHIR_CALL_FUNCTION(&routeFound, "preg_match", &_5, pattern, arguments, matches);
Z_UNSET_ISREF_P(matches);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(routeFound);
ZVAL_BOOL(routeFound, ZEPHIR_IS_EQUAL(pattern, arguments));
}
if (zephir_is_true(routeFound)) {
ZEPHIR_CALL_METHOD(&beforeMatch, route, "getbeforematch", NULL);
zephir_check_call_status();
if (Z_TYPE_P(beforeMatch) != IS_NULL) {
if (!(zephir_is_callable(beforeMatch TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_router_exception_ce, "Before-Match callback is not callable in matched route", "phalcon/cli/router.zep", 251);
return;
}
ZEPHIR_INIT_NVAR(routeFound);
ZEPHIR_INIT_NVAR(_6);
zephir_create_array(_6, 3, 0 TSRMLS_CC);
zephir_array_fast_append(_6, arguments);
zephir_array_fast_append(_6, route);
zephir_array_fast_append(_6, this_ptr);
ZEPHIR_CALL_USER_FUNC_ARRAY(routeFound, beforeMatch, _6);
zephir_check_call_status();
}
}
if (zephir_is_true(routeFound)) {
ZEPHIR_CALL_METHOD(&paths, route, "getpaths", NULL);
zephir_check_call_status();
ZEPHIR_CPY_WRT(parts, paths);
if (Z_TYPE_P(matches) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&converters, route, "getconverters", NULL);
zephir_check_call_status();
zephir_is_iterable(paths, &_8, &_7, 0, 0, "phalcon/cli/router.zep", 312);
for (
; zephir_hash_get_current_data_ex(_8, (void**) &_9, &_7) == SUCCESS
; zephir_hash_move_forward_ex(_8, &_7)
) {
ZEPHIR_GET_HMKEY(part, _8, _7);
ZEPHIR_GET_HVALUE(position, _9);
ZEPHIR_OBS_NVAR(matchPosition);
if (zephir_array_isset_fetch(&matchPosition, matches, position, 0 TSRMLS_CC)) {
if (Z_TYPE_P(converters) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(converter);
if (zephir_array_isset_fetch(&converter, converters, part, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_10);
ZEPHIR_INIT_NVAR(_6);
zephir_create_array(_6, 1, 0 TSRMLS_CC);
zephir_array_fast_append(_6, matchPosition);
ZEPHIR_CALL_USER_FUNC_ARRAY(_10, converter, _6);
zephir_check_call_status();
zephir_array_update_zval(&parts, part, &_10, PH_COPY | PH_SEPARATE);
continue;
}
}
zephir_array_update_zval(&parts, part, &matchPosition, PH_COPY | PH_SEPARATE);
} else {
if (Z_TYPE_P(converters) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(converter);
if (zephir_array_isset_fetch(&converter, converters, part, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_10);
ZEPHIR_INIT_NVAR(_11);
zephir_create_array(_11, 1, 0 TSRMLS_CC);
zephir_array_fast_append(_11, position);
ZEPHIR_CALL_USER_FUNC_ARRAY(_10, converter, _11);
zephir_check_call_status();
zephir_array_update_zval(&parts, part, &_10, PH_COPY | PH_SEPARATE);
}
}
}
}
zephir_update_property_this(this_ptr, SL("_matches"), matches TSRMLS_CC);
}
zephir_update_property_this(this_ptr, SL("_matchedRoute"), route TSRMLS_CC);
break;
}
}
if (zephir_is_true(routeFound)) {
zephir_update_property_this(this_ptr, SL("_wasMatched"), (1) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
_12 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultModule"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_module"), _12 TSRMLS_CC);
_13 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultTask"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_task"), _13 TSRMLS_CC);
_14 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAction"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_action"), _14 TSRMLS_CC);
_15 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultParams"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_params"), _15 TSRMLS_CC);
RETURN_THIS();
}
} else {
ZEPHIR_CPY_WRT(parts, arguments);
}
ZEPHIR_INIT_VAR(moduleName);
ZVAL_NULL(moduleName);
ZEPHIR_INIT_VAR(taskName);
ZVAL_NULL(taskName);
ZEPHIR_INIT_VAR(actionName);
ZVAL_NULL(actionName);
ZEPHIR_OBS_NVAR(moduleName);
if (zephir_array_isset_string_fetch(&moduleName, parts, SS("module"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&parts, SS("module"), PH_SEPARATE);
} else {
ZEPHIR_OBS_NVAR(moduleName);
zephir_read_property_this(&moduleName, this_ptr, SL("_defaultModule"), PH_NOISY_CC);
}
ZEPHIR_OBS_NVAR(taskName);
if (zephir_array_isset_string_fetch(&taskName, parts, SS("task"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&parts, SS("task"), PH_SEPARATE);
} else {
ZEPHIR_OBS_NVAR(taskName);
zephir_read_property_this(&taskName, this_ptr, SL("_defaultTask"), PH_NOISY_CC);
}
ZEPHIR_OBS_NVAR(actionName);
if (zephir_array_isset_string_fetch(&actionName, parts, SS("action"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&parts, SS("action"), PH_SEPARATE);
} else {
ZEPHIR_OBS_NVAR(actionName);
zephir_read_property_this(&actionName, this_ptr, SL("_defaultAction"), PH_NOISY_CC);
}
if (zephir_is_true(routeFound)) {
ZEPHIR_OBS_NVAR(params);
if (zephir_array_isset_string_fetch(¶ms, parts, SS("params"), 0 TSRMLS_CC)) {
if (Z_TYPE_P(params) != IS_ARRAY) {
zephir_get_strval(_16, params);
ZEPHIR_SINIT_VAR(_17);
ZVAL_LONG(&_17, 1);
ZEPHIR_INIT_VAR(strParams);
zephir_substr(strParams, _16, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
if (zephir_is_true(strParams)) {
ZEPHIR_INIT_NVAR(params);
ZEPHIR_CALL_CE_STATIC(&_18, phalcon_cli_router_route_ce, "getdelimiter", &_19);
zephir_check_call_status();
zephir_fast_explode(params, _18, strParams, LONG_MAX TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(params);
array_init(params);
}
}
zephir_array_unset_string(&parts, SS("params"), PH_SEPARATE);
}
if (zephir_fast_count_int(params TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_10);
zephir_fast_array_merge(_10, &(params), &(parts) TSRMLS_CC);
ZEPHIR_CPY_WRT(params, _10);
} else {
ZEPHIR_CPY_WRT(params, parts);
}
} else {
ZEPHIR_CPY_WRT(params, parts);
}
zephir_update_property_this(this_ptr, SL("_module"), moduleName TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_task"), taskName TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_action"), actionName TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_params"), params TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_Regex, validate) {
zend_bool failed = 0;
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *matches = NULL, *message = NULL, *value = NULL, *label = NULL, *replacePairs = NULL, *code = NULL, *pattern = NULL, *_0 = NULL, *_1$$3, *_2$$4, *_3$$6 = NULL, *_8$$6 = NULL, *_9$$6, *_4$$7, *_5$$9, *_6$$10, *_7$$11;
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(matches);
ZVAL_NULL(matches);
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "pattern", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&pattern, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (Z_TYPE_P(pattern) == IS_ARRAY) {
zephir_array_fetch(&_1$$3, pattern, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/regex.zep", 81 TSRMLS_CC);
ZEPHIR_CPY_WRT(pattern, _1$$3);
}
ZEPHIR_INIT_NVAR(_0);
zephir_preg_match(_0, pattern, value, matches, 0, 0 , 0 TSRMLS_CC);
if (zephir_is_true(_0)) {
zephir_array_fetch_long(&_2$$4, matches, 0, PH_NOISY | PH_READONLY, "phalcon/validation/validator/regex.zep", 85 TSRMLS_CC);
failed = !ZEPHIR_IS_EQUAL(_2$$4, value);
} else {
failed = 1;
}
if (failed == 1) {
ZEPHIR_INIT_VAR(_3$$6);
ZVAL_STRING(_3$$6, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _3$$6);
zephir_check_temp_parameter(_3$$6);
zephir_check_call_status();
if (Z_TYPE_P(label) == IS_ARRAY) {
zephir_array_fetch(&_4$$7, label, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/regex.zep", 94 TSRMLS_CC);
ZEPHIR_CPY_WRT(label, _4$$7);
}
if (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_3$$6);
ZVAL_STRING(_3$$6, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _3$$6);
zephir_check_temp_parameter(_3$$6);
zephir_check_call_status();
if (Z_TYPE_P(message) == IS_ARRAY) {
zephir_array_fetch(&_5$$9, message, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/regex.zep", 102 TSRMLS_CC);
ZEPHIR_CPY_WRT(message, _5$$9);
}
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_VAR(_6$$10);
ZVAL_STRING(_6$$10, "Regex", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _6$$10);
zephir_check_temp_parameter(_6$$10);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_3$$6);
ZVAL_STRING(_3$$6, "code", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&code, this_ptr, "getoption", NULL, 0, _3$$6);
zephir_check_temp_parameter(_3$$6);
zephir_check_call_status();
if (Z_TYPE_P(code) == IS_ARRAY) {
zephir_array_fetch(&_7$$11, code, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/regex.zep", 111 TSRMLS_CC);
ZEPHIR_CPY_WRT(code, _7$$11);
}
ZEPHIR_INIT_NVAR(_3$$6);
object_init_ex(_3$$6, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_8$$6, "strtr", NULL, 26, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_9$$6);
ZVAL_STRING(_9$$6, "Regex", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _3$$6, "__construct", NULL, 465, _8$$6, field, _9$$6, code);
zephir_check_temp_parameter(_9$$6);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _3$$6);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_Callback, validate) {
zend_bool _1$$3;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *message = NULL, *label = NULL, *replacePairs = NULL, *code = NULL, *callback = NULL, *returnedValue = NULL, *data = NULL, *_0, *_2$$6 = NULL, *_3$$6 = NULL, *_4$$6;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field_param);
if (UNEXPECTED(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 (EXPECTED(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, "callback", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&callback, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (zephir_is_callable(callback TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(&data, validation, "getentity", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(data)) {
ZEPHIR_CALL_METHOD(&data, validation, "getdata", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_CALL_FUNCTION(&returnedValue, "call_user_func", NULL, 403, callback, data);
zephir_check_call_status();
_1$$3 = Z_TYPE_P(returnedValue) == IS_OBJECT;
if (_1$$3) {
_1$$3 = zephir_instance_of_ev(returnedValue, phalcon_validation_validator_ce TSRMLS_CC);
}
if (Z_TYPE_P(returnedValue) == IS_BOOL) {
if (!(zephir_is_true(returnedValue))) {
ZEPHIR_CALL_METHOD(&label, this_ptr, "preparelabel", NULL, 0, validation, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_2$$6);
ZVAL_STRING(_2$$6, "Callback", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _2$$6);
zephir_check_temp_parameter(_2$$6);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&code, this_ptr, "preparecode", NULL, 0, field);
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);
ZEPHIR_INIT_NVAR(_2$$6);
object_init_ex(_2$$6, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_3$$6, "strtr", NULL, 27, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_4$$6);
ZVAL_STRING(_4$$6, "Callback", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _2$$6, "__construct", NULL, 470, _3$$6, field, _4$$6, code);
zephir_check_temp_parameter(_4$$6);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _2$$6);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
} else if (_1$$3) {
ZEPHIR_RETURN_CALL_METHOD(returnedValue, "validate", NULL, 0, validation, field);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_validator_exception_ce, "Callback must return boolean or Phalcon\\Validation\\Validator object", "phalcon/validation/validator/callback.zep", 114);
return;
}
RETURN_MM_BOOL(1);
}
/**
* Generates random text in accordance with the template
*
* <code>
* echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hi my name is a Bob
* echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hi my name is a Jon
* echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hello my name is a Bob
* </code>
*/
PHP_METHOD(Phalcon_Text, dynamic) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_1 = NULL, *_5 = NULL, *_8 = NULL;
zval *text_param = NULL, *leftDelimiter_param = NULL, *rightDelimiter_param = NULL, *separator_param = NULL, *ldS = NULL, *rdS = NULL, *result = NULL, *pattern = NULL, *_0 = NULL, *_2 = NULL, *_3$$3, *_6$$4 = NULL, *_7$$4 = NULL;
zval *text = NULL, *leftDelimiter = NULL, *rightDelimiter = NULL, *separator = NULL, *_4$$3;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 3, &text_param, &leftDelimiter_param, &rightDelimiter_param, &separator_param);
if (unlikely(Z_TYPE_P(text_param) != IS_STRING && Z_TYPE_P(text_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'text' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(text_param) == IS_STRING)) {
zephir_get_strval(text, text_param);
} else {
ZEPHIR_INIT_VAR(text);
ZVAL_EMPTY_STRING(text);
}
if (!leftDelimiter_param) {
ZEPHIR_INIT_VAR(leftDelimiter);
ZVAL_STRING(leftDelimiter, "{", 1);
} else {
if (unlikely(Z_TYPE_P(leftDelimiter_param) != IS_STRING && Z_TYPE_P(leftDelimiter_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'leftDelimiter' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(leftDelimiter_param) == IS_STRING)) {
zephir_get_strval(leftDelimiter, leftDelimiter_param);
} else {
ZEPHIR_INIT_VAR(leftDelimiter);
ZVAL_EMPTY_STRING(leftDelimiter);
}
}
if (!rightDelimiter_param) {
ZEPHIR_INIT_VAR(rightDelimiter);
ZVAL_STRING(rightDelimiter, "}", 1);
} else {
if (unlikely(Z_TYPE_P(rightDelimiter_param) != IS_STRING && Z_TYPE_P(rightDelimiter_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'rightDelimiter' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(rightDelimiter_param) == IS_STRING)) {
zephir_get_strval(rightDelimiter, rightDelimiter_param);
} else {
ZEPHIR_INIT_VAR(rightDelimiter);
ZVAL_EMPTY_STRING(rightDelimiter);
}
}
if (!separator_param) {
ZEPHIR_INIT_VAR(separator);
ZVAL_STRING(separator, "|", 1);
} else {
if (unlikely(Z_TYPE_P(separator_param) != IS_STRING && Z_TYPE_P(separator_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'separator' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(separator_param) == IS_STRING)) {
zephir_get_strval(separator, separator_param);
} else {
ZEPHIR_INIT_VAR(separator);
ZVAL_EMPTY_STRING(separator);
}
}
ZEPHIR_CALL_FUNCTION(&_0, "substr_count", &_1, 420, text, leftDelimiter);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_2, "substr_count", &_1, 420, text, rightDelimiter);
zephir_check_call_status();
if (!ZEPHIR_IS_IDENTICAL(_0, _2)) {
ZEPHIR_INIT_VAR(_3$$3);
object_init_ex(_3$$3, spl_ce_RuntimeException);
ZEPHIR_INIT_VAR(_4$$3);
ZEPHIR_CONCAT_SVS(_4$$3, "Syntax error in string \"", text, "\"");
ZEPHIR_CALL_METHOD(NULL, _3$$3, "__construct", NULL, 421, _4$$3);
zephir_check_call_status();
zephir_throw_exception_debug(_3$$3, "phalcon/text.zep", 261 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_CALL_FUNCTION(&ldS, "preg_quote", &_5, 422, leftDelimiter);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&rdS, "preg_quote", &_5, 422, rightDelimiter);
zephir_check_call_status();
ZEPHIR_INIT_VAR(pattern);
ZEPHIR_CONCAT_SVSVVSVS(pattern, "/", ldS, "([^", ldS, rdS, "]+)", rdS, "/");
ZEPHIR_CPY_WRT(result, text);
while (1) {
if (!(zephir_memnstr(result, leftDelimiter, "phalcon/text.zep", 269))) {
break;
}
ZEPHIR_INIT_NVAR(_6$$4);
ZEPHIR_INIT_NVAR(_6$$4);
zephir_create_closure_ex(_6$$4, NULL, phalcon_0__closure_ce, SS("__invoke") TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_7$$4, "preg_replace_callback", &_8, 423, pattern, _6$$4, result);
zephir_check_call_status();
ZEPHIR_CPY_WRT(result, _7$$4);
}
RETURN_CCTOR(result);
}
/**
* Generates a random string based on the given type. Type is one of the RANDOM_* constants
*
* <code>
* echo Phalcon\Text::random(Phalcon\Text::RANDOM_ALNUM); //"aloiwkqz"
* </code>
*/
PHP_METHOD(Phalcon_Text, random) {
zephir_fcall_cache_entry *_3 = NULL, *_18 = NULL;
long length;
zval *type_param = NULL, *length_param = NULL, *pool = NULL, *str = NULL, _0$$3 = zval_used_for_init, _1$$3 = zval_used_for_init, *_2$$3 = NULL, *_4$$3 = NULL, _5$$4 = zval_used_for_init, _6$$4 = zval_used_for_init, *_7$$4 = NULL, *_8$$4 = NULL, _9$$5, _10$$5, _11$$6, _12$$6, _13$$7 = zval_used_for_init, _14$$7 = zval_used_for_init, *_15$$7 = NULL, *_16$$7 = NULL, *_17$$7 = NULL, *_19$$8, _20$$8 = zval_used_for_init, _21$$8 = zval_used_for_init;
int type, ZEPHIR_LAST_CALL_STATUS, end = 0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 2, &type_param, &length_param);
if (!type_param) {
type = 0;
} else {
type = zephir_get_intval(type_param);
}
if (!length_param) {
length = 8;
} else {
length = zephir_get_intval(length_param);
}
ZEPHIR_INIT_VAR(str);
ZVAL_STRING(str, "", 1);
do {
if (type == 1) {
ZEPHIR_SINIT_VAR(_0$$3);
ZVAL_STRING(&_0$$3, "a", 0);
ZEPHIR_SINIT_VAR(_1$$3);
ZVAL_STRING(&_1$$3, "z", 0);
ZEPHIR_CALL_FUNCTION(&_2$$3, "range", &_3, 416, &_0$$3, &_1$$3);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_0$$3);
ZVAL_STRING(&_0$$3, "A", 0);
ZEPHIR_SINIT_NVAR(_1$$3);
ZVAL_STRING(&_1$$3, "Z", 0);
ZEPHIR_CALL_FUNCTION(&_4$$3, "range", &_3, 416, &_0$$3, &_1$$3);
zephir_check_call_status();
ZEPHIR_INIT_VAR(pool);
zephir_fast_array_merge(pool, &(_2$$3), &(_4$$3) TSRMLS_CC);
break;
}
if (type == 2) {
ZEPHIR_SINIT_VAR(_5$$4);
ZVAL_LONG(&_5$$4, 0);
ZEPHIR_SINIT_VAR(_6$$4);
ZVAL_LONG(&_6$$4, 9);
ZEPHIR_CALL_FUNCTION(&_7$$4, "range", &_3, 416, &_5$$4, &_6$$4);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_5$$4);
ZVAL_STRING(&_5$$4, "a", 0);
ZEPHIR_SINIT_NVAR(_6$$4);
ZVAL_STRING(&_6$$4, "f", 0);
ZEPHIR_CALL_FUNCTION(&_8$$4, "range", &_3, 416, &_5$$4, &_6$$4);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(pool);
zephir_fast_array_merge(pool, &(_7$$4), &(_8$$4) TSRMLS_CC);
break;
}
if (type == 3) {
ZEPHIR_SINIT_VAR(_9$$5);
ZVAL_LONG(&_9$$5, 0);
ZEPHIR_SINIT_VAR(_10$$5);
ZVAL_LONG(&_10$$5, 9);
ZEPHIR_CALL_FUNCTION(&pool, "range", &_3, 416, &_9$$5, &_10$$5);
zephir_check_call_status();
break;
}
if (type == 4) {
ZEPHIR_SINIT_VAR(_11$$6);
ZVAL_LONG(&_11$$6, 1);
ZEPHIR_SINIT_VAR(_12$$6);
ZVAL_LONG(&_12$$6, 9);
ZEPHIR_CALL_FUNCTION(&pool, "range", &_3, 416, &_11$$6, &_12$$6);
zephir_check_call_status();
break;
}
ZEPHIR_SINIT_VAR(_13$$7);
ZVAL_LONG(&_13$$7, 0);
ZEPHIR_SINIT_VAR(_14$$7);
ZVAL_LONG(&_14$$7, 9);
ZEPHIR_CALL_FUNCTION(&_15$$7, "range", &_3, 416, &_13$$7, &_14$$7);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_13$$7);
ZVAL_STRING(&_13$$7, "a", 0);
ZEPHIR_SINIT_NVAR(_14$$7);
ZVAL_STRING(&_14$$7, "z", 0);
ZEPHIR_CALL_FUNCTION(&_16$$7, "range", &_3, 416, &_13$$7, &_14$$7);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_13$$7);
ZVAL_STRING(&_13$$7, "A", 0);
ZEPHIR_SINIT_NVAR(_14$$7);
ZVAL_STRING(&_14$$7, "Z", 0);
ZEPHIR_CALL_FUNCTION(&_17$$7, "range", &_3, 416, &_13$$7, &_14$$7);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&pool, "array_merge", &_18, 417, _15$$7, _16$$7, _17$$7);
zephir_check_call_status();
break;
} while(0);
end = (zephir_fast_count_int(pool TSRMLS_CC) - 1);
while (1) {
if (!(zephir_fast_strlen_ev(str) < length)) {
break;
}
ZEPHIR_SINIT_NVAR(_20$$8);
ZVAL_LONG(&_20$$8, 0);
ZEPHIR_SINIT_NVAR(_21$$8);
ZVAL_LONG(&_21$$8, end);
zephir_array_fetch_long(&_19$$8, pool, zephir_mt_rand(zephir_get_intval(&_20$$8), zephir_get_intval(&_21$$8) TSRMLS_CC), PH_NOISY | PH_READONLY, "phalcon/text.zep", 126 TSRMLS_CC);
zephir_concat_self(&str, _19$$8 TSRMLS_CC);
}
RETURN_CCTOR(str);
}
/**
* Returns routePaths
*/
PHP_METHOD(Phalcon_Mvc_Router_Route, getRoutePaths) {
int _0;
zval *paths = NULL, *moduleName = NULL, *controllerName = NULL, *actionName = NULL, *parts, *routePaths = NULL, *realClassName = NULL, *namespaceName, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &paths);
if (!paths) {
paths = ZEPHIR_GLOBAL(global_null);
}
if (Z_TYPE_P(paths) != IS_NULL) {
if (Z_TYPE_P(paths) == IS_STRING) {
ZEPHIR_INIT_VAR(moduleName);
ZVAL_NULL(moduleName);
ZEPHIR_INIT_VAR(controllerName);
ZVAL_NULL(controllerName);
ZEPHIR_INIT_VAR(actionName);
ZVAL_NULL(actionName);
ZEPHIR_INIT_VAR(parts);
zephir_fast_explode_str(parts, SL("::"), paths, LONG_MAX TSRMLS_CC);
do {
_0 = zephir_fast_count_int(parts TSRMLS_CC);
if (_0 == 3) {
ZEPHIR_OBS_NVAR(moduleName);
zephir_array_fetch_long(&moduleName, parts, 0, PH_NOISY, "phalcon/mvc/router/route.zep", 353 TSRMLS_CC);
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 1, PH_NOISY, "phalcon/mvc/router/route.zep", 354 TSRMLS_CC);
ZEPHIR_OBS_NVAR(actionName);
zephir_array_fetch_long(&actionName, parts, 2, PH_NOISY, "phalcon/mvc/router/route.zep", 355 TSRMLS_CC);
break;
}
if (_0 == 2) {
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY, "phalcon/mvc/router/route.zep", 359 TSRMLS_CC);
ZEPHIR_OBS_NVAR(actionName);
zephir_array_fetch_long(&actionName, parts, 1, PH_NOISY, "phalcon/mvc/router/route.zep", 360 TSRMLS_CC);
break;
}
if (_0 == 1) {
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY, "phalcon/mvc/router/route.zep", 364 TSRMLS_CC);
break;
}
} while(0);
ZEPHIR_INIT_VAR(routePaths);
array_init(routePaths);
if (Z_TYPE_P(moduleName) != IS_NULL) {
zephir_array_update_string(&routePaths, SL("module"), &moduleName, PH_COPY | PH_SEPARATE);
}
if (Z_TYPE_P(controllerName) != IS_NULL) {
if (zephir_memnstr_str(controllerName, SL("\\"), "phalcon/mvc/router/route.zep", 379)) {
ZEPHIR_INIT_VAR(realClassName);
zephir_get_class_ns(realClassName, controllerName, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(namespaceName);
zephir_get_ns_class(namespaceName, controllerName, 0 TSRMLS_CC);
if (zephir_is_true(namespaceName)) {
zephir_array_update_string(&routePaths, SL("namespace"), &namespaceName, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_CPY_WRT(realClassName, controllerName);
}
ZEPHIR_INIT_VAR(_1);
zephir_uncamelize(_1, realClassName);
zephir_array_update_string(&routePaths, SL("controller"), &_1, PH_COPY | PH_SEPARATE);
}
if (Z_TYPE_P(actionName) != IS_NULL) {
zephir_array_update_string(&routePaths, SL("action"), &actionName, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_CPY_WRT(routePaths, paths);
}
} else {
ZEPHIR_INIT_NVAR(routePaths);
array_init(routePaths);
}
if (Z_TYPE_P(routePaths) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_router_exception_ce, "The route contains invalid paths", "phalcon/mvc/router/route.zep", 411);
return;
}
RETURN_CCTOR(routePaths);
}
/**
* Phalcon\Di\FactoryDefault constructor
*/
PHP_METHOD(Phalcon_Di_FactoryDefault, __construct) {
zval *_2 = NULL, *_3 = NULL, *_4 = NULL, *_5 = NULL;
zval *_1;
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_0 = NULL, *_6 = NULL;
ZEPHIR_MM_GROW();
ZEPHIR_CALL_PARENT(NULL, phalcon_di_factorydefault_ce, this_ptr, "__construct", &_0, 77);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_1);
zephir_create_array(_1, 21, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_VAR(_3);
ZVAL_STRING(_3, "router", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_4);
ZVAL_STRING(_4, "Phalcon\\Mvc\\Router", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_5);
ZVAL_BOOL(_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("router"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "dispatcher", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Mvc\\Dispatcher", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_5);
ZVAL_BOOL(_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("dispatcher"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "url", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Mvc\\Url", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_5);
ZVAL_BOOL(_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("url"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "modelsManager", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Mvc\\Model\\Manager", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_5);
ZVAL_BOOL(_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("modelsManager"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "modelsMetadata", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Mvc\\Model\\MetaData\\Memory", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_5);
ZVAL_BOOL(_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("modelsMetadata"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "response", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Http\\Response", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_5);
ZVAL_BOOL(_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("response"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "cookies", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Http\\Response\\Cookies", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_5);
ZVAL_BOOL(_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("cookies"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "request", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Http\\Request", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_5);
ZVAL_BOOL(_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("request"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "filter", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Filter", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_5);
ZVAL_BOOL(_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("filter"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "escaper", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Escaper", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_5);
ZVAL_BOOL(_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("escaper"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "security", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Security", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_5);
ZVAL_BOOL(_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("security"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "crypt", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Crypt", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_5);
ZVAL_BOOL(_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("crypt"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "annotations", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Annotations\\Adapter\\Memory", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_5);
ZVAL_BOOL(_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("annotations"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "flash", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Flash\\Direct", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_5);
ZVAL_BOOL(_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("flash"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "flashSession", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Flash\\Session", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_5);
ZVAL_BOOL(_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("flashSession"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "tag", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Tag", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_5);
ZVAL_BOOL(_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("tag"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "session", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Session\\Adapter\\Files", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_5);
ZVAL_BOOL(_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("session"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "sessionBag", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Session\\Bag", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("sessionBag"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "eventsManager", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Events\\Manager", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_5);
ZVAL_BOOL(_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("eventsManager"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "transactionManager", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Mvc\\Model\\Transaction\\Manager", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_5);
ZVAL_BOOL(_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("transactionManager"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "assets", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Assets\\Manager", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_5);
ZVAL_BOOL(_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("assets"), &_2, PH_COPY | PH_SEPARATE);
zephir_update_property_this(this_ptr, SL("_services"), _1 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Changes the fetching mode affecting Phalcon\Db\Result\Pdo::fetch()
*
*<code>
* //Return array with integer indexes
* $result->setFetchMode(Phalcon\Db::FETCH_NUM);
*
* //Return associative array without integer indexes
* $result->setFetchMode(Phalcon\Db::FETCH_ASSOC);
*
* //Return associative array together with integer indexes
* $result->setFetchMode(Phalcon\Db::FETCH_BOTH);
*
* //Return an object
* $result->setFetchMode(Phalcon\Db::FETCH_OBJ);
*</code>
*/
PHP_METHOD(Phalcon_Db_Result_Pdo, setFetchMode) {
zval *fetchMode_param = NULL, *colNoOrClassNameOrObject = NULL, *ctorargs = NULL, *pdoStatement, *_0 = NULL, *_1 = NULL, *_2;
int fetchMode, ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &fetchMode_param, &colNoOrClassNameOrObject, &ctorargs);
fetchMode = zephir_get_intval(fetchMode_param);
if (!colNoOrClassNameOrObject) {
colNoOrClassNameOrObject = ZEPHIR_GLOBAL(global_null);
}
if (!ctorargs) {
ctorargs = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_OBS_VAR(pdoStatement);
zephir_read_property_this(&pdoStatement, this_ptr, SL("_pdoStatement"), PH_NOISY_CC);
if (((fetchMode & 7)) == 7) {
ZEPHIR_INIT_VAR(_1);
ZVAL_LONG(_1, fetchMode);
ZEPHIR_CALL_METHOD(&_0, pdoStatement, "setfetchmode", NULL, 0, _1, colNoOrClassNameOrObject);
zephir_check_call_status();
if (zephir_is_true(_0)) {
ZEPHIR_INIT_ZVAL_NREF(_2);
ZVAL_LONG(_2, fetchMode);
zephir_update_property_this(this_ptr, SL("_fetchMode"), _2 TSRMLS_CC);
RETURN_MM_BOOL(1);
}
RETURN_MM_BOOL(0);
}
if (((fetchMode & 8)) == 8) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, fetchMode);
ZEPHIR_CALL_METHOD(&_0, pdoStatement, "setfetchmode", NULL, 0, _1, colNoOrClassNameOrObject, ctorargs);
zephir_check_call_status();
if (zephir_is_true(_0)) {
ZEPHIR_INIT_ZVAL_NREF(_2);
ZVAL_LONG(_2, fetchMode);
zephir_update_property_this(this_ptr, SL("_fetchMode"), _2 TSRMLS_CC);
RETURN_MM_BOOL(1);
}
RETURN_MM_BOOL(0);
}
if (((fetchMode & 9)) == 9) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, fetchMode);
ZEPHIR_CALL_METHOD(&_0, pdoStatement, "setfetchmode", NULL, 0, _1, colNoOrClassNameOrObject);
zephir_check_call_status();
if (zephir_is_true(_0)) {
ZEPHIR_INIT_ZVAL_NREF(_2);
ZVAL_LONG(_2, fetchMode);
zephir_update_property_this(this_ptr, SL("_fetchMode"), _2 TSRMLS_CC);
RETURN_MM_BOOL(1);
}
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, fetchMode);
ZEPHIR_CALL_METHOD(&_0, pdoStatement, "setfetchmode", NULL, 0, _1);
zephir_check_call_status();
if (zephir_is_true(_0)) {
ZEPHIR_INIT_ZVAL_NREF(_2);
ZVAL_LONG(_2, fetchMode);
zephir_update_property_this(this_ptr, SL("_fetchMode"), _2 TSRMLS_CC);
RETURN_MM_BOOL(1);
}
RETURN_MM_BOOL(0);
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_Numericality, validate) {
zend_bool _2;
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *value = NULL, *message = NULL, *label = NULL, *replacePairs = NULL, *_0 = NULL, *_1 = NULL, *_3, _4, *_5$$4 = NULL, *_7$$4 = NULL, *_8$$4, *_6$$6;
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_INIT_VAR(_3);
ZEPHIR_INIT_NVAR(_1);
ZEPHIR_SINIT_VAR(_4);
ZVAL_STRING(&_4, "/^-?\\d+\\.?\\d*$/", 0);
zephir_preg_match(_1, &_4, value, _3, 0, 0 , 0 TSRMLS_CC);
if (!(zephir_is_true(_1))) {
ZEPHIR_INIT_VAR(_5$$4);
ZVAL_STRING(_5$$4, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _5$$4);
zephir_check_temp_parameter(_5$$4);
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(_5$$4);
ZVAL_STRING(_5$$4, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _5$$4);
zephir_check_temp_parameter(_5$$4);
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_VAR(_6$$6);
ZVAL_STRING(_6$$6, "Numericality", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _6$$6);
zephir_check_temp_parameter(_6$$6);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_5$$4);
object_init_ex(_5$$4, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_7$$4, "strtr", NULL, 55, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_8$$4);
ZVAL_STRING(_8$$4, "Numericality", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _5$$4, "__construct", NULL, 434, _7$$4, field, _8$$4);
zephir_check_temp_parameter(_8$$4);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _5$$4);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Changes the fetching mode affecting Phalcon\Db\Result\Pdo::fetch()
*
*<code>
* //Return array with integer indexes
* $result->setFetchMode(\Phalcon\Db::FETCH_NUM);
*
* //Return associative array without integer indexes
* $result->setFetchMode(\Phalcon\Db::FETCH_ASSOC);
*
* //Return associative array together with integer indexes
* $result->setFetchMode(\Phalcon\Db::FETCH_BOTH);
*
* //Return an object
* $result->setFetchMode(\Phalcon\Db::FETCH_OBJ);
*</code>
*/
PHP_METHOD(Phalcon_Db_Result_Pdo, setFetchMode) {
zval *fetchMode_param = NULL, *colNoOrClassNameOrObject = NULL, *ctorargs = NULL, *pdoStatement = NULL, *_9 = NULL, *_10, *_0$$3 = NULL, *_1$$3, *_2$$4, *_3$$5 = NULL, *_4$$5, *_5$$6, *_6$$7 = NULL, *_7$$7, *_8$$8, *_11$$9;
int fetchMode, ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &fetchMode_param, &colNoOrClassNameOrObject, &ctorargs);
fetchMode = zephir_get_intval(fetchMode_param);
if (!colNoOrClassNameOrObject) {
colNoOrClassNameOrObject = ZEPHIR_GLOBAL(global_null);
}
if (!ctorargs) {
ctorargs = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_OBS_VAR(pdoStatement);
zephir_read_property_this(&pdoStatement, this_ptr, SL("_pdoStatement"), PH_NOISY_CC);
if (fetchMode == 8) {
ZEPHIR_INIT_VAR(_1$$3);
ZVAL_LONG(_1$$3, fetchMode);
ZEPHIR_CALL_METHOD(&_0$$3, pdoStatement, "setfetchmode", NULL, 0, _1$$3, colNoOrClassNameOrObject, ctorargs);
zephir_check_call_status();
if (zephir_is_true(_0$$3)) {
ZEPHIR_INIT_ZVAL_NREF(_2$$4);
ZVAL_LONG(_2$$4, fetchMode);
zephir_update_property_this(this_ptr, SL("_fetchMode"), _2$$4 TSRMLS_CC);
RETURN_MM_BOOL(1);
}
RETURN_MM_BOOL(0);
}
if (fetchMode == 9) {
ZEPHIR_INIT_VAR(_4$$5);
ZVAL_LONG(_4$$5, fetchMode);
ZEPHIR_CALL_METHOD(&_3$$5, pdoStatement, "setfetchmode", NULL, 0, _4$$5, colNoOrClassNameOrObject);
zephir_check_call_status();
if (zephir_is_true(_3$$5)) {
ZEPHIR_INIT_ZVAL_NREF(_5$$6);
ZVAL_LONG(_5$$6, fetchMode);
zephir_update_property_this(this_ptr, SL("_fetchMode"), _5$$6 TSRMLS_CC);
RETURN_MM_BOOL(1);
}
RETURN_MM_BOOL(0);
}
if (fetchMode == 7) {
ZEPHIR_INIT_VAR(_7$$7);
ZVAL_LONG(_7$$7, fetchMode);
ZEPHIR_CALL_METHOD(&_6$$7, pdoStatement, "setfetchmode", NULL, 0, _7$$7, colNoOrClassNameOrObject);
zephir_check_call_status();
if (zephir_is_true(_6$$7)) {
ZEPHIR_INIT_ZVAL_NREF(_8$$8);
ZVAL_LONG(_8$$8, fetchMode);
zephir_update_property_this(this_ptr, SL("_fetchMode"), _8$$8 TSRMLS_CC);
RETURN_MM_BOOL(1);
}
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_VAR(_10);
ZVAL_LONG(_10, fetchMode);
ZEPHIR_CALL_METHOD(&_9, pdoStatement, "setfetchmode", NULL, 0, _10);
zephir_check_call_status();
if (zephir_is_true(_9)) {
ZEPHIR_INIT_ZVAL_NREF(_11$$9);
ZVAL_LONG(_11$$9, fetchMode);
zephir_update_property_this(this_ptr, SL("_fetchMode"), _11$$9 TSRMLS_CC);
RETURN_MM_BOOL(1);
}
RETURN_MM_BOOL(0);
}
/**
* Returns an array of prepared attributes for Phalcon\Tag helpers
* according to the element parameters
*
* @param array attributes
* @param boolean useChecked
* @return array
*/
PHP_METHOD(Phalcon_Forms_Element, prepareAttributes) {
int ZEPHIR_LAST_CALL_STATUS;
zend_bool useChecked;
zval *attributes = NULL, *useChecked_param = NULL, *value = NULL, *name = NULL, *widgetAttributes = NULL, *mergedAttributes = NULL, *defaultAttributes = NULL, *currentValue = NULL, *_0$$10, *_1$$12;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 2, &attributes, &useChecked_param);
if (!attributes) {
attributes = ZEPHIR_GLOBAL(global_null);
}
if (!useChecked_param) {
useChecked = 0;
} else {
useChecked = zephir_get_boolval(useChecked_param);
}
ZEPHIR_OBS_VAR(name);
zephir_read_property_this(&name, this_ptr, SL("_name"), PH_NOISY_CC);
if (Z_TYPE_P(attributes) != IS_ARRAY) {
ZEPHIR_INIT_VAR(widgetAttributes);
array_init(widgetAttributes);
} else {
ZEPHIR_CPY_WRT(widgetAttributes, attributes);
}
zephir_array_update_long(&widgetAttributes, 0, &name, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY);
ZEPHIR_OBS_VAR(defaultAttributes);
zephir_read_property_this(&defaultAttributes, this_ptr, SL("_attributes"), PH_NOISY_CC);
if (Z_TYPE_P(defaultAttributes) == IS_ARRAY) {
ZEPHIR_INIT_VAR(mergedAttributes);
zephir_fast_array_merge(mergedAttributes, &(defaultAttributes), &(widgetAttributes) TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(mergedAttributes, widgetAttributes);
}
ZEPHIR_CALL_METHOD(&value, this_ptr, "getvalue", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(value) != IS_NULL) {
if (useChecked) {
if (zephir_array_isset_string_fetch(¤tValue, mergedAttributes, SS("value"), 1 TSRMLS_CC)) {
if (ZEPHIR_IS_EQUAL(currentValue, value)) {
ZEPHIR_INIT_VAR(_0$$10);
ZVAL_STRING(_0$$10, "checked", 1);
zephir_array_update_string(&mergedAttributes, SL("checked"), &_0$$10, PH_COPY | PH_SEPARATE);
}
} else {
if (zephir_is_true(value)) {
ZEPHIR_INIT_VAR(_1$$12);
ZVAL_STRING(_1$$12, "checked", 1);
zephir_array_update_string(&mergedAttributes, SL("checked"), &_1$$12, PH_COPY | PH_SEPARATE);
}
zephir_array_update_string(&mergedAttributes, SL("value"), &value, PH_COPY | PH_SEPARATE);
}
} else {
zephir_array_update_string(&mergedAttributes, SL("value"), &value, PH_COPY | PH_SEPARATE);
}
}
RETURN_CCTOR(mergedAttributes);
}
/**
* Reconfigure the route adding a new pattern and a set of paths
*
* @param string pattern
* @param array paths
*/
PHP_METHOD(Test_Router_Route, reConfigure) {
int _0, ZEPHIR_LAST_CALL_STATUS;
zval *pattern, *paths = NULL, *moduleName = NULL, *controllerName = NULL, *actionName = NULL, *parts, *routePaths = NULL, *realClassName = NULL, *namespaceName, *pcrePattern = NULL, *compiledPattern = NULL, *extracted = NULL, *_1 = NULL, *_2;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &pattern, &paths);
if (!paths) {
paths = ZEPHIR_GLOBAL(global_null);
}
if (Z_TYPE_P(pattern) != IS_STRING) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(test_router_exception_ce, "The pattern must be string", "test/router/route.zep", 270);
return;
}
if (Z_TYPE_P(paths) != IS_NULL) {
if (Z_TYPE_P(paths) == IS_STRING) {
ZEPHIR_INIT_VAR(moduleName);
ZVAL_NULL(moduleName);
ZEPHIR_INIT_VAR(controllerName);
ZVAL_NULL(controllerName);
ZEPHIR_INIT_VAR(actionName);
ZVAL_NULL(actionName);
ZEPHIR_INIT_VAR(parts);
zephir_fast_explode_str(parts, SL("::"), paths, LONG_MAX TSRMLS_CC);
do {
_0 = zephir_fast_count_int(parts TSRMLS_CC);
if (_0 == 3) {
ZEPHIR_OBS_NVAR(moduleName);
zephir_array_fetch_long(&moduleName, parts, 0, PH_NOISY, "test/router/route.zep", 286 TSRMLS_CC);
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 1, PH_NOISY, "test/router/route.zep", 287 TSRMLS_CC);
ZEPHIR_OBS_NVAR(actionName);
zephir_array_fetch_long(&actionName, parts, 2, PH_NOISY, "test/router/route.zep", 288 TSRMLS_CC);
break;
}
if (_0 == 2) {
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY, "test/router/route.zep", 291 TSRMLS_CC);
ZEPHIR_OBS_NVAR(actionName);
zephir_array_fetch_long(&actionName, parts, 1, PH_NOISY, "test/router/route.zep", 292 TSRMLS_CC);
break;
}
if (_0 == 1) {
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY, "test/router/route.zep", 295 TSRMLS_CC);
break;
}
} while(0);
ZEPHIR_INIT_VAR(routePaths);
array_init(routePaths);
if (Z_TYPE_P(moduleName) != IS_NULL) {
zephir_array_update_string(&routePaths, SL("module"), &moduleName, PH_COPY | PH_SEPARATE);
}
if (Z_TYPE_P(controllerName) != IS_NULL) {
if (zephir_memnstr_str(controllerName, SL("\\"), "test/router/route.zep", 310)) {
ZEPHIR_INIT_VAR(realClassName);
zephir_get_class_ns(realClassName, controllerName, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(namespaceName);
zephir_get_ns_class(namespaceName, controllerName, 0 TSRMLS_CC);
if (zephir_is_true(namespaceName)) {
zephir_array_update_string(&routePaths, SL("namespace"), &namespaceName, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_CPY_WRT(realClassName, controllerName);
}
ZEPHIR_INIT_VAR(_1);
zephir_uncamelize(_1, realClassName);
zephir_array_update_string(&routePaths, SL("controller"), &_1, PH_COPY | PH_SEPARATE);
}
if (Z_TYPE_P(actionName) != IS_NULL) {
zephir_array_update_string(&routePaths, SL("action"), &actionName, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_CPY_WRT(routePaths, paths);
}
} else {
ZEPHIR_INIT_NVAR(routePaths);
array_init(routePaths);
}
if (Z_TYPE_P(routePaths) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(test_router_exception_ce, "The route contains invalid paths", "test/router/route.zep", 342);
return;
}
if (!(zephir_start_with_str(pattern, SL("#")))) {
if (zephir_memnstr_str(pattern, SL("{"), "test/router/route.zep", 348)) {
ZEPHIR_CALL_METHOD(&extracted, this_ptr, "extractnamedparams", NULL, pattern);
zephir_check_call_status();
ZEPHIR_OBS_VAR(pcrePattern);
zephir_array_fetch_long(&pcrePattern, extracted, 0, PH_NOISY, "test/router/route.zep", 351 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_1);
zephir_array_fetch_long(&_2, extracted, 1, PH_NOISY | PH_READONLY, "test/router/route.zep", 352 TSRMLS_CC);
zephir_fast_array_merge(_1, &(routePaths), &(_2) TSRMLS_CC);
ZEPHIR_CPY_WRT(routePaths, _1);
} else {
ZEPHIR_CPY_WRT(pcrePattern, pattern);
}
ZEPHIR_CALL_METHOD(&compiledPattern, this_ptr, "compilepattern", NULL, pcrePattern);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(compiledPattern, pattern);
}
zephir_update_property_this(this_ptr, SL("_pattern"), pattern TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_compiledPattern"), compiledPattern TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_paths"), routePaths TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Extracts parameters from a string
*
* @param string pattern
*/
PHP_METHOD(Test_Router_Route, extractNamedParams) {
long _0, _5$$11, _26$$19;
zend_bool notValid, _6$$12, _7$$12, _8$$12, _9$$12, _10$$12, _11$$12, _12$$12, _13$$12, _14$$12, _15$$12, _16$$12, _17$$12, _25$$18;
int tmp = 0, cursor = 0, cursorVar = 0, marker = 0, bracketCount, parenthesesCount, foundPattern, intermediate, numberMatches;
char ch = 0;
zval *pattern_param = NULL, *matches = NULL, _1$$11 = zval_used_for_init, _2$$11 = zval_used_for_init, *_3$$11 = NULL, _18$$16 = zval_used_for_init, _19$$16 = zval_used_for_init, *_20$$16 = NULL, _22$$16 = zval_used_for_init, *_23$$16 = NULL, *_27$$19 = NULL, *_28$$28 = NULL;
zval *pattern = NULL, *route = NULL, *item = NULL, *variable = NULL, *regexp = NULL, *_4$$11 = NULL, *_21$$16 = NULL, *_24$$16 = NULL, *_29$$29 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &pattern_param);
zephir_get_strval(pattern, pattern_param);
notValid = 0;
bracketCount = 0;
parenthesesCount = 0;
foundPattern = 0;
intermediate = 0;
numberMatches = 0;
if (zephir_fast_strlen_ev(pattern) <= 0) {
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_VAR(matches);
array_init(matches);
ZEPHIR_INIT_VAR(route);
ZVAL_EMPTY_STRING(route);
for (_0 = 0; _0 < Z_STRLEN_P(pattern); _0++) {
cursor = _0;
ch = ZEPHIR_STRING_OFFSET(pattern, _0);
if (parenthesesCount == 0) {
if (ch == '{') {
if (bracketCount == 0) {
marker = (cursor + 1);
intermediate = 0;
notValid = 0;
}
bracketCount++;
} else {
if (ch == '}') {
bracketCount--;
if (intermediate > 0) {
if (bracketCount == 0) {
numberMatches++;
ZEPHIR_INIT_NVAR(variable);
ZVAL_EMPTY_STRING(variable);
ZEPHIR_INIT_NVAR(regexp);
ZVAL_EMPTY_STRING(regexp);
ZEPHIR_SINIT_NVAR(_1$$11);
ZVAL_LONG(&_1$$11, marker);
ZEPHIR_SINIT_NVAR(_2$$11);
ZVAL_LONG(&_2$$11, (cursor - marker));
ZEPHIR_INIT_NVAR(_3$$11);
zephir_substr(_3$$11, pattern, zephir_get_intval(&_1$$11), zephir_get_intval(&_2$$11), 0);
zephir_get_strval(_4$$11, _3$$11);
ZEPHIR_CPY_WRT(item, _4$$11);
for (_5$$11 = 0; _5$$11 < Z_STRLEN_P(item); _5$$11++) {
cursorVar = _5$$11;
ch = ZEPHIR_STRING_OFFSET(item, _5$$11);
if (ch == '\0') {
break;
}
_6$$12 = cursorVar == 0;
if (_6$$12) {
_7$$12 = ch >= 'a';
if (_7$$12) {
_7$$12 = ch <= 'z';
}
_8$$12 = _7$$12;
if (!(_8$$12)) {
_9$$12 = ch >= 'A';
if (_9$$12) {
_9$$12 = ch <= 'Z';
}
_8$$12 = _9$$12;
}
_6$$12 = !(_8$$12);
}
if (_6$$12) {
notValid = 1;
break;
}
_10$$12 = ch >= 'a';
if (_10$$12) {
_10$$12 = ch <= 'z';
}
_11$$12 = _10$$12;
if (!(_11$$12)) {
_12$$12 = ch >= 'A';
if (_12$$12) {
_12$$12 = ch <= 'Z';
}
_11$$12 = _12$$12;
}
_13$$12 = _11$$12;
if (!(_13$$12)) {
_14$$12 = ch >= '0';
if (_14$$12) {
_14$$12 = ch <= '9';
}
_13$$12 = _14$$12;
}
_15$$12 = _13$$12;
if (!(_15$$12)) {
_15$$12 = ch == '-';
}
_16$$12 = _15$$12;
if (!(_16$$12)) {
_16$$12 = ch == '_';
}
_17$$12 = _16$$12;
if (!(_17$$12)) {
_17$$12 = ch == ':';
}
if (_17$$12) {
if (ch == ':') {
ZEPHIR_SINIT_NVAR(_18$$16);
ZVAL_LONG(&_18$$16, 0);
ZEPHIR_SINIT_NVAR(_19$$16);
ZVAL_LONG(&_19$$16, cursorVar);
ZEPHIR_INIT_NVAR(_20$$16);
zephir_substr(_20$$16, item, 0 , zephir_get_intval(&_19$$16), 0);
zephir_get_strval(_21$$16, _20$$16);
ZEPHIR_CPY_WRT(variable, _21$$16);
ZEPHIR_SINIT_NVAR(_22$$16);
ZVAL_LONG(&_22$$16, (cursorVar + 1));
ZEPHIR_INIT_NVAR(_23$$16);
zephir_substr(_23$$16, item, zephir_get_intval(&_22$$16), 0, ZEPHIR_SUBSTR_NO_LENGTH);
zephir_get_strval(_24$$16, _23$$16);
ZEPHIR_CPY_WRT(regexp, _24$$16);
break;
}
} else {
notValid = 1;
break;
}
}
if (!(notValid)) {
tmp = numberMatches;
_25$$18 = zephir_is_true(variable);
if (_25$$18) {
_25$$18 = zephir_is_true(regexp);
}
if (_25$$18) {
foundPattern = 0;
for (_26$$19 = 0; _26$$19 < Z_STRLEN_P(regexp); _26$$19++) {
ch = ZEPHIR_STRING_OFFSET(regexp, _26$$19);
if (ch == '\0') {
break;
}
if (!(foundPattern)) {
if (ch == '(') {
foundPattern = 1;
}
} else {
if (ch == ')') {
foundPattern = 2;
break;
}
}
}
if (foundPattern != 2) {
zephir_concat_self_str(&route, "(", sizeof("(")-1 TSRMLS_CC);
zephir_concat_self(&route, regexp TSRMLS_CC);
zephir_concat_self_str(&route, ")", sizeof(")")-1 TSRMLS_CC);
} else {
zephir_concat_self(&route, regexp TSRMLS_CC);
}
ZEPHIR_INIT_NVAR(_27$$19);
ZVAL_LONG(_27$$19, tmp);
zephir_array_update_zval(&matches, variable, &_27$$19, PH_COPY | PH_SEPARATE);
} else {
zephir_concat_self_str(&route, "([^/]*)", sizeof("([^/]*)")-1 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_28$$28);
ZVAL_LONG(_28$$28, tmp);
zephir_array_update_zval(&matches, item, &_28$$28, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_INIT_LNVAR(_29$$29);
ZEPHIR_CONCAT_SVS(_29$$29, "{", item, "}");
zephir_concat_self(&route, _29$$29 TSRMLS_CC);
}
continue;
}
}
}
}
}
if (bracketCount == 0) {
if (ch == '(') {
parenthesesCount++;
} else {
if (ch == ')') {
parenthesesCount--;
if (parenthesesCount == 0) {
numberMatches++;
}
}
}
}
if (bracketCount > 0) {
intermediate++;
} else {
zephir_concat_self_char(&route, ch TSRMLS_CC);
}
}
zephir_create_array(return_value, 2, 0 TSRMLS_CC);
zephir_array_fast_append(return_value, route);
zephir_array_fast_append(return_value, matches);
RETURN_MM();
}
/**
* Applies a format to a message before sending it to the log
*
* @param string $message
* @param int $type
* @param int $timestamp
* @param array $context
*
* @return string
*/
PHP_METHOD(Phalcon_Logger_Formatter_Firephp, format) {
HashTable *_7$$4;
HashPosition _6$$4;
zval *_18;
zend_bool _11, _14;
int type, timestamp, ZEPHIR_LAST_CALL_STATUS;
zval *message_param = NULL, *type_param = NULL, *timestamp_param = NULL, *context = NULL, *meta = NULL, *body = NULL, *backtrace = NULL, *encoded = NULL, *len = NULL, *lastTrace = NULL, *_1 = NULL, *_2, *_3, *_9, *_10, *_12, *_13, *_15, *_0$$3 = NULL, *param$$4 = NULL, *backtraceItem$$4 = NULL, *key$$4 = NULL, **_8$$4, *_4$$5, *_5$$6, *_16$$11, *_17$$11;
zval *message = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 1, &message_param, &type_param, ×tamp_param, &context);
zephir_get_strval(message, message_param);
type = zephir_get_intval(type_param);
timestamp = zephir_get_intval(timestamp_param);
if (!context) {
context = ZEPHIR_GLOBAL(global_null);
}
if (Z_TYPE_P(context) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&_0$$3, this_ptr, "interpolate", NULL, 0, message, context);
zephir_check_call_status();
zephir_get_strval(message, _0$$3);
}
ZEPHIR_INIT_VAR(meta);
zephir_create_array(meta, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_2);
ZVAL_LONG(_2, type);
ZEPHIR_CALL_METHOD(&_1, this_ptr, "gettypestring", NULL, 0, _2);
zephir_check_call_status();
zephir_array_update_string(&meta, SL("Type"), &_1, PH_COPY | PH_SEPARATE);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC);
if (zephir_is_true(_3)) {
ZEPHIR_INIT_VAR(param$$4);
ZVAL_LONG(param$$4, 2);
ZEPHIR_CALL_FUNCTION(&backtrace, "debug_backtrace", NULL, 160, param$$4);
zephir_check_call_status();
ZEPHIR_MAKE_REF(backtrace);
ZEPHIR_CALL_FUNCTION(&lastTrace, "end", NULL, 178, backtrace);
ZEPHIR_UNREF(backtrace);
zephir_check_call_status();
if (zephir_array_isset_string(lastTrace, SS("file"))) {
zephir_array_fetch_string(&_4$$5, lastTrace, SL("file"), PH_NOISY | PH_READONLY, "phalcon/logger/formatter/firephp.zep", 128 TSRMLS_CC);
zephir_array_update_string(&meta, SL("File"), &_4$$5, PH_COPY | PH_SEPARATE);
}
if (zephir_array_isset_string(lastTrace, SS("line"))) {
zephir_array_fetch_string(&_5$$6, lastTrace, SL("line"), PH_NOISY | PH_READONLY, "phalcon/logger/formatter/firephp.zep", 132 TSRMLS_CC);
zephir_array_update_string(&meta, SL("Line"), &_5$$6, PH_COPY | PH_SEPARATE);
}
zephir_is_iterable(backtrace, &_7$$4, &_6$$4, 1, 0, "phalcon/logger/formatter/firephp.zep", 141);
for (
; zephir_hash_get_current_data_ex(_7$$4, (void**) &_8$$4, &_6$$4) == SUCCESS
; zephir_hash_move_forward_ex(_7$$4, &_6$$4)
) {
ZEPHIR_GET_HMKEY(key$$4, _7$$4, _6$$4);
ZEPHIR_GET_HVALUE(backtraceItem$$4, _8$$4);
zephir_array_unset_string(&backtraceItem$$4, SS("object"), PH_SEPARATE);
zephir_array_unset_string(&backtraceItem$$4, SS("args"), PH_SEPARATE);
zephir_array_update_zval(&backtrace, key$$4, &backtraceItem$$4, PH_COPY | PH_SEPARATE);
}
zend_hash_destroy(_7$$4);
FREE_HASHTABLE(_7$$4);
}
_9 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC);
if (zephir_is_true(_9)) {
zephir_array_update_string(&meta, SL("Label"), &message, PH_COPY | PH_SEPARATE);
}
_10 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC);
_11 = !zephir_is_true(_10);
if (_11) {
_12 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC);
_11 = !zephir_is_true(_12);
}
_13 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC);
_14 = zephir_is_true(_13);
if (_14) {
_15 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC);
_14 = !zephir_is_true(_15);
}
if (_11) {
ZEPHIR_CPY_WRT(body, message);
} else if (_14) {
ZEPHIR_INIT_NVAR(body);
ZVAL_STRING(body, "", 1);
} else {
ZEPHIR_INIT_NVAR(body);
array_init(body);
_16$$11 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC);
if (zephir_is_true(_16$$11)) {
zephir_array_update_string(&body, SL("backtrace"), &backtrace, PH_COPY | PH_SEPARATE);
}
_17$$11 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC);
if (!(zephir_is_true(_17$$11))) {
zephir_array_update_string(&body, SL("message"), &message, PH_COPY | PH_SEPARATE);
}
}
ZEPHIR_INIT_VAR(_18);
zephir_create_array(_18, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_18, meta);
zephir_array_fast_append(_18, body);
ZEPHIR_INIT_VAR(encoded);
zephir_json_encode(encoded, &(encoded), _18, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(len);
ZVAL_LONG(len, zephir_fast_strlen_ev(encoded));
ZEPHIR_CONCAT_VSVS(return_value, len, "|", encoded, "|");
RETURN_MM();
}
/**
* Replaces placeholders from pattern returning a valid PCRE regular expression
*
* @param string pattern
* @return string
*/
PHP_METHOD(Test_Router_Route, compilePattern) {
zval *pattern = NULL, *idPattern = NULL, *_0$$4, _1$$4, *_2$$5, _3$$5, *_4$$6, _5$$6, *_6$$7, _7$$7, *_8$$8, _9$$8, _10$$8, *_11$$9, _12$$9, _13$$9;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &pattern);
ZEPHIR_SEPARATE_PARAM(pattern);
if (zephir_memnstr_str(pattern, SL(":"), "test/router/route.zep", 56)) {
ZEPHIR_INIT_VAR(idPattern);
ZVAL_STRING(idPattern, "/([a-zA-Z0-9\\_\\-]+)", 1);
if (zephir_memnstr_str(pattern, SL("/:module"), "test/router/route.zep", 62)) {
ZEPHIR_INIT_VAR(_0$$4);
ZEPHIR_SINIT_VAR(_1$$4);
ZVAL_STRING(&_1$$4, "/:module", 0);
zephir_fast_str_replace(&_0$$4, &_1$$4, idPattern, pattern TSRMLS_CC);
ZEPHIR_CPY_WRT(pattern, _0$$4);
}
if (zephir_memnstr_str(pattern, SL("/:controller"), "test/router/route.zep", 67)) {
ZEPHIR_INIT_VAR(_2$$5);
ZEPHIR_SINIT_VAR(_3$$5);
ZVAL_STRING(&_3$$5, "/:controller", 0);
zephir_fast_str_replace(&_2$$5, &_3$$5, idPattern, pattern TSRMLS_CC);
ZEPHIR_CPY_WRT(pattern, _2$$5);
}
if (zephir_memnstr_str(pattern, SL("/:namespace"), "test/router/route.zep", 72)) {
ZEPHIR_INIT_VAR(_4$$6);
ZEPHIR_SINIT_VAR(_5$$6);
ZVAL_STRING(&_5$$6, "/:namespace", 0);
zephir_fast_str_replace(&_4$$6, &_5$$6, idPattern, pattern TSRMLS_CC);
ZEPHIR_CPY_WRT(pattern, _4$$6);
}
if (zephir_memnstr_str(pattern, SL("/:action"), "test/router/route.zep", 77)) {
ZEPHIR_INIT_VAR(_6$$7);
ZEPHIR_SINIT_VAR(_7$$7);
ZVAL_STRING(&_7$$7, "/:action", 0);
zephir_fast_str_replace(&_6$$7, &_7$$7, idPattern, pattern TSRMLS_CC);
ZEPHIR_CPY_WRT(pattern, _6$$7);
}
if (zephir_memnstr_str(pattern, SL("/:params"), "test/router/route.zep", 82)) {
ZEPHIR_INIT_VAR(_8$$8);
ZEPHIR_SINIT_VAR(_9$$8);
ZVAL_STRING(&_9$$8, "/:params", 0);
ZEPHIR_SINIT_VAR(_10$$8);
ZVAL_STRING(&_10$$8, "(/.*)*", 0);
zephir_fast_str_replace(&_8$$8, &_9$$8, &_10$$8, pattern TSRMLS_CC);
ZEPHIR_CPY_WRT(pattern, _8$$8);
}
if (zephir_memnstr_str(pattern, SL("/:int"), "test/router/route.zep", 87)) {
ZEPHIR_INIT_VAR(_11$$9);
ZEPHIR_SINIT_VAR(_12$$9);
ZVAL_STRING(&_12$$9, "/:int", 0);
ZEPHIR_SINIT_VAR(_13$$9);
ZVAL_STRING(&_13$$9, "/([0-9]+)", 0);
zephir_fast_str_replace(&_11$$9, &_12$$9, &_13$$9, pattern TSRMLS_CC);
ZEPHIR_CPY_WRT(pattern, _11$$9);
}
}
if (zephir_memnstr_str(pattern, SL("("), "test/router/route.zep", 93)) {
ZEPHIR_CONCAT_SVS(return_value, "#^", pattern, "$#");
RETURN_MM();
}
if (zephir_memnstr_str(pattern, SL("["), "test/router/route.zep", 98)) {
ZEPHIR_CONCAT_SVS(return_value, "#^", pattern, "$#");
RETURN_MM();
}
RETVAL_ZVAL(pattern, 1, 0);
RETURN_MM();
}
/**
* @todo this method can be write differently with (P< style match
* Matches a user submitted path with parts defined by a map. Assigns and
* returns an array of variables on a successful match.
*
* @param string $path Path used to match against this routing map
* @return array|false An array of assigned values or a false on a mismatch
*/
PHP_METHOD(Yaf_Route_Rewrite, _match) {
zephir_nts_static zephir_fcall_cache_entry *_27 = NULL, *_33 = NULL;
zend_bool _12, _28, _32;
HashTable *_7, *_22, *_35;
HashPosition _6, _21, _34;
int staticCount, pathStaticCount, ZEPHIR_LAST_CALL_STATUS;
zval *path_param = NULL, *values, *matchedPath = NULL, *parts, *variables, *wildcardData, *name = NULL, *part = NULL, *pos = NULL, *pathMatch, *count = NULL, *i = NULL, *varr = NULL, *pathPart = NULL, *tmpReturn = NULL, *_0, *_1 = NULL, *_2 = NULL, *_3, _4 = zval_used_for_init, _5 = zval_used_for_init, **_8, _9 = zval_used_for_init, _10 = zval_used_for_init, *_11 = NULL, _13 = zval_used_for_init, _14 = zval_used_for_init, *_15 = NULL, _16 = zval_used_for_init, _17 = zval_used_for_init, *_18 = NULL, _19 = zval_used_for_init, *_20 = NULL, **_23, *_24 = NULL, *_25, *_26, *_29 = NULL, *_30, *_31 = NULL, **_36;
zval *path = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &path_param);
zephir_get_strval(path, path_param);
staticCount = 0;
pathStaticCount = 0;
ZEPHIR_INIT_VAR(values);
array_init(values);
ZEPHIR_INIT_VAR(matchedPath);
ZVAL_STRING(matchedPath, "", 1);
ZEPHIR_INIT_VAR(parts);
array_init(parts);
ZEPHIR_INIT_VAR(variables);
array_init(variables);
ZEPHIR_INIT_VAR(wildcardData);
array_init(wildcardData);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_route"), PH_NOISY_CC);
if (!ZEPHIR_IS_STRING_IDENTICAL(_0, "")) {
ZEPHIR_INIT_VAR(_1);
ZEPHIR_INIT_VAR(_2);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_route"), PH_NOISY_CC);
ZEPHIR_SINIT_VAR(_4);
ZVAL_STRING(&_4, "/", 0);
zephir_fast_trim(_2, _3, &_4, ZEPHIR_TRIM_BOTH TSRMLS_CC);
ZEPHIR_SINIT_VAR(_5);
ZVAL_STRING(&_5, "/", 0);
zephir_fast_explode(_1, &_5, _2, LONG_MAX TSRMLS_CC);
zephir_is_iterable(_1, &_7, &_6, 0, 0, "yaf/Route/rewrite.zep", 135);
for (
; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS
; zephir_hash_move_forward_ex(_7, &_6)
) {
ZEPHIR_GET_HMKEY(pos, _7, _6);
ZEPHIR_GET_HVALUE(part, _8);
ZEPHIR_SINIT_NVAR(_9);
ZVAL_LONG(&_9, 0);
ZEPHIR_SINIT_NVAR(_10);
ZVAL_LONG(&_10, 1);
ZEPHIR_INIT_NVAR(_11);
zephir_substr(_11, part, 0 , 1 , 0);
_12 = ZEPHIR_IS_STRING(_11, ":");
if (_12) {
ZEPHIR_SINIT_NVAR(_13);
ZVAL_LONG(&_13, 1);
ZEPHIR_SINIT_NVAR(_14);
ZVAL_LONG(&_14, 1);
ZEPHIR_INIT_NVAR(_15);
zephir_substr(_15, part, 1 , 1 , 0);
_12 = !ZEPHIR_IS_STRING(_15, ":");
}
if (_12) {
ZEPHIR_SINIT_NVAR(_16);
ZVAL_LONG(&_16, 1);
ZEPHIR_INIT_NVAR(name);
zephir_substr(name, part, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
zephir_array_update_zval(&parts, pos, &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
zephir_array_update_zval(&variables, pos, &name, PH_COPY | PH_SEPARATE);
} else {
ZEPHIR_SINIT_NVAR(_16);
ZVAL_LONG(&_16, 0);
ZEPHIR_SINIT_NVAR(_17);
ZVAL_LONG(&_17, 1);
ZEPHIR_INIT_NVAR(_18);
zephir_substr(_18, part, 0 , 1 , 0);
if (ZEPHIR_IS_STRING(_18, ":")) {
ZEPHIR_SINIT_NVAR(_19);
ZVAL_LONG(&_19, 1);
ZEPHIR_INIT_NVAR(_20);
zephir_substr(_20, part, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
ZEPHIR_CPY_WRT(part, _20);
}
zephir_array_update_zval(&parts, pos, &part, PH_COPY | PH_SEPARATE);
if (!ZEPHIR_IS_STRING_IDENTICAL(part, "*")) {
staticCount++;
}
}
}
}
if (!ZEPHIR_IS_STRING_IDENTICAL(path, "")) {
ZEPHIR_INIT_VAR(pathMatch);
ZEPHIR_SINIT_NVAR(_4);
ZVAL_STRING(&_4, "/", 0);
zephir_fast_explode(pathMatch, &_4, path, LONG_MAX TSRMLS_CC);
zephir_is_iterable(pathMatch, &_22, &_21, 0, 0, "yaf/Route/rewrite.zep", 193);
for (
; zephir_hash_get_current_data_ex(_22, (void**) &_23, &_21) == SUCCESS
; zephir_hash_move_forward_ex(_22, &_21)
) {
ZEPHIR_GET_HMKEY(pos, _22, _21);
ZEPHIR_GET_HVALUE(pathPart, _23);
if (!(zephir_array_key_exists(parts, pos TSRMLS_CC))) {
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_LNVAR(_24);
ZEPHIR_CONCAT_VS(_24, pathPart, "/");
zephir_concat_self(&matchedPath, _24 TSRMLS_CC);
zephir_array_fetch(&_25, parts, pos, PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 150 TSRMLS_CC);
if (ZEPHIR_IS_STRING(_25, "*")) {
ZEPHIR_INIT_NVAR(count);
ZVAL_LONG(count, zephir_fast_count_int(pathMatch TSRMLS_CC));
ZEPHIR_CPY_WRT(i, pos);
while (1) {
if (!(ZEPHIR_LT(i, count))) {
break;
}
zephir_array_fetch(&_26, pathMatch, i, PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 154 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&varr, "urldecode", &_27, _26);
zephir_check_call_status();
_12 = !(zephir_array_isset(wildcardData, varr));
if (_12) {
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC);
_12 = !(zephir_array_isset(_3, varr));
}
_28 = _12;
if (_28) {
_28 = !(zephir_array_isset(values, varr));
}
if (_28) {
ZEPHIR_INIT_LNVAR(_29);
if (zephir_array_isset_long(pathMatch, (zephir_get_numberval(i) + 1))) {
zephir_array_fetch_long(&_30, pathMatch, (zephir_get_numberval(i) + 1), PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 157 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_29, "urldecode", &_27, _30);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(_29);
ZVAL_NULL(_29);
}
zephir_array_update_zval(&wildcardData, varr, &_29, PH_COPY | PH_SEPARATE);
}
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, 2);
ZEPHIR_ADD_ASSIGN(i, _1);
}
ZEPHIR_INIT_NVAR(matchedPath);
ZEPHIR_SINIT_NVAR(_5);
ZVAL_STRING(&_5, "/", 0);
zephir_fast_join(matchedPath, &_5, pathMatch TSRMLS_CC);
break;
}
if (zephir_array_isset(variables, pos)) {
ZEPHIR_OBS_NVAR(name);
zephir_array_fetch(&name, variables, pos, PH_NOISY, "yaf/Route/rewrite.zep", 165 TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(name);
ZVAL_NULL(name);
}
ZEPHIR_CALL_FUNCTION(&_31, "urldecode", &_27, pathPart);
zephir_check_call_status();
ZEPHIR_CPY_WRT(pathPart, _31);
ZEPHIR_OBS_NVAR(part);
zephir_array_fetch(&part, parts, pos, PH_NOISY, "yaf/Route/rewrite.zep", 167 TSRMLS_CC);
ZEPHIR_SINIT_NVAR(_9);
ZVAL_LONG(&_9, 0);
ZEPHIR_SINIT_NVAR(_10);
ZVAL_LONG(&_10, 2);
ZEPHIR_INIT_NVAR(_2);
zephir_substr(_2, part, 0 , 2 , 0);
if (ZEPHIR_IS_STRING_IDENTICAL(_2, "@@")) {
ZEPHIR_SINIT_NVAR(_13);
ZVAL_LONG(&_13, 1);
ZEPHIR_INIT_NVAR(_11);
zephir_substr(_11, part, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
ZEPHIR_CPY_WRT(part, _11);
}
_28 = Z_TYPE_P(name) == IS_NULL;
if (_28) {
_28 = !ZEPHIR_IS_EQUAL(part, pathPart);
}
if (_28) {
RETURN_MM_BOOL(0);
}
_32 = Z_TYPE_P(part) != IS_NULL;
if (_32) {
ZEPHIR_INIT_LNVAR(_29);
ZEPHIR_CONCAT_VSSS(_29, part, "#^", "$#", "iu");
ZEPHIR_CALL_FUNCTION(&_31, "preg_match", &_33, _29, pathPart);
zephir_check_call_status();
_32 = !zephir_is_true(_31);
}
if (_32) {
RETURN_MM_BOOL(0);
}
if (Z_TYPE_P(name) != IS_NULL) {
zephir_array_update_zval(&values, name, &pathPart, PH_COPY | PH_SEPARATE);
} else {
pathStaticCount++;
}
}
}
if (staticCount != pathStaticCount) {
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_VAR(tmpReturn);
zephir_add_function_ex(tmpReturn, values, wildcardData TSRMLS_CC);
zephir_is_iterable(variables, &_35, &_34, 0, 0, "yaf/Route/rewrite.zep", 212);
for (
; zephir_hash_get_current_data_ex(_35, (void**) &_36, &_34) == SUCCESS
; zephir_hash_move_forward_ex(_35, &_34)
) {
ZEPHIR_GET_HVALUE(varr, _36);
if (!(zephir_array_key_exists(tmpReturn, varr TSRMLS_CC))) {
RETURN_MM_BOOL(0);
}
}
_12 = Z_TYPE_P(values) == IS_NULL;
if (_12) {
_12 = Z_TYPE_P(wildcardData) == IS_NULL;
}
_32 = _12;
if (_32) {
_32 = staticCount != 0;
}
if (_32) {
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC);
ZEPHIR_INIT_LNVAR(_24);
zephir_add_function_ex(_24, tmpReturn, _3 TSRMLS_CC);
ZEPHIR_CPY_WRT(tmpReturn, _24);
}
RETURN_CCTOR(tmpReturn);
}
/**
* Replaces placeholders from pattern returning a valid PCRE regular expression
*/
PHP_METHOD(Phalcon_Mvc_Router_Route, compilePattern) {
zval *pattern_param = NULL, *idPattern, *_0 = NULL, _1 = zval_used_for_init, _2 = zval_used_for_init;
zval *pattern = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &pattern_param);
if (unlikely(Z_TYPE_P(pattern_param) != IS_STRING && Z_TYPE_P(pattern_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'pattern' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(pattern_param) == IS_STRING)) {
zephir_get_strval(pattern, pattern_param);
} else {
ZEPHIR_INIT_VAR(pattern);
ZVAL_EMPTY_STRING(pattern);
}
if (zephir_memnstr_str(pattern, SL(":"), "phalcon/mvc/router/route.zep", 87)) {
ZEPHIR_INIT_VAR(idPattern);
ZVAL_STRING(idPattern, "/([a-zA-Z0-9\\_\\-]+)", 1);
if (zephir_memnstr_str(pattern, SL("/:module"), "phalcon/mvc/router/route.zep", 93)) {
ZEPHIR_INIT_VAR(_0);
ZEPHIR_SINIT_VAR(_1);
ZVAL_STRING(&_1, "/:module", 0);
zephir_fast_str_replace(&_0, &_1, idPattern, pattern TSRMLS_CC);
zephir_get_strval(pattern, _0);
}
if (zephir_memnstr_str(pattern, SL("/:controller"), "phalcon/mvc/router/route.zep", 98)) {
ZEPHIR_INIT_NVAR(_0);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_STRING(&_1, "/:controller", 0);
zephir_fast_str_replace(&_0, &_1, idPattern, pattern TSRMLS_CC);
zephir_get_strval(pattern, _0);
}
if (zephir_memnstr_str(pattern, SL("/:namespace"), "phalcon/mvc/router/route.zep", 103)) {
ZEPHIR_INIT_NVAR(_0);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_STRING(&_1, "/:namespace", 0);
zephir_fast_str_replace(&_0, &_1, idPattern, pattern TSRMLS_CC);
zephir_get_strval(pattern, _0);
}
if (zephir_memnstr_str(pattern, SL("/:action"), "phalcon/mvc/router/route.zep", 108)) {
ZEPHIR_INIT_NVAR(_0);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_STRING(&_1, "/:action", 0);
zephir_fast_str_replace(&_0, &_1, idPattern, pattern TSRMLS_CC);
zephir_get_strval(pattern, _0);
}
if (zephir_memnstr_str(pattern, SL("/:params"), "phalcon/mvc/router/route.zep", 113)) {
ZEPHIR_INIT_NVAR(_0);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_STRING(&_1, "/:params", 0);
ZEPHIR_SINIT_VAR(_2);
ZVAL_STRING(&_2, "(/.*)*", 0);
zephir_fast_str_replace(&_0, &_1, &_2, pattern TSRMLS_CC);
zephir_get_strval(pattern, _0);
}
if (zephir_memnstr_str(pattern, SL("/:int"), "phalcon/mvc/router/route.zep", 118)) {
ZEPHIR_INIT_NVAR(_0);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_STRING(&_1, "/:int", 0);
ZEPHIR_SINIT_NVAR(_2);
ZVAL_STRING(&_2, "/([0-9]+)", 0);
zephir_fast_str_replace(&_0, &_1, &_2, pattern TSRMLS_CC);
zephir_get_strval(pattern, _0);
}
}
if (zephir_memnstr_str(pattern, SL("("), "phalcon/mvc/router/route.zep", 124)) {
ZEPHIR_CONCAT_SVS(return_value, "#^", pattern, "$#");
RETURN_MM();
}
if (zephir_memnstr_str(pattern, SL("["), "phalcon/mvc/router/route.zep", 129)) {
ZEPHIR_CONCAT_SVS(return_value, "#^", pattern, "$#");
RETURN_MM();
}
RETURN_CTOR(pattern);
}
/**
* Tries to render the view with every engine registered in the component
*
* @param string path
* @param array params
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, _internalRender) {
HashTable *_4;
HashPosition _3;
zend_bool notExists = 0, mustClean = 0, _7$$8, _10$$8;
zephir_fcall_cache_entry *_13 = NULL, *_16 = NULL;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *path_param = NULL, *params, *eventsManager = NULL, *engines = NULL, *extension = NULL, *engine = NULL, *viewEnginePath = NULL, *viewsDirPath = NULL, *_2, **_5, *_0$$4 = NULL, *_1$$4, *_6$$6 = NULL, _8$$8 = zval_used_for_init, *_9$$8 = NULL, *_11$$12 = NULL, *_12$$12 = NULL, *_14$$11 = NULL, *_15$$14 = NULL, *_17$$15, *_18$$15, *_19$$16;
zval *path = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &path_param, ¶ms);
if (UNEXPECTED(Z_TYPE_P(path_param) != IS_STRING && Z_TYPE_P(path_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'path' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(path_param) == IS_STRING)) {
zephir_get_strval(path, path_param);
} else {
ZEPHIR_INIT_VAR(path);
ZVAL_EMPTY_STRING(path);
}
ZEPHIR_OBS_VAR(eventsManager);
zephir_read_property_this(&eventsManager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
zephir_update_property_this(getThis(), SL("_activeRenderPath"), path TSRMLS_CC);
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_1$$4);
ZVAL_STRING(_1$$4, "view:beforeRender", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0$$4, eventsManager, "fire", NULL, 0, _1$$4, this_ptr);
zephir_check_temp_parameter(_1$$4);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_0$$4)) {
RETURN_MM_NULL();
}
}
notExists = 1;
mustClean = 1;
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_viewsDir"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(viewsDirPath);
ZEPHIR_CONCAT_VV(viewsDirPath, _2, path);
ZEPHIR_CALL_METHOD(&engines, this_ptr, "_loadtemplateengines", NULL, 0);
zephir_check_call_status();
zephir_is_iterable(engines, &_4, &_3, 0, 0, "phalcon/mvc/view/simple.zep", 282);
for (
; zend_hash_get_current_data_ex(_4, (void**) &_5, &_3) == SUCCESS
; zend_hash_move_forward_ex(_4, &_3)
) {
ZEPHIR_GET_HMKEY(extension, _4, _3);
ZEPHIR_GET_HVALUE(engine, _5);
ZEPHIR_INIT_LNVAR(_6$$6);
ZEPHIR_CONCAT_VV(_6$$6, viewsDirPath, extension);
if ((zephir_file_exists(_6$$6 TSRMLS_CC) == SUCCESS)) {
ZEPHIR_INIT_NVAR(viewEnginePath);
ZEPHIR_CONCAT_VV(viewEnginePath, viewsDirPath, extension);
} else {
_7$$8 = zephir_is_true(extension);
if (_7$$8) {
ZEPHIR_SINIT_NVAR(_8$$8);
ZVAL_LONG(&_8$$8, -zephir_fast_strlen_ev(extension));
ZEPHIR_INIT_NVAR(_9$$8);
zephir_substr(_9$$8, viewsDirPath, zephir_get_intval(&_8$$8), 0, ZEPHIR_SUBSTR_NO_LENGTH);
_7$$8 = ZEPHIR_IS_EQUAL(_9$$8, extension);
}
_10$$8 = _7$$8;
if (_10$$8) {
_10$$8 = (zephir_file_exists(viewsDirPath TSRMLS_CC) == SUCCESS);
}
if (_10$$8) {
ZEPHIR_CPY_WRT(viewEnginePath, viewsDirPath);
} else {
ZEPHIR_INIT_NVAR(viewEnginePath);
ZVAL_STRING(viewEnginePath, "", 1);
}
}
if (zephir_is_true(viewEnginePath)) {
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_12$$12);
ZVAL_STRING(_12$$12, "view:beforeRenderView", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_11$$12, eventsManager, "fire", &_13, 0, _12$$12, this_ptr, viewEnginePath);
zephir_check_temp_parameter(_12$$12);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_11$$12)) {
continue;
}
}
ZEPHIR_INIT_NVAR(_14$$11);
if (mustClean) {
ZVAL_BOOL(_14$$11, 1);
} else {
ZVAL_BOOL(_14$$11, 0);
}
ZEPHIR_CALL_METHOD(NULL, engine, "render", NULL, 0, viewEnginePath, params, _14$$11);
zephir_check_call_status();
notExists = 0;
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_15$$14);
ZVAL_STRING(_15$$14, "view:afterRenderView", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", &_16, 0, _15$$14, this_ptr);
zephir_check_temp_parameter(_15$$14);
zephir_check_call_status();
}
break;
}
}
if (notExists == 1) {
ZEPHIR_INIT_VAR(_17$$15);
object_init_ex(_17$$15, phalcon_mvc_view_exception_ce);
ZEPHIR_INIT_VAR(_18$$15);
ZEPHIR_CONCAT_SVS(_18$$15, "View '", viewsDirPath, "' was not found in the views directory");
ZEPHIR_CALL_METHOD(NULL, _17$$15, "__construct", NULL, 9, _18$$15);
zephir_check_call_status();
zephir_throw_exception_debug(_17$$15, "phalcon/mvc/view/simple.zep", 283 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_19$$16);
ZVAL_STRING(_19$$16, "view:afterRender", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _19$$16, this_ptr);
zephir_check_temp_parameter(_19$$16);
zephir_check_call_status();
}
ZEPHIR_MM_RESTORE();
}
/**
* Extracts parameters from a string
*/
PHP_METHOD(Phalcon_Mvc_Router_Route, extractNamedParams) {
long _0, _5, _25;
zend_bool notValid, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17;
int tmp, cursor, cursorVar, marker, bracketCount = 0, parenthesesCount = 0, foundPattern = 0, intermediate = 0, numberMatches = 0;
char ch;
zval *pattern_param = NULL, *matches, _1 = zval_used_for_init, _2 = zval_used_for_init, *_3 = NULL, _18 = zval_used_for_init, _19 = zval_used_for_init, *_20 = NULL, _22 = zval_used_for_init, *_23 = NULL;
zval *pattern = NULL, *route, *item = NULL, *variable = NULL, *regexp = NULL, *_4 = NULL, *_21 = NULL, *_24 = NULL, *_26 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &pattern_param);
if (unlikely(Z_TYPE_P(pattern_param) != IS_STRING && Z_TYPE_P(pattern_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'pattern' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(pattern_param) == IS_STRING)) {
zephir_get_strval(pattern, pattern_param);
} else {
ZEPHIR_INIT_VAR(pattern);
ZVAL_EMPTY_STRING(pattern);
}
if (zephir_fast_strlen_ev(pattern) <= 0) {
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_VAR(matches);
array_init(matches);
ZEPHIR_INIT_VAR(route);
ZVAL_EMPTY_STRING(route);
for (_0 = 0; _0 < Z_STRLEN_P(pattern); _0++) {
cursor = _0;
ch = ZEPHIR_STRING_OFFSET(pattern, _0);
if (parenthesesCount == 0) {
if (ch == '{') {
if (bracketCount == 0) {
marker = (cursor + 1);
intermediate = 0;
notValid = 0;
}
bracketCount++;
} else {
if (ch == '}') {
bracketCount--;
if (intermediate > 0) {
if (bracketCount == 0) {
numberMatches++;
ZEPHIR_INIT_NVAR(variable);
ZVAL_EMPTY_STRING(variable);
ZEPHIR_INIT_NVAR(regexp);
ZVAL_EMPTY_STRING(regexp);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, marker);
ZEPHIR_SINIT_NVAR(_2);
ZVAL_LONG(&_2, (cursor - marker));
ZEPHIR_INIT_NVAR(_3);
zephir_substr(_3, pattern, zephir_get_intval(&_1), zephir_get_intval(&_2), 0);
zephir_get_strval(_4, _3);
ZEPHIR_CPY_WRT(item, _4);
for (_5 = 0; _5 < Z_STRLEN_P(item); _5++) {
cursorVar = _5;
ch = ZEPHIR_STRING_OFFSET(item, _5);
if (ch == '\0') {
break;
}
_6 = cursorVar == 0;
if (_6) {
_7 = ch >= 'a';
if (_7) {
_7 = ch <= 'z';
}
_8 = _7;
if (!(_8)) {
_9 = ch >= 'A';
if (_9) {
_9 = ch <= 'Z';
}
_8 = _9;
}
_6 = !(_8);
}
if (_6) {
notValid = 1;
break;
}
_10 = ch >= 'a';
if (_10) {
_10 = ch <= 'z';
}
_11 = _10;
if (!(_11)) {
_12 = ch >= 'A';
if (_12) {
_12 = ch <= 'Z';
}
_11 = _12;
}
_13 = _11;
if (!(_13)) {
_14 = ch >= '0';
if (_14) {
_14 = ch <= '9';
}
_13 = _14;
}
_15 = _13;
if (!(_15)) {
_15 = ch == '-';
}
_16 = _15;
if (!(_16)) {
_16 = ch == '_';
}
_17 = _16;
if (!(_17)) {
_17 = ch == ':';
}
if (_17) {
if (ch == ':') {
ZEPHIR_SINIT_NVAR(_18);
ZVAL_LONG(&_18, 0);
ZEPHIR_SINIT_NVAR(_19);
ZVAL_LONG(&_19, cursorVar);
ZEPHIR_INIT_NVAR(_20);
zephir_substr(_20, item, 0 , zephir_get_intval(&_19), 0);
zephir_get_strval(_21, _20);
ZEPHIR_CPY_WRT(variable, _21);
ZEPHIR_SINIT_NVAR(_22);
ZVAL_LONG(&_22, (cursorVar + 1));
ZEPHIR_INIT_NVAR(_23);
zephir_substr(_23, item, zephir_get_intval(&_22), 0, ZEPHIR_SUBSTR_NO_LENGTH);
zephir_get_strval(_24, _23);
ZEPHIR_CPY_WRT(regexp, _24);
break;
}
} else {
notValid = 1;
break;
}
}
if (!(notValid)) {
tmp = numberMatches;
_6 = zephir_is_true(variable);
if (_6) {
_6 = zephir_is_true(regexp);
}
if (_6) {
foundPattern = 0;
for (_25 = 0; _25 < Z_STRLEN_P(regexp); _25++) {
ch = ZEPHIR_STRING_OFFSET(regexp, _25);
if (ch == '\0') {
break;
}
if (!(foundPattern)) {
if (ch == '(') {
foundPattern = 1;
}
} else {
if (ch == ')') {
foundPattern = 2;
break;
}
}
}
if (foundPattern != 2) {
ZEPHIR_INIT_LNVAR(_26);
ZEPHIR_CONCAT_SVS(_26, "(", regexp, ")");
zephir_concat_self(&route, _26 TSRMLS_CC);
} else {
zephir_concat_self(&route, regexp TSRMLS_CC);
}
ZEPHIR_INIT_NVAR(_20);
ZVAL_LONG(_20, tmp);
zephir_array_update_zval(&matches, variable, &_20, PH_COPY | PH_SEPARATE);
} else {
zephir_concat_self_str(&route, "([^/]*)", sizeof("([^/]*)")-1 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_23);
ZVAL_LONG(_23, tmp);
zephir_array_update_zval(&matches, item, &_23, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_INIT_LNVAR(_26);
ZEPHIR_CONCAT_SVS(_26, "{", item, "}");
zephir_concat_self(&route, _26 TSRMLS_CC);
}
continue;
}
}
}
}
}
if (bracketCount == 0) {
if (ch == '(') {
parenthesesCount++;
} else {
if (ch == ')') {
parenthesesCount--;
if (parenthesesCount == 0) {
numberMatches++;
}
}
}
}
if (bracketCount > 0) {
intermediate++;
} else {
zephir_concat_self_char(&route, ch TSRMLS_CC);
}
}
zephir_create_array(return_value, 2, 0 TSRMLS_CC);
zephir_array_fast_append(return_value, route);
zephir_array_fast_append(return_value, matches);
RETURN_MM();
}
/**
* Returns a slice of the resultset to show in the pagination
*/
PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilder, getPaginate) {
int numberPage, before, ZEPHIR_LAST_CALL_STATUS;
zval *originalBuilder, *builder, *totalBuilder, *totalPages, *limit, *number, *query = NULL, *page, *items = NULL, *totalQuery = NULL, *result = NULL, *row = NULL, *rowcount, *next = NULL, *_0, *_1 = NULL, *_2, _3, _4, *_5;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(originalBuilder);
zephir_read_property_this(&originalBuilder, this_ptr, SL("_builder"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(builder);
if (zephir_clone(builder, originalBuilder TSRMLS_CC) == FAILURE) {
RETURN_MM();
}
ZEPHIR_INIT_VAR(totalBuilder);
if (zephir_clone(totalBuilder, builder TSRMLS_CC) == FAILURE) {
RETURN_MM();
}
ZEPHIR_OBS_VAR(limit);
zephir_read_property_this(&limit, this_ptr, SL("_limitRows"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(_0);
zephir_read_property_this(&_0, this_ptr, SL("_page"), PH_NOISY_CC);
numberPage = zephir_get_intval(_0);
if (!(numberPage)) {
numberPage = 1;
}
ZEPHIR_INIT_VAR(number);
ZVAL_LONG(number, (zephir_get_numberval(limit) * ((numberPage - 1))));
if (ZEPHIR_LT(number, limit)) {
ZEPHIR_CALL_METHOD(NULL, builder, "limit", NULL, 0, limit);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(NULL, builder, "limit", NULL, 0, limit, number);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&query, builder, "getquery", NULL, 0);
zephir_check_call_status();
if (numberPage == 1) {
before = 1;
} else {
before = (numberPage - 1);
}
ZEPHIR_CALL_METHOD(&items, query, "execute", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "COUNT(*) [rowcount]", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, totalBuilder, "columns", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_1);
ZVAL_NULL(_1);
ZEPHIR_CALL_METHOD(NULL, totalBuilder, "orderby", NULL, 0, _1);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&totalQuery, totalBuilder, "getquery", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&result, totalQuery, "execute", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&row, result, "getfirst", NULL, 0);
zephir_check_call_status();
ZEPHIR_OBS_VAR(_2);
zephir_read_property(&_2, row, SL("rowcount"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(rowcount);
ZVAL_LONG(rowcount, zephir_get_intval(_2));
ZEPHIR_SINIT_VAR(_3);
div_function(&_3, rowcount, limit TSRMLS_CC);
ZEPHIR_SINIT_VAR(_4);
ZVAL_DOUBLE(&_4, zephir_ceil(&_3 TSRMLS_CC));
ZEPHIR_INIT_VAR(totalPages);
ZVAL_LONG(totalPages, zephir_get_intval(&_4));
if (ZEPHIR_GT_LONG(totalPages, numberPage)) {
ZEPHIR_INIT_VAR(next);
ZVAL_LONG(next, (numberPage + 1));
} else {
ZEPHIR_CPY_WRT(next, totalPages);
}
ZEPHIR_INIT_VAR(page);
object_init(page);
zephir_update_property_zval(page, SL("items"), items TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_5);
ZVAL_LONG(_5, 1);
zephir_update_property_zval(page, SL("first"), _5 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_5);
ZVAL_LONG(_5, before);
zephir_update_property_zval(page, SL("before"), _5 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_5);
ZVAL_LONG(_5, numberPage);
zephir_update_property_zval(page, SL("current"), _5 TSRMLS_CC);
zephir_update_property_zval(page, SL("last"), totalPages TSRMLS_CC);
zephir_update_property_zval(page, SL("next"), next TSRMLS_CC);
zephir_update_property_zval(page, SL("total_pages"), totalPages TSRMLS_CC);
zephir_update_property_zval(page, SL("total_items"), rowcount TSRMLS_CC);
_5 = zephir_fetch_nproperty_this(this_ptr, SL("_limitRows"), PH_NOISY_CC);
zephir_update_property_zval(page, SL("limit"), _5 TSRMLS_CC);
RETURN_CCTOR(page);
}
/**
* Logs messages to the internal logger. Appends logs to the logger
*/
PHP_METHOD(Phalcon_Logger_Adapter, log) {
zend_bool _0, _1$$4;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *context = NULL;
zval *type, *message = NULL, *context_param = NULL, *timestamp = NULL, *toggledMessage = NULL, *toggledType = NULL, *_2, *_3$$8, *_4$$9;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &type, &message, &context_param);
if (!message) {
message = ZEPHIR_GLOBAL(global_null);
}
if (!context_param) {
ZEPHIR_INIT_VAR(context);
array_init(context);
} else {
context = context_param;
}
_0 = Z_TYPE_P(type) == IS_STRING;
if (_0) {
_0 = Z_TYPE_P(message) == IS_LONG;
}
if (_0) {
ZEPHIR_CPY_WRT(toggledMessage, type);
ZEPHIR_CPY_WRT(toggledType, message);
} else {
_1$$4 = Z_TYPE_P(type) == IS_STRING;
if (_1$$4) {
_1$$4 = Z_TYPE_P(message) == IS_NULL;
}
if (_1$$4) {
ZEPHIR_CPY_WRT(toggledMessage, type);
ZEPHIR_CPY_WRT(toggledType, message);
} else {
ZEPHIR_CPY_WRT(toggledMessage, message);
ZEPHIR_CPY_WRT(toggledType, type);
}
}
if (Z_TYPE_P(toggledType) == IS_NULL) {
ZEPHIR_INIT_NVAR(toggledType);
ZVAL_LONG(toggledType, 7);
}
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_logLevel"), PH_NOISY_CC);
if (ZEPHIR_GE(_2, toggledType)) {
ZEPHIR_INIT_VAR(timestamp);
zephir_time(timestamp);
_3$$8 = zephir_fetch_nproperty_this(this_ptr, SL("_transaction"), PH_NOISY_CC);
if (zephir_is_true(_3$$8)) {
ZEPHIR_INIT_VAR(_4$$9);
object_init_ex(_4$$9, phalcon_logger_item_ce);
ZEPHIR_CALL_METHOD(NULL, _4$$9, "__construct", NULL, 23, toggledMessage, toggledType, timestamp, context);
zephir_check_call_status();
zephir_update_property_array_append(this_ptr, SL("_queue"), _4$$9 TSRMLS_CC);
} else {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "loginternal", NULL, 0, toggledMessage, toggledType, timestamp, context);
zephir_check_call_status();
}
}
RETURN_THIS();
}