/**
* Commits the active transaction in the connection
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, commit) {
int transactionLevel, ZEPHIR_LAST_CALL_STATUS;
zval *nesting_param = NULL, *pdo, *eventsManager = NULL, *savepointName = NULL, *_0, *_1, *_2 = NULL, *_5 = NULL;
zend_bool nesting, _3, _4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &nesting_param);
if (!nesting_param) {
nesting = 1;
} else {
nesting = zephir_get_boolval(nesting_param);
}
ZEPHIR_OBS_VAR(pdo);
zephir_read_property_this(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC);
if (Z_TYPE_P(pdo) != IS_OBJECT) {
RETURN_MM_BOOL(0);
}
ZEPHIR_OBS_VAR(_0);
zephir_read_property_this(&_0, this_ptr, SL("_transactionLevel"), PH_NOISY_CC);
transactionLevel = zephir_get_intval(_0);
if (!(transactionLevel)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "There is no active transaction", "phalcon/db/adapter/pdo.zep", 615);
return;
}
if (transactionLevel == 1) {
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(eventsManager, _1);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_2);
ZVAL_STRING(_2, "db:commitTransaction", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _2, this_ptr);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
}
RETURN_ON_FAILURE(zephir_property_decr(this_ptr, SL("_transactionLevel") TSRMLS_CC));
ZEPHIR_RETURN_CALL_METHOD(pdo, "commit", NULL, 0);
zephir_check_call_status();
RETURN_MM();
} else {
_3 = (transactionLevel) ? 1 : 0;
if (_3) {
_3 = nesting;
}
_4 = _3;
if (_4) {
ZEPHIR_CALL_METHOD(&_5, this_ptr, "isnestedtransactionswithsavepoints", NULL, 0);
zephir_check_call_status();
_4 = zephir_is_true(_5);
}
if (_4) {
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(eventsManager, _1);
ZEPHIR_CALL_METHOD(&savepointName, this_ptr, "getnestedtransactionsavepointname", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "db:releaseSavepoint", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _2, this_ptr, savepointName);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
}
RETURN_ON_FAILURE(zephir_property_decr(this_ptr, SL("_transactionLevel") TSRMLS_CC));
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "releasesavepoint", NULL, 0, savepointName);
zephir_check_call_status();
RETURN_MM();
}
}
if (transactionLevel > 0) {
RETURN_ON_FAILURE(zephir_property_decr(this_ptr, SL("_transactionLevel") TSRMLS_CC));
}
RETURN_MM_BOOL(0);
}
/**
* Outputs a message formatting it with HTML
*
*<code>
* $flash->outputMessage('error', message);
*</code>
*
* @param string|array message
* @return string|void
*/
PHP_METHOD(Phalcon_Flash, outputMessage) {
HashTable *_3$$8;
HashPosition _2$$8;
zend_bool automaticHtml = 0, implicitFlush = 0;
zval *type_param = NULL, *message, *content = NULL, *cssClasses = NULL, *classes = NULL, *typeClasses = NULL, *eol = NULL, *msg = NULL, *htmlMessage = NULL, *_0 = NULL, *_1$$5, **_4$$8;
zval *type = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &type_param, &message);
zephir_get_strval(type, type_param);
ZEPHIR_OBS_VAR(_0);
zephir_read_property_this(&_0, this_ptr, SL("_automaticHtml"), PH_NOISY_CC);
automaticHtml = zephir_get_boolval(_0);
if (automaticHtml == 1) {
ZEPHIR_OBS_VAR(classes);
zephir_read_property_this(&classes, this_ptr, SL("_cssClasses"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(typeClasses);
if (zephir_array_isset_fetch(&typeClasses, classes, type, 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(cssClasses);
if (Z_TYPE_P(typeClasses) == IS_ARRAY) {
ZEPHIR_INIT_VAR(_1$$5);
zephir_fast_join_str(_1$$5, SL(" "), typeClasses TSRMLS_CC);
ZEPHIR_CONCAT_SVS(cssClasses, " class=\"", _1$$5, "\"");
} else {
ZEPHIR_CONCAT_SVS(cssClasses, " class=\"", typeClasses, "\"");
}
} else {
ZEPHIR_INIT_NVAR(cssClasses);
ZVAL_STRING(cssClasses, "", 1);
}
ZEPHIR_INIT_VAR(eol);
ZEPHIR_GET_CONSTANT(eol, "PHP_EOL");
}
ZEPHIR_OBS_NVAR(_0);
zephir_read_property_this(&_0, this_ptr, SL("_implicitFlush"), PH_NOISY_CC);
implicitFlush = zephir_get_boolval(_0);
if (Z_TYPE_P(message) == IS_ARRAY) {
if (implicitFlush == 0) {
ZEPHIR_INIT_VAR(content);
ZVAL_STRING(content, "", 1);
}
zephir_is_iterable(message, &_3$$8, &_2$$8, 0, 0, "phalcon/flash.zep", 204);
for (
; zephir_hash_get_current_data_ex(_3$$8, (void**) &_4$$8, &_2$$8) == SUCCESS
; zephir_hash_move_forward_ex(_3$$8, &_2$$8)
) {
ZEPHIR_GET_HVALUE(msg, _4$$8);
if (automaticHtml == 1) {
ZEPHIR_INIT_NVAR(htmlMessage);
ZEPHIR_CONCAT_SVSVSV(htmlMessage, "<div", cssClasses, ">", msg, "</div>", eol);
} else {
ZEPHIR_CPY_WRT(htmlMessage, msg);
}
if (implicitFlush == 1) {
zend_print_zval(htmlMessage, 0);
} else {
zephir_concat_self(&content, htmlMessage TSRMLS_CC);
zephir_update_property_array_append(this_ptr, SL("_messages"), htmlMessage TSRMLS_CC);
}
}
if (implicitFlush == 0) {
RETURN_CCTOR(content);
}
} else {
if (automaticHtml == 1) {
ZEPHIR_INIT_NVAR(htmlMessage);
ZEPHIR_CONCAT_SVSVSV(htmlMessage, "<div", cssClasses, ">", message, "</div>", eol);
} else {
ZEPHIR_CPY_WRT(htmlMessage, message);
}
if (implicitFlush == 1) {
zend_print_zval(htmlMessage, 0);
} else {
zephir_update_property_array_append(this_ptr, SL("_messages"), htmlMessage TSRMLS_CC);
RETURN_CCTOR(htmlMessage);
}
}
ZEPHIR_MM_RESTORE();
}
/**
* Magic method to get or set services using setters/getters
*/
PHP_METHOD(Phalcon_Di, __call) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_2 = NULL, *_3 = NULL;
zval *method_param = NULL, *arguments = NULL, *instance = NULL, *possibleService = NULL, *services = NULL, *definition = NULL, *_7, _0$$3, *_1$$3, _4$$8, *_5$$8, *_6$$8 = NULL;
zval *method = NULL, *_8;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &method_param, &arguments);
if (unlikely(Z_TYPE_P(method_param) != IS_STRING && Z_TYPE_P(method_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'method' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(method_param) == IS_STRING)) {
zephir_get_strval(method, method_param);
} else {
ZEPHIR_INIT_VAR(method);
ZVAL_EMPTY_STRING(method);
}
if (!arguments) {
arguments = ZEPHIR_GLOBAL(global_null);
}
if (zephir_start_with_str(method, SL("get"))) {
ZEPHIR_OBS_VAR(services);
zephir_read_property_this(&services, this_ptr, SL("_services"), PH_NOISY_CC);
ZEPHIR_SINIT_VAR(_0$$3);
ZVAL_LONG(&_0$$3, 3);
ZEPHIR_INIT_VAR(_1$$3);
zephir_substr(_1$$3, method, 3 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
ZEPHIR_CALL_FUNCTION(&possibleService, "lcfirst", &_2, 68, _1$$3);
zephir_check_call_status();
if (zephir_array_isset(services, possibleService)) {
if (zephir_fast_count_int(arguments TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(&instance, this_ptr, "get", &_3, 0, possibleService, arguments);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(&instance, this_ptr, "get", &_3, 0, possibleService);
zephir_check_call_status();
}
RETURN_CCTOR(instance);
}
}
if (zephir_start_with_str(method, SL("set"))) {
ZEPHIR_OBS_VAR(definition);
if (zephir_array_isset_long_fetch(&definition, arguments, 0, 0 TSRMLS_CC)) {
ZEPHIR_SINIT_VAR(_4$$8);
ZVAL_LONG(&_4$$8, 3);
ZEPHIR_INIT_VAR(_5$$8);
zephir_substr(_5$$8, method, 3 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
ZEPHIR_CALL_FUNCTION(&_6$$8, "lcfirst", &_2, 68, _5$$8);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, this_ptr, "set", NULL, 0, _6$$8, definition);
zephir_check_call_status();
RETURN_MM_NULL();
}
}
ZEPHIR_INIT_VAR(_7);
object_init_ex(_7, phalcon_di_exception_ce);
ZEPHIR_INIT_VAR(_8);
ZEPHIR_CONCAT_SVS(_8, "Call to undefined method or service '", method, "'");
ZEPHIR_CALL_METHOD(NULL, _7, "__construct", NULL, 9, _8);
zephir_check_call_status();
zephir_throw_exception_debug(_7, "phalcon/di.zep", 406 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
/**
* Changes internal pointer to a specific position in the resultset
* Set new position if required and set this->_row
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, seek) {
zend_bool _1, _7$$3;
zephir_fcall_cache_entry *_16 = NULL;
zval *position_param = NULL, *result = NULL, *row = NULL, *_0, *_2, *_3$$3, *_6$$3, *_8$$3, *_10$$3, *_14$$3, *_17$$3, *_4$$4, *_5$$4, *_9$$6 = NULL, *_11$$7, *_12$$7 = NULL, *_13$$7, *_15$$8 = NULL;
int position, ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &position_param);
position = zephir_get_intval(position_param);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_pointer"), PH_NOISY_CC);
_1 = !ZEPHIR_IS_LONG(_0, position);
if (!(_1)) {
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_row"), PH_NOISY_CC);
_1 = Z_TYPE_P(_2) == IS_NULL;
}
if (_1) {
ZEPHIR_OBS_VAR(_3$$3);
zephir_read_property_this(&_3$$3, this_ptr, SL("_rows"), PH_NOISY_CC);
if (Z_TYPE_P(_3$$3) == IS_ARRAY) {
ZEPHIR_OBS_VAR(row);
_4$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_rows"), PH_NOISY_CC);
if (zephir_array_isset_long_fetch(&row, _4$$4, position, 0 TSRMLS_CC)) {
zephir_update_property_this(this_ptr, SL("_row"), row TSRMLS_CC);
}
ZEPHIR_INIT_ZVAL_NREF(_5$$4);
ZVAL_LONG(_5$$4, position);
zephir_update_property_this(this_ptr, SL("_pointer"), _5$$4 TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_activeRow"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
RETURN_MM_NULL();
}
ZEPHIR_OBS_VAR(result);
zephir_read_property_this(&result, this_ptr, SL("_result"), PH_NOISY_CC);
_6$$3 = zephir_fetch_nproperty_this(this_ptr, SL("_row"), PH_NOISY_CC);
_7$$3 = Z_TYPE_P(_6$$3) == IS_NULL;
if (_7$$3) {
_8$$3 = zephir_fetch_nproperty_this(this_ptr, SL("_pointer"), PH_NOISY_CC);
_7$$3 = ZEPHIR_IS_LONG_IDENTICAL(_8$$3, 0);
}
if (_7$$3) {
ZEPHIR_CALL_METHOD(&_9$$6, result, "fetch", NULL, 0);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_row"), _9$$6 TSRMLS_CC);
}
_10$$3 = zephir_fetch_nproperty_this(this_ptr, SL("_pointer"), PH_NOISY_CC);
if (ZEPHIR_GT_LONG(_10$$3, position)) {
ZEPHIR_INIT_VAR(_11$$7);
ZVAL_LONG(_11$$7, position);
ZEPHIR_CALL_METHOD(NULL, result, "dataseek", NULL, 0, _11$$7);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_12$$7, result, "fetch", NULL, 0);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_row"), _12$$7 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_13$$7);
ZVAL_LONG(_13$$7, position);
zephir_update_property_this(this_ptr, SL("_pointer"), _13$$7 TSRMLS_CC);
}
while (1) {
_14$$3 = zephir_fetch_nproperty_this(this_ptr, SL("_pointer"), PH_NOISY_CC);
if (!(ZEPHIR_LT_LONG(_14$$3, position))) {
break;
}
ZEPHIR_CALL_METHOD(&_15$$8, result, "fetch", &_16, 0);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_row"), _15$$8 TSRMLS_CC);
RETURN_ON_FAILURE(zephir_property_incr(this_ptr, SL("_pointer") TSRMLS_CC));
}
ZEPHIR_INIT_ZVAL_NREF(_17$$3);
ZVAL_LONG(_17$$3, position);
zephir_update_property_this(this_ptr, SL("_pointer"), _17$$3 TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_activeRow"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
}
ZEPHIR_MM_RESTORE();
}
/**
* Stores cached content into the APCu backend and stops the frontend
*
* @param string|int keyName
* @param string content
* @param int lifetime
* @param boolean stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_Apcu, save) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zend_bool stopBuffer;
zval *keyName = NULL, *content = NULL, *lifetime = NULL, *stopBuffer_param = NULL, *lastKey = NULL, *frontend = NULL, *cachedContent = NULL, *preparedContent = NULL, *ttl = NULL, *isBuffering = NULL, *success = NULL, *_0$$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) {
ZEPHIR_CPY_WRT(lifetime, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(lifetime);
}
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);
} else {
_0$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(lastKey);
ZEPHIR_CONCAT_SVV(lastKey, "_PHCA", _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/apcu.zep", 95);
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, 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_NVAR(lifetime);
zephir_read_property_this(&lifetime, this_ptr, SL("_lastLifetime"), PH_NOISY_CC);
if (Z_TYPE_P(lifetime) == IS_NULL) {
ZEPHIR_CALL_METHOD(&ttl, frontend, "getlifetime", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(ttl, lifetime);
zephir_update_property_this(getThis(), SL("_lastKey"), lastKey TSRMLS_CC);
}
} else {
ZEPHIR_CPY_WRT(ttl, lifetime);
}
ZEPHIR_CALL_FUNCTION(&success, "apcu_store", NULL, 93, lastKey, preparedContent, ttl);
zephir_check_call_status();
if (!(zephir_is_true(success))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Failed storing data in APCu", "phalcon/cache/backend/apcu.zep", 132);
return;
}
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);
}
/**
* Phalcon\Mvc\Model\MetaData\Redis constructor
*
* @param array options
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Redis, __construct) {
zval *_6;
int ZEPHIR_LAST_CALL_STATUS;
zval *options = NULL, *ttl = NULL, *_4, *_5, *_7, *_8, *_0$$4, *_1$$5, *_2$$6, *_3$$7;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &options);
if (!options) {
ZEPHIR_CPY_WRT(options, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(options);
}
if (Z_TYPE_P(options) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(options);
array_init(options);
}
if (!(zephir_array_isset_string(options, SS("host")))) {
ZEPHIR_INIT_VAR(_0$$4);
ZVAL_STRING(_0$$4, "127.0.0.1", 1);
zephir_array_update_string(&options, SL("host"), &_0$$4, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("port")))) {
ZEPHIR_INIT_VAR(_1$$5);
ZVAL_LONG(_1$$5, 6379);
zephir_array_update_string(&options, SL("port"), &_1$$5, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("persistent")))) {
ZEPHIR_INIT_VAR(_2$$6);
ZVAL_LONG(_2$$6, 0);
zephir_array_update_string(&options, SL("persistent"), &_2$$6, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("statsKey")))) {
ZEPHIR_INIT_VAR(_3$$7);
ZVAL_STRING(_3$$7, "_PHCM_MM", 1);
zephir_array_update_string(&options, SL("statsKey"), &_3$$7, PH_COPY | PH_SEPARATE);
}
if (zephir_array_isset_string_fetch(&ttl, options, SS("lifetime"), 1 TSRMLS_CC)) {
zephir_update_property_this(this_ptr, SL("_ttl"), ttl TSRMLS_CC);
}
ZEPHIR_INIT_VAR(_4);
object_init_ex(_4, phalcon_cache_backend_redis_ce);
ZEPHIR_INIT_VAR(_5);
object_init_ex(_5, phalcon_cache_frontend_data_ce);
ZEPHIR_INIT_VAR(_6);
zephir_create_array(_6, 1, 0 TSRMLS_CC);
ZEPHIR_OBS_VAR(_7);
zephir_read_property_this(&_7, this_ptr, SL("_ttl"), PH_NOISY_CC);
zephir_array_update_string(&_6, SL("lifetime"), &_7, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, _5, "__construct", NULL, 313, _6);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, _4, "__construct", NULL, 317, _5, options);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_redis"), _4 TSRMLS_CC);
ZEPHIR_INIT_VAR(_8);
array_init(_8);
zephir_update_property_this(this_ptr, SL("_metaData"), _8 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Phalcon\Mvc\Model\MetaData\Memcache constructor
*
* @param array options
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Memcache, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zval *_2;
zval *options = NULL, *ttl, *_0 = NULL, *_1, *_3, *_4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &options);
if (!options) {
ZEPHIR_CPY_WRT(options, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(options);
}
if (Z_TYPE_P(options) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(options);
array_init(options);
}
if (!(zephir_array_isset_string(options, SS("host")))) {
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "127.0.0.1", 1);
zephir_array_update_string(&options, SL("host"), &_0, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("port")))) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_LONG(_0, 11211);
zephir_array_update_string(&options, SL("port"), &_0, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("persistent")))) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_LONG(_0, 0);
zephir_array_update_string(&options, SL("persistent"), &_0, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("statsKey")))) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "_PHCM_MM", 1);
zephir_array_update_string(&options, SL("statsKey"), &_0, PH_COPY | PH_SEPARATE);
}
if (zephir_array_isset_string_fetch(&ttl, options, SS("lifetime"), 1 TSRMLS_CC)) {
zephir_update_property_this(this_ptr, SL("_ttl"), ttl TSRMLS_CC);
}
ZEPHIR_INIT_NVAR(_0);
object_init_ex(_0, phalcon_cache_backend_memcache_ce);
ZEPHIR_INIT_VAR(_1);
object_init_ex(_1, phalcon_cache_frontend_data_ce);
ZEPHIR_INIT_VAR(_2);
zephir_create_array(_2, 1, 0 TSRMLS_CC);
ZEPHIR_OBS_VAR(_3);
zephir_read_property_this(&_3, this_ptr, SL("_ttl"), PH_NOISY_CC);
zephir_array_update_string(&_2, SL("lifetime"), &_3, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 312, _2);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 315, _1, options);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_memcache"), _0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_4);
array_init(_4);
zephir_update_property_this(this_ptr, SL("_metaData"), _4 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php
*
* @return array
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, _loadTemplateEngines) {
zephir_fcall_cache_entry *_4 = NULL, *_6 = NULL;
HashTable *_2;
HashPosition _1;
int ZEPHIR_LAST_CALL_STATUS;
zval *engines = NULL, *dependencyInjector, *registeredEngines, *arguments, *extension = NULL, *engineService = NULL, *engineObject = NULL, *_0 = NULL, **_3, *_5 = NULL;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(engines);
zephir_read_property_this(&engines, this_ptr, SL("_engines"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(engines)) {
ZEPHIR_OBS_VAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(engines);
array_init(engines);
ZEPHIR_OBS_VAR(registeredEngines);
zephir_read_property_this(®isteredEngines, this_ptr, SL("_registeredEngines"), PH_NOISY_CC);
if (Z_TYPE_P(registeredEngines) != IS_ARRAY) {
ZEPHIR_INIT_VAR(_0);
object_init_ex(_0, phalcon_mvc_view_engine_php_ce);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 370, this_ptr, dependencyInjector);
zephir_check_call_status();
zephir_array_update_string(&engines, SL(".phtml"), &_0, PH_COPY | PH_SEPARATE);
} else {
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_view_exception_ce, "A dependency injector container is required to obtain the application services", "phalcon/mvc/view/simple.zep", 139);
return;
}
ZEPHIR_INIT_VAR(arguments);
zephir_create_array(arguments, 2, 0 TSRMLS_CC);
zephir_array_fast_append(arguments, this_ptr);
zephir_array_fast_append(arguments, dependencyInjector);
zephir_is_iterable(registeredEngines, &_2, &_1, 0, 0, "phalcon/mvc/view/simple.zep", 171);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HMKEY(extension, _2, _1);
ZEPHIR_GET_HVALUE(engineService, _3);
if (Z_TYPE_P(engineService) == IS_OBJECT) {
if (zephir_instance_of_ev(engineService, zend_ce_closure TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(engineObject);
ZEPHIR_CALL_USER_FUNC_ARRAY(engineObject, engineService, arguments);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(engineObject, engineService);
}
} else {
if (Z_TYPE_P(engineService) == IS_STRING) {
ZEPHIR_CALL_METHOD(&engineObject, dependencyInjector, "getshared", &_4, 0, engineService, arguments);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(_0);
object_init_ex(_0, phalcon_mvc_view_exception_ce);
ZEPHIR_INIT_LNVAR(_5);
ZEPHIR_CONCAT_SV(_5, "Invalid template engine registration for extension: ", extension);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", &_6, 9, _5);
zephir_check_call_status();
zephir_throw_exception_debug(_0, "phalcon/mvc/view/simple.zep", 165 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
zephir_array_update_zval(&engines, extension, &engineObject, PH_COPY | PH_SEPARATE);
}
}
zephir_update_property_this(this_ptr, SL("_engines"), engines TSRMLS_CC);
} else {
ZEPHIR_OBS_NVAR(engines);
zephir_read_property_this(&engines, this_ptr, SL("_engines"), PH_NOISY_CC);
}
RETURN_CCTOR(engines);
}
/**
* Tries to render the view with every engine registered in the component
*
* @param string path
* @param array params
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, _internalRender) {
zephir_fcall_cache_entry *_11 = NULL, *_12 = NULL;
HashTable *_4;
HashPosition _3;
int ZEPHIR_LAST_CALL_STATUS;
zend_bool notExists, mustClean, _7, _9;
zval *path_param = NULL, *params, *eventsManager, *engines = NULL, *extension = NULL, *engine = NULL, *viewEnginePath = NULL, *viewsDirPath, *_0 = NULL, *_1 = NULL, *_2, **_5, *_6 = NULL, _8 = zval_used_for_init, *_10 = NULL;
zval *path = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &path_param, ¶ms);
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_OBS_VAR(eventsManager);
zephir_read_property_this(&eventsManager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
zephir_update_property_this(this_ptr, SL("_activeRenderPath"), path TSRMLS_CC);
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "view:beforeRender", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0, eventsManager, "fire", NULL, 0, _1, this_ptr);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
RETURN_MM_NULL();
}
}
notExists = 1;
mustClean = 1;
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_viewsDir"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(viewsDirPath);
ZEPHIR_CONCAT_VV(viewsDirPath, _2, path);
ZEPHIR_CALL_METHOD(&engines, this_ptr, "_loadtemplateengines", NULL, 0);
zephir_check_call_status();
zephir_is_iterable(engines, &_4, &_3, 0, 0, "phalcon/mvc/view/simple.zep", 261);
for (
; zephir_hash_get_current_data_ex(_4, (void**) &_5, &_3) == SUCCESS
; zephir_hash_move_forward_ex(_4, &_3)
) {
ZEPHIR_GET_HMKEY(extension, _4, _3);
ZEPHIR_GET_HVALUE(engine, _5);
ZEPHIR_INIT_LNVAR(_6);
ZEPHIR_CONCAT_VV(_6, viewsDirPath, extension);
if ((zephir_file_exists(_6 TSRMLS_CC) == SUCCESS)) {
ZEPHIR_INIT_NVAR(viewEnginePath);
ZEPHIR_CONCAT_VV(viewEnginePath, viewsDirPath, extension);
} else {
_7 = zephir_is_true(extension);
if (_7) {
ZEPHIR_SINIT_NVAR(_8);
ZVAL_LONG(&_8, -zephir_fast_strlen_ev(extension));
ZEPHIR_INIT_NVAR(_1);
zephir_substr(_1, viewsDirPath, zephir_get_intval(&_8), 0, ZEPHIR_SUBSTR_NO_LENGTH);
_7 = ZEPHIR_IS_EQUAL(_1, extension);
}
_9 = _7;
if (_9) {
_9 = (zephir_file_exists(viewsDirPath TSRMLS_CC) == SUCCESS);
}
if (_9) {
ZEPHIR_CPY_WRT(viewEnginePath, viewsDirPath);
} else {
ZEPHIR_INIT_NVAR(viewEnginePath);
ZVAL_STRING(viewEnginePath, "", 1);
}
}
if (zephir_is_true(viewEnginePath)) {
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_10);
ZVAL_STRING(_10, "view:beforeRenderView", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0, eventsManager, "fire", &_11, 0, _10, this_ptr, viewEnginePath);
zephir_check_temp_parameter(_10);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
continue;
}
}
ZEPHIR_CALL_METHOD(NULL, engine, "render", NULL, 0, viewEnginePath, params, (mustClean ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false)));
zephir_check_call_status();
notExists = 0;
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_10);
ZVAL_STRING(_10, "view:afterRenderView", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", &_12, 0, _10, this_ptr);
zephir_check_temp_parameter(_10);
zephir_check_call_status();
}
break;
}
}
if (notExists == 1) {
ZEPHIR_INIT_NVAR(_1);
object_init_ex(_1, phalcon_mvc_view_exception_ce);
ZEPHIR_INIT_LNVAR(_6);
ZEPHIR_CONCAT_SVS(_6, "View '", viewsDirPath, "' was not found in the views directory");
ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 9, _6);
zephir_check_call_status();
zephir_throw_exception_debug(_1, "phalcon/mvc/view/simple.zep", 262 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "view:afterRender", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _1, this_ptr);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
}
ZEPHIR_MM_RESTORE();
}
/**
* Returns a complete resultset as an array, if the resultset has a big number of rows
* it could consume more memory than currently it does. Export the resultset to an array
* couldn't be faster with a large number of records
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, toArray) {
HashTable *_2$$7, *_5$$8;
HashPosition _1$$7, _4$$8;
zephir_fcall_cache_entry *_9 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *renameColumns_param = NULL, *result = NULL, *records = NULL, *record = NULL, *renamed = NULL, *renamedKey = NULL, *key = NULL, *value = NULL, *renamedRecords = NULL, *columnMap = NULL, *_0$$3, **_3$$7, **_6$$8, *_7$$10 = NULL, *_8$$10 = NULL, *_10$$12 = NULL, *_11$$12 = NULL;
zend_bool renameColumns;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &renameColumns_param);
if (!renameColumns_param) {
renameColumns = 1;
} else {
renameColumns = zephir_get_boolval(renameColumns_param);
}
ZEPHIR_OBS_VAR(records);
zephir_read_property_this(&records, this_ptr, SL("_rows"), PH_NOISY_CC);
if (Z_TYPE_P(records) != IS_ARRAY) {
ZEPHIR_OBS_VAR(result);
zephir_read_property_this(&result, this_ptr, SL("_result"), PH_NOISY_CC);
_0$$3 = zephir_fetch_nproperty_this(this_ptr, SL("_row"), PH_NOISY_CC);
if (Z_TYPE_P(_0$$3) != IS_NULL) {
ZEPHIR_CALL_METHOD(NULL, result, "execute", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&records, result, "fetchall", NULL, 0);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_row"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_rows"), records TSRMLS_CC);
}
if (renameColumns) {
ZEPHIR_OBS_VAR(columnMap);
zephir_read_property_this(&columnMap, this_ptr, SL("_columnMap"), PH_NOISY_CC);
if (Z_TYPE_P(columnMap) != IS_ARRAY) {
RETURN_CCTOR(records);
}
ZEPHIR_INIT_VAR(renamedRecords);
array_init(renamedRecords);
if (Z_TYPE_P(records) == IS_ARRAY) {
zephir_is_iterable(records, &_2$$7, &_1$$7, 0, 0, "phalcon/mvc/model/resultset/simple.zep", 218);
for (
; zephir_hash_get_current_data_ex(_2$$7, (void**) &_3$$7, &_1$$7) == SUCCESS
; zephir_hash_move_forward_ex(_2$$7, &_1$$7)
) {
ZEPHIR_GET_HVALUE(record, _3$$7);
ZEPHIR_INIT_NVAR(renamed);
array_init(renamed);
zephir_is_iterable(record, &_5$$8, &_4$$8, 0, 0, "phalcon/mvc/model/resultset/simple.zep", 216);
for (
; zephir_hash_get_current_data_ex(_5$$8, (void**) &_6$$8, &_4$$8) == SUCCESS
; zephir_hash_move_forward_ex(_5$$8, &_4$$8)
) {
ZEPHIR_GET_HMKEY(key, _5$$8, _4$$8);
ZEPHIR_GET_HVALUE(value, _6$$8);
ZEPHIR_OBS_NVAR(renamedKey);
if (!(zephir_array_isset_fetch(&renamedKey, columnMap, key, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_7$$10);
object_init_ex(_7$$10, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_8$$10);
ZEPHIR_CONCAT_SVS(_8$$10, "Column '", key, "' is not part of the column map");
ZEPHIR_CALL_METHOD(NULL, _7$$10, "__construct", &_9, 9, _8$$10);
zephir_check_call_status();
zephir_throw_exception_debug(_7$$10, "phalcon/mvc/model/resultset/simple.zep", 200 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (Z_TYPE_P(renamedKey) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(renamedKey);
if (!(zephir_array_isset_long_fetch(&renamedKey, renamedKey, 0, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_10$$12);
object_init_ex(_10$$12, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_11$$12);
ZEPHIR_CONCAT_SVS(_11$$12, "Column '", key, "' is not part of the column map");
ZEPHIR_CALL_METHOD(NULL, _10$$12, "__construct", &_9, 9, _11$$12);
zephir_check_call_status();
zephir_throw_exception_debug(_10$$12, "phalcon/mvc/model/resultset/simple.zep", 206 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
zephir_array_update_zval(&renamed, renamedKey, &value, PH_COPY | PH_SEPARATE);
}
zephir_array_append(&renamedRecords, renamed, PH_SEPARATE, "phalcon/mvc/model/resultset/simple.zep", 216);
}
}
RETURN_CCTOR(renamedRecords);
}
RETURN_CCTOR(records);
}
/**
* Returns current row in the resultset
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, current) {
zend_class_entry *_5$$6;
zval *row = NULL, *hydrateMode = NULL, *columnMap = NULL, *activeRow = NULL, *modelName = NULL, *_0$$6, *_2$$6, *_3$$6, *_4$$6, *_1$$7, *_7$$9, *_8$$9, *_9$$9;
zephir_fcall_cache_entry *_6 = NULL, *_10 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(activeRow);
zephir_read_property_this(&activeRow, this_ptr, SL("_activeRow"), PH_NOISY_CC);
if (Z_TYPE_P(activeRow) != IS_NULL) {
RETURN_CCTOR(activeRow);
}
ZEPHIR_OBS_VAR(row);
zephir_read_property_this(&row, this_ptr, SL("_row"), PH_NOISY_CC);
if (Z_TYPE_P(row) != IS_ARRAY) {
if (0) {
zephir_update_property_this(this_ptr, SL("_activeRow"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_activeRow"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
RETURN_MM_BOOL(0);
}
ZEPHIR_OBS_VAR(hydrateMode);
zephir_read_property_this(&hydrateMode, this_ptr, SL("_hydrateMode"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(columnMap);
zephir_read_property_this(&columnMap, this_ptr, SL("_columnMap"), PH_NOISY_CC);
do {
if (ZEPHIR_IS_LONG(hydrateMode, 0)) {
if (ZEPHIR_GLOBAL(orm).late_state_binding) {
ZEPHIR_OBS_VAR(_0$$6);
zephir_read_property_this(&_0$$6, this_ptr, SL("_model"), PH_NOISY_CC);
if (zephir_instance_of_ev(_0$$6, phalcon_mvc_model_ce TSRMLS_CC)) {
_1$$7 = zephir_fetch_nproperty_this(this_ptr, SL("_model"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(modelName);
zephir_get_class(modelName, _1$$7, 0 TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(modelName);
ZVAL_STRING(modelName, "Phalcon\\Mvc\\Model", 1);
}
_2$$6 = zephir_fetch_nproperty_this(this_ptr, SL("_model"), PH_NOISY_CC);
_3$$6 = zephir_fetch_nproperty_this(this_ptr, SL("_keepSnapshots"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_4$$6);
ZVAL_LONG(_4$$6, 0);
_5$$6 = zephir_fetch_class(modelName TSRMLS_CC);
ZEPHIR_CALL_CE_STATIC(&activeRow, _5$$6, "cloneresultmap", NULL, 0, _2$$6, row, columnMap, _4$$6, _3$$6);
zephir_check_call_status();
} else {
_7$$9 = zephir_fetch_nproperty_this(this_ptr, SL("_model"), PH_NOISY_CC);
_8$$9 = zephir_fetch_nproperty_this(this_ptr, SL("_keepSnapshots"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_9$$9);
ZVAL_LONG(_9$$9, 0);
ZEPHIR_CALL_CE_STATIC(&activeRow, phalcon_mvc_model_ce, "cloneresultmap", &_6, 369, _7$$9, row, columnMap, _9$$9, _8$$9);
zephir_check_call_status();
}
break;
}
ZEPHIR_CALL_CE_STATIC(&activeRow, phalcon_mvc_model_ce, "cloneresultmaphydrate", &_10, 370, row, columnMap, hydrateMode);
zephir_check_call_status();
break;
} while(0);
zephir_update_property_this(this_ptr, SL("_activeRow"), activeRow TSRMLS_CC);
RETURN_CCTOR(activeRow);
}
/**
* Creates a password hash using bcrypt with a pseudo random salt
*/
PHP_METHOD(Phalcon_Security, hash) {
zephir_fcall_cache_entry *_3 = NULL, *_6 = NULL;
int workFactor, ZEPHIR_LAST_CALL_STATUS, hash = 0;
zval *password_param = NULL, *workFactor_param = NULL, *saltBytes = NULL, *_1, *_0$$3, *_2$$9, *_4$$11, *_5$$11, *_7$$13, _8$$13, _9$$13, *_10$$13 = NULL, *_11$$13;
zval *password = NULL, *variant = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &password_param, &workFactor_param);
zephir_get_strval(password, password_param);
if (!workFactor_param) {
workFactor = 0;
} else {
workFactor = zephir_get_intval(workFactor_param);
}
if (!(workFactor)) {
ZEPHIR_OBS_VAR(_0$$3);
zephir_read_property_this(&_0$$3, this_ptr, SL("_workFactor"), PH_NOISY_CC);
workFactor = zephir_get_intval(_0$$3);
}
ZEPHIR_OBS_VAR(_1);
zephir_read_property_this(&_1, this_ptr, SL("_defaultHash"), PH_NOISY_CC);
hash = zephir_get_intval(_1);
do {
if (hash == 5) {
ZEPHIR_INIT_VAR(variant);
ZVAL_STRING(variant, "x", 1);
break;
}
if (hash == 6) {
ZEPHIR_INIT_NVAR(variant);
ZVAL_STRING(variant, "y", 1);
break;
}
if (hash == 7) {
ZEPHIR_INIT_NVAR(variant);
ZVAL_STRING(variant, "5", 1);
break;
}
if (hash == 8) {
ZEPHIR_INIT_NVAR(variant);
ZVAL_STRING(variant, "6", 1);
break;
}
ZEPHIR_INIT_NVAR(variant);
ZVAL_STRING(variant, "a", 1);
break;
} while(0);
do {
if (hash == 1) {
ZEPHIR_INIT_VAR(_2$$9);
ZVAL_LONG(_2$$9, 2);
ZEPHIR_CALL_METHOD(&saltBytes, this_ptr, "getsaltbytes", &_3, 0, _2$$9);
zephir_check_call_status();
if (Z_TYPE_P(saltBytes) != IS_STRING) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_security_exception_ce, "Unable to get random bytes for the salt", "phalcon/security.zep", 195);
return;
}
break;
}
if (hash == 8) {
ZEPHIR_INIT_VAR(_4$$11);
ZVAL_LONG(_4$$11, 8);
ZEPHIR_CALL_METHOD(&saltBytes, this_ptr, "getsaltbytes", &_3, 0, _4$$11);
zephir_check_call_status();
if (Z_TYPE_P(saltBytes) != IS_STRING) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_security_exception_ce, "Unable to get random bytes for the salt", "phalcon/security.zep", 203);
return;
}
ZEPHIR_INIT_VAR(_5$$11);
ZEPHIR_CONCAT_SVSV(_5$$11, "$", variant, "$", saltBytes);
ZEPHIR_RETURN_CALL_FUNCTION("crypt", &_6, 396, password, _5$$11);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_INIT_VAR(_7$$13);
ZVAL_LONG(_7$$13, 22);
ZEPHIR_CALL_METHOD(&saltBytes, this_ptr, "getsaltbytes", &_3, 0, _7$$13);
zephir_check_call_status();
if (Z_TYPE_P(saltBytes) != IS_STRING) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_security_exception_ce, "Unable to get random bytes for the salt", "phalcon/security.zep", 225);
return;
}
if (workFactor < 4) {
workFactor = 4;
} else {
if (workFactor > 31) {
workFactor = 31;
}
}
ZEPHIR_SINIT_VAR(_8$$13);
ZVAL_STRING(&_8$$13, "%02s", 0);
ZEPHIR_SINIT_VAR(_9$$13);
ZVAL_LONG(&_9$$13, workFactor);
ZEPHIR_CALL_FUNCTION(&_10$$13, "sprintf", NULL, 184, &_8$$13, &_9$$13);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_11$$13);
ZEPHIR_CONCAT_SVSVSV(_11$$13, "$2", variant, "$", _10$$13, "$", saltBytes);
ZEPHIR_RETURN_CALL_FUNCTION("crypt", &_6, 396, password, _11$$13);
zephir_check_call_status();
RETURN_MM();
} while(0);
RETURN_MM_STRING("", 1);
}
/**
* Gets the a value to validate in the array/object data source
*
* @param string field
* @return mixed
*/
PHP_METHOD(Phalcon_Validation, getValue) {
zephir_fcall_cache_entry *_2 = NULL;
zend_bool _1;
int ZEPHIR_LAST_CALL_STATUS;
zval *field_param = NULL, *entity, *method = NULL, *value = NULL, *data, *values, *filters, *fieldFilters, *dependencyInjector = NULL, *filterService = NULL, *_3;
zval *field = NULL, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &field_param);
zephir_get_strval(field, field_param);
ZEPHIR_OBS_VAR(entity);
zephir_read_property_this(&entity, this_ptr, SL("_entity"), PH_NOISY_CC);
if (Z_TYPE_P(entity) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_0);
ZEPHIR_CONCAT_SV(_0, "get", field);
ZEPHIR_CPY_WRT(method, _0);
if ((zephir_method_exists(entity, method TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD_ZVAL(&value, entity, method, NULL, 0);
zephir_check_call_status();
} else {
if ((zephir_method_exists_ex(entity, SS("readattribute") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(&value, entity, "readattribute", NULL, 0, field);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(value);
if (zephir_isset_property_zval(entity, field TSRMLS_CC)) {
zephir_read_property_zval(&value, entity, field, PH_NOISY_CC);
} else {
ZVAL_NULL(value);
}
}
}
RETURN_CCTOR(value);
}
ZEPHIR_OBS_VAR(data);
zephir_read_property_this(&data, this_ptr, SL("_data"), PH_NOISY_CC);
_1 = Z_TYPE_P(data) != IS_ARRAY;
if (_1) {
_1 = Z_TYPE_P(data) != IS_OBJECT;
}
if (_1) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "There is no data to validate", "phalcon/validation.zep", 386);
return;
}
ZEPHIR_OBS_VAR(values);
zephir_read_property_this(&values, this_ptr, SL("_values"), PH_NOISY_CC);
ZEPHIR_OBS_NVAR(value);
if (zephir_array_isset_fetch(&value, values, field, 0 TSRMLS_CC)) {
RETURN_CCTOR(value);
}
ZEPHIR_INIT_NVAR(value);
ZVAL_NULL(value);
if (Z_TYPE_P(data) == IS_ARRAY) {
if (zephir_array_isset(data, field)) {
ZEPHIR_OBS_NVAR(value);
zephir_array_fetch(&value, data, field, PH_NOISY, "phalcon/validation.zep", 400 TSRMLS_CC);
}
} else if (Z_TYPE_P(data) == IS_OBJECT) {
if (zephir_isset_property_zval(data, field TSRMLS_CC)) {
ZEPHIR_OBS_NVAR(value);
zephir_read_property_zval(&value, data, field, PH_NOISY_CC);
}
}
if (Z_TYPE_P(value) == IS_NULL) {
RETURN_MM_NULL();
}
ZEPHIR_OBS_VAR(filters);
zephir_read_property_this(&filters, this_ptr, SL("_filters"), PH_NOISY_CC);
if (Z_TYPE_P(filters) == IS_ARRAY) {
ZEPHIR_OBS_VAR(fieldFilters);
if (zephir_array_isset_fetch(&fieldFilters, filters, field, 0 TSRMLS_CC)) {
if (zephir_is_true(fieldFilters)) {
ZEPHIR_CALL_METHOD(&dependencyInjector, this_ptr, "getdi", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_CALL_CE_STATIC(&dependencyInjector, phalcon_di_ce, "getdefault", &_2, 147);
zephir_check_call_status();
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "A dependency injector is required to obtain the 'filter' service", "phalcon/validation.zep", 423);
return;
}
}
ZEPHIR_INIT_VAR(_3);
ZVAL_STRING(_3, "filter", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&filterService, dependencyInjector, "getshared", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(filterService) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Returned 'filter' service is invalid", "phalcon/validation.zep", 429);
return;
}
ZEPHIR_RETURN_CALL_METHOD(filterService, "sanitize", NULL, 0, value, fieldFilters);
zephir_check_call_status();
RETURN_MM();
}
}
}
zephir_update_property_array(this_ptr, SL("_values"), field, value TSRMLS_CC);
RETURN_CCTOR(value);
}
/**
* Validate a set of data according to a set of rules
*
* @param array|object data
* @param object entity
* @return Phalcon\Validation\Message\Group
*/
PHP_METHOD(Phalcon_Validation, validate) {
HashTable *_2;
HashPosition _1;
zend_bool _0;
int ZEPHIR_LAST_CALL_STATUS;
zval *data = NULL, *entity = NULL, *validators, *messages = NULL, *scope = NULL, *field = NULL, *validator = NULL, *status = NULL, **_3, *_4 = NULL, *_5 = NULL, *_6 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 2, &data, &entity);
if (!data) {
data = ZEPHIR_GLOBAL(global_null);
}
if (!entity) {
entity = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_OBS_VAR(validators);
zephir_read_property_this(&validators, this_ptr, SL("_validators"), PH_NOISY_CC);
if (Z_TYPE_P(validators) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "There are no validators to validate", "phalcon/validation.zep", 83);
return;
}
zephir_update_property_this(this_ptr, SL("_values"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
ZEPHIR_INIT_VAR(messages);
object_init_ex(messages, phalcon_validation_message_group_ce);
ZEPHIR_CALL_METHOD(NULL, messages, "__construct", NULL, 173);
zephir_check_call_status();
if ((zephir_method_exists_ex(this_ptr, SS("beforevalidation") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(&status, this_ptr, "beforevalidation", NULL, 0, data, entity, messages);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(status)) {
RETURN_CCTOR(status);
}
}
zephir_update_property_this(this_ptr, SL("_messages"), messages TSRMLS_CC);
_0 = Z_TYPE_P(data) == IS_ARRAY;
if (!(_0)) {
_0 = Z_TYPE_P(data) == IS_OBJECT;
}
if (_0) {
zephir_update_property_this(this_ptr, SL("_data"), data TSRMLS_CC);
}
zephir_is_iterable(validators, &_2, &_1, 0, 0, "phalcon/validation.zep", 138);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(scope, _3);
if (Z_TYPE_P(scope) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "The validator scope is not valid", "phalcon/validation.zep", 115);
return;
}
ZEPHIR_OBS_NVAR(field);
zephir_array_fetch_long(&field, scope, 0, PH_NOISY, "phalcon/validation.zep", 118 TSRMLS_CC);
ZEPHIR_OBS_NVAR(validator);
zephir_array_fetch_long(&validator, scope, 1, PH_NOISY, "phalcon/validation.zep", 119 TSRMLS_CC);
if (Z_TYPE_P(validator) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "One of the validators is not valid", "phalcon/validation.zep", 122);
return;
}
ZEPHIR_CALL_METHOD(&_4, validator, "validate", NULL, 0, this_ptr, field);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_4)) {
ZEPHIR_INIT_NVAR(_6);
ZVAL_STRING(_6, "cancelOnFail", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_5, validator, "getoption", NULL, 0, _6);
zephir_check_temp_parameter(_6);
zephir_check_call_status();
if (zephir_is_true(_5)) {
break;
}
}
}
ZEPHIR_OBS_NVAR(messages);
zephir_read_property_this(&messages, this_ptr, SL("_messages"), PH_NOISY_CC);
if ((zephir_method_exists_ex(this_ptr, SS("aftervalidation") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "aftervalidation", NULL, 0, data, entity, messages);
zephir_check_call_status();
}
RETURN_CCTOR(messages);
}
/**
* Produce the routing parameters from the rewrite information
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, handle) {
zephir_fcall_cache_entry *_9 = NULL, *_17 = NULL, *_18 = NULL;
HashTable *_2, *_7, *_11, *_15;
HashPosition _1, _6, _10, _14;
int ZEPHIR_LAST_CALL_STATUS;
zval *uri_param = NULL, *realUri = NULL, *annotationsService = NULL, *handlers, *controllerSuffix, *scope = NULL, *prefix = NULL, *dependencyInjector = NULL, *handler = NULL, *controllerName = NULL, *lowerControllerName = NULL, *namespaceName = NULL, *moduleName = NULL, *sufixed = NULL, *handlerAnnotations = NULL, *classAnnotations = NULL, *annotations = NULL, *annotation = NULL, *methodAnnotations = NULL, *lowercased = NULL, *method = NULL, *collection = NULL, *_0, **_3, *_4, *_5 = NULL, **_8, **_12, *_13 = NULL, **_16;
zval *uri = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &uri_param);
if (!uri_param) {
ZEPHIR_INIT_VAR(uri);
ZVAL_EMPTY_STRING(uri);
} else {
if (unlikely(Z_TYPE_P(uri_param) != IS_STRING && Z_TYPE_P(uri_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'uri' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(uri_param) == IS_STRING)) {
zephir_get_strval(uri, uri_param);
} else {
ZEPHIR_INIT_VAR(uri);
ZVAL_EMPTY_STRING(uri);
}
}
if (!(!(!uri) && Z_STRLEN_P(uri))) {
ZEPHIR_CALL_METHOD(&realUri, this_ptr, "getrewriteuri", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(realUri, uri);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_processed"), PH_NOISY_CC);
if (!(zephir_is_true(_0))) {
ZEPHIR_INIT_VAR(annotationsService);
ZVAL_NULL(annotationsService);
ZEPHIR_OBS_VAR(handlers);
zephir_read_property_this(&handlers, this_ptr, SL("_handlers"), PH_NOISY_CC);
if (Z_TYPE_P(handlers) == IS_ARRAY) {
ZEPHIR_OBS_VAR(controllerSuffix);
zephir_read_property_this(&controllerSuffix, this_ptr, SL("_controllerSuffix"), PH_NOISY_CC);
zephir_is_iterable(handlers, &_2, &_1, 0, 0, "phalcon/mvc/router/annotations.zep", 208);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(scope, _3);
if (Z_TYPE_P(scope) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(prefix);
zephir_array_fetch_long(&prefix, scope, 0, PH_NOISY, "phalcon/mvc/router/annotations.zep", 117 TSRMLS_CC);
if (!(ZEPHIR_IS_EMPTY(prefix))) {
if (!(zephir_start_with(realUri, prefix, NULL))) {
continue;
}
}
if (Z_TYPE_P(annotationsService) != IS_OBJECT) {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(dependencyInjector, _4);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_router_exception_ce, "A dependency injection container is required to access the 'annotations' service", "phalcon/mvc/router/annotations.zep", 129);
return;
}
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRING(_5, "annotations", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&annotationsService, dependencyInjector, "getshared", NULL, 0, _5);
zephir_check_temp_parameter(_5);
zephir_check_call_status();
}
ZEPHIR_OBS_NVAR(handler);
zephir_array_fetch_long(&handler, scope, 1, PH_NOISY, "phalcon/mvc/router/annotations.zep", 138 TSRMLS_CC);
if (zephir_memnstr_str(handler, SL("\\"), "phalcon/mvc/router/annotations.zep", 140)) {
ZEPHIR_INIT_NVAR(controllerName);
zephir_get_class_ns(controllerName, handler, 0 TSRMLS_CC);
ZEPHIR_INIT_NVAR(lowerControllerName);
zephir_uncamelize(lowerControllerName, controllerName);
ZEPHIR_INIT_NVAR(namespaceName);
zephir_get_ns_class(namespaceName, handler, 0 TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(controllerName, handler);
ZEPHIR_INIT_NVAR(lowerControllerName);
zephir_uncamelize(lowerControllerName, controllerName);
ZEPHIR_INIT_NVAR(namespaceName);
ZVAL_NULL(namespaceName);
}
zephir_update_property_this(this_ptr, SL("_routePrefix"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
ZEPHIR_OBS_NVAR(moduleName);
zephir_array_isset_long_fetch(&moduleName, scope, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_NVAR(sufixed);
ZEPHIR_CONCAT_VV(sufixed, handler, controllerSuffix);
ZEPHIR_CALL_METHOD(&handlerAnnotations, annotationsService, "get", NULL, 0, sufixed);
zephir_check_call_status();
if (Z_TYPE_P(handlerAnnotations) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&classAnnotations, handlerAnnotations, "getclassannotations", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(classAnnotations) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&annotations, classAnnotations, "getannotations", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(annotations) == IS_ARRAY) {
zephir_is_iterable(annotations, &_7, &_6, 0, 0, "phalcon/mvc/router/annotations.zep", 187);
for (
; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS
; zephir_hash_move_forward_ex(_7, &_6)
) {
ZEPHIR_GET_HVALUE(annotation, _8);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "processcontrollerannotation", &_9, 0, controllerName, annotation);
zephir_check_call_status();
}
}
}
ZEPHIR_CALL_METHOD(&methodAnnotations, handlerAnnotations, "getmethodsannotations", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(methodAnnotations) == IS_ARRAY) {
ZEPHIR_INIT_NVAR(lowercased);
zephir_uncamelize(lowercased, handler);
zephir_is_iterable(methodAnnotations, &_11, &_10, 0, 0, "phalcon/mvc/router/annotations.zep", 203);
for (
; zephir_hash_get_current_data_ex(_11, (void**) &_12, &_10) == SUCCESS
; zephir_hash_move_forward_ex(_11, &_10)
) {
ZEPHIR_GET_HMKEY(method, _11, _10);
ZEPHIR_GET_HVALUE(collection, _12);
if (Z_TYPE_P(collection) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&_13, collection, "getannotations", NULL, 0);
zephir_check_call_status();
zephir_is_iterable(_13, &_15, &_14, 0, 0, "phalcon/mvc/router/annotations.zep", 201);
for (
; zephir_hash_get_current_data_ex(_15, (void**) &_16, &_14) == SUCCESS
; zephir_hash_move_forward_ex(_15, &_14)
) {
ZEPHIR_GET_HVALUE(annotation, _16);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "processactionannotation", &_17, 0, moduleName, namespaceName, lowerControllerName, method, annotation);
zephir_check_call_status();
}
}
}
}
}
}
}
}
if (1) {
zephir_update_property_this(this_ptr, SL("_processed"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_processed"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
}
ZEPHIR_CALL_PARENT(NULL, phalcon_mvc_router_annotations_ce, this_ptr, "handle", &_18, 361, realUri);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Renders a view
*
* @param string path
* @param array params
* @return string
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, render) {
int ZEPHIR_LAST_CALL_STATUS;
zval *path_param = NULL, *params = NULL, *cache = NULL, *key = NULL, *lifetime = NULL, *cacheOptions, *content = NULL, *viewParams, *mergedParams = NULL, *_0 = NULL, *_1, *_2 = NULL;
zval *path = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &path_param, ¶ms);
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 (!params) {
params = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_CALL_METHOD(&cache, this_ptr, "getcache", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(cache) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&_0, cache, "isstarted", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
ZEPHIR_INIT_VAR(key);
ZVAL_NULL(key);
ZEPHIR_INIT_VAR(lifetime);
ZVAL_NULL(lifetime);
ZEPHIR_OBS_VAR(cacheOptions);
zephir_read_property_this(&cacheOptions, this_ptr, SL("_cacheOptions"), PH_NOISY_CC);
if (Z_TYPE_P(cacheOptions) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(key);
zephir_array_isset_string_fetch(&key, cacheOptions, SS("key"), 0 TSRMLS_CC);
ZEPHIR_OBS_NVAR(lifetime);
zephir_array_isset_string_fetch(&lifetime, cacheOptions, SS("lifetime"), 0 TSRMLS_CC);
}
if (Z_TYPE_P(key) == IS_NULL) {
ZEPHIR_INIT_NVAR(key);
zephir_md5(key, path);
}
ZEPHIR_CALL_METHOD(&content, cache, "start", NULL, 0, key, lifetime);
zephir_check_call_status();
if (Z_TYPE_P(content) != IS_NULL) {
zephir_update_property_this(this_ptr, SL("_content"), content TSRMLS_CC);
RETURN_CCTOR(content);
}
}
}
ZEPHIR_INIT_VAR(_1);
zephir_create_symbol_table(TSRMLS_C);
ZEPHIR_CALL_FUNCTION(NULL, "ob_start", NULL, 116);
zephir_check_call_status();
ZEPHIR_OBS_VAR(viewParams);
zephir_read_property_this(&viewParams, this_ptr, SL("_viewParams"), PH_NOISY_CC);
if (Z_TYPE_P(params) == IS_ARRAY) {
if (Z_TYPE_P(viewParams) == IS_ARRAY) {
ZEPHIR_INIT_VAR(mergedParams);
zephir_fast_array_merge(mergedParams, &(viewParams), &(params) TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(mergedParams, params);
}
} else {
ZEPHIR_CPY_WRT(mergedParams, viewParams);
}
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_internalrender", NULL, 389, path, mergedParams);
zephir_check_call_status();
if (Z_TYPE_P(cache) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&_0, cache, "isstarted", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_TRUE_IDENTICAL(_0)) {
ZEPHIR_CALL_METHOD(&_2, cache, "isfresh", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_TRUE_IDENTICAL(_2)) {
ZEPHIR_CALL_METHOD(NULL, cache, "save", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(NULL, cache, "stop", NULL, 0);
zephir_check_call_status();
}
} else {
ZEPHIR_CALL_METHOD(NULL, cache, "stop", NULL, 0);
zephir_check_call_status();
}
}
ZEPHIR_CALL_FUNCTION(NULL, "ob_end_clean", NULL, 118);
zephir_check_call_status();
RETURN_MM_MEMBER(this_ptr, "_content");
}
/**
* Checks for annotations in the public methods of the controller
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, processActionAnnotation) {
zephir_fcall_cache_entry *_7 = NULL, *_11 = NULL;
HashTable *_5, *_9;
HashPosition _4, _8;
int ZEPHIR_LAST_CALL_STATUS;
zend_bool isRoute, _12;
zval *module_param = NULL, *namespaceName_param = NULL, *controller_param = NULL, *action_param = NULL, *annotation, *name = NULL, *actionName, *routePrefix, *paths = NULL, *value = NULL, *uri = NULL, *route = NULL, *methods = NULL, *converts = NULL, *param = NULL, *convert = NULL, *conversorParam = NULL, *routeName = NULL, *beforeMatch = NULL, *_0, *_1, _2, *_3 = NULL, **_6, **_10;
zval *module = NULL, *namespaceName = NULL, *controller = NULL, *action = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 5, 0, &module_param, &namespaceName_param, &controller_param, &action_param, &annotation);
if (unlikely(Z_TYPE_P(module_param) != IS_STRING && Z_TYPE_P(module_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'module' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(module_param) == IS_STRING)) {
zephir_get_strval(module, module_param);
} else {
ZEPHIR_INIT_VAR(module);
ZVAL_EMPTY_STRING(module);
}
if (unlikely(Z_TYPE_P(namespaceName_param) != IS_STRING && Z_TYPE_P(namespaceName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'namespaceName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(namespaceName_param) == IS_STRING)) {
zephir_get_strval(namespaceName, namespaceName_param);
} else {
ZEPHIR_INIT_VAR(namespaceName);
ZVAL_EMPTY_STRING(namespaceName);
}
if (unlikely(Z_TYPE_P(controller_param) != IS_STRING && Z_TYPE_P(controller_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'controller' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(controller_param) == IS_STRING)) {
zephir_get_strval(controller, controller_param);
} else {
ZEPHIR_INIT_VAR(controller);
ZVAL_EMPTY_STRING(controller);
}
if (unlikely(Z_TYPE_P(action_param) != IS_STRING && Z_TYPE_P(action_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'action' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(action_param) == IS_STRING)) {
zephir_get_strval(action, action_param);
} else {
ZEPHIR_INIT_VAR(action);
ZVAL_EMPTY_STRING(action);
}
isRoute = 0;
ZEPHIR_INIT_VAR(methods);
ZVAL_NULL(methods);
ZEPHIR_CALL_METHOD(&name, annotation, "getname", NULL, 0);
zephir_check_call_status();
do {
if (ZEPHIR_IS_STRING(name, "Route")) {
isRoute = 1;
break;
}
if (ZEPHIR_IS_STRING(name, "Get")) {
isRoute = 1;
ZEPHIR_INIT_NVAR(methods);
ZVAL_STRING(methods, "GET", 1);
break;
}
if (ZEPHIR_IS_STRING(name, "Post")) {
isRoute = 1;
ZEPHIR_INIT_NVAR(methods);
ZVAL_STRING(methods, "POST", 1);
break;
}
if (ZEPHIR_IS_STRING(name, "Put")) {
isRoute = 1;
ZEPHIR_INIT_NVAR(methods);
ZVAL_STRING(methods, "PUT", 1);
break;
}
if (ZEPHIR_IS_STRING(name, "Delete")) {
isRoute = 1;
ZEPHIR_INIT_NVAR(methods);
ZVAL_STRING(methods, "DELETE", 1);
break;
}
if (ZEPHIR_IS_STRING(name, "Options")) {
isRoute = 1;
ZEPHIR_INIT_NVAR(methods);
ZVAL_STRING(methods, "OPTIONS", 1);
break;
}
} while(0);
if (isRoute == 1) {
ZEPHIR_INIT_VAR(_0);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_actionSuffix"), PH_NOISY_CC);
ZEPHIR_SINIT_VAR(_2);
ZVAL_STRING(&_2, "", 0);
zephir_fast_str_replace(&_0, _1, &_2, action TSRMLS_CC);
ZEPHIR_INIT_VAR(actionName);
zephir_fast_strtolower(actionName, _0);
ZEPHIR_OBS_VAR(routePrefix);
zephir_read_property_this(&routePrefix, this_ptr, SL("_routePrefix"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_3);
ZVAL_STRING(_3, "paths", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&paths, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(paths) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(paths);
array_init(paths);
}
if (!(ZEPHIR_IS_EMPTY(module))) {
zephir_array_update_string(&paths, SL("module"), &module, PH_COPY | PH_SEPARATE);
}
if (!(ZEPHIR_IS_EMPTY(namespaceName))) {
zephir_array_update_string(&paths, SL("namespace"), &namespaceName, PH_COPY | PH_SEPARATE);
}
zephir_array_update_string(&paths, SL("controller"), &controller, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&paths, SL("action"), &actionName, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_3);
ZVAL_LONG(_3, 0);
ZEPHIR_CALL_METHOD(&value, annotation, "getargument", NULL, 0, _3);
zephir_check_call_status();
if (Z_TYPE_P(value) != IS_NULL) {
if (!ZEPHIR_IS_STRING(value, "/")) {
ZEPHIR_INIT_VAR(uri);
ZEPHIR_CONCAT_VV(uri, routePrefix, value);
} else {
if (Z_TYPE_P(routePrefix) != IS_NULL) {
ZEPHIR_CPY_WRT(uri, routePrefix);
} else {
ZEPHIR_CPY_WRT(uri, value);
}
}
} else {
ZEPHIR_INIT_NVAR(uri);
ZEPHIR_CONCAT_VV(uri, routePrefix, actionName);
}
ZEPHIR_CALL_METHOD(&route, this_ptr, "add", NULL, 0, uri, paths);
zephir_check_call_status();
if (Z_TYPE_P(methods) != IS_NULL) {
ZEPHIR_CALL_METHOD(NULL, route, "via", NULL, 0, methods);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "methods", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&methods, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(methods) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(NULL, route, "via", NULL, 0, methods);
zephir_check_call_status();
} else {
if (Z_TYPE_P(methods) == IS_STRING) {
ZEPHIR_CALL_METHOD(NULL, route, "via", NULL, 0, methods);
zephir_check_call_status();
}
}
}
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "converts", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&converts, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(converts) == IS_ARRAY) {
zephir_is_iterable(converts, &_5, &_4, 0, 0, "phalcon/mvc/router/annotations.zep", 354);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HMKEY(param, _5, _4);
ZEPHIR_GET_HVALUE(convert, _6);
ZEPHIR_CALL_METHOD(NULL, route, "convert", &_7, 0, param, convert);
zephir_check_call_status();
}
}
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "conversors", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&converts, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(converts) == IS_ARRAY) {
zephir_is_iterable(converts, &_9, &_8, 0, 0, "phalcon/mvc/router/annotations.zep", 364);
for (
; zephir_hash_get_current_data_ex(_9, (void**) &_10, &_8) == SUCCESS
; zephir_hash_move_forward_ex(_9, &_8)
) {
ZEPHIR_GET_HMKEY(conversorParam, _9, _8);
ZEPHIR_GET_HVALUE(convert, _10);
ZEPHIR_CALL_METHOD(NULL, route, "convert", &_11, 0, conversorParam, convert);
zephir_check_call_status();
}
}
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "beforeMatch", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&beforeMatch, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
_12 = Z_TYPE_P(beforeMatch) == IS_ARRAY;
if (!(_12)) {
_12 = Z_TYPE_P(beforeMatch) == IS_STRING;
}
if (_12) {
ZEPHIR_CALL_METHOD(NULL, route, "beforematch", NULL, 0, beforeMatch);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "name", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&routeName, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(routeName) == IS_STRING) {
ZEPHIR_CALL_METHOD(NULL, route, "setname", NULL, 0, routeName);
zephir_check_call_status();
}
RETURN_MM_BOOL(1);
}
ZEPHIR_MM_RESTORE();
}
/**
* Shows a backtrace item
*/
PHP_METHOD(Phalcon_Debug, showTraceItem) {
zend_bool _40$$24;
HashTable *_18$$14;
HashPosition _17$$14;
zval *_1, *_26$$16 = NULL;
zephir_fcall_cache_entry *_21 = NULL, *_47 = NULL;
zval *trace = NULL;
zval *n_param = NULL, *trace_param = NULL, *className = NULL, *prepareInternalClass = NULL, *preparedFunctionName = NULL, *html = NULL, *classReflection = NULL, *prepareUriClass = NULL, *functionName = NULL, *functionReflection = NULL, *traceArgs = NULL, *arguments = NULL, *argument = NULL, *filez = NULL, *line = NULL, *showFiles = NULL, *lines = NULL, *numberLines = NULL, *showFileFragment = NULL, *beforeLine = NULL, *afterLine = NULL, *lastLine = NULL, *linePosition = NULL, *currentLine = NULL, *classNameWithLink = NULL, *functionNameWithLink = NULL, _0, *_16, *_2$$3, *_3$$3, _4$$3, *_11$$3, *_12$$3, _5$$4, _6$$4, *_7$$5 = NULL, *_8$$6, _9$$6, _10$$6, *_13$$10 = NULL, _14$$11, _15$$11, **_19$$14, *_23$$14, *_24$$14, *_20$$15 = NULL, *_22$$15 = NULL, *_25$$16, *_27$$16, _28$$18, _29$$18, *_30$$18, _31$$23, *_32$$23, *_33$$26 = NULL, *_34$$26 = NULL, *_35$$26 = NULL, _36$$26 = zval_used_for_init, *_37$$27 = NULL, _38$$27 = zval_used_for_init, _39$$27 = zval_used_for_init, *_41$$29 = NULL, _42$$29 = zval_used_for_init, _43$$29 = zval_used_for_init, _44$$29 = zval_used_for_init, _45$$29 = zval_used_for_init, *_46$$29 = NULL;
int n, ZEPHIR_LAST_CALL_STATUS, firstLine = 0, i = 0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &n_param, &trace_param);
n = zephir_get_intval(n_param);
trace = trace_param;
ZEPHIR_SINIT_VAR(_0);
ZVAL_LONG(&_0, n);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SVS(_1, "<tr><td align=\"right\" valign=\"top\" class=\"error-number\">#", &_0, "</td><td>");
ZEPHIR_CPY_WRT(html, _1);
ZEPHIR_OBS_VAR(className);
if (zephir_array_isset_string_fetch(&className, trace, SS("class"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(_2$$3);
ZEPHIR_INIT_VAR(_3$$3);
ZEPHIR_SINIT_VAR(_4$$3);
ZVAL_STRING(&_4$$3, "/^Phalcon/", 0);
zephir_preg_match(_3$$3, &_4$$3, className, _2$$3, 0, 0 , 0 TSRMLS_CC);
if (zephir_is_true(_3$$3)) {
ZEPHIR_SINIT_VAR(_5$$4);
ZVAL_STRING(&_5$$4, "\\", 0);
ZEPHIR_SINIT_VAR(_6$$4);
ZVAL_STRING(&_6$$4, "/", 0);
ZEPHIR_INIT_VAR(prepareUriClass);
zephir_fast_str_replace(&prepareUriClass, &_5$$4, &_6$$4, className TSRMLS_CC);
ZEPHIR_INIT_VAR(classNameWithLink);
ZEPHIR_CONCAT_SVSVS(classNameWithLink, "<a target=\"_new\" href=\"//api.phalconphp.com/class/", prepareUriClass, ".html\">", className, "</a>");
} else {
ZEPHIR_INIT_VAR(classReflection);
object_init_ex(classReflection, zephir_get_internal_ce(SS("reflectionclass") TSRMLS_CC));
ZEPHIR_CALL_METHOD(NULL, classReflection, "__construct", NULL, 91, className);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_7$$5, classReflection, "isinternal", NULL, 163);
zephir_check_call_status();
if (zephir_is_true(_7$$5)) {
ZEPHIR_INIT_VAR(_8$$6);
zephir_fast_strtolower(_8$$6, className);
ZEPHIR_SINIT_VAR(_9$$6);
ZVAL_STRING(&_9$$6, "_", 0);
ZEPHIR_SINIT_VAR(_10$$6);
ZVAL_STRING(&_10$$6, "-", 0);
ZEPHIR_INIT_VAR(prepareInternalClass);
zephir_fast_str_replace(&prepareInternalClass, &_9$$6, &_10$$6, _8$$6 TSRMLS_CC);
ZEPHIR_INIT_NVAR(classNameWithLink);
ZEPHIR_CONCAT_SVSVS(classNameWithLink, "<a target=\"_new\" href=\"http://php.net/manual/en/class.", prepareInternalClass, ".php\">", className, "</a>");
} else {
ZEPHIR_CPY_WRT(classNameWithLink, className);
}
}
ZEPHIR_INIT_VAR(_11$$3);
ZEPHIR_CONCAT_SVS(_11$$3, "<span class=\"error-class\">", classNameWithLink, "</span>");
zephir_concat_self(&html, _11$$3 TSRMLS_CC);
zephir_array_fetch_string(&_12$$3, trace, SL("type"), PH_NOISY | PH_READONLY, "phalcon/debug.zep", 386 TSRMLS_CC);
zephir_concat_self(&html, _12$$3 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(functionName);
zephir_array_fetch_string(&functionName, trace, SL("function"), PH_NOISY, "phalcon/debug.zep", 392 TSRMLS_CC);
if (zephir_array_isset_string(trace, SS("class"))) {
ZEPHIR_CPY_WRT(functionNameWithLink, functionName);
} else {
if ((zephir_function_exists(functionName TSRMLS_CC) == SUCCESS)) {
ZEPHIR_INIT_VAR(functionReflection);
object_init_ex(functionReflection, zephir_get_internal_ce(SS("reflectionfunction") TSRMLS_CC));
ZEPHIR_CALL_METHOD(NULL, functionReflection, "__construct", NULL, 82, functionName);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_13$$10, functionReflection, "isinternal", NULL, 164);
zephir_check_call_status();
if (zephir_is_true(_13$$10)) {
ZEPHIR_SINIT_VAR(_14$$11);
ZVAL_STRING(&_14$$11, "_", 0);
ZEPHIR_SINIT_VAR(_15$$11);
ZVAL_STRING(&_15$$11, "-", 0);
ZEPHIR_INIT_VAR(preparedFunctionName);
zephir_fast_str_replace(&preparedFunctionName, &_14$$11, &_15$$11, functionName TSRMLS_CC);
ZEPHIR_INIT_NVAR(functionNameWithLink);
ZEPHIR_CONCAT_SVSVS(functionNameWithLink, "<a target=\"_new\" href=\"http://php.net/manual/en/function.", preparedFunctionName, ".php\">", functionName, "</a>");
} else {
ZEPHIR_CPY_WRT(functionNameWithLink, functionName);
}
} else {
ZEPHIR_CPY_WRT(functionNameWithLink, functionName);
}
}
ZEPHIR_INIT_VAR(_16);
ZEPHIR_CONCAT_SVS(_16, "<span class=\"error-function\">", functionNameWithLink, "</span>");
zephir_concat_self(&html, _16 TSRMLS_CC);
ZEPHIR_OBS_VAR(traceArgs);
if (zephir_array_isset_string_fetch(&traceArgs, trace, SS("args"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(arguments);
array_init(arguments);
zephir_is_iterable(traceArgs, &_18$$14, &_17$$14, 0, 0, "phalcon/debug.zep", 441);
for (
; zend_hash_get_current_data_ex(_18$$14, (void**) &_19$$14, &_17$$14) == SUCCESS
; zend_hash_move_forward_ex(_18$$14, &_17$$14)
) {
ZEPHIR_GET_HVALUE(argument, _19$$14);
ZEPHIR_CALL_METHOD(&_20$$15, this_ptr, "_getvardump", &_21, 0, argument);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_22$$15);
ZEPHIR_CONCAT_SVS(_22$$15, "<span class=\"error-parameter\">", _20$$15, "</span>");
zephir_array_append(&arguments, _22$$15, PH_SEPARATE, "phalcon/debug.zep", 435);
}
ZEPHIR_INIT_VAR(_23$$14);
zephir_fast_join_str(_23$$14, SL(", "), arguments TSRMLS_CC);
ZEPHIR_INIT_VAR(_24$$14);
ZEPHIR_CONCAT_SVS(_24$$14, "(", _23$$14, ")");
zephir_concat_self(&html, _24$$14 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(filez);
if (zephir_array_isset_string_fetch(&filez, trace, SS("file"), 0 TSRMLS_CC)) {
ZEPHIR_OBS_VAR(_25$$16);
zephir_array_fetch_string(&_25$$16, trace, SL("line"), PH_NOISY, "phalcon/debug.zep", 449 TSRMLS_CC);
zephir_get_strval(_26$$16, _25$$16);
ZEPHIR_CPY_WRT(line, _26$$16);
ZEPHIR_INIT_VAR(_27$$16);
ZEPHIR_CONCAT_SVSVS(_27$$16, "<br/><div class=\"error-file\">", filez, " (", line, ")</div>");
zephir_concat_self(&html, _27$$16 TSRMLS_CC);
ZEPHIR_OBS_VAR(showFiles);
zephir_read_property_this(&showFiles, this_ptr, SL("_showFiles"), PH_NOISY_CC);
if (zephir_is_true(showFiles)) {
ZEPHIR_CALL_FUNCTION(&lines, "file", NULL, 165, filez);
zephir_check_call_status();
ZEPHIR_INIT_VAR(numberLines);
ZVAL_LONG(numberLines, zephir_fast_count_int(lines TSRMLS_CC));
ZEPHIR_OBS_VAR(showFileFragment);
zephir_read_property_this(&showFileFragment, this_ptr, SL("_showFileFragment"), PH_NOISY_CC);
if (zephir_is_true(showFileFragment)) {
ZEPHIR_INIT_VAR(beforeLine);
ZVAL_LONG(beforeLine, (zephir_get_numberval(line) - 7));
if (ZEPHIR_LT_LONG(beforeLine, 1)) {
firstLine = 1;
} else {
firstLine = zephir_get_numberval(beforeLine);
}
ZEPHIR_INIT_VAR(afterLine);
ZVAL_LONG(afterLine, (zephir_get_numberval(line) + 5));
if (ZEPHIR_GT(afterLine, numberLines)) {
ZEPHIR_CPY_WRT(lastLine, numberLines);
} else {
ZEPHIR_CPY_WRT(lastLine, afterLine);
}
ZEPHIR_SINIT_VAR(_28$$18);
ZVAL_LONG(&_28$$18, firstLine);
ZEPHIR_SINIT_VAR(_29$$18);
ZVAL_LONG(&_29$$18, firstLine);
ZEPHIR_INIT_VAR(_30$$18);
ZEPHIR_CONCAT_SVSVSVS(_30$$18, "<pre class=\"prettyprint highlight:", &_28$$18, ":", line, " linenums:", &_29$$18, "\">");
zephir_concat_self(&html, _30$$18 TSRMLS_CC);
} else {
firstLine = 1;
ZEPHIR_CPY_WRT(lastLine, numberLines);
ZEPHIR_SINIT_VAR(_31$$23);
ZVAL_LONG(&_31$$23, firstLine);
ZEPHIR_INIT_VAR(_32$$23);
ZEPHIR_CONCAT_SVSVS(_32$$23, "<pre class=\"prettyprint highlight:", &_31$$23, ":", line, " linenums error-scroll\">");
zephir_concat_self(&html, _32$$23 TSRMLS_CC);
}
i = firstLine;
while (1) {
if (!(ZEPHIR_GE_LONG(lastLine, i))) {
break;
}
ZEPHIR_INIT_NVAR(linePosition);
ZVAL_LONG(linePosition, (i - 1));
ZEPHIR_OBS_NVAR(currentLine);
zephir_array_fetch(¤tLine, lines, linePosition, PH_NOISY, "phalcon/debug.zep", 522 TSRMLS_CC);
if (zephir_is_true(showFileFragment)) {
if (i == firstLine) {
ZEPHIR_INIT_NVAR(_33$$26);
ZEPHIR_INIT_NVAR(_34$$26);
ZEPHIR_INIT_NVAR(_35$$26);
zephir_fast_trim(_35$$26, currentLine, NULL , ZEPHIR_TRIM_RIGHT TSRMLS_CC);
ZEPHIR_SINIT_NVAR(_36$$26);
ZVAL_STRING(&_36$$26, "#\\*\\/#", 0);
zephir_preg_match(_34$$26, &_36$$26, _35$$26, _33$$26, 0, 0 , 0 TSRMLS_CC);
if (zephir_is_true(_34$$26)) {
ZEPHIR_INIT_NVAR(_37$$27);
ZEPHIR_SINIT_NVAR(_38$$27);
ZVAL_STRING(&_38$$27, "* /", 0);
ZEPHIR_SINIT_NVAR(_39$$27);
ZVAL_STRING(&_39$$27, " ", 0);
zephir_fast_str_replace(&_37$$27, &_38$$27, &_39$$27, currentLine TSRMLS_CC);
ZEPHIR_CPY_WRT(currentLine, _37$$27);
}
}
}
_40$$24 = ZEPHIR_IS_STRING(currentLine, "\n");
if (!(_40$$24)) {
_40$$24 = ZEPHIR_IS_STRING(currentLine, "\r\n");
}
if (_40$$24) {
zephir_concat_self_str(&html, SL(" \n") TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(_41$$29);
ZEPHIR_SINIT_NVAR(_42$$29);
ZVAL_STRING(&_42$$29, "\t", 0);
ZEPHIR_SINIT_NVAR(_43$$29);
ZVAL_STRING(&_43$$29, " ", 0);
zephir_fast_str_replace(&_41$$29, &_42$$29, &_43$$29, currentLine TSRMLS_CC);
ZEPHIR_SINIT_NVAR(_44$$29);
ZVAL_LONG(&_44$$29, 2);
ZEPHIR_SINIT_NVAR(_45$$29);
ZVAL_STRING(&_45$$29, "UTF-8", 0);
ZEPHIR_CALL_FUNCTION(&_46$$29, "htmlentities", &_47, 158, _41$$29, &_44$$29, &_45$$29);
zephir_check_call_status();
zephir_concat_self(&html, _46$$29 TSRMLS_CC);
}
i++;
}
zephir_concat_self_str(&html, SL("</pre>") TSRMLS_CC);
}
}
zephir_concat_self_str(&html, SL("</td></tr>") TSRMLS_CC);
RETURN_CCTOR(html);
}
/**
* Handles routing information received from command-line arguments
*
* @param array arguments
*/
PHP_METHOD(Phalcon_Cli_Router, handle) {
zephir_fcall_cache_entry *_18 = NULL;
zval *_15 = NULL;
zval *_5 = NULL, *_10 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_3, *_7;
HashPosition _2, _6;
zend_bool _0;
zval *arguments = NULL, *moduleName = NULL, *taskName = NULL, *actionName = NULL, *params = NULL, *route = NULL, *parts = NULL, *pattern = NULL, *routeFound = NULL, *matches, *paths = NULL, *beforeMatch = NULL, *converters = NULL, *converter = NULL, *part = NULL, *position = NULL, *matchPosition = NULL, *strParams, *_1, **_4, **_8, *_9 = NULL, *_11, *_12, *_13, *_14, _16, *_17 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &arguments);
if (!arguments) {
arguments = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_INIT_VAR(routeFound);
ZVAL_BOOL(routeFound, 0);
ZEPHIR_INIT_VAR(parts);
array_init(parts);
ZEPHIR_INIT_VAR(params);
array_init(params);
ZEPHIR_INIT_VAR(matches);
ZVAL_NULL(matches);
zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_matchedRoute"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
if (Z_TYPE_P(arguments) != IS_ARRAY) {
_0 = Z_TYPE_P(arguments) != IS_STRING;
if (_0) {
_0 = Z_TYPE_P(arguments) != IS_NULL;
}
if (_0) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_router_exception_ce, "Arguments must be an array or string", "phalcon/cli/router.zep", 204);
return;
}
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_routes"), PH_NOISY_CC);
zephir_is_iterable(_1, &_3, &_2, 0, 1, "phalcon/cli/router.zep", 304);
for (
; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS
; zephir_hash_move_backwards_ex(_3, &_2)
) {
ZEPHIR_GET_HVALUE(route, _4);
ZEPHIR_CALL_METHOD(&pattern, route, "getcompiledpattern", NULL, 0);
zephir_check_call_status();
if (zephir_memnstr_str(pattern, SL("^"), "phalcon/cli/router.zep", 214)) {
ZEPHIR_INIT_NVAR(routeFound);
zephir_preg_match(routeFound, pattern, arguments, matches, 0, 0 , 0 TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(routeFound);
ZVAL_BOOL(routeFound, ZEPHIR_IS_EQUAL(pattern, arguments));
}
if (zephir_is_true(routeFound)) {
ZEPHIR_CALL_METHOD(&beforeMatch, route, "getbeforematch", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(beforeMatch) != IS_NULL) {
if (!(zephir_is_callable(beforeMatch TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_router_exception_ce, "Before-Match callback is not callable in matched route", "phalcon/cli/router.zep", 232);
return;
}
ZEPHIR_INIT_NVAR(_5);
zephir_create_array(_5, 3, 0 TSRMLS_CC);
zephir_array_fast_append(_5, arguments);
zephir_array_fast_append(_5, route);
zephir_array_fast_append(_5, this_ptr);
ZEPHIR_INIT_NVAR(routeFound);
ZEPHIR_CALL_USER_FUNC_ARRAY(routeFound, beforeMatch, _5);
zephir_check_call_status();
}
}
if (zephir_is_true(routeFound)) {
ZEPHIR_CALL_METHOD(&paths, route, "getpaths", NULL, 0);
zephir_check_call_status();
ZEPHIR_CPY_WRT(parts, paths);
if (Z_TYPE_P(matches) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&converters, route, "getconverters", NULL, 0);
zephir_check_call_status();
zephir_is_iterable(paths, &_7, &_6, 0, 0, "phalcon/cli/router.zep", 293);
for (
; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS
; zephir_hash_move_forward_ex(_7, &_6)
) {
ZEPHIR_GET_HMKEY(part, _7, _6);
ZEPHIR_GET_HVALUE(position, _8);
ZEPHIR_OBS_NVAR(matchPosition);
if (zephir_array_isset_fetch(&matchPosition, matches, position, 0 TSRMLS_CC)) {
if (Z_TYPE_P(converters) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(converter);
if (zephir_array_isset_fetch(&converter, converters, part, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_9);
ZEPHIR_INIT_NVAR(_5);
zephir_create_array(_5, 1, 0 TSRMLS_CC);
zephir_array_fast_append(_5, matchPosition);
ZEPHIR_CALL_USER_FUNC_ARRAY(_9, converter, _5);
zephir_check_call_status();
zephir_array_update_zval(&parts, part, &_9, PH_COPY | PH_SEPARATE);
continue;
}
}
zephir_array_update_zval(&parts, part, &matchPosition, PH_COPY | PH_SEPARATE);
} else {
if (Z_TYPE_P(converters) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(converter);
if (zephir_array_isset_fetch(&converter, converters, part, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_9);
ZEPHIR_INIT_NVAR(_10);
zephir_create_array(_10, 1, 0 TSRMLS_CC);
zephir_array_fast_append(_10, position);
ZEPHIR_CALL_USER_FUNC_ARRAY(_9, converter, _10);
zephir_check_call_status();
zephir_array_update_zval(&parts, part, &_9, PH_COPY | PH_SEPARATE);
}
}
}
}
zephir_update_property_this(this_ptr, SL("_matches"), matches TSRMLS_CC);
}
zephir_update_property_this(this_ptr, SL("_matchedRoute"), route TSRMLS_CC);
break;
}
}
if (zephir_is_true(routeFound)) {
zephir_update_property_this(this_ptr, SL("_wasMatched"), (1) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
_11 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultModule"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_module"), _11 TSRMLS_CC);
_12 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultTask"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_task"), _12 TSRMLS_CC);
_13 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAction"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_action"), _13 TSRMLS_CC);
_14 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultParams"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_params"), _14 TSRMLS_CC);
RETURN_THIS();
}
} else {
ZEPHIR_CPY_WRT(parts, arguments);
}
ZEPHIR_INIT_VAR(moduleName);
ZVAL_NULL(moduleName);
ZEPHIR_INIT_VAR(taskName);
ZVAL_NULL(taskName);
ZEPHIR_INIT_VAR(actionName);
ZVAL_NULL(actionName);
ZEPHIR_OBS_NVAR(moduleName);
if (zephir_array_isset_string_fetch(&moduleName, parts, SS("module"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&parts, SS("module"), PH_SEPARATE);
} else {
ZEPHIR_OBS_NVAR(moduleName);
zephir_read_property_this(&moduleName, this_ptr, SL("_defaultModule"), PH_NOISY_CC);
}
ZEPHIR_OBS_NVAR(taskName);
if (zephir_array_isset_string_fetch(&taskName, parts, SS("task"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&parts, SS("task"), PH_SEPARATE);
} else {
ZEPHIR_OBS_NVAR(taskName);
zephir_read_property_this(&taskName, this_ptr, SL("_defaultTask"), PH_NOISY_CC);
}
ZEPHIR_OBS_NVAR(actionName);
if (zephir_array_isset_string_fetch(&actionName, parts, SS("action"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&parts, SS("action"), PH_SEPARATE);
} else {
ZEPHIR_OBS_NVAR(actionName);
zephir_read_property_this(&actionName, this_ptr, SL("_defaultAction"), PH_NOISY_CC);
}
if (zephir_is_true(routeFound)) {
ZEPHIR_OBS_NVAR(params);
if (zephir_array_isset_string_fetch(¶ms, parts, SS("params"), 0 TSRMLS_CC)) {
if (Z_TYPE_P(params) != IS_ARRAY) {
zephir_get_strval(_15, params);
ZEPHIR_SINIT_VAR(_16);
ZVAL_LONG(&_16, 1);
ZEPHIR_INIT_VAR(strParams);
zephir_substr(strParams, _15, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
if (zephir_is_true(strParams)) {
ZEPHIR_CALL_CE_STATIC(&_17, phalcon_cli_router_route_ce, "getdelimiter", &_18, 121);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(params);
zephir_fast_explode(params, _17, strParams, LONG_MAX TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(params);
array_init(params);
}
}
zephir_array_unset_string(&parts, SS("params"), PH_SEPARATE);
}
if (zephir_fast_count_int(params TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_9);
zephir_fast_array_merge(_9, &(params), &(parts) TSRMLS_CC);
ZEPHIR_CPY_WRT(params, _9);
} else {
ZEPHIR_CPY_WRT(params, parts);
}
} else {
ZEPHIR_CPY_WRT(params, parts);
}
zephir_update_property_this(this_ptr, SL("_module"), moduleName TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_task"), taskName TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_action"), actionName TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_params"), params TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Handles uncaught exceptions
*/
PHP_METHOD(Phalcon_Debug, onUncaughtException) {
HashTable *_12$$5, *_17$$5, *_24$$5, *_31$$5, *_37$$13;
HashPosition _11$$5, _16$$5, _23$$5, _30$$5, _36$$13;
zephir_fcall_cache_entry *_15 = NULL, *_21 = NULL, *_27 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *exception, *_REQUEST, *_SERVER, *obLevel = NULL, *className = NULL, *escapedMessage = NULL, *html = NULL, *showBackTrace = NULL, *dataVars = NULL, *n = NULL, *traceItem = NULL, *keyRequest = NULL, *value = NULL, *keyServer = NULL, *keyFile = NULL, *keyVar = NULL, *dataVar = NULL, *_0, *_2 = NULL, *_3 = NULL, *_4, *_5 = NULL, *_6, *_7 = NULL, *_8 = NULL, *_9, *_42 = NULL, *_43, *_1$$4 = NULL, *_10$$5 = NULL, **_13$$5, **_18$$5, **_25$$5, *_29$$5 = NULL, **_32$$5, *_34$$5 = NULL, *_35$$5, *_14$$7 = NULL, *_19$$9 = NULL, *_20$$10 = NULL, *_22$$10 = NULL, *_26$$11 = NULL, *_28$$11 = NULL, *_33$$12 = NULL, **_38$$13, *_39$$14 = NULL, *_40$$14, *_41$$14 = NULL;
ZEPHIR_MM_GROW();
zephir_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC);
zephir_get_global(&_REQUEST, SS("_REQUEST") TSRMLS_CC);
zephir_fetch_params(1, 1, 0, &exception);
ZEPHIR_CALL_FUNCTION(&obLevel, "ob_get_level", NULL, 168);
zephir_check_call_status();
if (ZEPHIR_GT_LONG(obLevel, 0)) {
ZEPHIR_CALL_FUNCTION(NULL, "ob_end_clean", NULL, 128);
zephir_check_call_status();
}
_0 = zephir_fetch_static_property_ce(phalcon_debug_ce, SL("_isActive") TSRMLS_CC);
if (zephir_is_true(_0)) {
ZEPHIR_CALL_METHOD(&_1$$4, exception, "getmessage", NULL, 0);
zephir_check_call_status();
zend_print_zval(_1$$4, 0);
RETURN_MM_NULL();
}
zephir_update_static_property_ce(phalcon_debug_ce, SL("_isActive"), &ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
ZEPHIR_INIT_VAR(className);
zephir_get_class(className, exception, 0 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_2, exception, "getmessage", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&escapedMessage, this_ptr, "_escapestring", NULL, 0, _2);
zephir_check_call_status();
ZEPHIR_INIT_VAR(html);
ZEPHIR_CONCAT_SVSVS(html, "<html><head><title>", className, ": ", escapedMessage, "</title>");
ZEPHIR_CALL_METHOD(&_3, this_ptr, "getcsssources", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_4);
ZEPHIR_CONCAT_VS(_4, _3, "</head><body>");
zephir_concat_self(&html, _4 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_5, this_ptr, "getversion", NULL, 0);
zephir_check_call_status();
zephir_concat_self(&html, _5 TSRMLS_CC);
zephir_concat_self_str(&html, SL("<div align=\"center\"><div class=\"error-main\">") TSRMLS_CC);
ZEPHIR_INIT_VAR(_6);
ZEPHIR_CONCAT_SVSVS(_6, "<h1>", className, ": ", escapedMessage, "</h1>");
zephir_concat_self(&html, _6 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_7, exception, "getfile", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_8, exception, "getline", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_9);
ZEPHIR_CONCAT_SVSVS(_9, "<span class=\"error-file\">", _7, " (", _8, ")</span>");
zephir_concat_self(&html, _9 TSRMLS_CC);
zephir_concat_self_str(&html, SL("</div>") TSRMLS_CC);
ZEPHIR_OBS_VAR(showBackTrace);
zephir_read_property_this(&showBackTrace, this_ptr, SL("_showBackTrace"), PH_NOISY_CC);
if (zephir_is_true(showBackTrace)) {
ZEPHIR_OBS_VAR(dataVars);
zephir_read_property_this(&dataVars, this_ptr, SL("_data"), PH_NOISY_CC);
zephir_concat_self_str(&html, SL("<div class=\"error-info\"><div id=\"tabs\"><ul>") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<li><a href=\"#error-tabs-1\">Backtrace</a></li>") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<li><a href=\"#error-tabs-2\">Request</a></li>") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<li><a href=\"#error-tabs-3\">Server</a></li>") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<li><a href=\"#error-tabs-4\">Included Files</a></li>") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<li><a href=\"#error-tabs-5\">Memory</a></li>") TSRMLS_CC);
if (Z_TYPE_P(dataVars) == IS_ARRAY) {
zephir_concat_self_str(&html, SL("<li><a href=\"#error-tabs-6\">Variables</a></li>") TSRMLS_CC);
}
zephir_concat_self_str(&html, SL("</ul>") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<div id=\"error-tabs-1\"><table cellspacing=\"0\" align=\"center\" width=\"100%\">") TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_10$$5, exception, "gettrace", NULL, 0);
zephir_check_call_status();
zephir_is_iterable(_10$$5, &_12$$5, &_11$$5, 0, 0, "phalcon/debug.zep", 659);
for (
; zend_hash_get_current_data_ex(_12$$5, (void**) &_13$$5, &_11$$5) == SUCCESS
; zend_hash_move_forward_ex(_12$$5, &_11$$5)
) {
ZEPHIR_GET_HMKEY(n, _12$$5, _11$$5);
ZEPHIR_GET_HVALUE(traceItem, _13$$5);
ZEPHIR_CALL_METHOD(&_14$$7, this_ptr, "showtraceitem", &_15, 169, n, traceItem);
zephir_check_call_status();
zephir_concat_self(&html, _14$$7 TSRMLS_CC);
}
zephir_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<div id=\"error-tabs-2\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<tr><th>Key</th><th>Value</th></tr>") TSRMLS_CC);
zephir_is_iterable(_REQUEST, &_17$$5, &_16$$5, 0, 0, "phalcon/debug.zep", 673);
for (
; zend_hash_get_current_data_ex(_17$$5, (void**) &_18$$5, &_16$$5) == SUCCESS
; zend_hash_move_forward_ex(_17$$5, &_16$$5)
) {
ZEPHIR_GET_HMKEY(keyRequest, _17$$5, _16$$5);
ZEPHIR_GET_HVALUE(value, _18$$5);
if (Z_TYPE_P(value) != IS_ARRAY) {
ZEPHIR_INIT_LNVAR(_19$$9);
ZEPHIR_CONCAT_SVSVS(_19$$9, "<tr><td class=\"key\">", keyRequest, "</td><td>", value, "</td></tr>");
zephir_concat_self(&html, _19$$9 TSRMLS_CC);
} else {
ZEPHIR_CALL_FUNCTION(&_20$$10, "print_r", &_21, 170, value, ZEPHIR_GLOBAL(global_true));
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_22$$10);
ZEPHIR_CONCAT_SVSVS(_22$$10, "<tr><td class=\"key\">", keyRequest, "</td><td>", _20$$10, "</td></tr>");
zephir_concat_self(&html, _22$$10 TSRMLS_CC);
}
}
zephir_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<div id=\"error-tabs-3\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<tr><th>Key</th><th>Value</th></tr>") TSRMLS_CC);
zephir_is_iterable(_SERVER, &_24$$5, &_23$$5, 0, 0, "phalcon/debug.zep", 683);
for (
; zend_hash_get_current_data_ex(_24$$5, (void**) &_25$$5, &_23$$5) == SUCCESS
; zend_hash_move_forward_ex(_24$$5, &_23$$5)
) {
ZEPHIR_GET_HMKEY(keyServer, _24$$5, _23$$5);
ZEPHIR_GET_HVALUE(value, _25$$5);
ZEPHIR_CALL_METHOD(&_26$$11, this_ptr, "_getvardump", &_27, 0, value);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_28$$11);
ZEPHIR_CONCAT_SVSVS(_28$$11, "<tr><td class=\"key\">", keyServer, "</td><td>", _26$$11, "</td></tr>");
zephir_concat_self(&html, _28$$11 TSRMLS_CC);
}
zephir_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<div id=\"error-tabs-4\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<tr><th>#</th><th>Path</th></tr>") TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_29$$5, "get_included_files", NULL, 171);
zephir_check_call_status();
zephir_is_iterable(_29$$5, &_31$$5, &_30$$5, 0, 0, "phalcon/debug.zep", 693);
for (
; zend_hash_get_current_data_ex(_31$$5, (void**) &_32$$5, &_30$$5) == SUCCESS
; zend_hash_move_forward_ex(_31$$5, &_30$$5)
) {
ZEPHIR_GET_HMKEY(keyFile, _31$$5, _30$$5);
ZEPHIR_GET_HVALUE(value, _32$$5);
ZEPHIR_INIT_LNVAR(_33$$12);
ZEPHIR_CONCAT_SVSVS(_33$$12, "<tr><td>", keyFile, "</th><td>", value, "</td></tr>");
zephir_concat_self(&html, _33$$12 TSRMLS_CC);
}
zephir_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<div id=\"error-tabs-5\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_34$$5, "memory_get_usage", NULL, 172, ZEPHIR_GLOBAL(global_true));
zephir_check_call_status();
ZEPHIR_INIT_VAR(_35$$5);
ZEPHIR_CONCAT_SVS(_35$$5, "<tr><th colspan=\"2\">Memory</th></tr><tr><td>Usage</td><td>", _34$$5, "</td></tr>");
zephir_concat_self(&html, _35$$5 TSRMLS_CC);
zephir_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
if (Z_TYPE_P(dataVars) == IS_ARRAY) {
zephir_concat_self_str(&html, SL("<div id=\"error-tabs-6\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<tr><th>Key</th><th>Value</th></tr>") TSRMLS_CC);
zephir_is_iterable(dataVars, &_37$$13, &_36$$13, 0, 0, "phalcon/debug.zep", 711);
for (
; zend_hash_get_current_data_ex(_37$$13, (void**) &_38$$13, &_36$$13) == SUCCESS
; zend_hash_move_forward_ex(_37$$13, &_36$$13)
) {
ZEPHIR_GET_HMKEY(keyVar, _37$$13, _36$$13);
ZEPHIR_GET_HVALUE(dataVar, _38$$13);
zephir_array_fetch_long(&_40$$14, dataVar, 0, PH_NOISY | PH_READONLY, "phalcon/debug.zep", 709 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_39$$14, this_ptr, "_getvardump", &_27, 0, _40$$14);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_41$$14);
ZEPHIR_CONCAT_SVSVS(_41$$14, "<tr><td class=\"key\">", keyVar, "</td><td>", _39$$14, "</td></tr>");
zephir_concat_self(&html, _41$$14 TSRMLS_CC);
}
zephir_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
}
zephir_concat_self_str(&html, SL("</div>") TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_42, this_ptr, "getjssources", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_43);
ZEPHIR_CONCAT_VS(_43, _42, "</div></body></html>");
zephir_concat_self(&html, _43 TSRMLS_CC);
zend_print_zval(html, 0);
zephir_update_static_property_ce(phalcon_debug_ce, SL("_isActive"), &ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
RETURN_MM_BOOL(1);
}
/**
* Create/Returns a new transaction or an existing one
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, getOrCreateTransaction) {
HashTable *_2$$5;
HashPosition _1$$5;
int ZEPHIR_LAST_CALL_STATUS;
zval *autoBegin_param = NULL, *dependencyInjector = NULL, *transaction = NULL, *transactions = NULL, *_0, *_5, *_6, **_3$$5, *_4$$7 = NULL;
zend_bool autoBegin;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &autoBegin_param);
if (!autoBegin_param) {
autoBegin = 1;
} else {
autoBegin = zephir_get_boolval(autoBegin_param);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(dependencyInjector, _0);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_transaction_exception_ce, "A dependency injector container is required to obtain the services related to the ORM", "phalcon/mvc/model/transaction/manager.zep", 188);
return;
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_number"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
ZEPHIR_OBS_VAR(transactions);
zephir_read_property_this(&transactions, this_ptr, SL("_transactions"), PH_NOISY_CC);
if (Z_TYPE_P(transactions) == IS_ARRAY) {
zephir_is_iterable(transactions, &_2$$5, &_1$$5, 0, 1, "phalcon/mvc/model/transaction/manager.zep", 200);
for (
; zephir_hash_get_current_data_ex(_2$$5, (void**) &_3$$5, &_1$$5) == SUCCESS
; zephir_hash_move_backwards_ex(_2$$5, &_1$$5)
) {
ZEPHIR_GET_HVALUE(transaction, _3$$5);
if (Z_TYPE_P(transaction) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_4$$7);
ZVAL_BOOL(_4$$7, 0);
ZEPHIR_CALL_METHOD(NULL, transaction, "setisnewtransaction", NULL, 0, _4$$7);
zephir_check_call_status();
RETURN_CCTOR(transaction);
}
}
}
}
ZEPHIR_INIT_NVAR(transaction);
object_init_ex(transaction, phalcon_mvc_model_transaction_ce);
_5 = zephir_fetch_nproperty_this(this_ptr, SL("_service"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_6);
if (autoBegin) {
ZVAL_BOOL(_6, 1);
} else {
ZVAL_BOOL(_6, 0);
}
ZEPHIR_CALL_METHOD(NULL, transaction, "__construct", NULL, 352, dependencyInjector, _6, _5);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, transaction, "settransactionmanager", NULL, 353, this_ptr);
zephir_check_call_status();
zephir_update_property_array_append(this_ptr, SL("_transactions"), transaction TSRMLS_CC);
RETURN_ON_FAILURE(zephir_property_incr(this_ptr, SL("_number") TSRMLS_CC));
RETURN_CCTOR(transaction);
}
/**
* Throws an internal exception
*/
PHP_METHOD(Phalcon_Mvc_Dispatcher, _throwDispatchException) {
int exceptionCode, ZEPHIR_LAST_CALL_STATUS;
zval *message_param = NULL, *exceptionCode_param = NULL, *dependencyInjector, *response = NULL, *exception, *_0 = NULL, *_1 = NULL, *_2, *_3 = NULL;
zval *message = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &message_param, &exceptionCode_param);
if (unlikely(Z_TYPE_P(message_param) != IS_STRING && Z_TYPE_P(message_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'message' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(message_param) == IS_STRING)) {
zephir_get_strval(message, message_param);
} else {
ZEPHIR_INIT_VAR(message);
ZVAL_EMPTY_STRING(message);
}
if (!exceptionCode_param) {
exceptionCode = 0;
} else {
exceptionCode = zephir_get_intval(exceptionCode_param);
}
ZEPHIR_OBS_VAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_INIT_VAR(_0);
object_init_ex(_0, phalcon_mvc_dispatcher_exception_ce);
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "A dependency injection container is required to access the 'response' service", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_2);
ZVAL_LONG(_2, 0);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 9, _1, _2);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
zephir_throw_exception_debug(_0, "phalcon/mvc/dispatcher.zep", 120 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "response", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_3, dependencyInjector, "getshared", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
ZEPHIR_CPY_WRT(response, _3);
ZEPHIR_INIT_NVAR(_0);
ZVAL_LONG(_0, 404);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "Not Found", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, response, "setstatuscode", NULL, 0, _0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
ZEPHIR_INIT_VAR(exception);
object_init_ex(exception, phalcon_mvc_dispatcher_exception_ce);
ZEPHIR_INIT_NVAR(_0);
ZVAL_LONG(_0, exceptionCode);
ZEPHIR_CALL_METHOD(NULL, exception, "__construct", NULL, 9, message, _0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_3, this_ptr, "_handleexception", NULL, 0, exception);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_3)) {
RETURN_MM_BOOL(0);
}
zephir_throw_exception_debug(exception, "phalcon/mvc/dispatcher.zep", 142 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
/**
* Phalcon\Session\Adapter\Redis constructor
*/
PHP_METHOD(Phalcon_Session_Adapter_Redis, __construct) {
zephir_fcall_cache_entry *_13 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *options_param = NULL, *lifetime = NULL, *_2, *_3, *_5, *_7 = NULL, *_0$$3, *_1$$4;
zval *options = NULL, *_4, *_6, *_8, *_9, *_10, *_11, *_12;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &options_param);
if (!options_param) {
ZEPHIR_INIT_VAR(options);
array_init(options);
} else {
zephir_get_arrval(options, options_param);
}
if (!(zephir_array_isset_string(options, SS("host")))) {
ZEPHIR_INIT_VAR(_0$$3);
ZVAL_STRING(_0$$3, "127.0.0.1", 1);
zephir_array_update_string(&options, SL("host"), &_0$$3, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("port")))) {
ZEPHIR_INIT_VAR(_1$$4);
ZVAL_LONG(_1$$4, 6379);
zephir_array_update_string(&options, SL("port"), &_1$$4, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("persistent")))) {
zephir_array_update_string(&options, SL("persistent"), &ZEPHIR_GLOBAL(global_false), PH_COPY | PH_SEPARATE);
}
ZEPHIR_OBS_VAR(lifetime);
if (zephir_array_isset_string_fetch(&lifetime, options, SS("lifetime"), 0 TSRMLS_CC)) {
zephir_update_property_this(this_ptr, SL("_lifetime"), lifetime TSRMLS_CC);
}
ZEPHIR_INIT_VAR(_2);
object_init_ex(_2, phalcon_cache_backend_redis_ce);
ZEPHIR_INIT_VAR(_3);
object_init_ex(_3, phalcon_cache_frontend_none_ce);
if (zephir_has_constructor(_3 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(_4);
zephir_create_array(_4, 1, 0 TSRMLS_CC);
ZEPHIR_OBS_VAR(_5);
zephir_read_property_this(&_5, this_ptr, SL("_lifetime"), PH_NOISY_CC);
zephir_array_update_string(&_4, SL("lifetime"), &_5, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, _3, "__construct", NULL, 0, _4);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", NULL, 336, _3, options);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_redis"), _2 TSRMLS_CC);
ZEPHIR_INIT_VAR(_6);
zephir_create_array(_6, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_6, this_ptr);
ZEPHIR_INIT_VAR(_7);
ZVAL_STRING(_7, "open", 1);
zephir_array_fast_append(_6, _7);
ZEPHIR_INIT_VAR(_8);
zephir_create_array(_8, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_8, this_ptr);
ZEPHIR_INIT_NVAR(_7);
ZVAL_STRING(_7, "close", 1);
zephir_array_fast_append(_8, _7);
ZEPHIR_INIT_VAR(_9);
zephir_create_array(_9, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_9, this_ptr);
ZEPHIR_INIT_NVAR(_7);
ZVAL_STRING(_7, "read", 1);
zephir_array_fast_append(_9, _7);
ZEPHIR_INIT_VAR(_10);
zephir_create_array(_10, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_10, this_ptr);
ZEPHIR_INIT_NVAR(_7);
ZVAL_STRING(_7, "write", 1);
zephir_array_fast_append(_10, _7);
ZEPHIR_INIT_VAR(_11);
zephir_create_array(_11, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_11, this_ptr);
ZEPHIR_INIT_NVAR(_7);
ZVAL_STRING(_7, "destroy", 1);
zephir_array_fast_append(_11, _7);
ZEPHIR_INIT_VAR(_12);
zephir_create_array(_12, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_12, this_ptr);
ZEPHIR_INIT_NVAR(_7);
ZVAL_STRING(_7, "gc", 1);
zephir_array_fast_append(_12, _7);
ZEPHIR_CALL_FUNCTION(NULL, "session_set_save_handler", NULL, 436, _6, _8, _9, _10, _11, _12);
zephir_check_call_status();
ZEPHIR_CALL_PARENT(NULL, phalcon_session_adapter_redis_ce, this_ptr, "__construct", &_13, 437, options);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* 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_Memcache, 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, *ttl = NULL, *success = NULL, *options = NULL, *specialKey = NULL, *keys = NULL, *isBuffering = NULL, *_0$$4, *_1$$13, *_2$$14;
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);
} 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/memcache.zep", 189);
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 (Z_TYPE_P(content) == IS_NULL) {
ZEPHIR_CALL_METHOD(&cachedContent, frontend, "getcontent", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(cachedContent, content);
}
ZEPHIR_CALL_METHOD(&preparedContent, frontend, "beforestore", NULL, 0, cachedContent);
zephir_check_call_status();
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(&ttl, frontend, "getlifetime", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(ttl, tmp);
}
} else {
ZEPHIR_CPY_WRT(ttl, lifetime);
}
if (zephir_is_numeric(cachedContent)) {
ZEPHIR_INIT_VAR(_1$$13);
ZVAL_LONG(_1$$13, 0);
ZEPHIR_CALL_METHOD(&success, memcache, "set", NULL, 0, lastKey, cachedContent, _1$$13, ttl);
zephir_check_call_status();
} else {
ZEPHIR_INIT_VAR(_2$$14);
ZVAL_LONG(_2$$14, 0);
ZEPHIR_CALL_METHOD(&success, memcache, "set", NULL, 0, lastKey, preparedContent, _2$$14, ttl);
zephir_check_call_status();
}
if (!(zephir_is_true(success))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Failed storing data in memcached", "phalcon/cache/backend/memcache.zep", 236);
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/memcache.zep", 242);
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, &ttl, 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);
}
RETURN_CCTOR(success);
}
/**
* Phalcon\Session\Adapter\Libmemcached constructor
*
* @throws \Phalcon\Session\Exception
*/
PHP_METHOD(Phalcon_Session_Adapter_Libmemcached, __construct) {
zephir_fcall_cache_entry *_13 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *options_param = NULL, *servers = NULL, *client = NULL, *lifetime = NULL, *prefix = NULL, *statsKey = NULL, *_0 = NULL, *_1 = NULL, *_2, *_4, *_7 = NULL;
zval *options = NULL, *_3, *_5, *_6, *_8, *_9, *_10, *_11, *_12;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &options_param);
zephir_get_arrval(options, options_param);
ZEPHIR_OBS_VAR(servers);
if (!(zephir_array_isset_string_fetch(&servers, options, SS("servers"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_session_exception_ce, "No servers given in options", "phalcon/session/adapter/libmemcached.zep", 71);
return;
}
ZEPHIR_OBS_VAR(client);
if (!(zephir_array_isset_string_fetch(&client, options, SS("client"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(client);
ZVAL_NULL(client);
}
ZEPHIR_OBS_VAR(lifetime);
if (!(zephir_array_isset_string_fetch(&lifetime, options, SS("lifetime"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(lifetime);
ZVAL_LONG(lifetime, 8600);
}
ZEPHIR_INIT_VAR(_0);
ZVAL_LONG(_0, 2592000);
ZEPHIR_CALL_FUNCTION(&_1, "min", NULL, 405, lifetime, _0);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_lifetime"), _1 TSRMLS_CC);
ZEPHIR_OBS_VAR(prefix);
if (!(zephir_array_isset_string_fetch(&prefix, options, SS("prefix"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(prefix);
ZVAL_NULL(prefix);
}
ZEPHIR_OBS_VAR(statsKey);
if (!(zephir_array_isset_string_fetch(&statsKey, options, SS("statsKey"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(statsKey);
ZVAL_NULL(statsKey);
}
ZEPHIR_INIT_NVAR(_0);
object_init_ex(_0, phalcon_cache_backend_libmemcached_ce);
ZEPHIR_INIT_VAR(_2);
object_init_ex(_2, phalcon_cache_frontend_data_ce);
ZEPHIR_INIT_VAR(_3);
zephir_create_array(_3, 1, 0 TSRMLS_CC);
ZEPHIR_OBS_VAR(_4);
zephir_read_property_this(&_4, this_ptr, SL("_lifetime"), PH_NOISY_CC);
zephir_array_update_string(&_3, SL("lifetime"), &_4, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", NULL, 309, _3);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_5);
zephir_create_array(_5, 4, 0 TSRMLS_CC);
zephir_array_update_string(&_5, SL("servers"), &servers, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_5, SL("client"), &client, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_5, SL("prefix"), &prefix, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_5, SL("statsKey"), &statsKey, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 310, _2, _5);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_libmemcached"), _0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_6);
zephir_create_array(_6, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_6, this_ptr);
ZEPHIR_INIT_VAR(_7);
ZVAL_STRING(_7, "open", 1);
zephir_array_fast_append(_6, _7);
ZEPHIR_INIT_VAR(_8);
zephir_create_array(_8, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_8, this_ptr);
ZEPHIR_INIT_NVAR(_7);
ZVAL_STRING(_7, "close", 1);
zephir_array_fast_append(_8, _7);
ZEPHIR_INIT_VAR(_9);
zephir_create_array(_9, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_9, this_ptr);
ZEPHIR_INIT_NVAR(_7);
ZVAL_STRING(_7, "read", 1);
zephir_array_fast_append(_9, _7);
ZEPHIR_INIT_VAR(_10);
zephir_create_array(_10, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_10, this_ptr);
ZEPHIR_INIT_NVAR(_7);
ZVAL_STRING(_7, "write", 1);
zephir_array_fast_append(_10, _7);
ZEPHIR_INIT_VAR(_11);
zephir_create_array(_11, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_11, this_ptr);
ZEPHIR_INIT_NVAR(_7);
ZVAL_STRING(_7, "destroy", 1);
zephir_array_fast_append(_11, _7);
ZEPHIR_INIT_VAR(_12);
zephir_create_array(_12, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_12, this_ptr);
ZEPHIR_INIT_NVAR(_7);
ZVAL_STRING(_7, "gc", 1);
zephir_array_fast_append(_12, _7);
ZEPHIR_CALL_FUNCTION(NULL, "session_set_save_handler", NULL, 406, _6, _8, _9, _10, _11, _12);
zephir_check_call_status();
ZEPHIR_CALL_PARENT(NULL, phalcon_session_adapter_libmemcached_ce, this_ptr, "__construct", &_13, 407, options);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Encrypts a text
*
*<code>
* $encrypted = $crypt->encrypt("Ultra-secret text", "encrypt password");
*</code>
*/
PHP_METHOD(Phalcon_Crypt, encrypt) {
zend_bool _4, _5;
zephir_nts_static zephir_fcall_cache_entry *_2 = NULL, *_6 = NULL;
int ZEPHIR_LAST_CALL_STATUS, _3;
zval *text_param = NULL, *key_param = NULL, *encryptKey = NULL, *ivSize = NULL, *iv = NULL, *cipher, *mode, *blockSize = NULL, *paddingType, *padded = NULL, _0, *_1 = NULL;
zval *text = NULL, *key = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &text_param, &key_param);
if (unlikely(Z_TYPE_P(text_param) != IS_STRING && Z_TYPE_P(text_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'text' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(text_param) == IS_STRING)) {
zephir_get_strval(text, text_param);
} else {
ZEPHIR_INIT_VAR(text);
ZVAL_EMPTY_STRING(text);
}
if (!key_param) {
ZEPHIR_INIT_VAR(key);
ZVAL_EMPTY_STRING(key);
} else {
if (unlikely(Z_TYPE_P(key_param) != IS_STRING && Z_TYPE_P(key_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'key' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(key_param) == IS_STRING)) {
zephir_get_strval(key, key_param);
} else {
ZEPHIR_INIT_VAR(key);
ZVAL_EMPTY_STRING(key);
}
}
if (!((zephir_function_exists_ex(SS("mcrypt_get_iv_size") TSRMLS_CC) == SUCCESS))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "mcrypt extension is required", "phalcon/crypt.zep", 306);
return;
}
if (ZEPHIR_IS_STRING_IDENTICAL(key, "")) {
ZEPHIR_OBS_VAR(encryptKey);
zephir_read_property_this(&encryptKey, this_ptr, SL("_key"), PH_NOISY_CC);
} else {
ZEPHIR_CPY_WRT(encryptKey, key);
}
if (ZEPHIR_IS_EMPTY(encryptKey)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Encryption key cannot be empty", "phalcon/crypt.zep", 316);
return;
}
ZEPHIR_OBS_VAR(cipher);
zephir_read_property_this(&cipher, this_ptr, SL("_cipher"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(mode);
zephir_read_property_this(&mode, this_ptr, SL("_mode"), PH_NOISY_CC);
ZEPHIR_CALL_FUNCTION(&ivSize, "mcrypt_get_iv_size", NULL, cipher, mode);
zephir_check_call_status();
if (ZEPHIR_LT_LONG(ivSize, zephir_fast_strlen_ev(encryptKey))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Size of key is too large for this algorithm", "phalcon/crypt.zep", 324);
return;
}
ZEPHIR_SINIT_VAR(_0);
ZVAL_LONG(&_0, 2);
ZEPHIR_CALL_FUNCTION(&iv, "mcrypt_create_iv", NULL, ivSize, &_0);
zephir_check_call_status();
if (Z_TYPE_P(iv) != IS_STRING) {
ZEPHIR_CALL_FUNCTION(&_1, "strval", &_2, iv);
zephir_check_call_status();
ZEPHIR_CPY_WRT(iv, _1);
}
ZEPHIR_CALL_FUNCTION(&blockSize, "mcrypt_get_block_size", NULL, cipher, mode);
zephir_check_call_status();
if (Z_TYPE_P(blockSize) != IS_LONG) {
_3 = zephir_get_intval(blockSize);
ZEPHIR_INIT_NVAR(blockSize);
ZVAL_LONG(blockSize, _3);
}
ZEPHIR_OBS_VAR(paddingType);
zephir_read_property_this(&paddingType, this_ptr, SL("_padding"), PH_NOISY_CC);
_4 = !ZEPHIR_IS_LONG(paddingType, 0);
if (_4) {
_5 = ZEPHIR_IS_STRING(mode, "cbc");
if (!(_5)) {
_5 = ZEPHIR_IS_STRING(mode, "ecb");
}
_4 = _5;
}
if (_4) {
ZEPHIR_CALL_METHOD(&padded, this_ptr, "_cryptpadtext", &_6, text, mode, blockSize, paddingType);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(padded, text);
}
ZEPHIR_CALL_FUNCTION(&_1, "mcrypt_encrypt", NULL, cipher, encryptKey, padded, mode, iv);
zephir_check_call_status();
ZEPHIR_CONCAT_VV(return_value, iv, _1);
RETURN_MM();
}
/**
* Returns current row in the resultset
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, current) {
zephir_fcall_cache_entry *_8 = NULL, *_11 = NULL;
HashTable *_2, *_5;
HashPosition _1, _4;
int dirtyState, ZEPHIR_LAST_CALL_STATUS;
zval *row, *hydrateMode, *alias = NULL, *activeRow = NULL, *type = NULL, *columnTypes, *column = NULL, *columnValue = NULL, *value = NULL, *attribute = NULL, *source = NULL, *attributes = NULL, *columnMap = NULL, *rowModel = NULL, *keepSnapshots = NULL, *sqlAlias = NULL, *_0, **_3, **_6, *_7 = NULL, *_9, *_10 = NULL, _12 = zval_used_for_init, _13 = zval_used_for_init;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(activeRow);
zephir_read_property_this(&activeRow, this_ptr, SL("_activeRow"), PH_NOISY_CC);
if (Z_TYPE_P(activeRow) != IS_NULL) {
RETURN_CCTOR(activeRow);
}
ZEPHIR_OBS_VAR(row);
zephir_read_property_this(&row, this_ptr, SL("_row"), PH_NOISY_CC);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_disableHydration"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
zephir_update_property_this(this_ptr, SL("_activeRow"), row TSRMLS_CC);
RETURN_CCTOR(row);
}
if (Z_TYPE_P(row) != IS_ARRAY) {
zephir_update_property_this(this_ptr, SL("_activeRow"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
RETURN_MM_BOOL(0);
}
ZEPHIR_OBS_VAR(hydrateMode);
zephir_read_property_this(&hydrateMode, this_ptr, SL("_hydrateMode"), PH_NOISY_CC);
do {
if (ZEPHIR_IS_LONG(hydrateMode, 0)) {
ZEPHIR_INIT_NVAR(activeRow);
object_init_ex(activeRow, phalcon_mvc_model_row_ce);
if (zephir_has_constructor(activeRow TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, activeRow, "__construct", NULL, 0);
zephir_check_call_status();
}
break;
}
if (ZEPHIR_IS_LONG(hydrateMode, 1)) {
ZEPHIR_INIT_NVAR(activeRow);
array_init(activeRow);
break;
}
ZEPHIR_INIT_NVAR(activeRow);
object_init(activeRow);
break;
} while(0);
ZEPHIR_OBS_VAR(columnTypes);
zephir_read_property_this(&columnTypes, this_ptr, SL("_columnTypes"), PH_NOISY_CC);
dirtyState = 0;
zephir_is_iterable(columnTypes, &_2, &_1, 0, 0, "phalcon/mvc/model/resultset/complex.zep", 235);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HMKEY(alias, _2, _1);
ZEPHIR_GET_HVALUE(column, _3);
if (Z_TYPE_P(column) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Column type is corrupt", "phalcon/mvc/model/resultset/complex.zep", 136);
return;
}
ZEPHIR_OBS_NVAR(type);
zephir_array_fetch_string(&type, column, SL("type"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 139 TSRMLS_CC);
if (ZEPHIR_IS_STRING(type, "object")) {
ZEPHIR_OBS_NVAR(source);
zephir_array_fetch_string(&source, column, SL("column"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 145 TSRMLS_CC);
ZEPHIR_OBS_NVAR(attributes);
zephir_array_fetch_string(&attributes, column, SL("attributes"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 146 TSRMLS_CC);
ZEPHIR_OBS_NVAR(columnMap);
zephir_array_fetch_string(&columnMap, column, SL("columnMap"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 147 TSRMLS_CC);
ZEPHIR_INIT_NVAR(rowModel);
array_init(rowModel);
zephir_is_iterable(attributes, &_5, &_4, 0, 0, "phalcon/mvc/model/resultset/complex.zep", 165);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HVALUE(attribute, _6);
ZEPHIR_OBS_NVAR(columnValue);
ZEPHIR_INIT_LNVAR(_7);
ZEPHIR_CONCAT_SVSV(_7, "_", source, "_", attribute);
zephir_array_fetch(&columnValue, row, _7, PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 158 TSRMLS_CC);
zephir_array_update_zval(&rowModel, attribute, &columnValue, PH_COPY | PH_SEPARATE);
}
do {
if (ZEPHIR_IS_LONG(hydrateMode, 0)) {
ZEPHIR_OBS_NVAR(keepSnapshots);
if (!(zephir_array_isset_string_fetch(&keepSnapshots, column, SS("keepSnapshots"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(keepSnapshots);
ZVAL_BOOL(keepSnapshots, 0);
}
zephir_array_fetch_string(&_9, column, SL("instance"), PH_NOISY | PH_READONLY, "phalcon/mvc/model/resultset/complex.zep", 180 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_10);
ZVAL_LONG(_10, dirtyState);
ZEPHIR_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmap", &_8, 0, _9, rowModel, columnMap, _10, keepSnapshots);
zephir_check_call_status();
break;
}
ZEPHIR_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmaphydrate", &_11, 0, rowModel, columnMap, hydrateMode);
zephir_check_call_status();
break;
} while(0);
ZEPHIR_OBS_NVAR(attribute);
zephir_array_fetch_string(&attribute, column, SL("balias"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 194 TSRMLS_CC);
} else {
ZEPHIR_OBS_NVAR(sqlAlias);
if (zephir_array_isset_string_fetch(&sqlAlias, column, SS("sqlAlias"), 0 TSRMLS_CC)) {
ZEPHIR_OBS_NVAR(value);
zephir_array_fetch(&value, row, sqlAlias, PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 202 TSRMLS_CC);
} else {
ZEPHIR_OBS_NVAR(value);
zephir_array_isset_fetch(&value, row, alias, 0 TSRMLS_CC);
}
if (zephir_array_isset_string(column, SS("balias"))) {
ZEPHIR_CPY_WRT(attribute, alias);
} else {
ZEPHIR_SINIT_NVAR(_12);
ZVAL_STRING(&_12, "_", 0);
ZEPHIR_SINIT_NVAR(_13);
ZVAL_STRING(&_13, "", 0);
ZEPHIR_INIT_NVAR(attribute);
zephir_fast_str_replace(&attribute, &_12, &_13, alias TSRMLS_CC);
}
}
do {
if (ZEPHIR_IS_LONG(hydrateMode, 1)) {
zephir_array_update_zval(&activeRow, attribute, &value, PH_COPY | PH_SEPARATE);
break;
}
zephir_update_property_zval_zval(activeRow, attribute, value TSRMLS_CC);
break;
} while(0);
}
zephir_update_property_this(this_ptr, SL("_activeRow"), activeRow TSRMLS_CC);
RETURN_CCTOR(activeRow);
}
/**
* Decrypts an encrypted text
*
*<code>
* echo $crypt->decrypt($encrypted, "decrypt password");
*</code>
*/
PHP_METHOD(Phalcon_Crypt, decrypt) {
zephir_nts_static zephir_fcall_cache_entry *_4 = NULL;
zend_bool _3;
int ZEPHIR_LAST_CALL_STATUS;
zval *text_param = NULL, *key = NULL, *decryptKey = NULL, *ivSize = NULL, *cipher, *mode, *keySize, *length, *blockSize = NULL, *paddingType, *decrypted = NULL, *_0, _1, *_2;
zval *text = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &text_param, &key);
if (unlikely(Z_TYPE_P(text_param) != IS_STRING && Z_TYPE_P(text_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'text' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(text_param) == IS_STRING)) {
zephir_get_strval(text, text_param);
} else {
ZEPHIR_INIT_VAR(text);
ZVAL_EMPTY_STRING(text);
}
if (!key) {
key = ZEPHIR_GLOBAL(global_null);
}
if (!((zephir_function_exists_ex(SS("mcrypt_get_iv_size") TSRMLS_CC) == SUCCESS))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "mcrypt extension is required", "phalcon/crypt.zep", 360);
return;
}
if (Z_TYPE_P(key) == IS_NULL) {
ZEPHIR_OBS_VAR(decryptKey);
zephir_read_property_this(&decryptKey, this_ptr, SL("_key"), PH_NOISY_CC);
} else {
ZEPHIR_CPY_WRT(decryptKey, key);
}
if (ZEPHIR_IS_EMPTY(decryptKey)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Decryption key cannot be empty", "phalcon/crypt.zep", 370);
return;
}
ZEPHIR_OBS_VAR(cipher);
zephir_read_property_this(&cipher, this_ptr, SL("_cipher"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(mode);
zephir_read_property_this(&mode, this_ptr, SL("_mode"), PH_NOISY_CC);
ZEPHIR_CALL_FUNCTION(&ivSize, "mcrypt_get_iv_size", NULL, cipher, mode);
zephir_check_call_status();
ZEPHIR_INIT_VAR(keySize);
ZVAL_LONG(keySize, zephir_fast_strlen_ev(decryptKey));
if (ZEPHIR_GT(keySize, ivSize)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Size of key is too large for this algorithm", "phalcon/crypt.zep", 379);
return;
}
ZEPHIR_INIT_VAR(length);
ZVAL_LONG(length, zephir_fast_strlen_ev(text));
if (ZEPHIR_GT(keySize, length)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Size of IV is larger than text to decrypt", "phalcon/crypt.zep", 384);
return;
}
ZEPHIR_INIT_VAR(_0);
zephir_substr(_0, text, zephir_get_intval(ivSize), 0, ZEPHIR_SUBSTR_NO_LENGTH);
ZEPHIR_SINIT_VAR(_1);
ZVAL_LONG(&_1, 0);
ZEPHIR_INIT_VAR(_2);
zephir_substr(_2, text, 0 , zephir_get_intval(ivSize), 0);
ZEPHIR_CALL_FUNCTION(&decrypted, "mcrypt_decrypt", NULL, cipher, decryptKey, _0, mode, _2);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&blockSize, "mcrypt_get_block_size", NULL, cipher, mode);
zephir_check_call_status();
ZEPHIR_OBS_VAR(paddingType);
zephir_read_property_this(&paddingType, this_ptr, SL("_padding"), PH_NOISY_CC);
_3 = ZEPHIR_IS_STRING(mode, "cbc");
if (!(_3)) {
_3 = ZEPHIR_IS_STRING(mode, "ecb");
}
if (_3) {
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "_cryptunpadtext", &_4, decrypted, mode, blockSize, paddingType);
zephir_check_call_status();
RETURN_MM();
}
RETURN_CCTOR(decrypted);
}
/**
* Handles routing information received from the rewrite engine
*
*<code>
* //Read the info from the rewrite engine
* $router->handle();
*
* //Manually passing an URL
* $router->handle('/posts/edit/1');
*</code>
*
* @param string uri
*/
PHP_METHOD(Test_Router, handle) {
zephir_nts_static zephir_fcall_cache_entry *_12 = NULL;
HashTable *_2, *_9;
HashPosition _1, _8;
int ZEPHIR_LAST_CALL_STATUS;
zval *uri = NULL, *realUri = NULL, *request = NULL, *currentHostName = NULL, *routeFound = NULL, *parts = NULL, *params, *matches, *notFoundPaths, *vnamespace, *module, *controller, *action, *paramsStr, *strParams = NULL, *paramsMerge = NULL, *route = NULL, *methods = NULL, *dependencyInjector = NULL, *hostname = NULL, *regexHostName = NULL, *matched = NULL, *pattern = NULL, *handledUri = NULL, *beforeMatch = NULL, *paths = NULL, *converters = NULL, *part = NULL, *position = NULL, *matchPosition = NULL, *_0, **_3, *_4, *_5 = NULL, *_6 = NULL, *_7 = NULL, **_10, _11, *_13, *_14, *_15, *_16;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &uri);
if (!uri) {
uri = ZEPHIR_GLOBAL(global_null);
}
if (!(zephir_is_true(uri))) {
ZEPHIR_CALL_METHOD(&realUri, this_ptr, "getrewriteuri", NULL);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(realUri, uri);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_removeExtraSlashes"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
ZEPHIR_CALL_METHOD(&handledUri, this_ptr, "doremoveextraslashes", NULL, realUri);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(handledUri, realUri);
}
ZEPHIR_INIT_VAR(request);
ZVAL_NULL(request);
ZEPHIR_INIT_VAR(currentHostName);
ZVAL_NULL(currentHostName);
ZEPHIR_INIT_VAR(routeFound);
ZVAL_BOOL(routeFound, 0);
ZEPHIR_INIT_VAR(parts);
array_init(parts);
ZEPHIR_INIT_VAR(params);
array_init(params);
ZEPHIR_INIT_VAR(matches);
ZVAL_NULL(matches);
zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_matchedRoute"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_routes"), PH_NOISY_CC);
zephir_is_iterable(_0, &_2, &_1, 0, 1);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_backwards_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(route, _3);
ZEPHIR_CALL_METHOD(&methods, route, "gethttpmethods", NULL);
zephir_check_call_status();
if (Z_TYPE_P(methods) != IS_NULL) {
if (Z_TYPE_P(request) == IS_NULL) {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(dependencyInjector, _4);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_STR(test_router_exception_ce, "A dependency injection container is required to access the 'request' service");
return;
}
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRING(_5, "request", 0);
ZEPHIR_CALL_METHOD(&request, dependencyInjector, "getshared", NULL, _5);
zephir_check_temp_parameter(_5);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&_6, request, "ismethod", NULL, methods);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE(_6)) {
continue;
}
}
ZEPHIR_CALL_METHOD(&hostname, route, "gethostname", NULL);
zephir_check_call_status();
if (Z_TYPE_P(hostname) != IS_NULL) {
if (Z_TYPE_P(request) == IS_NULL) {
ZEPHIR_OBS_NVAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_STR(test_router_exception_ce, "A dependency injection container is required to access the 'request' service");
return;
}
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRING(_5, "request", 0);
ZEPHIR_CALL_METHOD(&request, dependencyInjector, "getshared", NULL, _5);
zephir_check_temp_parameter(_5);
zephir_check_call_status();
}
if (Z_TYPE_P(currentHostName) != IS_OBJECT) {
ZEPHIR_CALL_METHOD(¤tHostName, request, "gethttphost", NULL);
zephir_check_call_status();
}
if (Z_TYPE_P(currentHostName) != IS_NULL) {
continue;
}
ZEPHIR_INIT_NVAR(matched);
if (zephir_memnstr_str(hostname, SL("("), "test/router.zep", 381)) {
if (zephir_memnstr_str(hostname, SL("#"), "test/router.zep", 382)) {
ZEPHIR_INIT_NVAR(regexHostName);
ZEPHIR_CONCAT_SVS(regexHostName, "#^", hostname, "$#");
} else {
ZEPHIR_CPY_WRT(regexHostName, hostname);
}
ZEPHIR_INIT_NVAR(_7);
zephir_preg_match(matched, &(matched), regexHostName, currentHostName, _7, 0, 0 , 0 TSRMLS_CC);
} else {
ZVAL_BOOL(matched, ZEPHIR_IS_EQUAL(currentHostName, hostname));
}
if (!(zephir_is_true(matched))) {
continue;
}
}
ZEPHIR_CALL_METHOD(&pattern, route, "getcompiledpattern", NULL);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(routeFound);
if (zephir_memnstr_str(pattern, SL("^"), "test/router.zep", 400)) {
zephir_preg_match(routeFound, &(routeFound), pattern, handledUri, matches, 0, 0 , 0 TSRMLS_CC);
} else {
ZVAL_BOOL(routeFound, ZEPHIR_IS_EQUAL(pattern, handledUri));
}
if (zephir_is_true(routeFound)) {
ZEPHIR_CALL_METHOD(&beforeMatch, route, "getbeforematch", NULL);
zephir_check_call_status();
if (Z_TYPE_P(beforeMatch) != IS_NULL) {
if (zephir_is_callable(beforeMatch TSRMLS_CC)) {
ZEPHIR_THROW_EXCEPTION_STR(test_router_exception_ce, "Before-Match callback is not callable in matched route");
return;
}
}
}
if (zephir_is_true(routeFound)) {
ZEPHIR_CALL_METHOD(&paths, route, "getpaths", NULL);
zephir_check_call_status();
ZEPHIR_CPY_WRT(parts, paths);
if (Z_TYPE_P(matches) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&converters, route, "getconverters", NULL);
zephir_check_call_status();
zephir_is_iterable(paths, &_9, &_8, 0, 0);
for (
; zephir_hash_get_current_data_ex(_9, (void**) &_10, &_8) == SUCCESS
; zephir_hash_move_forward_ex(_9, &_8)
) {
ZEPHIR_GET_HMKEY(part, _9, _8);
ZEPHIR_GET_HVALUE(position, _10);
ZEPHIR_OBS_NVAR(matchPosition);
if (zephir_array_isset_fetch(&matchPosition, matches, position, 0 TSRMLS_CC)) {
if (Z_TYPE_P(converters) == IS_ARRAY) {
if (zephir_array_isset(converters, part)) {
continue;
}
}
zephir_array_update_zval(&parts, part, &matchPosition, PH_COPY | PH_SEPARATE);
} else {
if (Z_TYPE_P(converters) == IS_ARRAY) {
if (zephir_array_isset(converters, part)) {
}
}
}
}
zephir_update_property_this(this_ptr, SL("_matches"), matches TSRMLS_CC);
}
zephir_update_property_this(this_ptr, SL("_matchedRoute"), route TSRMLS_CC);
break;
}
}
if (zephir_is_true(routeFound)) {
zephir_update_property_this(this_ptr, SL("_wasMatched"), (1) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
if (!(zephir_is_true(routeFound))) {
ZEPHIR_OBS_VAR(notFoundPaths);
zephir_read_property_this(¬FoundPaths, this_ptr, SL("_notFoundPaths"), PH_NOISY_CC);
if (Z_TYPE_P(notFoundPaths) != IS_NULL) {
ZEPHIR_CPY_WRT(parts, notFoundPaths);
ZEPHIR_INIT_BNVAR(routeFound);
ZVAL_BOOL(routeFound, 1);
}
}
if (zephir_is_true(routeFound)) {
ZEPHIR_OBS_VAR(vnamespace);
if (zephir_array_isset_string_fetch(&vnamespace, parts, SS("namespace"), 0 TSRMLS_CC)) {
if (!(zephir_is_numeric(vnamespace))) {
zephir_update_property_this(this_ptr, SL("_namespace"), vnamespace TSRMLS_CC);
}
zephir_array_unset_string(&parts, SS("namespace"), PH_SEPARATE);
} else {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultNamespace"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_namespace"), _4 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(module);
if (zephir_array_isset_string_fetch(&module, parts, SS("module"), 0 TSRMLS_CC)) {
if (!(zephir_is_numeric(module))) {
zephir_update_property_this(this_ptr, SL("_module"), module TSRMLS_CC);
}
zephir_array_unset_string(&parts, SS("module"), PH_SEPARATE);
} else {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultModule"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_module"), _4 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(controller);
if (zephir_array_isset_string_fetch(&controller, parts, SS("controller"), 0 TSRMLS_CC)) {
if (!(zephir_is_numeric(controller))) {
zephir_update_property_this(this_ptr, SL("_controller"), controller TSRMLS_CC);
}
zephir_array_unset_string(&parts, SS("controller"), PH_SEPARATE);
} else {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultController"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_controller"), _4 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(action);
if (zephir_array_isset_string_fetch(&action, parts, SS("action"), 0 TSRMLS_CC)) {
if (!(zephir_is_numeric(action))) {
zephir_update_property_this(this_ptr, SL("_action"), action TSRMLS_CC);
}
zephir_array_unset_string(&parts, SS("action"), PH_SEPARATE);
} else {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAction"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_action"), _4 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(paramsStr);
if (zephir_array_isset_string_fetch(¶msStr, parts, SS("params"), 0 TSRMLS_CC)) {
ZEPHIR_SINIT_VAR(_11);
ZVAL_LONG(&_11, 1);
ZEPHIR_CALL_FUNCTION(&strParams, "substr", &_12, paramsStr, &_11);
zephir_check_call_status();
if (zephir_is_true(strParams)) {
ZEPHIR_INIT_BNVAR(params);
zephir_fast_explode_str(params, SL("/"), strParams, LONG_MAX TSRMLS_CC);
}
zephir_array_unset_string(&parts, SS("params"), PH_SEPARATE);
}
if (zephir_fast_count_int(params TSRMLS_CC)) {
ZEPHIR_INIT_VAR(paramsMerge);
zephir_fast_array_merge(paramsMerge, &(params), &(parts) TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(paramsMerge, parts);
}
zephir_update_property_this(this_ptr, SL("_params"), paramsMerge TSRMLS_CC);
} else {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultNamespace"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_namespace"), _4 TSRMLS_CC);
_13 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultModule"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_module"), _13 TSRMLS_CC);
_14 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultController"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_controller"), _14 TSRMLS_CC);
_15 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAction"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_action"), _15 TSRMLS_CC);
_16 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultParams"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_params"), _16 TSRMLS_CC);
}
ZEPHIR_MM_RESTORE();
}
/**
* This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
* Call it when you need to restore a database connection
*
*<code>
* //Make a connection
* $connection = new \Phalcon\Db\Adapter\Pdo\Mysql(array(
* 'host' => '192.168.0.11',
* 'username' => 'sigma',
* 'password' => 'secret',
* 'dbname' => 'blog',
* ));
*
* //Reconnect
* $connection->connect();
* </code>
*
* @param array descriptor
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, connect) {
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_1;
HashPosition _0;
zval *descriptor = NULL, *username = NULL, *password = NULL, *dsnParts, *dsnAttributes = NULL, *persistent, *options = NULL, *key = NULL, *value = NULL, **_2, *_3 = NULL, *_4, *_5, *_6;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &descriptor);
if (!descriptor) {
ZEPHIR_CPY_WRT(descriptor, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(descriptor);
}
if (Z_TYPE_P(descriptor) == IS_NULL) {
ZEPHIR_OBS_NVAR(descriptor);
zephir_read_property_this(&descriptor, this_ptr, SL("_descriptor"), PH_NOISY_CC);
}
ZEPHIR_OBS_VAR(username);
if (zephir_array_isset_string_fetch(&username, descriptor, SS("username"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&descriptor, SS("username"), PH_SEPARATE);
} else {
ZEPHIR_INIT_NVAR(username);
ZVAL_NULL(username);
}
ZEPHIR_OBS_VAR(password);
if (zephir_array_isset_string_fetch(&password, descriptor, SS("password"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&descriptor, SS("password"), PH_SEPARATE);
} else {
ZEPHIR_INIT_NVAR(password);
ZVAL_NULL(password);
}
ZEPHIR_OBS_VAR(options);
if (zephir_array_isset_string_fetch(&options, descriptor, SS("options"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&descriptor, SS("options"), PH_SEPARATE);
} else {
ZEPHIR_INIT_NVAR(options);
array_init(options);
}
ZEPHIR_OBS_VAR(dsnAttributes);
if (!(zephir_array_isset_string_fetch(&dsnAttributes, descriptor, SS("dsn"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_VAR(dsnParts);
array_init(dsnParts);
zephir_is_iterable(descriptor, &_1, &_0, 0, 0, "phalcon/db/adapter/pdo.zep", 130);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HMKEY(key, _1, _0);
ZEPHIR_GET_HVALUE(value, _2);
ZEPHIR_INIT_LNVAR(_3);
ZEPHIR_CONCAT_VSV(_3, key, "=", value);
zephir_array_append(&dsnParts, _3, PH_SEPARATE, "phalcon/db/adapter/pdo.zep", 128);
}
ZEPHIR_INIT_NVAR(dsnAttributes);
zephir_fast_join_str(dsnAttributes, SL(";"), dsnParts TSRMLS_CC);
}
ZEPHIR_INIT_VAR(_4);
ZVAL_LONG(_4, 2);
zephir_array_update_long(&options, 3, &_4, PH_COPY | PH_SEPARATE, "phalcon/db/adapter/pdo.zep", 133);
if (zephir_array_isset_string_fetch(&persistent, descriptor, SS("persistent"), 1 TSRMLS_CC)) {
if (zephir_is_true(persistent)) {
zephir_array_update_long(&options, 12, &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE, "phalcon/db/adapter/pdo.zep", 140);
}
}
ZEPHIR_INIT_VAR(_5);
object_init_ex(_5, php_pdo_get_dbh_ce());
_6 = zephir_fetch_nproperty_this(this_ptr, SL("_type"), PH_NOISY_CC);
ZEPHIR_INIT_LNVAR(_3);
ZEPHIR_CONCAT_VSV(_3, _6, ":", dsnAttributes);
ZEPHIR_CALL_METHOD(NULL, _5, "__construct", NULL, 0, _3, username, password, options);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_pdo"), _5 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
