/**
* Initializes the session bag. This method must not be called directly, the
* class calls it when its internal data is accessed
*/
PHP_METHOD(Phalcon_Session_Bag, initialize) {
zval *session = NULL, *dependencyInjector = NULL, *data = NULL, *_2, *_1$$3;
zend_long ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_0 = NULL;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(session);
zephir_read_property_this(&session, this_ptr, SL("_session"), PH_NOISY_CC);
if (Z_TYPE_P(session) != IS_OBJECT) {
ZEPHIR_OBS_VAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_CALL_CE_STATIC(&dependencyInjector, phalcon_di_ce, "getdefault", &_0, 1);
zephir_check_call_status();
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_session_exception_ce, "A dependency injection object is required to access the 'session' service", "phalcon/session/bag.zep", 91);
return;
}
}
ZEPHIR_INIT_VAR(_1$$3);
ZVAL_STRING(_1$$3, "session", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&session, dependencyInjector, "getshared", NULL, 0, _1$$3);
zephir_check_temp_parameter(_1$$3);
zephir_check_call_status();
zephir_update_property_this(getThis(), SL("_session"), session TSRMLS_CC);
}
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_name"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&data, session, "get", NULL, 0, _2);
zephir_check_call_status();
if (Z_TYPE_P(data) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(data);
array_init(data);
}
zephir_update_property_this(getThis(), SL("_data"), data TSRMLS_CC);
if (1) {
zephir_update_property_this(getThis(), SL("_initialized"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(getThis(), SL("_initialized"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
ZEPHIR_MM_RESTORE();
}
/**
* @param \Ouchbase\Entity entity
* @param string|null cas
* @throws \Ouchbase\Exception\EntityLogicException
* @return this
*/
PHP_METHOD(Ouchbase_UnitOfWork, persist) {
zval *_5;
int ZEPHIR_LAST_CALL_STATUS;
zephir_nts_static zephir_fcall_cache_entry *_2 = NULL;
zval *entity, *cas = NULL, *_0, *_1 = NULL, *_3, *_4, *_6 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &entity, &cas);
if (!cas) {
cas = ZEPHIR_GLOBAL(global_null);
}
if (!(zephir_instance_of_ev(entity, ouchbase_entity_ce TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'entity' must be an instance of 'Ouchbase\\Entity'", "", 0);
return;
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("deleted"), PH_NOISY_CC);
ZEPHIR_CALL_CE_STATIC(&_1, ouchbase__etc_ce, "getentityhash", &_2, entity);
zephir_check_call_status();
if (zephir_array_isset(_0, _1)) {
ZEPHIR_INIT_VAR(_3);
object_init_ex(_3, ouchbase_exception_entitylogicexception_ce);
ZEPHIR_INIT_VAR(_4);
ZVAL_STRING(_4, "was marked as deleted", 0);
ZEPHIR_CALL_METHOD(NULL, _3, "__construct", NULL, entity, _4);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_throw_exception_debug(_3, "ouchbase/UnitOfWork.zep", 49 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_INIT_VAR(_5);
array_init_size(_5, 3);
zephir_array_fast_append(_5, entity);
zephir_array_fast_append(_5, cas);
ZEPHIR_CALL_CE_STATIC(&_6, ouchbase__etc_ce, "getentityhash", &_2, entity);
zephir_check_call_status();
zephir_update_property_array(this_ptr, SL("persisted"), _6, _5 TSRMLS_CC);
RETURN_THIS();
}
/**
* Constructor.
*/
PHP_METHOD(Xpl_HtmlElement, __construct) {
zval *_0, *_1 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "div", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "settag", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_1, this_ptr, "getdefaultattributes", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, this_ptr, "setattributes", NULL, 0, _1);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Simply closes the connection.
*/
PHP_METHOD(Phalcon_Queue_Beanstalk, quit) {
zval *_0, *_1;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "quit", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "write", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, this_ptr, "disconnect", NULL, 0);
zephir_check_call_status();
ZEPHIR_OBS_VAR(_1);
zephir_read_property_this(&_1, this_ptr, SL("_connection"), PH_NOISY_CC);
RETURN_MM_BOOL(Z_TYPE_P(_1) != IS_RESOURCE);
}
PHP_METHOD(Test_Exceptions, testException5) {
int ZEPHIR_LAST_CALL_STATUS;
zval *exception, *_0;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(exception);
object_init_ex(exception, test_exception_ce);
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "hello5", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, exception, "__construct", NULL, 28, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
zephir_throw_exception_debug(exception, "test/exceptions.zep", 46 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
/**
* Phalcon\Assets\Inline\Css
*
* @param string content
* @param boolean filter
* @param array attributes
*/
PHP_METHOD(Phalcon_Assets_Inline_Css, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_0 = NULL;
zend_bool filter;
zval *content_param = NULL, *filter_param = NULL, *attributes = NULL, *_1, *_2;
zval *content = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &content_param, &filter_param, &attributes);
zephir_get_strval(content, content_param);
if (!filter_param) {
filter = 1;
} else {
filter = zephir_get_boolval(filter_param);
}
if (!attributes) {
ZEPHIR_CPY_WRT(attributes, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(attributes);
}
if (Z_TYPE_P(attributes) == IS_NULL) {
ZEPHIR_INIT_NVAR(attributes);
zephir_create_array(attributes, 1, 0 TSRMLS_CC);
add_assoc_stringl_ex(attributes, SS("type"), SL("text/css"), 1);
}
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "css", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_2);
if (filter) {
ZVAL_BOOL(_2, 1);
} else {
ZVAL_BOOL(_2, 0);
}
ZEPHIR_CALL_PARENT(NULL, phalcon_assets_inline_css_ce, this_ptr, "__construct", &_0, 104, _1, content, _2, attributes);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Retrieve the language
* @return string
*/
PHP_METHOD(Yaf_Request_Abstract, getLanguage) {
int ZEPHIR_LAST_CALL_STATUS;
zval *_0, *_1 = NULL, *_2;
ZEPHIR_MM_GROW();
_0 = zephir_fetch_nproperty_this(this_ptr, SL("language"), PH_NOISY_CC);
if (Z_TYPE_P(_0) == IS_NULL) {
ZEPHIR_INIT_VAR(_2);
ZVAL_STRING(_2, "HTTP_ACCEPT_LANGUAGE", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_1, this_ptr, "getenv", NULL, _2);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("language"), _1 TSRMLS_CC);
}
RETURN_MM_MEMBER(this_ptr, "language");
}
PHP_METHOD(PhalconPlus_RPC_Client_Adapter_Local, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zval *di, *_0 = NULL, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &di);
zephir_update_property_this(this_ptr, SL("di"), di TSRMLS_CC);
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "config", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0, di, "get", NULL, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("config"), _0 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Shows a HTML success message
*
*<code>
* $flash->success('The process was finished successfully');
*</code>
*/
PHP_METHOD(Phalcon_Flash, success) {
int ZEPHIR_LAST_CALL_STATUS;
zval *message_param = NULL, *_0;
zval *message = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &message_param);
zephir_get_strval(message, message_param);
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "success", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "message", NULL, 0, _0, message);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
RETURN_MM();
}
/**
* @param \Ouchbase\Entity entity
* @return this
*/
PHP_METHOD(Ouchbase_Repository, insert) {
zval *_0;
int ZEPHIR_LAST_CALL_STATUS;
zval *entity, *data = NULL, *_1 = NULL, *_2 = NULL, *_3, *_4, *_5;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &entity);
if (!(zephir_instance_of_ev(entity, ouchbase_entity_ce TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'entity' must be an instance of 'Ouchbase\\Entity'", "", 0);
return;
}
ZEPHIR_CALL_METHOD(&data, this_ptr, "toarray", NULL, entity);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_0);
array_init_size(_0, 3);
ZEPHIR_CALL_METHOD(&_2, entity, "getid", NULL);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_1, this_ptr, "getkey", NULL, _2);
zephir_check_call_status();
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_VAR(_3);
zephir_json_encode(_3, &(_3), data, 0 TSRMLS_CC);
zephir_array_fast_append(_0, _3);
ZEPHIR_INIT_BNVAR(_3);
ZVAL_STRING(_3, "set", 0);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "executewithouttimeouts", NULL, _3, _0);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
_4 = zephir_fetch_nproperty_this(this_ptr, SL("uow"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, _4, "persist", NULL, entity);
zephir_check_call_status();
_5 = zephir_fetch_nproperty_this(this_ptr, SL("im"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, _5, "updateoriginaldata", NULL, entity, data);
zephir_check_call_status();
RETURN_THIS();
}
/**
* @param \Ouchbase\Entity entity
* @return this
* @throws \Ouchbase\Exception\EntityLogicException
*/
PHP_METHOD(Ouchbase_IdentityMap, unregister) {
zend_class_entry *_3;
int ZEPHIR_LAST_CALL_STATUS;
zephir_nts_static zephir_fcall_cache_entry *_0 = NULL;
zval *entity, *hash = NULL, *_1, *_2, *_4, *_5, *_6;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &entity);
if (!(zephir_instance_of_ev(entity, ouchbase_entity_ce TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'entity' must be an instance of 'Ouchbase\\Entity'", "", 0);
return;
}
ZEPHIR_CALL_CE_STATIC(&hash, ouchbase__etc_ce, "getentityhash", &_0, entity);
zephir_check_call_status();
_1 = zephir_fetch_nproperty_this(this_ptr, SL("entities"), PH_NOISY_CC);
if (!(zephir_array_isset(_1, hash))) {
ZEPHIR_INIT_VAR(_2);
_3 = zend_fetch_class(SL("Ouchbase\\EntityLogicException"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(_2, _3);
if (zephir_has_constructor(_2 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(_4);
ZVAL_STRING(_4, "is not registered in the identity map", 0);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", NULL, entity, _4);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
}
zephir_throw_exception_debug(_2, "ouchbase/IdentityMap.zep", 51 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
_5 = zephir_fetch_nproperty_this(this_ptr, SL("entities"), PH_NOISY_CC);
zephir_array_unset(&_5, hash, PH_SEPARATE);
_6 = zephir_fetch_nproperty_this(this_ptr, SL("originalData"), PH_NOISY_CC);
zephir_array_unset(&_6, hash, PH_SEPARATE);
RETURN_THIS();
}
/**
* Adds a route to the router that only match if the HTTP method is HEAD
*
* @param string pattern
* @param string/array paths
* @return Test\Router\Route
*/
PHP_METHOD(Test_Router, addHead) {
int ZEPHIR_LAST_CALL_STATUS;
zval *pattern, *paths = NULL, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &pattern, &paths);
if (!paths) {
paths = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "HEAD", 0);
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "add", NULL, pattern, paths, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
RETURN_MM();
}
/**
* Compare strings
*/
PHP_METHOD(Phalcon_Validation_Validator_Confirmation, compare) {
zephir_fcall_cache_entry *_5 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *a_param = NULL, *b_param = NULL, *_0 = NULL, *_1, *_2, _3$$3 = zval_used_for_init, *_4$$3 = NULL, *_6$$3 = NULL;
zval *a = NULL, *b = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &a_param, &b_param);
zephir_get_strval(a, a_param);
zephir_get_strval(b, b_param);
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "ignoreCase", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_2);
ZVAL_BOOL(_2, 0);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "getoption", NULL, 0, _1, _2);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (zephir_is_true(_0)) {
if (!((zephir_function_exists_ex(SS("mb_strtolower") TSRMLS_CC) == SUCCESS))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Extension 'mbstring' is required", "phalcon/validation/validator/confirmation.zep", 122);
return;
}
ZEPHIR_SINIT_VAR(_3$$3);
ZVAL_STRING(&_3$$3, "utf-8", 0);
ZEPHIR_CALL_FUNCTION(&_4$$3, "mb_strtolower", &_5, 200, a, &_3$$3);
zephir_check_call_status();
zephir_get_strval(a, _4$$3);
ZEPHIR_SINIT_NVAR(_3$$3);
ZVAL_STRING(&_3$$3, "utf-8", 0);
ZEPHIR_CALL_FUNCTION(&_6$$3, "mb_strtolower", &_5, 200, b, &_3$$3);
zephir_check_call_status();
zephir_get_strval(b, _6$$3);
}
RETURN_MM_BOOL(ZEPHIR_IS_EQUAL(a, b));
}
/**
* Sets Cache headers to use HTTP cache
*
*<code>
* $this->response->setCache(60);
*</code>
*/
PHP_METHOD(Phalcon_Http_Response, setCache) {
zval *_1, *_3;
zval *minutes_param = NULL, *date, _0, _2, *_4;
int minutes, ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &minutes_param);
if (unlikely(Z_TYPE_P(minutes_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'minutes' must be a int") TSRMLS_CC);
RETURN_MM_NULL();
}
minutes = Z_LVAL_P(minutes_param);
ZEPHIR_INIT_VAR(date);
object_init_ex(date, php_date_get_date_ce());
ZEPHIR_CALL_METHOD(NULL, date, "__construct", NULL, 0);
zephir_check_call_status();
ZEPHIR_SINIT_VAR(_0);
ZVAL_LONG(&_0, minutes);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SVS(_1, "+", &_0, " minutes");
ZEPHIR_CALL_METHOD(NULL, date, "modify", NULL, 0, _1);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, this_ptr, "setexpires", NULL, 0, date);
zephir_check_call_status();
ZEPHIR_SINIT_VAR(_2);
ZVAL_LONG(&_2, ((minutes * 60)));
ZEPHIR_INIT_VAR(_3);
ZEPHIR_CONCAT_SV(_3, "max-age=", &_2);
ZEPHIR_INIT_VAR(_4);
ZVAL_STRING(_4, "Cache-Control", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "setheader", NULL, 0, _4, _3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
RETURN_THIS();
}
PHP_METHOD(Yb_Std, outputScript) {
int ZEPHIR_LAST_CALL_STATUS;
zval *data = NULL;
zval *path_param = NULL, *data_param = NULL, *_0$$3, *_2, *_3;
zval *path = NULL, *_1$$3;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &path_param, &data_param);
zephir_get_strval(path, path_param);
zephir_get_arrval(data, data_param);
if (unlikely(!((zephir_file_exists(path TSRMLS_CC) == SUCCESS)))) {
ZEPHIR_INIT_VAR(_0$$3);
object_init_ex(_0$$3, yb_exception_ce);
ZEPHIR_INIT_VAR(_1$$3);
ZEPHIR_CONCAT_SV(_1$$3, "Cannot find script path: ", path);
ZEPHIR_CALL_METHOD(NULL, _0$$3, "__construct", NULL, 2, _1$$3);
zephir_check_call_status();
zephir_throw_exception_debug(_0$$3, "yb/std.zep", 423 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_INIT_VAR(_2);
ZVAL_LONG(_2, 4);
ZEPHIR_INIT_VAR(_3);
ZVAL_STRING(_3, "", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_MAKE_REF(data);
ZEPHIR_CALL_FUNCTION(NULL, "extract", NULL, 81, data, _2, _3);
zephir_check_temp_parameter(_3);
ZEPHIR_UNREF(data);
zephir_check_call_status();
if (zephir_require_zval(path TSRMLS_CC) == FAILURE) {
RETURN_MM_NULL();
}
ZEPHIR_MM_RESTORE();
}
/**
* Sets action params to be dispatched
*
* @param array params
*/
PHP_METHOD(Phalcon_Dispatcher, setParams) {
int ZEPHIR_LAST_CALL_STATUS;
zval *params, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, ¶ms);
if (Z_TYPE_P(params) != IS_ARRAY) {
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "Parameters must be an Array", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_throwdispatchexception", NULL, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
RETURN_MM_NULL();
}
zephir_update_property_this(this_ptr, SL("_params"), params TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Get list of a tubes.
*/
PHP_METHOD(Phalcon_Queue_Beanstalk, listTubes) {
zval *response = NULL, *_0, *_1, *_2;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "list-tubes", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "write", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&response, this_ptr, "readyaml", NULL, 384);
zephir_check_call_status();
zephir_array_fetch_long(&_1, response, 0, PH_NOISY | PH_READONLY, "phalcon/queue/beanstalk.zep", 266 TSRMLS_CC);
if (!ZEPHIR_IS_STRING(_1, "OK")) {
RETURN_MM_BOOL(0);
}
zephir_array_fetch_long(&_2, response, 2, PH_NOISY | PH_READONLY, "phalcon/queue/beanstalk.zep", 270 TSRMLS_CC);
RETURN_CTOR(_2);
}
/**
* Returns the connection related to transaction
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction, getConnection) {
zval *_0, *_1$$3 = NULL, *_2$$4;
zend_long ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_rollbackOnAbort"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
ZEPHIR_CALL_FUNCTION(&_1$$3, "connection_aborted", NULL, 393);
zephir_check_call_status();
if (zephir_is_true(_1$$3)) {
ZEPHIR_INIT_VAR(_2$$4);
ZVAL_STRING(_2$$4, "The request was aborted", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "rollback", NULL, 0, _2$$4);
zephir_check_temp_parameter(_2$$4);
zephir_check_call_status();
}
}
RETURN_MM_MEMBER(getThis(), "_connection");
}
/**
* Set a custom ETag
*
*<code>
* $response->setEtag(md5(time()));
*</code>
*/
PHP_METHOD(Phalcon_Http_Response, setEtag) {
int ZEPHIR_LAST_CALL_STATUS;
zval *etag_param = NULL, *headers = NULL, *_0;
zval *etag = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &etag_param);
zephir_get_strval(etag, etag_param);
ZEPHIR_CALL_METHOD(&headers, this_ptr, "getheaders", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "Etag", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, headers, "set", NULL, 0, _0, etag);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
RETURN_THIS();
}
/**
* Adds a route to the router that only match if the HTTP method is HEAD
*
* @param string pattern
* @param string/array paths
* @return Phalcon\Mvc\Router\Route
*/
PHP_METHOD(Phalcon_Mvc_Router_Group, addHead) {
int ZEPHIR_LAST_CALL_STATUS;
zval *pattern_param = NULL, *paths = NULL, *_0;
zval *pattern = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &pattern_param, &paths);
zephir_get_strval(pattern, pattern_param);
if (!paths) {
paths = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "HEAD", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "_addroute", NULL, pattern, paths, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
RETURN_MM();
}
/**
* Phalcon\Mvc\Model\Transaction constructor
*
* @param \Phalcon\DiInterface $ependencyInjector
* @param boolean autoBegin
* @param string service
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zend_bool autoBegin;
zval *dependencyInjector, *autoBegin_param = NULL, *service = NULL, *connection = NULL, *_0$$4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &dependencyInjector, &autoBegin_param, &service);
if (!autoBegin_param) {
autoBegin = 0;
} else {
autoBegin = zephir_get_boolval(autoBegin_param);
}
if (!service) {
service = ZEPHIR_GLOBAL(global_null);
}
if (zephir_is_true(service)) {
ZEPHIR_CALL_METHOD(&connection, dependencyInjector, "get", NULL, 0, service);
zephir_check_call_status();
} else {
ZEPHIR_INIT_VAR(_0$$4);
ZVAL_STRING(_0$$4, "db", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&connection, dependencyInjector, "get", NULL, 0, _0$$4);
zephir_check_temp_parameter(_0$$4);
zephir_check_call_status();
}
zephir_update_property_this(this_ptr, SL("_connection"), connection TSRMLS_CC);
if (autoBegin) {
ZEPHIR_CALL_METHOD(NULL, connection, "begin", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_MM_RESTORE();
}
/**
* Adds a route to the router that only match if the HTTP method is PUT
*/
PHP_METHOD(Phalcon_Mvc_Router, addPut) {
int ZEPHIR_LAST_CALL_STATUS;
zval *pattern_param = NULL, *paths = NULL, *position = NULL, *_0;
zval *pattern = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &pattern_param, &paths, &position);
if (unlikely(Z_TYPE_P(pattern_param) != IS_STRING && Z_TYPE_P(pattern_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'pattern' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(pattern_param) == IS_STRING)) {
zephir_get_strval(pattern, pattern_param);
} else {
ZEPHIR_INIT_VAR(pattern);
ZVAL_EMPTY_STRING(pattern);
}
if (!paths) {
paths = ZEPHIR_GLOBAL(global_null);
}
if (!position) {
ZEPHIR_INIT_VAR(position);
ZVAL_LONG(position, 1);
}
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "PUT", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "add", NULL, 0, pattern, paths, _0, position);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
RETURN_MM();
}
/**
* Returns an HTML string of information about a single variable.
*
* <code>
* echo (new \Phalcon\Debug\Dump())->variable($foo, "foo");
* </code>
*/
PHP_METHOD(Phalcon_Debug_Dump, variable) {
zval *_0;
int ZEPHIR_LAST_CALL_STATUS;
zval *name = NULL;
zval *variable, *name_param = NULL, *_1 = NULL, *_2, _3;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &variable, &name_param);
if (!name_param) {
ZEPHIR_INIT_VAR(name);
ZVAL_EMPTY_STRING(name);
} else {
zephir_get_strval(name, name_param);
}
ZEPHIR_INIT_VAR(_0);
zephir_create_array(_0, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_2);
ZVAL_STRING(_2, "pre", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_1, this_ptr, "getstyle", NULL, 0, _2);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
zephir_array_update_string(&_0, SL(":style"), &_1, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(&_1, this_ptr, "output", NULL, 0, variable, name);
zephir_check_call_status();
zephir_array_update_string(&_0, SL(":output"), &_1, PH_COPY | PH_SEPARATE);
ZEPHIR_SINIT_VAR(_3);
ZVAL_STRING(&_3, "<pre style=':style'>:output</pre>", 0);
ZEPHIR_RETURN_CALL_FUNCTION("strtr", NULL, 26, &_3, _0);
zephir_check_call_status();
RETURN_MM();
}
PHP_METHOD(Test_Pregmatch, testMatchAll) {
int ZEPHIR_LAST_CALL_STATUS;
zval *flags, *text, *matches, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &flags);
ZEPHIR_INIT_VAR(matches);
array_init(matches);
ZEPHIR_INIT_VAR(text);
ZVAL_STRING(text, "test1,test2", 1);
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "/(test[0-9]+)/", ZEPHIR_TEMP_PARAM_COPY);
Z_SET_ISREF_P(matches);
ZEPHIR_CALL_FUNCTION(NULL, "preg_match_all", NULL, 50, _0, text, matches, flags);
zephir_check_temp_parameter(_0);
Z_UNSET_ISREF_P(matches);
zephir_check_call_status();
RETURN_CCTOR(matches);
}
/**
* Initializes the class. It assigns the attributes that can be obtained and modified.
*/
PHP_METHOD(Phady_Security_Core_Models_Entities_Resources, init) {
zval *_1, *_2 = NULL, *_3 = NULL, *_4 = NULL, *_6;
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_0 = NULL, *_5 = NULL;
ZEPHIR_MM_GROW();
ZEPHIR_CALL_PARENT(NULL, phady_security_core_models_entities_resources_ce, this_ptr, "init", &_0, 56);
zephir_check_call_status();
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_set"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_2);
ZVAL_STRING(_2, "resource_id", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_3);
ZVAL_STRING(_3, "module_id", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_4);
ZVAL_STRING(_4, "name", ZEPHIR_TEMP_PARAM_COPY);
Z_SET_ISREF_P(_1);
ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_5, 57, _1, _2, _3, _4);
zephir_check_temp_parameter(_2);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
Z_UNSET_ISREF_P(_1);
zephir_check_call_status();
_6 = zephir_fetch_nproperty_this(this_ptr, SL("_get"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "resource_id", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "module_id", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "name", ZEPHIR_TEMP_PARAM_COPY);
Z_SET_ISREF_P(_6);
ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_5, 57, _6, _2, _3, _4);
zephir_check_temp_parameter(_2);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
Z_UNSET_ISREF_P(_6);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Executes the validator
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator_StringLength, validate) {
zval *_6$$9, *_11$$12;
zend_bool _1, _3;
zephir_fcall_cache_entry *_8 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *record, *field = NULL, *isSetMin = NULL, *isSetMax = NULL, *value = NULL, *length = NULL, *maximum = NULL, *minimum = NULL, *message = NULL, *_0 = NULL, *_2 = NULL, *_4$$8, *_5$$9 = NULL, *_7$$9 = NULL, *_9$$11, *_10$$12 = NULL, *_12$$12 = 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/stringlength.zep", 67);
return;
}
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "min", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&isSetMin, this_ptr, "issetoption", NULL, 0, _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, _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_mvc_model_exception_ce, "A minimum or maximum must be set", "phalcon/mvc/model/validator/stringlength.zep", 77);
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(&_2, this_ptr, "issetoption", NULL, 0, _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);
}
if ((zephir_function_exists_ex(SS("mb_strlen") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_FUNCTION(&length, "mb_strlen", NULL, 357, 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_VAR(_4$$8);
ZVAL_STRING(_4$$8, "max", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&maximum, this_ptr, "getoption", NULL, 0, _4$$8);
zephir_check_temp_parameter(_4$$8);
zephir_check_call_status();
if (ZEPHIR_GT(length, maximum)) {
ZEPHIR_INIT_VAR(_5$$9);
ZVAL_STRING(_5$$9, "messageMaximum", 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 (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(message);
ZVAL_STRING(message, "Value of field ':field' exceeds the maximum :max characters", 1);
}
ZEPHIR_INIT_VAR(_6$$9);
zephir_create_array(_6$$9, 2, 0 TSRMLS_CC);
zephir_array_update_string(&_6$$9, SL(":field"), &field, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_6$$9, SL(":max"), &maximum, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_FUNCTION(&_7$$9, "strtr", &_8, 55, message, _6$$9);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_5$$9);
ZVAL_STRING(_5$$9, "TooLong", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "appendmessage", NULL, 0, _7$$9, field, _5$$9);
zephir_check_temp_parameter(_5$$9);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
if (zephir_is_true(isSetMin)) {
ZEPHIR_INIT_VAR(_9$$11);
ZVAL_STRING(_9$$11, "min", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&minimum, this_ptr, "getoption", NULL, 0, _9$$11);
zephir_check_temp_parameter(_9$$11);
zephir_check_call_status();
if (ZEPHIR_LT(length, minimum)) {
ZEPHIR_INIT_VAR(_10$$12);
ZVAL_STRING(_10$$12, "messageMinimum", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _10$$12);
zephir_check_temp_parameter(_10$$12);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(message);
ZVAL_STRING(message, "Value of field ':field' is less than the minimum :min characters", 1);
}
ZEPHIR_INIT_VAR(_11$$12);
zephir_create_array(_11$$12, 2, 0 TSRMLS_CC);
zephir_array_update_string(&_11$$12, SL(":field"), &field, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_11$$12, SL(":min"), &minimum, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_FUNCTION(&_12$$12, "strtr", &_8, 55, message, _11$$12);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_10$$12);
ZVAL_STRING(_10$$12, "TooShort", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "appendmessage", NULL, 0, _12$$12, field, _10$$12);
zephir_check_temp_parameter(_10$$12);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
RETURN_MM_BOOL(1);
}
/**
* 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", 74);
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", 82 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", 86);
return;
}
}
ZEPHIR_CALL_FUNCTION(&_4, "in_array", NULL, 376, 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", 97 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", 105 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", 114 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, 462, _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);
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_PresenceOf, validate) {
zend_bool _0;
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *value = NULL, *message = NULL, *label = NULL, *replacePairs = NULL, *code = NULL, *_1$$3 = NULL, *_6$$3 = NULL, *_7$$3, *_2$$4, *_3$$6, *_4$$7, *_5$$8;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field_param);
if (unlikely(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(field_param) == IS_STRING)) {
zephir_get_strval(field, field_param);
} else {
ZEPHIR_INIT_VAR(field);
ZVAL_EMPTY_STRING(field);
}
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
_0 = Z_TYPE_P(value) == IS_NULL;
if (!(_0)) {
_0 = ZEPHIR_IS_STRING_IDENTICAL(value, "");
}
if (_0) {
ZEPHIR_INIT_VAR(_1$$3);
ZVAL_STRING(_1$$3, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _1$$3);
zephir_check_temp_parameter(_1$$3);
zephir_check_call_status();
if (Z_TYPE_P(label) == IS_ARRAY) {
zephir_array_fetch(&_2$$4, label, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/presenceof.zep", 74 TSRMLS_CC);
ZEPHIR_CPY_WRT(label, _2$$4);
}
if (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_1$$3);
ZVAL_STRING(_1$$3, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _1$$3);
zephir_check_temp_parameter(_1$$3);
zephir_check_call_status();
if (Z_TYPE_P(message) == IS_ARRAY) {
zephir_array_fetch(&_3$$6, message, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/presenceof.zep", 82 TSRMLS_CC);
ZEPHIR_CPY_WRT(message, _3$$6);
}
ZEPHIR_INIT_VAR(replacePairs);
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_VAR(_4$$7);
ZVAL_STRING(_4$$7, "PresenceOf", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _4$$7);
zephir_check_temp_parameter(_4$$7);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_1$$3);
ZVAL_STRING(_1$$3, "code", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&code, this_ptr, "getoption", NULL, 0, _1$$3);
zephir_check_temp_parameter(_1$$3);
zephir_check_call_status();
if (Z_TYPE_P(code) == IS_ARRAY) {
zephir_array_fetch(&_5$$8, code, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/presenceof.zep", 91 TSRMLS_CC);
ZEPHIR_CPY_WRT(code, _5$$8);
}
ZEPHIR_INIT_NVAR(_1$$3);
object_init_ex(_1$$3, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_6$$3, "strtr", NULL, 26, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_7$$3);
ZVAL_STRING(_7$$3, "PresenceOf", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _1$$3, "__construct", NULL, 466, _6$$3, field, _7$$3, code);
zephir_check_temp_parameter(_7$$3);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _1$$3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Internal validations, if it returns true, then skip the current validator
*/
PHP_METHOD(Phalcon_Validation, preChecking) {
HashTable *_1$$3, *_7$$9;
HashPosition _0$$3, _6$$9;
zephir_fcall_cache_entry *_3 = NULL;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *field, *validator, *singleField = NULL, *allowEmpty = NULL, *emptyValue = NULL, *value = NULL, *result = NULL, **_2$$3, *_4$$6, *_5$$6, **_8$$9;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &field, &validator);
if (Z_TYPE_P(field) == IS_ARRAY) {
zephir_is_iterable(field, &_1$$3, &_0$$3, 0, 0, "phalcon/validation.zep", 590);
for (
; zend_hash_get_current_data_ex(_1$$3, (void**) &_2$$3, &_0$$3) == SUCCESS
; zend_hash_move_forward_ex(_1$$3, &_0$$3)
) {
ZEPHIR_GET_HVALUE(singleField, _2$$3);
ZEPHIR_CALL_METHOD(&result, this_ptr, "prechecking", &_3, 469, singleField, validator);
zephir_check_call_status();
if (zephir_is_true(result)) {
RETURN_CCTOR(result);
}
}
} else {
ZEPHIR_INIT_VAR(_4$$6);
ZVAL_STRING(_4$$6, "allowEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_5$$6);
ZVAL_BOOL(_5$$6, 0);
ZEPHIR_CALL_METHOD(&allowEmpty, validator, "getoption", NULL, 0, _4$$6, _5$$6);
zephir_check_temp_parameter(_4$$6);
zephir_check_call_status();
if (zephir_is_true(allowEmpty)) {
if ((zephir_method_exists_ex(validator, SS("isallowempty") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_METHOD(validator, "isallowempty", NULL, 0, this_ptr, field);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_CALL_METHOD(&value, this_ptr, "getvalue", NULL, 0, field);
zephir_check_call_status();
if (Z_TYPE_P(allowEmpty) == IS_ARRAY) {
zephir_is_iterable(allowEmpty, &_7$$9, &_6$$9, 0, 0, "phalcon/validation.zep", 604);
for (
; zend_hash_get_current_data_ex(_7$$9, (void**) &_8$$9, &_6$$9) == SUCCESS
; zend_hash_move_forward_ex(_7$$9, &_6$$9)
) {
ZEPHIR_GET_HVALUE(emptyValue, _8$$9);
if (ZEPHIR_IS_IDENTICAL(emptyValue, value)) {
RETURN_MM_BOOL(1);
}
}
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(ZEPHIR_IS_EMPTY(value));
}
}
RETURN_MM_BOOL(0);
}
/**
* Gets the a value to validate in the array/object data source
*
* @param string field
* @return mixed
*/
PHP_METHOD(Phalcon_Validation, getValue) {
zend_bool _0$$10;
zephir_fcall_cache_entry *_1 = NULL;
zend_long 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, *camelizedField = NULL, *_2$$20, *_3$$20 = NULL, *_4$$28 = NULL;
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(camelizedField);
zephir_camelize(camelizedField, field, NULL );
ZEPHIR_INIT_VAR(method);
ZEPHIR_CONCAT_SV(method, "get", camelizedField);
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);
}
}
}
} else {
ZEPHIR_OBS_VAR(data);
zephir_read_property_this(&data, this_ptr, SL("_data"), PH_NOISY_CC);
_0$$10 = Z_TYPE_P(data) != IS_ARRAY;
if (_0$$10) {
_0$$10 = Z_TYPE_P(data) != IS_OBJECT;
}
if (_0$$10) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "There is no data to validate", "phalcon/validation.zep", 499);
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", 511 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);
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", &_1, 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", 536);
return;
}
}
ZEPHIR_INIT_VAR(_2$$20);
ZVAL_STRING(_2$$20, "filter", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&filterService, dependencyInjector, "getshared", NULL, 0, _2$$20);
zephir_check_temp_parameter(_2$$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", 542);
return;
}
ZEPHIR_CALL_METHOD(&_3$$20, filterService, "sanitize", NULL, 0, value, fieldFilters);
zephir_check_call_status();
ZEPHIR_CPY_WRT(value, _3$$20);
if (Z_TYPE_P(entity) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(method);
ZEPHIR_CONCAT_SV(method, "set", camelizedField);
if ((zephir_method_exists(entity, method TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD_ZVAL(NULL, entity, method, NULL, 0, value);
zephir_check_call_status();
} else {
if ((zephir_method_exists_ex(entity, SS("writeattribute") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(NULL, entity, "writeattribute", NULL, 0, field, value);
zephir_check_call_status();
} else {
ZEPHIR_CALL_FUNCTION(&_4$$28, "property_exists", NULL, 329, entity, field);
zephir_check_call_status();
if (zephir_is_true(_4$$28)) {
zephir_update_property_zval_zval(entity, field, value TSRMLS_CC);
}
}
}
}
RETURN_CCTOR(value);
}
}
if (Z_TYPE_P(entity) != IS_OBJECT) {
zephir_update_property_array(this_ptr, SL("_values"), field, value TSRMLS_CC);
}
RETURN_CCTOR(value);
}
