/**
* Generates random text in accordance with the template
*
* <code>
* echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hi my name is a Bob
* echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hi my name is a Jon
* echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hello my name is a Bob
* </code>
*/
PHP_METHOD(Phalcon_Text, dynamic) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_1 = NULL, *_5 = NULL, *_7 = NULL;
zval *text_param = NULL, *leftDelimiter_param = NULL, *rightDelimiter_param = NULL, *separator_param = NULL, *ld_s = NULL, *rd_s = NULL, *result = NULL, *pattern, *_0 = NULL, *_2 = NULL, *_3 = NULL, *_6 = NULL;
zval *text = NULL, *leftDelimiter = NULL, *rightDelimiter = NULL, *separator = NULL, *_4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 3, &text_param, &leftDelimiter_param, &rightDelimiter_param, &separator_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 (!leftDelimiter_param) {
ZEPHIR_INIT_VAR(leftDelimiter);
ZVAL_STRING(leftDelimiter, "{", 1);
} else {
if (unlikely(Z_TYPE_P(leftDelimiter_param) != IS_STRING && Z_TYPE_P(leftDelimiter_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'leftDelimiter' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(leftDelimiter_param) == IS_STRING)) {
zephir_get_strval(leftDelimiter, leftDelimiter_param);
} else {
ZEPHIR_INIT_VAR(leftDelimiter);
ZVAL_EMPTY_STRING(leftDelimiter);
}
}
if (!rightDelimiter_param) {
ZEPHIR_INIT_VAR(rightDelimiter);
ZVAL_STRING(rightDelimiter, "}", 1);
} else {
if (unlikely(Z_TYPE_P(rightDelimiter_param) != IS_STRING && Z_TYPE_P(rightDelimiter_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'rightDelimiter' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(rightDelimiter_param) == IS_STRING)) {
zephir_get_strval(rightDelimiter, rightDelimiter_param);
} else {
ZEPHIR_INIT_VAR(rightDelimiter);
ZVAL_EMPTY_STRING(rightDelimiter);
}
}
if (!separator_param) {
ZEPHIR_INIT_VAR(separator);
ZVAL_STRING(separator, "|", 1);
} else {
if (unlikely(Z_TYPE_P(separator_param) != IS_STRING && Z_TYPE_P(separator_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'separator' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(separator_param) == IS_STRING)) {
zephir_get_strval(separator, separator_param);
} else {
ZEPHIR_INIT_VAR(separator);
ZVAL_EMPTY_STRING(separator);
}
}
ZEPHIR_CALL_FUNCTION(&_0, "substr_count", &_1, 420, text, leftDelimiter);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_2, "substr_count", &_1, 420, text, rightDelimiter);
zephir_check_call_status();
if (!ZEPHIR_IS_IDENTICAL(_0, _2)) {
ZEPHIR_INIT_VAR(_3);
object_init_ex(_3, spl_ce_RuntimeException);
ZEPHIR_INIT_VAR(_4);
ZEPHIR_CONCAT_SVS(_4, "Syntax error in string \"", text, "\"");
ZEPHIR_CALL_METHOD(NULL, _3, "__construct", NULL, 421, _4);
zephir_check_call_status();
zephir_throw_exception_debug(_3, "phalcon/text.zep", 265 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_CALL_FUNCTION(&ld_s, "preg_quote", &_5, 422, leftDelimiter);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&rd_s, "preg_quote", &_5, 422, rightDelimiter);
zephir_check_call_status();
ZEPHIR_INIT_VAR(pattern);
ZEPHIR_CONCAT_SVSVVSVS(pattern, "/", ld_s, "([^", ld_s, rd_s, "]+)", rd_s, "/");
ZEPHIR_CPY_WRT(result, text);
while (1) {
if (!(zephir_memnstr(result, leftDelimiter, "phalcon/text.zep", 273))) {
break;
}
ZEPHIR_INIT_NVAR(_3);
ZEPHIR_INIT_NVAR(_3);
zephir_create_closure_ex(_3, NULL, phalcon_0__closure_ce, SS("__invoke") TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_6, "preg_replace_callback", &_7, 423, pattern, _3, result);
zephir_check_call_status();
ZEPHIR_CPY_WRT(result, _6);
}
RETURN_CCTOR(result);
}
/**
* Magic method __get
*/
PHP_METHOD(Phalcon_Di_Injectable, __get) {
zval *_4;
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_1 = NULL;
zval *propertyName_param = NULL, *dependencyInjector = NULL, *service = NULL, *persistent = NULL, *_0, *_2 = NULL, *_3 = NULL, *_5 = NULL;
zval *propertyName = NULL, *_6;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &propertyName_param);
if (unlikely(Z_TYPE_P(propertyName_param) != IS_STRING && Z_TYPE_P(propertyName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'propertyName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(propertyName_param) == IS_STRING)) {
zephir_get_strval(propertyName, propertyName_param);
} else {
ZEPHIR_INIT_VAR(propertyName);
ZVAL_EMPTY_STRING(propertyName);
}
_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_CALL_CE_STATIC(&dependencyInjector, phalcon_di_ce, "getdefault", &_1, 1);
zephir_check_call_status();
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_di_exception_ce, "A dependency injection object is required to access the application services", "phalcon/di/injectable.zep", 127);
return;
}
}
ZEPHIR_CALL_METHOD(&_2, dependencyInjector, "has", NULL, 0, propertyName);
zephir_check_call_status();
if (zephir_is_true(_2)) {
ZEPHIR_CALL_METHOD(&service, dependencyInjector, "getshared", NULL, 0, propertyName);
zephir_check_call_status();
zephir_update_property_zval_zval(this_ptr, propertyName, service TSRMLS_CC);
RETURN_CCTOR(service);
}
if (ZEPHIR_IS_STRING(propertyName, "di")) {
zephir_update_property_zval(this_ptr, SL("di"), dependencyInjector TSRMLS_CC);
RETURN_CCTOR(dependencyInjector);
}
if (ZEPHIR_IS_STRING(propertyName, "persistent")) {
ZEPHIR_INIT_VAR(_4);
zephir_create_array(_4, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_5);
zephir_get_class(_5, this_ptr, 0 TSRMLS_CC);
zephir_array_fast_append(_4, _5);
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRING(_5, "sessionBag", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_3, dependencyInjector, "get", NULL, 0, _5, _4);
zephir_check_temp_parameter(_5);
zephir_check_call_status();
ZEPHIR_CPY_WRT(persistent, _3);
zephir_update_property_zval(this_ptr, SL("persistent"), persistent TSRMLS_CC);
RETURN_CCTOR(persistent);
}
ZEPHIR_INIT_VAR(_6);
ZEPHIR_CONCAT_SV(_6, "Access to undefined property ", propertyName);
ZEPHIR_CALL_FUNCTION(NULL, "trigger_error", NULL, 2, _6);
zephir_check_call_status();
RETURN_MM_NULL();
}
/**
* Updates every record in the resultset
*
* @param array data
* @param Closure conditionCallback
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, update) {
zval *_2 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zend_object_iterator *_0;
zend_bool transaction;
zval *data, *conditionCallback = NULL, *record = NULL, *connection = NULL, *_1 = NULL, *_3 = NULL, *_4 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &data, &conditionCallback);
if (!conditionCallback) {
conditionCallback = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_INIT_VAR(connection);
ZVAL_NULL(connection);
transaction = 0;
_0 = zephir_get_iterator(this_ptr TSRMLS_CC);
_0->funcs->rewind(_0 TSRMLS_CC);
for (;_0->funcs->valid(_0 TSRMLS_CC) == SUCCESS && !EG(exception); _0->funcs->move_forward(_0 TSRMLS_CC)) {
{
zval **ZEPHIR_TMP_ITERATOR_PTR;
_0->funcs->get_current_data(_0, &ZEPHIR_TMP_ITERATOR_PTR TSRMLS_CC);
ZEPHIR_CPY_WRT(record, (*ZEPHIR_TMP_ITERATOR_PTR));
}
if (transaction == 0) {
if (!((zephir_method_exists_ex(record, SS("getwriteconnection") TSRMLS_CC) == SUCCESS))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "The returned record is not valid", "phalcon/mvc/model/resultset.zep", 417);
return;
}
ZEPHIR_CALL_METHOD(&connection, record, "getwriteconnection", NULL);
zephir_check_call_status();
transaction = 1;
ZEPHIR_CALL_METHOD(NULL, connection, "begin", NULL);
zephir_check_call_status();
}
if (Z_TYPE_P(conditionCallback) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_1);
ZEPHIR_INIT_NVAR(_2);
zephir_create_array(_2, 1, 0 TSRMLS_CC);
zephir_array_fast_append(_2, record);
ZEPHIR_CALL_USER_FUNC_ARRAY(_1, conditionCallback, _2);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_1)) {
continue;
}
}
ZEPHIR_CALL_METHOD(&_3, record, "save", NULL, data);
zephir_check_call_status();
if (!(zephir_is_true(_3))) {
ZEPHIR_CALL_METHOD(&_4, record, "getmessages", NULL);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_errorMessages"), _4 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, connection, "rollback", NULL);
zephir_check_call_status();
transaction = 0;
break;
}
}
_0->funcs->dtor(_0 TSRMLS_CC);
if (transaction == 1) {
ZEPHIR_CALL_METHOD(NULL, connection, "commit", NULL);
zephir_check_call_status();
}
RETURN_MM_BOOL(1);
}
/**
* Dispatches a handle action taking into account the routing parameters
*
* @return object
*/
PHP_METHOD(Phalcon_Dispatcher, _dispatch) {
HashTable *_53$$39;
HashPosition _52$$39;
zval *_30$$6 = NULL, *_60$$44 = NULL, *_62$$44 = NULL, *_63$$44 = NULL, *_68$$45 = NULL, *_70$$45 = NULL;
zval *value = NULL, *handler = NULL, *dependencyInjector = NULL, *namespaceName = NULL, *handlerName = NULL, *actionName = NULL, *params = NULL, *eventsManager = NULL, *actionSuffix = NULL, *handlerClass = NULL, *status = NULL, *actionMethod = NULL, *reflectionMethod = NULL, *methodParams = NULL, *className = NULL, *paramKey = NULL, *methodParam = NULL, *modelName = NULL, *bindModel = NULL, *e = NULL, *_0, *_1$$3, *_2$$3, *_3$$4 = NULL, *_4$$4, *_5$$7 = NULL, *_6$$7 = NULL, *_10$$8 = NULL, *_11$$8 = NULL, *_13$$8, *_14$$6 = NULL, *_49$$6, *_16$$12 = NULL, *_17$$12 = NULL, *_19$$13, *_22$$16 = NULL, *_23$$16 = NULL, *_25$$17, *_26$$19 = NULL, *_27$$19 = NULL, *_29$$20, *_31$$23 = NULL, *_32$$23 = NULL, *_34$$23, *_35$$22 = NULL, *_36$$22 = NULL, *_38$$26, *_39$$28 = NULL, *_40$$28 = NULL, *_42$$28, *_43$$31 = NULL, *_44$$31, *_45$$36 = NULL, *_46$$36 = NULL, *_48$$36, **_54$$39, *_55$$40 = NULL, *_56$$41 = NULL, *_57$$43 = NULL, _59$$43 = zval_used_for_init, *_61$$44 = NULL, *_64$$44 = NULL, _65$$42 = zval_used_for_init, *_66$$42 = NULL, *_69$$45 = NULL, *_71$$45 = NULL, *_72$$46 = NULL, *_74$$47 = NULL, *_76$$48, *_77$$51 = NULL, *_78$$51 = NULL, *_80$$51, *_82$$54 = NULL, *_83$$54, *_84$$57;
zend_bool hasService = 0, wasFresh;
zephir_fcall_cache_entry *_7 = NULL, *_8 = NULL, *_9 = NULL, *_12 = NULL, *_15 = NULL, *_18 = NULL, *_20 = NULL, *_21 = NULL, *_24 = NULL, *_28 = NULL, *_33 = NULL, *_37 = NULL, *_41 = NULL, *_47 = NULL, *_50 = NULL, *_51 = NULL, *_58 = NULL, *_67 = NULL, *_73 = NULL, *_75 = NULL, *_79 = NULL, *_81 = NULL;
int ZEPHIR_LAST_CALL_STATUS, numberDispatches = 0;
ZEPHIR_MM_GROW();
wasFresh = 0;
_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_INIT_VAR(_1$$3);
ZVAL_STRING(_1$$3, "A dependency injection container is required to access related dispatching services", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_2$$3);
ZVAL_LONG(_2$$3, 0);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_throwdispatchexception", NULL, 0, _1$$3, _2$$3);
zephir_check_temp_parameter(_1$$3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(eventsManager, _0);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_4$$4);
ZVAL_STRING(_4$$4, "dispatch:beforeDispatchLoop", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_3$$4, eventsManager, "fire", NULL, 0, _4$$4, this_ptr);
zephir_check_temp_parameter(_4$$4);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_3$$4)) {
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_VAR(value);
ZVAL_NULL(value);
ZEPHIR_INIT_VAR(handler);
ZVAL_NULL(handler);
numberDispatches = 0;
ZEPHIR_OBS_VAR(actionSuffix);
zephir_read_property_this(&actionSuffix, this_ptr, SL("_actionSuffix"), PH_NOISY_CC);
if (0) {
zephir_update_property_this(this_ptr, SL("_finished"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_finished"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
while (1) {
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (!(!(zephir_is_true(_0)))) {
break;
}
numberDispatches++;
if (numberDispatches == 256) {
ZEPHIR_INIT_NVAR(_5$$7);
ZVAL_STRING(_5$$7, "Dispatcher has detected a cyclic routing causing stability problems", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_6$$7);
ZVAL_LONG(_6$$7, 1);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_throwdispatchexception", &_7, 0, _5$$7, _6$$7);
zephir_check_temp_parameter(_5$$7);
zephir_check_call_status();
break;
}
if (1) {
zephir_update_property_this(this_ptr, SL("_finished"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_finished"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_resolveemptyproperties", &_8, 0);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(namespaceName);
zephir_read_property_this(&namespaceName, this_ptr, SL("_namespaceName"), PH_NOISY_CC);
ZEPHIR_OBS_NVAR(handlerName);
zephir_read_property_this(&handlerName, this_ptr, SL("_handlerName"), PH_NOISY_CC);
ZEPHIR_OBS_NVAR(actionName);
zephir_read_property_this(&actionName, this_ptr, SL("_actionName"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&handlerClass, this_ptr, "gethandlerclass", &_9, 0);
zephir_check_call_status();
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_11$$8);
ZVAL_STRING(_11$$8, "dispatch:beforeDispatch", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_10$$8, eventsManager, "fire", &_12, 0, _11$$8, this_ptr);
zephir_check_temp_parameter(_11$$8);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_10$$8)) {
continue;
}
_13$$8 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_13$$8)) {
continue;
}
}
ZEPHIR_CALL_METHOD(&_14$$6, dependencyInjector, "has", &_15, 0, handlerClass);
zephir_check_call_status();
hasService = zephir_get_boolval(_14$$6);
if (!(hasService)) {
hasService = zephir_class_exists(handlerClass, 1 TSRMLS_CC);
}
if (!(hasService)) {
ZEPHIR_INIT_LNVAR(_16$$12);
ZEPHIR_CONCAT_VS(_16$$12, handlerClass, " handler class cannot be loaded");
ZEPHIR_INIT_NVAR(_17$$12);
ZVAL_LONG(_17$$12, 2);
ZEPHIR_CALL_METHOD(&status, this_ptr, "_throwdispatchexception", &_18, 0, _16$$12, _17$$12);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(status)) {
_19$$13 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_19$$13)) {
continue;
}
}
break;
}
ZEPHIR_CALL_METHOD(&handler, dependencyInjector, "getshared", &_20, 0, handlerClass);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_14$$6, dependencyInjector, "wasfreshinstance", &_21, 0);
zephir_check_call_status();
if (ZEPHIR_IS_TRUE_IDENTICAL(_14$$6)) {
wasFresh = 1;
}
if (Z_TYPE_P(handler) != IS_OBJECT) {
ZEPHIR_INIT_NVAR(_22$$16);
ZVAL_STRING(_22$$16, "Invalid handler returned from the services container", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_23$$16);
ZVAL_LONG(_23$$16, 3);
ZEPHIR_CALL_METHOD(&status, this_ptr, "_throwdispatchexception", &_24, 0, _22$$16, _23$$16);
zephir_check_temp_parameter(_22$$16);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(status)) {
_25$$17 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_25$$17)) {
continue;
}
}
break;
}
zephir_update_property_this(this_ptr, SL("_activeHandler"), handler TSRMLS_CC);
ZEPHIR_OBS_NVAR(params);
zephir_read_property_this(¶ms, this_ptr, SL("_params"), PH_NOISY_CC);
if (Z_TYPE_P(params) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(_26$$19);
ZVAL_STRING(_26$$19, "Action parameters must be an Array", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_27$$19);
ZVAL_LONG(_27$$19, 4);
ZEPHIR_CALL_METHOD(&status, this_ptr, "_throwdispatchexception", &_28, 0, _26$$19, _27$$19);
zephir_check_temp_parameter(_26$$19);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(status)) {
_29$$20 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_29$$20)) {
continue;
}
}
break;
}
ZEPHIR_INIT_NVAR(actionMethod);
ZEPHIR_CONCAT_VV(actionMethod, actionName, actionSuffix);
ZEPHIR_INIT_NVAR(_30$$6);
zephir_create_array(_30$$6, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_30$$6, handler);
zephir_array_fast_append(_30$$6, actionMethod);
if (!(zephir_is_callable(_30$$6 TSRMLS_CC))) {
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_32$$23);
ZVAL_STRING(_32$$23, "dispatch:beforeNotFoundAction", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_31$$23, eventsManager, "fire", &_33, 0, _32$$23, this_ptr);
zephir_check_temp_parameter(_32$$23);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_31$$23)) {
continue;
}
_34$$23 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_34$$23)) {
continue;
}
}
ZEPHIR_INIT_LNVAR(_35$$22);
ZEPHIR_CONCAT_SVSVS(_35$$22, "Action '", actionName, "' was not found on handler '", handlerName, "'");
ZEPHIR_INIT_NVAR(_36$$22);
ZVAL_LONG(_36$$22, 5);
ZEPHIR_CALL_METHOD(&status, this_ptr, "_throwdispatchexception", &_37, 0, _35$$22, _36$$22);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(status)) {
_38$$26 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_38$$26)) {
continue;
}
}
break;
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_40$$28);
ZVAL_STRING(_40$$28, "dispatch:beforeExecuteRoute", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_39$$28, eventsManager, "fire", &_41, 0, _40$$28, this_ptr);
zephir_check_temp_parameter(_40$$28);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_39$$28)) {
continue;
}
_42$$28 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_42$$28)) {
continue;
}
}
if ((zephir_method_exists_ex(handler, SS("beforeexecuteroute") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(&_43$$31, handler, "beforeexecuteroute", NULL, 0, this_ptr);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_43$$31)) {
continue;
}
_44$$31 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_44$$31)) {
continue;
}
}
if (wasFresh == 1) {
if ((zephir_method_exists_ex(handler, SS("initialize") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(NULL, handler, "initialize", NULL, 0);
zephir_check_call_status();
}
if (zephir_is_true(eventsManager)) {
ZEPHIR_INIT_NVAR(_46$$36);
ZVAL_STRING(_46$$36, "dispatch:afterInitialize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_45$$36, eventsManager, "fire", &_47, 0, _46$$36, this_ptr);
zephir_check_temp_parameter(_46$$36);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_45$$36)) {
continue;
}
_48$$36 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_48$$36)) {
continue;
}
}
}
_49$$6 = zephir_fetch_nproperty_this(this_ptr, SL("_modelBinding"), PH_NOISY_CC);
if (ZEPHIR_IS_TRUE_IDENTICAL(_49$$6)) {
ZEPHIR_INIT_NVAR(reflectionMethod);
object_init_ex(reflectionMethod, zephir_get_internal_ce(SS("reflectionmethod") TSRMLS_CC));
ZEPHIR_CALL_METHOD(NULL, reflectionMethod, "__construct", &_50, 69, handlerClass, actionMethod);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&methodParams, reflectionMethod, "getparameters", &_51, 70);
zephir_check_call_status();
zephir_is_iterable(methodParams, &_53$$39, &_52$$39, 0, 0, "phalcon/dispatcher.zep", 582);
for (
; zephir_hash_get_current_data_ex(_53$$39, (void**) &_54$$39, &_52$$39) == SUCCESS
; zephir_hash_move_forward_ex(_53$$39, &_52$$39)
) {
ZEPHIR_GET_HMKEY(paramKey, _53$$39, _52$$39);
ZEPHIR_GET_HVALUE(methodParam, _54$$39);
ZEPHIR_CALL_METHOD(&_55$$40, methodParam, "getclass", NULL, 0);
zephir_check_call_status();
if (zephir_is_true(_55$$40)) {
ZEPHIR_CALL_METHOD(&_56$$41, methodParam, "getclass", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&className, _56$$41, "getname", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(className) == IS_STRING) {
if (ZEPHIR_IS_STRING(className, "Phalcon\\Mvc\\Model")) {
ZEPHIR_CALL_FUNCTION(&_57$$43, "class_implements", &_58, 71, handlerClass);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_59$$43);
ZVAL_STRING(&_59$$43, "Phalcon\\Mvc\\Controller\\BindModelInterface", 0);
if (zephir_fast_in_array(&_59$$43, _57$$43 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_60$$44);
zephir_create_array(_60$$44, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_60$$44, handlerClass);
ZEPHIR_INIT_NVAR(_61$$44);
ZVAL_STRING(_61$$44, "getModelName", 1);
zephir_array_fast_append(_60$$44, _61$$44);
ZEPHIR_INIT_NVAR(modelName);
ZEPHIR_CALL_USER_FUNC(modelName, _60$$44);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_62$$44);
zephir_create_array(_62$$44, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_62$$44, modelName);
ZEPHIR_INIT_NVAR(_61$$44);
ZVAL_STRING(_61$$44, "findFirst", 1);
zephir_array_fast_append(_62$$44, _61$$44);
ZEPHIR_INIT_NVAR(_63$$44);
zephir_create_array(_63$$44, 1, 0 TSRMLS_CC);
ZEPHIR_OBS_NVAR(_64$$44);
zephir_array_fetch(&_64$$44, params, paramKey, PH_NOISY, "phalcon/dispatcher.zep", 567 TSRMLS_CC);
zephir_array_fast_append(_63$$44, _64$$44);
ZEPHIR_INIT_NVAR(bindModel);
ZEPHIR_CALL_USER_FUNC_ARRAY(bindModel, _62$$44, _63$$44);
zephir_check_call_status();
zephir_array_update_zval(¶ms, paramKey, &bindModel, PH_COPY | PH_SEPARATE);
break;
}
}
ZEPHIR_SINIT_NVAR(_65$$42);
ZVAL_STRING(&_65$$42, "Phalcon\\Mvc\\Model", 0);
ZEPHIR_CALL_FUNCTION(&_66$$42, "is_subclass_of", &_67, 72, className, &_65$$42);
zephir_check_call_status();
if (zephir_is_true(_66$$42)) {
ZEPHIR_INIT_NVAR(_68$$45);
zephir_create_array(_68$$45, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_68$$45, className);
ZEPHIR_INIT_NVAR(_69$$45);
ZVAL_STRING(_69$$45, "findFirst", 1);
zephir_array_fast_append(_68$$45, _69$$45);
ZEPHIR_INIT_NVAR(_70$$45);
zephir_create_array(_70$$45, 1, 0 TSRMLS_CC);
ZEPHIR_OBS_NVAR(_71$$45);
zephir_array_fetch(&_71$$45, params, paramKey, PH_NOISY, "phalcon/dispatcher.zep", 575 TSRMLS_CC);
zephir_array_fast_append(_70$$45, _71$$45);
ZEPHIR_INIT_NVAR(bindModel);
ZEPHIR_CALL_USER_FUNC_ARRAY(bindModel, _68$$45, _70$$45);
zephir_check_call_status();
zephir_array_update_zval(¶ms, paramKey, &bindModel, PH_COPY | PH_SEPARATE);
break;
}
}
}
}
}
zephir_update_property_this(this_ptr, SL("_lastHandler"), handler TSRMLS_CC);
/* try_start_1: */
ZEPHIR_CALL_METHOD(&_72$$46, this_ptr, "callactionmethod", &_73, 0, handler, actionMethod, params);
zephir_check_call_status_or_jump(try_end_1);
zephir_update_property_this(this_ptr, SL("_returnedValue"), _72$$46 TSRMLS_CC);
try_end_1:
if (EG(exception)) {
ZEPHIR_CPY_WRT(e, EG(exception));
if (zephir_instance_of_ev(e, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) {
zend_clear_exception(TSRMLS_C);
ZEPHIR_CALL_METHOD(&_74$$47, this_ptr, "_handleexception", &_75, 0, e);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_74$$47)) {
_76$$48 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_76$$48)) {
continue;
}
} else {
zephir_throw_exception_debug(e, "phalcon/dispatcher.zep", 595 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_78$$51);
ZVAL_STRING(_78$$51, "dispatch:afterExecuteRoute", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_77$$51, eventsManager, "fire", &_79, 0, _78$$51, this_ptr, value);
zephir_check_temp_parameter(_78$$51);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_77$$51)) {
continue;
}
_80$$51 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_80$$51)) {
continue;
}
ZEPHIR_INIT_NVAR(_78$$51);
ZVAL_STRING(_78$$51, "dispatch:afterDispatch", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", &_81, 0, _78$$51, this_ptr);
zephir_check_temp_parameter(_78$$51);
zephir_check_call_status();
}
if ((zephir_method_exists_ex(handler, SS("afterexecuteroute") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(&_82$$54, handler, "afterexecuteroute", NULL, 0, this_ptr, value);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_82$$54)) {
continue;
}
_83$$54 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_83$$54)) {
continue;
}
}
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_84$$57);
ZVAL_STRING(_84$$57, "dispatch:afterDispatchLoop", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _84$$57, this_ptr);
zephir_check_temp_parameter(_84$$57);
zephir_check_call_status();
}
RETURN_CCTOR(handler);
}
/**
* Returns routePaths
*/
PHP_METHOD(Phalcon_Mvc_Router_Route, getRoutePaths) {
int _0$$4;
zval *paths = NULL, *moduleName = NULL, *controllerName = NULL, *actionName = NULL, *parts = NULL, *routePaths = NULL, *realClassName = NULL, *namespaceName = NULL, *_1$$9;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &paths);
if (!paths) {
paths = ZEPHIR_GLOBAL(global_null);
}
if (Z_TYPE_P(paths) != IS_NULL) {
if (Z_TYPE_P(paths) == IS_STRING) {
ZEPHIR_INIT_VAR(moduleName);
ZVAL_NULL(moduleName);
ZEPHIR_INIT_VAR(controllerName);
ZVAL_NULL(controllerName);
ZEPHIR_INIT_VAR(actionName);
ZVAL_NULL(actionName);
ZEPHIR_INIT_VAR(parts);
zephir_fast_explode_str(parts, SL("::"), paths, LONG_MAX TSRMLS_CC);
do {
_0$$4 = zephir_fast_count_int(parts TSRMLS_CC);
if (_0$$4 == 3) {
ZEPHIR_OBS_NVAR(moduleName);
zephir_array_fetch_long(&moduleName, parts, 0, PH_NOISY, "phalcon/mvc/router/route.zep", 353 TSRMLS_CC);
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 1, PH_NOISY, "phalcon/mvc/router/route.zep", 354 TSRMLS_CC);
ZEPHIR_OBS_NVAR(actionName);
zephir_array_fetch_long(&actionName, parts, 2, PH_NOISY, "phalcon/mvc/router/route.zep", 355 TSRMLS_CC);
break;
}
if (_0$$4 == 2) {
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY, "phalcon/mvc/router/route.zep", 359 TSRMLS_CC);
ZEPHIR_OBS_NVAR(actionName);
zephir_array_fetch_long(&actionName, parts, 1, PH_NOISY, "phalcon/mvc/router/route.zep", 360 TSRMLS_CC);
break;
}
if (_0$$4 == 1) {
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY, "phalcon/mvc/router/route.zep", 364 TSRMLS_CC);
break;
}
} while(0);
ZEPHIR_INIT_VAR(routePaths);
array_init(routePaths);
if (Z_TYPE_P(moduleName) != IS_NULL) {
zephir_array_update_string(&routePaths, SL("module"), &moduleName, PH_COPY | PH_SEPARATE);
}
if (Z_TYPE_P(controllerName) != IS_NULL) {
if (zephir_memnstr_str(controllerName, SL("\\"), "phalcon/mvc/router/route.zep", 379)) {
ZEPHIR_INIT_VAR(realClassName);
zephir_get_class_ns(realClassName, controllerName, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(namespaceName);
zephir_get_ns_class(namespaceName, controllerName, 0 TSRMLS_CC);
if (zephir_is_true(namespaceName)) {
zephir_array_update_string(&routePaths, SL("namespace"), &namespaceName, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_CPY_WRT(realClassName, controllerName);
}
ZEPHIR_INIT_VAR(_1$$9);
zephir_uncamelize(_1$$9, realClassName);
zephir_array_update_string(&routePaths, SL("controller"), &_1$$9, PH_COPY | PH_SEPARATE);
}
if (Z_TYPE_P(actionName) != IS_NULL) {
zephir_array_update_string(&routePaths, SL("action"), &actionName, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_CPY_WRT(routePaths, paths);
}
} else {
ZEPHIR_INIT_NVAR(routePaths);
array_init(routePaths);
}
if (Z_TYPE_P(routePaths) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_router_exception_ce, "The route contains invalid paths", "phalcon/mvc/router/route.zep", 411);
return;
}
RETURN_CCTOR(routePaths);
}
/**
* Returns an array of Phalcon\Db\Column objects describing a table
*
* <code>
* print_r($connection->describeColumns("posts"));
* </code>
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeColumns) {
zend_bool _11$$4, _36$$3;
HashTable *_5;
HashPosition _4;
zephir_fcall_cache_entry *_35 = NULL, *_42 = NULL, *_44 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *table_param = NULL, *schema_param = NULL, *columns = NULL, *columnType = NULL, *field = NULL, *definition = NULL, *oldColumn = NULL, *sizePattern = NULL, *matches = NULL, *matchOne = NULL, *matchTwo = NULL, *columnName = NULL, *_0 = NULL, *_1, *_2 = NULL, *_3, **_6, *_7$$5 = NULL, *_8$$5 = NULL, *_9$$6 = NULL, *_10$$6 = NULL, *_26$$4 = NULL, *_12$$7 = NULL, *_13$$7 = NULL, *_14$$7, *_15$$9 = NULL, *_16$$10 = NULL, *_17$$11 = NULL, *_18$$12 = NULL, *_19$$12 = NULL, *_20$$13 = NULL, *_21$$14 = NULL, *_22$$15 = NULL, *_23$$16 = NULL, *_24$$16 = NULL, *_25$$17 = NULL, *_27$$18 = NULL, *_28$$20 = NULL, *_29$$21 = NULL, *_30$$3, *_31$$3, *_32$$3, _33$$3 = zval_used_for_init, *_34$$3 = NULL, *_37$$3, *_43$$3 = NULL, *_38$$27, *_39$$27 = NULL, *_40$$27 = NULL, *_41$$27 = NULL;
zval *table = NULL, *schema = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &table_param, &schema_param);
zephir_get_strval(table, table_param);
if (!schema_param) {
ZEPHIR_INIT_VAR(schema);
ZVAL_EMPTY_STRING(schema);
} else {
zephir_get_strval(schema, schema_param);
}
ZEPHIR_INIT_VAR(oldColumn);
ZVAL_NULL(oldColumn);
ZEPHIR_INIT_VAR(sizePattern);
ZVAL_STRING(sizePattern, "#\\(([0-9]+)(?:,\\s*([0-9]+))*\\)#", 1);
ZEPHIR_INIT_VAR(columns);
array_init(columns);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_dialect"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_2, _1, "describecolumns", NULL, 0, table, schema);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_3);
ZVAL_LONG(_3, 3);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "fetchall", NULL, 0, _2, _3);
zephir_check_call_status();
zephir_is_iterable(_0, &_5, &_4, 0, 0, "phalcon/db/adapter/pdo/sqlite.zep", 286);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HVALUE(field, _6);
ZEPHIR_INIT_NVAR(definition);
zephir_create_array(definition, 1, 0 TSRMLS_CC);
add_assoc_long_ex(definition, SS("bindType"), 2);
ZEPHIR_OBS_NVAR(columnType);
zephir_array_fetch_long(&columnType, field, 2, PH_NOISY, "phalcon/db/adapter/pdo/sqlite.zep", 103 TSRMLS_CC);
while (1) {
if (zephir_memnstr_str(columnType, SL("tinyint(1)"), "phalcon/db/adapter/pdo/sqlite.zep", 110)) {
ZEPHIR_INIT_NVAR(_7$$5);
ZVAL_LONG(_7$$5, 8);
zephir_array_update_string(&definition, SL("type"), &_7$$5, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_8$$5);
ZVAL_LONG(_8$$5, 5);
zephir_array_update_string(&definition, SL("bindType"), &_8$$5, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(columnType);
ZVAL_STRING(columnType, "boolean", 1);
break;
}
if (zephir_memnstr_str(columnType, SL("bigint"), "phalcon/db/adapter/pdo/sqlite.zep", 120)) {
ZEPHIR_INIT_NVAR(_9$$6);
ZVAL_LONG(_9$$6, 14);
zephir_array_update_string(&definition, SL("type"), &_9$$6, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_10$$6);
ZVAL_LONG(_10$$6, 1);
zephir_array_update_string(&definition, SL("bindType"), &_10$$6, PH_COPY | PH_SEPARATE);
break;
}
_11$$4 = zephir_memnstr_str(columnType, SL("int"), "phalcon/db/adapter/pdo/sqlite.zep", 130);
if (!(_11$$4)) {
_11$$4 = zephir_memnstr_str(columnType, SL("INT"), "phalcon/db/adapter/pdo/sqlite.zep", 130);
}
if (_11$$4) {
ZEPHIR_INIT_NVAR(_12$$7);
ZVAL_LONG(_12$$7, 0);
zephir_array_update_string(&definition, SL("type"), &_12$$7, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_13$$7);
ZVAL_LONG(_13$$7, 1);
zephir_array_update_string(&definition, SL("bindType"), &_13$$7, PH_COPY | PH_SEPARATE);
zephir_array_fetch_long(&_14$$7, field, 5, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 136 TSRMLS_CC);
if (zephir_is_true(_14$$7)) {
zephir_array_update_string(&definition, SL("autoIncrement"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
break;
}
if (zephir_memnstr_str(columnType, SL("varchar"), "phalcon/db/adapter/pdo/sqlite.zep", 145)) {
ZEPHIR_INIT_NVAR(_15$$9);
ZVAL_LONG(_15$$9, 2);
zephir_array_update_string(&definition, SL("type"), &_15$$9, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("date"), "phalcon/db/adapter/pdo/sqlite.zep", 153)) {
ZEPHIR_INIT_NVAR(_16$$10);
ZVAL_LONG(_16$$10, 1);
zephir_array_update_string(&definition, SL("type"), &_16$$10, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("timestamp"), "phalcon/db/adapter/pdo/sqlite.zep", 161)) {
ZEPHIR_INIT_NVAR(_17$$11);
ZVAL_LONG(_17$$11, 17);
zephir_array_update_string(&definition, SL("type"), &_17$$11, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("decimal"), "phalcon/db/adapter/pdo/sqlite.zep", 169)) {
ZEPHIR_INIT_NVAR(_18$$12);
ZVAL_LONG(_18$$12, 3);
zephir_array_update_string(&definition, SL("type"), &_18$$12, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_19$$12);
ZVAL_LONG(_19$$12, 32);
zephir_array_update_string(&definition, SL("bindType"), &_19$$12, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("char"), "phalcon/db/adapter/pdo/sqlite.zep", 179)) {
ZEPHIR_INIT_NVAR(_20$$13);
ZVAL_LONG(_20$$13, 5);
zephir_array_update_string(&definition, SL("type"), &_20$$13, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("datetime"), "phalcon/db/adapter/pdo/sqlite.zep", 187)) {
ZEPHIR_INIT_NVAR(_21$$14);
ZVAL_LONG(_21$$14, 4);
zephir_array_update_string(&definition, SL("type"), &_21$$14, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("text"), "phalcon/db/adapter/pdo/sqlite.zep", 195)) {
ZEPHIR_INIT_NVAR(_22$$15);
ZVAL_LONG(_22$$15, 6);
zephir_array_update_string(&definition, SL("type"), &_22$$15, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("float"), "phalcon/db/adapter/pdo/sqlite.zep", 203)) {
ZEPHIR_INIT_NVAR(_23$$16);
ZVAL_LONG(_23$$16, 7);
zephir_array_update_string(&definition, SL("type"), &_23$$16, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_24$$16);
ZVAL_LONG(_24$$16, 3);
zephir_array_update_string(&definition, SL("bindType"), &_24$$16, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("enum"), "phalcon/db/adapter/pdo/sqlite.zep", 213)) {
ZEPHIR_INIT_NVAR(_25$$17);
ZVAL_LONG(_25$$17, 5);
zephir_array_update_string(&definition, SL("type"), &_25$$17, PH_COPY | PH_SEPARATE);
break;
}
ZEPHIR_INIT_NVAR(_26$$4);
ZVAL_LONG(_26$$4, 2);
zephir_array_update_string(&definition, SL("type"), &_26$$4, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("("), "phalcon/db/adapter/pdo/sqlite.zep", 228)) {
ZEPHIR_INIT_NVAR(matches);
ZVAL_NULL(matches);
ZEPHIR_INIT_NVAR(_27$$18);
zephir_preg_match(_27$$18, sizePattern, columnType, matches, 0, 0 , 0 TSRMLS_CC);
if (zephir_is_true(_27$$18)) {
ZEPHIR_OBS_NVAR(matchOne);
if (zephir_array_isset_long_fetch(&matchOne, matches, 1, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_28$$20);
ZVAL_LONG(_28$$20, zephir_get_intval(matchOne));
zephir_array_update_string(&definition, SL("size"), &_28$$20, PH_COPY | PH_SEPARATE);
}
ZEPHIR_OBS_NVAR(matchTwo);
if (zephir_array_isset_long_fetch(&matchTwo, matches, 2, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_29$$21);
ZVAL_LONG(_29$$21, zephir_get_intval(matchTwo));
zephir_array_update_string(&definition, SL("scale"), &_29$$21, PH_COPY | PH_SEPARATE);
}
}
}
if (zephir_memnstr_str(columnType, SL("unsigned"), "phalcon/db/adapter/pdo/sqlite.zep", 243)) {
zephir_array_update_string(&definition, SL("unsigned"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
if (Z_TYPE_P(oldColumn) == IS_NULL) {
zephir_array_update_string(&definition, SL("first"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
} else {
zephir_array_update_string(&definition, SL("after"), &oldColumn, PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&_30$$3, field, 5, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 259 TSRMLS_CC);
if (zephir_is_true(_30$$3)) {
zephir_array_update_string(&definition, SL("primary"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&_31$$3, field, 3, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 266 TSRMLS_CC);
if (zephir_is_true(_31$$3)) {
zephir_array_update_string(&definition, SL("notNull"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&_32$$3, field, 4, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 274 TSRMLS_CC);
ZEPHIR_SINIT_NVAR(_33$$3);
ZVAL_STRING(&_33$$3, "null", 0);
ZEPHIR_CALL_FUNCTION(&_34$$3, "strcasecmp", &_35, 16, _32$$3, &_33$$3);
zephir_check_call_status();
_36$$3 = !ZEPHIR_IS_LONG(_34$$3, 0);
if (_36$$3) {
zephir_array_fetch_long(&_37$$3, field, 4, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 274 TSRMLS_CC);
_36$$3 = !ZEPHIR_IS_STRING(_37$$3, "");
}
if (_36$$3) {
zephir_array_fetch_long(&_38$$27, field, 4, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 275 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_39$$27);
ZVAL_STRING(_39$$27, "/^'|'$/", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_40$$27);
ZVAL_STRING(_40$$27, "", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_FUNCTION(&_41$$27, "preg_replace", &_42, 39, _39$$27, _40$$27, _38$$27);
zephir_check_temp_parameter(_39$$27);
zephir_check_temp_parameter(_40$$27);
zephir_check_call_status();
zephir_array_update_string(&definition, SL("default"), &_41$$27, PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&columnName, field, 1, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 281 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_43$$3);
object_init_ex(_43$$3, phalcon_db_column_ce);
ZEPHIR_CALL_METHOD(NULL, _43$$3, "__construct", &_44, 151, columnName, definition);
zephir_check_call_status();
zephir_array_append(&columns, _43$$3, PH_SEPARATE, "phalcon/db/adapter/pdo/sqlite.zep", 282);
ZEPHIR_CPY_WRT(oldColumn, columnName);
}
RETURN_CCTOR(columns);
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_File, validate) {
zend_bool _1, _2, _3, _5, _6, _11, _12, _14, _20, _21, _50, _57$$16, _64$$21;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *validation, validation_sub, *field, field_sub, *_SERVER, *_POST, *_FILES, value, message, label, replacePairs, types, byteUnits, unit, maxSize, matches, bytes, mime, tmp, width, height, minResolution, maxResolution, minWidth, maxWidth, minHeight, maxHeight, fieldTypes, code, minResolutionArray, maxResolutionArray, _0, _4, _7, _13, _15, _16, _25, _26, _42, _49, _51, _8$$3, _9$$3, _10$$3, _17$$4, _18$$4, _19$$4, _22$$5, _23$$5, _24$$5, _27$$6, _29$$6, _30$$6, _31$$6, _32$$6, _33$$6, _34$$6, _35$$6, _36$$6, _37$$6, _38$$6, _28$$7, _39$$9, _40$$9, _41$$9, _43$$10, _44$$13, _45$$13, _46$$15, _47$$15, _48$$15, _52$$16, _53$$16, _54$$16, _61$$16, _55$$17, _56$$18, _58$$20, _59$$20, _60$$20, _62$$21, _63$$22, _65$$23, _66$$23, _67$$23;
zval *this_ptr = getThis();
ZVAL_UNDEF(&validation_sub);
ZVAL_UNDEF(&field_sub);
ZVAL_UNDEF(&value);
ZVAL_UNDEF(&message);
ZVAL_UNDEF(&label);
ZVAL_UNDEF(&replacePairs);
ZVAL_UNDEF(&types);
ZVAL_UNDEF(&byteUnits);
ZVAL_UNDEF(&unit);
ZVAL_UNDEF(&maxSize);
ZVAL_UNDEF(&matches);
ZVAL_UNDEF(&bytes);
ZVAL_UNDEF(&mime);
ZVAL_UNDEF(&tmp);
ZVAL_UNDEF(&width);
ZVAL_UNDEF(&height);
ZVAL_UNDEF(&minResolution);
ZVAL_UNDEF(&maxResolution);
ZVAL_UNDEF(&minWidth);
ZVAL_UNDEF(&maxWidth);
ZVAL_UNDEF(&minHeight);
ZVAL_UNDEF(&maxHeight);
ZVAL_UNDEF(&fieldTypes);
ZVAL_UNDEF(&code);
ZVAL_UNDEF(&minResolutionArray);
ZVAL_UNDEF(&maxResolutionArray);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_4);
ZVAL_UNDEF(&_7);
ZVAL_UNDEF(&_13);
ZVAL_UNDEF(&_15);
ZVAL_UNDEF(&_16);
ZVAL_UNDEF(&_25);
ZVAL_UNDEF(&_26);
ZVAL_UNDEF(&_42);
ZVAL_UNDEF(&_49);
ZVAL_UNDEF(&_51);
ZVAL_UNDEF(&_8$$3);
ZVAL_UNDEF(&_9$$3);
ZVAL_UNDEF(&_10$$3);
ZVAL_UNDEF(&_17$$4);
ZVAL_UNDEF(&_18$$4);
ZVAL_UNDEF(&_19$$4);
ZVAL_UNDEF(&_22$$5);
ZVAL_UNDEF(&_23$$5);
ZVAL_UNDEF(&_24$$5);
ZVAL_UNDEF(&_27$$6);
ZVAL_UNDEF(&_29$$6);
ZVAL_UNDEF(&_30$$6);
ZVAL_UNDEF(&_31$$6);
ZVAL_UNDEF(&_32$$6);
ZVAL_UNDEF(&_33$$6);
ZVAL_UNDEF(&_34$$6);
ZVAL_UNDEF(&_35$$6);
ZVAL_UNDEF(&_36$$6);
ZVAL_UNDEF(&_37$$6);
ZVAL_UNDEF(&_38$$6);
ZVAL_UNDEF(&_28$$7);
ZVAL_UNDEF(&_39$$9);
ZVAL_UNDEF(&_40$$9);
ZVAL_UNDEF(&_41$$9);
ZVAL_UNDEF(&_43$$10);
ZVAL_UNDEF(&_44$$13);
ZVAL_UNDEF(&_45$$13);
ZVAL_UNDEF(&_46$$15);
ZVAL_UNDEF(&_47$$15);
ZVAL_UNDEF(&_48$$15);
ZVAL_UNDEF(&_52$$16);
ZVAL_UNDEF(&_53$$16);
ZVAL_UNDEF(&_54$$16);
ZVAL_UNDEF(&_61$$16);
ZVAL_UNDEF(&_55$$17);
ZVAL_UNDEF(&_56$$18);
ZVAL_UNDEF(&_58$$20);
ZVAL_UNDEF(&_59$$20);
ZVAL_UNDEF(&_60$$20);
ZVAL_UNDEF(&_62$$21);
ZVAL_UNDEF(&_63$$22);
ZVAL_UNDEF(&_65$$23);
ZVAL_UNDEF(&_66$$23);
ZVAL_UNDEF(&_67$$23);
ZEPHIR_MM_GROW();
zephir_get_global(&_FILES, SL("_FILES"));
zephir_get_global(&_POST, SL("_POST"));
zephir_get_global(&_SERVER, SL("_SERVER"));
zephir_fetch_params(1, 2, 0, &validation, &field);
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&label, this_ptr, "preparelabel", NULL, 0, validation, field);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&code, this_ptr, "preparecode", NULL, 0, field);
zephir_check_call_status();
zephir_array_fetch_string(&_0, _SERVER, SL("REQUEST_METHOD"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 103 TSRMLS_CC);
_1 = ZEPHIR_IS_STRING(&_0, "POST");
if (_1) {
_1 = ZEPHIR_IS_EMPTY(_POST);
}
_2 = _1;
if (_2) {
_2 = ZEPHIR_IS_EMPTY(_FILES);
}
_3 = _2;
if (_3) {
zephir_array_fetch_string(&_4, _SERVER, SL("CONTENT_LENGTH"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 103 TSRMLS_CC);
_3 = ZEPHIR_GT_LONG(&_4, 0);
}
_5 = _3;
if (!(_5)) {
_6 = zephir_array_isset_string(&value, SL("error"));
if (_6) {
zephir_array_fetch_string(&_7, &value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 103 TSRMLS_CC);
_6 = ZEPHIR_IS_LONG_IDENTICAL(&_7, 1);
}
_5 = _6;
}
if (_5) {
ZEPHIR_INIT_VAR(&_8$$3);
ZVAL_STRING(&_8$$3, "FileIniSize");
ZEPHIR_INIT_VAR(&_9$$3);
ZVAL_STRING(&_9$$3, "messageIniSize");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_8$$3, &_9$$3);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&replacePairs);
zephir_create_array(&replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_8$$3);
object_init_ex(&_8$$3, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_10$$3, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_9$$3);
ZVAL_STRING(&_9$$3, "FileIniSize");
ZEPHIR_CALL_METHOD(NULL, &_8$$3, "__construct", NULL, 299, &_10$$3, field, &_9$$3, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_8$$3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
_11 = !(zephir_array_isset_string(&value, SL("error")));
if (!(_11)) {
_11 = !(zephir_array_isset_string(&value, SL("tmp_name")));
}
_12 = _11;
if (!(_12)) {
zephir_array_fetch_string(&_13, &value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 119 TSRMLS_CC);
_12 = !ZEPHIR_IS_LONG_IDENTICAL(&_13, 0);
}
_14 = _12;
if (!(_14)) {
zephir_array_fetch_string(&_15, &value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 119 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_16, "is_uploaded_file", NULL, 232, &_15);
zephir_check_call_status();
_14 = !zephir_is_true(&_16);
}
if (_14) {
ZEPHIR_INIT_VAR(&_17$$4);
ZVAL_STRING(&_17$$4, "FileEmpty");
ZEPHIR_INIT_VAR(&_18$$4);
ZVAL_STRING(&_18$$4, "messageEmpty");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_17$$4, &_18$$4);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&replacePairs);
zephir_create_array(&replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_17$$4);
object_init_ex(&_17$$4, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_19$$4, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_18$$4);
ZVAL_STRING(&_18$$4, "FileEmpty");
ZEPHIR_CALL_METHOD(NULL, &_17$$4, "__construct", NULL, 299, &_19$$4, field, &_18$$4, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_17$$4);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
_20 = !(zephir_array_isset_string(&value, SL("name")));
if (!(_20)) {
_20 = !(zephir_array_isset_string(&value, SL("type")));
}
_21 = _20;
if (!(_21)) {
_21 = !(zephir_array_isset_string(&value, SL("size")));
}
if (_21) {
ZEPHIR_INIT_VAR(&_22$$5);
ZVAL_STRING(&_22$$5, "FileValid");
ZEPHIR_INIT_VAR(&_23$$5);
ZVAL_STRING(&_23$$5, "messageValid");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_22$$5, &_23$$5);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&replacePairs);
zephir_create_array(&replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_22$$5);
object_init_ex(&_22$$5, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_24$$5, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_23$$5);
ZVAL_STRING(&_23$$5, "FileValid");
ZEPHIR_CALL_METHOD(NULL, &_22$$5, "__construct", NULL, 299, &_24$$5, field, &_23$$5, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_22$$5);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_VAR(&_26);
ZVAL_STRING(&_26, "maxSize");
ZEPHIR_CALL_METHOD(&_25, this_ptr, "hasoption", NULL, 0, &_26);
zephir_check_call_status();
if (zephir_is_true(&_25)) {
ZEPHIR_INIT_VAR(&byteUnits);
zephir_create_array(&byteUnits, 9, 0 TSRMLS_CC);
add_assoc_long_ex(&byteUnits, SL("B"), 0);
add_assoc_long_ex(&byteUnits, SL("K"), 10);
add_assoc_long_ex(&byteUnits, SL("M"), 20);
add_assoc_long_ex(&byteUnits, SL("G"), 30);
add_assoc_long_ex(&byteUnits, SL("T"), 40);
add_assoc_long_ex(&byteUnits, SL("KB"), 10);
add_assoc_long_ex(&byteUnits, SL("MB"), 20);
add_assoc_long_ex(&byteUnits, SL("GB"), 30);
add_assoc_long_ex(&byteUnits, SL("TB"), 40);
ZEPHIR_INIT_VAR(&_27$$6);
ZVAL_STRING(&_27$$6, "maxSize");
ZEPHIR_CALL_METHOD(&maxSize, this_ptr, "getoption", NULL, 0, &_27$$6);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&matches);
ZVAL_NULL(&matches);
ZEPHIR_INIT_VAR(&unit);
ZVAL_STRING(&unit, "B");
if (Z_TYPE_P(&maxSize) == IS_ARRAY) {
zephir_array_fetch(&_28$$7, &maxSize, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 159 TSRMLS_CC);
ZEPHIR_CPY_WRT(&maxSize, &_28$$7);
}
ZEPHIR_INIT_NVAR(&_27$$6);
ZEPHIR_INIT_VAR(&_29$$6);
zephir_array_keys(&_29$$6, &byteUnits TSRMLS_CC);
zephir_fast_join_str(&_27$$6, SL("|"), &_29$$6 TSRMLS_CC);
ZEPHIR_INIT_VAR(&_30$$6);
ZEPHIR_CONCAT_SVS(&_30$$6, "/^([0-9]+(?:\\.[0-9]+)?)(", &_27$$6, ")?$/Di");
ZEPHIR_INIT_VAR(&_31$$6);
zephir_preg_match(&_31$$6, &_30$$6, &maxSize, &matches, 0, 0 , 0 TSRMLS_CC);
if (zephir_array_isset_long(&matches, 2)) {
ZEPHIR_OBS_NVAR(&unit);
zephir_array_fetch_long(&unit, &matches, 2, PH_NOISY, "phalcon/validation/validator/file.zep", 165 TSRMLS_CC);
}
zephir_array_fetch_long(&_32$$6, &matches, 1, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 168 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_33$$6, "floatval", NULL, 323, &_32$$6);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_34$$6);
zephir_array_fetch(&_35$$6, &byteUnits, &unit, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 168 TSRMLS_CC);
ZVAL_LONG(&_36$$6, 2);
zephir_pow_function(&_34$$6, &_36$$6, &_35$$6);
ZEPHIR_INIT_VAR(&bytes);
mul_function(&bytes, &_33$$6, &_34$$6 TSRMLS_CC);
zephir_array_fetch_string(&_37$$6, &value, SL("size"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 170 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_33$$6, "floatval", NULL, 323, &_37$$6);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_38$$6, "floatval", NULL, 323, &bytes);
zephir_check_call_status();
if (ZEPHIR_GT(&_33$$6, &_38$$6)) {
ZEPHIR_INIT_VAR(&_39$$9);
ZVAL_STRING(&_39$$9, "FileSize");
ZEPHIR_INIT_VAR(&_40$$9);
ZVAL_STRING(&_40$$9, "messageSize");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_39$$9, &_40$$9);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&replacePairs);
zephir_create_array(&replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":max"), &maxSize, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_39$$9);
object_init_ex(&_39$$9, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_41$$9, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_40$$9);
ZVAL_STRING(&_40$$9, "FileSize");
ZEPHIR_CALL_METHOD(NULL, &_39$$9, "__construct", NULL, 299, &_41$$9, field, &_40$$9, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_39$$9);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_NVAR(&_26);
ZVAL_STRING(&_26, "allowedTypes");
ZEPHIR_CALL_METHOD(&_42, this_ptr, "hasoption", NULL, 0, &_26);
zephir_check_call_status();
if (zephir_is_true(&_42)) {
ZEPHIR_INIT_VAR(&_43$$10);
ZVAL_STRING(&_43$$10, "allowedTypes");
ZEPHIR_CALL_METHOD(&types, this_ptr, "getoption", NULL, 0, &_43$$10);
zephir_check_call_status();
ZEPHIR_OBS_VAR(&fieldTypes);
if (zephir_array_isset_fetch(&fieldTypes, &types, field, 0 TSRMLS_CC)) {
ZEPHIR_CPY_WRT(&types, &fieldTypes);
}
if (Z_TYPE_P(&types) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Option 'allowedTypes' must be an array", "phalcon/validation/validator/file.zep", 196);
return;
}
if ((zephir_function_exists_ex(SL("finfo_open") TSRMLS_CC) == SUCCESS)) {
ZVAL_LONG(&_44$$13, 16);
ZEPHIR_CALL_FUNCTION(&tmp, "finfo_open", NULL, 229, &_44$$13);
zephir_check_call_status();
zephir_array_fetch_string(&_45$$13, &value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 201 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&mime, "finfo_file", NULL, 230, &tmp, &_45$$13);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(NULL, "finfo_close", NULL, 231, &tmp);
zephir_check_call_status();
} else {
ZEPHIR_OBS_NVAR(&mime);
zephir_array_fetch_string(&mime, &value, SL("type"), PH_NOISY, "phalcon/validation/validator/file.zep", 205 TSRMLS_CC);
}
if (!(zephir_fast_in_array(&mime, &types TSRMLS_CC))) {
ZEPHIR_INIT_VAR(&_46$$15);
ZVAL_STRING(&_46$$15, "FileType");
ZEPHIR_INIT_VAR(&_47$$15);
ZVAL_STRING(&_47$$15, "messageType");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_46$$15, &_47$$15);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&replacePairs);
zephir_create_array(&replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_46$$15);
zephir_fast_join_str(&_46$$15, SL(", "), &types TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":types"), &_46$$15, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_46$$15);
object_init_ex(&_46$$15, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_48$$15, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_47$$15);
ZVAL_STRING(&_47$$15, "FileType");
ZEPHIR_CALL_METHOD(NULL, &_46$$15, "__construct", NULL, 299, &_48$$15, field, &_47$$15, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_46$$15);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_NVAR(&_26);
ZVAL_STRING(&_26, "minResolution");
ZEPHIR_CALL_METHOD(&_49, this_ptr, "hasoption", NULL, 0, &_26);
zephir_check_call_status();
_50 = zephir_is_true(&_49);
if (!(_50)) {
ZEPHIR_INIT_NVAR(&_26);
ZVAL_STRING(&_26, "maxResolution");
ZEPHIR_CALL_METHOD(&_51, this_ptr, "hasoption", NULL, 0, &_26);
zephir_check_call_status();
_50 = zephir_is_true(&_51);
}
if (_50) {
zephir_array_fetch_string(&_52$$16, &value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 226 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&tmp, "getimagesize", NULL, 241, &_52$$16);
zephir_check_call_status();
ZEPHIR_OBS_VAR(&width);
zephir_array_fetch_long(&width, &tmp, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 227 TSRMLS_CC);
ZEPHIR_OBS_VAR(&height);
zephir_array_fetch_long(&height, &tmp, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 228 TSRMLS_CC);
ZEPHIR_INIT_VAR(&_54$$16);
ZVAL_STRING(&_54$$16, "minResolution");
ZEPHIR_CALL_METHOD(&_53$$16, this_ptr, "hasoption", NULL, 0, &_54$$16);
zephir_check_call_status();
if (zephir_is_true(&_53$$16)) {
ZEPHIR_INIT_VAR(&_55$$17);
ZVAL_STRING(&_55$$17, "minResolution");
ZEPHIR_CALL_METHOD(&minResolution, this_ptr, "getoption", NULL, 0, &_55$$17);
zephir_check_call_status();
if (Z_TYPE_P(&minResolution) == IS_ARRAY) {
zephir_array_fetch(&_56$$18, &minResolution, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 233 TSRMLS_CC);
ZEPHIR_CPY_WRT(&minResolution, &_56$$18);
}
ZEPHIR_INIT_VAR(&minResolutionArray);
zephir_fast_explode_str(&minResolutionArray, SL("x"), &minResolution, LONG_MAX TSRMLS_CC);
ZEPHIR_OBS_VAR(&minWidth);
zephir_array_fetch_long(&minWidth, &minResolutionArray, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 236 TSRMLS_CC);
ZEPHIR_OBS_VAR(&minHeight);
zephir_array_fetch_long(&minHeight, &minResolutionArray, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 237 TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(&minWidth);
ZVAL_LONG(&minWidth, 1);
ZEPHIR_INIT_NVAR(&minHeight);
ZVAL_LONG(&minHeight, 1);
}
_57$$16 = ZEPHIR_LT(&width, &minWidth);
if (!(_57$$16)) {
_57$$16 = ZEPHIR_LT(&height, &minHeight);
}
if (_57$$16) {
ZEPHIR_INIT_VAR(&_58$$20);
ZVAL_STRING(&_58$$20, "FileMinResolution");
ZEPHIR_INIT_VAR(&_59$$20);
ZVAL_STRING(&_59$$20, "messageMinResolution");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_58$$20, &_59$$20);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&replacePairs);
zephir_create_array(&replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":min"), &minResolution, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_58$$20);
object_init_ex(&_58$$20, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_60$$20, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_59$$20);
ZVAL_STRING(&_59$$20, "FileMinResolution");
ZEPHIR_CALL_METHOD(NULL, &_58$$20, "__construct", NULL, 299, &_60$$20, field, &_59$$20, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_58$$20);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_NVAR(&_54$$16);
ZVAL_STRING(&_54$$16, "maxResolution");
ZEPHIR_CALL_METHOD(&_61$$16, this_ptr, "hasoption", NULL, 0, &_54$$16);
zephir_check_call_status();
if (zephir_is_true(&_61$$16)) {
ZEPHIR_INIT_VAR(&_62$$21);
ZVAL_STRING(&_62$$21, "maxResolution");
ZEPHIR_CALL_METHOD(&maxResolution, this_ptr, "getoption", NULL, 0, &_62$$21);
zephir_check_call_status();
if (Z_TYPE_P(&maxResolution) == IS_ARRAY) {
zephir_array_fetch(&_63$$22, &maxResolution, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 263 TSRMLS_CC);
ZEPHIR_CPY_WRT(&maxResolution, &_63$$22);
}
ZEPHIR_INIT_VAR(&maxResolutionArray);
zephir_fast_explode_str(&maxResolutionArray, SL("x"), &maxResolution, LONG_MAX TSRMLS_CC);
ZEPHIR_OBS_VAR(&maxWidth);
zephir_array_fetch_long(&maxWidth, &maxResolutionArray, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 266 TSRMLS_CC);
ZEPHIR_OBS_VAR(&maxHeight);
zephir_array_fetch_long(&maxHeight, &maxResolutionArray, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 267 TSRMLS_CC);
_64$$21 = ZEPHIR_GT(&width, &maxWidth);
if (!(_64$$21)) {
_64$$21 = ZEPHIR_GT(&height, &maxHeight);
}
if (_64$$21) {
ZEPHIR_INIT_VAR(&_65$$23);
ZVAL_STRING(&_65$$23, "FileMaxResolution");
ZEPHIR_INIT_VAR(&_66$$23);
ZVAL_STRING(&_66$$23, "messageMaxResolution");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_65$$23, &_66$$23);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&replacePairs);
zephir_create_array(&replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":max"), &maxResolution, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_65$$23);
object_init_ex(&_65$$23, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_67$$23, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_66$$23);
ZVAL_STRING(&_66$$23, "FileMaxResolution");
ZEPHIR_CALL_METHOD(NULL, &_65$$23, "__construct", NULL, 299, &_67$$23, field, &_66$$23, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_65$$23);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
}
RETURN_MM_BOOL(1);
}
/**
* Resolves the service
*
* @param array parameters
* @return mixed
*/
PHP_METHOD(Phalcon_Di_Service, resolve) {
zend_class_entry *_1$$15;
zend_bool found = 0;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *parameters = NULL, parameters_sub, *dependencyInjector = NULL, dependencyInjector_sub, __$true, __$false, __$null, shared, definition, sharedInstance, instance, builder, _0$$15, _2$$22;
zval *this_ptr = getThis();
ZVAL_UNDEF(¶meters_sub);
ZVAL_UNDEF(&dependencyInjector_sub);
ZVAL_BOOL(&__$true, 1);
ZVAL_BOOL(&__$false, 0);
ZVAL_NULL(&__$null);
ZVAL_UNDEF(&shared);
ZVAL_UNDEF(&definition);
ZVAL_UNDEF(&sharedInstance);
ZVAL_UNDEF(&instance);
ZVAL_UNDEF(&builder);
ZVAL_UNDEF(&_0$$15);
ZVAL_UNDEF(&_2$$22);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 2, ¶meters, &dependencyInjector);
if (!parameters) {
parameters = ¶meters_sub;
parameters = &__$null;
}
if (!dependencyInjector) {
dependencyInjector = &dependencyInjector_sub;
dependencyInjector = &__$null;
}
ZEPHIR_OBS_VAR(&shared);
zephir_read_property(&shared, this_ptr, SL("_shared"), PH_NOISY_CC);
if (zephir_is_true(&shared)) {
ZEPHIR_OBS_VAR(&sharedInstance);
zephir_read_property(&sharedInstance, this_ptr, SL("_sharedInstance"), PH_NOISY_CC);
if (Z_TYPE_P(&sharedInstance) != IS_NULL) {
RETURN_CCTOR(&sharedInstance);
}
}
found = 1;
ZEPHIR_INIT_VAR(&instance);
ZVAL_NULL(&instance);
ZEPHIR_OBS_VAR(&definition);
zephir_read_property(&definition, this_ptr, SL("_definition"), PH_NOISY_CC);
if (Z_TYPE_P(&definition) == IS_STRING) {
if (zephir_class_exists(&definition, 1 TSRMLS_CC)) {
if (Z_TYPE_P(parameters) == IS_ARRAY) {
if (zephir_fast_count_int(parameters TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(&instance);
ZEPHIR_LAST_CALL_STATUS = zephir_create_instance_params(&instance, &definition, parameters TSRMLS_CC);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(&instance);
ZEPHIR_LAST_CALL_STATUS = zephir_create_instance(&instance, &definition TSRMLS_CC);
zephir_check_call_status();
}
} else {
ZEPHIR_INIT_NVAR(&instance);
ZEPHIR_LAST_CALL_STATUS = zephir_create_instance(&instance, &definition TSRMLS_CC);
zephir_check_call_status();
}
} else {
found = 0;
}
} else {
if (Z_TYPE_P(&definition) == IS_OBJECT) {
if (zephir_instance_of_ev(&definition, zend_ce_closure TSRMLS_CC)) {
if (Z_TYPE_P(dependencyInjector) == IS_OBJECT) {
_1$$15 = zephir_fetch_class_str_ex(SL("Closure"), ZEND_FETCH_CLASS_AUTO);
ZEPHIR_CALL_CE_STATIC(&_0$$15, _1$$15, "bind", NULL, 0, &definition, dependencyInjector);
zephir_check_call_status();
ZEPHIR_CPY_WRT(&definition, &_0$$15);
}
if (Z_TYPE_P(parameters) == IS_ARRAY) {
ZEPHIR_INIT_NVAR(&instance);
ZEPHIR_CALL_USER_FUNC_ARRAY(&instance, &definition, parameters);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(&instance);
ZEPHIR_CALL_USER_FUNC(&instance, &definition);
zephir_check_call_status();
}
} else {
ZEPHIR_CPY_WRT(&instance, &definition);
}
} else {
if (Z_TYPE_P(&definition) == IS_ARRAY) {
ZEPHIR_INIT_VAR(&builder);
object_init_ex(&builder, phalcon_di_service_builder_ce);
if (zephir_has_constructor(&builder TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, &builder, "__construct", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&instance, &builder, "build", NULL, 171, dependencyInjector, &definition, parameters);
zephir_check_call_status();
} else {
found = 0;
}
}
}
if (found == 0) {
ZEPHIR_INIT_VAR(&_2$$22);
object_init_ex(&_2$$22, phalcon_di_exception_serviceresolutionexception_ce);
ZEPHIR_CALL_METHOD(NULL, &_2$$22, "__construct", NULL, 4);
zephir_check_call_status();
zephir_throw_exception_debug(&_2$$22, "phalcon/di/service.zep", 186 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (zephir_is_true(&shared)) {
zephir_update_property_zval(this_ptr, SL("_sharedInstance"), &instance);
}
if (1) {
zephir_update_property_zval(this_ptr, SL("_resolved"), &__$true);
} else {
zephir_update_property_zval(this_ptr, SL("_resolved"), &__$false);
}
RETURN_CCTOR(&instance);
}
/**
* Returns the cookie's value
*
* @param string|array filters
* @param string defaultValue
* @return mixed
*/
PHP_METHOD(Phalcon_Http_Cookie, getValue) {
int ZEPHIR_LAST_CALL_STATUS;
zval *filters = NULL, *defaultValue = NULL, *_COOKIE, *dependencyInjector = NULL, *value = NULL, *crypt = NULL, *decryptedValue = NULL, *filter = NULL, *_0, *_1, *_2$$4, *_3$$5, *_4$$6, *_5$$6, *_6$$11, *_7$$10;
ZEPHIR_MM_GROW();
zephir_get_global(&_COOKIE, SS("_COOKIE") TSRMLS_CC);
zephir_fetch_params(1, 0, 2, &filters, &defaultValue);
if (!filters) {
filters = ZEPHIR_GLOBAL(global_null);
}
if (!defaultValue) {
defaultValue = ZEPHIR_GLOBAL(global_null);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_restored"), PH_NOISY_CC);
if (!(zephir_is_true(_0))) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "restore", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_INIT_VAR(dependencyInjector);
ZVAL_NULL(dependencyInjector);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_readed"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_1)) {
ZEPHIR_OBS_VAR(value);
_2$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_name"), PH_NOISY_CC);
if (zephir_array_isset_fetch(&value, _COOKIE, _2$$4, 0 TSRMLS_CC)) {
_3$$5 = zephir_fetch_nproperty_this(this_ptr, SL("_useEncryption"), PH_NOISY_CC);
if (zephir_is_true(_3$$5)) {
_4$$6 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(dependencyInjector, _4$$6);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_http_response_exception_ce, "A dependency injection object is required to access the 'filter' service", "phalcon/http/cookie.zep", 152);
return;
}
ZEPHIR_INIT_VAR(_5$$6);
ZVAL_STRING(_5$$6, "crypt", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&crypt, dependencyInjector, "getshared", NULL, 0, _5$$6);
zephir_check_temp_parameter(_5$$6);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&decryptedValue, crypt, "decryptbase64", NULL, 0, value);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(decryptedValue, value);
}
zephir_update_property_this(this_ptr, SL("_value"), decryptedValue TSRMLS_CC);
if (Z_TYPE_P(filters) != IS_NULL) {
ZEPHIR_OBS_VAR(filter);
zephir_read_property_this(&filter, this_ptr, SL("_filter"), PH_NOISY_CC);
if (Z_TYPE_P(filter) != IS_OBJECT) {
if (Z_TYPE_P(dependencyInjector) == IS_NULL) {
_6$$11 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(dependencyInjector, _6$$11);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_http_response_exception_ce, "A dependency injection object is required to access the 'filter' service", "phalcon/http/cookie.zep", 178);
return;
}
}
ZEPHIR_INIT_VAR(_7$$10);
ZVAL_STRING(_7$$10, "filter", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&filter, dependencyInjector, "getshared", NULL, 0, _7$$10);
zephir_check_temp_parameter(_7$$10);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_filter"), filter TSRMLS_CC);
}
ZEPHIR_RETURN_CALL_METHOD(filter, "sanitize", NULL, 0, decryptedValue, filters);
zephir_check_call_status();
RETURN_MM();
}
RETURN_CCTOR(decryptedValue);
}
RETVAL_ZVAL(defaultValue, 1, 0);
RETURN_MM();
}
RETURN_MM_MEMBER(this_ptr, "_value");
}
/**
* Sanitizes a value with a specified single or set of filters
*/
PHP_METHOD(Phalcon_Filter, sanitize) {
zephir_fcall_cache_entry *_8 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_1, *_5, *_10;
HashPosition _0, _4, _9;
zend_bool noRecursive, _3;
zval *value = NULL, *filters, *noRecursive_param = NULL, *filter = NULL, *arrayValue = NULL, *itemKey = NULL, *itemValue = NULL, *sanitizedValue, **_2, **_6, *_7 = NULL, **_11;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 1, &value, &filters, &noRecursive_param);
ZEPHIR_SEPARATE_PARAM(value);
if (!noRecursive_param) {
noRecursive = 0;
} else {
noRecursive = zephir_get_boolval(noRecursive_param);
}
if (Z_TYPE_P(filters) == IS_ARRAY) {
if (Z_TYPE_P(value) != IS_NULL) {
zephir_is_iterable(filters, &_1, &_0, 0, 0, "phalcon/filter.zep", 107);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HVALUE(filter, _2);
_3 = Z_TYPE_P(value) == IS_ARRAY;
if (_3) {
_3 = !noRecursive;
}
if (_3) {
ZEPHIR_INIT_NVAR(arrayValue);
array_init(arrayValue);
zephir_is_iterable(value, &_5, &_4, 0, 0, "phalcon/filter.zep", 102);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HMKEY(itemKey, _5, _4);
ZEPHIR_GET_HVALUE(itemValue, _6);
ZEPHIR_CALL_METHOD(&_7, this_ptr, "_sanitize", &_8, 0, itemValue, filter);
zephir_check_call_status();
zephir_array_update_zval(&arrayValue, itemKey, &_7, PH_COPY | PH_SEPARATE);
}
ZEPHIR_CPY_WRT(value, arrayValue);
} else {
ZEPHIR_CALL_METHOD(&_7, this_ptr, "_sanitize", &_8, 0, value, filter);
zephir_check_call_status();
ZEPHIR_CPY_WRT(value, _7);
}
}
}
RETVAL_ZVAL(value, 1, 0);
RETURN_MM();
}
_3 = Z_TYPE_P(value) == IS_ARRAY;
if (_3) {
_3 = !noRecursive;
}
if (_3) {
ZEPHIR_INIT_VAR(sanitizedValue);
array_init(sanitizedValue);
zephir_is_iterable(value, &_10, &_9, 0, 0, "phalcon/filter.zep", 119);
for (
; zephir_hash_get_current_data_ex(_10, (void**) &_11, &_9) == SUCCESS
; zephir_hash_move_forward_ex(_10, &_9)
) {
ZEPHIR_GET_HMKEY(itemKey, _10, _9);
ZEPHIR_GET_HVALUE(itemValue, _11);
ZEPHIR_CALL_METHOD(&_7, this_ptr, "_sanitize", &_8, 0, itemValue, filters);
zephir_check_call_status();
zephir_array_update_zval(&sanitizedValue, itemKey, &_7, PH_COPY | PH_SEPARATE);
}
RETURN_CCTOR(sanitizedValue);
}
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "_sanitize", &_8, 0, value, filters);
zephir_check_call_status();
RETURN_MM();
}
/**
* Applies a format to a message before sending it to the log
*
* @param string $message
* @param int $type
* @param int $timestamp
* @param array $context
*
* @return string
*/
PHP_METHOD(Phalcon_Logger_Formatter_Firephp, format) {
HashTable *_11$$4;
HashPosition _10$$4;
zval *_22;
zend_bool _15, _18, param$$4 = 0;
int type, timestamp, ZEPHIR_LAST_CALL_STATUS;
zval *message_param = NULL, *type_param = NULL, *timestamp_param = NULL, *context = NULL, *meta = NULL, *body = NULL, *backtrace = NULL, *encoded = NULL, *len = NULL, *lastTrace = NULL, *_1 = NULL, *_2, *_3, *_13, *_14, *_16, *_17, *_19, *_0$$3 = NULL, *backtraceItem$$4 = NULL, *key$$4 = NULL, *_4$$4, _5$$4 = zval_used_for_init, _6$$4, *_7$$4 = NULL, **_12$$4, *_8$$6, *_9$$7, *_20$$12, *_21$$12;
zval *message = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 1, &message_param, &type_param, ×tamp_param, &context);
zephir_get_strval(message, message_param);
type = zephir_get_intval(type_param);
timestamp = zephir_get_intval(timestamp_param);
if (!context) {
context = ZEPHIR_GLOBAL(global_null);
}
if (Z_TYPE_P(context) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&_0$$3, this_ptr, "interpolate", NULL, 0, message, context);
zephir_check_call_status();
zephir_get_strval(message, _0$$3);
}
ZEPHIR_INIT_VAR(meta);
zephir_create_array(meta, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_2);
ZVAL_LONG(_2, type);
ZEPHIR_CALL_METHOD(&_1, this_ptr, "gettypestring", NULL, 0, _2);
zephir_check_call_status();
zephir_array_update_string(&meta, SL("Type"), &_1, PH_COPY | PH_SEPARATE);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC);
if (zephir_is_true(_3)) {
param$$4 = 0;
ZEPHIR_INIT_VAR(_4$$4);
ZEPHIR_GET_CONSTANT(_4$$4, "PHP_VERSION");
ZEPHIR_SINIT_VAR(_5$$4);
ZVAL_STRING(&_5$$4, "5.3.6", 0);
ZEPHIR_SINIT_VAR(_6$$4);
ZVAL_STRING(&_6$$4, "<", 0);
ZEPHIR_CALL_FUNCTION(&_7$$4, "version_compare", NULL, 241, _4$$4, &_5$$4, &_6$$4);
zephir_check_call_status();
if (!(zephir_is_true(_7$$4))) {
param$$4 = (2) ? 1 : 0;
}
ZEPHIR_SINIT_NVAR(_5$$4);
ZVAL_BOOL(&_5$$4, (param$$4 ? 1 : 0));
ZEPHIR_CALL_FUNCTION(&backtrace, "debug_backtrace", NULL, 153, &_5$$4);
zephir_check_call_status();
ZEPHIR_MAKE_REF(backtrace);
ZEPHIR_CALL_FUNCTION(&lastTrace, "end", NULL, 172, backtrace);
ZEPHIR_UNREF(backtrace);
zephir_check_call_status();
if (zephir_array_isset_string(lastTrace, SS("file"))) {
zephir_array_fetch_string(&_8$$6, lastTrace, SL("file"), PH_NOISY | PH_READONLY, "phalcon/logger/formatter/firephp.zep", 133 TSRMLS_CC);
zephir_array_update_string(&meta, SL("File"), &_8$$6, PH_COPY | PH_SEPARATE);
}
if (zephir_array_isset_string(lastTrace, SS("line"))) {
zephir_array_fetch_string(&_9$$7, lastTrace, SL("line"), PH_NOISY | PH_READONLY, "phalcon/logger/formatter/firephp.zep", 137 TSRMLS_CC);
zephir_array_update_string(&meta, SL("Line"), &_9$$7, PH_COPY | PH_SEPARATE);
}
zephir_is_iterable(backtrace, &_11$$4, &_10$$4, 1, 0, "phalcon/logger/formatter/firephp.zep", 146);
for (
; zephir_hash_get_current_data_ex(_11$$4, (void**) &_12$$4, &_10$$4) == SUCCESS
; zephir_hash_move_forward_ex(_11$$4, &_10$$4)
) {
ZEPHIR_GET_HMKEY(key$$4, _11$$4, _10$$4);
ZEPHIR_GET_HVALUE(backtraceItem$$4, _12$$4);
zephir_array_unset_string(&backtraceItem$$4, SS("object"), PH_SEPARATE);
zephir_array_unset_string(&backtraceItem$$4, SS("args"), PH_SEPARATE);
zephir_array_update_zval(&backtrace, key$$4, &backtraceItem$$4, PH_COPY | PH_SEPARATE);
}
zend_hash_destroy(_11$$4);
FREE_HASHTABLE(_11$$4);
}
_13 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC);
if (zephir_is_true(_13)) {
zephir_array_update_string(&meta, SL("Label"), &message, PH_COPY | PH_SEPARATE);
}
_14 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC);
_15 = !zephir_is_true(_14);
if (_15) {
_16 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC);
_15 = !zephir_is_true(_16);
}
_17 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC);
_18 = zephir_is_true(_17);
if (_18) {
_19 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC);
_18 = !zephir_is_true(_19);
}
if (_15) {
ZEPHIR_CPY_WRT(body, message);
} else if (_18) {
ZEPHIR_INIT_NVAR(body);
ZVAL_STRING(body, "", 1);
} else {
ZEPHIR_INIT_NVAR(body);
array_init(body);
_20$$12 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC);
if (zephir_is_true(_20$$12)) {
zephir_array_update_string(&body, SL("backtrace"), &backtrace, PH_COPY | PH_SEPARATE);
}
_21$$12 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC);
if (!(zephir_is_true(_21$$12))) {
zephir_array_update_string(&body, SL("message"), &message, PH_COPY | PH_SEPARATE);
}
}
ZEPHIR_INIT_VAR(_22);
zephir_create_array(_22, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_22, meta);
zephir_array_fast_append(_22, body);
ZEPHIR_INIT_VAR(encoded);
zephir_json_encode(encoded, &(encoded), _22, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(len);
ZVAL_LONG(len, zephir_fast_strlen_ev(encoded));
ZEPHIR_CONCAT_VSVS(return_value, len, "|", encoded, "|");
RETURN_MM();
}
PHP_METHOD(Test_RegexDNA, process) {
HashTable *_4;
HashPosition _3;
zval *path, *variants, *vIUB, *vIUBnew, *stuffToRemove, *contents = NULL, *initialLength, *regex = NULL, *codeLength, *discard, *_0 = NULL, *_1, _2, **_5, *_6 = NULL, *_7;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &path);
ZEPHIR_INIT_VAR(variants);
array_init_size(variants, 13);
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "agggtaaa|tttaccct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "[cgt]gggtaaa|tttaccc[acg]", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "a[act]ggtaaa|tttacc[agt]t", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "ag[act]gtaaa|tttac[agt]ct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "agg[act]taaa|ttta[agt]cct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "aggg[acg]aaa|ttt[cgt]ccct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "agggt[cgt]aa|tt[acg]accct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "agggta[cgt]a|t[acg]taccct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "agggtaa[cgt]|[acg]ttaccct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_VAR(vIUB);
array_init(vIUB);
ZEPHIR_INIT_VAR(vIUBnew);
array_init(vIUBnew);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/B/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(c|g|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/D/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|g|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/H/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|c|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/K/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(g|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/M/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|c)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/N/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|c|g|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/R/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|g)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/S/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(c|g)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/V/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|c|g)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/W/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(a|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/Y/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "(c|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE);
ZEPHIR_INIT_VAR(stuffToRemove);
ZVAL_STRING(stuffToRemove, "^>.*$|\n", 1);
ZEPHIR_INIT_VAR(discard);
ZVAL_NULL(discard);
ZEPHIR_INIT_VAR(contents);
zephir_file_get_contents(contents, path TSRMLS_CC);
ZEPHIR_INIT_VAR(initialLength);
ZVAL_LONG(initialLength, zephir_fast_strlen_ev(contents));
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SVS(_1, "/", stuffToRemove, "/mS");
ZEPHIR_SINIT_VAR(_2);
ZVAL_STRING(&_2, "", 0);
ZEPHIR_INIT_BNVAR(_0);
zephir_call_func_p3(_0, "preg_replace", _1, &_2, contents);
ZEPHIR_CPY_WRT(contents, _0);
ZEPHIR_INIT_VAR(codeLength);
ZVAL_LONG(codeLength, zephir_fast_strlen_ev(contents));
zephir_is_iterable(variants, &_4, &_3, 0, 0);
for (
; zend_hash_get_current_data_ex(_4, (void**) &_5, &_3) == SUCCESS
; zephir_hash_move_forward_ex(_4, &_3)
) {
ZEPHIR_GET_HVALUE(regex, _5);
zend_print_zval(regex, 0);
php_printf(" ");
ZEPHIR_INIT_NVAR(_0);
ZEPHIR_INIT_LNVAR(_6);
ZEPHIR_CONCAT_SVS(_6, "/", regex, "/iS");
zephir_preg_match(_0, &(_0), _6, contents, discard, 1, 0 , 0 TSRMLS_CC);
zend_print_zval(_0, 0);
php_printf("%c", '\n');
}
ZEPHIR_INIT_VAR(_7);
zephir_call_func_p3(_7, "preg_replace", vIUB, vIUBnew, contents);
ZEPHIR_CPY_WRT(contents, _7);
php_printf("%c", '\n');
zend_print_zval(initialLength, 0);
php_printf("%c", '\n');
zend_print_zval(codeLength, 0);
php_printf("%c", '\n');
php_printf("%d", zephir_fast_strlen_ev(contents));
php_printf("%c", '\n');
ZEPHIR_MM_RESTORE();
}
/**
* Returns a slice of the resultset to show in the pagination
*/
PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilder, getPaginate) {
int numberPage, before, ZEPHIR_LAST_CALL_STATUS;
zval *originalBuilder, *builder, *totalBuilder, *totalPages, *limit, *number, *query = NULL, *page, *items = NULL, *totalQuery = NULL, *result = NULL, *row = NULL, *rowcount, *next = NULL, *_0, *_1 = NULL, *_2, _3, _4, *_5;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(originalBuilder);
zephir_read_property_this(&originalBuilder, this_ptr, SL("_builder"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(builder);
if (zephir_clone(builder, originalBuilder TSRMLS_CC) == FAILURE) {
RETURN_MM();
}
ZEPHIR_INIT_VAR(totalBuilder);
if (zephir_clone(totalBuilder, builder TSRMLS_CC) == FAILURE) {
RETURN_MM();
}
ZEPHIR_OBS_VAR(limit);
zephir_read_property_this(&limit, this_ptr, SL("_limitRows"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(_0);
zephir_read_property_this(&_0, this_ptr, SL("_page"), PH_NOISY_CC);
numberPage = zephir_get_intval(_0);
if (!(numberPage)) {
numberPage = 1;
}
ZEPHIR_INIT_VAR(number);
ZVAL_LONG(number, (zephir_get_numberval(limit) * ((numberPage - 1))));
if (ZEPHIR_LT(number, limit)) {
ZEPHIR_CALL_METHOD(NULL, builder, "limit", NULL, limit);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(NULL, builder, "limit", NULL, limit, number);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&query, builder, "getquery", NULL);
zephir_check_call_status();
if (numberPage == 1) {
before = 1;
} else {
before = (numberPage - 1);
}
ZEPHIR_CALL_METHOD(&items, query, "execute", NULL);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "COUNT(*) [rowcount]", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, totalBuilder, "columns", NULL, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_1);
ZVAL_NULL(_1);
ZEPHIR_CALL_METHOD(NULL, totalBuilder, "orderby", NULL, _1);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&totalQuery, totalBuilder, "getquery", NULL);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&result, totalQuery, "execute", NULL);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&row, result, "getfirst", NULL);
zephir_check_call_status();
ZEPHIR_OBS_VAR(_2);
zephir_read_property(&_2, row, SL("rowcount"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(rowcount);
ZVAL_LONG(rowcount, zephir_get_intval(_2));
ZEPHIR_SINIT_VAR(_3);
div_function(&_3, rowcount, limit TSRMLS_CC);
ZEPHIR_SINIT_VAR(_4);
ZVAL_DOUBLE(&_4, zephir_ceil(&_3 TSRMLS_CC));
ZEPHIR_INIT_VAR(totalPages);
ZVAL_LONG(totalPages, zephir_get_intval(&_4));
if (ZEPHIR_GT_LONG(totalPages, numberPage)) {
ZEPHIR_INIT_VAR(next);
ZVAL_LONG(next, (numberPage + 1));
} else {
ZEPHIR_CPY_WRT(next, totalPages);
}
ZEPHIR_INIT_VAR(page);
object_init(page);
zephir_update_property_zval(page, SL("items"), items TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_5);
ZVAL_LONG(_5, 1);
zephir_update_property_zval(page, SL("first"), _5 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_5);
ZVAL_LONG(_5, before);
zephir_update_property_zval(page, SL("before"), _5 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_5);
ZVAL_LONG(_5, numberPage);
zephir_update_property_zval(page, SL("current"), _5 TSRMLS_CC);
zephir_update_property_zval(page, SL("last"), totalPages TSRMLS_CC);
zephir_update_property_zval(page, SL("next"), next TSRMLS_CC);
zephir_update_property_zval(page, SL("total_pages"), totalPages TSRMLS_CC);
zephir_update_property_zval(page, SL("total_items"), rowcount TSRMLS_CC);
_5 = zephir_fetch_nproperty_this(this_ptr, SL("_limitRows"), PH_NOISY_CC);
zephir_update_property_zval(page, SL("limit"), _5 TSRMLS_CC);
RETURN_CCTOR(page);
}
/**
* Stores cached content into the file backend and stops the frontend
*
* <code>
* $cache->save("my-key", $data);
*
* // Save data termlessly
* $cache->save("my-key", $data, -1);
* </code>
*
* @param int|string keyName
* @param string content
* @param int lifetime
* @param boolean stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_Redis, save) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zend_bool stopBuffer;
zval *keyName = NULL, *content = NULL, *lifetime = NULL, *stopBuffer_param = NULL, *prefixedKey = NULL, *lastKey = NULL, *frontend = NULL, *redis = NULL, *cachedContent = NULL, *preparedContent = NULL, *tmp = NULL, *tt1 = NULL, *success = NULL, *options = NULL, *specialKey = NULL, *isBuffering = NULL, _0$$3, *_1$$4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 4, &keyName, &content, &lifetime, &stopBuffer_param);
if (!keyName) {
keyName = ZEPHIR_GLOBAL(global_null);
}
if (!content) {
content = ZEPHIR_GLOBAL(global_null);
}
if (!lifetime) {
lifetime = ZEPHIR_GLOBAL(global_null);
}
if (!stopBuffer_param) {
stopBuffer = 1;
} else {
stopBuffer = zephir_get_boolval(stopBuffer_param);
}
if (Z_TYPE_P(keyName) == IS_NULL) {
ZEPHIR_OBS_VAR(lastKey);
zephir_read_property_this(&lastKey, this_ptr, SL("_lastKey"), PH_NOISY_CC);
ZEPHIR_SINIT_VAR(_0$$3);
ZVAL_LONG(&_0$$3, 5);
ZEPHIR_INIT_VAR(prefixedKey);
zephir_substr(prefixedKey, lastKey, 5 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
} else {
_1$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(prefixedKey);
ZEPHIR_CONCAT_VV(prefixedKey, _1$$4, keyName);
ZEPHIR_INIT_NVAR(lastKey);
ZEPHIR_CONCAT_SV(lastKey, "_PHCR", prefixedKey);
zephir_update_property_this(getThis(), SL("_lastKey"), lastKey TSRMLS_CC);
}
if (!(zephir_is_true(lastKey))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "The cache must be started first", "phalcon/cache/backend/redis.zep", 210);
return;
}
ZEPHIR_OBS_VAR(frontend);
zephir_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(redis);
zephir_read_property_this(&redis, this_ptr, SL("_redis"), PH_NOISY_CC);
if (Z_TYPE_P(redis) != IS_OBJECT) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_connect", NULL, 0);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(redis);
zephir_read_property_this(&redis, this_ptr, SL("_redis"), PH_NOISY_CC);
}
if (Z_TYPE_P(content) == IS_NULL) {
ZEPHIR_CALL_METHOD(&cachedContent, frontend, "getcontent", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(cachedContent, content);
}
if (!(zephir_is_numeric(cachedContent))) {
ZEPHIR_CALL_METHOD(&preparedContent, frontend, "beforestore", NULL, 0, cachedContent);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(preparedContent, cachedContent);
}
if (Z_TYPE_P(lifetime) == IS_NULL) {
ZEPHIR_OBS_VAR(tmp);
zephir_read_property_this(&tmp, this_ptr, SL("_lastLifetime"), PH_NOISY_CC);
if (!(zephir_is_true(tmp))) {
ZEPHIR_CALL_METHOD(&tt1, frontend, "getlifetime", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(tt1, tmp);
}
} else {
ZEPHIR_CPY_WRT(tt1, lifetime);
}
ZEPHIR_CALL_METHOD(&success, redis, "set", NULL, 0, lastKey, preparedContent);
zephir_check_call_status();
if (!(zephir_is_true(success))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Failed storing the data in redis", "phalcon/cache/backend/redis.zep", 254);
return;
}
if (ZEPHIR_GE_LONG(tt1, 1)) {
ZEPHIR_CALL_METHOD(NULL, redis, "settimeout", NULL, 0, lastKey, tt1);
zephir_check_call_status();
}
ZEPHIR_OBS_VAR(options);
zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(specialKey);
if (!(zephir_array_isset_string_fetch(&specialKey, options, SS("statsKey"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/redis.zep", 265);
return;
}
if (!ZEPHIR_IS_STRING(specialKey, "")) {
ZEPHIR_CALL_METHOD(NULL, redis, "sadd", NULL, 0, specialKey, prefixedKey);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&isBuffering, frontend, "isbuffering", NULL, 0);
zephir_check_call_status();
if (stopBuffer == 1) {
ZEPHIR_CALL_METHOD(NULL, frontend, "stop", NULL, 0);
zephir_check_call_status();
}
if (ZEPHIR_IS_TRUE_IDENTICAL(isBuffering)) {
zend_print_zval(cachedContent, 0);
}
if (0) {
zephir_update_property_this(getThis(), SL("_started"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(getThis(), SL("_started"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
RETURN_CCTOR(success);
}
/**
* Do a role inherit from another existing role
*/
PHP_METHOD(Phalcon_Acl_Adapter_Memory, addInherit) {
HashTable *_6$$6;
HashPosition _5$$6;
zephir_fcall_cache_entry *_8 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *roleName_param = NULL, *roleToInherit, *roleInheritName = NULL, *rolesNames = NULL, *deepInheritName = NULL, *_2, *_11, *_0$$3, *_3$$6, *_4$$6, **_7$$6, *_9$$8, *_10$$8;
zval *roleName = NULL, *_1$$3;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &roleName_param, &roleToInherit);
zephir_get_strval(roleName, roleName_param);
ZEPHIR_OBS_VAR(rolesNames);
zephir_read_property_this(&rolesNames, this_ptr, SL("_rolesNames"), PH_NOISY_CC);
if (!(zephir_array_isset(rolesNames, roleName))) {
ZEPHIR_INIT_VAR(_0$$3);
object_init_ex(_0$$3, phalcon_acl_exception_ce);
ZEPHIR_INIT_VAR(_1$$3);
ZEPHIR_CONCAT_SVS(_1$$3, "Role '", roleName, "' does not exist in the role list");
ZEPHIR_CALL_METHOD(NULL, _0$$3, "__construct", NULL, 9, _1$$3);
zephir_check_call_status();
zephir_throw_exception_debug(_0$$3, "phalcon/acl/adapter/memory.zep", 228 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (Z_TYPE_P(roleToInherit) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&roleInheritName, roleToInherit, "getname", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(roleInheritName, roleToInherit);
}
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_roleInherits"), PH_NOISY_CC);
if (zephir_array_isset(_2, roleInheritName)) {
_3$$6 = zephir_fetch_nproperty_this(this_ptr, SL("_roleInherits"), PH_NOISY_CC);
zephir_array_fetch(&_4$$6, _3$$6, roleInheritName, PH_NOISY | PH_READONLY, "phalcon/acl/adapter/memory.zep", 241 TSRMLS_CC);
zephir_is_iterable(_4$$6, &_6$$6, &_5$$6, 0, 0, "phalcon/acl/adapter/memory.zep", 244);
for (
; zephir_hash_get_current_data_ex(_6$$6, (void**) &_7$$6, &_5$$6) == SUCCESS
; zephir_hash_move_forward_ex(_6$$6, &_5$$6)
) {
ZEPHIR_GET_HVALUE(deepInheritName, _7$$6);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "addinherit", &_8, 83, roleName, deepInheritName);
zephir_check_call_status();
}
}
if (!(zephir_array_isset(rolesNames, roleInheritName))) {
ZEPHIR_INIT_VAR(_9$$8);
object_init_ex(_9$$8, phalcon_acl_exception_ce);
ZEPHIR_INIT_VAR(_10$$8);
ZEPHIR_CONCAT_SVS(_10$$8, "Role '", roleInheritName, "' (to inherit) does not exist in the role list");
ZEPHIR_CALL_METHOD(NULL, _9$$8, "__construct", NULL, 9, _10$$8);
zephir_check_call_status();
zephir_throw_exception_debug(_9$$8, "phalcon/acl/adapter/memory.zep", 250 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (ZEPHIR_IS_EQUAL(roleName, roleInheritName)) {
RETURN_MM_BOOL(0);
}
_11 = zephir_fetch_nproperty_this(this_ptr, SL("_roleInherits"), PH_NOISY_CC);
if (!(zephir_array_isset(_11, roleName))) {
zephir_update_property_array(this_ptr, SL("_roleInherits"), roleName, ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
}
zephir_update_property_array_multi(this_ptr, SL("_roleInherits"), &roleInheritName TSRMLS_CC, SL("za"), 2, roleName);
RETURN_MM_BOOL(1);
}
/**
* Sends the cookie to the HTTP client
* Stores the cookie definition in session
*/
PHP_METHOD(Phalcon_Http_Cookie, send) {
zval *_6$$12 = NULL;
zval *name = NULL, *value = NULL, *expire = NULL, *domain = NULL, *path = NULL, *secure = NULL, *httpOnly = NULL, *dependencyInjector = NULL, *definition = NULL, *session = NULL, *crypt = NULL, *encryptValue = NULL, *_3, *_0$$9 = NULL, *_1$$9, *_2$$10, *_4$$12 = NULL, *_5$$12;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(name);
zephir_read_property_this(&name, this_ptr, SL("_name"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(value);
zephir_read_property_this(&value, this_ptr, SL("_value"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(expire);
zephir_read_property_this(&expire, this_ptr, SL("_expire"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(domain);
zephir_read_property_this(&domain, this_ptr, SL("_domain"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(path);
zephir_read_property_this(&path, this_ptr, SL("_path"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(secure);
zephir_read_property_this(&secure, this_ptr, SL("_secure"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(httpOnly);
zephir_read_property_this(&httpOnly, this_ptr, SL("_httpOnly"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_http_response_exception_ce, "A dependency injection object is required to access the 'session' service", "phalcon/http/cookie.zep", 220);
return;
}
ZEPHIR_INIT_VAR(definition);
array_init(definition);
if (!ZEPHIR_IS_LONG(expire, 0)) {
zephir_array_update_string(&definition, SL("expire"), &expire, PH_COPY | PH_SEPARATE);
}
if (!(ZEPHIR_IS_EMPTY(path))) {
zephir_array_update_string(&definition, SL("path"), &path, PH_COPY | PH_SEPARATE);
}
if (!(ZEPHIR_IS_EMPTY(domain))) {
zephir_array_update_string(&definition, SL("domain"), &domain, PH_COPY | PH_SEPARATE);
}
if (!(ZEPHIR_IS_EMPTY(secure))) {
zephir_array_update_string(&definition, SL("secure"), &secure, PH_COPY | PH_SEPARATE);
}
if (!(ZEPHIR_IS_EMPTY(httpOnly))) {
zephir_array_update_string(&definition, SL("httpOnly"), &httpOnly, PH_COPY | PH_SEPARATE);
}
if (zephir_fast_count_int(definition TSRMLS_CC)) {
ZEPHIR_INIT_VAR(_1$$9);
ZVAL_STRING(_1$$9, "session", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0$$9, dependencyInjector, "getshared", NULL, 0, _1$$9);
zephir_check_temp_parameter(_1$$9);
zephir_check_call_status();
ZEPHIR_CPY_WRT(session, _0$$9);
ZEPHIR_CALL_METHOD(&_0$$9, session, "isstarted", NULL, 0);
zephir_check_call_status();
if (zephir_is_true(_0$$9)) {
ZEPHIR_INIT_VAR(_2$$10);
ZEPHIR_CONCAT_SV(_2$$10, "_PHCOOKIE_", name);
ZEPHIR_CALL_METHOD(NULL, session, "set", NULL, 0, _2$$10, definition);
zephir_check_call_status();
}
}
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_useEncryption"), PH_NOISY_CC);
if (zephir_is_true(_3)) {
if (!(ZEPHIR_IS_EMPTY(value))) {
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_http_response_exception_ce, "A dependency injection object is required to access the 'filter' service", "phalcon/http/cookie.zep", 260);
return;
}
ZEPHIR_INIT_VAR(_5$$12);
ZVAL_STRING(_5$$12, "crypt", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_4$$12, dependencyInjector, "getshared", NULL, 0, _5$$12);
zephir_check_temp_parameter(_5$$12);
zephir_check_call_status();
ZEPHIR_CPY_WRT(crypt, _4$$12);
zephir_get_strval(_6$$12, value);
ZEPHIR_CALL_METHOD(&encryptValue, crypt, "encryptbase64", NULL, 0, _6$$12);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(encryptValue, value);
}
} else {
ZEPHIR_CPY_WRT(encryptValue, value);
}
ZEPHIR_CALL_FUNCTION(NULL, "setcookie", NULL, 218, name, encryptValue, expire, path, domain, secure, httpOnly);
zephir_check_call_status();
RETURN_THIS();
}
/**
* Check whether a role is allowed to access an action from a resource
*
* <code>
* //Does andres have access to the customers resource to create?
* $acl->isAllowed("andres", "Products", "create");
*
* //Do guests have access to any resource to edit?
* $acl->isAllowed("guests", "*", "edit");
* </code>
*/
PHP_METHOD(Phalcon_Acl_Adapter_Memory, isAllowed) {
zend_bool _15$$31, _20$$33, _22$$33, _24$$33, _26$$33, _40$$40, _42$$39, _44$$41;
HashTable *_5$$13, *_8$$19, *_11$$25, *_18$$30;
HashPosition _4$$13, _7$$19, _10$$25, _17$$30;
zephir_fcall_cache_entry *_34 = NULL, *_38 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *parameters = NULL;
zval *access = NULL;
zval *roleName = NULL, *resourceName = NULL, *access_param = NULL, *parameters_param = NULL, *eventsManager = NULL, *accessList = NULL, *accessKey = NULL, *haveAccess = NULL, *roleInherits = NULL, *inheritedRole = NULL, *rolesNames = NULL, *inheritedRoles = NULL, *funcAccess = NULL, *resourceObject = NULL, *roleObject = NULL, *funcList = NULL, *reflectionFunction = NULL, *reflectionParameters = NULL, *parameterNumber = NULL, *parametersForFunction = NULL, *numberOfRequiredParameters = NULL, *userParametersSizeShouldBe = NULL, *reflectionClass = NULL, *parameterToCheck = NULL, *reflectionParameter = NULL, *_0, *_1$$7 = NULL, *_2$$7, *_3$$9, **_6$$13, **_9$$19, **_12$$25, *_13$$28, *_14$$29, *_16$$31, **_19$$30, *_46$$30, *_47$$30, *_21$$33 = NULL, *_23$$33 = NULL, *_25$$33 = NULL, *_27$$33 = NULL, *_28$$33, *_29$$36 = NULL, *_30$$36 = NULL, *_31$$36, *_32$$36 = NULL, *_33$$36 = NULL, *_35$$37, *_36$$38, _37$$38, *_39$$40, *_41$$40, *_43$$39, *_45$$41;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 1, &roleName, &resourceName, &access_param, ¶meters_param);
ZEPHIR_SEPARATE_PARAM(roleName);
ZEPHIR_SEPARATE_PARAM(resourceName);
zephir_get_strval(access, access_param);
if (!parameters_param) {
ZEPHIR_INIT_VAR(parameters);
array_init(parameters);
} else {
zephir_get_arrval(parameters, parameters_param);
}
ZEPHIR_INIT_VAR(haveAccess);
ZVAL_NULL(haveAccess);
ZEPHIR_INIT_VAR(funcAccess);
ZVAL_NULL(funcAccess);
ZEPHIR_INIT_VAR(resourceObject);
ZVAL_NULL(resourceObject);
ZEPHIR_INIT_VAR(roleObject);
ZVAL_NULL(roleObject);
if (Z_TYPE_P(roleName) == IS_OBJECT) {
if (!(zephir_instance_of_ev(roleName, phalcon_acl_roleaware_ce TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_acl_exception_ce, "Object passed as roleName must implement RoleAware", "phalcon/acl/adapter/memory.zep", 545);
return;
}
ZEPHIR_CPY_WRT(roleObject, roleName);
ZEPHIR_CALL_METHOD(&roleName, roleObject, "getrolename", NULL, 0);
zephir_check_call_status();
}
if (Z_TYPE_P(resourceName) == IS_OBJECT) {
if (!(zephir_instance_of_ev(resourceName, phalcon_acl_resourceaware_ce TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_acl_exception_ce, "Object passed as resourceName must implement ResourceAware", "phalcon/acl/adapter/memory.zep", 553);
return;
}
ZEPHIR_CPY_WRT(resourceObject, resourceName);
ZEPHIR_CALL_METHOD(&resourceName, resourceObject, "getresourcename", NULL, 0);
zephir_check_call_status();
}
zephir_update_property_this(this_ptr, SL("_activeRole"), roleName TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_activeResource"), resourceName TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_activeAccess"), access TSRMLS_CC);
ZEPHIR_OBS_VAR(accessList);
zephir_read_property_this(&accessList, this_ptr, SL("_access"), PH_NOISY_CC);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(eventsManager, _0);
ZEPHIR_OBS_VAR(funcList);
zephir_read_property_this(&funcList, this_ptr, SL("_func"), PH_NOISY_CC);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_2$$7);
ZVAL_STRING(_2$$7, "acl:beforeCheckAccess", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_1$$7, eventsManager, "fire", NULL, 0, _2$$7, this_ptr);
zephir_check_temp_parameter(_2$$7);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_1$$7)) {
RETURN_MM_BOOL(0);
}
}
ZEPHIR_OBS_VAR(rolesNames);
zephir_read_property_this(&rolesNames, this_ptr, SL("_rolesNames"), PH_NOISY_CC);
if (!(zephir_array_isset(rolesNames, roleName))) {
_3$$9 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAccess"), PH_NOISY_CC);
RETURN_MM_BOOL((ZEPHIR_IS_LONG(_3$$9, 1)));
}
ZEPHIR_INIT_VAR(accessKey);
ZEPHIR_CONCAT_VSVSV(accessKey, roleName, "!", resourceName, "!", access);
if (zephir_array_isset(accessList, accessKey)) {
ZEPHIR_OBS_NVAR(haveAccess);
zephir_array_fetch(&haveAccess, accessList, accessKey, PH_NOISY, "phalcon/acl/adapter/memory.zep", 586 TSRMLS_CC);
}
ZEPHIR_OBS_NVAR(funcAccess);
zephir_array_isset_fetch(&funcAccess, funcList, accessKey, 0 TSRMLS_CC);
if (Z_TYPE_P(haveAccess) == IS_NULL) {
ZEPHIR_OBS_VAR(roleInherits);
zephir_read_property_this(&roleInherits, this_ptr, SL("_roleInherits"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(inheritedRoles);
if (zephir_array_isset_fetch(&inheritedRoles, roleInherits, roleName, 0 TSRMLS_CC)) {
if (Z_TYPE_P(inheritedRoles) == IS_ARRAY) {
zephir_is_iterable(inheritedRoles, &_5$$13, &_4$$13, 0, 0, "phalcon/acl/adapter/memory.zep", 610);
for (
; zephir_hash_get_current_data_ex(_5$$13, (void**) &_6$$13, &_4$$13) == SUCCESS
; zephir_hash_move_forward_ex(_5$$13, &_4$$13)
) {
ZEPHIR_GET_HVALUE(inheritedRole, _6$$13);
ZEPHIR_INIT_NVAR(accessKey);
ZEPHIR_CONCAT_VSVSV(accessKey, inheritedRole, "!", resourceName, "!", access);
if (zephir_array_isset(accessList, accessKey)) {
ZEPHIR_OBS_NVAR(haveAccess);
zephir_array_fetch(&haveAccess, accessList, accessKey, PH_NOISY, "phalcon/acl/adapter/memory.zep", 606 TSRMLS_CC);
}
ZEPHIR_OBS_NVAR(funcAccess);
zephir_array_isset_fetch(&funcAccess, funcList, accessKey, 0 TSRMLS_CC);
}
}
}
}
if (Z_TYPE_P(haveAccess) == IS_NULL) {
ZEPHIR_INIT_NVAR(accessKey);
ZEPHIR_CONCAT_VSVS(accessKey, roleName, "!", resourceName, "!*");
if (zephir_array_isset(accessList, accessKey)) {
ZEPHIR_OBS_NVAR(haveAccess);
zephir_array_fetch(&haveAccess, accessList, accessKey, PH_NOISY, "phalcon/acl/adapter/memory.zep", 625 TSRMLS_CC);
ZEPHIR_OBS_NVAR(funcAccess);
zephir_array_isset_fetch(&funcAccess, funcList, accessKey, 0 TSRMLS_CC);
} else {
if (Z_TYPE_P(inheritedRoles) == IS_ARRAY) {
zephir_is_iterable(inheritedRoles, &_8$$19, &_7$$19, 0, 0, "phalcon/acl/adapter/memory.zep", 641);
for (
; zephir_hash_get_current_data_ex(_8$$19, (void**) &_9$$19, &_7$$19) == SUCCESS
; zephir_hash_move_forward_ex(_8$$19, &_7$$19)
) {
ZEPHIR_GET_HVALUE(inheritedRole, _9$$19);
ZEPHIR_INIT_NVAR(accessKey);
ZEPHIR_CONCAT_VSVS(accessKey, inheritedRole, "!", resourceName, "!*");
ZEPHIR_OBS_NVAR(funcAccess);
zephir_array_isset_fetch(&funcAccess, funcList, accessKey, 0 TSRMLS_CC);
if (zephir_array_isset(accessList, accessKey)) {
ZEPHIR_OBS_NVAR(haveAccess);
zephir_array_fetch(&haveAccess, accessList, accessKey, PH_NOISY, "phalcon/acl/adapter/memory.zep", 637 TSRMLS_CC);
break;
}
}
}
}
}
if (Z_TYPE_P(haveAccess) == IS_NULL) {
ZEPHIR_INIT_NVAR(accessKey);
ZEPHIR_CONCAT_VS(accessKey, roleName, "!*!*");
if (zephir_array_isset(accessList, accessKey)) {
ZEPHIR_OBS_NVAR(haveAccess);
zephir_array_fetch(&haveAccess, accessList, accessKey, PH_NOISY, "phalcon/acl/adapter/memory.zep", 656 TSRMLS_CC);
ZEPHIR_OBS_NVAR(funcAccess);
zephir_array_isset_fetch(&funcAccess, funcList, accessKey, 0 TSRMLS_CC);
} else {
if (Z_TYPE_P(inheritedRoles) == IS_ARRAY) {
zephir_is_iterable(inheritedRoles, &_11$$25, &_10$$25, 0, 0, "phalcon/acl/adapter/memory.zep", 672);
for (
; zephir_hash_get_current_data_ex(_11$$25, (void**) &_12$$25, &_10$$25) == SUCCESS
; zephir_hash_move_forward_ex(_11$$25, &_10$$25)
) {
ZEPHIR_GET_HVALUE(inheritedRole, _12$$25);
ZEPHIR_INIT_NVAR(accessKey);
ZEPHIR_CONCAT_VS(accessKey, inheritedRole, "!*!*");
ZEPHIR_OBS_NVAR(funcAccess);
zephir_array_isset_fetch(&funcAccess, funcList, accessKey, 0 TSRMLS_CC);
if (zephir_array_isset(accessList, accessKey)) {
ZEPHIR_OBS_NVAR(haveAccess);
zephir_array_fetch(&haveAccess, accessList, accessKey, PH_NOISY, "phalcon/acl/adapter/memory.zep", 668 TSRMLS_CC);
break;
}
}
}
}
}
zephir_update_property_this(this_ptr, SL("_accessGranted"), haveAccess TSRMLS_CC);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_13$$28);
ZVAL_STRING(_13$$28, "acl:afterCheckAccess", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _13$$28, this_ptr);
zephir_check_temp_parameter(_13$$28);
zephir_check_call_status();
}
if (Z_TYPE_P(haveAccess) == IS_NULL) {
_14$$29 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAccess"), PH_NOISY_CC);
RETURN_MM_BOOL(ZEPHIR_IS_LONG(_14$$29, 1));
}
if (Z_TYPE_P(funcAccess) != IS_NULL) {
ZEPHIR_INIT_VAR(reflectionFunction);
object_init_ex(reflectionFunction, zephir_get_internal_ce(SS("reflectionfunction") TSRMLS_CC));
ZEPHIR_CALL_METHOD(NULL, reflectionFunction, "__construct", NULL, 85, funcAccess);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&reflectionParameters, reflectionFunction, "getparameters", NULL, 86);
zephir_check_call_status();
ZEPHIR_INIT_VAR(parameterNumber);
ZVAL_LONG(parameterNumber, zephir_fast_count_int(reflectionParameters TSRMLS_CC));
if (ZEPHIR_IS_LONG_IDENTICAL(parameterNumber, 0)) {
_15$$31 = ZEPHIR_IS_LONG(haveAccess, 1);
if (_15$$31) {
ZEPHIR_INIT_VAR(_16$$31);
ZEPHIR_CALL_USER_FUNC(_16$$31, funcAccess);
zephir_check_call_status();
_15$$31 = zephir_is_true(_16$$31);
}
RETURN_MM_BOOL(_15$$31);
}
ZEPHIR_INIT_VAR(parametersForFunction);
array_init(parametersForFunction);
ZEPHIR_CALL_METHOD(&numberOfRequiredParameters, reflectionFunction, "getnumberofrequiredparameters", NULL, 87);
zephir_check_call_status();
ZEPHIR_CPY_WRT(userParametersSizeShouldBe, parameterNumber);
zephir_is_iterable(reflectionParameters, &_18$$30, &_17$$30, 0, 0, "phalcon/acl/adapter/memory.zep", 737);
for (
; zephir_hash_get_current_data_ex(_18$$30, (void**) &_19$$30, &_17$$30) == SUCCESS
; zephir_hash_move_forward_ex(_18$$30, &_17$$30)
) {
ZEPHIR_GET_HVALUE(reflectionParameter, _19$$30);
ZEPHIR_CALL_METHOD(&reflectionClass, reflectionParameter, "getclass", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(¶meterToCheck, reflectionParameter, "getname", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(reflectionClass) != IS_NULL) {
_20$$33 = Z_TYPE_P(roleObject) != IS_NULL;
if (_20$$33) {
ZEPHIR_CALL_METHOD(&_21$$33, reflectionClass, "isinstance", NULL, 0, roleObject);
zephir_check_call_status();
_20$$33 = zephir_is_true(_21$$33);
}
if (_20$$33) {
zephir_array_append(¶metersForFunction, roleObject, PH_SEPARATE, "phalcon/acl/adapter/memory.zep", 709);
ZEPHIR_SEPARATE(userParametersSizeShouldBe);
zephir_decrement(userParametersSizeShouldBe);
continue;
}
_22$$33 = Z_TYPE_P(resourceObject) != IS_NULL;
if (_22$$33) {
ZEPHIR_CALL_METHOD(&_23$$33, reflectionClass, "isinstance", NULL, 0, resourceObject);
zephir_check_call_status();
_22$$33 = zephir_is_true(_23$$33);
}
if (_22$$33) {
zephir_array_append(¶metersForFunction, resourceObject, PH_SEPARATE, "phalcon/acl/adapter/memory.zep", 717);
ZEPHIR_SEPARATE(userParametersSizeShouldBe);
zephir_decrement(userParametersSizeShouldBe);
continue;
}
_24$$33 = zephir_array_isset(parameters, parameterToCheck);
if (_24$$33) {
ZEPHIR_OBS_NVAR(_25$$33);
zephir_array_fetch(&_25$$33, parameters, parameterToCheck, PH_NOISY, "phalcon/acl/adapter/memory.zep", 724 TSRMLS_CC);
_24$$33 = Z_TYPE_P(_25$$33) == IS_OBJECT;
}
_26$$33 = _24$$33;
if (_26$$33) {
zephir_array_fetch(&_28$$33, parameters, parameterToCheck, PH_NOISY | PH_READONLY, "phalcon/acl/adapter/memory.zep", 724 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_27$$33, reflectionClass, "isinstance", NULL, 0, _28$$33);
zephir_check_call_status();
_26$$33 = !zephir_is_true(_27$$33);
}
if (_26$$33) {
ZEPHIR_INIT_NVAR(_29$$36);
object_init_ex(_29$$36, phalcon_acl_exception_ce);
ZEPHIR_INIT_NVAR(_30$$36);
zephir_array_fetch(&_31$$36, parameters, parameterToCheck, PH_NOISY | PH_READONLY, "phalcon/acl/adapter/memory.zep", 726 TSRMLS_CC);
zephir_get_class(_30$$36, _31$$36, 0 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_32$$36, reflectionClass, "getname", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_33$$36);
ZEPHIR_CONCAT_SVSVSVSVSVS(_33$$36, "Your passed parameter doesn't have the same class as the parameter in defined function when check ", roleName, " can ", access, " ", resourceName, ". Class passed: ", _30$$36, " , Class in defined function: ", _32$$36, ".");
ZEPHIR_CALL_METHOD(NULL, _29$$36, "__construct", &_34, 9, _33$$36);
zephir_check_call_status();
zephir_throw_exception_debug(_29$$36, "phalcon/acl/adapter/memory.zep", 727 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
if (zephir_array_isset(parameters, parameterToCheck)) {
zephir_array_fetch(&_35$$37, parameters, parameterToCheck, PH_NOISY | PH_READONLY, "phalcon/acl/adapter/memory.zep", 733 TSRMLS_CC);
zephir_array_append(¶metersForFunction, _35$$37, PH_SEPARATE, "phalcon/acl/adapter/memory.zep", 733);
}
}
if (ZEPHIR_LT_LONG(userParametersSizeShouldBe, zephir_fast_count_int(parameters TSRMLS_CC))) {
ZEPHIR_INIT_VAR(_36$$38);
ZEPHIR_CONCAT_SVSVSVS(_36$$38, "Number of parameters in array is higher than the number of parameters in defined function when check ", roleName, " can ", access, " ", resourceName, ". Remember that more parameters than defined in function will be ignored.");
ZEPHIR_SINIT_VAR(_37$$38);
ZVAL_LONG(&_37$$38, 512);
ZEPHIR_CALL_FUNCTION(NULL, "trigger_error", &_38, 2, _36$$38, &_37$$38);
zephir_check_call_status();
}
if (zephir_fast_count_int(parametersForFunction TSRMLS_CC) == 0) {
if (ZEPHIR_GT_LONG(numberOfRequiredParameters, 0)) {
ZEPHIR_INIT_VAR(_39$$40);
ZEPHIR_CONCAT_SVSVSVS(_39$$40, "You didn't provide any parameters when check ", roleName, " can ", access, " ", resourceName, ". We will use default action when no arguments.");
ZEPHIR_CALL_FUNCTION(NULL, "trigger_error", &_38, 2, _39$$40);
zephir_check_call_status();
_40$$40 = ZEPHIR_IS_LONG(haveAccess, 1);
if (_40$$40) {
_41$$40 = zephir_fetch_nproperty_this(this_ptr, SL("_noArgumentsDefaultAction"), PH_NOISY_CC);
_40$$40 = ZEPHIR_IS_LONG(_41$$40, 1);
}
RETURN_MM_BOOL(_40$$40);
}
_42$$39 = ZEPHIR_IS_LONG(haveAccess, 1);
if (_42$$39) {
ZEPHIR_INIT_VAR(_43$$39);
ZEPHIR_CALL_USER_FUNC(_43$$39, funcAccess);
zephir_check_call_status();
_42$$39 = zephir_is_true(_43$$39);
}
RETURN_MM_BOOL(_42$$39);
}
if (ZEPHIR_LE_LONG(numberOfRequiredParameters, zephir_fast_count_int(parametersForFunction TSRMLS_CC))) {
_44$$41 = ZEPHIR_IS_LONG(haveAccess, 1);
if (_44$$41) {
ZEPHIR_INIT_VAR(_45$$41);
ZEPHIR_CALL_USER_FUNC_ARRAY(_45$$41, funcAccess, parametersForFunction);
zephir_check_call_status();
_44$$41 = zephir_is_true(_45$$41);
}
RETURN_MM_BOOL(_44$$41);
}
ZEPHIR_INIT_VAR(_46$$30);
object_init_ex(_46$$30, phalcon_acl_exception_ce);
ZEPHIR_INIT_VAR(_47$$30);
ZEPHIR_CONCAT_SVSVSV(_47$$30, "You didn't provide all necessary parameters for defined function when check ", roleName, " can ", access, " ", resourceName);
ZEPHIR_CALL_METHOD(NULL, _46$$30, "__construct", &_34, 9, _47$$30);
zephir_check_call_status();
zephir_throw_exception_debug(_46$$30, "phalcon/acl/adapter/memory.zep", 766 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
RETURN_MM_BOOL(ZEPHIR_IS_LONG(haveAccess, 1));
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_Between, validate) {
zend_bool _3;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *validation, validation_sub, *field, field_sub, value, minimum, maximum, message, label, replacePairs, code, _0, _1$$3, _2$$4, _4$$5, _5$$5, _6$$5;
zval *this_ptr = getThis();
ZVAL_UNDEF(&validation_sub);
ZVAL_UNDEF(&field_sub);
ZVAL_UNDEF(&value);
ZVAL_UNDEF(&minimum);
ZVAL_UNDEF(&maximum);
ZVAL_UNDEF(&message);
ZVAL_UNDEF(&label);
ZVAL_UNDEF(&replacePairs);
ZVAL_UNDEF(&code);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1$$3);
ZVAL_UNDEF(&_2$$4);
ZVAL_UNDEF(&_4$$5);
ZVAL_UNDEF(&_5$$5);
ZVAL_UNDEF(&_6$$5);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field);
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_0);
ZVAL_STRING(&_0, "minimum");
ZEPHIR_CALL_METHOD(&minimum, this_ptr, "getoption", NULL, 0, &_0);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "maximum");
ZEPHIR_CALL_METHOD(&maximum, this_ptr, "getoption", NULL, 0, &_0);
zephir_check_call_status();
if (Z_TYPE_P(&minimum) == IS_ARRAY) {
zephir_array_fetch(&_1$$3, &minimum, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/between.zep", 79 TSRMLS_CC);
ZEPHIR_CPY_WRT(&minimum, &_1$$3);
}
if (Z_TYPE_P(&maximum) == IS_ARRAY) {
zephir_array_fetch(&_2$$4, &maximum, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/between.zep", 83 TSRMLS_CC);
ZEPHIR_CPY_WRT(&maximum, &_2$$4);
}
_3 = ZEPHIR_LT(&value, &minimum);
if (!(_3)) {
_3 = ZEPHIR_GT(&value, &maximum);
}
if (_3) {
ZEPHIR_CALL_METHOD(&label, this_ptr, "preparelabel", NULL, 0, validation, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_4$$5);
ZVAL_STRING(&_4$$5, "Between");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_4$$5);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&code, this_ptr, "preparecode", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&replacePairs);
zephir_create_array(&replacePairs, 3, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":min"), &minimum, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":max"), &maximum, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_4$$5);
object_init_ex(&_4$$5, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_5$$5, "strtr", NULL, 48, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_6$$5);
ZVAL_STRING(&_6$$5, "Between");
ZEPHIR_CALL_METHOD(NULL, &_4$$5, "__construct", NULL, 300, &_5$$5, field, &_6$$5, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_4$$5);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* 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_Mongo, save) {
zval *_2$$14;
int ZEPHIR_LAST_CALL_STATUS;
zend_bool stopBuffer;
zval *keyName = NULL, *content = NULL, *lifetime = NULL, *stopBuffer_param = NULL, *lastkey = NULL, *frontend = NULL, *cachedContent = NULL, *tmp = NULL, *ttl = NULL, *collection = NULL, *timestamp = NULL, *conditions = NULL, *document = NULL, *preparedContent = NULL, *isBuffering = NULL, *data = NULL, *success = NULL, *_1, *_0$$4, *_3$$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);
}
ZEPHIR_INIT_VAR(conditions);
array_init(conditions);
ZEPHIR_INIT_VAR(data);
array_init(data);
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);
zephir_update_property_this(this_ptr, SL("_lastKey"), lastkey TSRMLS_CC);
}
if (!(zephir_is_true(lastkey))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cache must be started first", "phalcon/cache/backend/mongo.zep", 208);
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_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);
}
ZEPHIR_CALL_METHOD(&collection, this_ptr, "_getcollection", NULL, 117);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_1);
zephir_time(_1);
ZEPHIR_INIT_VAR(timestamp);
ZVAL_LONG(timestamp, (zephir_get_numberval(_1) + zephir_get_intval(ttl)));
zephir_array_update_string(&conditions, SL("key"), &lastkey, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(&document, collection, "findone", NULL, 0, conditions);
zephir_check_call_status();
if (Z_TYPE_P(document) == IS_ARRAY) {
zephir_array_update_string(&document, SL("time"), ×tamp, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&document, SL("data"), &preparedContent, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_VAR(_2$$14);
zephir_create_array(_2$$14, 1, 0 TSRMLS_CC);
ZEPHIR_OBS_VAR(_3$$14);
zephir_array_fetch_string(&_3$$14, document, SL("_id"), PH_NOISY, "phalcon/cache/backend/mongo.zep", 243 TSRMLS_CC);
zephir_array_update_string(&_2$$14, SL("_id"), &_3$$14, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(&success, collection, "update", NULL, 0, _2$$14, document);
zephir_check_call_status();
} else {
zephir_array_update_string(&data, SL("key"), &lastkey, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&data, SL("time"), ×tamp, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&data, SL("data"), &preparedContent, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(&success, collection, "insert", NULL, 0, data);
zephir_check_call_status();
}
if (!(zephir_is_true(success))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Failed storing data in mongodb", "phalcon/cache/backend/mongo.zep", 252);
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(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);
}
/**
* 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, 364, 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);
}
/**
* 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, 356, dependencyInjector, _6, _5);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, transaction, "settransactionmanager", NULL, 357, 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);
}
/**
* 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, *_13 = 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, *_12 = 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_INIT_NVAR(_10);
if (mustClean) {
ZVAL_BOOL(_10, 1);
} else {
ZVAL_BOOL(_10, 0);
}
ZEPHIR_CALL_METHOD(NULL, engine, "render", NULL, 0, viewEnginePath, params, _10);
zephir_check_call_status();
notExists = 0;
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_12);
ZVAL_STRING(_12, "view:afterRenderView", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", &_13, 0, _12, this_ptr);
zephir_check_temp_parameter(_12);
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();
}
/**
* Extracts parameters from a string
*/
PHP_METHOD(Phalcon_Mvc_Router_Route, extractNamedParams) {
long _0, _5$$11, _26$$19;
zend_bool notValid = 0, _6$$12, _7$$12, _8$$12, _9$$12, _10$$12, _11$$12, _12$$12, _13$$12, _14$$12, _15$$12, _16$$12, _17$$12, _25$$18;
int tmp = 0, cursor = 0, cursorVar = 0, marker = 0, bracketCount, parenthesesCount, foundPattern, intermediate, numberMatches;
char ch = 0;
zval *pattern_param = NULL, *matches = NULL, _1$$11 = zval_used_for_init, _2$$11 = zval_used_for_init, *_3$$11 = NULL, _18$$16 = zval_used_for_init, _19$$16 = zval_used_for_init, *_20$$16 = NULL, _22$$16 = zval_used_for_init, *_23$$16 = NULL, *_28$$19 = NULL, *_29$$28 = NULL;
zval *pattern = NULL, *route = NULL, *item = NULL, *variable = NULL, *regexp = NULL, *_4$$11 = NULL, *_21$$16 = NULL, *_24$$16 = NULL, *_27$$26 = NULL, *_30$$29 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &pattern_param);
if (unlikely(Z_TYPE_P(pattern_param) != IS_STRING && Z_TYPE_P(pattern_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'pattern' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(pattern_param) == IS_STRING)) {
zephir_get_strval(pattern, pattern_param);
} else {
ZEPHIR_INIT_VAR(pattern);
ZVAL_EMPTY_STRING(pattern);
}
bracketCount = 0;
parenthesesCount = 0;
foundPattern = 0;
intermediate = 0;
numberMatches = 0;
if (zephir_fast_strlen_ev(pattern) <= 0) {
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_VAR(matches);
array_init(matches);
ZEPHIR_INIT_VAR(route);
ZVAL_EMPTY_STRING(route);
for (_0 = 0; _0 < Z_STRLEN_P(pattern); _0++) {
cursor = _0;
ch = ZEPHIR_STRING_OFFSET(pattern, _0);
if (parenthesesCount == 0) {
if (ch == '{') {
if (bracketCount == 0) {
marker = (cursor + 1);
intermediate = 0;
notValid = 0;
}
bracketCount++;
} else {
if (ch == '}') {
bracketCount--;
if (intermediate > 0) {
if (bracketCount == 0) {
numberMatches++;
ZEPHIR_INIT_NVAR(variable);
ZVAL_EMPTY_STRING(variable);
ZEPHIR_INIT_NVAR(regexp);
ZVAL_EMPTY_STRING(regexp);
ZEPHIR_SINIT_NVAR(_1$$11);
ZVAL_LONG(&_1$$11, marker);
ZEPHIR_SINIT_NVAR(_2$$11);
ZVAL_LONG(&_2$$11, (cursor - marker));
ZEPHIR_INIT_NVAR(_3$$11);
zephir_substr(_3$$11, pattern, zephir_get_intval(&_1$$11), zephir_get_intval(&_2$$11), 0);
zephir_get_strval(_4$$11, _3$$11);
ZEPHIR_CPY_WRT(item, _4$$11);
for (_5$$11 = 0; _5$$11 < Z_STRLEN_P(item); _5$$11++) {
cursorVar = _5$$11;
ch = ZEPHIR_STRING_OFFSET(item, _5$$11);
if (ch == '\0') {
break;
}
_6$$12 = cursorVar == 0;
if (_6$$12) {
_7$$12 = ch >= 'a';
if (_7$$12) {
_7$$12 = ch <= 'z';
}
_8$$12 = _7$$12;
if (!(_8$$12)) {
_9$$12 = ch >= 'A';
if (_9$$12) {
_9$$12 = ch <= 'Z';
}
_8$$12 = _9$$12;
}
_6$$12 = !(_8$$12);
}
if (_6$$12) {
notValid = 1;
break;
}
_10$$12 = ch >= 'a';
if (_10$$12) {
_10$$12 = ch <= 'z';
}
_11$$12 = _10$$12;
if (!(_11$$12)) {
_12$$12 = ch >= 'A';
if (_12$$12) {
_12$$12 = ch <= 'Z';
}
_11$$12 = _12$$12;
}
_13$$12 = _11$$12;
if (!(_13$$12)) {
_14$$12 = ch >= '0';
if (_14$$12) {
_14$$12 = ch <= '9';
}
_13$$12 = _14$$12;
}
_15$$12 = _13$$12;
if (!(_15$$12)) {
_15$$12 = ch == '-';
}
_16$$12 = _15$$12;
if (!(_16$$12)) {
_16$$12 = ch == '_';
}
_17$$12 = _16$$12;
if (!(_17$$12)) {
_17$$12 = ch == ':';
}
if (_17$$12) {
if (ch == ':') {
ZEPHIR_SINIT_NVAR(_18$$16);
ZVAL_LONG(&_18$$16, 0);
ZEPHIR_SINIT_NVAR(_19$$16);
ZVAL_LONG(&_19$$16, cursorVar);
ZEPHIR_INIT_NVAR(_20$$16);
zephir_substr(_20$$16, item, 0 , zephir_get_intval(&_19$$16), 0);
zephir_get_strval(_21$$16, _20$$16);
ZEPHIR_CPY_WRT(variable, _21$$16);
ZEPHIR_SINIT_NVAR(_22$$16);
ZVAL_LONG(&_22$$16, (cursorVar + 1));
ZEPHIR_INIT_NVAR(_23$$16);
zephir_substr(_23$$16, item, zephir_get_intval(&_22$$16), 0, ZEPHIR_SUBSTR_NO_LENGTH);
zephir_get_strval(_24$$16, _23$$16);
ZEPHIR_CPY_WRT(regexp, _24$$16);
break;
}
} else {
notValid = 1;
break;
}
}
if (!(notValid)) {
tmp = numberMatches;
_25$$18 = zephir_is_true(variable);
if (_25$$18) {
_25$$18 = zephir_is_true(regexp);
}
if (_25$$18) {
foundPattern = 0;
for (_26$$19 = 0; _26$$19 < Z_STRLEN_P(regexp); _26$$19++) {
ch = ZEPHIR_STRING_OFFSET(regexp, _26$$19);
if (ch == '\0') {
break;
}
if (!(foundPattern)) {
if (ch == '(') {
foundPattern = 1;
}
} else {
if (ch == ')') {
foundPattern = 2;
break;
}
}
}
if (foundPattern != 2) {
ZEPHIR_INIT_LNVAR(_27$$26);
ZEPHIR_CONCAT_SVS(_27$$26, "(", regexp, ")");
zephir_concat_self(&route, _27$$26 TSRMLS_CC);
} else {
zephir_concat_self(&route, regexp TSRMLS_CC);
}
ZEPHIR_INIT_NVAR(_28$$19);
ZVAL_LONG(_28$$19, tmp);
zephir_array_update_zval(&matches, variable, &_28$$19, PH_COPY | PH_SEPARATE);
} else {
zephir_concat_self_str(&route, "([^/]*)", sizeof("([^/]*)")-1 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_29$$28);
ZVAL_LONG(_29$$28, tmp);
zephir_array_update_zval(&matches, item, &_29$$28, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_INIT_LNVAR(_30$$29);
ZEPHIR_CONCAT_SVS(_30$$29, "{", item, "}");
zephir_concat_self(&route, _30$$29 TSRMLS_CC);
}
continue;
}
}
}
}
}
if (bracketCount == 0) {
if (ch == '(') {
parenthesesCount++;
} else {
if (ch == ')') {
parenthesesCount--;
if (parenthesesCount == 0) {
numberMatches++;
}
}
}
}
if (bracketCount > 0) {
intermediate++;
} else {
zephir_concat_self_char(&route, ch TSRMLS_CC);
}
}
zephir_create_array(return_value, 2, 0 TSRMLS_CC);
zephir_array_fast_append(return_value, route);
zephir_array_fast_append(return_value, matches);
RETURN_MM();
}
/**
* 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, 119);
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, 383, 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, 121);
zephir_check_call_status();
RETURN_MM_MEMBER(this_ptr, "_content");
}
/**
* Stores cached content into the file backend and stops the frontend
*
* @param int|string keyName
* @param string content
* @param int lifetime
* @param boolean stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_Xcache, save) {
zephir_fcall_cache_entry *_1 = NULL;
int 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, *tmp = NULL, *tt1 = NULL, *success = NULL, *isBuffering = NULL, *options = NULL, *keys = NULL, *specialKey = NULL, *_0$$4, *_2$$17;
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_SVV(lastKey, "_PHCX", _0$$4, keyName);
zephir_update_property_this(this_ptr, SL("_lastKey"), lastKey TSRMLS_CC);
}
if (!(zephir_is_true(lastKey))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cache must be started first", "phalcon/cache/backend/xcache.zep", 123);
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_VAR(tmp);
zephir_read_property_this(&tmp, this_ptr, SL("_lastLifetime"), PH_NOISY_CC);
if (!(zephir_is_true(tmp))) {
ZEPHIR_CALL_METHOD(&tt1, frontend, "getlifetime", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(tt1, tmp);
}
} else {
ZEPHIR_CPY_WRT(tt1, lifetime);
}
ZEPHIR_CALL_FUNCTION(&success, "xcache_set", &_1, 88, lastKey, preparedContent, tt1);
zephir_check_call_status();
if (!(zephir_is_true(success))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Failed storing the data in xcache", "phalcon/cache/backend/xcache.zep", 156);
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(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);
}
if (zephir_is_true(success)) {
ZEPHIR_OBS_VAR(options);
zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(specialKey);
_2$$17 = zephir_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY_CC);
if (!(zephir_array_isset_string_fetch(&specialKey, _2$$17, SS("statsKey"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/xcache.zep", 175);
return;
}
if (!ZEPHIR_IS_STRING(specialKey, "")) {
ZEPHIR_CALL_FUNCTION(&keys, "xcache_get", NULL, 87, specialKey);
zephir_check_call_status();
if (Z_TYPE_P(keys) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(keys);
array_init(keys);
}
zephir_array_update_zval(&keys, lastKey, &tt1, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_FUNCTION(NULL, "xcache_set", &_1, 88, specialKey, keys);
zephir_check_call_status();
}
}
RETURN_CCTOR(success);
}
/**
* Dispatches a handle action taking into account the routing parameters
*
* @return object
*/
PHP_METHOD(Phalcon_Dispatcher, dispatch) {
zval *_30$$6 = NULL, *_50$$39 = NULL;
zval *value = NULL, *handler = NULL, *dependencyInjector = NULL, *namespaceName = NULL, *handlerName = NULL, *actionName = NULL, *params = NULL, *eventsManager = NULL, *actionSuffix = NULL, *handlerClass = NULL, *status = NULL, *actionMethod = NULL, *e = NULL, *_0, *_1$$3, *_2$$3, *_3$$4 = NULL, *_4$$4, *_5$$7 = NULL, *_6$$7 = NULL, *_10$$8 = NULL, *_11$$8 = NULL, *_13$$8, *_14$$6 = NULL, *_16$$12 = NULL, *_17$$12 = NULL, *_19$$13, *_22$$16 = NULL, *_23$$16 = NULL, *_25$$17, *_26$$19 = NULL, *_27$$19 = NULL, *_29$$20, *_31$$23 = NULL, *_32$$23 = NULL, *_34$$23, *_35$$22 = NULL, *_36$$22 = NULL, *_38$$26, *_39$$28 = NULL, *_40$$28 = NULL, *_42$$28, *_43$$31 = NULL, *_44$$31, *_45$$36 = NULL, *_46$$36 = NULL, *_48$$36, *_49$$39 = NULL, *_51$$40 = NULL, *_53$$41, *_54$$44 = NULL, *_55$$44 = NULL, *_57$$44, *_59$$47 = NULL, *_60$$47, *_61$$50;
zend_bool hasService = 0, wasFresh;
zephir_fcall_cache_entry *_7 = NULL, *_8 = NULL, *_9 = NULL, *_12 = NULL, *_15 = NULL, *_18 = NULL, *_20 = NULL, *_21 = NULL, *_24 = NULL, *_28 = NULL, *_33 = NULL, *_37 = NULL, *_41 = NULL, *_47 = NULL, *_52 = NULL, *_56 = NULL, *_58 = NULL;
int ZEPHIR_LAST_CALL_STATUS, numberDispatches = 0;
ZEPHIR_MM_GROW();
wasFresh = 0;
_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_INIT_VAR(_1$$3);
ZVAL_STRING(_1$$3, "A dependency injection container is required to access related dispatching services", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_2$$3);
ZVAL_LONG(_2$$3, 0);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_throwdispatchexception", NULL, 0, _1$$3, _2$$3);
zephir_check_temp_parameter(_1$$3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(eventsManager, _0);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_4$$4);
ZVAL_STRING(_4$$4, "dispatch:beforeDispatchLoop", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_3$$4, eventsManager, "fire", NULL, 0, _4$$4, this_ptr);
zephir_check_temp_parameter(_4$$4);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_3$$4)) {
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_VAR(value);
ZVAL_NULL(value);
ZEPHIR_INIT_VAR(handler);
ZVAL_NULL(handler);
numberDispatches = 0;
ZEPHIR_OBS_VAR(actionSuffix);
zephir_read_property_this(&actionSuffix, this_ptr, SL("_actionSuffix"), PH_NOISY_CC);
if (0) {
zephir_update_property_this(this_ptr, SL("_finished"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_finished"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
while (1) {
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (!(!(zephir_is_true(_0)))) {
break;
}
numberDispatches++;
if (numberDispatches == 256) {
ZEPHIR_INIT_NVAR(_5$$7);
ZVAL_STRING(_5$$7, "Dispatcher has detected a cyclic routing causing stability problems", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_6$$7);
ZVAL_LONG(_6$$7, 1);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_throwdispatchexception", &_7, 0, _5$$7, _6$$7);
zephir_check_temp_parameter(_5$$7);
zephir_check_call_status();
break;
}
if (1) {
zephir_update_property_this(this_ptr, SL("_finished"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_finished"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_resolveemptyproperties", &_8, 0);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(namespaceName);
zephir_read_property_this(&namespaceName, this_ptr, SL("_namespaceName"), PH_NOISY_CC);
ZEPHIR_OBS_NVAR(handlerName);
zephir_read_property_this(&handlerName, this_ptr, SL("_handlerName"), PH_NOISY_CC);
ZEPHIR_OBS_NVAR(actionName);
zephir_read_property_this(&actionName, this_ptr, SL("_actionName"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&handlerClass, this_ptr, "gethandlerclass", &_9, 0);
zephir_check_call_status();
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_11$$8);
ZVAL_STRING(_11$$8, "dispatch:beforeDispatch", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_10$$8, eventsManager, "fire", &_12, 0, _11$$8, this_ptr);
zephir_check_temp_parameter(_11$$8);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_10$$8)) {
continue;
}
_13$$8 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_13$$8)) {
continue;
}
}
ZEPHIR_CALL_METHOD(&_14$$6, dependencyInjector, "has", &_15, 0, handlerClass);
zephir_check_call_status();
hasService = zephir_get_boolval(_14$$6);
if (!(hasService)) {
hasService = zephir_class_exists(handlerClass, 1 TSRMLS_CC);
}
if (!(hasService)) {
ZEPHIR_INIT_LNVAR(_16$$12);
ZEPHIR_CONCAT_VS(_16$$12, handlerClass, " handler class cannot be loaded");
ZEPHIR_INIT_NVAR(_17$$12);
ZVAL_LONG(_17$$12, 2);
ZEPHIR_CALL_METHOD(&status, this_ptr, "_throwdispatchexception", &_18, 0, _16$$12, _17$$12);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(status)) {
_19$$13 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_19$$13)) {
continue;
}
}
break;
}
ZEPHIR_CALL_METHOD(&handler, dependencyInjector, "getshared", &_20, 0, handlerClass);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_14$$6, dependencyInjector, "wasfreshinstance", &_21, 0);
zephir_check_call_status();
if (ZEPHIR_IS_TRUE_IDENTICAL(_14$$6)) {
wasFresh = 1;
}
if (Z_TYPE_P(handler) != IS_OBJECT) {
ZEPHIR_INIT_NVAR(_22$$16);
ZVAL_STRING(_22$$16, "Invalid handler returned from the services container", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_23$$16);
ZVAL_LONG(_23$$16, 3);
ZEPHIR_CALL_METHOD(&status, this_ptr, "_throwdispatchexception", &_24, 0, _22$$16, _23$$16);
zephir_check_temp_parameter(_22$$16);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(status)) {
_25$$17 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_25$$17)) {
continue;
}
}
break;
}
zephir_update_property_this(this_ptr, SL("_activeHandler"), handler TSRMLS_CC);
ZEPHIR_OBS_NVAR(params);
zephir_read_property_this(¶ms, this_ptr, SL("_params"), PH_NOISY_CC);
if (Z_TYPE_P(params) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(_26$$19);
ZVAL_STRING(_26$$19, "Action parameters must be an Array", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_27$$19);
ZVAL_LONG(_27$$19, 4);
ZEPHIR_CALL_METHOD(&status, this_ptr, "_throwdispatchexception", &_28, 0, _26$$19, _27$$19);
zephir_check_temp_parameter(_26$$19);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(status)) {
_29$$20 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_29$$20)) {
continue;
}
}
break;
}
ZEPHIR_INIT_NVAR(actionMethod);
ZEPHIR_CONCAT_VV(actionMethod, actionName, actionSuffix);
ZEPHIR_INIT_NVAR(_30$$6);
zephir_create_array(_30$$6, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_30$$6, handler);
zephir_array_fast_append(_30$$6, actionMethod);
if (!(zephir_is_callable(_30$$6 TSRMLS_CC))) {
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_32$$23);
ZVAL_STRING(_32$$23, "dispatch:beforeNotFoundAction", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_31$$23, eventsManager, "fire", &_33, 0, _32$$23, this_ptr);
zephir_check_temp_parameter(_32$$23);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_31$$23)) {
continue;
}
_34$$23 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_34$$23)) {
continue;
}
}
ZEPHIR_INIT_LNVAR(_35$$22);
ZEPHIR_CONCAT_SVSVS(_35$$22, "Action '", actionName, "' was not found on handler '", handlerName, "'");
ZEPHIR_INIT_NVAR(_36$$22);
ZVAL_LONG(_36$$22, 5);
ZEPHIR_CALL_METHOD(&status, this_ptr, "_throwdispatchexception", &_37, 0, _35$$22, _36$$22);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(status)) {
_38$$26 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_38$$26)) {
continue;
}
}
break;
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_40$$28);
ZVAL_STRING(_40$$28, "dispatch:beforeExecuteRoute", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_39$$28, eventsManager, "fire", &_41, 0, _40$$28, this_ptr);
zephir_check_temp_parameter(_40$$28);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_39$$28)) {
continue;
}
_42$$28 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_42$$28)) {
continue;
}
}
if ((zephir_method_exists_ex(handler, SS("beforeexecuteroute") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(&_43$$31, handler, "beforeexecuteroute", NULL, 0, this_ptr);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_43$$31)) {
continue;
}
_44$$31 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_44$$31)) {
continue;
}
}
if (wasFresh == 1) {
if ((zephir_method_exists_ex(handler, SS("initialize") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(NULL, handler, "initialize", NULL, 0);
zephir_check_call_status();
}
if (zephir_is_true(eventsManager)) {
ZEPHIR_INIT_NVAR(_46$$36);
ZVAL_STRING(_46$$36, "dispatch:afterInitialize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_45$$36, eventsManager, "fire", &_47, 0, _46$$36, this_ptr);
zephir_check_temp_parameter(_46$$36);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_45$$36)) {
continue;
}
_48$$36 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_48$$36)) {
continue;
}
}
}
zephir_update_property_this(this_ptr, SL("_lastHandler"), handler TSRMLS_CC);
/* try_start_1: */
ZEPHIR_INIT_NVAR(_49$$39);
ZEPHIR_INIT_NVAR(_50$$39);
zephir_create_array(_50$$39, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_50$$39, handler);
zephir_array_fast_append(_50$$39, actionMethod);
ZEPHIR_CALL_USER_FUNC_ARRAY(_49$$39, _50$$39, params);
zephir_check_call_status_or_jump(try_end_1);
zephir_update_property_this(this_ptr, SL("_returnedValue"), _49$$39 TSRMLS_CC);
try_end_1:
if (EG(exception)) {
ZEPHIR_CPY_WRT(e, EG(exception));
if (zephir_instance_of_ev(e, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) {
zend_clear_exception(TSRMLS_C);
zephir_update_property_this(this_ptr, SL("_lastHandler"), handler TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_51$$40, this_ptr, "_handleexception", &_52, 0, e);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_51$$40)) {
_53$$41 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_53$$41)) {
continue;
}
} else {
zephir_throw_exception_debug(e, "phalcon/dispatcher.zep", 522 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_55$$44);
ZVAL_STRING(_55$$44, "dispatch:afterExecuteRoute", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_54$$44, eventsManager, "fire", &_56, 0, _55$$44, this_ptr, value);
zephir_check_temp_parameter(_55$$44);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_54$$44)) {
continue;
}
_57$$44 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_57$$44)) {
continue;
}
ZEPHIR_INIT_NVAR(_55$$44);
ZVAL_STRING(_55$$44, "dispatch:afterDispatch", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", &_58, 0, _55$$44, this_ptr);
zephir_check_temp_parameter(_55$$44);
zephir_check_call_status();
}
if ((zephir_method_exists_ex(handler, SS("afterexecuteroute") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(&_59$$47, handler, "afterexecuteroute", NULL, 0, this_ptr, value);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_59$$47)) {
continue;
}
_60$$47 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_60$$47)) {
continue;
}
}
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_61$$50);
ZVAL_STRING(_61$$50, "dispatch:afterDispatchLoop", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _61$$50, this_ptr);
zephir_check_temp_parameter(_61$$50);
zephir_check_call_status();
}
RETURN_CCTOR(handler);
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_Alnum, validate) {
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *value = NULL, *message = NULL, *label = NULL, *replacePairs = NULL, *code = NULL, *_0 = NULL, *_1$$3 = NULL, *_6$$3 = NULL, *_7$$3, *_2$$4, *_3$$6, *_4$$7, *_5$$8;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field_param);
if (unlikely(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(field_param) == IS_STRING)) {
zephir_get_strval(field, field_param);
} else {
ZEPHIR_INIT_VAR(field);
ZVAL_EMPTY_STRING(field);
}
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_0, "ctype_alnum", NULL, 467, value);
zephir_check_call_status();
if (!(zephir_is_true(_0))) {
ZEPHIR_INIT_VAR(_1$$3);
ZVAL_STRING(_1$$3, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _1$$3);
zephir_check_temp_parameter(_1$$3);
zephir_check_call_status();
if (Z_TYPE_P(label) == IS_ARRAY) {
zephir_array_fetch(&_2$$4, label, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/alnum.zep", 75 TSRMLS_CC);
ZEPHIR_CPY_WRT(label, _2$$4);
}
if (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_1$$3);
ZVAL_STRING(_1$$3, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _1$$3);
zephir_check_temp_parameter(_1$$3);
zephir_check_call_status();
if (Z_TYPE_P(message) == IS_ARRAY) {
zephir_array_fetch(&_3$$6, message, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/alnum.zep", 83 TSRMLS_CC);
ZEPHIR_CPY_WRT(message, _3$$6);
}
ZEPHIR_INIT_VAR(replacePairs);
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_VAR(_4$$7);
ZVAL_STRING(_4$$7, "Alnum", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _4$$7);
zephir_check_temp_parameter(_4$$7);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_1$$3);
ZVAL_STRING(_1$$3, "code", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&code, this_ptr, "getoption", NULL, 0, _1$$3);
zephir_check_temp_parameter(_1$$3);
zephir_check_call_status();
if (Z_TYPE_P(code) == IS_ARRAY) {
zephir_array_fetch(&_5$$8, code, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/alnum.zep", 93 TSRMLS_CC);
ZEPHIR_CPY_WRT(code, _5$$8);
}
ZEPHIR_INIT_NVAR(_1$$3);
object_init_ex(_1$$3, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_6$$3, "strtr", NULL, 26, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_7$$3);
ZVAL_STRING(_7$$3, "Alnum", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _1$$3, "__construct", NULL, 466, _6$$3, field, _7$$3, code);
zephir_check_temp_parameter(_7$$3);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _1$$3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
PHP_METHOD(Yb_Upload_StorageAbstract, generateUri) {
unsigned char _12, _13, _14, _15;
zephir_fcall_cache_entry *_9 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *source_param = NULL, *prefix_param = NULL, *extension_param = NULL, *_0, *_2 = NULL, *_8 = NULL, *_1$$3, *_3$$4, *_4$$4, _5$$4, *_6$$5;
zval *source = NULL, *prefix = NULL, *extension = NULL, *uri, *uuid = NULL, *_10, *_11 = NULL, *_7$$5, *_16$$6;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 0, &source_param, &prefix_param, &extension_param);
zephir_get_strval(source, source_param);
zephir_get_strval(prefix, prefix_param);
zephir_get_strval(extension, extension_param);
ZEPHIR_INIT_VAR(uri);
ZVAL_STRING(uri, "/", 1);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("uriGenerator"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
_1$$3 = zephir_fetch_nproperty_this(this_ptr, SL("uriGenerator"), PH_NOISY_CC);
ZEPHIR_RETURN_CALL_METHOD(_1$$3, "generateuri", NULL, 0, source, prefix, extension);
zephir_check_call_status();
RETURN_MM();
}
if (zephir_fast_strlen_ev(prefix) > 0) {
ZEPHIR_INIT_VAR(_3$$4);
ZEPHIR_INIT_VAR(_4$$4);
ZEPHIR_SINIT_VAR(_5$$4);
ZVAL_STRING(&_5$$4, "#^(\\w+/)*\\w*$#", 0);
zephir_preg_match(_4$$4, &_5$$4, prefix, _3$$4, 0, 0 , 0 TSRMLS_CC);
if (unlikely(!zephir_is_true(_4$$4))) {
ZEPHIR_INIT_VAR(_6$$5);
object_init_ex(_6$$5, yb_upload_exception_ce);
ZEPHIR_INIT_VAR(_7$$5);
ZEPHIR_CONCAT_SV(_7$$5, "Invalid prefix: ", prefix);
ZEPHIR_CALL_METHOD(NULL, _6$$5, "__construct", NULL, 2, _7$$5);
zephir_check_call_status();
zephir_throw_exception_debug(_6$$5, "yb/upload/storageabstract.zep", 37 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
zephir_concat_self(&uri, prefix TSRMLS_CC);
}
ZEPHIR_INIT_VAR(_10);
ZEPHIR_CONCAT_VV(_10, source, extension);
ZEPHIR_CALL_CE_STATIC(&_8, yb_std_ce, "uuid", &_9, 28, _10);
zephir_check_call_status();
zephir_get_strval(_11, _8);
ZEPHIR_CPY_WRT(uuid, _11);
_12 = ZEPHIR_STRING_OFFSET(uuid, 0);
zephir_concat_self_char(&uri, _12 TSRMLS_CC);
_13 = ZEPHIR_STRING_OFFSET(uuid, 1);
zephir_concat_self_char(&uri, _13 TSRMLS_CC);
zephir_concat_self_str(&uri, "/", sizeof("/")-1 TSRMLS_CC);
_14 = ZEPHIR_STRING_OFFSET(uuid, 2);
zephir_concat_self_char(&uri, _14 TSRMLS_CC);
_15 = ZEPHIR_STRING_OFFSET(uuid, 3);
zephir_concat_self_char(&uri, _15 TSRMLS_CC);
zephir_concat_self_str(&uri, "/", sizeof("/")-1 TSRMLS_CC);
zephir_concat_self(&uri, uuid TSRMLS_CC);
if (!(!extension) && Z_STRLEN_P(extension)) {
ZEPHIR_INIT_VAR(_16$$6);
ZEPHIR_CONCAT_SV(_16$$6, ".", extension);
zephir_concat_self(&uri, _16$$6 TSRMLS_CC);
}
RETURN_CTOR(uri);
}
/**
* 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();
}
PHP_METHOD(Test_RegexDNA, process) {
HashTable *_5;
HashPosition _4;
int ZEPHIR_LAST_CALL_STATUS;
zephir_nts_static zephir_fcall_cache_entry *_3 = NULL, *_8 = NULL;
zval *path, *variants, *vIUB, *vIUBnew, *stuffToRemove, *contents = NULL, *initialLength, *regex = NULL, *codeLength, *discard = NULL, *_0 = NULL, *_1, *_2 = NULL, **_6, *_7 = NULL, *_9 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &path);
ZEPHIR_INIT_VAR(discard);
ZVAL_NULL(discard);
ZEPHIR_INIT_VAR(variants);
array_init_size(variants, 13);
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "agggtaaa|tttaccct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "[cgt]gggtaaa|tttaccc[acg]", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "a[act]ggtaaa|tttacc[agt]t", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "ag[act]gtaaa|tttac[agt]ct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "agg[act]taaa|ttta[agt]cct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "aggg[acg]aaa|ttt[cgt]ccct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "agggt[cgt]aa|tt[acg]accct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "agggta[cgt]a|t[acg]taccct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "agggtaa[cgt]|[acg]ttaccct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_VAR(vIUB);
array_init(vIUB);
ZEPHIR_INIT_VAR(vIUBnew);
array_init(vIUBnew);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "/B/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE, "test/regexdna.zep", 30);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "(c|g|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE, "test/regexdna.zep", 30);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "/D/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE, "test/regexdna.zep", 31);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "(a|g|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE, "test/regexdna.zep", 31);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "/H/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE, "test/regexdna.zep", 32);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "(a|c|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE, "test/regexdna.zep", 32);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "/K/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE, "test/regexdna.zep", 33);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "(g|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE, "test/regexdna.zep", 33);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "/M/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE, "test/regexdna.zep", 34);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "(a|c)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE, "test/regexdna.zep", 34);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "/N/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE, "test/regexdna.zep", 35);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "(a|c|g|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE, "test/regexdna.zep", 35);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "/R/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE, "test/regexdna.zep", 36);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "(a|g)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE, "test/regexdna.zep", 36);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "/S/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE, "test/regexdna.zep", 37);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "(c|g)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE, "test/regexdna.zep", 37);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "/V/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE, "test/regexdna.zep", 38);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "(a|c|g)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE, "test/regexdna.zep", 38);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "/W/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE, "test/regexdna.zep", 39);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "(a|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE, "test/regexdna.zep", 39);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "/Y/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE, "test/regexdna.zep", 40);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "(c|t)", 1);
zephir_array_append(&vIUBnew, _0, PH_SEPARATE, "test/regexdna.zep", 40);
ZEPHIR_INIT_VAR(stuffToRemove);
ZVAL_STRING(stuffToRemove, "^>.*$|\n", 1);
ZEPHIR_INIT_NVAR(discard);
ZVAL_NULL(discard);
ZEPHIR_INIT_VAR(contents);
zephir_file_get_contents(contents, path TSRMLS_CC);
ZEPHIR_INIT_VAR(initialLength);
ZVAL_LONG(initialLength, zephir_fast_strlen_ev(contents));
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SVS(_1, "/", stuffToRemove, "/mS");
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_FUNCTION(&_2, "preg_replace", &_3, _1, _0, contents);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
ZEPHIR_CPY_WRT(contents, _2);
ZEPHIR_INIT_VAR(codeLength);
ZVAL_LONG(codeLength, zephir_fast_strlen_ev(contents));
zephir_is_iterable(variants, &_5, &_4, 0, 0, "test/regexdna.zep", 59);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HVALUE(regex, _6);
zend_print_zval(regex, 0);
php_printf("%s", " ");
ZEPHIR_INIT_LNVAR(_7);
ZEPHIR_CONCAT_SVS(_7, "/", regex, "/iS");
Z_SET_ISREF_P(discard);
ZEPHIR_CALL_FUNCTION(&_2, "preg_match_all", &_8, _7, contents, discard);
Z_UNSET_ISREF_P(discard);
zephir_check_call_status();
zend_print_zval(_2, 0);
php_printf("%c", '\n');
}
ZEPHIR_CALL_FUNCTION(&_9, "preg_replace", &_3, vIUB, vIUBnew, contents);
zephir_check_call_status();
ZEPHIR_CPY_WRT(contents, _9);
php_printf("%c", '\n');
zend_print_zval(initialLength, 0);
php_printf("%c", '\n');
zend_print_zval(codeLength, 0);
php_printf("%c", '\n');
php_printf("%d", zephir_fast_strlen_ev(contents));
php_printf("%c", '\n');
ZEPHIR_MM_RESTORE();
}