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

PHP_METHOD(Phalcon_Validation_Validator_Date, checkDate) {	zend_bool _3;	zend_class_entry *_0, *_1;	int ZEPHIR_LAST_CALL_STATUS;	zval *value, *format, *date = NULL, *errors = NULL, *_2, *_4;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 2, 0, &value, &format);	if (!(Z_TYPE_P(value) == IS_STRING)) {		RETURN_MM_BOOL(0);	}		_0 = zend_fetch_class(SL("DateTime"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);	ZEPHIR_CALL_CE_STATIC(&date, _0, "createfromformat", NULL, 0, format, value);	zephir_check_call_status();		_1 = zend_fetch_class(SL("DateTime"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);	ZEPHIR_CALL_CE_STATIC(&errors, _1, "getlasterrors", NULL, 0);	zephir_check_call_status();	zephir_array_fetch_string(&_2, errors, SL("warning_count"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/date.zep", 121 TSRMLS_CC);	_3 = ZEPHIR_GT_LONG(_2, 0);	if (!(_3)) {		zephir_array_fetch_string(&_4, errors, SL("error_count"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/date.zep", 121 TSRMLS_CC);		_3 = ZEPHIR_GT_LONG(_4, 0);	}	if (_3) {		RETURN_MM_BOOL(0);	}	RETURN_MM_BOOL(1);}

PHP_METHOD(ADOdb_Cache, create) {	zend_class_entry *_0, *_1, *_2;	zval *type = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 0, 1, &type);	if (!type) {		ZEPHIR_CPY_WRT(type, ZEPHIR_GLOBAL(global_null));	} else {		ZEPHIR_SEPARATE_PARAM(type);	}	if ((Z_TYPE_P(type) == IS_NULL)) {		ZEPHIR_INIT_NVAR(type);		ZVAL_LONG(type, 0);	}	do {		if (ZEPHIR_IS_LONG(type, 0)) {			object_init_ex(return_value, adodb_driver_cache_memory_ce);			zephir_call_method_noret(return_value, "__construct");			RETURN_MM();		}		if (ZEPHIR_IS_LONG(type, 2)) {			_0 = zend_fetch_class(SL("ADOdb//Driver//Cache//APC"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);			object_init_ex(return_value, _0);			if (zephir_has_constructor(return_value TSRMLS_CC)) {				zephir_call_method_noret(return_value, "__construct");			}			RETURN_MM();		}		if (ZEPHIR_IS_LONG(type, 3)) {			_1 = zend_fetch_class(SL("ADOdb//Driver//Cache//Libredis"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);			object_init_ex(return_value, _1);			if (zephir_has_constructor(return_value TSRMLS_CC)) {				zephir_call_method_noret(return_value, "__construct");			}			RETURN_MM();		}		_2 = zend_fetch_class(SL("ADOdb//Driver//Cache//File"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);		object_init_ex(return_value, _2);		if (zephir_has_constructor(return_value TSRMLS_CC)) {			zephir_call_method_noret(return_value, "__construct");		}		RETURN_MM();	} while(0);	ZEPHIR_MM_RESTORE();}

PHP_METHOD(Configman_BaseServiceConfig, getService) {	int ZEPHIR_LAST_CALL_STATUS;	zend_class_entry *_1;	zval *service_param = NULL, *service_class_name, *upcase_service, *_0 = NULL;	zval *service = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &service_param);	zephir_get_strval(service, service_param);	ZEPHIR_INIT_VAR(upcase_service);	zephir_ucfirst(upcase_service, service);	ZEPHIR_INIT_VAR(service_class_name);	ZEPHIR_CONCAT_SVSVS(service_class_name, "//Configman//Service//", upcase_service, "//", upcase_service, "Config");	zephir_fetch_safe_class(_0, service_class_name);	_1 = zend_fetch_class(Z_STRVAL_P(_0), Z_STRLEN_P(_0), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);	object_init_ex(return_value, _1);	if (zephir_has_constructor(return_value TSRMLS_CC)) {		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, service);		zephir_check_call_status();	}	RETURN_MM();}

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

static PHP_METHOD(midgard_object_class, get_object_by_guid){	RETVAL_FALSE;	MidgardConnection *mgd = mgd_handle(TSRMLS_C);	CHECK_MGD(mgd);	char *guid;	int guid_length;	const gchar *type_name;	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &guid, &guid_length) == FAILURE)		return;	MidgardObject *object = midgard_schema_object_factory_get_object_by_guid(mgd, guid);	if (!object) {		php_midgard_error_exception_throw(mgd TSRMLS_CC);		return;	}	type_name = G_OBJECT_TYPE_NAME(G_OBJECT(object));	zend_class_entry *ce = zend_fetch_class((gchar *)type_name, strlen(type_name), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);	if (ce == NULL) {		php_error(E_WARNING, "Can not find %s class", type_name);		return;	}	php_midgard_gobject_new_with_gobject(return_value, ce, G_OBJECT(object), TRUE TSRMLS_CC);}

/** *  Constructor to create a new instance of a builtin class *   *  @param  name        Name of the class to instantiate *  @param  base        Implementation of the class */Object::Object(const char *name, Base *base){    // does the object already have a handle?    if (base->implementation())    {        // the object is already instantiated, we can assign it the this object        operator=(Value(base));    }    else    {        // we need the tsrm_ls variable        TSRMLS_FETCH();                // this is a brand new object that should be allocated, the C++ instance        // is already there (created by the extension) but it is not yet stored        // in PHP, find out the classname first        auto *entry = zend_fetch_class(name, strlen(name), 0 TSRMLS_CC);        if (!entry) throw Php::Exception(std::string("Unknown class name ") + name);                // construct an implementation (this will also set the implementation        // member in the base object)        new ObjectImpl(entry, base TSRMLS_CC);                // now we can store it        operator=(Value(base));    }}

/** * Sets transaction manager related to the transaction * * @param Phalcon/Mvc/Model/Transaction/Manager $manager */PHP_METHOD(Phalcon_Mvc_Model_Transaction, setTransactionManager){	zval *manager = NULL;	zval *i0 = NULL;	zval *r0 = NULL;	zend_class_entry *ce0;	PHALCON_MM_GROW();		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &manager) == FAILURE) {		PHALCON_MM_RESTORE();		RETURN_NULL();	}	if (Z_TYPE_P(manager) != IS_OBJECT) {		ce0 = zend_fetch_class(SL("Phalcon_Transaction_Exception"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);		PHALCON_ALLOC_ZVAL_MM(i0);		object_init_ex(i0, ce0);		PHALCON_ALLOC_ZVAL_MM(r0);		PHALCON_CONCAT_VS(r0, manager, " must be an Object");		PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", r0, PH_CHECK);		phalcon_throw_exception(i0 TSRMLS_CC);		return;	}	phalcon_update_property_zval(this_ptr, SL("_manager"), manager TSRMLS_CC);		PHALCON_MM_RESTORE();}

static PHP_METHOD(midgard_workspace_storage, list_children){	if (zend_parse_parameters_none() == FAILURE)		return;	guint n_objects;	MidgardWorkspaceStorage *self = MIDGARD_WORKSPACE_STORAGE(__php_gobject_ptr(getThis()));	MidgardWorkspaceStorage **children = midgard_workspace_storage_list_children(self, &n_objects);	array_init(return_value);	if (!children)		return;	const char *g_class_name = G_OBJECT_TYPE_NAME(children[0]);	zend_class_entry *ce = zend_fetch_class((char *) g_class_name, strlen(g_class_name), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);	int i;	for (i = 0; i < n_objects; i++) {		zval *zobject;		MAKE_STD_ZVAL(zobject);		php_midgard_gobject_new_with_gobject(zobject, ce, G_OBJECT(children[i]), TRUE TSRMLS_CC);		zend_hash_next_index_insert(HASH_OF(return_value), &zobject, sizeof(zval *), NULL);	}}

/** * Sets a Expires header to use HTTP cache * *<code> *	$this->response->setExpires(new DateTime()); *</code> * * @param DateTime $datetime * @return Phalcon/Http/ResponseInterface */PHP_METHOD(Phalcon_Http_Response, setExpires){	zval *datetime, *headers, *date, *utc_zone, *timezone;	zval *format, *utc_format, *utc_date, *expires_header;	zend_class_entry *ce0;	PHALCON_MM_GROW();	phalcon_fetch_params(1, 1, 0, &datetime);		if (Z_TYPE_P(datetime) != IS_OBJECT) {		PHALCON_THROW_EXCEPTION_STR(phalcon_http_response_exception_ce, "datetime parameter must be an instance of DateTime");		return;	}		PHALCON_INIT_VAR(headers);	phalcon_call_method(headers, this_ptr, "getheaders");		PHALCON_INIT_VAR(date);	if (phalcon_clone(date, datetime TSRMLS_CC) == FAILURE) {		return;	}		/** 	 * All the expiration times are sent in UTC	 */	PHALCON_INIT_VAR(utc_zone);	ZVAL_STRING(utc_zone, "UTC", 1);	ce0 = zend_fetch_class(SL("DateTimeZone"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);		PHALCON_INIT_VAR(timezone);	object_init_ex(timezone, ce0);	if (phalcon_has_constructor(timezone TSRMLS_CC)) {		phalcon_call_method_p1_noret(timezone, "__construct", utc_zone);	}		/** 	 * Change the timezone to utc	 */	phalcon_call_method_p1_noret(date, "settimezone", timezone);		PHALCON_INIT_VAR(format);	ZVAL_STRING(format, "D, d M Y H:i:s", 1);		PHALCON_INIT_VAR(utc_format);	phalcon_call_method_p1(utc_format, date, "format", format);		PHALCON_INIT_VAR(utc_date);	PHALCON_CONCAT_VS(utc_date, utc_format, " GMT");		/** 	 * The 'Expires' header set this info	 */	PHALCON_INIT_VAR(expires_header);	ZVAL_STRING(expires_header, "Expires", 1);	phalcon_call_method_p2_noret(this_ptr, "setheader", expires_header, utc_date);		RETURN_THIS();}

zend_class_entry *zephir_fetch_class_str_ex(const char *class_name, size_t length, int fetch_type){	zend_class_entry *retval;	zend_string *str = zend_string_init(class_name, length, 0);	retval = zend_fetch_class(str, fetch_type);	zend_string_release(str);	return retval;}

/** * Creates an instance of the JWT bearer grant type. * * @param OAuth2/Storage/JWTBearerInterface storage A valid storage interface that implements storage hooks for the JWT bearer grant type. * @param string audience The audience to validate the token against. This is usually the full URI of the OAuth token requests endpoint. * @param OAuth2/Encryption/Jwt jwtUtil OPTONAL The class used to decode, encode and verify JWTs. */PHP_METHOD(OAuth2_GrantType_JwtBearer, __construct) {	int ZEPHIR_LAST_CALL_STATUS;	zephir_nts_static zend_class_entry *_1 = NULL;	zend_bool _0;	zval *audience = NULL;	zval *storage, *audience_param = NULL, *jwtUtil = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 2, 1, &storage, &audience_param, &jwtUtil);	if (unlikely(Z_TYPE_P(audience_param) != IS_STRING && Z_TYPE_P(audience_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'audience' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (likely(Z_TYPE_P(audience_param) == IS_STRING)) {		zephir_get_strval(audience, audience_param);	} else {		ZEPHIR_INIT_VAR(audience);		ZVAL_EMPTY_STRING(audience);	}	if (!jwtUtil) {		ZEPHIR_CPY_WRT(jwtUtil, ZEPHIR_GLOBAL(global_null));	} else {		ZEPHIR_SEPARATE_PARAM(jwtUtil);	}	if (!(zephir_instance_of_ev(storage, oauth2_storage_jwtbearerinterface_ce TSRMLS_CC))) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'storage' must be an instance of 'OAuth2//Storage//JwtBearerInterface'", "", 0);		return;	}	_0 = Z_TYPE_P(jwtUtil) != IS_NULL;	if (_0) {		_0 = !zephir_instance_of_ev(jwtUtil, oauth2_encryption_encryptioninterface_ce TSRMLS_CC);	}	if (_0) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'jwtUtil' must be an instance of 'OAuth2//Encryption//EncryptionInterface'", "", 0);		return;	}	zephir_update_property_this(this_ptr, SL("storage"), storage TSRMLS_CC);	zephir_update_property_this(this_ptr, SL("audience"), audience TSRMLS_CC);	if (Z_TYPE_P(jwtUtil) == IS_NULL) {		ZEPHIR_INIT_NVAR(jwtUtil);		if (!_1) {			_1 = zend_fetch_class(SL("OAuth2//Encryption//Jwt"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);		}		object_init_ex(jwtUtil, _1);		if (zephir_has_constructor(jwtUtil TSRMLS_CC)) {			ZEPHIR_CALL_METHOD(NULL, jwtUtil, "__construct", NULL);			zephir_check_call_status();		}	}	zephir_update_property_this(this_ptr, SL("jwtUtil"), jwtUtil TSRMLS_CC);	ZEPHIR_MM_RESTORE();}

/** * Fetches a zend class entry from a zval value */zend_class_entry *zephir_fetch_class(const zval *class_name){	if (Z_TYPE_P(class_name) == IS_STRING) {		return zend_fetch_class(Z_STR_P(class_name), ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC);	}	php_error_docref(NULL, E_WARNING, "class name must be a string");	return zephir_fetch_class_str_ex(SL("stdclass"), ZEND_FETCH_CLASS_DEFAULT);}

/** * Initializes the internal handler, calling functions on it * * @param  string method * @param  array arguments * @return mixed */PHP_METHOD(Phalcon_Mvc_Micro_LazyLoader, __call) {	zend_class_entry *_1$$3;	zval *_3;	int ZEPHIR_LAST_CALL_STATUS;	zval *method_param = NULL, *arguments = NULL, *handler = NULL, *definition = NULL, *modelBinder = NULL, *bindCacheKey = NULL, *_0$$3 = NULL, *_2$$4 = NULL;	zval *method = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 2, 0, &method_param, &arguments);	if (UNEXPECTED(Z_TYPE_P(method_param) != IS_STRING && Z_TYPE_P(method_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'method' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (EXPECTED(Z_TYPE_P(method_param) == IS_STRING)) {		zephir_get_strval(method, method_param);	} else {		ZEPHIR_INIT_VAR(method);		ZVAL_EMPTY_STRING(method);	}	ZEPHIR_SEPARATE_PARAM(arguments);	ZEPHIR_OBS_VAR(handler);	zephir_read_property_this(&handler, this_ptr, SL("_handler"), PH_NOISY_CC);	ZEPHIR_OBS_VAR(definition);	zephir_read_property_this(&definition, this_ptr, SL("_definition"), PH_NOISY_CC);	if (Z_TYPE_P(handler) != IS_OBJECT) {		ZEPHIR_INIT_NVAR(handler);		zephir_fetch_safe_class(_0$$3, definition);			_1$$3 = zend_fetch_class(Z_STRVAL_P(_0$$3), Z_STRLEN_P(_0$$3), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);		object_init_ex(handler, _1$$3);		if (zephir_has_constructor(handler TSRMLS_CC)) {			ZEPHIR_CALL_METHOD(NULL, handler, "__construct", NULL, 0);			zephir_check_call_status();		}		zephir_update_property_this(this_ptr, SL("_handler"), handler TSRMLS_CC);	}	ZEPHIR_OBS_VAR(modelBinder);	zephir_read_property_this(&modelBinder, this_ptr, SL("_modelBinder"), PH_NOISY_CC);	if (Z_TYPE_P(modelBinder) != IS_NULL) {		ZEPHIR_INIT_VAR(bindCacheKey);		ZEPHIR_CONCAT_SVSV(bindCacheKey, "_PHMB_", definition, "_", method);		ZEPHIR_CALL_METHOD(&_2$$4, modelBinder, "bindtohandler", NULL, 0, handler, arguments, bindCacheKey, method);		zephir_check_call_status();		ZEPHIR_CPY_WRT(arguments, _2$$4);	}	ZEPHIR_INIT_VAR(_3);	zephir_create_array(_3, 2, 0 TSRMLS_CC);	zephir_array_fast_append(_3, handler);	zephir_array_fast_append(_3, method);	ZEPHIR_CALL_USER_FUNC_ARRAY(return_value, _3, arguments);	zephir_check_call_status();	RETURN_MM();}

/* Object constructor */static PHP_METHOD(midgard_query_builder, __construct){	MidgardConnection *mgd = mgd_handle(TSRMLS_C);	CHECK_MGD(mgd);	char *classname;	long classname_length;	zval *zval_object = getThis();	GObject *gobject;	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &classname, &classname_length) == FAILURE) {		return;	}	zend_class_entry *ce = zend_fetch_class(classname, classname_length, ZEND_FETCH_CLASS_AUTO TSRMLS_CC);	if (ce == NULL) {		php_error(E_WARNING, "Didn't find %s class", classname);		php_midgard_error_exception_force_throw(mgd, MGD_ERR_INVALID_OBJECT TSRMLS_CC);		return;	}	zend_class_entry *base_ce = php_midgard_get_baseclass_ptr(ce);	const gchar *g_base_class_name = php_class_name_to_g_class_name(base_ce->name);	GType classtype = g_type_from_name(g_base_class_name);	if (!g_type_is_a(classtype, MIDGARD_TYPE_DBOBJECT)) {		php_error(E_WARNING, "Expected %s derived class", g_type_name(MIDGARD_TYPE_DBOBJECT));		php_midgard_error_exception_force_throw(mgd, MGD_ERR_INVALID_OBJECT TSRMLS_CC);		return;	}	gobject = __php_gobject_ptr(zval_object);	if (!gobject) {		MidgardQueryBuilder *builder = midgard_query_builder_new(mgd, g_base_class_name);		if (!builder) {			php_midgard_error_exception_throw(mgd TSRMLS_CC);			return;		}		MGD_PHP_SET_GOBJECT(zval_object, builder);	} else {		// we already have gobject injected	}	php_midgard_gobject *php_gobject = __php_objstore_object(zval_object);	/* Set user defined class. We might need it when execute is invoked */	php_gobject->user_ce = ce;	php_gobject->user_class_name = (char *)ce->name;}

/** * Detects and returns the first available cache driver. * * @return /Xpl/Cache/DriverInterface */PHP_METHOD(Xpl_Cache_Cache, getDetectedDriver) {	zend_class_entry *_7$$4;	HashTable *_2;	HashPosition _1;	zval *driverClasses = NULL, *classname = NULL, *_0 = NULL, **_3, *_4$$3 = NULL, *_5$$3 = NULL, *_6$$4 = NULL;	zephir_fcall_cache_entry *_8 = NULL;	int ZEPHIR_LAST_CALL_STATUS;	ZEPHIR_MM_GROW();	ZEPHIR_INIT_VAR(driverClasses);	zephir_create_array(driverClasses, 3, 0 TSRMLS_CC);	ZEPHIR_INIT_VAR(_0);	ZVAL_STRING(_0, "Xpl//Cache//Driver//ApcuDriver", 1);	zephir_array_fast_append(driverClasses, _0);	ZEPHIR_INIT_NVAR(_0);	ZVAL_STRING(_0, "Xpl//Cache//Driver//ApcDriver", 1);	zephir_array_fast_append(driverClasses, _0);	ZEPHIR_INIT_NVAR(_0);	ZVAL_STRING(_0, "Xpl//Cache//Driver//XCacheDriver", 1);	zephir_array_fast_append(driverClasses, _0);	zephir_is_iterable(driverClasses, &_2, &_1, 0, 0, "xpl/cache/cache.zep", 215);	for (	  ; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS	  ; zephir_hash_move_forward_ex(_2, &_1)	) {		ZEPHIR_GET_HVALUE(classname, _3);		ZEPHIR_INIT_NVAR(_4$$3);		ZEPHIR_INIT_LNVAR(_5$$3);		ZEPHIR_CONCAT_VS(_5$$3, classname, "::isAvailable");		ZEPHIR_CALL_USER_FUNC(_4$$3, _5$$3);		zephir_check_call_status();		if (ZEPHIR_IS_TRUE_IDENTICAL(_4$$3)) {			zephir_fetch_safe_class(_6$$4, classname);				_7$$4 = zend_fetch_class(Z_STRVAL_P(_6$$4), Z_STRLEN_P(_6$$4), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);			object_init_ex(return_value, _7$$4);			if (zephir_has_constructor(return_value TSRMLS_CC)) {				ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", &_8, 0);				zephir_check_call_status();			}			RETURN_MM();		}	}	object_init_ex(return_value, xpl_cache_driver_memorydriver_ce);	if (zephir_has_constructor(return_value TSRMLS_CC)) {		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0);		zephir_check_call_status();	}	RETURN_MM();}

PHP_METHOD(Test_InternalClasses, testStaticCall) {	zend_class_entry *_0;	int ZEPHIR_LAST_CALL_STATUS;	ZEPHIR_MM_GROW();		_0 = zend_fetch_class(SL("Phalcon//DI"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);	ZEPHIR_RETURN_CALL_CE_STATIC(_0, "getdefault", NULL, 0);	zephir_check_call_status();	RETURN_MM();}

PHP_METHOD(Test_InternalClasses, testStaticCall) {	int ZEPHIR_LAST_CALL_STATUS;	zend_class_entry *phalcon_phalcon_di;	ZEPHIR_MM_GROW();	phalcon_phalcon_di = zend_fetch_class(SL("//Phalcon//Di"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);	ZEPHIR_RETURN_CALL_CE_STATIC(phalcon_phalcon_di, "getdefault", NULL);	zephir_check_call_status();	RETURN_MM();}

PHP_METHOD(Auryn_AbstractCachingReflector, getMethod) {	zend_class_entry *_3;	int ZEPHIR_LAST_CALL_STATUS;	zval *methodName = NULL;	zval *classNameOrInstance, *methodName_param = NULL, *className = NULL, *cacheKey, *reflectedMethod = NULL, *_0, *_1, *_2, *_4;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 2, 0, &classNameOrInstance, &methodName_param);	if (unlikely(Z_TYPE_P(methodName_param) != IS_STRING && Z_TYPE_P(methodName_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'methodName' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (unlikely(Z_TYPE_P(methodName_param) == IS_STRING)) {		methodName = methodName_param;	} else {		ZEPHIR_INIT_VAR(methodName);		ZVAL_EMPTY_STRING(methodName);	}	if (Z_TYPE_P(classNameOrInstance) == IS_STRING) {		ZEPHIR_CPY_WRT(className, classNameOrInstance);	} else {		ZEPHIR_INIT_VAR(className);		zephir_get_class(className, classNameOrInstance, 0 TSRMLS_CC);	}	ZEPHIR_INIT_VAR(_0);	zephir_fast_strtolower(_0, className);	ZEPHIR_INIT_VAR(_1);	zephir_fast_strtolower(_1, methodName);	ZEPHIR_INIT_VAR(cacheKey);	ZEPHIR_CONCAT_SVSV(cacheKey, "auryn.refls.methods.", _0, ".", _1);	_2 = zephir_fetch_nproperty_this(this_ptr, SL("cache"), PH_NOISY_CC);	ZEPHIR_CALL_METHOD(&reflectedMethod, _2, "fetch", NULL, cacheKey);	zephir_check_call_status();	if (!(zephir_is_true(reflectedMethod))) {		ZEPHIR_INIT_BNVAR(reflectedMethod);		_3 = zend_fetch_class(SL("ReflectionMethod"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);		object_init_ex(reflectedMethod, _3);		ZEPHIR_CALL_METHOD(NULL, reflectedMethod, "__construct", NULL, className, methodName);		zephir_check_call_status();		_4 = zephir_fetch_nproperty_this(this_ptr, SL("cache"), PH_NOISY_CC);		ZEPHIR_CALL_METHOD(NULL, _4, "store", NULL, cacheKey, reflectedMethod);		zephir_check_call_status();	}	RETURN_CCTOR(reflectedMethod);}

PHP_METHOD(Test_UseTest, testUseNamespaceAlias) {	zend_class_entry *_0;	ZEPHIR_MM_GROW();	_0 = zend_fetch_class(SL("Oo//OoConstruct"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);	object_init_ex(return_value, _0);	if (zephir_has_constructor(return_value TSRMLS_CC)) {		zephir_call_method_noret(return_value, "__construct");	}	RETURN_MM();}

// Create a PHP object given a typename and call the ctor, optionally passing up to 2 argumentsvoid createObject(char* obj_typename, zval* return_value, int nargs = 0, zval* arg1 = NULL, zval* arg2 = NULL) {    TSRMLS_FETCH();    size_t obj_typename_len = strlen(obj_typename);    zend_class_entry* ce = zend_fetch_class(obj_typename, obj_typename_len, ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC);    if (! ce) {        php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s does not exist", obj_typename);        RETURN_NULL();    }    object_and_properties_init(return_value, ce, NULL);    zend_function* constructor = zend_std_get_constructor(return_value TSRMLS_CC);    zval* ctor_rv = NULL;    zend_call_method(&return_value, ce, &constructor, NULL, 0, &ctor_rv, nargs, arg1, arg2 TSRMLS_CC);    zval_ptr_dtor(&ctor_rv);}

/** * Initializes the internal handler, calling functions on it * * @param  string method * @param  array arguments * @return mixed */PHP_METHOD(Phalcon_Mvc_Micro_LazyLoader, __call) {	zval *_2;	int ZEPHIR_LAST_CALL_STATUS;	zend_class_entry *_1;	zval *method_param = NULL, *arguments, *handler = NULL, *definition, *_0 = NULL;	zval *method = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 2, 0, &method_param, &arguments);	if (unlikely(Z_TYPE_P(method_param) != IS_STRING && Z_TYPE_P(method_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'method' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (likely(Z_TYPE_P(method_param) == IS_STRING)) {		zephir_get_strval(method, method_param);	} else {		ZEPHIR_INIT_VAR(method);		ZVAL_EMPTY_STRING(method);	}	ZEPHIR_OBS_VAR(handler);	zephir_read_property_this(&handler, this_ptr, SL("_handler"), PH_NOISY_CC);	if (Z_TYPE_P(handler) != IS_OBJECT) {		ZEPHIR_OBS_VAR(definition);		zephir_read_property_this(&definition, this_ptr, SL("_definition"), PH_NOISY_CC);		ZEPHIR_INIT_NVAR(handler);		zephir_fetch_safe_class(_0, definition);		_1 = zend_fetch_class(Z_STRVAL_P(_0), Z_STRLEN_P(_0), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);		object_init_ex(handler, _1);		if (zephir_has_constructor(handler TSRMLS_CC)) {			ZEPHIR_CALL_METHOD(NULL, handler, "__construct", NULL);			zephir_check_call_status();		}		zephir_update_property_this(this_ptr, SL("_handler"), handler TSRMLS_CC);	}	ZEPHIR_INIT_VAR(_2);	zephir_create_array(_2, 2, 0 TSRMLS_CC);	zephir_array_fast_append(_2, handler);	zephir_array_fast_append(_2, method);	ZEPHIR_CALL_USER_FUNC_ARRAY(return_value, _2, arguments);	zephir_check_call_status();	RETURN_MM();}

PHP_METHOD(Feathers_Router_MethodsCollection, getIterator) {	int ZEPHIR_LAST_CALL_STATUS;	zval *_1;	zend_class_entry *_0;	ZEPHIR_MM_GROW();	_0 = zend_fetch_class(SL("ArrayIterator"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);	object_init_ex(return_value, _0);	_1 = zephir_fetch_nproperty_this(this_ptr, SL("_methods"), PH_NOISY_CC);	ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, _1);	zephir_check_call_status();	RETURN_MM();}

PHP_METHOD(Test_Oo_OoDynamicA, getNew) {	zend_class_entry *_0;	zval *className, *fullClassName;	ZEPHIR_MM_GROW();	ZEPHIR_INIT_VAR(className);	zephir_call_func(className, "get_called_class");	ZEPHIR_INIT_VAR(fullClassName);	ZEPHIR_CONCAT_SV(fullClassName, "//", className);	_0 = zend_fetch_class(Z_STRVAL_P(fullClassName), Z_STRLEN_P(fullClassName), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);	object_init_ex(return_value, _0);	RETURN_MM();}

/** * Create internal connection to memcached */PHP_METHOD(Phalcon_Cache_Backend_Libmemcached, _connect){	zval *options, *memcache, *servers, *client = NULL, *res = NULL;	zend_string *str_key;	ulong idx;	zend_class_entry *ce0;	PHALCON_MM_GROW();	options = phalcon_read_property(getThis(), SL("_options"), PH_NOISY);	ce0 = zend_fetch_class(SSL("Memcached"), ZEND_FETCH_CLASS_AUTO);	PHALCON_INIT_VAR(memcache);	object_init_ex(memcache, ce0);	if (phalcon_has_constructor(memcache)) {		PHALCON_CALL_METHOD(NULL, memcache, "__construct");	}	if (!phalcon_array_isset_str_fetch(&servers, options, SL("servers")) || Z_TYPE_P(servers) != IS_ARRAY) {		PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Servers must be an array");		return;	}	phalcon_array_isset_str_fetch(&client, options, SL("client"));	PHALCON_RETURN_CALL_METHOD(memcache, "addservers", servers);	if (!zend_is_true(return_value)) {		PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Cannot connect to Memcached server");		return;	}	if (client && Z_TYPE_P(client) == IS_ARRAY) {		zval *value;		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(client), idx, str_key, value) {			zval option;			if (str_key) {				if ((res = zend_get_constant(str_key)) != NULL) {					PHALCON_CALL_METHOD(NULL, memcache, "setoption", res, value);				}			} else {				ZVAL_LONG(&option, idx);				PHALCON_CALL_METHOD(NULL, memcache, "setoption", &option, value);			}		} ZEND_HASH_FOREACH_END();

// Create a PHP object given a typename and call the ctor, optionally passing up to 2 argumentsstaticvoid createObject(const char* obj_typename, zval* return_value, int nargs = 0, zval* arg1 = nullptr, zval* arg2 = nullptr) {  /* is there a better way to do that on the stack ? */  zend_string *obj_name = zend_string_init(obj_typename, strlen(obj_typename), 0);  zend_class_entry* ce = zend_fetch_class(obj_name, ZEND_FETCH_CLASS_DEFAULT);  zend_string_release(obj_name);  if (! ce) {    php_error_docref(nullptr, E_ERROR, "Class %s does not exist", obj_typename);    RETURN_NULL();  }  object_and_properties_init(return_value, ce, nullptr);  zend_function* constructor = zend_std_get_constructor(Z_OBJ_P(return_value));  zval ctor_rv;  zend_call_method(return_value, ce, &constructor, NULL, 0, &ctor_rv, nargs, arg1, arg2);  zval_dtor(&ctor_rv);}

PHP_METHOD(Owl_Log_AbstractWriter, setFormatter) {	zend_class_entry *_5;	int ZEPHIR_LAST_CALL_STATUS;	zend_bool _0;	zval *formatter, _1, *_2 = NULL, *_3, *_4 = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &formatter);	_0 = Z_TYPE_P(formatter) == IS_OBJECT;	if (_0) {		ZEPHIR_SINIT_VAR(_1);		ZVAL_STRING(&_1, "//Owl//Log//FormatterInterface", 0);		ZEPHIR_CALL_FUNCTION(&_2, "is_subclass_of", NULL, 2, formatter, &_1);		zephir_check_call_status();		_0 = zephir_is_true(_2);	}	if (_0) {		zephir_update_property_this(this_ptr, SL("formatter"), formatter TSRMLS_CC);	} else if (Z_TYPE_P(formatter) == IS_STRING) {		if (!(zephir_class_exists(formatter, 1 TSRMLS_CC))) {			ZEPHIR_THROW_EXCEPTION_DEBUG_STR(owl_log_exception_invalidformatterexception_ce, "Formatter class is not exits", "owl/Log/AbstractWriter.zep", 94);			return;		}		ZEPHIR_INIT_VAR(_3);		zephir_fetch_safe_class(_4, formatter);		_5 = zend_fetch_class(Z_STRVAL_P(_4), Z_STRLEN_P(_4), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);		object_init_ex(_3, _5);		if (zephir_has_constructor(_3 TSRMLS_CC)) {			ZEPHIR_CALL_METHOD(NULL, _3, "__construct", NULL, 0);			zephir_check_call_status();		}		zephir_update_property_this(this_ptr, SL("formatter"), _3 TSRMLS_CC);	} else {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(owl_log_exception_invalidformatterexception_ce, "Formatter set error", "owl/Log/AbstractWriter.zep", 99);		return;	}	ZEPHIR_MM_RESTORE();}

/** * Create internal connection to memcached */PHP_METHOD(Phalcon_Cache_Backend_Memcache, _connect){	zval *options, *memcache, *host, *port, *persistent;	zval *success = NULL;	zend_class_entry *ce0;	PHALCON_MM_GROW();	PHALCON_OBS_VAR(options);	phalcon_read_property(&options, this_ptr, SL("_options"), PH_NOISY_CC);	ce0 = zend_fetch_class(SL("Memcache"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);		PHALCON_INIT_VAR(memcache);	object_init_ex(memcache, ce0);	if (phalcon_has_constructor(memcache TSRMLS_CC)) {		PHALCON_CALL_METHOD_NORETURN(memcache, "__construct");	}		PHALCON_OBS_VAR(host);	phalcon_array_fetch_string(&host, options, SL("host"), PH_NOISY_CC);		PHALCON_OBS_VAR(port);	phalcon_array_fetch_string(&port, options, SL("port"), PH_NOISY_CC);		PHALCON_OBS_VAR(persistent);	phalcon_array_fetch_string(&persistent, options, SL("persistent"), PH_NOISY_CC);	if (zend_is_true(persistent)) {		PHALCON_INIT_VAR(success);		PHALCON_CALL_METHOD_PARAMS_2(success, memcache, "pconnect", host, port);	} else {		PHALCON_INIT_NVAR(success);		PHALCON_CALL_METHOD_PARAMS_2(success, memcache, "connect", host, port);	}		if (!zend_is_true(success)) {		PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Cannot connect to Memcached server");		return;	}		phalcon_update_property_zval(this_ptr, SL("_memcache"), memcache TSRMLS_CC);		PHALCON_MM_RESTORE();}