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