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);
}
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);
}
}
}
/* {{{ */
static inline zend_string* php_memoize_scope(const zval *This, const zend_function *function) {
if (!function->common.scope) {
return NULL;
}
if (Z_TYPE_P(This) != IS_OBJECT) {
return zend_string_copy(function->common.scope->name);
} else {
smart_str smart = {0};
php_serialize_data_t data;
if (Z_OBJCE_P(This)->serialize == zend_class_serialize_deny) {
return PHP_MEMOIZE_SCOPE_FAILURE;
}
PHP_VAR_SERIALIZE_INIT(data);
php_var_serialize(&smart, (zval*) This, &data);
PHP_VAR_SERIALIZE_DESTROY(data);
if (EG(exception)) {
smart_str_free(&smart);
zend_clear_exception();
return PHP_MEMOIZE_SCOPE_FAILURE;
}
return smart.s;
}
return NULL;
} /* }}} */
/* {{{ */
static int php_memoize_return(zend_execute_data *execute_data) {
zend_long ttl = 0;
const zend_function *fbc = EX(func);
if (MG(ini.enabled) && php_memoize_is_memoizing(fbc, &ttl)) {
zend_string *key = php_memoize_key(
&EX(This),
fbc, EX_NUM_ARGS(), EX_VAR_NUM(0));
if (key) {
zval *return_value;
if (EX(opline)->op1_type & IS_CONST) {
return_value = EX_CONSTANT(EX(opline)->op1);
} else {
return_value = EX_VAR(EX(opline)->op1.var);
}
apc_cache_store(php_memoize_cache, key, return_value, ttl, 1);
if (EG(exception)) {
zend_clear_exception();
}
zend_string_release(key);
}
}
if (zend_return_function) {
return zend_return_function(execute_data);
}
return ZEND_USER_OPCODE_DISPATCH;
} /* }}} */
PHP_METHOD(Test_TryTest, testTry2) {
zval _0$$3, _1$$3;
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);
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", 27 TSRMLS_CC);
goto try_end_1;
try_end_1:
zend_clear_exception(TSRMLS_C);
}
PHP_METHOD(Test_Exceptions, testExceptionRethrow) {
zval e;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_INIT_THIS();
ZVAL_UNDEF(&e);
ZEPHIR_MM_GROW();
/* try_start_1: */
ZEPHIR_CALL_METHOD(NULL, this_ptr, "testexception1", NULL, 0);
zephir_check_call_status_or_jump(try_end_1);
try_end_1:
if (EG(exception)) {
ZVAL_OBJ(&e, EG(exception));
Z_ADDREF_P(&e);
if (zephir_instance_of_ev(&e, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) {
zend_clear_exception(TSRMLS_C);
zephir_throw_exception_debug(&e, "test/exceptions.zep", 80 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
ZEPHIR_MM_RESTORE();
}
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);
}
PHP_METHOD(Lynx_DBAL_Driver_PgSQL, prepare) {
int ZEPHIR_LAST_CALL_STATUS;
zval *statement, *e = NULL, *_0, *_1 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &statement);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "connect", NULL);
zephir_check_call_status();
/* try_start_1: */
_0 = zephir_fetch_nproperty_this(this_ptr, SL("connection"), PH_NOISY_CC);
ZEPHIR_RETURN_CALL_METHOD(_0, "prepare", NULL, statement);
zephir_check_call_status_or_jump(try_end_1);
RETURN_MM();
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_CALL_METHOD(&_1, e, "getmessage", NULL);
zephir_check_call_status();
zephir_var_dump(&_1 TSRMLS_CC);
zephir_exit_empty();
ZEPHIR_MM_RESTORE();
}
}
}
/**
* Destructor
*/
OrigException::~OrigException() noexcept
{
// skip if the exception was restored
if (_restored) return;
// clean up the exception, because it was handled in C++ code
zend_clear_exception();
}
/**
* Dispatches a handle action taking into account the routing parameters
*
* @return object
*/
PHP_METHOD(Phalcon_Dispatcher, dispatch) {
zval *handler = NULL, *e = NULL, *_0$$4 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
/* try_start_1: */
ZEPHIR_CALL_METHOD(&handler, this_ptr, "_dispatch", NULL, 0);
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_CALL_METHOD(&_0$$4, this_ptr, "_handleexception", NULL, 0, e);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_0$$4)) {
RETURN_MM_BOOL(0);
}
zephir_throw_exception_debug(e, "phalcon/dispatcher.zep", 348 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
RETURN_CCTOR(handler);
}
PHP_METHOD(Test_TryTest, testTry2) {
int ZEPHIR_LAST_CALL_STATUS;
zval *_0, *_1;
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", 27 TSRMLS_CC);
goto try_end_1;
try_end_1:
zend_clear_exception(TSRMLS_C);
}
PHP_METHOD(Test_TryTest, testTry8) {
zephir_nts_static zephir_fcall_cache_entry *_2 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *_0, *_1;
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 1!", 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", 111 TSRMLS_CC);
goto try_end_1;
try_end_1:
zend_clear_exception(TSRMLS_C);
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(zend_exception_get_default(TSRMLS_C), "error 2!", "test/trytest.zep", 113);
return;
}
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, testTry11) {
zval ex;
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(&ex);
/* try_start_1: */
RETURN_STRING("test");
try_end_1:
if (EG(exception)) {
ZVAL_OBJ(&ex, EG(exception));
Z_ADDREF_P(&ex);
if (zephir_instance_of_ev(&ex, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) {
zend_clear_exception(TSRMLS_C);
}
}
}
PHP_METHOD(Test_Exceptions, testExceptionRethrow) {
int ZEPHIR_LAST_CALL_STATUS;
zval *e = NULL;
ZEPHIR_MM_GROW();
/* try_start_1: */
ZEPHIR_CALL_METHOD(NULL, this_ptr, "testexception1", NULL, 0);
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_throw_exception_debug(e, "test/exceptions.zep", 80 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_Exceptions, issue1325) {
zval e, status, _0;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *this_ptr = getThis();
ZVAL_UNDEF(&e);
ZVAL_UNDEF(&status);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
/* try_start_1: */
ZEPHIR_CALL_METHOD(&status, this_ptr, "donoopexception", NULL, 27);
zephir_check_call_status_or_jump(try_end_1);
try_end_1:
if (EG(exception)) {
ZEPHIR_INIT_VAR(&_0);
ZVAL_OBJ(&_0, EG(exception));
Z_ADDREF_P(&_0);
if (zephir_instance_of_ev(&_0, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) {
zend_clear_exception(TSRMLS_C);
ZEPHIR_CPY_WRT(&e, &_0);
ZEPHIR_INIT_NVAR(&status);
ZVAL_STRING(&status, "woop");
}
}
RETURN_MM_LONG(1);
}
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);
}
ZEND_API void zend_strip(void)
{
zval token;
int token_type;
int prev_space = 0;
ZVAL_UNDEF(&token);
while ((token_type=lex_scan(&token))) {
switch (token_type) {
case T_WHITESPACE:
if (!prev_space) {
zend_write(" ", sizeof(" ") - 1);
prev_space = 1;
}
/* lack of break; is intentional */
case T_COMMENT:
case T_DOC_COMMENT:
ZVAL_UNDEF(&token);
continue;
case T_END_HEREDOC:
zend_write((char*)LANG_SCNG(yy_text), LANG_SCNG(yy_leng));
/* read the following character, either newline or ; */
if (lex_scan(&token) != T_WHITESPACE) {
zend_write((char*)LANG_SCNG(yy_text), LANG_SCNG(yy_leng));
}
zend_write("\n", sizeof("\n") - 1);
prev_space = 1;
ZVAL_UNDEF(&token);
continue;
default:
zend_write((char*)LANG_SCNG(yy_text), LANG_SCNG(yy_leng));
break;
}
if (Z_TYPE(token) == IS_STRING) {
switch (token_type) {
case T_OPEN_TAG:
case T_OPEN_TAG_WITH_ECHO:
case T_CLOSE_TAG:
case T_WHITESPACE:
case T_COMMENT:
case T_DOC_COMMENT:
break;
default:
zend_string_release(Z_STR(token));
break;
}
}
prev_space = 0;
ZVAL_UNDEF(&token);
}
/* Discard parse errors thrown during tokenization */
zend_clear_exception();
}
PHP_METHOD(Test_TryTest, testTry1) {
/* try_start_1: */
try_end_1:
zend_clear_exception(TSRMLS_C);
}
/**
* Execute query and return result
*/
PHP_METHOD(Lynx_DBAL_Driver_PgSQL, execute) {
int ZEPHIR_LAST_CALL_STATUS;
zval *query_param = NULL, *e = NULL, *_0, *_1 = NULL;
zval *query = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &query_param);
if (unlikely(Z_TYPE_P(query_param) != IS_STRING && Z_TYPE_P(query_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'query' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(query_param) == IS_STRING)) {
zephir_get_strval(query, query_param);
} else {
ZEPHIR_INIT_VAR(query);
ZVAL_EMPTY_STRING(query);
}
ZEPHIR_CALL_METHOD(NULL, this_ptr, "connect", NULL);
zephir_check_call_status();
/* try_start_1: */
_0 = zephir_fetch_nproperty_this(this_ptr, SL("connection"), PH_NOISY_CC);
ZEPHIR_RETURN_CALL_METHOD(_0, "exec", NULL, query);
zephir_check_call_status_or_jump(try_end_1);
RETURN_MM();
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_CALL_METHOD(&_1, e, "getmessage", NULL);
zephir_check_call_status();
zephir_var_dump(&_1 TSRMLS_CC);
zephir_exit_empty();
ZEPHIR_MM_RESTORE();
}
}
}
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);
}
PHP_METHOD(Test_TryTest, testTry1) {
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;
/* try_start_1: */
try_end_1:
zend_clear_exception(TSRMLS_C);
}
PHP_METHOD(Test_TryTest, testTry11) {
zval *ex = NULL;
/* try_start_1: */
RETURN_STRING("test", 1);
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);
}
}
}
PHP_METHOD(Yb_Task_TaskManagerAbstract, runTask) {
int ZEPHIR_LAST_CALL_STATUS;
zval *task_param = NULL, *re = NULL, *ex = NULL, *_0, *_1$$4, *_2$$4, *_3$$5;
zval *task = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &task_param);
zephir_get_arrval(task, task_param);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("taskExecutor"), PH_NOISY_CC);
if (unlikely(!zephir_is_true(_0))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(yb_task_exception_ce, "Missing task executor", "yb/task/taskmanagerabstract.zep", 76);
return;
}
/* try_start_1: */
_1$$4 = zephir_fetch_nproperty_this(this_ptr, SL("taskExecutor"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&re, _1$$4, "executetask", NULL, 0, task);
zephir_check_call_status_or_jump(try_end_1);
_2$$4 = zephir_fetch_nproperty_this(this_ptr, SL("taskExecutor"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, _2$$4, "ontaskreturn", NULL, 0, task, re);
zephir_check_call_status_or_jump(try_end_1);
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);
_3$$5 = zephir_fetch_nproperty_this(this_ptr, SL("taskExecutor"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, _3$$5, "ontaskexception", NULL, 0, task, ex);
zephir_check_call_status();
}
}
ZEPHIR_MM_RESTORE();
}
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");
}
}
}
TypedValue* zend_wrap_func(ActRec* ar) {
// Sync the translator state.
// We need to do this before a native function calls into a C library
// compiled with -fomit-frame-pointer with the intention of having it call
// back. Normal HHVM extensions have the luxury of only when such a thing
// will be attempted, but we have no way to know in advance.
VMRegAnchor _;
TSRMLS_FETCH();
zend_ext_func native_func = reinterpret_cast<zend_ext_func>(ar->func()->nativeFuncPtr());
// Using Variant so exceptions will decref them
Variant return_value_var(Variant::NullInit{});
auto const return_value = return_value_var.asTypedValue();
tvBox(return_value);
Variant this_ptr_var(Variant::NullInit{});
auto const this_ptr = this_ptr_var.asTypedValue();
tvBox(this_ptr);
if (ar->func()->cls() && ar->hasThis()) {
tvWriteObject(
ar->getThis(),
this_ptr->m_data.pref->tv()
);
}
auto *return_value_ptr = &return_value->m_data.pref;
// Clear any stored exception
zend_clear_exception(TSRMLS_C);
// Invoke the PHP extension function/method
ZendExecutionStack::pushHHVMStack((void*)ar);
try {
native_func(
ar->numArgs(),
return_value->m_data.pref,
return_value_ptr,
this_ptr_var.isNull() ? nullptr : this_ptr->m_data.pref,
1
TSRMLS_CC
);
} catch (...) {
zend_wrap_func_cleanup();
throw;
}
zend_wrap_func_cleanup();
// If an exception was caught, rethrow it
ZendExceptionStore& exceptionStore = ZendExceptionStore::getInstance();
if (!exceptionStore.empty()) {
exceptionStore.rethrow();
}
// Take care of freeing the args, tearing down the ActRec, and moving the
// return value to the right place. Note that frame_free_locals expects to
// be able to free return_value in the event of an exception, so we have to
// take it out of our Variant /before/ calling that.
TypedValue return_value_copy = *return_value;
return_value->m_type = KindOfNull; // clear the Variant's copy
frame_free_locals_inl(ar, ar->func()->numLocals(), &return_value_copy);
memcpy(&ar->m_r, &return_value_copy, sizeof(TypedValue));
if (ar->func()->isReturnRef()) {
if (!ar->m_r.m_data.pref->isReferenced()) {
tvUnbox(&ar->m_r);
}
} else {
tvUnbox(&ar->m_r);
}
return &ar->m_r;
}
ONPHP_METHOD(PrimitiveNumber, import)
{
zval *scope, *result, *name, *value, *min, *max, *out;
ONPHP_GET_ARGS("a", &scope);
zend_call_method_with_1_params(
&getThis(),
onphp_ce_BasePrimitive,
NULL,
"import",
&result,
scope
);
if (EG(exception)) {
zval_ptr_dtor(&result);
return;
}
if (!ONPHP_CHECK_EMPTY(result)) {
zval_ptr_dtor(&result);
RETURN_NULL();
}
zval_ptr_dtor(&result);
name = ONPHP_READ_PROPERTY(getThis(), "name");
ONPHP_ASSOC_GET(scope, Z_STRVAL_P(name), value);
ONPHP_CALL_METHOD_1_NORET(getThis(), "checknumber", NULL, value);
if (EG(exception)) {
zend_clear_exception(TSRMLS_C);
RETURN_FALSE;
}
ONPHP_CALL_METHOD_1(getThis(), "castnumber", &out, value);
ONPHP_CALL_METHOD_0(getThis(), "selffilter", NULL);
if (
(Z_TYPE_P(out) == IS_LONG)
&& (min = ONPHP_READ_PROPERTY(getThis(), "min"))
&& (max = ONPHP_READ_PROPERTY(getThis(), "max"))
&& !(
(IS_NULL != Z_TYPE_P(min))
&& (Z_LVAL_P(out) < Z_LVAL_P(min))
) && !(
(IS_NULL != Z_TYPE_P(max))
&& (Z_LVAL_P(out) > Z_LVAL_P(max))
)
) {
ONPHP_UPDATE_PROPERTY_LONG(getThis(), "value", Z_LVAL_P(out));
RETVAL_TRUE;
} else {
RETVAL_FALSE;
}
zval_ptr_dtor(&out);
}
PHP_METHOD(PhalconPlus_Db_Mysql, getConnection) {
zephir_nts_static zephir_fcall_cache_entry *_4 = NULL, *_7 = NULL;
zephir_fcall_cache_entry *_1 = NULL;
int ZEPHIR_LAST_CALL_STATUS, _5;
zval *connection = NULL, *tryTimes = NULL, *e = NULL, *_0, *_2 = NULL, *_3 = NULL, _6 = zval_used_for_init;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(connection);
ZVAL_NULL(connection);
ZEPHIR_INIT_VAR(tryTimes);
ZVAL_LONG(tryTimes, 5);
while (1) {
if (!(!(Z_TYPE_P(connection) == IS_OBJECT))) {
break;
}
/* try_start_1: */
ZEPHIR_INIT_NVAR(connection);
object_init_ex(connection, zephir_get_internal_ce(SS("phalcon\\db\\adapter\\pdo\\mysql") TSRMLS_CC));
_0 = zephir_fetch_nproperty_this(this_ptr, SL("descriptor"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, connection, "__construct", &_1, _0);
zephir_check_call_status_or_jump(try_end_1);
try_end_1:
if (EG(exception)) {
ZEPHIR_CPY_WRT(e, EG(exception));
if (zephir_is_instance_of(e, SL("PhalconPlus\\Db\\Exception") TSRMLS_CC)) {
zend_clear_exception(TSRMLS_C);
ZEPHIR_INIT_NVAR(_2);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("descriptor"), PH_NOISY_CC);
zephir_json_encode(_2, &(_2), _0, 0 TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_3);
ZEPHIR_CONCAT_SV(_3, "PHP Fatal error: PhalconPlus::Db::MySQL::connect() failed to connect to MySQL. Detail: ", _2);
ZEPHIR_CALL_FUNCTION(NULL, "error_log", &_4, _3);
zephir_check_call_status();
_5 = (zephir_get_numberval(tryTimes) - 1);
ZEPHIR_INIT_NVAR(tryTimes);
ZVAL_LONG(tryTimes, _5);
if (ZEPHIR_GT_LONG(tryTimes, 0)) {
ZEPHIR_SINIT_NVAR(_6);
ZVAL_LONG(&_6, 100000);
ZEPHIR_CALL_FUNCTION(NULL, "usleep", &_7, &_6);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_6);
ZVAL_STRING(&_6, "PHP Notice: PhalconPlus::Db::MySQL::connnect() retry to connect to MySQL for the time ... ", 0);
ZEPHIR_CALL_FUNCTION(NULL, "error_log", &_4, &_6);
zephir_check_call_status();
} else {
ZEPHIR_SINIT_NVAR(_6);
ZVAL_STRING(&_6, "PHP Fatal error: PhalconPlus::Db::MySQL::connect() finally failed to connect to MySQL", 0);
ZEPHIR_CALL_FUNCTION(NULL, "error_log", &_4, &_6);
zephir_check_call_status();
zephir_throw_exception_debug(e, "phalconplus/Db/Mysql.zep", 52 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
}
}
RETURN_CCTOR(connection);
}
PHP_METHOD(Fox_MsgCrypt, encrypt) {
zephir_fcall_cache_entry *_10 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *text = NULL, *random = NULL, *module = NULL, *size = NULL, *iv = NULL, *pkc_encoder = NULL, *encrypted = NULL, *e = NULL, _0$$3 = zval_used_for_init, _1$$3 = zval_used_for_init, *_2$$3 = NULL, *_3$$3, *_4$$3, _5$$3, _6$$3, *_7$$3, *_8$$3 = NULL, *_9$$3, *_11$$3, *_12$$3, *_13$$4, *_14$$4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &text);
ZEPHIR_SEPARATE_PARAM(text);
/* try_start_1: */
ZEPHIR_CALL_METHOD(&random, this_ptr, "_getrandomstr", NULL, 1);
zephir_check_call_status_or_jump(try_end_1);
ZEPHIR_SINIT_VAR(_0$$3);
ZVAL_STRING(&_0$$3, "N", 0);
ZEPHIR_SINIT_VAR(_1$$3);
ZVAL_LONG(&_1$$3, zephir_fast_strlen_ev(text));
ZEPHIR_CALL_FUNCTION(&_2$$3, "pack", NULL, 2, &_0$$3, &_1$$3);
zephir_check_call_status_or_jump(try_end_1);
_3$$3 = zephir_fetch_nproperty_this(this_ptr, SL("appid"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_4$$3);
ZEPHIR_CONCAT_VVVV(_4$$3, random, _2$$3, text, _3$$3);
ZEPHIR_CPY_WRT(text, _4$$3);
ZEPHIR_SINIT_NVAR(_0$$3);
ZVAL_STRING(&_0$$3, "rijndael-128", 0);
ZEPHIR_SINIT_NVAR(_1$$3);
ZVAL_STRING(&_1$$3, "cbc", 0);
ZEPHIR_CALL_FUNCTION(&size, "mcrypt_get_block_size", NULL, 3, &_0$$3, &_1$$3);
zephir_check_call_status_or_jump(try_end_1);
ZEPHIR_SINIT_NVAR(_0$$3);
ZVAL_STRING(&_0$$3, "rijndael-128", 0);
ZEPHIR_SINIT_NVAR(_1$$3);
ZVAL_STRING(&_1$$3, "", 0);
ZEPHIR_SINIT_VAR(_5$$3);
ZVAL_STRING(&_5$$3, "cbc", 0);
ZEPHIR_SINIT_VAR(_6$$3);
ZVAL_STRING(&_6$$3, "", 0);
ZEPHIR_CALL_FUNCTION(&module, "mcrypt_module_open", NULL, 4, &_0$$3, &_1$$3, &_5$$3, &_6$$3);
zephir_check_call_status_or_jump(try_end_1);
_7$$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, _7$$3, 0 , 16 , 0);
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(&_8$$3, pkc_encoder, "encode", NULL, 5, text);
zephir_check_call_status_or_jump(try_end_1);
ZEPHIR_CPY_WRT(text, _8$$3);
_9$$3 = zephir_fetch_nproperty_this(this_ptr, SL("appkey"), PH_NOISY_CC);
ZEPHIR_CALL_FUNCTION(NULL, "mcrypt_generic_init", NULL, 6, module, _9$$3, iv);
zephir_check_call_status_or_jump(try_end_1);
ZEPHIR_CALL_FUNCTION(&encrypted, "mcrypt_generic", NULL, 7, module, text);
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);
ZEPHIR_CALL_FUNCTION(&_8$$3, "base64_encode", NULL, 11, encrypted);
zephir_check_call_status_or_jump(try_end_1);
ZEPHIR_INIT_VAR(_11$$3);
ZVAL_BOOL(_11$$3, 1);
ZEPHIR_INIT_VAR(_12$$3);
ZVAL_STRING(_12$$3, "OK", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_RETURN_CALL_CE_STATIC(fox_common_ce, "rtn", &_10, 10, _11$$3, _12$$3, _8$$3);
zephir_check_temp_parameter(_12$$3);
zephir_check_call_status_or_jump(try_end_1);
RETURN_MM();
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(_13$$4);
ZVAL_BOOL(_13$$4, 0);
ZEPHIR_INIT_VAR(_14$$4);
ZVAL_STRING(_14$$4, "EncryptAESError", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_RETURN_CALL_CE_STATIC(fox_common_ce, "rtn", &_10, 10, _13$$4, _14$$4);
zephir_check_temp_parameter(_14$$4);
zephir_check_call_status();
RETURN_MM();
}
}
ZEPHIR_MM_RESTORE();
}