/**
* Render view
*/
PHP_METHOD(Owl_Mvc_View, render) {
int ZEPHIR_LAST_CALL_STATUS;
zval *parameters = NULL;
zval *path_param = NULL, *parameters_param = NULL, *_0, *_1, *_2, *_3, *_4, *tmp = NULL;
zval *path = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &path_param, ¶meters_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);
}
if (!parameters_param) {
ZEPHIR_INIT_VAR(parameters);
array_init(parameters);
} else {
zephir_get_arrval(parameters, parameters_param);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("path"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_VV(_1, _0, path);
if (!((zephir_file_exists(_1 TSRMLS_CC) == SUCCESS))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(owl_exception_ce, "File is not exists", "owl/Mvc/View.zep", 21);
return;
}
ZEPHIR_CALL_FUNCTION(NULL, "ob_start", NULL, 23);
zephir_check_call_status();
if (!(Z_TYPE_P(parameters) == IS_NULL)) {
ZEPHIR_INIT_VAR(_2);
ZVAL_LONG(_2, 0);
Z_SET_ISREF_P(parameters);
ZEPHIR_CALL_FUNCTION(NULL, "extract", NULL, 24, parameters, _2);
Z_UNSET_ISREF_P(parameters);
zephir_check_call_status();
}
_3 = zephir_fetch_nproperty_this(this_ptr, SL("path"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_4);
ZEPHIR_CONCAT_VV(_4, _3, path);
if (zephir_require_zval(_4 TSRMLS_CC) == FAILURE) {
RETURN_MM_NULL();
}
ZEPHIR_CALL_FUNCTION(&tmp, "ob_get_contents", NULL, 25);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(NULL, "ob_end_clean", NULL, 26);
zephir_check_call_status();
RETURN_CCTOR(tmp);
}
/**
* Returns the complete location where the joined/filtered collection must be written
*/
PHP_METHOD(Phalcon_Assets_Collection, getRealTargetPath) {
int ZEPHIR_LAST_CALL_STATUS;
zval *basePath_param = NULL, *targetPath, *completePath;
zval *basePath = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &basePath_param);
if (unlikely(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 (likely(Z_TYPE_P(basePath_param) == IS_STRING)) {
zephir_get_strval(basePath, basePath_param);
} else {
ZEPHIR_INIT_VAR(basePath);
ZVAL_EMPTY_STRING(basePath);
}
ZEPHIR_OBS_VAR(targetPath);
zephir_read_property_this(&targetPath, this_ptr, SL("_targetPath"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(completePath);
ZEPHIR_CONCAT_VV(completePath, basePath, targetPath);
if ((zephir_file_exists(completePath TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_FUNCTION("realpath", NULL, 62, completePath);
zephir_check_call_status();
RETURN_MM();
}
RETURN_CCTOR(completePath);
}
/**
* 随机生成16位字符串
* @return string 生成的字符串
*/
PHP_METHOD(Fox_MsgCrypt, _getRandomStr) {
zval *pol = NULL, *_0, _4, _5, *_1$$3, *_2$$3, *_3$$4 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(pol);
ZVAL_STRING(pol, "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz", 1);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("fixout"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
_1$$3 = zephir_fetch_nproperty_this(this_ptr, SL("appkey"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_2$$3);
ZEPHIR_CONCAT_VV(_2$$3, pol, _1$$3);
ZEPHIR_INIT_NVAR(pol);
zephir_md5(pol, _2$$3);
} else {
ZEPHIR_CALL_FUNCTION(&_3$$4, "str_shuffle", NULL, 16, pol);
zephir_check_call_status();
ZEPHIR_CPY_WRT(pol, _3$$4);
}
ZEPHIR_SINIT_VAR(_4);
ZVAL_LONG(&_4, 1);
ZEPHIR_SINIT_VAR(_5);
ZVAL_LONG(&_5, 16);
zephir_substr(return_value, pol, 1 , 16 , 0);
RETURN_MM();
}
/**
* @inheritdoc
*/
PHP_METHOD(Owl_Log_Writer_File, write) {
int ZEPHIR_LAST_CALL_STATUS;
zval *record_param = NULL, *_0 = NULL, *_1 = NULL, *_2, _3;
zval *record = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &record_param);
zephir_get_strval(record, record_param);
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "logFile", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "getoption", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_1);
ZEPHIR_GET_CONSTANT(_1, "PHP_EOL");
ZEPHIR_INIT_VAR(_2);
ZEPHIR_CONCAT_VV(_2, record, _1);
ZEPHIR_SINIT_VAR(_3);
ZVAL_LONG(&_3, 8);
ZEPHIR_CALL_FUNCTION(NULL, "file_put_contents", NULL, 26, _0, _2, &_3);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(ADOdb_Cache, getQueryId) {
zval *sql_param = NULL, *params = NULL, *_0 = NULL, *_1, *_2;
zval *sql = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &sql_param, ¶ms);
zephir_get_strval(sql, sql_param);
if (!params) {
params = ZEPHIR_GLOBAL(global_null);
}
if ((Z_TYPE_P(params) != IS_NULL)) {
ZEPHIR_INIT_VAR(_0);
zephir_fast_join_str(_0, SL(""), params TSRMLS_CC);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_VV(_1, sql, _0);
ZEPHIR_INIT_VAR(_2);
zephir_call_func_p1(_2, "md5", _1);
ZEPHIR_CONCAT_SV(return_value, "DB_", _2);
RETURN_MM();
} else {
ZEPHIR_INIT_NVAR(_0);
zephir_call_func_p1(_0, "md5", sql);
ZEPHIR_CONCAT_SV(return_value, "DB_", _0);
RETURN_MM();
}
ZEPHIR_MM_RESTORE();
}
/**
* Possible class name that will be located to dispatch the request
*/
PHP_METHOD(Phalcon_Dispatcher, getHandlerClass) {
zval *handlerSuffix = NULL, *handlerName = NULL, *namespaceName = NULL, *camelizedClass = NULL, *handlerClass = NULL;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_resolveemptyproperties", NULL, 0);
zephir_check_call_status();
ZEPHIR_OBS_VAR(handlerSuffix);
zephir_read_property_this(&handlerSuffix, this_ptr, SL("_handlerSuffix"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(handlerName);
zephir_read_property_this(&handlerName, this_ptr, SL("_handlerName"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(namespaceName);
zephir_read_property_this(&namespaceName, this_ptr, SL("_namespaceName"), PH_NOISY_CC);
if (!(zephir_memnstr_str(handlerName, SL("\\"), "phalcon/dispatcher.zep", 709))) {
ZEPHIR_INIT_VAR(camelizedClass);
zephir_camelize(camelizedClass, handlerName, NULL );
} else {
ZEPHIR_CPY_WRT(camelizedClass, handlerName);
}
if (zephir_is_true(namespaceName)) {
ZEPHIR_INIT_VAR(handlerClass);
if (zephir_end_with_str(namespaceName, SL("\\"))) {
ZEPHIR_CONCAT_VVV(handlerClass, namespaceName, camelizedClass, handlerSuffix);
} else {
ZEPHIR_CONCAT_VSVV(handlerClass, namespaceName, "\\", camelizedClass, handlerSuffix);
}
} else {
ZEPHIR_INIT_NVAR(handlerClass);
ZEPHIR_CONCAT_VV(handlerClass, camelizedClass, handlerSuffix);
}
RETURN_CCTOR(handlerClass);
}
/**
* Returns the complete location where the resource is located
*/
PHP_METHOD(Phalcon_Assets_Resource, getRealSourcePath) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *basePath_param = NULL, *sourcePath = NULL, *_0, *_1$$4;
zval *basePath = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &basePath_param);
if (!basePath_param) {
ZEPHIR_INIT_VAR(basePath);
ZVAL_EMPTY_STRING(basePath);
} else {
zephir_get_strval(basePath, basePath_param);
}
ZEPHIR_OBS_VAR(sourcePath);
zephir_read_property_this(&sourcePath, this_ptr, SL("_sourcePath"), PH_NOISY_CC);
if (ZEPHIR_IS_EMPTY(sourcePath)) {
ZEPHIR_OBS_NVAR(sourcePath);
zephir_read_property_this(&sourcePath, this_ptr, SL("_path"), PH_NOISY_CC);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_local"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
ZEPHIR_INIT_VAR(_1$$4);
ZEPHIR_CONCAT_VV(_1$$4, basePath, sourcePath);
ZEPHIR_RETURN_CALL_FUNCTION("realpath", NULL, 67, _1$$4);
zephir_check_call_status();
RETURN_MM();
}
RETURN_CCTOR(sourcePath);
}
/**
* Adds a route applying the common attributes
*/
PHP_METHOD(Phalcon_Mvc_Router_Group, _addRoute) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_0 = NULL;
zval *pattern_param = NULL, *paths = NULL, *httpMethods = NULL, *mergedPaths = NULL, *route, *defaultPaths, *processedPaths = NULL, *_1, *_2;
zval *pattern = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &pattern_param, &paths, &httpMethods);
if (unlikely(Z_TYPE_P(pattern_param) != IS_STRING && Z_TYPE_P(pattern_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'pattern' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(pattern_param) == IS_STRING)) {
zephir_get_strval(pattern, pattern_param);
} else {
ZEPHIR_INIT_VAR(pattern);
ZVAL_EMPTY_STRING(pattern);
}
if (!paths) {
paths = ZEPHIR_GLOBAL(global_null);
}
if (!httpMethods) {
httpMethods = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_OBS_VAR(defaultPaths);
zephir_read_property_this(&defaultPaths, this_ptr, SL("_paths"), PH_NOISY_CC);
if (Z_TYPE_P(defaultPaths) == IS_ARRAY) {
if (Z_TYPE_P(paths) == IS_STRING) {
ZEPHIR_CALL_CE_STATIC(&processedPaths, phalcon_mvc_router_route_ce, "getroutepaths", &_0, 77, paths);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(processedPaths, paths);
}
if (Z_TYPE_P(processedPaths) == IS_ARRAY) {
ZEPHIR_INIT_VAR(mergedPaths);
zephir_fast_array_merge(mergedPaths, &(defaultPaths), &(processedPaths) TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(mergedPaths, defaultPaths);
}
} else {
ZEPHIR_CPY_WRT(mergedPaths, paths);
}
ZEPHIR_INIT_VAR(route);
object_init_ex(route, phalcon_mvc_router_route_ce);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_2);
ZEPHIR_CONCAT_VV(_2, _1, pattern);
ZEPHIR_CALL_METHOD(NULL, route, "__construct", NULL, 76, _2, mergedPaths, httpMethods);
zephir_check_call_status();
zephir_update_property_array_append(this_ptr, SL("_routes"), route TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, route, "setgroup", NULL, 361, this_ptr);
zephir_check_call_status();
RETURN_CCTOR(route);
}
/**
* Generates a local path
*/
PHP_METHOD(Phalcon_Mvc_Url, path) {
zval *path_param = NULL, _0;
zval path;
zval *this_ptr = getThis();
ZVAL_UNDEF(&path);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &path_param);
if (!path_param) {
ZEPHIR_INIT_VAR(&path);
ZVAL_STRING(&path, "");
} else {
zephir_get_strval(&path, path_param);
}
zephir_read_property(&_0, this_ptr, SL("basePath"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_CONCAT_VV(return_value, &_0, &path);
RETURN_MM();
}
/**
* 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 string
*/
PHP_METHOD(Phalcon_Logger_Formatter_Line, format) {
zend_long type, timestamp, ZEPHIR_LAST_CALL_STATUS;
zval *message_param = NULL, *type_param = NULL, *timestamp_param = NULL, *context = NULL, *format = NULL, *_8, _9, *_10, *_11, *_0$$3, *_1$$3, _2$$3 = zval_used_for_init, *_3$$3 = NULL, *_4$$4, *_5$$4 = NULL, *_6$$4, _7$$4;
zval *message = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 1, &message_param, &type_param, ×tamp_param, &context);
zephir_get_strval(message, message_param);
type = zephir_get_intval(type_param);
timestamp = zephir_get_intval(timestamp_param);
if (!context) {
context = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_OBS_VAR(format);
zephir_read_property_this(&format, this_ptr, SL("_format"), PH_NOISY_CC);
if (zephir_memnstr_str(format, SL("%date%"), "phalcon/logger/formatter/line.zep", 80)) {
ZEPHIR_INIT_VAR(_0$$3);
_1$$3 = zephir_fetch_nproperty_this(this_ptr, SL("_dateFormat"), PH_NOISY_CC);
ZEPHIR_SINIT_VAR(_2$$3);
ZVAL_LONG(&_2$$3, timestamp);
ZEPHIR_CALL_FUNCTION(&_3$$3, "date", NULL, 306, _1$$3, &_2$$3);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_2$$3);
ZVAL_STRING(&_2$$3, "%date%", 0);
zephir_fast_str_replace(&_0$$3, &_2$$3, _3$$3, format TSRMLS_CC);
ZEPHIR_CPY_WRT(format, _0$$3);
}
if (zephir_memnstr_str(format, SL("%type%"), "phalcon/logger/formatter/line.zep", 87)) {
ZEPHIR_INIT_VAR(_4$$4);
ZEPHIR_INIT_VAR(_6$$4);
ZVAL_LONG(_6$$4, type);
ZEPHIR_CALL_METHOD(&_5$$4, this_ptr, "gettypestring", NULL, 0, _6$$4);
zephir_check_call_status();
ZEPHIR_SINIT_VAR(_7$$4);
ZVAL_STRING(&_7$$4, "%type%", 0);
zephir_fast_str_replace(&_4$$4, &_7$$4, _5$$4, format TSRMLS_CC);
ZEPHIR_CPY_WRT(format, _4$$4);
}
ZEPHIR_INIT_VAR(_8);
ZEPHIR_SINIT_VAR(_9);
ZVAL_STRING(&_9, "%message%", 0);
zephir_fast_str_replace(&_8, &_9, message, format TSRMLS_CC);
ZEPHIR_INIT_VAR(_10);
ZEPHIR_GET_CONSTANT(_10, "PHP_EOL");
ZEPHIR_INIT_VAR(_11);
ZEPHIR_CONCAT_VV(_11, _8, _10);
ZEPHIR_CPY_WRT(format, _11);
if (Z_TYPE_P(context) == IS_ARRAY) {
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "interpolate", NULL, 0, format, context);
zephir_check_call_status();
RETURN_MM();
}
RETURN_CCTOR(format);
}
/**
* Stores cached content into the backend and stops the frontend
*
* @param string keyName
* @param string content
* @param long lifetime
* @param boolean stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_Memory, save) {
int ZEPHIR_LAST_CALL_STATUS;
zval *keyName = NULL, *content = NULL, *lifetime = NULL, *stopBuffer = NULL, *lastKey = NULL, *frontend, *cachedContent = NULL, *preparedContent = NULL, *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 (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);
}
if (!(zephir_is_true(lastKey))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cache must be started first", "phalcon/cache/backend/memory.zep", 97);
return;
}
ZEPHIR_OBS_VAR(frontend);
zephir_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
if (Z_TYPE_P(content) == IS_NULL) {
ZEPHIR_CALL_METHOD(&cachedContent, frontend, "getcontent", NULL);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(cachedContent, content);
}
ZEPHIR_CALL_METHOD(&preparedContent, frontend, "beforestore", NULL, cachedContent);
zephir_check_call_status();
zephir_update_property_array(this_ptr, SL("_data"), lastKey, preparedContent TSRMLS_CC);
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();
}
/**
* Applies a format to a message before sent it to the internal log
*
* @param <Item> item
*
* @return string
*/
PHP_METHOD(Phalcon_Logger_Formatter_Json, format) {
zval _4;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *item, item_sub, message, _0, _3, _5, _6, _7, _8, _1$$3, _2$$3;
zval *this_ptr = getThis();
ZVAL_UNDEF(&item_sub);
ZVAL_UNDEF(&message);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_3);
ZVAL_UNDEF(&_5);
ZVAL_UNDEF(&_6);
ZVAL_UNDEF(&_7);
ZVAL_UNDEF(&_8);
ZVAL_UNDEF(&_1$$3);
ZVAL_UNDEF(&_2$$3);
ZVAL_UNDEF(&_4);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &item);
ZEPHIR_CALL_METHOD(&_0, item, "getcontext", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(&_0) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&_1$$3, item, "getmessage", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_2$$3, item, "getcontext", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&message, this_ptr, "interpolate", NULL, 0, &_1$$3, &_2$$3);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(&message, item, "getmessage", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_INIT_VAR(&_3);
ZEPHIR_INIT_VAR(&_4);
zephir_create_array(&_4, 3, 0 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_5, item, "getname", NULL, 0);
zephir_check_call_status();
zephir_array_update_string(&_4, SL("type"), &_5, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_4, SL("message"), &message, PH_COPY | PH_SEPARATE);
zephir_read_property(&_6, this_ptr, SL("dateFormat"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_CALL_METHOD(&_5, item, "gettime", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_7, "date", NULL, 294, &_6, &_5);
zephir_check_call_status();
zephir_array_update_string(&_4, SL("timestamp"), &_7, PH_COPY | PH_SEPARATE);
zephir_json_encode(&_3, &_4, 0 );
ZEPHIR_INIT_VAR(&_8);
ZEPHIR_GET_CONSTANT(&_8, "PHP_EOL");
ZEPHIR_CONCAT_VV(return_value, &_3, &_8);
RETURN_MM();
}
/**
* Returns a cached content
*/
PHP_METHOD(Phalcon_Cache_Backend_Libmemcached, get) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *keyName_param = NULL, *lifetime = NULL, lifetime_sub, __$null, memcache, prefixedKey, cachedContent, _0, _1, _2;
zval keyName;
zval *this_ptr = getThis();
ZVAL_UNDEF(&keyName);
ZVAL_UNDEF(&lifetime_sub);
ZVAL_NULL(&__$null);
ZVAL_UNDEF(&memcache);
ZVAL_UNDEF(&prefixedKey);
ZVAL_UNDEF(&cachedContent);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZVAL_UNDEF(&_2);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &keyName_param, &lifetime);
zephir_get_strval(&keyName, keyName_param);
if (!lifetime) {
lifetime = &lifetime_sub;
lifetime = &__$null;
}
ZEPHIR_OBS_VAR(&memcache);
zephir_read_property(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC);
if (Z_TYPE_P(&memcache) != IS_OBJECT) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_connect", NULL, 0);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(&memcache);
zephir_read_property(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC);
}
zephir_read_property(&_0, this_ptr, SL("_prefix"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_INIT_VAR(&prefixedKey);
ZEPHIR_CONCAT_VV(&prefixedKey, &_0, &keyName);
zephir_update_property_zval(this_ptr, SL("_lastKey"), &prefixedKey);
ZEPHIR_CALL_METHOD(&cachedContent, &memcache, "get", NULL, 0, &prefixedKey);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_1, &memcache, "getresultcode", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_LONG_IDENTICAL(&_1, 16)) {
RETURN_MM_NULL();
}
if (zephir_is_numeric(&cachedContent)) {
RETURN_CCTOR(&cachedContent);
}
zephir_read_property(&_2, this_ptr, SL("_frontend"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_RETURN_CALL_METHOD(&_2, "afterretrieve", NULL, 0, &cachedContent);
zephir_check_call_status();
RETURN_MM();
}
/**
* Returns the content of the resource as an string
* Optionally a base path where the resource is located can be set
*/
PHP_METHOD(Phalcon_Assets_Resource, getContent) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *basePath_param = NULL, *sourcePath = NULL, *completePath = NULL, *content = NULL, *_0, *_1$$5, *_2$$5, *_3$$6, *_4$$6;
zval *basePath = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &basePath_param);
if (!basePath_param) {
ZEPHIR_INIT_VAR(basePath);
ZVAL_EMPTY_STRING(basePath);
} else {
zephir_get_strval(basePath, basePath_param);
}
ZEPHIR_OBS_VAR(sourcePath);
zephir_read_property_this(&sourcePath, this_ptr, SL("_sourcePath"), PH_NOISY_CC);
if (ZEPHIR_IS_EMPTY(sourcePath)) {
ZEPHIR_OBS_NVAR(sourcePath);
zephir_read_property_this(&sourcePath, this_ptr, SL("_path"), PH_NOISY_CC);
}
ZEPHIR_INIT_VAR(completePath);
ZEPHIR_CONCAT_VV(completePath, basePath, sourcePath);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_local"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
if (!((zephir_file_exists(completePath TSRMLS_CC) == SUCCESS))) {
ZEPHIR_INIT_VAR(_1$$5);
object_init_ex(_1$$5, phalcon_assets_exception_ce);
ZEPHIR_INIT_VAR(_2$$5);
ZEPHIR_CONCAT_SVS(_2$$5, "Resource's content for '", completePath, "' cannot be read");
ZEPHIR_CALL_METHOD(NULL, _1$$5, "__construct", NULL, 9, _2$$5);
zephir_check_call_status();
zephir_throw_exception_debug(_1$$5, "phalcon/assets/resource.zep", 183 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
ZEPHIR_INIT_VAR(content);
zephir_file_get_contents(content, completePath TSRMLS_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(content)) {
ZEPHIR_INIT_VAR(_3$$6);
object_init_ex(_3$$6, phalcon_assets_exception_ce);
ZEPHIR_INIT_VAR(_4$$6);
ZEPHIR_CONCAT_SVS(_4$$6, "Resource's content for '", completePath, "' cannot be read");
ZEPHIR_CALL_METHOD(NULL, _3$$6, "__construct", NULL, 9, _4$$6);
zephir_check_call_status();
zephir_throw_exception_debug(_3$$6, "phalcon/assets/resource.zep", 192 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
RETURN_CCTOR(content);
}
/**
* Returns a cached content
*/
PHP_METHOD(Phalcon_Cache_Backend_Mongo, get) {
zval *_1;
int lifetime, ZEPHIR_LAST_CALL_STATUS;
zval *keyName_param = NULL, *lifetime_param = NULL, *frontend = NULL, *prefixedKey = NULL, *conditions = NULL, *document = NULL, *cachedContent = NULL, *_0, *_2, *_3 = NULL;
zval *keyName = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &keyName_param, &lifetime_param);
zephir_get_strval(keyName, keyName_param);
if (!lifetime_param) {
lifetime = 0;
} else {
lifetime = zephir_get_intval(lifetime_param);
}
ZEPHIR_INIT_VAR(conditions);
array_init(conditions);
ZEPHIR_OBS_VAR(frontend);
zephir_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(prefixedKey);
ZEPHIR_CONCAT_VV(prefixedKey, _0, keyName);
zephir_update_property_this(this_ptr, SL("_lastKey"), prefixedKey TSRMLS_CC);
zephir_array_update_string(&conditions, SL("key"), &prefixedKey, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_VAR(_1);
zephir_create_array(_1, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_2);
zephir_time(_2);
zephir_array_update_string(&_1, SL("$gt"), &_2, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&conditions, SL("time"), &_1, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(&_3, this_ptr, "_getcollection", NULL, 117);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&document, _3, "findone", NULL, 0, conditions);
zephir_check_call_status();
if (Z_TYPE_P(document) == IS_ARRAY) {
ZEPHIR_OBS_VAR(cachedContent);
if (zephir_array_isset_string_fetch(&cachedContent, document, SS("data"), 0 TSRMLS_CC)) {
if (zephir_is_numeric(cachedContent)) {
RETURN_CCTOR(cachedContent);
}
ZEPHIR_RETURN_CALL_METHOD(frontend, "afterretrieve", NULL, 0, cachedContent);
zephir_check_call_status();
RETURN_MM();
} else {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "The cache is corrupt", "phalcon/cache/backend/mongo.zep", 176);
return;
}
}
RETURN_MM_NULL();
}
/**
* Returns the current method to be/executed in the dispatcher
*/
PHP_METHOD(Phalcon_Dispatcher, getActiveMethod) {
zval *_0, *_1;
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_actionName"), PH_NOISY_CC);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_actionSuffix"), PH_NOISY_CC);
ZEPHIR_CONCAT_VV(return_value, _0, _1);
return;
}
PHP_METHOD(Yb_Std, uuid) {
int ZEPHIR_LAST_CALL_STATUS;
zval *salt_param = NULL, *_0 = NULL, *_1 = NULL, *_2, *_3 = NULL, *_4, _5, _6, *_7 = NULL;
zval *salt = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &salt_param);
if (!salt_param) {
ZEPHIR_INIT_VAR(salt);
ZVAL_STRING(salt, "", 1);
} else {
zephir_get_strval(salt, salt_param);
}
ZEPHIR_CALL_FUNCTION(&_0, "mt_rand", NULL, 76);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_1, "uniqid", NULL, 77, _0, ZEPHIR_GLOBAL(global_true));
zephir_check_call_status();
ZEPHIR_INIT_VAR(_2);
ZEPHIR_CONCAT_VV(_2, _1, salt);
ZEPHIR_CALL_FUNCTION(&_3, "sha1", NULL, 78, _2);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_4);
zephir_time(_4);
ZEPHIR_SINIT_VAR(_5);
ZVAL_STRING(&_5, "%04x", 0);
ZEPHIR_SINIT_VAR(_6);
ZVAL_LONG(&_6, (zephir_get_intval(_4) & 0xffff));
ZEPHIR_CALL_FUNCTION(&_7, "sprintf", NULL, 1, &_5, &_6);
zephir_check_call_status();
ZEPHIR_CONCAT_VV(return_value, _3, _7);
RETURN_MM();
}
PHP_METHOD(ZFrame_Request, __construct) {
zval *_SERVER, *_0, *_1, *_2, *_3;
ZEPHIR_MM_GROW();
zephir_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC);
zephir_array_fetch_string(&_0, _SERVER, SL("REQUEST_URI"), PH_NOISY | PH_READONLY, "zframe/request.zep", 15 TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_uri"), _0 TSRMLS_CC);
zephir_array_fetch_string(&_1, _SERVER, SL("SERVER_NAME"), PH_NOISY | PH_READONLY, "zframe/request.zep", 16 TSRMLS_CC);
zephir_array_fetch_string(&_2, _SERVER, SL("REQUEST_URI"), PH_NOISY | PH_READONLY, "zframe/request.zep", 16 TSRMLS_CC);
ZEPHIR_INIT_VAR(_3);
ZEPHIR_CONCAT_VV(_3, _1, _2);
zephir_update_property_this(this_ptr, SL("_fullUrl"), _3 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Xpl_HtmlElement, appendElement) {
zval *content_param = NULL, *_0, *_1;
zval *content = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &content_param);
zephir_get_strval(content, content_param);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_appendString"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_VV(_1, content, _0);
zephir_update_property_this(this_ptr, SL("_appendString"), _1 TSRMLS_CC);
RETURN_THIS();
}
/**
* Appends a string to the HTTP response body
*
* @param string content
* @return \Phalcon\Http\Response
*/
PHP_METHOD(Phalcon_Http_Response, appendContent) {
int ZEPHIR_LAST_CALL_STATUS;
zval *content, *_0 = NULL, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &content);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "getcontent", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_VV(_1, _0, content);
zephir_update_property_this(this_ptr, SL("_content"), _1 TSRMLS_CC);
RETURN_THIS();
}
/**
* Returns a cached content
*/
PHP_METHOD(Phalcon_Cache_Backend_Libmemcached, get) {
zend_long lifetime, ZEPHIR_LAST_CALL_STATUS;
zval *keyName_param = NULL, *lifetime_param = NULL, *memcache = NULL, *prefixedKey = NULL, *cachedContent = NULL, *_0, *_1$$6;
zval *keyName = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &keyName_param, &lifetime_param);
zephir_get_strval(keyName, keyName_param);
if (!lifetime_param) {
lifetime = 0;
} else {
lifetime = zephir_get_intval(lifetime_param);
}
ZEPHIR_OBS_VAR(memcache);
zephir_read_property_this(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC);
if (Z_TYPE_P(memcache) != IS_OBJECT) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_connect", NULL, 0);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(memcache);
zephir_read_property_this(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(prefixedKey);
ZEPHIR_CONCAT_VV(prefixedKey, _0, keyName);
zephir_update_property_this(getThis(), SL("_lastKey"), prefixedKey TSRMLS_CC);
ZEPHIR_CALL_METHOD(&cachedContent, memcache, "get", NULL, 0, prefixedKey);
zephir_check_call_status();
if (!(zephir_is_true(cachedContent))) {
RETURN_MM_NULL();
}
if (zephir_is_numeric(cachedContent)) {
RETURN_CCTOR(cachedContent);
} else {
_1$$6 = zephir_fetch_nproperty_this(this_ptr, SL("_frontend"), PH_NOISY_CC);
ZEPHIR_RETURN_CALL_METHOD(_1$$6, "afterretrieve", NULL, 0, cachedContent);
zephir_check_call_status();
RETURN_MM();
}
}
/**
* 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 string
*/
PHP_METHOD(Phalcon_Logger_Formatter_Json, format) {
zval *_2;
int type, timestamp, ZEPHIR_LAST_CALL_STATUS;
zval *message_param = NULL, *type_param = NULL, *timestamp_param = NULL, *context = NULL, *_0$$3 = NULL, *_1, *_3 = NULL, *_4 = NULL;
zval *message = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 1, &message_param, &type_param, ×tamp_param, &context);
zephir_get_strval(message, message_param);
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_get_strval(message, _0$$3);
}
ZEPHIR_INIT_VAR(_1);
ZEPHIR_INIT_VAR(_2);
zephir_create_array(_2, 3, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_4);
ZVAL_LONG(_4, type);
ZEPHIR_CALL_METHOD(&_3, this_ptr, "gettypestring", NULL, 0, _4);
zephir_check_call_status();
zephir_array_update_string(&_2, SL("type"), &_3, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_2, SL("message"), &message, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_4);
ZVAL_LONG(_4, timestamp);
zephir_array_update_string(&_2, SL("timestamp"), &_4, PH_COPY | PH_SEPARATE);
zephir_json_encode(_1, &(_1), _2, 0 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_4);
ZEPHIR_GET_CONSTANT(_4, "PHP_EOL");
ZEPHIR_CONCAT_VV(return_value, _1, _4);
RETURN_MM();
}
/**
* Generates a local path
*/
PHP_METHOD(Phalcon_Mvc_Url, path) {
zval *path_param = NULL, *_0;
zval *path = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &path_param);
if (!path_param) {
ZEPHIR_INIT_VAR(path);
ZVAL_EMPTY_STRING(path);
} else {
zephir_get_strval(path, path_param);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_basePath"), PH_NOISY_CC);
ZEPHIR_CONCAT_VV(return_value, _0, path);
RETURN_MM();
}
/**
* Returns a cached content
*
* @param int|string keyName
* @param long lifetime
* @return mixed
*/
PHP_METHOD(Phalcon_Cache_Backend_Memcache, get) {
int ZEPHIR_LAST_CALL_STATUS;
zval *keyName, *lifetime = NULL, *memcache = NULL, *prefixedKey, *cachedContent = NULL, *retrieve = NULL, *_0, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &keyName, &lifetime);
if (!lifetime) {
lifetime = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_OBS_VAR(memcache);
zephir_read_property_this(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC);
if (Z_TYPE_P(memcache) != IS_OBJECT) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_connect", NULL, 0);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(memcache);
zephir_read_property_this(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(prefixedKey);
ZEPHIR_CONCAT_VV(prefixedKey, _0, keyName);
zephir_update_property_this(this_ptr, SL("_lastKey"), prefixedKey TSRMLS_CC);
ZEPHIR_CALL_METHOD(&cachedContent, memcache, "get", NULL, 0, prefixedKey);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(cachedContent)) {
RETURN_MM_NULL();
}
if (zephir_is_numeric(cachedContent)) {
RETURN_CCTOR(cachedContent);
}
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_frontend"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&retrieve, _1, "afterretrieve", NULL, 0, cachedContent);
zephir_check_call_status();
RETURN_CCTOR(retrieve);
}
/**
* Writes the log to the file itself
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, logInternal) {
zval *context = NULL;
int type, time, ZEPHIR_LAST_CALL_STATUS;
zval *message_param = NULL, *type_param = NULL, *time_param = NULL, *context_param = NULL, *fileHandler, *_0 = NULL, *_1 = NULL, *_2 = NULL, *_3, *_4;
zval *message = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &message_param, &type_param, &time_param, &context_param);
zephir_get_strval(message, message_param);
type = zephir_get_intval(type_param);
time = zephir_get_intval(time_param);
zephir_get_arrval(context, context_param);
ZEPHIR_OBS_VAR(fileHandler);
zephir_read_property_this(&fileHandler, this_ptr, SL("_fileHandler"), PH_NOISY_CC);
if (Z_TYPE_P(fileHandler) != IS_RESOURCE) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_logger_exception_ce, "Cannot send message to the log because it is invalid", "phalcon/logger/adapter/file.zep", 117);
return;
}
ZEPHIR_CALL_METHOD(&_0, this_ptr, "getformatter", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_2);
ZVAL_LONG(_2, type);
ZEPHIR_INIT_VAR(_3);
ZVAL_LONG(_3, time);
ZEPHIR_CALL_METHOD(&_1, _0, "format", NULL, 0, message, _2, _3, context);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_2);
ZEPHIR_GET_CONSTANT(_2, "PHP_EOL");
ZEPHIR_INIT_VAR(_4);
ZEPHIR_CONCAT_VV(_4, _1, _2);
zephir_fwrite(NULL, fileHandler, _4 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Returns the complete location where the resource must be written
*/
PHP_METHOD(Phalcon_Assets_Resource, getRealTargetPath) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *basePath_param = NULL, *targetPath = NULL, *completePath = NULL, *_0;
zval *basePath = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &basePath_param);
if (!basePath_param) {
ZEPHIR_INIT_VAR(basePath);
ZVAL_EMPTY_STRING(basePath);
} else {
zephir_get_strval(basePath, basePath_param);
}
ZEPHIR_OBS_VAR(targetPath);
zephir_read_property_this(&targetPath, this_ptr, SL("_targetPath"), PH_NOISY_CC);
if (ZEPHIR_IS_EMPTY(targetPath)) {
ZEPHIR_OBS_NVAR(targetPath);
zephir_read_property_this(&targetPath, this_ptr, SL("_path"), PH_NOISY_CC);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_local"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
ZEPHIR_INIT_VAR(completePath);
ZEPHIR_CONCAT_VV(completePath, basePath, targetPath);
if ((zephir_file_exists(completePath TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_FUNCTION("realpath", NULL, 67, completePath);
zephir_check_call_status();
RETURN_MM();
}
RETURN_CCTOR(completePath);
}
RETURN_CCTOR(targetPath);
}
/**
* 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();
}
/**
* 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();
}
/**
* Stores cached content into the file backend and stops the frontend
*
* <code>
* $cache->save("my-key", $data);
*
* // Save data termlessly
* $cache->save("my-key", $data, -1);
* </code>
*
* @param int|string keyName
* @param string content
* @param int lifetime
* @param boolean stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_Redis, save) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zend_bool stopBuffer;
zval *keyName = NULL, *content = NULL, *lifetime = NULL, *stopBuffer_param = NULL, *prefixedKey = NULL, *lastKey = NULL, *frontend = NULL, *redis = NULL, *cachedContent = NULL, *preparedContent = NULL, *tmp = NULL, *tt1 = NULL, *success = NULL, *options = NULL, *specialKey = NULL, *isBuffering = NULL, _0$$3, *_1$$4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 4, &keyName, &content, &lifetime, &stopBuffer_param);
if (!keyName) {
keyName = ZEPHIR_GLOBAL(global_null);
}
if (!content) {
content = ZEPHIR_GLOBAL(global_null);
}
if (!lifetime) {
lifetime = ZEPHIR_GLOBAL(global_null);
}
if (!stopBuffer_param) {
stopBuffer = 1;
} else {
stopBuffer = zephir_get_boolval(stopBuffer_param);
}
if (Z_TYPE_P(keyName) == IS_NULL) {
ZEPHIR_OBS_VAR(lastKey);
zephir_read_property_this(&lastKey, this_ptr, SL("_lastKey"), PH_NOISY_CC);
ZEPHIR_SINIT_VAR(_0$$3);
ZVAL_LONG(&_0$$3, 5);
ZEPHIR_INIT_VAR(prefixedKey);
zephir_substr(prefixedKey, lastKey, 5 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
} else {
_1$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(prefixedKey);
ZEPHIR_CONCAT_VV(prefixedKey, _1$$4, keyName);
ZEPHIR_INIT_NVAR(lastKey);
ZEPHIR_CONCAT_SV(lastKey, "_PHCR", prefixedKey);
zephir_update_property_this(getThis(), SL("_lastKey"), lastKey TSRMLS_CC);
}
if (!(zephir_is_true(lastKey))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "The cache must be started first", "phalcon/cache/backend/redis.zep", 212);
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, 0);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(redis);
zephir_read_property_this(&redis, this_ptr, SL("_redis"), PH_NOISY_CC);
}
if (Z_TYPE_P(content) == IS_NULL) {
ZEPHIR_CALL_METHOD(&cachedContent, frontend, "getcontent", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(cachedContent, content);
}
if (!(zephir_is_numeric(cachedContent))) {
ZEPHIR_CALL_METHOD(&preparedContent, frontend, "beforestore", NULL, 0, cachedContent);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(preparedContent, cachedContent);
}
if (Z_TYPE_P(lifetime) == IS_NULL) {
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, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(tt1, tmp);
}
} else {
ZEPHIR_CPY_WRT(tt1, lifetime);
}
ZEPHIR_CALL_METHOD(&success, redis, "set", NULL, 0, lastKey, preparedContent);
zephir_check_call_status();
if (!(zephir_is_true(success))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Failed storing the data in redis", "phalcon/cache/backend/redis.zep", 256);
return;
}
if (ZEPHIR_GE_LONG(tt1, 1)) {
ZEPHIR_CALL_METHOD(NULL, redis, "settimeout", NULL, 0, lastKey, tt1);
zephir_check_call_status();
}
ZEPHIR_OBS_VAR(options);
zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(specialKey);
if (!(zephir_array_isset_string_fetch(&specialKey, options, SS("statsKey"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/redis.zep", 267);
return;
}
if (!ZEPHIR_IS_STRING(specialKey, "")) {
ZEPHIR_CALL_METHOD(NULL, redis, "sadd", NULL, 0, specialKey, prefixedKey);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&isBuffering, frontend, "isbuffering", NULL, 0);
zephir_check_call_status();
if (stopBuffer == 1) {
ZEPHIR_CALL_METHOD(NULL, frontend, "stop", NULL, 0);
zephir_check_call_status();
}
if (ZEPHIR_IS_TRUE_IDENTICAL(isBuffering)) {
zend_print_zval(cachedContent, 0);
}
if (0) {
zephir_update_property_this(getThis(), SL("_started"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(getThis(), SL("_started"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
RETURN_CCTOR(success);
}
/**
* 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_Libmemcached, save) {
int ZEPHIR_LAST_CALL_STATUS;
zend_bool stopBuffer;
zval *keyName = NULL, *content = NULL, *lifetime = NULL, *stopBuffer_param = NULL, *lastKey = NULL, *frontend = NULL, *memcache = NULL, *cachedContent = NULL, *preparedContent = NULL, *tmp = NULL, *tt1 = NULL, *success = NULL, *options = NULL, *specialKey = NULL, *keys = NULL, *isBuffering = NULL, *_0$$4, *_1$$16, *_2$$16 = NULL, *_3$$16;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 4, &keyName, &content, &lifetime, &stopBuffer_param);
if (!keyName) {
keyName = ZEPHIR_GLOBAL(global_null);
}
if (!content) {
content = ZEPHIR_GLOBAL(global_null);
}
if (!lifetime) {
lifetime = ZEPHIR_GLOBAL(global_null);
}
if (!stopBuffer_param) {
stopBuffer = 1;
} else {
stopBuffer = zephir_get_boolval(stopBuffer_param);
}
if (!(zephir_is_true(keyName))) {
ZEPHIR_OBS_VAR(lastKey);
zephir_read_property_this(&lastKey, this_ptr, SL("_lastKey"), PH_NOISY_CC);
} else {
_0$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(lastKey);
ZEPHIR_CONCAT_VV(lastKey, _0$$4, keyName);
}
if (!(zephir_is_true(lastKey))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cache must be started first", "phalcon/cache/backend/libmemcached.zep", 192);
return;
}
ZEPHIR_OBS_VAR(frontend);
zephir_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(memcache);
zephir_read_property_this(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC);
if (Z_TYPE_P(memcache) != IS_OBJECT) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_connect", NULL, 0);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(memcache);
zephir_read_property_this(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC);
}
if (!(zephir_is_true(content))) {
ZEPHIR_CALL_METHOD(&cachedContent, frontend, "getcontent", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(cachedContent, content);
}
if (!(zephir_is_numeric(cachedContent))) {
ZEPHIR_CALL_METHOD(&preparedContent, frontend, "beforestore", NULL, 0, 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, 0);
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, memcache, "set", NULL, 0, lastKey, cachedContent, tt1);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(&success, memcache, "set", NULL, 0, lastKey, preparedContent, tt1);
zephir_check_call_status();
}
if (!(zephir_is_true(success))) {
ZEPHIR_INIT_VAR(_1$$16);
object_init_ex(_1$$16, phalcon_cache_exception_ce);
ZEPHIR_CALL_METHOD(&_2$$16, memcache, "getresultcode", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_3$$16);
ZEPHIR_CONCAT_SV(_3$$16, "Failed storing data in memcached, error code: ", _2$$16);
ZEPHIR_CALL_METHOD(NULL, _1$$16, "__construct", NULL, 9, _3$$16);
zephir_check_call_status();
zephir_throw_exception_debug(_1$$16, "phalcon/cache/backend/libmemcached.zep", 238 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_OBS_VAR(options);
zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(specialKey);
if (!(zephir_array_isset_string_fetch(&specialKey, options, SS("statsKey"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/libmemcached.zep", 244);
return;
}
if (!ZEPHIR_IS_STRING(specialKey, "")) {
ZEPHIR_CALL_METHOD(&keys, memcache, "get", NULL, 0, specialKey);
zephir_check_call_status();
if (Z_TYPE_P(keys) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(keys);
array_init(keys);
}
if (!(zephir_array_isset(keys, lastKey))) {
zephir_array_update_zval(&keys, lastKey, &tt1, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, memcache, "set", NULL, 0, specialKey, keys);
zephir_check_call_status();
}
}
ZEPHIR_CALL_METHOD(&isBuffering, frontend, "isbuffering", NULL, 0);
zephir_check_call_status();
if (stopBuffer == 1) {
ZEPHIR_CALL_METHOD(NULL, frontend, "stop", NULL, 0);
zephir_check_call_status();
}
if (ZEPHIR_IS_TRUE_IDENTICAL(isBuffering)) {
zend_print_zval(cachedContent, 0);
}
if (0) {
zephir_update_property_this(this_ptr, SL("_started"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_started"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
ZEPHIR_MM_RESTORE();
}