自学教程：C++ zephir_throw_exception_debug函数代码示例

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(Yb_Std, uniqueValues) {	HashTable *_1;	HashPosition _0;	zephir_fcall_cache_entry *_5 = NULL;	int ZEPHIR_LAST_CALL_STATUS;	zval *uniqueKey = NULL;	zval *data_param = NULL, *uniqueKey_param = NULL, *k = NULL, *v = NULL, *arr = NULL, *uniqueValue = NULL, **_2, *_3$$4 = NULL, *_4$$4 = NULL, *_6$$5 = NULL, *_7$$5 = NULL;	zval *data = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 2, 0, &data_param, &uniqueKey_param);	zephir_get_arrval(data, data_param);	zephir_get_strval(uniqueKey, uniqueKey_param);	ZEPHIR_INIT_VAR(arr);	array_init(arr);	zephir_is_iterable(data, &_1, &_0, 0, 0, "yb/std.zep", 377);	for (	  ; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS	  ; zephir_hash_move_forward_ex(_1, &_0)	) {		ZEPHIR_GET_HMKEY(k, _1, _0);		ZEPHIR_GET_HVALUE(v, _2);		if (unlikely(Z_TYPE_P(v) != IS_ARRAY)) {			ZEPHIR_INIT_NVAR(_3$$4);			object_init_ex(_3$$4, yb_exception_ce);			ZEPHIR_INIT_LNVAR(_4$$4);			ZEPHIR_CONCAT_SV(_4$$4, "Invalid item type, array required at: ", k);			ZEPHIR_CALL_METHOD(NULL, _3$$4, "__construct", &_5, 2, _4$$4);			zephir_check_call_status();			zephir_throw_exception_debug(_3$$4, "yb/std.zep", 368 TSRMLS_CC);			ZEPHIR_MM_RESTORE();			return;		}		ZEPHIR_OBS_NVAR(uniqueValue);		if (unlikely(!(zephir_array_isset_fetch(&uniqueValue, v, uniqueKey, 0 TSRMLS_CC)))) {			ZEPHIR_INIT_NVAR(_6$$5);			object_init_ex(_6$$5, yb_exception_ce);			ZEPHIR_INIT_LNVAR(_7$$5);			ZEPHIR_CONCAT_SV(_7$$5, "Cannot find value of unique at: ", k);			ZEPHIR_CALL_METHOD(NULL, _6$$5, "__construct", &_5, 2, _7$$5);			zephir_check_call_status();			zephir_throw_exception_debug(_6$$5, "yb/std.zep", 371 TSRMLS_CC);			ZEPHIR_MM_RESTORE();			return;		}		zephir_array_update_zval(&arr, uniqueValue, &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);	}	zephir_array_keys(return_value, arr TSRMLS_CC);	RETURN_MM();}

/** * Returns the content of the resource as an string * Optionally a base path where the resource is located can be set */PHP_METHOD(Phalcon_Assets_Resource, getContent) {	zend_long ZEPHIR_LAST_CALL_STATUS;	zval *basePath_param = NULL, *sourcePath = NULL, *completePath = NULL, *content = NULL, *_0, *_1$$5, *_2$$5, *_3$$6, *_4$$6;	zval *basePath = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 0, 1, &basePath_param);	if (!basePath_param) {		ZEPHIR_INIT_VAR(basePath);		ZVAL_EMPTY_STRING(basePath);	} else {		zephir_get_strval(basePath, basePath_param);	}	ZEPHIR_OBS_VAR(sourcePath);	zephir_read_property_this(&sourcePath, this_ptr, SL("_sourcePath"), PH_NOISY_CC);	if (ZEPHIR_IS_EMPTY(sourcePath)) {		ZEPHIR_OBS_NVAR(sourcePath);		zephir_read_property_this(&sourcePath, this_ptr, SL("_path"), PH_NOISY_CC);	}	ZEPHIR_INIT_VAR(completePath);	ZEPHIR_CONCAT_VV(completePath, basePath, sourcePath);	_0 = zephir_fetch_nproperty_this(this_ptr, SL("_local"), PH_NOISY_CC);	if (zephir_is_true(_0)) {		if (!((zephir_file_exists(completePath TSRMLS_CC) == SUCCESS))) {			ZEPHIR_INIT_VAR(_1$$5);			object_init_ex(_1$$5, phalcon_assets_exception_ce);			ZEPHIR_INIT_VAR(_2$$5);			ZEPHIR_CONCAT_SVS(_2$$5, "Resource's content for '", completePath, "' cannot be read");			ZEPHIR_CALL_METHOD(NULL, _1$$5, "__construct", NULL, 9, _2$$5);			zephir_check_call_status();			zephir_throw_exception_debug(_1$$5, "phalcon/assets/resource.zep", 183 TSRMLS_CC);			ZEPHIR_MM_RESTORE();			return;		}	}	ZEPHIR_INIT_VAR(content);	zephir_file_get_contents(content, completePath TSRMLS_CC);	if (ZEPHIR_IS_FALSE_IDENTICAL(content)) {		ZEPHIR_INIT_VAR(_3$$6);		object_init_ex(_3$$6, phalcon_assets_exception_ce);		ZEPHIR_INIT_VAR(_4$$6);		ZEPHIR_CONCAT_SVS(_4$$6, "Resource's content for '", completePath, "' cannot be read");		ZEPHIR_CALL_METHOD(NULL, _3$$6, "__construct", NULL, 9, _4$$6);		zephir_check_call_status();		zephir_throw_exception_debug(_3$$6, "phalcon/assets/resource.zep", 192 TSRMLS_CC);		ZEPHIR_MM_RESTORE();		return;	}	RETURN_CCTOR(content);}

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

/** * Throws an internal exception */PHP_METHOD(Phalcon_Cli_Dispatcher, _throwDispatchException) {	int exceptionCode, ZEPHIR_LAST_CALL_STATUS;	zval *message_param = NULL, *exceptionCode_param = NULL, *exception, *_0, *_1 = NULL;	zval *message = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 1, &message_param, &exceptionCode_param);	zephir_get_strval(message, message_param);	if (!exceptionCode_param) {		exceptionCode = 0;	} else {		exceptionCode = zephir_get_intval(exceptionCode_param);	}	ZEPHIR_INIT_VAR(exception);	object_init_ex(exception, phalcon_cli_dispatcher_exception_ce);	ZEPHIR_INIT_VAR(_0);	ZVAL_LONG(_0, exceptionCode);	ZEPHIR_CALL_METHOD(NULL, exception, "__construct", NULL, 9, message, _0);	zephir_check_call_status();	ZEPHIR_CALL_METHOD(&_1, this_ptr, "_handleexception", NULL, 0, exception);	zephir_check_call_status();	if (ZEPHIR_IS_FALSE_IDENTICAL(_1)) {		RETURN_MM_BOOL(0);	}	zephir_throw_exception_debug(exception, "phalcon/cli/dispatcher.zep", 116 TSRMLS_CC);	ZEPHIR_MM_RESTORE();	return;}

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

/** * Phalcon/Logger/Adapter/File constructor * * @param string name * @param array options */PHP_METHOD(Phalcon_Logger_Adapter_File, __construct) {	int ZEPHIR_LAST_CALL_STATUS;	zephir_nts_static zephir_fcall_cache_entry *_0 = NULL, *_3 = NULL;	zval *name_param = NULL, *options = NULL, *mode = NULL, *handler = NULL, *_1;	zval *name = NULL, *_2;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 1, &name_param, &options);	if (unlikely(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (likely(Z_TYPE_P(name_param) == IS_STRING)) {		zephir_get_strval(name, name_param);	} else {		ZEPHIR_INIT_VAR(name);		ZVAL_EMPTY_STRING(name);	}	if (!options) {		options = ZEPHIR_GLOBAL(global_null);	}	ZEPHIR_INIT_VAR(mode);	ZVAL_NULL(mode);	if (Z_TYPE_P(options) == IS_ARRAY) {		ZEPHIR_OBS_NVAR(mode);		if (zephir_array_isset_string_fetch(&mode, options, SS("mode"), 0 TSRMLS_CC)) {			if (zephir_memnstr_str(mode, SL("r"), "phalcon/logger/adapter/file.zep", 72)) {				ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_logger_exception_ce, "Logger must be opened in append or write mode", "phalcon/logger/adapter/file.zep", 73);				return;			}		}	}	if (Z_TYPE_P(mode) == IS_NULL) {		ZEPHIR_INIT_NVAR(mode);		ZVAL_STRING(mode, "ab", 1);	}	ZEPHIR_CALL_FUNCTION(&handler, "fopen", &_0, name, mode);	zephir_check_call_status();	if (Z_TYPE_P(handler) != IS_RESOURCE) {		ZEPHIR_INIT_VAR(_1);		object_init_ex(_1, phalcon_logger_exception_ce);		ZEPHIR_INIT_VAR(_2);		ZEPHIR_CONCAT_SVS(_2, "Can't open log file at '", name, "'");		ZEPHIR_CALL_METHOD(NULL, _1, "__construct", &_3, _2);		zephir_check_call_status();		zephir_throw_exception_debug(_1, "phalcon/logger/adapter/file.zep", 87 TSRMLS_CC);		ZEPHIR_MM_RESTORE();		return;	}	zephir_update_property_this(this_ptr, SL("_path"), name TSRMLS_CC);	zephir_update_property_this(this_ptr, SL("_options"), options TSRMLS_CC);	zephir_update_property_this(this_ptr, SL("_fileHandler"), handler TSRMLS_CC);	ZEPHIR_MM_RESTORE();}

/** * @inheritdoc */PHP_METHOD(Owl_Log_AbstractWriter, getOption) {	int ZEPHIR_LAST_CALL_STATUS;	zval *option_param = NULL, *_0, *_1, *_3, *_4;	zval *option = NULL, *_2;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &option_param);	zephir_get_strval(option, option_param);	_0 = zephir_fetch_nproperty_this(this_ptr, SL("options"), PH_NOISY_CC);	if (!(zephir_array_isset(_0, option))) {		ZEPHIR_INIT_VAR(_1);		object_init_ex(_1, owl_log_exception_invalidwriterexception_ce);		ZEPHIR_INIT_VAR(_2);		ZEPHIR_CONCAT_SVS(_2, "Option ", option, " is not exists");		ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 1, _2);		zephir_check_call_status();		zephir_throw_exception_debug(_1, "owl/Log/AbstractWriter.zep", 66 TSRMLS_CC);		ZEPHIR_MM_RESTORE();		return;	}	_3 = zephir_fetch_nproperty_this(this_ptr, SL("options"), PH_NOISY_CC);	zephir_array_fetch(&_4, _3, option, PH_NOISY | PH_READONLY, "owl/Log/AbstractWriter.zep", 68 TSRMLS_CC);	RETURN_CTOR(_4);}

/** * 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(PhalconPlus_Enum_AbstractEnum, setValue) {	int ZEPHIR_LAST_CALL_STATUS;	zval *val, *_0 = NULL, *_1$$3, *_2$$3, _3$$3, *_4$$3 = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &val);	ZEPHIR_CALL_STATIC(&_0, "isvalid", NULL, 0, val);	zephir_check_call_status();	if (!(zephir_is_true(_0))) {		ZEPHIR_INIT_VAR(_1$$3);		object_init_ex(_1$$3, spl_ce_InvalidArgumentException);		ZEPHIR_INIT_VAR(_2$$3);		zephir_get_class(_2$$3, this_ptr, 0 TSRMLS_CC);		ZEPHIR_SINIT_VAR(_3$$3);		ZVAL_STRING(&_3$$3, "Invalid enumeration %s for Enum %s", 0);		ZEPHIR_CALL_FUNCTION(&_4$$3, "sprintf", NULL, 13, &_3$$3, val, _2$$3);		zephir_check_call_status();		ZEPHIR_CALL_METHOD(NULL, _1$$3, "__construct", NULL, 15, _4$$3);		zephir_check_call_status();		zephir_throw_exception_debug(_1$$3, "phalconplus/Enum/AbstractEnum.zep", 29 TSRMLS_CC);		ZEPHIR_MM_RESTORE();		return;	}	zephir_update_property_this(this_ptr, SL("val"), val TSRMLS_CC);	ZEPHIR_MM_RESTORE();}

/** * Get a route from collection * * @see ArrayAccess * @param mixed offset * @return mixed * @throws /InvalidArgumentException */PHP_METHOD(Prr_RouteCollection, offsetGet) {	int ZEPHIR_LAST_CALL_STATUS;	zval *offset, *value, *_0, *_1, *_2;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &offset);	ZEPHIR_OBS_VAR(value);	_0 = zephir_fetch_nproperty_this(this_ptr, SL("storage"), PH_NOISY_CC);	if (zephir_array_isset_fetch(&value, _0, offset, 0 TSRMLS_CC)) {		RETURN_CCTOR(value);	}	ZEPHIR_INIT_VAR(_1);	object_init_ex(_1, spl_ce_InvalidArgumentException);	ZEPHIR_INIT_VAR(_2);	ZEPHIR_CONCAT_VS(_2, offset, " does not exist.");	ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, _2);	zephir_check_call_status();	zephir_throw_exception_debug(_1, "prr/routecollection.zep", 144 TSRMLS_CC);	ZEPHIR_MM_RESTORE();	return;}

/** * Returns a form by its name */PHP_METHOD(Phalcon_Forms_Manager, get) {	zend_long ZEPHIR_LAST_CALL_STATUS;	zval *name_param = NULL, form, _0, _1$$3;	zval name, _2$$3;	zval *this_ptr = getThis();	ZVAL_UNDEF(&name);	ZVAL_UNDEF(&_2$$3);	ZVAL_UNDEF(&form);	ZVAL_UNDEF(&_0);	ZVAL_UNDEF(&_1$$3);	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &name_param);	zephir_get_strval(&name, name_param);	ZEPHIR_OBS_VAR(&form);	zephir_read_property(&_0, this_ptr, SL("_forms"), PH_NOISY_CC | PH_READONLY);	if (!(zephir_array_isset_fetch(&form, &_0, &name, 0 TSRMLS_CC))) {		ZEPHIR_INIT_VAR(&_1$$3);		object_init_ex(&_1$$3, phalcon_forms_exception_ce);		ZEPHIR_INIT_VAR(&_2$$3);		ZEPHIR_CONCAT_SVS(&_2$$3, "There is no form with name='", &name, "'");		ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 4, &_2$$3);		zephir_check_call_status();		zephir_throw_exception_debug(&_1$$3, "phalcon/forms/manager.zep", 43 TSRMLS_CC);		ZEPHIR_MM_RESTORE();		return;	}	RETURN_CCTOR(&form);}

PHP_METHOD(Test_TryTest, testThrow2) {	zval message, _0;	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(&message);	ZVAL_UNDEF(&_0);	ZEPHIR_MM_GROW();	ZEPHIR_INIT_VAR(&message);	ZVAL_STRING(&message, "error");	ZEPHIR_INIT_VAR(&_0);	object_init_ex(&_0, zend_exception_get_default(TSRMLS_C));	ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 24, &message);	zephir_check_call_status();	zephir_throw_exception_debug(&_0, "test/trytest.zep", 16 TSRMLS_CC);	ZEPHIR_MM_RESTORE();	return;}

/** * Computes a HMAC * * @param string data * @param string key * @param string algo * @param boolean raw */PHP_METHOD(Phalcon_Security, computeHmac) {	zephir_nts_static zephir_fcall_cache_entry *_2 = NULL;	int ZEPHIR_LAST_CALL_STATUS;	zend_bool raw;	zval *data, *key, *algo, *raw_param = NULL, *hmac = NULL, *_0, *_1;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 3, 1, &data, &key, &algo, &raw_param);	if (!raw_param) {		raw = 0;	} else {		raw = zephir_get_boolval(raw_param);	}	ZEPHIR_CALL_FUNCTION(&hmac, "hash_hmac", NULL, algo, data, key, (raw ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false)));	zephir_check_call_status();	if (!(zephir_is_true(hmac))) {		ZEPHIR_INIT_VAR(_0);		object_init_ex(_0, phalcon_security_exception_ce);		ZEPHIR_INIT_VAR(_1);		ZEPHIR_CONCAT_SV(_1, "Unknown hashing algorithm: %s", algo);		ZEPHIR_CALL_METHOD(NULL, _0, "__construct", &_2, _1);		zephir_check_call_status();		zephir_throw_exception_debug(_0, "phalcon/security.zep", 434 TSRMLS_CC);		ZEPHIR_MM_RESTORE();		return;	}	RETURN_CCTOR(hmac);}

/** * Returns a form by its name */PHP_METHOD(Phalcon_Forms_Manager, get) {	zend_long ZEPHIR_LAST_CALL_STATUS;	zval *name_param = NULL, *form = NULL, *_0, *_1$$3;	zval *name = NULL, *_2$$3;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &name_param);	zephir_get_strval(name, name_param);	ZEPHIR_OBS_VAR(form);	_0 = zephir_fetch_nproperty_this(this_ptr, SL("_forms"), PH_NOISY_CC);	if (!(zephir_array_isset_fetch(&form, _0, name, 0 TSRMLS_CC))) {		ZEPHIR_INIT_VAR(_1$$3);		object_init_ex(_1$$3, phalcon_forms_exception_ce);		ZEPHIR_INIT_VAR(_2$$3);		ZEPHIR_CONCAT_SVS(_2$$3, "There is no form with name='", name, "'");		ZEPHIR_CALL_METHOD(NULL, _1$$3, "__construct", NULL, 9, _2$$3);		zephir_check_call_status();		zephir_throw_exception_debug(_1$$3, "phalcon/forms/manager.zep", 52 TSRMLS_CC);		ZEPHIR_MM_RESTORE();		return;	}	RETURN_CCTOR(form);}

/** * Throws an exception when a notice or warning is raised */PHP_METHOD(Phalcon_Debug, onUncaughtLowSeverity) {	int ZEPHIR_LAST_CALL_STATUS;	zval *severity, *message, *file, *line, *context, *_0 = NULL, _1, *_2$$3, *_3$$3;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 5, 0, &severity, &message, &file, &line, &context);	ZEPHIR_CALL_FUNCTION(&_0, "error_reporting", NULL, 166);	zephir_check_call_status();	ZEPHIR_SINIT_VAR(_1);	zephir_bitwise_and_function(&_1, _0, severity TSRMLS_CC);	if (zephir_is_true(&_1)) {		ZEPHIR_INIT_VAR(_2$$3);		object_init_ex(_2$$3, zephir_get_internal_ce(SS("errorexception") TSRMLS_CC));		ZEPHIR_INIT_VAR(_3$$3);		ZVAL_LONG(_3$$3, 0);		ZEPHIR_CALL_METHOD(NULL, _2$$3, "__construct", NULL, 167, message, _3$$3, severity, file, line);		zephir_check_call_status();		zephir_throw_exception_debug(_2$$3, "phalcon/debug.zep", 565 TSRMLS_CC);		ZEPHIR_MM_RESTORE();		return;	}	ZEPHIR_MM_RESTORE();}

/** * Computes a HMAC * * @param string data * @param string key * @param string algo * @param boolean raw */PHP_METHOD(Phalcon_Security, computeHmac) {	int ZEPHIR_LAST_CALL_STATUS;	zend_bool raw;	zval *data, *key, *algo, *raw_param = NULL, *hmac = NULL, _0, *_1$$3, *_2$$3;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 3, 1, &data, &key, &algo, &raw_param);	if (!raw_param) {		raw = 0;	} else {		raw = zephir_get_boolval(raw_param);	}	ZEPHIR_SINIT_VAR(_0);	ZVAL_BOOL(&_0, (raw ? 1 : 0));	ZEPHIR_CALL_FUNCTION(&hmac, "hash_hmac", NULL, 397, algo, data, key, &_0);	zephir_check_call_status();	if (!(zephir_is_true(hmac))) {		ZEPHIR_INIT_VAR(_1$$3);		object_init_ex(_1$$3, phalcon_security_exception_ce);		ZEPHIR_INIT_VAR(_2$$3);		ZEPHIR_CONCAT_SV(_2$$3, "Unknown hashing algorithm: %s", algo);		ZEPHIR_CALL_METHOD(NULL, _1$$3, "__construct", NULL, 9, _2$$3);		zephir_check_call_status();		zephir_throw_exception_debug(_1$$3, "phalcon/security.zep", 441 TSRMLS_CC);		ZEPHIR_MM_RESTORE();		return;	}	RETURN_CCTOR(hmac);}

/** * Rollbacks the transaction * * @param  string rollbackMessage * @param  Phalcon/Mvc/ModelInterface rollbackRecord * @return boolean */PHP_METHOD(Phalcon_Mvc_Model_Transaction, rollback) {	zval *_1$$3, *_3$$3;	int ZEPHIR_LAST_CALL_STATUS;	zval *rollbackMessage = NULL, *rollbackRecord = NULL, *manager = NULL, *connection = NULL, *_4 = NULL, *_0$$3, *_2$$3, *_5$$4, *_6$$4;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 0, 2, &rollbackMessage, &rollbackRecord);	if (!rollbackMessage) {		ZEPHIR_CPY_WRT(rollbackMessage, ZEPHIR_GLOBAL(global_null));	} else {		ZEPHIR_SEPARATE_PARAM(rollbackMessage);	}	if (!rollbackRecord) {		rollbackRecord = ZEPHIR_GLOBAL(global_null);	}	ZEPHIR_OBS_VAR(manager);	zephir_read_property_this(&manager, this_ptr, SL("_manager"), PH_NOISY_CC);	if (Z_TYPE_P(manager) == IS_OBJECT) {		ZEPHIR_INIT_VAR(_0$$3);		ZEPHIR_INIT_VAR(_1$$3);		zephir_create_array(_1$$3, 2, 0 TSRMLS_CC);		zephir_array_fast_append(_1$$3, manager);		ZEPHIR_INIT_VAR(_2$$3);		ZVAL_STRING(_2$$3, "notifyRollback", 1);		zephir_array_fast_append(_1$$3, _2$$3);		ZEPHIR_INIT_VAR(_3$$3);		zephir_create_array(_3$$3, 1, 0 TSRMLS_CC);		zephir_array_fast_append(_3$$3, this_ptr);		ZEPHIR_CALL_USER_FUNC_ARRAY(_0$$3, _1$$3, _3$$3);		zephir_check_call_status();	}	ZEPHIR_OBS_VAR(connection);	zephir_read_property_this(&connection, this_ptr, SL("_connection"), PH_NOISY_CC);	ZEPHIR_CALL_METHOD(&_4, connection, "rollback", NULL, 0);	zephir_check_call_status();	if (zephir_is_true(_4)) {		if (!(zephir_is_true(rollbackMessage))) {			ZEPHIR_INIT_NVAR(rollbackMessage);			ZVAL_STRING(rollbackMessage, "Transaction aborted", 1);		}		if (Z_TYPE_P(rollbackRecord) == IS_OBJECT) {			zephir_update_property_this(this_ptr, SL("_rollbackRecord"), rollbackRecord TSRMLS_CC);		}		ZEPHIR_INIT_VAR(_5$$4);		object_init_ex(_5$$4, phalcon_mvc_model_transaction_failed_ce);		_6$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_rollbackRecord"), PH_NOISY_CC);		ZEPHIR_CALL_METHOD(NULL, _5$$4, "__construct", NULL, 349, rollbackMessage, _6$$4);		zephir_check_call_status();		zephir_throw_exception_debug(_5$$4, "phalcon/mvc/model/transaction.zep", 160 TSRMLS_CC);		ZEPHIR_MM_RESTORE();		return;	}	RETURN_MM_BOOL(1);}

/** * Load translates from file * * @param string file * @param int length * @param string delimiter * @param string enclosure */PHP_METHOD(Phalcon_Translate_Adapter_Csv, _load) {	zend_bool _6;	zephir_fcall_cache_entry *_3 = NULL;	int ZEPHIR_LAST_CALL_STATUS;	zval *file, *length, *delimiter, *enclosure, *data = NULL, *fileHandler = NULL, _0 = zval_used_for_init, *_1 = NULL, *_2, *_4, _5 = zval_used_for_init, *_7, *_8 = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 4, 0, &file, &length, &delimiter, &enclosure);	ZEPHIR_SINIT_VAR(_0);	ZVAL_STRING(&_0, "rb", 0);	ZEPHIR_CALL_FUNCTION(&fileHandler, "fopen", NULL, 292, file, &_0);	zephir_check_call_status();	if (Z_TYPE_P(fileHandler) != IS_RESOURCE) {		ZEPHIR_INIT_VAR(_1);		object_init_ex(_1, phalcon_translate_exception_ce);		ZEPHIR_INIT_VAR(_2);		ZEPHIR_CONCAT_SVS(_2, "Error opening translation file '", file, "'");		ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 9, _2);		zephir_check_call_status();		zephir_throw_exception_debug(_1, "phalcon/translate/adapter/csv.zep", 64 TSRMLS_CC);		ZEPHIR_MM_RESTORE();		return;	}	while (1) {		ZEPHIR_CALL_FUNCTION(&data, "fgetcsv", &_3, 428, fileHandler, length, delimiter, enclosure);		zephir_check_call_status();		if (ZEPHIR_IS_FALSE_IDENTICAL(data)) {			break;		}		zephir_array_fetch_long(&_4, data, 0, PH_NOISY | PH_READONLY, "phalcon/translate/adapter/csv.zep", 74 TSRMLS_CC);		ZEPHIR_SINIT_NVAR(_0);		ZVAL_LONG(&_0, 0);		ZEPHIR_SINIT_NVAR(_5);		ZVAL_LONG(&_5, 1);		ZEPHIR_INIT_NVAR(_1);		zephir_substr(_1, _4, 0 , 1 , 0);		_6 = ZEPHIR_IS_STRING_IDENTICAL(_1, "#");		if (!(_6)) {			_6 = !(zephir_array_isset_long(data, 1));		}		if (_6) {			continue;		}		zephir_array_fetch_long(&_7, data, 1, PH_NOISY | PH_READONLY, "phalcon/translate/adapter/csv.zep", 78 TSRMLS_CC);		ZEPHIR_OBS_NVAR(_8);		zephir_array_fetch_long(&_8, data, 0, PH_NOISY, "phalcon/translate/adapter/csv.zep", 78 TSRMLS_CC);		zephir_update_property_array(this_ptr, SL("_translate"), _8, _7 TSRMLS_CC);	}	zephir_fclose(fileHandler TSRMLS_CC);	ZEPHIR_MM_RESTORE();}

/** * Prepares event for execution by lazy-loading listener objects. * * @param string|/Xpl/Event/Event event The event ID or object to trigger. * @return boolean|array False if no listeners, otherwise indexed array of the * Event object (at index 0) and an array of listeners (at index 1). * * @throws /InvalidArgumentException if event is not a string or Event object. */PHP_METHOD(Xpl_Event_Manager, prepare) {	zval *_4$$7;	int ZEPHIR_LAST_CALL_STATUS;	zval *event, *eventObj = NULL, *eventId = NULL, *listeners = NULL, *onceListener = NULL, *_3, *_0$$5, *_1$$5, *_2$$5;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &event);	if (Z_TYPE_P(event) == IS_STRING) {		ZEPHIR_CPY_WRT(eventId, event);		ZEPHIR_INIT_VAR(eventObj);		object_init_ex(eventObj, xpl_event_event_ce);		ZEPHIR_CALL_METHOD(NULL, eventObj, "__construct", NULL, 104, event);		zephir_check_call_status();	} else if (zephir_instance_of_ev(event, xpl_event_event_ce TSRMLS_CC)) {		ZEPHIR_CPY_WRT(eventObj, event);		ZEPHIR_CALL_METHOD(&eventId, event, "getid", NULL, 0);		zephir_check_call_status();	} else {		ZEPHIR_INIT_VAR(_0$$5);		object_init_ex(_0$$5, spl_ce_InvalidArgumentException);		ZEPHIR_INIT_VAR(_1$$5);		zephir_gettype(_1$$5, event TSRMLS_CC);		ZEPHIR_INIT_VAR(_2$$5);		ZEPHIR_CONCAT_SV(_2$$5, "Event must be string or instance of Event, given: ", _1$$5);		ZEPHIR_CALL_METHOD(NULL, _0$$5, "__construct", NULL, 5, _2$$5);		zephir_check_call_status();		zephir_throw_exception_debug(_0$$5, "xpl/event/manager.zep", 367 TSRMLS_CC);		ZEPHIR_MM_RESTORE();		return;	}	_3 = zephir_fetch_nproperty_this(this_ptr, SL("listeners"), PH_NOISY_CC);	if (!(zephir_array_isset_fetch(&listeners, _3, eventId, 1 TSRMLS_CC))) {		RETURN_MM_BOOL(0);	}	if (zephir_array_isset_string_fetch(&onceListener, listeners, SS("one"), 1 TSRMLS_CC)) {		zephir_create_array(return_value, 2, 0 TSRMLS_CC);		zephir_array_fast_append(return_value, eventObj);		ZEPHIR_INIT_VAR(_4$$7);		zephir_create_array(_4$$7, 1, 0 TSRMLS_CC);		zephir_array_fast_append(_4$$7, onceListener);		zephir_array_fast_append(return_value, _4$$7);		RETURN_MM();	}	zephir_create_array(return_value, 2, 0 TSRMLS_CC);	zephir_array_fast_append(return_value, eventObj);	zephir_array_fast_append(return_value, listeners);	RETURN_MM();}

/** * Phalcon/Logger/Adapter/Stream constructor * * @param string name * @param array options */PHP_METHOD(Phalcon_Logger_Adapter_Stream, __construct) {    int ZEPHIR_LAST_CALL_STATUS;    zval *name_param = NULL, *options = NULL, *mode = NULL, *stream = NULL, *_0;    zval *name = NULL, *_1;    ZEPHIR_MM_GROW();    zephir_fetch_params(1, 1, 1, &name_param, &options);    if (unlikely(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) {        zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be a string") TSRMLS_CC);        RETURN_MM_NULL();    }    if (likely(Z_TYPE_P(name_param) == IS_STRING)) {        zephir_get_strval(name, name_param);    } else {        ZEPHIR_INIT_VAR(name);        ZVAL_EMPTY_STRING(name);    }    if (!options) {        options = ZEPHIR_GLOBAL(global_null);    }    ZEPHIR_OBS_VAR(mode);    if (zephir_array_isset_string_fetch(&mode, options, SS("mode"), 0 TSRMLS_CC)) {        if (zephir_memnstr_str(mode, SL("r"), "phalcon/logger/adapter/stream.zep", 61)) {            ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_logger_exception_ce, "Stream must be opened in append or write mode", "phalcon/logger/adapter/stream.zep", 62);            return;        }    } else {        ZEPHIR_INIT_NVAR(mode);        ZVAL_STRING(mode, "ab", 1);    }    ZEPHIR_CALL_FUNCTION(&stream, "fopen", NULL, 285, name, mode);    zephir_check_call_status();    if (!(zephir_is_true(stream))) {        ZEPHIR_INIT_VAR(_0);        object_init_ex(_0, phalcon_logger_exception_ce);        ZEPHIR_INIT_VAR(_1);        ZEPHIR_CONCAT_SVS(_1, "Can't open stream '", name, "'");        ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 9, _1);        zephir_check_call_status();        zephir_throw_exception_debug(_0, "phalcon/logger/adapter/stream.zep", 73 TSRMLS_CC);        ZEPHIR_MM_RESTORE();        return;    }    zephir_update_property_this(this_ptr, SL("_stream"), stream TSRMLS_CC);    ZEPHIR_MM_RESTORE();}

/** * Sets the expiration time for this cache item. * * @param /DateTimeInterface expiration *   The point in time after which the item MUST be considered expired. *   If null is passed explicitly, a default value MAY be used. If none is set, *   the value should be stored permanently or for as long as the *   implementation allows. * * @return /Xpl/Cache/Item The called object. */PHP_METHOD(Xpl_Cache_Item, expiresAt) {	int ZEPHIR_LAST_CALL_STATUS;	zval *expiration, *_0$$3, *_1$$3, *_2$$3, *_3$$5 = NULL, *_4$$5, *_5$$5, *_6$$6, *_7$$6 = NULL, _8$$6, *_9$$6 = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &expiration);	if (Z_TYPE_P(expiration) == IS_NULL) {		ZEPHIR_INIT_VAR(_0$$3);		zephir_time(_0$$3);		_1$$3 = zephir_fetch_nproperty_this(this_ptr, SL("defaultTtl"), PH_NOISY_CC);		ZEPHIR_INIT_VAR(_2$$3);		zephir_add_function(_2$$3, _0$$3, _1$$3);		zephir_update_property_this(this_ptr, SL("expires"), _2$$3 TSRMLS_CC);	} else {		if (zephir_is_instance_of(expiration, SL("DateTimeInterface") TSRMLS_CC)) {			ZEPHIR_INIT_VAR(_4$$5);			ZVAL_STRING(_4$$5, "U", ZEPHIR_TEMP_PARAM_COPY);			ZEPHIR_CALL_METHOD(&_3$$5, expiration, "format", NULL, 0, _4$$5);			zephir_check_temp_parameter(_4$$5);			zephir_check_call_status();			ZEPHIR_INIT_ZVAL_NREF(_5$$5);			ZVAL_LONG(_5$$5, zephir_get_intval(_3$$5));			zephir_update_property_this(this_ptr, SL("expires"), _5$$5 TSRMLS_CC);		} else {			ZEPHIR_INIT_VAR(_6$$6);			object_init_ex(_6$$6, xpl_cache_invalidargumentexception_ce);			ZEPHIR_INIT_VAR(_7$$6);			if (Z_TYPE_P(expiration) == IS_OBJECT) {				ZEPHIR_INIT_NVAR(_7$$6);				zephir_get_class(_7$$6, expiration, 0 TSRMLS_CC);			} else {				ZEPHIR_INIT_NVAR(_7$$6);				zephir_gettype(_7$$6, expiration TSRMLS_CC);			}			ZEPHIR_SINIT_VAR(_8$$6);			ZVAL_STRING(&_8$$6, "Expiration date must be null or instance of DateTimeInterface, given: /"%s/".", 0);			ZEPHIR_CALL_FUNCTION(&_9$$6, "sprintf", NULL, 41, &_8$$6, _7$$6);			zephir_check_call_status();			ZEPHIR_CALL_METHOD(NULL, _6$$6, "__construct", NULL, 42, _9$$6);			zephir_check_call_status();			zephir_throw_exception_debug(_6$$6, "xpl/cache/item.zep", 147 TSRMLS_CC);			ZEPHIR_MM_RESTORE();			return;		}	}	RETURN_THIS();}