mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-09-13 14:58:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

vim-patch:8.2.0069: ETYPE_ is used for two different enums

Browse Source 
Problem:    ETYPE_ is used for two different enums.
Solution:   Rename one to use EXPR_.
87396072c5
This commit is contained in:
Jan Edmund Lazo
2021-04-07 21:57:40 -04:00
parent de16fbcc57
commit ca214311d2
3 changed files with 71 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

118
src/nvim/eval.c
View File

@@ -3417,7 +3417,7 @@ static int eval4(char_u **arg, typval_T *rettv, int evaluate)
{ {
typval_T var2; typval_T var2;
char_u *p; char_u *p;
exptype_T type = ETYPE_UNKNOWN; exptype_T type = EXPR_UNKNOWN;
int len = 2; int len = 2;
bool ic; bool ic;
@@ -3431,32 +3431,32 @@ static int eval4(char_u **arg, typval_T *rettv, int evaluate)
switch (p[0]) { switch (p[0]) {
case '=': case '=':
if (p[1] == '=') { if (p[1] == '=') {
type = ETYPE_EQUAL; type = EXPR_EQUAL;
} else if (p[1] == '~') { } else if (p[1] == '~') {
type = ETYPE_MATCH; type = EXPR_MATCH;
} }
break; break;
case '!': case '!':
if (p[1] == '=') { if (p[1] == '=') {
type = ETYPE_NEQUAL; type = EXPR_NEQUAL;
} else if (p[1] == '~') { } else if (p[1] == '~') {
type = ETYPE_NOMATCH; type = EXPR_NOMATCH;
} }
break; break;
case '>': case '>':
if (p[1] != '=') { if (p[1] != '=') {
type = ETYPE_GREATER; type = EXPR_GREATER;
len = 1; len = 1;
} else { } else {
type = ETYPE_GEQUAL; type = EXPR_GEQUAL;
} }
break; break;
case '<': case '<':
if (p[1] != '=') { if (p[1] != '=') {
type = ETYPE_SMALLER; type = EXPR_SMALLER;
len = 1; len = 1;
} else { } else {
type = ETYPE_SEQUAL; type = EXPR_SEQUAL;
} }
break; break;
case 'i': if (p[1] == 's') { case 'i': if (p[1] == 's') {
@@ -3464,7 +3464,7 @@ static int eval4(char_u **arg, typval_T *rettv, int evaluate)
len = 5; len = 5;
} }
if (!isalnum(p[len]) && p[len] != '_') { if (!isalnum(p[len]) && p[len] != '_') {
type = len == 2 ? ETYPE_IS : ETYPE_ISNOT; type = len == 2 ? EXPR_IS : EXPR_ISNOT;
} }
} }
break; break;
@@ -3473,7 +3473,7 @@ static int eval4(char_u **arg, typval_T *rettv, int evaluate)
/* /*
* If there is a comparative operator, use it. * If there is a comparative operator, use it.
*/ */
if (type != ETYPE_UNKNOWN) { if (type != EXPR_UNKNOWN) {
// extra question mark appended: ignore case // extra question mark appended: ignore case
if (p[len] == '?') { if (p[len] == '?') {
ic = true; ic = true;
@@ -10594,21 +10594,21 @@ int typval_compare(
FUNC_ATTR_NONNULL_ALL FUNC_ATTR_NONNULL_ALL
{ {
varnumber_T n1, n2; varnumber_T n1, n2;
const bool type_is = type == ETYPE_IS || type == ETYPE_ISNOT; const bool type_is = type == EXPR_IS || type == EXPR_ISNOT;
if (type_is && typ1->v_type != typ2->v_type) { if (type_is && typ1->v_type != typ2->v_type) {
// For "is" a different type always means false, for "notis" // For "is" a different type always means false, for "notis"
// it means true. // it means true.
n1 = type == ETYPE_ISNOT; n1 = type == EXPR_ISNOT;
} else if (typ1->v_type == VAR_LIST || typ2->v_type == VAR_LIST) { } else if (typ1->v_type == VAR_LIST || typ2->v_type == VAR_LIST) {
if (type_is) { if (type_is) {
n1 = typ1->v_type == typ2->v_type n1 = typ1->v_type == typ2->v_type
&& typ1->vval.v_list == typ2->vval.v_list; && typ1->vval.v_list == typ2->vval.v_list;
if (type == ETYPE_ISNOT) { if (type == EXPR_ISNOT) {
n1 = !n1; n1 = !n1;
} }
} else if (typ1->v_type != typ2->v_type } else if (typ1->v_type != typ2->v_type
|| (type != ETYPE_EQUAL && type != ETYPE_NEQUAL)) { || (type != EXPR_EQUAL && type != EXPR_NEQUAL)) {
if (typ1->v_type != typ2->v_type) { if (typ1->v_type != typ2->v_type) {
EMSG(_("E691: Can only compare List with List")); EMSG(_("E691: Can only compare List with List"));
} else { } else {
@@ -10619,7 +10619,7 @@ int typval_compare(
} else { } else {
// Compare two Lists for being equal or unequal. // Compare two Lists for being equal or unequal.
n1 = tv_list_equal(typ1->vval.v_list, typ2->vval.v_list, ic, false); n1 = tv_list_equal(typ1->vval.v_list, typ2->vval.v_list, ic, false);
if (type == ETYPE_NEQUAL) { if (type == EXPR_NEQUAL) {
n1 = !n1; n1 = !n1;
} }
} }
@@ -10627,11 +10627,11 @@ int typval_compare(
if (type_is) { if (type_is) {
n1 = typ1->v_type == typ2->v_type n1 = typ1->v_type == typ2->v_type
&& typ1->vval.v_dict == typ2->vval.v_dict; && typ1->vval.v_dict == typ2->vval.v_dict;
if (type == ETYPE_ISNOT) { if (type == EXPR_ISNOT) {
n1 = !n1; n1 = !n1;
} }
} else if (typ1->v_type != typ2->v_type } else if (typ1->v_type != typ2->v_type
|| (type != ETYPE_EQUAL && type != ETYPE_NEQUAL)) { || (type != EXPR_EQUAL && type != EXPR_NEQUAL)) {
if (typ1->v_type != typ2->v_type) { if (typ1->v_type != typ2->v_type) {
EMSG(_("E735: Can only compare Dictionary with Dictionary")); EMSG(_("E735: Can only compare Dictionary with Dictionary"));
} else { } else {
@@ -10642,13 +10642,13 @@ int typval_compare(
} else { } else {
// Compare two Dictionaries for being equal or unequal. // Compare two Dictionaries for being equal or unequal.
n1 = tv_dict_equal(typ1->vval.v_dict, typ2->vval.v_dict, ic, false); n1 = tv_dict_equal(typ1->vval.v_dict, typ2->vval.v_dict, ic, false);
if (type == ETYPE_NEQUAL) { if (type == EXPR_NEQUAL) {
n1 = !n1; n1 = !n1;
} }
} }
} else if (tv_is_func(*typ1) || tv_is_func(*typ2)) { } else if (tv_is_func(*typ1) || tv_is_func(*typ2)) {
if (type != ETYPE_EQUAL && type != ETYPE_NEQUAL if (type != EXPR_EQUAL && type != EXPR_NEQUAL
&& type != ETYPE_IS && type != ETYPE_ISNOT) { && type != EXPR_IS && type != EXPR_ISNOT) {
EMSG(_("E694: Invalid operation for Funcrefs")); EMSG(_("E694: Invalid operation for Funcrefs"));
tv_clear(typ1); tv_clear(typ1);
return FAIL; return FAIL;
@@ -10670,47 +10670,47 @@ int typval_compare(
} else { } else {
n1 = tv_equal(typ1, typ2, ic, false); n1 = tv_equal(typ1, typ2, ic, false);
} }
if (type == ETYPE_NEQUAL || type == ETYPE_ISNOT) { if (type == EXPR_NEQUAL || type == EXPR_ISNOT) {
n1 = !n1; n1 = !n1;
} }
} else if ((typ1->v_type == VAR_FLOAT || typ2->v_type == VAR_FLOAT) } else if ((typ1->v_type == VAR_FLOAT || typ2->v_type == VAR_FLOAT)
&& type != ETYPE_MATCH && type != ETYPE_NOMATCH) { && type != EXPR_MATCH && type != EXPR_NOMATCH) {
// If one of the two variables is a float, compare as a float. // If one of the two variables is a float, compare as a float.
// When using "=~" or "!~", always compare as string. // When using "=~" or "!~", always compare as string.
const float_T f1 = tv_get_float(typ1); const float_T f1 = tv_get_float(typ1);
const float_T f2 = tv_get_float(typ2); const float_T f2 = tv_get_float(typ2);
n1 = false; n1 = false;
switch (type) { switch (type) {
case ETYPE_IS: case EXPR_IS:
case ETYPE_EQUAL: n1 = f1 == f2; break; case EXPR_EQUAL: n1 = f1 == f2; break;
case ETYPE_ISNOT: case EXPR_ISNOT:
case ETYPE_NEQUAL: n1 = f1 != f2; break; case EXPR_NEQUAL: n1 = f1 != f2; break;
case ETYPE_GREATER: n1 = f1 > f2; break; case EXPR_GREATER: n1 = f1 > f2; break;
case ETYPE_GEQUAL: n1 = f1 >= f2; break; case EXPR_GEQUAL: n1 = f1 >= f2; break;
case ETYPE_SMALLER: n1 = f1 < f2; break; case EXPR_SMALLER: n1 = f1 < f2; break;
case ETYPE_SEQUAL: n1 = f1 <= f2; break; case EXPR_SEQUAL: n1 = f1 <= f2; break;
case ETYPE_UNKNOWN: case EXPR_UNKNOWN:
case ETYPE_MATCH: case EXPR_MATCH:
case ETYPE_NOMATCH: break; // avoid gcc warning case EXPR_NOMATCH: break; // avoid gcc warning
} }
} else if ((typ1->v_type == VAR_NUMBER || typ2->v_type == VAR_NUMBER) } else if ((typ1->v_type == VAR_NUMBER || typ2->v_type == VAR_NUMBER)
&& type != ETYPE_MATCH && type != ETYPE_NOMATCH) { && type != EXPR_MATCH && type != EXPR_NOMATCH) {
// If one of the two variables is a number, compare as a number. // If one of the two variables is a number, compare as a number.
// When using "=~" or "!~", always compare as string. // When using "=~" or "!~", always compare as string.
n1 = tv_get_number(typ1); n1 = tv_get_number(typ1);
n2 = tv_get_number(typ2); n2 = tv_get_number(typ2);
switch (type) { switch (type) {
case ETYPE_IS: case EXPR_IS:
case ETYPE_EQUAL: n1 = n1 == n2; break; case EXPR_EQUAL: n1 = n1 == n2; break;
case ETYPE_ISNOT: case EXPR_ISNOT:
case ETYPE_NEQUAL: n1 = n1 != n2; break; case EXPR_NEQUAL: n1 = n1 != n2; break;
case ETYPE_GREATER: n1 = n1 > n2; break; case EXPR_GREATER: n1 = n1 > n2; break;
case ETYPE_GEQUAL: n1 = n1 >= n2; break; case EXPR_GEQUAL: n1 = n1 >= n2; break;
case ETYPE_SMALLER: n1 = n1 < n2; break; case EXPR_SMALLER: n1 = n1 < n2; break;
case ETYPE_SEQUAL: n1 = n1 <= n2; break; case EXPR_SEQUAL: n1 = n1 <= n2; break;
case ETYPE_UNKNOWN: case EXPR_UNKNOWN:
case ETYPE_MATCH: case EXPR_MATCH:
case ETYPE_NOMATCH: break; // avoid gcc warning case EXPR_NOMATCH: break; // avoid gcc warning
} }
} else { } else {
char buf1[NUMBUFLEN]; char buf1[NUMBUFLEN];
@@ -10718,30 +10718,30 @@ int typval_compare(
const char *const s1 = tv_get_string_buf(typ1, buf1); const char *const s1 = tv_get_string_buf(typ1, buf1);
const char *const s2 = tv_get_string_buf(typ2, buf2); const char *const s2 = tv_get_string_buf(typ2, buf2);
int i; int i;
if (type != ETYPE_MATCH && type != ETYPE_NOMATCH) { if (type != EXPR_MATCH && type != EXPR_NOMATCH) {
i = mb_strcmp_ic(ic, s1, s2); i = mb_strcmp_ic(ic, s1, s2);
} else { } else {
i = 0; i = 0;
} }
n1 = false; n1 = false;
switch (type) { switch (type) {
case ETYPE_IS: case EXPR_IS:
case ETYPE_EQUAL: n1 = i == 0; break; case EXPR_EQUAL: n1 = i == 0; break;
case ETYPE_ISNOT: case EXPR_ISNOT:
case ETYPE_NEQUAL: n1 = i != 0; break; case EXPR_NEQUAL: n1 = i != 0; break;
case ETYPE_GREATER: n1 = i > 0; break; case EXPR_GREATER: n1 = i > 0; break;
case ETYPE_GEQUAL: n1 = i >= 0; break; case EXPR_GEQUAL: n1 = i >= 0; break;
case ETYPE_SMALLER: n1 = i < 0; break; case EXPR_SMALLER: n1 = i < 0; break;
case ETYPE_SEQUAL: n1 = i <= 0; break; case EXPR_SEQUAL: n1 = i <= 0; break;
case ETYPE_MATCH: case EXPR_MATCH:
case ETYPE_NOMATCH: case EXPR_NOMATCH:
n1 = pattern_match((char_u *)s2, (char_u *)s1, ic); n1 = pattern_match((char_u *)s2, (char_u *)s1, ic);
if (type == ETYPE_NOMATCH) { if (type == EXPR_NOMATCH) {
n1 = !n1; n1 = !n1;
} }
break; break;
case ETYPE_UNKNOWN: break; // avoid gcc warning case EXPR_UNKNOWN: break; // avoid gcc warning
} }
} }
tv_clear(typ1); tv_clear(typ1);

22
src/nvim/eval.h
View File

@@ -230,17 +230,17 @@ typedef enum
/// types for expressions. /// types for expressions.
typedef enum { typedef enum {
ETYPE_UNKNOWN = 0, EXPR_UNKNOWN = 0,
ETYPE_EQUAL, ///< == EXPR_EQUAL, ///< ==
ETYPE_NEQUAL, ///< != EXPR_NEQUAL, ///< !=
ETYPE_GREATER, ///< > EXPR_GREATER, ///< >
ETYPE_GEQUAL, ///< >= EXPR_GEQUAL, ///< >=
ETYPE_SMALLER, ///< < EXPR_SMALLER, ///< <
ETYPE_SEQUAL, ///< <= EXPR_SEQUAL, ///< <=
ETYPE_MATCH, ///< =~ EXPR_MATCH, ///< =~
ETYPE_NOMATCH, ///< !~ EXPR_NOMATCH, ///< !~
ETYPE_IS, ///< is EXPR_IS, ///< is
ETYPE_ISNOT, ///< isnot EXPR_ISNOT, ///< isnot
} exptype_T; } exptype_T;
/// Type for dict_list function /// Type for dict_list function

2
src/nvim/ex_cmds2.c
View File

@@ -876,7 +876,7 @@ debuggy_find(
debug_newval = typval_tostring(bp->dbg_val); debug_newval = typval_tostring(bp->dbg_val);
line = true; line = true;
} else { } else {
if (typval_compare(tv, bp->dbg_val, ETYPE_IS, false) == OK if (typval_compare(tv, bp->dbg_val, EXPR_IS, false) == OK
&& tv->vval.v_number == false) { && tv->vval.v_number == false) {
line = true; line = true;
debug_oldval = typval_tostring(bp->dbg_val); debug_oldval = typval_tostring(bp->dbg_val);