Mercurial > vim

comparison src/eval.c @ 6773:eb4b705a5d6a v7.4.708

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
patch 7.4.708 Problem: gettext() is called too often. Solution: Do not call gettext() for messages until they are actually used. (idea by Yasuhiro Matsumoto)
author Bram Moolenaar <bram@vim.org>
date Tue, 21 Apr 2015 16:49:05 +0200
parents 203888fa7192
children 1805e45ce4d6
comparison
equal deleted inserted replaced
6772:38118242a25d 6773:eb4b705a5d6a
800 static void vars_clear_ext __ARGS((hashtab_T *ht, int free_val)); 800 static void vars_clear_ext __ARGS((hashtab_T *ht, int free_val));
801 static void delete_var __ARGS((hashtab_T *ht, hashitem_T *hi)); 801 static void delete_var __ARGS((hashtab_T *ht, hashitem_T *hi));
802 static void list_one_var __ARGS((dictitem_T *v, char_u *prefix, int *first)); 802 static void list_one_var __ARGS((dictitem_T *v, char_u *prefix, int *first));
803 static void list_one_var_a __ARGS((char_u *prefix, char_u *name, int type, char_u *string, int *first)); 803 static void list_one_var_a __ARGS((char_u *prefix, char_u *name, int type, char_u *string, int *first));
804 static void set_var __ARGS((char_u *name, typval_T *varp, int copy)); 804 static void set_var __ARGS((char_u *name, typval_T *varp, int copy));
805 static int var_check_ro __ARGS((int flags, char_u *name)); 805 static int var_check_ro __ARGS((int flags, char_u *name, int use_gettext));
806 static int var_check_fixed __ARGS((int flags, char_u *name)); 806 static int var_check_fixed __ARGS((int flags, char_u *name, int use_gettext));
807 static int var_check_func_name __ARGS((char_u *name, int new_var)); 807 static int var_check_func_name __ARGS((char_u *name, int new_var));
808 static int valid_varname __ARGS((char_u *varname)); 808 static int valid_varname __ARGS((char_u *varname));
809 static int tv_check_lock __ARGS((int lock, char_u *name)); 809 static int tv_check_lock __ARGS((int lock, char_u *name, int use_gettext));
810 static int item_copy __ARGS((typval_T *from, typval_T *to, int deep, int copyID)); 810 static int item_copy __ARGS((typval_T *from, typval_T *to, int deep, int copyID));
811 static char_u *find_option_end __ARGS((char_u **arg, int *opt_flags)); 811 static char_u *find_option_end __ARGS((char_u **arg, int *opt_flags));
812 static char_u *trans_function_name __ARGS((char_u **pp, int skip, int flags, funcdict_T *fd)); 812 static char_u *trans_function_name __ARGS((char_u **pp, int skip, int flags, funcdict_T *fd));
813 static int eval_fname_script __ARGS((char_u *p)); 813 static int eval_fname_script __ARGS((char_u *p));
814 static int eval_fname_sid __ARGS((char_u *p)); 814 static int eval_fname_sid __ARGS((char_u *p));
2806 if (lp->ll_newkey == NULL) 2806 if (lp->ll_newkey == NULL)
2807 p = NULL; 2807 p = NULL;
2808 break; 2808 break;
2809 } 2809 }
2810 /* existing variable, need to check if it can be changed */ 2810 /* existing variable, need to check if it can be changed */
2811 else if (var_check_ro(lp->ll_di->di_flags, name)) 2811 else if (var_check_ro(lp->ll_di->di_flags, name, FALSE))
2812 return NULL; 2812 return NULL;
2813 2813
2814 if (len == -1) 2814 if (len == -1)
2815 clear_tv(&var1); 2815 clear_tv(&var1);
2816 lp->ll_tv = &lp->ll_di->di_tv; 2816 lp->ll_tv = &lp->ll_di->di_tv;
2939 *endp = cc; 2939 *endp = cc;
2940 } 2940 }
2941 } 2941 }
2942 else if (tv_check_lock(lp->ll_newkey == NULL 2942 else if (tv_check_lock(lp->ll_newkey == NULL
2943 ? lp->ll_tv->v_lock 2943 ? lp->ll_tv->v_lock
2944 : lp->ll_tv->vval.v_dict->dv_lock, lp->ll_name)) 2944 : lp->ll_tv->vval.v_dict->dv_lock, lp->ll_name, FALSE))
2945 ; 2945 ;
2946 else if (lp->ll_range) 2946 else if (lp->ll_range)
2947 { 2947 {
2948 listitem_T *ll_li = lp->ll_li; 2948 listitem_T *ll_li = lp->ll_li;
2949 int ll_n1 = lp->ll_n1; 2949 int ll_n1 = lp->ll_n1;
2951 /* 2951 /*
2952 * Check whether any of the list items is locked 2952 * Check whether any of the list items is locked
2953 */ 2953 */
2954 for (ri = rettv->vval.v_list->lv_first; ri != NULL && ll_li != NULL; ) 2954 for (ri = rettv->vval.v_list->lv_first; ri != NULL && ll_li != NULL; )
2955 { 2955 {
2956 if (tv_check_lock(ll_li->li_tv.v_lock, lp->ll_name)) 2956 if (tv_check_lock(ll_li->li_tv.v_lock, lp->ll_name, FALSE))
2957 return; 2957 return;
2958 ri = ri->li_next; 2958 ri = ri->li_next;
2959 if (ri == NULL || (!lp->ll_empty2 && lp->ll_n2 == ll_n1)) 2959 if (ri == NULL || (!lp->ll_empty2 && lp->ll_n2 == ll_n1))
2960 break; 2960 break;
2961 ll_li = ll_li->li_next; 2961 ll_li = ll_li->li_next;
3657 else if (do_unlet(lp->ll_name, forceit) == FAIL) 3657 else if (do_unlet(lp->ll_name, forceit) == FAIL)
3658 ret = FAIL; 3658 ret = FAIL;
3659 *name_end = cc; 3659 *name_end = cc;
3660 } 3660 }
3661 else if ((lp->ll_list != NULL 3661 else if ((lp->ll_list != NULL
3662 && tv_check_lock(lp->ll_list->lv_lock, lp->ll_name)) 3662 && tv_check_lock(lp->ll_list->lv_lock, lp->ll_name, FALSE))
3663 || (lp->ll_dict != NULL 3663 || (lp->ll_dict != NULL
3664 && tv_check_lock(lp->ll_dict->dv_lock, lp->ll_name))) 3664 && tv_check_lock(lp->ll_dict->dv_lock, lp->ll_name, FALSE)))
3665 return FAIL; 3665 return FAIL;
3666 else if (lp->ll_range) 3666 else if (lp->ll_range)
3667 { 3667 {
3668 listitem_T *li; 3668 listitem_T *li;
3669 listitem_T *ll_li = lp->ll_li; 3669 listitem_T *ll_li = lp->ll_li;
3670 int ll_n1 = lp->ll_n1; 3670 int ll_n1 = lp->ll_n1;
3671 3671
3672 while (ll_li != NULL && (lp->ll_empty2 || lp->ll_n2 >= ll_n1)) 3672 while (ll_li != NULL && (lp->ll_empty2 || lp->ll_n2 >= ll_n1))
3673 { 3673 {
3674 li = ll_li->li_next; 3674 li = ll_li->li_next;
3675 if (tv_check_lock(ll_li->li_tv.v_lock, lp->ll_name)) 3675 if (tv_check_lock(ll_li->li_tv.v_lock, lp->ll_name, FALSE))
3676 return FAIL; 3676 return FAIL;
3677 ll_li = li; 3677 ll_li = li;
3678 ++ll_n1; 3678 ++ll_n1;
3679 } 3679 }
3680 3680
3730 } 3730 }
3731 hi = hash_find(ht, varname); 3731 hi = hash_find(ht, varname);
3732 if (!HASHITEM_EMPTY(hi)) 3732 if (!HASHITEM_EMPTY(hi))
3733 { 3733 {
3734 di = HI2DI(hi); 3734 di = HI2DI(hi);
3735 if (var_check_fixed(di->di_flags, name) 3735 if (var_check_fixed(di->di_flags, name, FALSE)
3736 || var_check_ro(di->di_flags, name) 3736 || var_check_ro(di->di_flags, name, FALSE)
3737 || tv_check_lock(d->dv_lock, name)) 3737 || tv_check_lock(d->dv_lock, name, FALSE))
3738 return FAIL; 3738 return FAIL;
3739 delete_var(ht, hi); 3739 delete_var(ht, hi);
3740 return OK; 3740 return OK;
3741 } 3741 }
3742 } 3742 }
8935 8935
8936 rettv->vval.v_number = 1; /* Default: Failed */ 8936 rettv->vval.v_number = 1; /* Default: Failed */
8937 if (argvars[0].v_type == VAR_LIST) 8937 if (argvars[0].v_type == VAR_LIST)
8938 { 8938 {
8939 if ((l = argvars[0].vval.v_list) != NULL 8939 if ((l = argvars[0].vval.v_list) != NULL
8940 && !tv_check_lock(l->lv_lock, (char_u *)_("add() argument")) 8940 && !tv_check_lock(l->lv_lock,
8941 (char_u *)N_("add() argument"), TRUE)
8941 && list_append_tv(l, &argvars[1]) == OK) 8942 && list_append_tv(l, &argvars[1]) == OK)
8942 copy_tv(&argvars[0], rettv); 8943 copy_tv(&argvars[0], rettv);
8943 } 8944 }
8944 else 8945 else
8945 EMSG(_(e_listreq)); 8946 EMSG(_(e_listreq));
10497 char_u *action; 10498 char_u *action;
10498 { 10499 {
10499 dictitem_T *di1; 10500 dictitem_T *di1;
10500 hashitem_T *hi2; 10501 hashitem_T *hi2;
10501 int todo; 10502 int todo;
10502 char *arg_errmsg = N_("extend() argument"); 10503 char_u *arg_errmsg = (char_u *)N_("extend() argument");
10503 10504
10504 todo = (int)d2->dv_hashtab.ht_used; 10505 todo = (int)d2->dv_hashtab.ht_used;
10505 for (hi2 = d2->dv_hashtab.ht_array; todo > 0; ++hi2) 10506 for (hi2 = d2->dv_hashtab.ht_array; todo > 0; ++hi2)
10506 { 10507 {
10507 if (!HASHITEM_EMPTY(hi2)) 10508 if (!HASHITEM_EMPTY(hi2))
10532 EMSG2(_("E737: Key already exists: %s"), hi2->hi_key); 10533 EMSG2(_("E737: Key already exists: %s"), hi2->hi_key);
10533 break; 10534 break;
10534 } 10535 }
10535 else if (*action == 'f' && HI2DI(hi2) != di1) 10536 else if (*action == 'f' && HI2DI(hi2) != di1)
10536 { 10537 {
10537 if (tv_check_lock(di1->di_tv.v_lock, (char_u *)_(arg_errmsg)) 10538 if (tv_check_lock(di1->di_tv.v_lock, arg_errmsg, TRUE)
10538 || var_check_ro(di1->di_flags, (char_u *)_(arg_errmsg))) 10539 || var_check_ro(di1->di_flags, arg_errmsg, TRUE))
10539 break; 10540 break;
10540 clear_tv(&di1->di_tv); 10541 clear_tv(&di1->di_tv);
10541 copy_tv(&HI2DI(hi2)->di_tv, &di1->di_tv); 10542 copy_tv(&HI2DI(hi2)->di_tv, &di1->di_tv);
10542 } 10543 }
10543 } 10544 }
10551 static void 10552 static void
10552 f_extend(argvars, rettv) 10553 f_extend(argvars, rettv)
10553 typval_T *argvars; 10554 typval_T *argvars;
10554 typval_T *rettv; 10555 typval_T *rettv;
10555 { 10556 {
10556 char *arg_errmsg = N_("extend() argument"); 10557 char_u *arg_errmsg = (char_u *)N_("extend() argument");
10557 10558
10558 if (argvars[0].v_type == VAR_LIST && argvars[1].v_type == VAR_LIST) 10559 if (argvars[0].v_type == VAR_LIST && argvars[1].v_type == VAR_LIST)
10559 { 10560 {
10560 list_T *l1, *l2; 10561 list_T *l1, *l2;
10561 listitem_T *item; 10562 listitem_T *item;
10562 long before; 10563 long before;
10563 int error = FALSE; 10564 int error = FALSE;
10564 10565
10565 l1 = argvars[0].vval.v_list; 10566 l1 = argvars[0].vval.v_list;
10566 l2 = argvars[1].vval.v_list; 10567 l2 = argvars[1].vval.v_list;
10567 if (l1 != NULL && !tv_check_lock(l1->lv_lock, (char_u *)_(arg_errmsg)) 10568 if (l1 != NULL && !tv_check_lock(l1->lv_lock, arg_errmsg, TRUE)
10568 && l2 != NULL) 10569 && l2 != NULL)
10569 { 10570 {
10570 if (argvars[2].v_type != VAR_UNKNOWN) 10571 if (argvars[2].v_type != VAR_UNKNOWN)
10571 { 10572 {
10572 before = get_tv_number_chk(&argvars[2], &error); 10573 before = get_tv_number_chk(&argvars[2], &error);
10598 char_u *action; 10599 char_u *action;
10599 int i; 10600 int i;
10600 10601
10601 d1 = argvars[0].vval.v_dict; 10602 d1 = argvars[0].vval.v_dict;
10602 d2 = argvars[1].vval.v_dict; 10603 d2 = argvars[1].vval.v_dict;
10603 if (d1 != NULL && !tv_check_lock(d1->dv_lock, (char_u *)_(arg_errmsg)) 10604 if (d1 != NULL && !tv_check_lock(d1->dv_lock, arg_errmsg, TRUE)
10604 && d2 != NULL) 10605 && d2 != NULL)
10605 { 10606 {
10606 /* Check the third argument. */ 10607 /* Check the third argument. */
10607 if (argvars[2].v_type != VAR_UNKNOWN) 10608 if (argvars[2].v_type != VAR_UNKNOWN)
10608 { 10609 {
10817 typval_T save_val; 10818 typval_T save_val;
10818 typval_T save_key; 10819 typval_T save_key;
10819 int rem; 10820 int rem;
10820 int todo; 10821 int todo;
10821 char_u *ermsg = (char_u *)(map ? "map()" : "filter()"); 10822 char_u *ermsg = (char_u *)(map ? "map()" : "filter()");
10822 char *arg_errmsg = (map ? N_("map() argument") 10823 char_u *arg_errmsg = (char_u *)(map ? N_("map() argument")
10823 : N_("filter() argument")); 10824 : N_("filter() argument"));
10824 int save_did_emsg; 10825 int save_did_emsg;
10825 int idx = 0; 10826 int idx = 0;
10826 10827
10827 if (argvars[0].v_type == VAR_LIST) 10828 if (argvars[0].v_type == VAR_LIST)
10828 { 10829 {
10829 if ((l = argvars[0].vval.v_list) == NULL 10830 if ((l = argvars[0].vval.v_list) == NULL
10830 || (!map && tv_check_lock(l->lv_lock, (char_u *)_(arg_errmsg)))) 10831 || (!map && tv_check_lock(l->lv_lock, arg_errmsg, TRUE)))
10831 return; 10832 return;
10832 } 10833 }
10833 else if (argvars[0].v_type == VAR_DICT) 10834 else if (argvars[0].v_type == VAR_DICT)
10834 { 10835 {
10835 if ((d = argvars[0].vval.v_dict) == NULL 10836 if ((d = argvars[0].vval.v_dict) == NULL
10836 || (!map && tv_check_lock(d->dv_lock, (char_u *)_(arg_errmsg)))) 10837 || (!map && tv_check_lock(d->dv_lock, arg_errmsg, TRUE)))
10837 return; 10838 return;
10838 } 10839 }
10839 else 10840 else
10840 { 10841 {
10841 EMSG2(_(e_listdictarg), ermsg); 10842 EMSG2(_(e_listdictarg), ermsg);
10871 int r; 10872 int r;
10872 10873
10873 --todo; 10874 --todo;
10874 di = HI2DI(hi); 10875 di = HI2DI(hi);
10875 if (map && 10876 if (map &&
10876 (tv_check_lock(di->di_tv.v_lock, 10877 (tv_check_lock(di->di_tv.v_lock, arg_errmsg, TRUE)
10877 (char_u *)_(arg_errmsg)) 10878 || var_check_ro(di->di_flags, arg_errmsg, TRUE)))
10878 || var_check_ro(di->di_flags,
10879 (char_u *)_(arg_errmsg))))
10880 break; 10879 break;
10881 vimvars[VV_KEY].vv_str = vim_strsave(di->di_key); 10880 vimvars[VV_KEY].vv_str = vim_strsave(di->di_key);
10882 r = filter_map_one(&di->di_tv, expr, map, &rem); 10881 r = filter_map_one(&di->di_tv, expr, map, &rem);
10883 clear_tv(&vimvars[VV_KEY].vv_tv); 10882 clear_tv(&vimvars[VV_KEY].vv_tv);
10884 if (r == FAIL || did_emsg) 10883 if (r == FAIL || did_emsg)
10885 break; 10884 break;
10886 if (!map && rem) 10885 if (!map && rem)
10887 { 10886 {
10888 if (var_check_fixed(di->di_flags, 10887 if (var_check_fixed(di->di_flags, arg_errmsg, TRUE)
10889 (char_u *)_(arg_errmsg)) 10888 || var_check_ro(di->di_flags, arg_errmsg, TRUE))
10890 || var_check_ro(di->di_flags,
10891 (char_u *)_(arg_errmsg)))
10892 break; 10889 break;
10893 dictitem_remove(d, di); 10890 dictitem_remove(d, di);
10894 } 10891 }
10895 } 10892 }
10896 } 10893 }
10900 { 10897 {
10901 vimvars[VV_KEY].vv_type = VAR_NUMBER; 10898 vimvars[VV_KEY].vv_type = VAR_NUMBER;
10902 10899
10903 for (li = l->lv_first; li != NULL; li = nli) 10900 for (li = l->lv_first; li != NULL; li = nli)
10904 { 10901 {
10905 if (map && tv_check_lock(li->li_tv.v_lock, 10902 if (map && tv_check_lock(li->li_tv.v_lock, arg_errmsg, TRUE))
10906 (char_u *)_(arg_errmsg)))
10907 break; 10903 break;
10908 nli = li->li_next; 10904 nli = li->li_next;
10909 vimvars[VV_KEY].vv_nr = idx; 10905 vimvars[VV_KEY].vv_nr = idx;
10910 if (filter_map_one(&li->li_tv, expr, map, &rem) == FAIL 10906 if (filter_map_one(&li->li_tv, expr, map, &rem) == FAIL
10911 || did_emsg) 10907 || did_emsg)
13754 int error = FALSE; 13750 int error = FALSE;
13755 13751
13756 if (argvars[0].v_type != VAR_LIST) 13752 if (argvars[0].v_type != VAR_LIST)
13757 EMSG2(_(e_listarg), "insert()"); 13753 EMSG2(_(e_listarg), "insert()");
13758 else if ((l = argvars[0].vval.v_list) != NULL 13754 else if ((l = argvars[0].vval.v_list) != NULL
13759 && !tv_check_lock(l->lv_lock, (char_u *)_("insert() argument"))) 13755 && !tv_check_lock(l->lv_lock, (char_u *)N_("insert() argument"), TRUE))
13760 { 13756 {
13761 if (argvars[2].v_type != VAR_UNKNOWN) 13757 if (argvars[2].v_type != VAR_UNKNOWN)
13762 before = get_tv_number_chk(&argvars[2], &error); 13758 before = get_tv_number_chk(&argvars[2], &error);
13763 if (error) 13759 if (error)
13764 return; /* type error; errmsg already given */ 13760 return; /* type error; errmsg already given */
15835 long idx; 15831 long idx;
15836 long end; 15832 long end;
15837 char_u *key; 15833 char_u *key;
15838 dict_T *d; 15834 dict_T *d;
15839 dictitem_T *di; 15835 dictitem_T *di;
15840 char *arg_errmsg = N_("remove() argument"); 15836 char_u *arg_errmsg = (char_u *)N_("remove() argument");
15841 15837
15842 if (argvars[0].v_type == VAR_DICT) 15838 if (argvars[0].v_type == VAR_DICT)
15843 { 15839 {
15844 if (argvars[2].v_type != VAR_UNKNOWN) 15840 if (argvars[2].v_type != VAR_UNKNOWN)
15845 EMSG2(_(e_toomanyarg), "remove()"); 15841 EMSG2(_(e_toomanyarg), "remove()");
15846 else if ((d = argvars[0].vval.v_dict) != NULL 15842 else if ((d = argvars[0].vval.v_dict) != NULL
15847 && !tv_check_lock(d->dv_lock, (char_u *)_(arg_errmsg))) 15843 && !tv_check_lock(d->dv_lock, arg_errmsg, TRUE))
15848 { 15844 {
15849 key = get_tv_string_chk(&argvars[1]); 15845 key = get_tv_string_chk(&argvars[1]);
15850 if (key != NULL) 15846 if (key != NULL)
15851 { 15847 {
15852 di = dict_find(d, key, -1); 15848 di = dict_find(d, key, -1);
15853 if (di == NULL) 15849 if (di == NULL)
15854 EMSG2(_(e_dictkey), key); 15850 EMSG2(_(e_dictkey), key);
15855 else if (!var_check_fixed(di->di_flags, (char_u *)_(arg_errmsg)) 15851 else if (!var_check_fixed(di->di_flags, arg_errmsg, TRUE)
15856 && !var_check_ro(di->di_flags, 15852 && !var_check_ro(di->di_flags, arg_errmsg, TRUE))
15857 (char_u *)_(arg_errmsg)))
15858 { 15853 {
15859 *rettv = di->di_tv; 15854 *rettv = di->di_tv;
15860 init_tv(&di->di_tv); 15855 init_tv(&di->di_tv);
15861 dictitem_remove(d, di); 15856 dictitem_remove(d, di);
15862 } 15857 }
15864 } 15859 }
15865 } 15860 }
15866 else if (argvars[0].v_type != VAR_LIST) 15861 else if (argvars[0].v_type != VAR_LIST)
15867 EMSG2(_(e_listdictarg), "remove()"); 15862 EMSG2(_(e_listdictarg), "remove()");
15868 else if ((l = argvars[0].vval.v_list) != NULL 15863 else if ((l = argvars[0].vval.v_list) != NULL
15869 && !tv_check_lock(l->lv_lock, (char_u *)_(arg_errmsg))) 15864 && !tv_check_lock(l->lv_lock, arg_errmsg, TRUE))
15870 { 15865 {
15871 int error = FALSE; 15866 int error = FALSE;
15872 15867
15873 idx = get_tv_number_chk(&argvars[1], &error); 15868 idx = get_tv_number_chk(&argvars[1], &error);
15874 if (error) 15869 if (error)
16208 listitem_T *li, *ni; 16203 listitem_T *li, *ni;
16209 16204
16210 if (argvars[0].v_type != VAR_LIST) 16205 if (argvars[0].v_type != VAR_LIST)
16211 EMSG2(_(e_listarg), "reverse()"); 16206 EMSG2(_(e_listarg), "reverse()");
16212 else if ((l = argvars[0].vval.v_list) != NULL 16207 else if ((l = argvars[0].vval.v_list) != NULL
16213 && !tv_check_lock(l->lv_lock, (char_u *)_("reverse() argument"))) 16208 && !tv_check_lock(l->lv_lock,
16209 (char_u *)N_("reverse() argument"), TRUE))
16214 { 16210 {
16215 li = l->lv_last; 16211 li = l->lv_last;
16216 l->lv_first = l->lv_last = NULL; 16212 l->lv_first = l->lv_last = NULL;
16217 l->lv_len = 0; 16213 l->lv_len = 0;
16218 while (li != NULL) 16214 while (li != NULL)
17742 EMSG2(_(e_listarg), sort ? "sort()" : "uniq()"); 17738 EMSG2(_(e_listarg), sort ? "sort()" : "uniq()");
17743 else 17739 else
17744 { 17740 {
17745 l = argvars[0].vval.v_list; 17741 l = argvars[0].vval.v_list;
17746 if (l == NULL || tv_check_lock(l->lv_lock, 17742 if (l == NULL || tv_check_lock(l->lv_lock,
17747 (char_u *)(sort ? _("sort() argument") : _("uniq() argument")))) 17743 (char_u *)(sort ? N_("sort() argument") : N_("uniq() argument")),
17744 TRUE))
17748 return; 17745 return;
17749 rettv->vval.v_list = l; 17746 rettv->vval.v_list = l;
17750 rettv->v_type = VAR_LIST; 17747 rettv->v_type = VAR_LIST;
17751 ++l->lv_refcount; 17748 ++l->lv_refcount;
17752 17749
21454 return; 21451 return;
21455 21452
21456 if (v != NULL) 21453 if (v != NULL)
21457 { 21454 {
21458 /* existing variable, need to clear the value */ 21455 /* existing variable, need to clear the value */
21459 if (var_check_ro(v->di_flags, name) 21456 if (var_check_ro(v->di_flags, name, FALSE)
21460 || tv_check_lock(v->di_tv.v_lock, name)) 21457 || tv_check_lock(v->di_tv.v_lock, name, FALSE))
21461 return; 21458 return;
21462 if (v->di_tv.v_type != tv->v_type 21459 if (v->di_tv.v_type != tv->v_type
21463 && !((v->di_tv.v_type == VAR_STRING 21460 && !((v->di_tv.v_type == VAR_STRING
21464 || v->di_tv.v_type == VAR_NUMBER) 21461 || v->di_tv.v_type == VAR_NUMBER)
21465 && (tv->v_type == VAR_STRING 21462 && (tv->v_type == VAR_STRING
21553 /* 21550 /*
21554 * Return TRUE if di_flags "flags" indicates variable "name" is read-only. 21551 * Return TRUE if di_flags "flags" indicates variable "name" is read-only.
21555 * Also give an error message. 21552 * Also give an error message.
21556 */ 21553 */
21557 static int 21554 static int
21558 var_check_ro(flags, name) 21555 var_check_ro(flags, name, use_gettext)
21559 int flags; 21556 int flags;
21560 char_u *name; 21557 char_u *name;
21558 int use_gettext;
21561 { 21559 {
21562 if (flags & DI_FLAGS_RO) 21560 if (flags & DI_FLAGS_RO)
21563 { 21561 {
21564 EMSG2(_(e_readonlyvar), name); 21562 EMSG2(_(e_readonlyvar), use_gettext ? (char_u *)_(name) : name);
21565 return TRUE; 21563 return TRUE;
21566 } 21564 }
21567 if ((flags & DI_FLAGS_RO_SBX) && sandbox) 21565 if ((flags & DI_FLAGS_RO_SBX) && sandbox)
21568 { 21566 {
21569 EMSG2(_(e_readonlysbx), name); 21567 EMSG2(_(e_readonlysbx), use_gettext ? (char_u *)_(name) : name);
21570 return TRUE; 21568 return TRUE;
21571 } 21569 }
21572 return FALSE; 21570 return FALSE;
21573 } 21571 }
21574 21572
21575 /* 21573 /*
21576 * Return TRUE if di_flags "flags" indicates variable "name" is fixed. 21574 * Return TRUE if di_flags "flags" indicates variable "name" is fixed.
21577 * Also give an error message. 21575 * Also give an error message.
21578 */ 21576 */
21579 static int 21577 static int
21580 var_check_fixed(flags, name) 21578 var_check_fixed(flags, name, use_gettext)
21581 int flags; 21579 int flags;
21582 char_u *name; 21580 char_u *name;
21581 int use_gettext;
21583 { 21582 {
21584 if (flags & DI_FLAGS_FIX) 21583 if (flags & DI_FLAGS_FIX)
21585 { 21584 {
21586 EMSG2(_("E795: Cannot delete variable %s"), name); 21585 EMSG2(_("E795: Cannot delete variable %s"),
21586 use_gettext ? (char_u *)_(name) : name);
21587 return TRUE; 21587 return TRUE;
21588 } 21588 }
21589 return FALSE; 21589 return FALSE;
21590 } 21590 }
21591 21591
21639 return TRUE; 21639 return TRUE;
21640 } 21640 }
21641 21641
21642 /* 21642 /*
21643 * Return TRUE if typeval "tv" is set to be locked (immutable). 21643 * Return TRUE if typeval "tv" is set to be locked (immutable).
21644 * Also give an error message, using "name". 21644 * Also give an error message, using "name" or _("name") when use_gettext is
21645 * TRUE.
21645 */ 21646 */
21646 static int 21647 static int
21647 tv_check_lock(lock, name) 21648 tv_check_lock(lock, name, use_gettext)
21648 int lock; 21649 int lock;
21649 char_u *name; 21650 char_u *name;
21651 int use_gettext;
21650 { 21652 {
21651 if (lock & VAR_LOCKED) 21653 if (lock & VAR_LOCKED)
21652 { 21654 {
21653 EMSG2(_("E741: Value is locked: %s"), 21655 EMSG2(_("E741: Value is locked: %s"),
21654 name == NULL ? (char_u *)_("Unknown") : name); 21656 name == NULL ? (char_u *)_("Unknown")
21657 : use_gettext ? (char_u *)_(name)
21658 : name);
21655 return TRUE; 21659 return TRUE;
21656 } 21660 }
21657 if (lock & VAR_FIXED) 21661 if (lock & VAR_FIXED)
21658 { 21662 {
21659 EMSG2(_("E742: Cannot change value of %s"), 21663 EMSG2(_("E742: Cannot change value of %s"),
21660 name == NULL ? (char_u *)_("Unknown") : name); 21664 name == NULL ? (char_u *)_("Unknown")
21665 : use_gettext ? (char_u *)_(name)
21666 : name);
21661 return TRUE; 21667 return TRUE;
21662 } 21668 }
21663 return FALSE; 21669 return FALSE;
21664 } 21670 }
21665 21671
22593 goto erret; 22599 goto erret;
22594 } 22600 }
22595 if (fudi.fd_di == NULL) 22601 if (fudi.fd_di == NULL)
22596 { 22602 {
22597 /* Can't add a function to a locked dictionary */ 22603 /* Can't add a function to a locked dictionary */
22598 if (tv_check_lock(fudi.fd_dict->dv_lock, eap->arg)) 22604 if (tv_check_lock(fudi.fd_dict->dv_lock, eap->arg, FALSE))
22599 goto erret; 22605 goto erret;
22600 } 22606 }
22601 /* Can't change an existing function if it is locked */ 22607 /* Can't change an existing function if it is locked */
22602 else if (tv_check_lock(fudi.fd_di->di_tv.v_lock, eap->arg)) 22608 else if (tv_check_lock(fudi.fd_di->di_tv.v_lock, eap->arg, FALSE))
22603 goto erret; 22609 goto erret;
22604 22610
22605 /* Give the function a sequential number. Can only be used with a 22611 /* Give the function a sequential number. Can only be used with a
22606 * Funcref! */ 22612 * Funcref! */
22607 vim_free(name); 22613 vim_free(name);