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);
}
/**
* Executes a prepared statement binding. This function uses integer indexes starting from zero
*
* <code>
* $statement = $db->prepare('SELECT * FROM robots WHERE name = :name');
* $result = $connection->executePrepared($statement, array('name' => 'Voltron'));
* </code>
*
* @param \PDOStatement statement
* @param array bindParams
* @param array bindTypes
* @return \PDOStatement
*/
PHP_METHOD(Pdm_Db_Adapter_AbstractPdo, executePrepared) {
int ZEPHIR_LAST_CALL_STATUS;
zval *statement, *bindParams = NULL, *bindTypes = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &statement, &bindParams, &bindTypes);
if (!bindParams) {
ZEPHIR_INIT_VAR(bindParams);
array_init(bindParams);
} else {
ZEPHIR_SEPARATE_PARAM(bindParams);
}
if (!bindTypes) {
ZEPHIR_INIT_VAR(bindTypes);
array_init(bindTypes);
}
if (!(zephir_instance_of_ev(statement, zephir_get_internal_ce(SS("pdostatement") TSRMLS_CC) TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'statement' must be an instance of 'PDOStatement'", "", 0);
return;
}
if (Z_TYPE_P(bindParams) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(bindParams);
array_init(bindParams);
}
ZEPHIR_CALL_METHOD(NULL, statement, "execute", NULL, bindParams);
zephir_check_call_status();
RETURN_CCTOR(statement);
}
PHP_METHOD(Test_Flow, testWhile11) {
double c = 0;
int b = 0;
zval *a, a_sub, *d, d_sub;
ZEPHIR_INIT_THIS();
ZVAL_UNDEF(&a_sub);
ZVAL_UNDEF(&d_sub);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &a, &d);
ZEPHIR_SEPARATE_PARAM(a);
b = 0;
while (1) {
if (!(zephir_is_true(a))) {
break;
}
b = zephir_get_numberval(d);
while (1) {
if (!(b)) {
break;
}
b--;
}
ZEPHIR_SEPARATE(a);
zephir_decrement(a);
}
c = (double) ((zephir_get_numberval(a) + b));
RETURN_MM_DOUBLE(c);
}
/**
* Set an action parameter
*
* A $value of null will unset the $key if it exists
*
* @param string $key
* @param mixed $value
* @return Yaf_Request_Abstract
*/
PHP_METHOD(Yaf_Request_Abstract, setParam) {
zval *_2 = NULL;
zval *name = NULL, *value = NULL, *_0, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &name, &value);
ZEPHIR_SEPARATE_PARAM(name);
if (!value) {
value = ZEPHIR_GLOBAL(global_null);
}
if (Z_TYPE_P(name) == IS_ARRAY) {
_0 = zephir_fetch_nproperty_this(this_ptr, SL("params"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_1);
zephir_add_function_ex(_1, _0, name TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("params"), _1 TSRMLS_CC);
} else {
zephir_get_strval(_2, name);
ZEPHIR_CPY_WRT(name, _2);
zephir_update_property_array(this_ptr, SL("params"), name, value TSRMLS_CC);
}
RETURN_THIS();
}
/**
* Get an action parameter
*
* @param string $key
* @param mixed $default Default value to use if key not found
* @return mixed
*/
PHP_METHOD(Yaf_Request_Abstract, getParam) {
zval *_0 = NULL;
zval *name = NULL, *tmpDefault = NULL, *_1, *_2, *_3;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &name, &tmpDefault);
ZEPHIR_SEPARATE_PARAM(name);
if (!tmpDefault) {
tmpDefault = ZEPHIR_GLOBAL(global_null);
}
zephir_get_strval(_0, name);
ZEPHIR_CPY_WRT(name, _0);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("params"), PH_NOISY_CC);
if (zephir_array_isset(_1, name)) {
_2 = zephir_fetch_nproperty_this(this_ptr, SL("params"), PH_NOISY_CC);
zephir_array_fetch(&_3, _2, name, PH_NOISY | PH_READONLY, "yaf/request_abstract.zep", 196 TSRMLS_CC);
RETURN_CTOR(_3);
}
RETVAL_ZVAL(tmpDefault, 1, 0);
RETURN_MM();
}
/**
* Gets an attribute from the configuration, if the attribute isn't defined returns null
* If the value is exactly null or is not defined the default value will be used instead
*
*<code>
* echo $config->get('controllersDir', '../app/controllers/');
*</code>
*/
PHP_METHOD(Phalcon_Config, get) {
int ZEPHIR_LAST_CALL_STATUS;
zval *index = NULL, *defaultValue = NULL, *_0 = NULL, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &index, &defaultValue);
ZEPHIR_SEPARATE_PARAM(index);
if (!defaultValue) {
defaultValue = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_CALL_FUNCTION(&_0, "strval", NULL, 20, index);
zephir_check_call_status();
ZEPHIR_CPY_WRT(index, _0);
if (zephir_isset_property_zval(this_ptr, index TSRMLS_CC)) {
ZEPHIR_OBS_VAR(_1);
zephir_read_property_zval(&_1, this_ptr, index, PH_NOISY_CC);
RETURN_CCTOR(_1);
}
RETVAL_ZVAL(defaultValue, 1, 0);
RETURN_MM();
}
PHP_METHOD(Test_Flow, testWhile10) {
double c = 0;
zend_long b = 0;
zval *a, a_sub;
zval *this_ptr = getThis();
ZVAL_UNDEF(&a_sub);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &a);
ZEPHIR_SEPARATE_PARAM(a);
b = 0;
while (1) {
if (!(zephir_is_true(a))) {
break;
}
b = 5;
while (1) {
if (!(b)) {
break;
}
b--;
}
ZEPHIR_SEPARATE(a);
zephir_decrement(a);
}
c = (double) ((zephir_get_numberval(a) + b));
RETURN_MM_DOUBLE(c);
}
/**
* Applies a format to a message before sent it to the internal log
*
* @param string message
* @param int type
* @param int timestamp
* @param array context
* @return array
*/
PHP_METHOD(Phalcon_Logger_Formatter_Syslog, format) {
int type, timestamp, ZEPHIR_LAST_CALL_STATUS;
zval *message = NULL, *type_param = NULL, *timestamp_param = NULL, *context = NULL, *_0$$3 = NULL, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 1, &message, &type_param, ×tamp_param, &context);
ZEPHIR_SEPARATE_PARAM(message);
type = zephir_get_intval(type_param);
timestamp = zephir_get_intval(timestamp_param);
if (!context) {
context = ZEPHIR_GLOBAL(global_null);
}
if (Z_TYPE_P(context) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&_0$$3, this_ptr, "interpolate", NULL, 0, message, context);
zephir_check_call_status();
ZEPHIR_CPY_WRT(message, _0$$3);
}
zephir_create_array(return_value, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_1);
ZVAL_LONG(_1, type);
zephir_array_fast_append(return_value, _1);
zephir_array_fast_append(return_value, message);
RETURN_MM();
}
/**
* 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();
}
/**
* Sets an attribute using the array-syntax
*
*<code>
* $config['database'] = array('type' => 'Sqlite');
*</code>
*/
PHP_METHOD(Phalcon_Config, offsetSet) {
int ZEPHIR_LAST_CALL_STATUS;
zval *index = NULL, *value, *_0 = NULL, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &index, &value);
ZEPHIR_SEPARATE_PARAM(index);
ZEPHIR_CALL_FUNCTION(&_0, "strval", NULL, 20, index);
zephir_check_call_status();
ZEPHIR_CPY_WRT(index, _0);
if (Z_TYPE_P(value) == IS_ARRAY) {
ZEPHIR_INIT_VAR(_1);
object_init_ex(_1, phalcon_config_ce);
ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 21, value);
zephir_check_call_status();
zephir_update_property_zval_zval(this_ptr, index, _1 TSRMLS_CC);
} else {
zephir_update_property_zval_zval(this_ptr, index, value TSRMLS_CC);
}
ZEPHIR_MM_RESTORE();
}
/**
* Parses a raw doc block returning the annotations found
*/
PHP_METHOD(Phalcon_Annotations_Reader, parseDocBlock) {
int ZEPHIR_LAST_CALL_STATUS;
zval *docBlock_param = NULL, *file = NULL, *line = NULL;
zval *docBlock = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &docBlock_param, &file, &line);
zephir_get_strval(docBlock, docBlock_param);
if (!file) {
ZEPHIR_CPY_WRT(file, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(file);
}
if (!line) {
line = ZEPHIR_GLOBAL(global_null);
}
if (Z_TYPE_P(file) != IS_STRING) {
ZEPHIR_INIT_NVAR(file);
ZVAL_STRING(file, "eval code", 1);
}
ZEPHIR_LAST_CALL_STATUS = phannot_parse_annotations(return_value, docBlock, file, line TSRMLS_CC);
zephir_check_call_status();
RETURN_MM();
}
PHP_METHOD(Test_Flow, testWhile11) {
double c;
zval *a, *d, *b = NULL, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &a, &d);
ZEPHIR_SEPARATE_PARAM(a);
while (1) {
if (!(zephir_is_true(a))) {
break;
}
ZEPHIR_CPY_WRT(b, d);
while (1) {
if (!(zephir_is_true(b))) {
break;
}
ZEPHIR_SEPARATE(b);
zephir_decrement(b);
}
ZEPHIR_SEPARATE(a);
zephir_decrement(a);
}
ZEPHIR_INIT_VAR(_0);
zephir_add_function(_0, a, b TSRMLS_CC);
c = zephir_get_numberval(_0);
RETURN_MM_DOUBLE(c);
}
/**
* Adds a number to a string or increment that number if it already is defined
*
* <code>
* echo Phalcon\Text::increment("a"); // "a_1"
* echo Phalcon\Text::increment("a_1"); // "a_2"
* </code>
*/
PHP_METHOD(Phalcon_Text, increment) {
zval *str_param = NULL, *separator = NULL, *parts, *number = NULL, *_0;
zval *str = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &str_param, &separator);
zephir_get_strval(str, str_param);
if (!separator) {
ZEPHIR_CPY_WRT(separator, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(separator);
}
if (Z_TYPE_P(separator) == IS_NULL) {
ZEPHIR_INIT_NVAR(separator);
ZVAL_STRING(separator, "_", 1);
}
ZEPHIR_INIT_VAR(parts);
zephir_fast_explode(parts, separator, str, LONG_MAX TSRMLS_CC);
ZEPHIR_OBS_VAR(number);
if (zephir_array_isset_long_fetch(&number, parts, 1, 0 TSRMLS_CC)) {
ZEPHIR_SEPARATE(number);
zephir_increment(number);
} else {
ZEPHIR_INIT_NVAR(number);
ZVAL_LONG(number, 1);
}
zephir_array_fetch_long(&_0, parts, 0, PH_NOISY | PH_READONLY, "phalcon/text.zep", 88 TSRMLS_CC);
ZEPHIR_CONCAT_VVV(return_value, _0, separator, number);
RETURN_MM();
}
/**
* 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_Sqlite, connect) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_0 = NULL;
zval *descriptor = NULL, *dbname;
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(dbname);
if (!(zephir_array_isset_string_fetch(&dbname, descriptor, SS("dbname"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "dbname must be specified", "phalcon/db/adapter/pdo/sqlite.zep", 70);
return;
}
zephir_array_update_string(&descriptor, SL("dsn"), &dbname, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_PARENT(NULL, phalcon_db_adapter_pdo_sqlite_ce, this_ptr, "connect", &_0, 141, descriptor);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_Flow, testWhile10) {
double c;
int b;
zval *a;
zephir_fetch_params(0, 1, 0, &a);
ZEPHIR_SEPARATE_PARAM(a);
while (1) {
if (!(zephir_is_true(a))) {
break;
}
b = 5;
while (1) {
if (!(b)) {
break;
}
b--;
}
ZEPHIR_SEPARATE(a);
zephir_decrement(a);
}
c = (double) ((zephir_get_numberval(a) + b));
RETURN_DOUBLE(c);
}
/**
* Phalcon\Mvc\Model\Transaction\Manager constructor
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, __construct) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_0 = NULL;
zval *dependencyInjector = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &dependencyInjector);
if (!dependencyInjector) {
ZEPHIR_CPY_WRT(dependencyInjector, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(dependencyInjector);
}
if (!(zephir_is_true(dependencyInjector))) {
ZEPHIR_CALL_CE_STATIC(&dependencyInjector, phalcon_di_ce, "getdefault", &_0, 1);
zephir_check_call_status();
}
zephir_update_property_this(getThis(), SL("_dependencyInjector"), dependencyInjector TSRMLS_CC);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_transaction_exception_ce, "A dependency injector container is required to obtain the services related to the ORM", "phalcon/mvc/model/transaction/manager.zep", 102);
return;
}
ZEPHIR_MM_RESTORE();
}
/**
* Phalcon\Flash constructor
*/
PHP_METHOD(Phalcon_Flash, __construct) {
zval *cssClasses = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &cssClasses);
if (!cssClasses) {
ZEPHIR_CPY_WRT(cssClasses, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(cssClasses);
}
if (Z_TYPE_P(cssClasses) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(cssClasses);
zephir_create_array(cssClasses, 4, 0 TSRMLS_CC);
add_assoc_stringl_ex(cssClasses, SS("error"), SL("errorMessage"), 1);
add_assoc_stringl_ex(cssClasses, SS("notice"), SL("noticeMessage"), 1);
add_assoc_stringl_ex(cssClasses, SS("success"), SL("successMessage"), 1);
add_assoc_stringl_ex(cssClasses, SS("warning"), SL("warningMessage"), 1);
}
zephir_update_property_this(this_ptr, SL("_cssClasses"), cssClasses TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Returns the constants for a given class or the current class.
*
* @param string classname [Optional]
* @return array
*/
PHP_METHOD(Xpl_Enum, getConstants) {
int ZEPHIR_LAST_CALL_STATUS;
zval *classname = NULL, *reflection = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &classname);
if (!classname) {
ZEPHIR_CPY_WRT(classname, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(classname);
}
if (Z_TYPE_P(classname) == IS_NULL) {
ZEPHIR_INIT_NVAR(classname);
zephir_get_called_class(classname TSRMLS_CC);
}
ZEPHIR_INIT_VAR(reflection);
object_init_ex(reflection, zephir_get_internal_ce(SS("reflectionclass") TSRMLS_CC));
ZEPHIR_CALL_METHOD(NULL, reflection, "__construct", NULL, 63, classname);
zephir_check_call_status();
ZEPHIR_RETURN_CALL_METHOD(reflection, "getconstants", NULL, 100);
zephir_check_call_status();
RETURN_MM();
}
/**
* {@inheritdoc}
*
* @param string sessionId
* @return boolean
*/
PHP_METHOD(Phalcon_Session_Adapter_Memcache, destroy) {
int ZEPHIR_LAST_CALL_STATUS;
zval *sessionId = NULL, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &sessionId);
if (!sessionId) {
ZEPHIR_CPY_WRT(sessionId, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(sessionId);
}
if (Z_TYPE_P(sessionId) == IS_NULL) {
ZEPHIR_CALL_METHOD(&sessionId, this_ptr, "getid", NULL, 0);
zephir_check_call_status();
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_memcache"), PH_NOISY_CC);
ZEPHIR_RETURN_CALL_METHOD(_0, "delete", NULL, 0, sessionId);
zephir_check_call_status();
RETURN_MM();
}
/**
* 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();
}
/**
* Registers a set of PSR-0 directories for a given prefix,
* replacing any others previously set for this prefix.
*
* @param string $prefix The prefix
* @param array|string $paths The PSR-0 base directories
*/
PHP_METHOD(Xpl_ClassLoader, set) {
zval *prefix, *paths = NULL, _0$$4, _1$$4, *_2$$4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &prefix, &paths);
ZEPHIR_SEPARATE_PARAM(paths);
if (Z_TYPE_P(paths) == IS_STRING) {
ZEPHIR_INIT_NVAR(paths);
zephir_create_array(paths, 1, 0 TSRMLS_CC);
zephir_array_fast_append(paths, paths);
}
if (Z_TYPE_P(prefix) == IS_STRING) {
ZEPHIR_SINIT_VAR(_0$$4);
ZVAL_LONG(&_0$$4, 0);
ZEPHIR_SINIT_VAR(_1$$4);
ZVAL_LONG(&_1$$4, 1);
ZEPHIR_INIT_VAR(_2$$4);
zephir_substr(_2$$4, prefix, 0 , 1 , 0);
zephir_update_property_array_multi(this_ptr, SL("prefixesPsr0"), &paths TSRMLS_CC, SL("zz"), 2, _2$$4, prefix);
} else {
zephir_update_property_this(this_ptr, SL("fallbackDirsPsr0"), paths TSRMLS_CC);
}
ZEPHIR_MM_RESTORE();
}
/**
* Rollbacks the transaction
*
* @param string rollbackMessage
* @param Phalcon\Mvc\ModelInterface rollbackRecord
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction, rollback) {
zval *_1$$3, *_3$$3;
int ZEPHIR_LAST_CALL_STATUS;
zval *rollbackMessage = NULL, *rollbackRecord = NULL, *manager = NULL, *connection = NULL, *_4 = NULL, *_0$$3, *_2$$3, *_5$$4, *_6$$4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 2, &rollbackMessage, &rollbackRecord);
if (!rollbackMessage) {
ZEPHIR_CPY_WRT(rollbackMessage, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(rollbackMessage);
}
if (!rollbackRecord) {
rollbackRecord = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_OBS_VAR(manager);
zephir_read_property_this(&manager, this_ptr, SL("_manager"), PH_NOISY_CC);
if (Z_TYPE_P(manager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_0$$3);
ZEPHIR_INIT_VAR(_1$$3);
zephir_create_array(_1$$3, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_1$$3, manager);
ZEPHIR_INIT_VAR(_2$$3);
ZVAL_STRING(_2$$3, "notifyRollback", 1);
zephir_array_fast_append(_1$$3, _2$$3);
ZEPHIR_INIT_VAR(_3$$3);
zephir_create_array(_3$$3, 1, 0 TSRMLS_CC);
zephir_array_fast_append(_3$$3, this_ptr);
ZEPHIR_CALL_USER_FUNC_ARRAY(_0$$3, _1$$3, _3$$3);
zephir_check_call_status();
}
ZEPHIR_OBS_VAR(connection);
zephir_read_property_this(&connection, this_ptr, SL("_connection"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_4, connection, "rollback", NULL, 0);
zephir_check_call_status();
if (zephir_is_true(_4)) {
if (!(zephir_is_true(rollbackMessage))) {
ZEPHIR_INIT_NVAR(rollbackMessage);
ZVAL_STRING(rollbackMessage, "Transaction aborted", 1);
}
if (Z_TYPE_P(rollbackRecord) == IS_OBJECT) {
zephir_update_property_this(this_ptr, SL("_rollbackRecord"), rollbackRecord TSRMLS_CC);
}
ZEPHIR_INIT_VAR(_5$$4);
object_init_ex(_5$$4, phalcon_mvc_model_transaction_failed_ce);
_6$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_rollbackRecord"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, _5$$4, "__construct", NULL, 349, rollbackMessage, _6$$4);
zephir_check_call_status();
zephir_throw_exception_debug(_5$$4, "phalcon/mvc/model/transaction.zep", 160 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
RETURN_MM_BOOL(1);
}
PHP_METHOD(Test_Strings, issue1267) {
zval _1;
zephir_fcall_cache_entry *_5 = NULL;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *value = NULL, value_sub, x, _0, _2, _3, _4, _6, _7;
zval *this_ptr = getThis();
ZVAL_UNDEF(&value_sub);
ZVAL_UNDEF(&x);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_2);
ZVAL_UNDEF(&_3);
ZVAL_UNDEF(&_4);
ZVAL_UNDEF(&_6);
ZVAL_UNDEF(&_7);
ZVAL_UNDEF(&_1);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &value);
ZEPHIR_SEPARATE_PARAM(value);
ZEPHIR_INIT_VAR(&_0);
ZEPHIR_INIT_VAR(&_1);
zephir_create_array(&_1, 3, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(&_2);
ZVAL_STRING(&_2, "\\");
zephir_array_fast_append(&_1, &_2);
ZEPHIR_INIT_NVAR(&_2);
ZVAL_STRING(&_2, "\"");
zephir_array_fast_append(&_1, &_2);
ZEPHIR_INIT_NVAR(&_2);
ZVAL_STRING(&_2, "'");
zephir_array_fast_append(&_1, &_2);
ZEPHIR_INIT_NVAR(&_2);
ZVAL_STRING(&_2, "");
zephir_fast_str_replace(&_0, &_1, &_2, value TSRMLS_CC);
ZEPHIR_CPY_WRT(value, &_0);
ZVAL_LONG(&_3, 513);
ZEPHIR_CALL_FUNCTION(&_4, "filter_var", NULL, 79, value, &_3);
zephir_check_call_status();
ZEPHIR_CPY_WRT(value, &_4);
ZEPHIR_INIT_NVAR(&_0);
ZEPHIR_CALL_FUNCTION(&_4, "strip_tags", &_5, 80, value);
zephir_check_call_status();
zephir_stripslashes(&_0, &_4);
ZEPHIR_INIT_VAR(&x);
zephir_fast_trim(&x, &_0, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC);
ZEPHIR_INIT_VAR(&_6);
ZEPHIR_CALL_FUNCTION(&_7, "strip_tags", &_5, 80, value);
zephir_check_call_status();
zephir_stripcslashes(&_6, &_7);
zephir_fast_trim(return_value, &_6, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC);
RETURN_MM();
}
/**
* 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();
}
/**
* 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();
}
/**
* 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();
}
/**
* 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);
}
PHP_METHOD(BeeFramework_Input, xss_clean) {
zval *_3;
int ZEPHIR_LAST_CALL_STATUS;
zval *value = NULL, *_0 = NULL, *_1 = NULL, *_2 = NULL, _4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &value);
ZEPHIR_SEPARATE_PARAM(value);
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "/([\\x00-\\x08,\\x0b-\\x0c,\\x0e-\\x19])/", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_FUNCTION(&_2, "preg_replace", NULL, 6, _0, _1, value);
zephir_check_temp_parameter(_0);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
ZEPHIR_CPY_WRT(value, _2);
ZEPHIR_INIT_NVAR(_0);
ZEPHIR_INIT_VAR(_3);
zephir_create_array(_3, 8, 0 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "\"", 1);
zephir_array_fast_append(_3, _1);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "\\", 1);
zephir_array_fast_append(_3, _1);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "'", 1);
zephir_array_fast_append(_3, _1);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "/", 1);
zephir_array_fast_append(_3, _1);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "..", 1);
zephir_array_fast_append(_3, _1);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "../", 1);
zephir_array_fast_append(_3, _1);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "./", 1);
zephir_array_fast_append(_3, _1);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "//", 1);
zephir_array_fast_append(_3, _1);
ZEPHIR_SINIT_VAR(_4);
ZVAL_STRING(&_4, "", 0);
zephir_fast_str_replace(&_0, _3, &_4, value TSRMLS_CC);
ZEPHIR_CPY_WRT(value, _0);
RETVAL_ZVAL(value, 1, 0);
RETURN_MM();
}
/**
* 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();
}
/**
* Validates a value against the class constants.
*
* If value is a valid constant name, returns the corresponding value.
*
* If value is null and a default is set, returns the default value.
*
* @param mixed value
*
* @return mixed
*
* @throws \RuntimeException if value is null and no default exists, or if given an invalid value.
*/
PHP_METHOD(Xpl_Enum, filterValidateValue) {
int ZEPHIR_LAST_CALL_STATUS;
zval *value = NULL, *reflection = NULL, *constants = NULL, *_0, *_2 = NULL, *_1$$6;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &value);
if (!value) {
ZEPHIR_CPY_WRT(value, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(value);
}
ZEPHIR_INIT_VAR(reflection);
object_init_ex(reflection, zephir_get_internal_ce(SS("reflectionclass") TSRMLS_CC));
ZEPHIR_INIT_VAR(_0);
zephir_get_class(_0, this_ptr, 0 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, reflection, "__construct", NULL, 63, _0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&constants, reflection, "getconstants", NULL, 100);
zephir_check_call_status();
if (Z_TYPE_P(value) == IS_NULL) {
ZEPHIR_OBS_NVAR(value);
if (zephir_array_isset_string_fetch(&value, constants, SS("_default"), 0 TSRMLS_CC)) {
RETVAL_ZVAL(value, 1, 0);
RETURN_MM();
}
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_RuntimeException, "Missing value: no default exists", "xpl/enum.zep", 177);
return;
}
if (Z_TYPE_P(value) == IS_STRING) {
if (zephir_array_isset(constants, value)) {
zephir_array_fetch(&_1$$6, constants, value, PH_NOISY | PH_READONLY, "xpl/enum.zep", 183 TSRMLS_CC);
ZEPHIR_CPY_WRT(value, _1$$6);
}
if ((zephir_method_exists(this_ptr, value TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_METHOD_ZVAL(this_ptr, value, NULL, 0);
zephir_check_call_status();
RETURN_MM();
}
}
ZEPHIR_CALL_FUNCTION(&_2, "in_array", NULL, 2, value, constants, ZEPHIR_GLOBAL(global_true));
zephir_check_call_status();
if (!(zephir_is_true(_2))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_RuntimeException, "Invalid enum value", "xpl/enum.zep", 193);
return;
}
RETVAL_ZVAL(value, 1, 0);
RETURN_MM();
}
