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

/** * Sets a prefix for all routes added to the collection */PHP_METHOD(Phalcon_Mvc_Micro_Collection, setPrefix) {	zval *prefix_param = NULL;	zval *prefix = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &prefix_param);	if (UNEXPECTED(Z_TYPE_P(prefix_param) != IS_STRING && Z_TYPE_P(prefix_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'prefix' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (EXPECTED(Z_TYPE_P(prefix_param) == IS_STRING)) {		zephir_get_strval(prefix, prefix_param);	} else {		ZEPHIR_INIT_VAR(prefix);		ZVAL_EMPTY_STRING(prefix);	}	zephir_update_property_this(getThis(), SL("_prefix"), prefix TSRMLS_CC);	RETURN_THIS();}

/** * Sets a hostname restriction to the route * *<code> * $route->setHostname('localhost'); *</code> */PHP_METHOD(Phalcon_Mvc_Router_Route, setHostname) {	zval *hostname_param = NULL;	zval *hostname = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &hostname_param);	if (unlikely(Z_TYPE_P(hostname_param) != IS_STRING && Z_TYPE_P(hostname_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'hostname' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (likely(Z_TYPE_P(hostname_param) == IS_STRING)) {		zephir_get_strval(hostname, hostname_param);	} else {		ZEPHIR_INIT_VAR(hostname);		ZVAL_EMPTY_STRING(hostname);	}	zephir_update_property_this(this_ptr, SL("_hostname"), hostname TSRMLS_CC);	RETURN_THIS();}

/** * Phalcon/Validation/Validator constructor */PHP_METHOD(Phalcon_Validation_Validator, __construct) {	zend_bool _0;	zval *options = NULL;	zephir_fetch_params(0, 0, 1, &options);	if (!options) {		options = ZEPHIR_GLOBAL(global_null);	}	_0 = Z_TYPE_P(options) != IS_ARRAY;	if (_0) {		_0 = Z_TYPE_P(options) != IS_NULL;	}	if (_0) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(phalcon_validation_exception_ce, "Options must be an array", "phalcon/validation/validator.zep", 39);		return;	} else {		zephir_update_property_this(this_ptr, SL("_options"), options TSRMLS_CC);	}}

/** * Externally sets the view content * *<code> *	$this->view->setContent("<h1>hello</h1>"); *</code> */PHP_METHOD(Phalcon_Mvc_View_Simple, setContent) {	zval *content_param = NULL;	zval *content = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &content_param);	if (unlikely(Z_TYPE_P(content_param) != IS_STRING && Z_TYPE_P(content_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'content' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (likely(Z_TYPE_P(content_param) == IS_STRING)) {		zephir_get_strval(content, content_param);	} else {		ZEPHIR_INIT_VAR(content);		ZVAL_EMPTY_STRING(content);	}	zephir_update_property_this(this_ptr, SL("_content"), content TSRMLS_CC);	RETURN_THIS();}

/** * Phalcon/Mvc/Micro/LazyLoader constructor */PHP_METHOD(Phalcon_Mvc_Micro_LazyLoader, __construct) {	zval *definition_param = NULL;	zval *definition = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &definition_param);	if (UNEXPECTED(Z_TYPE_P(definition_param) != IS_STRING && Z_TYPE_P(definition_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'definition' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (EXPECTED(Z_TYPE_P(definition_param) == IS_STRING)) {		zephir_get_strval(definition, definition_param);	} else {		ZEPHIR_INIT_VAR(definition);		ZVAL_EMPTY_STRING(definition);	}	zephir_update_property_this(this_ptr, SL("_definition"), definition 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(this_ptr, SL("_action"), action TSRMLS_CC);	RETURN_THIS();}

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

/** * Sets a target uri for the generated HTML */PHP_METHOD(Phalcon_Assets_Collection, setTargetUri) {	zval *targetUri_param = NULL;	zval *targetUri = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &targetUri_param);	if (unlikely(Z_TYPE_P(targetUri_param) != IS_STRING && Z_TYPE_P(targetUri_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'targetUri' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (likely(Z_TYPE_P(targetUri_param) == IS_STRING)) {		zephir_get_strval(targetUri, targetUri_param);	} else {		ZEPHIR_INIT_VAR(targetUri);		ZVAL_EMPTY_STRING(targetUri);	}	zephir_update_property_this(this_ptr, SL("_targetUri"), targetUri TSRMLS_CC);	RETURN_THIS();}

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

/** * Registers a set of PSR-4 directories for a given namespace, * replacing any others previously set for this namespace. * * @param string       $prefix The prefix/namespace, with trailing "//" * @param array|string $paths  The PSR-4 base directories * * @throws /InvalidArgumentException */PHP_METHOD(Xpl_ClassLoader, setPsr4) {	zval *prefix, *paths = NULL, *_0$$4, _1$$4, _2$$4, *_3$$4;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 2, 0, &prefix, &paths);	ZEPHIR_SEPARATE_PARAM(paths);	if (Z_TYPE_P(paths) == IS_STRING) {		ZEPHIR_INIT_NVAR(paths);		zephir_create_array(paths, 1, 0 TSRMLS_CC);		zephir_array_fast_append(paths, paths);	}	if (Z_TYPE_P(prefix) == IS_STRING) {		if (!(zephir_end_with_str(prefix, SL("//")))) {			ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "A non-empty PSR-4 prefix must end with a namespace separator.", "xpl/classloader.zep", 366);			return;		}		ZEPHIR_INIT_VAR(_0$$4);		ZVAL_LONG(_0$$4, zephir_fast_strlen_ev(prefix));		ZEPHIR_SINIT_VAR(_1$$4);		ZVAL_LONG(&_1$$4, 0);		ZEPHIR_SINIT_VAR(_2$$4);		ZVAL_LONG(&_2$$4, 1);		ZEPHIR_INIT_VAR(_3$$4);		zephir_substr(_3$$4, prefix, 0 , 1 , 0);		zephir_update_property_array_multi(this_ptr, SL("prefixLengthsPsr4"), &_0$$4 TSRMLS_CC, SL("zz"), 2, _3$$4, prefix);		zephir_update_property_array(this_ptr, SL("prefixDirsPsr4"), prefix, paths TSRMLS_CC);	} else {		zephir_update_property_this(this_ptr, SL("fallbackDirsPsr4"), paths TSRMLS_CC);	}	ZEPHIR_MM_RESTORE();}

/** * Sets the default controller name */PHP_METHOD(Phalcon_Mvc_Dispatcher, setDefaultController) {	zval *controllerName_param = NULL;	zval *controllerName = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &controllerName_param);	if (UNEXPECTED(Z_TYPE_P(controllerName_param) != IS_STRING && Z_TYPE_P(controllerName_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'controllerName' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (EXPECTED(Z_TYPE_P(controllerName_param) == IS_STRING)) {		zephir_get_strval(controllerName, controllerName_param);	} else {		ZEPHIR_INIT_VAR(controllerName);		ZVAL_EMPTY_STRING(controllerName);	}	zephir_update_property_this(getThis(), SL("_defaultHandler"), controllerName TSRMLS_CC);	ZEPHIR_MM_RESTORE();}

/** * Sets the route's name * *<code> * $router->add( *     "/about", *     [ *         "controller" => "about", *     ] * )->setName("about"); *</code> */PHP_METHOD(Phalcon_Cli_Router_Route, setName) {	zval *name_param = NULL;	zval *name = NULL;	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_update_property_this(this_ptr, SL("_name"), name TSRMLS_CC);	RETURN_THIS();}

/** * 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(this_ptr, SL("_message"), message TSRMLS_CC);	RETURN_THIS();}

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

/** * Sets the encryption key */PHP_METHOD(Phalcon_Crypt, setKey) {	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);	}	zephir_update_property_this(this_ptr, SL("_key"), key TSRMLS_CC);	RETURN_THIS();}

/** * Phalcon/Session/Bag constructor */PHP_METHOD(Phalcon_Session_Bag, __construct) {	zval *name_param = NULL;	zval *name = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &name_param);	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);	}	zephir_update_property_this(this_ptr, SL("_name"), name TSRMLS_CC);	ZEPHIR_MM_RESTORE();}

/** * Constructor * * @param string $message * @param string $usage */PHP_METHOD(ZendFramework_Console_Exception_RuntimeException, __construct) {	int ZEPHIR_LAST_CALL_STATUS;	zval *message_param = NULL, *usage_param = NULL;	zval *message = NULL, *usage = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 1, &message_param, &usage_param);	zephir_get_strval(message, message_param);	if (!usage_param) {		ZEPHIR_INIT_VAR(usage);		ZVAL_STRING(usage, "", 1);	} else {		zephir_get_strval(usage, usage_param);	}	zephir_update_property_this(this_ptr, SL("usage"), usage TSRMLS_CC);	ZEPHIR_CALL_PARENT(NULL, zendframework_console_exception_runtimeexception_ce, this_ptr, "__construct", NULL, message);	zephir_check_call_status();	ZEPHIR_MM_RESTORE();}

/** * 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 (unlikely(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 (likely(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(this_ptr, SL("_defaultDomain"), domain TSRMLS_CC);	ZEPHIR_MM_RESTORE();}

/** * Sets the path for a domain */PHP_METHOD(Phalcon_Translate_Adapter_Gettext, setDirectory) {	int ZEPHIR_LAST_CALL_STATUS;	zephir_fcall_cache_entry *_3 = NULL;	HashTable *_1;	HashPosition _0;	zval *directory, *key = NULL, *value = NULL, **_2, *_4 = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &directory);	zephir_update_property_this(this_ptr, SL("_directory"), directory TSRMLS_CC);	if (Z_TYPE_P(directory) == IS_ARRAY) {		if (zephir_fast_count_int(directory TSRMLS_CC)) {			zephir_is_iterable(directory, &_1, &_0, 0, 0, "phalcon/translate/adapter/gettext.zep", 180);			for (			  ; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS			  ; zephir_hash_move_forward_ex(_1, &_0)			) {				ZEPHIR_GET_HMKEY(key, _1, _0);				ZEPHIR_GET_HVALUE(value, _2);				ZEPHIR_CALL_FUNCTION(NULL, "bindtextdomain", &_3, 423, key, value);				zephir_check_call_status();			}		}	} else {		ZEPHIR_CALL_METHOD(&_4, this_ptr, "getdefaultdomain", NULL, 0);		zephir_check_call_status();		ZEPHIR_CALL_FUNCTION(NULL, "bindtextdomain", &_3, 423, _4, directory);		zephir_check_call_status();	}	ZEPHIR_MM_RESTORE();}

/** * Sets message type */PHP_METHOD(Phalcon_Mvc_Model_Message, setType) {	zval *type_param = NULL;	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);	}	zephir_update_property_this(this_ptr, SL("_type"), type TSRMLS_CC);	RETURN_THIS();}

/** * Sets field name related to message */PHP_METHOD(Phalcon_Validation_Message, setField) {	zval *field_param = NULL;	zval *field = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &field_param);	if (unlikely(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 (likely(Z_TYPE_P(field_param) == IS_STRING)) {		zephir_get_strval(field, field_param);	} else {		ZEPHIR_INIT_VAR(field);		ZVAL_EMPTY_STRING(field);	}	zephir_update_property_this(this_ptr, SL("_field"), field 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();}

/** * Returns a cached content * * @param 	string keyName * @param   long lifetime * @return  mixed */PHP_METHOD(Phalcon_Cache_Backend_Memory, get) {	int ZEPHIR_LAST_CALL_STATUS;	zval *keyName, *lifetime = NULL, *lastKey = NULL, *cachedContent, *_0;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 1, &keyName, &lifetime);	if (!lifetime) {		lifetime = ZEPHIR_GLOBAL(global_null);	}	if (Z_TYPE_P(keyName) == IS_NULL) {		ZEPHIR_OBS_VAR(lastKey);		zephir_read_property_this(&lastKey, this_ptr, SL("_lastKey"), PH_NOISY_CC);	} else {		_0 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC);		ZEPHIR_INIT_NVAR(lastKey);		ZEPHIR_CONCAT_VV(lastKey, _0, keyName);		zephir_update_property_this(this_ptr, SL("_lastKey"), lastKey TSRMLS_CC);	}	ZEPHIR_OBS_VAR(cachedContent);	_0 = zephir_fetch_nproperty_this(this_ptr, SL("_data"), PH_NOISY_CC);	if (!(zephir_array_isset_fetch(&cachedContent, _0, lastKey, 0 TSRMLS_CC))) {		RETURN_MM_NULL();	}	if (Z_TYPE_P(cachedContent) == IS_NULL) {		RETURN_MM_NULL();	}	_0 = zephir_fetch_nproperty_this(this_ptr, SL("_frontend"), PH_NOISY_CC);	ZEPHIR_RETURN_CALL_METHOD(_0, "afterretrieve", NULL, cachedContent);	zephir_check_call_status();	RETURN_MM();}

PHP_METHOD(Lynx_DBAL_Driver_PgSQL, connect) {	int ZEPHIR_LAST_CALL_STATUS;	zval *_0 = NULL, *_1, *_2, *_3, *_4, *_5;	ZEPHIR_MM_GROW();	ZEPHIR_CALL_METHOD(&_0, this_ptr, "isconnected", NULL);	zephir_check_call_status();	if (zephir_is_true(_0)) {		RETURN_MM_BOOL(0);	}	ZEPHIR_INIT_VAR(_1);	object_init_ex(_1, lynx_dbal_driver_pdo_ce);	_2 = zephir_fetch_nproperty_this(this_ptr, SL("dsn"), PH_NOISY_CC);	_3 = zephir_fetch_nproperty_this(this_ptr, SL("username"), PH_NOISY_CC);	_4 = zephir_fetch_nproperty_this(this_ptr, SL("password"), PH_NOISY_CC);	_5 = zephir_fetch_nproperty_this(this_ptr, SL("driverOptions"), PH_NOISY_CC);	ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, _2, _3, _4, _5);	zephir_check_call_status();	zephir_update_property_this(this_ptr, SL("connection"), _1 TSRMLS_CC);	ZEPHIR_MM_RESTORE();}

/** * Sets the database service used to run the isolated transactions */PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, setDbService) {	zval *service_param = NULL;	zval *service = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &service_param);	if (unlikely(Z_TYPE_P(service_param) != IS_STRING && Z_TYPE_P(service_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'service' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (likely(Z_TYPE_P(service_param) == IS_STRING)) {		zephir_get_strval(service, service_param);	} else {		ZEPHIR_INIT_VAR(service);		ZVAL_EMPTY_STRING(service);	}	zephir_update_property_this(this_ptr, SL("_service"), service 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();}

//.........这里部分代码省略.........		keyName = ZEPHIR_GLOBAL(global_null);	}	if (!content) {		content = ZEPHIR_GLOBAL(global_null);	}	if (!lifetime) {		lifetime = ZEPHIR_GLOBAL(global_null);	}	if (!stopBuffer) {		stopBuffer = ZEPHIR_GLOBAL(global_true);	}	if (!(zephir_is_true(keyName))) {		ZEPHIR_OBS_VAR(lastKey);		zephir_read_property_this(&lastKey, this_ptr, SL("_lastKey"), PH_NOISY_CC);		ZEPHIR_SINIT_VAR(_0);		ZVAL_LONG(&_0, 5);		ZEPHIR_INIT_VAR(prefixedKey);		zephir_substr(prefixedKey, lastKey, 5 , 0, ZEPHIR_SUBSTR_NO_LENGTH);	} else {		ZEPHIR_OBS_VAR(prefix);		zephir_read_property_this(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC);		ZEPHIR_INIT_NVAR(prefixedKey);		ZEPHIR_CONCAT_VV(prefixedKey, prefix, keyName);		ZEPHIR_INIT_NVAR(lastKey);		ZEPHIR_CONCAT_SV(lastKey, "_PHCR", prefixedKey);	}	if (!(zephir_is_true(lastKey))) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cache must be started first", "phalcon/cache/backend/redis.zep", 185);		return;	}	ZEPHIR_OBS_VAR(frontend);	zephir_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);	ZEPHIR_OBS_VAR(redis);	zephir_read_property_this(&redis, this_ptr, SL("_redis"), PH_NOISY_CC);	if (Z_TYPE_P(redis) != IS_OBJECT) {		ZEPHIR_CALL_METHOD(NULL, this_ptr, "_connect", NULL);		zephir_check_call_status();		ZEPHIR_OBS_NVAR(redis);		zephir_read_property_this(&redis, this_ptr, SL("_redis"), PH_NOISY_CC);	}	if (!(zephir_is_true(content))) {		ZEPHIR_CALL_METHOD(&cachedContent, frontend, "getcontent", NULL);		zephir_check_call_status();	} else {		ZEPHIR_CPY_WRT(cachedContent, content);	}	if (!(zephir_is_numeric(cachedContent))) {		ZEPHIR_CALL_METHOD(&preparedContent, frontend, "beforestore", NULL, cachedContent);		zephir_check_call_status();	}	if (!(zephir_is_true(lifetime))) {		ZEPHIR_OBS_VAR(tmp);		zephir_read_property_this(&tmp, this_ptr, SL("_lastLifetime"), PH_NOISY_CC);		if (!(zephir_is_true(tmp))) {			ZEPHIR_CALL_METHOD(&tt1, frontend, "getlifetime", NULL);			zephir_check_call_status();		} else {			ZEPHIR_CPY_WRT(tt1, tmp);		}	} else {		ZEPHIR_CPY_WRT(tt1, lifetime);	}	if (zephir_is_numeric(cachedContent)) {		ZEPHIR_CALL_METHOD(&success, redis, "set", NULL, lastKey, cachedContent);		zephir_check_call_status();	} else {		ZEPHIR_CALL_METHOD(&success, redis, "set", NULL, lastKey, preparedContent);		zephir_check_call_status();	}	if (!(zephir_is_true(success))) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Failed storing data in redis", "phalcon/cache/backend/redis.zep", 231);		return;	}	ZEPHIR_CALL_METHOD(NULL, redis, "settimeout", NULL, lastKey, tt1);	zephir_check_call_status();	ZEPHIR_OBS_VAR(options);	zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC);	if (!(zephir_array_isset_string(options, SS("statsKey")))) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/redis.zep", 239);		return;	}	ZEPHIR_OBS_VAR(specialKey);	zephir_array_fetch_string(&specialKey, options, SL("statsKey"), PH_NOISY, "phalcon/cache/backend/redis.zep", 242 TSRMLS_CC);	ZEPHIR_CALL_METHOD(NULL, redis, "sadd", NULL, specialKey, prefixedKey);	zephir_check_call_status();	ZEPHIR_CALL_METHOD(&isBuffering, frontend, "isbuffering", NULL);	zephir_check_call_status();	if (ZEPHIR_IS_TRUE_IDENTICAL(stopBuffer)) {		ZEPHIR_CALL_METHOD(NULL, frontend, "stop", NULL);		zephir_check_call_status();	}	if (ZEPHIR_IS_TRUE_IDENTICAL(isBuffering)) {		zend_print_zval(cachedContent, 0);	}	zephir_update_property_this(this_ptr, SL("_started"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);	ZEPHIR_MM_RESTORE();}