/** * 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(); }
/** * Set an specific argument */ PHP_METHOD(Phalcon_Cli_Console, setArgument) { HashTable *_3; HashPosition _2; int ZEPHIR_LAST_CALL_STATUS; zephir_fcall_cache_entry *_1 = NULL, *_8 = NULL, *_27 = NULL; zend_bool str, shift, _0; zval *arguments_param = NULL, *str_param = NULL, *shift_param = NULL, *arg = NULL, *pos = NULL, *args = NULL, *opts = NULL, *handleArgs = NULL, **_4, _5$$5 = zval_used_for_init, _6$$5 = zval_used_for_init, *_7$$5 = NULL, _9$$6 = zval_used_for_init, *_10$$7 = NULL, _11$$7 = zval_used_for_init, *_12$$7 = NULL, *_13$$7 = NULL, _14$$7 = zval_used_for_init, _15$$7 = zval_used_for_init, *_16$$7 = NULL, *_17$$8 = NULL, _18$$8 = zval_used_for_init, *_19$$8 = NULL, _20$$9 = zval_used_for_init, _21$$9 = zval_used_for_init, *_22$$9 = NULL, _23$$10 = zval_used_for_init, *_24$$10 = NULL, *_25$$13, *_26$$13 = NULL, *_28$$15 = NULL, *_29$$16 = NULL, *_30$$17; zval *arguments = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 3, &arguments_param, &str_param, &shift_param); if (!arguments_param) { ZEPHIR_INIT_VAR(arguments); array_init(arguments); } else { arguments = arguments_param; } if (!str_param) { str = 1; } else { if (unlikely(Z_TYPE_P(str_param) != IS_BOOL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'str' must be a bool") TSRMLS_CC); RETURN_MM_NULL(); } str = Z_BVAL_P(str_param); } if (!shift_param) { shift = 1; } else { if (unlikely(Z_TYPE_P(shift_param) != IS_BOOL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'shift' must be a bool") TSRMLS_CC); RETURN_MM_NULL(); } shift = Z_BVAL_P(shift_param); } ZEPHIR_INIT_VAR(args); array_init(args); ZEPHIR_INIT_VAR(opts); array_init(opts); ZEPHIR_INIT_VAR(handleArgs); array_init(handleArgs); _0 = shift; if (_0) { _0 = ((zephir_fast_count_int(arguments TSRMLS_CC)) ? 1 : 0); } if (_0) { ZEPHIR_MAKE_REF(arguments); ZEPHIR_CALL_FUNCTION(NULL, "array_shift", &_1, 132, arguments); ZEPHIR_UNREF(arguments); zephir_check_call_status(); } zephir_is_iterable(arguments, &_3, &_2, 0, 0, "phalcon/cli/console.zep", 199); for ( ; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS ; zephir_hash_move_forward_ex(_3, &_2) ) { ZEPHIR_GET_HVALUE(arg, _4); if (Z_TYPE_P(arg) == IS_STRING) { ZEPHIR_SINIT_NVAR(_5$$5); ZVAL_STRING(&_5$$5, "--", 0); ZEPHIR_SINIT_NVAR(_6$$5); ZVAL_LONG(&_6$$5, 2); ZEPHIR_CALL_FUNCTION(&_7$$5, "strncmp", &_8, 133, arg, &_5$$5, &_6$$5); zephir_check_call_status(); if (ZEPHIR_IS_LONG(_7$$5, 0)) { ZEPHIR_SINIT_NVAR(_9$$6); ZVAL_STRING(&_9$$6, "=", 0); ZEPHIR_INIT_NVAR(pos); zephir_fast_strpos(pos, arg, &_9$$6, 0 ); if (zephir_is_true(pos)) { ZEPHIR_INIT_NVAR(_10$$7); ZEPHIR_SINIT_NVAR(_11$$7); ZVAL_LONG(&_11$$7, (zephir_get_numberval(pos) + 1)); ZEPHIR_INIT_NVAR(_12$$7); zephir_substr(_12$$7, arg, zephir_get_intval(&_11$$7), 0, ZEPHIR_SUBSTR_NO_LENGTH); zephir_fast_trim(_10$$7, _12$$7, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC); ZEPHIR_INIT_NVAR(_13$$7); ZEPHIR_SINIT_NVAR(_14$$7); ZVAL_LONG(&_14$$7, 2); ZEPHIR_SINIT_NVAR(_15$$7); ZVAL_LONG(&_15$$7, (zephir_get_numberval(pos) - 2)); ZEPHIR_INIT_NVAR(_16$$7); zephir_substr(_16$$7, arg, 2 , zephir_get_intval(&_15$$7), 0); zephir_fast_trim(_13$$7, _16$$7, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC); zephir_array_update_zval(&opts, _13$$7, &_10$$7, PH_COPY | PH_SEPARATE); } else { ZEPHIR_INIT_NVAR(_17$$8); ZEPHIR_SINIT_NVAR(_18$$8); ZVAL_LONG(&_18$$8, 2); ZEPHIR_INIT_NVAR(_19$$8); zephir_substr(_19$$8, arg, 2 , 0, ZEPHIR_SUBSTR_NO_LENGTH); zephir_fast_trim(_17$$8, _19$$8, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC); zephir_array_update_zval(&opts, _17$$8, &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE); } } else { ZEPHIR_SINIT_NVAR(_20$$9); ZVAL_STRING(&_20$$9, "-", 0); ZEPHIR_SINIT_NVAR(_21$$9); ZVAL_LONG(&_21$$9, 1); ZEPHIR_CALL_FUNCTION(&_22$$9, "strncmp", &_8, 133, arg, &_20$$9, &_21$$9); zephir_check_call_status(); if (ZEPHIR_IS_LONG(_22$$9, 0)) { ZEPHIR_SINIT_NVAR(_23$$10); ZVAL_LONG(&_23$$10, 1); ZEPHIR_INIT_NVAR(_24$$10); zephir_substr(_24$$10, arg, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); zephir_array_update_zval(&opts, _24$$10, &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE); } else { zephir_array_append(&args, arg, PH_SEPARATE, "phalcon/cli/console.zep", 191); } } } else { zephir_array_append(&args, arg, PH_SEPARATE, "phalcon/cli/console.zep", 195); } } if (str) { ZEPHIR_INIT_VAR(_25$$13); ZEPHIR_CALL_CE_STATIC(&_26$$13, phalcon_cli_router_route_ce, "getdelimiter", &_27, 134); zephir_check_call_status(); zephir_fast_join(_25$$13, _26$$13, args TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_arguments"), _25$$13 TSRMLS_CC); } else { if (zephir_fast_count_int(args TSRMLS_CC)) { ZEPHIR_MAKE_REF(args); ZEPHIR_CALL_FUNCTION(&_28$$15, "array_shift", &_1, 132, args); ZEPHIR_UNREF(args); zephir_check_call_status(); zephir_array_update_string(&handleArgs, SL("task"), &_28$$15, PH_COPY | PH_SEPARATE); } if (zephir_fast_count_int(args TSRMLS_CC)) { ZEPHIR_MAKE_REF(args); ZEPHIR_CALL_FUNCTION(&_29$$16, "array_shift", &_1, 132, args); ZEPHIR_UNREF(args); zephir_check_call_status(); zephir_array_update_string(&handleArgs, SL("action"), &_29$$16, PH_COPY | PH_SEPARATE); } if (zephir_fast_count_int(args TSRMLS_CC)) { ZEPHIR_INIT_VAR(_30$$17); zephir_fast_array_merge(_30$$17, &(handleArgs), &(args) TSRMLS_CC); ZEPHIR_CPY_WRT(handleArgs, _30$$17); } zephir_update_property_this(this_ptr, SL("_arguments"), handleArgs TSRMLS_CC); } zephir_update_property_this(this_ptr, SL("_options"), opts TSRMLS_CC); RETURN_THIS(); }
/** * 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; int 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 (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 int") 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 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", 142); return; } do { if (paddingType == 1) { ZEPHIR_SINIT_VAR(_1$$5); ZVAL_LONG(&_1$$5, 0); ZEPHIR_CALL_FUNCTION(&_2$$5, "chr", &_3, 132, &_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, 133, _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, 132, &_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, 132, &_7$$6); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_7$$6); ZVAL_LONG(&_7$$6, paddingSize); ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_5, 133, _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, 111); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&_14$$8, "chr", &_3, 132, _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, 132, &_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, 132, &_17$$9); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_17$$9); ZVAL_LONG(&_17$$9, 0); ZEPHIR_CALL_FUNCTION(&_19$$9, "chr", &_3, 132, &_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, 133, _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, 132, &_21$$10); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_21$$10); ZVAL_LONG(&_21$$10, paddingSize); ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_5, 133, _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, 133, &_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", 186); 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(); }
/** * Decrypt a text that is coded as a base64 string */ PHP_METHOD(Phalcon_Crypt, decryptBase64) { zephir_fcall_cache_entry *_6 = NULL, *_7 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; zend_bool safe; zval *text_param = NULL, *key = NULL, *safe_param = NULL, _0$$3 = zval_used_for_init, _1$$3 = zval_used_for_init, *_2$$3 = NULL, *_3$$3, *_4$$3, *_5$$3 = NULL, *_8 = NULL; zval *text = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 2, &text_param, &key, &safe_param); if (UNEXPECTED(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 (EXPECTED(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 (!safe_param) { safe = 0; } else { if (UNEXPECTED(Z_TYPE_P(safe_param) != IS_BOOL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'safe' must be a bool") TSRMLS_CC); RETURN_MM_NULL(); } safe = Z_BVAL_P(safe_param); } if (safe == 1) { ZEPHIR_SINIT_VAR(_0$$3); ZVAL_STRING(&_0$$3, "-_", 0); ZEPHIR_SINIT_VAR(_1$$3); ZVAL_STRING(&_1$$3, "+/", 0); ZEPHIR_CALL_FUNCTION(&_2$$3, "strtr", NULL, 27, text, &_0$$3, &_1$$3); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_0$$3); ZVAL_STRING(&_0$$3, "===", 0); ZEPHIR_SINIT_NVAR(_1$$3); ZVAL_DOUBLE(&_1$$3, zephir_safe_mod_long_long(((zephir_fast_strlen_ev(text) + 3)), 4 TSRMLS_CC)); ZEPHIR_INIT_VAR(_3$$3); zephir_substr(_3$$3, &_0$$3, zephir_get_intval(&_1$$3), 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_INIT_VAR(_4$$3); ZEPHIR_CONCAT_VV(_4$$3, _2$$3, _3$$3); ZEPHIR_CALL_FUNCTION(&_5$$3, "base64_decode", &_6, 133, _4$$3); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "decrypt", &_7, 0, _5$$3, key); zephir_check_call_status(); RETURN_MM(); } ZEPHIR_CALL_FUNCTION(&_8, "base64_decode", &_6, 133, text); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "decrypt", &_7, 0, _8, key); zephir_check_call_status(); RETURN_MM(); }
/** * Magic method to get or set services using setters/getters * * @param string method * @param array arguments * @return mixed */ PHP_METHOD(Phalcon_Di, __call) { zephir_fcall_cache_entry *_3 = NULL; int ZEPHIR_LAST_CALL_STATUS; zephir_nts_static zephir_fcall_cache_entry *_2 = NULL, *_6 = NULL; zval *method_param = NULL, *arguments = NULL, *instance = NULL, *possibleService = NULL, *services, *definition, _0 = zval_used_for_init, *_1 = NULL, *_4 = NULL; zval *method = NULL, *_5; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &method_param, &arguments); if (unlikely(Z_TYPE_P(method_param) != IS_STRING && Z_TYPE_P(method_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'method' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(method_param) == IS_STRING)) { zephir_get_strval(method, method_param); } else { ZEPHIR_INIT_VAR(method); ZVAL_EMPTY_STRING(method); } if (!arguments) { arguments = ZEPHIR_GLOBAL(global_null); } if (zephir_start_with_str(method, SL("get"))) { ZEPHIR_OBS_VAR(services); zephir_read_property_this(&services, this_ptr, SL("_services"), PH_NOISY_CC); ZEPHIR_SINIT_VAR(_0); ZVAL_LONG(&_0, 3); ZEPHIR_INIT_VAR(_1); zephir_substr(_1, method, 3 , 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_CALL_FUNCTION(&possibleService, "lcfirst", &_2, _1); zephir_check_call_status(); if (zephir_array_isset(services, possibleService)) { if (zephir_fast_count_int(arguments TSRMLS_CC)) { ZEPHIR_CALL_METHOD(&instance, this_ptr, "get", &_3, possibleService, arguments); zephir_check_call_status(); } else { ZEPHIR_CALL_METHOD(&instance, this_ptr, "get", &_3, possibleService); zephir_check_call_status(); } RETURN_CCTOR(instance); } } if (zephir_start_with_str(method, SL("set"))) { ZEPHIR_OBS_VAR(definition); if (zephir_array_isset_long_fetch(&definition, arguments, 0, 0 TSRMLS_CC)) { ZEPHIR_SINIT_NVAR(_0); ZVAL_LONG(&_0, 3); ZEPHIR_INIT_NVAR(_1); zephir_substr(_1, method, 3 , 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_CALL_FUNCTION(&_4, "lcfirst", &_2, _1); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, this_ptr, "set", NULL, _4, definition); zephir_check_call_status(); RETURN_MM_NULL(); } } ZEPHIR_INIT_NVAR(_1); object_init_ex(_1, phalcon_di_exception_ce); ZEPHIR_INIT_VAR(_5); ZEPHIR_CONCAT_SVS(_5, "Call to undefined method or service '", method, "'"); ZEPHIR_CALL_METHOD(NULL, _1, "__construct", &_6, _5); zephir_check_call_status(); zephir_throw_exception_debug(_1, "phalcon/di.zep", 436 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; }
/** * Gets the column name in SQLite */ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, getColumnDefinition) { HashTable *_13$$41; HashPosition _12$$41; zephir_fcall_cache_entry *_17 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *column, *columnSql = NULL, *type = NULL, *typeValues = NULL, *_0$$8 = NULL, *_1$$8, *_2$$10 = NULL, *_3$$10 = NULL, *_4$$10, *_5$$16 = NULL, *_6$$16, *_7$$24 = NULL, *_8$$27 = NULL, *_9$$39, *_10$$39 = NULL, *_11$$39, *value$$41 = NULL, *valueSql$$41 = NULL, **_14$$41, _19$$41, _20$$41, *_21$$41, *_22$$41, _15$$42 = zval_used_for_init, *_16$$42 = NULL, *_18$$42 = NULL, _23$$43, *_24$$43 = NULL, *_25$$43; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &column); ZEPHIR_INIT_VAR(columnSql); ZVAL_STRING(columnSql, "", 1); ZEPHIR_CALL_METHOD(&type, column, "gettype", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(type) == IS_STRING) { zephir_concat_self(&columnSql, type TSRMLS_CC); ZEPHIR_CALL_METHOD(&type, column, "gettypereference", NULL, 0); zephir_check_call_status(); } do { if (ZEPHIR_IS_LONG(type, 0)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("INTEGER") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(type, 1)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("DATE") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(type, 2)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("VARCHAR") TSRMLS_CC); } ZEPHIR_CALL_METHOD(&_0$$8, column, "getsize", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(_1$$8); ZEPHIR_CONCAT_SVS(_1$$8, "(", _0$$8, ")"); zephir_concat_self(&columnSql, _1$$8 TSRMLS_CC); break; } if (ZEPHIR_IS_LONG(type, 3)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("NUMERIC") TSRMLS_CC); } ZEPHIR_CALL_METHOD(&_2$$10, column, "getsize", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_3$$10, column, "getscale", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(_4$$10); ZEPHIR_CONCAT_SVSVS(_4$$10, "(", _2$$10, ",", _3$$10, ")"); zephir_concat_self(&columnSql, _4$$10 TSRMLS_CC); break; } if (ZEPHIR_IS_LONG(type, 4)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("DATETIME") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(type, 17)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("TIMESTAMP") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(type, 5)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("CHARACTER") TSRMLS_CC); } ZEPHIR_CALL_METHOD(&_5$$16, column, "getsize", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(_6$$16); ZEPHIR_CONCAT_SVS(_6$$16, "(", _5$$16, ")"); zephir_concat_self(&columnSql, _6$$16 TSRMLS_CC); break; } if (ZEPHIR_IS_LONG(type, 6)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("TEXT") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(type, 8)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("TINYINT") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(type, 7)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("FLOAT") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(type, 9)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("DOUBLE") TSRMLS_CC); } ZEPHIR_CALL_METHOD(&_7$$24, column, "isunsigned", NULL, 0); zephir_check_call_status(); if (zephir_is_true(_7$$24)) { zephir_concat_self_str(&columnSql, SL(" UNSIGNED") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(type, 14)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("BIGINT") TSRMLS_CC); } ZEPHIR_CALL_METHOD(&_8$$27, column, "isunsigned", NULL, 0); zephir_check_call_status(); if (zephir_is_true(_8$$27)) { zephir_concat_self_str(&columnSql, SL(" UNSIGNED") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(type, 10)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("TINYBLOB") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(type, 11)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("BLOB") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(type, 12)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("MEDIUMBLOB") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(type, 13)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("LONGBLOB") TSRMLS_CC); } break; } if (ZEPHIR_IS_EMPTY(columnSql)) { ZEPHIR_INIT_VAR(_9$$39); object_init_ex(_9$$39, phalcon_db_exception_ce); ZEPHIR_CALL_METHOD(&_10$$39, column, "getname", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(_11$$39); ZEPHIR_CONCAT_SV(_11$$39, "Unrecognized SQLite data type at column ", _10$$39); ZEPHIR_CALL_METHOD(NULL, _9$$39, "__construct", NULL, 9, _11$$39); zephir_check_call_status(); zephir_throw_exception_debug(_9$$39, "phalcon/db/dialect/sqlite.zep", 169 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } ZEPHIR_CALL_METHOD(&typeValues, column, "gettypevalues", NULL, 0); zephir_check_call_status(); if (!(ZEPHIR_IS_EMPTY(typeValues))) { if (Z_TYPE_P(typeValues) == IS_ARRAY) { ZEPHIR_INIT_VAR(valueSql$$41); ZVAL_STRING(valueSql$$41, "", 1); zephir_is_iterable(typeValues, &_13$$41, &_12$$41, 0, 0, "phalcon/db/dialect/sqlite.zep", 180); for ( ; zephir_hash_get_current_data_ex(_13$$41, (void**) &_14$$41, &_12$$41) == SUCCESS ; zephir_hash_move_forward_ex(_13$$41, &_12$$41) ) { ZEPHIR_GET_HVALUE(value$$41, _14$$41); ZEPHIR_SINIT_NVAR(_15$$42); ZVAL_STRING(&_15$$42, "\"", 0); ZEPHIR_CALL_FUNCTION(&_16$$42, "addcslashes", &_17, 153, value$$41, &_15$$42); zephir_check_call_status(); ZEPHIR_INIT_LNVAR(_18$$42); ZEPHIR_CONCAT_SVS(_18$$42, "\"", _16$$42, "\", "); zephir_concat_self(&valueSql$$41, _18$$42 TSRMLS_CC); } ZEPHIR_SINIT_VAR(_19$$41); ZVAL_LONG(&_19$$41, 0); ZEPHIR_SINIT_VAR(_20$$41); ZVAL_LONG(&_20$$41, -2); ZEPHIR_INIT_VAR(_21$$41); zephir_substr(_21$$41, valueSql$$41, 0 , -2 , 0); ZEPHIR_INIT_VAR(_22$$41); ZEPHIR_CONCAT_SVS(_22$$41, "(", _21$$41, ")"); zephir_concat_self(&columnSql, _22$$41 TSRMLS_CC); } else { ZEPHIR_SINIT_VAR(_23$$43); ZVAL_STRING(&_23$$43, "\"", 0); ZEPHIR_CALL_FUNCTION(&_24$$43, "addcslashes", &_17, 153, typeValues, &_23$$43); zephir_check_call_status(); ZEPHIR_INIT_VAR(_25$$43); ZEPHIR_CONCAT_SVS(_25$$43, "(\"", _24$$43, "\")"); zephir_concat_self(&columnSql, _25$$43 TSRMLS_CC); } } } while(0); RETURN_CCTOR(columnSql); }
/** * Extracts a slice from a string/array/traversable object value */ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt, slice) { zend_bool _1$$5; zephir_fcall_cache_entry *_3 = NULL, *_4 = NULL, *_7 = NULL; int start, ZEPHIR_LAST_CALL_STATUS, position = 0; zval *value, *start_param = NULL, *end = NULL, *length = NULL, *slice = NULL, _10, *_0$$3 = NULL, *_2$$6 = NULL, _5$$9, _6$$11, _8$$10, _9$$12; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 2, &value, &start_param, &end); if (!start_param) { start = 0; } else { start = zephir_get_intval(start_param); } if (!end) { ZEPHIR_CPY_WRT(end, ZEPHIR_GLOBAL(global_null)); } else { ZEPHIR_SEPARATE_PARAM(end); } if (Z_TYPE_P(value) == IS_OBJECT) { if (Z_TYPE_P(end) == IS_NULL) { ZEPHIR_INIT_NVAR(end); ZVAL_LONG(end, (zephir_fast_count_int(value TSRMLS_CC) - 1)); } position = 0; ZEPHIR_INIT_VAR(slice); array_init(slice); ZEPHIR_CALL_METHOD(NULL, value, "rewind", NULL, 0); zephir_check_call_status(); while (1) { ZEPHIR_CALL_METHOD(&_0$$3, value, "valid", NULL, 0); zephir_check_call_status(); if (!(zephir_is_true(_0$$3))) { break; } _1$$5 = position >= start; if (_1$$5) { _1$$5 = ZEPHIR_GE_LONG(end, position); } if (_1$$5) { ZEPHIR_CALL_METHOD(&_2$$6, value, "current", &_3, 0); zephir_check_call_status(); zephir_array_append(&slice, _2$$6, PH_SEPARATE, "phalcon/mvc/view/engine/volt.zep", 223); } ZEPHIR_CALL_METHOD(NULL, value, "next", &_4, 0); zephir_check_call_status(); position++; } RETURN_CCTOR(slice); } ZEPHIR_INIT_VAR(length); if (Z_TYPE_P(end) != IS_NULL) { ZVAL_LONG(length, (((zephir_get_numberval(end) - start)) + 1)); } else { ZVAL_NULL(length); } if (Z_TYPE_P(value) == IS_ARRAY) { ZEPHIR_SINIT_VAR(_5$$9); ZVAL_LONG(&_5$$9, start); ZEPHIR_RETURN_CALL_FUNCTION("array_slice", NULL, 394, value, &_5$$9, length); zephir_check_call_status(); RETURN_MM(); } if ((zephir_function_exists_ex(SS("mb_substr") TSRMLS_CC) == SUCCESS)) { if (Z_TYPE_P(length) != IS_NULL) { ZEPHIR_SINIT_VAR(_6$$11); ZVAL_LONG(&_6$$11, start); ZEPHIR_RETURN_CALL_FUNCTION("mb_substr", &_7, 395, value, &_6$$11, length); zephir_check_call_status(); RETURN_MM(); } ZEPHIR_SINIT_VAR(_8$$10); ZVAL_LONG(&_8$$10, start); ZEPHIR_RETURN_CALL_FUNCTION("mb_substr", &_7, 395, value, &_8$$10); zephir_check_call_status(); RETURN_MM(); } if (Z_TYPE_P(length) != IS_NULL) { ZEPHIR_SINIT_VAR(_9$$12); ZVAL_LONG(&_9$$12, start); zephir_substr(return_value, value, zephir_get_intval(&_9$$12), zephir_get_intval(length), 0); RETURN_MM(); } ZEPHIR_SINIT_VAR(_10); ZVAL_LONG(&_10, start); zephir_substr(return_value, value, zephir_get_intval(&_10), 0, ZEPHIR_SUBSTR_NO_LENGTH); RETURN_MM(); }
/** * @todo this method can be write differently with (P< style match * Matches a user submitted path with parts defined by a map. Assigns and * returns an array of variables on a successful match. * * @param string $path Path used to match against this routing map * @return array|false An array of assigned values or a false on a mismatch */ PHP_METHOD(Yaf_Route_Rewrite, _match) { zephir_nts_static zephir_fcall_cache_entry *_27 = NULL, *_33 = NULL; zend_bool _12, _28, _32; HashTable *_7, *_22, *_35; HashPosition _6, _21, _34; int staticCount, pathStaticCount, ZEPHIR_LAST_CALL_STATUS; zval *path_param = NULL, *values, *matchedPath = NULL, *parts, *variables, *wildcardData, *name = NULL, *part = NULL, *pos = NULL, *pathMatch, *count = NULL, *i = NULL, *varr = NULL, *pathPart = NULL, *tmpReturn = NULL, *_0, *_1 = NULL, *_2 = NULL, *_3, _4 = zval_used_for_init, _5 = zval_used_for_init, **_8, _9 = zval_used_for_init, _10 = zval_used_for_init, *_11 = NULL, _13 = zval_used_for_init, _14 = zval_used_for_init, *_15 = NULL, _16 = zval_used_for_init, _17 = zval_used_for_init, *_18 = NULL, _19 = zval_used_for_init, *_20 = NULL, **_23, *_24 = NULL, *_25, *_26, *_29 = NULL, *_30, *_31 = NULL, **_36; zval *path = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &path_param); zephir_get_strval(path, path_param); staticCount = 0; pathStaticCount = 0; ZEPHIR_INIT_VAR(values); array_init(values); ZEPHIR_INIT_VAR(matchedPath); ZVAL_STRING(matchedPath, "", 1); ZEPHIR_INIT_VAR(parts); array_init(parts); ZEPHIR_INIT_VAR(variables); array_init(variables); ZEPHIR_INIT_VAR(wildcardData); array_init(wildcardData); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_route"), PH_NOISY_CC); if (!ZEPHIR_IS_STRING_IDENTICAL(_0, "")) { ZEPHIR_INIT_VAR(_1); ZEPHIR_INIT_VAR(_2); _3 = zephir_fetch_nproperty_this(this_ptr, SL("_route"), PH_NOISY_CC); ZEPHIR_SINIT_VAR(_4); ZVAL_STRING(&_4, "/", 0); zephir_fast_trim(_2, _3, &_4, ZEPHIR_TRIM_BOTH TSRMLS_CC); ZEPHIR_SINIT_VAR(_5); ZVAL_STRING(&_5, "/", 0); zephir_fast_explode(_1, &_5, _2, LONG_MAX TSRMLS_CC); zephir_is_iterable(_1, &_7, &_6, 0, 0, "yaf/Route/rewrite.zep", 135); for ( ; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS ; zephir_hash_move_forward_ex(_7, &_6) ) { ZEPHIR_GET_HMKEY(pos, _7, _6); ZEPHIR_GET_HVALUE(part, _8); ZEPHIR_SINIT_NVAR(_9); ZVAL_LONG(&_9, 0); ZEPHIR_SINIT_NVAR(_10); ZVAL_LONG(&_10, 1); ZEPHIR_INIT_NVAR(_11); zephir_substr(_11, part, 0 , 1 , 0); _12 = ZEPHIR_IS_STRING(_11, ":"); if (_12) { ZEPHIR_SINIT_NVAR(_13); ZVAL_LONG(&_13, 1); ZEPHIR_SINIT_NVAR(_14); ZVAL_LONG(&_14, 1); ZEPHIR_INIT_NVAR(_15); zephir_substr(_15, part, 1 , 1 , 0); _12 = !ZEPHIR_IS_STRING(_15, ":"); } if (_12) { ZEPHIR_SINIT_NVAR(_16); ZVAL_LONG(&_16, 1); ZEPHIR_INIT_NVAR(name); zephir_substr(name, part, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); zephir_array_update_zval(&parts, pos, &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE); zephir_array_update_zval(&variables, pos, &name, PH_COPY | PH_SEPARATE); } else { ZEPHIR_SINIT_NVAR(_16); ZVAL_LONG(&_16, 0); ZEPHIR_SINIT_NVAR(_17); ZVAL_LONG(&_17, 1); ZEPHIR_INIT_NVAR(_18); zephir_substr(_18, part, 0 , 1 , 0); if (ZEPHIR_IS_STRING(_18, ":")) { ZEPHIR_SINIT_NVAR(_19); ZVAL_LONG(&_19, 1); ZEPHIR_INIT_NVAR(_20); zephir_substr(_20, part, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_CPY_WRT(part, _20); } zephir_array_update_zval(&parts, pos, &part, PH_COPY | PH_SEPARATE); if (!ZEPHIR_IS_STRING_IDENTICAL(part, "*")) { staticCount++; } } } } if (!ZEPHIR_IS_STRING_IDENTICAL(path, "")) { ZEPHIR_INIT_VAR(pathMatch); ZEPHIR_SINIT_NVAR(_4); ZVAL_STRING(&_4, "/", 0); zephir_fast_explode(pathMatch, &_4, path, LONG_MAX TSRMLS_CC); zephir_is_iterable(pathMatch, &_22, &_21, 0, 0, "yaf/Route/rewrite.zep", 193); for ( ; zephir_hash_get_current_data_ex(_22, (void**) &_23, &_21) == SUCCESS ; zephir_hash_move_forward_ex(_22, &_21) ) { ZEPHIR_GET_HMKEY(pos, _22, _21); ZEPHIR_GET_HVALUE(pathPart, _23); if (!(zephir_array_key_exists(parts, pos TSRMLS_CC))) { RETURN_MM_BOOL(0); } ZEPHIR_INIT_LNVAR(_24); ZEPHIR_CONCAT_VS(_24, pathPart, "/"); zephir_concat_self(&matchedPath, _24 TSRMLS_CC); zephir_array_fetch(&_25, parts, pos, PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 150 TSRMLS_CC); if (ZEPHIR_IS_STRING(_25, "*")) { ZEPHIR_INIT_NVAR(count); ZVAL_LONG(count, zephir_fast_count_int(pathMatch TSRMLS_CC)); ZEPHIR_CPY_WRT(i, pos); while (1) { if (!(ZEPHIR_LT(i, count))) { break; } zephir_array_fetch(&_26, pathMatch, i, PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 154 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&varr, "urldecode", &_27, _26); zephir_check_call_status(); _12 = !(zephir_array_isset(wildcardData, varr)); if (_12) { _3 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC); _12 = !(zephir_array_isset(_3, varr)); } _28 = _12; if (_28) { _28 = !(zephir_array_isset(values, varr)); } if (_28) { ZEPHIR_INIT_LNVAR(_29); if (zephir_array_isset_long(pathMatch, (zephir_get_numberval(i) + 1))) { zephir_array_fetch_long(&_30, pathMatch, (zephir_get_numberval(i) + 1), PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 157 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&_29, "urldecode", &_27, _30); zephir_check_call_status(); } else { ZEPHIR_INIT_NVAR(_29); ZVAL_NULL(_29); } zephir_array_update_zval(&wildcardData, varr, &_29, PH_COPY | PH_SEPARATE); } ZEPHIR_INIT_NVAR(_1); ZVAL_LONG(_1, 2); ZEPHIR_ADD_ASSIGN(i, _1); } ZEPHIR_INIT_NVAR(matchedPath); ZEPHIR_SINIT_NVAR(_5); ZVAL_STRING(&_5, "/", 0); zephir_fast_join(matchedPath, &_5, pathMatch TSRMLS_CC); break; } if (zephir_array_isset(variables, pos)) { ZEPHIR_OBS_NVAR(name); zephir_array_fetch(&name, variables, pos, PH_NOISY, "yaf/Route/rewrite.zep", 165 TSRMLS_CC); } else { ZEPHIR_INIT_NVAR(name); ZVAL_NULL(name); } ZEPHIR_CALL_FUNCTION(&_31, "urldecode", &_27, pathPart); zephir_check_call_status(); ZEPHIR_CPY_WRT(pathPart, _31); ZEPHIR_OBS_NVAR(part); zephir_array_fetch(&part, parts, pos, PH_NOISY, "yaf/Route/rewrite.zep", 167 TSRMLS_CC); ZEPHIR_SINIT_NVAR(_9); ZVAL_LONG(&_9, 0); ZEPHIR_SINIT_NVAR(_10); ZVAL_LONG(&_10, 2); ZEPHIR_INIT_NVAR(_2); zephir_substr(_2, part, 0 , 2 , 0); if (ZEPHIR_IS_STRING_IDENTICAL(_2, "@@")) { ZEPHIR_SINIT_NVAR(_13); ZVAL_LONG(&_13, 1); ZEPHIR_INIT_NVAR(_11); zephir_substr(_11, part, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_CPY_WRT(part, _11); } _28 = Z_TYPE_P(name) == IS_NULL; if (_28) { _28 = !ZEPHIR_IS_EQUAL(part, pathPart); } if (_28) { RETURN_MM_BOOL(0); } _32 = Z_TYPE_P(part) != IS_NULL; if (_32) { ZEPHIR_INIT_LNVAR(_29); ZEPHIR_CONCAT_VSSS(_29, part, "#^", "$#", "iu"); ZEPHIR_CALL_FUNCTION(&_31, "preg_match", &_33, _29, pathPart); zephir_check_call_status(); _32 = !zephir_is_true(_31); } if (_32) { RETURN_MM_BOOL(0); } if (Z_TYPE_P(name) != IS_NULL) { zephir_array_update_zval(&values, name, &pathPart, PH_COPY | PH_SEPARATE); } else { pathStaticCount++; } } } if (staticCount != pathStaticCount) { RETURN_MM_BOOL(0); } ZEPHIR_INIT_VAR(tmpReturn); zephir_add_function_ex(tmpReturn, values, wildcardData TSRMLS_CC); zephir_is_iterable(variables, &_35, &_34, 0, 0, "yaf/Route/rewrite.zep", 212); for ( ; zephir_hash_get_current_data_ex(_35, (void**) &_36, &_34) == SUCCESS ; zephir_hash_move_forward_ex(_35, &_34) ) { ZEPHIR_GET_HVALUE(varr, _36); if (!(zephir_array_key_exists(tmpReturn, varr TSRMLS_CC))) { RETURN_MM_BOOL(0); } } _12 = Z_TYPE_P(values) == IS_NULL; if (_12) { _12 = Z_TYPE_P(wildcardData) == IS_NULL; } _32 = _12; if (_32) { _32 = staticCount != 0; } if (_32) { _3 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC); ZEPHIR_INIT_LNVAR(_24); zephir_add_function_ex(_24, tmpReturn, _3 TSRMLS_CC); ZEPHIR_CPY_WRT(tmpReturn, _24); } RETURN_CCTOR(tmpReturn); }
/** * Handles routing information received from command-line arguments * * @param array arguments */ PHP_METHOD(Phalcon_Cli_Router, handle) { zephir_fcall_cache_entry *_18 = NULL; zval *_15 = NULL; zval *_5 = NULL, *_10 = NULL; int ZEPHIR_LAST_CALL_STATUS; HashTable *_3, *_7; HashPosition _2, _6; zend_bool _0; zval *arguments = NULL, *moduleName = NULL, *taskName = NULL, *actionName = NULL, *params = NULL, *route = NULL, *parts = NULL, *pattern = NULL, *routeFound = NULL, *matches, *paths = NULL, *beforeMatch = NULL, *converters = NULL, *converter = NULL, *part = NULL, *position = NULL, *matchPosition = NULL, *strParams, *_1, **_4, **_8, *_9 = NULL, *_11, *_12, *_13, *_14, _16, *_17 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &arguments); if (!arguments) { arguments = ZEPHIR_GLOBAL(global_null); } ZEPHIR_INIT_VAR(routeFound); ZVAL_BOOL(routeFound, 0); ZEPHIR_INIT_VAR(parts); array_init(parts); ZEPHIR_INIT_VAR(params); array_init(params); ZEPHIR_INIT_VAR(matches); ZVAL_NULL(matches); zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_matchedRoute"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC); if (Z_TYPE_P(arguments) != IS_ARRAY) { _0 = Z_TYPE_P(arguments) != IS_STRING; if (_0) { _0 = Z_TYPE_P(arguments) != IS_NULL; } if (_0) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_router_exception_ce, "Arguments must be an array or string", "phalcon/cli/router.zep", 204); return; } _1 = zephir_fetch_nproperty_this(this_ptr, SL("_routes"), PH_NOISY_CC); zephir_is_iterable(_1, &_3, &_2, 0, 1, "phalcon/cli/router.zep", 304); for ( ; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS ; zephir_hash_move_backwards_ex(_3, &_2) ) { ZEPHIR_GET_HVALUE(route, _4); ZEPHIR_CALL_METHOD(&pattern, route, "getcompiledpattern", NULL, 0); zephir_check_call_status(); if (zephir_memnstr_str(pattern, SL("^"), "phalcon/cli/router.zep", 214)) { ZEPHIR_INIT_NVAR(routeFound); zephir_preg_match(routeFound, pattern, arguments, matches, 0, 0 , 0 TSRMLS_CC); } else { ZEPHIR_INIT_NVAR(routeFound); ZVAL_BOOL(routeFound, ZEPHIR_IS_EQUAL(pattern, arguments)); } if (zephir_is_true(routeFound)) { ZEPHIR_CALL_METHOD(&beforeMatch, route, "getbeforematch", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(beforeMatch) != IS_NULL) { if (!(zephir_is_callable(beforeMatch TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_router_exception_ce, "Before-Match callback is not callable in matched route", "phalcon/cli/router.zep", 232); return; } ZEPHIR_INIT_NVAR(_5); zephir_create_array(_5, 3, 0 TSRMLS_CC); zephir_array_fast_append(_5, arguments); zephir_array_fast_append(_5, route); zephir_array_fast_append(_5, this_ptr); ZEPHIR_INIT_NVAR(routeFound); ZEPHIR_CALL_USER_FUNC_ARRAY(routeFound, beforeMatch, _5); zephir_check_call_status(); } } if (zephir_is_true(routeFound)) { ZEPHIR_CALL_METHOD(&paths, route, "getpaths", NULL, 0); zephir_check_call_status(); ZEPHIR_CPY_WRT(parts, paths); if (Z_TYPE_P(matches) == IS_ARRAY) { ZEPHIR_CALL_METHOD(&converters, route, "getconverters", NULL, 0); zephir_check_call_status(); zephir_is_iterable(paths, &_7, &_6, 0, 0, "phalcon/cli/router.zep", 293); for ( ; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS ; zephir_hash_move_forward_ex(_7, &_6) ) { ZEPHIR_GET_HMKEY(part, _7, _6); ZEPHIR_GET_HVALUE(position, _8); ZEPHIR_OBS_NVAR(matchPosition); if (zephir_array_isset_fetch(&matchPosition, matches, position, 0 TSRMLS_CC)) { if (Z_TYPE_P(converters) == IS_ARRAY) { ZEPHIR_OBS_NVAR(converter); if (zephir_array_isset_fetch(&converter, converters, part, 0 TSRMLS_CC)) { ZEPHIR_INIT_NVAR(_9); ZEPHIR_INIT_NVAR(_5); zephir_create_array(_5, 1, 0 TSRMLS_CC); zephir_array_fast_append(_5, matchPosition); ZEPHIR_CALL_USER_FUNC_ARRAY(_9, converter, _5); zephir_check_call_status(); zephir_array_update_zval(&parts, part, &_9, PH_COPY | PH_SEPARATE); continue; } } zephir_array_update_zval(&parts, part, &matchPosition, PH_COPY | PH_SEPARATE); } else { if (Z_TYPE_P(converters) == IS_ARRAY) { ZEPHIR_OBS_NVAR(converter); if (zephir_array_isset_fetch(&converter, converters, part, 0 TSRMLS_CC)) { ZEPHIR_INIT_NVAR(_9); ZEPHIR_INIT_NVAR(_10); zephir_create_array(_10, 1, 0 TSRMLS_CC); zephir_array_fast_append(_10, position); ZEPHIR_CALL_USER_FUNC_ARRAY(_9, converter, _10); zephir_check_call_status(); zephir_array_update_zval(&parts, part, &_9, PH_COPY | PH_SEPARATE); } } } } zephir_update_property_this(this_ptr, SL("_matches"), matches TSRMLS_CC); } zephir_update_property_this(this_ptr, SL("_matchedRoute"), route TSRMLS_CC); break; } } if (zephir_is_true(routeFound)) { zephir_update_property_this(this_ptr, SL("_wasMatched"), (1) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC); } else { zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC); _11 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultModule"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_module"), _11 TSRMLS_CC); _12 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultTask"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_task"), _12 TSRMLS_CC); _13 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAction"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_action"), _13 TSRMLS_CC); _14 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultParams"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_params"), _14 TSRMLS_CC); RETURN_THIS(); } } else { ZEPHIR_CPY_WRT(parts, arguments); } ZEPHIR_INIT_VAR(moduleName); ZVAL_NULL(moduleName); ZEPHIR_INIT_VAR(taskName); ZVAL_NULL(taskName); ZEPHIR_INIT_VAR(actionName); ZVAL_NULL(actionName); ZEPHIR_OBS_NVAR(moduleName); if (zephir_array_isset_string_fetch(&moduleName, parts, SS("module"), 0 TSRMLS_CC)) { zephir_array_unset_string(&parts, SS("module"), PH_SEPARATE); } else { ZEPHIR_OBS_NVAR(moduleName); zephir_read_property_this(&moduleName, this_ptr, SL("_defaultModule"), PH_NOISY_CC); } ZEPHIR_OBS_NVAR(taskName); if (zephir_array_isset_string_fetch(&taskName, parts, SS("task"), 0 TSRMLS_CC)) { zephir_array_unset_string(&parts, SS("task"), PH_SEPARATE); } else { ZEPHIR_OBS_NVAR(taskName); zephir_read_property_this(&taskName, this_ptr, SL("_defaultTask"), PH_NOISY_CC); } ZEPHIR_OBS_NVAR(actionName); if (zephir_array_isset_string_fetch(&actionName, parts, SS("action"), 0 TSRMLS_CC)) { zephir_array_unset_string(&parts, SS("action"), PH_SEPARATE); } else { ZEPHIR_OBS_NVAR(actionName); zephir_read_property_this(&actionName, this_ptr, SL("_defaultAction"), PH_NOISY_CC); } if (zephir_is_true(routeFound)) { ZEPHIR_OBS_NVAR(params); if (zephir_array_isset_string_fetch(¶ms, parts, SS("params"), 0 TSRMLS_CC)) { if (Z_TYPE_P(params) != IS_ARRAY) { zephir_get_strval(_15, params); ZEPHIR_SINIT_VAR(_16); ZVAL_LONG(&_16, 1); ZEPHIR_INIT_VAR(strParams); zephir_substr(strParams, _15, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); if (zephir_is_true(strParams)) { ZEPHIR_CALL_CE_STATIC(&_17, phalcon_cli_router_route_ce, "getdelimiter", &_18, 123); zephir_check_call_status(); ZEPHIR_INIT_NVAR(params); zephir_fast_explode(params, _17, strParams, LONG_MAX TSRMLS_CC); } else { ZEPHIR_INIT_NVAR(params); array_init(params); } } zephir_array_unset_string(&parts, SS("params"), PH_SEPARATE); } if (zephir_fast_count_int(params TSRMLS_CC)) { ZEPHIR_INIT_NVAR(_9); zephir_fast_array_merge(_9, &(params), &(parts) TSRMLS_CC); ZEPHIR_CPY_WRT(params, _9); } else { ZEPHIR_CPY_WRT(params, parts); } } else { ZEPHIR_CPY_WRT(params, parts); } zephir_update_property_this(this_ptr, SL("_module"), moduleName TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_task"), taskName TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_action"), actionName TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_params"), params TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * 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(); }
/** * 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); }
/** * 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(); }
/** * Set an specific argument */ PHP_METHOD(Phalcon_Cli_Console, setArgument) { zephir_fcall_cache_entry *_5 = NULL, *_24 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; zend_bool str, shift, _0; zval *arguments_param = NULL, *str_param = NULL, *shift_param = NULL, __$true, arg, pos, args, opts, handleArgs, *_1, _2$$5, _3$$5, _4$$5, _6$$6, _7$$7, _8$$7, _9$$7, _10$$7, _11$$7, _12$$7, _13$$7, _14$$8, _15$$8, _16$$8, _17$$9, _18$$9, _19$$9, _20$$10, _21$$10, _22$$13, _23$$13, _25$$15, _26$$16, _27$$17; zval arguments; zval *this_ptr = getThis(); ZVAL_UNDEF(&arguments); ZVAL_BOOL(&__$true, 1); ZVAL_UNDEF(&arg); ZVAL_UNDEF(&pos); ZVAL_UNDEF(&args); ZVAL_UNDEF(&opts); ZVAL_UNDEF(&handleArgs); ZVAL_UNDEF(&_2$$5); ZVAL_UNDEF(&_3$$5); ZVAL_UNDEF(&_4$$5); ZVAL_UNDEF(&_6$$6); ZVAL_UNDEF(&_7$$7); ZVAL_UNDEF(&_8$$7); ZVAL_UNDEF(&_9$$7); ZVAL_UNDEF(&_10$$7); ZVAL_UNDEF(&_11$$7); ZVAL_UNDEF(&_12$$7); ZVAL_UNDEF(&_13$$7); ZVAL_UNDEF(&_14$$8); ZVAL_UNDEF(&_15$$8); ZVAL_UNDEF(&_16$$8); ZVAL_UNDEF(&_17$$9); ZVAL_UNDEF(&_18$$9); ZVAL_UNDEF(&_19$$9); ZVAL_UNDEF(&_20$$10); ZVAL_UNDEF(&_21$$10); ZVAL_UNDEF(&_22$$13); ZVAL_UNDEF(&_23$$13); ZVAL_UNDEF(&_25$$15); ZVAL_UNDEF(&_26$$16); ZVAL_UNDEF(&_27$$17); ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 3, &arguments_param, &str_param, &shift_param); if (!arguments_param) { ZEPHIR_INIT_VAR(&arguments); array_init(&arguments); } else { ZEPHIR_OBS_COPY_OR_DUP(&arguments, arguments_param); } if (!str_param) { str = 1; } else { if (UNEXPECTED(Z_TYPE_P(str_param) != IS_TRUE && Z_TYPE_P(str_param) != IS_FALSE)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'str' must be of the type bool") TSRMLS_CC); RETURN_MM_NULL(); } str = (Z_TYPE_P(str_param) == IS_TRUE); } if (!shift_param) { shift = 1; } else { if (UNEXPECTED(Z_TYPE_P(shift_param) != IS_TRUE && Z_TYPE_P(shift_param) != IS_FALSE)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'shift' must be of the type bool") TSRMLS_CC); RETURN_MM_NULL(); } shift = (Z_TYPE_P(shift_param) == IS_TRUE); } ZEPHIR_INIT_VAR(&args); array_init(&args); ZEPHIR_INIT_VAR(&opts); array_init(&opts); ZEPHIR_INIT_VAR(&handleArgs); array_init(&handleArgs); _0 = shift; if (_0) { _0 = ((zephir_fast_count_int(&arguments TSRMLS_CC)) ? 1 : 0); } if (_0) { ZEPHIR_MAKE_REF(&arguments); ZEPHIR_CALL_FUNCTION(NULL, "array_shift", NULL, 11, &arguments); ZEPHIR_UNREF(&arguments); zephir_check_call_status(); } zephir_is_iterable(&arguments, 0, "phalcon/cli/console.zep", 176); ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&arguments), _1) { ZEPHIR_INIT_NVAR(&arg); ZVAL_COPY(&arg, _1); if (Z_TYPE_P(&arg) == IS_STRING) { ZEPHIR_INIT_NVAR(&_2$$5); ZVAL_STRING(&_2$$5, "--"); ZVAL_LONG(&_3$$5, 2); ZEPHIR_CALL_FUNCTION(&_4$$5, "strncmp", &_5, 117, &arg, &_2$$5, &_3$$5); zephir_check_call_status(); if (ZEPHIR_IS_LONG(&_4$$5, 0)) { ZEPHIR_INIT_NVAR(&_6$$6); ZVAL_STRING(&_6$$6, "="); ZEPHIR_INIT_NVAR(&pos); zephir_fast_strpos(&pos, &arg, &_6$$6, 0 ); if (zephir_is_true(&pos)) { ZEPHIR_INIT_NVAR(&_7$$7); ZVAL_LONG(&_8$$7, (zephir_get_numberval(&pos) + 1)); ZEPHIR_INIT_NVAR(&_9$$7); zephir_substr(&_9$$7, &arg, zephir_get_intval(&_8$$7), 0, ZEPHIR_SUBSTR_NO_LENGTH); zephir_fast_trim(&_7$$7, &_9$$7, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC); ZEPHIR_INIT_NVAR(&_10$$7); ZVAL_LONG(&_11$$7, 2); ZVAL_LONG(&_12$$7, (zephir_get_numberval(&pos) - 2)); ZEPHIR_INIT_NVAR(&_13$$7); zephir_substr(&_13$$7, &arg, 2 , zephir_get_intval(&_12$$7), 0); zephir_fast_trim(&_10$$7, &_13$$7, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC); zephir_array_update_zval(&opts, &_10$$7, &_7$$7, PH_COPY | PH_SEPARATE); } else { ZEPHIR_INIT_NVAR(&_14$$8); ZVAL_LONG(&_15$$8, 2); ZEPHIR_INIT_NVAR(&_16$$8); zephir_substr(&_16$$8, &arg, 2 , 0, ZEPHIR_SUBSTR_NO_LENGTH); zephir_fast_trim(&_14$$8, &_16$$8, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC); zephir_array_update_zval(&opts, &_14$$8, &__$true, PH_COPY | PH_SEPARATE); } } else { ZEPHIR_INIT_NVAR(&_17$$9); ZVAL_STRING(&_17$$9, "-"); ZVAL_LONG(&_18$$9, 1); ZEPHIR_CALL_FUNCTION(&_19$$9, "strncmp", &_5, 117, &arg, &_17$$9, &_18$$9); zephir_check_call_status(); if (ZEPHIR_IS_LONG(&_19$$9, 0)) { ZVAL_LONG(&_20$$10, 1); ZEPHIR_INIT_NVAR(&_21$$10); zephir_substr(&_21$$10, &arg, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); zephir_array_update_zval(&opts, &_21$$10, &__$true, PH_COPY | PH_SEPARATE); } else { zephir_array_append(&args, &arg, PH_SEPARATE, "phalcon/cli/console.zep", 168); } } } else { zephir_array_append(&args, &arg, PH_SEPARATE, "phalcon/cli/console.zep", 172); } } ZEND_HASH_FOREACH_END();
/** * 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(); }
PHP_METHOD(Xpl_ClassLoader, findFileWithExtension) { HashTable *_16, *_39, *_6$$3, *_11$$5, *_32$$12, *_35$$14; HashPosition _15, _38, _5$$3, _10$$5, _31$$12, _34$$14; int ZEPHIR_LAST_CALL_STATUS; zephir_fcall_cache_entry *_3 = NULL; zval *className_param = NULL, *ext_param = NULL, *logicalPathPsr4 = NULL, *firstChar = NULL, *prefixLengthsPsr4 = NULL, *prefix = NULL, *length = NULL, *dir = NULL, *file = NULL, *prefixesPsr0 = NULL, *logicalPathPsr0 = NULL, *nsPos = NULL, *dirs = NULL, _0 = zval_used_for_init, _1 = zval_used_for_init, *_2 = NULL, *_4, *_14, **_17, _18, *_30, *_37, **_40, *_41, **_7$$3, *_8$$5, *_9$$5, **_12$$5, *_13$$6 = NULL, _19$$10, _20$$10, *_21$$10, _22$$10, *_23$$10, _24$$10, _25$$10, *_26$$10 = NULL, _27$$11, _28$$11, *_29$$11 = NULL, **_33$$12, **_36$$14; zval *className = NULL, *ext = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &className_param, &ext_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_get_strval(ext, ext_param); ZEPHIR_SINIT_VAR(_0); ZVAL_STRING(&_0, "\\", 0); ZEPHIR_SINIT_VAR(_1); ZVAL_STRING(&_1, "/", 0); ZEPHIR_CALL_FUNCTION(&_2, "strtr", &_3, 56, className, &_0, &_1); zephir_check_call_status(); ZEPHIR_INIT_VAR(logicalPathPsr4); ZEPHIR_CONCAT_VV(logicalPathPsr4, _2, ext); ZEPHIR_SINIT_NVAR(_0); ZVAL_LONG(&_0, 0); ZEPHIR_SINIT_NVAR(_1); ZVAL_LONG(&_1, 1); ZEPHIR_INIT_VAR(firstChar); zephir_substr(firstChar, className, 0 , 1 , 0); ZEPHIR_OBS_VAR(prefixLengthsPsr4); _4 = zephir_fetch_nproperty_this(this_ptr, SL("prefixLengthsPsr4"), PH_NOISY_CC); if (zephir_array_isset_fetch(&prefixLengthsPsr4, _4, firstChar, 0 TSRMLS_CC)) { zephir_is_iterable(prefixLengthsPsr4, &_6$$3, &_5$$3, 0, 0, "xpl/classloader.zep", 505); for ( ; zephir_hash_get_current_data_ex(_6$$3, (void**) &_7$$3, &_5$$3) == SUCCESS ; zephir_hash_move_forward_ex(_6$$3, &_5$$3) ) { ZEPHIR_GET_HMKEY(prefix, _6$$3, _5$$3); ZEPHIR_GET_HVALUE(length, _7$$3); if (zephir_start_with(className, prefix, ZEPHIR_GLOBAL(global_false))) { _8$$5 = zephir_fetch_nproperty_this(this_ptr, SL("prefixDirsPsr4"), PH_NOISY_CC); zephir_array_fetch(&_9$$5, _8$$5, prefix, PH_NOISY | PH_READONLY, "xpl/classloader.zep", 495 TSRMLS_CC); zephir_is_iterable(_9$$5, &_11$$5, &_10$$5, 0, 0, "xpl/classloader.zep", 503); for ( ; zephir_hash_get_current_data_ex(_11$$5, (void**) &_12$$5, &_10$$5) == SUCCESS ; zephir_hash_move_forward_ex(_11$$5, &_10$$5) ) { ZEPHIR_GET_HVALUE(dir, _12$$5); ZEPHIR_INIT_NVAR(_13$$6); zephir_substr(_13$$6, logicalPathPsr4, zephir_get_intval(length), 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_INIT_NVAR(file); ZEPHIR_CONCAT_VSV(file, dir, "/", _13$$6); if ((zephir_file_exists(file TSRMLS_CC) == SUCCESS)) { RETURN_CCTOR(file); } } } } } _14 = zephir_fetch_nproperty_this(this_ptr, SL("fallbackDirsPsr4"), PH_NOISY_CC); zephir_is_iterable(_14, &_16, &_15, 0, 0, "xpl/classloader.zep", 517); for ( ; zephir_hash_get_current_data_ex(_16, (void**) &_17, &_15) == SUCCESS ; zephir_hash_move_forward_ex(_16, &_15) ) { ZEPHIR_GET_HVALUE(dir, _17); ZEPHIR_INIT_NVAR(file); ZEPHIR_CONCAT_VSV(file, dir, "/", logicalPathPsr4); if ((zephir_file_exists(file TSRMLS_CC) == SUCCESS)) { RETURN_CCTOR(file); } } ZEPHIR_SINIT_VAR(_18); ZVAL_STRING(&_18, "\\", 0); ZEPHIR_CALL_FUNCTION(&nsPos, "strrpos", NULL, 57, className, &_18); zephir_check_call_status(); ZEPHIR_INIT_VAR(logicalPathPsr0); if (zephir_is_true(nsPos)) { ZEPHIR_SINIT_VAR(_19$$10); ZVAL_LONG(&_19$$10, 0); ZEPHIR_SINIT_VAR(_20$$10); ZVAL_LONG(&_20$$10, (zephir_get_numberval(nsPos) + 1)); ZEPHIR_INIT_VAR(_21$$10); zephir_substr(_21$$10, logicalPathPsr4, 0 , zephir_get_intval(&_20$$10), 0); ZEPHIR_SINIT_VAR(_22$$10); ZVAL_LONG(&_22$$10, (zephir_get_numberval(nsPos) + 1)); ZEPHIR_INIT_VAR(_23$$10); zephir_substr(_23$$10, logicalPathPsr4, zephir_get_intval(&_22$$10), 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_SINIT_VAR(_24$$10); ZVAL_STRING(&_24$$10, "_", 0); ZEPHIR_SINIT_VAR(_25$$10); ZVAL_STRING(&_25$$10, "/", 0); ZEPHIR_CALL_FUNCTION(&_26$$10, "strtr", &_3, 56, _23$$10, &_24$$10, &_25$$10); zephir_check_call_status(); ZEPHIR_CONCAT_VV(logicalPathPsr0, _21$$10, _26$$10); } else { ZEPHIR_SINIT_VAR(_27$$11); ZVAL_STRING(&_27$$11, "_", 0); ZEPHIR_SINIT_VAR(_28$$11); ZVAL_STRING(&_28$$11, "/", 0); ZEPHIR_CALL_FUNCTION(&_29$$11, "strtr", &_3, 56, className, &_27$$11, &_28$$11); zephir_check_call_status(); ZEPHIR_CONCAT_VV(logicalPathPsr0, _29$$11, ext); } ZEPHIR_OBS_VAR(prefixesPsr0); _30 = zephir_fetch_nproperty_this(this_ptr, SL("prefixesPsr0"), PH_NOISY_CC); if (zephir_array_isset_fetch(&prefixesPsr0, _30, firstChar, 0 TSRMLS_CC)) { zephir_is_iterable(prefixesPsr0, &_32$$12, &_31$$12, 0, 0, "xpl/classloader.zep", 546); for ( ; zephir_hash_get_current_data_ex(_32$$12, (void**) &_33$$12, &_31$$12) == SUCCESS ; zephir_hash_move_forward_ex(_32$$12, &_31$$12) ) { ZEPHIR_GET_HMKEY(prefix, _32$$12, _31$$12); ZEPHIR_GET_HVALUE(dirs, _33$$12); if (zephir_start_with(className, prefix, NULL)) { zephir_is_iterable(dirs, &_35$$14, &_34$$14, 0, 0, "xpl/classloader.zep", 544); for ( ; zephir_hash_get_current_data_ex(_35$$14, (void**) &_36$$14, &_34$$14) == SUCCESS ; zephir_hash_move_forward_ex(_35$$14, &_34$$14) ) { ZEPHIR_GET_HVALUE(dir, _36$$14); ZEPHIR_INIT_NVAR(file); ZEPHIR_CONCAT_VSV(file, dir, "/", logicalPathPsr0); if ((zephir_file_exists(file TSRMLS_CC) == SUCCESS)) { RETURN_CCTOR(file); } } } } } _37 = zephir_fetch_nproperty_this(this_ptr, SL("fallbackDirsPsr0"), PH_NOISY_CC); zephir_is_iterable(_37, &_39, &_38, 0, 0, "xpl/classloader.zep", 559); for ( ; zephir_hash_get_current_data_ex(_39, (void**) &_40, &_38) == SUCCESS ; zephir_hash_move_forward_ex(_39, &_38) ) { ZEPHIR_GET_HVALUE(dir, _40); ZEPHIR_INIT_NVAR(file); ZEPHIR_CONCAT_VSV(file, dir, "/", logicalPathPsr0); if ((zephir_file_exists(file TSRMLS_CC) == SUCCESS)) { RETURN_CCTOR(file); } } _41 = zephir_fetch_nproperty_this(this_ptr, SL("useIncludePath"), PH_NOISY_CC); if (ZEPHIR_IS_TRUE_IDENTICAL(_41)) { ZEPHIR_CALL_FUNCTION(&file, "stream_resolve_include_path", NULL, 58, logicalPathPsr0); zephir_check_call_status(); if (zephir_is_true(file)) { RETURN_CCTOR(file); } } RETURN_MM_NULL(); }
/** * 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(); }
/** * Stores cached content into the file backend and stops the frontend * * @param int|string keyName * @param string content * @param long lifetime * @param boolean stopBuffer */ PHP_METHOD(Phalcon_Cache_Backend_Redis, save) { int ZEPHIR_LAST_CALL_STATUS; zend_bool stopBuffer; zval *keyName = NULL, *content = NULL, *lifetime = NULL, *stopBuffer_param = NULL, *prefixedKey = NULL, *lastKey = NULL, *prefix, *frontend, *redis = NULL, *cachedContent = NULL, *preparedContent = NULL, *tmp, *tt1 = NULL, *success = NULL, *options, *specialKey, *isBuffering = NULL, _0; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 4, &keyName, &content, &lifetime, &stopBuffer_param); if (!keyName) { keyName = ZEPHIR_GLOBAL(global_null); } if (!content) { content = ZEPHIR_GLOBAL(global_null); } if (!lifetime) { lifetime = ZEPHIR_GLOBAL(global_null); } if (!stopBuffer_param) { stopBuffer = 1; } else { stopBuffer = zephir_get_boolval(stopBuffer_param); } if (!(zephir_is_true(keyName))) { ZEPHIR_OBS_VAR(lastKey); zephir_read_property_this(&lastKey, this_ptr, SL("_lastKey"), PH_NOISY_CC); ZEPHIR_SINIT_VAR(_0); ZVAL_LONG(&_0, 5); ZEPHIR_INIT_VAR(prefixedKey); zephir_substr(prefixedKey, lastKey, 5 , 0, ZEPHIR_SUBSTR_NO_LENGTH); } else { ZEPHIR_OBS_VAR(prefix); zephir_read_property_this(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC); ZEPHIR_INIT_NVAR(prefixedKey); ZEPHIR_CONCAT_VV(prefixedKey, prefix, keyName); ZEPHIR_INIT_NVAR(lastKey); ZEPHIR_CONCAT_SV(lastKey, "_PHCR", prefixedKey); } if (!(zephir_is_true(lastKey))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "The cache must be started first", "phalcon/cache/backend/redis.zep", 197); return; } ZEPHIR_OBS_VAR(frontend); zephir_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); ZEPHIR_OBS_VAR(redis); zephir_read_property_this(&redis, this_ptr, SL("_redis"), PH_NOISY_CC); if (Z_TYPE_P(redis) != IS_OBJECT) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "_connect", NULL, 0); zephir_check_call_status(); ZEPHIR_OBS_NVAR(redis); zephir_read_property_this(&redis, this_ptr, SL("_redis"), PH_NOISY_CC); } if (!(zephir_is_true(content))) { ZEPHIR_CALL_METHOD(&cachedContent, frontend, "getcontent", NULL, 0); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(cachedContent, content); } if (!(zephir_is_numeric(cachedContent))) { ZEPHIR_CALL_METHOD(&preparedContent, frontend, "beforestore", NULL, 0, cachedContent); zephir_check_call_status(); } if (!(zephir_is_true(lifetime))) { ZEPHIR_OBS_VAR(tmp); zephir_read_property_this(&tmp, this_ptr, SL("_lastLifetime"), PH_NOISY_CC); if (!(zephir_is_true(tmp))) { ZEPHIR_CALL_METHOD(&tt1, frontend, "getlifetime", NULL, 0); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(tt1, tmp); } } else { ZEPHIR_CPY_WRT(tt1, lifetime); } if (zephir_is_numeric(cachedContent)) { ZEPHIR_CALL_METHOD(&success, redis, "set", NULL, 0, lastKey, cachedContent); zephir_check_call_status(); } else { ZEPHIR_CALL_METHOD(&success, redis, "set", NULL, 0, lastKey, preparedContent); zephir_check_call_status(); } if (!(zephir_is_true(success))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Failed storing the data in redis", "phalcon/cache/backend/redis.zep", 243); return; } ZEPHIR_CALL_METHOD(NULL, redis, "settimeout", NULL, 0, lastKey, tt1); zephir_check_call_status(); ZEPHIR_OBS_VAR(options); zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC); if (!(zephir_array_isset_string(options, SS("statsKey")))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/redis.zep", 251); return; } ZEPHIR_OBS_VAR(specialKey); zephir_array_fetch_string(&specialKey, options, SL("statsKey"), PH_NOISY, "phalcon/cache/backend/redis.zep", 254 TSRMLS_CC); ZEPHIR_CALL_METHOD(NULL, redis, "sadd", NULL, 0, specialKey, prefixedKey); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&isBuffering, frontend, "isbuffering", NULL, 0); zephir_check_call_status(); if (stopBuffer == 1) { ZEPHIR_CALL_METHOD(NULL, frontend, "stop", NULL, 0); zephir_check_call_status(); } if (ZEPHIR_IS_TRUE_IDENTICAL(isBuffering)) { zend_print_zval(cachedContent, 0); } zephir_update_property_this(this_ptr, SL("_started"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * Set an specific argument * * @param var arguments * @param boolean str * @param boolean shift */ PHP_METHOD(Phalcon_Cli_Console, setArgument) { HashTable *_3; HashPosition _2; int ZEPHIR_LAST_CALL_STATUS; zephir_nts_static zephir_fcall_cache_entry *_1 = NULL, *_8 = NULL, *_16 = NULL; zend_bool str, shift, _0; zval *arguments = NULL, *str_param = NULL, *shift_param = NULL, *arg = NULL, *pos = NULL, *args, *opts, *handleArgs = NULL, **_4, _5 = zval_used_for_init, _6 = zval_used_for_init, *_7 = NULL, *_9 = NULL, *_10 = NULL, *_11 = NULL, _12 = zval_used_for_init, _13 = zval_used_for_init, *_14 = NULL, *_15 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 3, &arguments, &str_param, &shift_param); if (!arguments) { arguments = ZEPHIR_GLOBAL(global_null); } if (!str_param) { str = 1; } else { if (unlikely(Z_TYPE_P(str_param) != IS_BOOL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'str' must be a bool") TSRMLS_CC); RETURN_MM_NULL(); } str = Z_BVAL_P(str_param); } if (!shift_param) { shift = 1; } else { if (unlikely(Z_TYPE_P(shift_param) != IS_BOOL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'shift' must be a bool") TSRMLS_CC); RETURN_MM_NULL(); } shift = Z_BVAL_P(shift_param); } ZEPHIR_INIT_VAR(args); array_init(args); ZEPHIR_INIT_VAR(opts); array_init(opts); ZEPHIR_INIT_VAR(handleArgs); array_init(handleArgs); if (Z_TYPE_P(arguments) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_console_exception_ce, "Arguments must be an array", "phalcon/cli/console.zep", 266); return; } _0 = shift; if (_0) { _0 = (zephir_fast_count_int(arguments TSRMLS_CC)) ? 1 : 0; } if (_0) { Z_SET_ISREF_P(arguments); ZEPHIR_CALL_FUNCTION(NULL, "array_shift", &_1, arguments); Z_UNSET_ISREF_P(arguments); zephir_check_call_status(); } zephir_is_iterable(arguments, &_3, &_2, 0, 0, "phalcon/cli/console.zep", 294); for ( ; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS ; zephir_hash_move_forward_ex(_3, &_2) ) { ZEPHIR_GET_HVALUE(arg, _4); if (Z_TYPE_P(arg) == IS_STRING) { ZEPHIR_SINIT_NVAR(_5); ZVAL_STRING(&_5, "--", 0); ZEPHIR_SINIT_NVAR(_6); ZVAL_LONG(&_6, 2); ZEPHIR_CALL_FUNCTION(&_7, "strncmp", &_8, arg, &_5, &_6); zephir_check_call_status(); if (ZEPHIR_IS_LONG(_7, 0)) { ZEPHIR_SINIT_NVAR(_5); ZVAL_STRING(&_5, "=", 0); ZEPHIR_INIT_NVAR(pos); zephir_fast_strpos(pos, arg, &_5, 0 ); if (zephir_is_true(pos)) { ZEPHIR_INIT_NVAR(_9); ZEPHIR_SINIT_NVAR(_6); ZVAL_LONG(&_6, (zephir_get_numberval(pos) + 1)); ZEPHIR_INIT_NVAR(_10); zephir_substr(_10, arg, zephir_get_intval(&_6), 0, ZEPHIR_SUBSTR_NO_LENGTH); zephir_fast_trim(_9, _10, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC); ZEPHIR_INIT_NVAR(_11); ZEPHIR_SINIT_NVAR(_12); ZVAL_LONG(&_12, 2); ZEPHIR_SINIT_NVAR(_13); ZVAL_LONG(&_13, (zephir_get_numberval(pos) - 2)); ZEPHIR_INIT_NVAR(_14); zephir_substr(_14, arg, 2 , zephir_get_intval(&_13), 0); zephir_fast_trim(_11, _14, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC); zephir_array_update_zval(&opts, _11, &_9, PH_COPY | PH_SEPARATE); } else { ZEPHIR_INIT_NVAR(_9); ZEPHIR_SINIT_NVAR(_12); ZVAL_LONG(&_12, 2); ZEPHIR_INIT_NVAR(_10); zephir_substr(_10, arg, 2 , 0, ZEPHIR_SUBSTR_NO_LENGTH); zephir_fast_trim(_9, _10, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC); zephir_array_update_zval(&opts, _9, &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE); } } else { ZEPHIR_SINIT_NVAR(_12); ZVAL_STRING(&_12, "-", 0); ZEPHIR_SINIT_NVAR(_13); ZVAL_LONG(&_13, 1); ZEPHIR_CALL_FUNCTION(&_15, "strncmp", &_8, arg, &_12, &_13); zephir_check_call_status(); if (ZEPHIR_IS_LONG(_15, 0)) { ZEPHIR_SINIT_NVAR(_12); ZVAL_LONG(&_12, 1); ZEPHIR_INIT_NVAR(_9); zephir_substr(_9, arg, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); zephir_array_update_zval(&opts, _9, &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE); } else { zephir_array_append(&args, arg, PH_SEPARATE, "phalcon/cli/console.zep", 286); } } } else { zephir_array_append(&args, arg, PH_SEPARATE, "phalcon/cli/console.zep", 290); } } if (str) { ZEPHIR_INIT_NVAR(_9); ZEPHIR_CALL_CE_STATIC(&_7, phalcon_cli_router_route_ce, "getdelimiter", &_16); zephir_check_call_status(); zephir_fast_join(_9, _7, args TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_arguments"), _9 TSRMLS_CC); } else { if (zephir_fast_count_int(args TSRMLS_CC)) { Z_SET_ISREF_P(args); ZEPHIR_CALL_FUNCTION(&_15, "array_shift", &_1, args); Z_UNSET_ISREF_P(args); zephir_check_call_status(); zephir_array_update_string(&handleArgs, SL("task"), &_15, PH_COPY | PH_SEPARATE); } if (zephir_fast_count_int(args TSRMLS_CC)) { Z_SET_ISREF_P(args); ZEPHIR_CALL_FUNCTION(&_7, "array_shift", &_1, args); Z_UNSET_ISREF_P(args); zephir_check_call_status(); zephir_array_update_string(&handleArgs, SL("action"), &_7, PH_COPY | PH_SEPARATE); } if (zephir_fast_count_int(args TSRMLS_CC)) { ZEPHIR_INIT_NVAR(_10); zephir_fast_array_merge(_10, &(handleArgs), &(args) TSRMLS_CC); ZEPHIR_CPY_WRT(handleArgs, _10); } zephir_update_property_this(this_ptr, SL("_arguments"), handleArgs TSRMLS_CC); } zephir_update_property_this(this_ptr, SL("_options"), opts TSRMLS_CC); RETURN_THIS(); }
/** * 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); }
/** * 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(); }
/** * Decrypts an encrypted text * *<code> * echo $crypt->decrypt($encrypted, "decrypt password"); *</code> */ PHP_METHOD(Phalcon_Crypt, decrypt) { zend_bool _12; zephir_fcall_cache_entry *_4 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; zval *text_param = NULL, *key = NULL, *decryptKey = NULL, *ivSize = NULL, *cipher = NULL, *mode = NULL, *blockSize = NULL, *paddingType = NULL, *decrypted = NULL, _0 = zval_used_for_init, *_1 = NULL, *_2, *_3 = NULL, *_8, _9, *_10, _11, *_5$$9, *_6$$9, *_7$$9 = NULL; zval *text = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &text_param, &key); if (UNEXPECTED(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 (EXPECTED(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("openssl_cipher_iv_length") TSRMLS_CC) == SUCCESS))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "openssl extension is required", "phalcon/crypt.zep", 331); 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", 341); return; } ZEPHIR_OBS_VAR(cipher); zephir_read_property_this(&cipher, this_ptr, SL("_cipher"), PH_NOISY_CC); ZEPHIR_SINIT_VAR(_0); ZVAL_STRING(&_0, "-", 0); ZEPHIR_CALL_FUNCTION(&_1, "strrpos", NULL, 152, cipher, &_0); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_0); ZVAL_LONG(&_0, (zephir_get_numberval(_1) - zephir_fast_strlen_ev(cipher))); ZEPHIR_INIT_VAR(_2); zephir_substr(_2, cipher, zephir_get_intval(&_0), 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_INIT_VAR(mode); zephir_fast_strtolower(mode, _2); ZEPHIR_CALL_FUNCTION(&_3, "openssl_get_cipher_methods", NULL, 153, ZEPHIR_GLOBAL(global_true)); zephir_check_call_status(); if (!(zephir_fast_in_array(cipher, _3 TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Cipher algorithm is unknown", "phalcon/crypt.zep", 348); return; } ZEPHIR_CALL_FUNCTION(&ivSize, "openssl_cipher_iv_length", &_4, 154, cipher); zephir_check_call_status(); if (ZEPHIR_GT_LONG(ivSize, 0)) { ZEPHIR_CPY_WRT(blockSize, ivSize); } else { ZEPHIR_INIT_VAR(_5$$9); ZEPHIR_CONCAT_SV(_5$$9, "-", mode); ZEPHIR_INIT_VAR(_6$$9); ZVAL_STRING(_6$$9, "", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_FUNCTION(&_7$$9, "str_ireplace", NULL, 155, _5$$9, _6$$9, cipher); zephir_check_temp_parameter(_6$$9); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&blockSize, "openssl_cipher_iv_length", &_4, 154, _7$$9); zephir_check_call_status(); } ZEPHIR_INIT_VAR(_8); zephir_substr(_8, text, zephir_get_intval(ivSize), 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_SINIT_VAR(_9); ZVAL_LONG(&_9, 0); ZEPHIR_INIT_VAR(_10); zephir_substr(_10, text, 0 , zephir_get_intval(ivSize), 0); ZEPHIR_SINIT_VAR(_11); ZVAL_LONG(&_11, 1); ZEPHIR_CALL_FUNCTION(&decrypted, "openssl_decrypt", NULL, 158, _8, cipher, decryptKey, &_11, _10); zephir_check_call_status(); ZEPHIR_OBS_VAR(paddingType); zephir_read_property_this(&paddingType, this_ptr, SL("_padding"), PH_NOISY_CC); _12 = ZEPHIR_IS_STRING(mode, "cbc"); if (!(_12)) { _12 = ZEPHIR_IS_STRING(mode, "ecb"); } if (_12) { ZEPHIR_RETURN_CALL_METHOD(this_ptr, "_cryptunpadtext", NULL, 0, decrypted, mode, blockSize, paddingType); zephir_check_call_status(); RETURN_MM(); } RETURN_CCTOR(decrypted); }
/** * 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(); }
/** * Handles routing information received from the rewrite engine * *<code> * //Read the info from the rewrite engine * $router->handle(); * * //Manually passing an URL * $router->handle('/posts/edit/1'); *</code> * * @param string uri */ PHP_METHOD(Test_Router, handle) { HashTable *_3, *_9; HashPosition _2, _8; zval *uri = NULL, *realUri = NULL, *request = NULL, *currentHostName = NULL, *routeFound = NULL, *parts = NULL, *params, *matches, *notFoundPaths, *vnamespace, *module, *controller, *action, *paramsStr, *strParams, *paramsMerge = NULL, *route = NULL, *methods = NULL, *dependencyInjector = NULL, *hostname = NULL, *regexHostName = NULL, *matched = NULL, *pattern = NULL, *handledUri = NULL, *beforeMatch = NULL, *paths = NULL, *converters = NULL, *part = NULL, *position = NULL, *matchPosition, *_0, *_1, **_4, *_5, *_6 = NULL, *_7 = NULL, **_10, *_11, *_12, *_13, *_14, *_15; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &uri); if (!uri) { uri = ZEPHIR_GLOBAL(global_null); } if (!(zephir_is_true(uri))) { ZEPHIR_INIT_VAR(realUri); zephir_call_method(realUri, this_ptr, "getrewriteuri"); } else { ZEPHIR_CPY_WRT(realUri, uri); } _0 = zephir_fetch_nproperty_this(this_ptr, SL("_removeExtraSlashes"), PH_NOISY_CC); if (zephir_is_true(_0)) { ZEPHIR_INIT_VAR(handledUri); zephir_call_method_p1(handledUri, this_ptr, "doremoveextraslashes", realUri); } else { ZEPHIR_CPY_WRT(handledUri, realUri); } ZEPHIR_INIT_VAR(request); ZVAL_NULL(request); ZEPHIR_INIT_VAR(currentHostName); ZVAL_NULL(currentHostName); ZEPHIR_INIT_VAR(routeFound); ZVAL_BOOL(routeFound, 0); ZEPHIR_INIT_VAR(parts); array_init(parts); ZEPHIR_INIT_VAR(params); array_init(params); ZEPHIR_INIT_VAR(matches); ZVAL_NULL(matches); zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_matchedRoute"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC); _1 = zephir_fetch_nproperty_this(this_ptr, SL("_routes"), PH_NOISY_CC); zephir_is_iterable(_1, &_3, &_2, 0, 1); for ( ; zend_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS ; zend_hash_move_backwards_ex(_3, &_2) ) { ZEPHIR_GET_HVALUE(route, _4); ZEPHIR_INIT_NVAR(methods); zephir_call_method(methods, route, "gethttpmethods"); if ((Z_TYPE_P(methods) != IS_NULL)) { if ((Z_TYPE_P(request) == IS_NULL)) { _5 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); ZEPHIR_CPY_WRT(dependencyInjector, _5); if ((Z_TYPE_P(dependencyInjector) != IS_OBJECT)) { ZEPHIR_THROW_EXCEPTION_STR(test_router_exception_ce, "A dependency injection container is required to access the 'request' service"); return; } ZEPHIR_INIT_NVAR(_6); ZVAL_STRING(_6, "request", 1); ZEPHIR_INIT_NVAR(request); zephir_call_method_p1(request, dependencyInjector, "getshared", _6); } ZEPHIR_INIT_NVAR(_6); zephir_call_method_p1(_6, request, "ismethod", methods); if (ZEPHIR_IS_FALSE(_6)) { continue; } } ZEPHIR_INIT_NVAR(hostname); zephir_call_method(hostname, route, "gethostname"); if ((Z_TYPE_P(hostname) != IS_NULL)) { if ((Z_TYPE_P(request) == IS_NULL)) { ZEPHIR_OBS_NVAR(dependencyInjector); zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); if ((Z_TYPE_P(dependencyInjector) != IS_OBJECT)) { ZEPHIR_THROW_EXCEPTION_STR(test_router_exception_ce, "A dependency injection container is required to access the 'request' service"); return; } ZEPHIR_INIT_NVAR(_6); ZVAL_STRING(_6, "request", 1); ZEPHIR_INIT_NVAR(request); zephir_call_method_p1(request, dependencyInjector, "getshared", _6); } if ((Z_TYPE_P(currentHostName) != IS_OBJECT)) { ZEPHIR_INIT_NVAR(currentHostName); zephir_call_method(currentHostName, request, "gethttphost"); } if ((Z_TYPE_P(currentHostName) != IS_NULL)) { continue; } ZEPHIR_INIT_NVAR(matched); if (zephir_memnstr_str(hostname, SL("("), "test/router.zep", 381)) { if (zephir_memnstr_str(hostname, SL("#"), "test/router.zep", 382)) { ZEPHIR_INIT_NVAR(regexHostName); ZEPHIR_CONCAT_SVS(regexHostName, "#^", hostname, "$#"); } else { ZEPHIR_CPY_WRT(regexHostName, hostname); } ZEPHIR_INIT_NVAR(_7); zephir_preg_match(matched, &(matched), regexHostName, currentHostName, _7, 0, 0 , 0 TSRMLS_CC); } else { ZVAL_BOOL(matched, ZEPHIR_IS_EQUAL(currentHostName, hostname)); } if (!(zephir_is_true(matched))) { continue; } } ZEPHIR_INIT_NVAR(pattern); zephir_call_method(pattern, route, "getcompiledpattern"); ZEPHIR_INIT_NVAR(routeFound); if (zephir_memnstr_str(pattern, SL("^"), "test/router.zep", 400)) { zephir_preg_match(routeFound, &(routeFound), pattern, handledUri, matches, 0, 0 , 0 TSRMLS_CC); } else { ZVAL_BOOL(routeFound, ZEPHIR_IS_EQUAL(pattern, handledUri)); } if (zephir_is_true(routeFound)) { ZEPHIR_INIT_NVAR(beforeMatch); zephir_call_method(beforeMatch, route, "getbeforematch"); if ((Z_TYPE_P(beforeMatch) != IS_NULL)) { if (zephir_is_callable(beforeMatch TSRMLS_CC)) { ZEPHIR_THROW_EXCEPTION_STR(test_router_exception_ce, "Before-Match callback is not callable in matched route"); return; } } } if (zephir_is_true(routeFound)) { ZEPHIR_INIT_NVAR(paths); zephir_call_method(paths, route, "getpaths"); ZEPHIR_CPY_WRT(parts, paths); if ((Z_TYPE_P(matches) == IS_ARRAY)) { ZEPHIR_INIT_NVAR(converters); zephir_call_method(converters, route, "getconverters"); zephir_is_iterable(paths, &_9, &_8, 0, 0); for ( ; zend_hash_get_current_data_ex(_9, (void**) &_10, &_8) == SUCCESS ; zend_hash_move_forward_ex(_9, &_8) ) { ZEPHIR_GET_HMKEY(part, _9, _8); ZEPHIR_GET_HVALUE(position, _10); if (zephir_array_isset_fetch(&matchPosition, matches, position, 1 TSRMLS_CC)) { if ((Z_TYPE_P(converters) == IS_ARRAY)) { if (zephir_array_isset(converters, part)) { continue; } } zephir_array_update_zval(&parts, part, &matchPosition, PH_COPY | PH_SEPARATE); } else { if ((Z_TYPE_P(converters) == IS_ARRAY)) { if (zephir_array_isset(converters, part)) { } } } } zephir_update_property_this(this_ptr, SL("_matches"), matches TSRMLS_CC); } zephir_update_property_this(this_ptr, SL("_matchedRoute"), route TSRMLS_CC); break; } } if (zephir_is_true(routeFound)) { zephir_update_property_this(this_ptr, SL("_wasMatched"), (1) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC); } else { zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC); } if (!(zephir_is_true(routeFound))) { notFoundPaths = zephir_fetch_nproperty_this(this_ptr, SL("_notFoundPaths"), PH_NOISY_CC); if ((Z_TYPE_P(notFoundPaths) != IS_NULL)) { ZEPHIR_CPY_WRT(parts, notFoundPaths); ZEPHIR_INIT_BNVAR(routeFound); ZVAL_BOOL(routeFound, 1); } } if (zephir_is_true(routeFound)) { if (zephir_array_isset_string_fetch(&vnamespace, parts, SS("namespace"), 1 TSRMLS_CC)) { if (!(zephir_is_numeric(vnamespace))) { zephir_update_property_this(this_ptr, SL("_namespace"), vnamespace TSRMLS_CC); } zephir_array_fetch_string(&_11, parts, SL("namespace"), PH_NOISY | PH_READONLY TSRMLS_CC); zephir_array_unset(&parts, _11, PH_SEPARATE); } else { _5 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultNamespace"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_namespace"), _5 TSRMLS_CC); } if (zephir_array_isset_string_fetch(&module, parts, SS("module"), 1 TSRMLS_CC)) { if (!(zephir_is_numeric(module))) { zephir_update_property_this(this_ptr, SL("_module"), module TSRMLS_CC); } zephir_array_fetch_string(&_11, parts, SL("module"), PH_NOISY | PH_READONLY TSRMLS_CC); zephir_array_unset(&parts, _11, PH_SEPARATE); } else { _5 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultModule"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_module"), _5 TSRMLS_CC); } if (zephir_array_isset_string_fetch(&controller, parts, SS("controller"), 1 TSRMLS_CC)) { if (!(zephir_is_numeric(controller))) { zephir_update_property_this(this_ptr, SL("_controller"), controller TSRMLS_CC); } zephir_array_fetch_string(&_11, parts, SL("controller"), PH_NOISY | PH_READONLY TSRMLS_CC); zephir_array_unset(&parts, _11, PH_SEPARATE); } else { _5 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultController"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_controller"), _5 TSRMLS_CC); } if (zephir_array_isset_string_fetch(&action, parts, SS("action"), 1 TSRMLS_CC)) { if (!(zephir_is_numeric(action))) { zephir_update_property_this(this_ptr, SL("_action"), action TSRMLS_CC); } zephir_array_fetch_string(&_11, parts, SL("action"), PH_NOISY | PH_READONLY TSRMLS_CC); zephir_array_unset(&parts, _11, PH_SEPARATE); } else { _5 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAction"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_action"), _5 TSRMLS_CC); } if (zephir_array_isset_string_fetch(¶msStr, parts, SS("params"), 1 TSRMLS_CC)) { ZEPHIR_INIT_VAR(strParams); zephir_substr(strParams, paramsStr, 1 , 0 ); if (zephir_is_true(strParams)) { ZEPHIR_INIT_BNVAR(params); zephir_fast_explode_str(params, SL("/"), strParams, LONG_MAX TSRMLS_CC); } zephir_array_fetch_string(&_11, parts, SL("params"), PH_NOISY | PH_READONLY TSRMLS_CC); zephir_array_unset(&parts, _11, PH_SEPARATE); } if (zephir_fast_count_int(params TSRMLS_CC)) { ZEPHIR_INIT_VAR(paramsMerge); zephir_fast_array_merge(paramsMerge, &(params), &(parts) TSRMLS_CC); } else { ZEPHIR_CPY_WRT(paramsMerge, parts); } zephir_update_property_this(this_ptr, SL("_params"), paramsMerge TSRMLS_CC); } else { _5 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultNamespace"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_namespace"), _5 TSRMLS_CC); _12 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultModule"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_module"), _12 TSRMLS_CC); _13 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultController"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_controller"), _13 TSRMLS_CC); _14 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAction"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_action"), _14 TSRMLS_CC); _15 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultParams"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_params"), _15 TSRMLS_CC); } ZEPHIR_MM_RESTORE(); }
/** * 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); }
/** * Gets the column name in SQLite */ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, getColumnDefinition) { zephir_fcall_cache_entry *_7 = NULL; HashTable *_4; HashPosition _3; int ZEPHIR_LAST_CALL_STATUS; zval *column, *columnSql, *type = NULL, *typeValues = NULL, *_0 = NULL, *_1 = NULL, *_2 = NULL, *value = NULL, *valueSql, **_5, _6 = zval_used_for_init, _8 = zval_used_for_init, *_9, *_10 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &column); ZEPHIR_INIT_VAR(columnSql); ZVAL_STRING(columnSql, "", 1); ZEPHIR_CALL_METHOD(&type, column, "gettype", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(type) == IS_STRING) { zephir_concat_self(&columnSql, type TSRMLS_CC); ZEPHIR_CALL_METHOD(&type, column, "gettypereference", NULL, 0); zephir_check_call_status(); } do { if (ZEPHIR_IS_LONG(type, 0)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("INT") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(type, 1)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("DATE") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(type, 2)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("VARCHAR") TSRMLS_CC); } ZEPHIR_CALL_METHOD(&_0, column, "getsize", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(_1); ZEPHIR_CONCAT_SVS(_1, "(", _0, ")"); zephir_concat_self(&columnSql, _1 TSRMLS_CC); break; } if (ZEPHIR_IS_LONG(type, 3)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("NUMERIC") TSRMLS_CC); } ZEPHIR_CALL_METHOD(&_0, column, "getsize", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_2, column, "getscale", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_LNVAR(_1); ZEPHIR_CONCAT_SVSVS(_1, "(", _0, ",", _2, ")"); zephir_concat_self(&columnSql, _1 TSRMLS_CC); break; } if (ZEPHIR_IS_LONG(type, 4)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("TIMESTAMP") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(type, 5)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("CHARACTER") TSRMLS_CC); } ZEPHIR_CALL_METHOD(&_0, column, "getsize", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_LNVAR(_1); ZEPHIR_CONCAT_SVS(_1, "(", _0, ")"); zephir_concat_self(&columnSql, _1 TSRMLS_CC); break; } if (ZEPHIR_IS_LONG(type, 6)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("TEXT") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(type, 7)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("FLOAT") TSRMLS_CC); } break; } if (ZEPHIR_IS_EMPTY(columnSql)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Unrecognized SQLite data type", "phalcon/db/dialect/sqlite.zep", 112); return; } ZEPHIR_CALL_METHOD(&typeValues, column, "gettypevalues", NULL, 0); zephir_check_call_status(); if (!(ZEPHIR_IS_EMPTY(typeValues))) { if (Z_TYPE_P(typeValues) == IS_ARRAY) { ZEPHIR_INIT_VAR(valueSql); ZVAL_STRING(valueSql, "", 1); zephir_is_iterable(typeValues, &_4, &_3, 0, 0, "phalcon/db/dialect/sqlite.zep", 123); for ( ; zephir_hash_get_current_data_ex(_4, (void**) &_5, &_3) == SUCCESS ; zephir_hash_move_forward_ex(_4, &_3) ) { ZEPHIR_GET_HVALUE(value, _5); ZEPHIR_SINIT_NVAR(_6); ZVAL_STRING(&_6, "\"", 0); ZEPHIR_CALL_FUNCTION(&_0, "addcslashes", &_7, 109, value, &_6); zephir_check_call_status(); ZEPHIR_INIT_LNVAR(_1); ZEPHIR_CONCAT_SVS(_1, "\"", _0, "\", "); zephir_concat_self(&valueSql, _1 TSRMLS_CC); } ZEPHIR_SINIT_NVAR(_6); ZVAL_LONG(&_6, 0); ZEPHIR_SINIT_VAR(_8); ZVAL_LONG(&_8, -2); ZEPHIR_INIT_VAR(_9); zephir_substr(_9, valueSql, 0 , -2 , 0); ZEPHIR_INIT_VAR(_10); ZEPHIR_CONCAT_SVS(_10, "(", _9, ")"); zephir_concat_self(&columnSql, _10 TSRMLS_CC); } else { ZEPHIR_SINIT_NVAR(_8); ZVAL_STRING(&_8, "\"", 0); ZEPHIR_CALL_FUNCTION(&_2, "addcslashes", &_7, 109, typeValues, &_8); zephir_check_call_status(); ZEPHIR_INIT_LNVAR(_10); ZEPHIR_CONCAT_SVS(_10, "(\"", _2, "\")"); zephir_concat_self(&columnSql, _10 TSRMLS_CC); } } } while(0); RETURN_CCTOR(columnSql); }
/** * Registers a set of PSR-0 directories for a given prefix, either * appending or prepending to the ones previously set for this prefix. * * @param string $prefix The prefix * @param array|string $paths The PSR-0 root directories * @param bool $prepend Whether to prepend the directories */ PHP_METHOD(Xpl_ClassLoader, add) { zend_bool prepend; zval *prefix, *paths = NULL, *prepend_param = NULL, *firstChar = NULL, *prefixPaths = NULL, _4, _5, *_6, *_7, *_0$$5, *_1$$5, *_2$$6, *_3$$6, *_8$$9, *_9$$10; 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("fallbackDirsPsr0"), PH_NOISY_CC); zephir_fast_array_merge(_0$$5, &(paths), &(_1$$5) TSRMLS_CC); zephir_update_property_this(this_ptr, SL("fallbackDirsPsr0"), _0$$5 TSRMLS_CC); } else { ZEPHIR_INIT_VAR(_2$$6); _3$$6 = zephir_fetch_nproperty_this(this_ptr, SL("fallbackDirsPsr0"), PH_NOISY_CC); zephir_fast_array_merge(_2$$6, &(_3$$6), &(paths) TSRMLS_CC); zephir_update_property_this(this_ptr, SL("fallbackDirsPsr0"), _2$$6 TSRMLS_CC); } RETURN_MM_NULL(); } ZEPHIR_SINIT_VAR(_4); ZVAL_LONG(&_4, 0); ZEPHIR_SINIT_VAR(_5); ZVAL_LONG(&_5, 1); ZEPHIR_INIT_VAR(firstChar); zephir_substr(firstChar, prefix, 0 , 1 , 0); ZEPHIR_OBS_VAR(prefixPaths); _6 = zephir_fetch_nproperty_this(this_ptr, SL("prefixesPsr0"), PH_NOISY_CC); zephir_array_fetch(&_7, _6, firstChar, PH_READONLY, "xpl/classloader.zep", 262 TSRMLS_CC); if (!(zephir_array_isset_fetch(&prefixPaths, _7, prefix, 0 TSRMLS_CC))) { ZEPHIR_CPY_WRT(prefixPaths, paths); } else { if (prepend) { ZEPHIR_INIT_VAR(_8$$9); zephir_fast_array_merge(_8$$9, &(paths), &(prefixPaths) TSRMLS_CC); ZEPHIR_CPY_WRT(prefixPaths, _8$$9); } else { ZEPHIR_INIT_VAR(_9$$10); zephir_fast_array_merge(_9$$10, &(prefixPaths), &(paths) TSRMLS_CC); ZEPHIR_CPY_WRT(prefixPaths, _9$$10); } } zephir_update_property_array_multi(this_ptr, SL("prefixesPsr0"), &prefixPaths TSRMLS_CC, SL("zz"), 2, firstChar, prefix); ZEPHIR_MM_RESTORE(); }
/** * @return mixed */ PHP_METHOD(Lynx_Annotation_RegexDocParser, parseValue) { int ZEPHIR_LAST_CALL_STATUS; zephir_nts_static zephir_fcall_cache_entry *_14 = NULL; HashTable *_11; HashPosition _10; zend_bool _3, _15, _20; zval *value, *val = NULL, *vals, *v = NULL, _0, _1, *_2, _4, *_5, _6 = zval_used_for_init, _7 = zval_used_for_init, *_8 = NULL, _9 = zval_used_for_init, **_12, *_13 = NULL, *_16, _17, _18, *_19, _21, *_22, _23, _24, *_25 = NULL, *_26; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &value); ZEPHIR_INIT_VAR(val); zephir_fast_trim(val, value, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC); ZEPHIR_SINIT_VAR(_0); ZVAL_LONG(&_0, 0); ZEPHIR_SINIT_VAR(_1); ZVAL_LONG(&_1, 1); ZEPHIR_INIT_VAR(_2); zephir_substr(_2, val, 0 , 1 , 0); _3 = ZEPHIR_IS_STRING(_2, "["); if (_3) { ZEPHIR_SINIT_VAR(_4); ZVAL_LONG(&_4, -1); ZEPHIR_INIT_VAR(_5); zephir_substr(_5, val, -1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); _3 = ZEPHIR_IS_STRING(_5, "]"); } if (_3) { ZEPHIR_INIT_VAR(vals); ZEPHIR_SINIT_VAR(_6); ZVAL_LONG(&_6, 1); ZEPHIR_SINIT_VAR(_7); ZVAL_LONG(&_7, -1); ZEPHIR_INIT_VAR(_8); zephir_substr(_8, val, 1 , -1 , 0); ZEPHIR_SINIT_VAR(_9); ZVAL_LONG(&_9, ','); zephir_fast_explode(vals, &_9, _8, LONG_MAX TSRMLS_CC); ZEPHIR_INIT_NVAR(val); array_init(val); zephir_is_iterable(vals, &_11, &_10, 0, 0, "lynx/Annotation/RegexDocParser.zep", 89); for ( ; zephir_hash_get_current_data_ex(_11, (void**) &_12, &_10) == SUCCESS ; zephir_hash_move_forward_ex(_11, &_10) ) { ZEPHIR_GET_HVALUE(v, _12); ZEPHIR_CALL_SELF(&_13, "parsevalue", &_14, v); zephir_check_call_status(); zephir_array_append(&val, _13, PH_SEPARATE, "lynx/Annotation/RegexDocParser.zep", 86); } RETURN_CCTOR(val); } else { ZEPHIR_SINIT_NVAR(_6); ZVAL_LONG(&_6, 0); ZEPHIR_SINIT_NVAR(_7); ZVAL_LONG(&_7, 1); ZEPHIR_INIT_NVAR(_8); zephir_substr(_8, val, 0 , 1 , 0); _15 = ZEPHIR_IS_STRING(_8, "{"); if (_15) { ZEPHIR_SINIT_NVAR(_9); ZVAL_LONG(&_9, -1); ZEPHIR_INIT_VAR(_16); zephir_substr(_16, val, -1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); _15 = ZEPHIR_IS_STRING(_16, "}"); } if (_15) { zephir_json_decode(return_value, &(return_value), val, 0 TSRMLS_CC); RETURN_MM(); } else { ZEPHIR_SINIT_VAR(_17); ZVAL_LONG(&_17, 0); ZEPHIR_SINIT_VAR(_18); ZVAL_LONG(&_18, 1); ZEPHIR_INIT_VAR(_19); zephir_substr(_19, val, 0 , 1 , 0); _20 = ZEPHIR_IS_STRING(_19, "\""); if (_20) { ZEPHIR_SINIT_VAR(_21); ZVAL_LONG(&_21, -1); ZEPHIR_INIT_VAR(_22); zephir_substr(_22, val, -1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); _20 = ZEPHIR_IS_STRING(_22, "\""); } if (_20) { ZEPHIR_SINIT_VAR(_23); ZVAL_LONG(&_23, 1); ZEPHIR_SINIT_VAR(_24); ZVAL_LONG(&_24, -1); ZEPHIR_INIT_VAR(_25); zephir_substr(_25, val, 1 , -1 , 0); ZEPHIR_CPY_WRT(val, _25); ZEPHIR_RETURN_CALL_SELF("parsevalue", &_14, val); zephir_check_call_status(); RETURN_MM(); } else { ZEPHIR_INIT_NVAR(_25); zephir_fast_strtolower(_25, val); if (ZEPHIR_IS_STRING(_25, "true")) { RETURN_MM_BOOL(1); } else { ZEPHIR_INIT_VAR(_26); zephir_fast_strtolower(_26, val); if (ZEPHIR_IS_STRING(_26, "false")) { RETURN_MM_BOOL(0); } else { if (zephir_is_numeric(val)) { if (zephir_get_doubleval(val) == zephir_get_intval(val)) { RETURN_MM_LONG(zephir_get_intval(val)); } else { RETURN_MM_DOUBLE(zephir_get_doubleval(val)); } } } } } } } RETURN_CCTOR(val); }
/** * 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(); }
/** * 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; int 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 (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 int") 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 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, 134, 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, 132, &_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, 133, _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, 134, 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, 132, &_16$$8); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_16$$8); ZVAL_LONG(&_16$$8, paddingSize); ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_11, 133, _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, 134, 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(); }
/** * 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(); }