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

PHP_METHOD(PocketMine_Math_Vector2, distance) {	zephir_nts_static zephir_fcall_cache_entry *_4 = NULL;	int ZEPHIR_LAST_CALL_STATUS;	zval *x, *y = NULL, *_0 = NULL, *_1, *_2, *_3 = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 1, &x, &y);	if (!y) {		ZEPHIR_INIT_VAR(y);		ZVAL_LONG(y, 0);	}	if (zephir_instance_of_ev(x, pocketmine_math_vector2_ce TSRMLS_CC)) {		ZEPHIR_OBS_VAR(_1);		zephir_read_property(&_1, x, SL("x"), PH_NOISY_CC);		ZEPHIR_OBS_VAR(_2);		zephir_read_property(&_2, x, SL("y"), PH_NOISY_CC);		ZEPHIR_CALL_METHOD(&_0, this_ptr, "distancesquared", NULL, _1, _2);		zephir_check_call_status();		ZEPHIR_CALL_FUNCTION(&_3, "sqrt", &_4, _0);		zephir_check_call_status();		RETURN_MM_DOUBLE(zephir_get_doubleval(_3));	}	ZEPHIR_CALL_METHOD(&_0, this_ptr, "distancesquared", NULL, x, y);	zephir_check_call_status();	ZEPHIR_CALL_FUNCTION(&_3, "sqrt", &_4, _0);	zephir_check_call_status();	RETURN_MM_DOUBLE(zephir_get_doubleval(_3));}

PHP_METHOD(Test_Oo_PropertyAccess, __construct) {	zval *test, *test1, *_0, *_1, *_2, *_3, *_4, *_5, *_6, *_7 = NULL, *_8, *_9;	ZEPHIR_MM_GROW();	ZEPHIR_INIT_VAR(test);	object_init(test);	ZEPHIR_INIT_VAR(_0);	array_init_size(_0, 6);	ZEPHIR_INIT_VAR(_1);	ZVAL_LONG(_1, 1);	zephir_array_fast_append(_0, _1);	ZEPHIR_INIT_BNVAR(_1);	ZVAL_LONG(_1, 2);	zephir_array_fast_append(_0, _1);	ZEPHIR_INIT_BNVAR(_1);	ZVAL_LONG(_1, 3);	zephir_array_fast_append(_0, _1);	ZEPHIR_INIT_BNVAR(_1);	ZVAL_LONG(_1, 5);	zephir_array_fast_append(_0, _1);	ZEPHIR_INIT_BNVAR(_1);	ZVAL_DOUBLE(_1, 6.00);	zephir_array_fast_append(_0, _1);	zephir_update_property_zval(test, SL("test"), _0 TSRMLS_CC);	ZEPHIR_OBS_VAR(_2);	zephir_read_property(&_2, test, SL("test"), PH_NOISY_CC);	zephir_array_fetch_long(&_3, _2, 0, PH_NOISY | PH_READONLY TSRMLS_CC);	zephir_update_property_zval(test, SL("test2"), _3 TSRMLS_CC);	ZEPHIR_OBS_VAR(_4);	zephir_read_property(&_4, test, SL("test"), PH_NOISY_CC);	zephir_array_fetch_long(&_5, _4, 1, PH_NOISY | PH_READONLY TSRMLS_CC);	zephir_update_property_zval(test, SL("test3"), _5 TSRMLS_CC);	ZEPHIR_INIT_BNVAR(_1);	array_init_size(_1, 5);	ZEPHIR_OBS_VAR(_6);	zephir_read_property(&_6, test, SL("test"), PH_NOISY_CC);	ZEPHIR_OBS_VAR(_7);	zephir_array_fetch_long(&_7, _6, 1, PH_NOISY TSRMLS_CC);	zephir_array_fast_append(_1, _7);	ZEPHIR_INIT_VAR(_8);	ZVAL_LONG(_8, 1);	zephir_array_fast_append(_1, _8);	ZEPHIR_INIT_BNVAR(_8);	ZVAL_LONG(_8, 2);	zephir_array_fast_append(_1, _8);	ZEPHIR_INIT_BNVAR(_8);	ZVAL_LONG(_8, 3);	zephir_array_fast_append(_1, _8);	zephir_update_property_zval(test, SL("test3"), _1 TSRMLS_CC);	zephir_update_property_this(this_ptr, SL("a"), test TSRMLS_CC);	_9 = zephir_fetch_nproperty_this(this_ptr, SL("a"), PH_NOISY_CC);	ZEPHIR_OBS_NVAR(_7);	zephir_read_property(&_7, _9, SL("test2"), PH_NOISY_CC);	zephir_update_property_this(this_ptr, SL("b"), _7 TSRMLS_CC);	test1 = zephir_fetch_nproperty_this(this_ptr, SL("a"), PH_NOISY_CC);	ZEPHIR_MM_RESTORE();}

PHP_METHOD(Test_Trie, getTrieNodeByKey) {	zend_class_entry *_5;	zephir_nts_static zephir_fcall_cache_entry *_2 = NULL;	int i, ZEPHIR_LAST_CALL_STATUS;	zend_bool create;	zval *key_param = NULL, *create_param = NULL, *trieNode = NULL, *keyLen, *character = NULL, _0 = zval_used_for_init, _1 = zval_used_for_init, *_3 = NULL, *_4 = NULL, *_6 = NULL, *_7;	zval *key = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 1, &key_param, &create_param);	zephir_get_strval(key, key_param);	if (!create_param) {		create = 0;	} else {		create = zephir_get_boolval(create_param);	}	ZEPHIR_OBS_VAR(trieNode);	zephir_read_property_this(&trieNode, this_ptr, SL("trie"), PH_NOISY_CC);	ZEPHIR_INIT_VAR(keyLen);	ZVAL_LONG(keyLen, zephir_fast_strlen_ev(key));	i = 0;	while (1) {		if (!(ZEPHIR_GT_LONG(keyLen, i))) {			break;		}		ZEPHIR_SINIT_NVAR(_0);		ZVAL_LONG(&_0, i);		ZEPHIR_SINIT_NVAR(_1);		ZVAL_LONG(&_1, 1);		ZEPHIR_CALL_FUNCTION(&character, "substr", &_2, key, &_0, &_1);		zephir_check_call_status();		ZEPHIR_OBS_NVAR(_3);		zephir_read_property(&_3, trieNode, SL("children"), PH_NOISY_CC);		if (!(zephir_array_isset(_3, character))) {			if (create) {				ZEPHIR_INIT_LNVAR(_4);				_5 = zend_fetch_class(SL("tries//trienode"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);				object_init_ex(_4, _5);				if (zephir_has_constructor(_4 TSRMLS_CC)) {					ZEPHIR_CALL_METHOD(NULL, _4, "__construct", NULL);					zephir_check_call_status();				}				zephir_update_property_array(trieNode, SL("children"), character, _4 TSRMLS_CC);			} else {				RETURN_MM_BOOL(0);			}		}		ZEPHIR_OBS_NVAR(_6);		zephir_read_property(&_6, trieNode, SL("children"), PH_NOISY_CC);		zephir_array_fetch(&_7, _6, character, PH_NOISY | PH_READONLY TSRMLS_CC);		ZEPHIR_CPY_WRT(trieNode, _7);		i += 1;	}	RETURN_CCTOR(trieNode);}

/** * @inheritdoc */PHP_METHOD(Owl_Log_Formatter_Json, format) {	int ZEPHIR_LAST_CALL_STATUS;	zephir_fcall_cache_entry *_2 = NULL;	zval *_0;	zval *record, *_1 = NULL, *_3, *_4 = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &record);	ZEPHIR_INIT_VAR(_0);	zephir_create_array(_0, 3, 0 TSRMLS_CC);	ZEPHIR_OBS_VAR(_3);	zephir_read_property(&_3, record, SL("level"), PH_NOISY_CC);	ZEPHIR_CALL_CE_STATIC(&_1, owl_log_logger_ce, "getleveltitle", &_2, 18, _3);	zephir_check_call_status();	zephir_array_update_string(&_0, SL("type"), &_1, PH_COPY | PH_SEPARATE);	ZEPHIR_OBS_VAR(_4);	zephir_read_property(&_4, record, SL("message"), PH_NOISY_CC);	zephir_array_update_string(&_0, SL("message"), &_4, PH_COPY | PH_SEPARATE);	ZEPHIR_OBS_NVAR(_4);	zephir_read_property(&_4, record, SL("timestamp"), PH_NOISY_CC);	zephir_array_update_string(&_0, SL("timestamp"), &_4, PH_COPY | PH_SEPARATE);	zephir_json_encode(return_value, &(return_value), _0, 0  TSRMLS_CC);	RETURN_MM();}

PHP_METHOD(Phalcon_Session_Adapter_Libmemcached, write) {	zend_long ZEPHIR_LAST_CALL_STATUS;	zval *id, id_sub, *data, data_sub, name, _0, _1;	zval *this_ptr = getThis();	ZVAL_UNDEF(&id_sub);	ZVAL_UNDEF(&data_sub);	ZVAL_UNDEF(&name);	ZVAL_UNDEF(&_0);	ZVAL_UNDEF(&_1);	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 2, 0, &id, &data);	ZEPHIR_CALL_METHOD(&name, this_ptr, "getprefixedname", NULL, 0, id);	zephir_check_call_status();	zephir_read_property(&_0, this_ptr, SL("connection"), PH_NOISY_CC | PH_READONLY);	zephir_read_property(&_1, this_ptr, SL("ttl"), PH_NOISY_CC | PH_READONLY);	ZEPHIR_RETURN_CALL_METHOD(&_0, "save", NULL, 0, &name, data, &_1);	zephir_check_call_status();	RETURN_MM();}

/** * Destroys the session bag * *<code> * $user->destroy(); *</code> */PHP_METHOD(Phalcon_Session_Bag, destroy) {	zval _0, _1, _2, _3;	zend_long ZEPHIR_LAST_CALL_STATUS;	zval *this_ptr = getThis();	ZVAL_UNDEF(&_0);	ZVAL_UNDEF(&_1);	ZVAL_UNDEF(&_2);	ZVAL_UNDEF(&_3);	ZEPHIR_MM_GROW();	zephir_read_property(&_0, this_ptr, SL("_initialized"), PH_NOISY_CC | PH_READONLY);	if (ZEPHIR_IS_FALSE_IDENTICAL(&_0)) {		ZEPHIR_CALL_METHOD(NULL, this_ptr, "initialize", NULL, 0);		zephir_check_call_status();	}	ZEPHIR_INIT_VAR(&_1);	array_init(&_1);	zephir_update_property_zval(this_ptr, SL("_data"), &_1);	zephir_read_property(&_2, this_ptr, SL("_session"), PH_NOISY_CC | PH_READONLY);	zephir_read_property(&_3, this_ptr, SL("_name"), PH_NOISY_CC | PH_READONLY);	ZEPHIR_CALL_METHOD(NULL, &_2, "remove", NULL, 0, &_3);	zephir_check_call_status();	ZEPHIR_MM_RESTORE();}

/** * Returns a cached content */PHP_METHOD(Phalcon_Cache_Backend_Libmemcached, get) {	zend_long ZEPHIR_LAST_CALL_STATUS;	zval *keyName_param = NULL, *lifetime = NULL, lifetime_sub, __$null, memcache, prefixedKey, cachedContent, _0, _1, _2;	zval keyName;	zval *this_ptr = getThis();	ZVAL_UNDEF(&keyName);	ZVAL_UNDEF(&lifetime_sub);	ZVAL_NULL(&__$null);	ZVAL_UNDEF(&memcache);	ZVAL_UNDEF(&prefixedKey);	ZVAL_UNDEF(&cachedContent);	ZVAL_UNDEF(&_0);	ZVAL_UNDEF(&_1);	ZVAL_UNDEF(&_2);	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 1, &keyName_param, &lifetime);	zephir_get_strval(&keyName, keyName_param);	if (!lifetime) {		lifetime = &lifetime_sub;		lifetime = &__$null;	}	ZEPHIR_OBS_VAR(&memcache);	zephir_read_property(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC);	if (Z_TYPE_P(&memcache) != IS_OBJECT) {		ZEPHIR_CALL_METHOD(NULL, this_ptr, "_connect", NULL, 0);		zephir_check_call_status();		ZEPHIR_OBS_NVAR(&memcache);		zephir_read_property(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC);	}	zephir_read_property(&_0, this_ptr, SL("_prefix"), PH_NOISY_CC | PH_READONLY);	ZEPHIR_INIT_VAR(&prefixedKey);	ZEPHIR_CONCAT_VV(&prefixedKey, &_0, &keyName);	zephir_update_property_zval(this_ptr, SL("_lastKey"), &prefixedKey);	ZEPHIR_CALL_METHOD(&cachedContent, &memcache, "get", NULL, 0, &prefixedKey);	zephir_check_call_status();	ZEPHIR_CALL_METHOD(&_1, &memcache, "getresultcode", NULL, 0);	zephir_check_call_status();	if (ZEPHIR_IS_LONG_IDENTICAL(&_1, 16)) {		RETURN_MM_NULL();	}	if (zephir_is_numeric(&cachedContent)) {		RETURN_CCTOR(&cachedContent);	}	zephir_read_property(&_2, this_ptr, SL("_frontend"), PH_NOISY_CC | PH_READONLY);	ZEPHIR_RETURN_CALL_METHOD(&_2, "afterretrieve", NULL, 0, &cachedContent);	zephir_check_call_status();	RETURN_MM();}

PHP_METHOD(Owl_Router_Router, match) {	zend_bool _5, _7;	int ZEPHIR_LAST_CALL_STATUS;	HashTable *_2;	HashPosition _1;	zval *uri_param = NULL, *method_param = NULL, *router = NULL, *_0, **_3, *_4 = NULL, *_6 = NULL, *_8 = NULL;	zval *uri = NULL, *method = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 1, &uri_param, &method_param);	zephir_get_strval(uri, uri_param);	if (!method_param) {		ZEPHIR_INIT_VAR(method);		ZVAL_STRING(method, "GET", 1);	} else {		zephir_get_strval(method, method_param);	}	_0 = zephir_fetch_nproperty_this(this_ptr, SL("routers"), PH_NOISY_CC);	zephir_is_iterable(_0, &_2, &_1, 0, 0, "owl/Router/Router.zep", 56);	for (	  ; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS	  ; zephir_hash_move_forward_ex(_2, &_1)	) {		ZEPHIR_GET_HVALUE(router, _3);		ZEPHIR_CALL_METHOD(&_4, router, "match", NULL, 0, uri);		zephir_check_call_status();		_5 = zephir_is_true(_4);		if (_5) {			ZEPHIR_OBS_NVAR(_6);			zephir_read_property(&_6, router, SL("method"), PH_NOISY_CC);			_7 = ZEPHIR_IS_LONG(_6, 7);			if (!(_7)) {				ZEPHIR_OBS_NVAR(_8);				zephir_read_property(&_8, router, SL("method"), PH_NOISY_CC);				_7 = ZEPHIR_IS_EQUAL(_8, method);			}			_5 = _7;		}		if (_5) {			RETURN_CCTOR(router);		}	}	RETURN_MM_BOOL(0);}

PHP_METHOD(Dgafka_BookStore_Business_Service_Handler_BookQueryHandler, handleGetByIdQuery) {	int ZEPHIR_LAST_CALL_STATUS;	zval *query, *book = NULL, *_0, *_1, *_2, *_3 = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &query);	if (!(zephir_instance_of_ev(query, dgafka_bookstore_business_service_dto_query_book_getbyidquery_ce TSRMLS_CC))) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'query' must be an instance of 'Dgafka//BookStore//Business//Service//Dto//Query//Book//GetByIdQuery'", "", 0);		return;	}	_0 = zephir_fetch_nproperty_this(this_ptr, SL("repository"), PH_NOISY_CC);	ZEPHIR_OBS_VAR(_1);	zephir_read_property(&_1, query, SL("id"), PH_NOISY_CC);	ZEPHIR_CALL_METHOD(&book, _0, "findbyid", NULL, _1);	zephir_check_call_status();	if (!(zephir_instance_of_ev(book, dgafka_bookstore_business_model_entity_book_ce TSRMLS_CC))) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(dgafka_bookstore_business_service_handler_exception_notfoundexception_ce, "Results not found.", "dgafka/bookStore/business/service/handler/BookQueryHandler.zep", 45);		return;	}	_2 = zephir_fetch_nproperty_this(this_ptr, SL("converter"), PH_NOISY_CC);	ZEPHIR_CALL_METHOD(&_3, _2, "convert", NULL, book);	zephir_check_call_status();	ZEPHIR_CPY_WRT(book, _3);	RETURN_CCTOR(book);}

PHP_METHOD(Test_Issues, someMethod) {	int ZEPHIR_LAST_CALL_STATUS;	zval *methodName, methodName_sub, _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(&methodName_sub);	ZVAL_UNDEF(&_0);	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &methodName);	zephir_read_property(&_0, this_ptr, SL("adapter"), PH_NOISY_CC | PH_READONLY);	ZEPHIR_RETURN_CALL_METHOD_ZVAL(&_0, methodName, NULL, 0);	zephir_check_call_status();	RETURN_MM();}

/** * Filter records by levels */PHP_METHOD(Owl_Log_AbstractWriter, filterRecords) {	HashTable *_2;	HashPosition _1;	zval *records_param = NULL, *index = NULL, *record = NULL, *_0, **_3, *_4 = NULL, *_5;	zval *records = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &records_param);	zephir_get_arrval(records, records_param);	ZEPHIR_OBS_VAR(_0);	zephir_read_property_this(&_0, this_ptr, SL("levels"), PH_NOISY_CC);	if (ZEPHIR_IS_EMPTY(_0)) {		RETURN_CTOR(records);	}	zephir_is_iterable(records, &_2, &_1, 1, 0, "owl/Log/AbstractWriter.zep", 125);	for (	  ; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS	  ; zephir_hash_move_forward_ex(_2, &_1)	) {		ZEPHIR_GET_HMKEY(index, _2, _1);		ZEPHIR_GET_HVALUE(record, _3);		ZEPHIR_OBS_NVAR(_4);		zephir_read_property(&_4, record, SL("level"), PH_NOISY_CC);		_5 = zephir_fetch_nproperty_this(this_ptr, SL("levels"), PH_NOISY_CC);		if (!(zephir_fast_in_array(_4, _5 TSRMLS_CC))) {			zephir_array_unset(&records, index, PH_SEPARATE);		}	}	RETURN_CTOR(records);}

/** * Returns a parameter in a specific position * * @return array */PHP_METHOD(Phalcon_Di_Service, getParameter) {	zval *position_param = NULL, definition, arguments, parameter;	zend_long position;	zval *this_ptr = getThis();	ZVAL_UNDEF(&definition);	ZVAL_UNDEF(&arguments);	ZVAL_UNDEF(&parameter);	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &position_param);	position = zephir_get_intval(position_param);	ZEPHIR_OBS_VAR(&definition);	zephir_read_property(&definition, this_ptr, SL("_definition"), PH_NOISY_CC);	if (Z_TYPE_P(&definition) != IS_ARRAY) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_di_exception_ce, "Definition must be an array to obtain its parameters", "phalcon/di/service.zep", 246);		return;	}	if (zephir_array_isset_string_fetch(&arguments, &definition, SL("arguments"), 1)) {		if (zephir_array_isset_long_fetch(&parameter, &arguments, position, 1 TSRMLS_CC)) {			RETURN_CTOR(&parameter);		}	}	RETURN_MM_NULL();}

/** * Return the strategy to obtain the meta-data */PHP_METHOD(Phalcon_Mvc_Model_MetaData, getStrategy) {	zval _0, _1$$3;	zend_long ZEPHIR_LAST_CALL_STATUS;	zval *this_ptr = getThis();	ZVAL_UNDEF(&_0);	ZVAL_UNDEF(&_1$$3);	ZEPHIR_MM_GROW();	ZEPHIR_OBS_VAR(&_0);	zephir_read_property(&_0, this_ptr, SL("_strategy"), PH_NOISY_CC);	if (Z_TYPE_P(&_0) == IS_NULL) {		ZEPHIR_INIT_VAR(&_1$$3);		object_init_ex(&_1$$3, phalcon_mvc_model_metadata_strategy_introspection_ce);		if (zephir_has_constructor(&_1$$3 TSRMLS_CC)) {			ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 0);			zephir_check_call_status();		}		zephir_update_property_zval(this_ptr, SL("_strategy"), &_1$$3);	}	RETURN_MM_MEMBER(getThis(), "_strategy");}

/** * Unsets an index in an array property */int zephir_unset_property_array(zval *object, char *property, unsigned int property_length, zval *index){	zval tmp;	int separated = 0;	if (Z_TYPE_P(object) == IS_OBJECT) {		zephir_read_property(&tmp, object, property, property_length, PH_NOISY_CC);		Z_TRY_DELREF(tmp);		/** Separation only when refcount > 1 */		if (Z_REFCOUNTED(tmp) && Z_REFCOUNT(tmp) > 1) {			if (!Z_ISREF(tmp)) {				zval new_zv;				ZVAL_DUP(&new_zv, &tmp);				ZVAL_COPY_VALUE(&tmp, &new_zv);				Z_TRY_DELREF(new_zv);				separated = 1;			}		}		zephir_array_unset(&tmp, index, PH_SEPARATE);		if (separated) {			zephir_update_property_zval(object, property, property_length, &tmp);		}	}	return SUCCESS;}

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

/** * Returns an option by the specified name * If the option doesn't exist null is returned	  */PHP_METHOD(Phalcon_Mvc_Model_Relation, getOption) {	zval *name_param = NULL, option, _0;	zval name;	zval *this_ptr = getThis();	ZVAL_UNDEF(&name);	ZVAL_UNDEF(&option);	ZVAL_UNDEF(&_0);	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 of the type 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_read_property(&_0, this_ptr, SL("_options"), PH_NOISY_CC | PH_READONLY);	if (zephir_array_isset_fetch(&option, &_0, &name, 1 TSRMLS_CC)) {		RETURN_CTOR(&option);	}	RETURN_MM_NULL();}

/** * Returns the paths using positions as keys and names as values * * @return array */PHP_METHOD(Test_Router_Route, getReversedPaths) {	zend_string *_3;	zend_ulong _2;	zval reversed, path, position, _0, *_1;	ZEPHIR_INIT_THIS();	ZVAL_UNDEF(&reversed);	ZVAL_UNDEF(&path);	ZVAL_UNDEF(&position);	ZVAL_UNDEF(&_0);	ZEPHIR_MM_GROW();	ZEPHIR_INIT_VAR(&reversed);	array_init(&reversed);	zephir_read_property(&_0, this_ptr, SL("_paths"), PH_NOISY_CC | PH_READONLY);	zephir_is_iterable(&_0, 0, "test/router/route.zep", 478);	ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_0), _2, _3, _1)	{		ZEPHIR_INIT_NVAR(&path);		if (_3 != NULL) { 			ZVAL_STR_COPY(&path, _3);		} else {			ZVAL_LONG(&path, _2);		}		ZEPHIR_INIT_NVAR(&position);		ZVAL_COPY(&position, _1);		zephir_array_update_zval(&reversed, &position, &path, PH_COPY | PH_SEPARATE);	} ZEND_HASH_FOREACH_END();

/** * Generates a local path */PHP_METHOD(Phalcon_Mvc_Url, path) {	zval *path_param = NULL, _0;	zval path;	zval *this_ptr = getThis();	ZVAL_UNDEF(&path);	ZVAL_UNDEF(&_0);	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 0, 1, &path_param);	if (!path_param) {		ZEPHIR_INIT_VAR(&path);		ZVAL_STRING(&path, "");	} else {		zephir_get_strval(&path, path_param);	}	zephir_read_property(&_0, this_ptr, SL("basePath"), PH_NOISY_CC | PH_READONLY);	ZEPHIR_CONCAT_VV(return_value, &_0, &path);	RETURN_MM();}

/** * Applies a format to a message before sent it to the internal log * * @param <Item> item * * @return string */PHP_METHOD(Phalcon_Logger_Formatter_Json, format) {	zval _4;	zend_long ZEPHIR_LAST_CALL_STATUS;	zval *item, item_sub, message, _0, _3, _5, _6, _7, _8, _1$$3, _2$$3;	zval *this_ptr = getThis();	ZVAL_UNDEF(&item_sub);	ZVAL_UNDEF(&message);	ZVAL_UNDEF(&_0);	ZVAL_UNDEF(&_3);	ZVAL_UNDEF(&_5);	ZVAL_UNDEF(&_6);	ZVAL_UNDEF(&_7);	ZVAL_UNDEF(&_8);	ZVAL_UNDEF(&_1$$3);	ZVAL_UNDEF(&_2$$3);	ZVAL_UNDEF(&_4);	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &item);	ZEPHIR_CALL_METHOD(&_0, item, "getcontext", NULL, 0);	zephir_check_call_status();	if (Z_TYPE_P(&_0) == IS_ARRAY) {		ZEPHIR_CALL_METHOD(&_1$$3, item, "getmessage", NULL, 0);		zephir_check_call_status();		ZEPHIR_CALL_METHOD(&_2$$3, item, "getcontext", NULL, 0);		zephir_check_call_status();		ZEPHIR_CALL_METHOD(&message, this_ptr, "interpolate", NULL, 0, &_1$$3, &_2$$3);		zephir_check_call_status();	} else {		ZEPHIR_CALL_METHOD(&message, item, "getmessage", NULL, 0);		zephir_check_call_status();	}	ZEPHIR_INIT_VAR(&_3);	ZEPHIR_INIT_VAR(&_4);	zephir_create_array(&_4, 3, 0 TSRMLS_CC);	ZEPHIR_CALL_METHOD(&_5, item, "getname", NULL, 0);	zephir_check_call_status();	zephir_array_update_string(&_4, SL("type"), &_5, PH_COPY | PH_SEPARATE);	zephir_array_update_string(&_4, SL("message"), &message, PH_COPY | PH_SEPARATE);	zephir_read_property(&_6, this_ptr, SL("dateFormat"), PH_NOISY_CC | PH_READONLY);	ZEPHIR_CALL_METHOD(&_5, item, "gettime", NULL, 0);	zephir_check_call_status();	ZEPHIR_CALL_FUNCTION(&_7, "date", NULL, 294, &_6, &_5);	zephir_check_call_status();	zephir_array_update_string(&_4, SL("timestamp"), &_7, PH_COPY | PH_SEPARATE);	zephir_json_encode(&_3, &_4, 0 );	ZEPHIR_INIT_VAR(&_8);	ZEPHIR_GET_CONSTANT(&_8, "PHP_EOL");	ZEPHIR_CONCAT_VV(return_value, &_3, &_8);	RETURN_MM();}

/** * Increments an object property */int zephir_property_incr_decr(zval *object, char *property_name, unsigned int property_length, unsigned int increment){	zval tmp;	zend_class_entry *ce;	int separated = 0;	ZVAL_UNDEF(&tmp);	if (Z_TYPE_P(object) != IS_OBJECT) {		php_error_docref(NULL, E_WARNING, "Attempt to assign property of non-object");		return FAILURE;	}	ce = Z_OBJCE_P(object);	if (ce->parent) {		ce = zephir_lookup_class_ce(ce, property_name, property_length);	}	zephir_read_property(&tmp, object, property_name, property_length, 0);	if (Z_TYPE(tmp) > IS_UNDEF) {		Z_TRY_DELREF(tmp);		/** Separation only when refcount > 1 */		if (Z_REFCOUNTED(tmp)) {			if (Z_REFCOUNT(tmp) > 1) {				if (!Z_ISREF(tmp)) {					zval new_zv;					ZVAL_DUP(&new_zv, &tmp);					ZVAL_COPY_VALUE(&tmp, &new_zv);					Z_TRY_DELREF(new_zv);					separated = 1;				}			}		} else {			zval new_zv;			ZVAL_DUP(&new_zv, &tmp);			ZVAL_COPY_VALUE(&tmp, &new_zv);			Z_TRY_DELREF(new_zv);			separated = 1;		}		if (increment) {			zephir_increment(&tmp);		} else {			zephir_decrement(&tmp);		}		if (separated) {			zephir_update_property_zval(object, property_name, property_length, &tmp);		}	}	return SUCCESS;}