/**
* Returns the cookie's value
*
* @param string|array filters
* @param string defaultValue
* @return mixed
*/
PHP_METHOD(Phalcon_Http_Cookie, getValue) {
int ZEPHIR_LAST_CALL_STATUS;
zval *filters = NULL, *defaultValue = NULL, *_COOKIE, *dependencyInjector = NULL, *value = NULL, *crypt = NULL, *decryptedValue = NULL, *filter = NULL, *_0, *_1, *_2$$4, *_3$$5, *_4$$6, *_5$$6, *_6$$11, *_7$$10;
ZEPHIR_MM_GROW();
zephir_get_global(&_COOKIE, SS("_COOKIE") TSRMLS_CC);
zephir_fetch_params(1, 0, 2, &filters, &defaultValue);
if (!filters) {
filters = ZEPHIR_GLOBAL(global_null);
}
if (!defaultValue) {
defaultValue = ZEPHIR_GLOBAL(global_null);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_restored"), PH_NOISY_CC);
if (!(zephir_is_true(_0))) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "restore", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_INIT_VAR(dependencyInjector);
ZVAL_NULL(dependencyInjector);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_readed"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_1)) {
ZEPHIR_OBS_VAR(value);
_2$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_name"), PH_NOISY_CC);
if (zephir_array_isset_fetch(&value, _COOKIE, _2$$4, 0 TSRMLS_CC)) {
_3$$5 = zephir_fetch_nproperty_this(this_ptr, SL("_useEncryption"), PH_NOISY_CC);
if (zephir_is_true(_3$$5)) {
_4$$6 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(dependencyInjector, _4$$6);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_http_response_exception_ce, "A dependency injection object is required to access the 'filter' service", "phalcon/http/cookie.zep", 152);
return;
}
ZEPHIR_INIT_VAR(_5$$6);
ZVAL_STRING(_5$$6, "crypt", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&crypt, dependencyInjector, "getshared", NULL, 0, _5$$6);
zephir_check_temp_parameter(_5$$6);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&decryptedValue, crypt, "decryptbase64", NULL, 0, value);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(decryptedValue, value);
}
zephir_update_property_this(this_ptr, SL("_value"), decryptedValue TSRMLS_CC);
if (Z_TYPE_P(filters) != IS_NULL) {
ZEPHIR_OBS_VAR(filter);
zephir_read_property_this(&filter, this_ptr, SL("_filter"), PH_NOISY_CC);
if (Z_TYPE_P(filter) != IS_OBJECT) {
if (Z_TYPE_P(dependencyInjector) == IS_NULL) {
_6$$11 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(dependencyInjector, _6$$11);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_http_response_exception_ce, "A dependency injection object is required to access the 'filter' service", "phalcon/http/cookie.zep", 178);
return;
}
}
ZEPHIR_INIT_VAR(_7$$10);
ZVAL_STRING(_7$$10, "filter", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&filter, dependencyInjector, "getshared", NULL, 0, _7$$10);
zephir_check_temp_parameter(_7$$10);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_filter"), filter TSRMLS_CC);
}
ZEPHIR_RETURN_CALL_METHOD(filter, "sanitize", NULL, 0, decryptedValue, filters);
zephir_check_call_status();
RETURN_MM();
}
RETURN_CCTOR(decryptedValue);
}
RETVAL_ZVAL(defaultValue, 1, 0);
RETURN_MM();
}
RETURN_MM_MEMBER(this_ptr, "_value");
}
/**
* Internal sanitize wrapper to filter_var
*/
PHP_METHOD(Phalcon_Filter, _sanitize) {
zephir_fcall_cache_entry *_5 = NULL;
zval *_2 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zend_bool _1;
zval *filter = NULL, *_8;
zval *value, *filter_param = NULL, *filterObject, *_0, _3 = zval_used_for_init, *_4 = NULL, *_6 = NULL, *_7;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &value, &filter_param);
if (unlikely(Z_TYPE_P(filter_param) != IS_STRING && Z_TYPE_P(filter_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'filter' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(filter_param) == IS_STRING)) {
zephir_get_strval(filter, filter_param);
} else {
ZEPHIR_INIT_VAR(filter);
ZVAL_EMPTY_STRING(filter);
}
ZEPHIR_OBS_VAR(filterObject);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_filters"), PH_NOISY_CC);
if (zephir_array_isset_fetch(&filterObject, _0, filter, 0 TSRMLS_CC)) {
_1 = zephir_instance_of_ev(filterObject, zend_ce_closure TSRMLS_CC);
if (!(_1)) {
_1 = zephir_is_callable(filterObject TSRMLS_CC);
}
if (_1) {
ZEPHIR_INIT_VAR(_2);
zephir_create_array(_2, 1, 0 TSRMLS_CC);
zephir_array_fast_append(_2, value);
ZEPHIR_CALL_USER_FUNC_ARRAY(return_value, filterObject, _2);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_RETURN_CALL_METHOD(filterObject, "filter", NULL, 0, value);
zephir_check_call_status();
RETURN_MM();
}
do {
if (ZEPHIR_IS_STRING(filter, "email")) {
ZEPHIR_SINIT_VAR(_3);
ZVAL_STRING(&_3, "FILTER_SANITIZE_EMAIL", 0);
ZEPHIR_CALL_FUNCTION(&_4, "constant", NULL, 189, &_3);
zephir_check_call_status();
ZEPHIR_RETURN_CALL_FUNCTION("filter_var", &_5, 190, value, _4);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "int")) {
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, 519);
ZEPHIR_RETURN_CALL_FUNCTION("filter_var", &_5, 190, value, &_3);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "int!")) {
RETURN_MM_LONG(zephir_get_intval(value));
}
if (ZEPHIR_IS_STRING(filter, "absint")) {
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, zephir_get_intval(value));
ZEPHIR_RETURN_CALL_FUNCTION("abs", NULL, 191, &_3);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "string")) {
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, 513);
ZEPHIR_RETURN_CALL_FUNCTION("filter_var", &_5, 190, value, &_3);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "float")) {
ZEPHIR_INIT_NVAR(_2);
zephir_create_array(_2, 1, 0 TSRMLS_CC);
add_assoc_long_ex(_2, SS("flags"), 4096);
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, 520);
ZEPHIR_RETURN_CALL_FUNCTION("filter_var", &_5, 190, value, &_3, _2);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "float!")) {
RETURN_MM_DOUBLE(zephir_get_doubleval(value));
}
if (ZEPHIR_IS_STRING(filter, "alphanum")) {
ZEPHIR_INIT_VAR(_6);
ZVAL_STRING(_6, "/[^A-Za-z0-9]/", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_7);
ZVAL_STRING(_7, "", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_RETURN_CALL_FUNCTION("preg_replace", NULL, 28, _6, _7, value);
zephir_check_temp_parameter(_6);
zephir_check_temp_parameter(_7);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "trim")) {
zephir_fast_trim(return_value, value, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC);
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "striptags")) {
ZEPHIR_RETURN_CALL_FUNCTION("strip_tags", NULL, 192, value);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "lower")) {
if ((zephir_function_exists_ex(SS("mb_strtolower") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_FUNCTION("mb_strtolower", NULL, 193, value);
zephir_check_call_status();
RETURN_MM();
}
zephir_fast_strtolower(return_value, value);
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "upper")) {
if ((zephir_function_exists_ex(SS("mb_strtoupper") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_FUNCTION("mb_strtoupper", NULL, 194, value);
zephir_check_call_status();
RETURN_MM();
}
zephir_fast_strtoupper(return_value, value);
RETURN_MM();
}
ZEPHIR_INIT_NVAR(_6);
object_init_ex(_6, phalcon_filter_exception_ce);
ZEPHIR_INIT_VAR(_8);
ZEPHIR_CONCAT_SVS(_8, "Sanitize filter '", filter, "' is not supported");
ZEPHIR_CALL_METHOD(NULL, _6, "__construct", NULL, 9, _8);
zephir_check_call_status();
zephir_throw_exception_debug(_6, "phalcon/filter.zep", 213 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
} while(0);
ZEPHIR_MM_RESTORE();
}
/**
* Check whether a role is allowed to access an action from a resource
*
* <code>
* //Does andres have access to the customers resource to create?
* $acl->isAllowed("andres", "Products", "create");
*
* //Do guests have access to any resource to edit?
* $acl->isAllowed("guests", "*", "edit");
* </code>
*/
PHP_METHOD(Phalcon_Acl_Adapter_Memory, isAllowed) {
zend_bool _15$$31, _22$$34, _25$$34, _28$$34, _29$$34, _31$$34, _42$$33, _48$$41, _50$$40, _52$$42;
HashTable *_5$$13, *_8$$19, *_11$$25, *_18$$32;
HashPosition _4$$13, _7$$19, _10$$25, _17$$32;
zephir_fcall_cache_entry *_20 = NULL, *_21 = NULL, *_24 = NULL, *_27 = NULL, *_34 = NULL, *_39 = NULL, *_41 = NULL, *_46 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *parameters = NULL;
zval *access = NULL;
zval *roleName = NULL, *resourceName = NULL, *access_param = NULL, *parameters_param = NULL, *eventsManager = NULL, *accessList = NULL, *accessKey = NULL, *haveAccess = NULL, *roleInherits = NULL, *inheritedRole = NULL, *rolesNames = NULL, *inheritedRoles = NULL, *funcAccess = NULL, *resourceObject = NULL, *roleObject = NULL, *funcList = NULL, *_0, *_1$$7 = NULL, *_2$$7, *_3$$9, **_6$$13, **_9$$19, **_12$$25, *_13$$28, *_14$$29, *reflectionFunction$$30 = NULL, *reflectionParameters$$30 = NULL, *parameterNumber$$30 = NULL, *parametersForFunction$$30 = NULL, *numberOfRequiredParameters$$30 = NULL, *userParametersSizeShouldBe$$30 = NULL, *reflectionClass$$30 = NULL, *parameterToCheck$$30 = NULL, *reflectionParameter$$30 = NULL, *_16$$31, **_19$$32, *_23$$34 = NULL, *_26$$34 = NULL, *_30$$34 = NULL, *_32$$34 = NULL, *_33$$34, *_35$$37 = NULL, *_36$$37 = NULL, *_37$$37, *_38$$37 = NULL, *_40$$37 = NULL, *_43$$38, *_44$$39, _45$$39, *_47$$41, *_49$$41, *_51$$40, *_53$$42, *_54$$43, *_55$$43;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 1, &roleName, &resourceName, &access_param, ¶meters_param);
ZEPHIR_SEPARATE_PARAM(roleName);
ZEPHIR_SEPARATE_PARAM(resourceName);
zephir_get_strval(access, access_param);
if (!parameters_param) {
ZEPHIR_INIT_VAR(parameters);
array_init(parameters);
} else {
zephir_get_arrval(parameters, parameters_param);
}
ZEPHIR_INIT_VAR(haveAccess);
ZVAL_NULL(haveAccess);
ZEPHIR_INIT_VAR(funcAccess);
ZVAL_NULL(funcAccess);
ZEPHIR_INIT_VAR(resourceObject);
ZVAL_NULL(resourceObject);
ZEPHIR_INIT_VAR(roleObject);
ZVAL_NULL(roleObject);
if (Z_TYPE_P(roleName) == IS_OBJECT) {
if (!(zephir_instance_of_ev(roleName, phalcon_acl_roleaware_ce TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_acl_exception_ce, "Object passed as roleName must implement RoleAware", "phalcon/acl/adapter/memory.zep", 544);
return;
}
ZEPHIR_CPY_WRT(roleObject, roleName);
ZEPHIR_CALL_METHOD(&roleName, roleObject, "getrolename", NULL, 0);
zephir_check_call_status();
}
if (Z_TYPE_P(resourceName) == IS_OBJECT) {
if (!(zephir_instance_of_ev(resourceName, phalcon_acl_resourceaware_ce TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_acl_exception_ce, "Object passed as resourceName must implement ResourceAware", "phalcon/acl/adapter/memory.zep", 552);
return;
}
ZEPHIR_CPY_WRT(resourceObject, resourceName);
ZEPHIR_CALL_METHOD(&resourceName, resourceObject, "getresourcename", NULL, 0);
zephir_check_call_status();
}
zephir_update_property_this(this_ptr, SL("_activeRole"), roleName TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_activeResource"), resourceName TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_activeAccess"), access TSRMLS_CC);
ZEPHIR_OBS_VAR(accessList);
zephir_read_property_this(&accessList, this_ptr, SL("_access"), PH_NOISY_CC);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(eventsManager, _0);
ZEPHIR_OBS_VAR(funcList);
zephir_read_property_this(&funcList, this_ptr, SL("_func"), PH_NOISY_CC);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_2$$7);
ZVAL_STRING(_2$$7, "acl:beforeCheckAccess", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_1$$7, eventsManager, "fire", NULL, 0, _2$$7, this_ptr);
zephir_check_temp_parameter(_2$$7);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_1$$7)) {
RETURN_MM_BOOL(0);
}
}
ZEPHIR_OBS_VAR(rolesNames);
zephir_read_property_this(&rolesNames, this_ptr, SL("_rolesNames"), PH_NOISY_CC);
if (!(zephir_array_isset(rolesNames, roleName))) {
_3$$9 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAccess"), PH_NOISY_CC);
RETURN_MM_BOOL((ZEPHIR_IS_LONG(_3$$9, 1)));
}
ZEPHIR_INIT_VAR(accessKey);
ZEPHIR_CONCAT_VSVSV(accessKey, roleName, "!", resourceName, "!", access);
if (zephir_array_isset(accessList, accessKey)) {
ZEPHIR_OBS_NVAR(haveAccess);
zephir_array_fetch(&haveAccess, accessList, accessKey, PH_NOISY, "phalcon/acl/adapter/memory.zep", 585 TSRMLS_CC);
}
ZEPHIR_OBS_NVAR(funcAccess);
zephir_array_isset_fetch(&funcAccess, funcList, accessKey, 0 TSRMLS_CC);
if (Z_TYPE_P(haveAccess) == IS_NULL) {
ZEPHIR_OBS_VAR(roleInherits);
zephir_read_property_this(&roleInherits, this_ptr, SL("_roleInherits"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(inheritedRoles);
if (zephir_array_isset_fetch(&inheritedRoles, roleInherits, roleName, 0 TSRMLS_CC)) {
if (Z_TYPE_P(inheritedRoles) == IS_ARRAY) {
zephir_is_iterable(inheritedRoles, &_5$$13, &_4$$13, 0, 0, "phalcon/acl/adapter/memory.zep", 609);
for (
; zephir_hash_get_current_data_ex(_5$$13, (void**) &_6$$13, &_4$$13) == SUCCESS
; zephir_hash_move_forward_ex(_5$$13, &_4$$13)
) {
ZEPHIR_GET_HVALUE(inheritedRole, _6$$13);
ZEPHIR_INIT_NVAR(accessKey);
ZEPHIR_CONCAT_VSVSV(accessKey, inheritedRole, "!", resourceName, "!", access);
if (zephir_array_isset(accessList, accessKey)) {
ZEPHIR_OBS_NVAR(haveAccess);
zephir_array_fetch(&haveAccess, accessList, accessKey, PH_NOISY, "phalcon/acl/adapter/memory.zep", 605 TSRMLS_CC);
}
ZEPHIR_OBS_NVAR(funcAccess);
zephir_array_isset_fetch(&funcAccess, funcList, accessKey, 0 TSRMLS_CC);
}
}
}
}
if (Z_TYPE_P(haveAccess) == IS_NULL) {
ZEPHIR_INIT_NVAR(accessKey);
ZEPHIR_CONCAT_VSVS(accessKey, roleName, "!", resourceName, "!*");
if (zephir_array_isset(accessList, accessKey)) {
ZEPHIR_OBS_NVAR(haveAccess);
zephir_array_fetch(&haveAccess, accessList, accessKey, PH_NOISY, "phalcon/acl/adapter/memory.zep", 624 TSRMLS_CC);
ZEPHIR_OBS_NVAR(funcAccess);
zephir_array_isset_fetch(&funcAccess, funcList, accessKey, 0 TSRMLS_CC);
} else {
if (Z_TYPE_P(inheritedRoles) == IS_ARRAY) {
zephir_is_iterable(inheritedRoles, &_8$$19, &_7$$19, 0, 0, "phalcon/acl/adapter/memory.zep", 640);
for (
; zephir_hash_get_current_data_ex(_8$$19, (void**) &_9$$19, &_7$$19) == SUCCESS
; zephir_hash_move_forward_ex(_8$$19, &_7$$19)
) {
ZEPHIR_GET_HVALUE(inheritedRole, _9$$19);
ZEPHIR_INIT_NVAR(accessKey);
ZEPHIR_CONCAT_VSVS(accessKey, inheritedRole, "!", resourceName, "!*");
ZEPHIR_OBS_NVAR(funcAccess);
zephir_array_isset_fetch(&funcAccess, funcList, accessKey, 0 TSRMLS_CC);
if (zephir_array_isset(accessList, accessKey)) {
ZEPHIR_OBS_NVAR(haveAccess);
zephir_array_fetch(&haveAccess, accessList, accessKey, PH_NOISY, "phalcon/acl/adapter/memory.zep", 636 TSRMLS_CC);
break;
}
}
}
}
}
if (Z_TYPE_P(haveAccess) == IS_NULL) {
ZEPHIR_INIT_NVAR(accessKey);
ZEPHIR_CONCAT_VS(accessKey, roleName, "!*!*");
if (zephir_array_isset(accessList, accessKey)) {
ZEPHIR_OBS_NVAR(haveAccess);
zephir_array_fetch(&haveAccess, accessList, accessKey, PH_NOISY, "phalcon/acl/adapter/memory.zep", 655 TSRMLS_CC);
ZEPHIR_OBS_NVAR(funcAccess);
zephir_array_isset_fetch(&funcAccess, funcList, accessKey, 0 TSRMLS_CC);
} else {
if (Z_TYPE_P(inheritedRoles) == IS_ARRAY) {
zephir_is_iterable(inheritedRoles, &_11$$25, &_10$$25, 0, 0, "phalcon/acl/adapter/memory.zep", 671);
for (
; zephir_hash_get_current_data_ex(_11$$25, (void**) &_12$$25, &_10$$25) == SUCCESS
; zephir_hash_move_forward_ex(_11$$25, &_10$$25)
) {
ZEPHIR_GET_HVALUE(inheritedRole, _12$$25);
ZEPHIR_INIT_NVAR(accessKey);
ZEPHIR_CONCAT_VS(accessKey, inheritedRole, "!*!*");
ZEPHIR_OBS_NVAR(funcAccess);
zephir_array_isset_fetch(&funcAccess, funcList, accessKey, 0 TSRMLS_CC);
if (zephir_array_isset(accessList, accessKey)) {
ZEPHIR_OBS_NVAR(haveAccess);
zephir_array_fetch(&haveAccess, accessList, accessKey, PH_NOISY, "phalcon/acl/adapter/memory.zep", 667 TSRMLS_CC);
break;
}
}
}
}
}
zephir_update_property_this(this_ptr, SL("_accessGranted"), haveAccess TSRMLS_CC);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_13$$28);
ZVAL_STRING(_13$$28, "acl:afterCheckAccess", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _13$$28, this_ptr);
zephir_check_temp_parameter(_13$$28);
zephir_check_call_status();
}
if (Z_TYPE_P(haveAccess) == IS_NULL) {
_14$$29 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAccess"), PH_NOISY_CC);
RETURN_MM_BOOL((ZEPHIR_IS_LONG(_14$$29, 1)));
}
if (Z_TYPE_P(funcAccess) != IS_NULL) {
ZEPHIR_INIT_VAR(reflectionFunction$$30);
object_init_ex(reflectionFunction$$30, zephir_get_internal_ce(SS("reflectionfunction") TSRMLS_CC));
ZEPHIR_CALL_METHOD(NULL, reflectionFunction$$30, "__construct", NULL, 85, funcAccess);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&reflectionParameters$$30, reflectionFunction$$30, "getparameters", NULL, 86);
zephir_check_call_status();
ZEPHIR_INIT_VAR(parameterNumber$$30);
ZVAL_LONG(parameterNumber$$30, zephir_fast_count_int(reflectionParameters$$30 TSRMLS_CC));
do {
if (ZEPHIR_IS_LONG(parameterNumber$$30, 0)) {
_15$$31 = (ZEPHIR_IS_LONG(haveAccess, 1));
if (_15$$31) {
ZEPHIR_INIT_VAR(_16$$31);
ZEPHIR_CALL_USER_FUNC(_16$$31, funcAccess);
zephir_check_call_status();
_15$$31 = zephir_is_true(_16$$31);
}
RETURN_MM_BOOL(_15$$31);
}
ZEPHIR_INIT_VAR(parametersForFunction$$30);
array_init(parametersForFunction$$30);
ZEPHIR_CALL_METHOD(&numberOfRequiredParameters$$30, reflectionFunction$$30, "getnumberofrequiredparameters", NULL, 87);
zephir_check_call_status();
ZEPHIR_CPY_WRT(userParametersSizeShouldBe$$30, parameterNumber$$30);
zephir_is_iterable(reflectionParameters$$30, &_18$$32, &_17$$32, 0, 0, "phalcon/acl/adapter/memory.zep", 730);
for (
; zephir_hash_get_current_data_ex(_18$$32, (void**) &_19$$32, &_17$$32) == SUCCESS
; zephir_hash_move_forward_ex(_18$$32, &_17$$32)
) {
ZEPHIR_GET_HVALUE(reflectionParameter$$30, _19$$32);
ZEPHIR_CALL_METHOD(&reflectionClass$$30, reflectionParameter$$30, "getclass", &_20, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(¶meterToCheck$$30, reflectionParameter$$30, "getname", &_21, 0);
zephir_check_call_status();
if (Z_TYPE_P(reflectionClass$$30) != IS_NULL) {
_22$$34 = Z_TYPE_P(roleObject) != IS_NULL;
if (_22$$34) {
ZEPHIR_CALL_METHOD(&_23$$34, reflectionClass$$30, "isinstance", &_24, 0, roleObject);
zephir_check_call_status();
_22$$34 = zephir_is_true(_23$$34);
}
_25$$34 = Z_TYPE_P(resourceObject) != IS_NULL;
if (_25$$34) {
ZEPHIR_CALL_METHOD(&_26$$34, reflectionClass$$30, "isinstance", &_27, 0, resourceObject);
zephir_check_call_status();
_25$$34 = zephir_is_true(_26$$34);
}
_28$$34 = !ZEPHIR_IS_STRING(parameters, "");
if (_28$$34) {
_28$$34 = zephir_array_isset(parameters, parameterToCheck$$30);
}
_29$$34 = _28$$34;
if (_29$$34) {
ZEPHIR_OBS_NVAR(_30$$34);
zephir_array_fetch(&_30$$34, parameters, parameterToCheck$$30, PH_NOISY, "phalcon/acl/adapter/memory.zep", 721 TSRMLS_CC);
_29$$34 = Z_TYPE_P(_30$$34) == IS_OBJECT;
}
_31$$34 = _29$$34;
if (_31$$34) {
zephir_array_fetch(&_33$$34, parameters, parameterToCheck$$30, PH_NOISY | PH_READONLY, "phalcon/acl/adapter/memory.zep", 721 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_32$$34, reflectionClass$$30, "isinstance", &_34, 0, _33$$34);
zephir_check_call_status();
_31$$34 = !zephir_is_true(_32$$34);
}
if (_22$$34) {
zephir_array_append(¶metersForFunction$$30, roleObject, PH_SEPARATE, "phalcon/acl/adapter/memory.zep", 710);
ZEPHIR_SEPARATE(userParametersSizeShouldBe$$30);
zephir_decrement(userParametersSizeShouldBe$$30);
continue;
} else if (_25$$34) {
zephir_array_append(¶metersForFunction$$30, resourceObject, PH_SEPARATE, "phalcon/acl/adapter/memory.zep", 716);
ZEPHIR_SEPARATE(userParametersSizeShouldBe$$30);
zephir_decrement(userParametersSizeShouldBe$$30);
continue;
} else if (_31$$34) {
ZEPHIR_INIT_NVAR(_35$$37);
object_init_ex(_35$$37, phalcon_acl_exception_ce);
ZEPHIR_INIT_NVAR(_36$$37);
zephir_array_fetch(&_37$$37, parameters, parameterToCheck$$30, PH_NOISY | PH_READONLY, "phalcon/acl/adapter/memory.zep", 722 TSRMLS_CC);
zephir_get_class(_36$$37, _37$$37, 0 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_38$$37, reflectionClass$$30, "getname", &_39, 0);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_40$$37);
ZEPHIR_CONCAT_SVSVSVSVSVS(_40$$37, "Your passed parameter dont have same class as parameter in defined function when check ", roleName, " can ", access, " ", resourceName, ". Class passed: ", _36$$37, " , Class in defined function: ", _38$$37, ".");
ZEPHIR_CALL_METHOD(NULL, _35$$37, "__construct", &_41, 9, _40$$37);
zephir_check_call_status();
zephir_throw_exception_debug(_35$$37, "phalcon/acl/adapter/memory.zep", 722 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
_42$$33 = !ZEPHIR_IS_STRING(parameters, "");
if (_42$$33) {
_42$$33 = zephir_array_isset(parameters, parameterToCheck$$30);
}
if (_42$$33) {
zephir_array_fetch(&_43$$38, parameters, parameterToCheck$$30, PH_NOISY | PH_READONLY, "phalcon/acl/adapter/memory.zep", 727 TSRMLS_CC);
zephir_array_append(¶metersForFunction$$30, _43$$38, PH_SEPARATE, "phalcon/acl/adapter/memory.zep", 727);
}
}
if (ZEPHIR_LT_LONG(userParametersSizeShouldBe$$30, zephir_fast_count_int(parameters TSRMLS_CC))) {
ZEPHIR_INIT_VAR(_44$$39);
ZEPHIR_CONCAT_SVSVSVS(_44$$39, "Number of parameters in array is higher than number of parameters in defined function when check ", roleName, " can ", access, " ", resourceName, ". Remember that more parameters than defined in function will be ignored.");
ZEPHIR_SINIT_VAR(_45$$39);
ZVAL_LONG(&_45$$39, 512);
ZEPHIR_CALL_FUNCTION(NULL, "trigger_error", &_46, 2, _44$$39, &_45$$39);
zephir_check_call_status();
}
if (zephir_fast_count_int(parametersForFunction$$30 TSRMLS_CC) == 0) {
if (ZEPHIR_GT_LONG(numberOfRequiredParameters$$30, 0)) {
ZEPHIR_INIT_VAR(_47$$41);
ZEPHIR_CONCAT_SVSVSVS(_47$$41, "You didn't provide any parameters when check ", roleName, " can ", access, " ", resourceName, ". We will use default action when no arguments.");
ZEPHIR_CALL_FUNCTION(NULL, "trigger_error", &_46, 2, _47$$41);
zephir_check_call_status();
_48$$41 = (ZEPHIR_IS_LONG(haveAccess, 1));
if (_48$$41) {
_49$$41 = zephir_fetch_nproperty_this(this_ptr, SL("_noArgumentsDefaultAction"), PH_NOISY_CC);
_48$$41 = (ZEPHIR_IS_LONG(_49$$41, 1));
}
RETURN_MM_BOOL(_48$$41);
}
_50$$40 = (ZEPHIR_IS_LONG(haveAccess, 1));
if (_50$$40) {
ZEPHIR_INIT_VAR(_51$$40);
ZEPHIR_CALL_USER_FUNC(_51$$40, funcAccess);
zephir_check_call_status();
_50$$40 = zephir_is_true(_51$$40);
}
RETURN_MM_BOOL(_50$$40);
} else if (ZEPHIR_LE_LONG(numberOfRequiredParameters$$30, zephir_fast_count_int(parametersForFunction$$30 TSRMLS_CC))) {
_52$$42 = (ZEPHIR_IS_LONG(haveAccess, 1));
if (_52$$42) {
ZEPHIR_INIT_VAR(_53$$42);
ZEPHIR_CALL_USER_FUNC_ARRAY(_53$$42, funcAccess, parametersForFunction$$30);
zephir_check_call_status();
_52$$42 = zephir_is_true(_53$$42);
}
RETURN_MM_BOOL(_52$$42);
} else {
ZEPHIR_INIT_VAR(_54$$43);
object_init_ex(_54$$43, phalcon_acl_exception_ce);
ZEPHIR_INIT_VAR(_55$$43);
ZEPHIR_CONCAT_SVSVSV(_55$$43, "You didn't provide all necessary parameters for defined function when check ", roleName, " can ", access, " ", resourceName);
ZEPHIR_CALL_METHOD(NULL, _54$$43, "__construct", &_41, 9, _55$$43);
zephir_check_call_status();
zephir_throw_exception_debug(_54$$43, "phalcon/acl/adapter/memory.zep", 748 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} while(0);
}
RETURN_MM_BOOL((ZEPHIR_IS_LONG(haveAccess, 1)));
}
/**
* Gets a value from the internal related entity or from the default value
*/
PHP_METHOD(Phalcon_Forms_Form, getValue) {
int ZEPHIR_LAST_CALL_STATUS;
zval *name_param = NULL, *entity = NULL, *method = NULL, *value = NULL, *data = NULL, *internal = NULL, *forbidden = NULL, *_1, *_0$$4;
zval *name = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &name_param);
if (UNEXPECTED(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(name_param) == IS_STRING)) {
zephir_get_strval(name, name_param);
} else {
ZEPHIR_INIT_VAR(name);
ZVAL_EMPTY_STRING(name);
}
ZEPHIR_OBS_VAR(entity);
zephir_read_property_this(&entity, this_ptr, SL("_entity"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(data);
zephir_read_property_this(&data, this_ptr, SL("_data"), PH_NOISY_CC);
if ((zephir_method_exists_ex(this_ptr, SS("getcustomvalue") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getcustomvalue", NULL, 0, name, entity, data);
zephir_check_call_status();
RETURN_MM();
}
if (Z_TYPE_P(entity) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_0$$4);
zephir_camelize(_0$$4, name, NULL );
ZEPHIR_INIT_VAR(method);
ZEPHIR_CONCAT_SV(method, "get", _0$$4);
if ((zephir_method_exists(entity, method TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_METHOD_ZVAL(entity, method, NULL, 0);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_OBS_VAR(value);
if (zephir_fetch_property_zval(&value, entity, name, PH_SILENT_CC)) {
RETURN_CCTOR(value);
}
}
if (Z_TYPE_P(data) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(value);
if (zephir_array_isset_fetch(&value, data, name, 0 TSRMLS_CC)) {
RETURN_CCTOR(value);
}
}
ZEPHIR_INIT_VAR(forbidden);
zephir_create_array(forbidden, 12, 0 TSRMLS_CC);
zephir_array_update_string(&forbidden, SL("validation"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("action"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("useroption"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("useroptions"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("entity"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("elements"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("messages"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("messagesfor"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("label"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("value"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("di"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("eventsmanager"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_VAR(internal);
zephir_fast_strtolower(internal, name);
if (zephir_array_isset(forbidden, internal)) {
RETURN_MM_NULL();
}
ZEPHIR_INIT_VAR(_1);
zephir_camelize(_1, name, NULL );
ZEPHIR_INIT_NVAR(method);
ZEPHIR_CONCAT_SV(method, "get", _1);
if ((zephir_method_exists(this_ptr, method TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_METHOD_ZVAL(this_ptr, method, NULL, 0);
zephir_check_call_status();
RETURN_MM();
}
RETURN_MM_NULL();
}
/**
* 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, 379, 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, 464, _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);
}
/**
* Sets a cookie to be sent at the end of the request
* This method overrides any cookie set before with the same name
*/
PHP_METHOD(Phalcon_Http_Response_Cookies, set) {
zval *_3;
zend_bool secure, httpOnly;
int expire, ZEPHIR_LAST_CALL_STATUS;
zval *name_param = NULL, *value = NULL, *expire_param = NULL, *path_param = NULL, *secure_param = NULL, *domain_param = NULL, *httpOnly_param = NULL, *cookie = NULL, *encryption, *dependencyInjector, *response = NULL, *_0, *_1, *_2 = NULL, *_4 = NULL, *_5;
zval *name = NULL, *path = NULL, *domain = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 6, &name_param, &value, &expire_param, &path_param, &secure_param, &domain_param, &httpOnly_param);
if (unlikely(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(name_param) == IS_STRING)) {
zephir_get_strval(name, name_param);
} else {
ZEPHIR_INIT_VAR(name);
ZVAL_EMPTY_STRING(name);
}
if (!value) {
value = ZEPHIR_GLOBAL(global_null);
}
if (!expire_param) {
expire = 0;
} else {
expire = zephir_get_intval(expire_param);
}
if (!path_param) {
ZEPHIR_INIT_VAR(path);
ZVAL_STRING(path, "/", 1);
} else {
zephir_get_strval(path, path_param);
}
if (!secure_param) {
secure = 0;
} else {
secure = zephir_get_boolval(secure_param);
}
if (!domain_param) {
ZEPHIR_INIT_VAR(domain);
ZVAL_EMPTY_STRING(domain);
} else {
if (unlikely(Z_TYPE_P(domain_param) != IS_STRING && Z_TYPE_P(domain_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'domain' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(domain_param) == IS_STRING)) {
zephir_get_strval(domain, domain_param);
} else {
ZEPHIR_INIT_VAR(domain);
ZVAL_EMPTY_STRING(domain);
}
}
if (!httpOnly_param) {
httpOnly = 0;
} else {
httpOnly = zephir_get_boolval(httpOnly_param);
}
ZEPHIR_OBS_VAR(encryption);
zephir_read_property_this(&encryption, this_ptr, SL("_useEncryption"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(cookie);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_cookies"), PH_NOISY_CC);
if (!(zephir_array_isset_fetch(&cookie, _0, name, 0 TSRMLS_CC))) {
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_3);
zephir_create_array(_3, 7, 0 TSRMLS_CC);
zephir_array_fast_append(_3, name);
zephir_array_fast_append(_3, value);
ZEPHIR_INIT_VAR(_4);
ZVAL_LONG(_4, expire);
zephir_array_fast_append(_3, _4);
zephir_array_fast_append(_3, path);
ZEPHIR_INIT_NVAR(_4);
ZVAL_BOOL(_4, secure);
zephir_array_fast_append(_3, _4);
zephir_array_fast_append(_3, domain);
ZEPHIR_INIT_NVAR(_4);
ZVAL_BOOL(_4, httpOnly);
zephir_array_fast_append(_3, _4);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Http\\Cookie", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_2, _1, "get", NULL, 0, _4, _3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
ZEPHIR_CPY_WRT(cookie, _2);
_5 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, cookie, "setdi", NULL, 0, _5);
zephir_check_call_status();
if (zephir_is_true(encryption)) {
ZEPHIR_CALL_METHOD(NULL, cookie, "useencryption", NULL, 0, encryption);
zephir_check_call_status();
}
zephir_update_property_array(this_ptr, SL("_cookies"), name, cookie TSRMLS_CC);
} else {
ZEPHIR_CALL_METHOD(NULL, cookie, "setvalue", NULL, 0, value);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_4);
ZVAL_LONG(_4, expire);
ZEPHIR_CALL_METHOD(NULL, cookie, "setexpiration", NULL, 0, _4);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, cookie, "setpath", NULL, 0, path);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, cookie, "setsecure", NULL, 0, (secure ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false)));
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, cookie, "setdomain", NULL, 0, domain);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, cookie, "sethttponly", NULL, 0, (httpOnly ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false)));
zephir_check_call_status();
}
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_registered"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_1)) {
ZEPHIR_OBS_VAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_http_cookie_exception_ce, "A dependency injection object is required to access the 'response' service", "phalcon/http/response/cookies.zep", 130);
return;
}
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "response", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&response, dependencyInjector, "getshared", NULL, 0, _4);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, response, "setcookies", NULL, 0, this_ptr);
zephir_check_call_status();
}
RETURN_THIS();
}
/**
* 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;
int 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(this_ptr, SL("_data"), data TSRMLS_CC);
RETURN_THIS();
}
/**
* Returns a complete resultset as an array, if the resultset has a big number of rows
* it could consume more memory than currently it does. Export the resultset to an array
* couldn't be faster with a large number of records
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, toArray) {
zephir_fcall_cache_entry *_9 = NULL;
HashTable *_2, *_5;
HashPosition _1, _4;
int ZEPHIR_LAST_CALL_STATUS;
zval *renameColumns_param = NULL, *result, *records = NULL, *record = NULL, *renamed = NULL, *renamedKey = NULL, *key = NULL, *value = NULL, *renamedRecords, *columnMap, *_0, **_3, **_6, *_7 = NULL, *_8 = NULL, *_10 = NULL;
zend_bool renameColumns;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &renameColumns_param);
if (!renameColumns_param) {
renameColumns = 1;
} else {
renameColumns = zephir_get_boolval(renameColumns_param);
}
ZEPHIR_OBS_VAR(records);
zephir_read_property_this(&records, this_ptr, SL("_rows"), PH_NOISY_CC);
if (Z_TYPE_P(records) != IS_ARRAY) {
ZEPHIR_OBS_VAR(result);
zephir_read_property_this(&result, this_ptr, SL("_result"), PH_NOISY_CC);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_row"), PH_NOISY_CC);
if (Z_TYPE_P(_0) != IS_NULL) {
ZEPHIR_CALL_METHOD(NULL, result, "execute", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&records, result, "fetchall", NULL, 0);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_row"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_rows"), records TSRMLS_CC);
}
if (renameColumns) {
ZEPHIR_OBS_VAR(columnMap);
zephir_read_property_this(&columnMap, this_ptr, SL("_columnMap"), PH_NOISY_CC);
if (Z_TYPE_P(columnMap) != IS_ARRAY) {
RETURN_CCTOR(records);
}
ZEPHIR_INIT_VAR(renamedRecords);
array_init(renamedRecords);
if (Z_TYPE_P(records) == IS_ARRAY) {
zephir_is_iterable(records, &_2, &_1, 0, 0, "phalcon/mvc/model/resultset/simple.zep", 220);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(record, _3);
ZEPHIR_INIT_NVAR(renamed);
array_init(renamed);
zephir_is_iterable(record, &_5, &_4, 0, 0, "phalcon/mvc/model/resultset/simple.zep", 218);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HMKEY(key, _5, _4);
ZEPHIR_GET_HVALUE(value, _6);
ZEPHIR_OBS_NVAR(renamedKey);
if (!(zephir_array_isset_fetch(&renamedKey, columnMap, key, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_7);
object_init_ex(_7, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_8);
ZEPHIR_CONCAT_SVS(_8, "Column '", key, "' is not part of the column map");
ZEPHIR_CALL_METHOD(NULL, _7, "__construct", &_9, 9, _8);
zephir_check_call_status();
zephir_throw_exception_debug(_7, "phalcon/mvc/model/resultset/simple.zep", 200 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (Z_TYPE_P(renamedKey) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(renamedKey);
if (!(zephir_array_isset_long_fetch(&renamedKey, renamedKey, 0, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_7);
object_init_ex(_7, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_8);
ZEPHIR_CONCAT_SVS(_8, "Column '", key, "' is not part of the column map");
ZEPHIR_CALL_METHOD(NULL, _7, "__construct", &_9, 9, _8);
zephir_check_call_status();
zephir_throw_exception_debug(_7, "phalcon/mvc/model/resultset/simple.zep", 206 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_OBS_NVAR(_10);
zephir_array_fetch_long(&_10, renamedKey, 0, PH_NOISY, "phalcon/mvc/model/resultset/simple.zep", 209 TSRMLS_CC);
zephir_array_update_zval(&renamed, _10, &value, PH_COPY | PH_SEPARATE);
} else {
zephir_array_update_zval(&renamed, renamedKey, &value, PH_COPY | PH_SEPARATE);
}
}
zephir_array_append(&renamedRecords, renamed, PH_SEPARATE, "phalcon/mvc/model/resultset/simple.zep", 218);
}
}
RETURN_CCTOR(renamedRecords);
}
RETURN_CCTOR(records);
}
/**
* Returns current row in the resultset
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, current) {
zend_class_entry *_13$$15;
HashTable *_3, *_6$$11;
HashPosition _2, _5$$11;
zval *row = NULL, *hydrateMode = NULL, *eager = NULL, *alias = NULL, *activeRow = NULL, *type = NULL, *column = NULL, *columnValue = NULL, *value = NULL, *attribute = NULL, *source = NULL, *attributes = NULL, *columnMap = NULL, *rowModel = NULL, *keepSnapshots = NULL, *sqlAlias = NULL, *modelName = NULL, *_0, *_1, **_4, **_7$$11, *_8$$12 = NULL, *_9$$15 = NULL, *_11$$15, *_12$$15 = NULL, *_10$$16, *_15$$18, *_16$$18 = NULL, _18$$24 = zval_used_for_init, _19$$24 = zval_used_for_init;
zephir_fcall_cache_entry *_14 = NULL, *_17 = NULL;
zend_long ZEPHIR_LAST_CALL_STATUS, dirtyState = 0;
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(getThis(), SL("_activeRow"), row TSRMLS_CC);
RETURN_CCTOR(row);
}
if (Z_TYPE_P(row) != IS_ARRAY) {
if (0) {
zephir_update_property_this(getThis(), SL("_activeRow"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(getThis(), SL("_activeRow"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
RETURN_MM_BOOL(0);
}
ZEPHIR_OBS_VAR(hydrateMode);
zephir_read_property_this(&hydrateMode, this_ptr, SL("_hydrateMode"), PH_NOISY_CC);
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);
dirtyState = 0;
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_columnTypes"), PH_NOISY_CC);
zephir_is_iterable(_1, &_3, &_2, 0, 0, "phalcon/mvc/model/resultset/complex.zep", 246);
for (
; zend_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS
; zend_hash_move_forward_ex(_3, &_2)
) {
ZEPHIR_GET_HMKEY(alias, _3, _2);
ZEPHIR_GET_HVALUE(column, _4);
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", 133);
return;
}
ZEPHIR_OBS_NVAR(type);
zephir_array_fetch_string(&type, column, SL("type"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 136 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", 142 TSRMLS_CC);
ZEPHIR_OBS_NVAR(attributes);
zephir_array_fetch_string(&attributes, column, SL("attributes"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 143 TSRMLS_CC);
ZEPHIR_OBS_NVAR(columnMap);
zephir_array_fetch_string(&columnMap, column, SL("columnMap"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 144 TSRMLS_CC);
ZEPHIR_INIT_NVAR(rowModel);
array_init(rowModel);
zephir_is_iterable(attributes, &_6$$11, &_5$$11, 0, 0, "phalcon/mvc/model/resultset/complex.zep", 162);
for (
; zend_hash_get_current_data_ex(_6$$11, (void**) &_7$$11, &_5$$11) == SUCCESS
; zend_hash_move_forward_ex(_6$$11, &_5$$11)
) {
ZEPHIR_GET_HVALUE(attribute, _7$$11);
ZEPHIR_OBS_NVAR(columnValue);
ZEPHIR_INIT_LNVAR(_8$$12);
ZEPHIR_CONCAT_SVSV(_8$$12, "_", source, "_", attribute);
zephir_array_fetch(&columnValue, row, _8$$12, PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 155 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);
}
if (ZEPHIR_GLOBAL(orm).late_state_binding) {
ZEPHIR_OBS_NVAR(_9$$15);
zephir_array_fetch_string(&_9$$15, column, SL("instance"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 173 TSRMLS_CC);
if (zephir_instance_of_ev(_9$$15, phalcon_mvc_model_ce TSRMLS_CC)) {
zephir_array_fetch_string(&_10$$16, column, SL("instance"), PH_NOISY | PH_READONLY, "phalcon/mvc/model/resultset/complex.zep", 174 TSRMLS_CC);
ZEPHIR_INIT_NVAR(modelName);
zephir_get_class(modelName, _10$$16, 0 TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(modelName);
ZVAL_STRING(modelName, "Phalcon\\Mvc\\Model", 1);
}
zephir_array_fetch_string(&_11$$15, column, SL("instance"), PH_NOISY | PH_READONLY, "phalcon/mvc/model/resultset/complex.zep", 180 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_12$$15);
ZVAL_LONG(_12$$15, dirtyState);
_13$$15 = zephir_fetch_class(modelName TSRMLS_CC);
ZEPHIR_CALL_CE_STATIC(&value, _13$$15, "cloneresultmap", NULL, 0, _11$$15, rowModel, columnMap, _12$$15, keepSnapshots);
zephir_check_call_status();
} else {
zephir_array_fetch_string(&_15$$18, column, SL("instance"), PH_NOISY | PH_READONLY, "phalcon/mvc/model/resultset/complex.zep", 188 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_16$$18);
ZVAL_LONG(_16$$18, dirtyState);
ZEPHIR_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmap", &_14, 0, _15$$18, rowModel, columnMap, _16$$18, keepSnapshots);
zephir_check_call_status();
}
break;
}
ZEPHIR_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmaphydrate", &_17, 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", 202 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", 210 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(_18$$24);
ZVAL_STRING(&_18$$24, "_", 0);
ZEPHIR_SINIT_NVAR(_19$$24);
ZVAL_STRING(&_19$$24, "", 0);
ZEPHIR_INIT_NVAR(attribute);
zephir_fast_str_replace(&attribute, &_18$$24, &_19$$24, alias TSRMLS_CC);
}
}
if (!(zephir_array_isset_string_fetch(&eager, column, SS("eager"), 1 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(getThis(), SL("_activeRow"), activeRow TSRMLS_CC);
RETURN_CCTOR(activeRow);
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_File, validate) {
zend_bool _4, _5, _6, _8, _9, _18, _19, _21, _29, _30, _65, _72$$29, _81$$36;
zephir_fcall_cache_entry *_15 = NULL, *_17 = NULL, *_44 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *_SERVER, *_POST, *_FILES, *value = NULL, *message = NULL, *label = NULL, *replacePairs = NULL, *types = NULL, *byteUnits = NULL, *unit = NULL, *maxSize = NULL, *matches = NULL, *bytes = NULL, *mime = NULL, *tmp = NULL, *width = NULL, *height = NULL, *minResolution = NULL, *maxResolution = NULL, *minWidth = NULL, *maxWidth = NULL, *minHeight = NULL, *maxHeight = NULL, *fieldTypes = NULL, *code = NULL, *minResolutionArray = NULL, *maxResolutionArray = NULL, *_0 = NULL, *_3, *_7, *_10, *_20, *_22, *_23 = NULL, *_36 = NULL, *_55 = NULL, *_64 = NULL, *_66 = NULL, *_1$$3, *_2$$5, *_11$$6 = NULL, *_14$$6 = NULL, *_16$$6, *_12$$7, *_13$$8, *_24$$9 = NULL, *_27$$9 = NULL, *_28$$9, *_25$$10, *_26$$11, *_31$$12 = NULL, *_34$$12 = NULL, *_35$$12, *_32$$13, *_33$$14, *_37$$15 = NULL, *_39$$15, *_40$$15, *_41$$15, *_42$$15, *_43$$15 = NULL, *_45$$15, *_46$$15, _47$$15, *_48$$15, *_49$$15 = NULL, *_38$$16, *_50$$18 = NULL, *_53$$18 = NULL, *_54$$18, *_51$$19, *_52$$20, *_56$$21, _57$$24, *_58$$24, *_59$$26 = NULL, *_62$$26 = NULL, *_63$$26, *_60$$27, *_61$$28, *_67$$29, *_68$$29 = NULL, *_69$$29 = NULL, *_78$$29 = NULL, *_70$$30, *_71$$31, *_73$$33 = NULL, *_76$$33 = NULL, *_77$$33, *_74$$34, *_75$$35, *_79$$36, *_80$$37, *_82$$38 = NULL, *_85$$38 = NULL, *_86$$38, *_83$$39, *_84$$40;
ZEPHIR_MM_GROW();
zephir_get_global(&_FILES, SS("_FILES") TSRMLS_CC);
zephir_get_global(&_POST, SS("_POST") TSRMLS_CC);
zephir_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC);
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, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (Z_TYPE_P(label) == IS_ARRAY) {
zephir_array_fetch(&_1$$3, label, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 108 TSRMLS_CC);
ZEPHIR_CPY_WRT(label, _1$$3);
}
if (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "code", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&code, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (Z_TYPE_P(code) == IS_ARRAY) {
zephir_array_fetch(&_2$$5, code, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 117 TSRMLS_CC);
ZEPHIR_CPY_WRT(code, _2$$5);
}
zephir_array_fetch_string(&_3, _SERVER, SL("REQUEST_METHOD"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 121 TSRMLS_CC);
_4 = ZEPHIR_IS_STRING(_3, "POST");
if (_4) {
_4 = ZEPHIR_IS_EMPTY(_POST);
}
_5 = _4;
if (_5) {
_5 = ZEPHIR_IS_EMPTY(_FILES);
}
_6 = _5;
if (_6) {
zephir_array_fetch_string(&_7, _SERVER, SL("CONTENT_LENGTH"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 121 TSRMLS_CC);
_6 = ZEPHIR_GT_LONG(_7, 0);
}
_8 = _6;
if (!(_8)) {
_9 = zephir_array_isset_string(value, SS("error"));
if (_9) {
zephir_array_fetch_string(&_10, value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 121 TSRMLS_CC);
_9 = ZEPHIR_IS_LONG_IDENTICAL(_10, 1);
}
_8 = _9;
}
if (_8) {
ZEPHIR_INIT_VAR(_11$$6);
ZVAL_STRING(_11$$6, "messageIniSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _11$$6);
zephir_check_temp_parameter(_11$$6);
zephir_check_call_status();
ZEPHIR_INIT_VAR(replacePairs);
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
if (Z_TYPE_P(message) == IS_ARRAY) {
zephir_array_fetch(&_12$$7, message, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 127 TSRMLS_CC);
ZEPHIR_CPY_WRT(message, _12$$7);
}
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_VAR(_13$$8);
ZVAL_STRING(_13$$8, "FileIniSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _13$$8);
zephir_check_temp_parameter(_13$$8);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_11$$6);
object_init_ex(_11$$6, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_14$$6, "strtr", &_15, 26, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_16$$6);
ZVAL_STRING(_16$$6, "FileIniSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _11$$6, "__construct", &_17, 466, _14$$6, field, _16$$6, code);
zephir_check_temp_parameter(_16$$6);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _11$$6);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
_18 = !(zephir_array_isset_string(value, SS("error")));
if (!(_18)) {
_18 = !(zephir_array_isset_string(value, SS("tmp_name")));
}
_19 = _18;
if (!(_19)) {
zephir_array_fetch_string(&_20, value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 138 TSRMLS_CC);
_19 = !ZEPHIR_IS_LONG_IDENTICAL(_20, 0);
}
_21 = _19;
if (!(_21)) {
zephir_array_fetch_string(&_22, value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 138 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_23, "is_uploaded_file", NULL, 246, _22);
zephir_check_call_status();
_21 = !zephir_is_true(_23);
}
if (_21) {
ZEPHIR_INIT_VAR(_24$$9);
ZVAL_STRING(_24$$9, "messageEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _24$$9);
zephir_check_temp_parameter(_24$$9);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(replacePairs);
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
if (Z_TYPE_P(message) == IS_ARRAY) {
zephir_array_fetch(&_25$$10, message, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 144 TSRMLS_CC);
ZEPHIR_CPY_WRT(message, _25$$10);
}
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_VAR(_26$$11);
ZVAL_STRING(_26$$11, "FileEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _26$$11);
zephir_check_temp_parameter(_26$$11);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_24$$9);
object_init_ex(_24$$9, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_27$$9, "strtr", &_15, 26, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_28$$9);
ZVAL_STRING(_28$$9, "FileEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _24$$9, "__construct", &_17, 466, _27$$9, field, _28$$9, code);
zephir_check_temp_parameter(_28$$9);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _24$$9);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
_29 = !(zephir_array_isset_string(value, SS("name")));
if (!(_29)) {
_29 = !(zephir_array_isset_string(value, SS("type")));
}
_30 = _29;
if (!(_30)) {
_30 = !(zephir_array_isset_string(value, SS("size")));
}
if (_30) {
ZEPHIR_INIT_VAR(_31$$12);
ZVAL_STRING(_31$$12, "messageValid", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _31$$12);
zephir_check_temp_parameter(_31$$12);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(replacePairs);
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
if (Z_TYPE_P(message) == IS_ARRAY) {
zephir_array_fetch(&_32$$13, message, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 161 TSRMLS_CC);
ZEPHIR_CPY_WRT(message, _32$$13);
}
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_VAR(_33$$14);
ZVAL_STRING(_33$$14, "FileValid", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _33$$14);
zephir_check_temp_parameter(_33$$14);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_31$$12);
object_init_ex(_31$$12, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_34$$12, "strtr", &_15, 26, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_35$$12);
ZVAL_STRING(_35$$12, "FileValid", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _31$$12, "__construct", &_17, 466, _34$$12, field, _35$$12, code);
zephir_check_temp_parameter(_35$$12);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _31$$12);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "maxSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_36, this_ptr, "hasoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (zephir_is_true(_36)) {
ZEPHIR_INIT_VAR(byteUnits);
zephir_create_array(byteUnits, 9, 0 TSRMLS_CC);
add_assoc_long_ex(byteUnits, SS("B"), 0);
add_assoc_long_ex(byteUnits, SS("K"), 10);
add_assoc_long_ex(byteUnits, SS("M"), 20);
add_assoc_long_ex(byteUnits, SS("G"), 30);
add_assoc_long_ex(byteUnits, SS("T"), 40);
add_assoc_long_ex(byteUnits, SS("KB"), 10);
add_assoc_long_ex(byteUnits, SS("MB"), 20);
add_assoc_long_ex(byteUnits, SS("GB"), 30);
add_assoc_long_ex(byteUnits, SS("TB"), 40);
ZEPHIR_INIT_VAR(_37$$15);
ZVAL_STRING(_37$$15, "maxSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&maxSize, this_ptr, "getoption", NULL, 0, _37$$15);
zephir_check_temp_parameter(_37$$15);
zephir_check_call_status();
ZEPHIR_INIT_VAR(matches);
ZVAL_NULL(matches);
ZEPHIR_INIT_VAR(unit);
ZVAL_STRING(unit, "B", 1);
if (Z_TYPE_P(maxSize) == IS_ARRAY) {
zephir_array_fetch(&_38$$16, maxSize, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 180 TSRMLS_CC);
ZEPHIR_CPY_WRT(maxSize, _38$$16);
}
ZEPHIR_INIT_NVAR(_37$$15);
ZEPHIR_INIT_VAR(_39$$15);
ZEPHIR_INIT_VAR(_40$$15);
zephir_array_keys(_40$$15, byteUnits TSRMLS_CC);
zephir_fast_join_str(_39$$15, SL("|"), _40$$15 TSRMLS_CC);
ZEPHIR_INIT_VAR(_41$$15);
ZEPHIR_CONCAT_SVS(_41$$15, "/^([0-9]+(?:\\.[0-9]+)?)(", _39$$15, ")?$/Di");
zephir_preg_match(_37$$15, _41$$15, maxSize, matches, 0, 0 , 0 TSRMLS_CC);
if (zephir_array_isset_long(matches, 2)) {
ZEPHIR_OBS_NVAR(unit);
zephir_array_fetch_long(&unit, matches, 2, PH_NOISY, "phalcon/validation/validator/file.zep", 186 TSRMLS_CC);
}
zephir_array_fetch_long(&_42$$15, matches, 1, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 189 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_43$$15, "floatval", &_44, 322, _42$$15);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_45$$15);
zephir_array_fetch(&_46$$15, byteUnits, unit, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 189 TSRMLS_CC);
ZEPHIR_SINIT_VAR(_47$$15);
ZVAL_LONG(&_47$$15, 2);
zephir_pow_function(_45$$15, &_47$$15, _46$$15);
ZEPHIR_INIT_VAR(bytes);
mul_function(bytes, _43$$15, _45$$15 TSRMLS_CC);
zephir_array_fetch_string(&_48$$15, value, SL("size"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 191 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_43$$15, "floatval", &_44, 322, _48$$15);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_49$$15, "floatval", &_44, 322, bytes);
zephir_check_call_status();
if (ZEPHIR_GT(_43$$15, _49$$15)) {
ZEPHIR_INIT_VAR(_50$$18);
ZVAL_STRING(_50$$18, "messageSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _50$$18);
zephir_check_temp_parameter(_50$$18);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(replacePairs);
zephir_create_array(replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":max"), &maxSize, PH_COPY | PH_SEPARATE);
if (Z_TYPE_P(message) == IS_ARRAY) {
zephir_array_fetch(&_51$$19, message, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 196 TSRMLS_CC);
ZEPHIR_CPY_WRT(message, _51$$19);
}
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_VAR(_52$$20);
ZVAL_STRING(_52$$20, "FileSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _52$$20);
zephir_check_temp_parameter(_52$$20);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_50$$18);
object_init_ex(_50$$18, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_53$$18, "strtr", &_15, 26, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_54$$18);
ZVAL_STRING(_54$$18, "FileSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _50$$18, "__construct", &_17, 466, _53$$18, field, _54$$18, code);
zephir_check_temp_parameter(_54$$18);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _50$$18);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "allowedTypes", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_55, this_ptr, "hasoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (zephir_is_true(_55)) {
ZEPHIR_INIT_VAR(_56$$21);
ZVAL_STRING(_56$$21, "allowedTypes", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&types, this_ptr, "getoption", NULL, 0, _56$$21);
zephir_check_temp_parameter(_56$$21);
zephir_check_call_status();
ZEPHIR_OBS_VAR(fieldTypes);
if (zephir_array_isset_fetch(&fieldTypes, types, field, 0 TSRMLS_CC)) {
ZEPHIR_CPY_WRT(types, fieldTypes);
}
if (Z_TYPE_P(types) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Option 'allowedTypes' must be an array", "phalcon/validation/validator/file.zep", 217);
return;
}
if ((zephir_function_exists_ex(SS("finfo_open") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_SINIT_VAR(_57$$24);
ZVAL_LONG(&_57$$24, 16);
ZEPHIR_CALL_FUNCTION(&tmp, "finfo_open", NULL, 243, &_57$$24);
zephir_check_call_status();
zephir_array_fetch_string(&_58$$24, value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 222 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&mime, "finfo_file", NULL, 244, tmp, _58$$24);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(NULL, "finfo_close", NULL, 245, tmp);
zephir_check_call_status();
} else {
ZEPHIR_OBS_NVAR(mime);
zephir_array_fetch_string(&mime, value, SL("type"), PH_NOISY, "phalcon/validation/validator/file.zep", 226 TSRMLS_CC);
}
if (!(zephir_fast_in_array(mime, types TSRMLS_CC))) {
ZEPHIR_INIT_VAR(_59$$26);
ZVAL_STRING(_59$$26, "messageType", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _59$$26);
zephir_check_temp_parameter(_59$$26);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(replacePairs);
zephir_create_array(replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_59$$26);
zephir_fast_join_str(_59$$26, SL(", "), types TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":types"), &_59$$26, PH_COPY | PH_SEPARATE);
if (Z_TYPE_P(message) == IS_ARRAY) {
zephir_array_fetch(&_60$$27, message, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 234 TSRMLS_CC);
ZEPHIR_CPY_WRT(message, _60$$27);
}
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_VAR(_61$$28);
ZVAL_STRING(_61$$28, "FileType", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _61$$28);
zephir_check_temp_parameter(_61$$28);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_59$$26);
object_init_ex(_59$$26, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_62$$26, "strtr", &_15, 26, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_63$$26);
ZVAL_STRING(_63$$26, "FileType", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _59$$26, "__construct", &_17, 466, _62$$26, field, _63$$26, code);
zephir_check_temp_parameter(_63$$26);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _59$$26);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "minResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_64, this_ptr, "hasoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
_65 = zephir_is_true(_64);
if (!(_65)) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "maxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_66, this_ptr, "hasoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
_65 = zephir_is_true(_66);
}
if (_65) {
zephir_array_fetch_string(&_67$$29, value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 247 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&tmp, "getimagesize", NULL, 254, _67$$29);
zephir_check_call_status();
ZEPHIR_OBS_VAR(width);
zephir_array_fetch_long(&width, tmp, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 248 TSRMLS_CC);
ZEPHIR_OBS_VAR(height);
zephir_array_fetch_long(&height, tmp, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 249 TSRMLS_CC);
ZEPHIR_INIT_VAR(_69$$29);
ZVAL_STRING(_69$$29, "minResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_68$$29, this_ptr, "hasoption", NULL, 0, _69$$29);
zephir_check_temp_parameter(_69$$29);
zephir_check_call_status();
if (zephir_is_true(_68$$29)) {
ZEPHIR_INIT_VAR(_70$$30);
ZVAL_STRING(_70$$30, "minResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&minResolution, this_ptr, "getoption", NULL, 0, _70$$30);
zephir_check_temp_parameter(_70$$30);
zephir_check_call_status();
if (Z_TYPE_P(minResolution) == IS_ARRAY) {
zephir_array_fetch(&_71$$31, minResolution, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 254 TSRMLS_CC);
ZEPHIR_CPY_WRT(minResolution, _71$$31);
}
ZEPHIR_INIT_VAR(minResolutionArray);
zephir_fast_explode_str(minResolutionArray, SL("x"), minResolution, LONG_MAX TSRMLS_CC);
ZEPHIR_OBS_VAR(minWidth);
zephir_array_fetch_long(&minWidth, minResolutionArray, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 257 TSRMLS_CC);
ZEPHIR_OBS_VAR(minHeight);
zephir_array_fetch_long(&minHeight, minResolutionArray, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 258 TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(minWidth);
ZVAL_LONG(minWidth, 1);
ZEPHIR_INIT_NVAR(minHeight);
ZVAL_LONG(minHeight, 1);
}
_72$$29 = ZEPHIR_LT(width, minWidth);
if (!(_72$$29)) {
_72$$29 = ZEPHIR_LT(height, minHeight);
}
if (_72$$29) {
ZEPHIR_INIT_VAR(_73$$33);
ZVAL_STRING(_73$$33, "messageMinResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _73$$33);
zephir_check_temp_parameter(_73$$33);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(replacePairs);
zephir_create_array(replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":min"), &minResolution, PH_COPY | PH_SEPARATE);
if (Z_TYPE_P(message) == IS_ARRAY) {
zephir_array_fetch(&_74$$34, message, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 269 TSRMLS_CC);
ZEPHIR_CPY_WRT(message, _74$$34);
}
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_VAR(_75$$35);
ZVAL_STRING(_75$$35, "FileMinResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _75$$35);
zephir_check_temp_parameter(_75$$35);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_73$$33);
object_init_ex(_73$$33, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_76$$33, "strtr", &_15, 26, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_77$$33);
ZVAL_STRING(_77$$33, "FileMinResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _73$$33, "__construct", &_17, 466, _76$$33, field, _77$$33, code);
zephir_check_temp_parameter(_77$$33);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _73$$33);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_NVAR(_69$$29);
ZVAL_STRING(_69$$29, "maxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_78$$29, this_ptr, "hasoption", NULL, 0, _69$$29);
zephir_check_temp_parameter(_69$$29);
zephir_check_call_status();
if (zephir_is_true(_78$$29)) {
ZEPHIR_INIT_VAR(_79$$36);
ZVAL_STRING(_79$$36, "maxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&maxResolution, this_ptr, "getoption", NULL, 0, _79$$36);
zephir_check_temp_parameter(_79$$36);
zephir_check_call_status();
if (Z_TYPE_P(maxResolution) == IS_ARRAY) {
zephir_array_fetch(&_80$$37, maxResolution, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 284 TSRMLS_CC);
ZEPHIR_CPY_WRT(maxResolution, _80$$37);
}
ZEPHIR_INIT_VAR(maxResolutionArray);
zephir_fast_explode_str(maxResolutionArray, SL("x"), maxResolution, LONG_MAX TSRMLS_CC);
ZEPHIR_OBS_VAR(maxWidth);
zephir_array_fetch_long(&maxWidth, maxResolutionArray, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 287 TSRMLS_CC);
ZEPHIR_OBS_VAR(maxHeight);
zephir_array_fetch_long(&maxHeight, maxResolutionArray, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 288 TSRMLS_CC);
_81$$36 = ZEPHIR_GT(width, maxWidth);
if (!(_81$$36)) {
_81$$36 = ZEPHIR_GT(height, maxHeight);
}
if (_81$$36) {
ZEPHIR_INIT_VAR(_82$$38);
ZVAL_STRING(_82$$38, "messageMaxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _82$$38);
zephir_check_temp_parameter(_82$$38);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(replacePairs);
zephir_create_array(replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":max"), &maxResolution, PH_COPY | PH_SEPARATE);
if (Z_TYPE_P(message) == IS_ARRAY) {
zephir_array_fetch(&_83$$39, message, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 295 TSRMLS_CC);
ZEPHIR_CPY_WRT(message, _83$$39);
}
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_VAR(_84$$40);
ZVAL_STRING(_84$$40, "FileMaxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _84$$40);
zephir_check_temp_parameter(_84$$40);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_82$$38);
object_init_ex(_82$$38, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_85$$38, "strtr", &_15, 26, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_86$$38);
ZVAL_STRING(_86$$38, "FileMaxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _82$$38, "__construct", &_17, 466, _85$$38, field, _86$$38, code);
zephir_check_temp_parameter(_86$$38);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _82$$38);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
}
RETURN_MM_BOOL(1);
}
/**
* Builds a Phalcon\Mvc\Model\Criteria based on an input array like _POST
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, fromInput) {
zend_bool _6$$4, _7$$7;
HashTable *_4$$3;
HashPosition _3$$3;
zend_class_entry *_2$$3;
int ZEPHIR_LAST_CALL_STATUS;
zval *data = NULL;
zval *modelName = NULL, *operator = NULL, *_12$$10;
zval *dependencyInjector, *modelName_param = NULL, *data_param = NULL, *operator_param = NULL, *attribute = NULL, *conditions = NULL, *field = NULL, *value = NULL, *type = NULL, *metaData = NULL, *model = NULL, *dataTypes = NULL, *bind = NULL, *criteria = NULL, *columnMap = NULL, *_0$$3 = NULL, *_1$$3 = NULL, **_5$$3, *_8$$9 = NULL, *_9$$9 = NULL, *_10$$8 = NULL, *_11$$10;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 1, &dependencyInjector, &modelName_param, &data_param, &operator_param);
if (unlikely(Z_TYPE_P(modelName_param) != IS_STRING && Z_TYPE_P(modelName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'modelName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(modelName_param) == IS_STRING)) {
zephir_get_strval(modelName, modelName_param);
} else {
ZEPHIR_INIT_VAR(modelName);
ZVAL_EMPTY_STRING(modelName);
}
data = data_param;
if (!operator_param) {
ZEPHIR_INIT_VAR(operator);
ZVAL_STRING(operator, "AND", 1);
} else {
if (unlikely(Z_TYPE_P(operator_param) != IS_STRING && Z_TYPE_P(operator_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'operator' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(operator_param) == IS_STRING)) {
zephir_get_strval(operator, operator_param);
} else {
ZEPHIR_INIT_VAR(operator);
ZVAL_EMPTY_STRING(operator);
}
}
ZEPHIR_INIT_VAR(conditions);
array_init(conditions);
if (zephir_fast_count_int(data TSRMLS_CC)) {
ZEPHIR_INIT_VAR(_0$$3);
ZVAL_STRING(_0$$3, "modelsMetadata", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&metaData, dependencyInjector, "getshared", NULL, 0, _0$$3);
zephir_check_temp_parameter(_0$$3);
zephir_check_call_status();
ZEPHIR_INIT_VAR(model);
zephir_fetch_safe_class(_1$$3, modelName);
_2$$3 = zend_fetch_class(Z_STRVAL_P(_1$$3), Z_STRLEN_P(_1$$3), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(model, _2$$3);
if (zephir_has_constructor(model TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_0$$3);
ZVAL_NULL(_0$$3);
ZEPHIR_CALL_METHOD(NULL, model, "__construct", NULL, 0, _0$$3, dependencyInjector);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&dataTypes, metaData, "getdatatypes", NULL, 0, model);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&columnMap, metaData, "getreversecolumnmap", NULL, 0, model);
zephir_check_call_status();
ZEPHIR_INIT_VAR(bind);
array_init(bind);
zephir_is_iterable(data, &_4$$3, &_3$$3, 0, 0, "phalcon/mvc/model/criteria.zep", 711);
for (
; zephir_hash_get_current_data_ex(_4$$3, (void**) &_5$$3, &_3$$3) == SUCCESS
; zephir_hash_move_forward_ex(_4$$3, &_3$$3)
) {
ZEPHIR_GET_HMKEY(field, _4$$3, _3$$3);
ZEPHIR_GET_HVALUE(value, _5$$3);
_6$$4 = Z_TYPE_P(columnMap) == IS_ARRAY;
if (_6$$4) {
_6$$4 = ((zephir_fast_count_int(columnMap TSRMLS_CC)) ? 1 : 0);
}
if (_6$$4) {
ZEPHIR_OBS_NVAR(attribute);
zephir_array_fetch(&attribute, columnMap, field, PH_NOISY, "phalcon/mvc/model/criteria.zep", 688 TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(attribute, field);
}
ZEPHIR_OBS_NVAR(type);
if (zephir_array_isset_fetch(&type, dataTypes, attribute, 0 TSRMLS_CC)) {
_7$$7 = Z_TYPE_P(value) != IS_NULL;
if (_7$$7) {
_7$$7 = !ZEPHIR_IS_STRING_IDENTICAL(value, "");
}
if (_7$$7) {
if (ZEPHIR_IS_LONG(type, 2)) {
ZEPHIR_INIT_LNVAR(_8$$9);
ZEPHIR_CONCAT_SVSVS(_8$$9, "[", field, "] LIKE :", field, ":");
zephir_array_append(&conditions, _8$$9, PH_SEPARATE, "phalcon/mvc/model/criteria.zep", 700);
ZEPHIR_INIT_LNVAR(_9$$9);
ZEPHIR_CONCAT_SVS(_9$$9, "%", value, "%");
zephir_array_update_zval(&bind, field, &_9$$9, PH_COPY | PH_SEPARATE);
continue;
}
ZEPHIR_INIT_LNVAR(_10$$8);
ZEPHIR_CONCAT_SVSVS(_10$$8, "[", field, "] = :", field, ":");
zephir_array_append(&conditions, _10$$8, PH_SEPARATE, "phalcon/mvc/model/criteria.zep", 707);
zephir_array_update_zval(&bind, field, &value, PH_COPY | PH_SEPARATE);
}
}
}
}
ZEPHIR_INIT_VAR(criteria);
object_init_ex(criteria, phalcon_mvc_model_criteria_ce);
if (zephir_has_constructor(criteria TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, criteria, "__construct", NULL, 0);
zephir_check_call_status();
}
if (zephir_fast_count_int(conditions TSRMLS_CC)) {
ZEPHIR_INIT_VAR(_11$$10);
ZEPHIR_INIT_VAR(_12$$10);
ZEPHIR_CONCAT_SVS(_12$$10, " ", operator, " ");
zephir_fast_join(_11$$10, _12$$10, conditions TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, criteria, "where", NULL, 328, _11$$10);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, criteria, "bind", NULL, 329, bind);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(NULL, criteria, "setmodelname", NULL, 320, modelName);
zephir_check_call_status();
RETURN_CCTOR(criteria);
}
/**
* Converts bound parameters such as :name: or ?1 into PDO bind params ?
*
*<code>
* print_r($connection->convertBoundParams('SELECT * FROM robots WHERE name = :name:', array('Bender')));
*</code>
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, convertBoundParams) {
HashTable *_4;
HashPosition _3;
zephir_nts_static zephir_fcall_cache_entry *_2 = NULL, *_8 = NULL;
int setOrder, ZEPHIR_LAST_CALL_STATUS;
zval *params = NULL;
zval *sql_param = NULL, *params_param = NULL, *boundSql = NULL, *placeHolders, *bindPattern, *matches, *placeMatch = NULL, *value = NULL, *_0 = NULL, *_1 = NULL, **_5, *_6, *_7;
zval *sql = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &sql_param, ¶ms_param);
if (unlikely(Z_TYPE_P(sql_param) != IS_STRING && Z_TYPE_P(sql_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'sql' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(sql_param) == IS_STRING)) {
zephir_get_strval(sql, sql_param);
} else {
ZEPHIR_INIT_VAR(sql);
ZVAL_EMPTY_STRING(sql);
}
if (!params_param) {
ZEPHIR_INIT_VAR(params);
array_init(params);
} else {
zephir_get_arrval(params, params_param);
}
ZEPHIR_INIT_VAR(placeHolders);
array_init(placeHolders);
ZEPHIR_INIT_VAR(bindPattern);
ZVAL_STRING(bindPattern, "/\\?([0-9]+)|:([a-zA-Z0-9_]+):/", 1);
ZEPHIR_INIT_VAR(matches);
ZVAL_NULL(matches);
setOrder = 2;
ZEPHIR_INIT_VAR(_0);
ZVAL_LONG(_0, setOrder);
Z_SET_ISREF_P(matches);
ZEPHIR_CALL_FUNCTION(&_1, "preg_match_all", &_2, bindPattern, sql, matches, _0);
Z_UNSET_ISREF_P(matches);
zephir_check_call_status();
if (zephir_is_true(_1)) {
zephir_is_iterable(matches, &_4, &_3, 0, 0, "phalcon/db/adapter/pdo.zep", 438);
for (
; zephir_hash_get_current_data_ex(_4, (void**) &_5, &_3) == SUCCESS
; zephir_hash_move_forward_ex(_4, &_3)
) {
ZEPHIR_GET_HVALUE(placeMatch, _5);
ZEPHIR_OBS_NVAR(value);
zephir_array_fetch_long(&_6, placeMatch, 1, PH_READONLY, "phalcon/db/adapter/pdo.zep", 424 TSRMLS_CC);
if (!(zephir_array_isset_fetch(&value, params, _6, 0 TSRMLS_CC))) {
if (zephir_array_isset_long(placeMatch, 2)) {
ZEPHIR_OBS_NVAR(value);
zephir_array_fetch_long(&_7, placeMatch, 2, PH_READONLY, "phalcon/db/adapter/pdo.zep", 426 TSRMLS_CC);
if (!(zephir_array_isset_fetch(&value, params, _7, 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Matched parameter wasn't found in parameters list", "phalcon/db/adapter/pdo.zep", 427);
return;
}
} else {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Matched parameter wasn't found in parameters list", "phalcon/db/adapter/pdo.zep", 430);
return;
}
}
zephir_array_append(&placeHolders, value, PH_SEPARATE, "phalcon/db/adapter/pdo.zep", 434);
}
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "?", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_FUNCTION(&boundSql, "preg_replace", &_8, bindPattern, _0, sql);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(boundSql, sql);
}
zephir_create_array(return_value, 2, 0 TSRMLS_CC);
zephir_array_update_string(&return_value, SL("sql"), &boundSql, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&return_value, SL("params"), &placeHolders, PH_COPY | PH_SEPARATE);
RETURN_MM();
}
/**
* Executes a prepared statement binding. This function uses integer indexes starting from zero
*
*<code>
* $statement = $db->prepare('SELECT * FROM robots WHERE name = :name');
* $result = $connection->executePrepared($statement, array('name' => 'Voltron'));
*</code>
*
* @param \PDOStatement statement
* @param array placeholders
* @param array dataTypes
* @return \PDOStatement
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, executePrepared) {
zephir_fcall_cache_entry *_3 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_1;
HashPosition _0;
zval *statement, *placeholders, *dataTypes, *wildcard = NULL, *value = NULL, *type = NULL, *castValue = NULL, *parameter = NULL, **_2;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 0, &statement, &placeholders, &dataTypes);
if (Z_TYPE_P(placeholders) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Placeholders must be an array", "phalcon/db/adapter/pdo.zep", 181);
return;
}
zephir_is_iterable(placeholders, &_1, &_0, 0, 0, "phalcon/db/adapter/pdo.zep", 225);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HMKEY(wildcard, _1, _0);
ZEPHIR_GET_HVALUE(value, _2);
if (Z_TYPE_P(wildcard) == IS_LONG) {
ZEPHIR_INIT_NVAR(parameter);
ZVAL_LONG(parameter, (zephir_get_numberval(wildcard) + 1));
} else {
if (Z_TYPE_P(wildcard) == IS_STRING) {
ZEPHIR_CPY_WRT(parameter, wildcard);
} else {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Invalid bind parameter (1)", "phalcon/db/adapter/pdo.zep", 192);
return;
}
}
if (Z_TYPE_P(dataTypes) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(type);
if (!(zephir_array_isset_fetch(&type, dataTypes, wildcard, 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Invalid bind type parameter (2)", "phalcon/db/adapter/pdo.zep", 199);
return;
}
if (ZEPHIR_IS_LONG(type, 32)) {
ZEPHIR_INIT_NVAR(castValue);
ZVAL_DOUBLE(castValue, zephir_get_doubleval(value));
ZEPHIR_INIT_NVAR(type);
ZVAL_LONG(type, 1024);
} else {
ZEPHIR_CPY_WRT(castValue, value);
}
if (ZEPHIR_IS_LONG(type, 1024)) {
ZEPHIR_CALL_METHOD(NULL, statement, "bindvalue", &_3, parameter, castValue);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(NULL, statement, "bindvalue", &_3, parameter, castValue, type);
zephir_check_call_status();
}
} else {
ZEPHIR_CALL_METHOD(NULL, statement, "bindvalue", &_3, parameter, value);
zephir_check_call_status();
}
}
ZEPHIR_CALL_METHOD(NULL, statement, "execute", NULL);
zephir_check_call_status();
RETVAL_ZVAL(statement, 1, 0);
RETURN_MM();
}
/**
* Returns current row in the resultset
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, current) {
zephir_nts_static zephir_fcall_cache_entry *_6 = NULL, *_8 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *result, *row = NULL, *hydrateMode, *columnMap, *activeRow = NULL, *_0, *_1, *_2 = NULL, *_3, *_4, *_5, *_7;
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);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_type"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
ZEPHIR_OBS_VAR(row);
zephir_read_property_this(&row, this_ptr, SL("_row"), PH_NOISY_CC);
} else {
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_rows"), PH_NOISY_CC);
if (Z_TYPE_P(_1) == IS_NULL) {
ZEPHIR_OBS_VAR(result);
zephir_read_property_this(&result, this_ptr, SL("_result"), PH_NOISY_CC);
if (Z_TYPE_P(result) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&_2, result, "fetchall", NULL);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_rows"), _2 TSRMLS_CC);
}
}
ZEPHIR_OBS_VAR(_3);
zephir_read_property_this(&_3, this_ptr, SL("_rows"), PH_NOISY_CC);
if (Z_TYPE_P(_3) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(row);
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_rows"), PH_NOISY_CC);
_5 = zephir_fetch_nproperty_this(this_ptr, SL("_pointer"), PH_NOISY_CC);
if (!(zephir_array_isset_fetch(&row, _4, _5, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(row);
ZVAL_BOOL(row, 0);
}
} else {
ZEPHIR_INIT_NVAR(row);
ZVAL_BOOL(row, 0);
}
}
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);
ZEPHIR_OBS_VAR(columnMap);
zephir_read_property_this(&columnMap, this_ptr, SL("_columnMap"), PH_NOISY_CC);
do {
if (ZEPHIR_IS_LONG(hydrateMode, 0)) {
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_model"), PH_NOISY_CC);
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_keepSnapshots"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_7);
ZVAL_LONG(_7, 0);
ZEPHIR_CALL_CE_STATIC(&activeRow, phalcon_mvc_model_ce, "cloneresultmap", &_6, _1, row, columnMap, _7, _4);
zephir_check_call_status();
break;
}
ZEPHIR_CALL_CE_STATIC(&activeRow, phalcon_mvc_model_ce, "cloneresultmaphydrate", &_8, row, columnMap, hydrateMode);
zephir_check_call_status();
break;
} while(0);
zephir_update_property_this(this_ptr, SL("_activeRow"), activeRow TSRMLS_CC);
RETURN_CCTOR(activeRow);
}