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

/** * Obtains a value from the session bag optionally setting a default value * *<code> * echo $user->get("name", "Kimbra"); *</code> */PHP_METHOD(Phalcon_Session_Bag, get) {	zend_long ZEPHIR_LAST_CALL_STATUS;	zval *property_param = NULL, *defaultValue = NULL, *value = NULL, *_0, *_1;	zval *property = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 1, &property_param, &defaultValue);	if (UNEXPECTED(Z_TYPE_P(property_param) != IS_STRING && Z_TYPE_P(property_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'property' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (EXPECTED(Z_TYPE_P(property_param) == IS_STRING)) {		zephir_get_strval(property, property_param);	} else {		ZEPHIR_INIT_VAR(property);		ZVAL_EMPTY_STRING(property);	}	if (!defaultValue) {		defaultValue = ZEPHIR_GLOBAL(global_null);	}	_0 = zephir_fetch_nproperty_this(this_ptr, SL("_initialized"), PH_NOISY_CC);	if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {		ZEPHIR_CALL_METHOD(NULL, this_ptr, "initialize", NULL, 0);		zephir_check_call_status();	}	_1 = zephir_fetch_nproperty_this(this_ptr, SL("_data"), PH_NOISY_CC);	if (zephir_array_isset_fetch(&value, _1, property, 1 TSRMLS_CC)) {		RETURN_CTOR(value);	}	RETVAL_ZVAL(defaultValue, 1, 0);	RETURN_MM();}

/** * Returns an element added to the form by its name */PHP_METHOD(Phalcon_Forms_Form, get) {	int ZEPHIR_LAST_CALL_STATUS;	zval *name_param = NULL, *element = NULL, *_0, *_1;	zval *name = NULL, *_2;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &name_param);	if (UNEXPECTED(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 (EXPECTED(Z_TYPE_P(name_param) == IS_STRING)) {		zephir_get_strval(name, name_param);	} else {		ZEPHIR_INIT_VAR(name);		ZVAL_EMPTY_STRING(name);	}	ZEPHIR_OBS_VAR(element);	_0 = zephir_fetch_nproperty_this(this_ptr, SL("_elements"), PH_NOISY_CC);	if (zephir_array_isset_fetch(&element, _0, name, 0 TSRMLS_CC)) {		RETURN_CCTOR(element);	}	ZEPHIR_INIT_VAR(_1);	object_init_ex(_1, phalcon_forms_exception_ce);	ZEPHIR_INIT_VAR(_2);	ZEPHIR_CONCAT_SVS(_2, "Element with ID=", name, " is not part of the form");	ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 9, _2);	zephir_check_call_status();	zephir_throw_exception_debug(_1, "phalcon/forms/form.zep", 482 TSRMLS_CC);	ZEPHIR_MM_RESTORE();	return;}

/** * Replaces placeholders by the values passed */PHP_METHOD(Phalcon_Translate_Adapter, replacePlaceholders) {	zend_long ZEPHIR_LAST_CALL_STATUS;	zval *translation_param = NULL, *placeholders = NULL, placeholders_sub, __$null, _0;	zval translation;	zval *this_ptr = getThis();	ZVAL_UNDEF(&translation);	ZVAL_UNDEF(&placeholders_sub);	ZVAL_NULL(&__$null);	ZVAL_UNDEF(&_0);	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 1, &translation_param, &placeholders);	if (UNEXPECTED(Z_TYPE_P(translation_param) != IS_STRING && Z_TYPE_P(translation_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'translation' must be of the type string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (EXPECTED(Z_TYPE_P(translation_param) == IS_STRING)) {		zephir_get_strval(&translation, translation_param);	} else {		ZEPHIR_INIT_VAR(&translation);		ZVAL_EMPTY_STRING(&translation);	}	if (!placeholders) {		placeholders = &placeholders_sub;		placeholders = &__$null;	}	zephir_read_property(&_0, this_ptr, SL("_interpolator"), PH_NOISY_CC | PH_READONLY);	ZEPHIR_RETURN_CALL_METHOD(&_0, "replaceplaceholders", NULL, 0, &translation, placeholders);	zephir_check_call_status();	RETURN_MM();}

/** * Can delay any new job being reserved for a given time. */PHP_METHOD(Phalcon_Queue_Beanstalk, pauseTube) {	int delay, ZEPHIR_LAST_CALL_STATUS;	zval *tube_param = NULL, *delay_param = NULL, *response = NULL, _0, *_2;	zval *tube = NULL, *_1;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 2, 0, &tube_param, &delay_param);	if (UNEXPECTED(Z_TYPE_P(tube_param) != IS_STRING && Z_TYPE_P(tube_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'tube' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (EXPECTED(Z_TYPE_P(tube_param) == IS_STRING)) {		zephir_get_strval(tube, tube_param);	} else {		ZEPHIR_INIT_VAR(tube);		ZVAL_EMPTY_STRING(tube);	}	delay = zephir_get_intval(delay_param);	ZEPHIR_SINIT_VAR(_0);	ZVAL_LONG(&_0, delay);	ZEPHIR_INIT_VAR(_1);	ZEPHIR_CONCAT_SVSV(_1, "pause-tube ", tube, " ", &_0);	ZEPHIR_CALL_METHOD(NULL, this_ptr, "write", NULL, 0, _1);	zephir_check_call_status();	ZEPHIR_CALL_METHOD(&response, this_ptr, "readstatus", NULL, 409);	zephir_check_call_status();	zephir_array_fetch_long(&_2, response, 0, PH_NOISY | PH_READONLY, "phalcon/queue/beanstalk.zep", 289 TSRMLS_CC);	if (!ZEPHIR_IS_STRING(_2, "PAUSED")) {		RETURN_MM_BOOL(0);	}	RETURN_MM_BOOL(1);}

/** * Removes all events from the EventsManager */PHP_METHOD(Phalcon_Events_Manager, detachAll) {	zval *type_param = NULL, *_0$$4, *_1$$5;	zval *type = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 0, 1, &type_param);	if (!type_param) {		ZEPHIR_INIT_VAR(type);		ZVAL_EMPTY_STRING(type);	} else {	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);	}	}	if (ZEPHIR_IS_STRING_IDENTICAL(type, "")) {		zephir_update_property_this(this_ptr, SL("_events"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);	} else {		_0$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_events"), PH_NOISY_CC);		if (zephir_array_isset(_0$$4, type)) {			_1$$5 = zephir_fetch_nproperty_this(this_ptr, SL("_events"), PH_NOISY_CC);			zephir_array_unset(&_1$$5, type, PH_SEPARATE);		}	}	ZEPHIR_MM_RESTORE();}

/** * Change the base URI for static resources */PHP_METHOD(Phalcon_Debug, setUri) {	zval *uri_param = NULL;	zval *uri = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &uri_param);	if (UNEXPECTED(Z_TYPE_P(uri_param) != IS_STRING && Z_TYPE_P(uri_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'uri' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (EXPECTED(Z_TYPE_P(uri_param) == IS_STRING)) {		zephir_get_strval(uri, uri_param);	} else {		ZEPHIR_INIT_VAR(uri);		ZVAL_EMPTY_STRING(uri);	}	zephir_update_property_this(this_ptr, SL("_uri"), uri TSRMLS_CC);	RETURN_THIS();}

/** * Phalcon/Di/Service * * @param string name * @param mixed definition * @param boolean shared */PHP_METHOD(Phalcon_Di_Service, __construct) {	zend_bool shared;	zval *name_param = NULL, *definition, *shared_param = NULL;	zval *name = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 2, 1, &name_param, &definition, &shared_param);	if (UNEXPECTED(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 (EXPECTED(Z_TYPE_P(name_param) == IS_STRING)) {		zephir_get_strval(name, name_param);	} else {		ZEPHIR_INIT_VAR(name);		ZVAL_EMPTY_STRING(name);	}	if (!shared_param) {		shared = 0;	} else {		shared = zephir_get_boolval(shared_param);	}	zephir_update_property_this(this_ptr, SL("_name"), name TSRMLS_CC);	zephir_update_property_this(this_ptr, SL("_definition"), definition TSRMLS_CC);	if (shared) {		zephir_update_property_this(this_ptr, SL("_shared"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);	} else {		zephir_update_property_this(this_ptr, SL("_shared"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);	}	ZEPHIR_MM_RESTORE();}

/** * Sets views directory. Depending of your platform, always add a trailing slash or backslash */PHP_METHOD(Phalcon_Mvc_View_Simple, setViewsDir) {	zval *viewsDir_param = NULL;	zval *viewsDir = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &viewsDir_param);	if (UNEXPECTED(Z_TYPE_P(viewsDir_param) != IS_STRING && Z_TYPE_P(viewsDir_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'viewsDir' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (EXPECTED(Z_TYPE_P(viewsDir_param) == IS_STRING)) {		zephir_get_strval(viewsDir, viewsDir_param);	} else {		ZEPHIR_INIT_VAR(viewsDir);		ZVAL_EMPTY_STRING(viewsDir);	}	zephir_update_property_this(getThis(), SL("_viewsDir"), viewsDir TSRMLS_CC);	ZEPHIR_MM_RESTORE();}

PHP_METHOD(Test_TryTest, testTry8) {	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 1!");		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", 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;}

/** * Sets the domain default to search within when calls are made to gettext() */PHP_METHOD(Phalcon_Translate_Adapter_Gettext, setDefaultDomain) {	zval *domain_param = NULL;	zval *domain = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &domain_param);	if (UNEXPECTED(Z_TYPE_P(domain_param) != IS_STRING && Z_TYPE_P(domain_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'domain' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (EXPECTED(Z_TYPE_P(domain_param) == IS_STRING)) {		zephir_get_strval(domain, domain_param);	} else {		ZEPHIR_INIT_VAR(domain);		ZVAL_EMPTY_STRING(domain);	}	zephir_update_property_this(getThis(), SL("_defaultDomain"), domain TSRMLS_CC);	ZEPHIR_MM_RESTORE();}

/** * Sets the form's action */PHP_METHOD(Phalcon_Forms_Form, setAction) {	zval *action_param = NULL;	zval *action = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &action_param);	if (UNEXPECTED(Z_TYPE_P(action_param) != IS_STRING && Z_TYPE_P(action_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'action' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (EXPECTED(Z_TYPE_P(action_param) == IS_STRING)) {		zephir_get_strval(action, action_param);	} else {		ZEPHIR_INIT_VAR(action);		ZVAL_EMPTY_STRING(action);	}	zephir_update_property_this(getThis(), SL("_action"), action TSRMLS_CC);	RETURN_THIS();}

/** * Check on empty */PHP_METHOD(Phalcon_Validation_Validator_File, isAllowEmpty) {	zend_bool _0, _1;	zend_long ZEPHIR_LAST_CALL_STATUS;	zval *field = NULL;	zval *validation, *field_param = NULL, *value = NULL, *_2;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 2, 0, &validation, &field_param);	if (UNEXPECTED(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (EXPECTED(Z_TYPE_P(field_param) == IS_STRING)) {		zephir_get_strval(field, field_param);	} else {		ZEPHIR_INIT_VAR(field);		ZVAL_EMPTY_STRING(field);	}	ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);	zephir_check_call_status();	_0 = ZEPHIR_IS_EMPTY(value);	if (!(_0)) {		_1 = zephir_array_isset_string(value, SS("error"));		if (_1) {			zephir_array_fetch_string(&_2, value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 301 TSRMLS_CC);			_1 = ZEPHIR_IS_LONG_IDENTICAL(_2, 4);		}		_0 = _1;	}	RETURN_MM_BOOL(_0);}

/** * Writes an attribute value by its name * *<code> *  $robot->writeAttribute("name", "Rosey"); *</code> * * @param string attribute * @param mixed value */PHP_METHOD(Phalcon_Mvc_Collection_Document, writeAttribute) {	zval *attribute_param = NULL, *value;	zval *attribute = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 2, 0, &attribute_param, &value);	if (UNEXPECTED(Z_TYPE_P(attribute_param) != IS_STRING && Z_TYPE_P(attribute_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'attribute' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (EXPECTED(Z_TYPE_P(attribute_param) == IS_STRING)) {		zephir_get_strval(attribute, attribute_param);	} else {		ZEPHIR_INIT_VAR(attribute);		ZVAL_EMPTY_STRING(attribute);	}	zephir_update_property_zval_zval(getThis(), attribute, value TSRMLS_CC);	ZEPHIR_MM_RESTORE();}

PHP_METHOD(Test_Instanceoff, testInstanceOf2) {    zval a;    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(&a);    ZEPHIR_MM_GROW();    ZEPHIR_INIT_VAR(&a);    object_init_ex(&a, test_instanceoff_ce);    if (zephir_has_constructor(&a TSRMLS_CC)) {        ZEPHIR_CALL_METHOD(NULL, &a, "__construct", NULL, 0);        zephir_check_call_status();    }    RETURN_MM_BOOL(zephir_instance_of_ev(&a, test_instanceoff_ce TSRMLS_CC));}

PHP_METHOD(Test_Oo, testInstance3) {	zval o;	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(&o);	ZEPHIR_MM_GROW();	ZEPHIR_INIT_VAR(&o);	object_init_ex(&o, test_oo_oonoconstruct_ce);	if (zephir_has_constructor(&o TSRMLS_CC)) {		ZEPHIR_CALL_METHOD(NULL, &o, "__construct", NULL, 0);		zephir_check_call_status();	}	RETURN_CCTOR(o);}

/** * Adds a converter to perform an additional transformation for certain parameter * * @param string name * @param callable converter * @return /Phalcon/Cli/Router/Route */PHP_METHOD(Phalcon_Cli_Router_Route, convert) {	zval *name_param = NULL, *converter;	zval *name = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 2, 0, &name_param, &converter);	if (UNEXPECTED(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 (EXPECTED(Z_TYPE_P(name_param) == IS_STRING)) {		zephir_get_strval(name, name_param);	} else {		ZEPHIR_INIT_VAR(name);		ZVAL_EMPTY_STRING(name);	}	zephir_update_property_array(this_ptr, SL("_converters"), name, converter TSRMLS_CC);	RETURN_THIS();}

/** * Sets the cipher algorithm */PHP_METHOD(Phalcon_Crypt, setCipher) {	zval *cipher_param = NULL;	zval *cipher = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &cipher_param);	if (UNEXPECTED(Z_TYPE_P(cipher_param) != IS_STRING && Z_TYPE_P(cipher_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'cipher' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (EXPECTED(Z_TYPE_P(cipher_param) == IS_STRING)) {		zephir_get_strval(cipher, cipher_param);	} else {		ZEPHIR_INIT_VAR(cipher);		ZVAL_EMPTY_STRING(cipher);	}	zephir_update_property_this(getThis(), SL("_cipher"), cipher TSRMLS_CC);	RETURN_THIS();}

/** * Check whether an option has been defined in the validator options */PHP_METHOD(Phalcon_Mvc_Model_Validator, isSetOption) {	zval *option_param = NULL, *_0;	zval *option = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &option_param);	if (UNEXPECTED(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 (EXPECTED(Z_TYPE_P(option_param) == IS_STRING)) {		zephir_get_strval(option, option_param);	} else {		ZEPHIR_INIT_VAR(option);		ZVAL_EMPTY_STRING(option);	}	_0 = zephir_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY_CC);	RETURN_MM_BOOL(zephir_array_isset(_0, option));}

/** * Sets a base path for all the generated paths * *<code> * $url->setBasePath("/var/www/htdocs/"); *</code> */PHP_METHOD(Phalcon_Mvc_Url, setBasePath) {	zval *basePath_param = NULL;	zval *basePath = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &basePath_param);	if (UNEXPECTED(Z_TYPE_P(basePath_param) != IS_STRING && Z_TYPE_P(basePath_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'basePath' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (EXPECTED(Z_TYPE_P(basePath_param) == IS_STRING)) {		zephir_get_strval(basePath, basePath_param);	} else {		ZEPHIR_INIT_VAR(basePath);		ZVAL_EMPTY_STRING(basePath);	}	zephir_update_property_this(getThis(), SL("_basePath"), basePath TSRMLS_CC);	RETURN_THIS();}

PHP_METHOD(Test_Strings, testSubstr2) {	int from;	zval *str, str_sub, *from_param = NULL, _0;		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(&str_sub);	ZVAL_UNDEF(&_0);	zephir_fetch_params(0, 2, 0, &str, &from_param);	from = zephir_get_intval(from_param);	ZVAL_LONG(&_0, from);	zephir_substr(return_value, str, zephir_get_intval(&_0), 0, ZEPHIR_SUBSTR_NO_LENGTH);	return;}

PHP_METHOD(Test_ResourceTest, testFunctionsForSTDIN) {	zval a, _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(&a);	ZVAL_UNDEF(&_0);	ZEPHIR_MM_GROW();	ZEPHIR_INIT_VAR(&a);	ZEPHIR_GET_CONSTANT(&a, "STDIN");	ZVAL_LONG(&_0, 1);	ZEPHIR_CALL_FUNCTION(NULL, "stream_set_blocking", NULL, 56, &a, &_0);	zephir_check_call_status();	ZEPHIR_MM_RESTORE();}

/** * Sets verbose message */PHP_METHOD(Phalcon_Mvc_Model_Message, setMessage) {	zval *message_param = NULL;	zval *message = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &message_param);	if (UNEXPECTED(Z_TYPE_P(message_param) != IS_STRING && Z_TYPE_P(message_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'message' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (EXPECTED(Z_TYPE_P(message_param) == IS_STRING)) {		zephir_get_strval(message, message_param);	} else {		ZEPHIR_INIT_VAR(message);		ZVAL_EMPTY_STRING(message);	}	zephir_update_property_this(getThis(), SL("_message"), message TSRMLS_CC);	RETURN_THIS();}

/** * Changes the action method suffix */PHP_METHOD(Phalcon_Mvc_Router_Annotations, setActionSuffix) {	zval *actionSuffix_param = NULL;	zval *actionSuffix = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &actionSuffix_param);	if (UNEXPECTED(Z_TYPE_P(actionSuffix_param) != IS_STRING && Z_TYPE_P(actionSuffix_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'actionSuffix' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (EXPECTED(Z_TYPE_P(actionSuffix_param) == IS_STRING)) {		zephir_get_strval(actionSuffix, actionSuffix_param);	} else {		ZEPHIR_INIT_VAR(actionSuffix);		ZVAL_EMPTY_STRING(actionSuffix);	}	zephir_update_property_this(getThis(), SL("_actionSuffix"), actionSuffix TSRMLS_CC);	ZEPHIR_MM_RESTORE();}