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();
}
