/**
* Phalcon\Logger\Adapter\Stream constructor
*
* @param string $name
* @param array $options
*/
PHP_METHOD(Phalcon_Logger_Adapter_Stream, __construct){
zval *name, *options = NULL, mode = {}, stream = {};
phalcon_fetch_params(0, 1, 1, &name, &options);
PHALCON_ENSURE_IS_STRING(name);
if (!options) {
options = &PHALCON_GLOBAL(z_null);
}
if (phalcon_array_isset_fetch_str(&mode, options, SL("mode"))) {
if (phalcon_memnstr_str(&mode, SL("r"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_logger_exception_ce, "Stream must be opened in append or write mode");
return;
}
} else {
ZVAL_STRING(&mode, "ab");
}
/**
* We use 'fopen' to respect to open-basedir directive
*/
PHALCON_CALL_FUNCTIONW(&stream, "fopen", name, &mode);
if (Z_TYPE(stream) != IS_RESOURCE) {
zend_throw_exception_ex(phalcon_logger_exception_ce, 0, "Cannot open stream '%s'", Z_STRVAL_P(name));
} else {
phalcon_update_property_this(getThis(), SL("_stream"), &stream);
}
}
/**
* Changes a parameter in the definition without resolve the service
*
* @param long $position
* @param array $parameter
* @return Phalcon\DI\Service
*/
PHP_METHOD(Phalcon_DI_Service, setParameter){
zval *position, *parameter, definition = {}, arguments = {};
phalcon_fetch_params(0, 2, 0, &position, ¶meter);
PHALCON_ENSURE_IS_LONG(position);
phalcon_return_property(&definition, getThis(), SL("_definition"));
if (unlikely(Z_TYPE(definition) != IS_ARRAY)) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_di_exception_ce, "Definition must be an array to update its parameters");
return;
}
if (unlikely(Z_TYPE_P(parameter) != IS_ARRAY)) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_di_exception_ce, "The parameter must be an array");
return;
}
/* Update the parameter */
if (phalcon_array_isset_fetch_str(&arguments, &definition, SL("arguments"))) {
phalcon_array_update_zval(&arguments, position, parameter, PH_COPY);
} else {
array_init_size(&arguments, 1);
phalcon_array_update_zval(&arguments, position, parameter, PH_COPY);
}
phalcon_array_update_str(&definition, SL("arguments"), &arguments, PH_COPY);
phalcon_update_property_zval(getThis(), SL("_definition"), &definition);
RETURN_THISW();
}
/**
* Phalcon\Paginator\Adapter\Model constructor
*
* @param array $config
*/
PHP_METHOD(Phalcon_Paginator_Adapter_Model, __construct)
{
zval *config, limit = {}, page = {};
phalcon_fetch_params(0, 1, 0, &config);
phalcon_update_property_zval(getThis(), SL("_config"), config);
if (phalcon_array_isset_fetch_str(&limit, config, SL("limit"))) {
phalcon_update_property_zval(getThis(), SL("_limitRows"), &limit);
}
if (phalcon_array_isset_fetch_str(&page, config, SL("page"))) {
phalcon_update_property_zval(getThis(), SL("_page"), &page);
}
}
/**
* Phalcon\Http\Uri constructor
*
* @param mixed $uri
*/
PHP_METHOD(Phalcon_Http_Uri, __construct)
{
zval *uri = NULL, parts = {}, query = {}, params = {};
phalcon_fetch_params(0, 0, 1, &uri);
if (!uri || PHALCON_IS_EMPTY(uri)) {
phalcon_update_property_empty_array(getThis(), SL("_parts"));
} else if (Z_TYPE_P(uri) == IS_STRING) {
PHALCON_CALL_FUNCTIONW(&parts, "parse_url", uri);
if (phalcon_array_isset_fetch_str(&query, &parts, SL("query"))) {
ZVAL_MAKE_REF(¶ms);
PHALCON_CALL_FUNCTIONW(NULL, "parse_str", &query, ¶ms);
ZVAL_UNREF(¶ms);
phalcon_array_update_str(&parts, SL("query"), ¶ms, PH_COPY);
}
phalcon_update_property_zval(getThis(), SL("_parts"), &parts);
} else if (Z_TYPE_P(uri) == IS_ARRAY) {
phalcon_update_property_zval(getThis(), SL("_parts"), uri);
} else if (Z_TYPE_P(uri) == IS_OBJECT && Z_OBJCE_P(uri) == phalcon_http_uri_ce) {
phalcon_return_property(&parts, uri, SL("_parts"));
phalcon_update_property_zval(getThis(), SL("_parts"), &parts);
} else {
phalcon_update_property_empty_array(getThis(), SL("_parts"));
}
}
/**
* Handles routing information received from command-line arguments
*
* @param array $arguments
*/
PHP_METHOD(Phalcon_CLI_Router, handle){
zval *arguments = NULL, module_name = {}, namespace_name = {}, task_name = {}, action_name = {};
phalcon_fetch_params(0, 0, 1, &arguments);
if (!arguments || Z_TYPE_P(arguments) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_cli_router_exception_ce, "Arguments must be an Array");
return;
}
PHALCON_SEPARATE_PARAM(arguments);
/**
* Check for a module
*/
if (phalcon_array_isset_fetch_str(&module_name, arguments, SL("module"))) {
phalcon_array_unset_str(arguments, SL("module"), PH_COPY);
phalcon_update_property_this(getThis(), SL("_module"), &module_name);
}
/**
* Check for a namespace
*/
if (phalcon_array_isset_fetch_str(&namespace_name, arguments, SL("namespace"))) {
phalcon_array_unset_str(arguments, SL("namespace"), PH_COPY);
phalcon_update_property_this(getThis(), SL("_namespace"), &namespace_name);
}
/**
* Check for a task
*/
if (phalcon_array_isset_fetch_str(&task_name, arguments, SL("task"))) {
phalcon_array_unset_str(arguments, SL("task"), PH_COPY);
phalcon_update_property_this(getThis(), SL("_task"), &task_name);
}
/**
* Check for an action
*/
if (phalcon_array_isset_fetch_str(&action_name, arguments, SL("action"))) {
phalcon_array_unset_str(arguments, SL("action"), PH_COPY);
phalcon_update_property_this(getThis(), SL("_action"), &action_name);
}
phalcon_update_property_this(getThis(), SL("_params"), arguments);
}
/**
* Reads the cookie-related info from the SESSION to restore the cookie as it was set
* This method is automatically called internally so normally you don't need to call it
*
* @return Phalcon\Http\Cookie
*/
PHP_METHOD(Phalcon_Http_Cookie, restore)
{
zval *restored, *dependency_injector, service = {}, session = {}, name = {}, key = {}, definition = {}, expire = {}, domain = {}, path = {}, secure = {}, http_only = {};
restored = phalcon_read_property(getThis(), SL("_restored"), PH_NOISY);
if (!zend_is_true(restored)) {
dependency_injector = phalcon_read_property(getThis(), SL("_dependencyInjector"), PH_NOISY);
if (Z_TYPE_P(dependency_injector) == IS_OBJECT) {
ZVAL_STRING(&service, ISV(session));
PHALCON_CALL_METHODW(&session, dependency_injector, "getshared", &service);
PHALCON_VERIFY_INTERFACEW(&session, phalcon_session_adapterinterface_ce);
phalcon_return_property(&name, getThis(), SL("_name"));
PHALCON_CONCAT_SV(&key, "_PHCOOKIE_", &name);
PHALCON_CALL_METHODW(&definition, &session, "get", &key);
if (Z_TYPE(definition) == IS_ARRAY) {
if (phalcon_array_isset_fetch_str(&expire, &definition, SL("expire"))) {
phalcon_update_property_this(getThis(), SL("_expire"), &expire);
}
if (phalcon_array_isset_fetch_str(&domain, &definition, SL("domain"))) {
phalcon_update_property_this(getThis(), SL("_domain"), &domain);
}
if (phalcon_array_isset_fetch_str(&path, &definition, SL("path"))) {
phalcon_update_property_this(getThis(), SL("_path"), &path);
}
if (phalcon_array_isset_fetch_str(&secure, &definition, SL("secure"))) {
phalcon_update_property_this(getThis(), SL("_secure"), &secure);
}
if (phalcon_array_isset_fetch_str(&http_only, &definition, SL("httpOnly"))) {
phalcon_update_property_this(getThis(), SL("_httpOnly"), &http_only);
}
}
}
phalcon_update_property_bool(getThis(), SL("_restored"), 1);
}
RETURN_THISW();
}
/**
* Restore the internal state of a service
*
* @param array $attributes
* @return Phalcon\DI\Service
*/
PHP_METHOD(Phalcon_DI_Service, __set_state){
zval *attributes, name = {}, definition = {}, shared = {};
phalcon_fetch_params(0, 1, 0, &attributes);
if (
!phalcon_array_isset_fetch_str(&name, attributes, SL("_name"))
|| !phalcon_array_isset_fetch_str(&definition, attributes, SL("_definition"))
|| !phalcon_array_isset_fetch_str(&shared, attributes, SL("_shared"))
) {
PHALCON_THROW_EXCEPTION_STRW(spl_ce_BadMethodCallException, "Bad parameters passed to Phalcon\\DI\\Service::__set_state()");
return;
}
object_init_ex(return_value, phalcon_di_service_ce);
PHALCON_CALL_METHODW(NULL, return_value, "__construct", &name, &definition, &shared);
}
/**
* Phalcon\Mvc\Model\MetaData\Apc constructor
*
* @param array $options
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Apc, __construct){
zval *options = NULL, prefix = {}, lifetime = {};
phalcon_fetch_params(0, 0, 1, &options);
if (options && Z_TYPE_P(options) == IS_ARRAY) {
if (phalcon_array_isset_fetch_str(&prefix, options, SL("prefix"))) {
phalcon_update_property_zval(getThis(), SL("_prefix"), &prefix);
}
if (phalcon_array_isset_fetch_str(&lifetime, options, SL("lifetime"))) {
phalcon_update_property_zval(getThis(), SL("_ttl"), &lifetime);
}
}
phalcon_update_property_empty_array(getThis(), SL("_metaData"));
}
/**
* Gets HTTP user agent used to made the request
*
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getUserAgent){
zval *server, user_agent = {};
server = phalcon_get_global_str(SL("_SERVER"));
if (phalcon_array_isset_fetch_str(&user_agent, server, SL("HTTP_USER_AGENT"))) {
RETURN_CTORW(&user_agent);
}
RETURN_EMPTY_STRING();
}
/**
* Gets active server name
*
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getServerName){
zval *server, server_name = {};
server = phalcon_get_global_str(SL("_SERVER"));
if (phalcon_array_isset_fetch_str(&server_name, server, SL("SERVER_NAME"))) {
RETURN_CTORW(&server_name);
}
RETURN_STRING("localhost");
}
/**
* Gets active server address IP
*
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getServerAddress){
zval *server, server_addr = {};
server = phalcon_get_global_str(SL("_SERVER"));
if (phalcon_array_isset_fetch_str(&server_addr, server, SL("SERVER_ADDR"))) {
RETURN_CTORW(&server_addr);
}
RETURN_STRING("127.0.0.1");
}
/**
* Gets most possible client IPv4 Address. This method search in $_SERVER['REMOTE_ADDR'] and optionally in $_SERVER['HTTP_X_FORWARDED_FOR']
*
* @param boolean $trustForwardedHeader
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getClientAddress){
zval *trust_forwarded_header = NULL, *_SERVER, address = {}, addresses = {}, first = {};
phalcon_fetch_params(0, 0, 1, &trust_forwarded_header);
if (!trust_forwarded_header) {
trust_forwarded_header = &PHALCON_GLOBAL(z_false);
}
_SERVER = phalcon_get_global_str(SL("_SERVER"));
/**
* Proxies use this IP
*/
if (zend_is_true(trust_forwarded_header)) {
if (!phalcon_array_isset_fetch_str(&address, _SERVER, SL("HTTP_X_FORWARDED_FOR"))) {
if (!phalcon_array_isset_fetch_str(&address, _SERVER, SL("REMOTE_ADDR"))) {
phalcon_array_fetch_str(&address, _SERVER, SL("REMOTE_ADDR"), PH_NOISY);
}
}
} else if (!phalcon_array_isset_fetch_str(&address, _SERVER, SL("REMOTE_ADDR"))) {
phalcon_array_fetch_str(&address, _SERVER, SL("REMOTE_ADDR"), PH_NOISY);
}
if (Z_TYPE(address) == IS_STRING) {
if (phalcon_memnstr_str(&address, SL(","))) {
/**
* The client address has multiples parts, only return the first part
*/
phalcon_fast_explode_str(&addresses, SL(","), &address);
phalcon_array_fetch_long(&first, &addresses, 0, PH_NOISY);
RETURN_CTORW(&first);
}
RETURN_CTORW(&address);
}
RETURN_FALSE;
}
/**
* Phalcon\Annotations\Adapter\Files constructor
*
* @param array $options
*/
PHP_METHOD(Phalcon_Annotations_Adapter_Files, __construct){
zval *options = NULL, annotations_dir = {};
phalcon_fetch_params(0, 0, 1, &options);
if (options && Z_TYPE_P(options) == IS_ARRAY) {
if (phalcon_array_isset_fetch_str(&annotations_dir, options, SL("annotationsDir"))) {
phalcon_update_property_zval(getThis(), SL("_annotationsDir"), &annotations_dir);
}
}
}
/**
* Retrieve the URI path
*
* @return string
*/
PHP_METHOD(Phalcon_Http_Uri, getPath)
{
zval parts = {}, value = {};
phalcon_read_property(&parts, getThis(), SL("_parts"), PH_NOISY);
if (!phalcon_array_isset_fetch_str(&value, &parts, SL("path"))) {
RETURN_NULL();
}
RETURN_CTORW(&value);
}
/**
* Phalcon\Binary\Writer constructor
*
* @param string|resource $data
* @param int $endian
* @throws \InvalidArgumentException
*/
PHP_METHOD(Phalcon_Binary_Writer, __construct){
zval *data = NULL, *endian = NULL, filename = {}, mode = {}, handler = {}, fstat = {}, size = {};
phalcon_fetch_params(0, 0, 2, &data, &endian);
if (!data) {
data = &PHALCON_GLOBAL(z_null);
}
if (Z_TYPE_P(data) == IS_STRING || Z_TYPE_P(data) == IS_NULL) {
ZVAL_STRING(&filename, "php://memory");
ZVAL_STRING(&mode, "br+");
PHALCON_CALL_FUNCTIONW(&handler, "fopen", &filename, &mode);
PHALCON_CALL_FUNCTIONW(NULL, "fwrite", &handler, data);
PHALCON_CALL_FUNCTIONW(&fstat, "fstat", &handler);
if (phalcon_array_isset_fetch_str(&size, &fstat, SL("size"))) {
phalcon_update_property_zval(getThis(), SL("_position"), &size);
}
phalcon_update_property_zval(getThis(), SL("_output"), &handler);
} else if (Z_TYPE_P(data) == IS_RESOURCE) {
phalcon_update_property_zval(getThis(), SL("_output"), data);
PHALCON_CALL_FUNCTIONW(&fstat, "fstat", data);
if (phalcon_array_isset_fetch_str(&size, &fstat, SL("size"))) {
phalcon_update_property_zval(getThis(), SL("_position"), &size);
}
} else {
PHALCON_THROW_EXCEPTION_STRW(phalcon_binary_exception_ce, "Data must be set as string or resource");
return;
}
if (endian && Z_TYPE_P(endian) != IS_NULL) {
if (Z_TYPE_P(endian) != IS_LONG || Z_LVAL_P(endian) < 0 || Z_LVAL_P(endian) > 2) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_binary_exception_ce, "Endian must be set as big or little");
}
phalcon_update_property_zval(getThis(), SL("_endian"), endian);
}
}
/**
* Create internal connection to memcached
*/
PHP_METHOD(Phalcon_Cache_Backend_Memcache, _connect)
{
zval options = {}, memcache = {}, host = {}, port = {}, persistent = {}, success = {};
zend_class_entry *ce0;
phalcon_return_property(&options, getThis(), SL("_options"));
ce0 = phalcon_fetch_str_class(SL("Memcache"), ZEND_FETCH_CLASS_AUTO);
object_init_ex(&memcache, ce0);
if (phalcon_has_constructor(&memcache)) {
PHALCON_CALL_METHODW(NULL, &memcache, "__construct");
}
if (
!phalcon_array_isset_fetch_str(&host, &options, SL("host"))
|| !phalcon_array_isset_fetch_str(&port, &options, SL("port"))
|| !phalcon_array_isset_fetch_str(&persistent, &options, SL("persistent"))
) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_cache_exception_ce, "Unexpected inconsistency in options");
return;
}
if (zend_is_true(&persistent)) {
PHALCON_CALL_METHODW(&success, &memcache, "pconnect", &host, &port);
} else {
PHALCON_CALL_METHODW(&success, &memcache, "connect", &host, &port);
}
if (!zend_is_true(&success)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Cannot connect to Memcached server");
return;
}
phalcon_update_property_zval(getThis(), SL("_memcache"), &memcache);
RETURN_CTORW(&memcache);
}
/**
* Phalcon\Paginator\Adapter\NativeArray constructor
*
* @param array $config
*/
PHP_METHOD(Phalcon_Paginator_Adapter_NativeArray, __construct){
zval *config, limit = {}, page = {}, data = {};
phalcon_fetch_params(0, 1, 0, &config);
if (phalcon_array_isset_fetch_str(&limit, config, SL("limit"))) {
phalcon_update_property_this(getThis(), SL("_limitRows"), &limit);
}
if (phalcon_array_isset_fetch_str(&page, config, SL("page"))) {
phalcon_update_property_this(getThis(), SL("_page"), &page);
}
if (!phalcon_array_isset_fetch_str(&data, config, SL("data"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_paginator_exception_ce, "Parameter 'data' is required");
return;
} else if (Z_TYPE_P(&data) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_paginator_exception_ce, "'data' should be an array");
return;
}
phalcon_update_property_this(getThis(), SL("_data"), &data);
}
/**
* Returns uri
*
* @return string
*/
PHP_METHOD(Phalcon_Http_Uri, build)
{
zval parts = {}, uri = {}, scheme = {}, host = {}, user = {}, pass = {}, port = {}, path = {}, query = {}, fragment = {}, tmp = {};
phalcon_read_property(&parts, getThis(), SL("_parts"), PH_NOISY);
if (phalcon_array_isset_fetch_str(&scheme, &parts, SL("scheme")) && PHALCON_IS_NOT_EMPTY(&scheme)) {
if (phalcon_array_isset_fetch_str(&host, &parts, SL("host")) && PHALCON_IS_NOT_EMPTY(&host)) {
if (phalcon_array_isset_fetch_str(&user, &parts, SL("user")) && PHALCON_IS_NOT_EMPTY(&user)) {
if (phalcon_array_isset_fetch_str(&pass, &parts, SL("pass")) && PHALCON_IS_NOT_EMPTY(&pass)) {
PHALCON_CONCAT_VSVSVSV(&uri, &scheme, "://", &user, ":", &pass, "@", &host);
} else {
PHALCON_CONCAT_VSVSV(&uri, &scheme, "://", &user, "@", &host);
}
} else {
PHALCON_CONCAT_VSV(&uri, &scheme, "://", &host);
}
} else {
PHALCON_CONCAT_VS(&uri, &scheme, ":");
}
}
if (phalcon_array_isset_fetch_str(&port, &parts, SL("port")) && PHALCON_IS_NOT_EMPTY(&port)) {
PHALCON_SCONCAT_SV(&uri, ":", &port);
}
if (phalcon_array_isset_fetch_str(&path, &parts, SL("path")) && PHALCON_IS_NOT_EMPTY(&path)) {
if (!phalcon_start_with_str(&path, SL("/"))) {
PHALCON_SCONCAT_SV(&uri, "/", &path);
} else {
PHALCON_SCONCAT(&uri, &path);
}
}
if (phalcon_array_isset_fetch_str(&query, &parts, SL("query")) && PHALCON_IS_NOT_EMPTY(&query)) {
phalcon_http_build_query(&tmp, &query, "&");
PHALCON_SCONCAT_SV(&uri, "?", &tmp);
}
if (phalcon_array_isset_fetch_str(&fragment, &parts, SL("fragment")) && PHALCON_IS_NOT_EMPTY(&fragment)) {
PHALCON_SCONCAT_SV(&uri, "#", &fragment);
}
RETURN_CTORW(&uri);
}
/**
* Phalcon\Paginator\Adapter\Sql
*
* @param array $config
*/
PHP_METHOD(Phalcon_Paginator_Adapter_Sql, __construct){
zval *config, db = {}, sql = {}, total_sql = {}, bind = {}, limit = {}, page = {};
long int i_limit;
phalcon_fetch_params(0, 1, 0, &config);
if (!phalcon_array_isset_fetch_str(&db, config, SL("db"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_paginator_exception_ce, "Parameter 'db' is required");
return;
}
if (!phalcon_array_isset_fetch_str(&sql, config, SL("sql"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_paginator_exception_ce, "Parameter 'sql' is required");
return;
}
if (!phalcon_array_isset_fetch_str(&total_sql, config, SL("total_sql"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_paginator_exception_ce, "Parameter 'sql' is required");
return;
}
if (phalcon_array_isset_fetch_str(&bind, config, SL("bind"))) {
if (Z_TYPE_P(&bind) != IS_ARRAY) {
phalcon_update_property_empty_array(getThis(), SL("_bind"));
} else {
phalcon_update_property_this(getThis(), SL("_bind"), &bind);
}
} else {
phalcon_update_property_empty_array(getThis(), SL("_bind"));
}
PHALCON_VERIFY_INTERFACE_EX(&db, phalcon_db_adapterinterface_ce, phalcon_paginator_exception_ce, 0);
phalcon_update_property_this(getThis(), SL("_db"), &db);
phalcon_update_property_this(getThis(), SL("_sql"), &sql);
phalcon_update_property_this(getThis(), SL("_total_sql"), &total_sql);
if (!phalcon_array_isset_fetch_str(&limit, config, SL("limit"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_paginator_exception_ce, "Parameter 'limit' is required");
return;
}
i_limit = phalcon_get_intval(&limit);
if (i_limit < 1) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_paginator_exception_ce, "'limit' should be positive");
return;
}
phalcon_update_property_this(getThis(), SL("_limitRows"), &limit);
if (phalcon_array_isset_fetch_str(&page, config, SL("page"))) {
phalcon_update_property_this(getThis(), SL("_page"), &page);
}
}
/**
* Checks whether request has been made using SOAP
*
* @return boolean
*/
PHP_METHOD(Phalcon_Http_Request, isSoapRequested)
{
zval *server, content_type = {};
server = phalcon_get_global_str(SL("_SERVER"));
if (phalcon_array_isset_str(server, SL("HTTP_SOAPACTION"))) {
RETURN_TRUE;
}
if (phalcon_array_isset_fetch_str(&content_type, server, SL("CONTENT_TYPE"))) {
if (phalcon_memnstr_str(&content_type, SL("application/soap+xml"))) {
RETURN_TRUE;
}
}
RETURN_FALSE;
}
/**
* Checks if GD is enabled
*
* @return boolean
*/
PHP_METHOD(Phalcon_Image_Adapter_GD, check){
zval gd_version = {}, ret = {}, gd_info = {}, version = {}, exception_message = {}, pattern = {}, matches = {};
if (phalcon_function_exists_ex(SL("gd_info")) == FAILURE) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_image_exception_ce, "GD is either not installed or not enabled, check your configuration");
return;
}
if (!phalcon_get_constant(&gd_version, SL("GD_VERSION"))) {
PHALCON_CALL_FUNCTIONW(&gd_info, "gd_info");
if (phalcon_array_isset_fetch_str(&gd_version, &gd_info, SL("GD Version"))) {
ZVAL_STRING(&pattern, "#\\d+\\.\\d+(?:\\.\\d+)?#");
ZVAL_NULL(&matches);
ZVAL_MAKE_REF(&matches);
RETURN_ON_FAILURE(phalcon_preg_match(&ret, &pattern, &gd_version, &matches));
ZVAL_UNREF(&matches);
if (zend_is_true(&ret)) {
if (!phalcon_array_isset_fetch_long(&version, &matches, 0)) {
ZVAL_EMPTY_STRING(&version);
}
} else {
ZVAL_EMPTY_STRING(&version);
}
} else {
PHALCON_CPY_WRT_CTOR(&version, &gd_version);
}
}
if (-1 == php_version_compare(Z_STRVAL_P(&gd_version), "2.0.1")) {
PHALCON_CONCAT_SV(&exception_message, "Phalcon\\Image\\Adapter\\GD requires GD version '2.0.1' or greater, you have '", &gd_version);
PHALCON_THROW_EXCEPTION_ZVALW(phalcon_image_exception_ce, &exception_message);
return;
}
phalcon_update_static_property_ce(phalcon_image_adapter_gd_ce, SL("_checked"), &PHALCON_GLOBAL(z_true));
RETURN_TRUE;
}
/**
* Returns a parameter in a specific position
*
* @param int $position
* @return array
*/
PHP_METHOD(Phalcon_DI_Service, getParameter){
zval *position, definition = {}, arguments = {};
phalcon_fetch_params(0, 1, 0, &position);
PHALCON_ENSURE_IS_LONG(position);
phalcon_return_property(&definition, getThis(), SL("_definition"));
if (Z_TYPE(definition) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_di_exception_ce, "Definition must be an array to obtain its parameters");
return;
}
/* Update the parameter */
if (
!phalcon_array_isset_fetch_str(&arguments, &definition, SL("arguments")) ||
!phalcon_array_isset_fetch(return_value, &arguments, position, 0)
) {
RETURN_NULL();
}
}
/**
* Stores cached content into the XCache backend and stops the frontend
*
* @param string $keyName
* @param string $content
* @param long $lifetime
* @param boolean $stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_Xcache, save){
zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL, cached_content = {}, keys = {}, last_key = {}, frontend = {};
zval prepared_content = {}, ttl = {}, success = {}, is_buffering = {}, prefix = {}, options = {}, special_key = {};
phalcon_fetch_params(0, 0, 4, &key_name, &content, &lifetime, &stop_buffer);
if (!key_name || Z_TYPE_P(key_name) == IS_NULL) {
phalcon_return_property(&last_key, getThis(), SL("_lastKey"));
} else {
phalcon_return_property(&prefix, getThis(), SL("_prefix"));
PHALCON_CONCAT_SVV(&last_key, "_PHCX", &prefix, key_name);
}
if (!zend_is_true(&last_key)) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_cache_exception_ce, "The cache must be started first");
return;
}
phalcon_return_property(&frontend, getThis(), SL("_frontend"));
if (!content || Z_TYPE_P(content) == IS_NULL) {
PHALCON_CALL_METHODW(&cached_content, &frontend, "getcontent");
} else {
PHALCON_CPY_WRT(&cached_content, content);
}
if (!phalcon_is_numeric(&cached_content)) {
PHALCON_CALL_METHODW(&prepared_content, &frontend, "beforestore", &cached_content);
}
/**
* Take the lifetime from the frontend or read it from the set in start()
*/
if (!lifetime || Z_TYPE_P(lifetime) == IS_NULL) {
phalcon_return_property(&ttl, getThis(), SL("_lastLifetime"));
if (Z_TYPE(ttl) <= IS_NULL) {
PHALCON_CALL_METHODW(&ttl, &frontend, "getlifetime");
}
} else {
PHALCON_CPY_WRT(&ttl, lifetime);
}
if (Z_TYPE(prepared_content) > IS_NULL) {
PHALCON_CALL_FUNCTIONW(&success, "xcache_set", &last_key, &prepared_content, &ttl);
} else {
PHALCON_CALL_FUNCTIONW(&success, "xcache_set", &last_key, &cached_content, &ttl);
}
PHALCON_CALL_METHODW(&is_buffering, &frontend, "isbuffering");
if (!stop_buffer || PHALCON_IS_TRUE(stop_buffer)) {
PHALCON_CALL_METHODW(NULL, &frontend, "stop");
}
if (PHALCON_IS_TRUE(&is_buffering)) {
zend_print_zval(&cached_content, 0);
}
phalcon_update_property_bool(getThis(), SL("_started"), 0);
if (zend_is_true(&success)) {
phalcon_return_property(&options, getThis(), SL("_options"));
if (unlikely(!phalcon_array_isset_fetch_str(&special_key, &options, SL("statsKey")))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_cache_exception_ce, "Unexpected inconsistency in options");
return;
}
/**
* xcache_list() is available only to the administrator (unless XCache was
* patched). We have to update the list of the stored keys.
*/
PHALCON_CALL_FUNCTIONW(&keys, "xcache_get", &special_key);
if (Z_TYPE(keys) != IS_ARRAY) {
array_init(&keys);
}
phalcon_array_update_zval(&keys, &last_key, &ttl, PH_COPY);
PHALCON_CALL_FUNCTIONW(NULL, "xcache_set", &special_key, &keys, &PHALCON_GLOBAL(z_zero));
}
}
/**
* Handles routing information received from command-line arguments
*
* @param array $arguments
*/
PHP_METHOD(Phalcon_CLI_Router, handle){
zval *arguments = NULL, longopts = {}, options = {}, module_name = {}, namespace_name = {}, task_name = {}, action_name = {};
phalcon_fetch_params(0, 0, 1, &arguments);
if (!arguments || Z_TYPE_P(arguments) != IS_ARRAY) {
if (unlikely(!strcmp(sapi_module.name, "cli"))) {
array_init(&longopts);
phalcon_array_append_string(&longopts, SL("module::"), 0);
phalcon_array_append_string(&longopts, SL("namespace::"), 0);
phalcon_array_append_string(&longopts, SL("task::"), 0);
phalcon_array_append_string(&longopts, SL("action::"), 0);
phalcon_array_append_string(&longopts, SL("params::"), 0);
PHALCON_CALL_FUNCTIONW(&options, "getopt", &PHALCON_GLOBAL(z_null), &longopts);
} else {
array_init(&options);
}
} else {
PHALCON_CPY_WRT_CTOR(&options, arguments);
}
/**
* Check for a module
*/
if (phalcon_array_isset_fetch_str(&module_name, &options, SL("module"))) {
phalcon_array_unset_str(arguments, SL("module"), PH_COPY);
} else {
ZVAL_NULL(&module_name);
}
phalcon_update_property_zval(getThis(), SL("_module"), &module_name);
/**
* Check for a namespace
*/
if (phalcon_array_isset_fetch_str(&namespace_name, &options, SL("namespace"))) {
phalcon_array_unset_str(arguments, SL("namespace"), PH_COPY);
} else {
ZVAL_NULL(&namespace_name);
}
phalcon_update_property_zval(getThis(), SL("_namespace"), &namespace_name);
/**
* Check for a task
*/
if (phalcon_array_isset_fetch_str(&task_name, &options, SL("task"))) {
phalcon_array_unset_str(arguments, SL("task"), PH_COPY);
} else {
ZVAL_NULL(&task_name);
}
phalcon_update_property_zval(getThis(), SL("_task"), &task_name);
/**
* Check for an action
*/
if (phalcon_array_isset_fetch_str(&action_name, &options, SL("action"))) {
phalcon_array_unset_str(arguments, SL("action"), PH_COPY);
} else {
ZVAL_NULL(&action_name);
}
phalcon_update_property_zval(getThis(), SL("_action"), &action_name);
phalcon_update_property_zval(getThis(), SL("_params"), &options);
}
/**
* Constructor for Phalcon\Session\Adapter\Memcache
*
* @param array $options
*/
PHP_METHOD(Phalcon_Session_Adapter_Memcache, __construct){
zval *options, host = {}, port = {}, lifetime = {}, persistent = {}, prefix = {};
zval frontend_option = {}, backend_option = {}, frontend_data = {}, memcache = {};
zval callable_open = {}, callable_close = {}, callable_read = {}, callable_write = {}, callable_destroy = {}, callable_gc = {};
phalcon_fetch_params(0, 1, 0, &options);
if (Z_TYPE_P(options) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_session_exception_ce, "The options must be an array");
return;
}
if (!phalcon_array_isset_fetch_str(&host, options, SL("host"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_session_exception_ce, "No session host given in options");
return;
}
if (!phalcon_array_isset_fetch_str(&port, options, SL("port"))) {
ZVAL_LONG(&port, 11211);
}
if (!phalcon_array_isset_fetch_str(&lifetime, options, SL("lifetime"))) {
ZVAL_LONG(&lifetime, 8600);
} else {
phalcon_update_property_this(getThis(), SL("_lifetime"), &lifetime);
}
if (!phalcon_array_isset_fetch_str(&persistent, options, SL("persistent"))) {
ZVAL_FALSE(&persistent);
}
if (!phalcon_array_isset_fetch_str(&prefix, options, SL("prefix"))) {
ZVAL_EMPTY_STRING(&prefix);
}
/* create memcache instance */
array_init_size(&frontend_option, 1);
phalcon_array_update_str(&frontend_option, SL("lifetime"), &lifetime, PH_COPY);
object_init_ex(&frontend_data, phalcon_cache_frontend_data_ce);
PHALCON_CALL_METHODW(NULL, &frontend_data, "__construct", &frontend_option);
array_init_size(&backend_option, 3);
phalcon_array_update_str(&backend_option, SL("host"), &host, PH_COPY);
phalcon_array_update_str(&backend_option, SL("port"), &port, PH_COPY);
phalcon_array_update_str(&backend_option, SL("persistent"), &persistent, PH_COPY);
phalcon_array_update_str(&backend_option, SL("prefix"), &prefix, PH_COPY);
object_init_ex(&memcache, phalcon_cache_backend_memcache_ce);
PHALCON_CALL_METHODW(NULL, &memcache, "__construct", &frontend_data, &backend_option);
phalcon_update_property_this(getThis(), SL("_memcache"), &memcache);
/* open callback */
array_init_size(&callable_open, 2);
phalcon_array_append(&callable_open, getThis(), 0);
phalcon_array_append_string(&callable_open, SL("open"), 0);
/* close callback */
array_init_size(&callable_close, 2);
phalcon_array_append(&callable_close, getThis(), 0);
phalcon_array_append_string(&callable_close, SL("close"), 0);
/* read callback */
array_init_size(&callable_read, 2);
phalcon_array_append(&callable_read, getThis(), 0);
phalcon_array_append_string(&callable_read, SL("read"), 0);
/* write callback */
array_init_size(&callable_write, 2);
phalcon_array_append(&callable_write, getThis(), 0);
phalcon_array_append_string(&callable_write, SL("write"), 0);
/* destroy callback */
array_init_size(&callable_destroy, 2);
phalcon_array_append(&callable_destroy, getThis(), 0);
phalcon_array_append_string(&callable_destroy, SL("destroy"), 0);
/* gc callback */
array_init_size(&callable_gc, 2);
phalcon_array_append(&callable_gc, getThis(), 0);
phalcon_array_append_string(&callable_gc, SL("gc"), 0);
PHALCON_CALL_FUNCTIONW(NULL, "session_set_save_handler", &callable_open, &callable_close, &callable_read, &callable_write, &callable_destroy, &callable_gc);
PHALCON_CALL_PARENTW(NULL, phalcon_session_adapter_memcache_ce, getThis(), "__construct", options);
}
/**
* Phalcon\Image\GD constructor
*
* @param string $file
*/
PHP_METHOD(Phalcon_Image_Adapter_GD, __construct){
zval *file, *width = NULL, *height = NULL, exception_message = {}, checked = {}, realpath = {}, img_width = {}, img_height = {}, type = {}, mime = {}, format = {}, image = {}, imageinfo = {}, saveflag = {}, blendmode = {};
phalcon_fetch_params(0, 1, 2, &file, &width, &height);
if (Z_TYPE_P(file) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_image_exception_ce, "file parameter should be a string");
return;
}
phalcon_return_static_property_ce(&checked, phalcon_image_adapter_gd_ce, SL("_checked"));
if (!zend_is_true(&checked)) {
PHALCON_CALL_CE_STATICW(NULL, phalcon_image_adapter_gd_ce, "check");
}
phalcon_update_property_zval(getThis(), SL("_file"), file);
if (phalcon_file_exists(file) != FAILURE) {
phalcon_file_realpath(&realpath, file);
if (unlikely(Z_TYPE(realpath) != IS_STRING)) {
convert_to_string(&realpath);
}
phalcon_update_property_zval(getThis(), SL("_realpath"), &realpath);
PHALCON_CALL_FUNCTIONW(&imageinfo, "getimagesize", &realpath);
if (phalcon_array_isset_fetch_long(&img_width, &imageinfo, 0)) {
phalcon_update_property_zval(getThis(), SL("_width"), &img_width);
}
if (phalcon_array_isset_fetch_long(&img_height, &imageinfo, 1)) {
phalcon_update_property_zval(getThis(), SL("_height"), &img_height);
}
if (phalcon_array_isset_fetch_long(&type, &imageinfo, 2)) {
convert_to_long(&type);
phalcon_update_property_zval(getThis(), SL("_type"), &type);
} else {
ZVAL_LONG(&type, -1);
}
if (phalcon_array_isset_fetch_str(&mime, &imageinfo, SL("mime"))) {
convert_to_string(&mime);
phalcon_update_property_zval(getThis(), SL("_mime"), &mime);
}
assert(Z_TYPE(type) == IS_LONG);
switch (Z_LVAL(type)) {
case 1: // GIF
ZVAL_STRING(&format, "gif");
PHALCON_CALL_FUNCTIONW(&image, "imagecreatefromgif", &realpath);
break;
case 2: // JPEG
ZVAL_STRING(&format, "jpg");
PHALCON_CALL_FUNCTIONW(&image, "imagecreatefromjpeg", &realpath);
break;
case 3: // PNG
ZVAL_STRING(&format, "png");
PHALCON_CALL_FUNCTIONW(&image, "imagecreatefrompng", &realpath);
break;
default:
if (PHALCON_IS_NOT_EMPTY(&mime)) {
zend_throw_exception_ex(phalcon_image_exception_ce, 0, "Installed GD does not support '%s' images", Z_STRVAL(mime));
} else {
zend_throw_exception_ex(phalcon_image_exception_ce, 0, "Installed GD does not support such images");
}
return;
}
if (Z_TYPE(image) != IS_RESOURCE) {
assert(Z_TYPE(realpath) == IS_STRING);
zend_throw_exception_ex(phalcon_image_exception_ce, 0, "Failed to create image from file '%s'", Z_STRVAL(realpath));
return;
}
phalcon_update_property_zval(getThis(), SL("_format"), &format);
ZVAL_TRUE(&saveflag);
PHALCON_CALL_FUNCTIONW(NULL, "imagesavealpha", &image, &saveflag);
} else if (width && height) {
PHALCON_CALL_FUNCTIONW(&image, "imagecreatetruecolor", width, height);
if (Z_TYPE(image) != IS_RESOURCE) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_image_exception_ce, "imagecreatetruecolor() failed");
return;
}
ZVAL_TRUE(&blendmode);
ZVAL_TRUE(&saveflag);
PHALCON_CALL_FUNCTIONW(NULL, "imagealphablending", &image, &blendmode);
PHALCON_CALL_FUNCTIONW(NULL, "imagesavealpha", &image, &saveflag);
phalcon_update_property_zval(getThis(), SL("_realpath"), file);
phalcon_update_property_zval(getThis(), SL("_width"), width);
phalcon_update_property_zval(getThis(), SL("_height"), height);
ZVAL_LONG(&type, 3);
phalcon_update_property_zval(getThis(), SL("_type"), &type);
ZVAL_STRING(&format, "png");
phalcon_update_property_zval(getThis(), SL("_format"), &format);
ZVAL_STRING(&mime, "image/png");
phalcon_update_property_zval(getThis(), SL("_mime"), &mime);
} else {
PHALCON_CONCAT_SVS(&exception_message, "Failed to create image from file '", file, "'");
PHALCON_THROW_EXCEPTION_ZVALW(phalcon_image_exception_ce, &exception_message);
return;
}
phalcon_update_property_zval(getThis(), SL("_image"), &image);
}
/**
* Handle the command-line arguments.
*
*
* <code>
* $arguments = array(
* 'task' => 'taskname',
* 'action' => 'action',
* 'params' => array('parameter1', 'parameter2')
* );
* $console->handle($arguments);
* </code>
*
* @param array $arguments
* @return mixed
*/
PHP_METHOD(Phalcon_CLI_Console, handle){
zval *_arguments = NULL, arguments = {}, dependency_injector = {}, events_manager = {}, event_name = {}, service = {}, router = {}, module_name = {};
zval status = {}, modules = {}, exception_msg = {}, module = {}, path = {}, class_name = {}, module_object = {};
zval namespace_name = {}, task_name = {}, action_name = {}, params = {}, dispatcher = {};
phalcon_fetch_params(0, 0, 1, &_arguments);
if (!_arguments) {
array_init(&arguments);
} else {
PHALCON_CPY_WRT(&arguments, _arguments);
}
phalcon_return_property(&events_manager, getThis(), SL("_eventsManager"));
ZVAL_STRING(&service, ISV(router));
PHALCON_CALL_METHODW(&dependency_injector, getThis(), "getdi");
if (Z_TYPE(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_FORMATW(phalcon_cli_console_exception_ce, "A dependency injection container is required to access the '%s' service", Z_STRVAL(service));
return;
}
PHALCON_CALL_METHODW(&router, &dependency_injector, "getshared", &service);
PHALCON_VERIFY_CLASSW(&router, phalcon_cli_router_ce);
PHALCON_CALL_METHODW(NULL, &router, "handle", &arguments);
PHALCON_CALL_METHODW(&module_name, &router, "getmodulename");
if (zend_is_true(&module_name)) {
if (Z_TYPE(events_manager) == IS_OBJECT) {
ZVAL_STRING(&event_name, "console:beforeStartModule");
PHALCON_CALL_METHODW(&status, &events_manager, "fire", &event_name, getThis(), &module_name);
if (PHALCON_IS_FALSE(&status)) {
RETURN_FALSE;
}
}
phalcon_read_property(&modules, getThis(), SL("_modules"), PH_NOISY);
if (!phalcon_array_isset_fetch(&module, &modules, &module_name, 0)) {
PHALCON_CONCAT_SVS(&exception_msg, "Module '", &module_name, "' isn't registered in the console container");
PHALCON_THROW_EXCEPTION_ZVALW(phalcon_cli_console_exception_ce, &exception_msg);
return;
}
if (Z_TYPE_P(&module) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_cli_console_exception_ce, "Invalid module definition path");
return;
}
if (phalcon_array_isset_fetch_str(&path, &module, SL("path"))) {
convert_to_string_ex(&path);
if (phalcon_file_exists(&path) == SUCCESS) {
RETURN_ON_FAILURE(phalcon_require(Z_STRVAL(path)));
} else {
zend_throw_exception_ex(phalcon_cli_console_exception_ce, 0, "Modules definition path '%s' does not exist", Z_STRVAL(path));
return;
}
}
if (!phalcon_array_isset_fetch_str(&class_name, &module, SL("className"))) {
ZVAL_STRING(&class_name, "Module");
}
PHALCON_CALL_METHODW(&module_object, &dependency_injector, "getshared", &class_name);
PHALCON_CALL_METHODW(NULL, &module_object, "registerautoloaders");
PHALCON_CALL_METHODW(NULL, &module_object, "registerservices", &dependency_injector);
if (Z_TYPE(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(getThis(), SL("_moduleObject"), &module_object);
ZVAL_STRING(&event_name, "console:afterStartModule");
PHALCON_CALL_METHODW(&status, &events_manager, "fire", &event_name, getThis(), &module_name);
if (PHALCON_IS_FALSE(&status)) {
RETURN_FALSE;
}
}
}
PHALCON_CALL_METHODW(&namespace_name, &router, "getnamespacename");
PHALCON_CALL_METHODW(&task_name, &router, "gettaskname");
PHALCON_CALL_METHODW(&action_name, &router, "getactionname");
PHALCON_CALL_METHODW(¶ms, &router, "getparams");
ZVAL_STRING(&service, ISV(dispatcher));
PHALCON_CALL_METHODW(&dispatcher, &dependency_injector, "getshared", &service);
PHALCON_VERIFY_INTERFACEW(&dispatcher, phalcon_dispatcherinterface_ce);
PHALCON_CALL_METHODW(NULL, &dispatcher, "setnamespacename", &namespace_name);
PHALCON_CALL_METHODW(NULL, &dispatcher, "settaskname", &task_name);
PHALCON_CALL_METHODW(NULL, &dispatcher, "setactionname", &action_name);
PHALCON_CALL_METHODW(NULL, &dispatcher, "setparams", ¶ms);
if (Z_TYPE(events_manager) == IS_OBJECT) {
ZVAL_STRING(&event_name, "console:beforeHandleTask");
PHALCON_CALL_METHODW(&status, &events_manager, "fire", &event_name, getThis(), &dispatcher);
if (PHALCON_IS_FALSE(&status)) {
RETURN_FALSE;
}
}
PHALCON_CALL_METHODW(&status, &dispatcher, "dispatch");
if (Z_TYPE(events_manager) == IS_OBJECT) {
ZVAL_STRING(&event_name, "console:afterHandleTask");
PHALCON_CALL_METHODW(NULL, &events_manager, "fire", &event_name, getThis(), &status);
}
RETURN_CTORW(&status);
}
/**
* Stores cached content into the Memcached backend and stops the frontend
*
* @param int|string $keyName
* @param string $content
* @param long $lifetime
* @param boolean $stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_Memcache, save){
zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL, last_key = {}, prefix = {}, cached_content = {}, prepared_content = {}, ttl = {}, flags = {}, success = {};
zval keys = {}, is_buffering = {}, frontend = {}, memcache = {}, options = {}, special_key = {};
phalcon_fetch_params(0, 0, 4, &key_name, &content, &lifetime, &stop_buffer);
if (!key_name || Z_TYPE_P(key_name) == IS_NULL) {
phalcon_return_property(&last_key, getThis(), SL("_lastKey"));
} else {
phalcon_return_property(&prefix, getThis(), SL("_prefix"));
PHALCON_CONCAT_VV(&last_key, &prefix, key_name);
}
if (!zend_is_true(&last_key)) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_cache_exception_ce, "The cache must be started first");
return;
}
phalcon_return_property(&frontend, getThis(), SL("_frontend"));
/**
* Check if a connection is created or make a new one
*/
phalcon_return_property(&memcache, getThis(), SL("_memcache"));
if (Z_TYPE(memcache) != IS_OBJECT) {
PHALCON_CALL_METHODW(&memcache, getThis(), "_connect");
}
if (!content || Z_TYPE_P(content) == IS_NULL) {
PHALCON_CALL_METHODW(&cached_content, &frontend, "getcontent");
} else {
PHALCON_CPY_WRT(&cached_content, content);
}
/**
* Prepare the content in the frontend
*/
PHALCON_CALL_METHODW(&prepared_content, &frontend, "beforestore", &cached_content);
if (!lifetime || Z_TYPE_P(lifetime) == IS_NULL) {
phalcon_return_property(&ttl, getThis(), SL("_lastLifetime"));
if (Z_TYPE(ttl) == IS_NULL) {
PHALCON_CALL_METHODW(&ttl, &frontend, "getlifetime");
}
} else {
PHALCON_CPY_WRT(&ttl, lifetime);
}
ZVAL_LONG(&flags, 0);
/**
* We store without flags
*/
if (phalcon_is_numeric(&cached_content)) {
PHALCON_CALL_METHODW(&success, &memcache, "set", &last_key, &cached_content, &flags, &ttl);
} else {
PHALCON_CALL_METHODW(&success, &memcache, "set", &last_key, &prepared_content, &flags, &ttl);
}
if (!zend_is_true(&success)) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_cache_exception_ce, "Failed to store data in memcached");
return;
}
phalcon_return_property(&options, getThis(), SL("_options"));
if (unlikely(!phalcon_array_isset_fetch_str(&special_key, &options, SL("statsKey")))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_cache_exception_ce, "Unexpected inconsistency in options");
return;
}
if (Z_TYPE(special_key) != IS_NULL) {
/* Update the stats key */
PHALCON_CALL_METHODW(&keys, &memcache, "get", &special_key);
if (Z_TYPE(keys) != IS_ARRAY) {
array_init(&keys);
}
if (!phalcon_array_isset(&keys, &last_key)) {
phalcon_array_update_zval(&keys, &last_key, &ttl, PH_COPY);
PHALCON_CALL_METHODW(NULL, &memcache, "set", &special_key, &keys);
}
}
PHALCON_CALL_METHODW(&is_buffering, &frontend, "isbuffering");
if (!stop_buffer || PHALCON_IS_TRUE(stop_buffer)) {
PHALCON_CALL_METHODW(NULL, &frontend, "stop");
}
if (PHALCON_IS_TRUE(&is_buffering)) {
zend_print_zval(&cached_content, 0);
}
phalcon_update_property_bool(getThis(), SL("_started"), 0);
}
/**
* Composite one image onto another
*
* @param Phalcon\Image\Adapter $mask mask Image instance
*/
PHP_METHOD(Phalcon_Image_Adapter_GD, _mask){
zval *mask, image = {}, mask_image = {}, blob = {}, mask_image_width = {}, mask_image_height = {}, newimage = {}, image_width = {}, image_height = {}, saveflag = {}, color = {}, c = {}, alpha = {}, temp_image = {};
int x, y, w, h, i;
phalcon_fetch_params(0, 1, 0, &mask);
phalcon_return_property(&image, getThis(), SL("_image"));
PHALCON_CALL_METHODW(&blob, mask, "render");
PHALCON_CALL_FUNCTIONW(&mask_image, "imagecreatefromstring", &blob);
ZVAL_TRUE(&saveflag);
PHALCON_CALL_FUNCTIONW(NULL, "imagesavealpha", &mask_image, &saveflag);
PHALCON_CALL_FUNCTIONW(&mask_image_width, "imagesx", &mask_image);
PHALCON_CALL_FUNCTIONW(&mask_image_height, "imagesy", &mask_image);
phalcon_return_property(&image_width, getThis(), SL("_width"));
phalcon_return_property(&image_height, getThis(), SL("_height"));
PHALCON_CALL_METHODW(&newimage, getThis(), "_create", &image_width, &image_height);
PHALCON_CALL_FUNCTIONW(NULL, "imagesavealpha", &newimage, &saveflag);
ZVAL_LONG(&c, 0);
ZVAL_LONG(&alpha, 127);
PHALCON_CALL_FUNCTIONW(&color, "imagecolorallocatealpha", &newimage, &c, &c, &c, &alpha);
PHALCON_CALL_FUNCTIONW(NULL, "imagefill", &newimage, &c, &c, &color);
if(!PHALCON_IS_EQUAL(&image_width, &mask_image_width) || !PHALCON_IS_EQUAL(&image_height, &mask_image_height)) {
PHALCON_CALL_FUNCTIONW(&temp_image, "imagecreatetruecolor", &image_width, &image_height);
PHALCON_CALL_FUNCTIONW(NULL, "imagecopyresampled", &temp_image, &mask_image, &c, &c, &c, &c, &image_width, &image_height, &mask_image_width, &mask_image_height);
PHALCON_CALL_FUNCTIONW(NULL, "imagedestroy", &mask_image);
PHALCON_CPY_WRT_CTOR(&mask_image, &temp_image);
}
w = phalcon_get_intval(&image_width);
h = phalcon_get_intval(&image_height);
for (x=0; x < w; x++) {
zval zx = {};
ZVAL_LONG(&zx, x);
for (y=0; y < h; y++) {
zval zy = {}, index = {}, red = {}, index2 = {}, color = {}, r = {}, g = {}, b = {};
ZVAL_LONG(&zy, y);
PHALCON_CALL_FUNCTIONW(&index, "imagecolorat", &mask_image, &zx, &zy);
PHALCON_CALL_FUNCTIONW(&alpha, "imagecolorsforindex", &mask_image, &index);
if (phalcon_array_isset_fetch_str(&red, &alpha, SL("red"))) {
i = (int)(127 - (phalcon_get_intval(&red) / 2));
ZVAL_LONG(&alpha, i);
}
PHALCON_CALL_FUNCTIONW(&index2, "imagecolorat", &image, &zx, &zy);
PHALCON_CALL_FUNCTIONW(&color, "imagecolorsforindex", &image, &index2);
phalcon_array_isset_fetch_str(&r, &color, SL("red"));
phalcon_array_isset_fetch_str(&g, &color, SL("green"));
phalcon_array_isset_fetch_str(&b, &color, SL("blue"));
PHALCON_CALL_FUNCTIONW(&color, "imagecolorallocatealpha", &newimage, &r, &g, &b, &alpha);
PHALCON_CALL_FUNCTIONW(NULL, "imagesetpixel", &newimage, &zx, &zy, &color);
}
}
PHALCON_CALL_FUNCTIONW(NULL, "imagedestroy", &image);
PHALCON_CALL_FUNCTIONW(NULL, "imagedestroy", &mask_image);
phalcon_update_property_zval(getThis(), SL("_image"), &newimage);
}
