/**
* @link https://github.com/phalcon/zephir/issues/110
*/
PHP_METHOD(Test_NativeArray, issue110) {
zval byteUnits, _0;
zval *this_ptr = getThis();
ZVAL_UNDEF(&byteUnits);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&byteUnits);
zephir_create_array(&byteUnits, 9, 0 TSRMLS_CC);
add_assoc_long_ex(&byteUnits, SL("B"), 0);
add_assoc_long_ex(&byteUnits, SL("K"), 10);
add_assoc_long_ex(&byteUnits, SL("M"), 20);
add_assoc_long_ex(&byteUnits, SL("G"), 30);
add_assoc_long_ex(&byteUnits, SL("T"), 40);
add_assoc_long_ex(&byteUnits, SL("KB"), 10);
add_assoc_long_ex(&byteUnits, SL("MB"), 20);
add_assoc_long_ex(&byteUnits, SL("GB"), 30);
add_assoc_long_ex(&byteUnits, SL("TB"), 40);
ZEPHIR_INIT_VAR(&_0);
zephir_array_keys(&_0, &byteUnits TSRMLS_CC);
zephir_fast_join_str(return_value, SL("|"), &_0 TSRMLS_CC);
RETURN_MM();
}
/**
* 检查数组是否包含 Associative 键？
*
* @param array arr
* @param bool reusingKeys
* @return bool
*/
PHP_METHOD(DotPHP_Utils_ArrayUtil, isAssoc) {
int ZEPHIR_LAST_CALL_STATUS;
zend_bool reusingKeys;
zval *arr_param = NULL, *reusingKeys_param = NULL, *r = NULL, _0, _1, *_2, *_3;
zval *arr = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &arr_param, &reusingKeys_param);
zephir_get_arrval(arr, arr_param);
if (!reusingKeys_param) {
reusingKeys = 0;
} else {
reusingKeys = zephir_get_boolval(reusingKeys_param);
}
ZEPHIR_SINIT_VAR(_0);
ZVAL_LONG(&_0, 0);
ZEPHIR_SINIT_VAR(_1);
ZVAL_LONG(&_1, (zephir_fast_count_int(arr TSRMLS_CC) - 1));
ZEPHIR_CALL_FUNCTION(&r, "range", NULL, 24, &_0, &_1);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_2);
if (reusingKeys) {
ZVAL_BOOL(_2, !ZEPHIR_IS_IDENTICAL(arr, r));
} else {
ZEPHIR_INIT_VAR(_3);
zephir_array_keys(_3, arr TSRMLS_CC);
ZVAL_BOOL(_2, !ZEPHIR_IS_IDENTICAL(_3, r));
}
RETURN_CCTOR(_2);
}
/**
* Gets the list of service definitions.
*
* @return array
*/
PHP_METHOD(Pdm_Di_Container, getServices) {
zval *_0;
_0 = zephir_fetch_nproperty_this(this_ptr, SL("container"), PH_NOISY_CC);
zephir_array_keys(return_value, _0 TSRMLS_CC);
return;
}
PHP_METHOD(Yb_Std, uniqueValues) {
HashTable *_1;
HashPosition _0;
zephir_fcall_cache_entry *_5 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *uniqueKey = NULL;
zval *data_param = NULL, *uniqueKey_param = NULL, *k = NULL, *v = NULL, *arr = NULL, *uniqueValue = NULL, **_2, *_3$$4 = NULL, *_4$$4 = NULL, *_6$$5 = NULL, *_7$$5 = NULL;
zval *data = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &data_param, &uniqueKey_param);
zephir_get_arrval(data, data_param);
zephir_get_strval(uniqueKey, uniqueKey_param);
ZEPHIR_INIT_VAR(arr);
array_init(arr);
zephir_is_iterable(data, &_1, &_0, 0, 0, "yb/std.zep", 377);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HMKEY(k, _1, _0);
ZEPHIR_GET_HVALUE(v, _2);
if (unlikely(Z_TYPE_P(v) != IS_ARRAY)) {
ZEPHIR_INIT_NVAR(_3$$4);
object_init_ex(_3$$4, yb_exception_ce);
ZEPHIR_INIT_LNVAR(_4$$4);
ZEPHIR_CONCAT_SV(_4$$4, "Invalid item type, array required at: ", k);
ZEPHIR_CALL_METHOD(NULL, _3$$4, "__construct", &_5, 2, _4$$4);
zephir_check_call_status();
zephir_throw_exception_debug(_3$$4, "yb/std.zep", 368 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_OBS_NVAR(uniqueValue);
if (unlikely(!(zephir_array_isset_fetch(&uniqueValue, v, uniqueKey, 0 TSRMLS_CC)))) {
ZEPHIR_INIT_NVAR(_6$$5);
object_init_ex(_6$$5, yb_exception_ce);
ZEPHIR_INIT_LNVAR(_7$$5);
ZEPHIR_CONCAT_SV(_7$$5, "Cannot find value of unique at: ", k);
ZEPHIR_CALL_METHOD(NULL, _6$$5, "__construct", &_5, 2, _7$$5);
zephir_check_call_status();
zephir_throw_exception_debug(_6$$5, "yb/std.zep", 371 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
zephir_array_update_zval(&arr, uniqueValue, &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
}
zephir_array_keys(return_value, arr TSRMLS_CC);
RETURN_MM();
}
PHP_METHOD(Test_NativeArray, testArrayKeys) {
zval *param;
zephir_fetch_params(0, 1, 0, ¶m);
zephir_array_keys(return_value, param TSRMLS_CC);
return;
}
/**
* Returns an array of keys
*
* @return array
*/
PHP_METHOD(Xpl_Collection_ArrayObject, keys) {
zval *_0 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_CALL_METHOD(&_0, this_ptr, "getarraycopy", NULL, 0);
zephir_check_call_status();
zephir_array_keys(return_value, _0 TSRMLS_CC);
RETURN_MM();
}
PHP_METHOD(Test_NativeArray, testArrayKeys) {
zval *param, param_sub;
zval *this_ptr = getThis();
ZVAL_UNDEF(¶m_sub);
zephir_fetch_params(0, 1, 0, ¶m);
zephir_array_keys(return_value, param TSRMLS_CC);
return;
}
PHP_METHOD(Test_NativeArray, testImplodeArray) {
zval *param, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, ¶m);
ZEPHIR_INIT_VAR(_0);
zephir_array_keys(_0, param TSRMLS_CC);
zephir_fast_join_str(return_value, SL("|"), _0 TSRMLS_CC);
RETURN_MM();
}
PHP_METHOD(Test_NativeArray, testImplodeArray) {
zval *param, param_sub, _0;
zval *this_ptr = getThis();
ZVAL_UNDEF(¶m_sub);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, ¶m);
ZEPHIR_INIT_VAR(&_0);
zephir_array_keys(&_0, param TSRMLS_CC);
zephir_fast_join_str(return_value, SL("|"), &_0 TSRMLS_CC);
RETURN_MM();
}
/**
* Determine if data is associative array
*
* @param mixed data
* @return boolean
*/
PHP_METHOD(Phal_Format_Reader_Hal_JsonReader, isAssocArray) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_nts_static zephir_fcall_cache_entry *_4 = NULL;
zval *data, *_0, _1, _2, *_3 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &data);
ZEPHIR_INIT_VAR(_0);
zephir_array_keys(_0, data TSRMLS_CC);
ZEPHIR_SINIT_VAR(_1);
ZVAL_LONG(&_1, 0);
ZEPHIR_SINIT_VAR(_2);
ZVAL_LONG(&_2, (zephir_fast_count_int(data TSRMLS_CC) - 1));
ZEPHIR_CALL_FUNCTION(&_3, "range", &_4, &_1, &_2);
zephir_check_call_status();
RETURN_MM_BOOL(!ZEPHIR_IS_IDENTICAL(_0, _3));
}
/**
* @link https://github.com/phalcon/zephir/issues/110
*/
PHP_METHOD(Test_NativeArray, issue110) {
zval *byteUnits, *_0;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(byteUnits);
array_init_size(byteUnits, 13);
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(_0);
zephir_array_keys(_0, byteUnits TSRMLS_CC);
zephir_fast_join_str(return_value, SL("|"), _0 TSRMLS_CC);
RETURN_MM();
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_File, validate) {
zephir_fcall_cache_entry *_10 = NULL, *_12 = NULL, *_29 = NULL;
zend_bool _2, _3, _4, _6, _7, _13, _14, _15, _17, _18, _20, _24, _25, _37, _38, _40;
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *value = NULL, *message = NULL, *label = NULL, *replacePairs = NULL, *types = NULL, *byteUnits, *unit = NULL, *maxSize = NULL, *matches, *bytes, *mime = NULL, *tmp = NULL, *width, *height, *minResolution, *maxResolution, *minWidth = NULL, *maxWidth, *minHeight = NULL, *maxHeight, *_0 = NULL, *_SERVER, *_1, *_POST, *_FILES, *_5, *_8, *_9 = NULL, *_11 = NULL, *_16, *_19, *_21, *_22 = NULL, *_23 = NULL, *_26 = NULL, *_27, *_28, *_30 = NULL, *_31, _32 = zval_used_for_init, *_33, *_34 = NULL, *_35 = NULL, *_36, *_39 = NULL, *_41 = NULL;
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 (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field);
zephir_check_call_status();
}
zephir_array_fetch_string(&_1, _SERVER, SL("REQUEST_METHOD"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 62 TSRMLS_CC);
_2 = ZEPHIR_IS_STRING(_1, "POST");
if (_2) {
_2 = ZEPHIR_IS_EMPTY(_POST);
}
_3 = _2;
if (_3) {
_3 = ZEPHIR_IS_EMPTY(_FILES);
}
_4 = _3;
if (_4) {
zephir_array_fetch_string(&_5, _SERVER, SL("CONTENT_LENGTH"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 62 TSRMLS_CC);
_4 = ZEPHIR_GT_LONG(_5, 0);
}
_6 = _4;
if (!(_6)) {
_7 = zephir_array_isset_string(value, SS("error"));
if (_7) {
zephir_array_fetch_string(&_8, value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 62 TSRMLS_CC);
_7 = ZEPHIR_IS_LONG_IDENTICAL(_8, 1);
}
_6 = _7;
}
if (_6) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "messageIniSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
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 (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "FileIniSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_0);
object_init_ex(_0, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_9, "strtr", &_10, 53, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_11);
ZVAL_STRING(_11, "FileIniSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", &_12, 436, _9, field, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _0);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "allowEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_9, this_ptr, "issetoption", NULL, 0, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
_13 = zephir_is_true(_9);
if (_13) {
_14 = ZEPHIR_IS_EMPTY(value);
if (!(_14)) {
_15 = zephir_array_isset_string(value, SS("error"));
if (_15) {
zephir_array_fetch_string(&_16, value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 75 TSRMLS_CC);
_15 = ZEPHIR_IS_LONG_IDENTICAL(_16, 4);
}
_14 = _15;
}
_13 = _14;
}
if (_13) {
RETURN_MM_BOOL(1);
}
_17 = !(zephir_array_isset_string(value, SS("error")));
if (!(_17)) {
_17 = !(zephir_array_isset_string(value, SS("tmp_name")));
}
_18 = _17;
if (!(_18)) {
zephir_array_fetch_string(&_19, value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 79 TSRMLS_CC);
_18 = !ZEPHIR_IS_LONG_IDENTICAL(_19, 0);
}
_20 = _18;
if (!(_20)) {
zephir_array_fetch_string(&_21, value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 79 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_9, "is_uploaded_file", NULL, 232, _21);
zephir_check_call_status();
_20 = !zephir_is_true(_9);
}
if (_20) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "messageEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _11);
zephir_check_temp_parameter(_11);
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 (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "FileEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_11);
object_init_ex(_11, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_22, "strtr", &_10, 53, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_23);
ZVAL_STRING(_23, "FileEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _11, "__construct", &_12, 436, _22, field, _23);
zephir_check_temp_parameter(_23);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _11);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
_24 = !(zephir_array_isset_string(value, SS("name")));
if (!(_24)) {
_24 = !(zephir_array_isset_string(value, SS("type")));
}
_25 = _24;
if (!(_25)) {
_25 = !(zephir_array_isset_string(value, SS("size")));
}
if (_25) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "messageValid", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _11);
zephir_check_temp_parameter(_11);
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 (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "FileValid", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_11);
object_init_ex(_11, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_9, "strtr", &_10, 53, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_23);
ZVAL_STRING(_23, "FileValid", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _11, "__construct", &_12, 436, _9, field, _23);
zephir_check_temp_parameter(_23);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _11);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "maxSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_9, this_ptr, "issetoption", NULL, 0, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
if (zephir_is_true(_9)) {
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_NVAR(_11);
ZVAL_STRING(_11, "maxSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&maxSize, this_ptr, "getoption", NULL, 0, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
ZEPHIR_INIT_VAR(matches);
ZVAL_NULL(matches);
ZEPHIR_INIT_VAR(unit);
ZVAL_STRING(unit, "B", 1);
ZEPHIR_INIT_NVAR(_11);
ZEPHIR_INIT_NVAR(_23);
ZEPHIR_INIT_VAR(_26);
zephir_array_keys(_26, byteUnits TSRMLS_CC);
zephir_fast_join_str(_23, SL("|"), _26 TSRMLS_CC);
ZEPHIR_INIT_VAR(_27);
ZEPHIR_CONCAT_SVS(_27, "/^([0-9]+(?:\\.[0-9]+)?)(", _23, ")?$/Di");
zephir_preg_match(_11, _27, 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", 115 TSRMLS_CC);
}
zephir_array_fetch_long(&_28, matches, 1, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 118 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_22, "floatval", &_29, 311, _28);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_30);
zephir_array_fetch(&_31, byteUnits, unit, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 118 TSRMLS_CC);
ZEPHIR_SINIT_VAR(_32);
ZVAL_LONG(&_32, 2);
zephir_pow_function(_30, &_32, _31);
ZEPHIR_INIT_VAR(bytes);
mul_function(bytes, _22, _30 TSRMLS_CC);
zephir_array_fetch_string(&_33, value, SL("size"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 120 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_22, "floatval", &_29, 311, _33);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_34, "floatval", &_29, 311, bytes);
zephir_check_call_status();
if (ZEPHIR_GT(_22, _34)) {
ZEPHIR_INIT_NVAR(_30);
ZVAL_STRING(_30, "messageSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _30);
zephir_check_temp_parameter(_30);
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 (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_30);
ZVAL_STRING(_30, "FileSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _30);
zephir_check_temp_parameter(_30);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_30);
object_init_ex(_30, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_35, "strtr", &_10, 53, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_36);
ZVAL_STRING(_36, "FileSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _30, "__construct", &_12, 436, _35, field, _36);
zephir_check_temp_parameter(_36);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _30);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "allowedTypes", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_9, this_ptr, "issetoption", NULL, 0, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
if (zephir_is_true(_9)) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "allowedTypes", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&types, this_ptr, "getoption", NULL, 0, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
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", 138);
return;
}
if ((zephir_function_exists_ex(SS("finfo_open") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_SINIT_NVAR(_32);
ZVAL_LONG(&_32, 16);
ZEPHIR_CALL_FUNCTION(&tmp, "finfo_open", NULL, 229, &_32);
zephir_check_call_status();
zephir_array_fetch_string(&_28, value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 143 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&mime, "finfo_file", NULL, 230, tmp, _28);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(NULL, "finfo_close", NULL, 231, tmp);
zephir_check_call_status();
} else {
ZEPHIR_OBS_NVAR(mime);
zephir_array_fetch_string(&mime, value, SL("type"), PH_NOISY, "phalcon/validation/validator/file.zep", 147 TSRMLS_CC);
}
if (!(zephir_fast_in_array(mime, types TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "messageType", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _11);
zephir_check_temp_parameter(_11);
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(_11);
zephir_fast_join_str(_11, SL(", "), types TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":types"), &_11, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "FileType", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_11);
object_init_ex(_11, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_22, "strtr", &_10, 53, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_23);
ZVAL_STRING(_23, "FileType", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _11, "__construct", &_12, 436, _22, field, _23);
zephir_check_temp_parameter(_23);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _11);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "minResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_9, this_ptr, "issetoption", NULL, 0, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
_37 = zephir_is_true(_9);
if (!(_37)) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "maxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_22, this_ptr, "issetoption", NULL, 0, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
_37 = zephir_is_true(_22);
}
if (_37) {
zephir_array_fetch_string(&_28, value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 164 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&tmp, "getimagesize", NULL, 249, _28);
zephir_check_call_status();
ZEPHIR_OBS_VAR(width);
zephir_array_fetch_long(&width, tmp, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 165 TSRMLS_CC);
ZEPHIR_OBS_VAR(height);
zephir_array_fetch_long(&height, tmp, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 166 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "minResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_34, this_ptr, "issetoption", NULL, 0, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
if (zephir_is_true(_34)) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "minResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_35, this_ptr, "getoption", NULL, 0, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
ZEPHIR_INIT_VAR(minResolution);
zephir_fast_explode_str(minResolution, SL("x"), _35, LONG_MAX TSRMLS_CC);
ZEPHIR_OBS_VAR(minWidth);
zephir_array_fetch_long(&minWidth, minResolution, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 170 TSRMLS_CC);
ZEPHIR_OBS_VAR(minHeight);
zephir_array_fetch_long(&minHeight, minResolution, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 171 TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(minWidth);
ZVAL_LONG(minWidth, 1);
ZEPHIR_INIT_NVAR(minHeight);
ZVAL_LONG(minHeight, 1);
}
_38 = ZEPHIR_LT(width, minWidth);
if (!(_38)) {
_38 = ZEPHIR_LT(height, minHeight);
}
if (_38) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "messageMinResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _11);
zephir_check_temp_parameter(_11);
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(_11);
ZVAL_STRING(_11, "minResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_35, this_ptr, "getoption", NULL, 0, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
zephir_array_update_string(&replacePairs, SL(":min"), &_35, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "FileMinResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_11);
object_init_ex(_11, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_35, "strtr", &_10, 53, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_23);
ZVAL_STRING(_23, "FileMinResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _11, "__construct", &_12, 436, _35, field, _23);
zephir_check_temp_parameter(_23);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _11);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_NVAR(_23);
ZVAL_STRING(_23, "maxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_35, this_ptr, "issetoption", NULL, 0, _23);
zephir_check_temp_parameter(_23);
zephir_check_call_status();
if (zephir_is_true(_35)) {
ZEPHIR_INIT_NVAR(_23);
ZVAL_STRING(_23, "maxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_39, this_ptr, "getoption", NULL, 0, _23);
zephir_check_temp_parameter(_23);
zephir_check_call_status();
ZEPHIR_INIT_VAR(maxResolution);
zephir_fast_explode_str(maxResolution, SL("x"), _39, LONG_MAX TSRMLS_CC);
ZEPHIR_OBS_VAR(maxWidth);
zephir_array_fetch_long(&maxWidth, maxResolution, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 192 TSRMLS_CC);
ZEPHIR_OBS_VAR(maxHeight);
zephir_array_fetch_long(&maxHeight, maxResolution, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 193 TSRMLS_CC);
_40 = ZEPHIR_GT(width, maxWidth);
if (!(_40)) {
_40 = ZEPHIR_GT(height, maxHeight);
}
if (_40) {
ZEPHIR_INIT_NVAR(_23);
ZVAL_STRING(_23, "messageMaxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _23);
zephir_check_temp_parameter(_23);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(replacePairs);
zephir_create_array(replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_23);
ZVAL_STRING(_23, "maxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_41, this_ptr, "getoption", NULL, 0, _23);
zephir_check_temp_parameter(_23);
zephir_check_call_status();
zephir_array_update_string(&replacePairs, SL(":max"), &_41, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_23);
ZVAL_STRING(_23, "FileMaxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _23);
zephir_check_temp_parameter(_23);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_23);
object_init_ex(_23, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_41, "strtr", &_10, 53, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_26);
ZVAL_STRING(_26, "FileMaxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _23, "__construct", &_12, 436, _41, field, _26);
zephir_check_temp_parameter(_26);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _23);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
}
RETURN_MM_BOOL(1);
}
/**
* Get modified params for handler using reflection
*/
PHP_METHOD(Phalcon_Mvc_Model_Binder, getParamsFromReflection) {
zend_class_entry *_8$$10, *_9$$14, *_13$$16, *_14$$18;
HashTable *_2;
HashPosition _1;
zephir_fcall_cache_entry *_7 = NULL, *_12 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *cacheKey = NULL;
zval *params = NULL;
zval *handler, *params_param = NULL, *cacheKey_param = NULL, *methodName, *methodParams = NULL, *reflection = NULL, *paramKey = NULL, *methodParam = NULL, *paramsCache = NULL, *className = NULL, *realClasses = NULL, *boundModel = NULL, *cache = NULL, *handlerClass = NULL, *reflectionClass = NULL, *paramsKeys = NULL, *paramValue = NULL, *_0, **_3, *_4$$7, _5$$5 = zval_used_for_init, *_6$$5 = NULL, *_10$$15 = NULL, *_11$$15 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &handler, ¶ms_param, &cacheKey_param, &methodName);
zephir_get_arrval(params, params_param);
zephir_get_strval(cacheKey, cacheKey_param);
ZEPHIR_INIT_VAR(realClasses);
ZVAL_NULL(realClasses);
ZEPHIR_INIT_VAR(paramsCache);
array_init(paramsCache);
ZEPHIR_INIT_VAR(reflection);
if (Z_TYPE_P(methodName) != IS_NULL) {
object_init_ex(reflection, zephir_get_internal_ce(SS("reflectionmethod") TSRMLS_CC));
ZEPHIR_CALL_METHOD(NULL, reflection, "__construct", NULL, 324, handler, methodName);
zephir_check_call_status();
} else {
object_init_ex(reflection, zephir_get_internal_ce(SS("reflectionfunction") TSRMLS_CC));
ZEPHIR_CALL_METHOD(NULL, reflection, "__construct", NULL, 82, handler);
zephir_check_call_status();
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("cache"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(cache, _0);
ZEPHIR_CALL_METHOD(&methodParams, reflection, "getparameters", NULL, 83);
zephir_check_call_status();
ZEPHIR_INIT_VAR(paramsKeys);
zephir_array_keys(paramsKeys, params TSRMLS_CC);
zephir_is_iterable(methodParams, &_2, &_1, 0, 0, "phalcon/mvc/model/binder.zep", 197);
for (
; zend_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zend_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HMKEY(paramKey, _2, _1);
ZEPHIR_GET_HVALUE(methodParam, _3);
ZEPHIR_CALL_METHOD(&reflectionClass, methodParam, "getclass", NULL, 0);
zephir_check_call_status();
if (!(zephir_is_true(reflectionClass))) {
continue;
}
ZEPHIR_CALL_METHOD(&className, reflectionClass, "getname", NULL, 0);
zephir_check_call_status();
if (!(zephir_array_isset(params, paramKey))) {
zephir_array_fetch(&_4$$7, paramsKeys, paramKey, PH_NOISY | PH_READONLY, "phalcon/mvc/model/binder.zep", 157 TSRMLS_CC);
ZEPHIR_CPY_WRT(paramKey, _4$$7);
}
ZEPHIR_INIT_NVAR(boundModel);
ZVAL_NULL(boundModel);
ZEPHIR_OBS_NVAR(paramValue);
zephir_array_fetch(¶mValue, params, paramKey, PH_NOISY, "phalcon/mvc/model/binder.zep", 160 TSRMLS_CC);
ZEPHIR_SINIT_NVAR(_5$$5);
ZVAL_STRING(&_5$$5, "Phalcon\\Mvc\\Model", 0);
ZEPHIR_CALL_FUNCTION(&_6$$5, "is_subclass_of", &_7, 325, className, &_5$$5);
zephir_check_call_status();
if (ZEPHIR_IS_STRING(className, "Phalcon\\Mvc\\Model")) {
if (Z_TYPE_P(realClasses) == IS_NULL) {
if (zephir_instance_of_ev(handler, phalcon_mvc_controller_bindmodelinterface_ce TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(handlerClass);
zephir_get_class(handlerClass, handler, 0 TSRMLS_CC);
_8$$10 = zephir_fetch_class(handlerClass TSRMLS_CC);
ZEPHIR_CALL_CE_STATIC(&realClasses, _8$$10, "getmodelname", NULL, 0);
zephir_check_call_status();
} else if (zephir_instance_of_ev(handler, phalcon_mvc_model_binder_bindableinterface_ce TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(&realClasses, handler, "getmodelname", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Handler must implement Phalcon\\Mvc\\Model\\Binder\\BindableInterface in order to use Phalcon\\Mvc\\Model as parameter", "phalcon/mvc/model/binder.zep", 170);
return;
}
}
if (Z_TYPE_P(realClasses) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(className);
if (zephir_array_isset_fetch(&className, realClasses, paramKey, 0 TSRMLS_CC)) {
_9$$14 = zephir_fetch_class(className TSRMLS_CC);
ZEPHIR_CALL_CE_STATIC(&boundModel, _9$$14, "findfirst", NULL, 0, paramValue);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(_10$$15);
object_init_ex(_10$$15, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_11$$15);
ZEPHIR_CONCAT_SVS(_11$$15, "You should provide model class name for ", paramKey, " parameter");
ZEPHIR_CALL_METHOD(NULL, _10$$15, "__construct", &_12, 9, _11$$15);
zephir_check_call_status();
zephir_throw_exception_debug(_10$$15, "phalcon/mvc/model/binder.zep", 177 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} else if (Z_TYPE_P(realClasses) == IS_STRING) {
_13$$16 = zephir_fetch_class(realClasses TSRMLS_CC);
ZEPHIR_CALL_CE_STATIC(&boundModel, _13$$16, "findfirst", NULL, 0, paramValue);
zephir_check_call_status();
ZEPHIR_CPY_WRT(className, realClasses);
} else {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "getModelName should return array or string", "phalcon/mvc/model/binder.zep", 183);
return;
}
} else if (zephir_is_true(_6$$5)) {
_14$$18 = zephir_fetch_class(className TSRMLS_CC);
ZEPHIR_CALL_CE_STATIC(&boundModel, _14$$18, "findfirst", NULL, 0, paramValue);
zephir_check_call_status();
}
if (Z_TYPE_P(boundModel) != IS_NULL) {
zephir_update_property_array(this_ptr, SL("originalValues"), paramKey, paramValue TSRMLS_CC);
zephir_array_update_zval(¶ms, paramKey, &boundModel, PH_COPY | PH_SEPARATE);
zephir_update_property_array(this_ptr, SL("boundModels"), paramKey, boundModel TSRMLS_CC);
zephir_array_update_zval(¶msCache, paramKey, &className, PH_COPY | PH_SEPARATE);
}
}
if (Z_TYPE_P(cache) != IS_NULL) {
ZEPHIR_CALL_METHOD(NULL, cache, "save", NULL, 0, cacheKey, paramsCache);
zephir_check_call_status();
}
zephir_update_property_array(this_ptr, SL("internalCache"), cacheKey, paramsCache TSRMLS_CC);
RETURN_CTOR(params);
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_File, validate) {
zend_bool _1, _2, _3, _5, _6, _11, _12, _14, _20, _21, _50, _57$$16, _64$$21;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *validation, validation_sub, *field, field_sub, *_SERVER, *_POST, *_FILES, value, message, label, replacePairs, types, byteUnits, unit, maxSize, matches, bytes, mime, tmp, width, height, minResolution, maxResolution, minWidth, maxWidth, minHeight, maxHeight, fieldTypes, code, minResolutionArray, maxResolutionArray, _0, _4, _7, _13, _15, _16, _25, _26, _42, _49, _51, _8$$3, _9$$3, _10$$3, _17$$4, _18$$4, _19$$4, _22$$5, _23$$5, _24$$5, _27$$6, _29$$6, _30$$6, _31$$6, _32$$6, _33$$6, _34$$6, _35$$6, _36$$6, _37$$6, _38$$6, _28$$7, _39$$9, _40$$9, _41$$9, _43$$10, _44$$13, _45$$13, _46$$15, _47$$15, _48$$15, _52$$16, _53$$16, _54$$16, _61$$16, _55$$17, _56$$18, _58$$20, _59$$20, _60$$20, _62$$21, _63$$22, _65$$23, _66$$23, _67$$23;
zval *this_ptr = getThis();
ZVAL_UNDEF(&validation_sub);
ZVAL_UNDEF(&field_sub);
ZVAL_UNDEF(&value);
ZVAL_UNDEF(&message);
ZVAL_UNDEF(&label);
ZVAL_UNDEF(&replacePairs);
ZVAL_UNDEF(&types);
ZVAL_UNDEF(&byteUnits);
ZVAL_UNDEF(&unit);
ZVAL_UNDEF(&maxSize);
ZVAL_UNDEF(&matches);
ZVAL_UNDEF(&bytes);
ZVAL_UNDEF(&mime);
ZVAL_UNDEF(&tmp);
ZVAL_UNDEF(&width);
ZVAL_UNDEF(&height);
ZVAL_UNDEF(&minResolution);
ZVAL_UNDEF(&maxResolution);
ZVAL_UNDEF(&minWidth);
ZVAL_UNDEF(&maxWidth);
ZVAL_UNDEF(&minHeight);
ZVAL_UNDEF(&maxHeight);
ZVAL_UNDEF(&fieldTypes);
ZVAL_UNDEF(&code);
ZVAL_UNDEF(&minResolutionArray);
ZVAL_UNDEF(&maxResolutionArray);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_4);
ZVAL_UNDEF(&_7);
ZVAL_UNDEF(&_13);
ZVAL_UNDEF(&_15);
ZVAL_UNDEF(&_16);
ZVAL_UNDEF(&_25);
ZVAL_UNDEF(&_26);
ZVAL_UNDEF(&_42);
ZVAL_UNDEF(&_49);
ZVAL_UNDEF(&_51);
ZVAL_UNDEF(&_8$$3);
ZVAL_UNDEF(&_9$$3);
ZVAL_UNDEF(&_10$$3);
ZVAL_UNDEF(&_17$$4);
ZVAL_UNDEF(&_18$$4);
ZVAL_UNDEF(&_19$$4);
ZVAL_UNDEF(&_22$$5);
ZVAL_UNDEF(&_23$$5);
ZVAL_UNDEF(&_24$$5);
ZVAL_UNDEF(&_27$$6);
ZVAL_UNDEF(&_29$$6);
ZVAL_UNDEF(&_30$$6);
ZVAL_UNDEF(&_31$$6);
ZVAL_UNDEF(&_32$$6);
ZVAL_UNDEF(&_33$$6);
ZVAL_UNDEF(&_34$$6);
ZVAL_UNDEF(&_35$$6);
ZVAL_UNDEF(&_36$$6);
ZVAL_UNDEF(&_37$$6);
ZVAL_UNDEF(&_38$$6);
ZVAL_UNDEF(&_28$$7);
ZVAL_UNDEF(&_39$$9);
ZVAL_UNDEF(&_40$$9);
ZVAL_UNDEF(&_41$$9);
ZVAL_UNDEF(&_43$$10);
ZVAL_UNDEF(&_44$$13);
ZVAL_UNDEF(&_45$$13);
ZVAL_UNDEF(&_46$$15);
ZVAL_UNDEF(&_47$$15);
ZVAL_UNDEF(&_48$$15);
ZVAL_UNDEF(&_52$$16);
ZVAL_UNDEF(&_53$$16);
ZVAL_UNDEF(&_54$$16);
ZVAL_UNDEF(&_61$$16);
ZVAL_UNDEF(&_55$$17);
ZVAL_UNDEF(&_56$$18);
ZVAL_UNDEF(&_58$$20);
ZVAL_UNDEF(&_59$$20);
ZVAL_UNDEF(&_60$$20);
ZVAL_UNDEF(&_62$$21);
ZVAL_UNDEF(&_63$$22);
ZVAL_UNDEF(&_65$$23);
ZVAL_UNDEF(&_66$$23);
ZVAL_UNDEF(&_67$$23);
ZEPHIR_MM_GROW();
zephir_get_global(&_FILES, SL("_FILES"));
zephir_get_global(&_POST, SL("_POST"));
zephir_get_global(&_SERVER, SL("_SERVER"));
zephir_fetch_params(1, 2, 0, &validation, &field);
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&label, this_ptr, "preparelabel", NULL, 0, validation, field);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&code, this_ptr, "preparecode", NULL, 0, field);
zephir_check_call_status();
zephir_array_fetch_string(&_0, _SERVER, SL("REQUEST_METHOD"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 103 TSRMLS_CC);
_1 = ZEPHIR_IS_STRING(&_0, "POST");
if (_1) {
_1 = ZEPHIR_IS_EMPTY(_POST);
}
_2 = _1;
if (_2) {
_2 = ZEPHIR_IS_EMPTY(_FILES);
}
_3 = _2;
if (_3) {
zephir_array_fetch_string(&_4, _SERVER, SL("CONTENT_LENGTH"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 103 TSRMLS_CC);
_3 = ZEPHIR_GT_LONG(&_4, 0);
}
_5 = _3;
if (!(_5)) {
_6 = zephir_array_isset_string(&value, SL("error"));
if (_6) {
zephir_array_fetch_string(&_7, &value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 103 TSRMLS_CC);
_6 = ZEPHIR_IS_LONG_IDENTICAL(&_7, 1);
}
_5 = _6;
}
if (_5) {
ZEPHIR_INIT_VAR(&_8$$3);
ZVAL_STRING(&_8$$3, "FileIniSize");
ZEPHIR_INIT_VAR(&_9$$3);
ZVAL_STRING(&_9$$3, "messageIniSize");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_8$$3, &_9$$3);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&replacePairs);
zephir_create_array(&replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_8$$3);
object_init_ex(&_8$$3, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_10$$3, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_9$$3);
ZVAL_STRING(&_9$$3, "FileIniSize");
ZEPHIR_CALL_METHOD(NULL, &_8$$3, "__construct", NULL, 295, &_10$$3, field, &_9$$3, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_8$$3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
_11 = !(zephir_array_isset_string(&value, SL("error")));
if (!(_11)) {
_11 = !(zephir_array_isset_string(&value, SL("tmp_name")));
}
_12 = _11;
if (!(_12)) {
zephir_array_fetch_string(&_13, &value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 119 TSRMLS_CC);
_12 = !ZEPHIR_IS_LONG_IDENTICAL(&_13, 0);
}
_14 = _12;
if (!(_14)) {
zephir_array_fetch_string(&_15, &value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 119 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_16, "is_uploaded_file", NULL, 228, &_15);
zephir_check_call_status();
_14 = !zephir_is_true(&_16);
}
if (_14) {
ZEPHIR_INIT_VAR(&_17$$4);
ZVAL_STRING(&_17$$4, "FileEmpty");
ZEPHIR_INIT_VAR(&_18$$4);
ZVAL_STRING(&_18$$4, "messageEmpty");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_17$$4, &_18$$4);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&replacePairs);
zephir_create_array(&replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_17$$4);
object_init_ex(&_17$$4, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_19$$4, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_18$$4);
ZVAL_STRING(&_18$$4, "FileEmpty");
ZEPHIR_CALL_METHOD(NULL, &_17$$4, "__construct", NULL, 295, &_19$$4, field, &_18$$4, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_17$$4);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
_20 = !(zephir_array_isset_string(&value, SL("name")));
if (!(_20)) {
_20 = !(zephir_array_isset_string(&value, SL("type")));
}
_21 = _20;
if (!(_21)) {
_21 = !(zephir_array_isset_string(&value, SL("size")));
}
if (_21) {
ZEPHIR_INIT_VAR(&_22$$5);
ZVAL_STRING(&_22$$5, "FileValid");
ZEPHIR_INIT_VAR(&_23$$5);
ZVAL_STRING(&_23$$5, "messageValid");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_22$$5, &_23$$5);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&replacePairs);
zephir_create_array(&replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_22$$5);
object_init_ex(&_22$$5, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_24$$5, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_23$$5);
ZVAL_STRING(&_23$$5, "FileValid");
ZEPHIR_CALL_METHOD(NULL, &_22$$5, "__construct", NULL, 295, &_24$$5, field, &_23$$5, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_22$$5);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_VAR(&_26);
ZVAL_STRING(&_26, "maxSize");
ZEPHIR_CALL_METHOD(&_25, this_ptr, "hasoption", NULL, 0, &_26);
zephir_check_call_status();
if (zephir_is_true(&_25)) {
ZEPHIR_INIT_VAR(&byteUnits);
zephir_create_array(&byteUnits, 9, 0 TSRMLS_CC);
add_assoc_long_ex(&byteUnits, SL("B"), 0);
add_assoc_long_ex(&byteUnits, SL("K"), 10);
add_assoc_long_ex(&byteUnits, SL("M"), 20);
add_assoc_long_ex(&byteUnits, SL("G"), 30);
add_assoc_long_ex(&byteUnits, SL("T"), 40);
add_assoc_long_ex(&byteUnits, SL("KB"), 10);
add_assoc_long_ex(&byteUnits, SL("MB"), 20);
add_assoc_long_ex(&byteUnits, SL("GB"), 30);
add_assoc_long_ex(&byteUnits, SL("TB"), 40);
ZEPHIR_INIT_VAR(&_27$$6);
ZVAL_STRING(&_27$$6, "maxSize");
ZEPHIR_CALL_METHOD(&maxSize, this_ptr, "getoption", NULL, 0, &_27$$6);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&matches);
ZVAL_NULL(&matches);
ZEPHIR_INIT_VAR(&unit);
ZVAL_STRING(&unit, "B");
if (Z_TYPE_P(&maxSize) == IS_ARRAY) {
zephir_array_fetch(&_28$$7, &maxSize, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 159 TSRMLS_CC);
ZEPHIR_CPY_WRT(&maxSize, &_28$$7);
}
ZEPHIR_INIT_NVAR(&_27$$6);
ZEPHIR_INIT_VAR(&_29$$6);
zephir_array_keys(&_29$$6, &byteUnits TSRMLS_CC);
zephir_fast_join_str(&_27$$6, SL("|"), &_29$$6 TSRMLS_CC);
ZEPHIR_INIT_VAR(&_30$$6);
ZEPHIR_CONCAT_SVS(&_30$$6, "/^([0-9]+(?:\\.[0-9]+)?)(", &_27$$6, ")?$/Di");
ZEPHIR_INIT_VAR(&_31$$6);
zephir_preg_match(&_31$$6, &_30$$6, &maxSize, &matches, 0, 0 , 0 TSRMLS_CC);
if (zephir_array_isset_long(&matches, 2)) {
ZEPHIR_OBS_NVAR(&unit);
zephir_array_fetch_long(&unit, &matches, 2, PH_NOISY, "phalcon/validation/validator/file.zep", 165 TSRMLS_CC);
}
zephir_array_fetch_long(&_32$$6, &matches, 1, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 168 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_33$$6, "floatval", NULL, 319, &_32$$6);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_34$$6);
zephir_array_fetch(&_35$$6, &byteUnits, &unit, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 168 TSRMLS_CC);
ZVAL_LONG(&_36$$6, 2);
zephir_pow_function(&_34$$6, &_36$$6, &_35$$6);
ZEPHIR_INIT_VAR(&bytes);
mul_function(&bytes, &_33$$6, &_34$$6 TSRMLS_CC);
zephir_array_fetch_string(&_37$$6, &value, SL("size"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 170 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_33$$6, "floatval", NULL, 319, &_37$$6);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_38$$6, "floatval", NULL, 319, &bytes);
zephir_check_call_status();
if (ZEPHIR_GT(&_33$$6, &_38$$6)) {
ZEPHIR_INIT_VAR(&_39$$9);
ZVAL_STRING(&_39$$9, "FileSize");
ZEPHIR_INIT_VAR(&_40$$9);
ZVAL_STRING(&_40$$9, "messageSize");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_39$$9, &_40$$9);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&replacePairs);
zephir_create_array(&replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":max"), &maxSize, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_39$$9);
object_init_ex(&_39$$9, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_41$$9, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_40$$9);
ZVAL_STRING(&_40$$9, "FileSize");
ZEPHIR_CALL_METHOD(NULL, &_39$$9, "__construct", NULL, 295, &_41$$9, field, &_40$$9, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_39$$9);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_NVAR(&_26);
ZVAL_STRING(&_26, "allowedTypes");
ZEPHIR_CALL_METHOD(&_42, this_ptr, "hasoption", NULL, 0, &_26);
zephir_check_call_status();
if (zephir_is_true(&_42)) {
ZEPHIR_INIT_VAR(&_43$$10);
ZVAL_STRING(&_43$$10, "allowedTypes");
ZEPHIR_CALL_METHOD(&types, this_ptr, "getoption", NULL, 0, &_43$$10);
zephir_check_call_status();
ZEPHIR_OBS_VAR(&fieldTypes);
if (zephir_array_isset_fetch(&fieldTypes, &types, field, 0 TSRMLS_CC)) {
ZEPHIR_CPY_WRT(&types, &fieldTypes);
}
if (Z_TYPE_P(&types) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Option 'allowedTypes' must be an array", "phalcon/validation/validator/file.zep", 196);
return;
}
if ((zephir_function_exists_ex(SL("finfo_open") TSRMLS_CC) == SUCCESS)) {
ZVAL_LONG(&_44$$13, 16);
ZEPHIR_CALL_FUNCTION(&tmp, "finfo_open", NULL, 225, &_44$$13);
zephir_check_call_status();
zephir_array_fetch_string(&_45$$13, &value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 201 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&mime, "finfo_file", NULL, 226, &tmp, &_45$$13);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(NULL, "finfo_close", NULL, 227, &tmp);
zephir_check_call_status();
} else {
ZEPHIR_OBS_NVAR(&mime);
zephir_array_fetch_string(&mime, &value, SL("type"), PH_NOISY, "phalcon/validation/validator/file.zep", 205 TSRMLS_CC);
}
if (!(zephir_fast_in_array(&mime, &types TSRMLS_CC))) {
ZEPHIR_INIT_VAR(&_46$$15);
ZVAL_STRING(&_46$$15, "FileType");
ZEPHIR_INIT_VAR(&_47$$15);
ZVAL_STRING(&_47$$15, "messageType");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_46$$15, &_47$$15);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&replacePairs);
zephir_create_array(&replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_46$$15);
zephir_fast_join_str(&_46$$15, SL(", "), &types TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":types"), &_46$$15, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_46$$15);
object_init_ex(&_46$$15, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_48$$15, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_47$$15);
ZVAL_STRING(&_47$$15, "FileType");
ZEPHIR_CALL_METHOD(NULL, &_46$$15, "__construct", NULL, 295, &_48$$15, field, &_47$$15, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_46$$15);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_NVAR(&_26);
ZVAL_STRING(&_26, "minResolution");
ZEPHIR_CALL_METHOD(&_49, this_ptr, "hasoption", NULL, 0, &_26);
zephir_check_call_status();
_50 = zephir_is_true(&_49);
if (!(_50)) {
ZEPHIR_INIT_NVAR(&_26);
ZVAL_STRING(&_26, "maxResolution");
ZEPHIR_CALL_METHOD(&_51, this_ptr, "hasoption", NULL, 0, &_26);
zephir_check_call_status();
_50 = zephir_is_true(&_51);
}
if (_50) {
zephir_array_fetch_string(&_52$$16, &value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 226 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&tmp, "getimagesize", NULL, 237, &_52$$16);
zephir_check_call_status();
ZEPHIR_OBS_VAR(&width);
zephir_array_fetch_long(&width, &tmp, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 227 TSRMLS_CC);
ZEPHIR_OBS_VAR(&height);
zephir_array_fetch_long(&height, &tmp, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 228 TSRMLS_CC);
ZEPHIR_INIT_VAR(&_54$$16);
ZVAL_STRING(&_54$$16, "minResolution");
ZEPHIR_CALL_METHOD(&_53$$16, this_ptr, "hasoption", NULL, 0, &_54$$16);
zephir_check_call_status();
if (zephir_is_true(&_53$$16)) {
ZEPHIR_INIT_VAR(&_55$$17);
ZVAL_STRING(&_55$$17, "minResolution");
ZEPHIR_CALL_METHOD(&minResolution, this_ptr, "getoption", NULL, 0, &_55$$17);
zephir_check_call_status();
if (Z_TYPE_P(&minResolution) == IS_ARRAY) {
zephir_array_fetch(&_56$$18, &minResolution, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 233 TSRMLS_CC);
ZEPHIR_CPY_WRT(&minResolution, &_56$$18);
}
ZEPHIR_INIT_VAR(&minResolutionArray);
zephir_fast_explode_str(&minResolutionArray, SL("x"), &minResolution, LONG_MAX TSRMLS_CC);
ZEPHIR_OBS_VAR(&minWidth);
zephir_array_fetch_long(&minWidth, &minResolutionArray, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 236 TSRMLS_CC);
ZEPHIR_OBS_VAR(&minHeight);
zephir_array_fetch_long(&minHeight, &minResolutionArray, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 237 TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(&minWidth);
ZVAL_LONG(&minWidth, 1);
ZEPHIR_INIT_NVAR(&minHeight);
ZVAL_LONG(&minHeight, 1);
}
_57$$16 = ZEPHIR_LT(&width, &minWidth);
if (!(_57$$16)) {
_57$$16 = ZEPHIR_LT(&height, &minHeight);
}
if (_57$$16) {
ZEPHIR_INIT_VAR(&_58$$20);
ZVAL_STRING(&_58$$20, "FileMinResolution");
ZEPHIR_INIT_VAR(&_59$$20);
ZVAL_STRING(&_59$$20, "messageMinResolution");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_58$$20, &_59$$20);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&replacePairs);
zephir_create_array(&replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":min"), &minResolution, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_58$$20);
object_init_ex(&_58$$20, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_60$$20, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_59$$20);
ZVAL_STRING(&_59$$20, "FileMinResolution");
ZEPHIR_CALL_METHOD(NULL, &_58$$20, "__construct", NULL, 295, &_60$$20, field, &_59$$20, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_58$$20);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_NVAR(&_54$$16);
ZVAL_STRING(&_54$$16, "maxResolution");
ZEPHIR_CALL_METHOD(&_61$$16, this_ptr, "hasoption", NULL, 0, &_54$$16);
zephir_check_call_status();
if (zephir_is_true(&_61$$16)) {
ZEPHIR_INIT_VAR(&_62$$21);
ZVAL_STRING(&_62$$21, "maxResolution");
ZEPHIR_CALL_METHOD(&maxResolution, this_ptr, "getoption", NULL, 0, &_62$$21);
zephir_check_call_status();
if (Z_TYPE_P(&maxResolution) == IS_ARRAY) {
zephir_array_fetch(&_63$$22, &maxResolution, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 263 TSRMLS_CC);
ZEPHIR_CPY_WRT(&maxResolution, &_63$$22);
}
ZEPHIR_INIT_VAR(&maxResolutionArray);
zephir_fast_explode_str(&maxResolutionArray, SL("x"), &maxResolution, LONG_MAX TSRMLS_CC);
ZEPHIR_OBS_VAR(&maxWidth);
zephir_array_fetch_long(&maxWidth, &maxResolutionArray, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 266 TSRMLS_CC);
ZEPHIR_OBS_VAR(&maxHeight);
zephir_array_fetch_long(&maxHeight, &maxResolutionArray, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 267 TSRMLS_CC);
_64$$21 = ZEPHIR_GT(&width, &maxWidth);
if (!(_64$$21)) {
_64$$21 = ZEPHIR_GT(&height, &maxHeight);
}
if (_64$$21) {
ZEPHIR_INIT_VAR(&_65$$23);
ZVAL_STRING(&_65$$23, "FileMaxResolution");
ZEPHIR_INIT_VAR(&_66$$23);
ZVAL_STRING(&_66$$23, "messageMaxResolution");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_65$$23, &_66$$23);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&replacePairs);
zephir_create_array(&replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":max"), &maxResolution, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_65$$23);
object_init_ex(&_65$$23, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_67$$23, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_66$$23);
ZVAL_STRING(&_66$$23, "FileMaxResolution");
ZEPHIR_CALL_METHOD(NULL, &_65$$23, "__construct", NULL, 295, &_67$$23, field, &_66$$23, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_65$$23);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
}
RETURN_MM_BOOL(1);
}
/**
* 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);
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_File, validate) {
zend_bool _1, _2, _3, _5, _6, _13, _14, _16, _22, _23, _53, _60$$16, _67$$21;
zephir_fcall_cache_entry *_11 = NULL, *_12 = NULL, *_36 = NULL;
zend_long 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, *_4, *_7, *_15, *_17, *_18 = NULL, *_27 = NULL, *_28 = NULL, *_45 = NULL, *_52 = NULL, *_54 = NULL, *_8$$3 = NULL, *_9$$3 = NULL, *_10$$3 = NULL, *_19$$4 = NULL, *_20$$4 = NULL, *_21$$4 = NULL, *_24$$5 = NULL, *_25$$5 = NULL, *_26$$5 = NULL, *_29$$6 = NULL, *_31$$6, *_32$$6, *_33$$6, *_34$$6, *_35$$6 = NULL, *_37$$6, *_38$$6, _39$$6, *_40$$6, *_41$$6 = NULL, *_30$$7, *_42$$9 = NULL, *_43$$9 = NULL, *_44$$9 = NULL, *_46$$10, _47$$13, *_48$$13, *_49$$15 = NULL, *_50$$15 = NULL, *_51$$15 = NULL, *_55$$16, *_56$$16 = NULL, *_57$$16 = NULL, *_64$$16 = NULL, *_58$$17, *_59$$18, *_61$$20 = NULL, *_62$$20 = NULL, *_63$$20 = NULL, *_65$$21, *_66$$22, *_68$$23 = NULL, *_69$$23 = NULL, *_70$$23 = NULL;
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 (UNEXPECTED(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 (EXPECTED(Z_TYPE_P(field_param) == IS_STRING)) {
zephir_get_strval(field, field_param);
} else {
ZEPHIR_INIT_VAR(field);
ZVAL_EMPTY_STRING(field);
}
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&label, this_ptr, "preparelabel", NULL, 0, validation, field);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&code, this_ptr, "preparecode", NULL, 0, field);
zephir_check_call_status();
zephir_array_fetch_string(&_0, _SERVER, SL("REQUEST_METHOD"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 109 TSRMLS_CC);
_1 = ZEPHIR_IS_STRING(_0, "POST");
if (_1) {
_1 = ZEPHIR_IS_EMPTY(_POST);
}
_2 = _1;
if (_2) {
_2 = ZEPHIR_IS_EMPTY(_FILES);
}
_3 = _2;
if (_3) {
zephir_array_fetch_string(&_4, _SERVER, SL("CONTENT_LENGTH"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 109 TSRMLS_CC);
_3 = ZEPHIR_GT_LONG(_4, 0);
}
_5 = _3;
if (!(_5)) {
_6 = zephir_array_isset_string(value, SS("error"));
if (_6) {
zephir_array_fetch_string(&_7, value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 109 TSRMLS_CC);
_6 = ZEPHIR_IS_LONG_IDENTICAL(_7, 1);
}
_5 = _6;
}
if (_5) {
ZEPHIR_INIT_VAR(_8$$3);
ZVAL_STRING(_8$$3, "FileIniSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_9$$3);
ZVAL_STRING(_9$$3, "messageIniSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _8$$3, _9$$3);
zephir_check_temp_parameter(_8$$3);
zephir_check_temp_parameter(_9$$3);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_8$$3);
object_init_ex(_8$$3, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_10$$3, "strtr", &_11, 27, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_9$$3);
ZVAL_STRING(_9$$3, "FileIniSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _8$$3, "__construct", &_12, 475, _10$$3, field, _9$$3, code);
zephir_check_temp_parameter(_9$$3);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _8$$3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
_13 = !(zephir_array_isset_string(value, SS("error")));
if (!(_13)) {
_13 = !(zephir_array_isset_string(value, SS("tmp_name")));
}
_14 = _13;
if (!(_14)) {
zephir_array_fetch_string(&_15, value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 124 TSRMLS_CC);
_14 = !ZEPHIR_IS_LONG_IDENTICAL(_15, 0);
}
_16 = _14;
if (!(_16)) {
zephir_array_fetch_string(&_17, value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 124 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_18, "is_uploaded_file", NULL, 253, _17);
zephir_check_call_status();
_16 = !zephir_is_true(_18);
}
if (_16) {
ZEPHIR_INIT_VAR(_19$$4);
ZVAL_STRING(_19$$4, "FileEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_20$$4);
ZVAL_STRING(_20$$4, "messageEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _19$$4, _20$$4);
zephir_check_temp_parameter(_19$$4);
zephir_check_temp_parameter(_20$$4);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_19$$4);
object_init_ex(_19$$4, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_21$$4, "strtr", &_11, 27, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_20$$4);
ZVAL_STRING(_20$$4, "FileEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _19$$4, "__construct", &_12, 475, _21$$4, field, _20$$4, code);
zephir_check_temp_parameter(_20$$4);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _19$$4);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
_22 = !(zephir_array_isset_string(value, SS("name")));
if (!(_22)) {
_22 = !(zephir_array_isset_string(value, SS("type")));
}
_23 = _22;
if (!(_23)) {
_23 = !(zephir_array_isset_string(value, SS("size")));
}
if (_23) {
ZEPHIR_INIT_VAR(_24$$5);
ZVAL_STRING(_24$$5, "FileValid", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_25$$5);
ZVAL_STRING(_25$$5, "messageValid", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _24$$5, _25$$5);
zephir_check_temp_parameter(_24$$5);
zephir_check_temp_parameter(_25$$5);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_24$$5);
object_init_ex(_24$$5, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_26$$5, "strtr", &_11, 27, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_25$$5);
ZVAL_STRING(_25$$5, "FileValid", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _24$$5, "__construct", &_12, 475, _26$$5, field, _25$$5, code);
zephir_check_temp_parameter(_25$$5);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _24$$5);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_VAR(_28);
ZVAL_STRING(_28, "maxSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_27, this_ptr, "hasoption", NULL, 0, _28);
zephir_check_temp_parameter(_28);
zephir_check_call_status();
if (zephir_is_true(_27)) {
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(_29$$6);
ZVAL_STRING(_29$$6, "maxSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&maxSize, this_ptr, "getoption", NULL, 0, _29$$6);
zephir_check_temp_parameter(_29$$6);
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(&_30$$7, maxSize, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 162 TSRMLS_CC);
ZEPHIR_CPY_WRT(maxSize, _30$$7);
}
ZEPHIR_INIT_NVAR(_29$$6);
ZEPHIR_INIT_VAR(_31$$6);
ZEPHIR_INIT_VAR(_32$$6);
zephir_array_keys(_32$$6, byteUnits TSRMLS_CC);
zephir_fast_join_str(_31$$6, SL("|"), _32$$6 TSRMLS_CC);
ZEPHIR_INIT_VAR(_33$$6);
ZEPHIR_CONCAT_SVS(_33$$6, "/^([0-9]+(?:\\.[0-9]+)?)(", _31$$6, ")?$/Di");
zephir_preg_match(_29$$6, _33$$6, maxSize, matches, 0, 0 , 0 TSRMLS_CC);
if (zephir_array_isset_long(matches, 2)) {
ZEPHIR_OBS_NVAR(unit);
zephir_array_fetch_long(&unit, matches, 2, PH_NOISY, "phalcon/validation/validator/file.zep", 168 TSRMLS_CC);
}
zephir_array_fetch_long(&_34$$6, matches, 1, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 171 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_35$$6, "floatval", &_36, 328, _34$$6);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_37$$6);
zephir_array_fetch(&_38$$6, byteUnits, unit, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 171 TSRMLS_CC);
ZEPHIR_SINIT_VAR(_39$$6);
ZVAL_LONG(&_39$$6, 2);
zephir_pow_function(_37$$6, &_39$$6, _38$$6);
ZEPHIR_INIT_VAR(bytes);
mul_function(bytes, _35$$6, _37$$6 TSRMLS_CC);
zephir_array_fetch_string(&_40$$6, value, SL("size"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 173 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_35$$6, "floatval", &_36, 328, _40$$6);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_41$$6, "floatval", &_36, 328, bytes);
zephir_check_call_status();
if (ZEPHIR_GT(_35$$6, _41$$6)) {
ZEPHIR_INIT_VAR(_42$$9);
ZVAL_STRING(_42$$9, "FileSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_43$$9);
ZVAL_STRING(_43$$9, "messageSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _42$$9, _43$$9);
zephir_check_temp_parameter(_42$$9);
zephir_check_temp_parameter(_43$$9);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_42$$9);
object_init_ex(_42$$9, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_44$$9, "strtr", &_11, 27, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_43$$9);
ZVAL_STRING(_43$$9, "FileSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _42$$9, "__construct", &_12, 475, _44$$9, field, _43$$9, code);
zephir_check_temp_parameter(_43$$9);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _42$$9);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_NVAR(_28);
ZVAL_STRING(_28, "allowedTypes", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_45, this_ptr, "hasoption", NULL, 0, _28);
zephir_check_temp_parameter(_28);
zephir_check_call_status();
if (zephir_is_true(_45)) {
ZEPHIR_INIT_VAR(_46$$10);
ZVAL_STRING(_46$$10, "allowedTypes", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&types, this_ptr, "getoption", NULL, 0, _46$$10);
zephir_check_temp_parameter(_46$$10);
zephir_check_call_status();
ZEPHIR_OBS_VAR(fieldTypes);
if (zephir_array_isset_fetch(&fieldTypes, types, field, 0 TSRMLS_CC)) {
ZEPHIR_CPY_WRT(types, fieldTypes);
}
if (Z_TYPE_P(types) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Option 'allowedTypes' must be an array", "phalcon/validation/validator/file.zep", 198);
return;
}
if ((zephir_function_exists_ex(SS("finfo_open") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_SINIT_VAR(_47$$13);
ZVAL_LONG(&_47$$13, 16);
ZEPHIR_CALL_FUNCTION(&tmp, "finfo_open", NULL, 250, &_47$$13);
zephir_check_call_status();
zephir_array_fetch_string(&_48$$13, value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 203 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&mime, "finfo_file", NULL, 251, tmp, _48$$13);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(NULL, "finfo_close", NULL, 252, 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", 207 TSRMLS_CC);
}
if (!(zephir_fast_in_array(mime, types TSRMLS_CC))) {
ZEPHIR_INIT_VAR(_49$$15);
ZVAL_STRING(_49$$15, "FileType", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_50$$15);
ZVAL_STRING(_50$$15, "messageType", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _49$$15, _50$$15);
zephir_check_temp_parameter(_49$$15);
zephir_check_temp_parameter(_50$$15);
zephir_check_call_status();
ZEPHIR_INIT_VAR(replacePairs);
zephir_create_array(replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_49$$15);
zephir_fast_join_str(_49$$15, SL(", "), types TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":types"), &_49$$15, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_49$$15);
object_init_ex(_49$$15, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_51$$15, "strtr", &_11, 27, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_50$$15);
ZVAL_STRING(_50$$15, "FileType", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _49$$15, "__construct", &_12, 475, _51$$15, field, _50$$15, code);
zephir_check_temp_parameter(_50$$15);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _49$$15);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_NVAR(_28);
ZVAL_STRING(_28, "minResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_52, this_ptr, "hasoption", NULL, 0, _28);
zephir_check_temp_parameter(_28);
zephir_check_call_status();
_53 = zephir_is_true(_52);
if (!(_53)) {
ZEPHIR_INIT_NVAR(_28);
ZVAL_STRING(_28, "maxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_54, this_ptr, "hasoption", NULL, 0, _28);
zephir_check_temp_parameter(_28);
zephir_check_call_status();
_53 = zephir_is_true(_54);
}
if (_53) {
zephir_array_fetch_string(&_55$$16, value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 228 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&tmp, "getimagesize", NULL, 261, _55$$16);
zephir_check_call_status();
ZEPHIR_OBS_VAR(width);
zephir_array_fetch_long(&width, tmp, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 229 TSRMLS_CC);
ZEPHIR_OBS_VAR(height);
zephir_array_fetch_long(&height, tmp, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 230 TSRMLS_CC);
ZEPHIR_INIT_VAR(_57$$16);
ZVAL_STRING(_57$$16, "minResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_56$$16, this_ptr, "hasoption", NULL, 0, _57$$16);
zephir_check_temp_parameter(_57$$16);
zephir_check_call_status();
if (zephir_is_true(_56$$16)) {
ZEPHIR_INIT_VAR(_58$$17);
ZVAL_STRING(_58$$17, "minResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&minResolution, this_ptr, "getoption", NULL, 0, _58$$17);
zephir_check_temp_parameter(_58$$17);
zephir_check_call_status();
if (Z_TYPE_P(minResolution) == IS_ARRAY) {
zephir_array_fetch(&_59$$18, minResolution, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 235 TSRMLS_CC);
ZEPHIR_CPY_WRT(minResolution, _59$$18);
}
ZEPHIR_INIT_VAR(minResolutionArray);
zephir_fast_explode_str(minResolutionArray, SL("x"), minResolution, LONG_MAX TSRMLS_CC);
ZEPHIR_OBS_VAR(minWidth);
zephir_array_fetch_long(&minWidth, minResolutionArray, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 238 TSRMLS_CC);
ZEPHIR_OBS_VAR(minHeight);
zephir_array_fetch_long(&minHeight, minResolutionArray, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 239 TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(minWidth);
ZVAL_LONG(minWidth, 1);
ZEPHIR_INIT_NVAR(minHeight);
ZVAL_LONG(minHeight, 1);
}
_60$$16 = ZEPHIR_LT(width, minWidth);
if (!(_60$$16)) {
_60$$16 = ZEPHIR_LT(height, minHeight);
}
if (_60$$16) {
ZEPHIR_INIT_VAR(_61$$20);
ZVAL_STRING(_61$$20, "FileMinResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_62$$20);
ZVAL_STRING(_62$$20, "messageMinResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _61$$20, _62$$20);
zephir_check_temp_parameter(_61$$20);
zephir_check_temp_parameter(_62$$20);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(replacePairs);
zephir_create_array(replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":min"), &minResolution, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_61$$20);
object_init_ex(_61$$20, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_63$$20, "strtr", &_11, 27, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_62$$20);
ZVAL_STRING(_62$$20, "FileMinResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _61$$20, "__construct", &_12, 475, _63$$20, field, _62$$20, code);
zephir_check_temp_parameter(_62$$20);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _61$$20);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_NVAR(_57$$16);
ZVAL_STRING(_57$$16, "maxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_64$$16, this_ptr, "hasoption", NULL, 0, _57$$16);
zephir_check_temp_parameter(_57$$16);
zephir_check_call_status();
if (zephir_is_true(_64$$16)) {
ZEPHIR_INIT_VAR(_65$$21);
ZVAL_STRING(_65$$21, "maxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&maxResolution, this_ptr, "getoption", NULL, 0, _65$$21);
zephir_check_temp_parameter(_65$$21);
zephir_check_call_status();
if (Z_TYPE_P(maxResolution) == IS_ARRAY) {
zephir_array_fetch(&_66$$22, maxResolution, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 265 TSRMLS_CC);
ZEPHIR_CPY_WRT(maxResolution, _66$$22);
}
ZEPHIR_INIT_VAR(maxResolutionArray);
zephir_fast_explode_str(maxResolutionArray, SL("x"), maxResolution, LONG_MAX TSRMLS_CC);
ZEPHIR_OBS_VAR(maxWidth);
zephir_array_fetch_long(&maxWidth, maxResolutionArray, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 268 TSRMLS_CC);
ZEPHIR_OBS_VAR(maxHeight);
zephir_array_fetch_long(&maxHeight, maxResolutionArray, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 269 TSRMLS_CC);
_67$$21 = ZEPHIR_GT(width, maxWidth);
if (!(_67$$21)) {
_67$$21 = ZEPHIR_GT(height, maxHeight);
}
if (_67$$21) {
ZEPHIR_INIT_VAR(_68$$23);
ZVAL_STRING(_68$$23, "FileMaxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_69$$23);
ZVAL_STRING(_69$$23, "messageMaxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _68$$23, _69$$23);
zephir_check_temp_parameter(_68$$23);
zephir_check_temp_parameter(_69$$23);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(replacePairs);
zephir_create_array(replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":max"), &maxResolution, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_68$$23);
object_init_ex(_68$$23, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_70$$23, "strtr", &_11, 27, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_69$$23);
ZVAL_STRING(_69$$23, "FileMaxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _68$$23, "__construct", &_12, 475, _70$$23, field, _69$$23, code);
zephir_check_temp_parameter(_69$$23);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _68$$23);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
}
RETURN_MM_BOOL(1);
}
/**
* Update row(s) of table and returns the number of updated rows
*/
PHP_METHOD(Lynx_DBAL_Connection, update) {
zephir_nts_static zephir_fcall_cache_entry *_12 = NULL, *_15 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_3;
HashPosition _2;
zval *data = NULL, *identifiers = NULL, *types = NULL;
zval *table_param = NULL, *data_param = NULL, *identifiers_param = NULL, *types_param = NULL, *set, *stmt = NULL, *columnName = NULL, *_0 = NULL, *_1, **_4, *_5, *_6 = NULL, *_7 = NULL, *_8, *cnt, *_9, *_10 = NULL, *_11 = NULL, *_13, *_14;
zval *table = NULL, *query = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 1, &table_param, &data_param, &identifiers_param, &types_param);
if (unlikely(Z_TYPE_P(table_param) != IS_STRING && Z_TYPE_P(table_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'table' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(table_param) == IS_STRING)) {
zephir_get_strval(table, table_param);
} else {
ZEPHIR_INIT_VAR(table);
ZVAL_EMPTY_STRING(table);
}
data = data_param;
identifiers = identifiers_param;
if (!types_param) {
ZEPHIR_INIT_VAR(types);
array_init(types);
} else {
types = types_param;
}
ZEPHIR_INIT_VAR(set);
array_init(set);
ZEPHIR_INIT_VAR(_1);
zephir_array_keys(_1, data TSRMLS_CC);
zephir_is_iterable(_1, &_3, &_2, 0, 0, "lynx/DBAL/Connection.zep", 88);
for (
; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS
; zephir_hash_move_forward_ex(_3, &_2)
) {
ZEPHIR_GET_HVALUE(columnName, _4);
_5 = zephir_fetch_nproperty_this(this_ptr, SL("platform"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_6, _5, "wrap", NULL, columnName);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_7);
ZEPHIR_CONCAT_VS(_7, _6, " = ?");
zephir_array_append(&set, _7, PH_SEPARATE, "lynx/DBAL/Connection.zep", 85);
}
_5 = zephir_fetch_nproperty_this(this_ptr, SL("platform"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_6, _5, "wrap", NULL, table);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_8);
zephir_fast_join_str(_8, SL(", "), set TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_7);
ZEPHIR_CONCAT_SVSV(_7, "UPDATE ", _6, " SET ", _8);
zephir_get_strval(query, _7);
ZEPHIR_INIT_VAR(cnt);
ZVAL_LONG(cnt, zephir_fast_count_int(identifiers TSRMLS_CC));
if (ZEPHIR_GT_LONG(cnt, 0)) {
zephir_concat_self_str(&query, " WHERE ", sizeof(" WHERE ")-1 TSRMLS_CC);
if (ZEPHIR_IS_LONG(cnt, 1)) {
_9 = zephir_fetch_nproperty_this(this_ptr, SL("platform"), PH_NOISY_CC);
Z_SET_ISREF_P(identifiers);
ZEPHIR_CALL_FUNCTION(&_11, "key", &_12, identifiers);
Z_UNSET_ISREF_P(identifiers);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_10, _9, "wrap", NULL, _11);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_13);
ZEPHIR_CONCAT_VS(_13, _10, " = ?");
zephir_concat_self(&query, _13 TSRMLS_CC);
} else {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(zend_exception_get_default(TSRMLS_C), "It's not implemented", "lynx/DBAL/Connection.zep", 99);
return;
}
}
_5 = zephir_fetch_nproperty_this(this_ptr, SL("driver"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&stmt, _5, "prepare", NULL, query);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_14);
ZEPHIR_CALL_FUNCTION(&_6, "array_values", &_15, data);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_10, "array_values", &_15, identifiers);
zephir_check_call_status();
zephir_fast_array_merge(_14, &(_6), &(_10) TSRMLS_CC);
ZEPHIR_RETURN_CALL_METHOD(stmt, "execute", NULL, _14);
zephir_check_call_status();
RETURN_MM();
}
PHP_METHOD(Phalcon_Validation_Validator_Uniqueness, isUniqueness) {
zval *_32$$16 = NULL, *_44$$20 = NULL, *_58$$25 = NULL;
zend_bool _11$$7, _18$$12;
zend_class_entry *_78;
HashTable *_2, *_8, *_24$$13, *_29$$15, *_41$$19, *_50$$22, *_55$$24, *_68$$27;
HashPosition _1, _7, _23$$13, _28$$15, _40$$19, _49$$22, _54$$24, _67$$27;
zephir_fcall_cache_entry *_5 = NULL, *_12 = NULL, *_14 = NULL;
int ZEPHIR_LAST_CALL_STATUS, index = 0;
zval *validation, *field = NULL, *value = NULL, *values = NULL, *convert = NULL, *record = NULL, *attribute = NULL, *except = NULL, *params = NULL, *metaData = NULL, *primaryField = NULL, *className = NULL, *singleField = NULL, *fieldExcept = NULL, *singleExcept = NULL, *notInValues = NULL, *exceptConditions = NULL, *_0 = NULL, **_3, **_9, *_63 = NULL, *_76, *_77 = NULL, *_4$$4 = NULL, *_6$$5 = NULL, *_10$$7 = NULL, *_13$$7 = NULL, _15$$10 = zval_used_for_init, *_16$$10 = NULL, *_17$$11 = NULL, *_19$$12, _20$$12, _21$$12, *_22$$12 = NULL, **_25$$13, *_26$$14 = NULL, *_27$$14 = NULL, **_30$$15, *_33$$15 = NULL, *_34$$15 = NULL, _31$$16 = zval_used_for_init, _35$$17 = zval_used_for_init, *_36$$17 = NULL, *_37$$18 = NULL, *_38$$18, *_39$$18, **_42$$19, *_45$$19, *_46$$19, _43$$20 = zval_used_for_init, _47$$21, *_48$$21, **_51$$22, *_52$$23 = NULL, *_53$$23 = NULL, **_56$$24, *_59$$24 = NULL, *_60$$24 = NULL, _57$$25 = zval_used_for_init, _61$$26 = zval_used_for_init, *_62$$26 = NULL, *_64$$27 = NULL, *_65$$27, *_66$$27 = NULL, **_69$$27, *_70$$28 = NULL, _71$$28 = zval_used_for_init, *_72$$28 = NULL, *_73$$28 = NULL, *_74$$29, *_75$$29;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field);
ZEPHIR_SEPARATE_PARAM(field);
ZEPHIR_INIT_VAR(exceptConditions);
array_init(exceptConditions);
index = 0;
ZEPHIR_INIT_VAR(params);
zephir_create_array(params, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_0);
array_init(_0);
zephir_array_update_string(¶ms, SL("conditions"), &_0, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_0);
array_init(_0);
zephir_array_update_string(¶ms, SL("bind"), &_0, PH_COPY | PH_SEPARATE);
if (Z_TYPE_P(field) != IS_ARRAY) {
ZEPHIR_CPY_WRT(singleField, field);
ZEPHIR_INIT_NVAR(field);
array_init(field);
zephir_array_append(&field, singleField, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 156);
}
ZEPHIR_INIT_VAR(values);
array_init(values);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "convert", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&convert, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
zephir_is_iterable(field, &_2, &_1, 0, 0, "phalcon/validation/validator/uniqueness.zep", 166);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(singleField, _3);
ZEPHIR_CALL_METHOD(&_4$$4, validation, "getvalue", &_5, 0, singleField);
zephir_check_call_status();
zephir_array_update_zval(&values, singleField, &_4$$4, PH_COPY | PH_SEPARATE);
}
if (Z_TYPE_P(convert) != IS_NULL) {
ZEPHIR_CALL_ZVAL_FUNCTION(&_6$$5, convert, NULL, 0, values);
zephir_check_call_status();
ZEPHIR_CPY_WRT(values, _6$$5);
if (!(Z_TYPE_P(values) == IS_ARRAY)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Value conversion must return an array", "phalcon/validation/validator/uniqueness.zep", 170);
return;
}
}
zephir_is_iterable(field, &_8, &_7, 0, 0, "phalcon/validation/validator/uniqueness.zep", 200);
for (
; zephir_hash_get_current_data_ex(_8, (void**) &_9, &_7) == SUCCESS
; zephir_hash_move_forward_ex(_8, &_7)
) {
ZEPHIR_GET_HVALUE(singleField, _9);
ZEPHIR_INIT_NVAR(fieldExcept);
ZVAL_NULL(fieldExcept);
ZEPHIR_INIT_NVAR(notInValues);
array_init(notInValues);
ZEPHIR_INIT_NVAR(_10$$7);
ZVAL_STRING(_10$$7, "model", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&record, this_ptr, "getoption", NULL, 0, _10$$7);
zephir_check_temp_parameter(_10$$7);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(value);
zephir_array_fetch(&value, values, singleField, PH_NOISY, "phalcon/validation/validator/uniqueness.zep", 178 TSRMLS_CC);
_11$$7 = ZEPHIR_IS_EMPTY(record);
if (!(_11$$7)) {
_11$$7 = Z_TYPE_P(record) != IS_OBJECT;
}
if (_11$$7) {
ZEPHIR_CALL_METHOD(&record, validation, "getentity", &_12, 0);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(record)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Model of record must be set to property \"model\"", "phalcon/validation/validator/uniqueness.zep", 184);
return;
}
}
ZEPHIR_INIT_NVAR(_10$$7);
ZVAL_STRING(_10$$7, "attribute", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_13$$7, this_ptr, "getoption", NULL, 0, _10$$7, singleField);
zephir_check_temp_parameter(_10$$7);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&attribute, this_ptr, "getcolumnnamereal", &_14, 0, record, _13$$7);
zephir_check_call_status();
if (Z_TYPE_P(value) != IS_NULL) {
ZEPHIR_SINIT_NVAR(_15$$10);
ZVAL_LONG(&_15$$10, index);
ZEPHIR_INIT_LNVAR(_16$$10);
ZEPHIR_CONCAT_VSV(_16$$10, attribute, " = ?", &_15$$10);
zephir_array_update_multi(¶ms, &_16$$10 TSRMLS_CC, SL("sa"), 3, SL("conditions"));
zephir_array_update_multi(¶ms, &value TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
} else {
ZEPHIR_INIT_LNVAR(_17$$11);
ZEPHIR_CONCAT_VS(_17$$11, attribute, " IS NULL");
zephir_array_update_multi(¶ms, &_17$$11 TSRMLS_CC, SL("sa"), 3, SL("conditions"));
}
}
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "except", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&except, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (zephir_is_true(except)) {
_18$$12 = Z_TYPE_P(except) == IS_ARRAY;
if (_18$$12) {
ZEPHIR_INIT_VAR(_19$$12);
zephir_array_keys(_19$$12, except TSRMLS_CC);
ZEPHIR_SINIT_VAR(_20$$12);
ZVAL_LONG(&_20$$12, 0);
ZEPHIR_SINIT_VAR(_21$$12);
ZVAL_LONG(&_21$$12, (zephir_fast_count_int(except TSRMLS_CC) - 1));
ZEPHIR_CALL_FUNCTION(&_22$$12, "range", NULL, 446, &_20$$12, &_21$$12);
zephir_check_call_status();
_18$$12 = !ZEPHIR_IS_IDENTICAL(_19$$12, _22$$12);
}
if (_18$$12) {
zephir_is_iterable(except, &_24$$13, &_23$$13, 0, 0, "phalcon/validation/validator/uniqueness.zep", 219);
for (
; zephir_hash_get_current_data_ex(_24$$13, (void**) &_25$$13, &_23$$13) == SUCCESS
; zephir_hash_move_forward_ex(_24$$13, &_23$$13)
) {
ZEPHIR_GET_HMKEY(singleField, _24$$13, _23$$13);
ZEPHIR_GET_HVALUE(fieldExcept, _25$$13);
ZEPHIR_INIT_NVAR(_27$$14);
ZVAL_STRING(_27$$14, "attribute", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_26$$14, this_ptr, "getoption", NULL, 0, _27$$14, singleField);
zephir_check_temp_parameter(_27$$14);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&attribute, this_ptr, "getcolumnnamereal", &_14, 0, record, _26$$14);
zephir_check_call_status();
if (Z_TYPE_P(fieldExcept) == IS_ARRAY) {
zephir_is_iterable(fieldExcept, &_29$$15, &_28$$15, 0, 0, "phalcon/validation/validator/uniqueness.zep", 212);
for (
; zephir_hash_get_current_data_ex(_29$$15, (void**) &_30$$15, &_28$$15) == SUCCESS
; zephir_hash_move_forward_ex(_29$$15, &_28$$15)
) {
ZEPHIR_GET_HVALUE(singleExcept, _30$$15);
ZEPHIR_SINIT_NVAR(_31$$16);
ZVAL_LONG(&_31$$16, index);
ZEPHIR_INIT_LNVAR(_32$$16);
ZEPHIR_CONCAT_SV(_32$$16, "?", &_31$$16);
zephir_array_append(¬InValues, _32$$16, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 208);
zephir_array_update_multi(¶ms, &singleExcept TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
ZEPHIR_INIT_NVAR(_33$$15);
zephir_fast_join_str(_33$$15, SL(","), notInValues TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_34$$15);
ZEPHIR_CONCAT_VSVS(_34$$15, attribute, " NOT IN (", _33$$15, ")");
zephir_array_append(&exceptConditions, _34$$15, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 212);
} else {
ZEPHIR_SINIT_NVAR(_35$$17);
ZVAL_LONG(&_35$$17, index);
ZEPHIR_INIT_LNVAR(_36$$17);
ZEPHIR_CONCAT_VSV(_36$$17, attribute, " <> ?", &_35$$17);
zephir_array_append(&exceptConditions, _36$$17, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 214);
zephir_array_update_multi(¶ms, &fieldExcept TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
}
} else if (zephir_fast_count_int(field TSRMLS_CC) == 1) {
zephir_array_fetch_long(&_38$$18, field, 0, PH_NOISY | PH_READONLY, "phalcon/validation/validator/uniqueness.zep", 220 TSRMLS_CC);
ZEPHIR_INIT_VAR(_39$$18);
ZVAL_STRING(_39$$18, "attribute", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_37$$18, this_ptr, "getoption", NULL, 0, _39$$18, _38$$18);
zephir_check_temp_parameter(_39$$18);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&attribute, this_ptr, "getcolumnnamereal", &_14, 0, record, _37$$18);
zephir_check_call_status();
if (Z_TYPE_P(except) == IS_ARRAY) {
zephir_is_iterable(except, &_41$$19, &_40$$19, 0, 0, "phalcon/validation/validator/uniqueness.zep", 227);
for (
; zephir_hash_get_current_data_ex(_41$$19, (void**) &_42$$19, &_40$$19) == SUCCESS
; zephir_hash_move_forward_ex(_41$$19, &_40$$19)
) {
ZEPHIR_GET_HVALUE(singleExcept, _42$$19);
ZEPHIR_SINIT_NVAR(_43$$20);
ZVAL_LONG(&_43$$20, index);
ZEPHIR_INIT_LNVAR(_44$$20);
ZEPHIR_CONCAT_SV(_44$$20, "?", &_43$$20);
zephir_array_append(¬InValues, _44$$20, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 223);
zephir_array_update_multi(¶ms, &singleExcept TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
ZEPHIR_INIT_VAR(_45$$19);
zephir_fast_join_str(_45$$19, SL(","), notInValues TSRMLS_CC);
ZEPHIR_INIT_VAR(_46$$19);
ZEPHIR_CONCAT_VSVS(_46$$19, attribute, " NOT IN (", _45$$19, ")");
zephir_array_append(&exceptConditions, _46$$19, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 227);
} else {
ZEPHIR_SINIT_VAR(_47$$21);
ZVAL_LONG(&_47$$21, index);
ZEPHIR_INIT_VAR(_48$$21);
ZEPHIR_CONCAT_VSV(_48$$21, attribute, " <> ?", &_47$$21);
zephir_array_update_multi(¶ms, &_48$$21 TSRMLS_CC, SL("sa"), 3, SL("conditions"));
zephir_array_update_multi(¶ms, &except TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
} else if (zephir_fast_count_int(field TSRMLS_CC) > 1) {
zephir_is_iterable(field, &_50$$22, &_49$$22, 0, 0, "phalcon/validation/validator/uniqueness.zep", 249);
for (
; zephir_hash_get_current_data_ex(_50$$22, (void**) &_51$$22, &_49$$22) == SUCCESS
; zephir_hash_move_forward_ex(_50$$22, &_49$$22)
) {
ZEPHIR_GET_HVALUE(singleField, _51$$22);
ZEPHIR_INIT_NVAR(_53$$23);
ZVAL_STRING(_53$$23, "attribute", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_52$$23, this_ptr, "getoption", NULL, 0, _53$$23, singleField);
zephir_check_temp_parameter(_53$$23);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&attribute, this_ptr, "getcolumnnamereal", &_14, 0, record, _52$$23);
zephir_check_call_status();
if (Z_TYPE_P(except) == IS_ARRAY) {
zephir_is_iterable(except, &_55$$24, &_54$$24, 0, 0, "phalcon/validation/validator/uniqueness.zep", 242);
for (
; zephir_hash_get_current_data_ex(_55$$24, (void**) &_56$$24, &_54$$24) == SUCCESS
; zephir_hash_move_forward_ex(_55$$24, &_54$$24)
) {
ZEPHIR_GET_HVALUE(singleExcept, _56$$24);
ZEPHIR_SINIT_NVAR(_57$$25);
ZVAL_LONG(&_57$$25, index);
ZEPHIR_INIT_LNVAR(_58$$25);
ZEPHIR_CONCAT_SV(_58$$25, "?", &_57$$25);
zephir_array_append(¬InValues, _58$$25, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 238);
zephir_array_update_multi(¶ms, &singleExcept TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
ZEPHIR_INIT_NVAR(_59$$24);
zephir_fast_join_str(_59$$24, SL(","), notInValues TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_60$$24);
ZEPHIR_CONCAT_VSVS(_60$$24, attribute, " NOT IN (", _59$$24, ")");
zephir_array_append(&exceptConditions, _60$$24, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 242);
} else {
ZEPHIR_SINIT_NVAR(_61$$26);
ZVAL_LONG(&_61$$26, index);
ZEPHIR_INIT_LNVAR(_62$$26);
ZEPHIR_CONCAT_VSV(_62$$26, attribute, " <> ?", &_61$$26);
zephir_array_update_multi(¶ms, &_62$$26 TSRMLS_CC, SL("sa"), 3, SL("conditions"));
zephir_array_update_multi(¶ms, &except TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
}
}
}
ZEPHIR_CALL_METHOD(&_63, record, "getdirtystate", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_LONG(_63, 0)) {
ZEPHIR_CALL_METHOD(&_64$$27, record, "getdi", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_65$$27);
ZVAL_STRING(_65$$27, "modelsMetadata", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&metaData, _64$$27, "getshared", NULL, 0, _65$$27);
zephir_check_temp_parameter(_65$$27);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_66$$27, metaData, "getprimarykeyattributes", NULL, 0, record);
zephir_check_call_status();
zephir_is_iterable(_66$$27, &_68$$27, &_67$$27, 0, 0, "phalcon/validation/validator/uniqueness.zep", 263);
for (
; zephir_hash_get_current_data_ex(_68$$27, (void**) &_69$$27, &_67$$27) == SUCCESS
; zephir_hash_move_forward_ex(_68$$27, &_67$$27)
) {
ZEPHIR_GET_HVALUE(primaryField, _69$$27);
ZEPHIR_CALL_METHOD(&_70$$28, this_ptr, "getcolumnnamereal", &_14, 0, record, primaryField);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_71$$28);
ZVAL_LONG(&_71$$28, index);
ZEPHIR_INIT_LNVAR(_72$$28);
ZEPHIR_CONCAT_VSV(_72$$28, _70$$28, " <> ?", &_71$$28);
zephir_array_update_multi(¶ms, &_72$$28 TSRMLS_CC, SL("sa"), 3, SL("conditions"));
ZEPHIR_CALL_METHOD(&_73$$28, record, "readattribute", NULL, 0, primaryField);
zephir_check_call_status();
zephir_array_update_multi(¶ms, &_73$$28 TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
}
ZEPHIR_INIT_VAR(className);
zephir_get_class(className, record, 0 TSRMLS_CC);
if (!(ZEPHIR_IS_EMPTY(exceptConditions))) {
ZEPHIR_INIT_VAR(_74$$29);
zephir_fast_join_str(_74$$29, SL(" OR "), exceptConditions TSRMLS_CC);
ZEPHIR_INIT_VAR(_75$$29);
ZEPHIR_CONCAT_SVS(_75$$29, "(", _74$$29, ")");
zephir_array_update_multi(¶ms, &_75$$29 TSRMLS_CC, SL("sa"), 3, SL("conditions"));
}
ZEPHIR_INIT_NVAR(_0);
zephir_array_fetch_string(&_76, params, SL("conditions"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/uniqueness.zep", 269 TSRMLS_CC);
zephir_fast_join_str(_0, SL(" AND "), _76 TSRMLS_CC);
zephir_array_update_string(¶ms, SL("conditions"), &_0, PH_COPY | PH_SEPARATE);
_78 = zephir_fetch_class(className TSRMLS_CC);
ZEPHIR_CALL_CE_STATIC(&_77, _78, "count", NULL, 0, params);
zephir_check_call_status();
RETURN_MM_BOOL(ZEPHIR_IS_LONG(_77, 0));
}
/**
* Insert a row in the table with the specified data and types
* returns the number of affected rows
*/
PHP_METHOD(Lynx_DBAL_Connection, insert) {
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_1;
HashPosition _0;
zval *data = NULL, *types = NULL;
zval *table_param = NULL, *data_param = NULL, *types_param = NULL, *query, *stmt = NULL, *value = NULL, *set, *columnName = NULL, *fields, **_2, *_3, *_4 = NULL, *_5, *_6 = NULL, *_7, *_8, *_9;
zval *table = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 1, &table_param, &data_param, &types_param);
if (unlikely(Z_TYPE_P(table_param) != IS_STRING && Z_TYPE_P(table_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'table' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(table_param) == IS_STRING)) {
zephir_get_strval(table, table_param);
} else {
ZEPHIR_INIT_VAR(table);
ZVAL_EMPTY_STRING(table);
}
data = data_param;
if (!types_param) {
ZEPHIR_INIT_VAR(types);
array_init(types);
} else {
types = types_param;
}
ZEPHIR_INIT_VAR(set);
array_init(set);
ZEPHIR_INIT_VAR(fields);
zephir_array_keys(fields, data TSRMLS_CC);
zephir_is_iterable(data, &_1, &_0, 1, 0, "lynx/DBAL/Connection.zep", 70);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HMKEY(columnName, _1, _0);
ZEPHIR_GET_HVALUE(value, _2);
if (zephir_array_isset(types, columnName)) {
zephir_array_fetch(&_3, types, columnName, PH_NOISY | PH_READONLY, "lynx/DBAL/Connection.zep", 59 TSRMLS_CC);
if (ZEPHIR_IS_LONG(_3, 10)) {
zephir_array_append(&set, value, PH_SEPARATE, "lynx/DBAL/Connection.zep", 60);
zephir_array_unset(&data, columnName, PH_SEPARATE);
} else {
ZEPHIR_INIT_LNVAR(_4);
ZEPHIR_CONCAT_SVS(_4, ":", columnName, "");
zephir_array_append(&set, _4, PH_SEPARATE, "lynx/DBAL/Connection.zep", 63);
}
} else {
ZEPHIR_INIT_LNVAR(_4);
ZEPHIR_CONCAT_SVS(_4, ":", columnName, "");
zephir_array_append(&set, _4, PH_SEPARATE, "lynx/DBAL/Connection.zep", 66);
}
}
_5 = zephir_fetch_nproperty_this(this_ptr, SL("platform"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_6, _5, "wrap", NULL, table);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_7);
zephir_fast_join_str(_7, SL(","), fields TSRMLS_CC);
ZEPHIR_INIT_VAR(_8);
zephir_fast_join_str(_8, SL(","), set TSRMLS_CC);
ZEPHIR_INIT_VAR(query);
ZEPHIR_CONCAT_SVSVSVS(query, "INSERT INTO ", _6, " (", _7, ") VALUES (", _8, ")");
_9 = zephir_fetch_nproperty_this(this_ptr, SL("driver"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&stmt, _9, "prepare", NULL, query);
zephir_check_call_status();
ZEPHIR_RETURN_CALL_METHOD(stmt, "execute", NULL, data);
zephir_check_call_status();
RETURN_MM();
}