/** * Bind models into params in proper handler */ PHP_METHOD(Phalcon_Mvc_Model_Binder, bindToHandler) { zend_class_entry *_6$$5; HashTable *_4$$4; HashPosition _3$$4; zend_bool _1; int ZEPHIR_LAST_CALL_STATUS; zval *cacheKey = NULL; zval *params = NULL; zval *handler, *params_param = NULL, *cacheKey_param = NULL, *methodName = NULL, *paramKey = NULL, *className = NULL, *boundModel = NULL, *paramsCache = NULL, *paramValue = NULL, *_0, *_2$$3, **_5$$4; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 3, 1, &handler, ¶ms_param, &cacheKey_param, &methodName); zephir_get_arrval(params, params_param); zephir_get_strval(cacheKey, cacheKey_param); if (!methodName) { methodName = ZEPHIR_GLOBAL(global_null); } ZEPHIR_INIT_VAR(_0); array_init(_0); zephir_update_property_this(this_ptr, SL("originalValues"), _0 TSRMLS_CC); _1 = zephir_instance_of_ev(handler, zend_ce_closure TSRMLS_CC); if (!(_1)) { _1 = Z_TYPE_P(methodName) != IS_NULL; } if (_1) { ZEPHIR_INIT_VAR(_2$$3); array_init(_2$$3); zephir_update_property_this(this_ptr, SL("boundModels"), _2$$3 TSRMLS_CC); ZEPHIR_CALL_METHOD(¶msCache, this_ptr, "getparamsfromcache", NULL, 0, cacheKey); zephir_check_call_status(); if (Z_TYPE_P(paramsCache) == IS_ARRAY) { zephir_is_iterable(paramsCache, &_4$$4, &_3$$4, 0, 0, "phalcon/mvc/model/binder.zep", 102); for ( ; zend_hash_get_current_data_ex(_4$$4, (void**) &_5$$4, &_3$$4) == SUCCESS ; zend_hash_move_forward_ex(_4$$4, &_3$$4) ) { ZEPHIR_GET_HMKEY(paramKey, _4$$4, _3$$4); ZEPHIR_GET_HVALUE(className, _5$$4); ZEPHIR_OBS_NVAR(paramValue); zephir_array_fetch(¶mValue, params, paramKey, PH_NOISY, "phalcon/mvc/model/binder.zep", 95 TSRMLS_CC); _6$$5 = zephir_fetch_class(className TSRMLS_CC); ZEPHIR_CALL_CE_STATIC(&boundModel, _6$$5, "findfirst", NULL, 0, paramValue); zephir_check_call_status(); zephir_update_property_array(this_ptr, SL("originalValues"), paramKey, paramValue TSRMLS_CC); zephir_array_update_zval(¶ms, paramKey, &boundModel, PH_COPY | PH_SEPARATE); zephir_update_property_array(this_ptr, SL("boundModels"), paramKey, boundModel TSRMLS_CC); } RETURN_CTOR(params); } ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getparamsfromreflection", NULL, 0, handler, params, cacheKey, methodName); zephir_check_call_status(); RETURN_MM(); } ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "You must specify methodName for handler or pass Closure as handler", "phalcon/mvc/model/binder.zep", 107); return; }
/** * Executes validator */ PHP_METHOD(Phalcon_Mvc_Model_Validator_Inclusionin, validate) { zval *_7; zephir_nts_static zephir_fcall_cache_entry *_6 = NULL, *_9 = NULL; zend_bool _3; int ZEPHIR_LAST_CALL_STATUS; zval *record, *field = NULL, *domain = NULL, *value = NULL, *message = NULL, *strict = NULL, *_0 = NULL, *_1 = NULL, *_2 = NULL, *_4 = NULL, *_5 = NULL, *_8 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &record); ZEPHIR_INIT_VAR(_0); ZVAL_STRING(_0, "field", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&field, this_ptr, "getoption", NULL, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); if (Z_TYPE_P(field) != IS_STRING) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Field name must be a string", "phalcon/mvc/model/validator/inclusionin.zep", 63); return; } ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "domain", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "issetoption", NULL, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(_1)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "The option 'domain' is required for this validator", "phalcon/mvc/model/validator/inclusionin.zep", 70); return; } ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "domain", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&domain, this_ptr, "getoption", NULL, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); if (Z_TYPE_P(domain) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Option 'domain' must be an array", "phalcon/mvc/model/validator/inclusionin.zep", 75); return; } ZEPHIR_CALL_METHOD(&value, record, "readattribute", NULL, field); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "allowEmpty", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_2, this_ptr, "issetoption", NULL, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); _3 = zephir_is_true(_2); if (_3) { _3 = ZEPHIR_IS_EMPTY(value); } if (_3) { RETURN_MM_BOOL(1); } ZEPHIR_INIT_VAR(strict); ZVAL_BOOL(strict, 0); ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "strict", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_4, this_ptr, "issetoption", NULL, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); if (zephir_is_true(_4)) { if (Z_TYPE_P(strict) != IS_BOOL) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Option 'strict' must be a boolean", "phalcon/mvc/model/validator/inclusionin.zep", 87); return; } ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "strict", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&strict, this_ptr, "getoption", NULL, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); } ZEPHIR_CALL_FUNCTION(&_5, "in_array", &_6, value, domain, strict); zephir_check_call_status(); if (!(zephir_is_true(_5))) { ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "message", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); if (ZEPHIR_IS_EMPTY(message)) { ZEPHIR_INIT_NVAR(message); ZVAL_STRING(message, "Value of field ':field' must be part of list: :domain", 1); } ZEPHIR_INIT_VAR(_7); zephir_create_array(_7, 2, 0 TSRMLS_CC); zephir_array_update_string(&_7, SL(":field"), &field, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_0); zephir_fast_join_str(_0, SL(", "), domain TSRMLS_CC); zephir_array_update_string(&_7, SL(":domain"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_FUNCTION(&_8, "strtr", &_9, message, _7); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "Inclusion", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, this_ptr, "appendmessage", NULL, _8, field, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); RETURN_MM_BOOL(0); } RETURN_MM_BOOL(1); }
/** * Create internal connection to redis */ PHP_METHOD(Phalcon_Cache_Backend_Redis, _connect) { zend_bool _0, _1, _2, _5, _7; zval *options = NULL, *redis = NULL, *persistent = NULL, *success = NULL, *host = NULL, *port = NULL, *auth = NULL, *index = NULL, *timeout = NULL, *_6, *_3$$6, *_4$$6; zend_long ZEPHIR_LAST_CALL_STATUS; ZEPHIR_MM_GROW(); ZEPHIR_OBS_VAR(options); zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC); ZEPHIR_INIT_VAR(redis); object_init_ex(redis, zephir_get_internal_ce(SS("redis") TSRMLS_CC)); if (zephir_has_constructor(redis TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, redis, "__construct", NULL, 0); zephir_check_call_status(); } ZEPHIR_OBS_VAR(host); _0 = !(zephir_array_isset_string_fetch(&host, options, SS("host"), 0 TSRMLS_CC)); if (!(_0)) { ZEPHIR_OBS_VAR(port); _0 = !(zephir_array_isset_string_fetch(&port, options, SS("port"), 0 TSRMLS_CC)); } _1 = _0; if (!(_1)) { ZEPHIR_OBS_VAR(persistent); _1 = !(zephir_array_isset_string_fetch(&persistent, options, SS("persistent"), 0 TSRMLS_CC)); } _2 = _1; if (!(_2)) { ZEPHIR_OBS_VAR(timeout); _2 = !(zephir_array_isset_string_fetch(&timeout, options, SS("timeout"), 0 TSRMLS_CC)); } if (_2) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/redis.zep", 120); return; } if (zephir_is_true(persistent)) { ZEPHIR_CALL_METHOD(&success, redis, "pconnect", NULL, 0, host, port, timeout); zephir_check_call_status(); } else { ZEPHIR_CALL_METHOD(&success, redis, "connect", NULL, 0, host, port, timeout); zephir_check_call_status(); } if (!(zephir_is_true(success))) { ZEPHIR_INIT_VAR(_3$$6); object_init_ex(_3$$6, phalcon_cache_exception_ce); ZEPHIR_INIT_VAR(_4$$6); ZEPHIR_CONCAT_SVSV(_4$$6, "Could not connect to the Redisd server ", host, ":", port); ZEPHIR_CALL_METHOD(NULL, _3$$6, "__construct", NULL, 9, _4$$6); zephir_check_call_status(); zephir_throw_exception_debug(_3$$6, "phalcon/cache/backend/redis.zep", 130 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } ZEPHIR_OBS_VAR(auth); _5 = zephir_array_isset_string_fetch(&auth, options, SS("auth"), 0 TSRMLS_CC); if (_5) { zephir_array_fetch_string(&_6, options, SL("auth"), PH_NOISY | PH_READONLY, "phalcon/cache/backend/redis.zep", 133 TSRMLS_CC); _5 = !(ZEPHIR_IS_EMPTY(_6)); } if (_5) { ZEPHIR_CALL_METHOD(&success, redis, "auth", NULL, 0, auth); zephir_check_call_status(); if (!(zephir_is_true(success))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Failed to authenticate with the Redisd server", "phalcon/cache/backend/redis.zep", 137); return; } } ZEPHIR_OBS_VAR(index); _7 = zephir_array_isset_string_fetch(&index, options, SS("index"), 0 TSRMLS_CC); if (_7) { _7 = ZEPHIR_GT_LONG(index, 0); } if (_7) { ZEPHIR_CALL_METHOD(&success, redis, "select", NULL, 0, index); zephir_check_call_status(); if (!(zephir_is_true(success))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Redis server selected database failed", "phalcon/cache/backend/redis.zep", 145); return; } } zephir_update_property_this(getThis(), SL("_redis"), redis TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * Listens for notifications from the models manager */ PHP_METHOD(Phalcon_Mvc_Collection_Behavior_SoftDelete, notify) { HashTable *_5$$7; HashPosition _4$$7; zephir_fcall_cache_entry *_7 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *type_param = NULL, *model, *options = NULL, *value = NULL, *field = NULL, *updateModel = NULL, *message = NULL, *_0$$3, *_1$$3 = NULL, *_2$$6 = NULL, *_3$$7 = NULL, **_6$$7; zval *type = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &type_param, &model); if (unlikely(Z_TYPE_P(type_param) != IS_STRING && Z_TYPE_P(type_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'type' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(type_param) == IS_STRING)) { zephir_get_strval(type, type_param); } else { ZEPHIR_INIT_VAR(type); ZVAL_EMPTY_STRING(type); } if (ZEPHIR_IS_STRING(type, "beforeDelete")) { ZEPHIR_CALL_METHOD(&options, this_ptr, "getoptions", NULL, 0); zephir_check_call_status(); ZEPHIR_OBS_VAR(value); if (!(zephir_array_isset_string_fetch(&value, options, SS("value"), 0 TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_collection_exception_ce, "The option 'value' is required", "phalcon/mvc/collection/behavior/softdelete.zep", 51); return; } ZEPHIR_OBS_VAR(field); if (!(zephir_array_isset_string_fetch(&field, options, SS("field"), 0 TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_collection_exception_ce, "The option 'field' is required", "phalcon/mvc/collection/behavior/softdelete.zep", 58); return; } ZEPHIR_INIT_VAR(_0$$3); ZVAL_BOOL(_0$$3, 1); ZEPHIR_CALL_METHOD(NULL, model, "skipoperation", NULL, 0, _0$$3); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_1$$3, model, "readattribute", NULL, 0, field); zephir_check_call_status(); if (!ZEPHIR_IS_EQUAL(_1$$3, value)) { ZEPHIR_INIT_VAR(updateModel); if (zephir_clone(updateModel, model TSRMLS_CC) == FAILURE) { RETURN_MM(); } ZEPHIR_CALL_METHOD(NULL, updateModel, "writeattribute", NULL, 0, field, value); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_2$$6, updateModel, "save", NULL, 0); zephir_check_call_status(); if (!(zephir_is_true(_2$$6))) { ZEPHIR_CALL_METHOD(&_3$$7, updateModel, "getmessages", NULL, 0); zephir_check_call_status(); zephir_is_iterable(_3$$7, &_5$$7, &_4$$7, 0, 0, "phalcon/mvc/collection/behavior/softdelete.zep", 90); for ( ; zephir_hash_get_current_data_ex(_5$$7, (void**) &_6$$7, &_4$$7) == SUCCESS ; zephir_hash_move_forward_ex(_5$$7, &_4$$7) ) { ZEPHIR_GET_HVALUE(message, _6$$7); ZEPHIR_CALL_METHOD(NULL, model, "appendmessage", &_7, 0, message); zephir_check_call_status(); } RETURN_MM_BOOL(0); } ZEPHIR_CALL_METHOD(NULL, model, "writeattribute", NULL, 0, field, value); zephir_check_call_status(); } } ZEPHIR_MM_RESTORE(); }
/** * Validate a set of data according to a set of rules * * @param array|object data * @param object entity * @return \Phalcon\Validation\Message\Group */ PHP_METHOD(Phalcon_Validation, validate) { zend_bool _0$$7; HashTable *_2, *_10$$16; HashPosition _1, _9$$16; zephir_fcall_cache_entry *_5 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *data = NULL, *entity = NULL, *validators = NULL, *messages = NULL, *scope = NULL, *field = NULL, *validator = NULL, *status = NULL, *combinedFieldsValidators = NULL, **_3, *_4$$10 = NULL, *_6$$10 = NULL, *_7$$14 = NULL, *_8$$14 = NULL, **_11$$16, *_12$$17 = NULL, *_13$$17 = NULL, *_14$$21 = NULL, *_15$$21 = NULL, *_16$$23; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 2, &data, &entity); if (!data) { data = ZEPHIR_GLOBAL(global_null); } if (!entity) { entity = ZEPHIR_GLOBAL(global_null); } ZEPHIR_OBS_VAR(validators); zephir_read_property_this(&validators, this_ptr, SL("_validators"), PH_NOISY_CC); ZEPHIR_OBS_VAR(combinedFieldsValidators); zephir_read_property_this(&combinedFieldsValidators, this_ptr, SL("_combinedFieldsValidators"), PH_NOISY_CC); if (Z_TYPE_P(validators) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "There are no validators to validate", "phalcon/validation.zep", 94); return; } zephir_update_property_this(this_ptr, SL("_values"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC); ZEPHIR_INIT_VAR(messages); object_init_ex(messages, phalcon_validation_message_group_ce); ZEPHIR_CALL_METHOD(NULL, messages, "__construct", NULL, 3); zephir_check_call_status(); if (Z_TYPE_P(entity) != IS_NULL) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "setentity", NULL, 0, entity); zephir_check_call_status(); } if ((zephir_method_exists_ex(this_ptr, SS("beforevalidation") TSRMLS_CC) == SUCCESS)) { ZEPHIR_CALL_METHOD(&status, this_ptr, "beforevalidation", NULL, 0, data, entity, messages); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(status)) { RETURN_CCTOR(status); } } zephir_update_property_this(this_ptr, SL("_messages"), messages TSRMLS_CC); if (Z_TYPE_P(data) != IS_NULL) { _0$$7 = Z_TYPE_P(data) == IS_ARRAY; if (!(_0$$7)) { _0$$7 = Z_TYPE_P(data) == IS_OBJECT; } if (_0$$7) { zephir_update_property_this(this_ptr, SL("_data"), data TSRMLS_CC); } else { zephir_var_dump(&data TSRMLS_CC); ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Invalid data to validate", "phalcon/validation.zep", 128); return; } } zephir_is_iterable(validators, &_2, &_1, 0, 0, "phalcon/validation.zep", 162); for ( ; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS ; zephir_hash_move_forward_ex(_2, &_1) ) { ZEPHIR_GET_HVALUE(scope, _3); if (Z_TYPE_P(scope) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "The validator scope is not valid", "phalcon/validation.zep", 135); return; } ZEPHIR_OBS_NVAR(field); zephir_array_fetch_long(&field, scope, 0, PH_NOISY, "phalcon/validation.zep", 138 TSRMLS_CC); ZEPHIR_OBS_NVAR(validator); zephir_array_fetch_long(&validator, scope, 1, PH_NOISY, "phalcon/validation.zep", 139 TSRMLS_CC); if (Z_TYPE_P(validator) != IS_OBJECT) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "One of the validators is not valid", "phalcon/validation.zep", 142); return; } ZEPHIR_CALL_METHOD(&_4$$10, this_ptr, "prechecking", &_5, 0, field, validator); zephir_check_call_status(); if (zephir_is_true(_4$$10)) { continue; } ZEPHIR_CALL_METHOD(&_6$$10, validator, "validate", NULL, 0, this_ptr, field); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(_6$$10)) { ZEPHIR_INIT_NVAR(_8$$14); ZVAL_STRING(_8$$14, "cancelOnFail", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_7$$14, validator, "getoption", NULL, 0, _8$$14); zephir_check_temp_parameter(_8$$14); zephir_check_call_status(); if (zephir_is_true(_7$$14)) { break; } } } if (!(ZEPHIR_IS_EMPTY(combinedFieldsValidators))) { zephir_is_iterable(combinedFieldsValidators, &_10$$16, &_9$$16, 0, 0, "phalcon/validation.zep", 191); for ( ; zephir_hash_get_current_data_ex(_10$$16, (void**) &_11$$16, &_9$$16) == SUCCESS ; zephir_hash_move_forward_ex(_10$$16, &_9$$16) ) { ZEPHIR_GET_HVALUE(scope, _11$$16); if (Z_TYPE_P(scope) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "The validator scope is not valid", "phalcon/validation.zep", 165); return; } ZEPHIR_OBS_NVAR(field); zephir_array_fetch_long(&field, scope, 0, PH_NOISY, "phalcon/validation.zep", 168 TSRMLS_CC); ZEPHIR_OBS_NVAR(validator); zephir_array_fetch_long(&validator, scope, 1, PH_NOISY, "phalcon/validation.zep", 169 TSRMLS_CC); if (Z_TYPE_P(validator) != IS_OBJECT) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "One of the validators is not valid", "phalcon/validation.zep", 172); return; } ZEPHIR_CALL_METHOD(&_12$$17, this_ptr, "prechecking", &_5, 0, field, validator); zephir_check_call_status(); if (zephir_is_true(_12$$17)) { continue; } ZEPHIR_CALL_METHOD(&_13$$17, validator, "validate", NULL, 0, this_ptr, field); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(_13$$17)) { ZEPHIR_INIT_NVAR(_15$$21); ZVAL_STRING(_15$$21, "cancelOnFail", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_14$$21, validator, "getoption", NULL, 0, _15$$21); zephir_check_temp_parameter(_15$$21); zephir_check_call_status(); if (zephir_is_true(_14$$21)) { break; } } } } if ((zephir_method_exists_ex(this_ptr, SS("aftervalidation") TSRMLS_CC) == SUCCESS)) { _16$$23 = zephir_fetch_nproperty_this(this_ptr, SL("_messages"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(NULL, this_ptr, "aftervalidation", NULL, 0, data, entity, _16$$23); zephir_check_call_status(); } RETURN_MM_MEMBER(this_ptr, "_messages"); }
/** * Creates a password hash using bcrypt with a pseudo random salt */ PHP_METHOD(Phalcon_Security, hash) { zephir_nts_static zephir_fcall_cache_entry *_6 = NULL, *_8 = NULL; zephir_fcall_cache_entry *_2 = NULL; int workFactor, hash, ZEPHIR_LAST_CALL_STATUS; zval *password_param = NULL, *workFactor_param = NULL, *saltBytes = NULL, *_0 = NULL, *_1 = NULL, _3, _4, *_5 = NULL, *_7; zval *password = NULL, *variant = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &password_param, &workFactor_param); zephir_get_strval(password, password_param); if (!workFactor_param) { workFactor = 0; } else { workFactor = zephir_get_intval(workFactor_param); } if (!(workFactor)) { ZEPHIR_OBS_VAR(_0); zephir_read_property_this(&_0, this_ptr, SL("_workFactor"), PH_NOISY_CC); workFactor = zephir_get_intval(_0); } ZEPHIR_OBS_NVAR(_0); zephir_read_property_this(&_0, this_ptr, SL("_defaultHash"), PH_NOISY_CC); hash = zephir_get_intval(_0); do { if (hash == 5) { ZEPHIR_INIT_VAR(variant); ZVAL_STRING(variant, "x", 1); break; } if (hash == 6) { ZEPHIR_INIT_NVAR(variant); ZVAL_STRING(variant, "y", 1); break; } if (hash == 7) { ZEPHIR_INIT_NVAR(variant); ZVAL_STRING(variant, "5", 1); break; } if (hash == 8) { ZEPHIR_INIT_NVAR(variant); ZVAL_STRING(variant, "6", 1); break; } ZEPHIR_INIT_NVAR(variant); ZVAL_STRING(variant, "a", 1); break; } while(0); do { if (hash == 1) { ZEPHIR_INIT_VAR(_1); ZVAL_LONG(_1, 2); ZEPHIR_CALL_METHOD(&saltBytes, this_ptr, "getsaltbytes", &_2, _1); zephir_check_call_status(); if (Z_TYPE_P(saltBytes) != IS_STRING) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_security_exception_ce, "Unable to get random bytes for the salt", "phalcon/security.zep", 195); return; } break; } ZEPHIR_INIT_NVAR(_1); ZVAL_LONG(_1, 22); ZEPHIR_CALL_METHOD(&saltBytes, this_ptr, "getsaltbytes", &_2, _1); zephir_check_call_status(); if (Z_TYPE_P(saltBytes) != IS_STRING) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_security_exception_ce, "Unable to get random bytes for the salt", "phalcon/security.zep", 218); return; } if (workFactor < 4) { workFactor = 4; } else { if (workFactor > 31) { workFactor = 31; } } ZEPHIR_SINIT_VAR(_3); ZVAL_STRING(&_3, "%02s", 0); ZEPHIR_SINIT_VAR(_4); ZVAL_LONG(&_4, workFactor); ZEPHIR_CALL_FUNCTION(&_5, "sprintf", &_6, &_3, &_4); zephir_check_call_status(); ZEPHIR_INIT_VAR(_7); ZEPHIR_CONCAT_SVSVSV(_7, "$2", variant, "$", _5, "$", saltBytes); ZEPHIR_RETURN_CALL_FUNCTION("crypt", &_8, password, _7); zephir_check_call_status(); RETURN_MM(); } while(0); RETURN_MM_STRING("", 1); }
/** * Executes the validation * * @param Phalcon\Validation validation * @param string field * @return boolean */ PHP_METHOD(Phalcon_Validation_Validator_StringLength, validate) { zephir_nts_static zephir_fcall_cache_entry *_5 = NULL, *_7 = NULL; zend_bool _1, _3; int ZEPHIR_LAST_CALL_STATUS; zval *field = NULL; zval *validation, *field_param = NULL, *isSetMin = NULL, *isSetMax = NULL, *value = NULL, *length = NULL, *message = NULL, *minimum = NULL, *maximum = NULL, *label = NULL, *replacePairs = NULL, *_0 = NULL, *_2 = NULL, *_4 = NULL, *_6 = NULL, *_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_INIT_VAR(_0); ZVAL_STRING(_0, "min", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&isSetMin, this_ptr, "issetoption", NULL, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "max", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&isSetMax, this_ptr, "issetoption", NULL, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); _1 = !zephir_is_true(isSetMin); if (_1) { _1 = !zephir_is_true(isSetMax); } if (_1) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "A minimum or maximum must be set", "phalcon/validation/validator/stringlength.zep", 62); return; } ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, field); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "allowEmpty", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_2, this_ptr, "issetoption", NULL, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); _3 = zephir_is_true(_2); if (_3) { _3 = ZEPHIR_IS_EMPTY(value); } if (_3) { RETURN_MM_BOOL(1); } ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "label", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); if (ZEPHIR_IS_EMPTY(label)) { ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, field); zephir_check_call_status(); } if ((zephir_function_exists_ex(SS("mb_strlen") TSRMLS_CC) == SUCCESS)) { ZEPHIR_CALL_FUNCTION(&length, "mb_strlen", NULL, value); zephir_check_call_status(); } else { ZEPHIR_INIT_NVAR(length); ZVAL_LONG(length, zephir_fast_strlen_ev(value)); } if (zephir_is_true(isSetMax)) { ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "max", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&maximum, this_ptr, "getoption", NULL, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); if (ZEPHIR_GT(length, maximum)) { ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "messageMaximum", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); ZEPHIR_INIT_VAR(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"), &maximum, PH_COPY | PH_SEPARATE); if (ZEPHIR_IS_EMPTY(message)) { ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "TooLong", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); } ZEPHIR_INIT_NVAR(_0); object_init_ex(_0, phalcon_validation_message_ce); ZEPHIR_CALL_FUNCTION(&_4, "strtr", &_5, message, replacePairs); zephir_check_call_status(); ZEPHIR_INIT_VAR(_6); ZVAL_STRING(_6, "TooLong", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _0, "__construct", &_7, _4, field, _6); zephir_check_temp_parameter(_6); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, _0); zephir_check_call_status(); RETURN_MM_BOOL(0); } } if (zephir_is_true(isSetMin)) { ZEPHIR_INIT_NVAR(_6); ZVAL_STRING(_6, "min", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&minimum, this_ptr, "getoption", NULL, _6); zephir_check_temp_parameter(_6); zephir_check_call_status(); if (ZEPHIR_LT(length, minimum)) { ZEPHIR_INIT_NVAR(_6); ZVAL_STRING(_6, "messageMinimum", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, _6); zephir_check_temp_parameter(_6); 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"), &minimum, PH_COPY | PH_SEPARATE); if (ZEPHIR_IS_EMPTY(message)) { ZEPHIR_INIT_NVAR(_6); ZVAL_STRING(_6, "TooShort", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, _6); zephir_check_temp_parameter(_6); zephir_check_call_status(); } ZEPHIR_INIT_NVAR(_6); object_init_ex(_6, phalcon_validation_message_ce); ZEPHIR_CALL_FUNCTION(&_4, "strtr", &_5, message, replacePairs); zephir_check_call_status(); ZEPHIR_INIT_VAR(_8); ZVAL_STRING(_8, "TooShort", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _6, "__construct", &_7, _4, field, _8); zephir_check_temp_parameter(_8); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, _6); zephir_check_call_status(); RETURN_MM_BOOL(0); } } RETURN_MM_BOOL(1); }
PHP_METHOD(Phalcon_Validation_Validator_Uniqueness, isUniqueness) { zval *_24$$17 = NULL, *_33$$20 = NULL; zend_bool _11$$7, _18$$12, _19$$12; zend_class_entry *_53; HashTable *_2, *_8, *_21$$16, *_30$$19, *_43$$22; HashPosition _1, _7, _20$$16, _29$$19, _42$$22; zephir_fcall_cache_entry *_5 = NULL, *_12 = NULL, *_14 = NULL; int ZEPHIR_LAST_CALL_STATUS, index = 0; zval *validation, *field = NULL, *value = NULL, *values = NULL, *convert = NULL, *record = NULL, *attribute = NULL, *except = NULL, *params = NULL, *metaData = NULL, *primaryField = NULL, *className = NULL, *singleField = NULL, *fieldExcept = NULL, *singleExcept = NULL, *notInValues = NULL, *exceptConditions = NULL, *_0 = NULL, **_3, **_9, *_38 = NULL, *_51, *_52 = NULL, *_4$$4 = NULL, *_6$$5 = NULL, *_10$$7 = NULL, *_13$$7 = NULL, _15$$10 = zval_used_for_init, *_16$$10 = NULL, *_17$$11 = NULL, **_22$$16, *_25$$16 = NULL, *_26$$16 = NULL, _23$$17 = zval_used_for_init, _27$$18 = zval_used_for_init, *_28$$18 = NULL, **_31$$19, *_34$$19 = NULL, *_35$$19 = NULL, _32$$20 = zval_used_for_init, _36$$21 = zval_used_for_init, *_37$$21 = NULL, *_39$$22 = NULL, *_40$$22, *_41$$22 = NULL, **_44$$22, *_45$$23 = NULL, _46$$23 = zval_used_for_init, *_47$$23 = NULL, *_48$$23 = NULL, *_49$$24, *_50$$24; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &validation, &field); ZEPHIR_SEPARATE_PARAM(field); ZEPHIR_INIT_VAR(exceptConditions); array_init(exceptConditions); index = 0; ZEPHIR_INIT_VAR(params); zephir_create_array(params, 2, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(_0); array_init(_0); zephir_array_update_string(¶ms, SL("conditions"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_0); array_init(_0); zephir_array_update_string(¶ms, SL("bind"), &_0, PH_COPY | PH_SEPARATE); if (Z_TYPE_P(field) != IS_ARRAY) { ZEPHIR_CPY_WRT(singleField, field); ZEPHIR_INIT_NVAR(field); array_init(field); zephir_array_append(&field, singleField, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 156); } ZEPHIR_INIT_VAR(values); array_init(values); ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "convert", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&convert, this_ptr, "getoption", NULL, 0, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); zephir_is_iterable(field, &_2, &_1, 0, 0, "phalcon/validation/validator/uniqueness.zep", 166); for ( ; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS ; zephir_hash_move_forward_ex(_2, &_1) ) { ZEPHIR_GET_HVALUE(singleField, _3); ZEPHIR_CALL_METHOD(&_4$$4, validation, "getvalue", &_5, 0, singleField); zephir_check_call_status(); zephir_array_update_zval(&values, singleField, &_4$$4, PH_COPY | PH_SEPARATE); } if (Z_TYPE_P(convert) != IS_NULL) { ZEPHIR_CALL_ZVAL_FUNCTION(&_6$$5, convert, NULL, 0, values); zephir_check_call_status(); ZEPHIR_CPY_WRT(values, _6$$5); if (!(Z_TYPE_P(values) == IS_ARRAY)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Value conversion must return an array", "phalcon/validation/validator/uniqueness.zep", 170); return; } } zephir_is_iterable(field, &_8, &_7, 0, 0, "phalcon/validation/validator/uniqueness.zep", 241); for ( ; zephir_hash_get_current_data_ex(_8, (void**) &_9, &_7) == SUCCESS ; zephir_hash_move_forward_ex(_8, &_7) ) { ZEPHIR_GET_HVALUE(singleField, _9); ZEPHIR_INIT_NVAR(fieldExcept); ZVAL_NULL(fieldExcept); ZEPHIR_INIT_NVAR(notInValues); array_init(notInValues); ZEPHIR_INIT_NVAR(_10$$7); ZVAL_STRING(_10$$7, "model", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&record, this_ptr, "getoption", NULL, 0, _10$$7); zephir_check_temp_parameter(_10$$7); zephir_check_call_status(); ZEPHIR_OBS_NVAR(value); zephir_array_fetch(&value, values, singleField, PH_NOISY, "phalcon/validation/validator/uniqueness.zep", 178 TSRMLS_CC); _11$$7 = ZEPHIR_IS_EMPTY(record); if (!(_11$$7)) { _11$$7 = Z_TYPE_P(record) != IS_OBJECT; } if (_11$$7) { ZEPHIR_CALL_METHOD(&record, validation, "getentity", &_12, 0); zephir_check_call_status(); if (ZEPHIR_IS_EMPTY(record)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Model of record must be set to property \"model\"", "phalcon/validation/validator/uniqueness.zep", 184); return; } } ZEPHIR_INIT_NVAR(_10$$7); ZVAL_STRING(_10$$7, "attribute", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_13$$7, this_ptr, "getoption", NULL, 0, _10$$7, singleField); zephir_check_temp_parameter(_10$$7); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&attribute, this_ptr, "getcolumnnamereal", &_14, 0, record, _13$$7); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_10$$7); ZVAL_STRING(_10$$7, "except", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&except, this_ptr, "getoption", NULL, 0, _10$$7); zephir_check_temp_parameter(_10$$7); zephir_check_call_status(); if (Z_TYPE_P(value) != IS_NULL) { ZEPHIR_SINIT_NVAR(_15$$10); ZVAL_LONG(&_15$$10, index); ZEPHIR_INIT_LNVAR(_16$$10); ZEPHIR_CONCAT_VSV(_16$$10, attribute, " = ?", &_15$$10); zephir_array_update_multi(¶ms, &_16$$10 TSRMLS_CC, SL("sa"), 3, SL("conditions")); zephir_array_update_multi(¶ms, &value TSRMLS_CC, SL("sa"), 3, SL("bind")); index++; } else { ZEPHIR_INIT_LNVAR(_17$$11); ZEPHIR_CONCAT_VS(_17$$11, attribute, " IS NULL"); zephir_array_update_multi(¶ms, &_17$$11 TSRMLS_CC, SL("sa"), 3, SL("conditions")); } if (zephir_is_true(except)) { _18$$12 = Z_TYPE_P(except) == IS_ARRAY; if (_18$$12) { _18$$12 = zephir_fast_count_int(field TSRMLS_CC) > 1; } if (_18$$12) { if (zephir_array_isset(except, singleField)) { ZEPHIR_OBS_NVAR(fieldExcept); zephir_array_fetch(&fieldExcept, except, singleField, PH_NOISY, "phalcon/validation/validator/uniqueness.zep", 203 TSRMLS_CC); } } _19$$12 = Z_TYPE_P(except) == IS_ARRAY; if (_19$$12) { _19$$12 = zephir_fast_count_int(field TSRMLS_CC) == 1; } if (Z_TYPE_P(fieldExcept) != IS_NULL) { if (Z_TYPE_P(fieldExcept) == IS_ARRAY) { zephir_is_iterable(fieldExcept, &_21$$16, &_20$$16, 0, 0, "phalcon/validation/validator/uniqueness.zep", 214); for ( ; zephir_hash_get_current_data_ex(_21$$16, (void**) &_22$$16, &_20$$16) == SUCCESS ; zephir_hash_move_forward_ex(_21$$16, &_20$$16) ) { ZEPHIR_GET_HVALUE(singleExcept, _22$$16); ZEPHIR_SINIT_NVAR(_23$$17); ZVAL_LONG(&_23$$17, index); ZEPHIR_INIT_LNVAR(_24$$17); ZEPHIR_CONCAT_SV(_24$$17, "?", &_23$$17); zephir_array_append(¬InValues, _24$$17, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 210); zephir_array_update_multi(¶ms, &singleExcept TSRMLS_CC, SL("sa"), 3, SL("bind")); index++; } ZEPHIR_INIT_NVAR(_25$$16); zephir_fast_join_str(_25$$16, SL(","), notInValues TSRMLS_CC); ZEPHIR_INIT_LNVAR(_26$$16); ZEPHIR_CONCAT_VSVS(_26$$16, attribute, " NOT IN (", _25$$16, ")"); zephir_array_append(&exceptConditions, _26$$16, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 214); } else { ZEPHIR_SINIT_NVAR(_27$$18); ZVAL_LONG(&_27$$18, index); ZEPHIR_INIT_LNVAR(_28$$18); ZEPHIR_CONCAT_VSV(_28$$18, attribute, " <> ?", &_27$$18); zephir_array_append(&exceptConditions, _28$$18, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 217); zephir_array_update_multi(¶ms, &fieldExcept TSRMLS_CC, SL("sa"), 3, SL("bind")); index++; } } else if (_19$$12) { zephir_is_iterable(except, &_30$$19, &_29$$19, 0, 0, "phalcon/validation/validator/uniqueness.zep", 228); for ( ; zephir_hash_get_current_data_ex(_30$$19, (void**) &_31$$19, &_29$$19) == SUCCESS ; zephir_hash_move_forward_ex(_30$$19, &_29$$19) ) { ZEPHIR_GET_HVALUE(singleExcept, _31$$19); ZEPHIR_SINIT_NVAR(_32$$20); ZVAL_LONG(&_32$$20, index); ZEPHIR_INIT_LNVAR(_33$$20); ZEPHIR_CONCAT_SV(_33$$20, "?", &_32$$20); zephir_array_append(¬InValues, _33$$20, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 224); zephir_array_update_multi(¶ms, &singleExcept TSRMLS_CC, SL("sa"), 3, SL("bind")); index++; } ZEPHIR_INIT_NVAR(_34$$19); zephir_fast_join_str(_34$$19, SL(","), notInValues TSRMLS_CC); ZEPHIR_INIT_LNVAR(_35$$19); ZEPHIR_CONCAT_VSVS(_35$$19, attribute, " NOT IN (", _34$$19, ")"); zephir_array_update_multi(¶ms, &_35$$19 TSRMLS_CC, SL("sa"), 3, SL("conditions")); } else if (zephir_fast_count_int(field TSRMLS_CC) == 1) { ZEPHIR_SINIT_NVAR(_36$$21); ZVAL_LONG(&_36$$21, index); ZEPHIR_INIT_LNVAR(_37$$21); ZEPHIR_CONCAT_VSV(_37$$21, attribute, " <> ?", &_36$$21); zephir_array_update_multi(¶ms, &_37$$21 TSRMLS_CC, SL("sa"), 3, SL("conditions")); zephir_array_update_multi(¶ms, &except TSRMLS_CC, SL("sa"), 3, SL("bind")); index++; } } } ZEPHIR_CALL_METHOD(&_38, record, "getdirtystate", NULL, 0); zephir_check_call_status(); if (ZEPHIR_IS_LONG(_38, 0)) { ZEPHIR_CALL_METHOD(&_39$$22, record, "getdi", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(_40$$22); ZVAL_STRING(_40$$22, "modelsMetadata", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&metaData, _39$$22, "getshared", NULL, 0, _40$$22); zephir_check_temp_parameter(_40$$22); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_41$$22, metaData, "getprimarykeyattributes", NULL, 0, record); zephir_check_call_status(); zephir_is_iterable(_41$$22, &_43$$22, &_42$$22, 0, 0, "phalcon/validation/validator/uniqueness.zep", 249); for ( ; zephir_hash_get_current_data_ex(_43$$22, (void**) &_44$$22, &_42$$22) == SUCCESS ; zephir_hash_move_forward_ex(_43$$22, &_42$$22) ) { ZEPHIR_GET_HVALUE(primaryField, _44$$22); ZEPHIR_CALL_METHOD(&_45$$23, this_ptr, "getcolumnnamereal", &_14, 0, record, primaryField); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_46$$23); ZVAL_LONG(&_46$$23, index); ZEPHIR_INIT_LNVAR(_47$$23); ZEPHIR_CONCAT_VSV(_47$$23, _45$$23, " <> ?", &_46$$23); zephir_array_update_multi(¶ms, &_47$$23 TSRMLS_CC, SL("sa"), 3, SL("conditions")); ZEPHIR_CALL_METHOD(&_48$$23, record, "readattribute", NULL, 0, primaryField); zephir_check_call_status(); zephir_array_update_multi(¶ms, &_48$$23 TSRMLS_CC, SL("sa"), 3, SL("bind")); index++; } } ZEPHIR_INIT_VAR(className); zephir_get_class(className, record, 0 TSRMLS_CC); if (!(ZEPHIR_IS_EMPTY(exceptConditions))) { ZEPHIR_INIT_VAR(_49$$24); zephir_fast_join_str(_49$$24, SL(" OR "), exceptConditions TSRMLS_CC); ZEPHIR_INIT_VAR(_50$$24); ZEPHIR_CONCAT_SVS(_50$$24, "(", _49$$24, ")"); zephir_array_update_multi(¶ms, &_50$$24 TSRMLS_CC, SL("sa"), 3, SL("conditions")); } ZEPHIR_INIT_NVAR(_0); zephir_array_fetch_string(&_51, params, SL("conditions"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/uniqueness.zep", 255 TSRMLS_CC); zephir_fast_join_str(_0, SL(" AND "), _51 TSRMLS_CC); zephir_array_update_string(¶ms, SL("conditions"), &_0, PH_COPY | PH_SEPARATE); _53 = zephir_fetch_class(className TSRMLS_CC); ZEPHIR_CALL_CE_STATIC(&_52, _53, "count", NULL, 0, params); zephir_check_call_status(); RETURN_MM_BOOL(ZEPHIR_IS_LONG(_52, 0)); }
/** * Phalcon\Session\Adapter\Libmemcached constructor * * @throws \Phalcon\Session\Exception */ PHP_METHOD(Phalcon_Session_Adapter_Libmemcached, __construct) { zephir_fcall_cache_entry *_13 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *options_param = NULL, *servers = NULL, *client = NULL, *lifetime = NULL, *prefix = NULL, *statsKey = NULL, *_0 = NULL, *_1 = NULL, *_2, *_4, *_7 = NULL; zval *options = NULL, *_3, *_5, *_6, *_8, *_9, *_10, *_11, *_12; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &options_param); zephir_get_arrval(options, options_param); ZEPHIR_OBS_VAR(servers); if (!(zephir_array_isset_string_fetch(&servers, options, SS("servers"), 0 TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_session_exception_ce, "No servers given in options", "phalcon/session/adapter/libmemcached.zep", 71); return; } ZEPHIR_OBS_VAR(client); if (!(zephir_array_isset_string_fetch(&client, options, SS("client"), 0 TSRMLS_CC))) { ZEPHIR_INIT_NVAR(client); ZVAL_NULL(client); } ZEPHIR_OBS_VAR(lifetime); if (!(zephir_array_isset_string_fetch(&lifetime, options, SS("lifetime"), 0 TSRMLS_CC))) { ZEPHIR_INIT_NVAR(lifetime); ZVAL_LONG(lifetime, 8600); } ZEPHIR_INIT_VAR(_0); ZVAL_LONG(_0, 2592000); ZEPHIR_CALL_FUNCTION(&_1, "min", NULL, 405, lifetime, _0); zephir_check_call_status(); zephir_update_property_this(this_ptr, SL("_lifetime"), _1 TSRMLS_CC); ZEPHIR_OBS_VAR(prefix); if (!(zephir_array_isset_string_fetch(&prefix, options, SS("prefix"), 0 TSRMLS_CC))) { ZEPHIR_INIT_NVAR(prefix); ZVAL_NULL(prefix); } ZEPHIR_OBS_VAR(statsKey); if (!(zephir_array_isset_string_fetch(&statsKey, options, SS("statsKey"), 0 TSRMLS_CC))) { ZEPHIR_INIT_NVAR(statsKey); ZVAL_NULL(statsKey); } ZEPHIR_INIT_NVAR(_0); object_init_ex(_0, phalcon_cache_backend_libmemcached_ce); ZEPHIR_INIT_VAR(_2); object_init_ex(_2, phalcon_cache_frontend_data_ce); ZEPHIR_INIT_VAR(_3); zephir_create_array(_3, 1, 0 TSRMLS_CC); ZEPHIR_OBS_VAR(_4); zephir_read_property_this(&_4, this_ptr, SL("_lifetime"), PH_NOISY_CC); zephir_array_update_string(&_3, SL("lifetime"), &_4, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", NULL, 309, _3); zephir_check_call_status(); ZEPHIR_INIT_VAR(_5); zephir_create_array(_5, 4, 0 TSRMLS_CC); zephir_array_update_string(&_5, SL("servers"), &servers, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_5, SL("client"), &client, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_5, SL("prefix"), &prefix, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_5, SL("statsKey"), &statsKey, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 310, _2, _5); zephir_check_call_status(); zephir_update_property_this(this_ptr, SL("_libmemcached"), _0 TSRMLS_CC); ZEPHIR_INIT_VAR(_6); zephir_create_array(_6, 2, 0 TSRMLS_CC); zephir_array_fast_append(_6, this_ptr); ZEPHIR_INIT_VAR(_7); ZVAL_STRING(_7, "open", 1); zephir_array_fast_append(_6, _7); ZEPHIR_INIT_VAR(_8); zephir_create_array(_8, 2, 0 TSRMLS_CC); zephir_array_fast_append(_8, this_ptr); ZEPHIR_INIT_NVAR(_7); ZVAL_STRING(_7, "close", 1); zephir_array_fast_append(_8, _7); ZEPHIR_INIT_VAR(_9); zephir_create_array(_9, 2, 0 TSRMLS_CC); zephir_array_fast_append(_9, this_ptr); ZEPHIR_INIT_NVAR(_7); ZVAL_STRING(_7, "read", 1); zephir_array_fast_append(_9, _7); ZEPHIR_INIT_VAR(_10); zephir_create_array(_10, 2, 0 TSRMLS_CC); zephir_array_fast_append(_10, this_ptr); ZEPHIR_INIT_NVAR(_7); ZVAL_STRING(_7, "write", 1); zephir_array_fast_append(_10, _7); ZEPHIR_INIT_VAR(_11); zephir_create_array(_11, 2, 0 TSRMLS_CC); zephir_array_fast_append(_11, this_ptr); ZEPHIR_INIT_NVAR(_7); ZVAL_STRING(_7, "destroy", 1); zephir_array_fast_append(_11, _7); ZEPHIR_INIT_VAR(_12); zephir_create_array(_12, 2, 0 TSRMLS_CC); zephir_array_fast_append(_12, this_ptr); ZEPHIR_INIT_NVAR(_7); ZVAL_STRING(_7, "gc", 1); zephir_array_fast_append(_12, _7); ZEPHIR_CALL_FUNCTION(NULL, "session_set_save_handler", NULL, 406, _6, _8, _9, _10, _11, _12); zephir_check_call_status(); ZEPHIR_CALL_PARENT(NULL, phalcon_session_adapter_libmemcached_ce, this_ptr, "__construct", &_13, 407, options); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); }
/** * Listens for notifications from the models manager */ PHP_METHOD(Phalcon_Mvc_Model_Behavior_SoftDelete, notify) { HashTable *_5$$7; HashPosition _4$$7; zend_bool _9$$6; zephir_fcall_cache_entry *_7 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; zval *type_param = NULL, *model, *options = NULL, *value = NULL, *field = NULL, *updateModel = NULL, *message = NULL, *modelsManager = NULL, *metaData = NULL, *columnMap = NULL, *_0$$3, *_1$$3 = NULL, *_2$$6 = NULL, *_8$$6 = NULL, *_3$$7 = NULL, **_6$$7, *_10$$9 = NULL, *_11$$9 = NULL; zval *type = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &type_param, &model); if (UNEXPECTED(Z_TYPE_P(type_param) != IS_STRING && Z_TYPE_P(type_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'type' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (EXPECTED(Z_TYPE_P(type_param) == IS_STRING)) { zephir_get_strval(type, type_param); } else { ZEPHIR_INIT_VAR(type); ZVAL_EMPTY_STRING(type); } if (ZEPHIR_IS_STRING(type, "beforeDelete")) { ZEPHIR_CALL_METHOD(&options, this_ptr, "getoptions", NULL, 0); zephir_check_call_status(); ZEPHIR_OBS_VAR(value); if (!(zephir_array_isset_string_fetch(&value, options, SS("value"), 0 TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "The option 'value' is required", "phalcon/mvc/model/behavior/softdelete.zep", 50); return; } ZEPHIR_OBS_VAR(field); if (!(zephir_array_isset_string_fetch(&field, options, SS("field"), 0 TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "The option 'field' is required", "phalcon/mvc/model/behavior/softdelete.zep", 57); return; } ZEPHIR_INIT_VAR(_0$$3); ZVAL_BOOL(_0$$3, 1); ZEPHIR_CALL_METHOD(NULL, model, "skipoperation", NULL, 0, _0$$3); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_1$$3, model, "readattribute", NULL, 0, field); zephir_check_call_status(); if (!ZEPHIR_IS_EQUAL(_1$$3, value)) { ZEPHIR_CALL_METHOD(&modelsManager, model, "getmodelsmanager", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(updateModel); if (zephir_clone(updateModel, model TSRMLS_CC) == FAILURE) { RETURN_MM(); } ZEPHIR_CALL_METHOD(NULL, updateModel, "writeattribute", NULL, 0, field, value); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_2$$6, updateModel, "save", NULL, 0); zephir_check_call_status(); if (!(zephir_is_true(_2$$6))) { ZEPHIR_CALL_METHOD(&_3$$7, updateModel, "getmessages", NULL, 0); zephir_check_call_status(); zephir_is_iterable(_3$$7, &_5$$7, &_4$$7, 0, 0, "phalcon/mvc/model/behavior/softdelete.zep", 91); for ( ; zend_hash_get_current_data_ex(_5$$7, (void**) &_6$$7, &_4$$7) == SUCCESS ; zend_hash_move_forward_ex(_5$$7, &_4$$7) ) { ZEPHIR_GET_HVALUE(message, _6$$7); ZEPHIR_CALL_METHOD(NULL, model, "appendmessage", &_7, 0, message); zephir_check_call_status(); } RETURN_MM_BOOL(0); } ZEPHIR_CALL_METHOD(NULL, model, "writeattribute", NULL, 0, field, value); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_8$$6, modelsManager, "iskeepingsnapshots", NULL, 0, model); zephir_check_call_status(); _9$$6 = zephir_is_true(_8$$6); if (_9$$6) { _9$$6 = ZEPHIR_GLOBAL(orm).update_snapshot_on_save; } if (_9$$6) { ZEPHIR_CALL_METHOD(&metaData, model, "getmodelsmetadata", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&columnMap, metaData, "getcolumnmap", NULL, 0, model); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_10$$9, updateModel, "getsnapshotdata", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, model, "setsnapshotdata", NULL, 0, _10$$9, columnMap); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_11$$9, updateModel, "getoldsnapshotdata", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, model, "setoldsnapshotdata", NULL, 0, _11$$9, columnMap); zephir_check_call_status(); } } } ZEPHIR_MM_RESTORE(); }
/** * Stores cached content into the APCu backend and stops the frontend * * @param string|int keyName * @param string content * @param int lifetime * @param boolean stopBuffer */ PHP_METHOD(Phalcon_Cache_Backend_Apcu, save) { zend_long ZEPHIR_LAST_CALL_STATUS; zend_bool stopBuffer; zval *keyName = NULL, *content = NULL, *lifetime = NULL, *stopBuffer_param = NULL, *lastKey = NULL, *frontend = NULL, *cachedContent = NULL, *preparedContent = NULL, *ttl = NULL, *isBuffering = NULL, *success = NULL, *_0$$4; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 4, &keyName, &content, &lifetime, &stopBuffer_param); if (!keyName) { keyName = ZEPHIR_GLOBAL(global_null); } if (!content) { content = ZEPHIR_GLOBAL(global_null); } if (!lifetime) { ZEPHIR_CPY_WRT(lifetime, ZEPHIR_GLOBAL(global_null)); } else { ZEPHIR_SEPARATE_PARAM(lifetime); } if (!stopBuffer_param) { stopBuffer = 1; } else { stopBuffer = zephir_get_boolval(stopBuffer_param); } if (Z_TYPE_P(keyName) == IS_NULL) { ZEPHIR_OBS_VAR(lastKey); zephir_read_property_this(&lastKey, this_ptr, SL("_lastKey"), PH_NOISY_CC); } else { _0$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC); ZEPHIR_INIT_NVAR(lastKey); ZEPHIR_CONCAT_SVV(lastKey, "_PHCA", _0$$4, keyName); } if (!(zephir_is_true(lastKey))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cache must be started first", "phalcon/cache/backend/apcu.zep", 95); return; } ZEPHIR_OBS_VAR(frontend); zephir_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); if (Z_TYPE_P(content) == IS_NULL) { ZEPHIR_CALL_METHOD(&cachedContent, frontend, "getcontent", NULL, 0); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(cachedContent, content); } if (!(zephir_is_numeric(cachedContent))) { ZEPHIR_CALL_METHOD(&preparedContent, frontend, "beforestore", NULL, 0, cachedContent); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(preparedContent, cachedContent); } if (Z_TYPE_P(lifetime) == IS_NULL) { ZEPHIR_OBS_NVAR(lifetime); zephir_read_property_this(&lifetime, this_ptr, SL("_lastLifetime"), PH_NOISY_CC); if (Z_TYPE_P(lifetime) == IS_NULL) { ZEPHIR_CALL_METHOD(&ttl, frontend, "getlifetime", NULL, 0); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(ttl, lifetime); zephir_update_property_this(getThis(), SL("_lastKey"), lastKey TSRMLS_CC); } } else { ZEPHIR_CPY_WRT(ttl, lifetime); } ZEPHIR_CALL_FUNCTION(&success, "apcu_store", NULL, 93, lastKey, preparedContent, ttl); zephir_check_call_status(); if (!(zephir_is_true(success))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Failed storing data in APCu", "phalcon/cache/backend/apcu.zep", 132); return; } ZEPHIR_CALL_METHOD(&isBuffering, frontend, "isbuffering", NULL, 0); zephir_check_call_status(); if (stopBuffer == 1) { ZEPHIR_CALL_METHOD(NULL, frontend, "stop", NULL, 0); zephir_check_call_status(); } if (ZEPHIR_IS_TRUE_IDENTICAL(isBuffering)) { zend_print_zval(cachedContent, 0); } if (0) { zephir_update_property_this(getThis(), SL("_started"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC); } else { zephir_update_property_this(getThis(), SL("_started"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC); } RETURN_CCTOR(success); }
/** * Updates every record in the resultset * * @param array data * @param \Closure conditionCallback * @return boolean */ PHP_METHOD(Phalcon_Mvc_Model_Resultset, update) { zval *_2$$6 = NULL; zend_object_iterator *_0; zend_bool transaction = 0; int ZEPHIR_LAST_CALL_STATUS; zval *data, *conditionCallback = NULL, *record = NULL, *connection = NULL, *_1$$6 = NULL, *_3$$3 = NULL, *_4$$8 = 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", 414); return; } ZEPHIR_CALL_METHOD(&connection, record, "getwriteconnection", NULL, 0); zephir_check_call_status(); transaction = 1; ZEPHIR_CALL_METHOD(NULL, connection, "begin", NULL, 0); zephir_check_call_status(); } if (Z_TYPE_P(conditionCallback) == IS_OBJECT) { ZEPHIR_INIT_NVAR(_1$$6); ZEPHIR_INIT_NVAR(_2$$6); zephir_create_array(_2$$6, 1, 0 TSRMLS_CC); zephir_array_fast_append(_2$$6, record); ZEPHIR_CALL_USER_FUNC_ARRAY(_1$$6, conditionCallback, _2$$6); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(_1$$6)) { continue; } } ZEPHIR_CALL_METHOD(&_3$$3, record, "save", NULL, 0, data); zephir_check_call_status(); if (!(zephir_is_true(_3$$3))) { ZEPHIR_CALL_METHOD(&_4$$8, record, "getmessages", NULL, 0); zephir_check_call_status(); zephir_update_property_this(this_ptr, SL("_errorMessages"), _4$$8 TSRMLS_CC); ZEPHIR_CALL_METHOD(NULL, connection, "rollback", NULL, 0); zephir_check_call_status(); transaction = 0; break; } } _0->funcs->dtor(_0 TSRMLS_CC); if (transaction == 1) { ZEPHIR_CALL_METHOD(NULL, connection, "commit", NULL, 0); zephir_check_call_status(); } RETURN_MM_BOOL(1); }
/** * Create/Returns a new transaction or an existing one */ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, getOrCreateTransaction) { HashTable *_2$$5; HashPosition _1$$5; int ZEPHIR_LAST_CALL_STATUS; zval *autoBegin_param = NULL, *dependencyInjector = NULL, *transaction = NULL, *transactions = NULL, *_0, *_5, *_6, **_3$$5, *_4$$7 = NULL; zend_bool autoBegin; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &autoBegin_param); if (!autoBegin_param) { autoBegin = 1; } else { autoBegin = zephir_get_boolval(autoBegin_param); } _0 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); ZEPHIR_CPY_WRT(dependencyInjector, _0); if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_transaction_exception_ce, "A dependency injector container is required to obtain the services related to the ORM", "phalcon/mvc/model/transaction/manager.zep", 188); return; } _0 = zephir_fetch_nproperty_this(this_ptr, SL("_number"), PH_NOISY_CC); if (zephir_is_true(_0)) { ZEPHIR_OBS_VAR(transactions); zephir_read_property_this(&transactions, this_ptr, SL("_transactions"), PH_NOISY_CC); if (Z_TYPE_P(transactions) == IS_ARRAY) { zephir_is_iterable(transactions, &_2$$5, &_1$$5, 0, 1, "phalcon/mvc/model/transaction/manager.zep", 200); for ( ; zephir_hash_get_current_data_ex(_2$$5, (void**) &_3$$5, &_1$$5) == SUCCESS ; zephir_hash_move_backwards_ex(_2$$5, &_1$$5) ) { ZEPHIR_GET_HVALUE(transaction, _3$$5); if (Z_TYPE_P(transaction) == IS_OBJECT) { ZEPHIR_INIT_NVAR(_4$$7); ZVAL_BOOL(_4$$7, 0); ZEPHIR_CALL_METHOD(NULL, transaction, "setisnewtransaction", NULL, 0, _4$$7); zephir_check_call_status(); RETURN_CCTOR(transaction); } } } } ZEPHIR_INIT_NVAR(transaction); object_init_ex(transaction, phalcon_mvc_model_transaction_ce); _5 = zephir_fetch_nproperty_this(this_ptr, SL("_service"), PH_NOISY_CC); ZEPHIR_INIT_VAR(_6); if (autoBegin) { ZVAL_BOOL(_6, 1); } else { ZVAL_BOOL(_6, 0); } ZEPHIR_CALL_METHOD(NULL, transaction, "__construct", NULL, 352, dependencyInjector, _6, _5); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, transaction, "settransactionmanager", NULL, 353, this_ptr); zephir_check_call_status(); zephir_update_property_array_append(this_ptr, SL("_transactions"), transaction TSRMLS_CC); RETURN_ON_FAILURE(zephir_property_incr(this_ptr, SL("_number") TSRMLS_CC)); RETURN_CCTOR(transaction); }
/** * Get modified params for handler using reflection */ PHP_METHOD(Phalcon_Mvc_Model_Binder, getParamsFromReflection) { zend_class_entry *_8$$10, *_9$$14, *_13$$16, *_14$$18; HashTable *_2; HashPosition _1; zephir_fcall_cache_entry *_7 = NULL, *_12 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *cacheKey = NULL; zval *params = NULL; zval *handler, *params_param = NULL, *cacheKey_param = NULL, *methodName, *methodParams = NULL, *reflection = NULL, *paramKey = NULL, *methodParam = NULL, *paramsCache = NULL, *className = NULL, *realClasses = NULL, *boundModel = NULL, *cache = NULL, *handlerClass = NULL, *reflectionClass = NULL, *paramsKeys = NULL, *paramValue = NULL, *_0, **_3, *_4$$7, _5$$5 = zval_used_for_init, *_6$$5 = NULL, *_10$$15 = NULL, *_11$$15 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 4, 0, &handler, ¶ms_param, &cacheKey_param, &methodName); zephir_get_arrval(params, params_param); zephir_get_strval(cacheKey, cacheKey_param); ZEPHIR_INIT_VAR(realClasses); ZVAL_NULL(realClasses); ZEPHIR_INIT_VAR(paramsCache); array_init(paramsCache); ZEPHIR_INIT_VAR(reflection); if (Z_TYPE_P(methodName) != IS_NULL) { object_init_ex(reflection, zephir_get_internal_ce(SS("reflectionmethod") TSRMLS_CC)); ZEPHIR_CALL_METHOD(NULL, reflection, "__construct", NULL, 324, handler, methodName); zephir_check_call_status(); } else { object_init_ex(reflection, zephir_get_internal_ce(SS("reflectionfunction") TSRMLS_CC)); ZEPHIR_CALL_METHOD(NULL, reflection, "__construct", NULL, 82, handler); zephir_check_call_status(); } _0 = zephir_fetch_nproperty_this(this_ptr, SL("cache"), PH_NOISY_CC); ZEPHIR_CPY_WRT(cache, _0); ZEPHIR_CALL_METHOD(&methodParams, reflection, "getparameters", NULL, 83); zephir_check_call_status(); ZEPHIR_INIT_VAR(paramsKeys); zephir_array_keys(paramsKeys, params TSRMLS_CC); zephir_is_iterable(methodParams, &_2, &_1, 0, 0, "phalcon/mvc/model/binder.zep", 197); for ( ; zend_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS ; zend_hash_move_forward_ex(_2, &_1) ) { ZEPHIR_GET_HMKEY(paramKey, _2, _1); ZEPHIR_GET_HVALUE(methodParam, _3); ZEPHIR_CALL_METHOD(&reflectionClass, methodParam, "getclass", NULL, 0); zephir_check_call_status(); if (!(zephir_is_true(reflectionClass))) { continue; } ZEPHIR_CALL_METHOD(&className, reflectionClass, "getname", NULL, 0); zephir_check_call_status(); if (!(zephir_array_isset(params, paramKey))) { zephir_array_fetch(&_4$$7, paramsKeys, paramKey, PH_NOISY | PH_READONLY, "phalcon/mvc/model/binder.zep", 157 TSRMLS_CC); ZEPHIR_CPY_WRT(paramKey, _4$$7); } ZEPHIR_INIT_NVAR(boundModel); ZVAL_NULL(boundModel); ZEPHIR_OBS_NVAR(paramValue); zephir_array_fetch(¶mValue, params, paramKey, PH_NOISY, "phalcon/mvc/model/binder.zep", 160 TSRMLS_CC); ZEPHIR_SINIT_NVAR(_5$$5); ZVAL_STRING(&_5$$5, "Phalcon\\Mvc\\Model", 0); ZEPHIR_CALL_FUNCTION(&_6$$5, "is_subclass_of", &_7, 325, className, &_5$$5); zephir_check_call_status(); if (ZEPHIR_IS_STRING(className, "Phalcon\\Mvc\\Model")) { if (Z_TYPE_P(realClasses) == IS_NULL) { if (zephir_instance_of_ev(handler, phalcon_mvc_controller_bindmodelinterface_ce TSRMLS_CC)) { ZEPHIR_INIT_NVAR(handlerClass); zephir_get_class(handlerClass, handler, 0 TSRMLS_CC); _8$$10 = zephir_fetch_class(handlerClass TSRMLS_CC); ZEPHIR_CALL_CE_STATIC(&realClasses, _8$$10, "getmodelname", NULL, 0); zephir_check_call_status(); } else if (zephir_instance_of_ev(handler, phalcon_mvc_model_binder_bindableinterface_ce TSRMLS_CC)) { ZEPHIR_CALL_METHOD(&realClasses, handler, "getmodelname", NULL, 0); zephir_check_call_status(); } else { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Handler must implement Phalcon\\Mvc\\Model\\Binder\\BindableInterface in order to use Phalcon\\Mvc\\Model as parameter", "phalcon/mvc/model/binder.zep", 170); return; } } if (Z_TYPE_P(realClasses) == IS_ARRAY) { ZEPHIR_OBS_NVAR(className); if (zephir_array_isset_fetch(&className, realClasses, paramKey, 0 TSRMLS_CC)) { _9$$14 = zephir_fetch_class(className TSRMLS_CC); ZEPHIR_CALL_CE_STATIC(&boundModel, _9$$14, "findfirst", NULL, 0, paramValue); zephir_check_call_status(); } else { ZEPHIR_INIT_NVAR(_10$$15); object_init_ex(_10$$15, phalcon_mvc_model_exception_ce); ZEPHIR_INIT_LNVAR(_11$$15); ZEPHIR_CONCAT_SVS(_11$$15, "You should provide model class name for ", paramKey, " parameter"); ZEPHIR_CALL_METHOD(NULL, _10$$15, "__construct", &_12, 9, _11$$15); zephir_check_call_status(); zephir_throw_exception_debug(_10$$15, "phalcon/mvc/model/binder.zep", 177 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } } else if (Z_TYPE_P(realClasses) == IS_STRING) { _13$$16 = zephir_fetch_class(realClasses TSRMLS_CC); ZEPHIR_CALL_CE_STATIC(&boundModel, _13$$16, "findfirst", NULL, 0, paramValue); zephir_check_call_status(); ZEPHIR_CPY_WRT(className, realClasses); } else { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "getModelName should return array or string", "phalcon/mvc/model/binder.zep", 183); return; } } else if (zephir_is_true(_6$$5)) { _14$$18 = zephir_fetch_class(className TSRMLS_CC); ZEPHIR_CALL_CE_STATIC(&boundModel, _14$$18, "findfirst", NULL, 0, paramValue); zephir_check_call_status(); } if (Z_TYPE_P(boundModel) != IS_NULL) { zephir_update_property_array(this_ptr, SL("originalValues"), paramKey, paramValue TSRMLS_CC); zephir_array_update_zval(¶ms, paramKey, &boundModel, PH_COPY | PH_SEPARATE); zephir_update_property_array(this_ptr, SL("boundModels"), paramKey, boundModel TSRMLS_CC); zephir_array_update_zval(¶msCache, paramKey, &className, PH_COPY | PH_SEPARATE); } } if (Z_TYPE_P(cache) != IS_NULL) { ZEPHIR_CALL_METHOD(NULL, cache, "save", NULL, 0, cacheKey, paramsCache); zephir_check_call_status(); } zephir_update_property_array(this_ptr, SL("internalCache"), cacheKey, paramsCache TSRMLS_CC); RETURN_CTOR(params); }
/** * Executes the validation */ PHP_METHOD(Phalcon_Validation_Validator_InclusionIn, validate) { int ZEPHIR_LAST_CALL_STATUS; zval *field = NULL; zval *validation, *field_param = NULL, *value = NULL, *domain = NULL, *message = NULL, *label = NULL, *replacePairs = NULL, *strict = NULL, *fieldDomain = NULL, *code = NULL, *_0 = NULL, *_1 = NULL, *_4 = NULL, *_2$$6, *_3$$7, *_5$$9 = NULL, *_10$$9 = NULL, *_11$$9, *_6$$10, *_7$$12, *_8$$13, *_9$$14; 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_INIT_VAR(_0); ZVAL_STRING(_0, "domain", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&domain, this_ptr, "getoption", NULL, 0, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); ZEPHIR_OBS_VAR(fieldDomain); if (zephir_array_isset_fetch(&fieldDomain, domain, field, 0 TSRMLS_CC)) { if (Z_TYPE_P(fieldDomain) == IS_ARRAY) { ZEPHIR_CPY_WRT(domain, fieldDomain); } } if (Z_TYPE_P(domain) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Option 'domain' must be an array", "phalcon/validation/validator/inclusionin.zep", 87); return; } ZEPHIR_INIT_VAR(strict); ZVAL_BOOL(strict, 0); ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "strict", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "hasoption", NULL, 0, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); if (zephir_is_true(_1)) { ZEPHIR_INIT_VAR(_2$$6); ZVAL_STRING(_2$$6, "strict", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&strict, this_ptr, "getoption", NULL, 0, _2$$6); zephir_check_temp_parameter(_2$$6); zephir_check_call_status(); if (Z_TYPE_P(strict) == IS_ARRAY) { zephir_array_fetch(&_3$$7, strict, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/inclusionin.zep", 95 TSRMLS_CC); ZEPHIR_CPY_WRT(strict, _3$$7); } if (Z_TYPE_P(strict) != IS_BOOL) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Option 'strict' must be a boolean", "phalcon/validation/validator/inclusionin.zep", 99); return; } } ZEPHIR_CALL_FUNCTION(&_4, "in_array", NULL, 381, value, domain, strict); zephir_check_call_status(); if (!(zephir_is_true(_4))) { ZEPHIR_INIT_VAR(_5$$9); ZVAL_STRING(_5$$9, "label", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _5$$9); zephir_check_temp_parameter(_5$$9); zephir_check_call_status(); if (Z_TYPE_P(label) == IS_ARRAY) { zephir_array_fetch(&_6$$10, label, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/inclusionin.zep", 110 TSRMLS_CC); ZEPHIR_CPY_WRT(label, _6$$10); } if (ZEPHIR_IS_EMPTY(label)) { ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field); zephir_check_call_status(); } ZEPHIR_INIT_NVAR(_5$$9); ZVAL_STRING(_5$$9, "message", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _5$$9); zephir_check_temp_parameter(_5$$9); zephir_check_call_status(); if (Z_TYPE_P(message) == IS_ARRAY) { zephir_array_fetch(&_7$$12, message, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/inclusionin.zep", 118 TSRMLS_CC); ZEPHIR_CPY_WRT(message, _7$$12); } ZEPHIR_INIT_VAR(replacePairs); zephir_create_array(replacePairs, 2, 0 TSRMLS_CC); zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_5$$9); zephir_fast_join_str(_5$$9, SL(", "), domain TSRMLS_CC); zephir_array_update_string(&replacePairs, SL(":domain"), &_5$$9, PH_COPY | PH_SEPARATE); if (ZEPHIR_IS_EMPTY(message)) { ZEPHIR_INIT_VAR(_8$$13); ZVAL_STRING(_8$$13, "InclusionIn", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _8$$13); zephir_check_temp_parameter(_8$$13); zephir_check_call_status(); } ZEPHIR_INIT_NVAR(_5$$9); ZVAL_STRING(_5$$9, "code", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&code, this_ptr, "getoption", NULL, 0, _5$$9); zephir_check_temp_parameter(_5$$9); zephir_check_call_status(); if (Z_TYPE_P(code) == IS_ARRAY) { zephir_array_fetch(&_9$$14, code, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/inclusionin.zep", 127 TSRMLS_CC); ZEPHIR_CPY_WRT(code, _9$$14); } ZEPHIR_INIT_NVAR(_5$$9); object_init_ex(_5$$9, phalcon_validation_message_ce); ZEPHIR_CALL_FUNCTION(&_10$$9, "strtr", NULL, 26, message, replacePairs); zephir_check_call_status(); ZEPHIR_INIT_VAR(_11$$9); ZVAL_STRING(_11$$9, "InclusionIn", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _5$$9, "__construct", NULL, 466, _10$$9, field, _11$$9, code); zephir_check_temp_parameter(_11$$9); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _5$$9); zephir_check_call_status(); RETURN_MM_BOOL(0); } RETURN_MM_BOOL(1); }
/** * Magic method __get */ PHP_METHOD(Phalcon_Di_Injectable, __get) { zval *_4$$7; 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$$7 = NULL, *_5$$7 = NULL; zval *propertyName = NULL, *_6; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &propertyName_param); if (UNEXPECTED(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 (EXPECTED(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_this(this_ptr, SL("di"), dependencyInjector TSRMLS_CC); RETURN_CCTOR(dependencyInjector); } if (ZEPHIR_IS_STRING(propertyName, "persistent")) { ZEPHIR_INIT_VAR(_4$$7); zephir_create_array(_4$$7, 1, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(_5$$7); zephir_get_class(_5$$7, this_ptr, 0 TSRMLS_CC); zephir_array_fast_append(_4$$7, _5$$7); ZEPHIR_INIT_NVAR(_5$$7); ZVAL_STRING(_5$$7, "sessionBag", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_3$$7, dependencyInjector, "get", NULL, 0, _5$$7, _4$$7); zephir_check_temp_parameter(_5$$7); zephir_check_call_status(); ZEPHIR_CPY_WRT(persistent, _3$$7); zephir_update_property_this(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(); }
/** * Returns the messages stored in session */ PHP_METHOD(Phalcon_Flash_Session, _getSessionMessages) { int ZEPHIR_LAST_CALL_STATUS; zval *remove_param = NULL, *type = NULL, *dependencyInjector = NULL, *session = NULL, *messages = NULL, *returnMessages = NULL, *_0, *_1 = NULL, *_2 = NULL, *_4$$6, *_5$$7; zend_bool remove, _3; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &remove_param, &type); remove = zephir_get_boolval(remove_param); if (!type) { type = ZEPHIR_GLOBAL(global_null); } _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_flash_exception_ce, "A dependency injection container is required to access the 'session' service", "phalcon/flash/session.zep", 64); return; } ZEPHIR_INIT_VAR(_2); ZVAL_STRING(_2, "session", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_1, dependencyInjector, "getshared", NULL, 0, _2); zephir_check_temp_parameter(_2); zephir_check_call_status(); ZEPHIR_CPY_WRT(session, _1); ZEPHIR_INIT_NVAR(_2); ZVAL_STRING(_2, "_flashMessages", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&messages, session, "get", NULL, 0, _2); zephir_check_temp_parameter(_2); zephir_check_call_status(); _3 = Z_TYPE_P(type) == IS_STRING; if (_3) { _3 = zephir_array_isset(messages, type); } if (_3) { ZEPHIR_OBS_VAR(returnMessages); if (!(zephir_array_isset_fetch(&returnMessages, messages, type, 0 TSRMLS_CC))) { ZEPHIR_INIT_NVAR(returnMessages); array_init(returnMessages); } if (remove == 1) { zephir_array_unset(&messages, type, PH_SEPARATE); ZEPHIR_INIT_VAR(_4$$6); ZVAL_STRING(_4$$6, "_flashMessages", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, session, "set", NULL, 0, _4$$6, messages); zephir_check_temp_parameter(_4$$6); zephir_check_call_status(); } RETURN_CCTOR(returnMessages); } if (remove == 1) { ZEPHIR_INIT_VAR(_5$$7); ZVAL_STRING(_5$$7, "_flashMessages", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, session, "remove", NULL, 0, _5$$7); zephir_check_temp_parameter(_5$$7); zephir_check_call_status(); } RETURN_CCTOR(messages); }
/** * Generates a URL * *<code> * // Generate a URL appending the URI to the base URI * echo $url->get("products/edit/1"); * * // Generate a URL for a predefined route * echo $url->get( * [ * "for" => "blog-post", * "title" => "some-cool-stuff", * "year" => "2015", * ] * ); * * // Generate a URL with GET arguments (/show/products?id=1&name=Carrots) * echo $url->get( * "show/products", * [ * "id" => 1, * "name" => "Carrots", * ] * ); * * // Generate an absolute URL by setting the third parameter as false. * echo $url->get( * "https://phalconphp.com/", * null, * false * ); *</code> */ PHP_METHOD(Phalcon_Mvc_Url, get) { unsigned char _17$$14, _19$$14, _24$$16; zend_bool _0$$3, _1$$3, _15$$14, _16$$14, _18$$14, _22$$16, _23$$16, _25$$19; zval *strUri = NULL, *_14$$14 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; zval *uri = NULL, *args = NULL, *local = NULL, *baseUri = NULL, *router = NULL, *dependencyInjector = NULL, *routeName = NULL, *route = NULL, *queryString = NULL, *_2$$4, *_3$$4, _4$$4, *_5$$9, *_9$$9 = NULL, *_12$$9, *_13$$9 = NULL, *_6$$11, *_7$$11 = NULL, *_8$$11, *_10$$13, *_11$$13, _20$$15, *_21$$15, _26$$20, *_27$$20, *_28$$21, *_29$$22; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 4, &uri, &args, &local, &baseUri); if (!uri) { ZEPHIR_CPY_WRT(uri, ZEPHIR_GLOBAL(global_null)); } else { ZEPHIR_SEPARATE_PARAM(uri); } if (!args) { args = ZEPHIR_GLOBAL(global_null); } if (!local) { ZEPHIR_CPY_WRT(local, ZEPHIR_GLOBAL(global_null)); } else { ZEPHIR_SEPARATE_PARAM(local); } if (!baseUri) { ZEPHIR_CPY_WRT(baseUri, ZEPHIR_GLOBAL(global_null)); } else { ZEPHIR_SEPARATE_PARAM(baseUri); } if (Z_TYPE_P(local) == IS_NULL) { _0$$3 = Z_TYPE_P(uri) == IS_STRING; if (_0$$3) { _1$$3 = zephir_memnstr_str(uri, SL("//"), "phalcon/mvc/url.zep", 208); if (!(_1$$3)) { _1$$3 = zephir_memnstr_str(uri, SL(":"), "phalcon/mvc/url.zep", 208); } _0$$3 = _1$$3; } if (_0$$3) { ZEPHIR_INIT_VAR(_2$$4); ZEPHIR_INIT_VAR(_3$$4); ZEPHIR_SINIT_VAR(_4$$4); ZVAL_STRING(&_4$$4, "#^((//)|([a-z0-9]+://)|([a-z0-9]+:))#i", 0); zephir_preg_match(_3$$4, &_4$$4, uri, _2$$4, 0, 0 , 0 TSRMLS_CC); ZEPHIR_INIT_NVAR(local); if (zephir_is_true(_3$$4)) { ZVAL_BOOL(local, 0); } else { ZVAL_BOOL(local, 1); } } else { ZEPHIR_INIT_NVAR(local); ZVAL_BOOL(local, 1); } } if (Z_TYPE_P(baseUri) != IS_STRING) { ZEPHIR_CALL_METHOD(&baseUri, this_ptr, "getbaseuri", NULL, 0); zephir_check_call_status(); } if (Z_TYPE_P(uri) == IS_ARRAY) { ZEPHIR_OBS_VAR(routeName); if (!(zephir_array_isset_string_fetch(&routeName, uri, SS("for"), 0 TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_url_exception_ce, "It's necessary to define the route name with the parameter 'for'", "phalcon/mvc/url.zep", 226); return; } _5$$9 = zephir_fetch_nproperty_this(this_ptr, SL("_router"), PH_NOISY_CC); ZEPHIR_CPY_WRT(router, _5$$9); if (Z_TYPE_P(router) != IS_OBJECT) { _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_mvc_url_exception_ce, "A dependency injector container is required to obtain the 'router' service", "phalcon/mvc/url.zep", 238); return; } ZEPHIR_INIT_VAR(_8$$11); ZVAL_STRING(_8$$11, "router", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_7$$11, dependencyInjector, "getshared", NULL, 0, _8$$11); zephir_check_temp_parameter(_8$$11); zephir_check_call_status(); ZEPHIR_CPY_WRT(router, _7$$11); zephir_update_property_this(getThis(), SL("_router"), router TSRMLS_CC); } ZEPHIR_CALL_METHOD(&_9$$9, router, "getroutebyname", NULL, 0, routeName); zephir_check_call_status(); ZEPHIR_CPY_WRT(route, _9$$9); if (Z_TYPE_P(route) != IS_OBJECT) { ZEPHIR_INIT_VAR(_10$$13); object_init_ex(_10$$13, phalcon_mvc_url_exception_ce); ZEPHIR_INIT_VAR(_11$$13); ZEPHIR_CONCAT_SVS(_11$$13, "Cannot obtain a route using the name '", routeName, "'"); ZEPHIR_CALL_METHOD(NULL, _10$$13, "__construct", NULL, 9, _11$$13); zephir_check_call_status(); zephir_throw_exception_debug(_10$$13, "phalcon/mvc/url.zep", 250 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } ZEPHIR_INIT_VAR(_12$$9); ZEPHIR_CALL_METHOD(&_9$$9, route, "getpattern", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_13$$9, route, "getreversedpaths", NULL, 0); zephir_check_call_status(); phalcon_replace_paths(_12$$9, _9$$9, _13$$9, uri TSRMLS_CC); ZEPHIR_CPY_WRT(uri, _12$$9); } if (zephir_is_true(local)) { zephir_get_strval(_14$$14, uri); ZEPHIR_CPY_WRT(strUri, _14$$14); _15$$14 = ZEPHIR_IS_STRING(baseUri, "/"); if (_15$$14) { _15$$14 = zephir_fast_strlen_ev(strUri) > 2; } _16$$14 = _15$$14; if (_16$$14) { _17$$14 = ZEPHIR_STRING_OFFSET(strUri, 0); _16$$14 = _17$$14 == '/'; } _18$$14 = _16$$14; if (_18$$14) { _19$$14 = ZEPHIR_STRING_OFFSET(strUri, 1); _18$$14 = _19$$14 != '/'; } if (_18$$14) { ZEPHIR_SINIT_VAR(_20$$15); ZVAL_LONG(&_20$$15, 1); ZEPHIR_INIT_VAR(_21$$15); zephir_substr(_21$$15, strUri, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_INIT_NVAR(uri); ZEPHIR_CONCAT_VV(uri, baseUri, _21$$15); } else { _22$$16 = ZEPHIR_IS_STRING(baseUri, "/"); if (_22$$16) { _22$$16 = zephir_fast_strlen_ev(strUri) == 1; } _23$$16 = _22$$16; if (_23$$16) { _24$$16 = ZEPHIR_STRING_OFFSET(strUri, 0); _23$$16 = _24$$16 == '/'; } if (_23$$16) { ZEPHIR_CPY_WRT(uri, baseUri); } else { ZEPHIR_INIT_NVAR(uri); ZEPHIR_CONCAT_VV(uri, baseUri, strUri); } } } if (zephir_is_true(args)) { ZEPHIR_CALL_FUNCTION(&queryString, "http_build_query", NULL, 394, args); zephir_check_call_status(); _25$$19 = Z_TYPE_P(queryString) == IS_STRING; if (_25$$19) { _25$$19 = ((zephir_fast_strlen_ev(queryString)) ? 1 : 0); } if (_25$$19) { ZEPHIR_SINIT_VAR(_26$$20); ZVAL_STRING(&_26$$20, "?", 0); ZEPHIR_INIT_VAR(_27$$20); zephir_fast_strpos(_27$$20, uri, &_26$$20, 0 ); if (!ZEPHIR_IS_FALSE_IDENTICAL(_27$$20)) { ZEPHIR_INIT_VAR(_28$$21); ZEPHIR_CONCAT_SV(_28$$21, "&", queryString); zephir_concat_self(&uri, _28$$21 TSRMLS_CC); } else { ZEPHIR_INIT_VAR(_29$$22); ZEPHIR_CONCAT_SV(_29$$22, "?", queryString); zephir_concat_self(&uri, _29$$22 TSRMLS_CC); } } } RETVAL_ZVAL(uri, 1, 0); RETURN_MM(); }
/** * Check if the CSRF token sent in the request is the same that the current in session */ PHP_METHOD(Phalcon_Security, checkToken) { int ZEPHIR_LAST_CALL_STATUS; zend_bool destroyIfValid, returnValue, _4; zval *tokenKey = NULL, *tokenValue = NULL, *destroyIfValid_param = NULL, *dependencyInjector = NULL, *session = NULL, *request = NULL, *token = NULL, *_0, *_1 = NULL, *_2 = NULL, *_3, *_5, *_6; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 3, &tokenKey, &tokenValue, &destroyIfValid_param); if (!tokenKey) { ZEPHIR_CPY_WRT(tokenKey, ZEPHIR_GLOBAL(global_null)); } else { ZEPHIR_SEPARATE_PARAM(tokenKey); } if (!tokenValue) { tokenValue = ZEPHIR_GLOBAL(global_null); } if (!destroyIfValid_param) { destroyIfValid = 1; } else { destroyIfValid = zephir_get_boolval(destroyIfValid_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_security_exception_ce, "A dependency injection container is required to access the 'session' service", "phalcon/security.zep", 341); return; } ZEPHIR_INIT_VAR(_2); ZVAL_STRING(_2, "session", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_1, dependencyInjector, "getshared", NULL, _2); zephir_check_temp_parameter(_2); zephir_check_call_status(); ZEPHIR_CPY_WRT(session, _1); if (!(zephir_is_true(tokenKey))) { _0 = zephir_fetch_nproperty_this(this_ptr, SL("_tokenKeySessionID"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&tokenKey, session, "get", NULL, _0); zephir_check_call_status(); } if (!(zephir_is_true(tokenKey))) { RETURN_MM_BOOL(0); } if (!(zephir_is_true(tokenValue))) { ZEPHIR_INIT_NVAR(_2); ZVAL_STRING(_2, "request", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&request, dependencyInjector, "getshared", NULL, _2); zephir_check_temp_parameter(_2); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&token, request, "getpost", NULL, tokenKey); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(token, tokenValue); } _3 = zephir_fetch_nproperty_this(this_ptr, SL("_tokenValueSessionID"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&_1, session, "get", NULL, _3); zephir_check_call_status(); returnValue = ZEPHIR_IS_EQUAL(token, _1); _4 = returnValue; if (_4) { _4 = destroyIfValid; } if (_4) { _5 = zephir_fetch_nproperty_this(this_ptr, SL("_tokenKeySessionID"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(NULL, session, "remove", NULL, _5); zephir_check_call_status(); _6 = zephir_fetch_nproperty_this(this_ptr, SL("_tokenValueSessionID"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(NULL, session, "remove", NULL, _6); zephir_check_call_status(); } RETURN_MM_BOOL(returnValue); }
/** * Executes the validator */ PHP_METHOD(Phalcon_Mvc_Model_Validator_Url, validate) { zval *_5; zend_bool _2; int ZEPHIR_LAST_CALL_STATUS; zval *record, *field = NULL, *value = NULL, *message = NULL, *_0 = NULL, *_1 = NULL, _3, *_4 = NULL, *_6 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &record); ZEPHIR_INIT_VAR(_0); ZVAL_STRING(_0, "field", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&field, this_ptr, "getoption", NULL, 0, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); if (Z_TYPE_P(field) != IS_STRING) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Field name must be a string", "phalcon/mvc/model/validator/url.zep", 62); return; } ZEPHIR_CALL_METHOD(&value, record, "readattribute", NULL, 0, field); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "allowEmpty", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "issetoption", NULL, 0, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); _2 = zephir_is_true(_1); if (_2) { _2 = ZEPHIR_IS_EMPTY(value); } if (_2) { RETURN_MM_BOOL(1); } ZEPHIR_SINIT_VAR(_3); ZVAL_LONG(&_3, 273); ZEPHIR_CALL_FUNCTION(&_4, "filter_var", NULL, 192, value, &_3); zephir_check_call_status(); if (!(zephir_is_true(_4))) { ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "message", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); if (ZEPHIR_IS_EMPTY(message)) { ZEPHIR_INIT_NVAR(message); ZVAL_STRING(message, ":field does not have a valid url format", 1); } ZEPHIR_INIT_VAR(_5); zephir_create_array(_5, 1, 0 TSRMLS_CC); zephir_array_update_string(&_5, SL(":field"), &field, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_FUNCTION(&_6, "strtr", NULL, 54, message, _5); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "Url", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, this_ptr, "appendmessage", NULL, 0, _6, field, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); RETURN_MM_BOOL(0); } RETURN_MM_BOOL(1); }
PHP_METHOD(Yb_View_Redirect, run) { zend_bool redirectDataAsQueries = 0, _7; zval *redirectUrl = NULL, *_4 = NULL, *_11; int ZEPHIR_LAST_CALL_STATUS; zephir_fcall_cache_entry *_1 = NULL; zval *data_param = NULL, *options_param = NULL, *_0 = NULL, *_2 = NULL, *_3 = NULL, *_5 = NULL, *_6 = NULL, _8$$4, *_9$$4, *_10$$4 = NULL; zval *data = NULL, *options = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &data_param, &options_param); zephir_get_arrval(data, data_param); zephir_get_arrval(options, options_param); ZEPHIR_INIT_VAR(_2); ZVAL_STRING(_2, "redirectUrl", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_VAR(_3); ZVAL_STRING(_3, "", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_CE_STATIC(&_0, yb_std_ce, "valueat", &_1, 5, options, _2, _3); zephir_check_temp_parameter(_2); zephir_check_temp_parameter(_3); zephir_check_call_status(); zephir_get_strval(_4, _0); ZEPHIR_CPY_WRT(redirectUrl, _4); if (unlikely(zephir_fast_strlen_ev(redirectUrl) < 1)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(yb_view_exception_ce, "Missing option: redirectUrl", "yb/view/redirect.zep", 14); return; } ZEPHIR_INIT_NVAR(_2); ZVAL_STRING(_2, "redirectDataAsQueries", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_3); ZVAL_BOOL(_3, 0); ZEPHIR_CALL_CE_STATIC(&_6, yb_std_ce, "valueat", &_1, 5, options, _2, _3); zephir_check_temp_parameter(_2); zephir_check_call_status(); redirectDataAsQueries = zephir_get_boolval(_6); _7 = redirectDataAsQueries; if (_7) { _7 = zephir_fast_count_int(data TSRMLS_CC) > 0; } if (_7) { ZEPHIR_SINIT_VAR(_8$$4); ZVAL_STRING(&_8$$4, "?", 0); ZEPHIR_INIT_VAR(_9$$4); zephir_fast_strpos(_9$$4, redirectUrl, &_8$$4, 0 ); if (ZEPHIR_IS_FALSE_IDENTICAL(_9$$4)) { zephir_concat_self_str(&redirectUrl, "?", sizeof("?")-1 TSRMLS_CC); } else { zephir_concat_self_str(&redirectUrl, "&", sizeof("&")-1 TSRMLS_CC); } ZEPHIR_CALL_FUNCTION(&_10$$4, "http_build_query", NULL, 99, data); zephir_check_call_status(); zephir_concat_self(&redirectUrl, _10$$4 TSRMLS_CC); } ZEPHIR_INIT_VAR(_11); ZEPHIR_CONCAT_SV(_11, "Location: ", redirectUrl); ZEPHIR_CALL_FUNCTION(NULL, "header", NULL, 93, _11); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); }
/** * Returns current row in the resultset */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, current) { zephir_fcall_cache_entry *_8 = NULL, *_11 = NULL; HashTable *_2, *_5; HashPosition _1, _4; int dirtyState, ZEPHIR_LAST_CALL_STATUS; zval *row, *hydrateMode, *alias = NULL, *activeRow = NULL, *type = NULL, *columnTypes, *column = NULL, *columnValue = NULL, *value = NULL, *attribute = NULL, *source = NULL, *attributes = NULL, *columnMap = NULL, *rowModel = NULL, *keepSnapshots = NULL, *sqlAlias = NULL, *_0, **_3, **_6, *_7 = NULL, *_9, *_10 = NULL, _12 = zval_used_for_init, _13 = zval_used_for_init; ZEPHIR_MM_GROW(); ZEPHIR_OBS_VAR(activeRow); zephir_read_property_this(&activeRow, this_ptr, SL("_activeRow"), PH_NOISY_CC); if (Z_TYPE_P(activeRow) != IS_NULL) { RETURN_CCTOR(activeRow); } ZEPHIR_OBS_VAR(row); zephir_read_property_this(&row, this_ptr, SL("_row"), PH_NOISY_CC); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_disableHydration"), PH_NOISY_CC); if (zephir_is_true(_0)) { zephir_update_property_this(this_ptr, SL("_activeRow"), row TSRMLS_CC); RETURN_CCTOR(row); } if (Z_TYPE_P(row) != IS_ARRAY) { zephir_update_property_this(this_ptr, SL("_activeRow"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC); RETURN_MM_BOOL(0); } ZEPHIR_OBS_VAR(hydrateMode); zephir_read_property_this(&hydrateMode, this_ptr, SL("_hydrateMode"), PH_NOISY_CC); do { if (ZEPHIR_IS_LONG(hydrateMode, 0)) { ZEPHIR_INIT_NVAR(activeRow); object_init_ex(activeRow, phalcon_mvc_model_row_ce); if (zephir_has_constructor(activeRow TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, activeRow, "__construct", NULL, 0); zephir_check_call_status(); } break; } if (ZEPHIR_IS_LONG(hydrateMode, 1)) { ZEPHIR_INIT_NVAR(activeRow); array_init(activeRow); break; } ZEPHIR_INIT_NVAR(activeRow); object_init(activeRow); break; } while(0); ZEPHIR_OBS_VAR(columnTypes); zephir_read_property_this(&columnTypes, this_ptr, SL("_columnTypes"), PH_NOISY_CC); dirtyState = 0; zephir_is_iterable(columnTypes, &_2, &_1, 0, 0, "phalcon/mvc/model/resultset/complex.zep", 235); for ( ; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS ; zephir_hash_move_forward_ex(_2, &_1) ) { ZEPHIR_GET_HMKEY(alias, _2, _1); ZEPHIR_GET_HVALUE(column, _3); if (Z_TYPE_P(column) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Column type is corrupt", "phalcon/mvc/model/resultset/complex.zep", 136); return; } ZEPHIR_OBS_NVAR(type); zephir_array_fetch_string(&type, column, SL("type"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 139 TSRMLS_CC); if (ZEPHIR_IS_STRING(type, "object")) { ZEPHIR_OBS_NVAR(source); zephir_array_fetch_string(&source, column, SL("column"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 145 TSRMLS_CC); ZEPHIR_OBS_NVAR(attributes); zephir_array_fetch_string(&attributes, column, SL("attributes"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 146 TSRMLS_CC); ZEPHIR_OBS_NVAR(columnMap); zephir_array_fetch_string(&columnMap, column, SL("columnMap"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 147 TSRMLS_CC); ZEPHIR_INIT_NVAR(rowModel); array_init(rowModel); zephir_is_iterable(attributes, &_5, &_4, 0, 0, "phalcon/mvc/model/resultset/complex.zep", 165); for ( ; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS ; zephir_hash_move_forward_ex(_5, &_4) ) { ZEPHIR_GET_HVALUE(attribute, _6); ZEPHIR_OBS_NVAR(columnValue); ZEPHIR_INIT_LNVAR(_7); ZEPHIR_CONCAT_SVSV(_7, "_", source, "_", attribute); zephir_array_fetch(&columnValue, row, _7, PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 158 TSRMLS_CC); zephir_array_update_zval(&rowModel, attribute, &columnValue, PH_COPY | PH_SEPARATE); } do { if (ZEPHIR_IS_LONG(hydrateMode, 0)) { ZEPHIR_OBS_NVAR(keepSnapshots); if (!(zephir_array_isset_string_fetch(&keepSnapshots, column, SS("keepSnapshots"), 0 TSRMLS_CC))) { ZEPHIR_INIT_NVAR(keepSnapshots); ZVAL_BOOL(keepSnapshots, 0); } zephir_array_fetch_string(&_9, column, SL("instance"), PH_NOISY | PH_READONLY, "phalcon/mvc/model/resultset/complex.zep", 180 TSRMLS_CC); ZEPHIR_INIT_NVAR(_10); ZVAL_LONG(_10, dirtyState); ZEPHIR_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmap", &_8, 0, _9, rowModel, columnMap, _10, keepSnapshots); zephir_check_call_status(); break; } ZEPHIR_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmaphydrate", &_11, 0, rowModel, columnMap, hydrateMode); zephir_check_call_status(); break; } while(0); ZEPHIR_OBS_NVAR(attribute); zephir_array_fetch_string(&attribute, column, SL("balias"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 194 TSRMLS_CC); } else { ZEPHIR_OBS_NVAR(sqlAlias); if (zephir_array_isset_string_fetch(&sqlAlias, column, SS("sqlAlias"), 0 TSRMLS_CC)) { ZEPHIR_OBS_NVAR(value); zephir_array_fetch(&value, row, sqlAlias, PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 202 TSRMLS_CC); } else { ZEPHIR_OBS_NVAR(value); zephir_array_isset_fetch(&value, row, alias, 0 TSRMLS_CC); } if (zephir_array_isset_string(column, SS("balias"))) { ZEPHIR_CPY_WRT(attribute, alias); } else { ZEPHIR_SINIT_NVAR(_12); ZVAL_STRING(&_12, "_", 0); ZEPHIR_SINIT_NVAR(_13); ZVAL_STRING(&_13, "", 0); ZEPHIR_INIT_NVAR(attribute); zephir_fast_str_replace(&attribute, &_12, &_13, alias TSRMLS_CC); } } do { if (ZEPHIR_IS_LONG(hydrateMode, 1)) { zephir_array_update_zval(&activeRow, attribute, &value, PH_COPY | PH_SEPARATE); break; } zephir_update_property_zval_zval(activeRow, attribute, value TSRMLS_CC); break; } while(0); } zephir_update_property_this(this_ptr, SL("_activeRow"), activeRow TSRMLS_CC); RETURN_CCTOR(activeRow); }
/** * Binds data to the entity * * @param array data * @param object entity * @param array whitelist */ PHP_METHOD(Phalcon_Forms_Form, bind) { HashTable *_2; HashPosition _1; zephir_fcall_cache_entry *_5 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; zval *data_param = NULL, *entity, *whitelist = NULL, *filter = NULL, *key = NULL, *value = NULL, *element = NULL, *filters = NULL, *dependencyInjector = NULL, *filteredValue = NULL, *method = NULL, *_0, **_3, *_4$$4, *_8$$4 = NULL, *_6$$9 = NULL, *_7$$9 = NULL; zval *data = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 1, &data_param, &entity, &whitelist); data = data_param; ZEPHIR_SEPARATE_PARAM(entity); if (!whitelist) { whitelist = ZEPHIR_GLOBAL(global_null); } _0 = zephir_fetch_nproperty_this(this_ptr, SL("_elements"), PH_NOISY_CC); if (ZEPHIR_IS_EMPTY(_0)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_forms_exception_ce, "There are no elements in the form", "phalcon/forms/form.zep", 189); return; } ZEPHIR_INIT_VAR(filter); ZVAL_NULL(filter); zephir_is_iterable(data, &_2, &_1, 0, 0, "phalcon/forms/form.zep", 246); for ( ; zend_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS ; zend_hash_move_forward_ex(_2, &_1) ) { ZEPHIR_GET_HMKEY(key, _2, _1); ZEPHIR_GET_HVALUE(value, _3); ZEPHIR_OBS_NVAR(element); _4$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_elements"), PH_NOISY_CC); if (!(zephir_array_isset_fetch(&element, _4$$4, key, 0 TSRMLS_CC))) { continue; } if (Z_TYPE_P(whitelist) == IS_ARRAY) { if (!(zephir_fast_in_array(key, whitelist TSRMLS_CC))) { continue; } } ZEPHIR_CALL_METHOD(&filters, element, "getfilters", NULL, 0); zephir_check_call_status(); if (zephir_is_true(filters)) { if (Z_TYPE_P(filter) != IS_OBJECT) { ZEPHIR_CALL_METHOD(&dependencyInjector, this_ptr, "getdi", &_5, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_7$$9); ZVAL_STRING(_7$$9, "filter", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_6$$9, dependencyInjector, "getshared", NULL, 0, _7$$9); zephir_check_temp_parameter(_7$$9); zephir_check_call_status(); ZEPHIR_CPY_WRT(filter, _6$$9); } ZEPHIR_CALL_METHOD(&filteredValue, filter, "sanitize", NULL, 0, value, filters); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(filteredValue, value); } ZEPHIR_INIT_NVAR(_8$$4); zephir_camelize(_8$$4, key, NULL ); ZEPHIR_INIT_NVAR(method); ZEPHIR_CONCAT_SV(method, "set", _8$$4); if ((zephir_method_exists(entity, method TSRMLS_CC) == SUCCESS)) { ZEPHIR_CALL_METHOD_ZVAL(NULL, entity, method, NULL, 0, filteredValue); zephir_check_call_status(); continue; } zephir_update_property_zval_zval(entity, key, filteredValue TSRMLS_CC); } zephir_update_property_this(getThis(), SL("_data"), data TSRMLS_CC); RETURN_THIS(); }
/** * Performs a string conversion */ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt, convertEncoding) { int ZEPHIR_LAST_CALL_STATUS; zend_bool _0, _1; zval *text_param = NULL, *from_param = NULL, *to_param = NULL; zval *text = NULL, *from = NULL, *to = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 3, 0, &text_param, &from_param, &to_param); zephir_get_strval(text, text_param); if (unlikely(Z_TYPE_P(from_param) != IS_STRING && Z_TYPE_P(from_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'from' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(from_param) == IS_STRING)) { zephir_get_strval(from, from_param); } else { ZEPHIR_INIT_VAR(from); ZVAL_EMPTY_STRING(from); } if (unlikely(Z_TYPE_P(to_param) != IS_STRING && Z_TYPE_P(to_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'to' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(to_param) == IS_STRING)) { zephir_get_strval(to, to_param); } else { ZEPHIR_INIT_VAR(to); ZVAL_EMPTY_STRING(to); } _0 = ZEPHIR_IS_STRING(from, "latin1"); if (!(_0)) { _0 = ZEPHIR_IS_STRING(to, "utf8"); } if (_0) { ZEPHIR_RETURN_CALL_FUNCTION("utf8_encode", NULL, 376, text); zephir_check_call_status(); RETURN_MM(); } _1 = ZEPHIR_IS_STRING(to, "latin1"); if (!(_1)) { _1 = ZEPHIR_IS_STRING(from, "utf8"); } if (_1) { ZEPHIR_RETURN_CALL_FUNCTION("utf8_decode", NULL, 377, text); zephir_check_call_status(); RETURN_MM(); } if ((zephir_function_exists_ex(SS("mb_convert_encoding") TSRMLS_CC) == SUCCESS)) { ZEPHIR_RETURN_CALL_FUNCTION("mb_convert_encoding", NULL, 180, text, from, to); zephir_check_call_status(); RETURN_MM(); } if ((zephir_function_exists_ex(SS("iconv") TSRMLS_CC) == SUCCESS)) { ZEPHIR_RETURN_CALL_FUNCTION("iconv", NULL, 378, from, to, text); zephir_check_call_status(); RETURN_MM(); } ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_view_exception_ce, "Any of 'mbstring' or 'iconv' is required to perform the charset conversion", "phalcon/mvc/view/engine/volt.zep", 205); return; }
/** * Gets the a value to validate in the array/object data source * * @param string field * @return mixed */ PHP_METHOD(Phalcon_Validation, getValue) { zend_bool _1; zephir_fcall_cache_entry *_2 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *field_param = NULL, *entity = NULL, *method = NULL, *value = NULL, *data = NULL, *values = NULL, *filters = NULL, *fieldFilters = NULL, *dependencyInjector = NULL, *filterService = NULL, *_0$$3, *_3$$20; zval *field = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &field_param); zephir_get_strval(field, field_param); ZEPHIR_OBS_VAR(entity); zephir_read_property_this(&entity, this_ptr, SL("_entity"), PH_NOISY_CC); if (Z_TYPE_P(entity) == IS_OBJECT) { ZEPHIR_INIT_VAR(_0$$3); zephir_camelize(_0$$3, field, NULL ); ZEPHIR_INIT_VAR(method); ZEPHIR_CONCAT_SV(method, "get", _0$$3); if ((zephir_method_exists(entity, method TSRMLS_CC) == SUCCESS)) { ZEPHIR_CALL_METHOD_ZVAL(&value, entity, method, NULL, 0); zephir_check_call_status(); } else { if ((zephir_method_exists_ex(entity, SS("readattribute") TSRMLS_CC) == SUCCESS)) { ZEPHIR_CALL_METHOD(&value, entity, "readattribute", NULL, 0, field); zephir_check_call_status(); } else { ZEPHIR_INIT_NVAR(value); if (zephir_isset_property_zval(entity, field TSRMLS_CC)) { zephir_read_property_zval(&value, entity, field, PH_NOISY_CC); } else { ZVAL_NULL(value); } } } RETURN_CCTOR(value); } ZEPHIR_OBS_VAR(data); zephir_read_property_this(&data, this_ptr, SL("_data"), PH_NOISY_CC); _1 = Z_TYPE_P(data) != IS_ARRAY; if (_1) { _1 = Z_TYPE_P(data) != IS_OBJECT; } if (_1) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "There is no data to validate", "phalcon/validation.zep", 504); return; } ZEPHIR_OBS_VAR(values); zephir_read_property_this(&values, this_ptr, SL("_values"), PH_NOISY_CC); ZEPHIR_OBS_NVAR(value); if (zephir_array_isset_fetch(&value, values, field, 0 TSRMLS_CC)) { RETURN_CCTOR(value); } ZEPHIR_INIT_NVAR(value); ZVAL_NULL(value); if (Z_TYPE_P(data) == IS_ARRAY) { if (zephir_array_isset(data, field)) { ZEPHIR_OBS_NVAR(value); zephir_array_fetch(&value, data, field, PH_NOISY, "phalcon/validation.zep", 516 TSRMLS_CC); } } else { if (Z_TYPE_P(data) == IS_OBJECT) { if (zephir_isset_property_zval(data, field TSRMLS_CC)) { ZEPHIR_OBS_NVAR(value); zephir_read_property_zval(&value, data, field, PH_NOISY_CC); } } } if (Z_TYPE_P(value) == IS_NULL) { RETURN_MM_NULL(); } ZEPHIR_OBS_VAR(filters); zephir_read_property_this(&filters, this_ptr, SL("_filters"), PH_NOISY_CC); if (Z_TYPE_P(filters) == IS_ARRAY) { ZEPHIR_OBS_VAR(fieldFilters); if (zephir_array_isset_fetch(&fieldFilters, filters, field, 0 TSRMLS_CC)) { if (zephir_is_true(fieldFilters)) { ZEPHIR_CALL_METHOD(&dependencyInjector, this_ptr, "getdi", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) { ZEPHIR_CALL_CE_STATIC(&dependencyInjector, phalcon_di_ce, "getdefault", &_2, 1); zephir_check_call_status(); if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "A dependency injector is required to obtain the 'filter' service", "phalcon/validation.zep", 541); return; } } ZEPHIR_INIT_VAR(_3$$20); ZVAL_STRING(_3$$20, "filter", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&filterService, dependencyInjector, "getshared", NULL, 0, _3$$20); zephir_check_temp_parameter(_3$$20); zephir_check_call_status(); if (Z_TYPE_P(filterService) != IS_OBJECT) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Returned 'filter' service is invalid", "phalcon/validation.zep", 547); return; } ZEPHIR_RETURN_CALL_METHOD(filterService, "sanitize", NULL, 0, value, fieldFilters); zephir_check_call_status(); RETURN_MM(); } } } zephir_update_property_array(this_ptr, SL("_values"), field, value TSRMLS_CC); RETURN_CCTOR(value); }
/** * Reconfigure the route adding a new pattern and a set of paths * * @param string pattern * @param array paths */ PHP_METHOD(Test_Router_Route, reConfigure) { int _0, ZEPHIR_LAST_CALL_STATUS; zval *pattern, *paths = NULL, *moduleName = NULL, *controllerName = NULL, *actionName = NULL, *parts, *routePaths = NULL, *realClassName = NULL, *namespaceName, *pcrePattern = NULL, *compiledPattern = NULL, *extracted = NULL, *_1 = NULL, *_2; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &pattern, &paths); if (!paths) { paths = ZEPHIR_GLOBAL(global_null); } if (Z_TYPE_P(pattern) != IS_STRING) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(test_router_exception_ce, "The pattern must be string", "test/router/route.zep", 270); return; } 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 = zephir_fast_count_int(parts TSRMLS_CC); if (_0 == 3) { ZEPHIR_OBS_NVAR(moduleName); zephir_array_fetch_long(&moduleName, parts, 0, PH_NOISY, "test/router/route.zep", 286 TSRMLS_CC); ZEPHIR_OBS_NVAR(controllerName); zephir_array_fetch_long(&controllerName, parts, 1, PH_NOISY, "test/router/route.zep", 287 TSRMLS_CC); ZEPHIR_OBS_NVAR(actionName); zephir_array_fetch_long(&actionName, parts, 2, PH_NOISY, "test/router/route.zep", 288 TSRMLS_CC); break; } if (_0 == 2) { ZEPHIR_OBS_NVAR(controllerName); zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY, "test/router/route.zep", 291 TSRMLS_CC); ZEPHIR_OBS_NVAR(actionName); zephir_array_fetch_long(&actionName, parts, 1, PH_NOISY, "test/router/route.zep", 292 TSRMLS_CC); break; } if (_0 == 1) { ZEPHIR_OBS_NVAR(controllerName); zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY, "test/router/route.zep", 295 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("\\"), "test/router/route.zep", 310)) { 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); zephir_uncamelize(_1, realClassName); zephir_array_update_string(&routePaths, SL("controller"), &_1, 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(test_router_exception_ce, "The route contains invalid paths", "test/router/route.zep", 342); return; } if (!(zephir_start_with_str(pattern, SL("#")))) { if (zephir_memnstr_str(pattern, SL("{"), "test/router/route.zep", 348)) { ZEPHIR_CALL_METHOD(&extracted, this_ptr, "extractnamedparams", NULL, pattern); zephir_check_call_status(); ZEPHIR_OBS_VAR(pcrePattern); zephir_array_fetch_long(&pcrePattern, extracted, 0, PH_NOISY, "test/router/route.zep", 351 TSRMLS_CC); ZEPHIR_INIT_NVAR(_1); zephir_array_fetch_long(&_2, extracted, 1, PH_NOISY | PH_READONLY, "test/router/route.zep", 352 TSRMLS_CC); zephir_fast_array_merge(_1, &(routePaths), &(_2) TSRMLS_CC); ZEPHIR_CPY_WRT(routePaths, _1); } else { ZEPHIR_CPY_WRT(pcrePattern, pattern); } ZEPHIR_CALL_METHOD(&compiledPattern, this_ptr, "compilepattern", NULL, pcrePattern); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(compiledPattern, pattern); } zephir_update_property_this(this_ptr, SL("_pattern"), pattern TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_compiledPattern"), compiledPattern TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_paths"), routePaths TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * Reconfigure the route adding a new pattern and a set of paths * * @param string pattern * @param array paths */ PHP_METHOD(Test_Router_Route, reConfigure) { int ZEPHIR_LAST_CALL_STATUS, _0$$5; zval *pattern, pattern_sub, *paths = NULL, paths_sub, __$null, moduleName, controllerName, actionName, parts, routePaths, realClassName, namespaceName, pcrePattern, compiledPattern, extracted, _1$$10, _2$$19, _3$$19; ZEPHIR_INIT_THIS(); ZVAL_UNDEF(&pattern_sub); ZVAL_UNDEF(&paths_sub); ZVAL_NULL(&__$null); ZVAL_UNDEF(&moduleName); ZVAL_UNDEF(&controllerName); ZVAL_UNDEF(&actionName); ZVAL_UNDEF(&parts); ZVAL_UNDEF(&routePaths); ZVAL_UNDEF(&realClassName); ZVAL_UNDEF(&namespaceName); ZVAL_UNDEF(&pcrePattern); ZVAL_UNDEF(&compiledPattern); ZVAL_UNDEF(&extracted); ZVAL_UNDEF(&_1$$10); ZVAL_UNDEF(&_2$$19); ZVAL_UNDEF(&_3$$19); ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &pattern, &paths); if (!paths) { paths = &paths_sub; paths = &__$null; } if (Z_TYPE_P(pattern) != IS_STRING) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(test_router_exception_ce, "The pattern must be string", "test/router/route.zep", 270); return; } 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$$5 = zephir_fast_count_int(&parts TSRMLS_CC); if (_0$$5 == 3) { ZEPHIR_OBS_NVAR(&moduleName); zephir_array_fetch_long(&moduleName, &parts, 0, PH_NOISY, "test/router/route.zep", 286 TSRMLS_CC); ZEPHIR_OBS_NVAR(&controllerName); zephir_array_fetch_long(&controllerName, &parts, 1, PH_NOISY, "test/router/route.zep", 287 TSRMLS_CC); ZEPHIR_OBS_NVAR(&actionName); zephir_array_fetch_long(&actionName, &parts, 2, PH_NOISY, "test/router/route.zep", 288 TSRMLS_CC); break; } if (_0$$5 == 2) { ZEPHIR_OBS_NVAR(&controllerName); zephir_array_fetch_long(&controllerName, &parts, 0, PH_NOISY, "test/router/route.zep", 291 TSRMLS_CC); ZEPHIR_OBS_NVAR(&actionName); zephir_array_fetch_long(&actionName, &parts, 1, PH_NOISY, "test/router/route.zep", 292 TSRMLS_CC); break; } if (_0$$5 == 1) { ZEPHIR_OBS_NVAR(&controllerName); zephir_array_fetch_long(&controllerName, &parts, 0, PH_NOISY, "test/router/route.zep", 295 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("\\"), "test/router/route.zep", 310)) { 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$$10); zephir_uncamelize(&_1$$10, &realClassName); zephir_array_update_string(&routePaths, SL("controller"), &_1$$10, 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(test_router_exception_ce, "The route contains invalid paths", "test/router/route.zep", 342); return; } if (!(zephir_start_with_str(pattern, SL("#")))) { if (zephir_memnstr_str(pattern, SL("{"), "test/router/route.zep", 348)) { ZEPHIR_CALL_METHOD(&extracted, this_ptr, "extractnamedparams", NULL, 0, pattern); zephir_check_call_status(); ZEPHIR_OBS_VAR(&pcrePattern); zephir_array_fetch_long(&pcrePattern, &extracted, 0, PH_NOISY, "test/router/route.zep", 351 TSRMLS_CC); ZEPHIR_INIT_VAR(&_2$$19); zephir_array_fetch_long(&_3$$19, &extracted, 1, PH_NOISY | PH_READONLY, "test/router/route.zep", 352 TSRMLS_CC); zephir_fast_array_merge(&_2$$19, &routePaths, &_3$$19 TSRMLS_CC); ZEPHIR_CPY_WRT(&routePaths, &_2$$19); } else { ZEPHIR_CPY_WRT(&pcrePattern, pattern); } ZEPHIR_CALL_METHOD(&compiledPattern, this_ptr, "compilepattern", NULL, 0, &pcrePattern); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(&compiledPattern, pattern); } zephir_update_property_zval(this_ptr, SL("_pattern"), pattern); zephir_update_property_zval(this_ptr, SL("_compiledPattern"), &compiledPattern); zephir_update_property_zval(this_ptr, SL("_paths"), &routePaths); ZEPHIR_MM_RESTORE(); }
/** * Returns a slice of the resultset to show in the pagination */ PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilder, getPaginate) { zval *_6$$14, *_8$$15; zend_bool hasHaving = 0, hasGroup = 0, _2; zval *originalBuilder = NULL, *builder = NULL, *totalBuilder = NULL, *totalPages = NULL, *limit = NULL, *number = NULL, *query = NULL, *page = NULL, *items = NULL, *totalQuery = NULL, *result = NULL, *row = NULL, *rowcount = NULL, *next = NULL, *sql = NULL, *columns = NULL, *db = NULL, *_0, *_1 = NULL, *groups = NULL, *_10, *_22, *_3$$10, *groupColumn$$11 = NULL, *_4$$14 = NULL, *_5$$14, *_7$$14, *_9$$15, *_11$$16 = NULL, *_12$$16 = NULL, *_13$$16, *_14$$16, *_15$$16, *_16$$16, _17$$16, _18$$16, *_19$$17, _20$$17, _21$$17; zend_long ZEPHIR_LAST_CALL_STATUS, numberPage = 0, before = 0; ZEPHIR_MM_GROW(); ZEPHIR_OBS_VAR(originalBuilder); zephir_read_property_this(&originalBuilder, this_ptr, SL("_builder"), PH_NOISY_CC); ZEPHIR_OBS_VAR(columns); zephir_read_property_this(&columns, this_ptr, SL("_columns"), 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, 0, limit); zephir_check_call_status(); } else { ZEPHIR_CALL_METHOD(NULL, builder, "limit", NULL, 0, limit, number); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(&query, builder, "getquery", NULL, 0); zephir_check_call_status(); if (numberPage == 1) { before = 1; } else { before = (numberPage - 1); } ZEPHIR_CALL_METHOD(&items, query, "execute", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_1, totalBuilder, "gethaving", NULL, 0); zephir_check_call_status(); hasHaving = !(ZEPHIR_IS_EMPTY(_1)); ZEPHIR_CALL_METHOD(&groups, totalBuilder, "getgroupby", NULL, 0); zephir_check_call_status(); hasGroup = !(ZEPHIR_IS_EMPTY(groups)); _2 = hasHaving; if (_2) { _2 = !hasGroup; } if (_2) { if (ZEPHIR_IS_EMPTY(columns)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_paginator_exception_ce, "When having is set there should be columns option provided for which calculate row count", "phalcon/paginator/adapter/querybuilder.zep", 186); return; } ZEPHIR_CALL_METHOD(NULL, totalBuilder, "columns", NULL, 0, columns); zephir_check_call_status(); } else { ZEPHIR_INIT_VAR(_3$$10); ZVAL_STRING(_3$$10, "COUNT(*) [rowcount]", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, totalBuilder, "columns", NULL, 0, _3$$10); zephir_check_temp_parameter(_3$$10); zephir_check_call_status(); } if (hasGroup) { if (Z_TYPE_P(groups) == IS_ARRAY) { ZEPHIR_INIT_VAR(groupColumn$$11); zephir_fast_join_str(groupColumn$$11, SL(", "), groups TSRMLS_CC); } else { ZEPHIR_CPY_WRT(groupColumn$$11, groups); } if (!(hasHaving)) { ZEPHIR_INIT_VAR(_5$$14); ZVAL_NULL(_5$$14); ZEPHIR_CALL_METHOD(&_4$$14, totalBuilder, "groupby", NULL, 0, _5$$14); zephir_check_call_status(); ZEPHIR_INIT_VAR(_6$$14); zephir_create_array(_6$$14, 1, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(_7$$14); ZEPHIR_CONCAT_SVS(_7$$14, "COUNT(DISTINCT ", groupColumn$$11, ") AS rowcount"); zephir_array_fast_append(_6$$14, _7$$14); ZEPHIR_CALL_METHOD(NULL, _4$$14, "columns", NULL, 0, _6$$14); zephir_check_call_status(); } else { ZEPHIR_INIT_VAR(_8$$15); zephir_create_array(_8$$15, 1, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(_9$$15); ZEPHIR_CONCAT_SV(_9$$15, "DISTINCT ", groupColumn$$11); zephir_array_fast_append(_8$$15, _9$$15); ZEPHIR_CALL_METHOD(NULL, totalBuilder, "columns", NULL, 0, _8$$15); zephir_check_call_status(); } } ZEPHIR_INIT_VAR(_10); ZVAL_NULL(_10); ZEPHIR_CALL_METHOD(NULL, totalBuilder, "orderby", NULL, 0, _10); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&totalQuery, totalBuilder, "getquery", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(rowcount); if (hasHaving) { ZEPHIR_CALL_METHOD(&sql, totalQuery, "getsql", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_11$$16, totalBuilder, "getdi", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(_12$$16); ZVAL_STRING(_12$$16, "db", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&db, _11$$16, "get", NULL, 0, _12$$16); zephir_check_temp_parameter(_12$$16); zephir_check_call_status(); zephir_array_fetch_string(&_13$$16, sql, SL("sql"), PH_NOISY | PH_READONLY, "phalcon/paginator/adapter/querybuilder.zep", 228 TSRMLS_CC); ZEPHIR_INIT_VAR(_14$$16); ZEPHIR_CONCAT_SVS(_14$$16, "SELECT COUNT(*) as rowcount FROM (", _13$$16, ") as T1"); zephir_array_fetch_string(&_15$$16, sql, SL("bind"), PH_NOISY | PH_READONLY, "phalcon/paginator/adapter/querybuilder.zep", 228 TSRMLS_CC); ZEPHIR_INIT_NVAR(_12$$16); ZVAL_LONG(_12$$16, 2); ZEPHIR_CALL_METHOD(&row, db, "fetchone", NULL, 0, _14$$16, _12$$16, _15$$16); zephir_check_call_status(); if (zephir_is_true(row)) { zephir_array_fetch_string(&_16$$16, row, SL("rowcount"), PH_NOISY | PH_READONLY, "phalcon/paginator/adapter/querybuilder.zep", 229 TSRMLS_CC); ZVAL_LONG(rowcount, zephir_get_intval(_16$$16)); } else { ZVAL_LONG(rowcount, 0); } ZEPHIR_SINIT_VAR(_17$$16); div_function(&_17$$16, rowcount, limit TSRMLS_CC); ZEPHIR_SINIT_VAR(_18$$16); ZVAL_DOUBLE(&_18$$16, zephir_ceil(&_17$$16 TSRMLS_CC)); ZEPHIR_INIT_VAR(totalPages); ZVAL_LONG(totalPages, zephir_get_intval(&_18$$16)); } else { ZEPHIR_CALL_METHOD(&result, totalQuery, "execute", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&row, result, "getfirst", NULL, 0); zephir_check_call_status(); if (zephir_is_true(row)) { ZEPHIR_OBS_VAR(_19$$17); zephir_read_property(&_19$$17, row, SL("rowcount"), PH_NOISY_CC); ZEPHIR_INIT_NVAR(rowcount); ZVAL_LONG(rowcount, zephir_get_intval(_19$$17)); } else { ZEPHIR_INIT_NVAR(rowcount); ZVAL_LONG(rowcount, 0); } ZEPHIR_SINIT_VAR(_20$$17); div_function(&_20$$17, rowcount, limit TSRMLS_CC); ZEPHIR_SINIT_VAR(_21$$17); ZVAL_DOUBLE(&_21$$17, zephir_ceil(&_20$$17 TSRMLS_CC)); ZEPHIR_INIT_NVAR(totalPages); ZVAL_LONG(totalPages, zephir_get_intval(&_21$$17)); } 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(_22); ZVAL_LONG(_22, 1); zephir_update_property_zval(page, SL("first"), _22 TSRMLS_CC); ZEPHIR_INIT_ZVAL_NREF(_22); ZVAL_LONG(_22, before); zephir_update_property_zval(page, SL("before"), _22 TSRMLS_CC); ZEPHIR_INIT_ZVAL_NREF(_22); ZVAL_LONG(_22, numberPage); zephir_update_property_zval(page, SL("current"), _22 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); _22 = zephir_fetch_nproperty_this(this_ptr, SL("_limitRows"), PH_NOISY_CC); zephir_update_property_zval(page, SL("limit"), _22 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", 212); return; } ZEPHIR_OBS_VAR(frontend); zephir_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); ZEPHIR_OBS_VAR(redis); zephir_read_property_this(&redis, this_ptr, SL("_redis"), PH_NOISY_CC); if (Z_TYPE_P(redis) != IS_OBJECT) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "_connect", NULL, 0); zephir_check_call_status(); ZEPHIR_OBS_NVAR(redis); zephir_read_property_this(&redis, this_ptr, SL("_redis"), PH_NOISY_CC); } if (Z_TYPE_P(content) == IS_NULL) { ZEPHIR_CALL_METHOD(&cachedContent, frontend, "getcontent", NULL, 0); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(cachedContent, content); } if (!(zephir_is_numeric(cachedContent))) { ZEPHIR_CALL_METHOD(&preparedContent, frontend, "beforestore", NULL, 0, cachedContent); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(preparedContent, cachedContent); } if (Z_TYPE_P(lifetime) == IS_NULL) { ZEPHIR_OBS_VAR(tmp); zephir_read_property_this(&tmp, this_ptr, SL("_lastLifetime"), PH_NOISY_CC); if (!(zephir_is_true(tmp))) { ZEPHIR_CALL_METHOD(&tt1, frontend, "getlifetime", NULL, 0); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(tt1, tmp); } } else { ZEPHIR_CPY_WRT(tt1, lifetime); } ZEPHIR_CALL_METHOD(&success, redis, "set", NULL, 0, lastKey, preparedContent); zephir_check_call_status(); if (!(zephir_is_true(success))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Failed storing the data in redis", "phalcon/cache/backend/redis.zep", 256); return; } if (ZEPHIR_GE_LONG(tt1, 1)) { ZEPHIR_CALL_METHOD(NULL, redis, "settimeout", NULL, 0, lastKey, tt1); zephir_check_call_status(); } ZEPHIR_OBS_VAR(options); zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC); ZEPHIR_OBS_VAR(specialKey); if (!(zephir_array_isset_string_fetch(&specialKey, options, SS("statsKey"), 0 TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/redis.zep", 267); return; } if (!ZEPHIR_IS_STRING(specialKey, "")) { ZEPHIR_CALL_METHOD(NULL, redis, "sadd", NULL, 0, specialKey, prefixedKey); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(&isBuffering, frontend, "isbuffering", NULL, 0); zephir_check_call_status(); if (stopBuffer == 1) { ZEPHIR_CALL_METHOD(NULL, frontend, "stop", NULL, 0); zephir_check_call_status(); } if (ZEPHIR_IS_TRUE_IDENTICAL(isBuffering)) { zend_print_zval(cachedContent, 0); } if (0) { zephir_update_property_this(getThis(), SL("_started"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC); } else { zephir_update_property_this(getThis(), SL("_started"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC); } RETURN_CCTOR(success); }
/** * Handles routing information received from command-line arguments * * @param array arguments */ PHP_METHOD(Phalcon_Cli_Router, handle) { zephir_fcall_cache_entry *_18 = NULL; zval *_15 = NULL; zval *_5 = NULL, *_10 = NULL; int ZEPHIR_LAST_CALL_STATUS; HashTable *_3, *_7; HashPosition _2, _6; zend_bool _0; zval *arguments = NULL, *moduleName = NULL, *taskName = NULL, *actionName = NULL, *params = NULL, *route = NULL, *parts = NULL, *pattern = NULL, *routeFound = NULL, *matches, *paths = NULL, *beforeMatch = NULL, *converters = NULL, *converter = NULL, *part = NULL, *position = NULL, *matchPosition = NULL, *strParams, *_1, **_4, **_8, *_9 = NULL, *_11, *_12, *_13, *_14, _16, *_17 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &arguments); if (!arguments) { arguments = ZEPHIR_GLOBAL(global_null); } ZEPHIR_INIT_VAR(routeFound); ZVAL_BOOL(routeFound, 0); ZEPHIR_INIT_VAR(parts); array_init(parts); ZEPHIR_INIT_VAR(params); array_init(params); ZEPHIR_INIT_VAR(matches); ZVAL_NULL(matches); zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_matchedRoute"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC); if (Z_TYPE_P(arguments) != IS_ARRAY) { _0 = Z_TYPE_P(arguments) != IS_STRING; if (_0) { _0 = Z_TYPE_P(arguments) != IS_NULL; } if (_0) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_router_exception_ce, "Arguments must be an array or string", "phalcon/cli/router.zep", 204); return; } _1 = zephir_fetch_nproperty_this(this_ptr, SL("_routes"), PH_NOISY_CC); zephir_is_iterable(_1, &_3, &_2, 0, 1, "phalcon/cli/router.zep", 304); for ( ; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS ; zephir_hash_move_backwards_ex(_3, &_2) ) { ZEPHIR_GET_HVALUE(route, _4); ZEPHIR_CALL_METHOD(&pattern, route, "getcompiledpattern", NULL, 0); zephir_check_call_status(); if (zephir_memnstr_str(pattern, SL("^"), "phalcon/cli/router.zep", 214)) { ZEPHIR_INIT_NVAR(routeFound); zephir_preg_match(routeFound, pattern, arguments, matches, 0, 0 , 0 TSRMLS_CC); } else { ZEPHIR_INIT_NVAR(routeFound); ZVAL_BOOL(routeFound, ZEPHIR_IS_EQUAL(pattern, arguments)); } if (zephir_is_true(routeFound)) { ZEPHIR_CALL_METHOD(&beforeMatch, route, "getbeforematch", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(beforeMatch) != IS_NULL) { if (!(zephir_is_callable(beforeMatch TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_router_exception_ce, "Before-Match callback is not callable in matched route", "phalcon/cli/router.zep", 232); return; } ZEPHIR_INIT_NVAR(_5); zephir_create_array(_5, 3, 0 TSRMLS_CC); zephir_array_fast_append(_5, arguments); zephir_array_fast_append(_5, route); zephir_array_fast_append(_5, this_ptr); ZEPHIR_INIT_NVAR(routeFound); ZEPHIR_CALL_USER_FUNC_ARRAY(routeFound, beforeMatch, _5); zephir_check_call_status(); } } if (zephir_is_true(routeFound)) { ZEPHIR_CALL_METHOD(&paths, route, "getpaths", NULL, 0); zephir_check_call_status(); ZEPHIR_CPY_WRT(parts, paths); if (Z_TYPE_P(matches) == IS_ARRAY) { ZEPHIR_CALL_METHOD(&converters, route, "getconverters", NULL, 0); zephir_check_call_status(); zephir_is_iterable(paths, &_7, &_6, 0, 0, "phalcon/cli/router.zep", 293); for ( ; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS ; zephir_hash_move_forward_ex(_7, &_6) ) { ZEPHIR_GET_HMKEY(part, _7, _6); ZEPHIR_GET_HVALUE(position, _8); ZEPHIR_OBS_NVAR(matchPosition); if (zephir_array_isset_fetch(&matchPosition, matches, position, 0 TSRMLS_CC)) { if (Z_TYPE_P(converters) == IS_ARRAY) { ZEPHIR_OBS_NVAR(converter); if (zephir_array_isset_fetch(&converter, converters, part, 0 TSRMLS_CC)) { ZEPHIR_INIT_NVAR(_9); ZEPHIR_INIT_NVAR(_5); zephir_create_array(_5, 1, 0 TSRMLS_CC); zephir_array_fast_append(_5, matchPosition); ZEPHIR_CALL_USER_FUNC_ARRAY(_9, converter, _5); zephir_check_call_status(); zephir_array_update_zval(&parts, part, &_9, PH_COPY | PH_SEPARATE); continue; } } zephir_array_update_zval(&parts, part, &matchPosition, PH_COPY | PH_SEPARATE); } else { if (Z_TYPE_P(converters) == IS_ARRAY) { ZEPHIR_OBS_NVAR(converter); if (zephir_array_isset_fetch(&converter, converters, part, 0 TSRMLS_CC)) { ZEPHIR_INIT_NVAR(_9); ZEPHIR_INIT_NVAR(_10); zephir_create_array(_10, 1, 0 TSRMLS_CC); zephir_array_fast_append(_10, position); ZEPHIR_CALL_USER_FUNC_ARRAY(_9, converter, _10); zephir_check_call_status(); zephir_array_update_zval(&parts, part, &_9, PH_COPY | PH_SEPARATE); } } } } zephir_update_property_this(this_ptr, SL("_matches"), matches TSRMLS_CC); } zephir_update_property_this(this_ptr, SL("_matchedRoute"), route TSRMLS_CC); break; } } if (zephir_is_true(routeFound)) { zephir_update_property_this(this_ptr, SL("_wasMatched"), (1) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC); } else { zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC); _11 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultModule"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_module"), _11 TSRMLS_CC); _12 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultTask"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_task"), _12 TSRMLS_CC); _13 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAction"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_action"), _13 TSRMLS_CC); _14 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultParams"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_params"), _14 TSRMLS_CC); RETURN_THIS(); } } else { ZEPHIR_CPY_WRT(parts, arguments); } ZEPHIR_INIT_VAR(moduleName); ZVAL_NULL(moduleName); ZEPHIR_INIT_VAR(taskName); ZVAL_NULL(taskName); ZEPHIR_INIT_VAR(actionName); ZVAL_NULL(actionName); ZEPHIR_OBS_NVAR(moduleName); if (zephir_array_isset_string_fetch(&moduleName, parts, SS("module"), 0 TSRMLS_CC)) { zephir_array_unset_string(&parts, SS("module"), PH_SEPARATE); } else { ZEPHIR_OBS_NVAR(moduleName); zephir_read_property_this(&moduleName, this_ptr, SL("_defaultModule"), PH_NOISY_CC); } ZEPHIR_OBS_NVAR(taskName); if (zephir_array_isset_string_fetch(&taskName, parts, SS("task"), 0 TSRMLS_CC)) { zephir_array_unset_string(&parts, SS("task"), PH_SEPARATE); } else { ZEPHIR_OBS_NVAR(taskName); zephir_read_property_this(&taskName, this_ptr, SL("_defaultTask"), PH_NOISY_CC); } ZEPHIR_OBS_NVAR(actionName); if (zephir_array_isset_string_fetch(&actionName, parts, SS("action"), 0 TSRMLS_CC)) { zephir_array_unset_string(&parts, SS("action"), PH_SEPARATE); } else { ZEPHIR_OBS_NVAR(actionName); zephir_read_property_this(&actionName, this_ptr, SL("_defaultAction"), PH_NOISY_CC); } if (zephir_is_true(routeFound)) { ZEPHIR_OBS_NVAR(params); if (zephir_array_isset_string_fetch(¶ms, parts, SS("params"), 0 TSRMLS_CC)) { if (Z_TYPE_P(params) != IS_ARRAY) { zephir_get_strval(_15, params); ZEPHIR_SINIT_VAR(_16); ZVAL_LONG(&_16, 1); ZEPHIR_INIT_VAR(strParams); zephir_substr(strParams, _15, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); if (zephir_is_true(strParams)) { ZEPHIR_CALL_CE_STATIC(&_17, phalcon_cli_router_route_ce, "getdelimiter", &_18, 121); zephir_check_call_status(); ZEPHIR_INIT_NVAR(params); zephir_fast_explode(params, _17, strParams, LONG_MAX TSRMLS_CC); } else { ZEPHIR_INIT_NVAR(params); array_init(params); } } zephir_array_unset_string(&parts, SS("params"), PH_SEPARATE); } if (zephir_fast_count_int(params TSRMLS_CC)) { ZEPHIR_INIT_NVAR(_9); zephir_fast_array_merge(_9, &(params), &(parts) TSRMLS_CC); ZEPHIR_CPY_WRT(params, _9); } else { ZEPHIR_CPY_WRT(params, parts); } } else { ZEPHIR_CPY_WRT(params, parts); } zephir_update_property_this(this_ptr, SL("_module"), moduleName TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_task"), taskName TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_action"), actionName TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_params"), params TSRMLS_CC); ZEPHIR_MM_RESTORE(); }