PHP_METHOD(PhalconPlus_Enum_Sys, getModuleClassPath) {
zval *_0;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *moduleDir_param = NULL, *runMode, *_1 = NULL, *_2 = NULL;
zval *moduleDir = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &moduleDir_param, &runMode);
zephir_get_strval(moduleDir, moduleDir_param);
ZEPHIR_INIT_VAR(_0);
zephir_create_array(_0, 5, 0 TSRMLS_CC);
zephir_array_fast_append(_0, moduleDir);
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "app", 1);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "/", 1);
zephir_array_fast_append(_0, _1);
ZEPHIR_CALL_METHOD(&_2, runMode, "getmapclassname", NULL, 0);
zephir_check_call_status();
zephir_array_fast_append(_0, _2);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, ".php", 1);
zephir_array_fast_append(_0, _1);
zephir_fast_join_str(return_value, SL(""), _0 TSRMLS_CC);
RETURN_MM();
}
/**
* Get label for field
*
* @param string field
* @return string
*/
PHP_METHOD(Phalcon_Validation, getLabel) {
zend_bool _0;
zval *field, *labels = NULL, *value = NULL;
zephir_fetch_params(0, 1, 0, &field);
labels = zephir_fetch_nproperty_this(this_ptr, SL("_labels"), PH_NOISY_CC);
_0 = Z_TYPE_P(labels) == IS_ARRAY;
if (_0) {
_0 = Z_TYPE_P(field) != IS_ARRAY;
}
if (_0) {
if (zephir_array_isset_fetch(&value, labels, field, 1 TSRMLS_CC)) {
RETURN_CTORW(value);
}
} else if (Z_TYPE_P(field) == IS_ARRAY) {
zephir_fast_join_str(return_value, SL(", "), field TSRMLS_CC);
return;
}
RETVAL_ZVAL(field, 1, 0);
return;
}
/**
* @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();
}
/**
* Gets a list of columns with escaped identifiers
*
*<code>
* echo $dialect->getColumnList(array('column1', 'column'));
*</code>
*
* @param array columnList
* @return string
*/
PHP_METHOD(Pdm_Db_AbstractDialect, getColumnList) {
HashTable *_2;
HashPosition _1;
zval *columnList, *strList, *escapeChar = NULL, *column = NULL, *_0, **_3, *_4 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &columnList);
ZEPHIR_INIT_VAR(strList);
array_init(strList);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("escapeChar"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(escapeChar, _0);
zephir_is_iterable(columnList, &_2, &_1, 0, 0);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(column, _3);
ZEPHIR_INIT_LNVAR(_4);
ZEPHIR_CONCAT_VVV(_4, escapeChar, column, escapeChar);
zephir_array_append(&strList, _4, PH_SEPARATE);
}
zephir_fast_join_str(return_value, SL(", "), strList TSRMLS_CC);
RETURN_MM();
}
PHP_METHOD(Test_BuiltIn_ArrayMethods, getJoin1) {
zval _1;
zval _0;
ZEPHIR_INIT_THIS();
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&_0);
zephir_create_array(&_0, 3, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(&_1);
ZVAL_LONG(&_1, 1);
zephir_array_fast_append(&_0, &_1);
ZEPHIR_INIT_NVAR(&_1);
ZVAL_LONG(&_1, 2);
zephir_array_fast_append(&_0, &_1);
ZEPHIR_INIT_NVAR(&_1);
ZVAL_LONG(&_1, 3);
zephir_array_fast_append(&_0, &_1);
ZEPHIR_INIT_NVAR(&_1);
zephir_fast_join_str(&_1, SL("-"), &_0 TSRMLS_CC);
RETURN_CCTOR(_1);
}
PHP_METHOD(ADOdb_Cache, getQueryId) {
zval *sql_param = NULL, *params = NULL, *_0 = NULL, *_1, *_2;
zval *sql = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &sql_param, ¶ms);
zephir_get_strval(sql, sql_param);
if (!params) {
params = ZEPHIR_GLOBAL(global_null);
}
if ((Z_TYPE_P(params) != IS_NULL)) {
ZEPHIR_INIT_VAR(_0);
zephir_fast_join_str(_0, SL(""), params TSRMLS_CC);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_VV(_1, sql, _0);
ZEPHIR_INIT_VAR(_2);
zephir_call_func_p1(_2, "md5", _1);
ZEPHIR_CONCAT_SV(return_value, "DB_", _2);
RETURN_MM();
} else {
ZEPHIR_INIT_NVAR(_0);
zephir_call_func_p1(_0, "md5", sql);
ZEPHIR_CONCAT_SV(return_value, "DB_", _0);
RETURN_MM();
}
ZEPHIR_MM_RESTORE();
}
/**
* Appends a NOT IN condition to the current conditions
*
*<code>
* $criteria->notInWhere('id', [1, 2, 3]);
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, notInWhere) {
HashTable *_1;
HashPosition _0;
int ZEPHIR_LAST_CALL_STATUS;
zval *values = NULL;
zval *expr_param = NULL, *values_param = NULL, *hiddenParam = NULL, *bindParams = NULL, *bindKeys = NULL, *value = NULL, *key = NULL, **_2, *_4, *_5, *_3$$3 = NULL;
zval *expr = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &expr_param, &values_param);
if (unlikely(Z_TYPE_P(expr_param) != IS_STRING && Z_TYPE_P(expr_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'expr' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(expr_param) == IS_STRING)) {
zephir_get_strval(expr, expr_param);
} else {
ZEPHIR_INIT_VAR(expr);
ZVAL_EMPTY_STRING(expr);
}
values = values_param;
ZEPHIR_OBS_VAR(hiddenParam);
zephir_read_property_this(&hiddenParam, this_ptr, SL("_hiddenParamNumber"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(bindParams);
array_init(bindParams);
ZEPHIR_INIT_VAR(bindKeys);
array_init(bindKeys);
zephir_is_iterable(values, &_1, &_0, 0, 0, "phalcon/mvc/model/criteria.zep", 503);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HVALUE(value, _2);
ZEPHIR_INIT_NVAR(key);
ZEPHIR_CONCAT_SV(key, "ACP", hiddenParam);
ZEPHIR_INIT_LNVAR(_3$$3);
ZEPHIR_CONCAT_SVS(_3$$3, ":", key, ":");
zephir_array_append(&bindKeys, _3$$3, PH_SEPARATE, "phalcon/mvc/model/criteria.zep", 493);
zephir_array_update_zval(&bindParams, key, &value, PH_COPY | PH_SEPARATE);
ZEPHIR_SEPARATE(hiddenParam);
zephir_increment(hiddenParam);
}
ZEPHIR_INIT_VAR(_4);
zephir_fast_join_str(_4, SL(", "), bindKeys TSRMLS_CC);
ZEPHIR_INIT_VAR(_5);
ZEPHIR_CONCAT_VSVS(_5, expr, " NOT IN (", _4, ")");
ZEPHIR_CALL_METHOD(NULL, this_ptr, "andwhere", NULL, 0, _5, bindParams);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_hiddenParamNumber"), hiddenParam TSRMLS_CC);
RETURN_THIS();
}
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_BuiltInMethods, arrayMethodJoin1) {
zval *a_param = NULL, *_0;
zval *a = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &a_param);
zephir_get_arrval(a, a_param);
ZEPHIR_INIT_VAR(_0);
zephir_fast_join_str(_0, SL("|"), a TSRMLS_CC);
RETURN_CCTOR(_0);
}
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();
}
/**
* Check if the provided scope exists in storage.
*
* @param string! scope A space-separated string of scopes.
*
* @return boolean TRUE if it exists, FALSE otherwise.
*/
PHP_METHOD(OAuth2_Scope, scopeExists) {
zephir_nts_static zephir_fcall_cache_entry *_1 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *scope_param = NULL, *scopes, *reservedScope = NULL, *nonReservedScopes = NULL, *_0, *_2, *_3;
zval *scope = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &scope_param);
if (unlikely(Z_TYPE_P(scope_param) != IS_STRING && Z_TYPE_P(scope_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'scope' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(scope_param) == IS_STRING)) {
zephir_get_strval(scope, scope_param);
} else {
ZEPHIR_INIT_VAR(scope);
ZVAL_EMPTY_STRING(scope);
}
ZEPHIR_INIT_VAR(scopes);
ZEPHIR_INIT_VAR(_0);
zephir_fast_trim(_0, scope, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC);
zephir_fast_explode_str(scopes, SL(" "), _0, LONG_MAX TSRMLS_CC);
ZEPHIR_CALL_METHOD(&reservedScope, this_ptr, "getreservedscopes", NULL);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&nonReservedScopes, "array_diff", &_1, scopes, reservedScope);
zephir_check_call_status();
if (zephir_fast_count_int(nonReservedScopes TSRMLS_CC) == 0) {
RETURN_MM_BOOL(1);
}
ZEPHIR_INIT_VAR(_2);
zephir_fast_join_str(_2, SL(" "), nonReservedScopes TSRMLS_CC);
ZEPHIR_CPY_WRT(nonReservedScopes, _2);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("storage"), PH_NOISY_CC);
ZEPHIR_RETURN_CALL_METHOD(_3, "scopeexists", NULL, nonReservedScopes);
zephir_check_call_status();
RETURN_MM();
}
/**
* Get label for field
*
* @param string field
* @return string
*/
PHP_METHOD(Phalcon_Validation, getLabel) {
zval *field, *labels = NULL, *value = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &field);
ZEPHIR_OBS_VAR(labels);
zephir_read_property_this(&labels, this_ptr, SL("_labels"), PH_NOISY_CC);
if (Z_TYPE_P(field) == IS_ARRAY) {
zephir_fast_join_str(return_value, SL(", "), field TSRMLS_CC);
RETURN_MM();
}
if (zephir_array_isset_fetch(&value, labels, field, 1 TSRMLS_CC)) {
RETURN_CTOR(value);
}
RETVAL_ZVAL(field, 1, 0);
RETURN_MM();
}
/**
* @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);
}
/**
* 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);
}
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));
}
/**
* Executes the validator
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator_Uniqueness, validate) {
HashTable *_2$$5, *_22$$16;
HashPosition _1$$5, _21$$16;
zend_class_entry *_33;
zephir_fcall_cache_entry *_6 = NULL, *_12 = NULL, *_31 = NULL;
int ZEPHIR_LAST_CALL_STATUS, number = 0;
zval *record, *field = NULL, *dependencyInjector = NULL, *metaData = NULL, *message = NULL, *bindTypes = NULL, *bindDataTypes = NULL, *columnMap = NULL, *conditions = NULL, *bindParams = NULL, *composeField = NULL, *columnField = NULL, *bindType = NULL, *primaryField = NULL, *attributeField = NULL, *params = NULL, *className = NULL, *replacePairs = NULL, *_0 = NULL, *_19 = NULL, *_32 = NULL, **_3$$5, *_4$$8 = NULL, *_5$$8 = NULL, *_7$$10 = NULL, *_8$$10 = NULL, _9$$6 = zval_used_for_init, *_10$$6 = NULL, *_11$$6 = NULL, *_13$$13, *_14$$13, *_15$$15, *_16$$15, *_17$$11, *_18$$11 = NULL, *_20$$16 = NULL, **_23$$16, *_24$$20 = NULL, *_25$$20 = NULL, *_26$$22 = NULL, *_27$$22 = NULL, _28$$19 = zval_used_for_init, *_29$$19 = NULL, *_30$$19 = NULL, *_34$$24 = NULL, *_36$$24 = NULL, *_35$$25;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &record);
ZEPHIR_CALL_METHOD(&dependencyInjector, record, "getdi", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "modelsMetadata", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&metaData, dependencyInjector, "getshared", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(bindTypes);
array_init(bindTypes);
ZEPHIR_CALL_METHOD(&bindDataTypes, metaData, "getbindtypes", NULL, 0, record);
zephir_check_call_status();
if (ZEPHIR_GLOBAL(orm).column_renaming) {
ZEPHIR_CALL_METHOD(&columnMap, metaData, "getreversecolumnmap", NULL, 0, record);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(columnMap);
ZVAL_NULL(columnMap);
}
ZEPHIR_INIT_VAR(conditions);
array_init(conditions);
ZEPHIR_INIT_VAR(bindParams);
array_init(bindParams);
number = 0;
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "field", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&field, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (Z_TYPE_P(field) == IS_ARRAY) {
zephir_is_iterable(field, &_2$$5, &_1$$5, 0, 0, "phalcon/mvc/model/validator/uniqueness.zep", 127);
for (
; zephir_hash_get_current_data_ex(_2$$5, (void**) &_3$$5, &_1$$5) == SUCCESS
; zephir_hash_move_forward_ex(_2$$5, &_1$$5)
) {
ZEPHIR_GET_HVALUE(composeField, _3$$5);
if (Z_TYPE_P(columnMap) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(columnField);
if (!(zephir_array_isset_fetch(&columnField, columnMap, composeField, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_4$$8);
object_init_ex(_4$$8, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_5$$8);
ZEPHIR_CONCAT_SVS(_5$$8, "Column '", composeField, "' isn't part of the column map");
ZEPHIR_CALL_METHOD(NULL, _4$$8, "__construct", &_6, 9, _5$$8);
zephir_check_call_status();
zephir_throw_exception_debug(_4$$8, "phalcon/mvc/model/validator/uniqueness.zep", 104 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} else {
ZEPHIR_CPY_WRT(columnField, composeField);
}
ZEPHIR_OBS_NVAR(bindType);
if (!(zephir_array_isset_fetch(&bindType, bindDataTypes, columnField, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_7$$10);
object_init_ex(_7$$10, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_8$$10);
ZEPHIR_CONCAT_SVS(_8$$10, "Column '", columnField, "' isn't part of the table columns");
ZEPHIR_CALL_METHOD(NULL, _7$$10, "__construct", &_6, 9, _8$$10);
zephir_check_call_status();
zephir_throw_exception_debug(_7$$10, "phalcon/mvc/model/validator/uniqueness.zep", 114 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_SINIT_NVAR(_9$$6);
ZVAL_LONG(&_9$$6, number);
ZEPHIR_INIT_LNVAR(_10$$6);
ZEPHIR_CONCAT_SVSV(_10$$6, "[", composeField, "] = ?", &_9$$6);
zephir_array_append(&conditions, _10$$6, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 120);
ZEPHIR_CALL_METHOD(&_11$$6, record, "readattribute", &_12, 0, composeField);
zephir_check_call_status();
zephir_array_append(&bindParams, _11$$6, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 121);
zephir_array_append(&bindTypes, bindType, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 122);
number++;
}
} else {
if (Z_TYPE_P(columnMap) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(columnField);
if (!(zephir_array_isset_fetch(&columnField, columnMap, field, 0 TSRMLS_CC))) {
ZEPHIR_INIT_VAR(_13$$13);
object_init_ex(_13$$13, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_VAR(_14$$13);
ZEPHIR_CONCAT_SVS(_14$$13, "Column '", field, "' isn't part of the column map");
ZEPHIR_CALL_METHOD(NULL, _13$$13, "__construct", &_6, 9, _14$$13);
zephir_check_call_status();
zephir_throw_exception_debug(_13$$13, "phalcon/mvc/model/validator/uniqueness.zep", 134 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} else {
ZEPHIR_CPY_WRT(columnField, field);
}
ZEPHIR_OBS_NVAR(bindType);
if (!(zephir_array_isset_fetch(&bindType, bindDataTypes, columnField, 0 TSRMLS_CC))) {
ZEPHIR_INIT_VAR(_15$$15);
object_init_ex(_15$$15, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_VAR(_16$$15);
ZEPHIR_CONCAT_SVS(_16$$15, "Column '", columnField, "' isn't part of the table columns");
ZEPHIR_CALL_METHOD(NULL, _15$$15, "__construct", &_6, 9, _16$$15);
zephir_check_call_status();
zephir_throw_exception_debug(_15$$15, "phalcon/mvc/model/validator/uniqueness.zep", 144 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_INIT_VAR(_17$$11);
ZEPHIR_CONCAT_SVS(_17$$11, "[", field, "] = ?0");
zephir_array_append(&conditions, _17$$11, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 150);
ZEPHIR_CALL_METHOD(&_18$$11, record, "readattribute", NULL, 0, field);
zephir_check_call_status();
zephir_array_append(&bindParams, _18$$11, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 151);
zephir_array_append(&bindTypes, bindType, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 152);
number++;
}
ZEPHIR_CALL_METHOD(&_19, record, "getoperationmade", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_LONG(_19, 2)) {
if (ZEPHIR_GLOBAL(orm).column_renaming) {
ZEPHIR_CALL_METHOD(&columnMap, metaData, "getcolumnmap", NULL, 0, record);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(columnMap);
ZVAL_NULL(columnMap);
}
ZEPHIR_CALL_METHOD(&_20$$16, metaData, "getprimarykeyattributes", NULL, 0, record);
zephir_check_call_status();
zephir_is_iterable(_20$$16, &_22$$16, &_21$$16, 0, 0, "phalcon/mvc/model/validator/uniqueness.zep", 197);
for (
; zephir_hash_get_current_data_ex(_22$$16, (void**) &_23$$16, &_21$$16) == SUCCESS
; zephir_hash_move_forward_ex(_22$$16, &_21$$16)
) {
ZEPHIR_GET_HVALUE(primaryField, _23$$16);
ZEPHIR_OBS_NVAR(bindType);
if (!(zephir_array_isset_fetch(&bindType, bindDataTypes, primaryField, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_24$$20);
object_init_ex(_24$$20, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_25$$20);
ZEPHIR_CONCAT_SVS(_25$$20, "Column '", primaryField, "' isn't part of the table columns");
ZEPHIR_CALL_METHOD(NULL, _24$$20, "__construct", &_6, 9, _25$$20);
zephir_check_call_status();
zephir_throw_exception_debug(_24$$20, "phalcon/mvc/model/validator/uniqueness.zep", 174 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (Z_TYPE_P(columnMap) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(attributeField);
if (!(zephir_array_isset_fetch(&attributeField, columnMap, primaryField, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_26$$22);
object_init_ex(_26$$22, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_27$$22);
ZEPHIR_CONCAT_SVS(_27$$22, "Column '", primaryField, "' isn't part of the column map");
ZEPHIR_CALL_METHOD(NULL, _26$$22, "__construct", &_6, 9, _27$$22);
zephir_check_call_status();
zephir_throw_exception_debug(_26$$22, "phalcon/mvc/model/validator/uniqueness.zep", 182 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} else {
ZEPHIR_CPY_WRT(attributeField, primaryField);
}
ZEPHIR_SINIT_NVAR(_28$$19);
ZVAL_LONG(&_28$$19, number);
ZEPHIR_INIT_LNVAR(_29$$19);
ZEPHIR_CONCAT_SVSV(_29$$19, "[", attributeField, "] <> ?", &_28$$19);
zephir_array_append(&conditions, _29$$19, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 191);
ZEPHIR_CALL_METHOD(&_30$$19, record, "readattribute", &_31, 0, primaryField);
zephir_check_call_status();
zephir_array_append(&bindParams, _30$$19, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 192);
zephir_array_append(&bindTypes, bindType, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 193);
number++;
}
}
ZEPHIR_INIT_VAR(params);
array_init(params);
zephir_array_update_string(¶ms, SL("di"), &dependencyInjector, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_0);
zephir_fast_join_str(_0, SL(" AND "), conditions TSRMLS_CC);
zephir_array_update_string(¶ms, SL("conditions"), &_0, PH_COPY | PH_SEPARATE);
zephir_array_update_string(¶ms, SL("bind"), &bindParams, PH_COPY | PH_SEPARATE);
zephir_array_update_string(¶ms, SL("bindTypes"), &bindTypes, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_VAR(className);
zephir_get_class(className, record, 0 TSRMLS_CC);
_33 = zephir_fetch_class(className TSRMLS_CC);
ZEPHIR_CALL_CE_STATIC(&_32, _33, "count", NULL, 0, params);
zephir_check_call_status();
if (!ZEPHIR_IS_LONG(_32, 0)) {
ZEPHIR_INIT_VAR(_34$$24);
ZVAL_STRING(_34$$24, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _34$$24);
zephir_check_temp_parameter(_34$$24);
zephir_check_call_status();
ZEPHIR_INIT_VAR(replacePairs);
if (Z_TYPE_P(field) == IS_ARRAY) {
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_35$$25);
zephir_fast_join_str(_35$$25, SL(", "), field TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":fields"), &_35$$25, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(message);
ZVAL_STRING(message, "Value of fields: :fields are already present in another record", 1);
}
} else {
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &field, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(message);
ZVAL_STRING(message, "Value of field: ':field' is already present in another record", 1);
}
}
ZEPHIR_CALL_FUNCTION(&_36$$24, "strtr", NULL, 26, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_34$$24);
ZVAL_STRING(_34$$24, "Unique", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "appendmessage", NULL, 0, _36$$24, field, _34$$24);
zephir_check_temp_parameter(_34$$24);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_InclusionIn, validate) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *validation, validation_sub, *field, field_sub, value, domain, message, label, replacePairs, strict, fieldDomain, code, _0, _1, _4, _2$$6, _3$$7, _5$$9, _6$$9, _7$$9;
zval *this_ptr = getThis();
ZVAL_UNDEF(&validation_sub);
ZVAL_UNDEF(&field_sub);
ZVAL_UNDEF(&value);
ZVAL_UNDEF(&domain);
ZVAL_UNDEF(&message);
ZVAL_UNDEF(&label);
ZVAL_UNDEF(&replacePairs);
ZVAL_UNDEF(&strict);
ZVAL_UNDEF(&fieldDomain);
ZVAL_UNDEF(&code);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZVAL_UNDEF(&_4);
ZVAL_UNDEF(&_2$$6);
ZVAL_UNDEF(&_3$$7);
ZVAL_UNDEF(&_5$$9);
ZVAL_UNDEF(&_6$$9);
ZVAL_UNDEF(&_7$$9);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field);
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_0);
ZVAL_STRING(&_0, "domain");
ZEPHIR_CALL_METHOD(&domain, this_ptr, "getoption", NULL, 0, &_0);
zephir_check_call_status();
ZEPHIR_OBS_VAR(&fieldDomain);
if (zephir_array_isset_fetch(&fieldDomain, &domain, field, 0 TSRMLS_CC)) {
if (Z_TYPE_P(&fieldDomain) == IS_ARRAY) {
ZEPHIR_CPY_WRT(&domain, &fieldDomain);
}
}
if (Z_TYPE_P(&domain) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Option 'domain' must be an array", "phalcon/validation/validator/inclusionin.zep", 81);
return;
}
ZEPHIR_INIT_VAR(&strict);
ZVAL_BOOL(&strict, 0);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "strict");
ZEPHIR_CALL_METHOD(&_1, this_ptr, "hasoption", NULL, 0, &_0);
zephir_check_call_status();
if (zephir_is_true(&_1)) {
ZEPHIR_INIT_VAR(&_2$$6);
ZVAL_STRING(&_2$$6, "strict");
ZEPHIR_CALL_METHOD(&strict, this_ptr, "getoption", NULL, 0, &_2$$6);
zephir_check_call_status();
if (Z_TYPE_P(&strict) == IS_ARRAY) {
zephir_array_fetch(&_3$$7, &strict, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/inclusionin.zep", 89 TSRMLS_CC);
ZEPHIR_CPY_WRT(&strict, &_3$$7);
}
if (((Z_TYPE_P(&strict) == IS_TRUE || Z_TYPE_P(&strict) == IS_FALSE) != 1)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Option 'strict' must be a bool", "phalcon/validation/validator/inclusionin.zep", 93);
return;
}
}
ZEPHIR_CALL_FUNCTION(&_4, "in_array", NULL, 455, &value, &domain, &strict);
zephir_check_call_status();
if (!(zephir_is_true(&_4))) {
ZEPHIR_CALL_METHOD(&label, this_ptr, "preparelabel", NULL, 0, validation, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_5$$9);
ZVAL_STRING(&_5$$9, "InclusionIn");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_5$$9);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&code, this_ptr, "preparecode", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&replacePairs);
zephir_create_array(&replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_5$$9);
zephir_fast_join_str(&_5$$9, SL(", "), &domain TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":domain"), &_5$$9, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_5$$9);
object_init_ex(&_5$$9, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_6$$9, "strtr", NULL, 48, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_7$$9);
ZVAL_STRING(&_7$$9, "InclusionIn");
ZEPHIR_CALL_METHOD(NULL, &_5$$9, "__construct", NULL, 300, &_6$$9, field, &_7$$9, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_5$$9);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
PHP_METHOD(Test_Fasta, fastaRepeat) {
zval *_2 = NULL, *_5 = NULL;
int i, ZEPHIR_LAST_CALL_STATUS;
zval *seq = NULL;
zval *n, *seq_param = NULL, *len, *j = NULL, *k = NULL, *l, *block, *str, *lines = NULL, *_0, _1, *_3, _4, _6 = zval_used_for_init, _7 = zval_used_for_init, *_8 = NULL, *_9;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &n, &seq_param);
zephir_get_strval(seq, seq_param);
ZEPHIR_INIT_VAR(len);
ZVAL_LONG(len, zephir_fast_strlen_ev(seq));
ZEPHIR_INIT_VAR(_0);
ZEPHIR_SINIT_VAR(_1);
ZVAL_LONG(&_1, ((zephir_get_numberval(len) * 60) + 1));
zephir_create_array(_0, zephir_get_intval(&_1), 1 TSRMLS_CC);
zephir_get_arrval(_2, _0);
ZEPHIR_INIT_VAR(str);
zephir_fast_join(str, seq, _2 TSRMLS_CC);
ZEPHIR_INIT_VAR(_3);
ZEPHIR_SINIT_VAR(_4);
mul_function(&_4, len, len TSRMLS_CC);
zephir_create_array(_3, zephir_get_intval(&_4), 1 TSRMLS_CC);
zephir_get_arrval(_5, _3);
ZEPHIR_CPY_WRT(lines, _5);
ZEPHIR_INIT_VAR(j);
mul_function(j, len, len TSRMLS_CC);
i = zephir_get_numberval(j);
while (1) {
if (ZEPHIR_LE_LONG(j, -1)) {
break;
}
ZEPHIR_SEPARATE(j);
zephir_decrement(j);
ZEPHIR_SINIT_NVAR(_6);
ZVAL_LONG(&_6, (60 * zephir_get_numberval(j)));
ZEPHIR_SINIT_NVAR(_7);
ZVAL_LONG(&_7, 60);
ZEPHIR_INIT_NVAR(_8);
zephir_substr(_8, str, zephir_get_intval(&_6), 60 , 0);
zephir_array_update_zval(&lines, j, &_8, PH_COPY | PH_SEPARATE);
}
ZEPHIR_INIT_NVAR(j);
ZVAL_LONG(j, 0);
ZEPHIR_SINIT_NVAR(_6);
ZVAL_DOUBLE(&_6, zephir_safe_div_zval_long(n, 60 TSRMLS_CC));
ZEPHIR_INIT_VAR(l);
ZVAL_DOUBLE(l, zephir_floor(&_6 TSRMLS_CC));
ZEPHIR_SINIT_NVAR(_7);
ZVAL_DOUBLE(&_7, zephir_safe_div_zval_long(l, i TSRMLS_CC));
ZEPHIR_INIT_VAR(k);
ZVAL_DOUBLE(k, zephir_floor(&_7 TSRMLS_CC));
ZEPHIR_INIT_VAR(block);
zephir_fast_join_str(block, SL("\n"), lines TSRMLS_CC);
while (1) {
if (!(ZEPHIR_LT(j, k))) {
break;
}
zend_print_zval(block, 0);
ZEPHIR_SEPARATE(j);
zephir_increment(j);
}
ZEPHIR_INIT_NVAR(j);
ZVAL_LONG(j, 0);
ZEPHIR_INIT_NVAR(k);
ZVAL_DOUBLE(k, zephir_safe_mod_zval_long(l, i TSRMLS_CC));
while (1) {
if (!(ZEPHIR_LT(j, k))) {
break;
}
zephir_array_fetch(&_9, lines, j, PH_NOISY | PH_READONLY, "test/fasta.zep", 38 TSRMLS_CC);
zend_print_zval(_9, 0);
ZEPHIR_SEPARATE(j);
zephir_increment(j);
}
if (zephir_safe_mod_zval_long(n, 60 TSRMLS_CC) > 0) {
zephir_array_fetch(&_9, lines, k, PH_NOISY | PH_READONLY, "test/fasta.zep", 43 TSRMLS_CC);
ZEPHIR_SINIT_NVAR(_6);
ZVAL_LONG(&_6, 0);
ZEPHIR_SINIT_NVAR(_7);
ZVAL_DOUBLE(&_7, zephir_safe_mod_zval_long(n, 60 TSRMLS_CC));
ZEPHIR_INIT_NVAR(_8);
zephir_substr(_8, _9, 0 , zephir_get_intval(&_7), 0);
zend_print_zval(_8, 0);
}
ZEPHIR_MM_RESTORE();
}
/**
* 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();
}
/**
* Outputs a message formatting it with HTML
*
*<code>
* $flash->outputMessage('error', message);
*</code>
*
* @param string|array message
* @return string|void
*/
PHP_METHOD(Phalcon_Flash, outputMessage) {
HashTable *_3$$8;
HashPosition _2$$8;
zend_bool automaticHtml = 0, implicitFlush = 0;
zval *type_param = NULL, *message, *content = NULL, *cssClasses = NULL, *classes = NULL, *typeClasses = NULL, *eol = NULL, *msg = NULL, *htmlMessage = NULL, *_0 = NULL, *_1$$5, **_4$$8;
zval *type = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &type_param, &message);
zephir_get_strval(type, type_param);
ZEPHIR_OBS_VAR(_0);
zephir_read_property_this(&_0, this_ptr, SL("_automaticHtml"), PH_NOISY_CC);
automaticHtml = zephir_get_boolval(_0);
if (automaticHtml == 1) {
ZEPHIR_OBS_VAR(classes);
zephir_read_property_this(&classes, this_ptr, SL("_cssClasses"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(typeClasses);
if (zephir_array_isset_fetch(&typeClasses, classes, type, 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(cssClasses);
if (Z_TYPE_P(typeClasses) == IS_ARRAY) {
ZEPHIR_INIT_VAR(_1$$5);
zephir_fast_join_str(_1$$5, SL(" "), typeClasses TSRMLS_CC);
ZEPHIR_CONCAT_SVS(cssClasses, " class=\"", _1$$5, "\"");
} else {
ZEPHIR_CONCAT_SVS(cssClasses, " class=\"", typeClasses, "\"");
}
} else {
ZEPHIR_INIT_NVAR(cssClasses);
ZVAL_STRING(cssClasses, "", 1);
}
ZEPHIR_INIT_VAR(eol);
ZEPHIR_GET_CONSTANT(eol, "PHP_EOL");
}
ZEPHIR_OBS_NVAR(_0);
zephir_read_property_this(&_0, this_ptr, SL("_implicitFlush"), PH_NOISY_CC);
implicitFlush = zephir_get_boolval(_0);
if (Z_TYPE_P(message) == IS_ARRAY) {
if (implicitFlush == 0) {
ZEPHIR_INIT_VAR(content);
ZVAL_STRING(content, "", 1);
}
zephir_is_iterable(message, &_3$$8, &_2$$8, 0, 0, "phalcon/flash.zep", 204);
for (
; zephir_hash_get_current_data_ex(_3$$8, (void**) &_4$$8, &_2$$8) == SUCCESS
; zephir_hash_move_forward_ex(_3$$8, &_2$$8)
) {
ZEPHIR_GET_HVALUE(msg, _4$$8);
if (automaticHtml == 1) {
ZEPHIR_INIT_NVAR(htmlMessage);
ZEPHIR_CONCAT_SVSVSV(htmlMessage, "<div", cssClasses, ">", msg, "</div>", eol);
} else {
ZEPHIR_CPY_WRT(htmlMessage, msg);
}
if (implicitFlush == 1) {
zend_print_zval(htmlMessage, 0);
} else {
zephir_concat_self(&content, htmlMessage TSRMLS_CC);
zephir_update_property_array_append(this_ptr, SL("_messages"), htmlMessage TSRMLS_CC);
}
}
if (implicitFlush == 0) {
RETURN_CCTOR(content);
}
} else {
if (automaticHtml == 1) {
ZEPHIR_INIT_NVAR(htmlMessage);
ZEPHIR_CONCAT_SVSVSV(htmlMessage, "<div", cssClasses, ">", message, "</div>", eol);
} else {
ZEPHIR_CPY_WRT(htmlMessage, message);
}
if (implicitFlush == 1) {
zend_print_zval(htmlMessage, 0);
} else {
zephir_update_property_array_append(this_ptr, SL("_messages"), htmlMessage TSRMLS_CC);
RETURN_CCTOR(htmlMessage);
}
}
ZEPHIR_MM_RESTORE();
}
/**
* 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();
}
/**
* Returns a slice of the resultset to show in the pagination
*/
PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilder, getPaginate) {
zval *_6$$14, *_8$$15;
zend_bool hasHaving = 0, hasGroup = 0, _2;
zval *originalBuilder = NULL, *builder = NULL, *totalBuilder = NULL, *totalPages = NULL, *limit = NULL, *number = NULL, *query = NULL, *page = NULL, *items = NULL, *totalQuery = NULL, *result = NULL, *row = NULL, *rowcount = NULL, *next = NULL, *sql = NULL, *columns = NULL, *db = NULL, *_0, *_1 = NULL, *groups = NULL, *_10, *_22, *_3$$10, *groupColumn$$11 = NULL, *_4$$14 = NULL, *_5$$14, *_7$$14, *_9$$15, *_11$$16 = NULL, *_12$$16 = NULL, *_13$$16, *_14$$16, *_15$$16, *_16$$16, _17$$16, _18$$16, *_19$$17, _20$$17, _21$$17;
zend_long ZEPHIR_LAST_CALL_STATUS, numberPage = 0, before = 0;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(originalBuilder);
zephir_read_property_this(&originalBuilder, this_ptr, SL("_builder"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(columns);
zephir_read_property_this(&columns, this_ptr, SL("_columns"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(builder);
if (zephir_clone(builder, originalBuilder TSRMLS_CC) == FAILURE) {
RETURN_MM();
}
ZEPHIR_INIT_VAR(totalBuilder);
if (zephir_clone(totalBuilder, builder TSRMLS_CC) == FAILURE) {
RETURN_MM();
}
ZEPHIR_OBS_VAR(limit);
zephir_read_property_this(&limit, this_ptr, SL("_limitRows"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(_0);
zephir_read_property_this(&_0, this_ptr, SL("_page"), PH_NOISY_CC);
numberPage = zephir_get_intval(_0);
if (!(numberPage)) {
numberPage = 1;
}
ZEPHIR_INIT_VAR(number);
ZVAL_LONG(number, (zephir_get_numberval(limit) * ((numberPage - 1))));
if (ZEPHIR_LT(number, limit)) {
ZEPHIR_CALL_METHOD(NULL, builder, "limit", NULL, 0, limit);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(NULL, builder, "limit", NULL, 0, limit, number);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&query, builder, "getquery", NULL, 0);
zephir_check_call_status();
if (numberPage == 1) {
before = 1;
} else {
before = (numberPage - 1);
}
ZEPHIR_CALL_METHOD(&items, query, "execute", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_1, totalBuilder, "gethaving", NULL, 0);
zephir_check_call_status();
hasHaving = !(ZEPHIR_IS_EMPTY(_1));
ZEPHIR_CALL_METHOD(&groups, totalBuilder, "getgroupby", NULL, 0);
zephir_check_call_status();
hasGroup = !(ZEPHIR_IS_EMPTY(groups));
_2 = hasHaving;
if (_2) {
_2 = !hasGroup;
}
if (_2) {
if (ZEPHIR_IS_EMPTY(columns)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_paginator_exception_ce, "When having is set there should be columns option provided for which calculate row count", "phalcon/paginator/adapter/querybuilder.zep", 186);
return;
}
ZEPHIR_CALL_METHOD(NULL, totalBuilder, "columns", NULL, 0, columns);
zephir_check_call_status();
} else {
ZEPHIR_INIT_VAR(_3$$10);
ZVAL_STRING(_3$$10, "COUNT(*) [rowcount]", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, totalBuilder, "columns", NULL, 0, _3$$10);
zephir_check_temp_parameter(_3$$10);
zephir_check_call_status();
}
if (hasGroup) {
if (Z_TYPE_P(groups) == IS_ARRAY) {
ZEPHIR_INIT_VAR(groupColumn$$11);
zephir_fast_join_str(groupColumn$$11, SL(", "), groups TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(groupColumn$$11, groups);
}
if (!(hasHaving)) {
ZEPHIR_INIT_VAR(_5$$14);
ZVAL_NULL(_5$$14);
ZEPHIR_CALL_METHOD(&_4$$14, totalBuilder, "groupby", NULL, 0, _5$$14);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_6$$14);
zephir_create_array(_6$$14, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_7$$14);
ZEPHIR_CONCAT_SVS(_7$$14, "COUNT(DISTINCT ", groupColumn$$11, ") AS rowcount");
zephir_array_fast_append(_6$$14, _7$$14);
ZEPHIR_CALL_METHOD(NULL, _4$$14, "columns", NULL, 0, _6$$14);
zephir_check_call_status();
} else {
ZEPHIR_INIT_VAR(_8$$15);
zephir_create_array(_8$$15, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_9$$15);
ZEPHIR_CONCAT_SV(_9$$15, "DISTINCT ", groupColumn$$11);
zephir_array_fast_append(_8$$15, _9$$15);
ZEPHIR_CALL_METHOD(NULL, totalBuilder, "columns", NULL, 0, _8$$15);
zephir_check_call_status();
}
}
ZEPHIR_INIT_VAR(_10);
ZVAL_NULL(_10);
ZEPHIR_CALL_METHOD(NULL, totalBuilder, "orderby", NULL, 0, _10);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&totalQuery, totalBuilder, "getquery", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(rowcount);
if (hasHaving) {
ZEPHIR_CALL_METHOD(&sql, totalQuery, "getsql", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_11$$16, totalBuilder, "getdi", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_12$$16);
ZVAL_STRING(_12$$16, "db", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&db, _11$$16, "get", NULL, 0, _12$$16);
zephir_check_temp_parameter(_12$$16);
zephir_check_call_status();
zephir_array_fetch_string(&_13$$16, sql, SL("sql"), PH_NOISY | PH_READONLY, "phalcon/paginator/adapter/querybuilder.zep", 228 TSRMLS_CC);
ZEPHIR_INIT_VAR(_14$$16);
ZEPHIR_CONCAT_SVS(_14$$16, "SELECT COUNT(*) as rowcount FROM (", _13$$16, ") as T1");
zephir_array_fetch_string(&_15$$16, sql, SL("bind"), PH_NOISY | PH_READONLY, "phalcon/paginator/adapter/querybuilder.zep", 228 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_12$$16);
ZVAL_LONG(_12$$16, 2);
ZEPHIR_CALL_METHOD(&row, db, "fetchone", NULL, 0, _14$$16, _12$$16, _15$$16);
zephir_check_call_status();
if (zephir_is_true(row)) {
zephir_array_fetch_string(&_16$$16, row, SL("rowcount"), PH_NOISY | PH_READONLY, "phalcon/paginator/adapter/querybuilder.zep", 229 TSRMLS_CC);
ZVAL_LONG(rowcount, zephir_get_intval(_16$$16));
} else {
ZVAL_LONG(rowcount, 0);
}
ZEPHIR_SINIT_VAR(_17$$16);
div_function(&_17$$16, rowcount, limit TSRMLS_CC);
ZEPHIR_SINIT_VAR(_18$$16);
ZVAL_DOUBLE(&_18$$16, zephir_ceil(&_17$$16 TSRMLS_CC));
ZEPHIR_INIT_VAR(totalPages);
ZVAL_LONG(totalPages, zephir_get_intval(&_18$$16));
} else {
ZEPHIR_CALL_METHOD(&result, totalQuery, "execute", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&row, result, "getfirst", NULL, 0);
zephir_check_call_status();
if (zephir_is_true(row)) {
ZEPHIR_OBS_VAR(_19$$17);
zephir_read_property(&_19$$17, row, SL("rowcount"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(rowcount);
ZVAL_LONG(rowcount, zephir_get_intval(_19$$17));
} else {
ZEPHIR_INIT_NVAR(rowcount);
ZVAL_LONG(rowcount, 0);
}
ZEPHIR_SINIT_VAR(_20$$17);
div_function(&_20$$17, rowcount, limit TSRMLS_CC);
ZEPHIR_SINIT_VAR(_21$$17);
ZVAL_DOUBLE(&_21$$17, zephir_ceil(&_20$$17 TSRMLS_CC));
ZEPHIR_INIT_NVAR(totalPages);
ZVAL_LONG(totalPages, zephir_get_intval(&_21$$17));
}
if (ZEPHIR_GT_LONG(totalPages, numberPage)) {
ZEPHIR_INIT_VAR(next);
ZVAL_LONG(next, (numberPage + 1));
} else {
ZEPHIR_CPY_WRT(next, totalPages);
}
ZEPHIR_INIT_VAR(page);
object_init(page);
zephir_update_property_zval(page, SL("items"), items TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_22);
ZVAL_LONG(_22, 1);
zephir_update_property_zval(page, SL("first"), _22 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_22);
ZVAL_LONG(_22, before);
zephir_update_property_zval(page, SL("before"), _22 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_22);
ZVAL_LONG(_22, numberPage);
zephir_update_property_zval(page, SL("current"), _22 TSRMLS_CC);
zephir_update_property_zval(page, SL("last"), totalPages TSRMLS_CC);
zephir_update_property_zval(page, SL("next"), next TSRMLS_CC);
zephir_update_property_zval(page, SL("total_pages"), totalPages TSRMLS_CC);
zephir_update_property_zval(page, SL("total_items"), rowcount TSRMLS_CC);
_22 = zephir_fetch_nproperty_this(this_ptr, SL("_limitRows"), PH_NOISY_CC);
zephir_update_property_zval(page, SL("limit"), _22 TSRMLS_CC);
RETURN_CCTOR(page);
}
/**
* This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
* Call it when you need to restore a database connection
*
*<code>
* //Make a connection
* $connection = new \Phalcon\Db\Adapter\Pdo\Mysql(array(
* 'host' => '192.168.0.11',
* 'username' => 'sigma',
* 'password' => 'secret',
* 'dbname' => 'blog',
* ));
*
* //Reconnect
* $connection->connect();
* </code>
*
* @param array descriptor
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, connect) {
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_1;
HashPosition _0;
zval *descriptor = NULL, *username = NULL, *password = NULL, *dsnParts, *dsnAttributes = NULL, *persistent, *options = NULL, *key = NULL, *value = NULL, **_2, *_3 = NULL, *_4, *_5, *_6;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &descriptor);
if (!descriptor) {
ZEPHIR_CPY_WRT(descriptor, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(descriptor);
}
if (Z_TYPE_P(descriptor) == IS_NULL) {
ZEPHIR_OBS_NVAR(descriptor);
zephir_read_property_this(&descriptor, this_ptr, SL("_descriptor"), PH_NOISY_CC);
}
ZEPHIR_OBS_VAR(username);
if (zephir_array_isset_string_fetch(&username, descriptor, SS("username"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&descriptor, SS("username"), PH_SEPARATE);
} else {
ZEPHIR_INIT_NVAR(username);
ZVAL_NULL(username);
}
ZEPHIR_OBS_VAR(password);
if (zephir_array_isset_string_fetch(&password, descriptor, SS("password"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&descriptor, SS("password"), PH_SEPARATE);
} else {
ZEPHIR_INIT_NVAR(password);
ZVAL_NULL(password);
}
ZEPHIR_OBS_VAR(options);
if (zephir_array_isset_string_fetch(&options, descriptor, SS("options"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&descriptor, SS("options"), PH_SEPARATE);
} else {
ZEPHIR_INIT_NVAR(options);
array_init(options);
}
ZEPHIR_OBS_VAR(dsnAttributes);
if (!(zephir_array_isset_string_fetch(&dsnAttributes, descriptor, SS("dsn"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_VAR(dsnParts);
array_init(dsnParts);
zephir_is_iterable(descriptor, &_1, &_0, 0, 0, "phalcon/db/adapter/pdo.zep", 130);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HMKEY(key, _1, _0);
ZEPHIR_GET_HVALUE(value, _2);
ZEPHIR_INIT_LNVAR(_3);
ZEPHIR_CONCAT_VSV(_3, key, "=", value);
zephir_array_append(&dsnParts, _3, PH_SEPARATE, "phalcon/db/adapter/pdo.zep", 128);
}
ZEPHIR_INIT_NVAR(dsnAttributes);
zephir_fast_join_str(dsnAttributes, SL(";"), dsnParts TSRMLS_CC);
}
ZEPHIR_INIT_VAR(_4);
ZVAL_LONG(_4, 2);
zephir_array_update_long(&options, 3, &_4, PH_COPY | PH_SEPARATE, "phalcon/db/adapter/pdo.zep", 133);
if (zephir_array_isset_string_fetch(&persistent, descriptor, SS("persistent"), 1 TSRMLS_CC)) {
if (zephir_is_true(persistent)) {
zephir_array_update_long(&options, 12, &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE, "phalcon/db/adapter/pdo.zep", 140);
}
}
ZEPHIR_INIT_VAR(_5);
object_init_ex(_5, php_pdo_get_dbh_ce());
_6 = zephir_fetch_nproperty_this(this_ptr, SL("_type"), PH_NOISY_CC);
ZEPHIR_INIT_LNVAR(_3);
ZEPHIR_CONCAT_VSV(_3, _6, ":", dsnAttributes);
ZEPHIR_CALL_METHOD(NULL, _5, "__construct", NULL, 0, _3, username, password, options);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_pdo"), _5 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Executes validator
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator_Inclusionin, validate) {
zval *_7;
zephir_nts_static zephir_fcall_cache_entry *_6 = NULL, *_9 = NULL;
zend_bool _3;
int ZEPHIR_LAST_CALL_STATUS;
zval *record, *field = NULL, *domain = NULL, *value = NULL, *message = NULL, *strict = NULL, *_0 = NULL, *_1 = NULL, *_2 = NULL, *_4 = NULL, *_5 = NULL, *_8 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &record);
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "field", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&field, this_ptr, "getoption", NULL, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (Z_TYPE_P(field) != IS_STRING) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Field name must be a string", "phalcon/mvc/model/validator/inclusionin.zep", 63);
return;
}
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "domain", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_1, this_ptr, "issetoption", NULL, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_1)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "The option 'domain' is required for this validator", "phalcon/mvc/model/validator/inclusionin.zep", 70);
return;
}
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "domain", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&domain, this_ptr, "getoption", NULL, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (Z_TYPE_P(domain) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Option 'domain' must be an array", "phalcon/mvc/model/validator/inclusionin.zep", 75);
return;
}
ZEPHIR_CALL_METHOD(&value, record, "readattribute", NULL, field);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "allowEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_2, this_ptr, "issetoption", NULL, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
_3 = zephir_is_true(_2);
if (_3) {
_3 = ZEPHIR_IS_EMPTY(value);
}
if (_3) {
RETURN_MM_BOOL(1);
}
ZEPHIR_INIT_VAR(strict);
ZVAL_BOOL(strict, 0);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "strict", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_4, this_ptr, "issetoption", NULL, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (zephir_is_true(_4)) {
if (Z_TYPE_P(strict) != IS_BOOL) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Option 'strict' must be a boolean", "phalcon/mvc/model/validator/inclusionin.zep", 87);
return;
}
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "strict", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&strict, this_ptr, "getoption", NULL, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
}
ZEPHIR_CALL_FUNCTION(&_5, "in_array", &_6, value, domain, strict);
zephir_check_call_status();
if (!(zephir_is_true(_5))) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(message);
ZVAL_STRING(message, "Value of field ':field' must be part of list: :domain", 1);
}
ZEPHIR_INIT_VAR(_7);
zephir_create_array(_7, 2, 0 TSRMLS_CC);
zephir_array_update_string(&_7, SL(":field"), &field, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_0);
zephir_fast_join_str(_0, SL(", "), domain TSRMLS_CC);
zephir_array_update_string(&_7, SL(":domain"), &_0, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_FUNCTION(&_8, "strtr", &_9, message, _7);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "Inclusion", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "appendmessage", NULL, _8, field, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Executes the validator
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator_Exclusionin, validate) {
zval *_5$$7;
zend_bool _3;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *record, *field = NULL, *domain = NULL, *value = NULL, *message = NULL, *_0 = NULL, *_1 = NULL, *_2 = NULL, *_4$$7 = NULL, *_6$$7 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &record);
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "field", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&field, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (Z_TYPE_P(field) != IS_STRING) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Field name must be a string", "phalcon/mvc/model/validator/exclusionin.zep", 73);
return;
}
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "domain", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_1, this_ptr, "issetoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_1)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "The option 'domain' is required by this validator", "phalcon/mvc/model/validator/exclusionin.zep", 80);
return;
}
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "domain", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&domain, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (Z_TYPE_P(domain) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Option 'domain' must be an array", "phalcon/mvc/model/validator/exclusionin.zep", 85);
return;
}
ZEPHIR_CALL_METHOD(&value, record, "readattribute", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "allowEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_2, this_ptr, "issetoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
_3 = zephir_is_true(_2);
if (_3) {
_3 = ZEPHIR_IS_EMPTY(value);
}
if (_3) {
RETURN_MM_BOOL(1);
}
if (zephir_fast_in_array(value, domain TSRMLS_CC)) {
ZEPHIR_INIT_VAR(_4$$7);
ZVAL_STRING(_4$$7, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _4$$7);
zephir_check_temp_parameter(_4$$7);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(message);
ZVAL_STRING(message, "Value of field ':field' must not be part of list: :domain", 1);
}
ZEPHIR_INIT_VAR(_5$$7);
zephir_create_array(_5$$7, 2, 0 TSRMLS_CC);
zephir_array_update_string(&_5$$7, SL(":field"), &field, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_4$$7);
zephir_fast_join_str(_4$$7, SL(", "), domain TSRMLS_CC);
zephir_array_update_string(&_5$$7, SL(":domain"), &_4$$7, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_FUNCTION(&_6$$7, "strtr", NULL, 27, message, _5$$7);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_4$$7);
ZVAL_STRING(_4$$7, "Exclusion", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "appendmessage", NULL, 0, _6$$7, field, _4$$7);
zephir_check_temp_parameter(_4$$7);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_InclusionIn, validate) {
zend_bool _2;
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *value = NULL, *domain = NULL, *message = NULL, *label = NULL, *replacePairs = NULL, *strict = NULL, *_0 = NULL, *_1 = NULL, *_3 = NULL, *_5 = NULL, *_4$$5, *_6$$7 = NULL, *_8$$7 = NULL, *_9$$7, *_7$$9;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field_param);
if (unlikely(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(field_param) == IS_STRING)) {
zephir_get_strval(field, field_param);
} else {
ZEPHIR_INIT_VAR(field);
ZVAL_EMPTY_STRING(field);
}
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "allowEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "issetoption", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
_2 = zephir_is_true(_0);
if (_2) {
_2 = ZEPHIR_IS_EMPTY(value);
}
if (_2) {
RETURN_MM_BOOL(1);
}
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "domain", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&domain, this_ptr, "getoption", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (Z_TYPE_P(domain) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Option 'domain' must be an array", "phalcon/validation/validator/inclusionin.zep", 62);
return;
}
ZEPHIR_INIT_VAR(strict);
ZVAL_BOOL(strict, 0);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "strict", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_3, this_ptr, "issetoption", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (zephir_is_true(_3)) {
if (Z_TYPE_P(strict) != IS_BOOL) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Option 'strict' must be a boolean", "phalcon/validation/validator/inclusionin.zep", 68);
return;
}
ZEPHIR_INIT_VAR(_4$$5);
ZVAL_STRING(_4$$5, "strict", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&strict, this_ptr, "getoption", NULL, 0, _4$$5);
zephir_check_temp_parameter(_4$$5);
zephir_check_call_status();
}
ZEPHIR_CALL_FUNCTION(&_5, "in_array", NULL, 358, value, domain, strict);
zephir_check_call_status();
if (!(zephir_is_true(_5))) {
ZEPHIR_INIT_VAR(_6$$7);
ZVAL_STRING(_6$$7, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _6$$7);
zephir_check_temp_parameter(_6$$7);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_6$$7);
ZVAL_STRING(_6$$7, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _6$$7);
zephir_check_temp_parameter(_6$$7);
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(_6$$7);
zephir_fast_join_str(_6$$7, SL(", "), domain TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":domain"), &_6$$7, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_VAR(_7$$9);
ZVAL_STRING(_7$$9, "InclusionIn", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _7$$9);
zephir_check_temp_parameter(_7$$9);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_6$$7);
object_init_ex(_6$$7, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_8$$7, "strtr", NULL, 55, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_9$$7);
ZVAL_STRING(_9$$7, "InclusionIn", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _6$$7, "__construct", NULL, 438, _8$$7, field, _9$$7);
zephir_check_temp_parameter(_9$$7);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _6$$7);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Produces a recursive representation of an array
*/
PHP_METHOD(Phalcon_Debug, _getArrayDump) {
HashTable *_2;
HashPosition _1;
zend_bool _0;
zephir_fcall_cache_entry *_4 = NULL, *_7 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *argument_param = NULL, *n = NULL, *numberArguments = NULL, *dump = NULL, *varDump = NULL, *k = NULL, *v = NULL, **_3, *_5$$8 = NULL, *_6$$8 = NULL, *_8$$9 = NULL, *_9$$5 = NULL;
zval *argument = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &argument_param, &n);
argument = argument_param;
if (!n) {
ZEPHIR_INIT_VAR(n);
ZVAL_LONG(n, 0);
}
ZEPHIR_INIT_VAR(numberArguments);
ZVAL_LONG(numberArguments, zephir_fast_count_int(argument TSRMLS_CC));
_0 = ZEPHIR_GE_LONG(n, 3);
if (!(_0)) {
_0 = ZEPHIR_IS_LONG(numberArguments, 0);
}
if (_0) {
RETURN_MM_NULL();
}
if (ZEPHIR_GE_LONG(numberArguments, 10)) {
RETURN_CCTOR(numberArguments);
}
ZEPHIR_INIT_VAR(dump);
array_init(dump);
zephir_is_iterable(argument, &_2, &_1, 0, 0, "phalcon/debug.zep", 189);
for (
; zend_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zend_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HMKEY(k, _2, _1);
ZEPHIR_GET_HVALUE(v, _3);
if (ZEPHIR_IS_STRING(v, "")) {
ZEPHIR_INIT_NVAR(varDump);
ZVAL_STRING(varDump, "(empty string)", 1);
} else if (zephir_is_scalar(v)) {
ZEPHIR_CALL_METHOD(&varDump, this_ptr, "_escapestring", &_4, 0, v);
zephir_check_call_status();
} else if (Z_TYPE_P(v) == IS_ARRAY) {
ZEPHIR_INIT_NVAR(_6$$8);
ZVAL_LONG(_6$$8, (zephir_get_numberval(n) + 1));
ZEPHIR_CALL_METHOD(&_5$$8, this_ptr, "_getarraydump", &_7, 159, v, _6$$8);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(varDump);
ZEPHIR_CONCAT_SVS(varDump, "Array(", _5$$8, ")");
} else if (Z_TYPE_P(v) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_8$$9);
zephir_get_class(_8$$9, v, 0 TSRMLS_CC);
ZEPHIR_INIT_NVAR(varDump);
ZEPHIR_CONCAT_SVS(varDump, "Object(", _8$$9, ")");
} else if (Z_TYPE_P(v) == IS_NULL) {
ZEPHIR_INIT_NVAR(varDump);
ZVAL_STRING(varDump, "null", 1);
} else {
ZEPHIR_CPY_WRT(varDump, v);
}
ZEPHIR_INIT_LNVAR(_9$$5);
ZEPHIR_CONCAT_SVSV(_9$$5, "[", k, "] => ", varDump);
zephir_array_append(&dump, _9$$5, PH_SEPARATE, "phalcon/debug.zep", 186);
}
zephir_fast_join_str(return_value, SL(", "), dump TSRMLS_CC);
RETURN_MM();
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_InclusionIn, validate) {
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *value = NULL, *domain = NULL, *message = NULL, *label = NULL, *replacePairs = NULL, *strict = NULL, *fieldDomain = NULL, *code = NULL, *_0 = NULL, *_1 = NULL, *_4 = NULL, *_2$$6, *_3$$7, *_5$$9 = NULL, *_10$$9 = NULL, *_11$$9, *_6$$10, *_7$$12, *_8$$13, *_9$$14;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field_param);
if (unlikely(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(field_param) == IS_STRING)) {
zephir_get_strval(field, field_param);
} else {
ZEPHIR_INIT_VAR(field);
ZVAL_EMPTY_STRING(field);
}
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "domain", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&domain, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
ZEPHIR_OBS_VAR(fieldDomain);
if (zephir_array_isset_fetch(&fieldDomain, domain, field, 0 TSRMLS_CC)) {
if (Z_TYPE_P(fieldDomain) == IS_ARRAY) {
ZEPHIR_CPY_WRT(domain, fieldDomain);
}
}
if (Z_TYPE_P(domain) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Option 'domain' must be an array", "phalcon/validation/validator/inclusionin.zep", 74);
return;
}
ZEPHIR_INIT_VAR(strict);
ZVAL_BOOL(strict, 0);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "strict", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_1, this_ptr, "hasoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (zephir_is_true(_1)) {
ZEPHIR_INIT_VAR(_2$$6);
ZVAL_STRING(_2$$6, "strict", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&strict, this_ptr, "getoption", NULL, 0, _2$$6);
zephir_check_temp_parameter(_2$$6);
zephir_check_call_status();
if (Z_TYPE_P(strict) == IS_ARRAY) {
zephir_array_fetch(&_3$$7, strict, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/inclusionin.zep", 82 TSRMLS_CC);
ZEPHIR_CPY_WRT(strict, _3$$7);
}
if (Z_TYPE_P(strict) != IS_BOOL) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Option 'strict' must be a boolean", "phalcon/validation/validator/inclusionin.zep", 86);
return;
}
}
ZEPHIR_CALL_FUNCTION(&_4, "in_array", NULL, 376, value, domain, strict);
zephir_check_call_status();
if (!(zephir_is_true(_4))) {
ZEPHIR_INIT_VAR(_5$$9);
ZVAL_STRING(_5$$9, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _5$$9);
zephir_check_temp_parameter(_5$$9);
zephir_check_call_status();
if (Z_TYPE_P(label) == IS_ARRAY) {
zephir_array_fetch(&_6$$10, label, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/inclusionin.zep", 97 TSRMLS_CC);
ZEPHIR_CPY_WRT(label, _6$$10);
}
if (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_5$$9);
ZVAL_STRING(_5$$9, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _5$$9);
zephir_check_temp_parameter(_5$$9);
zephir_check_call_status();
if (Z_TYPE_P(message) == IS_ARRAY) {
zephir_array_fetch(&_7$$12, message, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/inclusionin.zep", 105 TSRMLS_CC);
ZEPHIR_CPY_WRT(message, _7$$12);
}
ZEPHIR_INIT_VAR(replacePairs);
zephir_create_array(replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_5$$9);
zephir_fast_join_str(_5$$9, SL(", "), domain TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":domain"), &_5$$9, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_VAR(_8$$13);
ZVAL_STRING(_8$$13, "InclusionIn", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _8$$13);
zephir_check_temp_parameter(_8$$13);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_5$$9);
ZVAL_STRING(_5$$9, "code", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&code, this_ptr, "getoption", NULL, 0, _5$$9);
zephir_check_temp_parameter(_5$$9);
zephir_check_call_status();
if (Z_TYPE_P(code) == IS_ARRAY) {
zephir_array_fetch(&_9$$14, code, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/inclusionin.zep", 114 TSRMLS_CC);
ZEPHIR_CPY_WRT(code, _9$$14);
}
ZEPHIR_INIT_NVAR(_5$$9);
object_init_ex(_5$$9, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_10$$9, "strtr", NULL, 26, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_11$$9);
ZVAL_STRING(_11$$9, "InclusionIn", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _5$$9, "__construct", NULL, 462, _10$$9, field, _11$$9, code);
zephir_check_temp_parameter(_11$$9);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _5$$9);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Shows a backtrace item
*/
PHP_METHOD(Phalcon_Debug, showTraceItem) {
zend_bool _40$$24;
HashTable *_18$$14;
HashPosition _17$$14;
zval *_1, *_26$$16 = NULL;
zephir_fcall_cache_entry *_21 = NULL, *_47 = NULL;
zval *trace = NULL;
zval *n_param = NULL, *trace_param = NULL, *className = NULL, *prepareInternalClass = NULL, *preparedFunctionName = NULL, *html = NULL, *classReflection = NULL, *prepareUriClass = NULL, *functionName = NULL, *functionReflection = NULL, *traceArgs = NULL, *arguments = NULL, *argument = NULL, *filez = NULL, *line = NULL, *showFiles = NULL, *lines = NULL, *numberLines = NULL, *showFileFragment = NULL, *beforeLine = NULL, *afterLine = NULL, *lastLine = NULL, *linePosition = NULL, *currentLine = NULL, *classNameWithLink = NULL, *functionNameWithLink = NULL, _0, *_16, *_2$$3, *_3$$3, _4$$3, *_11$$3, *_12$$3, _5$$4, _6$$4, *_7$$5 = NULL, *_8$$6, _9$$6, _10$$6, *_13$$10 = NULL, _14$$11, _15$$11, **_19$$14, *_23$$14, *_24$$14, *_20$$15 = NULL, *_22$$15 = NULL, *_25$$16, *_27$$16, _28$$18, _29$$18, *_30$$18, _31$$23, *_32$$23, *_33$$26 = NULL, *_34$$26 = NULL, *_35$$26 = NULL, _36$$26 = zval_used_for_init, *_37$$27 = NULL, _38$$27 = zval_used_for_init, _39$$27 = zval_used_for_init, *_41$$29 = NULL, _42$$29 = zval_used_for_init, _43$$29 = zval_used_for_init, _44$$29 = zval_used_for_init, _45$$29 = zval_used_for_init, *_46$$29 = NULL;
int n, ZEPHIR_LAST_CALL_STATUS, firstLine = 0, i = 0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &n_param, &trace_param);
n = zephir_get_intval(n_param);
trace = trace_param;
ZEPHIR_SINIT_VAR(_0);
ZVAL_LONG(&_0, n);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SVS(_1, "<tr><td align=\"right\" valign=\"top\" class=\"error-number\">#", &_0, "</td><td>");
ZEPHIR_CPY_WRT(html, _1);
ZEPHIR_OBS_VAR(className);
if (zephir_array_isset_string_fetch(&className, trace, SS("class"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(_2$$3);
ZEPHIR_INIT_VAR(_3$$3);
ZEPHIR_SINIT_VAR(_4$$3);
ZVAL_STRING(&_4$$3, "/^Phalcon/", 0);
zephir_preg_match(_3$$3, &_4$$3, className, _2$$3, 0, 0 , 0 TSRMLS_CC);
if (zephir_is_true(_3$$3)) {
ZEPHIR_SINIT_VAR(_5$$4);
ZVAL_STRING(&_5$$4, "\\", 0);
ZEPHIR_SINIT_VAR(_6$$4);
ZVAL_STRING(&_6$$4, "/", 0);
ZEPHIR_INIT_VAR(prepareUriClass);
zephir_fast_str_replace(&prepareUriClass, &_5$$4, &_6$$4, className TSRMLS_CC);
ZEPHIR_INIT_VAR(classNameWithLink);
ZEPHIR_CONCAT_SVSVS(classNameWithLink, "<a target=\"_new\" href=\"//api.phalconphp.com/class/", prepareUriClass, ".html\">", className, "</a>");
} else {
ZEPHIR_INIT_VAR(classReflection);
object_init_ex(classReflection, zephir_get_internal_ce(SS("reflectionclass") TSRMLS_CC));
ZEPHIR_CALL_METHOD(NULL, classReflection, "__construct", NULL, 91, className);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_7$$5, classReflection, "isinternal", NULL, 163);
zephir_check_call_status();
if (zephir_is_true(_7$$5)) {
ZEPHIR_INIT_VAR(_8$$6);
zephir_fast_strtolower(_8$$6, className);
ZEPHIR_SINIT_VAR(_9$$6);
ZVAL_STRING(&_9$$6, "_", 0);
ZEPHIR_SINIT_VAR(_10$$6);
ZVAL_STRING(&_10$$6, "-", 0);
ZEPHIR_INIT_VAR(prepareInternalClass);
zephir_fast_str_replace(&prepareInternalClass, &_9$$6, &_10$$6, _8$$6 TSRMLS_CC);
ZEPHIR_INIT_NVAR(classNameWithLink);
ZEPHIR_CONCAT_SVSVS(classNameWithLink, "<a target=\"_new\" href=\"http://php.net/manual/en/class.", prepareInternalClass, ".php\">", className, "</a>");
} else {
ZEPHIR_CPY_WRT(classNameWithLink, className);
}
}
ZEPHIR_INIT_VAR(_11$$3);
ZEPHIR_CONCAT_SVS(_11$$3, "<span class=\"error-class\">", classNameWithLink, "</span>");
zephir_concat_self(&html, _11$$3 TSRMLS_CC);
zephir_array_fetch_string(&_12$$3, trace, SL("type"), PH_NOISY | PH_READONLY, "phalcon/debug.zep", 386 TSRMLS_CC);
zephir_concat_self(&html, _12$$3 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(functionName);
zephir_array_fetch_string(&functionName, trace, SL("function"), PH_NOISY, "phalcon/debug.zep", 392 TSRMLS_CC);
if (zephir_array_isset_string(trace, SS("class"))) {
ZEPHIR_CPY_WRT(functionNameWithLink, functionName);
} else {
if ((zephir_function_exists(functionName TSRMLS_CC) == SUCCESS)) {
ZEPHIR_INIT_VAR(functionReflection);
object_init_ex(functionReflection, zephir_get_internal_ce(SS("reflectionfunction") TSRMLS_CC));
ZEPHIR_CALL_METHOD(NULL, functionReflection, "__construct", NULL, 82, functionName);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_13$$10, functionReflection, "isinternal", NULL, 164);
zephir_check_call_status();
if (zephir_is_true(_13$$10)) {
ZEPHIR_SINIT_VAR(_14$$11);
ZVAL_STRING(&_14$$11, "_", 0);
ZEPHIR_SINIT_VAR(_15$$11);
ZVAL_STRING(&_15$$11, "-", 0);
ZEPHIR_INIT_VAR(preparedFunctionName);
zephir_fast_str_replace(&preparedFunctionName, &_14$$11, &_15$$11, functionName TSRMLS_CC);
ZEPHIR_INIT_NVAR(functionNameWithLink);
ZEPHIR_CONCAT_SVSVS(functionNameWithLink, "<a target=\"_new\" href=\"http://php.net/manual/en/function.", preparedFunctionName, ".php\">", functionName, "</a>");
} else {
ZEPHIR_CPY_WRT(functionNameWithLink, functionName);
}
} else {
ZEPHIR_CPY_WRT(functionNameWithLink, functionName);
}
}
ZEPHIR_INIT_VAR(_16);
ZEPHIR_CONCAT_SVS(_16, "<span class=\"error-function\">", functionNameWithLink, "</span>");
zephir_concat_self(&html, _16 TSRMLS_CC);
ZEPHIR_OBS_VAR(traceArgs);
if (zephir_array_isset_string_fetch(&traceArgs, trace, SS("args"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(arguments);
array_init(arguments);
zephir_is_iterable(traceArgs, &_18$$14, &_17$$14, 0, 0, "phalcon/debug.zep", 441);
for (
; zend_hash_get_current_data_ex(_18$$14, (void**) &_19$$14, &_17$$14) == SUCCESS
; zend_hash_move_forward_ex(_18$$14, &_17$$14)
) {
ZEPHIR_GET_HVALUE(argument, _19$$14);
ZEPHIR_CALL_METHOD(&_20$$15, this_ptr, "_getvardump", &_21, 0, argument);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_22$$15);
ZEPHIR_CONCAT_SVS(_22$$15, "<span class=\"error-parameter\">", _20$$15, "</span>");
zephir_array_append(&arguments, _22$$15, PH_SEPARATE, "phalcon/debug.zep", 435);
}
ZEPHIR_INIT_VAR(_23$$14);
zephir_fast_join_str(_23$$14, SL(", "), arguments TSRMLS_CC);
ZEPHIR_INIT_VAR(_24$$14);
ZEPHIR_CONCAT_SVS(_24$$14, "(", _23$$14, ")");
zephir_concat_self(&html, _24$$14 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(filez);
if (zephir_array_isset_string_fetch(&filez, trace, SS("file"), 0 TSRMLS_CC)) {
ZEPHIR_OBS_VAR(_25$$16);
zephir_array_fetch_string(&_25$$16, trace, SL("line"), PH_NOISY, "phalcon/debug.zep", 449 TSRMLS_CC);
zephir_get_strval(_26$$16, _25$$16);
ZEPHIR_CPY_WRT(line, _26$$16);
ZEPHIR_INIT_VAR(_27$$16);
ZEPHIR_CONCAT_SVSVS(_27$$16, "<br/><div class=\"error-file\">", filez, " (", line, ")</div>");
zephir_concat_self(&html, _27$$16 TSRMLS_CC);
ZEPHIR_OBS_VAR(showFiles);
zephir_read_property_this(&showFiles, this_ptr, SL("_showFiles"), PH_NOISY_CC);
if (zephir_is_true(showFiles)) {
ZEPHIR_CALL_FUNCTION(&lines, "file", NULL, 165, filez);
zephir_check_call_status();
ZEPHIR_INIT_VAR(numberLines);
ZVAL_LONG(numberLines, zephir_fast_count_int(lines TSRMLS_CC));
ZEPHIR_OBS_VAR(showFileFragment);
zephir_read_property_this(&showFileFragment, this_ptr, SL("_showFileFragment"), PH_NOISY_CC);
if (zephir_is_true(showFileFragment)) {
ZEPHIR_INIT_VAR(beforeLine);
ZVAL_LONG(beforeLine, (zephir_get_numberval(line) - 7));
if (ZEPHIR_LT_LONG(beforeLine, 1)) {
firstLine = 1;
} else {
firstLine = zephir_get_numberval(beforeLine);
}
ZEPHIR_INIT_VAR(afterLine);
ZVAL_LONG(afterLine, (zephir_get_numberval(line) + 5));
if (ZEPHIR_GT(afterLine, numberLines)) {
ZEPHIR_CPY_WRT(lastLine, numberLines);
} else {
ZEPHIR_CPY_WRT(lastLine, afterLine);
}
ZEPHIR_SINIT_VAR(_28$$18);
ZVAL_LONG(&_28$$18, firstLine);
ZEPHIR_SINIT_VAR(_29$$18);
ZVAL_LONG(&_29$$18, firstLine);
ZEPHIR_INIT_VAR(_30$$18);
ZEPHIR_CONCAT_SVSVSVS(_30$$18, "<pre class=\"prettyprint highlight:", &_28$$18, ":", line, " linenums:", &_29$$18, "\">");
zephir_concat_self(&html, _30$$18 TSRMLS_CC);
} else {
firstLine = 1;
ZEPHIR_CPY_WRT(lastLine, numberLines);
ZEPHIR_SINIT_VAR(_31$$23);
ZVAL_LONG(&_31$$23, firstLine);
ZEPHIR_INIT_VAR(_32$$23);
ZEPHIR_CONCAT_SVSVS(_32$$23, "<pre class=\"prettyprint highlight:", &_31$$23, ":", line, " linenums error-scroll\">");
zephir_concat_self(&html, _32$$23 TSRMLS_CC);
}
i = firstLine;
while (1) {
if (!(ZEPHIR_GE_LONG(lastLine, i))) {
break;
}
ZEPHIR_INIT_NVAR(linePosition);
ZVAL_LONG(linePosition, (i - 1));
ZEPHIR_OBS_NVAR(currentLine);
zephir_array_fetch(¤tLine, lines, linePosition, PH_NOISY, "phalcon/debug.zep", 522 TSRMLS_CC);
if (zephir_is_true(showFileFragment)) {
if (i == firstLine) {
ZEPHIR_INIT_NVAR(_33$$26);
ZEPHIR_INIT_NVAR(_34$$26);
ZEPHIR_INIT_NVAR(_35$$26);
zephir_fast_trim(_35$$26, currentLine, NULL , ZEPHIR_TRIM_RIGHT TSRMLS_CC);
ZEPHIR_SINIT_NVAR(_36$$26);
ZVAL_STRING(&_36$$26, "#\\*\\/#", 0);
zephir_preg_match(_34$$26, &_36$$26, _35$$26, _33$$26, 0, 0 , 0 TSRMLS_CC);
if (zephir_is_true(_34$$26)) {
ZEPHIR_INIT_NVAR(_37$$27);
ZEPHIR_SINIT_NVAR(_38$$27);
ZVAL_STRING(&_38$$27, "* /", 0);
ZEPHIR_SINIT_NVAR(_39$$27);
ZVAL_STRING(&_39$$27, " ", 0);
zephir_fast_str_replace(&_37$$27, &_38$$27, &_39$$27, currentLine TSRMLS_CC);
ZEPHIR_CPY_WRT(currentLine, _37$$27);
}
}
}
_40$$24 = ZEPHIR_IS_STRING(currentLine, "\n");
if (!(_40$$24)) {
_40$$24 = ZEPHIR_IS_STRING(currentLine, "\r\n");
}
if (_40$$24) {
zephir_concat_self_str(&html, SL(" \n") TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(_41$$29);
ZEPHIR_SINIT_NVAR(_42$$29);
ZVAL_STRING(&_42$$29, "\t", 0);
ZEPHIR_SINIT_NVAR(_43$$29);
ZVAL_STRING(&_43$$29, " ", 0);
zephir_fast_str_replace(&_41$$29, &_42$$29, &_43$$29, currentLine TSRMLS_CC);
ZEPHIR_SINIT_NVAR(_44$$29);
ZVAL_LONG(&_44$$29, 2);
ZEPHIR_SINIT_NVAR(_45$$29);
ZVAL_STRING(&_45$$29, "UTF-8", 0);
ZEPHIR_CALL_FUNCTION(&_46$$29, "htmlentities", &_47, 158, _41$$29, &_44$$29, &_45$$29);
zephir_check_call_status();
zephir_concat_self(&html, _46$$29 TSRMLS_CC);
}
i++;
}
zephir_concat_self_str(&html, SL("</pre>") TSRMLS_CC);
}
}
zephir_concat_self_str(&html, SL("</td></tr>") TSRMLS_CC);
RETURN_CCTOR(html);
}
