Mercurial > vim

comparison src/eval.c @ 19017:d9ea4f0bfd34 v8.2.0069

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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;