Mercurial > vim
comparison src/eval.c @ 19017:d9ea4f0bfd34 v8.2.0069
patch 8.2.0069: ETYPE_ is used for two different enums
Commit: https://github.com/vim/vim/commit/87396072c5c468f0c129e4ec7cd944ac897b7752
Author: Bram Moolenaar <Bram@vim.org>
Date: Tue Dec 31 22:36:18 2019 +0100
patch 8.2.0069: ETYPE_ is used for two different enums
Problem: ETYPE_ is used for two different enums.
Solution: Rename one to use EXPR_.
author | Bram Moolenaar <Bram@vim.org> |
---|---|
date | Tue, 31 Dec 2019 22:45:03 +0100 |
parents | 1ebfb46710cd |
children | a3fce2763e83 |
comparison
equal
deleted
inserted
replaced
19016:2c87424f5ea1 | 19017:d9ea4f0bfd34 |
---|---|
1995 eval4(char_u **arg, typval_T *rettv, int evaluate) | 1995 eval4(char_u **arg, typval_T *rettv, int evaluate) |
1996 { | 1996 { |
1997 typval_T var2; | 1997 typval_T var2; |
1998 char_u *p; | 1998 char_u *p; |
1999 int i; | 1999 int i; |
2000 exptype_T type = ETYPE_UNKNOWN; | 2000 exptype_T type = EXPR_UNKNOWN; |
2001 int len = 2; | 2001 int len = 2; |
2002 int ic; | 2002 int ic; |
2003 | 2003 |
2004 /* | 2004 /* |
2005 * Get the first variable. | 2005 * Get the first variable. |
2009 | 2009 |
2010 p = *arg; | 2010 p = *arg; |
2011 switch (p[0]) | 2011 switch (p[0]) |
2012 { | 2012 { |
2013 case '=': if (p[1] == '=') | 2013 case '=': if (p[1] == '=') |
2014 type = ETYPE_EQUAL; | 2014 type = EXPR_EQUAL; |
2015 else if (p[1] == '~') | 2015 else if (p[1] == '~') |
2016 type = ETYPE_MATCH; | 2016 type = EXPR_MATCH; |
2017 break; | 2017 break; |
2018 case '!': if (p[1] == '=') | 2018 case '!': if (p[1] == '=') |
2019 type = ETYPE_NEQUAL; | 2019 type = EXPR_NEQUAL; |
2020 else if (p[1] == '~') | 2020 else if (p[1] == '~') |
2021 type = ETYPE_NOMATCH; | 2021 type = EXPR_NOMATCH; |
2022 break; | 2022 break; |
2023 case '>': if (p[1] != '=') | 2023 case '>': if (p[1] != '=') |
2024 { | 2024 { |
2025 type = ETYPE_GREATER; | 2025 type = EXPR_GREATER; |
2026 len = 1; | 2026 len = 1; |
2027 } | 2027 } |
2028 else | 2028 else |
2029 type = ETYPE_GEQUAL; | 2029 type = EXPR_GEQUAL; |
2030 break; | 2030 break; |
2031 case '<': if (p[1] != '=') | 2031 case '<': if (p[1] != '=') |
2032 { | 2032 { |
2033 type = ETYPE_SMALLER; | 2033 type = EXPR_SMALLER; |
2034 len = 1; | 2034 len = 1; |
2035 } | 2035 } |
2036 else | 2036 else |
2037 type = ETYPE_SEQUAL; | 2037 type = EXPR_SEQUAL; |
2038 break; | 2038 break; |
2039 case 'i': if (p[1] == 's') | 2039 case 'i': if (p[1] == 's') |
2040 { | 2040 { |
2041 if (p[2] == 'n' && p[3] == 'o' && p[4] == 't') | 2041 if (p[2] == 'n' && p[3] == 'o' && p[4] == 't') |
2042 len = 5; | 2042 len = 5; |
2043 i = p[len]; | 2043 i = p[len]; |
2044 if (!isalnum(i) && i != '_') | 2044 if (!isalnum(i) && i != '_') |
2045 type = len == 2 ? ETYPE_IS : ETYPE_ISNOT; | 2045 type = len == 2 ? EXPR_IS : EXPR_ISNOT; |
2046 } | 2046 } |
2047 break; | 2047 break; |
2048 } | 2048 } |
2049 | 2049 |
2050 /* | 2050 /* |
2051 * If there is a comparative operator, use it. | 2051 * If there is a comparative operator, use it. |
2052 */ | 2052 */ |
2053 if (type != ETYPE_UNKNOWN) | 2053 if (type != EXPR_UNKNOWN) |
2054 { | 2054 { |
2055 // extra question mark appended: ignore case | 2055 // extra question mark appended: ignore case |
2056 if (p[len] == '?') | 2056 if (p[len] == '?') |
2057 { | 2057 { |
2058 ic = TRUE; | 2058 ic = TRUE; |
6187 { | 6187 { |
6188 int i; | 6188 int i; |
6189 varnumber_T n1, n2; | 6189 varnumber_T n1, n2; |
6190 char_u *s1, *s2; | 6190 char_u *s1, *s2; |
6191 char_u buf1[NUMBUFLEN], buf2[NUMBUFLEN]; | 6191 char_u buf1[NUMBUFLEN], buf2[NUMBUFLEN]; |
6192 int type_is = type == ETYPE_IS || type == ETYPE_ISNOT; | 6192 int type_is = type == EXPR_IS || type == EXPR_ISNOT; |
6193 | 6193 |
6194 if (type_is && typ1->v_type != typ2->v_type) | 6194 if (type_is && typ1->v_type != typ2->v_type) |
6195 { | 6195 { |
6196 // For "is" a different type always means FALSE, for "notis" | 6196 // For "is" a different type always means FALSE, for "notis" |
6197 // it means TRUE. | 6197 // it means TRUE. |
6198 n1 = (type == ETYPE_ISNOT); | 6198 n1 = (type == EXPR_ISNOT); |
6199 } | 6199 } |
6200 else if (typ1->v_type == VAR_BLOB || typ2->v_type == VAR_BLOB) | 6200 else if (typ1->v_type == VAR_BLOB || typ2->v_type == VAR_BLOB) |
6201 { | 6201 { |
6202 if (type_is) | 6202 if (type_is) |
6203 { | 6203 { |
6204 n1 = (typ1->v_type == typ2->v_type | 6204 n1 = (typ1->v_type == typ2->v_type |
6205 && typ1->vval.v_blob == typ2->vval.v_blob); | 6205 && typ1->vval.v_blob == typ2->vval.v_blob); |
6206 if (type == ETYPE_ISNOT) | 6206 if (type == EXPR_ISNOT) |
6207 n1 = !n1; | 6207 n1 = !n1; |
6208 } | 6208 } |
6209 else if (typ1->v_type != typ2->v_type | 6209 else if (typ1->v_type != typ2->v_type |
6210 || (type != ETYPE_EQUAL && type != ETYPE_NEQUAL)) | 6210 || (type != EXPR_EQUAL && type != EXPR_NEQUAL)) |
6211 { | 6211 { |
6212 if (typ1->v_type != typ2->v_type) | 6212 if (typ1->v_type != typ2->v_type) |
6213 emsg(_("E977: Can only compare Blob with Blob")); | 6213 emsg(_("E977: Can only compare Blob with Blob")); |
6214 else | 6214 else |
6215 emsg(_(e_invalblob)); | 6215 emsg(_(e_invalblob)); |
6218 } | 6218 } |
6219 else | 6219 else |
6220 { | 6220 { |
6221 // Compare two Blobs for being equal or unequal. | 6221 // Compare two Blobs for being equal or unequal. |
6222 n1 = blob_equal(typ1->vval.v_blob, typ2->vval.v_blob); | 6222 n1 = blob_equal(typ1->vval.v_blob, typ2->vval.v_blob); |
6223 if (type == ETYPE_NEQUAL) | 6223 if (type == EXPR_NEQUAL) |
6224 n1 = !n1; | 6224 n1 = !n1; |
6225 } | 6225 } |
6226 } | 6226 } |
6227 else if (typ1->v_type == VAR_LIST || typ2->v_type == VAR_LIST) | 6227 else if (typ1->v_type == VAR_LIST || typ2->v_type == VAR_LIST) |
6228 { | 6228 { |
6229 if (type_is) | 6229 if (type_is) |
6230 { | 6230 { |
6231 n1 = (typ1->v_type == typ2->v_type | 6231 n1 = (typ1->v_type == typ2->v_type |
6232 && typ1->vval.v_list == typ2->vval.v_list); | 6232 && typ1->vval.v_list == typ2->vval.v_list); |
6233 if (type == ETYPE_ISNOT) | 6233 if (type == EXPR_ISNOT) |
6234 n1 = !n1; | 6234 n1 = !n1; |
6235 } | 6235 } |
6236 else if (typ1->v_type != typ2->v_type | 6236 else if (typ1->v_type != typ2->v_type |
6237 || (type != ETYPE_EQUAL && type != ETYPE_NEQUAL)) | 6237 || (type != EXPR_EQUAL && type != EXPR_NEQUAL)) |
6238 { | 6238 { |
6239 if (typ1->v_type != typ2->v_type) | 6239 if (typ1->v_type != typ2->v_type) |
6240 emsg(_("E691: Can only compare List with List")); | 6240 emsg(_("E691: Can only compare List with List")); |
6241 else | 6241 else |
6242 emsg(_("E692: Invalid operation for List")); | 6242 emsg(_("E692: Invalid operation for List")); |
6246 else | 6246 else |
6247 { | 6247 { |
6248 // Compare two Lists for being equal or unequal. | 6248 // Compare two Lists for being equal or unequal. |
6249 n1 = list_equal(typ1->vval.v_list, typ2->vval.v_list, | 6249 n1 = list_equal(typ1->vval.v_list, typ2->vval.v_list, |
6250 ic, FALSE); | 6250 ic, FALSE); |
6251 if (type == ETYPE_NEQUAL) | 6251 if (type == EXPR_NEQUAL) |
6252 n1 = !n1; | 6252 n1 = !n1; |
6253 } | 6253 } |
6254 } | 6254 } |
6255 | 6255 |
6256 else if (typ1->v_type == VAR_DICT || typ2->v_type == VAR_DICT) | 6256 else if (typ1->v_type == VAR_DICT || typ2->v_type == VAR_DICT) |
6257 { | 6257 { |
6258 if (type_is) | 6258 if (type_is) |
6259 { | 6259 { |
6260 n1 = (typ1->v_type == typ2->v_type | 6260 n1 = (typ1->v_type == typ2->v_type |
6261 && typ1->vval.v_dict == typ2->vval.v_dict); | 6261 && typ1->vval.v_dict == typ2->vval.v_dict); |
6262 if (type == ETYPE_ISNOT) | 6262 if (type == EXPR_ISNOT) |
6263 n1 = !n1; | 6263 n1 = !n1; |
6264 } | 6264 } |
6265 else if (typ1->v_type != typ2->v_type | 6265 else if (typ1->v_type != typ2->v_type |
6266 || (type != ETYPE_EQUAL && type != ETYPE_NEQUAL)) | 6266 || (type != EXPR_EQUAL && type != EXPR_NEQUAL)) |
6267 { | 6267 { |
6268 if (typ1->v_type != typ2->v_type) | 6268 if (typ1->v_type != typ2->v_type) |
6269 emsg(_("E735: Can only compare Dictionary with Dictionary")); | 6269 emsg(_("E735: Can only compare Dictionary with Dictionary")); |
6270 else | 6270 else |
6271 emsg(_("E736: Invalid operation for Dictionary")); | 6271 emsg(_("E736: Invalid operation for Dictionary")); |
6275 else | 6275 else |
6276 { | 6276 { |
6277 // Compare two Dictionaries for being equal or unequal. | 6277 // Compare two Dictionaries for being equal or unequal. |
6278 n1 = dict_equal(typ1->vval.v_dict, typ2->vval.v_dict, | 6278 n1 = dict_equal(typ1->vval.v_dict, typ2->vval.v_dict, |
6279 ic, FALSE); | 6279 ic, FALSE); |
6280 if (type == ETYPE_NEQUAL) | 6280 if (type == EXPR_NEQUAL) |
6281 n1 = !n1; | 6281 n1 = !n1; |
6282 } | 6282 } |
6283 } | 6283 } |
6284 | 6284 |
6285 else if (typ1->v_type == VAR_FUNC || typ2->v_type == VAR_FUNC | 6285 else if (typ1->v_type == VAR_FUNC || typ2->v_type == VAR_FUNC |
6286 || typ1->v_type == VAR_PARTIAL || typ2->v_type == VAR_PARTIAL) | 6286 || typ1->v_type == VAR_PARTIAL || typ2->v_type == VAR_PARTIAL) |
6287 { | 6287 { |
6288 if (type != ETYPE_EQUAL && type != ETYPE_NEQUAL | 6288 if (type != EXPR_EQUAL && type != EXPR_NEQUAL |
6289 && type != ETYPE_IS && type != ETYPE_ISNOT) | 6289 && type != EXPR_IS && type != EXPR_ISNOT) |
6290 { | 6290 { |
6291 emsg(_("E694: Invalid operation for Funcrefs")); | 6291 emsg(_("E694: Invalid operation for Funcrefs")); |
6292 clear_tv(typ1); | 6292 clear_tv(typ1); |
6293 return FAIL; | 6293 return FAIL; |
6294 } | 6294 } |
6310 else | 6310 else |
6311 n1 = FALSE; | 6311 n1 = FALSE; |
6312 } | 6312 } |
6313 else | 6313 else |
6314 n1 = tv_equal(typ1, typ2, ic, FALSE); | 6314 n1 = tv_equal(typ1, typ2, ic, FALSE); |
6315 if (type == ETYPE_NEQUAL || type == ETYPE_ISNOT) | 6315 if (type == EXPR_NEQUAL || type == EXPR_ISNOT) |
6316 n1 = !n1; | 6316 n1 = !n1; |
6317 } | 6317 } |
6318 | 6318 |
6319 #ifdef FEAT_FLOAT | 6319 #ifdef FEAT_FLOAT |
6320 /* | 6320 /* |
6321 * If one of the two variables is a float, compare as a float. | 6321 * If one of the two variables is a float, compare as a float. |
6322 * When using "=~" or "!~", always compare as string. | 6322 * When using "=~" or "!~", always compare as string. |
6323 */ | 6323 */ |
6324 else if ((typ1->v_type == VAR_FLOAT || typ2->v_type == VAR_FLOAT) | 6324 else if ((typ1->v_type == VAR_FLOAT || typ2->v_type == VAR_FLOAT) |
6325 && type != ETYPE_MATCH && type != ETYPE_NOMATCH) | 6325 && type != EXPR_MATCH && type != EXPR_NOMATCH) |
6326 { | 6326 { |
6327 float_T f1, f2; | 6327 float_T f1, f2; |
6328 | 6328 |
6329 f1 = tv_get_float(typ1); | 6329 f1 = tv_get_float(typ1); |
6330 f2 = tv_get_float(typ2); | 6330 f2 = tv_get_float(typ2); |
6331 n1 = FALSE; | 6331 n1 = FALSE; |
6332 switch (type) | 6332 switch (type) |
6333 { | 6333 { |
6334 case ETYPE_IS: | 6334 case EXPR_IS: |
6335 case ETYPE_EQUAL: n1 = (f1 == f2); break; | 6335 case EXPR_EQUAL: n1 = (f1 == f2); break; |
6336 case ETYPE_ISNOT: | 6336 case EXPR_ISNOT: |
6337 case ETYPE_NEQUAL: n1 = (f1 != f2); break; | 6337 case EXPR_NEQUAL: n1 = (f1 != f2); break; |
6338 case ETYPE_GREATER: n1 = (f1 > f2); break; | 6338 case EXPR_GREATER: n1 = (f1 > f2); break; |
6339 case ETYPE_GEQUAL: n1 = (f1 >= f2); break; | 6339 case EXPR_GEQUAL: n1 = (f1 >= f2); break; |
6340 case ETYPE_SMALLER: n1 = (f1 < f2); break; | 6340 case EXPR_SMALLER: n1 = (f1 < f2); break; |
6341 case ETYPE_SEQUAL: n1 = (f1 <= f2); break; | 6341 case EXPR_SEQUAL: n1 = (f1 <= f2); break; |
6342 case ETYPE_UNKNOWN: | 6342 case EXPR_UNKNOWN: |
6343 case ETYPE_MATCH: | 6343 case EXPR_MATCH: |
6344 case ETYPE_NOMATCH: break; // avoid gcc warning | 6344 case EXPR_NOMATCH: break; // avoid gcc warning |
6345 } | 6345 } |
6346 } | 6346 } |
6347 #endif | 6347 #endif |
6348 | 6348 |
6349 /* | 6349 /* |
6350 * If one of the two variables is a number, compare as a number. | 6350 * If one of the two variables is a number, compare as a number. |
6351 * When using "=~" or "!~", always compare as string. | 6351 * When using "=~" or "!~", always compare as string. |
6352 */ | 6352 */ |
6353 else if ((typ1->v_type == VAR_NUMBER || typ2->v_type == VAR_NUMBER) | 6353 else if ((typ1->v_type == VAR_NUMBER || typ2->v_type == VAR_NUMBER) |
6354 && type != ETYPE_MATCH && type != ETYPE_NOMATCH) | 6354 && type != EXPR_MATCH && type != EXPR_NOMATCH) |
6355 { | 6355 { |
6356 n1 = tv_get_number(typ1); | 6356 n1 = tv_get_number(typ1); |
6357 n2 = tv_get_number(typ2); | 6357 n2 = tv_get_number(typ2); |
6358 switch (type) | 6358 switch (type) |
6359 { | 6359 { |
6360 case ETYPE_IS: | 6360 case EXPR_IS: |
6361 case ETYPE_EQUAL: n1 = (n1 == n2); break; | 6361 case EXPR_EQUAL: n1 = (n1 == n2); break; |
6362 case ETYPE_ISNOT: | 6362 case EXPR_ISNOT: |
6363 case ETYPE_NEQUAL: n1 = (n1 != n2); break; | 6363 case EXPR_NEQUAL: n1 = (n1 != n2); break; |
6364 case ETYPE_GREATER: n1 = (n1 > n2); break; | 6364 case EXPR_GREATER: n1 = (n1 > n2); break; |
6365 case ETYPE_GEQUAL: n1 = (n1 >= n2); break; | 6365 case EXPR_GEQUAL: n1 = (n1 >= n2); break; |
6366 case ETYPE_SMALLER: n1 = (n1 < n2); break; | 6366 case EXPR_SMALLER: n1 = (n1 < n2); break; |
6367 case ETYPE_SEQUAL: n1 = (n1 <= n2); break; | 6367 case EXPR_SEQUAL: n1 = (n1 <= n2); break; |
6368 case ETYPE_UNKNOWN: | 6368 case EXPR_UNKNOWN: |
6369 case ETYPE_MATCH: | 6369 case EXPR_MATCH: |
6370 case ETYPE_NOMATCH: break; // avoid gcc warning | 6370 case EXPR_NOMATCH: break; // avoid gcc warning |
6371 } | 6371 } |
6372 } | 6372 } |
6373 else | 6373 else |
6374 { | 6374 { |
6375 s1 = tv_get_string_buf(typ1, buf1); | 6375 s1 = tv_get_string_buf(typ1, buf1); |
6376 s2 = tv_get_string_buf(typ2, buf2); | 6376 s2 = tv_get_string_buf(typ2, buf2); |
6377 if (type != ETYPE_MATCH && type != ETYPE_NOMATCH) | 6377 if (type != EXPR_MATCH && type != EXPR_NOMATCH) |
6378 i = ic ? MB_STRICMP(s1, s2) : STRCMP(s1, s2); | 6378 i = ic ? MB_STRICMP(s1, s2) : STRCMP(s1, s2); |
6379 else | 6379 else |
6380 i = 0; | 6380 i = 0; |
6381 n1 = FALSE; | 6381 n1 = FALSE; |
6382 switch (type) | 6382 switch (type) |
6383 { | 6383 { |
6384 case ETYPE_IS: | 6384 case EXPR_IS: |
6385 case ETYPE_EQUAL: n1 = (i == 0); break; | 6385 case EXPR_EQUAL: n1 = (i == 0); break; |
6386 case ETYPE_ISNOT: | 6386 case EXPR_ISNOT: |
6387 case ETYPE_NEQUAL: n1 = (i != 0); break; | 6387 case EXPR_NEQUAL: n1 = (i != 0); break; |
6388 case ETYPE_GREATER: n1 = (i > 0); break; | 6388 case EXPR_GREATER: n1 = (i > 0); break; |
6389 case ETYPE_GEQUAL: n1 = (i >= 0); break; | 6389 case EXPR_GEQUAL: n1 = (i >= 0); break; |
6390 case ETYPE_SMALLER: n1 = (i < 0); break; | 6390 case EXPR_SMALLER: n1 = (i < 0); break; |
6391 case ETYPE_SEQUAL: n1 = (i <= 0); break; | 6391 case EXPR_SEQUAL: n1 = (i <= 0); break; |
6392 | 6392 |
6393 case ETYPE_MATCH: | 6393 case EXPR_MATCH: |
6394 case ETYPE_NOMATCH: | 6394 case EXPR_NOMATCH: |
6395 n1 = pattern_match(s2, s1, ic); | 6395 n1 = pattern_match(s2, s1, ic); |
6396 if (type == ETYPE_NOMATCH) | 6396 if (type == EXPR_NOMATCH) |
6397 n1 = !n1; | 6397 n1 = !n1; |
6398 break; | 6398 break; |
6399 | 6399 |
6400 case ETYPE_UNKNOWN: break; // avoid gcc warning | 6400 case EXPR_UNKNOWN: break; // avoid gcc warning |
6401 } | 6401 } |
6402 } | 6402 } |
6403 clear_tv(typ1); | 6403 clear_tv(typ1); |
6404 typ1->v_type = VAR_NUMBER; | 6404 typ1->v_type = VAR_NUMBER; |
6405 typ1->vval.v_number = n1; | 6405 typ1->vval.v_number = n1; |