/**
* Set the background color of an image
*/
PHP_METHOD(Phalcon_Image_Adapter, background) {
zend_bool _0;
int opacity, ZEPHIR_LAST_CALL_STATUS;
zval *color_param = NULL, *opacity_param = NULL, *colors = NULL, _1, _2, *_3, _4 = zval_used_for_init, *_5 = NULL, *_6, *_7 = NULL, *_8, *_9, *_10;
zval *color = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &color_param, &opacity_param);
zephir_get_strval(color, color_param);
if (!opacity_param) {
opacity = 100;
} else {
opacity = zephir_get_intval(opacity_param);
}
_0 = zephir_fast_strlen_ev(color) > 1;
if (_0) {
ZEPHIR_SINIT_VAR(_1);
ZVAL_LONG(&_1, 0);
ZEPHIR_SINIT_VAR(_2);
ZVAL_LONG(&_2, 1);
ZEPHIR_INIT_VAR(_3);
zephir_substr(_3, color, 0 , 1 , 0);
_0 = ZEPHIR_IS_STRING_IDENTICAL(_3, "#");
}
if (_0) {
ZEPHIR_SINIT_VAR(_4);
ZVAL_LONG(&_4, 1);
ZEPHIR_INIT_VAR(_5);
zephir_substr(_5, color, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
zephir_get_strval(color, _5);
}
if (zephir_fast_strlen_ev(color) == 3) {
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRING(_5, "/./", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_6);
ZVAL_STRING(_6, "$0$0", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_FUNCTION(&_7, "preg_replace", NULL, 29, _5, _6, color);
zephir_check_temp_parameter(_5);
zephir_check_temp_parameter(_6);
zephir_check_call_status();
zephir_get_strval(color, _7);
}
ZEPHIR_SINIT_NVAR(_4);
ZVAL_LONG(&_4, 2);
ZEPHIR_CALL_FUNCTION(&_7, "str_split", NULL, 69, color, &_4);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_4);
ZVAL_STRING(&_4, "hexdec", 0);
ZEPHIR_CALL_FUNCTION(&colors, "array_map", NULL, 70, &_4, _7);
zephir_check_call_status();
zephir_array_fetch_long(&_8, colors, 0, PH_NOISY | PH_READONLY, "phalcon/image/adapter.zep", 366 TSRMLS_CC);
zephir_array_fetch_long(&_9, colors, 1, PH_NOISY | PH_READONLY, "phalcon/image/adapter.zep", 366 TSRMLS_CC);
zephir_array_fetch_long(&_10, colors, 2, PH_NOISY | PH_READONLY, "phalcon/image/adapter.zep", 366 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_5);
ZVAL_LONG(_5, opacity);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_background", NULL, 0, _8, _9, _10, _5);
zephir_check_call_status();
RETURN_THIS();
}
PHP_METHOD(Test_RegexDNA, process) {
HashTable *_6;
HashPosition _5;
int ZEPHIR_LAST_CALL_STATUS;
zephir_nts_static zephir_fcall_cache_entry *_4 = NULL, *_9 = NULL;
zval *path, *variants, *vIUB, *vIUBnew, *stuffToRemove, *contents = NULL, *initialLength, *regex = NULL, *codeLength, *discard = NULL, *_0, *_1, _2, *_3 = NULL, **_7, *_8 = NULL, *_10 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &path);
ZEPHIR_INIT_VAR(discard);
ZVAL_NULL(discard);
ZEPHIR_INIT_VAR(variants);
array_init_size(variants, 13);
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "agggtaaa|tttaccct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "[cgt]gggtaaa|tttaccc[acg]", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "a[act]ggtaaa|tttacc[agt]t", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "ag[act]gtaaa|tttac[agt]ct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "agg[act]taaa|ttta[agt]cct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "aggg[acg]aaa|ttt[cgt]ccct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "agggt[cgt]aa|tt[acg]accct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "agggta[cgt]a|t[acg]taccct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "agggtaa[cgt]|[acg]ttaccct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_VAR(vIUB);
array_init(vIUB);
ZEPHIR_INIT_VAR(vIUBnew);
array_init(vIUBnew);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/B/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(c|g|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/D/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|g|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/H/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|c|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/K/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(g|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/M/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|c)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/N/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|c|g|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/R/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|g)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/S/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(c|g)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/V/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|c|g)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/W/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/Y/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(c|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_VAR(stuffToRemove);
ZVAL_STRING(stuffToRemove, "^>.*$|\n", 1);
ZEPHIR_INIT_VAR(discard);
ZVAL_NULL(discard);
ZEPHIR_INIT_VAR(contents);
zephir_file_get_contents(contents, path TSRMLS_CC);
ZEPHIR_INIT_VAR(initialLength);
ZVAL_LONG(initialLength, zephir_fast_strlen_ev(contents));
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SVS(_1, "/", stuffToRemove, "/mS");
ZEPHIR_SINIT_VAR(_2);
ZVAL_STRING(&_2, "", 0);
ZEPHIR_CALL_FUNCTION(&_3, "preg_replace", &_4, _1, &_2, contents);
zephir_check_call_status();
ZEPHIR_CPY_WRT(contents, _3);
ZEPHIR_INIT_VAR(codeLength);
ZVAL_LONG(codeLength, zephir_fast_strlen_ev(contents));
zephir_is_iterable(variants, &_6, &_5, 0, 0);
for (
; zephir_hash_get_current_data_ex(_6, (void**) &_7, &_5) == SUCCESS
; zephir_hash_move_forward_ex(_6, &_5)
) {
ZEPHIR_GET_HVALUE(regex, _7);
zend_print_zval(regex, 0);
php_printf(" ");
ZEPHIR_INIT_LNVAR(_8);
ZEPHIR_CONCAT_SVS(_8, "/", regex, "/iS");
Z_SET_ISREF_P(discard);
ZEPHIR_CALL_FUNCTION(&_3, "preg_match_all", &_9, _8, contents, discard);
Z_UNSET_ISREF_P(discard);
zephir_check_call_status();
zend_print_zval(_3, 0);
php_printf("%c", '\n');
}
ZEPHIR_CALL_FUNCTION(&_10, "preg_replace", &_4, vIUB, vIUBnew, contents);
zephir_check_call_status();
ZEPHIR_CPY_WRT(contents, _10);
php_printf("%c", '\n');
zend_print_zval(initialLength, 0);
php_printf("%c", '\n');
zend_print_zval(codeLength, 0);
php_printf("%c", '\n');
php_printf("%d", zephir_fast_strlen_ev(contents));
php_printf("%c", '\n');
ZEPHIR_MM_RESTORE();
}
/**
* Pads texts before encryption
*
* @see http://www.di-mgt.com.au/cryptopad.html
*/
PHP_METHOD(Phalcon_Crypt, _cryptPadText) {
zend_bool _0, _9$$7;
zephir_fcall_cache_entry *_3 = NULL, *_5 = NULL, *_13 = NULL;
zend_long blockSize, paddingType, ZEPHIR_LAST_CALL_STATUS, i = 0, paddingSize, _10$$7, _11$$7;
zval *text_param = NULL, *mode_param = NULL, *blockSize_param = NULL, *paddingType_param = NULL, *padding = NULL, _25, _26, *_27, _1$$5 = zval_used_for_init, *_2$$5 = NULL, *_4$$5 = NULL, *_6$$5 = NULL, _7$$6 = zval_used_for_init, *_8$$6 = NULL, _15$$7, *_16$$7 = NULL, *_12$$8 = NULL, *_14$$8 = NULL, _17$$9 = zval_used_for_init, *_18$$9 = NULL, *_19$$9 = NULL, *_20$$9 = NULL, _21$$10 = zval_used_for_init, *_22$$10 = NULL, _23$$11, _24$$11;
zval *text = NULL, *mode = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &text_param, &mode_param, &blockSize_param, &paddingType_param);
zephir_get_strval(text, text_param);
if (UNEXPECTED(Z_TYPE_P(mode_param) != IS_STRING && Z_TYPE_P(mode_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'mode' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(mode_param) == IS_STRING)) {
zephir_get_strval(mode, mode_param);
} else {
ZEPHIR_INIT_VAR(mode);
ZVAL_EMPTY_STRING(mode);
}
if (UNEXPECTED(Z_TYPE_P(blockSize_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'blockSize' must be a int") TSRMLS_CC);
RETURN_MM_NULL();
}
blockSize = Z_LVAL_P(blockSize_param);
if (UNEXPECTED(Z_TYPE_P(paddingType_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'paddingType' must be a int") TSRMLS_CC);
RETURN_MM_NULL();
}
paddingType = Z_LVAL_P(paddingType_param);
paddingSize = 0;
ZEPHIR_INIT_VAR(padding);
ZVAL_NULL(padding);
_0 = ZEPHIR_IS_STRING(mode, "cbc");
if (!(_0)) {
_0 = ZEPHIR_IS_STRING(mode, "ecb");
}
if (_0) {
paddingSize = (blockSize - (zephir_safe_mod_long_long(zephir_fast_strlen_ev(text), blockSize TSRMLS_CC)));
if (paddingSize >= 256) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Block size is bigger than 256", "phalcon/crypt.zep", 121);
return;
}
do {
if (paddingType == 1) {
ZEPHIR_SINIT_VAR(_1$$5);
ZVAL_LONG(&_1$$5, 0);
ZEPHIR_CALL_FUNCTION(&_2$$5, "chr", &_3, 149, &_1$$5);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_1$$5);
ZVAL_LONG(&_1$$5, (paddingSize - 1));
ZEPHIR_CALL_FUNCTION(&_4$$5, "str_repeat", &_5, 150, _2$$5, &_1$$5);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_1$$5);
ZVAL_LONG(&_1$$5, paddingSize);
ZEPHIR_CALL_FUNCTION(&_6$$5, "chr", &_3, 149, &_1$$5);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(padding);
ZEPHIR_CONCAT_VV(padding, _4$$5, _6$$5);
break;
}
if (paddingType == 2) {
ZEPHIR_SINIT_VAR(_7$$6);
ZVAL_LONG(&_7$$6, paddingSize);
ZEPHIR_CALL_FUNCTION(&_8$$6, "chr", &_3, 149, &_7$$6);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_7$$6);
ZVAL_LONG(&_7$$6, paddingSize);
ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_5, 150, _8$$6, &_7$$6);
zephir_check_call_status();
break;
}
if (paddingType == 3) {
ZEPHIR_INIT_NVAR(padding);
ZVAL_STRING(padding, "", 1);
_11$$7 = (paddingSize - 2);
_10$$7 = 0;
_9$$7 = 0;
if (_10$$7 <= _11$$7) {
while (1) {
if (_9$$7) {
_10$$7++;
if (!(_10$$7 <= _11$$7)) {
break;
}
} else {
_9$$7 = 1;
}
i = _10$$7;
ZEPHIR_CALL_FUNCTION(&_12$$8, "rand", &_13, 127);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_14$$8, "chr", &_3, 149, _12$$8);
zephir_check_call_status();
zephir_concat_self(&padding, _14$$8 TSRMLS_CC);
}
}
ZEPHIR_SINIT_VAR(_15$$7);
ZVAL_LONG(&_15$$7, paddingSize);
ZEPHIR_CALL_FUNCTION(&_16$$7, "chr", &_3, 149, &_15$$7);
zephir_check_call_status();
zephir_concat_self(&padding, _16$$7 TSRMLS_CC);
break;
}
if (paddingType == 4) {
ZEPHIR_SINIT_VAR(_17$$9);
ZVAL_LONG(&_17$$9, 0x80);
ZEPHIR_CALL_FUNCTION(&_18$$9, "chr", &_3, 149, &_17$$9);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_17$$9);
ZVAL_LONG(&_17$$9, 0);
ZEPHIR_CALL_FUNCTION(&_19$$9, "chr", &_3, 149, &_17$$9);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_17$$9);
ZVAL_LONG(&_17$$9, (paddingSize - 1));
ZEPHIR_CALL_FUNCTION(&_20$$9, "str_repeat", &_5, 150, _19$$9, &_17$$9);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(padding);
ZEPHIR_CONCAT_VV(padding, _18$$9, _20$$9);
break;
}
if (paddingType == 5) {
ZEPHIR_SINIT_VAR(_21$$10);
ZVAL_LONG(&_21$$10, 0);
ZEPHIR_CALL_FUNCTION(&_22$$10, "chr", &_3, 149, &_21$$10);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_21$$10);
ZVAL_LONG(&_21$$10, paddingSize);
ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_5, 150, _22$$10, &_21$$10);
zephir_check_call_status();
break;
}
if (paddingType == 6) {
ZEPHIR_SINIT_VAR(_23$$11);
ZVAL_STRING(&_23$$11, " ", 0);
ZEPHIR_SINIT_VAR(_24$$11);
ZVAL_LONG(&_24$$11, paddingSize);
ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_5, 150, &_23$$11, &_24$$11);
zephir_check_call_status();
break;
}
paddingSize = 0;
break;
} while(0);
}
if (!(paddingSize)) {
RETURN_CTOR(text);
}
if (paddingSize > blockSize) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Invalid padding size", "phalcon/crypt.zep", 165);
return;
}
ZEPHIR_SINIT_VAR(_25);
ZVAL_LONG(&_25, 0);
ZEPHIR_SINIT_VAR(_26);
ZVAL_LONG(&_26, paddingSize);
ZEPHIR_INIT_VAR(_27);
zephir_substr(_27, padding, 0 , zephir_get_intval(&_26), 0);
ZEPHIR_CONCAT_VV(return_value, text, _27);
RETURN_MM();
}
/**
* Registers a set of PSR-4 directories for a given namespace, either
* appending or prepending to the ones previously set for this namespace.
*
* @param string $prefix The prefix/namespace, with trailing "\\"
* @param array|string $paths The PSR-0 base directories
* @param bool $prepend Whether to prepend the directories
* @throws \InvalidArgumentException
*/
PHP_METHOD(Xpl_ClassLoader, addPsr4) {
zend_bool prepend;
zval *prefix, *paths = NULL, *prepend_param = NULL, *firstChar = NULL, *prefixDirs = NULL, *_4, *_0$$5, *_1$$5, *_2$$6, *_3$$6, _5$$7, _6$$7, *_7$$7, *_8$$10, *_9$$11;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 1, &prefix, &paths, &prepend_param);
ZEPHIR_SEPARATE_PARAM(paths);
if (!prepend_param) {
prepend = 0;
} else {
prepend = zephir_get_boolval(prepend_param);
}
if (Z_TYPE_P(paths) == IS_STRING) {
ZEPHIR_INIT_NVAR(paths);
zephir_create_array(paths, 1, 0 TSRMLS_CC);
zephir_array_fast_append(paths, paths);
}
if (Z_TYPE_P(prefix) != IS_STRING) {
if (prepend) {
ZEPHIR_INIT_VAR(_0$$5);
_1$$5 = zephir_fetch_nproperty_this(this_ptr, SL("fallbackDirsPsr4"), PH_NOISY_CC);
zephir_fast_array_merge(_0$$5, &(paths), &(_1$$5) TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("fallbackDirsPsr4"), _0$$5 TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(_2$$6);
_3$$6 = zephir_fetch_nproperty_this(this_ptr, SL("fallbackDirsPsr4"), PH_NOISY_CC);
zephir_fast_array_merge(_2$$6, &(_3$$6), &(paths) TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("fallbackDirsPsr4"), _2$$6 TSRMLS_CC);
}
RETURN_MM_NULL();
}
ZEPHIR_OBS_VAR(prefixDirs);
_4 = zephir_fetch_nproperty_this(this_ptr, SL("prefixDirsPsr4"), PH_NOISY_CC);
if (!(zephir_array_isset_fetch(&prefixDirs, _4, prefix, 0 TSRMLS_CC))) {
ZEPHIR_SINIT_VAR(_5$$7);
ZVAL_LONG(&_5$$7, 0);
ZEPHIR_SINIT_VAR(_6$$7);
ZVAL_LONG(&_6$$7, 1);
ZEPHIR_INIT_VAR(firstChar);
zephir_substr(firstChar, prefix, 0 , 1 , 0);
if (!(zephir_end_with_str(prefix, SL("\\")))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "A non-empty PSR-4 prefix must end with a namespace separator.", "xpl/classloader.zep", 310);
return;
}
ZEPHIR_INIT_VAR(_7$$7);
ZVAL_LONG(_7$$7, zephir_fast_strlen_ev(prefix));
zephir_update_property_array_multi(this_ptr, SL("prefixLengthsPsr4"), &_7$$7 TSRMLS_CC, SL("zz"), 2, firstChar, prefix);
zephir_update_property_array(this_ptr, SL("prefixDirsPsr4"), prefix, paths TSRMLS_CC);
} else {
if (prepend) {
ZEPHIR_INIT_VAR(_8$$10);
zephir_fast_array_merge(_8$$10, &(paths), &(prefixDirs) TSRMLS_CC);
zephir_update_property_array(this_ptr, SL("prefixDirsPsr4"), prefix, _8$$10 TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(_9$$11);
zephir_fast_array_merge(_9$$11, &(prefixDirs), &(paths) TSRMLS_CC);
zephir_update_property_array(this_ptr, SL("prefixDirsPsr4"), prefix, _9$$11 TSRMLS_CC);
}
}
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_RegexDNA, process) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_3 = NULL;
zval *path, path_sub, variants, vIUB, vIUBnew, stuffToRemove, contents, initialLength, regex, codeLength, discard, _0, _1, _2, *_4, _5$$3, _6$$3;
ZEPHIR_INIT_THIS();
ZVAL_UNDEF(&path_sub);
ZVAL_UNDEF(&variants);
ZVAL_UNDEF(&vIUB);
ZVAL_UNDEF(&vIUBnew);
ZVAL_UNDEF(&stuffToRemove);
ZVAL_UNDEF(&contents);
ZVAL_UNDEF(&initialLength);
ZVAL_UNDEF(®ex);
ZVAL_UNDEF(&codeLength);
ZVAL_UNDEF(&discard);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZVAL_UNDEF(&_2);
ZVAL_UNDEF(&_5$$3);
ZVAL_UNDEF(&_6$$3);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &path);
ZEPHIR_INIT_VAR(&discard);
ZVAL_NULL(&discard);
ZEPHIR_INIT_VAR(&variants);
zephir_create_array(&variants, 9, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(&_0);
ZVAL_STRING(&_0, "agggtaaa|tttaccct");
zephir_array_fast_append(&variants, &_0);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "[cgt]gggtaaa|tttaccc[acg]");
zephir_array_fast_append(&variants, &_0);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "a[act]ggtaaa|tttacc[agt]t");
zephir_array_fast_append(&variants, &_0);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "ag[act]gtaaa|tttac[agt]ct");
zephir_array_fast_append(&variants, &_0);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "agg[act]taaa|ttta[agt]cct");
zephir_array_fast_append(&variants, &_0);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "aggg[acg]aaa|ttt[cgt]ccct");
zephir_array_fast_append(&variants, &_0);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "agggt[cgt]aa|tt[acg]accct");
zephir_array_fast_append(&variants, &_0);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "agggta[cgt]a|t[acg]taccct");
zephir_array_fast_append(&variants, &_0);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "agggtaa[cgt]|[acg]ttaccct");
zephir_array_fast_append(&variants, &_0);
ZEPHIR_INIT_VAR(&vIUB);
array_init(&vIUB);
ZEPHIR_INIT_VAR(&vIUBnew);
array_init(&vIUBnew);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "/B/S");
zephir_array_append(&vIUB, &_0, PH_SEPARATE, "test/regexdna.zep", 30);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "(c|g|t)");
zephir_array_append(&vIUBnew, &_0, PH_SEPARATE, "test/regexdna.zep", 30);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "/D/S");
zephir_array_append(&vIUB, &_0, PH_SEPARATE, "test/regexdna.zep", 31);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "(a|g|t)");
zephir_array_append(&vIUBnew, &_0, PH_SEPARATE, "test/regexdna.zep", 31);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "/H/S");
zephir_array_append(&vIUB, &_0, PH_SEPARATE, "test/regexdna.zep", 32);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "(a|c|t)");
zephir_array_append(&vIUBnew, &_0, PH_SEPARATE, "test/regexdna.zep", 32);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "/K/S");
zephir_array_append(&vIUB, &_0, PH_SEPARATE, "test/regexdna.zep", 33);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "(g|t)");
zephir_array_append(&vIUBnew, &_0, PH_SEPARATE, "test/regexdna.zep", 33);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "/M/S");
zephir_array_append(&vIUB, &_0, PH_SEPARATE, "test/regexdna.zep", 34);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "(a|c)");
zephir_array_append(&vIUBnew, &_0, PH_SEPARATE, "test/regexdna.zep", 34);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "/N/S");
zephir_array_append(&vIUB, &_0, PH_SEPARATE, "test/regexdna.zep", 35);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "(a|c|g|t)");
zephir_array_append(&vIUBnew, &_0, PH_SEPARATE, "test/regexdna.zep", 35);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "/R/S");
zephir_array_append(&vIUB, &_0, PH_SEPARATE, "test/regexdna.zep", 36);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "(a|g)");
zephir_array_append(&vIUBnew, &_0, PH_SEPARATE, "test/regexdna.zep", 36);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "/S/S");
zephir_array_append(&vIUB, &_0, PH_SEPARATE, "test/regexdna.zep", 37);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "(c|g)");
zephir_array_append(&vIUBnew, &_0, PH_SEPARATE, "test/regexdna.zep", 37);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "/V/S");
zephir_array_append(&vIUB, &_0, PH_SEPARATE, "test/regexdna.zep", 38);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "(a|c|g)");
zephir_array_append(&vIUBnew, &_0, PH_SEPARATE, "test/regexdna.zep", 38);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "/W/S");
zephir_array_append(&vIUB, &_0, PH_SEPARATE, "test/regexdna.zep", 39);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "(a|t)");
zephir_array_append(&vIUBnew, &_0, PH_SEPARATE, "test/regexdna.zep", 39);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "/Y/S");
zephir_array_append(&vIUB, &_0, PH_SEPARATE, "test/regexdna.zep", 40);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "(c|t)");
zephir_array_append(&vIUBnew, &_0, PH_SEPARATE, "test/regexdna.zep", 40);
ZEPHIR_INIT_VAR(&stuffToRemove);
ZVAL_STRING(&stuffToRemove, "^>.*$|\n");
ZEPHIR_INIT_NVAR(&discard);
ZVAL_NULL(&discard);
ZEPHIR_INIT_VAR(&contents);
zephir_file_get_contents(&contents, path TSRMLS_CC);
ZEPHIR_INIT_VAR(&initialLength);
ZVAL_LONG(&initialLength, zephir_fast_strlen_ev(&contents));
ZEPHIR_INIT_VAR(&_1);
ZEPHIR_CONCAT_SVS(&_1, "/", &stuffToRemove, "/mS");
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "");
ZEPHIR_CALL_FUNCTION(&_2, "preg_replace", &_3, 51, &_1, &_0, &contents);
zephir_check_call_status();
ZEPHIR_CPY_WRT(&contents, &_2);
ZEPHIR_INIT_VAR(&codeLength);
ZVAL_LONG(&codeLength, zephir_fast_strlen_ev(&contents));
zephir_is_iterable(&variants, 0, "test/regexdna.zep", 59);
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&variants), _4)
{
ZEPHIR_INIT_NVAR(®ex);
ZVAL_COPY(®ex, _4);
zend_print_zval(®ex, 0);
php_printf("%s", " ");
ZEPHIR_INIT_NVAR(&_5$$3);
ZEPHIR_INIT_LNVAR(_6$$3);
ZEPHIR_CONCAT_SVS(&_6$$3, "/", ®ex, "/iS");
zephir_preg_match(&_5$$3, &_6$$3, &contents, &discard, 1, 0 , 0 TSRMLS_CC);
zend_print_zval(&_5$$3, 0);
php_printf("%c", '\n');
} ZEND_HASH_FOREACH_END();
/**
* Pads texts before encryption
*
* @see http://www.di-mgt.com.au/cryptopad.html
*/
PHP_METHOD(Phalcon_Crypt, _cryptPadText) {
zephir_fcall_cache_entry *_3 = NULL, *_5 = NULL, *_10 = NULL;
zend_bool _0, _7;
int blockSize, paddingType, i, paddingSize = 0, ZEPHIR_LAST_CALL_STATUS, _8, _9;
zval *text_param = NULL, *mode_param = NULL, *blockSize_param = NULL, *paddingType_param = NULL, *padding = NULL, _1 = zval_used_for_init, *_2 = NULL, *_4 = NULL, *_6 = NULL, _11 = zval_used_for_init, *_12;
zval *text = NULL, *mode = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &text_param, &mode_param, &blockSize_param, &paddingType_param);
zephir_get_strval(text, text_param);
if (unlikely(Z_TYPE_P(mode_param) != IS_STRING && Z_TYPE_P(mode_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'mode' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(mode_param) == IS_STRING)) {
zephir_get_strval(mode, mode_param);
} else {
ZEPHIR_INIT_VAR(mode);
ZVAL_EMPTY_STRING(mode);
}
if (unlikely(Z_TYPE_P(blockSize_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'blockSize' must be a long/integer") TSRMLS_CC);
RETURN_MM_NULL();
}
blockSize = Z_LVAL_P(blockSize_param);
if (unlikely(Z_TYPE_P(paddingType_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'paddingType' must be a long/integer") TSRMLS_CC);
RETURN_MM_NULL();
}
paddingType = Z_LVAL_P(paddingType_param);
ZEPHIR_INIT_VAR(padding);
ZVAL_NULL(padding);
_0 = ZEPHIR_IS_STRING(mode, "cbc");
if (!(_0)) {
_0 = ZEPHIR_IS_STRING(mode, "ecb");
}
if (_0) {
paddingSize = (blockSize - (zephir_safe_mod_long_long(zephir_fast_strlen_ev(text), blockSize TSRMLS_CC)));
if (paddingSize >= 256) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Block size is bigger than 256", "phalcon/crypt.zep", 142);
return;
}
do {
if (paddingType == 1) {
ZEPHIR_SINIT_VAR(_1);
ZVAL_LONG(&_1, 0);
ZEPHIR_CALL_FUNCTION(&_2, "chr", &_3, 128, &_1);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, (paddingSize - 1));
ZEPHIR_CALL_FUNCTION(&_4, "str_repeat", &_5, 129, _2, &_1);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, paddingSize);
ZEPHIR_CALL_FUNCTION(&_6, "chr", &_3, 128, &_1);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(padding);
ZEPHIR_CONCAT_VV(padding, _4, _6);
break;
}
if (paddingType == 2) {
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, paddingSize);
ZEPHIR_CALL_FUNCTION(&_2, "chr", &_3, 128, &_1);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, paddingSize);
ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_5, 129, _2, &_1);
zephir_check_call_status();
break;
}
if (paddingType == 3) {
ZEPHIR_INIT_NVAR(padding);
ZVAL_STRING(padding, "", 1);
_9 = (paddingSize - 2);
_8 = 0;
_7 = 0;
if (_8 <= _9) {
while (1) {
if (_7) {
_8++;
if (!(_8 <= _9)) {
break;
}
} else {
_7 = 1;
}
i = _8;
ZEPHIR_CALL_FUNCTION(&_2, "rand", &_10, 107);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_4, "chr", &_3, 128, _2);
zephir_check_call_status();
zephir_concat_self(&padding, _4 TSRMLS_CC);
}
}
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, paddingSize);
ZEPHIR_CALL_FUNCTION(&_6, "chr", &_3, 128, &_1);
zephir_check_call_status();
zephir_concat_self(&padding, _6 TSRMLS_CC);
break;
}
if (paddingType == 4) {
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, 0x80);
ZEPHIR_CALL_FUNCTION(&_2, "chr", &_3, 128, &_1);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, 0);
ZEPHIR_CALL_FUNCTION(&_4, "chr", &_3, 128, &_1);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, (paddingSize - 1));
ZEPHIR_CALL_FUNCTION(&_6, "str_repeat", &_5, 129, _4, &_1);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(padding);
ZEPHIR_CONCAT_VV(padding, _2, _6);
break;
}
if (paddingType == 5) {
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, 0);
ZEPHIR_CALL_FUNCTION(&_2, "chr", &_3, 128, &_1);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, paddingSize);
ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_5, 129, _2, &_1);
zephir_check_call_status();
break;
}
if (paddingType == 6) {
ZEPHIR_SINIT_NVAR(_1);
ZVAL_STRING(&_1, " ", 0);
ZEPHIR_SINIT_VAR(_11);
ZVAL_LONG(&_11, paddingSize);
ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_5, 129, &_1, &_11);
zephir_check_call_status();
break;
}
paddingSize = 0;
break;
} while(0);
}
if (!(paddingSize)) {
RETURN_CTOR(text);
}
if (paddingSize > blockSize) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Invalid padding size", "phalcon/crypt.zep", 186);
return;
}
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, 0);
ZEPHIR_SINIT_NVAR(_11);
ZVAL_LONG(&_11, paddingSize);
ZEPHIR_INIT_VAR(_12);
zephir_substr(_12, padding, 0 , zephir_get_intval(&_11), 0);
ZEPHIR_CONCAT_VV(return_value, text, _12);
RETURN_MM();
}
/**
* Encrypts a text
*
*<code>
* $encrypted = $crypt->encrypt("Ultra-secret text", "encrypt password");
*</code>
*/
PHP_METHOD(Phalcon_Crypt, encrypt) {
zend_bool _3, _4;
int ZEPHIR_LAST_CALL_STATUS, _2;
zval *text_param = NULL, *key_param = NULL, *encryptKey = NULL, *ivSize = NULL, *iv = NULL, *cipher, *mode, *blockSize = NULL, *paddingType, *padded = NULL, _0, *_1 = NULL;
zval *text = NULL, *key = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &text_param, &key_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 (!key_param) {
ZEPHIR_INIT_VAR(key);
ZVAL_EMPTY_STRING(key);
} else {
if (unlikely(Z_TYPE_P(key_param) != IS_STRING && Z_TYPE_P(key_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'key' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(key_param) == IS_STRING)) {
zephir_get_strval(key, key_param);
} else {
ZEPHIR_INIT_VAR(key);
ZVAL_EMPTY_STRING(key);
}
}
if (!((zephir_function_exists_ex(SS("mcrypt_get_iv_size") TSRMLS_CC) == SUCCESS))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "mcrypt extension is required", "phalcon/crypt.zep", 302);
return;
}
if (ZEPHIR_IS_STRING_IDENTICAL(key, "")) {
ZEPHIR_OBS_VAR(encryptKey);
zephir_read_property_this(&encryptKey, this_ptr, SL("_key"), PH_NOISY_CC);
} else {
ZEPHIR_CPY_WRT(encryptKey, key);
}
if (ZEPHIR_IS_EMPTY(encryptKey)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Encryption key cannot be empty", "phalcon/crypt.zep", 312);
return;
}
ZEPHIR_OBS_VAR(cipher);
zephir_read_property_this(&cipher, this_ptr, SL("_cipher"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(mode);
zephir_read_property_this(&mode, this_ptr, SL("_mode"), PH_NOISY_CC);
ZEPHIR_CALL_FUNCTION(&ivSize, "mcrypt_get_iv_size", NULL, 131, cipher, mode);
zephir_check_call_status();
if (ZEPHIR_LT_LONG(ivSize, zephir_fast_strlen_ev(encryptKey))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Size of key is too large for this algorithm", "phalcon/crypt.zep", 320);
return;
}
ZEPHIR_SINIT_VAR(_0);
ZVAL_LONG(&_0, 2);
ZEPHIR_CALL_FUNCTION(&iv, "mcrypt_create_iv", NULL, 132, ivSize, &_0);
zephir_check_call_status();
if (Z_TYPE_P(iv) != IS_STRING) {
ZEPHIR_CALL_FUNCTION(&_1, "strval", NULL, 20, iv);
zephir_check_call_status();
ZEPHIR_CPY_WRT(iv, _1);
}
ZEPHIR_CALL_FUNCTION(&blockSize, "mcrypt_get_block_size", NULL, 133, cipher, mode);
zephir_check_call_status();
if (Z_TYPE_P(blockSize) != IS_LONG) {
_2 = zephir_get_intval(blockSize);
ZEPHIR_INIT_NVAR(blockSize);
ZVAL_LONG(blockSize, _2);
}
ZEPHIR_OBS_VAR(paddingType);
zephir_read_property_this(&paddingType, this_ptr, SL("_padding"), PH_NOISY_CC);
_3 = !ZEPHIR_IS_LONG(paddingType, 0);
if (_3) {
_4 = ZEPHIR_IS_STRING(mode, "cbc");
if (!(_4)) {
_4 = ZEPHIR_IS_STRING(mode, "ecb");
}
_3 = _4;
}
if (_3) {
ZEPHIR_CALL_METHOD(&padded, this_ptr, "_cryptpadtext", NULL, 0, text, mode, blockSize, paddingType);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(padded, text);
}
ZEPHIR_CALL_FUNCTION(&_1, "mcrypt_encrypt", NULL, 134, cipher, encryptKey, padded, mode, iv);
zephir_check_call_status();
ZEPHIR_CONCAT_VV(return_value, iv, _1);
RETURN_MM();
}
/**
* Executes the validator
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator_StringLength, validate) {
zval *_6$$9, *_11$$12;
zend_bool _1, _3;
zephir_fcall_cache_entry *_8 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *record, *field = NULL, *isSetMin = NULL, *isSetMax = NULL, *value = NULL, *length = NULL, *maximum = NULL, *minimum = NULL, *message = NULL, *_0 = NULL, *_2 = NULL, *_4$$8, *_5$$9 = NULL, *_7$$9 = NULL, *_9$$11, *_10$$12 = NULL, *_12$$12 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &record);
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "field", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&field, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (Z_TYPE_P(field) != IS_STRING) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Field name must be a string", "phalcon/mvc/model/validator/stringlength.zep", 67);
return;
}
ZEPHIR_INIT_NVAR(_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_mvc_model_exception_ce, "A minimum or maximum must be set", "phalcon/mvc/model/validator/stringlength.zep", 77);
return;
}
ZEPHIR_CALL_METHOD(&value, record, "readattribute", 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);
}
if ((zephir_function_exists_ex(SS("mb_strlen") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_FUNCTION(&length, "mb_strlen", NULL, 355, 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();
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(message);
ZVAL_STRING(message, "Value of field ':field' exceeds the maximum :max characters", 1);
}
ZEPHIR_INIT_VAR(_6$$9);
zephir_create_array(_6$$9, 2, 0 TSRMLS_CC);
zephir_array_update_string(&_6$$9, SL(":field"), &field, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_6$$9, SL(":max"), &maximum, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_FUNCTION(&_7$$9, "strtr", &_8, 55, message, _6$$9);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_5$$9);
ZVAL_STRING(_5$$9, "TooLong", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "appendmessage", NULL, 0, _7$$9, field, _5$$9);
zephir_check_temp_parameter(_5$$9);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
if (zephir_is_true(isSetMin)) {
ZEPHIR_INIT_VAR(_9$$11);
ZVAL_STRING(_9$$11, "min", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&minimum, this_ptr, "getoption", NULL, 0, _9$$11);
zephir_check_temp_parameter(_9$$11);
zephir_check_call_status();
if (ZEPHIR_LT(length, minimum)) {
ZEPHIR_INIT_VAR(_10$$12);
ZVAL_STRING(_10$$12, "messageMinimum", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _10$$12);
zephir_check_temp_parameter(_10$$12);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(message);
ZVAL_STRING(message, "Value of field ':field' is less than the minimum :min characters", 1);
}
ZEPHIR_INIT_VAR(_11$$12);
zephir_create_array(_11$$12, 2, 0 TSRMLS_CC);
zephir_array_update_string(&_11$$12, SL(":field"), &field, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_11$$12, SL(":min"), &minimum, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_FUNCTION(&_12$$12, "strtr", &_8, 55, message, _11$$12);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_10$$12);
ZVAL_STRING(_10$$12, "TooShort", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "appendmessage", NULL, 0, _12$$12, field, _10$$12);
zephir_check_temp_parameter(_10$$12);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
RETURN_MM_BOOL(1);
}
PHP_METHOD(Yb_Upload_StorageAbstract, generateUri) {
unsigned char _12, _13, _14, _15;
zephir_fcall_cache_entry *_9 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *source_param = NULL, *prefix_param = NULL, *extension_param = NULL, *_0, *_2 = NULL, *_8 = NULL, *_1$$3, *_3$$4, *_4$$4, _5$$4, *_6$$5;
zval *source = NULL, *prefix = NULL, *extension = NULL, *uri, *uuid = NULL, *_10, *_11 = NULL, *_7$$5, *_16$$6;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 0, &source_param, &prefix_param, &extension_param);
zephir_get_strval(source, source_param);
zephir_get_strval(prefix, prefix_param);
zephir_get_strval(extension, extension_param);
ZEPHIR_INIT_VAR(uri);
ZVAL_STRING(uri, "/", 1);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("uriGenerator"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
_1$$3 = zephir_fetch_nproperty_this(this_ptr, SL("uriGenerator"), PH_NOISY_CC);
ZEPHIR_RETURN_CALL_METHOD(_1$$3, "generateuri", NULL, 0, source, prefix, extension);
zephir_check_call_status();
RETURN_MM();
}
if (zephir_fast_strlen_ev(prefix) > 0) {
ZEPHIR_INIT_VAR(_3$$4);
ZEPHIR_INIT_VAR(_4$$4);
ZEPHIR_SINIT_VAR(_5$$4);
ZVAL_STRING(&_5$$4, "#^(\\w+/)*\\w*$#", 0);
zephir_preg_match(_4$$4, &_5$$4, prefix, _3$$4, 0, 0 , 0 TSRMLS_CC);
if (unlikely(!zephir_is_true(_4$$4))) {
ZEPHIR_INIT_VAR(_6$$5);
object_init_ex(_6$$5, yb_upload_exception_ce);
ZEPHIR_INIT_VAR(_7$$5);
ZEPHIR_CONCAT_SV(_7$$5, "Invalid prefix: ", prefix);
ZEPHIR_CALL_METHOD(NULL, _6$$5, "__construct", NULL, 2, _7$$5);
zephir_check_call_status();
zephir_throw_exception_debug(_6$$5, "yb/upload/storageabstract.zep", 37 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
zephir_concat_self(&uri, prefix TSRMLS_CC);
}
ZEPHIR_INIT_VAR(_10);
ZEPHIR_CONCAT_VV(_10, source, extension);
ZEPHIR_CALL_CE_STATIC(&_8, yb_std_ce, "uuid", &_9, 28, _10);
zephir_check_call_status();
zephir_get_strval(_11, _8);
ZEPHIR_CPY_WRT(uuid, _11);
_12 = ZEPHIR_STRING_OFFSET(uuid, 0);
zephir_concat_self_char(&uri, _12 TSRMLS_CC);
_13 = ZEPHIR_STRING_OFFSET(uuid, 1);
zephir_concat_self_char(&uri, _13 TSRMLS_CC);
zephir_concat_self_str(&uri, "/", sizeof("/")-1 TSRMLS_CC);
_14 = ZEPHIR_STRING_OFFSET(uuid, 2);
zephir_concat_self_char(&uri, _14 TSRMLS_CC);
_15 = ZEPHIR_STRING_OFFSET(uuid, 3);
zephir_concat_self_char(&uri, _15 TSRMLS_CC);
zephir_concat_self_str(&uri, "/", sizeof("/")-1 TSRMLS_CC);
zephir_concat_self(&uri, uuid TSRMLS_CC);
if (!(!extension) && Z_STRLEN_P(extension)) {
ZEPHIR_INIT_VAR(_16$$6);
ZEPHIR_CONCAT_SV(_16$$6, ".", extension);
zephir_concat_self(&uri, _16$$6 TSRMLS_CC);
}
RETURN_CTOR(uri);
}
/**
* 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, *_6 = NULL;
long length;
zval *type_param = NULL, *length_param = NULL, *pool = NULL, *str, _0 = zval_used_for_init, _1 = zval_used_for_init, *_2 = NULL, *_4 = NULL, *_5 = NULL, *_7;
int type, end, ZEPHIR_LAST_CALL_STATUS;
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);
ZVAL_STRING(&_0, "a", 0);
ZEPHIR_SINIT_VAR(_1);
ZVAL_STRING(&_1, "z", 0);
ZEPHIR_CALL_FUNCTION(&_2, "range", &_3, 416, &_0, &_1);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_0);
ZVAL_STRING(&_0, "A", 0);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_STRING(&_1, "Z", 0);
ZEPHIR_CALL_FUNCTION(&_4, "range", &_3, 416, &_0, &_1);
zephir_check_call_status();
ZEPHIR_INIT_VAR(pool);
zephir_fast_array_merge(pool, &(_2), &(_4) TSRMLS_CC);
break;
}
if (type == 2) {
ZEPHIR_SINIT_NVAR(_0);
ZVAL_LONG(&_0, 0);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, 9);
ZEPHIR_CALL_FUNCTION(&_2, "range", &_3, 416, &_0, &_1);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_0);
ZVAL_STRING(&_0, "a", 0);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_STRING(&_1, "f", 0);
ZEPHIR_CALL_FUNCTION(&_4, "range", &_3, 416, &_0, &_1);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(pool);
zephir_fast_array_merge(pool, &(_2), &(_4) TSRMLS_CC);
break;
}
if (type == 3) {
ZEPHIR_SINIT_NVAR(_0);
ZVAL_LONG(&_0, 0);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, 9);
ZEPHIR_CALL_FUNCTION(&pool, "range", &_3, 416, &_0, &_1);
zephir_check_call_status();
break;
}
if (type == 4) {
ZEPHIR_SINIT_NVAR(_0);
ZVAL_LONG(&_0, 1);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, 9);
ZEPHIR_CALL_FUNCTION(&pool, "range", &_3, 416, &_0, &_1);
zephir_check_call_status();
break;
}
ZEPHIR_SINIT_NVAR(_0);
ZVAL_LONG(&_0, 0);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, 9);
ZEPHIR_CALL_FUNCTION(&_2, "range", &_3, 416, &_0, &_1);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_0);
ZVAL_STRING(&_0, "a", 0);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_STRING(&_1, "z", 0);
ZEPHIR_CALL_FUNCTION(&_4, "range", &_3, 416, &_0, &_1);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_0);
ZVAL_STRING(&_0, "A", 0);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_STRING(&_1, "Z", 0);
ZEPHIR_CALL_FUNCTION(&_5, "range", &_3, 416, &_0, &_1);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&pool, "array_merge", &_6, 417, _2, _4, _5);
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(_0);
ZVAL_LONG(&_0, 0);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, end);
zephir_array_fetch_long(&_7, pool, zephir_mt_rand(zephir_get_intval(&_0), zephir_get_intval(&_1) TSRMLS_CC), PH_NOISY | PH_READONLY, "phalcon/text.zep", 130 TSRMLS_CC);
zephir_concat_self(&str, _7 TSRMLS_CC);
}
RETURN_CCTOR(str);
}
PHP_METHOD(Test_RegexDNA, process) {
HashTable *_4;
HashPosition _3;
zval *path, *variants, *vIUB, *vIUBnew, *stuffToRemove, *contents = NULL, *initialLength, *regex = NULL, *codeLength, *discard, *_0 = NULL, *_1, _2, **_5, *_6 = NULL, *_7;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &path);
ZEPHIR_INIT_VAR(variants);
array_init_size(variants, 13);
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "agggtaaa|tttaccct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "[cgt]gggtaaa|tttaccc[acg]", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "a[act]ggtaaa|tttacc[agt]t", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "ag[act]gtaaa|tttac[agt]ct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "agg[act]taaa|ttta[agt]cct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "aggg[acg]aaa|ttt[cgt]ccct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "agggt[cgt]aa|tt[acg]accct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "agggta[cgt]a|t[acg]taccct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "agggtaa[cgt]|[acg]ttaccct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_VAR(vIUB);
array_init(vIUB);
ZEPHIR_INIT_VAR(vIUBnew);
array_init(vIUBnew);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/B/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(c|g|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/D/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|g|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/H/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|c|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/K/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(g|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/M/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|c)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/N/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|c|g|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/R/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|g)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/S/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(c|g)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/V/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|c|g)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/W/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/Y/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(c|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_VAR(stuffToRemove);
ZVAL_STRING(stuffToRemove, "^>.*$|\n", 1);
ZEPHIR_INIT_VAR(discard);
ZVAL_NULL(discard);
ZEPHIR_INIT_VAR(contents);
zephir_file_get_contents(contents, path TSRMLS_CC);
ZEPHIR_INIT_VAR(initialLength);
ZVAL_LONG(initialLength, zephir_fast_strlen_ev(contents));
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SVS(_1, "/", stuffToRemove, "/mS");
ZEPHIR_SINIT_VAR(_2);
ZVAL_STRING(&_2, "", 0);
ZEPHIR_INIT_BNVAR(_0);
zephir_call_func_p3(_0, "preg_replace", _1, &_2, contents);
ZEPHIR_CPY_WRT(contents, _0);
ZEPHIR_INIT_VAR(codeLength);
ZVAL_LONG(codeLength, zephir_fast_strlen_ev(contents));
zephir_is_iterable(variants, &_4, &_3, 0, 0);
for (
; zend_hash_get_current_data_ex(_4, (void**) &_5, &_3) == SUCCESS
; zephir_hash_move_forward_ex(_4, &_3)
) {
ZEPHIR_GET_HVALUE(regex, _5);
zend_print_zval(regex, 0);
php_printf(" ");
ZEPHIR_INIT_NVAR(_0);
ZEPHIR_INIT_LNVAR(_6);
ZEPHIR_CONCAT_SVS(_6, "/", regex, "/iS");
zephir_preg_match(_0, &(_0), _6, contents, discard, 1, 0 , 0 TSRMLS_CC);
zend_print_zval(_0, 0);
php_printf("%c", '\n');
}
ZEPHIR_INIT_VAR(_7);
zephir_call_func_p3(_7, "preg_replace", vIUB, vIUBnew, contents);
ZEPHIR_CPY_WRT(contents, _7);
php_printf("%c", '\n');
zend_print_zval(initialLength, 0);
php_printf("%c", '\n');
zend_print_zval(codeLength, 0);
php_printf("%c", '\n');
php_printf("%d", zephir_fast_strlen_ev(contents));
php_printf("%c", '\n');
ZEPHIR_MM_RESTORE();
}
/**
* Decodes a URL-safe base64-encoded string.
*
* @param string data
*
* @return string Decoded string.
*/
PHP_METHOD(Xpl_Base64Url, decode) {
zval *_0, *_2;
int ZEPHIR_LAST_CALL_STATUS, mod4 = 0;
zval *data_param = NULL, *replaced = NULL, *_1 = NULL, _3$$3, _4$$3, *_5$$3;
zval *data = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &data_param);
zephir_get_strval(data, data_param);
ZEPHIR_INIT_VAR(_0);
zephir_create_array(_0, 8, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "-", 1);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "_", 1);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, " ", 1);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "\x09", 1);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "\x0a", 1);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "\x0b", 1);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "\x0c", 1);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "\x0d", 1);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_VAR(_2);
zephir_create_array(_2, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "+", 1);
zephir_array_fast_append(_2, _1);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "/", 1);
zephir_array_fast_append(_2, _1);
ZEPHIR_INIT_VAR(replaced);
zephir_fast_str_replace(&replaced, _0, _2, data TSRMLS_CC);
mod4 = (long) (zephir_safe_mod_long_long(zephir_fast_strlen_ev(replaced), 4 TSRMLS_CC));
if (mod4) {
ZEPHIR_SINIT_VAR(_3$$3);
ZVAL_STRING(&_3$$3, "====", 0);
ZEPHIR_SINIT_VAR(_4$$3);
ZVAL_LONG(&_4$$3, mod4);
ZEPHIR_INIT_VAR(_5$$3);
zephir_substr(_5$$3, &_3$$3, zephir_get_intval(&_4$$3), 0, ZEPHIR_SUBSTR_NO_LENGTH);
zephir_concat_self(&replaced, _5$$3 TSRMLS_CC);
}
ZEPHIR_RETURN_CALL_FUNCTION("base64_decode", NULL, 25, replaced);
zephir_check_call_status();
RETURN_MM();
}
/**
* Generates a URL
*
*<code>
* // Generate a URL appending the URI to the base URI
* echo $url->get("products/edit/1");
*
* // Generate a URL for a predefined route
* echo $url->get(
* [
* "for" => "blog-post",
* "title" => "some-cool-stuff",
* "year" => "2015",
* ]
* );
*
* // Generate a URL with GET arguments (/show/products?id=1&name=Carrots)
* echo $url->get(
* "show/products",
* [
* "id" => 1,
* "name" => "Carrots",
* ]
* );
*
* // Generate an absolute URL by setting the third parameter as false.
* echo $url->get(
* "https://phalconphp.com/",
* null,
* false
* );
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Url, get) {
unsigned char _17$$14, _19$$14, _24$$16;
zend_bool _0$$3, _1$$3, _15$$14, _16$$14, _18$$14, _22$$16, _23$$16, _25$$19;
zval *strUri = NULL, *_14$$14 = NULL;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *uri = NULL, *args = NULL, *local = NULL, *baseUri = NULL, *router = NULL, *dependencyInjector = NULL, *routeName = NULL, *route = NULL, *queryString = NULL, *_2$$4, *_3$$4, _4$$4, *_5$$9, *_9$$9 = NULL, *_12$$9, *_13$$9 = NULL, *_6$$11, *_7$$11 = NULL, *_8$$11, *_10$$13, *_11$$13, _20$$15, *_21$$15, _26$$20, *_27$$20, *_28$$21, *_29$$22;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 4, &uri, &args, &local, &baseUri);
if (!uri) {
ZEPHIR_CPY_WRT(uri, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(uri);
}
if (!args) {
args = ZEPHIR_GLOBAL(global_null);
}
if (!local) {
ZEPHIR_CPY_WRT(local, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(local);
}
if (!baseUri) {
ZEPHIR_CPY_WRT(baseUri, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(baseUri);
}
if (Z_TYPE_P(local) == IS_NULL) {
_0$$3 = Z_TYPE_P(uri) == IS_STRING;
if (_0$$3) {
_1$$3 = zephir_memnstr_str(uri, SL("//"), "phalcon/mvc/url.zep", 208);
if (!(_1$$3)) {
_1$$3 = zephir_memnstr_str(uri, SL(":"), "phalcon/mvc/url.zep", 208);
}
_0$$3 = _1$$3;
}
if (_0$$3) {
ZEPHIR_INIT_VAR(_2$$4);
ZEPHIR_INIT_VAR(_3$$4);
ZEPHIR_SINIT_VAR(_4$$4);
ZVAL_STRING(&_4$$4, "#^((//)|([a-z0-9]+://)|([a-z0-9]+:))#i", 0);
zephir_preg_match(_3$$4, &_4$$4, uri, _2$$4, 0, 0 , 0 TSRMLS_CC);
ZEPHIR_INIT_NVAR(local);
if (zephir_is_true(_3$$4)) {
ZVAL_BOOL(local, 0);
} else {
ZVAL_BOOL(local, 1);
}
} else {
ZEPHIR_INIT_NVAR(local);
ZVAL_BOOL(local, 1);
}
}
if (Z_TYPE_P(baseUri) != IS_STRING) {
ZEPHIR_CALL_METHOD(&baseUri, this_ptr, "getbaseuri", NULL, 0);
zephir_check_call_status();
}
if (Z_TYPE_P(uri) == IS_ARRAY) {
ZEPHIR_OBS_VAR(routeName);
if (!(zephir_array_isset_string_fetch(&routeName, uri, SS("for"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_url_exception_ce, "It's necessary to define the route name with the parameter 'for'", "phalcon/mvc/url.zep", 226);
return;
}
_5$$9 = zephir_fetch_nproperty_this(this_ptr, SL("_router"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(router, _5$$9);
if (Z_TYPE_P(router) != IS_OBJECT) {
_6$$11 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(dependencyInjector, _6$$11);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_url_exception_ce, "A dependency injector container is required to obtain the 'router' service", "phalcon/mvc/url.zep", 238);
return;
}
ZEPHIR_INIT_VAR(_8$$11);
ZVAL_STRING(_8$$11, "router", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_7$$11, dependencyInjector, "getshared", NULL, 0, _8$$11);
zephir_check_temp_parameter(_8$$11);
zephir_check_call_status();
ZEPHIR_CPY_WRT(router, _7$$11);
zephir_update_property_this(getThis(), SL("_router"), router TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_9$$9, router, "getroutebyname", NULL, 0, routeName);
zephir_check_call_status();
ZEPHIR_CPY_WRT(route, _9$$9);
if (Z_TYPE_P(route) != IS_OBJECT) {
ZEPHIR_INIT_VAR(_10$$13);
object_init_ex(_10$$13, phalcon_mvc_url_exception_ce);
ZEPHIR_INIT_VAR(_11$$13);
ZEPHIR_CONCAT_SVS(_11$$13, "Cannot obtain a route using the name '", routeName, "'");
ZEPHIR_CALL_METHOD(NULL, _10$$13, "__construct", NULL, 9, _11$$13);
zephir_check_call_status();
zephir_throw_exception_debug(_10$$13, "phalcon/mvc/url.zep", 250 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_INIT_VAR(_12$$9);
ZEPHIR_CALL_METHOD(&_9$$9, route, "getpattern", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_13$$9, route, "getreversedpaths", NULL, 0);
zephir_check_call_status();
phalcon_replace_paths(_12$$9, _9$$9, _13$$9, uri TSRMLS_CC);
ZEPHIR_CPY_WRT(uri, _12$$9);
}
if (zephir_is_true(local)) {
zephir_get_strval(_14$$14, uri);
ZEPHIR_CPY_WRT(strUri, _14$$14);
_15$$14 = ZEPHIR_IS_STRING(baseUri, "/");
if (_15$$14) {
_15$$14 = zephir_fast_strlen_ev(strUri) > 2;
}
_16$$14 = _15$$14;
if (_16$$14) {
_17$$14 = ZEPHIR_STRING_OFFSET(strUri, 0);
_16$$14 = _17$$14 == '/';
}
_18$$14 = _16$$14;
if (_18$$14) {
_19$$14 = ZEPHIR_STRING_OFFSET(strUri, 1);
_18$$14 = _19$$14 != '/';
}
if (_18$$14) {
ZEPHIR_SINIT_VAR(_20$$15);
ZVAL_LONG(&_20$$15, 1);
ZEPHIR_INIT_VAR(_21$$15);
zephir_substr(_21$$15, strUri, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
ZEPHIR_INIT_NVAR(uri);
ZEPHIR_CONCAT_VV(uri, baseUri, _21$$15);
} else {
_22$$16 = ZEPHIR_IS_STRING(baseUri, "/");
if (_22$$16) {
_22$$16 = zephir_fast_strlen_ev(strUri) == 1;
}
_23$$16 = _22$$16;
if (_23$$16) {
_24$$16 = ZEPHIR_STRING_OFFSET(strUri, 0);
_23$$16 = _24$$16 == '/';
}
if (_23$$16) {
ZEPHIR_CPY_WRT(uri, baseUri);
} else {
ZEPHIR_INIT_NVAR(uri);
ZEPHIR_CONCAT_VV(uri, baseUri, strUri);
}
}
}
if (zephir_is_true(args)) {
ZEPHIR_CALL_FUNCTION(&queryString, "http_build_query", NULL, 390, args);
zephir_check_call_status();
_25$$19 = Z_TYPE_P(queryString) == IS_STRING;
if (_25$$19) {
_25$$19 = ((zephir_fast_strlen_ev(queryString)) ? 1 : 0);
}
if (_25$$19) {
ZEPHIR_SINIT_VAR(_26$$20);
ZVAL_STRING(&_26$$20, "?", 0);
ZEPHIR_INIT_VAR(_27$$20);
zephir_fast_strpos(_27$$20, uri, &_26$$20, 0 );
if (!ZEPHIR_IS_FALSE_IDENTICAL(_27$$20)) {
ZEPHIR_INIT_VAR(_28$$21);
ZEPHIR_CONCAT_SV(_28$$21, "&", queryString);
zephir_concat_self(&uri, _28$$21 TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(_29$$22);
ZEPHIR_CONCAT_SV(_29$$22, "?", queryString);
zephir_concat_self(&uri, _29$$22 TSRMLS_CC);
}
}
}
RETVAL_ZVAL(uri, 1, 0);
RETURN_MM();
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_StringLength, validate) {
zend_bool _1;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *isSetMin = NULL, *isSetMax = NULL, *value = NULL, *length = NULL, *message = NULL, *minimum = NULL, *maximum = NULL, *label = NULL, *replacePairs = NULL, *code = NULL, *_0 = NULL, *_2$$6, *_3$$7, *_4$$8 = NULL, *_5$$8 = NULL, *_6$$8 = NULL, *_7$$9, *_8$$10, *_9$$11 = NULL, *_10$$11 = NULL, *_11$$11 = NULL;
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, "min", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&isSetMin, this_ptr, "hasoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "max", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&isSetMax, this_ptr, "hasoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
_1 = !zephir_is_true(isSetMin);
if (_1) {
_1 = !zephir_is_true(isSetMax);
}
if (_1) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "A minimum or maximum must be set", "phalcon/validation/validator/stringlength.zep", 95);
return;
}
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&label, this_ptr, "preparelabel", NULL, 0, validation, field);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&code, this_ptr, "preparecode", 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, 238, 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(_2$$6);
ZVAL_STRING(_2$$6, "max", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&maximum, this_ptr, "getoption", NULL, 0, _2$$6);
zephir_check_temp_parameter(_2$$6);
zephir_check_call_status();
if (Z_TYPE_P(maximum) == IS_ARRAY) {
zephir_array_fetch(&_3$$7, maximum, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/stringlength.zep", 116 TSRMLS_CC);
ZEPHIR_CPY_WRT(maximum, _3$$7);
}
if (ZEPHIR_GT(length, maximum)) {
ZEPHIR_INIT_VAR(_4$$8);
ZVAL_STRING(_4$$8, "TooLong", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_5$$8);
ZVAL_STRING(_5$$8, "messageMaximum", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _4$$8, _5$$8);
zephir_check_temp_parameter(_4$$8);
zephir_check_temp_parameter(_5$$8);
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);
ZEPHIR_INIT_NVAR(_4$$8);
object_init_ex(_4$$8, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_6$$8, "strtr", NULL, 27, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_5$$8);
ZVAL_STRING(_5$$8, "TooLong", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _4$$8, "__construct", NULL, 478, _6$$8, field, _5$$8, code);
zephir_check_temp_parameter(_5$$8);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _4$$8);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
if (zephir_is_true(isSetMin)) {
ZEPHIR_INIT_VAR(_7$$9);
ZVAL_STRING(_7$$9, "min", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&minimum, this_ptr, "getoption", NULL, 0, _7$$9);
zephir_check_temp_parameter(_7$$9);
zephir_check_call_status();
if (Z_TYPE_P(minimum) == IS_ARRAY) {
zephir_array_fetch(&_8$$10, minimum, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/stringlength.zep", 142 TSRMLS_CC);
ZEPHIR_CPY_WRT(minimum, _8$$10);
}
if (ZEPHIR_LT(length, minimum)) {
ZEPHIR_INIT_VAR(_9$$11);
ZVAL_STRING(_9$$11, "TooShort", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_10$$11);
ZVAL_STRING(_10$$11, "messageMinimum", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _9$$11, _10$$11);
zephir_check_temp_parameter(_9$$11);
zephir_check_temp_parameter(_10$$11);
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);
ZEPHIR_INIT_NVAR(_9$$11);
object_init_ex(_9$$11, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_11$$11, "strtr", NULL, 27, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_10$$11);
ZVAL_STRING(_10$$11, "TooShort", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _9$$11, "__construct", NULL, 478, _11$$11, field, _10$$11, code);
zephir_check_temp_parameter(_10$$11);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _9$$11);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
RETURN_MM_BOOL(1);
}
/**
* 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, 441, &_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, 441, &_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, 441, &_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, 441, &_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, 441, &_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, 441, &_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, 441, &_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, 441, &_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, 441, &_13$$7, &_14$$7);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&pool, "array_merge", &_18, 442, _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", 129 TSRMLS_CC);
zephir_concat_self(&str, _19$$8 TSRMLS_CC);
}
RETURN_CCTOR(str);
}
/**
* 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);
}
/**
* Prepare an HTML string of information about a single variable.
*/
PHP_METHOD(Phalcon_Debug_Dump, output) {
zend_bool _17$$5, _18$$5, _19$$5;
HashTable *_8$$4, *_42$$11, *_76$$20;
HashPosition _7$$4, _41$$11, _75$$20;
zval *_123, *_1$$4, *_13$$5 = NULL, *_26$$8, *_68$$8, *_32$$9, *_46$$12 = NULL, *_60$$14 = NULL, *_81$$22 = NULL, *_87$$23 = NULL, *_95$$24, *_100$$25, *_104$$26, *_108$$27, *_114$$28, *_119$$29;
zephir_fcall_cache_entry *_4 = NULL, *_6 = NULL, *_12 = NULL, *_23 = NULL, *_31 = NULL, *_53 = NULL, *_57 = NULL, *_62 = NULL;
int tab, ZEPHIR_LAST_CALL_STATUS;
zval *name = NULL, *_0$$3;
zval *variable, *name_param = NULL, *tab_param = NULL, *key = NULL, *value = NULL, *output = NULL, *space = NULL, *type = NULL, *attr = NULL, *_99 = NULL, *_124 = NULL, *_125, _126, *_2$$4 = NULL, *_3$$4, _5$$4 = zval_used_for_init, **_9$$4, *_25$$4 = NULL, _10$$5 = zval_used_for_init, *_11$$5 = NULL, *_14$$5 = NULL, *_15$$5 = NULL, *_16$$5 = NULL, *_20$$7 = NULL, *_21$$7 = NULL, *_22$$7 = NULL, *_24$$7 = NULL, *_27$$8 = NULL, *_28$$8 = NULL, _29$$8 = zval_used_for_init, *_30$$8 = NULL, *_36$$8, *_67$$8 = NULL, *_69$$8 = NULL, *_70$$8, *_71$$8, *_94$$8 = NULL, *_33$$9 = NULL, *_34$$9, _35$$9, _37$$10, *_38$$10 = NULL, *_39$$10, *_40$$11 = NULL, **_43$$11, _44$$12 = zval_used_for_init, *_45$$12 = NULL, *_47$$12 = NULL, *_48$$12 = NULL, *_49$$12 = NULL, *_50$$12 = NULL, *_51$$12 = NULL, *_52$$12 = NULL, *_54$$14 = NULL, _55$$14 = zval_used_for_init, *_56$$14 = NULL, *_59$$14 = NULL, *_61$$14 = NULL, *_63$$14 = NULL, *_64$$14 = NULL, *_65$$14 = NULL, *_66$$14 = NULL, *_58$$17, _72$$19, *_73$$19 = NULL, *_74$$19, **_77$$20, _91$$20, *_92$$20 = NULL, *_93$$20, *_78$$21 = NULL, _79$$22 = zval_used_for_init, *_80$$22 = NULL, *_82$$22 = NULL, *_83$$22 = NULL, *_84$$22 = NULL, _85$$23 = zval_used_for_init, *_86$$23 = NULL, *_88$$23 = NULL, *_89$$23 = NULL, *_90$$23 = NULL, *_96$$24 = NULL, *_97$$24, _98$$24, *_101$$25 = NULL, *_102$$25, _103$$25, *_105$$26 = NULL, *_106$$26, _107$$26, *_109$$27 = NULL, *_110$$27, _111$$27 = zval_used_for_init, _112$$27, *_113$$27 = NULL, *_115$$28 = NULL, *_116$$28, *_117$$28 = NULL, _118$$28, *_120$$29 = NULL, *_121$$29, _122$$29;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &variable, &name_param, &tab_param);
if (!name_param) {
ZEPHIR_INIT_VAR(name);
ZVAL_EMPTY_STRING(name);
} else {
zephir_get_strval(name, name_param);
}
if (!tab_param) {
tab = 1;
} else {
tab = zephir_get_intval(tab_param);
}
ZEPHIR_INIT_VAR(space);
ZVAL_STRING(space, " ", 1);
ZEPHIR_INIT_VAR(output);
ZVAL_STRING(output, "", 1);
if (!(!name) && Z_STRLEN_P(name)) {
ZEPHIR_INIT_VAR(_0$$3);
ZEPHIR_CONCAT_VS(_0$$3, name, " ");
ZEPHIR_CPY_WRT(output, _0$$3);
}
if (Z_TYPE_P(variable) == IS_ARRAY) {
ZEPHIR_INIT_VAR(_1$$4);
zephir_create_array(_1$$4, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_3$$4);
ZVAL_STRING(_3$$4, "arr", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_2$$4, this_ptr, "getstyle", &_4, 0, _3$$4);
zephir_check_temp_parameter(_3$$4);
zephir_check_call_status();
zephir_array_update_string(&_1$$4, SL(":style"), &_2$$4, PH_COPY | PH_SEPARATE);
add_assoc_long_ex(_1$$4, SS(":count"), zephir_fast_count_int(variable TSRMLS_CC));
ZEPHIR_SINIT_VAR(_5$$4);
ZVAL_STRING(&_5$$4, "<b style =':style'>Array</b> (<span style =':style'>:count</span>) (\n", 0);
ZEPHIR_CALL_FUNCTION(&_2$$4, "strtr", &_6, 26, &_5$$4, _1$$4);
zephir_check_call_status();
zephir_concat_self(&output, _2$$4 TSRMLS_CC);
zephir_is_iterable(variable, &_8$$4, &_7$$4, 0, 0, "phalcon/debug/dump.zep", 156);
for (
; zephir_hash_get_current_data_ex(_8$$4, (void**) &_9$$4, &_7$$4) == SUCCESS
; zephir_hash_move_forward_ex(_8$$4, &_7$$4)
) {
ZEPHIR_GET_HMKEY(key, _8$$4, _7$$4);
ZEPHIR_GET_HVALUE(value, _9$$4);
ZEPHIR_SINIT_NVAR(_10$$5);
ZVAL_LONG(&_10$$5, tab);
ZEPHIR_CALL_FUNCTION(&_11$$5, "str_repeat", &_12, 142, space, &_10$$5);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_13$$5);
zephir_create_array(_13$$5, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_15$$5);
ZVAL_STRING(_15$$5, "arr", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_14$$5, this_ptr, "getstyle", &_4, 0, _15$$5);
zephir_check_temp_parameter(_15$$5);
zephir_check_call_status();
zephir_array_update_string(&_13$$5, SL(":style"), &_14$$5, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_13$$5, SL(":key"), &key, PH_COPY | PH_SEPARATE);
ZEPHIR_SINIT_NVAR(_10$$5);
ZVAL_STRING(&_10$$5, "[<span style=':style'>:key</span>] => ", 0);
ZEPHIR_CALL_FUNCTION(&_14$$5, "strtr", &_6, 26, &_10$$5, _13$$5);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_16$$5);
ZEPHIR_CONCAT_VV(_16$$5, _11$$5, _14$$5);
zephir_concat_self(&output, _16$$5 TSRMLS_CC);
_17$$5 = tab == 1;
if (_17$$5) {
_17$$5 = !ZEPHIR_IS_STRING(name, "");
}
_18$$5 = _17$$5;
if (_18$$5) {
_18$$5 = !(Z_TYPE_P(key) == IS_LONG);
}
_19$$5 = _18$$5;
if (_19$$5) {
_19$$5 = ZEPHIR_IS_EQUAL(name, key);
}
if (_19$$5) {
continue;
} else {
ZEPHIR_INIT_NVAR(_21$$7);
ZVAL_STRING(_21$$7, "", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_22$$7);
ZVAL_LONG(_22$$7, (tab + 1));
ZEPHIR_CALL_METHOD(&_20$$7, this_ptr, "output", &_23, 175, value, _21$$7, _22$$7);
zephir_check_temp_parameter(_21$$7);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_24$$7);
ZEPHIR_CONCAT_VS(_24$$7, _20$$7, "\n");
zephir_concat_self(&output, _24$$7 TSRMLS_CC);
}
}
ZEPHIR_SINIT_NVAR(_5$$4);
ZVAL_LONG(&_5$$4, (tab - 1));
ZEPHIR_CALL_FUNCTION(&_25$$4, "str_repeat", &_12, 142, space, &_5$$4);
zephir_check_call_status();
ZEPHIR_CONCAT_VVS(return_value, output, _25$$4, ")");
RETURN_MM();
}
if (Z_TYPE_P(variable) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_26$$8);
zephir_create_array(_26$$8, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_28$$8);
ZVAL_STRING(_28$$8, "obj", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_27$$8, this_ptr, "getstyle", &_4, 0, _28$$8);
zephir_check_temp_parameter(_28$$8);
zephir_check_call_status();
zephir_array_update_string(&_26$$8, SL(":style"), &_27$$8, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_28$$8);
zephir_get_class(_28$$8, variable, 0 TSRMLS_CC);
zephir_array_update_string(&_26$$8, SL(":class"), &_28$$8, PH_COPY | PH_SEPARATE);
ZEPHIR_SINIT_VAR(_29$$8);
ZVAL_STRING(&_29$$8, "<b style=':style'>Object</b> :class", 0);
ZEPHIR_CALL_FUNCTION(&_27$$8, "strtr", &_6, 26, &_29$$8, _26$$8);
zephir_check_call_status();
zephir_concat_self(&output, _27$$8 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_30$$8, "get_parent_class", &_31, 176, variable);
zephir_check_call_status();
if (zephir_is_true(_30$$8)) {
ZEPHIR_INIT_VAR(_32$$9);
zephir_create_array(_32$$9, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_34$$9);
ZVAL_STRING(_34$$9, "obj", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_33$$9, this_ptr, "getstyle", &_4, 0, _34$$9);
zephir_check_temp_parameter(_34$$9);
zephir_check_call_status();
zephir_array_update_string(&_32$$9, SL(":style"), &_33$$9, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_FUNCTION(&_33$$9, "get_parent_class", &_31, 176, variable);
zephir_check_call_status();
zephir_array_update_string(&_32$$9, SL(":parent"), &_33$$9, PH_COPY | PH_SEPARATE);
ZEPHIR_SINIT_VAR(_35$$9);
ZVAL_STRING(&_35$$9, " <b style=':style'>extends</b> :parent", 0);
ZEPHIR_CALL_FUNCTION(&_33$$9, "strtr", &_6, 26, &_35$$9, _32$$9);
zephir_check_call_status();
zephir_concat_self(&output, _33$$9 TSRMLS_CC);
}
zephir_concat_self_str(&output, SL(" (\n") TSRMLS_CC);
_36$$8 = zephir_fetch_nproperty_this(this_ptr, SL("_detailed"), PH_NOISY_CC);
if (zephir_instance_of_ev(variable, phalcon_di_ce TSRMLS_CC)) {
ZEPHIR_SINIT_VAR(_37$$10);
ZVAL_LONG(&_37$$10, tab);
ZEPHIR_CALL_FUNCTION(&_38$$10, "str_repeat", &_12, 142, space, &_37$$10);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_39$$10);
ZEPHIR_CONCAT_VS(_39$$10, _38$$10, "[skipped]\n");
zephir_concat_self(&output, _39$$10 TSRMLS_CC);
} else if (!(zephir_is_true(_36$$8))) {
ZEPHIR_CALL_FUNCTION(&_40$$11, "get_object_vars", NULL, 21, variable);
zephir_check_call_status();
zephir_is_iterable(_40$$11, &_42$$11, &_41$$11, 0, 0, "phalcon/debug/dump.zep", 177);
for (
; zephir_hash_get_current_data_ex(_42$$11, (void**) &_43$$11, &_41$$11) == SUCCESS
; zephir_hash_move_forward_ex(_42$$11, &_41$$11)
) {
ZEPHIR_GET_HMKEY(key, _42$$11, _41$$11);
ZEPHIR_GET_HVALUE(value, _43$$11);
ZEPHIR_SINIT_NVAR(_44$$12);
ZVAL_LONG(&_44$$12, tab);
ZEPHIR_CALL_FUNCTION(&_45$$12, "str_repeat", &_12, 142, space, &_44$$12);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_46$$12);
zephir_create_array(_46$$12, 3, 0 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_48$$12);
ZVAL_STRING(_48$$12, "obj", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_47$$12, this_ptr, "getstyle", &_4, 0, _48$$12);
zephir_check_temp_parameter(_48$$12);
zephir_check_call_status();
zephir_array_update_string(&_46$$12, SL(":style"), &_47$$12, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_46$$12, SL(":key"), &key, PH_COPY | PH_SEPARATE);
add_assoc_stringl_ex(_46$$12, SS(":type"), SL("public"), 1);
ZEPHIR_SINIT_NVAR(_44$$12);
ZVAL_STRING(&_44$$12, "-><span style=':style'>:key</span> (<span style=':style'>:type</span>) = ", 0);
ZEPHIR_CALL_FUNCTION(&_47$$12, "strtr", &_6, 26, &_44$$12, _46$$12);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_49$$12);
ZEPHIR_CONCAT_VV(_49$$12, _45$$12, _47$$12);
zephir_concat_self(&output, _49$$12 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_48$$12);
ZVAL_STRING(_48$$12, "", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_51$$12);
ZVAL_LONG(_51$$12, (tab + 1));
ZEPHIR_CALL_METHOD(&_50$$12, this_ptr, "output", &_23, 175, value, _48$$12, _51$$12);
zephir_check_temp_parameter(_48$$12);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_52$$12);
ZEPHIR_CONCAT_VS(_52$$12, _50$$12, "\n");
zephir_concat_self(&output, _52$$12 TSRMLS_CC);
}
} else {
do {
ZEPHIR_MAKE_REF(variable);
ZEPHIR_CALL_FUNCTION(&attr, "each", &_53, 177, variable);
ZEPHIR_UNREF(variable);
zephir_check_call_status();
if (!(zephir_is_true(attr))) {
continue;
}
ZEPHIR_OBS_NVAR(key);
zephir_array_fetch_string(&key, attr, SL("key"), PH_NOISY, "phalcon/debug/dump.zep", 187 TSRMLS_CC);
ZEPHIR_OBS_NVAR(value);
zephir_array_fetch_string(&value, attr, SL("value"), PH_NOISY, "phalcon/debug/dump.zep", 188 TSRMLS_CC);
if (!(zephir_is_true(key))) {
continue;
}
ZEPHIR_INIT_NVAR(_54$$14);
ZEPHIR_SINIT_NVAR(_55$$14);
ZVAL_LONG(&_55$$14, 0);
ZEPHIR_CALL_FUNCTION(&_56$$14, "chr", &_57, 141, &_55$$14);
zephir_check_call_status();
zephir_fast_explode(_54$$14, _56$$14, key, LONG_MAX TSRMLS_CC);
ZEPHIR_CPY_WRT(key, _54$$14);
ZEPHIR_INIT_NVAR(type);
ZVAL_STRING(type, "public", 1);
if (zephir_array_isset_long(key, 1)) {
ZEPHIR_INIT_NVAR(type);
ZVAL_STRING(type, "private", 1);
zephir_array_fetch_long(&_58$$17, key, 1, PH_NOISY | PH_READONLY, "phalcon/debug/dump.zep", 200 TSRMLS_CC);
if (ZEPHIR_IS_STRING(_58$$17, "*")) {
ZEPHIR_INIT_NVAR(type);
ZVAL_STRING(type, "protected", 1);
}
}
ZEPHIR_SINIT_NVAR(_55$$14);
ZVAL_LONG(&_55$$14, tab);
ZEPHIR_CALL_FUNCTION(&_59$$14, "str_repeat", &_12, 142, space, &_55$$14);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_60$$14);
zephir_create_array(_60$$14, 3, 0 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_54$$14);
ZVAL_STRING(_54$$14, "obj", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_61$$14, this_ptr, "getstyle", &_4, 0, _54$$14);
zephir_check_temp_parameter(_54$$14);
zephir_check_call_status();
zephir_array_update_string(&_60$$14, SL(":style"), &_61$$14, PH_COPY | PH_SEPARATE);
ZEPHIR_MAKE_REF(key);
ZEPHIR_CALL_FUNCTION(&_61$$14, "end", &_62, 178, key);
ZEPHIR_UNREF(key);
zephir_check_call_status();
zephir_array_update_string(&_60$$14, SL(":key"), &_61$$14, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_60$$14, SL(":type"), &type, PH_COPY | PH_SEPARATE);
ZEPHIR_SINIT_NVAR(_55$$14);
ZVAL_STRING(&_55$$14, "-><span style=':style'>:key</span> (<span style=':style'>:type</span>) = ", 0);
ZEPHIR_CALL_FUNCTION(&_61$$14, "strtr", &_6, 26, &_55$$14, _60$$14);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_63$$14);
ZEPHIR_CONCAT_VV(_63$$14, _59$$14, _61$$14);
zephir_concat_self(&output, _63$$14 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_54$$14);
ZVAL_STRING(_54$$14, "", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_65$$14);
ZVAL_LONG(_65$$14, (tab + 1));
ZEPHIR_CALL_METHOD(&_64$$14, this_ptr, "output", &_23, 175, value, _54$$14, _65$$14);
zephir_check_temp_parameter(_54$$14);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_66$$14);
ZEPHIR_CONCAT_VS(_66$$14, _64$$14, "\n");
zephir_concat_self(&output, _66$$14 TSRMLS_CC);
} while (zephir_is_true(attr));
}
ZEPHIR_CALL_FUNCTION(&attr, "get_class_methods", NULL, 179, variable);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_29$$8);
ZVAL_LONG(&_29$$8, tab);
ZEPHIR_CALL_FUNCTION(&_67$$8, "str_repeat", &_12, 142, space, &_29$$8);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_68$$8);
zephir_create_array(_68$$8, 3, 0 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_28$$8);
ZVAL_STRING(_28$$8, "obj", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_69$$8, this_ptr, "getstyle", &_4, 0, _28$$8);
zephir_check_temp_parameter(_28$$8);
zephir_check_call_status();
zephir_array_update_string(&_68$$8, SL(":style"), &_69$$8, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_28$$8);
zephir_get_class(_28$$8, variable, 0 TSRMLS_CC);
zephir_array_update_string(&_68$$8, SL(":class"), &_28$$8, PH_COPY | PH_SEPARATE);
add_assoc_long_ex(_68$$8, SS(":count"), zephir_fast_count_int(attr TSRMLS_CC));
ZEPHIR_SINIT_NVAR(_29$$8);
ZVAL_STRING(&_29$$8, ":class <b style=':style'>methods</b>: (<span style=':style'>:count</span>) (\n", 0);
ZEPHIR_CALL_FUNCTION(&_69$$8, "strtr", &_6, 26, &_29$$8, _68$$8);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_70$$8);
ZEPHIR_CONCAT_VV(_70$$8, _67$$8, _69$$8);
zephir_concat_self(&output, _70$$8 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_28$$8);
zephir_get_class(_28$$8, variable, 0 TSRMLS_CC);
_71$$8 = zephir_fetch_nproperty_this(this_ptr, SL("_methods"), PH_NOISY_CC);
if (zephir_fast_in_array(_28$$8, _71$$8 TSRMLS_CC)) {
ZEPHIR_SINIT_VAR(_72$$19);
ZVAL_LONG(&_72$$19, tab);
ZEPHIR_CALL_FUNCTION(&_73$$19, "str_repeat", &_12, 142, space, &_72$$19);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_74$$19);
ZEPHIR_CONCAT_VS(_74$$19, _73$$19, "[already listed]\n");
zephir_concat_self(&output, _74$$19 TSRMLS_CC);
} else {
zephir_is_iterable(attr, &_76$$20, &_75$$20, 0, 0, "phalcon/debug/dump.zep", 226);
for (
; zephir_hash_get_current_data_ex(_76$$20, (void**) &_77$$20, &_75$$20) == SUCCESS
; zephir_hash_move_forward_ex(_76$$20, &_75$$20)
) {
ZEPHIR_GET_HVALUE(value, _77$$20);
ZEPHIR_INIT_NVAR(_78$$21);
zephir_get_class(_78$$21, variable, 0 TSRMLS_CC);
zephir_update_property_array_append(this_ptr, SL("_methods"), _78$$21 TSRMLS_CC);
if (ZEPHIR_IS_STRING(value, "__construct")) {
ZEPHIR_SINIT_NVAR(_79$$22);
ZVAL_LONG(&_79$$22, (tab + 1));
ZEPHIR_CALL_FUNCTION(&_80$$22, "str_repeat", &_12, 142, space, &_79$$22);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_81$$22);
zephir_create_array(_81$$22, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_83$$22);
ZVAL_STRING(_83$$22, "obj", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_82$$22, this_ptr, "getstyle", &_4, 0, _83$$22);
zephir_check_temp_parameter(_83$$22);
zephir_check_call_status();
zephir_array_update_string(&_81$$22, SL(":style"), &_82$$22, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_81$$22, SL(":method"), &value, PH_COPY | PH_SEPARATE);
ZEPHIR_SINIT_NVAR(_79$$22);
ZVAL_STRING(&_79$$22, "-><span style=':style'>:method</span>(); [<b style=':style'>constructor</b>]\n", 0);
ZEPHIR_CALL_FUNCTION(&_82$$22, "strtr", &_6, 26, &_79$$22, _81$$22);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_84$$22);
ZEPHIR_CONCAT_VV(_84$$22, _80$$22, _82$$22);
zephir_concat_self(&output, _84$$22 TSRMLS_CC);
} else {
ZEPHIR_SINIT_NVAR(_85$$23);
ZVAL_LONG(&_85$$23, (tab + 1));
ZEPHIR_CALL_FUNCTION(&_86$$23, "str_repeat", &_12, 142, space, &_85$$23);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_87$$23);
zephir_create_array(_87$$23, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_89$$23);
ZVAL_STRING(_89$$23, "obj", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_88$$23, this_ptr, "getstyle", &_4, 0, _89$$23);
zephir_check_temp_parameter(_89$$23);
zephir_check_call_status();
zephir_array_update_string(&_87$$23, SL(":style"), &_88$$23, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_87$$23, SL(":method"), &value, PH_COPY | PH_SEPARATE);
ZEPHIR_SINIT_NVAR(_85$$23);
ZVAL_STRING(&_85$$23, "-><span style=':style'>:method</span>();\n", 0);
ZEPHIR_CALL_FUNCTION(&_88$$23, "strtr", &_6, 26, &_85$$23, _87$$23);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_90$$23);
ZEPHIR_CONCAT_VV(_90$$23, _86$$23, _88$$23);
zephir_concat_self(&output, _90$$23 TSRMLS_CC);
}
}
ZEPHIR_SINIT_VAR(_91$$20);
ZVAL_LONG(&_91$$20, tab);
ZEPHIR_CALL_FUNCTION(&_92$$20, "str_repeat", &_12, 142, space, &_91$$20);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_93$$20);
ZEPHIR_CONCAT_VS(_93$$20, _92$$20, ")\n");
zephir_concat_self(&output, _93$$20 TSRMLS_CC);
}
ZEPHIR_SINIT_NVAR(_29$$8);
ZVAL_LONG(&_29$$8, (tab - 1));
ZEPHIR_CALL_FUNCTION(&_94$$8, "str_repeat", &_12, 142, space, &_29$$8);
zephir_check_call_status();
ZEPHIR_CONCAT_VVS(return_value, output, _94$$8, ")");
RETURN_MM();
}
if (Z_TYPE_P(variable) == IS_LONG) {
ZEPHIR_INIT_VAR(_95$$24);
zephir_create_array(_95$$24, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_97$$24);
ZVAL_STRING(_97$$24, "int", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_96$$24, this_ptr, "getstyle", &_4, 0, _97$$24);
zephir_check_temp_parameter(_97$$24);
zephir_check_call_status();
zephir_array_update_string(&_95$$24, SL(":style"), &_96$$24, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_95$$24, SL(":var"), &variable, PH_COPY | PH_SEPARATE);
ZEPHIR_SINIT_VAR(_98$$24);
ZVAL_STRING(&_98$$24, "<b style=':style'>Integer</b> (<span style=':style'>:var</span>)", 0);
ZEPHIR_CALL_FUNCTION(&_96$$24, "strtr", &_6, 26, &_98$$24, _95$$24);
zephir_check_call_status();
ZEPHIR_CONCAT_VV(return_value, output, _96$$24);
RETURN_MM();
}
ZEPHIR_CALL_FUNCTION(&_99, "is_float", NULL, 180, variable);
zephir_check_call_status();
if (zephir_is_true(_99)) {
ZEPHIR_INIT_VAR(_100$$25);
zephir_create_array(_100$$25, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_102$$25);
ZVAL_STRING(_102$$25, "float", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_101$$25, this_ptr, "getstyle", &_4, 0, _102$$25);
zephir_check_temp_parameter(_102$$25);
zephir_check_call_status();
zephir_array_update_string(&_100$$25, SL(":style"), &_101$$25, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_100$$25, SL(":var"), &variable, PH_COPY | PH_SEPARATE);
ZEPHIR_SINIT_VAR(_103$$25);
ZVAL_STRING(&_103$$25, "<b style=':style'>Float</b> (<span style=':style'>:var</span>)", 0);
ZEPHIR_CALL_FUNCTION(&_101$$25, "strtr", &_6, 26, &_103$$25, _100$$25);
zephir_check_call_status();
ZEPHIR_CONCAT_VV(return_value, output, _101$$25);
RETURN_MM();
}
if (zephir_is_numeric(variable)) {
ZEPHIR_INIT_VAR(_104$$26);
zephir_create_array(_104$$26, 3, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_106$$26);
ZVAL_STRING(_106$$26, "num", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_105$$26, this_ptr, "getstyle", &_4, 0, _106$$26);
zephir_check_temp_parameter(_106$$26);
zephir_check_call_status();
zephir_array_update_string(&_104$$26, SL(":style"), &_105$$26, PH_COPY | PH_SEPARATE);
add_assoc_long_ex(_104$$26, SS(":length"), zephir_fast_strlen_ev(variable));
zephir_array_update_string(&_104$$26, SL(":var"), &variable, PH_COPY | PH_SEPARATE);
ZEPHIR_SINIT_VAR(_107$$26);
ZVAL_STRING(&_107$$26, "<b style=':style'>Numeric string</b> (<span style=':style'>:length</span>) \"<span style=':style'>:var</span>\"", 0);
ZEPHIR_CALL_FUNCTION(&_105$$26, "strtr", &_6, 26, &_107$$26, _104$$26);
zephir_check_call_status();
ZEPHIR_CONCAT_VV(return_value, output, _105$$26);
RETURN_MM();
}
if (Z_TYPE_P(variable) == IS_STRING) {
ZEPHIR_INIT_VAR(_108$$27);
zephir_create_array(_108$$27, 3, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_110$$27);
ZVAL_STRING(_110$$27, "str", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_109$$27, this_ptr, "getstyle", &_4, 0, _110$$27);
zephir_check_temp_parameter(_110$$27);
zephir_check_call_status();
zephir_array_update_string(&_108$$27, SL(":style"), &_109$$27, PH_COPY | PH_SEPARATE);
add_assoc_long_ex(_108$$27, SS(":length"), zephir_fast_strlen_ev(variable));
ZEPHIR_SINIT_VAR(_111$$27);
ZVAL_LONG(&_111$$27, 4);
ZEPHIR_SINIT_VAR(_112$$27);
ZVAL_STRING(&_112$$27, "utf-8", 0);
ZEPHIR_CALL_FUNCTION(&_109$$27, "htmlentities", NULL, 161, variable, &_111$$27, &_112$$27);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_113$$27, "nl2br", NULL, 181, _109$$27);
zephir_check_call_status();
zephir_array_update_string(&_108$$27, SL(":var"), &_113$$27, PH_COPY | PH_SEPARATE);
ZEPHIR_SINIT_NVAR(_111$$27);
ZVAL_STRING(&_111$$27, "<b style=':style'>String</b> (<span style=':style'>:length</span>) \"<span style=':style'>:var</span>\"", 0);
ZEPHIR_CALL_FUNCTION(&_113$$27, "strtr", &_6, 26, &_111$$27, _108$$27);
zephir_check_call_status();
ZEPHIR_CONCAT_VV(return_value, output, _113$$27);
RETURN_MM();
}
if (Z_TYPE_P(variable) == IS_BOOL) {
ZEPHIR_INIT_VAR(_114$$28);
zephir_create_array(_114$$28, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_116$$28);
ZVAL_STRING(_116$$28, "bool", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_115$$28, this_ptr, "getstyle", &_4, 0, _116$$28);
zephir_check_temp_parameter(_116$$28);
zephir_check_call_status();
zephir_array_update_string(&_114$$28, SL(":style"), &_115$$28, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_VAR(_117$$28);
if (zephir_is_true(variable)) {
ZEPHIR_INIT_NVAR(_117$$28);
ZVAL_STRING(_117$$28, "TRUE", 1);
} else {
ZEPHIR_INIT_NVAR(_117$$28);
ZVAL_STRING(_117$$28, "FALSE", 1);
}
zephir_array_update_string(&_114$$28, SL(":var"), &_117$$28, PH_COPY | PH_SEPARATE);
ZEPHIR_SINIT_VAR(_118$$28);
ZVAL_STRING(&_118$$28, "<b style=':style'>Boolean</b> (<span style=':style'>:var</span>)", 0);
ZEPHIR_CALL_FUNCTION(&_115$$28, "strtr", &_6, 26, &_118$$28, _114$$28);
zephir_check_call_status();
ZEPHIR_CONCAT_VV(return_value, output, _115$$28);
RETURN_MM();
}
if (Z_TYPE_P(variable) == IS_NULL) {
ZEPHIR_INIT_VAR(_119$$29);
zephir_create_array(_119$$29, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_121$$29);
ZVAL_STRING(_121$$29, "null", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_120$$29, this_ptr, "getstyle", &_4, 0, _121$$29);
zephir_check_temp_parameter(_121$$29);
zephir_check_call_status();
zephir_array_update_string(&_119$$29, SL(":style"), &_120$$29, PH_COPY | PH_SEPARATE);
ZEPHIR_SINIT_VAR(_122$$29);
ZVAL_STRING(&_122$$29, "<b style=':style'>NULL</b>", 0);
ZEPHIR_CALL_FUNCTION(&_120$$29, "strtr", &_6, 26, &_122$$29, _119$$29);
zephir_check_call_status();
ZEPHIR_CONCAT_VV(return_value, output, _120$$29);
RETURN_MM();
}
ZEPHIR_INIT_VAR(_123);
zephir_create_array(_123, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_125);
ZVAL_STRING(_125, "other", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_124, this_ptr, "getstyle", &_4, 0, _125);
zephir_check_temp_parameter(_125);
zephir_check_call_status();
zephir_array_update_string(&_123, SL(":style"), &_124, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_123, SL(":var"), &variable, PH_COPY | PH_SEPARATE);
ZEPHIR_SINIT_VAR(_126);
ZVAL_STRING(&_126, "(<span style=':style'>:var</span>)", 0);
ZEPHIR_CALL_FUNCTION(&_124, "strtr", &_6, 26, &_126, _123);
zephir_check_call_status();
ZEPHIR_CONCAT_VV(return_value, output, _124);
RETURN_MM();
}
/**
* 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();
}
/**
* Removes padding @a padding_type from @a text
* If the function detects that the text was not padded, it will return it unmodified
*
* @param return_value Result, possibly unpadded
* @param text Message to be unpadded
* @param mode Encryption mode; unpadding is applied only in CBC or ECB mode
* @param block_size Cipher block size
* @param padding_type Padding scheme
*/
PHP_METHOD(Phalcon_Crypt, _cryptUnpadText) {
unsigned char _14, _16;
zephir_fcall_cache_entry *_6 = NULL, *_9 = NULL, *_11 = NULL;
zend_bool _0, _1, _2, _13, _15;
long length;
int blockSize, paddingType, i, paddingSize = 0, ord, ZEPHIR_LAST_CALL_STATUS;
zval *text_param = NULL, *mode_param = NULL, *blockSize_param = NULL, *paddingType_param = NULL, *padding = NULL, *last = NULL, _3 = zval_used_for_init, _4 = zval_used_for_init, *_5 = NULL, _7 = zval_used_for_init, *_8 = NULL, *_10 = NULL, *_12 = NULL;
zval *text = NULL, *mode = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &text_param, &mode_param, &blockSize_param, &paddingType_param);
zephir_get_strval(text, text_param);
if (unlikely(Z_TYPE_P(mode_param) != IS_STRING && Z_TYPE_P(mode_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'mode' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(mode_param) == IS_STRING)) {
zephir_get_strval(mode, mode_param);
} else {
ZEPHIR_INIT_VAR(mode);
ZVAL_EMPTY_STRING(mode);
}
if (unlikely(Z_TYPE_P(blockSize_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'blockSize' must be a long/integer") TSRMLS_CC);
RETURN_MM_NULL();
}
blockSize = Z_LVAL_P(blockSize_param);
if (unlikely(Z_TYPE_P(paddingType_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'paddingType' must be a long/integer") TSRMLS_CC);
RETURN_MM_NULL();
}
paddingType = Z_LVAL_P(paddingType_param);
length = zephir_fast_strlen_ev(text);
_0 = length > 0;
if (_0) {
_0 = (zephir_safe_mod_long_long(length, blockSize TSRMLS_CC) == 0);
}
_1 = _0;
if (_1) {
_2 = ZEPHIR_IS_STRING(mode, "cbc");
if (!(_2)) {
_2 = ZEPHIR_IS_STRING(mode, "ecb");
}
_1 = _2;
}
if (_1) {
do {
if (paddingType == 1) {
ZEPHIR_SINIT_VAR(_3);
ZVAL_LONG(&_3, (length - 1));
ZEPHIR_SINIT_VAR(_4);
ZVAL_LONG(&_4, 1);
ZEPHIR_INIT_VAR(last);
zephir_substr(last, text, zephir_get_intval(&_3), 1 , 0);
ZEPHIR_CALL_FUNCTION(&_5, "ord", &_6, 130, last);
zephir_check_call_status();
ord = zephir_get_intval(_5);
if (ord <= blockSize) {
paddingSize = ord;
ZEPHIR_SINIT_VAR(_7);
ZVAL_LONG(&_7, 0);
ZEPHIR_CALL_FUNCTION(&_8, "chr", &_9, 128, &_7);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_7);
ZVAL_LONG(&_7, (paddingSize - 1));
ZEPHIR_CALL_FUNCTION(&_10, "str_repeat", &_11, 129, _8, &_7);
zephir_check_call_status();
ZEPHIR_INIT_VAR(padding);
ZEPHIR_CONCAT_VV(padding, _10, last);
ZEPHIR_SINIT_NVAR(_7);
ZVAL_LONG(&_7, (length - paddingSize));
ZEPHIR_INIT_VAR(_12);
zephir_substr(_12, text, zephir_get_intval(&_7), 0, ZEPHIR_SUBSTR_NO_LENGTH);
if (!ZEPHIR_IS_EQUAL(_12, padding)) {
paddingSize = 0;
}
}
break;
}
if (paddingType == 2) {
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, (length - 1));
ZEPHIR_SINIT_NVAR(_4);
ZVAL_LONG(&_4, 1);
ZEPHIR_INIT_NVAR(last);
zephir_substr(last, text, zephir_get_intval(&_3), 1 , 0);
ZEPHIR_CALL_FUNCTION(&_5, "ord", &_6, 130, last);
zephir_check_call_status();
ord = zephir_get_intval(_5);
if (ord <= blockSize) {
paddingSize = ord;
ZEPHIR_SINIT_NVAR(_7);
ZVAL_LONG(&_7, paddingSize);
ZEPHIR_CALL_FUNCTION(&_8, "chr", &_9, 128, &_7);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_7);
ZVAL_LONG(&_7, paddingSize);
ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_11, 129, _8, &_7);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_7);
ZVAL_LONG(&_7, (length - paddingSize));
ZEPHIR_INIT_NVAR(_12);
zephir_substr(_12, text, zephir_get_intval(&_7), 0, ZEPHIR_SUBSTR_NO_LENGTH);
if (!ZEPHIR_IS_EQUAL(_12, padding)) {
paddingSize = 0;
}
}
break;
}
if (paddingType == 3) {
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, (length - 1));
ZEPHIR_SINIT_NVAR(_4);
ZVAL_LONG(&_4, 1);
ZEPHIR_INIT_NVAR(last);
zephir_substr(last, text, zephir_get_intval(&_3), 1 , 0);
ZEPHIR_CALL_FUNCTION(&_5, "ord", &_6, 130, last);
zephir_check_call_status();
paddingSize = zephir_get_intval(_5);
break;
}
if (paddingType == 4) {
i = (length - 1);
while (1) {
_13 = i > 0;
if (_13) {
_14 = ZEPHIR_STRING_OFFSET(text, i);
_13 = _14 == 0x00;
}
_15 = _13;
if (_15) {
_15 = paddingSize < blockSize;
}
if (!(_15)) {
break;
}
paddingSize++;
i--;
}
_16 = ZEPHIR_STRING_OFFSET(text, i);
if (_16 == 0x80) {
paddingSize++;
} else {
paddingSize = 0;
}
break;
}
if (paddingType == 5) {
i = (length - 1);
while (1) {
_13 = i >= 0;
if (_13) {
_14 = ZEPHIR_STRING_OFFSET(text, i);
_13 = _14 == 0x00;
}
_15 = _13;
if (_15) {
_15 = paddingSize <= blockSize;
}
if (!(_15)) {
break;
}
paddingSize++;
i--;
}
break;
}
if (paddingType == 6) {
i = (length - 1);
while (1) {
_13 = i >= 0;
if (_13) {
_14 = ZEPHIR_STRING_OFFSET(text, i);
_13 = _14 == 0x20;
}
_15 = _13;
if (_15) {
_15 = paddingSize <= blockSize;
}
if (!(_15)) {
break;
}
paddingSize++;
i--;
}
break;
}
break;
} while(0);
_13 = (paddingSize) ? 1 : 0;
if (_13) {
_13 = paddingSize <= blockSize;
}
if (_13) {
if (paddingSize < length) {
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, 0);
ZEPHIR_SINIT_NVAR(_4);
ZVAL_LONG(&_4, (length - paddingSize));
zephir_substr(return_value, text, 0 , zephir_get_intval(&_4), 0);
RETURN_MM();
}
RETURN_MM_STRING("", 1);
} else {
paddingSize = 0;
}
}
if (!(paddingSize)) {
RETURN_CTOR(text);
}
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();
}
/**
* Decrypts an encrypted text
*
*<code>
* echo $crypt->decrypt($encrypted, "decrypt password");
*</code>
*/
PHP_METHOD(Phalcon_Crypt, decrypt) {
zend_bool _3;
int ZEPHIR_LAST_CALL_STATUS;
zval *text_param = NULL, *key = NULL, *decryptKey = NULL, *ivSize = NULL, *cipher, *mode, *keySize, *length, *blockSize = NULL, *paddingType, *decrypted = NULL, *_0, _1, *_2;
zval *text = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &text_param, &key);
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 (!key) {
key = ZEPHIR_GLOBAL(global_null);
}
if (!((zephir_function_exists_ex(SS("mcrypt_get_iv_size") TSRMLS_CC) == SUCCESS))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "mcrypt extension is required", "phalcon/crypt.zep", 356);
return;
}
if (Z_TYPE_P(key) == IS_NULL) {
ZEPHIR_OBS_VAR(decryptKey);
zephir_read_property_this(&decryptKey, this_ptr, SL("_key"), PH_NOISY_CC);
} else {
ZEPHIR_CPY_WRT(decryptKey, key);
}
if (ZEPHIR_IS_EMPTY(decryptKey)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Decryption key cannot be empty", "phalcon/crypt.zep", 366);
return;
}
ZEPHIR_OBS_VAR(cipher);
zephir_read_property_this(&cipher, this_ptr, SL("_cipher"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(mode);
zephir_read_property_this(&mode, this_ptr, SL("_mode"), PH_NOISY_CC);
ZEPHIR_CALL_FUNCTION(&ivSize, "mcrypt_get_iv_size", NULL, 131, cipher, mode);
zephir_check_call_status();
ZEPHIR_INIT_VAR(keySize);
ZVAL_LONG(keySize, zephir_fast_strlen_ev(decryptKey));
if (ZEPHIR_GT(keySize, ivSize)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Size of key is too large for this algorithm", "phalcon/crypt.zep", 375);
return;
}
ZEPHIR_INIT_VAR(length);
ZVAL_LONG(length, zephir_fast_strlen_ev(text));
if (ZEPHIR_GT(keySize, length)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Size of IV is larger than text to decrypt", "phalcon/crypt.zep", 380);
return;
}
ZEPHIR_INIT_VAR(_0);
zephir_substr(_0, text, zephir_get_intval(ivSize), 0, ZEPHIR_SUBSTR_NO_LENGTH);
ZEPHIR_SINIT_VAR(_1);
ZVAL_LONG(&_1, 0);
ZEPHIR_INIT_VAR(_2);
zephir_substr(_2, text, 0 , zephir_get_intval(ivSize), 0);
ZEPHIR_CALL_FUNCTION(&decrypted, "mcrypt_decrypt", NULL, 135, cipher, decryptKey, _0, mode, _2);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&blockSize, "mcrypt_get_block_size", NULL, 133, cipher, mode);
zephir_check_call_status();
ZEPHIR_OBS_VAR(paddingType);
zephir_read_property_this(&paddingType, this_ptr, SL("_padding"), PH_NOISY_CC);
_3 = ZEPHIR_IS_STRING(mode, "cbc");
if (!(_3)) {
_3 = ZEPHIR_IS_STRING(mode, "ecb");
}
if (_3) {
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "_cryptunpadtext", NULL, 0, decrypted, mode, blockSize, paddingType);
zephir_check_call_status();
RETURN_MM();
}
RETURN_CCTOR(decrypted);
}
/**
* 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();
}
ZVAL_LONG(&codeLength, zephir_fast_strlen_ev(&contents));
zephir_is_iterable(&variants, 0, "test/regexdna.zep", 59);
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&variants), _4)
{
ZEPHIR_INIT_NVAR(®ex);
ZVAL_COPY(®ex, _4);
zend_print_zval(®ex, 0);
php_printf("%s", " ");
ZEPHIR_INIT_NVAR(&_5$$3);
ZEPHIR_INIT_LNVAR(_6$$3);
ZEPHIR_CONCAT_SVS(&_6$$3, "/", ®ex, "/iS");
zephir_preg_match(&_5$$3, &_6$$3, &contents, &discard, 1, 0 , 0 TSRMLS_CC);
zend_print_zval(&_5$$3, 0);
php_printf("%c", '\n');
} ZEND_HASH_FOREACH_END();
ZEPHIR_INIT_NVAR(®ex);
ZEPHIR_CALL_FUNCTION(&_2, "preg_replace", &_3, 51, &vIUB, &vIUBnew, &contents);
zephir_check_call_status();
ZEPHIR_CPY_WRT(&contents, &_2);
php_printf("%c", '\n');
zend_print_zval(&initialLength, 0);
php_printf("%c", '\n');
zend_print_zval(&codeLength, 0);
php_printf("%c", '\n');
php_printf("%d", zephir_fast_strlen_ev(&contents));
php_printf("%c", '\n');
ZEPHIR_MM_RESTORE();
}
/**
* 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();
}
/**
* 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) {
zval *_18;
HashTable *_7;
HashPosition _6;
zend_bool param, _11, _14;
int type, timestamp, ZEPHIR_LAST_CALL_STATUS;
zval *message_param = NULL, *type_param = NULL, *timestamp_param = NULL, *context = NULL, *meta, *body = NULL, *backtrace = NULL, *encoded, *len, *lastTrace = NULL, *_0 = NULL, *_1 = NULL, *_2, *backtraceItem = NULL, *key = NULL, _3, _4, *_5, **_8, *_9, *_10, *_12, *_13, *_15, *_16, *_17;
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, this_ptr, "interpolate", NULL, 0, message, context);
zephir_check_call_status();
zephir_get_strval(message, _0);
}
ZEPHIR_INIT_VAR(meta);
zephir_create_array(meta, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_1);
ZVAL_LONG(_1, type);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "gettypestring", NULL, 0, _1);
zephir_check_call_status();
zephir_array_update_string(&meta, SL("Type"), &_0, PH_COPY | PH_SEPARATE);
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC);
if (zephir_is_true(_2)) {
param = 0;
ZEPHIR_INIT_NVAR(_1);
ZEPHIR_GET_CONSTANT(_1, "PHP_VERSION");
ZEPHIR_SINIT_VAR(_3);
ZVAL_STRING(&_3, "5.3.6", 0);
ZEPHIR_SINIT_VAR(_4);
ZVAL_STRING(&_4, "<", 0);
ZEPHIR_CALL_FUNCTION(&_0, "version_compare", NULL, 230, _1, &_3, &_4);
zephir_check_call_status();
if (!(zephir_is_true(_0))) {
param = (2) ? 1 : 0;
}
ZEPHIR_CALL_FUNCTION(&backtrace, "debug_backtrace", NULL, 116, (param ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false)));
zephir_check_call_status();
Z_SET_ISREF_P(backtrace);
ZEPHIR_CALL_FUNCTION(&lastTrace, "end", NULL, 135, backtrace);
Z_UNSET_ISREF_P(backtrace);
zephir_check_call_status();
if (zephir_array_isset_string(lastTrace, SS("file"))) {
zephir_array_fetch_string(&_5, lastTrace, SL("file"), PH_NOISY | PH_READONLY, "phalcon/logger/formatter/firephp.zep", 133 TSRMLS_CC);
zephir_array_update_string(&meta, SL("File"), &_5, PH_COPY | PH_SEPARATE);
}
if (zephir_array_isset_string(lastTrace, SS("line"))) {
zephir_array_fetch_string(&_5, lastTrace, SL("line"), PH_NOISY | PH_READONLY, "phalcon/logger/formatter/firephp.zep", 137 TSRMLS_CC);
zephir_array_update_string(&meta, SL("Line"), &_5, PH_COPY | PH_SEPARATE);
}
zephir_is_iterable(backtrace, &_7, &_6, 1, 0, "phalcon/logger/formatter/firephp.zep", 146);
for (
; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS
; zephir_hash_move_forward_ex(_7, &_6)
) {
ZEPHIR_GET_HMKEY(key, _7, _6);
ZEPHIR_GET_HVALUE(backtraceItem, _8);
zephir_array_unset_string(&backtraceItem, SS("object"), PH_SEPARATE);
zephir_array_unset_string(&backtraceItem, SS("args"), PH_SEPARATE);
zephir_array_update_zval(&backtrace, key, &backtraceItem, PH_COPY | PH_SEPARATE);
}
}
_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 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC);
if (zephir_is_true(_16)) {
zephir_array_update_string(&body, SL("backtrace"), &backtrace, PH_COPY | PH_SEPARATE);
}
_17 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC);
if (!(zephir_is_true(_17))) {
zephir_array_update_string(&body, SL("message"), &message, PH_COPY | PH_SEPARATE);
}
}
ZEPHIR_INIT_VAR(encoded);
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_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();
}
/**
* 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);
}
/**
* Autoloads the registered classes
*/
PHP_METHOD(Phalcon_Loader, autoLoad) {
zephir_fcall_cache_entry *_10 = NULL, *_12 = NULL, *_13 = NULL, *_23 = NULL, *_24 = NULL, *_31 = NULL, *_32 = NULL;
HashTable *_2, *_7, *_15, *_21, *_26, *_29;
HashPosition _1, _6, _14, _20, _25, _28;
int ZEPHIR_LAST_CALL_STATUS;
zval *className_param = NULL, *eventsManager, *classes, *extensions, *filePath = NULL, *ds, *fixedDirectory = NULL, *prefixes, *directories, *namespaceSeparator, *namespaces, *nsPrefix = NULL, *directory = NULL, *fileName = NULL, *extension = NULL, *prefix = NULL, *dsClassName, *nsClassName, *_0 = NULL, **_3, *_4 = NULL, _5 = zval_used_for_init, **_8, *_9 = NULL, *_11 = NULL, **_16, *_17 = NULL, _18 = zval_used_for_init, _19 = zval_used_for_init, **_22, **_27, **_30;
zval *className = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &className_param);
if (unlikely(Z_TYPE_P(className_param) != IS_STRING && Z_TYPE_P(className_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'className' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(className_param) == IS_STRING)) {
zephir_get_strval(className, className_param);
} else {
ZEPHIR_INIT_VAR(className);
ZVAL_EMPTY_STRING(className);
}
ZEPHIR_OBS_VAR(eventsManager);
zephir_read_property_this(&eventsManager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "loader:beforeCheckClass", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _0, this_ptr, className);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
}
ZEPHIR_OBS_VAR(classes);
zephir_read_property_this(&classes, this_ptr, SL("_classes"), PH_NOISY_CC);
if (Z_TYPE_P(classes) == IS_ARRAY) {
ZEPHIR_OBS_VAR(filePath);
if (zephir_array_isset_fetch(&filePath, classes, className, 0 TSRMLS_CC)) {
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
zephir_update_property_this(this_ptr, SL("_foundPath"), filePath TSRMLS_CC);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "loader:pathFound", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _0, this_ptr, filePath);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
}
if (zephir_require_zval(filePath TSRMLS_CC) == FAILURE) {
RETURN_MM_NULL();
}
RETURN_MM_BOOL(1);
}
}
ZEPHIR_OBS_VAR(extensions);
zephir_read_property_this(&extensions, this_ptr, SL("_extensions"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(ds);
ZVAL_STRING(ds, "/", 1);
ZEPHIR_INIT_VAR(namespaceSeparator);
ZVAL_STRING(namespaceSeparator, "\\", 1);
ZEPHIR_OBS_VAR(namespaces);
zephir_read_property_this(&namespaces, this_ptr, SL("_namespaces"), PH_NOISY_CC);
if (Z_TYPE_P(namespaces) == IS_ARRAY) {
zephir_is_iterable(namespaces, &_2, &_1, 0, 0, "phalcon/loader.zep", 347);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HMKEY(nsPrefix, _2, _1);
ZEPHIR_GET_HVALUE(directory, _3);
if (zephir_start_with(className, nsPrefix, NULL)) {
ZEPHIR_INIT_LNVAR(_4);
ZEPHIR_CONCAT_VV(_4, nsPrefix, namespaceSeparator);
ZEPHIR_SINIT_NVAR(_5);
ZVAL_LONG(&_5, zephir_fast_strlen_ev(_4));
ZEPHIR_INIT_NVAR(fileName);
zephir_substr(fileName, className, zephir_get_intval(&_5), 0, ZEPHIR_SUBSTR_NO_LENGTH);
ZEPHIR_INIT_NVAR(_0);
zephir_fast_str_replace(&_0, namespaceSeparator, ds, fileName TSRMLS_CC);
ZEPHIR_CPY_WRT(fileName, _0);
if (zephir_is_true(fileName)) {
ZEPHIR_INIT_NVAR(_0);
zephir_fast_trim(_0, directory, ds, ZEPHIR_TRIM_RIGHT TSRMLS_CC);
ZEPHIR_INIT_NVAR(fixedDirectory);
ZEPHIR_CONCAT_VV(fixedDirectory, _0, ds);
zephir_is_iterable(extensions, &_7, &_6, 0, 0, "phalcon/loader.zep", 344);
for (
; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS
; zephir_hash_move_forward_ex(_7, &_6)
) {
ZEPHIR_GET_HVALUE(extension, _8);
ZEPHIR_INIT_NVAR(filePath);
ZEPHIR_CONCAT_VVSV(filePath, fixedDirectory, fileName, ".", extension);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
zephir_update_property_this(this_ptr, SL("_checkedPath"), filePath TSRMLS_CC);
ZEPHIR_INIT_NVAR(_9);
ZVAL_STRING(_9, "loader:beforeCheckPath", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", &_10, 0, _9, this_ptr);
zephir_check_temp_parameter(_9);
zephir_check_call_status();
}
ZEPHIR_CALL_FUNCTION(&_11, "is_file", &_12, 279, filePath);
zephir_check_call_status();
if (zephir_is_true(_11)) {
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
zephir_update_property_this(this_ptr, SL("_foundPath"), filePath TSRMLS_CC);
ZEPHIR_INIT_NVAR(_9);
ZVAL_STRING(_9, "loader:pathFound", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", &_13, 0, _9, this_ptr, filePath);
zephir_check_temp_parameter(_9);
zephir_check_call_status();
}
if (zephir_require_zval(filePath TSRMLS_CC) == FAILURE) {
RETURN_MM_NULL();
}
RETURN_MM_BOOL(1);
}
}
}
}
}
}
ZEPHIR_OBS_VAR(prefixes);
zephir_read_property_this(&prefixes, this_ptr, SL("_prefixes"), PH_NOISY_CC);
if (Z_TYPE_P(prefixes) == IS_ARRAY) {
zephir_is_iterable(prefixes, &_15, &_14, 0, 0, "phalcon/loader.zep", 402);
for (
; zephir_hash_get_current_data_ex(_15, (void**) &_16, &_14) == SUCCESS
; zephir_hash_move_forward_ex(_15, &_14)
) {
ZEPHIR_GET_HMKEY(prefix, _15, _14);
ZEPHIR_GET_HVALUE(directory, _16);
if (zephir_start_with(className, prefix, NULL)) {
ZEPHIR_INIT_LNVAR(_4);
ZEPHIR_CONCAT_VV(_4, prefix, namespaceSeparator);
ZEPHIR_SINIT_NVAR(_5);
ZVAL_STRING(&_5, "", 0);
ZEPHIR_INIT_NVAR(fileName);
zephir_fast_str_replace(&fileName, _4, &_5, className TSRMLS_CC);
ZEPHIR_INIT_NVAR(_0);
ZEPHIR_INIT_LNVAR(_17);
ZEPHIR_CONCAT_VS(_17, prefix, "_");
ZEPHIR_SINIT_NVAR(_18);
ZVAL_STRING(&_18, "", 0);
zephir_fast_str_replace(&_0, _17, &_18, fileName TSRMLS_CC);
ZEPHIR_CPY_WRT(fileName, _0);
ZEPHIR_INIT_NVAR(_0);
ZEPHIR_SINIT_NVAR(_19);
ZVAL_STRING(&_19, "_", 0);
zephir_fast_str_replace(&_0, &_19, ds, fileName TSRMLS_CC);
ZEPHIR_CPY_WRT(fileName, _0);
if (zephir_is_true(fileName)) {
ZEPHIR_INIT_NVAR(_0);
zephir_fast_trim(_0, directory, ds, ZEPHIR_TRIM_RIGHT TSRMLS_CC);
ZEPHIR_INIT_NVAR(fixedDirectory);
ZEPHIR_CONCAT_VV(fixedDirectory, _0, ds);
zephir_is_iterable(extensions, &_21, &_20, 0, 0, "phalcon/loader.zep", 399);
for (
; zephir_hash_get_current_data_ex(_21, (void**) &_22, &_20) == SUCCESS
; zephir_hash_move_forward_ex(_21, &_20)
) {
ZEPHIR_GET_HVALUE(extension, _22);
ZEPHIR_INIT_NVAR(filePath);
ZEPHIR_CONCAT_VVSV(filePath, fixedDirectory, fileName, ".", extension);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
zephir_update_property_this(this_ptr, SL("_checkedPath"), filePath TSRMLS_CC);
ZEPHIR_INIT_NVAR(_9);
ZVAL_STRING(_9, "loader:beforeCheckPath", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", &_23, 0, _9, this_ptr, filePath);
zephir_check_temp_parameter(_9);
zephir_check_call_status();
}
ZEPHIR_CALL_FUNCTION(&_11, "is_file", &_12, 279, filePath);
zephir_check_call_status();
if (zephir_is_true(_11)) {
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
zephir_update_property_this(this_ptr, SL("_foundPath"), filePath TSRMLS_CC);
ZEPHIR_INIT_NVAR(_9);
ZVAL_STRING(_9, "loader:pathFound", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", &_24, 0, _9, this_ptr, filePath);
zephir_check_temp_parameter(_9);
zephir_check_call_status();
}
if (zephir_require_zval(filePath TSRMLS_CC) == FAILURE) {
RETURN_MM_NULL();
}
RETURN_MM_BOOL(1);
}
}
}
}
}
}
ZEPHIR_SINIT_NVAR(_5);
ZVAL_STRING(&_5, "_", 0);
ZEPHIR_INIT_VAR(dsClassName);
zephir_fast_str_replace(&dsClassName, &_5, ds, className TSRMLS_CC);
ZEPHIR_SINIT_NVAR(_18);
ZVAL_STRING(&_18, "\\", 0);
ZEPHIR_INIT_VAR(nsClassName);
zephir_fast_str_replace(&nsClassName, &_18, ds, dsClassName TSRMLS_CC);
ZEPHIR_OBS_VAR(directories);
zephir_read_property_this(&directories, this_ptr, SL("_directories"), PH_NOISY_CC);
if (Z_TYPE_P(directories) == IS_ARRAY) {
zephir_is_iterable(directories, &_26, &_25, 0, 0, "phalcon/loader.zep", 464);
for (
; zephir_hash_get_current_data_ex(_26, (void**) &_27, &_25) == SUCCESS
; zephir_hash_move_forward_ex(_26, &_25)
) {
ZEPHIR_GET_HVALUE(directory, _27);
ZEPHIR_INIT_NVAR(_0);
zephir_fast_trim(_0, directory, ds, ZEPHIR_TRIM_RIGHT TSRMLS_CC);
ZEPHIR_INIT_NVAR(fixedDirectory);
ZEPHIR_CONCAT_VV(fixedDirectory, _0, ds);
zephir_is_iterable(extensions, &_29, &_28, 0, 0, "phalcon/loader.zep", 463);
for (
; zephir_hash_get_current_data_ex(_29, (void**) &_30, &_28) == SUCCESS
; zephir_hash_move_forward_ex(_29, &_28)
) {
ZEPHIR_GET_HVALUE(extension, _30);
ZEPHIR_INIT_NVAR(filePath);
ZEPHIR_CONCAT_VVSV(filePath, fixedDirectory, nsClassName, ".", extension);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
zephir_update_property_this(this_ptr, SL("_checkedPath"), filePath TSRMLS_CC);
ZEPHIR_INIT_NVAR(_9);
ZVAL_STRING(_9, "loader:beforeCheckPath", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", &_31, 0, _9, this_ptr, filePath);
zephir_check_temp_parameter(_9);
zephir_check_call_status();
}
ZEPHIR_CALL_FUNCTION(&_11, "is_file", &_12, 279, filePath);
zephir_check_call_status();
if (zephir_is_true(_11)) {
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
zephir_update_property_this(this_ptr, SL("_foundPath"), filePath TSRMLS_CC);
ZEPHIR_INIT_NVAR(_9);
ZVAL_STRING(_9, "loader:pathFound", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", &_32, 0, _9, this_ptr, filePath);
zephir_check_temp_parameter(_9);
zephir_check_call_status();
}
if (zephir_require_zval(filePath TSRMLS_CC) == FAILURE) {
RETURN_MM_NULL();
}
RETURN_MM_BOOL(1);
}
}
}
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "loader:afterCheckClass", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _0, this_ptr, className);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
}
RETURN_MM_BOOL(0);
}
/**
* 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) {
zephir_nts_static zephir_fcall_cache_entry *_13 = NULL;
zephir_fcall_cache_entry *_11 = NULL, *_12 = NULL;
HashTable *_4;
HashPosition _3;
int ZEPHIR_LAST_CALL_STATUS;
zend_bool notExists, mustClean, _7, _9;
zval *path_param = NULL, *params, *eventsManager, *engines = NULL, *extension = NULL, *engine = NULL, *viewEnginePath = NULL, *viewsDirPath, *_0 = NULL, *_1 = NULL, *_2, **_5, *_6 = NULL, _8 = zval_used_for_init, *_10 = NULL;
zval *path = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &path_param, ¶ms);
if (unlikely(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 (likely(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(this_ptr, SL("_activeRenderPath"), path TSRMLS_CC);
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "view:beforeRender", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0, eventsManager, "fire", NULL, _1, this_ptr);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
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);
zephir_check_call_status();
zephir_is_iterable(engines, &_4, &_3, 0, 0, "phalcon/mvc/view/simple.zep", 260);
for (
; zephir_hash_get_current_data_ex(_4, (void**) &_5, &_3) == SUCCESS
; zephir_hash_move_forward_ex(_4, &_3)
) {
ZEPHIR_GET_HMKEY(extension, _4, _3);
ZEPHIR_GET_HVALUE(engine, _5);
ZEPHIR_INIT_LNVAR(_6);
ZEPHIR_CONCAT_VV(_6, viewsDirPath, extension);
if ((zephir_file_exists(_6 TSRMLS_CC) == SUCCESS)) {
ZEPHIR_INIT_NVAR(viewEnginePath);
ZEPHIR_CONCAT_VV(viewEnginePath, viewsDirPath, extension);
} else {
_7 = zephir_is_true(extension);
if (_7) {
ZEPHIR_SINIT_NVAR(_8);
ZVAL_LONG(&_8, -zephir_fast_strlen_ev(extension));
ZEPHIR_INIT_NVAR(_1);
zephir_substr(_1, viewsDirPath, zephir_get_intval(&_8), 0, ZEPHIR_SUBSTR_NO_LENGTH);
_7 = ZEPHIR_IS_EQUAL(_1, extension);
}
_9 = _7;
if (_9) {
_9 = (zephir_file_exists(viewsDirPath TSRMLS_CC) == SUCCESS);
}
if (_9) {
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(_10);
ZVAL_STRING(_10, "view:beforeRenderView", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0, eventsManager, "fire", &_11, _10, this_ptr, viewEnginePath);
zephir_check_temp_parameter(_10);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
continue;
}
}
ZEPHIR_CALL_METHOD(NULL, engine, "render", NULL, viewEnginePath, params, (mustClean ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false)));
zephir_check_call_status();
notExists = 0;
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_10);
ZVAL_STRING(_10, "view:afterRenderView", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", &_12, _10, this_ptr);
zephir_check_temp_parameter(_10);
zephir_check_call_status();
}
break;
}
}
if (notExists == 1) {
ZEPHIR_INIT_NVAR(_1);
object_init_ex(_1, phalcon_mvc_view_exception_ce);
ZEPHIR_INIT_LNVAR(_6);
ZEPHIR_CONCAT_SVS(_6, "View '", viewsDirPath, "' was not found in the views directory");
ZEPHIR_CALL_METHOD(NULL, _1, "__construct", &_13, _6);
zephir_check_call_status();
zephir_throw_exception_debug(_1, "phalcon/mvc/view/simple.zep", 261 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "view:afterRender", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, _1, this_ptr);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
}
ZEPHIR_MM_RESTORE();
}
/**
* Removes padding @a padding_type from @a text
* If the function detects that the text was not padded, it will return it unmodified
*
* @param string text Message to be unpadded
* @param string mode Encryption mode; unpadding is applied only in CBC or ECB mode
* @param int blockSize Cipher block size
* @param int paddingType Padding scheme
*/
PHP_METHOD(Phalcon_Crypt, _cryptUnpadText) {
unsigned char _23$$11, _25$$11, _27$$15, _30$$17;
zend_bool _0, _1, _2, _22$$11, _24$$11, _26$$15, _28$$15, _29$$17, _31$$17, _32$$3;
long length = 0;
zephir_fcall_cache_entry *_6 = NULL, *_9 = NULL, *_11 = NULL;
zend_long blockSize, paddingType, ZEPHIR_LAST_CALL_STATUS, i = 0, paddingSize, ord = 0;
zval *text_param = NULL, *mode_param = NULL, *blockSize_param = NULL, *paddingType_param = NULL, *padding = NULL, *last = NULL, _3$$4, _4$$4, *_5$$4 = NULL, _7$$5 = zval_used_for_init, *_8$$5 = NULL, *_10$$5 = NULL, *_12$$5, _13$$7, _14$$7, *_15$$7 = NULL, _16$$8 = zval_used_for_init, *_17$$8 = NULL, *_18$$8, _19$$10, _20$$10, *_21$$10 = NULL, _33$$21, _34$$21;
zval *text = NULL, *mode = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &text_param, &mode_param, &blockSize_param, &paddingType_param);
zephir_get_strval(text, text_param);
if (UNEXPECTED(Z_TYPE_P(mode_param) != IS_STRING && Z_TYPE_P(mode_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'mode' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(mode_param) == IS_STRING)) {
zephir_get_strval(mode, mode_param);
} else {
ZEPHIR_INIT_VAR(mode);
ZVAL_EMPTY_STRING(mode);
}
if (UNEXPECTED(Z_TYPE_P(blockSize_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'blockSize' must be a int") TSRMLS_CC);
RETURN_MM_NULL();
}
blockSize = Z_LVAL_P(blockSize_param);
if (UNEXPECTED(Z_TYPE_P(paddingType_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'paddingType' must be a int") TSRMLS_CC);
RETURN_MM_NULL();
}
paddingType = Z_LVAL_P(paddingType_param);
paddingSize = 0;
length = zephir_fast_strlen_ev(text);
_0 = length > 0;
if (_0) {
_0 = (zephir_safe_mod_long_long(length, blockSize TSRMLS_CC) == 0);
}
_1 = _0;
if (_1) {
_2 = ZEPHIR_IS_STRING(mode, "cbc");
if (!(_2)) {
_2 = ZEPHIR_IS_STRING(mode, "ecb");
}
_1 = _2;
}
if (_1) {
do {
if (paddingType == 1) {
ZEPHIR_SINIT_VAR(_3$$4);
ZVAL_LONG(&_3$$4, (length - 1));
ZEPHIR_SINIT_VAR(_4$$4);
ZVAL_LONG(&_4$$4, 1);
ZEPHIR_INIT_VAR(last);
zephir_substr(last, text, zephir_get_intval(&_3$$4), 1 , 0);
ZEPHIR_CALL_FUNCTION(&_5$$4, "ord", &_6, 151, last);
zephir_check_call_status();
ord = zephir_get_intval(_5$$4);
if (ord <= blockSize) {
paddingSize = ord;
ZEPHIR_SINIT_VAR(_7$$5);
ZVAL_LONG(&_7$$5, 0);
ZEPHIR_CALL_FUNCTION(&_8$$5, "chr", &_9, 149, &_7$$5);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_7$$5);
ZVAL_LONG(&_7$$5, (paddingSize - 1));
ZEPHIR_CALL_FUNCTION(&_10$$5, "str_repeat", &_11, 150, _8$$5, &_7$$5);
zephir_check_call_status();
ZEPHIR_INIT_VAR(padding);
ZEPHIR_CONCAT_VV(padding, _10$$5, last);
ZEPHIR_SINIT_NVAR(_7$$5);
ZVAL_LONG(&_7$$5, (length - paddingSize));
ZEPHIR_INIT_VAR(_12$$5);
zephir_substr(_12$$5, text, zephir_get_intval(&_7$$5), 0, ZEPHIR_SUBSTR_NO_LENGTH);
if (!ZEPHIR_IS_EQUAL(_12$$5, padding)) {
paddingSize = 0;
}
}
break;
}
if (paddingType == 2) {
ZEPHIR_SINIT_VAR(_13$$7);
ZVAL_LONG(&_13$$7, (length - 1));
ZEPHIR_SINIT_VAR(_14$$7);
ZVAL_LONG(&_14$$7, 1);
ZEPHIR_INIT_NVAR(last);
zephir_substr(last, text, zephir_get_intval(&_13$$7), 1 , 0);
ZEPHIR_CALL_FUNCTION(&_15$$7, "ord", &_6, 151, last);
zephir_check_call_status();
ord = zephir_get_intval(_15$$7);
if (ord <= blockSize) {
paddingSize = ord;
ZEPHIR_SINIT_VAR(_16$$8);
ZVAL_LONG(&_16$$8, paddingSize);
ZEPHIR_CALL_FUNCTION(&_17$$8, "chr", &_9, 149, &_16$$8);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_16$$8);
ZVAL_LONG(&_16$$8, paddingSize);
ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_11, 150, _17$$8, &_16$$8);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_16$$8);
ZVAL_LONG(&_16$$8, (length - paddingSize));
ZEPHIR_INIT_VAR(_18$$8);
zephir_substr(_18$$8, text, zephir_get_intval(&_16$$8), 0, ZEPHIR_SUBSTR_NO_LENGTH);
if (!ZEPHIR_IS_EQUAL(_18$$8, padding)) {
paddingSize = 0;
}
}
break;
}
if (paddingType == 3) {
ZEPHIR_SINIT_VAR(_19$$10);
ZVAL_LONG(&_19$$10, (length - 1));
ZEPHIR_SINIT_VAR(_20$$10);
ZVAL_LONG(&_20$$10, 1);
ZEPHIR_INIT_NVAR(last);
zephir_substr(last, text, zephir_get_intval(&_19$$10), 1 , 0);
ZEPHIR_CALL_FUNCTION(&_21$$10, "ord", &_6, 151, last);
zephir_check_call_status();
paddingSize = zephir_get_intval(_21$$10);
break;
}
if (paddingType == 4) {
i = (length - 1);
while (1) {
_22$$11 = i > 0;
if (_22$$11) {
_23$$11 = ZEPHIR_STRING_OFFSET(text, i);
_22$$11 = _23$$11 == 0x00;
}
_24$$11 = _22$$11;
if (_24$$11) {
_24$$11 = paddingSize < blockSize;
}
if (!(_24$$11)) {
break;
}
paddingSize++;
i--;
}
_25$$11 = ZEPHIR_STRING_OFFSET(text, i);
if (_25$$11 == 0x80) {
paddingSize++;
} else {
paddingSize = 0;
}
break;
}
if (paddingType == 5) {
i = (length - 1);
while (1) {
_26$$15 = i >= 0;
if (_26$$15) {
_27$$15 = ZEPHIR_STRING_OFFSET(text, i);
_26$$15 = _27$$15 == 0x00;
}
_28$$15 = _26$$15;
if (_28$$15) {
_28$$15 = paddingSize <= blockSize;
}
if (!(_28$$15)) {
break;
}
paddingSize++;
i--;
}
break;
}
if (paddingType == 6) {
i = (length - 1);
while (1) {
_29$$17 = i >= 0;
if (_29$$17) {
_30$$17 = ZEPHIR_STRING_OFFSET(text, i);
_29$$17 = _30$$17 == 0x20;
}
_31$$17 = _29$$17;
if (_31$$17) {
_31$$17 = paddingSize <= blockSize;
}
if (!(_31$$17)) {
break;
}
paddingSize++;
i--;
}
break;
}
break;
} while(0);
_32$$3 = ((paddingSize) ? 1 : 0);
if (_32$$3) {
_32$$3 = paddingSize <= blockSize;
}
if (_32$$3) {
if (paddingSize < length) {
ZEPHIR_SINIT_VAR(_33$$21);
ZVAL_LONG(&_33$$21, 0);
ZEPHIR_SINIT_VAR(_34$$21);
ZVAL_LONG(&_34$$21, (length - paddingSize));
zephir_substr(return_value, text, 0 , zephir_get_intval(&_34$$21), 0);
RETURN_MM();
}
RETURN_MM_STRING("", 1);
} else {
paddingSize = 0;
}
}
if (!(paddingSize)) {
RETURN_CTOR(text);
}
ZEPHIR_MM_RESTORE();
}
/**
* Add a text to an image with a specified opacity
*/
PHP_METHOD(Phalcon_Image_Adapter, text) {
zend_bool _0;
int opacity, size, ZEPHIR_LAST_CALL_STATUS;
zval *text_param = NULL, *offsetX = NULL, *offsetY = NULL, *opacity_param = NULL, *color_param = NULL, *size_param = NULL, *fontfile_param = NULL, *colors = NULL, _1, _2, *_3, _4 = zval_used_for_init, *_5 = NULL, *_6 = NULL, *_7 = NULL, *_8, *_9, *_10;
zval *text = NULL, *color = NULL, *fontfile = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 6, &text_param, &offsetX, &offsetY, &opacity_param, &color_param, &size_param, &fontfile_param);
zephir_get_strval(text, text_param);
if (!offsetX) {
offsetX = ZEPHIR_GLOBAL(global_false);
}
if (!offsetY) {
offsetY = ZEPHIR_GLOBAL(global_false);
}
if (!opacity_param) {
opacity = 100;
} else {
opacity = zephir_get_intval(opacity_param);
}
if (!color_param) {
ZEPHIR_INIT_VAR(color);
ZVAL_STRING(color, "000000", 1);
} else {
zephir_get_strval(color, color_param);
}
if (!size_param) {
size = 12;
} else {
size = zephir_get_intval(size_param);
}
if (!fontfile_param) {
ZEPHIR_INIT_VAR(fontfile);
ZVAL_EMPTY_STRING(fontfile);
} else {
zephir_get_strval(fontfile, fontfile_param);
}
if (opacity < 0) {
opacity = 0;
} else {
if (opacity > 100) {
opacity = 100;
}
}
_0 = zephir_fast_strlen_ev(color) > 1;
if (_0) {
ZEPHIR_SINIT_VAR(_1);
ZVAL_LONG(&_1, 0);
ZEPHIR_SINIT_VAR(_2);
ZVAL_LONG(&_2, 1);
ZEPHIR_INIT_VAR(_3);
zephir_substr(_3, color, 0 , 1 , 0);
_0 = ZEPHIR_IS_STRING_IDENTICAL(_3, "#");
}
if (_0) {
ZEPHIR_SINIT_VAR(_4);
ZVAL_LONG(&_4, 1);
ZEPHIR_INIT_VAR(_5);
zephir_substr(_5, color, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
zephir_get_strval(color, _5);
}
if (zephir_fast_strlen_ev(color) == 3) {
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRING(_5, "/./", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_6);
ZVAL_STRING(_6, "$0$0", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_FUNCTION(&_7, "preg_replace", NULL, 29, _5, _6, color);
zephir_check_temp_parameter(_5);
zephir_check_temp_parameter(_6);
zephir_check_call_status();
zephir_get_strval(color, _7);
}
ZEPHIR_SINIT_NVAR(_4);
ZVAL_LONG(&_4, 2);
ZEPHIR_CALL_FUNCTION(&_7, "str_split", NULL, 69, color, &_4);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_4);
ZVAL_STRING(&_4, "hexdec", 0);
ZEPHIR_CALL_FUNCTION(&colors, "array_map", NULL, 70, &_4, _7);
zephir_check_call_status();
zephir_array_fetch_long(&_8, colors, 0, PH_NOISY | PH_READONLY, "phalcon/image/adapter.zep", 335 TSRMLS_CC);
zephir_array_fetch_long(&_9, colors, 1, PH_NOISY | PH_READONLY, "phalcon/image/adapter.zep", 335 TSRMLS_CC);
zephir_array_fetch_long(&_10, colors, 2, PH_NOISY | PH_READONLY, "phalcon/image/adapter.zep", 335 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_5);
ZVAL_LONG(_5, opacity);
ZEPHIR_INIT_NVAR(_6);
ZVAL_LONG(_6, size);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_text", NULL, 0, text, offsetX, offsetY, _5, _8, _9, _10, _6, fontfile);
zephir_check_call_status();
RETURN_THIS();
}
