PHP_METHOD(Test_TryTest, testTry10) { zephir_nts_static zephir_fcall_cache_entry *_0 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *e = NULL; ZEPHIR_MM_GROW(); /* try_start_1: */ ZEPHIR_CALL_METHOD(NULL, this_ptr, "somemethod2", &_0); zephir_check_call_status_or_jump(try_end_1); RETURN_MM_STRING("not catched", 1); try_end_1: if (EG(exception)) { ZEPHIR_CPY_WRT(e, EG(exception)); if (zephir_instance_of_ev(e, spl_ce_RuntimeException TSRMLS_CC)) { zend_clear_exception(TSRMLS_C); RETURN_MM_STRING("domain error", 1); } } RETURN_MM_BOOL(0); }
PHP_METHOD(Test_TryTest, testTry10) { zval e; int ZEPHIR_LAST_CALL_STATUS; zval this_zv; zval *this_ptr = getThis(); if (EXPECTED(this_ptr)) { ZVAL_OBJ(&this_zv, Z_OBJ_P(this_ptr)); this_ptr = &this_zv; } else this_ptr = NULL; ZVAL_UNDEF(&e); ZEPHIR_MM_GROW(); /* try_start_1: */ ZEPHIR_CALL_METHOD(NULL, this_ptr, "somemethod2", NULL, 77); zephir_check_call_status_or_jump(try_end_1); RETURN_MM_STRING("not catched"); try_end_1: if (EG(exception)) { ZVAL_OBJ(&e, EG(exception)); Z_ADDREF_P(&e); if (zephir_instance_of_ev(&e, spl_ce_RuntimeException TSRMLS_CC)) { zend_clear_exception(TSRMLS_C); RETURN_MM_STRING("domain error"); } } RETURN_MM_BOOL(0); }
PHP_METHOD(Test_TryTest, testTry4) { zephir_nts_static zephir_fcall_cache_entry *_2 = NULL, *_3 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *a_param = NULL, *_0 = NULL, *_1 = NULL; zend_bool a; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &a_param); a = zephir_get_boolval(a_param); /* try_start_1: */ if (a) { ZEPHIR_INIT_VAR(_0); object_init_ex(_0, zend_exception_get_default(TSRMLS_C)); ZEPHIR_INIT_VAR(_1); ZVAL_STRING(_1, "error!", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _0, "__construct", &_2, _1); zephir_check_temp_parameter(_1); zephir_check_call_status_or_jump(try_end_1); zephir_throw_exception_debug(_0, "test/trytest.zep", 46 TSRMLS_CC); goto try_end_1; } else { ZEPHIR_INIT_NVAR(_0); object_init_ex(_0, spl_ce_RuntimeException); ZEPHIR_INIT_NVAR(_1); ZVAL_STRING(_1, "error!", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _0, "__construct", &_3, _1); zephir_check_temp_parameter(_1); zephir_check_call_status_or_jump(try_end_1); zephir_throw_exception_debug(_0, "test/trytest.zep", 48 TSRMLS_CC); goto try_end_1; } try_end_1: if (EG(exception)) { ZEPHIR_INIT_NVAR(_0); ZEPHIR_CPY_WRT(_0, EG(exception)); if (zephir_instance_of_ev(_0, spl_ce_RuntimeException TSRMLS_CC)) { zend_clear_exception(TSRMLS_C); RETURN_MM_STRING("domain error", 1); } ZEPHIR_INIT_NVAR(_0); ZEPHIR_CPY_WRT(_0, EG(exception)); if (zephir_instance_of_ev(_0, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) { zend_clear_exception(TSRMLS_C); RETURN_MM_STRING("error", 1); } } RETURN_MM_BOOL(0); }
/** * Produces an string representation of a variable */ PHP_METHOD(Phalcon_Debug, _getVarDump) { zephir_fcall_cache_entry *_3 = NULL; int ZEPHIR_LAST_CALL_STATUS; zephir_nts_static zephir_fcall_cache_entry *_1 = NULL; zval *variable, *className, *dumpedObject = NULL, *dump, *_0 = NULL, *_2 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &variable); ZEPHIR_CALL_FUNCTION(&_0, "is_scalar", &_1, variable); zephir_check_call_status(); if (zephir_is_true(_0)) { if (Z_TYPE_P(variable) == IS_BOOL) { if (zephir_is_true(variable)) { RETURN_MM_STRING("true", 1); } else { RETURN_MM_STRING("false", 1); } } if (Z_TYPE_P(variable) == IS_STRING) { ZEPHIR_RETURN_CALL_METHOD(this_ptr, "_escapestring", NULL, variable); zephir_check_call_status(); RETURN_MM(); } RETVAL_ZVAL(variable, 1, 0); RETURN_MM(); } if (Z_TYPE_P(variable) == IS_OBJECT) { ZEPHIR_INIT_VAR(className); zephir_get_class(className, variable, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(dump); if ((zephir_method_exists_ex(variable, SS("dump") TSRMLS_CC) == SUCCESS)) { ZEPHIR_CALL_METHOD(&dumpedObject, variable, "dump", NULL); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_2, this_ptr, "_getarraydump", &_3, dumpedObject); zephir_check_call_status(); ZEPHIR_CONCAT_SVSVS(dump, "Object(", className, ": ", _2, ")"); } else { ZEPHIR_CONCAT_SVS(dump, "Object(", className, ")</span>"); } RETURN_CCTOR(dump); } if (Z_TYPE_P(variable) == IS_ARRAY) { ZEPHIR_CALL_METHOD(&_2, this_ptr, "_getarraydump", &_3, variable); zephir_check_call_status(); ZEPHIR_CONCAT_SVS(return_value, "Array(", _2, ")"); RETURN_MM(); } if (Z_TYPE_P(variable) == IS_NULL) { RETURN_MM_STRING("null", 1); } zephir_gettype(return_value, variable TSRMLS_CC); RETURN_MM(); }
PHP_METHOD(Test_TryTest, testTry7) { int ZEPHIR_LAST_CALL_STATUS; zval *a_param = NULL, *e = NULL, *_0 = NULL, *_1 = NULL; zend_bool a; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &a_param); a = zephir_get_boolval(a_param); /* try_start_1: */ if (a) { ZEPHIR_INIT_VAR(_0); object_init_ex(_0, zend_exception_get_default(TSRMLS_C)); ZEPHIR_INIT_VAR(_1); ZVAL_STRING(_1, "error!", 0); ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, _1); zephir_check_temp_parameter(_1); zephir_check_call_status_or_jump(try_end_1); zephir_throw_exception_debug(_0, "test/trytest.zep", 99 TSRMLS_CC); goto try_end_1; } else { ZEPHIR_INIT_LNVAR(_0); object_init_ex(_0, spl_ce_RuntimeException); ZEPHIR_INIT_NVAR(_1); ZVAL_STRING(_1, "error!", 0); ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, _1); zephir_check_temp_parameter(_1); zephir_check_call_status_or_jump(try_end_1); zephir_throw_exception_debug(_0, "test/trytest.zep", 101 TSRMLS_CC); goto try_end_1; } try_end_1: if (EG(exception)) { ZEPHIR_CPY_WRT(e, EG(exception)); if (zephir_instance_of_ev(e, spl_ce_RuntimeException TSRMLS_CC)) { zend_clear_exception(TSRMLS_C); RETURN_MM_STRING("any error", 1); } if (zephir_instance_of_ev(e, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) { zend_clear_exception(TSRMLS_C); RETURN_MM_STRING("any error", 1); } } }
/** * Returns an option * * @param string option * @return mixed */ PHP_METHOD(Phalcon_Mvc_Model_Validator, getOption) { zval *option_param = NULL, *options, *value; zval *option = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &option_param); if (unlikely(Z_TYPE_P(option_param) != IS_STRING && Z_TYPE_P(option_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'option' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(option_param) == IS_STRING)) { zephir_get_strval(option, option_param); } else { ZEPHIR_INIT_VAR(option); ZVAL_EMPTY_STRING(option); } options = zephir_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY_CC); if (zephir_array_isset_fetch(&value, options, option, 1 TSRMLS_CC)) { RETURN_CTOR(value); } RETURN_MM_STRING("", 1); }
/** * Get default message for validator type * * @param string type */ PHP_METHOD(Phalcon_Validation, getDefaultMessage) { zval *type_param = NULL, *_0, *_1, *_2; zval *type = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &type_param); if (unlikely(Z_TYPE_P(type_param) != IS_STRING && Z_TYPE_P(type_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'type' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(type_param) == IS_STRING)) { zephir_get_strval(type, type_param); } else { ZEPHIR_INIT_VAR(type); ZVAL_EMPTY_STRING(type); } _0 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultMessages"), PH_NOISY_CC); if (!(zephir_array_isset(_0, type))) { RETURN_MM_STRING("", 1); } _1 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultMessages"), PH_NOISY_CC); zephir_array_fetch(&_2, _1, type, PH_NOISY | PH_READONLY, "phalcon/validation.zep", 278 TSRMLS_CC); RETURN_CTOR(_2); }
PHP_METHOD(Test_TryTest, testTry3) { int ZEPHIR_LAST_CALL_STATUS; zval *_0, *_1 = NULL; ZEPHIR_MM_GROW(); /* try_start_1: */ ZEPHIR_INIT_VAR(_0); object_init_ex(_0, zend_exception_get_default(TSRMLS_C)); ZEPHIR_INIT_VAR(_1); ZVAL_STRING(_1, "error!", 0); ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, _1); zephir_check_temp_parameter(_1); zephir_check_call_status_or_jump(try_end_1); zephir_throw_exception_debug(_0, "test/trytest.zep", 34 TSRMLS_CC); goto try_end_1; try_end_1: if (EG(exception)) { ZEPHIR_INIT_NVAR(_1); ZEPHIR_CPY_WRT(_1, EG(exception)); if (zephir_instance_of_ev(_1, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) { zend_clear_exception(TSRMLS_C); RETURN_MM_STRING("error", 1); } } RETURN_MM_BOOL(0); }
/** * Generates the SQL to describe the table creation options */ PHP_METHOD(Phalcon_Db_Dialect_Oracle, tableOptions) { zval *table_param = NULL, *schema_param = NULL; zval *table = NULL, *schema = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &table_param, &schema_param); if (unlikely(Z_TYPE_P(table_param) != IS_STRING && Z_TYPE_P(table_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'table' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(table_param) == IS_STRING)) { zephir_get_strval(table, table_param); } else { ZEPHIR_INIT_VAR(table); ZVAL_EMPTY_STRING(table); } if (!schema_param) { ZEPHIR_INIT_VAR(schema); ZVAL_EMPTY_STRING(schema); } else { zephir_get_strval(schema, schema_param); } RETURN_MM_STRING("", 1); }
/** * List all tables in database * * <code> * print_r($dialect->listTables("blog")) * </code> */ PHP_METHOD(Phalcon_Db_Dialect_Oracle, listTables) { int ZEPHIR_LAST_CALL_STATUS; zephir_fcall_cache_entry *_1 = NULL; zval *schemaName_param = NULL, *_0 = NULL; zval *schemaName = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &schemaName_param); if (!schemaName_param) { ZEPHIR_INIT_VAR(schemaName); ZVAL_EMPTY_STRING(schemaName); } else { zephir_get_strval(schemaName, schemaName_param); } if (!ZEPHIR_IS_STRING(schemaName, "")) { ZEPHIR_CALL_CE_STATIC(&_0, phalcon_text_ce, "upper", &_1, 144, schemaName); zephir_check_call_status(); ZEPHIR_CONCAT_SVS(return_value, "SELECT TABLE_NAME, OWNER FROM ALL_TABLES WHERE OWNER='", _0, "' ORDER BY OWNER, TABLE_NAME"); RETURN_MM(); } RETURN_MM_STRING("SELECT TABLE_NAME, OWNER FROM ALL_TABLES ORDER BY OWNER, TABLE_NAME", 1); }
/** * Get rewrite info. This info is read from $_GET['_url']. This returns '/' if the rewrite information cannot be read * * @return string */ PHP_METHOD(Test_Router, getRewriteUri) { zval *url = NULL, *urlParts, *realUri, *_0, *_GET, *_SERVER; ZEPHIR_MM_GROW(); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_uriSource"), PH_NOISY_CC); if (!(zephir_is_true(_0))) { ZEPHIR_OBS_VAR(url); zephir_get_global(&_GET, SS("_GET") TSRMLS_CC); if (zephir_array_isset_string_fetch(&url, _GET, SS("_url"), 0 TSRMLS_CC)) { if (!(zephir_is_true(url))) { RETURN_CCTOR(url); } } } else { ZEPHIR_OBS_NVAR(url); zephir_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC); if (zephir_array_isset_string_fetch(&url, _SERVER, SS("REQUEST_URI"), 0 TSRMLS_CC)) { ZEPHIR_INIT_VAR(urlParts); zephir_fast_explode_str(urlParts, SL("?"), url, LONG_MAX TSRMLS_CC); zephir_array_fetch_long(&realUri, urlParts, 0, PH_NOISY | PH_READONLY TSRMLS_CC); if (!(zephir_is_true(realUri))) { RETURN_CTOR(realUri); } } } RETURN_MM_STRING("/", 1); }
/** * Get style for type */ PHP_METHOD(Phalcon_Debug_Dump, getStyle) { zval *type_param = NULL, *style = NULL, *_0; zval *type = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &type_param); if (unlikely(Z_TYPE_P(type_param) != IS_STRING && Z_TYPE_P(type_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'type' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(type_param) == IS_STRING)) { zephir_get_strval(type, type_param); } else { ZEPHIR_INIT_VAR(type); ZVAL_EMPTY_STRING(type); } _0 = zephir_fetch_nproperty_this(this_ptr, SL("_styles"), PH_NOISY_CC); if (zephir_array_isset_fetch(&style, _0, type, 1 TSRMLS_CC)) { RETURN_CTOR(style); } else { RETURN_MM_STRING("color:gray", 1); } }
/** * Get default message for validator type */ PHP_METHOD(Phalcon_Validation, getDefaultMessage) { zval *type_param = NULL, *defaultMessage = NULL, *_0; zval *type = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &type_param); if (UNEXPECTED(Z_TYPE_P(type_param) != IS_STRING && Z_TYPE_P(type_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'type' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (EXPECTED(Z_TYPE_P(type_param) == IS_STRING)) { zephir_get_strval(type, type_param); } else { ZEPHIR_INIT_VAR(type); ZVAL_EMPTY_STRING(type); } _0 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultMessages"), PH_NOISY_CC); if (zephir_array_isset_fetch(&defaultMessage, _0, type, 1 TSRMLS_CC)) { RETURN_CTOR(defaultMessage); } RETURN_MM_STRING("", 1); }
/** * List all tables in database * *<code> * print_r($dialect->listTables("blog")) *</code> */ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, listTables) { zval *schemaName_param = NULL; zval *schemaName = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &schemaName_param); if (!schemaName_param) { ZEPHIR_INIT_VAR(schemaName); ZVAL_EMPTY_STRING(schemaName); } else { if (unlikely(Z_TYPE_P(schemaName_param) != IS_STRING && Z_TYPE_P(schemaName_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'schemaName' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(schemaName_param) == IS_STRING)) { zephir_get_strval(schemaName, schemaName_param); } else { ZEPHIR_INIT_VAR(schemaName); ZVAL_EMPTY_STRING(schemaName); } } RETURN_MM_STRING("SELECT tbl_name FROM sqlite_master WHERE type = 'table' ORDER BY tbl_name", 1); }
PHP_METHOD(Yb_Std, randString) { zephir_fcall_cache_entry *_9 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *charList = NULL, *result; zval *len_param = NULL, *charList_param = NULL, *_0 = NULL, _1, *_2 = NULL, _3$$5 = zval_used_for_init, _4$$5 = zval_used_for_init, _5$$5 = zval_used_for_init, _6$$5 = zval_used_for_init, _7$$5 = zval_used_for_init, *_8$$5 = NULL; long len, maxIndex = 0; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &len_param, &charList_param); len = zephir_get_intval(len_param); if (!charList_param) { ZEPHIR_INIT_VAR(charList); ZVAL_STRING(charList, "", 1); } else { zephir_get_strval(charList, charList_param); } ZEPHIR_INIT_VAR(result); ZVAL_EMPTY_STRING(result); if (unlikely(len < 1)) { RETURN_MM_STRING("", 1); } if (zephir_fast_strlen_ev(charList) < 1) { ZEPHIR_INIT_NVAR(charList); ZVAL_STRING(charList, "0123456789abcdefghijklmnopqrstuvwxyz", 1); } ZEPHIR_SINIT_VAR(_1); ZVAL_STRING(&_1, "UTF-8", 0); ZEPHIR_CALL_FUNCTION(&_2, "mb_strlen", NULL, 51, charList, &_1); zephir_check_call_status(); maxIndex = (zephir_get_intval(_2) - 1); while (1) { if (!(len)) { break; } len--; ZEPHIR_SINIT_NVAR(_3$$5); ZVAL_LONG(&_3$$5, 0); ZEPHIR_SINIT_NVAR(_4$$5); ZVAL_LONG(&_4$$5, maxIndex); ZEPHIR_SINIT_NVAR(_5$$5); ZVAL_LONG(&_5$$5, zephir_mt_rand(zephir_get_intval(&_3$$5), zephir_get_intval(&_4$$5) TSRMLS_CC)); ZEPHIR_SINIT_NVAR(_6$$5); ZVAL_LONG(&_6$$5, 1); ZEPHIR_SINIT_NVAR(_7$$5); ZVAL_STRING(&_7$$5, "UTF-8", 0); ZEPHIR_CALL_FUNCTION(&_8$$5, "mb_substr", &_9, 54, charList, &_5$$5, &_6$$5, &_7$$5); zephir_check_call_status(); zephir_concat_self(&result, _8$$5 TSRMLS_CC); } RETURN_CTOR(result); }
PHP_METHOD(Test_Returns, returnWithParameter) { zval *parameter_param = NULL; zval parameter; zval *this_ptr = getThis(); ZVAL_UNDEF(¶meter); ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, ¶meter_param); zephir_get_strval(¶meter, parameter_param); RETURN_MM_STRING("Return back"); }
PHP_METHOD(Test_TryTest, testTry3) { zval _0$$3, _1$$3, _2; int ZEPHIR_LAST_CALL_STATUS; zval this_zv; zval *this_ptr = getThis(); if (EXPECTED(this_ptr)) { ZVAL_OBJ(&this_zv, Z_OBJ_P(this_ptr)); this_ptr = &this_zv; } else this_ptr = NULL; ZVAL_UNDEF(&_0$$3); ZVAL_UNDEF(&_1$$3); ZVAL_UNDEF(&_2); ZEPHIR_MM_GROW(); /* try_start_1: */ ZEPHIR_INIT_VAR(&_0$$3); object_init_ex(&_0$$3, zend_exception_get_default(TSRMLS_C)); ZEPHIR_INIT_VAR(&_1$$3); ZVAL_STRING(&_1$$3, "error!"); ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 24, &_1$$3); zephir_check_call_status_or_jump(try_end_1); zephir_throw_exception_debug(&_0$$3, "test/trytest.zep", 34 TSRMLS_CC); goto try_end_1; try_end_1: if (EG(exception)) { ZEPHIR_INIT_VAR(&_2); ZVAL_OBJ(&_2, EG(exception)); Z_ADDREF_P(&_2); if (zephir_instance_of_ev(&_2, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) { zend_clear_exception(TSRMLS_C); RETURN_MM_STRING("error"); } } RETURN_MM_BOOL(0); }
/** * List all tables in database * * <code> * print_r($dialect->listTables("blog")) * </code> */ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, listTables) { zval *schemaName_param = NULL; zval *schemaName = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &schemaName_param); if (!schemaName_param) { ZEPHIR_INIT_VAR(schemaName); ZVAL_EMPTY_STRING(schemaName); } else { zephir_get_strval(schemaName, schemaName_param); } RETURN_MM_STRING("SELECT tbl_name FROM sqlite_master WHERE type = 'table' ORDER BY tbl_name", 1); }
PHP_METHOD(Yb_Std, renderScript) { int ZEPHIR_LAST_CALL_STATUS; zval *data = NULL; zval *path_param = NULL, *data_param = NULL, *ex = NULL; zval *path = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &path_param, &data_param); zephir_get_strval(path, path_param); zephir_get_arrval(data, data_param); ZEPHIR_CALL_FUNCTION(NULL, "ob_start", NULL, 23); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(NULL, "ob_implicit_flush", NULL, 24, ZEPHIR_GLOBAL(global_false)); zephir_check_call_status(); /* try_start_1: */ ZEPHIR_CALL_SELF(NULL, "outputscript", NULL, 0, path, data); zephir_check_call_status_or_jump(try_end_1); ZEPHIR_RETURN_CALL_FUNCTION("ob_get_clean", NULL, 25); zephir_check_call_status_or_jump(try_end_1); RETURN_MM(); try_end_1: if (EG(exception)) { ZEPHIR_CPY_WRT(ex, EG(exception)); if (zephir_instance_of_ev(ex, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) { zend_clear_exception(TSRMLS_C); ZEPHIR_CALL_FUNCTION(NULL, "ob_end_clean", NULL, 26); zephir_check_call_status(); zephir_throw_exception_debug(ex, "yb/std.zep", 442 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } } RETURN_MM_STRING("", 1); }
/** * Gets the real mime type of the upload file using finfo */ PHP_METHOD(Phalcon_Http_Request_File, getRealType) { zval *finfo = NULL, *mime = NULL, _0, *_1; int ZEPHIR_LAST_CALL_STATUS; ZEPHIR_MM_GROW(); ZEPHIR_SINIT_VAR(_0); ZVAL_LONG(&_0, 16); ZEPHIR_CALL_FUNCTION(&finfo, "finfo_open", NULL, 243, &_0); zephir_check_call_status(); if (Z_TYPE_P(finfo) != IS_RESOURCE) { RETURN_MM_STRING("", 1); } _1 = zephir_fetch_nproperty_this(this_ptr, SL("_tmp"), PH_NOISY_CC); ZEPHIR_CALL_FUNCTION(&mime, "finfo_file", NULL, 244, finfo, _1); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(NULL, "finfo_close", NULL, 245, finfo); zephir_check_call_status(); RETURN_CCTOR(mime); }
PHP_METHOD(Fox_MsgCrypt, decrypt) { zephir_fcall_cache_entry *_6 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *encrypted, *ciphertext_dec = NULL, *module = NULL, *iv = NULL, *decrypted = NULL, *e = NULL, *pkc_encoder = NULL, *result = NULL, *content = NULL, *len_list = NULL, *xml_len = NULL, *xml_content = NULL, *from_appid = NULL, *_18, *_21, *_22, _0$$3 = zval_used_for_init, _1$$3 = zval_used_for_init, _2$$3, _3$$3, *_4$$3, *_5$$3, *_7$$4, *_8$$4, _9$$5, _10$$5, _11$$5, _12$$5, *_13$$5, _14$$5 = zval_used_for_init, _15$$5, *_16$$7, *_17$$7, *_19$$8, *_20$$8; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &encrypted); /* try_start_1: */ ZEPHIR_CALL_FUNCTION(&ciphertext_dec, "base64_decode", NULL, 12, encrypted); zephir_check_call_status_or_jump(try_end_1); ZEPHIR_SINIT_VAR(_0$$3); ZVAL_STRING(&_0$$3, "rijndael-128", 0); ZEPHIR_SINIT_VAR(_1$$3); ZVAL_STRING(&_1$$3, "", 0); ZEPHIR_SINIT_VAR(_2$$3); ZVAL_STRING(&_2$$3, "cbc", 0); ZEPHIR_SINIT_VAR(_3$$3); ZVAL_STRING(&_3$$3, "", 0); ZEPHIR_CALL_FUNCTION(&module, "mcrypt_module_open", NULL, 4, &_0$$3, &_1$$3, &_2$$3, &_3$$3); zephir_check_call_status_or_jump(try_end_1); _4$$3 = zephir_fetch_nproperty_this(this_ptr, SL("appkey"), PH_NOISY_CC); ZEPHIR_SINIT_NVAR(_0$$3); ZVAL_LONG(&_0$$3, 0); ZEPHIR_SINIT_NVAR(_1$$3); ZVAL_LONG(&_1$$3, 16); ZEPHIR_INIT_VAR(iv); zephir_substr(iv, _4$$3, 0 , 16 , 0); _5$$3 = zephir_fetch_nproperty_this(this_ptr, SL("appkey"), PH_NOISY_CC); ZEPHIR_CALL_FUNCTION(NULL, "mcrypt_generic_init", NULL, 6, module, _5$$3, iv); zephir_check_call_status_or_jump(try_end_1); ZEPHIR_CALL_FUNCTION(&decrypted, "mdecrypt_generic", NULL, 13, module, ciphertext_dec); zephir_check_call_status_or_jump(try_end_1); ZEPHIR_CALL_FUNCTION(NULL, "mcrypt_generic_deinit", NULL, 8, module); zephir_check_call_status_or_jump(try_end_1); ZEPHIR_CALL_FUNCTION(NULL, "mcrypt_module_close", NULL, 9, module); zephir_check_call_status_or_jump(try_end_1); try_end_1: if (EG(exception)) { ZEPHIR_CPY_WRT(e, EG(exception)); if (zephir_instance_of_ev(e, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) { zend_clear_exception(TSRMLS_C); ZEPHIR_INIT_VAR(_7$$4); ZVAL_BOOL(_7$$4, 0); ZEPHIR_INIT_VAR(_8$$4); ZVAL_STRING(_8$$4, "DecryptAESError", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_RETURN_CALL_CE_STATIC(fox_common_ce, "rtn", &_6, 10, _7$$4, _8$$4); zephir_check_temp_parameter(_8$$4); zephir_check_call_status(); RETURN_MM(); } } /* try_start_2: */ ZEPHIR_INIT_VAR(pkc_encoder); object_init_ex(pkc_encoder, fox_pkcs7encoder_ce); if (zephir_has_constructor(pkc_encoder TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, pkc_encoder, "__construct", NULL, 0); zephir_check_call_status_or_jump(try_end_1); } ZEPHIR_CALL_METHOD(&result, pkc_encoder, "decode", NULL, 14, decrypted); zephir_check_call_status_or_jump(try_end_1); if (zephir_fast_strlen_ev(result) < 16) { RETURN_MM_STRING("", 1); } ZEPHIR_SINIT_VAR(_9$$5); ZVAL_LONG(&_9$$5, 16); ZEPHIR_SINIT_VAR(_10$$5); ZVAL_LONG(&_10$$5, zephir_fast_strlen_ev(result)); ZEPHIR_INIT_VAR(content); zephir_substr(content, result, 16 , zephir_get_intval(&_10$$5), 0); ZEPHIR_SINIT_VAR(_11$$5); ZVAL_LONG(&_11$$5, 0); ZEPHIR_SINIT_VAR(_12$$5); ZVAL_LONG(&_12$$5, 4); ZEPHIR_INIT_VAR(_13$$5); zephir_substr(_13$$5, content, 0 , 4 , 0); ZEPHIR_SINIT_VAR(_14$$5); ZVAL_STRING(&_14$$5, "N", 0); ZEPHIR_CALL_FUNCTION(&len_list, "unpack", NULL, 15, &_14$$5, _13$$5); zephir_check_call_status_or_jump(try_end_1); ZEPHIR_OBS_VAR(xml_len); zephir_array_fetch_long(&xml_len, len_list, 1, PH_NOISY, "fox/MsgCrypt.zep", 86 TSRMLS_CC); ZEPHIR_SINIT_NVAR(_14$$5); ZVAL_LONG(&_14$$5, 4); ZEPHIR_INIT_VAR(xml_content); zephir_substr(xml_content, content, 4 , zephir_get_intval(xml_len), 0); ZEPHIR_SINIT_VAR(_15$$5); ZVAL_LONG(&_15$$5, (zephir_get_numberval(xml_len) + 4)); ZEPHIR_INIT_VAR(from_appid); zephir_substr(from_appid, content, zephir_get_intval(&_15$$5), 0, ZEPHIR_SUBSTR_NO_LENGTH); try_end_2: if (EG(exception)) { ZEPHIR_CPY_WRT(e, EG(exception)); if (zephir_instance_of_ev(e, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) { zend_clear_exception(TSRMLS_C); ZEPHIR_INIT_VAR(_16$$7); ZVAL_BOOL(_16$$7, 0); ZEPHIR_INIT_VAR(_17$$7); ZVAL_STRING(_17$$7, "IllegalBuffer", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_RETURN_CALL_CE_STATIC(fox_common_ce, "rtn", &_6, 10, _16$$7, _17$$7); zephir_check_temp_parameter(_17$$7); zephir_check_call_status(); RETURN_MM(); } } _18 = zephir_fetch_nproperty_this(this_ptr, SL("appid"), PH_NOISY_CC); if (!ZEPHIR_IS_EQUAL(from_appid, _18)) { ZEPHIR_INIT_VAR(_19$$8); ZVAL_BOOL(_19$$8, 0); ZEPHIR_INIT_VAR(_20$$8); ZVAL_STRING(_20$$8, "ValidateAppidError", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_RETURN_CALL_CE_STATIC(fox_common_ce, "rtn", &_6, 10, _19$$8, _20$$8); zephir_check_temp_parameter(_20$$8); zephir_check_call_status(); RETURN_MM(); } ZEPHIR_INIT_VAR(_21); ZVAL_BOOL(_21, 1); ZEPHIR_INIT_VAR(_22); ZVAL_STRING(_22, "OK", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_RETURN_CALL_CE_STATIC(fox_common_ce, "rtn", &_6, 10, _21, _22, xml_content); zephir_check_temp_parameter(_22); zephir_check_call_status(); RETURN_MM(); }
PHP_METHOD(Test_TryTest, testTry7) { int ZEPHIR_LAST_CALL_STATUS; zval *a_param = NULL, e, _0$$4, _1$$4, _2$$5, _3$$5; zend_bool a; zval this_zv; zval *this_ptr = getThis(); if (EXPECTED(this_ptr)) { ZVAL_OBJ(&this_zv, Z_OBJ_P(this_ptr)); this_ptr = &this_zv; } else this_ptr = NULL; ZVAL_UNDEF(&e); ZVAL_UNDEF(&_0$$4); ZVAL_UNDEF(&_1$$4); ZVAL_UNDEF(&_2$$5); ZVAL_UNDEF(&_3$$5); ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &a_param); a = zephir_get_boolval(a_param); /* try_start_1: */ if (a) { ZEPHIR_INIT_VAR(&_0$$4); object_init_ex(&_0$$4, zend_exception_get_default(TSRMLS_C)); ZEPHIR_INIT_VAR(&_1$$4); ZVAL_STRING(&_1$$4, "error!"); ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 24, &_1$$4); zephir_check_call_status_or_jump(try_end_1); zephir_throw_exception_debug(&_0$$4, "test/trytest.zep", 99 TSRMLS_CC); goto try_end_1; } else { ZEPHIR_INIT_VAR(&_2$$5); object_init_ex(&_2$$5, spl_ce_RuntimeException); ZEPHIR_INIT_VAR(&_3$$5); ZVAL_STRING(&_3$$5, "error!"); ZEPHIR_CALL_METHOD(NULL, &_2$$5, "__construct", NULL, 75, &_3$$5); zephir_check_call_status_or_jump(try_end_1); zephir_throw_exception_debug(&_2$$5, "test/trytest.zep", 101 TSRMLS_CC); goto try_end_1; } try_end_1: if (EG(exception)) { ZVAL_OBJ(&e, EG(exception)); Z_ADDREF_P(&e); if (zephir_instance_of_ev(&e, spl_ce_RuntimeException TSRMLS_CC)) { zend_clear_exception(TSRMLS_C); RETURN_MM_STRING("any error"); } if (zephir_instance_of_ev(&e, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) { zend_clear_exception(TSRMLS_C); RETURN_MM_STRING("any error"); } } }
/** * Produces an string representation of a variable * * @param mixed $variable * @return string */ PHP_METHOD(Phalcon_Debug, _getVarDump){ zval *variable, *class_name, *dumped_object; zval *array_dump = NULL, *dump = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &variable); if (PHALCON_IS_SCALAR(variable)) { /** * Boolean variables are represented as 'true'/'false' */ if (Z_TYPE_P(variable) == IS_BOOL) { if (zend_is_true(variable)) { RETURN_MM_STRING("true", 1); } else { RETURN_MM_STRING("false", 1); } } /** * String variables are escaped to avoid XSS injections */ if (Z_TYPE_P(variable) == IS_STRING) { phalcon_call_method_p1(return_value, this_ptr, "_escapestring", variable); RETURN_MM(); } /** * Other scalar variables are just converted to strings */ RETURN_CCTOR(variable); } /** * If the variable is an object print its class name */ if (Z_TYPE_P(variable) == IS_OBJECT) { PHALCON_INIT_VAR(class_name); phalcon_get_class(class_name, variable, 0 TSRMLS_CC); /** * Try to check for a 'dump' method, this surely produces a better printable * representation */ if (phalcon_method_exists_ex(variable, SS("dump") TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(dumped_object); phalcon_call_method(dumped_object, variable, "dump"); /** * dump() must return an array, generate a recursive representation using * getArrayDump */ PHALCON_INIT_VAR(array_dump); phalcon_call_method_p1(array_dump, this_ptr, "_getarraydump", dumped_object); PHALCON_INIT_VAR(dump); PHALCON_CONCAT_SVSVS(dump, "Object(", class_name, ": ", array_dump, ")"); } else { /** * If dump() is not available just print the class name */ PHALCON_INIT_NVAR(dump); PHALCON_CONCAT_SVS(dump, "Object(", class_name, ")</span>"); } RETURN_CTOR(dump); } /** * Recursively process the array and enclose it in Array() */ if (Z_TYPE_P(variable) == IS_ARRAY) { PHALCON_INIT_NVAR(array_dump); phalcon_call_method_p1(array_dump, this_ptr, "_getarraydump", variable); PHALCON_CONCAT_SVS(return_value, "Array(", array_dump, ")"); RETURN_MM(); } /** * Null variables are represented as 'null' * Other types are represented by its type */ RETURN_MM_STRING(zend_zval_type_name(variable), 1); }
/** * Produces a pre-computed hash key based on a string. This function produces different numbers in 32bit/64bit processors * * @param string key * @return string */ PHP_METHOD(Phalcon_Kernel, preComputeHashKey) { zval *key_param = NULL; zval *key = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &key_param); if (unlikely(Z_TYPE_P(key_param) != IS_STRING && Z_TYPE_P(key_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'key' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(key_param) == IS_STRING)) { zephir_get_strval(key, key_param); } else { ZEPHIR_INIT_VAR(key); ZVAL_EMPTY_STRING(key); } { #if PHP_VERSION_ID < 70000 char *arKey = Z_STRVAL_P(key), *strKey; int nKeyLength = strlen(arKey); register ulong hash = 5381; nKeyLength++; /* variant with the hash unrolled eight times */ for (; nKeyLength >= 8; nKeyLength -= 8) { hash = ((hash << 5) + hash) + *arKey++; hash = ((hash << 5) + hash) + *arKey++; hash = ((hash << 5) + hash) + *arKey++; hash = ((hash << 5) + hash) + *arKey++; hash = ((hash << 5) + hash) + *arKey++; hash = ((hash << 5) + hash) + *arKey++; hash = ((hash << 5) + hash) + *arKey++; hash = ((hash << 5) + hash) + *arKey++; } switch (nKeyLength) { case 7: hash = ((hash << 5) + hash) + *arKey++; /* no break */ case 6: hash = ((hash << 5) + hash) + *arKey++; /* no break */ case 5: hash = ((hash << 5) + hash) + *arKey++; /* no break */ case 4: hash = ((hash << 5) + hash) + *arKey++; /* no break */ case 3: hash = ((hash << 5) + hash) + *arKey++; /* no break */ case 2: hash = ((hash << 5) + hash) + *arKey++; /* no break */ case 1: hash = ((hash << 5) + hash) + *arKey++; break; } strKey = emalloc(24); snprintf(strKey, 24, "%lu", hash); RETURN_MM_STRING(strKey, 0); #else RETURN_MM_NULL(); #endif } ZEPHIR_MM_RESTORE(); }
/** * Creates a password hash using bcrypt with a pseudo random salt */ PHP_METHOD(Phalcon_Security, hash) { zephir_nts_static zephir_fcall_cache_entry *_6 = NULL, *_8 = NULL; zephir_fcall_cache_entry *_2 = NULL; int workFactor, hash, ZEPHIR_LAST_CALL_STATUS; zval *password_param = NULL, *workFactor_param = NULL, *saltBytes = NULL, *_0 = NULL, *_1 = NULL, _3, _4, *_5 = NULL, *_7; zval *password = NULL, *variant = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &password_param, &workFactor_param); zephir_get_strval(password, password_param); if (!workFactor_param) { workFactor = 0; } else { workFactor = zephir_get_intval(workFactor_param); } if (!(workFactor)) { ZEPHIR_OBS_VAR(_0); zephir_read_property_this(&_0, this_ptr, SL("_workFactor"), PH_NOISY_CC); workFactor = zephir_get_intval(_0); } ZEPHIR_OBS_NVAR(_0); zephir_read_property_this(&_0, this_ptr, SL("_defaultHash"), PH_NOISY_CC); hash = zephir_get_intval(_0); do { if (hash == 5) { ZEPHIR_INIT_VAR(variant); ZVAL_STRING(variant, "x", 1); break; } if (hash == 6) { ZEPHIR_INIT_NVAR(variant); ZVAL_STRING(variant, "y", 1); break; } if (hash == 7) { ZEPHIR_INIT_NVAR(variant); ZVAL_STRING(variant, "5", 1); break; } if (hash == 8) { ZEPHIR_INIT_NVAR(variant); ZVAL_STRING(variant, "6", 1); break; } ZEPHIR_INIT_NVAR(variant); ZVAL_STRING(variant, "a", 1); break; } while(0); do { if (hash == 1) { ZEPHIR_INIT_VAR(_1); ZVAL_LONG(_1, 2); ZEPHIR_CALL_METHOD(&saltBytes, this_ptr, "getsaltbytes", &_2, _1); zephir_check_call_status(); if (Z_TYPE_P(saltBytes) != IS_STRING) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_security_exception_ce, "Unable to get random bytes for the salt", "phalcon/security.zep", 195); return; } break; } ZEPHIR_INIT_NVAR(_1); ZVAL_LONG(_1, 22); ZEPHIR_CALL_METHOD(&saltBytes, this_ptr, "getsaltbytes", &_2, _1); zephir_check_call_status(); if (Z_TYPE_P(saltBytes) != IS_STRING) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_security_exception_ce, "Unable to get random bytes for the salt", "phalcon/security.zep", 218); return; } if (workFactor < 4) { workFactor = 4; } else { if (workFactor > 31) { workFactor = 31; } } ZEPHIR_SINIT_VAR(_3); ZVAL_STRING(&_3, "%02s", 0); ZEPHIR_SINIT_VAR(_4); ZVAL_LONG(&_4, workFactor); ZEPHIR_CALL_FUNCTION(&_5, "sprintf", &_6, &_3, &_4); zephir_check_call_status(); ZEPHIR_INIT_VAR(_7); ZEPHIR_CONCAT_SVSVSV(_7, "$2", variant, "$", _5, "$", saltBytes); ZEPHIR_RETURN_CALL_FUNCTION("crypt", &_8, password, _7); zephir_check_call_status(); RETURN_MM(); } while(0); RETURN_MM_STRING("", 1); }
/** * Transforms an intermediate representation for a expression into a database system valid expression * * @param array expression * @param string escapeChar * @return string */ PHP_METHOD(Pdm_Db_AbstractDialect, getSqlExpression) { zephir_fcall_cache_entry *_10 = NULL; HashTable *_7, *_13; HashPosition _6, _12; int ZEPHIR_LAST_CALL_STATUS; zval *escapeChar = NULL, *_1 = NULL; zval *expression, *escapeChar_param = NULL, *type, *domain, *operator, *left = NULL, *right = NULL, *name = NULL, *sqlItems, *escapedName = NULL, *sqlArguments, *arguments, *argument = NULL, *item = NULL, *_0, *_2, *_3, *_4, *_5 = NULL, **_8, *_9 = NULL, *_11 = NULL, **_14, *_15, *_16; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &expression, &escapeChar_param); if (!escapeChar_param) { ZEPHIR_INIT_VAR(escapeChar); ZVAL_EMPTY_STRING(escapeChar); } else { zephir_get_strval(escapeChar, escapeChar_param); } if (ZEPHIR_GLOBAL(db).escape_identifiers) { if (ZEPHIR_IS_STRING_IDENTICAL(escapeChar, "")) { ZEPHIR_OBS_VAR(_0); zephir_read_property_this(&_0, this_ptr, SL("escapeChar"), PH_NOISY_CC); zephir_get_strval(_1, _0); ZEPHIR_CPY_WRT(escapeChar, _1); } } if (Z_TYPE_P(expression) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_exception_ce, "Invalid SQL expression", "pdm/db/abstractdialect.zep", 176); return; } ZEPHIR_OBS_VAR(type); if (!(zephir_array_isset_string_fetch(&type, expression, SS("type"), 0 TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_exception_ce, "Invalid SQL expression", "pdm/db/abstractdialect.zep", 180); return; } if (ZEPHIR_IS_STRING(type, "qualified")) { ZEPHIR_OBS_VAR(name); zephir_array_fetch_string(&name, expression, SL("name"), PH_NOISY TSRMLS_CC); if (ZEPHIR_GLOBAL(db).escape_identifiers) { ZEPHIR_INIT_VAR(escapedName); ZEPHIR_CONCAT_VVV(escapedName, escapeChar, name, escapeChar); } else { ZEPHIR_CPY_WRT(escapedName, name); } ZEPHIR_OBS_VAR(domain); if (zephir_array_isset_string_fetch(&domain, expression, SS("domain"), 0 TSRMLS_CC)) { if (ZEPHIR_GLOBAL(db).escape_identifiers) { ZEPHIR_CONCAT_VVVSV(return_value, escapeChar, domain, escapeChar, ".", escapedName); RETURN_MM(); } else { ZEPHIR_CONCAT_VSV(return_value, domain, ".", escapedName); RETURN_MM(); } } RETURN_CCTOR(escapedName); } if (ZEPHIR_IS_STRING(type, "literal")) { zephir_array_fetch_string(&_2, expression, SL("value"), PH_NOISY | PH_READONLY TSRMLS_CC); RETURN_CTOR(_2); } if (ZEPHIR_IS_STRING(type, "binary-op")) { zephir_array_fetch_string(&_2, expression, SL("left"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&left, this_ptr, "getsqlexpression", NULL, _2, escapeChar); zephir_check_call_status(); zephir_array_fetch_string(&_3, expression, SL("right"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&right, this_ptr, "getsqlexpression", NULL, _3, escapeChar); zephir_check_call_status(); zephir_array_fetch_string(&_4, expression, SL("op"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CONCAT_VSVSV(return_value, left, " ", _4, " ", right); RETURN_MM(); } if (ZEPHIR_IS_STRING(type, "unary-op")) { ZEPHIR_OBS_VAR(operator); zephir_array_fetch_string(&operator, expression, SL("op"), PH_NOISY TSRMLS_CC); ZEPHIR_OBS_NVAR(left); if (zephir_array_isset_string_fetch(&left, expression, SS("left"), 0 TSRMLS_CC)) { ZEPHIR_CALL_METHOD(&_5, this_ptr, "getsqlexpression", NULL, left, escapeChar); zephir_check_call_status(); ZEPHIR_CONCAT_VV(return_value, _5, operator); RETURN_MM(); } ZEPHIR_OBS_NVAR(right); if (zephir_array_isset_string_fetch(&right, expression, SS("right"), 0 TSRMLS_CC)) { ZEPHIR_CALL_METHOD(&_5, this_ptr, "getsqlexpression", NULL, right, escapeChar); zephir_check_call_status(); ZEPHIR_CONCAT_VV(return_value, _5, operator); RETURN_MM(); } } if (ZEPHIR_IS_STRING(type, "placeholder")) { zephir_array_fetch_string(&_2, expression, SL("value"), PH_NOISY | PH_READONLY TSRMLS_CC); RETURN_CTOR(_2); } if (ZEPHIR_IS_STRING(type, "parentheses")) { zephir_array_fetch_string(&_2, expression, SL("left"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&_5, this_ptr, "getsqlexpression", NULL, _2, escapeChar); zephir_check_call_status(); ZEPHIR_CONCAT_SVS(return_value, "(", _5, ")"); RETURN_MM(); } if (ZEPHIR_IS_STRING(type, "functionCall")) { ZEPHIR_OBS_NVAR(name); zephir_array_fetch_string(&name, expression, SL("name"), PH_NOISY TSRMLS_CC); ZEPHIR_INIT_VAR(sqlArguments); array_init(sqlArguments); ZEPHIR_OBS_VAR(arguments); if (zephir_array_isset_string_fetch(&arguments, expression, SS("arguments"), 0 TSRMLS_CC)) { zephir_is_iterable(arguments, &_7, &_6, 0, 0); for ( ; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS ; zephir_hash_move_forward_ex(_7, &_6) ) { ZEPHIR_GET_HVALUE(argument, _8); ZEPHIR_CALL_METHOD(&_9, this_ptr, "getsqlexpression", &_10, argument, escapeChar); zephir_check_call_status(); zephir_array_append(&sqlArguments, _9, PH_SEPARATE); } ZEPHIR_INIT_VAR(_11); zephir_fast_join_str(_11, SL(", "), sqlArguments TSRMLS_CC); ZEPHIR_CONCAT_VSVS(return_value, name, "(", _11, ")"); RETURN_MM(); } else { ZEPHIR_CONCAT_VS(return_value, name, "()"); RETURN_MM(); } } if (ZEPHIR_IS_STRING(type, "list")) { ZEPHIR_INIT_VAR(sqlItems); array_init(sqlItems); zephir_array_fetch_long(&_2, expression, 0, PH_NOISY | PH_READONLY TSRMLS_CC); zephir_is_iterable(_2, &_13, &_12, 0, 0); for ( ; zephir_hash_get_current_data_ex(_13, (void**) &_14, &_12) == SUCCESS ; zephir_hash_move_forward_ex(_13, &_12) ) { ZEPHIR_GET_HVALUE(item, _14); ZEPHIR_CALL_METHOD(&_5, this_ptr, "getsqlexpression", &_10, item, escapeChar); zephir_check_call_status(); zephir_array_append(&sqlItems, _5, PH_SEPARATE); } ZEPHIR_INIT_NVAR(_11); zephir_fast_join_str(_11, SL(", "), sqlItems TSRMLS_CC); ZEPHIR_CONCAT_SVS(return_value, "(", _11, ")"); RETURN_MM(); } if (ZEPHIR_IS_STRING(type, "all")) { RETURN_MM_STRING("*", 1); } if (ZEPHIR_IS_STRING(type, "cast")) { zephir_array_fetch_string(&_2, expression, SL("left"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&left, this_ptr, "getsqlexpression", &_10, _2, escapeChar); zephir_check_call_status(); zephir_array_fetch_string(&_3, expression, SL("right"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&right, this_ptr, "getsqlexpression", &_10, _3, escapeChar); zephir_check_call_status(); ZEPHIR_CONCAT_SVSVS(return_value, "CAST(", left, " AS ", right, ")"); RETURN_MM(); } if (ZEPHIR_IS_STRING(type, "convert")) { zephir_array_fetch_string(&_2, expression, SL("left"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&left, this_ptr, "getsqlexpression", &_10, _2, escapeChar); zephir_check_call_status(); zephir_array_fetch_string(&_3, expression, SL("right"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&right, this_ptr, "getsqlexpression", &_10, _3, escapeChar); zephir_check_call_status(); ZEPHIR_CONCAT_SVSVS(return_value, "CONVERT(", left, " USING ", right, ")"); RETURN_MM(); } ZEPHIR_INIT_VAR(_15); object_init_ex(_15, pdm_db_exception_ce); ZEPHIR_INIT_VAR(_16); ZEPHIR_CONCAT_SVS(_16, "Invalid SQL expression type '", type, "'"); ZEPHIR_CALL_METHOD(NULL, _15, "__construct", NULL, _16); zephir_check_call_status(); zephir_throw_exception_debug(_15, "pdm/db/abstractdialect.zep", 287 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; }
/** * 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(); }
/** * Transforms an intermediate representation for a expression into a database system valid expression * * @param array $expression * @param string $escapeChar * @return string */ PHP_METHOD(Phalcon_Db_Dialect, getSqlExpression){ zval *expression, *escape_char = NULL, *type, *name = NULL, *escaped_name = NULL; zval *domain, *escaped_domain = NULL, *value = NULL, *operator = NULL; zval *left = NULL, *expression_left = NULL, *right = NULL, *expression_right = NULL; zval *expression_group, *sql_arguments, *arguments; zval *argument = NULL, *argument_expression = NULL, *arguments_joined; zval *sql_items, *items, *item = NULL, *item_expression = NULL; zval *list_expression, *exception_message; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &expression, &escape_char); if (!escape_char) { PHALCON_INIT_VAR(escape_char); } else { PHALCON_SEPARATE_PARAM(escape_char); } if (PHALCON_GLOBAL(db).escape_identifiers) { if (Z_TYPE_P(escape_char) == IS_NULL) { PHALCON_OBS_NVAR(escape_char); phalcon_read_property_this(&escape_char, this_ptr, SL("_escapeChar"), PH_NOISY_CC); } } if (Z_TYPE_P(expression) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid SQL expression"); return; } if (!phalcon_array_isset_string(expression, SS("type"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid SQL expression"); return; } PHALCON_OBS_VAR(type); phalcon_array_fetch_string(&type, expression, SL("type"), PH_NOISY); /** * Resolve qualified expressions */ if (PHALCON_IS_STRING(type, "qualified")) { PHALCON_OBS_VAR(name); phalcon_array_fetch_string(&name, expression, SL("name"), PH_NOISY); if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_VAR(escaped_name); PHALCON_CONCAT_VVV(escaped_name, escape_char, name, escape_char); } else { PHALCON_CPY_WRT(escaped_name, name); } /** * A domain could be a table/schema */ if (phalcon_array_isset_string(expression, SS("domain"))) { PHALCON_OBS_VAR(domain); phalcon_array_fetch_string(&domain, expression, SL("domain"), PH_NOISY); if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_VAR(escaped_domain); PHALCON_CONCAT_VVVSV(escaped_domain, escape_char, domain, escape_char, ".", escaped_name); } else { PHALCON_INIT_NVAR(escaped_domain); PHALCON_CONCAT_VSV(escaped_domain, domain, ".", escaped_name); } RETURN_CTOR(escaped_domain); } RETURN_CCTOR(escaped_name); } /** * Resolve literal expressions */ if (PHALCON_IS_STRING(type, "literal")) { PHALCON_OBS_VAR(value); phalcon_array_fetch_string(&value, expression, SL("value"), PH_NOISY); RETURN_CCTOR(value); } /** * Resolve binary operations expressions */ if (PHALCON_IS_STRING(type, "binary-op")) { PHALCON_OBS_VAR(operator); phalcon_array_fetch_string(&operator, expression, SL("op"), PH_NOISY); PHALCON_OBS_VAR(left); phalcon_array_fetch_string(&left, expression, SL("left"), PH_NOISY); PHALCON_INIT_VAR(expression_left); phalcon_call_method_p2(expression_left, this_ptr, "getsqlexpression", left, escape_char); PHALCON_OBS_VAR(right); phalcon_array_fetch_string(&right, expression, SL("right"), PH_NOISY); PHALCON_INIT_VAR(expression_right); phalcon_call_method_p2(expression_right, this_ptr, "getsqlexpression", right, escape_char); PHALCON_CONCAT_VSVSV(return_value, expression_left, " ", operator, " ", expression_right); RETURN_MM(); } /** * Resolve unary operations expressions */ if (PHALCON_IS_STRING(type, "unary-op")) { PHALCON_OBS_NVAR(operator); phalcon_array_fetch_string(&operator, expression, SL("op"), PH_NOISY); /** * Some unary operators uses the left operand... */ if (phalcon_array_isset_string(expression, SS("left"))) { PHALCON_OBS_NVAR(left); phalcon_array_fetch_string(&left, expression, SL("left"), PH_NOISY); PHALCON_INIT_NVAR(expression_left); phalcon_call_method_p2(expression_left, this_ptr, "getsqlexpression", left, escape_char); PHALCON_CONCAT_VV(return_value, expression_left, operator); RETURN_MM(); } /** * ...Others uses the right operand */ if (phalcon_array_isset_string(expression, SS("right"))) { PHALCON_OBS_NVAR(right); phalcon_array_fetch_string(&right, expression, SL("right"), PH_NOISY); PHALCON_INIT_NVAR(expression_right); phalcon_call_method_p2(expression_right, this_ptr, "getsqlexpression", right, escape_char); PHALCON_CONCAT_VV(return_value, operator, expression_right); RETURN_MM(); } } /** * Resolve placeholder */ if (PHALCON_IS_STRING(type, "placeholder")) { PHALCON_OBS_NVAR(value); phalcon_array_fetch_string(&value, expression, SL("value"), PH_NOISY); RETURN_CCTOR(value); } /** * Resolve parentheses */ if (PHALCON_IS_STRING(type, "parentheses")) { PHALCON_OBS_NVAR(left); phalcon_array_fetch_string(&left, expression, SL("left"), PH_NOISY); PHALCON_INIT_NVAR(expression_left); phalcon_call_method_p2(expression_left, this_ptr, "getsqlexpression", left, escape_char); PHALCON_INIT_VAR(expression_group); PHALCON_CONCAT_SVS(expression_group, "(", expression_left, ")"); RETURN_CTOR(expression_group); } /** * Resolve function calls */ if (PHALCON_IS_STRING(type, "functionCall")) { PHALCON_OBS_NVAR(name); phalcon_array_fetch_string(&name, expression, SL("name"), PH_NOISY); PHALCON_INIT_VAR(sql_arguments); array_init(sql_arguments); if (phalcon_array_isset_string(expression, SS("arguments"))) { PHALCON_OBS_VAR(arguments); phalcon_array_fetch_string(&arguments, expression, SL("arguments"), PH_NOISY); phalcon_is_iterable(arguments, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(argument); PHALCON_INIT_NVAR(argument_expression); phalcon_call_method_p2(argument_expression, this_ptr, "getsqlexpression", argument, escape_char); phalcon_array_append(&sql_arguments, argument_expression, PH_SEPARATE); zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_INIT_VAR(arguments_joined); phalcon_fast_join_str(arguments_joined, SL(", "), sql_arguments TSRMLS_CC); PHALCON_CONCAT_VSVS(return_value, name, "(", arguments_joined, ")"); RETURN_MM(); } else { PHALCON_CONCAT_VS(return_value, name, "()"); RETURN_MM(); } } /** * Resolve lists */ if (PHALCON_IS_STRING(type, "list")) { PHALCON_INIT_VAR(sql_items); array_init(sql_items); PHALCON_OBS_VAR(items); phalcon_array_fetch_long(&items, expression, 0, PH_NOISY); phalcon_is_iterable(items, &ah1, &hp1, 0, 0); while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_HVALUE(item); PHALCON_INIT_NVAR(item_expression); phalcon_call_method_p2(item_expression, this_ptr, "getsqlexpression", item, escape_char); phalcon_array_append(&sql_items, item_expression, PH_SEPARATE); zend_hash_move_forward_ex(ah1, &hp1); } PHALCON_INIT_VAR(list_expression); phalcon_fast_join_str(list_expression, SL(", "), sql_items TSRMLS_CC); PHALCON_CONCAT_SVS(return_value, "(", list_expression, ")"); RETURN_MM(); } /** * Resolve * */ if (PHALCON_IS_STRING(type, "all")) { RETURN_MM_STRING("*", 1); } /** * Resolve CAST of values */ if (PHALCON_IS_STRING(type, "cast")) { PHALCON_OBS_NVAR(left); phalcon_array_fetch_string(&left, expression, SL("left"), PH_NOISY); PHALCON_INIT_NVAR(expression_left); phalcon_call_method_p2(expression_left, this_ptr, "getsqlexpression", left, escape_char); PHALCON_OBS_NVAR(right); phalcon_array_fetch_string(&right, expression, SL("right"), PH_NOISY); PHALCON_INIT_NVAR(expression_right); phalcon_call_method_p2(expression_right, this_ptr, "getsqlexpression", right, escape_char); PHALCON_CONCAT_SVSVS(return_value, "CAST(", expression_left, " AS ", expression_right, ")"); RETURN_MM(); } /** * Resolve CONVERT of values encodings */ if (PHALCON_IS_STRING(type, "convert")) { PHALCON_OBS_NVAR(left); phalcon_array_fetch_string(&left, expression, SL("left"), PH_NOISY); PHALCON_INIT_NVAR(expression_left); phalcon_call_method_p2(expression_left, this_ptr, "getsqlexpression", left, escape_char); PHALCON_OBS_NVAR(right); phalcon_array_fetch_string(&right, expression, SL("right"), PH_NOISY); PHALCON_INIT_NVAR(expression_right); phalcon_call_method_p2(expression_right, this_ptr, "getsqlexpression", right, escape_char); PHALCON_CONCAT_SVSVS(return_value, "CONVERT(", expression_left, " USING ", expression_right, ")"); RETURN_MM(); } /** * Expression type wasn't found */ PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Invalid SQL expression type '", type, "'"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_db_exception_ce, exception_message); return; }
/** * 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_nts_static 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); 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 (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, 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, &_7); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_7); ZVAL_LONG(&_7, (paddingSize - 1)); ZEPHIR_CALL_FUNCTION(&_10, "str_repeat", &_11, _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, 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, &_7); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_7); ZVAL_LONG(&_7, paddingSize); ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_11, _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, 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(); } else { RETURN_MM_STRING("", 1); } } else { paddingSize = 0; } } if (!(paddingSize)) { RETURN_CTOR(text); } ZEPHIR_MM_RESTORE(); }