/** * Sets a prefix for all routes added to the collection */ PHP_METHOD(Phalcon_Mvc_Micro_Collection, setPrefix) { zval *prefix_param = NULL; zval *prefix = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &prefix_param); if (UNEXPECTED(Z_TYPE_P(prefix_param) != IS_STRING && Z_TYPE_P(prefix_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'prefix' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (EXPECTED(Z_TYPE_P(prefix_param) == IS_STRING)) { zephir_get_strval(prefix, prefix_param); } else { ZEPHIR_INIT_VAR(prefix); ZVAL_EMPTY_STRING(prefix); } zephir_update_property_this(getThis(), SL("_prefix"), prefix TSRMLS_CC); RETURN_THIS(); }
/** * Sets a hostname restriction to the route * *<code> * $route->setHostname('localhost'); *</code> */ PHP_METHOD(Phalcon_Mvc_Router_Route, setHostname) { zval *hostname_param = NULL; zval *hostname = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &hostname_param); if (unlikely(Z_TYPE_P(hostname_param) != IS_STRING && Z_TYPE_P(hostname_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'hostname' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(hostname_param) == IS_STRING)) { zephir_get_strval(hostname, hostname_param); } else { ZEPHIR_INIT_VAR(hostname); ZVAL_EMPTY_STRING(hostname); } zephir_update_property_this(this_ptr, SL("_hostname"), hostname TSRMLS_CC); RETURN_THIS(); }
/** * Phalcon\Validation\Validator constructor */ PHP_METHOD(Phalcon_Validation_Validator, __construct) { zend_bool _0; zval *options = NULL; zephir_fetch_params(0, 0, 1, &options); if (!options) { options = ZEPHIR_GLOBAL(global_null); } _0 = Z_TYPE_P(options) != IS_ARRAY; if (_0) { _0 = Z_TYPE_P(options) != IS_NULL; } if (_0) { ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(phalcon_validation_exception_ce, "Options must be an array", "phalcon/validation/validator.zep", 39); return; } else { zephir_update_property_this(this_ptr, SL("_options"), options TSRMLS_CC); } }
/** * Externally sets the view content * *<code> * $this->view->setContent("<h1>hello</h1>"); *</code> */ PHP_METHOD(Phalcon_Mvc_View_Simple, setContent) { zval *content_param = NULL; zval *content = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &content_param); if (unlikely(Z_TYPE_P(content_param) != IS_STRING && Z_TYPE_P(content_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'content' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(content_param) == IS_STRING)) { zephir_get_strval(content, content_param); } else { ZEPHIR_INIT_VAR(content); ZVAL_EMPTY_STRING(content); } zephir_update_property_this(this_ptr, SL("_content"), content TSRMLS_CC); RETURN_THIS(); }
/** * Phalcon\Mvc\Micro\LazyLoader constructor */ PHP_METHOD(Phalcon_Mvc_Micro_LazyLoader, __construct) { zval *definition_param = NULL; zval *definition = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &definition_param); if (UNEXPECTED(Z_TYPE_P(definition_param) != IS_STRING && Z_TYPE_P(definition_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'definition' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (EXPECTED(Z_TYPE_P(definition_param) == IS_STRING)) { zephir_get_strval(definition, definition_param); } else { ZEPHIR_INIT_VAR(definition); ZVAL_EMPTY_STRING(definition); } zephir_update_property_this(this_ptr, SL("_definition"), definition TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * Sets the form's action */ PHP_METHOD(Phalcon_Forms_Form, setAction) { zval *action_param = NULL; zval *action = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &action_param); if (UNEXPECTED(Z_TYPE_P(action_param) != IS_STRING && Z_TYPE_P(action_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'action' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (EXPECTED(Z_TYPE_P(action_param) == IS_STRING)) { zephir_get_strval(action, action_param); } else { ZEPHIR_INIT_VAR(action); ZVAL_EMPTY_STRING(action); } zephir_update_property_this(this_ptr, SL("_action"), action TSRMLS_CC); RETURN_THIS(); }
/** * Sets a base path for all the generated paths * *<code> * $url->setBasePath("/var/www/htdocs/"); *</code> */ PHP_METHOD(Phalcon_Mvc_Url, setBasePath) { zval *basePath_param = NULL; zval *basePath = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &basePath_param); if (UNEXPECTED(Z_TYPE_P(basePath_param) != IS_STRING && Z_TYPE_P(basePath_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'basePath' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (EXPECTED(Z_TYPE_P(basePath_param) == IS_STRING)) { zephir_get_strval(basePath, basePath_param); } else { ZEPHIR_INIT_VAR(basePath); ZVAL_EMPTY_STRING(basePath); } zephir_update_property_this(getThis(), SL("_basePath"), basePath TSRMLS_CC); RETURN_THIS(); }
/** * Sets a target uri for the generated HTML */ PHP_METHOD(Phalcon_Assets_Collection, setTargetUri) { zval *targetUri_param = NULL; zval *targetUri = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &targetUri_param); if (unlikely(Z_TYPE_P(targetUri_param) != IS_STRING && Z_TYPE_P(targetUri_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'targetUri' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(targetUri_param) == IS_STRING)) { zephir_get_strval(targetUri, targetUri_param); } else { ZEPHIR_INIT_VAR(targetUri); ZVAL_EMPTY_STRING(targetUri); } zephir_update_property_this(this_ptr, SL("_targetUri"), targetUri TSRMLS_CC); RETURN_THIS(); }
/** * Sets a base source path for all the resources in this collection */ PHP_METHOD(Phalcon_Assets_Collection, setSourcePath) { zval *sourcePath_param = NULL; zval *sourcePath = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &sourcePath_param); if (unlikely(Z_TYPE_P(sourcePath_param) != IS_STRING && Z_TYPE_P(sourcePath_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'sourcePath' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(sourcePath_param) == IS_STRING)) { zephir_get_strval(sourcePath, sourcePath_param); } else { ZEPHIR_INIT_VAR(sourcePath); ZVAL_EMPTY_STRING(sourcePath); } zephir_update_property_this(this_ptr, SL("_sourcePath"), sourcePath TSRMLS_CC); RETURN_THIS(); }
/** * Sets views directory. Depending of your platform, always add a trailing slash or backslash */ PHP_METHOD(Phalcon_Mvc_View_Simple, setViewsDir) { zval *viewsDir_param = NULL; zval *viewsDir = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &viewsDir_param); if (UNEXPECTED(Z_TYPE_P(viewsDir_param) != IS_STRING && Z_TYPE_P(viewsDir_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'viewsDir' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (EXPECTED(Z_TYPE_P(viewsDir_param) == IS_STRING)) { zephir_get_strval(viewsDir, viewsDir_param); } else { ZEPHIR_INIT_VAR(viewsDir); ZVAL_EMPTY_STRING(viewsDir); } zephir_update_property_this(getThis(), SL("_viewsDir"), viewsDir TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * Registers a set of PSR-4 directories for a given namespace, * replacing any others previously set for this namespace. * * @param string $prefix The prefix/namespace, with trailing "\\" * @param array|string $paths The PSR-4 base directories * * @throws \InvalidArgumentException */ PHP_METHOD(Xpl_ClassLoader, setPsr4) { zval *prefix, *paths = NULL, *_0$$4, _1$$4, _2$$4, *_3$$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) { if (!(zephir_end_with_str(prefix, SL("\\")))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "A non-empty PSR-4 prefix must end with a namespace separator.", "xpl/classloader.zep", 366); return; } ZEPHIR_INIT_VAR(_0$$4); ZVAL_LONG(_0$$4, zephir_fast_strlen_ev(prefix)); ZEPHIR_SINIT_VAR(_1$$4); ZVAL_LONG(&_1$$4, 0); ZEPHIR_SINIT_VAR(_2$$4); ZVAL_LONG(&_2$$4, 1); ZEPHIR_INIT_VAR(_3$$4); zephir_substr(_3$$4, prefix, 0 , 1 , 0); zephir_update_property_array_multi(this_ptr, SL("prefixLengthsPsr4"), &_0$$4 TSRMLS_CC, SL("zz"), 2, _3$$4, prefix); zephir_update_property_array(this_ptr, SL("prefixDirsPsr4"), prefix, paths TSRMLS_CC); } else { zephir_update_property_this(this_ptr, SL("fallbackDirsPsr4"), paths TSRMLS_CC); } ZEPHIR_MM_RESTORE(); }
/** * Sets the default controller name */ PHP_METHOD(Phalcon_Mvc_Dispatcher, setDefaultController) { zval *controllerName_param = NULL; zval *controllerName = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &controllerName_param); if (UNEXPECTED(Z_TYPE_P(controllerName_param) != IS_STRING && Z_TYPE_P(controllerName_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'controllerName' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (EXPECTED(Z_TYPE_P(controllerName_param) == IS_STRING)) { zephir_get_strval(controllerName, controllerName_param); } else { ZEPHIR_INIT_VAR(controllerName); ZVAL_EMPTY_STRING(controllerName); } zephir_update_property_this(getThis(), SL("_defaultHandler"), controllerName TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * Sets the route's name * *<code> * $router->add( * "/about", * [ * "controller" => "about", * ] * )->setName("about"); *</code> */ PHP_METHOD(Phalcon_Cli_Router_Route, setName) { zval *name_param = NULL; zval *name = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &name_param); if (UNEXPECTED(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (EXPECTED(Z_TYPE_P(name_param) == IS_STRING)) { zephir_get_strval(name, name_param); } else { ZEPHIR_INIT_VAR(name); ZVAL_EMPTY_STRING(name); } zephir_update_property_this(this_ptr, SL("_name"), name TSRMLS_CC); RETURN_THIS(); }
/** * Sets verbose message */ PHP_METHOD(Phalcon_Mvc_Model_Message, setMessage) { zval *message_param = NULL; zval *message = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &message_param); if (UNEXPECTED(Z_TYPE_P(message_param) != IS_STRING && Z_TYPE_P(message_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'message' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (EXPECTED(Z_TYPE_P(message_param) == IS_STRING)) { zephir_get_strval(message, message_param); } else { ZEPHIR_INIT_VAR(message); ZVAL_EMPTY_STRING(message); } zephir_update_property_this(this_ptr, SL("_message"), message TSRMLS_CC); RETURN_THIS(); }
/** * Change the base URI for static resources */ PHP_METHOD(Phalcon_Debug, setUri) { zval *uri_param = NULL; zval *uri = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &uri_param); if (UNEXPECTED(Z_TYPE_P(uri_param) != IS_STRING && Z_TYPE_P(uri_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'uri' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (EXPECTED(Z_TYPE_P(uri_param) == IS_STRING)) { zephir_get_strval(uri, uri_param); } else { ZEPHIR_INIT_VAR(uri); ZVAL_EMPTY_STRING(uri); } zephir_update_property_this(this_ptr, SL("_uri"), uri TSRMLS_CC); RETURN_THIS(); }
/** * Sets the encryption key */ PHP_METHOD(Phalcon_Crypt, setKey) { zval *key_param = NULL; zval *key = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &key_param); if (unlikely(Z_TYPE_P(key_param) != IS_STRING && Z_TYPE_P(key_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'key' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(key_param) == IS_STRING)) { zephir_get_strval(key, key_param); } else { ZEPHIR_INIT_VAR(key); ZVAL_EMPTY_STRING(key); } zephir_update_property_this(this_ptr, SL("_key"), key TSRMLS_CC); RETURN_THIS(); }
/** * Phalcon\Session\Bag constructor */ PHP_METHOD(Phalcon_Session_Bag, __construct) { zval *name_param = NULL; zval *name = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &name_param); if (unlikely(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(name_param) == IS_STRING)) { zephir_get_strval(name, name_param); } else { ZEPHIR_INIT_VAR(name); ZVAL_EMPTY_STRING(name); } zephir_update_property_this(this_ptr, SL("_name"), name TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * Constructor * * @param string $message * @param string $usage */ PHP_METHOD(ZendFramework_Console_Exception_RuntimeException, __construct) { int ZEPHIR_LAST_CALL_STATUS; zval *message_param = NULL, *usage_param = NULL; zval *message = NULL, *usage = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &message_param, &usage_param); zephir_get_strval(message, message_param); if (!usage_param) { ZEPHIR_INIT_VAR(usage); ZVAL_STRING(usage, "", 1); } else { zephir_get_strval(usage, usage_param); } zephir_update_property_this(this_ptr, SL("usage"), usage TSRMLS_CC); ZEPHIR_CALL_PARENT(NULL, zendframework_console_exception_runtimeexception_ce, this_ptr, "__construct", NULL, message); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); }
/** * Sets the domain default to search within when calls are made to gettext() */ PHP_METHOD(Phalcon_Translate_Adapter_Gettext, setDefaultDomain) { zval *domain_param = NULL; zval *domain = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &domain_param); if (unlikely(Z_TYPE_P(domain_param) != IS_STRING && Z_TYPE_P(domain_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'domain' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(domain_param) == IS_STRING)) { zephir_get_strval(domain, domain_param); } else { ZEPHIR_INIT_VAR(domain); ZVAL_EMPTY_STRING(domain); } zephir_update_property_this(this_ptr, SL("_defaultDomain"), domain TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * Sets the path for a domain */ PHP_METHOD(Phalcon_Translate_Adapter_Gettext, setDirectory) { int ZEPHIR_LAST_CALL_STATUS; zephir_fcall_cache_entry *_3 = NULL; HashTable *_1; HashPosition _0; zval *directory, *key = NULL, *value = NULL, **_2, *_4 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &directory); zephir_update_property_this(this_ptr, SL("_directory"), directory TSRMLS_CC); if (Z_TYPE_P(directory) == IS_ARRAY) { if (zephir_fast_count_int(directory TSRMLS_CC)) { zephir_is_iterable(directory, &_1, &_0, 0, 0, "phalcon/translate/adapter/gettext.zep", 180); for ( ; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS ; zephir_hash_move_forward_ex(_1, &_0) ) { ZEPHIR_GET_HMKEY(key, _1, _0); ZEPHIR_GET_HVALUE(value, _2); ZEPHIR_CALL_FUNCTION(NULL, "bindtextdomain", &_3, 423, key, value); zephir_check_call_status(); } } } else { ZEPHIR_CALL_METHOD(&_4, this_ptr, "getdefaultdomain", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(NULL, "bindtextdomain", &_3, 423, _4, directory); zephir_check_call_status(); } ZEPHIR_MM_RESTORE(); }
/** * Sets message type */ PHP_METHOD(Phalcon_Mvc_Model_Message, setType) { zval *type_param = NULL; zval *type = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &type_param); if (unlikely(Z_TYPE_P(type_param) != IS_STRING && Z_TYPE_P(type_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'type' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(type_param) == IS_STRING)) { zephir_get_strval(type, type_param); } else { ZEPHIR_INIT_VAR(type); ZVAL_EMPTY_STRING(type); } zephir_update_property_this(this_ptr, SL("_type"), type TSRMLS_CC); RETURN_THIS(); }
/** * Sets field name related to message */ PHP_METHOD(Phalcon_Validation_Message, setField) { zval *field_param = NULL; zval *field = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &field_param); if (unlikely(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(field_param) == IS_STRING)) { zephir_get_strval(field, field_param); } else { ZEPHIR_INIT_VAR(field); ZVAL_EMPTY_STRING(field); } zephir_update_property_this(this_ptr, SL("_field"), field TSRMLS_CC); RETURN_THIS(); }
/** * Sets the cipher algorithm */ PHP_METHOD(Phalcon_Crypt, setCipher) { zval *cipher_param = NULL; zval *cipher = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &cipher_param); if (UNEXPECTED(Z_TYPE_P(cipher_param) != IS_STRING && Z_TYPE_P(cipher_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'cipher' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (EXPECTED(Z_TYPE_P(cipher_param) == IS_STRING)) { zephir_get_strval(cipher, cipher_param); } else { ZEPHIR_INIT_VAR(cipher); ZVAL_EMPTY_STRING(cipher); } zephir_update_property_this(getThis(), SL("_cipher"), cipher TSRMLS_CC); RETURN_THIS(); }
/** * Sets the loader's Composer path. * * @param string path Path to 'vendor' directory */ PHP_METHOD(Xpl_ClassLoader, setComposerPath) { zval *path_param = NULL; zval *path = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &path_param); if (unlikely(Z_TYPE_P(path_param) != IS_STRING && Z_TYPE_P(path_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'path' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(path_param) == IS_STRING)) { zephir_get_strval(path, path_param); } else { ZEPHIR_INIT_VAR(path); ZVAL_EMPTY_STRING(path); } zephir_update_property_this(this_ptr, SL("composerPath"), path TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * Returns a cached content * * @param string keyName * @param long lifetime * @return mixed */ PHP_METHOD(Phalcon_Cache_Backend_Memory, get) { int ZEPHIR_LAST_CALL_STATUS; zval *keyName, *lifetime = NULL, *lastKey = NULL, *cachedContent, *_0; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &keyName, &lifetime); if (!lifetime) { lifetime = ZEPHIR_GLOBAL(global_null); } if (Z_TYPE_P(keyName) == IS_NULL) { ZEPHIR_OBS_VAR(lastKey); zephir_read_property_this(&lastKey, this_ptr, SL("_lastKey"), PH_NOISY_CC); } else { _0 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC); ZEPHIR_INIT_NVAR(lastKey); ZEPHIR_CONCAT_VV(lastKey, _0, keyName); zephir_update_property_this(this_ptr, SL("_lastKey"), lastKey TSRMLS_CC); } ZEPHIR_OBS_VAR(cachedContent); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_data"), PH_NOISY_CC); if (!(zephir_array_isset_fetch(&cachedContent, _0, lastKey, 0 TSRMLS_CC))) { RETURN_MM_NULL(); } if (Z_TYPE_P(cachedContent) == IS_NULL) { RETURN_MM_NULL(); } _0 = zephir_fetch_nproperty_this(this_ptr, SL("_frontend"), PH_NOISY_CC); ZEPHIR_RETURN_CALL_METHOD(_0, "afterretrieve", NULL, cachedContent); zephir_check_call_status(); RETURN_MM(); }
PHP_METHOD(Lynx_DBAL_Driver_PgSQL, connect) { int ZEPHIR_LAST_CALL_STATUS; zval *_0 = NULL, *_1, *_2, *_3, *_4, *_5; ZEPHIR_MM_GROW(); ZEPHIR_CALL_METHOD(&_0, this_ptr, "isconnected", NULL); zephir_check_call_status(); if (zephir_is_true(_0)) { RETURN_MM_BOOL(0); } ZEPHIR_INIT_VAR(_1); object_init_ex(_1, lynx_dbal_driver_pdo_ce); _2 = zephir_fetch_nproperty_this(this_ptr, SL("dsn"), PH_NOISY_CC); _3 = zephir_fetch_nproperty_this(this_ptr, SL("username"), PH_NOISY_CC); _4 = zephir_fetch_nproperty_this(this_ptr, SL("password"), PH_NOISY_CC); _5 = zephir_fetch_nproperty_this(this_ptr, SL("driverOptions"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, _2, _3, _4, _5); zephir_check_call_status(); zephir_update_property_this(this_ptr, SL("connection"), _1 TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * Sets the database service used to run the isolated transactions */ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, setDbService) { zval *service_param = NULL; zval *service = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &service_param); if (unlikely(Z_TYPE_P(service_param) != IS_STRING && Z_TYPE_P(service_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'service' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(service_param) == IS_STRING)) { zephir_get_strval(service, service_param); } else { ZEPHIR_INIT_VAR(service); ZVAL_EMPTY_STRING(service); } zephir_update_property_this(this_ptr, SL("_service"), service TSRMLS_CC); RETURN_THIS(); }
/** * Changes the action method suffix */ PHP_METHOD(Phalcon_Mvc_Router_Annotations, setActionSuffix) { zval *actionSuffix_param = NULL; zval *actionSuffix = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &actionSuffix_param); if (UNEXPECTED(Z_TYPE_P(actionSuffix_param) != IS_STRING && Z_TYPE_P(actionSuffix_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'actionSuffix' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (EXPECTED(Z_TYPE_P(actionSuffix_param) == IS_STRING)) { zephir_get_strval(actionSuffix, actionSuffix_param); } else { ZEPHIR_INIT_VAR(actionSuffix); ZVAL_EMPTY_STRING(actionSuffix); } zephir_update_property_this(getThis(), SL("_actionSuffix"), actionSuffix TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * Cache the actual view render to certain level * *<code> * $this->view->cache( * [ * "key" => "my-key", * "lifetime" => 86400, * ] * ); *</code> */ PHP_METHOD(Phalcon_Mvc_View_Simple, cache) { zval *options = NULL; zephir_fetch_params(0, 0, 1, &options); if (!options) { options = ZEPHIR_GLOBAL(global_true); } if (Z_TYPE_P(options) == IS_ARRAY) { if (1) { zephir_update_property_this(getThis(), SL("_cache"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC); } else { zephir_update_property_this(getThis(), SL("_cache"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC); } zephir_update_property_this(getThis(), SL("_cacheOptions"), options TSRMLS_CC); } else { if (zephir_is_true(options)) { if (1) { zephir_update_property_this(getThis(), SL("_cache"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC); } else { zephir_update_property_this(getThis(), SL("_cache"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC); } } else { if (0) { zephir_update_property_this(getThis(), SL("_cache"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC); } else { zephir_update_property_this(getThis(), SL("_cache"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC); } } } RETURN_THISW(); }
/** * Stores cached content into the file backend and stops the frontend * * @param int|string keyName * @param string content * @param long lifetime * @param boolean stopBuffer */ PHP_METHOD(Phalcon_Cache_Backend_Redis, save) { int ZEPHIR_LAST_CALL_STATUS; zval *keyName = NULL, *content = NULL, *lifetime = NULL, *stopBuffer = NULL, *prefixedKey = NULL, *lastKey = NULL, *prefix, *frontend, *redis = NULL, *cachedContent = NULL, *preparedContent = NULL, *tmp, *tt1 = NULL, *success = NULL, *options, *specialKey, *isBuffering = NULL, _0; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 4, &keyName, &content, &lifetime, &stopBuffer); if (!keyName) { keyName = ZEPHIR_GLOBAL(global_null); } if (!content) { content = ZEPHIR_GLOBAL(global_null); } if (!lifetime) { lifetime = ZEPHIR_GLOBAL(global_null); } if (!stopBuffer) { stopBuffer = ZEPHIR_GLOBAL(global_true); } if (!(zephir_is_true(keyName))) { ZEPHIR_OBS_VAR(lastKey); zephir_read_property_this(&lastKey, this_ptr, SL("_lastKey"), PH_NOISY_CC); ZEPHIR_SINIT_VAR(_0); ZVAL_LONG(&_0, 5); ZEPHIR_INIT_VAR(prefixedKey); zephir_substr(prefixedKey, lastKey, 5 , 0, ZEPHIR_SUBSTR_NO_LENGTH); } else { ZEPHIR_OBS_VAR(prefix); zephir_read_property_this(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC); ZEPHIR_INIT_NVAR(prefixedKey); ZEPHIR_CONCAT_VV(prefixedKey, prefix, keyName); ZEPHIR_INIT_NVAR(lastKey); ZEPHIR_CONCAT_SV(lastKey, "_PHCR", prefixedKey); } if (!(zephir_is_true(lastKey))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cache must be started first", "phalcon/cache/backend/redis.zep", 185); return; } ZEPHIR_OBS_VAR(frontend); zephir_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); ZEPHIR_OBS_VAR(redis); zephir_read_property_this(&redis, this_ptr, SL("_redis"), PH_NOISY_CC); if (Z_TYPE_P(redis) != IS_OBJECT) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "_connect", NULL); zephir_check_call_status(); ZEPHIR_OBS_NVAR(redis); zephir_read_property_this(&redis, this_ptr, SL("_redis"), PH_NOISY_CC); } if (!(zephir_is_true(content))) { ZEPHIR_CALL_METHOD(&cachedContent, frontend, "getcontent", NULL); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(cachedContent, content); } if (!(zephir_is_numeric(cachedContent))) { ZEPHIR_CALL_METHOD(&preparedContent, frontend, "beforestore", NULL, cachedContent); zephir_check_call_status(); } if (!(zephir_is_true(lifetime))) { ZEPHIR_OBS_VAR(tmp); zephir_read_property_this(&tmp, this_ptr, SL("_lastLifetime"), PH_NOISY_CC); if (!(zephir_is_true(tmp))) { ZEPHIR_CALL_METHOD(&tt1, frontend, "getlifetime", NULL); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(tt1, tmp); } } else { ZEPHIR_CPY_WRT(tt1, lifetime); } if (zephir_is_numeric(cachedContent)) { ZEPHIR_CALL_METHOD(&success, redis, "set", NULL, lastKey, cachedContent); zephir_check_call_status(); } else { ZEPHIR_CALL_METHOD(&success, redis, "set", NULL, lastKey, preparedContent); zephir_check_call_status(); } if (!(zephir_is_true(success))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Failed storing data in redis", "phalcon/cache/backend/redis.zep", 231); return; } ZEPHIR_CALL_METHOD(NULL, redis, "settimeout", NULL, lastKey, tt1); zephir_check_call_status(); ZEPHIR_OBS_VAR(options); zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC); if (!(zephir_array_isset_string(options, SS("statsKey")))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/redis.zep", 239); return; } ZEPHIR_OBS_VAR(specialKey); zephir_array_fetch_string(&specialKey, options, SL("statsKey"), PH_NOISY, "phalcon/cache/backend/redis.zep", 242 TSRMLS_CC); ZEPHIR_CALL_METHOD(NULL, redis, "sadd", NULL, specialKey, prefixedKey); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&isBuffering, frontend, "isbuffering", NULL); zephir_check_call_status(); if (ZEPHIR_IS_TRUE_IDENTICAL(stopBuffer)) { ZEPHIR_CALL_METHOD(NULL, frontend, "stop", NULL); zephir_check_call_status(); } if (ZEPHIR_IS_TRUE_IDENTICAL(isBuffering)) { zend_print_zval(cachedContent, 0); } zephir_update_property_this(this_ptr, SL("_started"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC); ZEPHIR_MM_RESTORE(); }