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

PHP_METHOD(Auryn_AbstractCachingReflector, __construct) {	int ZEPHIR_LAST_CALL_STATUS;	zend_bool _0, _1;	zval *reflector = NULL, *cache = NULL, *_2 = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 0, 2, &reflector, &cache);	if (!reflector) {		reflector = ZEPHIR_GLOBAL(global_null);	}	if (!cache) {		cache = ZEPHIR_GLOBAL(global_null);	}	_0 = Z_TYPE_P(reflector) != IS_NULL;	if (_0) {		_0 = !zephir_instance_of_ev(reflector, auryn_reflectorinterface_ce TSRMLS_CC);	}	if (_0) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'reflector' must be an instance of 'Auryn////ReflectorInterface'", "", 0);		return;	}	_1 = Z_TYPE_P(cache) != IS_NULL;	if (_1) {		_1 = !zephir_instance_of_ev(cache, auryn_reflectioncacheinterface_ce TSRMLS_CC);	}	if (_1) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'cache' must be an instance of 'Auryn////ReflectionCacheInterface'", "", 0);		return;	}	if (unlikely(Z_TYPE_P(reflector) == IS_NULL)) {		ZEPHIR_INIT_VAR(_2);		object_init_ex(_2, auryn_standardreflector_ce);		if (zephir_has_constructor(_2 TSRMLS_CC)) {			ZEPHIR_CALL_METHOD(NULL, _2, "__construct", NULL);			zephir_check_call_status();		}		zephir_update_property_this(this_ptr, SL("reflector"), _2 TSRMLS_CC);	} else {		zephir_update_property_this(this_ptr, SL("reflector"), reflector TSRMLS_CC);	}	if (unlikely(Z_TYPE_P(cache) == IS_NULL)) {		ZEPHIR_INIT_LNVAR(_2);		object_init_ex(_2, auryn_reflectioncachearray_ce);		if (zephir_has_constructor(_2 TSRMLS_CC)) {			ZEPHIR_CALL_METHOD(NULL, _2, "__construct", NULL);			zephir_check_call_status();		}		zephir_update_property_this(this_ptr, SL("cache"), _2 TSRMLS_CC);	} else {		zephir_update_property_this(this_ptr, SL("cache"), cache TSRMLS_CC);	}	ZEPHIR_MM_RESTORE();}

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

PHP_METHOD(Owl_Cache_Driver_Redis, getInstance) {	int ZEPHIR_LAST_CALL_STATUS;	zval *_0, *_1, *_2, *_3 = NULL, *_4, *_5;	ZEPHIR_MM_GROW();	_0 = zephir_fetch_nproperty_this(this_ptr, SL("instance"), PH_NOISY_CC);	if (Z_TYPE_P(_0) == IS_NULL) {		ZEPHIR_INIT_VAR(_1);		object_init_ex(_1, zephir_get_internal_ce(SS("redis") TSRMLS_CC));		if (zephir_has_constructor(_1 TSRMLS_CC)) {			ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 0);			zephir_check_call_status();		}		zephir_update_property_this(this_ptr, SL("instance"), _1 TSRMLS_CC);		_2 = zephir_fetch_nproperty_this(this_ptr, SL("instance"), PH_NOISY_CC);		ZEPHIR_INIT_VAR(_3);		ZVAL_STRING(_3, "localhost", ZEPHIR_TEMP_PARAM_COPY);		ZEPHIR_CALL_METHOD(NULL, _2, "connect", NULL, 0, _3);		zephir_check_temp_parameter(_3);		zephir_check_call_status();		_4 = zephir_fetch_nproperty_this(this_ptr, SL("instance"), PH_NOISY_CC);		ZEPHIR_INIT_NVAR(_3);		ZVAL_LONG(_3, 1);		ZEPHIR_INIT_VAR(_5);		ZVAL_LONG(_5, 1);		ZEPHIR_CALL_METHOD(NULL, _4, "setoption", NULL, 0, _3, _5);		zephir_check_call_status();		RETURN_MM_MEMBER(this_ptr, "instance");	}	RETURN_MM_MEMBER(this_ptr, "instance");}

PHP_METHOD(Test_Oo_OoDynamicA, getNew) {	zend_class_entry *_1;	zval className, fullClassName, _0;	int ZEPHIR_LAST_CALL_STATUS;	ZEPHIR_INIT_THIS();	ZVAL_UNDEF(&className);	ZVAL_UNDEF(&fullClassName);	ZVAL_UNDEF(&_0);	ZEPHIR_MM_GROW();	ZEPHIR_INIT_VAR(&className);	zephir_get_called_class(&className TSRMLS_CC);	ZEPHIR_INIT_VAR(&fullClassName);	ZEPHIR_CONCAT_SV(&fullClassName, "//", &className);	zephir_fetch_safe_class(_0, fullClassName);	_1 = zephir_fetch_class_str_ex(Z_STRVAL_P(&_0), Z_STRLEN_P(&_0), ZEND_FETCH_CLASS_AUTO);	object_init_ex(return_value, _1);	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_Instanceoff, testInstanceOf8) {	zend_long ZEPHIR_LAST_CALL_STATUS;	zval *test_param = NULL, a;	zval test;	zval *this_ptr = getThis();	ZVAL_UNDEF(&test);	ZVAL_UNDEF(&a);	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &test_param);	zephir_get_strval(&test, test_param);	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_is_instance_of(&a, Z_STRVAL_P(&test), Z_STRLEN_P(&test) TSRMLS_CC));}

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

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(Phalcon_Translate_Adapter, __construct) {	zend_long ZEPHIR_LAST_CALL_STATUS;	zval *options_param = NULL, interpolator;	zval options;	zval *this_ptr = getThis();	ZVAL_UNDEF(&options);	ZVAL_UNDEF(&interpolator);	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &options_param);	ZEPHIR_OBS_COPY_OR_DUP(&options, options_param);	ZEPHIR_OBS_VAR(&interpolator);	if (!(zephir_array_isset_string_fetch(&interpolator, &options, SL("interpolator"), 0))) {		ZEPHIR_INIT_NVAR(&interpolator);		object_init_ex(&interpolator, phalcon_translate_interpolator_associativearray_ce);		if (zephir_has_constructor(&interpolator TSRMLS_CC)) {			ZEPHIR_CALL_METHOD(NULL, &interpolator, "__construct", NULL, 0);			zephir_check_call_status();		}	}	ZEPHIR_CALL_METHOD(NULL, this_ptr, "setinterpolator", NULL, 0, &interpolator);	zephir_check_call_status();	ZEPHIR_MM_RESTORE();}

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

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

/** * Create internal connection to redis */PHP_METHOD(Phalcon_Cache_Backend_Redis, _connect) {	zend_bool _0, _1;	int ZEPHIR_LAST_CALL_STATUS;	zval *options, *redis, *persistent, *success = NULL, *host, *port, *auth;	ZEPHIR_MM_GROW();	ZEPHIR_OBS_VAR(options);	zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC);	ZEPHIR_INIT_VAR(redis);	object_init_ex(redis, zephir_get_internal_ce(SS("redis") TSRMLS_CC));	if (zephir_has_constructor(redis TSRMLS_CC)) {		ZEPHIR_CALL_METHOD(NULL, redis, "__construct", NULL);		zephir_check_call_status();	}	ZEPHIR_OBS_VAR(host);	_0 = !(zephir_array_isset_string_fetch(&host, options, SS("host"), 0 TSRMLS_CC));	if (!(_0)) {		ZEPHIR_OBS_VAR(port);		_0 = !(zephir_array_isset_string_fetch(&port, options, SS("port"), 0 TSRMLS_CC));	}	_1 = _0;	if (!(_1)) {		ZEPHIR_OBS_VAR(persistent);		_1 = !(zephir_array_isset_string_fetch(&persistent, options, SS("persistent"), 0 TSRMLS_CC));	}	if (_1) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/redis.zep", 104);		return;	}	if (zephir_is_true(persistent)) {		ZEPHIR_CALL_METHOD(&success, redis, "pconnect", NULL, host, port);		zephir_check_call_status();	} else {		ZEPHIR_CALL_METHOD(&success, redis, "connect", NULL, host, port);		zephir_check_call_status();	}	if (!(zephir_is_true(success))) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cannot connect to Redisd server", "phalcon/cache/backend/redis.zep", 114);		return;	}	ZEPHIR_OBS_VAR(auth);	if (zephir_array_isset_string_fetch(&auth, options, SS("auth"), 0 TSRMLS_CC)) {		ZEPHIR_CALL_METHOD(&success, redis, "auth", NULL, auth);		zephir_check_call_status();		if (!(zephir_is_true(success))) {			ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Redisd server is authentication failed", "phalcon/cache/backend/redis.zep", 121);			return;		}	}	zephir_update_property_this(this_ptr, SL("_redis"), redis TSRMLS_CC);	ZEPHIR_MM_RESTORE();}

PHP_METHOD(Test_Oo_OoParams, createOtherClassWithoutWriteCurrentNamespace) {	ZEPHIR_MM_GROW();	object_init_ex(return_value, test_oo_oodynamica_ce);	if (zephir_has_constructor(return_value TSRMLS_CC)) {		zephir_call_method_noret(return_value, "__construct");	}	RETURN_MM();}

/** * Dumps a PHP array to a YAML string. * * The dump method, when supplied with an array, will do its best * to convert the array into friendly YAML. * * @param array array  PHP array * @param int   inline The level where you switch to inline YAML * @param int   indent The amount of spaces to use for indentation of nested nodes. * @param int   flags  A bit field of DUMP_* constants to customize the dumped YAML string * * @return string A YAML string representing the original PHP array */PHP_METHOD(Symphir_Component_Yaml_Yaml, dump) {	zephir_nts_static zend_class_entry *_0 = NULL;	int inlineLevel, indent, flags, ZEPHIR_LAST_CALL_STATUS;	zval *phpArray_param = NULL, *inlineLevel_param = NULL, *indent_param = NULL, *flags_param = NULL, yaml, _1, _2, _3;	zval phpArray;	ZEPHIR_INIT_THIS();	ZVAL_UNDEF(&phpArray);	ZVAL_UNDEF(&yaml);	ZVAL_UNDEF(&_1);	ZVAL_UNDEF(&_2);	ZVAL_UNDEF(&_3);	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 3, &phpArray_param, &inlineLevel_param, &indent_param, &flags_param);	zephir_get_arrval(&phpArray, phpArray_param);	if (!inlineLevel_param) {		inlineLevel = 2;	} else {		inlineLevel = zephir_get_intval(inlineLevel_param);	}	if (!indent_param) {		indent = 4;	} else {		indent = zephir_get_intval(indent_param);	}	if (!flags_param) {		flags = 0;	} else {		flags = zephir_get_intval(flags_param);	}	ZEPHIR_INIT_VAR(&yaml);	if (!_0) {	_0 = zephir_fetch_class_str_ex(SL("Symphir//Component//Yaml//Dumper"), ZEND_FETCH_CLASS_AUTO);	}	object_init_ex(&yaml, _0);	if (zephir_has_constructor(&yaml TSRMLS_CC)) {		ZVAL_LONG(&_1, indent);		ZEPHIR_CALL_METHOD(NULL, &yaml, "__construct", NULL, 0, &_1);		zephir_check_call_status();	}	ZVAL_LONG(&_1, inlineLevel);	ZVAL_LONG(&_2, 0);	ZVAL_LONG(&_3, flags);	ZEPHIR_RETURN_CALL_METHOD(&yaml, "dump", NULL, 0, &phpArray, &_1, &_2, &_3);	zephir_check_call_status();	RETURN_MM();}

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

PHP_METHOD(Owl_Log_AbstractWriter, defaultFormatter) {	int ZEPHIR_LAST_CALL_STATUS;	ZEPHIR_MM_GROW();	object_init_ex(return_value, owl_log_formatter_line_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_Oo, testInstance3) {	zval *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_noret(o, "__construct");	}	RETURN_CCTOR(o);}

PHP_METHOD(Test_Oo_OoParams, createOtherClassWithoutWriteCurrentNamespace) {	int ZEPHIR_LAST_CALL_STATUS;	ZEPHIR_MM_GROW();	object_init_ex(return_value, test_oo_oodynamica_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_Instanceoff, testInstanceOf2) {	zval *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_noret(a, "__construct");	}	RETURN_MM_BOOL(zephir_instance_of_ev(a, test_instanceoff_ce TSRMLS_CC));}

PHP_METHOD(Lynx_DBAL_Driver_PgSQL, getNewPlatform) {	int ZEPHIR_LAST_CALL_STATUS;	ZEPHIR_MM_GROW();	object_init_ex(return_value, lynx_dbal_platform_pgsql_ce);	if (zephir_has_constructor(return_value TSRMLS_CC)) {		ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL);		zephir_check_call_status();	}	RETURN_MM();}

/** * 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(Test_Instanceoff, testInstanceOf2) {	int ZEPHIR_LAST_CALL_STATUS;	zval *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) {	int ZEPHIR_LAST_CALL_STATUS;	zval *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);		zephir_check_call_status();	}	RETURN_CCTOR(o);}

/** * Create internal connection to memcached */PHP_METHOD(Phalcon_Cache_Backend_Memcache, _connect) {    zend_bool _0, _1;    zval *options = NULL, *memcache = NULL, *persistent = NULL, *success = NULL, *host = NULL, *port = NULL;    int ZEPHIR_LAST_CALL_STATUS;    ZEPHIR_MM_GROW();    ZEPHIR_OBS_VAR(options);    zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC);    ZEPHIR_INIT_VAR(memcache);    object_init_ex(memcache, zephir_get_internal_ce(SS("memcache") TSRMLS_CC));    if (zephir_has_constructor(memcache TSRMLS_CC)) {        ZEPHIR_CALL_METHOD(NULL, memcache, "__construct", NULL, 0);        zephir_check_call_status();    }    ZEPHIR_OBS_VAR(host);    _0 = !(zephir_array_isset_string_fetch(&host, options, SS("host"), 0 TSRMLS_CC));    if (!(_0)) {        ZEPHIR_OBS_VAR(port);        _0 = !(zephir_array_isset_string_fetch(&port, options, SS("port"), 0 TSRMLS_CC));    }    _1 = _0;    if (!(_1)) {        ZEPHIR_OBS_VAR(persistent);        _1 = !(zephir_array_isset_string_fetch(&persistent, options, SS("persistent"), 0 TSRMLS_CC));    }    if (_1) {        ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/memcache.zep", 105);        return;    }    if (zephir_is_true(persistent)) {        ZEPHIR_CALL_METHOD(&success, memcache, "pconnect", NULL, 0, host, port);        zephir_check_call_status();    } else {        ZEPHIR_CALL_METHOD(&success, memcache, "connect", NULL, 0, host, port);        zephir_check_call_status();    }    if (!(zephir_is_true(success))) {        ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cannot connect to Memcached server", "phalcon/cache/backend/memcache.zep", 115);        return;    }    zephir_update_property_this(this_ptr, SL("_memcache"), memcache TSRMLS_CC);    ZEPHIR_MM_RESTORE();}

/** * Starts the profile of a SQL sentence * * @param string sqlStatement * @return Phalcon/Db/Profiler */PHP_METHOD(Phalcon_Db_Profiler, startProfile) {	zephir_nts_static zephir_fcall_cache_entry *_0 = NULL, *_1 = NULL, *_2 = NULL, *_4 = NULL;	int ZEPHIR_LAST_CALL_STATUS;	zval *sqlStatement, *sqlVariables = NULL, *sqlBindTypes = NULL, *activeProfile, *_3;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 2, &sqlStatement, &sqlVariables, &sqlBindTypes);	if (!sqlVariables) {		sqlVariables = ZEPHIR_GLOBAL(global_null);	}	if (!sqlBindTypes) {		sqlBindTypes = ZEPHIR_GLOBAL(global_null);	}	ZEPHIR_INIT_VAR(activeProfile);	object_init_ex(activeProfile, phalcon_db_profiler_item_ce);	if (zephir_has_constructor(activeProfile TSRMLS_CC)) {		ZEPHIR_CALL_METHOD(NULL, activeProfile, "__construct", NULL);		zephir_check_call_status();	}	ZEPHIR_CALL_METHOD(NULL, activeProfile, "setsqlstatement", &_0, sqlStatement);	zephir_check_call_status();	if (Z_TYPE_P(sqlVariables) == IS_ARRAY) {		ZEPHIR_CALL_METHOD(NULL, activeProfile, "setsqlvariables", &_1, sqlVariables);		zephir_check_call_status();	}	if (Z_TYPE_P(sqlBindTypes) == IS_ARRAY) {		ZEPHIR_CALL_METHOD(NULL, activeProfile, "setsqlbindtypes", &_2, sqlBindTypes);		zephir_check_call_status();	}	ZEPHIR_INIT_VAR(_3);	zephir_microtime(_3, ZEPHIR_GLOBAL(global_true) TSRMLS_CC);	ZEPHIR_CALL_METHOD(NULL, activeProfile, "setinitialtime", &_4, _3);	zephir_check_call_status();	if ((zephir_method_exists_ex(this_ptr, SS("beforestartprofile") TSRMLS_CC) == SUCCESS)) {		ZEPHIR_CALL_METHOD(NULL, this_ptr, "beforestartprofile", NULL, activeProfile);		zephir_check_call_status();	}	zephir_update_property_this(this_ptr, SL("_activeProfile"), activeProfile TSRMLS_CC);	RETURN_THIS();}

PHP_METHOD(Test_Mcall, aa) {	zephir_nts_static zephir_fcall_cache_entry *_0 = NULL;	int ZEPHIR_LAST_CALL_STATUS;	zval *a;	ZEPHIR_MM_GROW();	ZEPHIR_INIT_VAR(a);	object_init_ex(a, test_mcall_ce);	if (zephir_has_constructor(a TSRMLS_CC)) {		ZEPHIR_CALL_METHOD(NULL, a, "__construct", NULL);		zephir_check_call_status();	}	ZEPHIR_RETURN_CALL_METHOD(a, "bb", &_0);	zephir_check_call_status();	RETURN_MM();}