/**
* Checks if the needle is included in the haystack
*/
PHP_METHOD(Phalcon_Mvc_View_Engine_Volt, isIncluded) {
int ZEPHIR_LAST_CALL_STATUS;
zval *needle, *haystack, *_0 = NULL, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &needle, &haystack);
if (Z_TYPE_P(haystack) == IS_ARRAY) {
RETURN_MM_BOOL(zephir_fast_in_array(needle, haystack TSRMLS_CC));
}
if (Z_TYPE_P(haystack) == IS_STRING) {
if ((zephir_function_exists_ex(SS("mb_strpos") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_FUNCTION(&_0, "mb_strpos", NULL, 375, haystack, needle);
zephir_check_call_status();
RETURN_MM_BOOL(!ZEPHIR_IS_FALSE_IDENTICAL(_0));
}
ZEPHIR_INIT_VAR(_1);
zephir_fast_strpos(_1, haystack, needle, 0 );
RETURN_MM_BOOL(!ZEPHIR_IS_FALSE_IDENTICAL(_1));
}
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_view_exception_ce, "Invalid haystack", "phalcon/mvc/view/engine/volt.zep", 166);
return;
}
/**
* Gets number of rows returned by a resultset
*
*<code>
* $result = $connection->query("SELECT * FROM robots ORDER BY name");
* echo 'There are ', $result->numRows(), ' rows in the resultset';
*</code>
*/
PHP_METHOD(Phalcon_Db_Result_Pdo, numRows) {
zend_bool _0$$3;
zval *sqlStatement = NULL, *rowCount = NULL, *connection = NULL, *type = NULL, *pdoStatement = NULL, *matches = NULL, *result = NULL, *row = NULL, *_1$$6, _2$$6, *_3$$7, *_4$$7, *_5$$7, *_6$$7;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(rowCount);
zephir_read_property_this(&rowCount, this_ptr, SL("_rowCount"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(rowCount)) {
ZEPHIR_OBS_VAR(connection);
zephir_read_property_this(&connection, this_ptr, SL("_connection"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&type, connection, "gettype", NULL, 0);
zephir_check_call_status();
_0$$3 = ZEPHIR_IS_STRING(type, "mysql");
if (!(_0$$3)) {
_0$$3 = ZEPHIR_IS_STRING(type, "pgsql");
}
if (_0$$3) {
ZEPHIR_OBS_VAR(pdoStatement);
zephir_read_property_this(&pdoStatement, this_ptr, SL("_pdoStatement"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&rowCount, pdoStatement, "rowcount", NULL, 0);
zephir_check_call_status();
}
if (ZEPHIR_IS_FALSE_IDENTICAL(rowCount)) {
ZEPHIR_OBS_VAR(sqlStatement);
zephir_read_property_this(&sqlStatement, this_ptr, SL("_sqlStatement"), PH_NOISY_CC);
if (!(zephir_start_with_str(sqlStatement, SL("SELECT COUNT(*) ")))) {
ZEPHIR_INIT_VAR(matches);
ZVAL_NULL(matches);
ZEPHIR_INIT_VAR(_1$$6);
ZEPHIR_SINIT_VAR(_2$$6);
ZVAL_STRING(&_2$$6, "/^SELECT\\s+(.*)/i", 0);
zephir_preg_match(_1$$6, &_2$$6, sqlStatement, matches, 0, 0 , 0 TSRMLS_CC);
if (zephir_is_true(_1$$6)) {
zephir_array_fetch_long(&_3$$7, matches, 1, PH_NOISY | PH_READONLY, "phalcon/db/result/pdo.zep", 217 TSRMLS_CC);
ZEPHIR_INIT_VAR(_4$$7);
ZEPHIR_CONCAT_SVS(_4$$7, "SELECT COUNT(*) \"numrows\" FROM (SELECT ", _3$$7, ")");
_5$$7 = zephir_fetch_nproperty_this(this_ptr, SL("_bindParams"), PH_NOISY_CC);
_6$$7 = zephir_fetch_nproperty_this(this_ptr, SL("_bindTypes"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&result, connection, "query", NULL, 0, _4$$7, _5$$7, _6$$7);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&row, result, "fetch", NULL, 0);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(rowCount);
zephir_array_fetch_string(&rowCount, row, SL("numrows"), PH_NOISY, "phalcon/db/result/pdo.zep", 219 TSRMLS_CC);
}
} else {
ZEPHIR_INIT_NVAR(rowCount);
ZVAL_LONG(rowCount, 1);
}
}
zephir_update_property_this(this_ptr, SL("_rowCount"), rowCount TSRMLS_CC);
}
RETURN_CCTOR(rowCount);
}
PHP_METHOD(Owl_Router_Router, add) {
int ZEPHIR_LAST_CALL_STATUS;
zend_bool _2;
zval *parameters = NULL;
zval *uri_param = NULL, *parameters_param = NULL, *method_param = NULL, *route, _0, *_1, _3, *_4;
zval *uri = NULL, *method = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &uri_param, ¶meters_param, &method_param);
zephir_get_strval(uri, uri_param);
if (!parameters_param) {
ZEPHIR_INIT_VAR(parameters);
array_init(parameters);
} else {
parameters = parameters_param;
}
if (!method_param) {
ZEPHIR_INIT_VAR(method);
ZVAL_STRING(method, "GET", 1);
} else {
zephir_get_strval(method, method_param);
}
ZEPHIR_SINIT_VAR(_0);
ZVAL_STRING(&_0, "{", 0);
ZEPHIR_INIT_VAR(_1);
zephir_fast_strpos(_1, uri, &_0, 0 );
_2 = ZEPHIR_IS_FALSE_IDENTICAL(_1);
if (_2) {
ZEPHIR_SINIT_VAR(_3);
ZVAL_STRING(&_3, ":", 0);
ZEPHIR_INIT_VAR(_4);
zephir_fast_strpos(_4, uri, &_3, 0 );
_2 = ZEPHIR_IS_FALSE_IDENTICAL(_4);
}
ZEPHIR_INIT_VAR(route);
if (_2) {
object_init_ex(route, owl_router_http_staticroute_ce);
ZEPHIR_CALL_METHOD(NULL, route, "__construct", NULL, 27, uri);
zephir_check_call_status();
} else {
object_init_ex(route, owl_router_http_dynamicroute_ce);
ZEPHIR_CALL_METHOD(NULL, route, "__construct", NULL, 28, uri);
zephir_check_call_status();
}
zephir_update_property_zval(route, SL("method"), method TSRMLS_CC);
zephir_update_property_zval(route, SL("parameters"), parameters TSRMLS_CC);
zephir_update_property_array_append(this_ptr, SL("routers"), route TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Destroys the session bag
*
*<code>
* $user->destroy();
*</code>
*/
PHP_METHOD(Phalcon_Session_Bag, destroy) {
zval _0, _1, _2, _3;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *this_ptr = getThis();
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZVAL_UNDEF(&_2);
ZVAL_UNDEF(&_3);
ZEPHIR_MM_GROW();
zephir_read_property(&_0, this_ptr, SL("_initialized"), PH_NOISY_CC | PH_READONLY);
if (ZEPHIR_IS_FALSE_IDENTICAL(&_0)) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "initialize", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_INIT_VAR(&_1);
array_init(&_1);
zephir_update_property_zval(this_ptr, SL("_data"), &_1);
zephir_read_property(&_2, this_ptr, SL("_session"), PH_NOISY_CC | PH_READONLY);
zephir_read_property(&_3, this_ptr, SL("_name"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_CALL_METHOD(NULL, &_2, "remove", NULL, 0, &_3);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Check whether a property is defined in the internal bag
*
*<code>
* var_dump(
* $user->has("name")
* );
*</code>
*/
PHP_METHOD(Phalcon_Session_Bag, has) {
int ZEPHIR_LAST_CALL_STATUS;
zval *property_param = NULL, *_0, *_1;
zval *property = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &property_param);
if (unlikely(Z_TYPE_P(property_param) != IS_STRING && Z_TYPE_P(property_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'property' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(property_param) == IS_STRING)) {
zephir_get_strval(property, property_param);
} else {
ZEPHIR_INIT_VAR(property);
ZVAL_EMPTY_STRING(property);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_initialized"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "initialize", NULL, 0);
zephir_check_call_status();
}
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_data"), PH_NOISY_CC);
RETURN_MM_BOOL(zephir_array_isset(_1, property));
}
/**
* Sets a value in the session bag
*
*<code>
* $user->set("name", "Kimbra");
*</code>
*/
PHP_METHOD(Phalcon_Session_Bag, set) {
int ZEPHIR_LAST_CALL_STATUS;
zval *property_param = NULL, *value, *_0, *_1, *_2, *_3;
zval *property = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &property_param, &value);
if (unlikely(Z_TYPE_P(property_param) != IS_STRING && Z_TYPE_P(property_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'property' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(property_param) == IS_STRING)) {
zephir_get_strval(property, property_param);
} else {
ZEPHIR_INIT_VAR(property);
ZVAL_EMPTY_STRING(property);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_initialized"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "initialize", NULL, 0);
zephir_check_call_status();
}
zephir_update_property_array(this_ptr, SL("_data"), property, value TSRMLS_CC);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_session"), PH_NOISY_CC);
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_name"), PH_NOISY_CC);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_data"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, _1, "set", NULL, 0, _2, _3);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Returns a cached content
*/
PHP_METHOD(Phalcon_Cache_Backend_Apcu, get) {
zend_long lifetime, ZEPHIR_LAST_CALL_STATUS;
zval *keyName_param = NULL, *lifetime_param = NULL, *prefixedKey = NULL, *cachedContent = NULL, *_0, *_1;
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);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(prefixedKey);
ZEPHIR_CONCAT_SVV(prefixedKey, "_PHCA", _0, keyName);
zephir_update_property_this(getThis(), SL("_lastKey"), prefixedKey TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&cachedContent, "apcu_fetch", NULL, 92, prefixedKey);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(cachedContent)) {
RETURN_MM_NULL();
}
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_frontend"), PH_NOISY_CC);
ZEPHIR_RETURN_CALL_METHOD(_1, "afterretrieve", NULL, 0, cachedContent);
zephir_check_call_status();
RETURN_MM();
}
/**
* Removes an attribute from the element.
*
* @param string name
* @param mixed value [Optional]
* @return \Xpl\HtmlElement
*/
PHP_METHOD(Xpl_HtmlElement, removeAttribute) {
int ZEPHIR_LAST_CALL_STATUS;
zval *name_param = NULL, *value = NULL, *attributeValues = NULL, *_0, *_1$$4, *valueKey$$5 = NULL;
zval *name = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &name_param, &value);
zephir_get_strval(name, name_param);
if (!value) {
value = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_OBS_VAR(attributeValues);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_attributes"), PH_NOISY_CC);
if (zephir_array_isset_fetch(&attributeValues, _0, name, 0 TSRMLS_CC)) {
if (Z_TYPE_P(value) == IS_NULL) {
_1$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_attributes"), PH_NOISY_CC);
zephir_array_unset(&_1$$4, name, PH_SEPARATE);
} else {
ZEPHIR_CALL_FUNCTION(&valueKey$$5, "array_search", NULL, 67, value, attributeValues, ZEPHIR_GLOBAL(global_true));
zephir_check_call_status();
if (!ZEPHIR_IS_FALSE_IDENTICAL(valueKey$$5)) {
zephir_array_unset(&attributeValues, valueKey$$5, PH_SEPARATE);
zephir_update_property_array(this_ptr, SL("_attributes"), name, attributeValues TSRMLS_CC);
}
}
}
RETURN_THIS();
}
/**
* Triggers an event.
*
* @param \Xpl\Event\Event|string event Event object or ID.
* @param ... Arguments to pass to callback.
* @return array Items returned from event listeners.
*/
PHP_METHOD(Xpl_Event_Manager, trigger) {
int ZEPHIR_LAST_CALL_STATUS;
zval *event, *prepared = NULL, *eventObj = NULL, *listeners = NULL, *args = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &event);
ZEPHIR_CALL_METHOD(&prepared, this_ptr, "prepare", NULL, 0, event);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(prepared)) {
array_init(return_value);
RETURN_MM();
}
ZEPHIR_OBS_VAR(eventObj);
zephir_array_fetch_long(&eventObj, prepared, 0, PH_NOISY, "xpl/event/manager.zep", 181 TSRMLS_CC);
ZEPHIR_OBS_VAR(listeners);
zephir_array_fetch_long(&listeners, prepared, 1, PH_NOISY, "xpl/event/manager.zep", 182 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&args, "func_get_args", NULL, 98);
zephir_check_call_status();
ZEPHIR_MAKE_REF(args);
ZEPHIR_CALL_FUNCTION(NULL, "array_shift", NULL, 103, args);
ZEPHIR_UNREF(args);
zephir_check_call_status();
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "execute", NULL, 0, eventObj, listeners, args);
zephir_check_call_status();
RETURN_MM();
}
/**
* Triggers an event with an array of arguments.
*
* @param \Xpl\Event\Event|string event Event object or ID.
* @param array args Args to pass to listeners.
* @return array Items returned from event Listeners.
*/
PHP_METHOD(Xpl_Event_Manager, triggerArray) {
int ZEPHIR_LAST_CALL_STATUS;
zval *args = NULL;
zval *event, *args_param = NULL, *prepared = NULL, *eventObj = NULL, *listeners = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &event, &args_param);
if (!args_param) {
ZEPHIR_INIT_VAR(args);
array_init(args);
} else {
zephir_get_arrval(args, args_param);
}
ZEPHIR_CALL_METHOD(&prepared, this_ptr, "prepare", NULL, 0, event);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(prepared)) {
array_init(return_value);
RETURN_MM();
}
ZEPHIR_OBS_VAR(eventObj);
zephir_array_fetch_long(&eventObj, prepared, 0, PH_NOISY, "xpl/event/manager.zep", 213 TSRMLS_CC);
ZEPHIR_OBS_VAR(listeners);
zephir_array_fetch_long(&listeners, prepared, 1, PH_NOISY, "xpl/event/manager.zep", 214 TSRMLS_CC);
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "execute", NULL, 0, eventObj, listeners, args);
zephir_check_call_status();
RETURN_MM();
}
/**
* Get first row in the resultset
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, getFirst) {
zephir_nts_static zephir_fcall_cache_entry *_1 = NULL, *_2 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *_0, *_3 = NULL;
ZEPHIR_MM_GROW();
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_pointer"), PH_NOISY_CC);
if (ZEPHIR_IS_LONG(_0, 0)) {
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "current", &_1);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_CALL_METHOD(NULL, this_ptr, "rewind", &_2);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_3, this_ptr, "valid", NULL);
zephir_check_call_status();
if (!ZEPHIR_IS_FALSE_IDENTICAL(_3)) {
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "current", &_1);
zephir_check_call_status();
RETURN_MM();
}
RETURN_MM_BOOL(0);
}
/**
* Check whether a property is defined in the internal bag
*
*<code>
* var_dump(
* $user->has("name")
* );
*</code>
*/
PHP_METHOD(Phalcon_Session_Bag, has) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *property_param = NULL, _0, _1;
zval property;
zval *this_ptr = getThis();
ZVAL_UNDEF(&property);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &property_param);
if (UNEXPECTED(Z_TYPE_P(property_param) != IS_STRING && Z_TYPE_P(property_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'property' must be of the type string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(property_param) == IS_STRING)) {
zephir_get_strval(&property, property_param);
} else {
ZEPHIR_INIT_VAR(&property);
ZVAL_EMPTY_STRING(&property);
}
zephir_read_property(&_0, this_ptr, SL("_initialized"), PH_NOISY_CC | PH_READONLY);
if (ZEPHIR_IS_FALSE_IDENTICAL(&_0)) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "initialize", NULL, 0);
zephir_check_call_status();
}
zephir_read_property(&_1, this_ptr, SL("_data"), PH_NOISY_CC | PH_READONLY);
RETURN_MM_BOOL(zephir_array_isset(&_1, &property));
}
/**
* Dispatches a handle action taking into account the routing parameters
*
* @return object
*/
PHP_METHOD(Phalcon_Dispatcher, dispatch) {
zval *handler = NULL, *e = NULL, *_0$$4 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
/* try_start_1: */
ZEPHIR_CALL_METHOD(&handler, this_ptr, "_dispatch", NULL, 0);
zephir_check_call_status_or_jump(try_end_1);
try_end_1:
if (EG(exception)) {
ZEPHIR_CPY_WRT(e, EG(exception));
if (zephir_instance_of_ev(e, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) {
zend_clear_exception(TSRMLS_C);
ZEPHIR_CALL_METHOD(&_0$$4, this_ptr, "_handleexception", NULL, 0, e);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_0$$4)) {
RETURN_MM_BOOL(0);
}
zephir_throw_exception_debug(e, "phalcon/dispatcher.zep", 348 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
RETURN_CCTOR(handler);
}
/**
* Handles a user exception
*/
PHP_METHOD(Phalcon_Mvc_Dispatcher, _handleException) {
int ZEPHIR_LAST_CALL_STATUS;
zval *exception, *eventsManager = NULL, *_0, *_1 = NULL, *_2;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &exception);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(eventsManager, _0);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_2);
ZVAL_STRING(_2, "dispatch:beforeException", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_1, eventsManager, "fire", NULL, 0, _2, this_ptr, exception);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_1)) {
RETURN_MM_BOOL(0);
}
}
ZEPHIR_MM_RESTORE();
}
/**
* Throws an internal exception
*/
PHP_METHOD(Phalcon_Cli_Dispatcher, _throwDispatchException) {
int exceptionCode, ZEPHIR_LAST_CALL_STATUS;
zval *message_param = NULL, *exceptionCode_param = NULL, *exception, *_0, *_1 = NULL;
zval *message = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &message_param, &exceptionCode_param);
zephir_get_strval(message, message_param);
if (!exceptionCode_param) {
exceptionCode = 0;
} else {
exceptionCode = zephir_get_intval(exceptionCode_param);
}
ZEPHIR_INIT_VAR(exception);
object_init_ex(exception, phalcon_cli_dispatcher_exception_ce);
ZEPHIR_INIT_VAR(_0);
ZVAL_LONG(_0, exceptionCode);
ZEPHIR_CALL_METHOD(NULL, exception, "__construct", NULL, 9, message, _0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_1, this_ptr, "_handleexception", NULL, 0, exception);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_1)) {
RETURN_MM_BOOL(0);
}
zephir_throw_exception_debug(exception, "phalcon/cli/dispatcher.zep", 116 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
/**
* Load translates from file
*
* @param string file
* @param int length
* @param string delimiter
* @param string enclosure
*/
PHP_METHOD(Phalcon_Translate_Adapter_Csv, _load) {
zend_bool _6;
zephir_fcall_cache_entry *_3 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *file, *length, *delimiter, *enclosure, *data = NULL, *fileHandler = NULL, _0 = zval_used_for_init, *_1 = NULL, *_2, *_4, _5 = zval_used_for_init, *_7, *_8 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &file, &length, &delimiter, &enclosure);
ZEPHIR_SINIT_VAR(_0);
ZVAL_STRING(&_0, "rb", 0);
ZEPHIR_CALL_FUNCTION(&fileHandler, "fopen", NULL, 292, file, &_0);
zephir_check_call_status();
if (Z_TYPE_P(fileHandler) != IS_RESOURCE) {
ZEPHIR_INIT_VAR(_1);
object_init_ex(_1, phalcon_translate_exception_ce);
ZEPHIR_INIT_VAR(_2);
ZEPHIR_CONCAT_SVS(_2, "Error opening translation file '", file, "'");
ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 9, _2);
zephir_check_call_status();
zephir_throw_exception_debug(_1, "phalcon/translate/adapter/csv.zep", 64 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
while (1) {
ZEPHIR_CALL_FUNCTION(&data, "fgetcsv", &_3, 428, fileHandler, length, delimiter, enclosure);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(data)) {
break;
}
zephir_array_fetch_long(&_4, data, 0, PH_NOISY | PH_READONLY, "phalcon/translate/adapter/csv.zep", 74 TSRMLS_CC);
ZEPHIR_SINIT_NVAR(_0);
ZVAL_LONG(&_0, 0);
ZEPHIR_SINIT_NVAR(_5);
ZVAL_LONG(&_5, 1);
ZEPHIR_INIT_NVAR(_1);
zephir_substr(_1, _4, 0 , 1 , 0);
_6 = ZEPHIR_IS_STRING_IDENTICAL(_1, "#");
if (!(_6)) {
_6 = !(zephir_array_isset_long(data, 1));
}
if (_6) {
continue;
}
zephir_array_fetch_long(&_7, data, 1, PH_NOISY | PH_READONLY, "phalcon/translate/adapter/csv.zep", 78 TSRMLS_CC);
ZEPHIR_OBS_NVAR(_8);
zephir_array_fetch_long(&_8, data, 0, PH_NOISY, "phalcon/translate/adapter/csv.zep", 78 TSRMLS_CC);
zephir_update_property_array(this_ptr, SL("_translate"), _8, _7 TSRMLS_CC);
}
zephir_fclose(fileHandler TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* 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);
}
/**
* Parses or retrieves all the annotations found in a class
*
* @param string|object className
* @return Phalcon\Annotations\Reflection
*/
PHP_METHOD(Phalcon_Annotations_Adapter, get) {
zephir_nts_static zephir_fcall_cache_entry *_2 = NULL;
zend_bool _1;
int ZEPHIR_LAST_CALL_STATUS;
zval *className, *annotations, *classAnnotations = NULL, *parsedAnnotations = NULL, *realClassName = NULL, *reader = NULL, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &className);
if (Z_TYPE_P(className) == IS_OBJECT) {
ZEPHIR_INIT_VAR(realClassName);
zephir_get_class(realClassName, className, 0 TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(realClassName, className);
}
ZEPHIR_OBS_VAR(annotations);
zephir_read_property_this(&annotations, this_ptr, SL("_annotations"), PH_NOISY_CC);
if (Z_TYPE_P(annotations) == IS_ARRAY) {
if (zephir_array_isset(annotations, realClassName)) {
zephir_array_fetch(&_0, annotations, realClassName, PH_NOISY | PH_READONLY, "phalcon/annotations/adapter.zep", 91 TSRMLS_CC);
RETURN_CTOR(_0);
}
}
ZEPHIR_CALL_METHOD(&classAnnotations, this_ptr, "read", NULL, realClassName);
zephir_check_call_status();
_1 = Z_TYPE_P(classAnnotations) == IS_NULL;
if (!(_1)) {
_1 = ZEPHIR_IS_FALSE_IDENTICAL(classAnnotations);
}
if (_1) {
ZEPHIR_CALL_METHOD(&reader, this_ptr, "getreader", NULL);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&parsedAnnotations, reader, "parse", NULL, realClassName);
zephir_check_call_status();
if (Z_TYPE_P(parsedAnnotations) == IS_ARRAY) {
ZEPHIR_INIT_NVAR(classAnnotations);
object_init_ex(classAnnotations, phalcon_annotations_reflection_ce);
ZEPHIR_CALL_METHOD(NULL, classAnnotations, "__construct", &_2, parsedAnnotations);
zephir_check_call_status();
zephir_update_property_array(this_ptr, SL("_annotations"), realClassName, classAnnotations TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "write", NULL, realClassName, classAnnotations);
zephir_check_call_status();
}
}
RETURN_CCTOR(classAnnotations);
}
/**
* Build multidimensional array from string
*
* <code>
* $this->_parseIniString('path.hello.world', 'value for last key');
*
* // result
* [
* 'path' => [
* 'hello' => [
* 'world' => 'value for last key',
* ],
* ],
* ];
* </code>
*/
PHP_METHOD(Phalcon_Config_Adapter_Ini, _parseIniString) {
int ZEPHIR_LAST_CALL_STATUS;
zval *path_param = NULL, *value = NULL, *pos = NULL, *key = NULL, *_0 = NULL, _1, _2, _3, *_4;
zval *path = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &path_param, &value);
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_SEPARATE_PARAM(value);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "_cast", NULL, 135, value);
zephir_check_call_status();
ZEPHIR_CPY_WRT(value, _0);
ZEPHIR_SINIT_VAR(_1);
ZVAL_STRING(&_1, ".", 0);
ZEPHIR_INIT_VAR(pos);
zephir_fast_strpos(pos, path, &_1, 0 );
if (ZEPHIR_IS_FALSE_IDENTICAL(pos)) {
zephir_create_array(return_value, 1, 0 TSRMLS_CC);
zephir_array_update_zval(&return_value, path, &value, PH_COPY);
RETURN_MM();
}
ZEPHIR_SINIT_VAR(_2);
ZVAL_LONG(&_2, 0);
ZEPHIR_INIT_VAR(key);
zephir_substr(key, path, 0 , zephir_get_intval(pos), 0);
ZEPHIR_SINIT_VAR(_3);
ZVAL_LONG(&_3, (zephir_get_numberval(pos) + 1));
ZEPHIR_INIT_VAR(_4);
zephir_substr(_4, path, zephir_get_intval(&_3), 0, ZEPHIR_SUBSTR_NO_LENGTH);
zephir_get_strval(path, _4);
zephir_create_array(return_value, 1, 0 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "_parseinistring", NULL, 136, path, value);
zephir_check_call_status();
zephir_array_update_zval(&return_value, key, &_0, PH_COPY);
RETURN_MM();
}
/**
* Return length of bag
*
*<code>
* echo $user->count();
*</code>
*/
PHP_METHOD(Phalcon_Session_Bag, count) {
zval *_0, *_1;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_initialized"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "initialize", NULL, 0);
zephir_check_call_status();
}
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_data"), PH_NOISY_CC);
RETURN_MM_LONG(zephir_fast_count_int(_1 TSRMLS_CC));
}
/**
* Reads the latest status from the Beanstalkd server
*/
PHP_METHOD(Phalcon_Queue_Beanstalk, readStatus) {
zval *status = NULL;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_CALL_METHOD(&status, this_ptr, "read", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(status)) {
array_init(return_value);
RETURN_MM();
}
zephir_fast_explode_str(return_value, SL(" "), status, LONG_MAX TSRMLS_CC);
RETURN_MM();
}
/**
* Rewinds resultset to its beginning
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, rewind) {
zephir_nts_static zephir_fcall_cache_entry *_3 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *rows = NULL, *result = NULL, *_0, *_1, *_2;
ZEPHIR_MM_GROW();
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_type"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
ZEPHIR_OBS_VAR(result);
zephir_read_property_this(&result, this_ptr, SL("_result"), PH_NOISY_CC);
if (!ZEPHIR_IS_FALSE_IDENTICAL(result)) {
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_activeRow"), PH_NOISY_CC);
if (Z_TYPE_P(_1) != IS_NULL) {
ZEPHIR_INIT_VAR(_2);
ZVAL_LONG(_2, 0);
ZEPHIR_CALL_METHOD(NULL, result, "dataseek", NULL, _2);
zephir_check_call_status();
}
}
} else {
ZEPHIR_OBS_VAR(rows);
zephir_read_property_this(&rows, this_ptr, SL("_rows"), PH_NOISY_CC);
if (Z_TYPE_P(rows) == IS_NULL) {
ZEPHIR_OBS_NVAR(result);
zephir_read_property_this(&result, this_ptr, SL("_result"), PH_NOISY_CC);
if (Z_TYPE_P(result) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&rows, result, "fetchall", NULL);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_rows"), rows TSRMLS_CC);
}
}
if (Z_TYPE_P(rows) == IS_ARRAY) {
Z_SET_ISREF_P(rows);
ZEPHIR_CALL_FUNCTION(NULL, "reset", &_3, rows);
Z_UNSET_ISREF_P(rows);
zephir_check_call_status();
}
}
ZEPHIR_INIT_ZVAL_NREF(_1);
ZVAL_LONG(_1, 0);
zephir_update_property_this(this_ptr, SL("_pointer"), _1 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Returns a cached content
*/
PHP_METHOD(Phalcon_Cache_Backend_Redis, get) {
zend_long lifetime, ZEPHIR_LAST_CALL_STATUS;
zval *keyName_param = NULL, *lifetime_param = NULL, *redis = NULL, *frontend = NULL, *prefix = NULL, *lastKey = NULL, *cachedContent = 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_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);
}
ZEPHIR_OBS_VAR(frontend);
zephir_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(prefix);
zephir_read_property_this(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(lastKey);
ZEPHIR_CONCAT_SVV(lastKey, "_PHCR", prefix, keyName);
zephir_update_property_this(getThis(), SL("_lastKey"), lastKey TSRMLS_CC);
ZEPHIR_CALL_METHOD(&cachedContent, redis, "get", NULL, 0, lastKey);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(cachedContent)) {
RETURN_MM_NULL();
}
if (zephir_is_numeric(cachedContent)) {
RETURN_CCTOR(cachedContent);
}
ZEPHIR_RETURN_CALL_METHOD(frontend, "afterretrieve", NULL, 0, cachedContent);
zephir_check_call_status();
RETURN_MM();
}
/**
* 验证日期时间格式。
* -- 1、验证value是否为format格式。
* -- 2、只能验证格式，不能验证时间是否正确。比如：2014-22-22
* @param string format 格式。格式如：Y-m-d 或H:i:s
* @param string value 日期。
* @return boolean
*/
PHP_METHOD(Winer_Validator, is_date_format) {
int ZEPHIR_LAST_CALL_STATUS;
zval *format_param = NULL, *value_param = NULL, *_0 = NULL;
zval *format = NULL, *value = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &format_param, &value_param);
zephir_get_strval(format, format_param);
zephir_get_strval(value, value_param);
ZEPHIR_CALL_FUNCTION(&_0, "date_create_from_format", NULL, format, value);
zephir_check_call_status();
RETURN_MM_BOOL(!ZEPHIR_IS_FALSE_IDENTICAL(_0));
}
/**
* Returns the bag iterator
*/
PHP_METHOD(Phalcon_Session_Bag, getIterator) {
zval *_0, *_1;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_initialized"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "initialize", NULL, 0);
zephir_check_call_status();
}
object_init_ex(return_value, zephir_get_internal_ce(SS("arrayiterator") TSRMLS_CC));
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_data"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 437, _1);
zephir_check_call_status();
RETURN_MM();
}
PHP_METHOD(Cake_Core_Functions, pluginSplit) {
zend_bool dotAppend;
zval *name_param = NULL, *dotAppend_param = NULL, *plugin_param = NULL, _0, *_1, *parts, *_2;
zval *name = NULL, *plugin = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &name_param, &dotAppend_param, &plugin_param);
zephir_get_strval(name, name_param);
if (!dotAppend_param) {
dotAppend = 0;
} else {
dotAppend = zephir_get_boolval(dotAppend_param);
}
if (!plugin_param) {
ZEPHIR_INIT_VAR(plugin);
ZVAL_EMPTY_STRING(plugin);
} else {
zephir_get_strval(plugin, plugin_param);
}
ZEPHIR_SINIT_VAR(_0);
ZVAL_STRING(&_0, ".", 0);
ZEPHIR_INIT_VAR(_1);
zephir_fast_strpos(_1, name, &_0, 0 );
if (!ZEPHIR_IS_FALSE_IDENTICAL(_1)) {
ZEPHIR_INIT_VAR(parts);
zephir_fast_explode_str(parts, SL("."), name, 2 TSRMLS_CC);
if (dotAppend) {
ZEPHIR_INIT_VAR(_2);
ZVAL_STRING(_2, ".", 1);
zephir_array_update_long(&parts, 0, &_2, PH_COPY | PH_SEPARATE, "cake/Core/Functions.zep", 12);
}
RETURN_CCTOR(parts);
}
zephir_create_array(return_value, 2, 0 TSRMLS_CC);
zephir_array_fast_append(return_value, plugin);
zephir_array_fast_append(return_value, name);
RETURN_MM();
}
/**
* Gets row in a specific position of the resultset
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, offsetGet) {
zephir_nts_static zephir_fcall_cache_entry *_1 = NULL, *_3 = NULL, *_5 = NULL;
zval *index_param = NULL, *_0 = NULL, *_2, _4, *_6 = NULL;
int index, ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &index_param);
if (unlikely(Z_TYPE_P(index_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'index' must be a long/integer") TSRMLS_CC);
RETURN_MM_NULL();
}
index = Z_LVAL_P(index_param);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "count", &_1);
zephir_check_call_status();
if (ZEPHIR_GT_LONG(_0, index)) {
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_pointer"), PH_NOISY_CC);
if (ZEPHIR_IS_LONG(_2, index)) {
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "current", &_3);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_SINIT_VAR(_4);
ZVAL_LONG(&_4, index);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "seek", &_5, &_4);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_6, this_ptr, "valid", NULL);
zephir_check_call_status();
if (!ZEPHIR_IS_FALSE_IDENTICAL(_6)) {
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "current", &_3);
zephir_check_call_status();
RETURN_MM();
}
RETURN_MM_BOOL(0);
}
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "The index does not exist in the cursor", "phalcon/mvc/model/resultset.zep", 272);
return;
}
/**
* Destroyes the session bag
*
*<code>
* $user->destroy();
*</code>
*/
PHP_METHOD(Phalcon_Session_Bag, destroy) {
int ZEPHIR_LAST_CALL_STATUS;
zval *_0, *_1, *_2;
ZEPHIR_MM_GROW();
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_initalized"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "initialize", NULL);
zephir_check_call_status();
}
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_session"), PH_NOISY_CC);
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_name"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, _1, "remove", NULL, _2);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* 判断email格式是否正确。
* @param string email
* @return bool
*/
PHP_METHOD(Winer_Validator, is_email) {
int ZEPHIR_LAST_CALL_STATUS;
zval *email_param = NULL, _0, *_1 = NULL;
zval *email = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &email_param);
zephir_get_strval(email, email_param);
ZEPHIR_SINIT_VAR(_0);
ZVAL_LONG(&_0, 274);
ZEPHIR_CALL_FUNCTION(&_1, "filter_var", NULL, email, &_0);
zephir_check_call_status();
RETURN_MM_BOOL(!ZEPHIR_IS_FALSE_IDENTICAL(_1));
}
/**
* Returns a cached content
*/
PHP_METHOD(Phalcon_Cache_Backend_Memcache, get) {
int lifetime, ZEPHIR_LAST_CALL_STATUS;
zval *keyName_param = NULL, *lifetime_param = NULL, *memcache = NULL, *prefixedKey = NULL, *cachedContent = NULL, *retrieve = NULL, *_0, *_1;
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(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);
}
