/**
* Phalcon\Mvc\Model\MetaData\Memcache constructor
*
* @param array options
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Memcache, __construct) {
zval *_6;
int ZEPHIR_LAST_CALL_STATUS;
zval *options = NULL, *ttl = NULL, *_4, *_5, *_7, *_0$$4, *_1$$5, *_2$$6, *_3$$7;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &options);
if (!options) {
ZEPHIR_CPY_WRT(options, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(options);
}
if (Z_TYPE_P(options) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(options);
array_init(options);
}
if (!(zephir_array_isset_string(options, SS("host")))) {
ZEPHIR_INIT_VAR(_0$$4);
ZVAL_STRING(_0$$4, "127.0.0.1", 1);
zephir_array_update_string(&options, SL("host"), &_0$$4, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("port")))) {
ZEPHIR_INIT_VAR(_1$$5);
ZVAL_LONG(_1$$5, 11211);
zephir_array_update_string(&options, SL("port"), &_1$$5, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("persistent")))) {
ZEPHIR_INIT_VAR(_2$$6);
ZVAL_LONG(_2$$6, 0);
zephir_array_update_string(&options, SL("persistent"), &_2$$6, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("statsKey")))) {
ZEPHIR_INIT_VAR(_3$$7);
ZVAL_STRING(_3$$7, "_PHCM_MM", 1);
zephir_array_update_string(&options, SL("statsKey"), &_3$$7, PH_COPY | PH_SEPARATE);
}
if (zephir_array_isset_string_fetch(&ttl, options, SS("lifetime"), 1 TSRMLS_CC)) {
zephir_update_property_this(this_ptr, SL("_ttl"), ttl TSRMLS_CC);
}
ZEPHIR_INIT_VAR(_4);
object_init_ex(_4, phalcon_cache_backend_memcache_ce);
ZEPHIR_INIT_VAR(_5);
object_init_ex(_5, phalcon_cache_frontend_data_ce);
ZEPHIR_INIT_VAR(_6);
zephir_create_array(_6, 1, 0 TSRMLS_CC);
ZEPHIR_OBS_VAR(_7);
zephir_read_property_this(&_7, this_ptr, SL("_ttl"), PH_NOISY_CC);
zephir_array_update_string(&_6, SL("lifetime"), &_7, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, _5, "__construct", NULL, 332, _6);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, _4, "__construct", NULL, 335, _5, options);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_memcache"), _4 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Phalcon\Queue\Beanstalk
*
* @param array options
*/
PHP_METHOD(Phalcon_Queue_Beanstalk, __construct) {
zval *options = NULL, *parameters = NULL, *_0$$5, *_1$$6;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &options);
if (!options) {
options = ZEPHIR_GLOBAL(global_null);
}
if (Z_TYPE_P(options) != IS_ARRAY) {
ZEPHIR_INIT_VAR(parameters);
array_init(parameters);
} else {
ZEPHIR_CPY_WRT(parameters, options);
}
if (!(zephir_array_isset_string(parameters, SS("host")))) {
ZEPHIR_INIT_VAR(_0$$5);
ZVAL_STRING(_0$$5, "127.0.0.1", 1);
zephir_array_update_string(¶meters, SL("host"), &_0$$5, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(parameters, SS("port")))) {
ZEPHIR_INIT_VAR(_1$$6);
ZVAL_LONG(_1$$6, 11300);
zephir_array_update_string(¶meters, SL("port"), &_1$$6, PH_COPY | PH_SEPARATE);
}
zephir_update_property_this(this_ptr, SL("_parameters"), parameters TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Check if the current page use SSL connection on not
*
* @return bool uses SSL
*/
PHP_METHOD(Phady_Util_Tools, usingSecureMode) {
zval *_SERVER, *_0, *_2 = NULL, *_3;
zend_bool secureMode, _1;
ZEPHIR_MM_GROW();
zephir_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC);
if (zephir_array_isset_string(_SERVER, SS("HTTPS"))) {
zephir_array_fetch_string(&_0, _SERVER, SL("HTTPS"), PH_NOISY | PH_READONLY, "phady/util/tools.zep", 113 TSRMLS_CC);
_1 = ZEPHIR_IS_LONG(_0, 1);
if (!(_1)) {
ZEPHIR_INIT_VAR(_2);
zephir_array_fetch_string(&_3, _SERVER, SL("HTTPS"), PH_NOISY | PH_READONLY, "phady/util/tools.zep", 113 TSRMLS_CC);
zephir_fast_strtolower(_2, _3);
_1 = ZEPHIR_IS_STRING(_2, "on");
}
secureMode = _1;
} else if (zephir_array_isset_string(_SERVER, SS("SSL"))) {
zephir_array_fetch_string(&_0, _SERVER, SL("SSL"), PH_NOISY | PH_READONLY, "phady/util/tools.zep", 117 TSRMLS_CC);
_1 = ZEPHIR_IS_LONG(_0, 1);
if (!(_1)) {
ZEPHIR_INIT_NVAR(_2);
zephir_array_fetch_string(&_3, _SERVER, SL("SSL"), PH_NOISY | PH_READONLY, "phady/util/tools.zep", 117 TSRMLS_CC);
zephir_fast_strtolower(_2, _3);
_1 = ZEPHIR_IS_STRING(_2, "on");
}
secureMode = _1;
} else {
secureMode = 0;
}
RETURN_MM_BOOL(secureMode);
}
/**
* Phalcon\Queue\Beanstalk
*/
PHP_METHOD(Phalcon_Queue_Beanstalk, __construct) {
zval *parameters_param = NULL, *_0$$3, *_1$$4;
zval *parameters = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, ¶meters_param);
if (!parameters_param) {
ZEPHIR_INIT_VAR(parameters);
array_init(parameters);
} else {
zephir_get_arrval(parameters, parameters_param);
}
if (!(zephir_array_isset_string(parameters, SS("host")))) {
ZEPHIR_INIT_VAR(_0$$3);
ZVAL_STRING(_0$$3, "127.0.0.1", 1);
zephir_array_update_string(¶meters, SL("host"), &_0$$3, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(parameters, SS("port")))) {
ZEPHIR_INIT_VAR(_1$$4);
ZVAL_LONG(_1$$4, 11300);
zephir_array_update_string(¶meters, SL("port"), &_1$$4, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(parameters, SS("persistent")))) {
zephir_array_update_string(¶meters, SL("persistent"), &ZEPHIR_GLOBAL(global_false), PH_COPY | PH_SEPARATE);
}
zephir_update_property_this(this_ptr, SL("_parameters"), parameters TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Phalcon\Cache\Backend\Mongo constructor
*
* @param Phalcon\Cache\FrontendInterface frontend
* @param array options
*/
PHP_METHOD(Phalcon_Cache_Backend_Mongo, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_nts_static zephir_fcall_cache_entry *_0 = NULL;
zval *frontend, *options = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &frontend, &options);
if (!options) {
options = ZEPHIR_GLOBAL(global_null);
}
if (!(zephir_array_isset_string(options, SS("mongo")))) {
if (!(zephir_array_isset_string(options, SS("server")))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "The parameter 'server' is required", "phalcon/cache/backend/mongo.zep", 70);
return;
}
}
if (!(zephir_array_isset_string(options, SS("db")))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "The parameter 'db' is required", "phalcon/cache/backend/mongo.zep", 75);
return;
}
if (!(zephir_array_isset_string(options, SS("collection")))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "The parameter 'collection' is required", "phalcon/cache/backend/mongo.zep", 79);
return;
}
ZEPHIR_CALL_PARENT(NULL, phalcon_cache_backend_mongo_ce, this_ptr, "__construct", &_0, frontend, options);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Phalcon\Cache\Backend\Redis constructor
*
* @param Phalcon\Cache\FrontendInterface frontend
* @param array options
*/
PHP_METHOD(Phalcon_Cache_Backend_Redis, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_3 = NULL;
zend_bool _1;
zval *frontend, *options = NULL, *_0 = NULL, *_2;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &frontend, &options);
if (!options) {
ZEPHIR_CPY_WRT(options, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(options);
}
if (Z_TYPE_P(options) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(options);
array_init(options);
}
if (!(zephir_array_isset_string(options, SS("host")))) {
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "127.0.0.1", 1);
zephir_array_update_string(&options, SL("host"), &_0, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("port")))) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_LONG(_0, 6379);
zephir_array_update_string(&options, SL("port"), &_0, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("index")))) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_LONG(_0, 0);
zephir_array_update_string(&options, SL("index"), &_0, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("persistent")))) {
zephir_array_update_string(&options, SL("persistent"), &ZEPHIR_GLOBAL(global_false), PH_COPY | PH_SEPARATE);
}
_1 = !(zephir_array_isset_string(options, SS("statsKey")));
if (!(_1)) {
zephir_array_fetch_string(&_2, options, SL("statsKey"), PH_NOISY | PH_READONLY, "phalcon/cache/backend/redis.zep", 90 TSRMLS_CC);
_1 = ZEPHIR_IS_EMPTY(_2);
}
if (_1) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "_PHCR", 1);
zephir_array_update_string(&options, SL("statsKey"), &_0, PH_COPY | PH_SEPARATE);
}
ZEPHIR_CALL_PARENT(NULL, phalcon_cache_backend_redis_ce, this_ptr, "__construct", &_3, 103, frontend, options);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Phalcon\Mvc\Model\MetaData\Libmemcached constructor
*
* @param array options
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Libmemcached, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zval *_2;
zval *options = NULL, *ttl, *_0 = NULL, *_1, *_3, *_4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &options);
if (!options) {
ZEPHIR_CPY_WRT(options, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(options);
}
if (Z_TYPE_P(options) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(options);
array_init(options);
}
if (!(zephir_array_isset_string(options, SS("servers")))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "No servers given in options", "phalcon/mvc/model/metadata/libmemcached.zep", 71);
return;
}
if (zephir_array_isset_string_fetch(&ttl, options, SS("lifetime"), 1 TSRMLS_CC)) {
zephir_update_property_this(this_ptr, SL("_ttl"), ttl TSRMLS_CC);
}
if (!(zephir_array_isset_string(options, SS("statsKey")))) {
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "_PHCM_MM", 1);
zephir_array_update_string(&options, SL("statsKey"), &_0, PH_COPY | PH_SEPARATE);
}
ZEPHIR_INIT_NVAR(_0);
object_init_ex(_0, phalcon_cache_backend_libmemcached_ce);
ZEPHIR_INIT_VAR(_1);
object_init_ex(_1, phalcon_cache_frontend_data_ce);
ZEPHIR_INIT_VAR(_2);
zephir_create_array(_2, 1, 0 TSRMLS_CC);
ZEPHIR_OBS_VAR(_3);
zephir_read_property_this(&_3, this_ptr, SL("_ttl"), PH_NOISY_CC);
zephir_array_update_string(&_2, SL("lifetime"), &_3, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 311, _2);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 312, _1, options);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_memcache"), _0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_4);
array_init(_4);
zephir_update_property_this(this_ptr, SL("_metaData"), _4 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Phalcon\Cache\Backend\Memcache constructor
*
* @param array options
*/
PHP_METHOD(Phalcon_Cache_Backend_Libmemcached, __construct) {
zval _0$$4;
zend_long ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_2 = NULL;
zval *frontend, frontend_sub, *options = NULL, options_sub, __$null, servers, _1$$5;
zval *this_ptr = getThis();
ZVAL_UNDEF(&frontend_sub);
ZVAL_UNDEF(&options_sub);
ZVAL_NULL(&__$null);
ZVAL_UNDEF(&servers);
ZVAL_UNDEF(&_1$$5);
ZVAL_UNDEF(&_0$$4);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &frontend, &options);
if (!options) {
options = &options_sub;
ZEPHIR_CPY_WRT(options, &__$null);
} else {
ZEPHIR_SEPARATE_PARAM(options);
}
if (Z_TYPE_P(options) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(options);
array_init(options);
}
if (!(zephir_array_isset_string(options, SL("servers")))) {
ZEPHIR_INIT_VAR(&servers);
zephir_create_array(&servers, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(&_0$$4);
zephir_create_array(&_0$$4, 3, 0 TSRMLS_CC);
add_assoc_stringl_ex(&_0$$4, SL("host"), SL("127.0.0.1"));
add_assoc_long_ex(&_0$$4, SL("port"), 11211);
add_assoc_long_ex(&_0$$4, SL("weight"), 1);
zephir_array_update_long(&servers, 0, &_0$$4, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_string(options, SL("servers"), &servers, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SL("statsKey")))) {
ZEPHIR_INIT_VAR(&_1$$5);
ZVAL_STRING(&_1$$5, "");
zephir_array_update_string(options, SL("statsKey"), &_1$$5, PH_COPY | PH_SEPARATE);
}
ZEPHIR_CALL_PARENT(NULL, phalcon_cache_backend_libmemcached_ce, getThis(), "__construct", &_2, 0, frontend, options);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Phalcon\Translate\Adapter\Csv constructor
*/
PHP_METHOD(Phalcon_Translate_Adapter_Csv, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_0 = NULL;
zval *options_param = NULL, *_1, *_2, *_3, *_4;
zval *options = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &options_param);
options = options_param;
ZEPHIR_CALL_PARENT(NULL, phalcon_translate_adapter_csv_ce, this_ptr, "__construct", &_0, 426, options);
zephir_check_call_status();
if (!(zephir_array_isset_string(options, SS("content")))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_translate_exception_ce, "Parameter 'content' is required", "phalcon/translate/adapter/csv.zep", 43);
return;
}
zephir_array_fetch_string(&_1, options, SL("content"), PH_NOISY | PH_READONLY, "phalcon/translate/adapter/csv.zep", 46 TSRMLS_CC);
ZEPHIR_INIT_VAR(_2);
ZVAL_LONG(_2, 0);
ZEPHIR_INIT_VAR(_3);
ZVAL_STRING(_3, ";", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_4);
ZVAL_STRING(_4, "\"", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_load", NULL, 427, _1, _2, _3, _4);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Create a Phalcon\Cache based on the internal cache options
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, _createCache) {
int ZEPHIR_LAST_CALL_STATUS;
zval *dependencyInjector, *cacheService = NULL, *cacheOptions, *viewCache = NULL, *_0 = NULL;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_view_exception_ce, "A dependency injector container is required to obtain the view cache services", "phalcon/mvc/view/simple.zep", 478);
return;
}
ZEPHIR_INIT_VAR(cacheService);
ZVAL_STRING(cacheService, "viewCache", 1);
ZEPHIR_OBS_VAR(cacheOptions);
zephir_read_property_this(&cacheOptions, this_ptr, SL("_cacheOptions"), PH_NOISY_CC);
if (Z_TYPE_P(cacheOptions) == IS_ARRAY) {
if (zephir_array_isset_string(cacheOptions, SS("service"))) {
ZEPHIR_OBS_NVAR(cacheService);
zephir_array_isset_string_fetch(&cacheService, cacheOptions, SS("service"), 0 TSRMLS_CC);
}
}
ZEPHIR_CALL_METHOD(&_0, dependencyInjector, "getshared", NULL, 0, cacheService);
zephir_check_call_status();
ZEPHIR_CPY_WRT(viewCache, _0);
if (Z_TYPE_P(viewCache) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_view_exception_ce, "The injected caching service is invalid", "phalcon/mvc/view/simple.zep", 495);
return;
}
RETURN_CCTOR(viewCache);
}
/**
* Phalcon\Cache\Backend\Xcache constructor
*
* @param \Phalcon\Cache\FrontendInterface frontend
* @param array options
*/
PHP_METHOD(Phalcon_Cache_Backend_Xcache, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_1 = NULL;
zval *frontend, *options = NULL, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &frontend, &options);
if (!options) {
ZEPHIR_CPY_WRT(options, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(options);
}
if (Z_TYPE_P(options) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(options);
array_init(options);
}
if (!(zephir_array_isset_string(options, SS("statsKey")))) {
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "_PHCX", 1);
zephir_array_update_string(&options, SL("statsKey"), &_0, PH_COPY | PH_SEPARATE);
}
ZEPHIR_CALL_PARENT(NULL, phalcon_cache_backend_xcache_ce, this_ptr, "__construct", &_1, 106, frontend, options);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Cake_Core_Configure, write) {
int ZEPHIR_LAST_CALL_STATUS, debug;
zephir_fcall_cache_entry *_4 = NULL;
HashTable *_1;
HashPosition _0;
zval *config = NULL, *value = NULL, *name = NULL, **_2, *_3 = NULL, *_5, *_6, *_7, _8, _9;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &config, &value);
ZEPHIR_SEPARATE_PARAM(config);
if (!value) {
ZEPHIR_CPY_WRT(value, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(value);
}
if (!(Z_TYPE_P(config) == IS_ARRAY)) {
ZEPHIR_INIT_NVAR(config);
zephir_create_array(config, 1, 0 TSRMLS_CC);
zephir_array_update_zval(&config, config, &value, PH_COPY);
}
zephir_is_iterable(config, &_1, &_0, 0, 0, "cake/Core/Configure.zep", 28);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HMKEY(name, _1, _0);
ZEPHIR_GET_HVALUE(value, _2);
_5 = zephir_fetch_static_property_ce(cake_core_configure_ce, SL("_values") TSRMLS_CC);
ZEPHIR_CALL_CE_STATIC(&_3, cake_utility_hash_ce, "insert", &_4, 0, _5, name, value);
zephir_check_call_status();
zephir_update_static_property_ce(cake_core_configure_ce, SL("_values"), &_3 TSRMLS_CC);
}
if (zephir_array_isset_string(config, SS("debug"))) {
_5 = zephir_fetch_static_property_ce(cake_core_configure_ce, SL("_hasIniSet") TSRMLS_CC);
if (Z_TYPE_P(_5) == IS_NULL) {
zephir_update_static_property_ce(cake_core_configure_ce, SL("_hasIniSet"), ((zephir_function_exists_ex(SS("ini_set") TSRMLS_CC) == SUCCESS)) ? &(ZEPHIR_GLOBAL(global_true)) : &(ZEPHIR_GLOBAL(global_false)) TSRMLS_CC);
}
_6 = zephir_fetch_static_property_ce(cake_core_configure_ce, SL("_hasIniSet") TSRMLS_CC);
if (zephir_is_true(_6)) {
zephir_array_fetch_string(&_7, config, SL("debug"), PH_NOISY | PH_READONLY, "cake/Core/Configure.zep", 36 TSRMLS_CC);
if (zephir_is_true(_7)) {
debug = 1;
} else {
debug = 0;
}
ZEPHIR_SINIT_VAR(_8);
ZVAL_STRING(&_8, "display_errors", 0);
ZEPHIR_SINIT_VAR(_9);
ZVAL_LONG(&_9, debug);
ZEPHIR_CALL_FUNCTION(NULL, "ini_set", NULL, 4, &_8, &_9);
zephir_check_call_status();
}
}
RETURN_MM_BOOL(1);
}
/**
* Get the server variable SERVER_NAME
*
* @return string server name
*/
PHP_METHOD(Phady_Util_Tools, getServerName) {
zend_bool _0;
zval *server = NULL, *_SERVER, *_1;
ZEPHIR_MM_GROW();
zephir_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC);
ZEPHIR_INIT_VAR(server);
ZVAL_STRING(server, "", 1);
_0 = zephir_array_isset_string(_SERVER, SS("HTTP_X_FORWARDED_SERVER"));
if (_0) {
zephir_array_fetch_string(&_1, _SERVER, SL("HTTP_X_FORWARDED_SERVER"), PH_NOISY | PH_READONLY, "phady/util/tools.zep", 37 TSRMLS_CC);
_0 = zephir_is_true(_1);
}
if (_0) {
ZEPHIR_OBS_NVAR(server);
zephir_array_fetch_string(&server, _SERVER, SL("HTTP_X_FORWARDED_SERVER"), PH_NOISY, "phady/util/tools.zep", 38 TSRMLS_CC);
} else {
ZEPHIR_OBS_NVAR(server);
zephir_array_fetch_string(&server, _SERVER, SL("SERVER_NAME"), PH_NOISY, "phady/util/tools.zep", 40 TSRMLS_CC);
}
RETURN_CCTOR(server);
}
/**
* Check whether the relation act as a foreign key
*/
PHP_METHOD(Phalcon_Mvc_Model_Relation, isForeignKey) {
zval *_0;
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY_CC);
RETURN_BOOL(zephir_array_isset_string(_0, SS("foreignKey")));
}
/**
* Generate the HTML to label the element
*
* @param array attributes
*/
PHP_METHOD(Phalcon_Forms_Element, label) {
zend_bool _2;
zephir_fcall_cache_entry *_0 = NULL;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *attributes = NULL, *internalAttributes = NULL, *label = NULL, *name = NULL, *code = NULL, *_1, *_3$$7, *_4$$8;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &attributes);
if (!attributes) {
ZEPHIR_CPY_WRT(attributes, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(attributes);
}
ZEPHIR_CALL_METHOD(&internalAttributes, this_ptr, "getattributes", NULL, 0);
zephir_check_call_status();
ZEPHIR_OBS_VAR(name);
if (!(zephir_array_isset_string_fetch(&name, internalAttributes, SS("id"), 0 TSRMLS_CC))) {
ZEPHIR_OBS_NVAR(name);
zephir_read_property_this(&name, this_ptr, SL("_name"), PH_NOISY_CC);
}
if (Z_TYPE_P(attributes) == IS_ARRAY) {
if (!(zephir_array_isset_string(attributes, SS("for")))) {
zephir_array_update_string(&attributes, SL("for"), &name, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_INIT_NVAR(attributes);
zephir_create_array(attributes, 1, 0 TSRMLS_CC);
zephir_array_update_string(&attributes, SL("for"), &name, PH_COPY | PH_SEPARATE);
}
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "<label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_CE_STATIC(&code, phalcon_tag_ce, "renderattributes", &_0, 4, _1, attributes);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
ZEPHIR_OBS_VAR(label);
zephir_read_property_this(&label, this_ptr, SL("_label"), PH_NOISY_CC);
_2 = zephir_is_true(label);
if (!(_2)) {
_2 = zephir_is_numeric(label);
}
if (_2) {
ZEPHIR_INIT_VAR(_3$$7);
ZEPHIR_CONCAT_SVS(_3$$7, ">", label, "</label>");
zephir_concat_self(&code, _3$$7 TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(_4$$8);
ZEPHIR_CONCAT_SVS(_4$$8, ">", name, "</label>");
zephir_concat_self(&code, _4$$8 TSRMLS_CC);
}
RETURN_CCTOR(code);
}
/**
* Phalcon\Cache\Backend\Memcache constructor
*
* @param Phalcon\Cache\FrontendInterface frontend
* @param array options
*/
PHP_METHOD(Phalcon_Cache_Backend_Memcache, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_3 = NULL;
zval *frontend, *options = NULL, *_0$$4, *_1$$5, *_2$$7;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &frontend, &options);
if (!options) {
ZEPHIR_CPY_WRT(options, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(options);
}
if (Z_TYPE_P(options) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(options);
array_init(options);
}
if (!(zephir_array_isset_string(options, SS("host")))) {
ZEPHIR_INIT_VAR(_0$$4);
ZVAL_STRING(_0$$4, "127.0.0.1", 1);
zephir_array_update_string(&options, SL("host"), &_0$$4, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("port")))) {
ZEPHIR_INIT_VAR(_1$$5);
ZVAL_LONG(_1$$5, 11211);
zephir_array_update_string(&options, SL("port"), &_1$$5, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("persistent")))) {
zephir_array_update_string(&options, SL("persistent"), &ZEPHIR_GLOBAL(global_false), PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("statsKey")))) {
ZEPHIR_INIT_VAR(_2$$7);
ZVAL_STRING(_2$$7, "", 1);
zephir_array_update_string(&options, SL("statsKey"), &_2$$7, PH_COPY | PH_SEPARATE);
}
ZEPHIR_CALL_PARENT(NULL, phalcon_cache_backend_memcache_ce, this_ptr, "__construct", &_3, 113, frontend, options);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Phalcon\Cache\Backend\Redis constructor
*
* @param Phalcon\Cache\FrontendInterface frontend
* @param array options
*/
PHP_METHOD(Phalcon_Cache_Backend_Redis, __construct) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_6 = NULL;
zval *frontend, *options = NULL, *_0$$4, *_1$$5, *_2$$6, *_3$$8, *_4$$9, *_5$$10;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &frontend, &options);
if (!options) {
ZEPHIR_CPY_WRT(options, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(options);
}
if (Z_TYPE_P(options) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(options);
array_init(options);
}
if (!(zephir_array_isset_string(options, SS("host")))) {
ZEPHIR_INIT_VAR(_0$$4);
ZVAL_STRING(_0$$4, "127.0.0.1", 1);
zephir_array_update_string(&options, SL("host"), &_0$$4, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("port")))) {
ZEPHIR_INIT_VAR(_1$$5);
ZVAL_LONG(_1$$5, 6379);
zephir_array_update_string(&options, SL("port"), &_1$$5, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("index")))) {
ZEPHIR_INIT_VAR(_2$$6);
ZVAL_LONG(_2$$6, 0);
zephir_array_update_string(&options, SL("index"), &_2$$6, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("persistent")))) {
zephir_array_update_string(&options, SL("persistent"), &ZEPHIR_GLOBAL(global_false), PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("statsKey")))) {
ZEPHIR_INIT_VAR(_3$$8);
ZVAL_STRING(_3$$8, "", 1);
zephir_array_update_string(&options, SL("statsKey"), &_3$$8, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("auth")))) {
ZEPHIR_INIT_VAR(_4$$9);
ZVAL_STRING(_4$$9, "", 1);
zephir_array_update_string(&options, SL("auth"), &_4$$9, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("timeout")))) {
ZEPHIR_INIT_VAR(_5$$10);
ZVAL_LONG(_5$$10, 0);
zephir_array_update_string(&options, SL("timeout"), &_5$$10, PH_COPY | PH_SEPARATE);
}
ZEPHIR_CALL_PARENT(NULL, phalcon_cache_backend_redis_ce, getThis(), "__construct", &_6, 124, frontend, options);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
* Call it when you need to restore a database connection.
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, connect) {
zend_bool _3$$6;
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_5 = NULL;
zval *descriptor_param = NULL, *schema = NULL, *sql = NULL, *status = NULL, *_0$$3, *_2$$6, *_4$$6;
zval *descriptor = NULL, *_1$$3 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &descriptor_param);
if (!descriptor_param) {
ZEPHIR_INIT_VAR(descriptor);
array_init(descriptor);
} else {
zephir_get_arrval(descriptor, descriptor_param);
}
if (ZEPHIR_IS_EMPTY(descriptor)) {
ZEPHIR_OBS_VAR(_0$$3);
zephir_read_property_this(&_0$$3, this_ptr, SL("_descriptor"), PH_NOISY_CC);
zephir_get_arrval(_1$$3, _0$$3);
ZEPHIR_CPY_WRT(descriptor, _1$$3);
}
ZEPHIR_OBS_VAR(schema);
if (zephir_array_isset_string_fetch(&schema, descriptor, SS("schema"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&descriptor, SS("schema"), PH_SEPARATE);
} else {
ZEPHIR_INIT_NVAR(schema);
ZVAL_STRING(schema, "", 1);
}
if (zephir_array_isset_string(descriptor, SS("password"))) {
ZEPHIR_OBS_VAR(_2$$6);
zephir_array_fetch_string(&_2$$6, descriptor, SL("password"), PH_NOISY, "phalcon/db/adapter/pdo/postgresql.zep", 73 TSRMLS_CC);
_3$$6 = Z_TYPE_P(_2$$6) == IS_STRING;
if (_3$$6) {
zephir_array_fetch_string(&_4$$6, descriptor, SL("password"), PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/postgresql.zep", 73 TSRMLS_CC);
_3$$6 = zephir_fast_strlen_ev(_4$$6) == 0;
}
if (_3$$6) {
zephir_array_update_string(&descriptor, SL("password"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
}
}
ZEPHIR_CALL_PARENT(&status, phalcon_db_adapter_pdo_postgresql_ce, this_ptr, "connect", &_5, 149, descriptor);
zephir_check_call_status();
if (!(ZEPHIR_IS_EMPTY(schema))) {
ZEPHIR_INIT_VAR(sql);
ZEPHIR_CONCAT_SVS(sql, "SET search_path TO '", schema, "'");
ZEPHIR_CALL_METHOD(NULL, this_ptr, "execute", NULL, 0, sql);
zephir_check_call_status();
}
RETURN_CCTOR(status);
}
/**
* Validator for constructor
*/
PHP_METHOD(Phalcon_Translate_Adapter_Gettext, prepareOptions) {
int ZEPHIR_LAST_CALL_STATUS;
zval *options_param = NULL, *_0, *_1 = NULL, *_2, *_3, *_4, *_5, *_6;
zval *options = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &options_param);
options = options_param;
if (!(zephir_array_isset_string(options, SS("locale")))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_translate_exception_ce, "Parameter \"locale\" is required", "phalcon/translate/adapter/gettext.zep", 227);
return;
}
if (!(zephir_array_isset_string(options, SS("directory")))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_translate_exception_ce, "Parameter \"directory\" is required", "phalcon/translate/adapter/gettext.zep", 231);
return;
}
ZEPHIR_INIT_VAR(_0);
ZEPHIR_CALL_METHOD(&_1, this_ptr, "getoptionsdefault", NULL, 0);
zephir_check_call_status();
zephir_fast_array_merge(_0, &(_1), &(options) TSRMLS_CC);
ZEPHIR_CPY_WRT(options, _0);
zephir_array_fetch_string(&_2, options, SL("category"), PH_NOISY | PH_READONLY, "phalcon/translate/adapter/gettext.zep", 236 TSRMLS_CC);
zephir_array_fetch_string(&_3, options, SL("locale"), PH_NOISY | PH_READONLY, "phalcon/translate/adapter/gettext.zep", 236 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "setlocale", NULL, 0, _2, _3);
zephir_check_call_status();
zephir_array_fetch_string(&_4, options, SL("defaultDomain"), PH_NOISY | PH_READONLY, "phalcon/translate/adapter/gettext.zep", 237 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "setdefaultdomain", NULL, 0, _4);
zephir_check_call_status();
zephir_array_fetch_string(&_5, options, SL("directory"), PH_NOISY | PH_READONLY, "phalcon/translate/adapter/gettext.zep", 238 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "setdirectory", NULL, 0, _5);
zephir_check_call_status();
zephir_array_fetch_string(&_6, options, SL("defaultDomain"), PH_NOISY | PH_READONLY, "phalcon/translate/adapter/gettext.zep", 239 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "setdomain", NULL, 0, _6);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_IssetTest, testIssetArray5) {
zval *a;
zephir_fetch_params(0, 1, 0, &a);
RETURN_BOOL(zephir_array_isset_string(a, SS("a")));
}
/**
* Phalcon\Cache\Backend\Mongo constructor
*/
PHP_METHOD(Phalcon_Cache_Backend_Mongo, __construct) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_0 = NULL;
zval options;
zval *frontend, frontend_sub, *options_param = NULL;
zval *this_ptr = getThis();
ZVAL_UNDEF(&frontend_sub);
ZVAL_UNDEF(&options);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &frontend, &options_param);
if (!options_param) {
ZEPHIR_INIT_VAR(&options);
array_init(&options);
} else {
zephir_get_arrval(&options, options_param);
}
if (!(zephir_array_isset_string(&options, SL("mongo")))) {
if (!(zephir_array_isset_string(&options, SL("server")))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "The parameter 'server' is required", "phalcon/cache/backend/mongo.zep", 65);
return;
}
}
if (!(zephir_array_isset_string(&options, SL("db")))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "The parameter 'db' is required", "phalcon/cache/backend/mongo.zep", 70);
return;
}
if (!(zephir_array_isset_string(&options, SL("collection")))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "The parameter 'collection' is required", "phalcon/cache/backend/mongo.zep", 74);
return;
}
ZEPHIR_CALL_PARENT(NULL, phalcon_cache_backend_mongo_ce, getThis(), "__construct", &_0, 0, frontend, &options);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Check whether the relation act as a foreign key
*/
PHP_METHOD(Phalcon_Mvc_Model_Relation, isForeignKey) {
zval _0;
zval *this_ptr = getThis();
ZVAL_UNDEF(&_0);
zephir_read_property(&_0, this_ptr, SL("_options"), PH_NOISY_CC | PH_READONLY);
RETURN_BOOL(zephir_array_isset_string(&_0, SL("foreignKey")));
}
/**
* This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
* Call it when you need to restore a database connection.
*
* @param array $descriptor
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, connect) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_nts_static zephir_fcall_cache_entry *_3 = NULL;
zend_bool _1;
zval *descriptor = NULL, *schema = NULL, *sql, *_0, *_2;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &descriptor);
if (!descriptor) {
ZEPHIR_CPY_WRT(descriptor, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(descriptor);
}
if (Z_TYPE_P(descriptor) == IS_NULL) {
ZEPHIR_OBS_NVAR(descriptor);
zephir_read_property_this(&descriptor, this_ptr, SL("_descriptor"), PH_NOISY_CC);
}
ZEPHIR_OBS_VAR(schema);
if (zephir_array_isset_string_fetch(&schema, descriptor, SS("schema"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&descriptor, SS("schema"), PH_SEPARATE);
} else {
ZEPHIR_INIT_NVAR(schema);
ZVAL_STRING(schema, "", 1);
}
if (zephir_array_isset_string(descriptor, SS("password"))) {
ZEPHIR_OBS_VAR(_0);
zephir_array_fetch_string(&_0, descriptor, SL("password"), PH_NOISY, "phalcon/db/adapter/pdo/postgresql.zep", 74 TSRMLS_CC);
_1 = Z_TYPE_P(_0) == IS_STRING;
if (_1) {
zephir_array_fetch_string(&_2, descriptor, SL("password"), PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/postgresql.zep", 74 TSRMLS_CC);
_1 = zephir_fast_strlen_ev(_2) == 0;
}
if (_1) {
zephir_array_update_string(&descriptor, SL("password"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
}
}
ZEPHIR_CALL_PARENT(NULL, phalcon_db_adapter_pdo_postgresql_ce, this_ptr, "connect", &_3, descriptor);
zephir_check_call_status();
if (!(ZEPHIR_IS_EMPTY(schema))) {
ZEPHIR_INIT_VAR(sql);
ZEPHIR_CONCAT_SVS(sql, "SET search_path TO '", schema, "'");
ZEPHIR_CALL_METHOD(NULL, this_ptr, "execute", NULL, sql);
zephir_check_call_status();
}
ZEPHIR_MM_RESTORE();
}
/**
* Instantiates route based on passed Yaf_Config_Abstract structure
*
* @param array $config Configuration object
*/
PHP_METHOD(Yaf_Route_Rewrite, getInstance) {
int ZEPHIR_LAST_CALL_STATUS;
zend_bool _0, _2;
zval *config_param = NULL, *_1, *_3, *_4, *_5;
zval *config = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &config_param);
zephir_get_arrval(config, config_param);
_0 = !(zephir_array_isset_string(config, SS("match")));
if (!(_0)) {
zephir_array_fetch_string(&_1, config, SL("match"), PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 21 TSRMLS_CC);
_0 = !(Z_TYPE_P(_1) == IS_STRING);
}
_2 = !(zephir_array_isset_string(config, SS("route")));
if (!(_2)) {
ZEPHIR_OBS_VAR(_3);
zephir_array_fetch_string(&_3, config, SL("route"), PH_NOISY, "yaf/Route/rewrite.zep", 23 TSRMLS_CC);
_2 = ZEPHIR_IS_EMPTY(_3);
}
if (_0) {
RETURN_MM_NULL();
} else if (_2) {
RETURN_MM_NULL();
} else {
object_init_ex(return_value, yaf_route_rewrite_ce);
zephir_array_fetch_string(&_4, config, SL("match"), PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 26 TSRMLS_CC);
zephir_array_fetch_string(&_5, config, SL("route"), PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 26 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, _4, _5);
zephir_check_call_status();
RETURN_MM();
}
}
/**
* Check whether the relation act as a foreign key
*/
PHP_METHOD(Phalcon_Mvc_Model_Relation, isForeignKey) {
zval *options;
options = zephir_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY_CC);
if (Z_TYPE_P(options) == IS_ARRAY) {
if (zephir_array_isset_string(options, SS("foreignKey"))) {
RETURN_BOOL(1);
}
}
RETURN_BOOL(0);
}
PHP_METHOD(Test_IssetTest, testIssetDynamicProperty1) {
zval *g;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(g);
zephir_read_property(&g, this_ptr, SL("s"), PH_NOISY_CC);
if (zephir_array_isset_string(g, SS("a"))) {
RETURN_MM_BOOL(1);
}
RETURN_MM_BOOL(0);
}
PHP_METHOD(OAuth2_ResponseType_AuthorizationCode, getAuthorizeResponse) {
int ZEPHIR_LAST_CALL_STATUS;
zval *_1;
zval *user_id = NULL;
zval *params = NULL, *user_id_param = NULL, *result, *_0 = NULL, *_2 = NULL, *_3, *_4, *_5, *_6, *_7;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, ¶ms, &user_id_param);
ZEPHIR_SEPARATE_PARAM(params);
if (!user_id_param) {
ZEPHIR_INIT_VAR(user_id);
ZVAL_EMPTY_STRING(user_id);
} else {
zephir_get_strval(user_id, user_id_param);
}
ZEPHIR_INIT_VAR(result);
array_init_size(result, 2);
ZEPHIR_INIT_VAR(_0);
array_init(_0);
zephir_array_update_string(&result, SL("query"), &_0, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_0);
ZEPHIR_INIT_VAR(_1);
array_init_size(_1, 3);
zephir_array_update_string(&_1, SL("scope"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_1, SL("state"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
zephir_fast_array_merge(_0, &(_1), &(params) TSRMLS_CC);
ZEPHIR_CPY_WRT(params, _0);
zephir_array_fetch_string(&_3, params, SL("client_id"), PH_NOISY | PH_READONLY, "oauth2/responsetype/authorizationcode.zep", 37 TSRMLS_CC);
zephir_array_fetch_string(&_4, params, SL("redirect_uri"), PH_NOISY | PH_READONLY, "oauth2/responsetype/authorizationcode.zep", 37 TSRMLS_CC);
zephir_array_fetch_string(&_5, params, SL("scope"), PH_NOISY | PH_READONLY, "oauth2/responsetype/authorizationcode.zep", 37 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_2, this_ptr, "createauthorizationcode", NULL, _3, user_id, _4, _5);
zephir_check_call_status();
zephir_array_update_multi(&result, &_2 TSRMLS_CC, SL("ss"), 4, SL("query"), SL("code"));
if (zephir_array_isset_string(params, SS("state"))) {
zephir_array_fetch_string(&_6, params, SL("state"), PH_NOISY | PH_READONLY, "oauth2/responsetype/authorizationcode.zep", 40 TSRMLS_CC);
zephir_array_update_multi(&result, &_6 TSRMLS_CC, SL("ss"), 4, SL("query"), SL("state"));
}
array_init_size(return_value, 3);
ZEPHIR_OBS_VAR(_7);
zephir_array_fetch_string(&_7, params, SL("redirect_uri"), PH_NOISY, "oauth2/responsetype/authorizationcode.zep", 43 TSRMLS_CC);
zephir_array_fast_append(return_value, _7);
zephir_array_fast_append(return_value, result);
RETURN_MM();
}
/**
* Phalcon\Cache\Backend\File constructor
*
* @param Phalcon\Cache\FrontendInterface frontend
* @param array options
*/
PHP_METHOD(Phalcon_Cache_Backend_File, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_nts_static zephir_fcall_cache_entry *_4 = NULL, *_5 = NULL;
zend_bool _1;
zval *frontend, *options = NULL, *prefix, *safekey, *_0, *_2, *_3 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &frontend, &options);
if (!options) {
options = ZEPHIR_GLOBAL(global_null);
}
if (!(zephir_array_isset_string(options, SS("cacheDir")))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cache directory must be specified with the option cacheDir", "phalcon/cache/backend/file.zep", 78);
return;
}
ZEPHIR_OBS_VAR(safekey);
if (zephir_array_isset_string_fetch(&safekey, options, SS("safekey"), 0 TSRMLS_CC)) {
if (Z_TYPE_P(safekey) != IS_BOOL) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "safekey option should be a boolean.", "phalcon/cache/backend/file.zep", 83);
return;
}
zephir_update_property_this(this_ptr, SL("_useSafeKey"), safekey TSRMLS_CC);
}
ZEPHIR_OBS_VAR(prefix);
if (zephir_array_isset_string_fetch(&prefix, options, SS("prefix"), 0 TSRMLS_CC)) {
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_useSafeKey"), PH_NOISY_CC);
_1 = zephir_is_true(_0);
if (_1) {
ZEPHIR_INIT_VAR(_2);
ZVAL_STRING(_2, "/[^a-zA-Z0-9_.-]+/", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_FUNCTION(&_3, "preg_match", &_4, _2, prefix);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
_1 = zephir_is_true(_3);
}
if (_1) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "FileCache prefix should only use alphanumeric characters.", "phalcon/cache/backend/file.zep", 92);
return;
}
}
ZEPHIR_CALL_PARENT(NULL, phalcon_cache_backend_file_ce, this_ptr, "__construct", &_5, frontend, options);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Phalcon\Cache\Backend\File constructor
*/
PHP_METHOD(Phalcon_Cache_Backend_File, __construct) {
zend_bool _1$$6;
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_5 = NULL;
zval *options = NULL;
zval *frontend, *options_param = NULL, *prefix = NULL, *safekey = NULL, *_0$$6, *_2$$6, *_3$$6, _4$$6;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &frontend, &options_param);
zephir_get_arrval(options, options_param);
if (!(zephir_array_isset_string(options, SS("cacheDir")))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cache directory must be specified with the option cacheDir", "phalcon/cache/backend/file.zep", 79);
return;
}
ZEPHIR_OBS_VAR(safekey);
if (zephir_array_isset_string_fetch(&safekey, options, SS("safekey"), 0 TSRMLS_CC)) {
if (Z_TYPE_P(safekey) != IS_BOOL) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "safekey option should be a boolean.", "phalcon/cache/backend/file.zep", 84);
return;
}
zephir_update_property_this(this_ptr, SL("_useSafeKey"), safekey TSRMLS_CC);
}
ZEPHIR_OBS_VAR(prefix);
if (zephir_array_isset_string_fetch(&prefix, options, SS("prefix"), 0 TSRMLS_CC)) {
_0$$6 = zephir_fetch_nproperty_this(this_ptr, SL("_useSafeKey"), PH_NOISY_CC);
_1$$6 = zephir_is_true(_0$$6);
if (_1$$6) {
ZEPHIR_INIT_VAR(_2$$6);
ZEPHIR_INIT_VAR(_3$$6);
ZEPHIR_SINIT_VAR(_4$$6);
ZVAL_STRING(&_4$$6, "/[^a-zA-Z0-9_.-]+/", 0);
zephir_preg_match(_3$$6, &_4$$6, prefix, _2$$6, 0, 0 , 0 TSRMLS_CC);
_1$$6 = zephir_is_true(_3$$6);
}
if (_1$$6) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "FileCache prefix should only use alphanumeric characters.", "phalcon/cache/backend/file.zep", 93);
return;
}
}
ZEPHIR_CALL_PARENT(NULL, phalcon_cache_backend_file_ce, this_ptr, "__construct", &_5, 113, frontend, options);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* getUserAgent Get user agent
*
* @return string
*/
PHP_METHOD(Phady_Util_Tools, getUserAgent) {
zval *_0, *_SERVER;
ZEPHIR_MM_GROW();
zephir_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC);
ZEPHIR_INIT_VAR(_0);
if (zephir_array_isset_string(_SERVER, SS("HTTP_USER_AGENT"))) {
zephir_array_fetch_string(&_0, _SERVER, SL("HTTP_USER_AGENT"), PH_NOISY, "phady/util/tools.zep", 181 TSRMLS_CC);
} else {
ZVAL_STRING(_0, "Desconocido", 1);
}
RETURN_CCTOR(_0);
}