Mercurial > vim

comparison src/eval.c @ 15211:de63593896b3 v8.1.0615

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
patch 8.1.0615: get_tv function names are not consistent commit https://github.com/vim/vim/commit/d155d7a8519987361169459b8d464ae1caef5e9c Author: Bram Moolenaar <Bram@vim.org> Date: Fri Dec 21 16:04:21 2018 +0100 patch 8.1.0615: get_tv function names are not consistent Problem: Get_tv function names are not consistent. Solution: Rename to tv_get.
author Bram Moolenaar <Bram@vim.org>
date Fri, 21 Dec 2018 16:15:06 +0100
parents 7903dce131d4
children dada0b389d4f
comparison
equal deleted inserted replaced
15210:fbb2936c39b6 15211:de63593896b3
679 else 679 else
680 { 680 {
681 *error = FALSE; 681 *error = FALSE;
682 if (!skip) 682 if (!skip)
683 { 683 {
684 retval = (get_tv_number_chk(&tv, error) != 0); 684 retval = (tv_get_number_chk(&tv, error) != 0);
685 clear_tv(&tv); 685 clear_tv(&tv);
686 } 686 }
687 } 687 }
688 if (skip) 688 if (skip)
689 --emsg_skip; 689 --emsg_skip;
718 0L, 0L, &dummy, TRUE, partial, NULL) == FAIL) 718 0L, 0L, &dummy, TRUE, partial, NULL) == FAIL)
719 return FAIL; 719 return FAIL;
720 } 720 }
721 else 721 else
722 { 722 {
723 s = get_tv_string_buf_chk(expr, buf); 723 s = tv_get_string_buf_chk(expr, buf);
724 if (s == NULL) 724 if (s == NULL)
725 return FAIL; 725 return FAIL;
726 s = skipwhite(s); 726 s = skipwhite(s);
727 if (eval1(&s, rettv, TRUE) == FAIL) 727 if (eval1(&s, rettv, TRUE) == FAIL)
728 return FAIL; 728 return FAIL;
749 if (eval_expr_typval(expr, NULL, 0, &rettv) == FAIL) 749 if (eval_expr_typval(expr, NULL, 0, &rettv) == FAIL)
750 { 750 {
751 *error = TRUE; 751 *error = TRUE;
752 return FALSE; 752 return FALSE;
753 } 753 }
754 res = (get_tv_number_chk(&rettv, error) != 0); 754 res = (tv_get_number_chk(&rettv, error) != 0);
755 clear_tv(&rettv); 755 clear_tv(&rettv);
756 return res; 756 return res;
757 } 757 }
758 758
759 /* 759 /*
774 ++emsg_skip; 774 ++emsg_skip;
775 if (eval0(arg, &tv, nextcmd, !skip) == FAIL || skip) 775 if (eval0(arg, &tv, nextcmd, !skip) == FAIL || skip)
776 retval = NULL; 776 retval = NULL;
777 else 777 else
778 { 778 {
779 retval = vim_strsave(get_tv_string(&tv)); 779 retval = vim_strsave(tv_get_string(&tv));
780 clear_tv(&tv); 780 clear_tv(&tv);
781 } 781 }
782 if (skip) 782 if (skip)
783 --emsg_skip; 783 --emsg_skip;
784 784
839 vim_snprintf((char *)numbuf, NUMBUFLEN, "%g", tv.vval.v_float); 839 vim_snprintf((char *)numbuf, NUMBUFLEN, "%g", tv.vval.v_float);
840 retval = vim_strsave(numbuf); 840 retval = vim_strsave(numbuf);
841 } 841 }
842 #endif 842 #endif
843 else 843 else
844 retval = vim_strsave(get_tv_string(&tv)); 844 retval = vim_strsave(tv_get_string(&tv));
845 clear_tv(&tv); 845 clear_tv(&tv);
846 } 846 }
847 847
848 return retval; 848 return retval;
849 } 849 }
889 889
890 if (eval1(&p, &rettv, TRUE) == FAIL) 890 if (eval1(&p, &rettv, TRUE) == FAIL)
891 retval = -1; 891 retval = -1;
892 else 892 else
893 { 893 {
894 retval = get_tv_number_chk(&rettv, NULL); 894 retval = tv_get_number_chk(&rettv, NULL);
895 clear_tv(&rettv); 895 clear_tv(&rettv);
896 } 896 }
897 --emsg_off; 897 --emsg_off;
898 898
899 return retval; 899 return retval;
980 listitem_T *li; 980 listitem_T *li;
981 981
982 li = list->lv_first; 982 li = list->lv_first;
983 if (li == NULL) 983 if (li == NULL)
984 return -1; 984 return -1;
985 *pp = get_tv_string(&li->li_tv); 985 *pp = tv_get_string(&li->li_tv);
986 986
987 li = li->li_next; 987 li = li->li_next;
988 if (li == NULL) 988 if (li == NULL)
989 return -1; 989 return -1;
990 return (int)get_tv_number(&li->li_tv); 990 return (int)tv_get_number(&li->li_tv);
991 } 991 }
992 #endif 992 #endif
993 993
994 /* 994 /*
995 * Top level evaluation function. 995 * Top level evaluation function.
1051 varnumber_T retval; 1051 varnumber_T retval;
1052 1052
1053 if (call_vim_function(func, argc, argv, &rettv) == FAIL) 1053 if (call_vim_function(func, argc, argv, &rettv) == FAIL)
1054 return -1; 1054 return -1;
1055 1055
1056 retval = get_tv_number_chk(&rettv, NULL); 1056 retval = tv_get_number_chk(&rettv, NULL);
1057 clear_tv(&rettv); 1057 clear_tv(&rettv);
1058 return retval; 1058 return retval;
1059 } 1059 }
1060 1060
1061 #if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) \ 1061 #if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) \
1078 char_u *retval; 1078 char_u *retval;
1079 1079
1080 if (call_vim_function(func, argc, argv, &rettv) == FAIL) 1080 if (call_vim_function(func, argc, argv, &rettv) == FAIL)
1081 return NULL; 1081 return NULL;
1082 1082
1083 retval = vim_strsave(get_tv_string(&rettv)); 1083 retval = vim_strsave(tv_get_string(&rettv));
1084 clear_tv(&rettv); 1084 clear_tv(&rettv);
1085 return retval; 1085 return retval;
1086 } 1086 }
1087 # endif 1087 # endif
1088 1088
1652 EMSG(_(e_letunexp)); 1652 EMSG(_(e_letunexp));
1653 else if (!check_secure()) 1653 else if (!check_secure())
1654 { 1654 {
1655 c1 = name[len]; 1655 c1 = name[len];
1656 name[len] = NUL; 1656 name[len] = NUL;
1657 p = get_tv_string_chk(tv); 1657 p = tv_get_string_chk(tv);
1658 if (p != NULL && op != NULL && *op == '.') 1658 if (p != NULL && op != NULL && *op == '.')
1659 { 1659 {
1660 int mustfree = FALSE; 1660 int mustfree = FALSE;
1661 char_u *s = vim_getenv(name, &mustfree); 1661 char_u *s = vim_getenv(name, &mustfree);
1662 1662
1706 char_u *s; 1706 char_u *s;
1707 1707
1708 c1 = *p; 1708 c1 = *p;
1709 *p = NUL; 1709 *p = NUL;
1710 1710
1711 n = (long)get_tv_number(tv); 1711 n = (long)tv_get_number(tv);
1712 s = get_tv_string_chk(tv); /* != NULL if number or string */ 1712 s = tv_get_string_chk(tv); /* != NULL if number or string */
1713 if (s != NULL && op != NULL && *op != '=') 1713 if (s != NULL && op != NULL && *op != '=')
1714 { 1714 {
1715 opt_type = get_option_value(arg, &numval, 1715 opt_type = get_option_value(arg, &numval,
1716 &stringval, opt_flags); 1716 &stringval, opt_flags);
1717 if ((opt_type == 1 && *op == '.') 1717 if ((opt_type == 1 && *op == '.')
1761 else 1761 else
1762 { 1762 {
1763 char_u *ptofree = NULL; 1763 char_u *ptofree = NULL;
1764 char_u *s; 1764 char_u *s;
1765 1765
1766 p = get_tv_string_chk(tv); 1766 p = tv_get_string_chk(tv);
1767 if (p != NULL && op != NULL && *op == '.') 1767 if (p != NULL && op != NULL && *op == '.')
1768 { 1768 {
1769 s = get_reg_contents(*arg == '@' ? '"' : *arg, GREG_EXPR_SRC); 1769 s = get_reg_contents(*arg == '@' ? '"' : *arg, GREG_EXPR_SRC);
1770 if (s != NULL) 1770 if (s != NULL)
1771 { 1771 {
1954 else 1954 else
1955 { 1955 {
1956 empty1 = FALSE; 1956 empty1 = FALSE;
1957 if (eval1(&p, &var1, TRUE) == FAIL) /* recursive! */ 1957 if (eval1(&p, &var1, TRUE) == FAIL) /* recursive! */
1958 return NULL; 1958 return NULL;
1959 if (get_tv_string_chk(&var1) == NULL) 1959 if (tv_get_string_chk(&var1) == NULL)
1960 { 1960 {
1961 /* not a number or string */ 1961 /* not a number or string */
1962 clear_tv(&var1); 1962 clear_tv(&var1);
1963 return NULL; 1963 return NULL;
1964 } 1964 }
1991 if (eval1(&p, &var2, TRUE) == FAIL) /* recursive! */ 1991 if (eval1(&p, &var2, TRUE) == FAIL) /* recursive! */
1992 { 1992 {
1993 clear_tv(&var1); 1993 clear_tv(&var1);
1994 return NULL; 1994 return NULL;
1995 } 1995 }
1996 if (get_tv_string_chk(&var2) == NULL) 1996 if (tv_get_string_chk(&var2) == NULL)
1997 { 1997 {
1998 /* not a number or string */ 1998 /* not a number or string */
1999 clear_tv(&var1); 1999 clear_tv(&var1);
2000 clear_tv(&var2); 2000 clear_tv(&var2);
2001 return NULL; 2001 return NULL;
2022 if (lp->ll_tv->v_type == VAR_DICT) 2022 if (lp->ll_tv->v_type == VAR_DICT)
2023 { 2023 {
2024 if (len == -1) 2024 if (len == -1)
2025 { 2025 {
2026 /* "[key]": get key from "var1" */ 2026 /* "[key]": get key from "var1" */
2027 key = get_tv_string_chk(&var1); /* is number or string */ 2027 key = tv_get_string_chk(&var1); /* is number or string */
2028 if (key == NULL) 2028 if (key == NULL)
2029 { 2029 {
2030 clear_tv(&var1); 2030 clear_tv(&var1);
2031 return NULL; 2031 return NULL;
2032 } 2032 }
2104 */ 2104 */
2105 if (empty1) 2105 if (empty1)
2106 lp->ll_n1 = 0; 2106 lp->ll_n1 = 0;
2107 else 2107 else
2108 /* is number or string */ 2108 /* is number or string */
2109 lp->ll_n1 = (long)get_tv_number(&var1); 2109 lp->ll_n1 = (long)tv_get_number(&var1);
2110 clear_tv(&var1); 2110 clear_tv(&var1);
2111 2111
2112 lp->ll_dict = NULL; 2112 lp->ll_dict = NULL;
2113 lp->ll_list = lp->ll_tv->vval.v_list; 2113 lp->ll_list = lp->ll_tv->vval.v_list;
2114 lp->ll_li = list_find(lp->ll_list, lp->ll_n1); 2114 lp->ll_li = list_find(lp->ll_list, lp->ll_n1);
2134 * When no index given: "lp->ll_empty2" is TRUE. 2134 * When no index given: "lp->ll_empty2" is TRUE.
2135 * Otherwise "lp->ll_n2" is set to the second index. 2135 * Otherwise "lp->ll_n2" is set to the second index.
2136 */ 2136 */
2137 if (lp->ll_range && !lp->ll_empty2) 2137 if (lp->ll_range && !lp->ll_empty2)
2138 { 2138 {
2139 lp->ll_n2 = (long)get_tv_number(&var2); 2139 lp->ll_n2 = (long)tv_get_number(&var2);
2140 /* is number or string */ 2140 /* is number or string */
2141 clear_tv(&var2); 2141 clear_tv(&var2);
2142 if (lp->ll_n2 < 0) 2142 if (lp->ll_n2 < 0)
2143 { 2143 {
2144 ni = list_find(lp->ll_list, lp->ll_n2); 2144 ni = list_find(lp->ll_list, lp->ll_n2);
2365 if (tv2->v_type == VAR_LIST) 2365 if (tv2->v_type == VAR_LIST)
2366 break; 2366 break;
2367 if (*op == '+' || *op == '-') 2367 if (*op == '+' || *op == '-')
2368 { 2368 {
2369 /* nr += nr or nr -= nr*/ 2369 /* nr += nr or nr -= nr*/
2370 n = get_tv_number(tv1); 2370 n = tv_get_number(tv1);
2371 #ifdef FEAT_FLOAT 2371 #ifdef FEAT_FLOAT
2372 if (tv2->v_type == VAR_FLOAT) 2372 if (tv2->v_type == VAR_FLOAT)
2373 { 2373 {
2374 float_T f = n; 2374 float_T f = n;
2375 2375
2383 } 2383 }
2384 else 2384 else
2385 #endif 2385 #endif
2386 { 2386 {
2387 if (*op == '+') 2387 if (*op == '+')
2388 n += get_tv_number(tv2); 2388 n += tv_get_number(tv2);
2389 else 2389 else
2390 n -= get_tv_number(tv2); 2390 n -= tv_get_number(tv2);
2391 clear_tv(tv1); 2391 clear_tv(tv1);
2392 tv1->v_type = VAR_NUMBER; 2392 tv1->v_type = VAR_NUMBER;
2393 tv1->vval.v_number = n; 2393 tv1->vval.v_number = n;
2394 } 2394 }
2395 } 2395 }
2397 { 2397 {
2398 if (tv2->v_type == VAR_FLOAT) 2398 if (tv2->v_type == VAR_FLOAT)
2399 break; 2399 break;
2400 2400
2401 /* str .= str */ 2401 /* str .= str */
2402 s = get_tv_string(tv1); 2402 s = tv_get_string(tv1);
2403 s = concat_str(s, get_tv_string_buf(tv2, numbuf)); 2403 s = concat_str(s, tv_get_string_buf(tv2, numbuf));
2404 clear_tv(tv1); 2404 clear_tv(tv1);
2405 tv1->v_type = VAR_STRING; 2405 tv1->v_type = VAR_STRING;
2406 tv1->vval.v_string = s; 2406 tv1->vval.v_string = s;
2407 } 2407 }
2408 return OK; 2408 return OK;
2417 && tv2->v_type != VAR_STRING)) 2417 && tv2->v_type != VAR_STRING))
2418 break; 2418 break;
2419 if (tv2->v_type == VAR_FLOAT) 2419 if (tv2->v_type == VAR_FLOAT)
2420 f = tv2->vval.v_float; 2420 f = tv2->vval.v_float;
2421 else 2421 else
2422 f = get_tv_number(tv2); 2422 f = tv_get_number(tv2);
2423 if (*op == '+') 2423 if (*op == '+')
2424 tv1->vval.v_float += f; 2424 tv1->vval.v_float += f;
2425 else 2425 else
2426 tv1->vval.v_float -= f; 2426 tv1->vval.v_float -= f;
2427 } 2427 }
3269 result = FALSE; 3269 result = FALSE;
3270 if (evaluate) 3270 if (evaluate)
3271 { 3271 {
3272 int error = FALSE; 3272 int error = FALSE;
3273 3273
3274 if (get_tv_number_chk(rettv, &error) != 0) 3274 if (tv_get_number_chk(rettv, &error) != 0)
3275 result = TRUE; 3275 result = TRUE;
3276 clear_tv(rettv); 3276 clear_tv(rettv);
3277 if (error) 3277 if (error)
3278 return FAIL; 3278 return FAIL;
3279 } 3279 }
3343 result = FALSE; 3343 result = FALSE;
3344 while ((*arg)[0] == '|' && (*arg)[1] == '|') 3344 while ((*arg)[0] == '|' && (*arg)[1] == '|')
3345 { 3345 {
3346 if (evaluate && first) 3346 if (evaluate && first)
3347 { 3347 {
3348 if (get_tv_number_chk(rettv, &error) != 0) 3348 if (tv_get_number_chk(rettv, &error) != 0)
3349 result = TRUE; 3349 result = TRUE;
3350 clear_tv(rettv); 3350 clear_tv(rettv);
3351 if (error) 3351 if (error)
3352 return FAIL; 3352 return FAIL;
3353 first = FALSE; 3353 first = FALSE;
3363 /* 3363 /*
3364 * Compute the result. 3364 * Compute the result.
3365 */ 3365 */
3366 if (evaluate && !result) 3366 if (evaluate && !result)
3367 { 3367 {
3368 if (get_tv_number_chk(&var2, &error) != 0) 3368 if (tv_get_number_chk(&var2, &error) != 0)
3369 result = TRUE; 3369 result = TRUE;
3370 clear_tv(&var2); 3370 clear_tv(&var2);
3371 if (error) 3371 if (error)
3372 return FAIL; 3372 return FAIL;
3373 } 3373 }
3411 result = TRUE; 3411 result = TRUE;
3412 while ((*arg)[0] == '&' && (*arg)[1] == '&') 3412 while ((*arg)[0] == '&' && (*arg)[1] == '&')
3413 { 3413 {
3414 if (evaluate && first) 3414 if (evaluate && first)
3415 { 3415 {
3416 if (get_tv_number_chk(rettv, &error) == 0) 3416 if (tv_get_number_chk(rettv, &error) == 0)
3417 result = FALSE; 3417 result = FALSE;
3418 clear_tv(rettv); 3418 clear_tv(rettv);
3419 if (error) 3419 if (error)
3420 return FAIL; 3420 return FAIL;
3421 first = FALSE; 3421 first = FALSE;
3431 /* 3431 /*
3432 * Compute the result. 3432 * Compute the result.
3433 */ 3433 */
3434 if (evaluate && result) 3434 if (evaluate && result)
3435 { 3435 {
3436 if (get_tv_number_chk(&var2, &error) == 0) 3436 if (tv_get_number_chk(&var2, &error) == 0)
3437 result = FALSE; 3437 result = FALSE;
3438 clear_tv(&var2); 3438 clear_tv(&var2);
3439 if (error) 3439 if (error)
3440 return FAIL; 3440 return FAIL;
3441 } 3441 }
3620 * operand: if this is also a list, all is ok. 3620 * operand: if this is also a list, all is ok.
3621 * For "something . ...", "something - ..." or "non-list + ...", 3621 * For "something . ...", "something - ..." or "non-list + ...",
3622 * we know that the first operand needs to be a string or number 3622 * we know that the first operand needs to be a string or number
3623 * without evaluating the 2nd operand. So check before to avoid 3623 * without evaluating the 2nd operand. So check before to avoid
3624 * side effects after an error. */ 3624 * side effects after an error. */
3625 if (evaluate && get_tv_string_chk(rettv) == NULL) 3625 if (evaluate && tv_get_string_chk(rettv) == NULL)
3626 { 3626 {
3627 clear_tv(rettv); 3627 clear_tv(rettv);
3628 return FAIL; 3628 return FAIL;
3629 } 3629 }
3630 } 3630 }
3644 /* 3644 /*
3645 * Compute the result. 3645 * Compute the result.
3646 */ 3646 */
3647 if (op == '.') 3647 if (op == '.')
3648 { 3648 {
3649 s1 = get_tv_string_buf(rettv, buf1); /* already checked */ 3649 s1 = tv_get_string_buf(rettv, buf1); /* already checked */
3650 s2 = get_tv_string_buf_chk(&var2, buf2); 3650 s2 = tv_get_string_buf_chk(&var2, buf2);
3651 if (s2 == NULL) /* type error ? */ 3651 if (s2 == NULL) /* type error ? */
3652 { 3652 {
3653 clear_tv(rettv); 3653 clear_tv(rettv);
3654 clear_tv(&var2); 3654 clear_tv(&var2);
3655 return FAIL; 3655 return FAIL;
3684 n1 = 0; 3684 n1 = 0;
3685 } 3685 }
3686 else 3686 else
3687 #endif 3687 #endif
3688 { 3688 {
3689 n1 = get_tv_number_chk(rettv, &error); 3689 n1 = tv_get_number_chk(rettv, &error);
3690 if (error) 3690 if (error)
3691 { 3691 {
3692 /* This can only happen for "list + non-list". For 3692 /* This can only happen for "list + non-list". For
3693 * "non-list + ..." or "something - ...", we returned 3693 * "non-list + ..." or "something - ...", we returned
3694 * before evaluating the 2nd operand. */ 3694 * before evaluating the 2nd operand. */
3707 n2 = 0; 3707 n2 = 0;
3708 } 3708 }
3709 else 3709 else
3710 #endif 3710 #endif
3711 { 3711 {
3712 n2 = get_tv_number_chk(&var2, &error); 3712 n2 = tv_get_number_chk(&var2, &error);
3713 if (error) 3713 if (error)
3714 { 3714 {
3715 clear_tv(rettv); 3715 clear_tv(rettv);
3716 clear_tv(&var2); 3716 clear_tv(&var2);
3717 return FAIL; 3717 return FAIL;
3802 use_float = TRUE; 3802 use_float = TRUE;
3803 n1 = 0; 3803 n1 = 0;
3804 } 3804 }
3805 else 3805 else
3806 #endif 3806 #endif
3807 n1 = get_tv_number_chk(rettv, &error); 3807 n1 = tv_get_number_chk(rettv, &error);
3808 clear_tv(rettv); 3808 clear_tv(rettv);
3809 if (error) 3809 if (error)
3810 return FAIL; 3810 return FAIL;
3811 } 3811 }
3812 else 3812 else
3833 n2 = 0; 3833 n2 = 0;
3834 } 3834 }
3835 else 3835 else
3836 #endif 3836 #endif
3837 { 3837 {
3838 n2 = get_tv_number_chk(&var2, &error); 3838 n2 = tv_get_number_chk(&var2, &error);
3839 clear_tv(&var2); 3839 clear_tv(&var2);
3840 if (error) 3840 if (error)
3841 return FAIL; 3841 return FAIL;
3842 #ifdef FEAT_FLOAT 3842 #ifdef FEAT_FLOAT
3843 if (use_float) 3843 if (use_float)
4198 4198
4199 if (rettv->v_type == VAR_FLOAT) 4199 if (rettv->v_type == VAR_FLOAT)
4200 f = rettv->vval.v_float; 4200 f = rettv->vval.v_float;
4201 else 4201 else
4202 #endif 4202 #endif
4203 val = get_tv_number_chk(rettv, &error); 4203 val = tv_get_number_chk(rettv, &error);
4204 if (error) 4204 if (error)
4205 { 4205 {
4206 clear_tv(rettv); 4206 clear_tv(rettv);
4207 ret = FAIL; 4207 ret = FAIL;
4208 } 4208 }
4324 *arg = skipwhite(*arg + 1); 4324 *arg = skipwhite(*arg + 1);
4325 if (**arg == ':') 4325 if (**arg == ':')
4326 empty1 = TRUE; 4326 empty1 = TRUE;
4327 else if (eval1(arg, &var1, evaluate) == FAIL) /* recursive! */ 4327 else if (eval1(arg, &var1, evaluate) == FAIL) /* recursive! */
4328 return FAIL; 4328 return FAIL;
4329 else if (evaluate && get_tv_string_chk(&var1) == NULL) 4329 else if (evaluate && tv_get_string_chk(&var1) == NULL)
4330 { 4330 {
4331 /* not a number or string */ 4331 /* not a number or string */
4332 clear_tv(&var1); 4332 clear_tv(&var1);
4333 return FAIL; 4333 return FAIL;
4334 } 4334 }
4346 { 4346 {
4347 if (!empty1) 4347 if (!empty1)
4348 clear_tv(&var1); 4348 clear_tv(&var1);
4349 return FAIL; 4349 return FAIL;
4350 } 4350 }
4351 else if (evaluate && get_tv_string_chk(&var2) == NULL) 4351 else if (evaluate && tv_get_string_chk(&var2) == NULL)
4352 { 4352 {
4353 /* not a number or string */ 4353 /* not a number or string */
4354 if (!empty1) 4354 if (!empty1)
4355 clear_tv(&var1); 4355 clear_tv(&var1);
4356 clear_tv(&var2); 4356 clear_tv(&var2);
4374 if (evaluate) 4374 if (evaluate)
4375 { 4375 {
4376 n1 = 0; 4376 n1 = 0;
4377 if (!empty1 && rettv->v_type != VAR_DICT) 4377 if (!empty1 && rettv->v_type != VAR_DICT)
4378 { 4378 {
4379 n1 = get_tv_number(&var1); 4379 n1 = tv_get_number(&var1);
4380 clear_tv(&var1); 4380 clear_tv(&var1);
4381 } 4381 }
4382 if (range) 4382 if (range)
4383 { 4383 {
4384 if (empty2) 4384 if (empty2)
4385 n2 = -1; 4385 n2 = -1;
4386 else 4386 else
4387 { 4387 {
4388 n2 = get_tv_number(&var2); 4388 n2 = tv_get_number(&var2);
4389 clear_tv(&var2); 4389 clear_tv(&var2);
4390 } 4390 }
4391 } 4391 }
4392 4392
4393 switch (rettv->v_type) 4393 switch (rettv->v_type)
4401 case VAR_CHANNEL: 4401 case VAR_CHANNEL:
4402 break; /* not evaluating, skipping over subscript */ 4402 break; /* not evaluating, skipping over subscript */
4403 4403
4404 case VAR_NUMBER: 4404 case VAR_NUMBER:
4405 case VAR_STRING: 4405 case VAR_STRING:
4406 s = get_tv_string(rettv); 4406 s = tv_get_string(rettv);
4407 len = (long)STRLEN(s); 4407 len = (long)STRLEN(s);
4408 if (range) 4408 if (range)
4409 { 4409 {
4410 /* The resulting variable is a substring. If the indexes 4410 /* The resulting variable is a substring. If the indexes
4411 * are out of range the result is empty. */ 4411 * are out of range the result is empty. */
4502 { 4502 {
4503 dictitem_T *item; 4503 dictitem_T *item;
4504 4504
4505 if (len == -1) 4505 if (len == -1)
4506 { 4506 {
4507 key = get_tv_string_chk(&var1); 4507 key = tv_get_string_chk(&var1);
4508 if (key == NULL) 4508 if (key == NULL)
4509 { 4509 {
4510 clear_tv(&var1); 4510 clear_tv(&var1);
4511 return FAIL; 4511 return FAIL;
4512 } 4512 }
4972 4972
4973 case VAR_NUMBER: 4973 case VAR_NUMBER:
4974 return tv1->vval.v_number == tv2->vval.v_number; 4974 return tv1->vval.v_number == tv2->vval.v_number;
4975 4975
4976 case VAR_STRING: 4976 case VAR_STRING:
4977 s1 = get_tv_string_buf(tv1, buf1); 4977 s1 = tv_get_string_buf(tv1, buf1);
4978 s2 = get_tv_string_buf(tv2, buf2); 4978 s2 = tv_get_string_buf(tv2, buf2);
4979 return ((ic ? MB_STRICMP(s1, s2) : STRCMP(s1, s2)) == 0); 4979 return ((ic ? MB_STRICMP(s1, s2) : STRCMP(s1, s2)) == 0);
4980 4980
4981 case VAR_SPECIAL: 4981 case VAR_SPECIAL:
4982 return tv1->vval.v_number == tv2->vval.v_number; 4982 return tv1->vval.v_number == tv2->vval.v_number;
4983 4983
5650 break; 5650 break;
5651 5651
5652 case VAR_NUMBER: 5652 case VAR_NUMBER:
5653 case VAR_UNKNOWN: 5653 case VAR_UNKNOWN:
5654 *tofree = NULL; 5654 *tofree = NULL;
5655 r = get_tv_string_buf(tv, numbuf); 5655 r = tv_get_string_buf(tv, numbuf);
5656 break; 5656 break;
5657 5657
5658 case VAR_JOB: 5658 case VAR_JOB:
5659 case VAR_CHANNEL: 5659 case VAR_CHANNEL:
5660 *tofree = NULL; 5660 *tofree = NULL;
5661 r = get_tv_string_buf(tv, numbuf); 5661 r = tv_get_string_buf(tv, numbuf);
5662 if (composite_val) 5662 if (composite_val)
5663 { 5663 {
5664 *tofree = string_quote(r, FALSE); 5664 *tofree = string_quote(r, FALSE);
5665 r = *tofree; 5665 r = *tofree;
5666 } 5666 }
5911 #endif 5911 #endif
5912 5912
5913 return &pos; 5913 return &pos;
5914 } 5914 }
5915 5915
5916 name = get_tv_string_chk(varp); 5916 name = tv_get_string_chk(varp);
5917 if (name == NULL) 5917 if (name == NULL)
5918 return NULL; 5918 return NULL;
5919 if (name[0] == '.') /* cursor */ 5919 if (name[0] == '.') /* cursor */
5920 return &curwin->w_cursor; 5920 return &curwin->w_cursor;
5921 if (name[0] == 'v' && name[1] == NUL) /* Visual start */ 5921 if (name[0] == 'v' && name[1] == NUL) /* Visual start */
6361 * Never returns NULL; 6361 * Never returns NULL;
6362 */ 6362 */
6363 char_u * 6363 char_u *
6364 get_vim_var_str(int idx) 6364 get_vim_var_str(int idx)
6365 { 6365 {
6366 return get_tv_string(&vimvars[idx].vv_tv); 6366 return tv_get_string(&vimvars[idx].vv_tv);
6367 } 6367 }
6368 6368
6369 /* 6369 /*
6370 * Get List v: variable value. Caller must take care of reference count when 6370 * Get List v: variable value. Caller must take care of reference count when
6371 * needed. 6371 * needed.
6934 6934
6935 /* 6935 /*
6936 * Get the number value of a variable. 6936 * Get the number value of a variable.
6937 * If it is a String variable, uses vim_str2nr(). 6937 * If it is a String variable, uses vim_str2nr().
6938 * For incompatible types, return 0. 6938 * For incompatible types, return 0.
6939 * get_tv_number_chk() is similar to get_tv_number(), but informs the 6939 * tv_get_number_chk() is similar to tv_get_number(), but informs the
6940 * caller of incompatible types: it sets *denote to TRUE if "denote" 6940 * caller of incompatible types: it sets *denote to TRUE if "denote"
6941 * is not NULL or returns -1 otherwise. 6941 * is not NULL or returns -1 otherwise.
6942 */ 6942 */
6943 varnumber_T 6943 varnumber_T
6944 get_tv_number(typval_T *varp) 6944 tv_get_number(typval_T *varp)
6945 { 6945 {
6946 int error = FALSE; 6946 int error = FALSE;
6947 6947
6948 return get_tv_number_chk(varp, &error); /* return 0L on error */ 6948 return tv_get_number_chk(varp, &error); /* return 0L on error */
6949 } 6949 }
6950 6950
6951 varnumber_T 6951 varnumber_T
6952 get_tv_number_chk(typval_T *varp, int *denote) 6952 tv_get_number_chk(typval_T *varp, int *denote)
6953 { 6953 {
6954 varnumber_T n = 0L; 6954 varnumber_T n = 0L;
6955 6955
6956 switch (varp->v_type) 6956 switch (varp->v_type)
6957 { 6957 {
6989 #ifdef FEAT_JOB_CHANNEL 6989 #ifdef FEAT_JOB_CHANNEL
6990 EMSG(_("E913: Using a Channel as a Number")); 6990 EMSG(_("E913: Using a Channel as a Number"));
6991 break; 6991 break;
6992 #endif 6992 #endif
6993 case VAR_UNKNOWN: 6993 case VAR_UNKNOWN:
6994 internal_error("get_tv_number(UNKNOWN)"); 6994 internal_error("tv_get_number(UNKNOWN)");
6995 break; 6995 break;
6996 } 6996 }
6997 if (denote == NULL) /* useful for values that must be unsigned */ 6997 if (denote == NULL) /* useful for values that must be unsigned */
6998 n = -1; 6998 n = -1;
6999 else 6999 else
7001 return n; 7001 return n;
7002 } 7002 }
7003 7003
7004 #ifdef FEAT_FLOAT 7004 #ifdef FEAT_FLOAT
7005 float_T 7005 float_T
7006 get_tv_float(typval_T *varp) 7006 tv_get_float(typval_T *varp)
7007 { 7007 {
7008 switch (varp->v_type) 7008 switch (varp->v_type)
7009 { 7009 {
7010 case VAR_NUMBER: 7010 case VAR_NUMBER:
7011 return (float_T)(varp->vval.v_number); 7011 return (float_T)(varp->vval.v_number);
7036 # ifdef FEAT_JOB_CHANNEL 7036 # ifdef FEAT_JOB_CHANNEL
7037 EMSG(_("E914: Using a Channel as a Float")); 7037 EMSG(_("E914: Using a Channel as a Float"));
7038 break; 7038 break;
7039 # endif 7039 # endif
7040 case VAR_UNKNOWN: 7040 case VAR_UNKNOWN:
7041 internal_error("get_tv_float(UNKNOWN)"); 7041 internal_error("tv_get_float(UNKNOWN)");
7042 break; 7042 break;
7043 } 7043 }
7044 return 0; 7044 return 0;
7045 } 7045 }
7046 #endif 7046 #endif
7047 7047
7048 /* 7048 /*
7049 * Get the string value of a variable. 7049 * Get the string value of a variable.
7050 * If it is a Number variable, the number is converted into a string. 7050 * If it is a Number variable, the number is converted into a string.
7051 * get_tv_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE! 7051 * tv_get_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
7052 * get_tv_string_buf() uses a given buffer. 7052 * tv_get_string_buf() uses a given buffer.
7053 * If the String variable has never been set, return an empty string. 7053 * If the String variable has never been set, return an empty string.
7054 * Never returns NULL; 7054 * Never returns NULL;
7055 * get_tv_string_chk() and get_tv_string_buf_chk() are similar, but return 7055 * tv_get_string_chk() and tv_get_string_buf_chk() are similar, but return
7056 * NULL on error. 7056 * NULL on error.
7057 */ 7057 */
7058 char_u * 7058 char_u *
7059 get_tv_string(typval_T *varp) 7059 tv_get_string(typval_T *varp)
7060 { 7060 {
7061 static char_u mybuf[NUMBUFLEN]; 7061 static char_u mybuf[NUMBUFLEN];
7062 7062
7063 return get_tv_string_buf(varp, mybuf); 7063 return tv_get_string_buf(varp, mybuf);
7064 } 7064 }
7065 7065
7066 char_u * 7066 char_u *
7067 get_tv_string_buf(typval_T *varp, char_u *buf) 7067 tv_get_string_buf(typval_T *varp, char_u *buf)
7068 { 7068 {
7069 char_u *res = get_tv_string_buf_chk(varp, buf); 7069 char_u *res = tv_get_string_buf_chk(varp, buf);
7070 7070
7071 return res != NULL ? res : (char_u *)""; 7071 return res != NULL ? res : (char_u *)"";
7072 } 7072 }
7073 7073
7074 /* 7074 /*
7075 * Careful: This uses a single, static buffer. YOU CAN ONLY USE IT ONCE! 7075 * Careful: This uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
7076 */ 7076 */
7077 char_u * 7077 char_u *
7078 get_tv_string_chk(typval_T *varp) 7078 tv_get_string_chk(typval_T *varp)
7079 { 7079 {
7080 static char_u mybuf[NUMBUFLEN]; 7080 static char_u mybuf[NUMBUFLEN];
7081 7081
7082 return get_tv_string_buf_chk(varp, mybuf); 7082 return tv_get_string_buf_chk(varp, mybuf);
7083 } 7083 }
7084 7084
7085 char_u * 7085 char_u *
7086 get_tv_string_buf_chk(typval_T *varp, char_u *buf) 7086 tv_get_string_buf_chk(typval_T *varp, char_u *buf)
7087 { 7087 {
7088 switch (varp->v_type) 7088 switch (varp->v_type)
7089 { 7089 {
7090 case VAR_NUMBER: 7090 case VAR_NUMBER:
7091 vim_snprintf((char *)buf, NUMBUFLEN, "%lld", 7091 vim_snprintf((char *)buf, NUMBUFLEN, "%lld",
7296 return NULL; 7296 return NULL;
7297 } 7297 }
7298 7298
7299 /* 7299 /*
7300 * Get the string value of a (global/local) variable. 7300 * Get the string value of a (global/local) variable.
7301 * Note: see get_tv_string() for how long the pointer remains valid. 7301 * Note: see tv_get_string() for how long the pointer remains valid.
7302 * Returns NULL when it doesn't exist. 7302 * Returns NULL when it doesn't exist.
7303 */ 7303 */
7304 char_u * 7304 char_u *
7305 get_var_value(char_u *name) 7305 get_var_value(char_u *name)
7306 { 7306 {
7307 dictitem_T *v; 7307 dictitem_T *v;
7308 7308
7309 v = find_var(name, NULL, FALSE); 7309 v = find_var(name, NULL, FALSE);
7310 if (v == NULL) 7310 if (v == NULL)
7311 return NULL; 7311 return NULL;
7312 return get_tv_string(&v->di_tv); 7312 return tv_get_string(&v->di_tv);
7313 } 7313 }
7314 7314
7315 /* 7315 /*
7316 * Allocate a new hashtab for a sourced script. It will be used while 7316 * Allocate a new hashtab for a sourced script. It will be used while
7317 * sourcing this script and when executing functions defined in the script. 7317 * sourcing this script and when executing functions defined in the script.
7542 { 7542 {
7543 if (v->di_tv.v_type == VAR_STRING) 7543 if (v->di_tv.v_type == VAR_STRING)
7544 { 7544 {
7545 vim_free(v->di_tv.vval.v_string); 7545 vim_free(v->di_tv.vval.v_string);
7546 if (copy || tv->v_type != VAR_STRING) 7546 if (copy || tv->v_type != VAR_STRING)
7547 v->di_tv.vval.v_string = vim_strsave(get_tv_string(tv)); 7547 v->di_tv.vval.v_string = vim_strsave(tv_get_string(tv));
7548 else 7548 else
7549 { 7549 {
7550 /* Take over the string to avoid an extra alloc/free. */ 7550 /* Take over the string to avoid an extra alloc/free. */
7551 v->di_tv.vval.v_string = tv->vval.v_string; 7551 v->di_tv.vval.v_string = tv->vval.v_string;
7552 tv->vval.v_string = NULL; 7552 tv->vval.v_string = NULL;
7553 } 7553 }
7554 return; 7554 return;
7555 } 7555 }
7556 else if (v->di_tv.v_type == VAR_NUMBER) 7556 else if (v->di_tv.v_type == VAR_NUMBER)
7557 { 7557 {
7558 v->di_tv.vval.v_number = get_tv_number(tv); 7558 v->di_tv.vval.v_number = tv_get_number(tv);
7559 if (STRCMP(varname, "searchforward") == 0) 7559 if (STRCMP(varname, "searchforward") == 0)
7560 set_search_direction(v->di_tv.vval.v_number ? '/' : '?'); 7560 set_search_direction(v->di_tv.vval.v_number ? '/' : '?');
7561 #ifdef FEAT_SEARCH_EXTRA 7561 #ifdef FEAT_SEARCH_EXTRA
7562 else if (STRCMP(varname, "hlsearch") == 0) 7562 else if (STRCMP(varname, "hlsearch") == 0)
7563 { 7563 {
7892 typval_T *argvars, 7892 typval_T *argvars,
7893 typval_T *rettv, 7893 typval_T *rettv,
7894 int inputdialog, 7894 int inputdialog,
7895 int secret) 7895 int secret)
7896 { 7896 {
7897 char_u *prompt = get_tv_string_chk(&argvars[0]); 7897 char_u *prompt = tv_get_string_chk(&argvars[0]);
7898 char_u *p = NULL; 7898 char_u *p = NULL;
7899 int c; 7899 int c;
7900 char_u buf[NUMBUFLEN]; 7900 char_u buf[NUMBUFLEN];
7901 int cmd_silent_save = cmd_silent; 7901 int cmd_silent_save = cmd_silent;
7902 char_u *defstr = (char_u *)""; 7902 char_u *defstr = (char_u *)"";
7935 } 7935 }
7936 cmdline_row = msg_row; 7936 cmdline_row = msg_row;
7937 7937
7938 if (argvars[1].v_type != VAR_UNKNOWN) 7938 if (argvars[1].v_type != VAR_UNKNOWN)
7939 { 7939 {
7940 defstr = get_tv_string_buf_chk(&argvars[1], buf); 7940 defstr = tv_get_string_buf_chk(&argvars[1], buf);
7941 if (defstr != NULL) 7941 if (defstr != NULL)
7942 stuffReadbuffSpec(defstr); 7942 stuffReadbuffSpec(defstr);
7943 7943
7944 if (!inputdialog && argvars[2].v_type != VAR_UNKNOWN) 7944 if (!inputdialog && argvars[2].v_type != VAR_UNKNOWN)
7945 { 7945 {
7948 long argt; 7948 long argt;
7949 7949
7950 /* input() with a third argument: completion */ 7950 /* input() with a third argument: completion */
7951 rettv->vval.v_string = NULL; 7951 rettv->vval.v_string = NULL;
7952 7952
7953 xp_name = get_tv_string_buf_chk(&argvars[2], buf); 7953 xp_name = tv_get_string_buf_chk(&argvars[2], buf);
7954 if (xp_name == NULL) 7954 if (xp_name == NULL)
7955 return; 7955 return;
7956 7956
7957 xp_namelen = (int)STRLEN(xp_name); 7957 xp_namelen = (int)STRLEN(xp_name);
7958 7958
7973 ex_normal_busy = save_ex_normal_busy; 7973 ex_normal_busy = save_ex_normal_busy;
7974 } 7974 }
7975 if (inputdialog && rettv->vval.v_string == NULL 7975 if (inputdialog && rettv->vval.v_string == NULL
7976 && argvars[1].v_type != VAR_UNKNOWN 7976 && argvars[1].v_type != VAR_UNKNOWN
7977 && argvars[2].v_type != VAR_UNKNOWN) 7977 && argvars[2].v_type != VAR_UNKNOWN)
7978 rettv->vval.v_string = vim_strsave(get_tv_string_buf( 7978 rettv->vval.v_string = vim_strsave(tv_get_string_buf(
7979 &argvars[2], buf)); 7979 &argvars[2], buf));
7980 7980
7981 vim_free(xp_arg); 7981 vim_free(xp_arg);
7982 7982
7983 /* since the user typed this, no need to wait for return */ 7983 /* since the user typed this, no need to wait for return */
8140 break; 8140 break;
8141 } 8141 }
8142 8142
8143 if (!eap->skip) 8143 if (!eap->skip)
8144 { 8144 {
8145 p = get_tv_string(&rettv); 8145 p = tv_get_string(&rettv);
8146 len = (int)STRLEN(p); 8146 len = (int)STRLEN(p);
8147 if (ga_grow(&ga, len + 2) == FAIL) 8147 if (ga_grow(&ga, len + 2) == FAIL)
8148 { 8148 {
8149 clear_tv(&rettv); 8149 clear_tv(&rettv);
8150 ret = FAIL; 8150 ret = FAIL;
8203 find_win_by_nr( 8203 find_win_by_nr(
8204 typval_T *vp, 8204 typval_T *vp,
8205 tabpage_T *tp) /* NULL for current tab page */ 8205 tabpage_T *tp) /* NULL for current tab page */
8206 { 8206 {
8207 win_T *wp; 8207 win_T *wp;
8208 int nr = (int)get_tv_number_chk(vp, NULL); 8208 int nr = (int)tv_get_number_chk(vp, NULL);
8209 8209
8210 if (nr < 0) 8210 if (nr < 0)
8211 return NULL; 8211 return NULL;
8212 if (nr == 0) 8212 if (nr == 0)
8213 return curwin; 8213 return curwin;
8232 * in the current tab page. 8232 * in the current tab page.
8233 */ 8233 */
8234 win_T * 8234 win_T *
8235 find_win_by_nr_or_id(typval_T *vp) 8235 find_win_by_nr_or_id(typval_T *vp)
8236 { 8236 {
8237 int nr = (int)get_tv_number_chk(vp, NULL); 8237 int nr = (int)tv_get_number_chk(vp, NULL);
8238 8238
8239 if (nr >= LOWEST_WIN_ID) 8239 if (nr >= LOWEST_WIN_ID)
8240 return win_id2wp(vp); 8240 return win_id2wp(vp);
8241 return find_win_by_nr(vp, NULL); 8241 return find_win_by_nr(vp, NULL);
8242 } 8242 }
8255 8255
8256 if (wvp->v_type != VAR_UNKNOWN) 8256 if (wvp->v_type != VAR_UNKNOWN)
8257 { 8257 {
8258 if (tvp->v_type != VAR_UNKNOWN) 8258 if (tvp->v_type != VAR_UNKNOWN)
8259 { 8259 {
8260 n = (long)get_tv_number(tvp); 8260 n = (long)tv_get_number(tvp);
8261 if (n >= 0) 8261 if (n >= 0)
8262 tp = find_tabpage(n); 8262 tp = find_tabpage(n);
8263 } 8263 }
8264 else 8264 else
8265 tp = curtab; 8265 tp = curtab;
8290 win_T *oldcurwin; 8290 win_T *oldcurwin;
8291 tabpage_T *oldtabpage; 8291 tabpage_T *oldtabpage;
8292 int need_switch_win; 8292 int need_switch_win;
8293 8293
8294 if (off == 1) 8294 if (off == 1)
8295 tp = find_tabpage((int)get_tv_number_chk(&argvars[0], NULL)); 8295 tp = find_tabpage((int)tv_get_number_chk(&argvars[0], NULL));
8296 else 8296 else
8297 tp = curtab; 8297 tp = curtab;
8298 win = find_win_by_nr(&argvars[off], tp); 8298 win = find_win_by_nr(&argvars[off], tp);
8299 varname = get_tv_string_chk(&argvars[off + 1]); 8299 varname = tv_get_string_chk(&argvars[off + 1]);
8300 ++emsg_off; 8300 ++emsg_off;
8301 8301
8302 rettv->v_type = VAR_STRING; 8302 rettv->v_type = VAR_STRING;
8303 rettv->vval.v_string = NULL; 8303 rettv->vval.v_string = NULL;
8304 8304
8371 8371
8372 if (check_restricted() || check_secure()) 8372 if (check_restricted() || check_secure())
8373 return; 8373 return;
8374 8374
8375 if (off == 1) 8375 if (off == 1)
8376 tp = find_tabpage((int)get_tv_number_chk(&argvars[0], NULL)); 8376 tp = find_tabpage((int)tv_get_number_chk(&argvars[0], NULL));
8377 else 8377 else
8378 tp = curtab; 8378 tp = curtab;
8379 win = find_win_by_nr(&argvars[off], tp); 8379 win = find_win_by_nr(&argvars[off], tp);
8380 varname = get_tv_string_chk(&argvars[off + 1]); 8380 varname = tv_get_string_chk(&argvars[off + 1]);
8381 varp = &argvars[off + 2]; 8381 varp = &argvars[off + 2];
8382 8382
8383 if (win != NULL && varname != NULL && varp != NULL) 8383 if (win != NULL && varname != NULL && varp != NULL)
8384 { 8384 {
8385 need_switch_win = !(tp == curtab && win == curwin); 8385 need_switch_win = !(tp == curtab && win == curwin);
8391 long numval; 8391 long numval;
8392 char_u *strval; 8392 char_u *strval;
8393 int error = FALSE; 8393 int error = FALSE;
8394 8394
8395 ++varname; 8395 ++varname;
8396 numval = (long)get_tv_number_chk(varp, &error); 8396 numval = (long)tv_get_number_chk(varp, &error);
8397 strval = get_tv_string_buf_chk(varp, nbuf); 8397 strval = tv_get_string_buf_chk(varp, nbuf);
8398 if (!error && strval != NULL) 8398 if (!error && strval != NULL)
8399 set_option_value(varname, numval, strval, OPT_LOCAL); 8399 set_option_value(varname, numval, strval, OPT_LOCAL);
8400 } 8400 }
8401 else 8401 else
8402 { 8402 {
8695 || this_var->di_tv.v_type == VAR_STRING) 8695 || this_var->di_tv.v_type == VAR_STRING)
8696 && var_flavour(this_var->di_key) == VAR_FLAVOUR_SESSION) 8696 && var_flavour(this_var->di_key) == VAR_FLAVOUR_SESSION)
8697 { 8697 {
8698 /* Escape special characters with a backslash. Turn a LF and 8698 /* Escape special characters with a backslash. Turn a LF and
8699 * CR into \n and \r. */ 8699 * CR into \n and \r. */
8700 p = vim_strsave_escaped(get_tv_string(&this_var->di_tv), 8700 p = vim_strsave_escaped(tv_get_string(&this_var->di_tv),
8701 (char_u *)"\\\"\n\r"); 8701 (char_u *)"\\\"\n\r");
8702 if (p == NULL) /* out of memory */ 8702 if (p == NULL) /* out of memory */
8703 break; 8703 break;
8704 for (t = p; *t != NUL; ++t) 8704 for (t = p; *t != NUL; ++t)
8705 if (*t == '\n') 8705 if (*t == '\n')
8840 int 8840 int
8841 assert_equalfile(typval_T *argvars) 8841 assert_equalfile(typval_T *argvars)
8842 { 8842 {
8843 char_u buf1[NUMBUFLEN]; 8843 char_u buf1[NUMBUFLEN];
8844 char_u buf2[NUMBUFLEN]; 8844 char_u buf2[NUMBUFLEN];
8845 char_u *fname1 = get_tv_string_buf_chk(&argvars[0], buf1); 8845 char_u *fname1 = tv_get_string_buf_chk(&argvars[0], buf1);
8846 char_u *fname2 = get_tv_string_buf_chk(&argvars[1], buf2); 8846 char_u *fname2 = tv_get_string_buf_chk(&argvars[1], buf2);
8847 garray_T ga; 8847 garray_T ga;
8848 FILE *fd1; 8848 FILE *fd1;
8849 FILE *fd2; 8849 FILE *fd2;
8850 8850
8851 if (fname1 == NULL || fname2 == NULL) 8851 if (fname1 == NULL || fname2 == NULL)
8912 assert_match_common(typval_T *argvars, assert_type_T atype) 8912 assert_match_common(typval_T *argvars, assert_type_T atype)
8913 { 8913 {
8914 garray_T ga; 8914 garray_T ga;
8915 char_u buf1[NUMBUFLEN]; 8915 char_u buf1[NUMBUFLEN];
8916 char_u buf2[NUMBUFLEN]; 8916 char_u buf2[NUMBUFLEN];
8917 char_u *pat = get_tv_string_buf_chk(&argvars[0], buf1); 8917 char_u *pat = tv_get_string_buf_chk(&argvars[0], buf1);
8918 char_u *text = get_tv_string_buf_chk(&argvars[1], buf2); 8918 char_u *text = tv_get_string_buf_chk(&argvars[1], buf2);
8919 8919
8920 if (pat == NULL || text == NULL) 8920 if (pat == NULL || text == NULL)
8921 EMSG(_(e_invarg)); 8921 EMSG(_(e_invarg));
8922 else if (pattern_match(pat, text, FALSE) != (atype == ASSERT_MATCH)) 8922 else if (pattern_match(pat, text, FALSE) != (atype == ASSERT_MATCH))
8923 { 8923 {
8934 int 8934 int
8935 assert_inrange(typval_T *argvars) 8935 assert_inrange(typval_T *argvars)
8936 { 8936 {
8937 garray_T ga; 8937 garray_T ga;
8938 int error = FALSE; 8938 int error = FALSE;
8939 varnumber_T lower = get_tv_number_chk(&argvars[0], &error); 8939 varnumber_T lower = tv_get_number_chk(&argvars[0], &error);
8940 varnumber_T upper = get_tv_number_chk(&argvars[1], &error); 8940 varnumber_T upper = tv_get_number_chk(&argvars[1], &error);
8941 varnumber_T actual = get_tv_number_chk(&argvars[2], &error); 8941 varnumber_T actual = tv_get_number_chk(&argvars[2], &error);
8942 char_u *tofree; 8942 char_u *tofree;
8943 char msg[200]; 8943 char msg[200];
8944 char_u numbuf[NUMBUFLEN]; 8944 char_u numbuf[NUMBUFLEN];
8945 8945
8946 if (error) 8946 if (error)
8978 8978
8979 if (argvars[0].v_type == VAR_SPECIAL 8979 if (argvars[0].v_type == VAR_SPECIAL
8980 && argvars[0].vval.v_number == (isTrue ? VVAL_TRUE : VVAL_FALSE)) 8980 && argvars[0].vval.v_number == (isTrue ? VVAL_TRUE : VVAL_FALSE))
8981 return 0; 8981 return 0;
8982 if (argvars[0].v_type != VAR_NUMBER 8982 if (argvars[0].v_type != VAR_NUMBER
8983 || (get_tv_number_chk(&argvars[0], &error) == 0) == isTrue 8983 || (tv_get_number_chk(&argvars[0], &error) == 0) == isTrue
8984 || error) 8984 || error)
8985 { 8985 {
8986 prepare_assert_error(&ga); 8986 prepare_assert_error(&ga);
8987 fill_assert_error(&ga, &argvars[1], 8987 fill_assert_error(&ga, &argvars[1],
8988 (char_u *)(isTrue ? "True" : "False"), 8988 (char_u *)(isTrue ? "True" : "False"),
8998 assert_report(typval_T *argvars) 8998 assert_report(typval_T *argvars)
8999 { 8999 {
9000 garray_T ga; 9000 garray_T ga;
9001 9001
9002 prepare_assert_error(&ga); 9002 prepare_assert_error(&ga);
9003 ga_concat(&ga, get_tv_string(&argvars[0])); 9003 ga_concat(&ga, tv_get_string(&argvars[0]));
9004 assert_error(&ga); 9004 assert_error(&ga);
9005 ga_clear(&ga); 9005 ga_clear(&ga);
9006 return 1; 9006 return 1;
9007 } 9007 }
9008 9008
9009 int 9009 int
9010 assert_exception(typval_T *argvars) 9010 assert_exception(typval_T *argvars)
9011 { 9011 {
9012 garray_T ga; 9012 garray_T ga;
9013 char_u *error = get_tv_string_chk(&argvars[0]); 9013 char_u *error = tv_get_string_chk(&argvars[0]);
9014 9014
9015 if (vimvars[VV_EXCEPTION].vv_str == NULL) 9015 if (vimvars[VV_EXCEPTION].vv_str == NULL)
9016 { 9016 {
9017 prepare_assert_error(&ga); 9017 prepare_assert_error(&ga);
9018 ga_concat(&ga, (char_u *)"v:exception is not set"); 9018 ga_concat(&ga, (char_u *)"v:exception is not set");
9034 } 9034 }
9035 9035
9036 int 9036 int
9037 assert_beeps(typval_T *argvars) 9037 assert_beeps(typval_T *argvars)
9038 { 9038 {
9039 char_u *cmd = get_tv_string_chk(&argvars[0]); 9039 char_u *cmd = tv_get_string_chk(&argvars[0]);
9040 garray_T ga; 9040 garray_T ga;
9041 int ret = 0; 9041 int ret = 0;
9042 9042
9043 called_vim_beep = FALSE; 9043 called_vim_beep = FALSE;
9044 suppress_errthrow = TRUE; 9044 suppress_errthrow = TRUE;
9060 } 9060 }
9061 9061
9062 int 9062 int
9063 assert_fails(typval_T *argvars) 9063 assert_fails(typval_T *argvars)
9064 { 9064 {
9065 char_u *cmd = get_tv_string_chk(&argvars[0]); 9065 char_u *cmd = tv_get_string_chk(&argvars[0]);
9066 garray_T ga; 9066 garray_T ga;
9067 int ret = 0; 9067 int ret = 0;
9068 char_u numbuf[NUMBUFLEN]; 9068 char_u numbuf[NUMBUFLEN];
9069 char_u *tofree; 9069 char_u *tofree;
9070 9070
9089 ret = 1; 9089 ret = 1;
9090 } 9090 }
9091 else if (argvars[1].v_type != VAR_UNKNOWN) 9091 else if (argvars[1].v_type != VAR_UNKNOWN)
9092 { 9092 {
9093 char_u buf[NUMBUFLEN]; 9093 char_u buf[NUMBUFLEN];
9094 char *error = (char *)get_tv_string_buf_chk(&argvars[1], buf); 9094 char *error = (char *)tv_get_string_buf_chk(&argvars[1], buf);
9095 9095
9096 if (error == NULL 9096 if (error == NULL
9097 || strstr((char *)vimvars[VV_ERRMSG].vv_str, error) == NULL) 9097 || strstr((char *)vimvars[VV_ERRMSG].vv_str, error) == NULL)
9098 { 9098 {
9099 prepare_assert_error(&ga); 9099 prepare_assert_error(&ga);
9323 float_T f1, f2; 9323 float_T f1, f2;
9324 9324
9325 if (typ1->v_type == VAR_FLOAT) 9325 if (typ1->v_type == VAR_FLOAT)
9326 f1 = typ1->vval.v_float; 9326 f1 = typ1->vval.v_float;
9327 else 9327 else
9328 f1 = get_tv_number(typ1); 9328 f1 = tv_get_number(typ1);
9329 if (typ2->v_type == VAR_FLOAT) 9329 if (typ2->v_type == VAR_FLOAT)
9330 f2 = typ2->vval.v_float; 9330 f2 = typ2->vval.v_float;
9331 else 9331 else
9332 f2 = get_tv_number(typ2); 9332 f2 = tv_get_number(typ2);
9333 n1 = FALSE; 9333 n1 = FALSE;
9334 switch (type) 9334 switch (type)
9335 { 9335 {
9336 case TYPE_EQUAL: n1 = (f1 == f2); break; 9336 case TYPE_EQUAL: n1 = (f1 == f2); break;
9337 case TYPE_NEQUAL: n1 = (f1 != f2); break; 9337 case TYPE_NEQUAL: n1 = (f1 != f2); break;
9351 * When using "=~" or "!~", always compare as string. 9351 * When using "=~" or "!~", always compare as string.
9352 */ 9352 */
9353 else if ((typ1->v_type == VAR_NUMBER || typ2->v_type == VAR_NUMBER) 9353 else if ((typ1->v_type == VAR_NUMBER || typ2->v_type == VAR_NUMBER)
9354 && type != TYPE_MATCH && type != TYPE_NOMATCH) 9354 && type != TYPE_MATCH && type != TYPE_NOMATCH)
9355 { 9355 {
9356 n1 = get_tv_number(typ1); 9356 n1 = tv_get_number(typ1);
9357 n2 = get_tv_number(typ2); 9357 n2 = tv_get_number(typ2);
9358 switch (type) 9358 switch (type)
9359 { 9359 {
9360 case TYPE_EQUAL: n1 = (n1 == n2); break; 9360 case TYPE_EQUAL: n1 = (n1 == n2); break;
9361 case TYPE_NEQUAL: n1 = (n1 != n2); break; 9361 case TYPE_NEQUAL: n1 = (n1 != n2); break;
9362 case TYPE_GREATER: n1 = (n1 > n2); break; 9362 case TYPE_GREATER: n1 = (n1 > n2); break;
9368 case TYPE_NOMATCH: break; /* avoid gcc warning */ 9368 case TYPE_NOMATCH: break; /* avoid gcc warning */
9369 } 9369 }
9370 } 9370 }
9371 else 9371 else
9372 { 9372 {
9373 s1 = get_tv_string_buf(typ1, buf1); 9373 s1 = tv_get_string_buf(typ1, buf1);
9374 s2 = get_tv_string_buf(typ2, buf2); 9374 s2 = tv_get_string_buf(typ2, buf2);
9375 if (type != TYPE_MATCH && type != TYPE_NOMATCH) 9375 if (type != TYPE_MATCH && type != TYPE_NOMATCH)
9376 i = ic ? MB_STRICMP(s1, s2) : STRCMP(s1, s2); 9376 i = ic ? MB_STRICMP(s1, s2) : STRCMP(s1, s2);
9377 else 9377 else
9378 i = 0; 9378 i = 0;
9379 n1 = FALSE; 9379 n1 = FALSE;
10218 else 10218 else
10219 { 10219 {
10220 int error = FALSE; 10220 int error = FALSE;
10221 10221
10222 /* filter(): when expr is zero remove the item */ 10222 /* filter(): when expr is zero remove the item */
10223 *remp = (get_tv_number_chk(&rettv, &error) == 0); 10223 *remp = (tv_get_number_chk(&rettv, &error) == 0);
10224 clear_tv(&rettv); 10224 clear_tv(&rettv);
10225 /* On type error, nothing has been removed; return FAIL to stop the 10225 /* On type error, nothing has been removed; return FAIL to stop the
10226 * loop. The error message was given by get_tv_number_chk(). */ 10226 * loop. The error message was given by tv_get_number_chk(). */
10227 if (error) 10227 if (error)
10228 goto theend; 10228 goto theend;
10229 } 10229 }
10230 retval = OK; 10230 retval = OK;
10231 theend: 10231 theend: