Mercurial > vim

comparison src/evalfunc.c @ 17970:684a15da9929 v8.1.1981

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
patch 8.1.1981: the evalfunc.c file is too big Commit: https://github.com/vim/vim/commit/08c308aeb5e7dfa18fa61f261b0bff79517a4883 Author: Bram Moolenaar <Bram@vim.org> Date: Wed Sep 4 17:48:15 2019 +0200 patch 8.1.1981: the evalfunc.c file is too big Problem: The evalfunc.c file is too big. Solution: Move undo functions to undo.c. Move cmdline functions to ex_getln.c. Move some container functions to list.c.
author Bram Moolenaar <Bram@vim.org>
date Wed, 04 Sep 2019 18:00:03 +0200
parents 46f95606b9ec
children a170c48e0f91
comparison
equal deleted inserted replaced
17969:bfc33cda9075 17970:684a15da9929
22 22
23 #ifdef MACOS_X 23 #ifdef MACOS_X
24 # include <time.h> // for time_t 24 # include <time.h> // for time_t
25 #endif 25 #endif
26 26
27 static char *e_listblobarg = N_("E899: Argument of %s must be a List or Blob");
28
29 #ifdef FEAT_FLOAT 27 #ifdef FEAT_FLOAT
30 static void f_abs(typval_T *argvars, typval_T *rettv); 28 static void f_abs(typval_T *argvars, typval_T *rettv);
31 static void f_acos(typval_T *argvars, typval_T *rettv); 29 static void f_acos(typval_T *argvars, typval_T *rettv);
32 #endif 30 #endif
33 static void f_add(typval_T *argvars, typval_T *rettv);
34 static void f_and(typval_T *argvars, typval_T *rettv); 31 static void f_and(typval_T *argvars, typval_T *rettv);
35 static void f_append(typval_T *argvars, typval_T *rettv); 32 static void f_append(typval_T *argvars, typval_T *rettv);
36 static void f_appendbufline(typval_T *argvars, typval_T *rettv); 33 static void f_appendbufline(typval_T *argvars, typval_T *rettv);
37 #ifdef FEAT_FLOAT 34 #ifdef FEAT_FLOAT
38 static void f_asin(typval_T *argvars, typval_T *rettv); 35 static void f_asin(typval_T *argvars, typval_T *rettv);
71 static void f_copy(typval_T *argvars, typval_T *rettv); 68 static void f_copy(typval_T *argvars, typval_T *rettv);
72 #ifdef FEAT_FLOAT 69 #ifdef FEAT_FLOAT
73 static void f_cos(typval_T *argvars, typval_T *rettv); 70 static void f_cos(typval_T *argvars, typval_T *rettv);
74 static void f_cosh(typval_T *argvars, typval_T *rettv); 71 static void f_cosh(typval_T *argvars, typval_T *rettv);
75 #endif 72 #endif
76 static void f_count(typval_T *argvars, typval_T *rettv);
77 static void f_cscope_connection(typval_T *argvars, typval_T *rettv); 73 static void f_cscope_connection(typval_T *argvars, typval_T *rettv);
78 static void f_cursor(typval_T *argsvars, typval_T *rettv); 74 static void f_cursor(typval_T *argsvars, typval_T *rettv);
79 #ifdef MSWIN 75 #ifdef MSWIN
80 static void f_debugbreak(typval_T *argvars, typval_T *rettv); 76 static void f_debugbreak(typval_T *argvars, typval_T *rettv);
81 #endif 77 #endif
94 #ifdef FEAT_FLOAT 90 #ifdef FEAT_FLOAT
95 static void f_exp(typval_T *argvars, typval_T *rettv); 91 static void f_exp(typval_T *argvars, typval_T *rettv);
96 #endif 92 #endif
97 static void f_expand(typval_T *argvars, typval_T *rettv); 93 static void f_expand(typval_T *argvars, typval_T *rettv);
98 static void f_expandcmd(typval_T *argvars, typval_T *rettv); 94 static void f_expandcmd(typval_T *argvars, typval_T *rettv);
99 static void f_extend(typval_T *argvars, typval_T *rettv);
100 static void f_feedkeys(typval_T *argvars, typval_T *rettv); 95 static void f_feedkeys(typval_T *argvars, typval_T *rettv);
101 #ifdef FEAT_FLOAT 96 #ifdef FEAT_FLOAT
102 static void f_float2nr(typval_T *argvars, typval_T *rettv); 97 static void f_float2nr(typval_T *argvars, typval_T *rettv);
103 static void f_floor(typval_T *argvars, typval_T *rettv); 98 static void f_floor(typval_T *argvars, typval_T *rettv);
104 static void f_fmod(typval_T *argvars, typval_T *rettv); 99 static void f_fmod(typval_T *argvars, typval_T *rettv);
113 static void f_getbufline(typval_T *argvars, typval_T *rettv); 108 static void f_getbufline(typval_T *argvars, typval_T *rettv);
114 static void f_getchangelist(typval_T *argvars, typval_T *rettv); 109 static void f_getchangelist(typval_T *argvars, typval_T *rettv);
115 static void f_getchar(typval_T *argvars, typval_T *rettv); 110 static void f_getchar(typval_T *argvars, typval_T *rettv);
116 static void f_getcharmod(typval_T *argvars, typval_T *rettv); 111 static void f_getcharmod(typval_T *argvars, typval_T *rettv);
117 static void f_getcharsearch(typval_T *argvars, typval_T *rettv); 112 static void f_getcharsearch(typval_T *argvars, typval_T *rettv);
118 static void f_getcmdline(typval_T *argvars, typval_T *rettv);
119 static void f_getcmdpos(typval_T *argvars, typval_T *rettv);
120 static void f_getcmdtype(typval_T *argvars, typval_T *rettv);
121 static void f_getcmdwintype(typval_T *argvars, typval_T *rettv); 113 static void f_getcmdwintype(typval_T *argvars, typval_T *rettv);
122 static void f_getenv(typval_T *argvars, typval_T *rettv); 114 static void f_getenv(typval_T *argvars, typval_T *rettv);
123 static void f_getfontname(typval_T *argvars, typval_T *rettv); 115 static void f_getfontname(typval_T *argvars, typval_T *rettv);
124 static void f_getjumplist(typval_T *argvars, typval_T *rettv); 116 static void f_getjumplist(typval_T *argvars, typval_T *rettv);
125 static void f_getline(typval_T *argvars, typval_T *rettv); 117 static void f_getline(typval_T *argvars, typval_T *rettv);
147 static void f_inputdialog(typval_T *argvars, typval_T *rettv); 139 static void f_inputdialog(typval_T *argvars, typval_T *rettv);
148 static void f_inputlist(typval_T *argvars, typval_T *rettv); 140 static void f_inputlist(typval_T *argvars, typval_T *rettv);
149 static void f_inputrestore(typval_T *argvars, typval_T *rettv); 141 static void f_inputrestore(typval_T *argvars, typval_T *rettv);
150 static void f_inputsave(typval_T *argvars, typval_T *rettv); 142 static void f_inputsave(typval_T *argvars, typval_T *rettv);
151 static void f_inputsecret(typval_T *argvars, typval_T *rettv); 143 static void f_inputsecret(typval_T *argvars, typval_T *rettv);
152 static void f_insert(typval_T *argvars, typval_T *rettv);
153 static void f_invert(typval_T *argvars, typval_T *rettv); 144 static void f_invert(typval_T *argvars, typval_T *rettv);
154 static void f_islocked(typval_T *argvars, typval_T *rettv); 145 static void f_islocked(typval_T *argvars, typval_T *rettv);
155 #if defined(FEAT_FLOAT) && defined(HAVE_MATH_H) 146 #if defined(FEAT_FLOAT) && defined(HAVE_MATH_H)
156 static void f_isinf(typval_T *argvars, typval_T *rettv); 147 static void f_isinf(typval_T *argvars, typval_T *rettv);
157 static void f_isnan(typval_T *argvars, typval_T *rettv); 148 static void f_isnan(typval_T *argvars, typval_T *rettv);
219 static void f_remote_foreground(typval_T *argvars, typval_T *rettv); 210 static void f_remote_foreground(typval_T *argvars, typval_T *rettv);
220 static void f_remote_peek(typval_T *argvars, typval_T *rettv); 211 static void f_remote_peek(typval_T *argvars, typval_T *rettv);
221 static void f_remote_read(typval_T *argvars, typval_T *rettv); 212 static void f_remote_read(typval_T *argvars, typval_T *rettv);
222 static void f_remote_send(typval_T *argvars, typval_T *rettv); 213 static void f_remote_send(typval_T *argvars, typval_T *rettv);
223 static void f_remote_startserver(typval_T *argvars, typval_T *rettv); 214 static void f_remote_startserver(typval_T *argvars, typval_T *rettv);
224 static void f_remove(typval_T *argvars, typval_T *rettv);
225 static void f_rename(typval_T *argvars, typval_T *rettv); 215 static void f_rename(typval_T *argvars, typval_T *rettv);
226 static void f_repeat(typval_T *argvars, typval_T *rettv); 216 static void f_repeat(typval_T *argvars, typval_T *rettv);
227 static void f_reverse(typval_T *argvars, typval_T *rettv);
228 #ifdef FEAT_FLOAT 217 #ifdef FEAT_FLOAT
229 static void f_round(typval_T *argvars, typval_T *rettv); 218 static void f_round(typval_T *argvars, typval_T *rettv);
230 #endif 219 #endif
231 #ifdef FEAT_RUBY 220 #ifdef FEAT_RUBY
232 static void f_rubyeval(typval_T *argvars, typval_T *rettv); 221 static void f_rubyeval(typval_T *argvars, typval_T *rettv);
244 static void f_searchpos(typval_T *argvars, typval_T *rettv); 233 static void f_searchpos(typval_T *argvars, typval_T *rettv);
245 static void f_server2client(typval_T *argvars, typval_T *rettv); 234 static void f_server2client(typval_T *argvars, typval_T *rettv);
246 static void f_serverlist(typval_T *argvars, typval_T *rettv); 235 static void f_serverlist(typval_T *argvars, typval_T *rettv);
247 static void f_setbufline(typval_T *argvars, typval_T *rettv); 236 static void f_setbufline(typval_T *argvars, typval_T *rettv);
248 static void f_setcharsearch(typval_T *argvars, typval_T *rettv); 237 static void f_setcharsearch(typval_T *argvars, typval_T *rettv);
249 static void f_setcmdpos(typval_T *argvars, typval_T *rettv);
250 static void f_setenv(typval_T *argvars, typval_T *rettv); 238 static void f_setenv(typval_T *argvars, typval_T *rettv);
251 static void f_setfperm(typval_T *argvars, typval_T *rettv); 239 static void f_setfperm(typval_T *argvars, typval_T *rettv);
252 static void f_setline(typval_T *argvars, typval_T *rettv); 240 static void f_setline(typval_T *argvars, typval_T *rettv);
253 static void f_setpos(typval_T *argvars, typval_T *rettv); 241 static void f_setpos(typval_T *argvars, typval_T *rettv);
254 static void f_setreg(typval_T *argvars, typval_T *rettv); 242 static void f_setreg(typval_T *argvars, typval_T *rettv);
318 static void f_trim(typval_T *argvars, typval_T *rettv); 306 static void f_trim(typval_T *argvars, typval_T *rettv);
319 #ifdef FEAT_FLOAT 307 #ifdef FEAT_FLOAT
320 static void f_trunc(typval_T *argvars, typval_T *rettv); 308 static void f_trunc(typval_T *argvars, typval_T *rettv);
321 #endif 309 #endif
322 static void f_type(typval_T *argvars, typval_T *rettv); 310 static void f_type(typval_T *argvars, typval_T *rettv);
323 static void f_undofile(typval_T *argvars, typval_T *rettv);
324 static void f_undotree(typval_T *argvars, typval_T *rettv);
325 static void f_virtcol(typval_T *argvars, typval_T *rettv); 311 static void f_virtcol(typval_T *argvars, typval_T *rettv);
326 static void f_visualmode(typval_T *argvars, typval_T *rettv); 312 static void f_visualmode(typval_T *argvars, typval_T *rettv);
327 static void f_wildmenumode(typval_T *argvars, typval_T *rettv); 313 static void f_wildmenumode(typval_T *argvars, typval_T *rettv);
328 static void f_win_execute(typval_T *argvars, typval_T *rettv); 314 static void f_win_execute(typval_T *argvars, typval_T *rettv);
329 static void f_win_findbuf(typval_T *argvars, typval_T *rettv); 315 static void f_win_findbuf(typval_T *argvars, typval_T *rettv);
1216 rettv->vval.v_float = 0.0; 1202 rettv->vval.v_float = 0.0;
1217 } 1203 }
1218 #endif 1204 #endif
1219 1205
1220 /* 1206 /*
1221 * "add(list, item)" function
1222 */
1223 static void
1224 f_add(typval_T *argvars, typval_T *rettv)
1225 {
1226 list_T *l;
1227 blob_T *b;
1228
1229 rettv->vval.v_number = 1; /* Default: Failed */
1230 if (argvars[0].v_type == VAR_LIST)
1231 {
1232 if ((l = argvars[0].vval.v_list) != NULL
1233 && !var_check_lock(l->lv_lock,
1234 (char_u *)N_("add() argument"), TRUE)
1235 && list_append_tv(l, &argvars[1]) == OK)
1236 copy_tv(&argvars[0], rettv);
1237 }
1238 else if (argvars[0].v_type == VAR_BLOB)
1239 {
1240 if ((b = argvars[0].vval.v_blob) != NULL
1241 && !var_check_lock(b->bv_lock,
1242 (char_u *)N_("add() argument"), TRUE))
1243 {
1244 int error = FALSE;
1245 varnumber_T n = tv_get_number_chk(&argvars[1], &error);
1246
1247 if (!error)
1248 {
1249 ga_append(&b->bv_ga, (int)n);
1250 copy_tv(&argvars[0], rettv);
1251 }
1252 }
1253 }
1254 else
1255 emsg(_(e_listblobreq));
1256 }
1257
1258 /*
1259 * "and(expr, expr)" function 1207 * "and(expr, expr)" function
1260 */ 1208 */
1261 static void 1209 static void
1262 f_and(typval_T *argvars, typval_T *rettv) 1210 f_and(typval_T *argvars, typval_T *rettv)
1263 { 1211 {
2147 rettv->vval.v_float = 0.0; 2095 rettv->vval.v_float = 0.0;
2148 } 2096 }
2149 #endif 2097 #endif
2150 2098
2151 /* 2099 /*
2152 * "count()" function
2153 */
2154 static void
2155 f_count(typval_T *argvars, typval_T *rettv)
2156 {
2157 long n = 0;
2158 int ic = FALSE;
2159 int error = FALSE;
2160
2161 if (argvars[2].v_type != VAR_UNKNOWN)
2162 ic = (int)tv_get_number_chk(&argvars[2], &error);
2163
2164 if (argvars[0].v_type == VAR_STRING)
2165 {
2166 char_u *expr = tv_get_string_chk(&argvars[1]);
2167 char_u *p = argvars[0].vval.v_string;
2168 char_u *next;
2169
2170 if (!error && expr != NULL && *expr != NUL && p != NULL)
2171 {
2172 if (ic)
2173 {
2174 size_t len = STRLEN(expr);
2175
2176 while (*p != NUL)
2177 {
2178 if (MB_STRNICMP(p, expr, len) == 0)
2179 {
2180 ++n;
2181 p += len;
2182 }
2183 else
2184 MB_PTR_ADV(p);
2185 }
2186 }
2187 else
2188 while ((next = (char_u *)strstr((char *)p, (char *)expr))
2189 != NULL)
2190 {
2191 ++n;
2192 p = next + STRLEN(expr);
2193 }
2194 }
2195
2196 }
2197 else if (argvars[0].v_type == VAR_LIST)
2198 {
2199 listitem_T *li;
2200 list_T *l;
2201 long idx;
2202
2203 if ((l = argvars[0].vval.v_list) != NULL)
2204 {
2205 li = l->lv_first;
2206 if (argvars[2].v_type != VAR_UNKNOWN)
2207 {
2208 if (argvars[3].v_type != VAR_UNKNOWN)
2209 {
2210 idx = (long)tv_get_number_chk(&argvars[3], &error);
2211 if (!error)
2212 {
2213 li = list_find(l, idx);
2214 if (li == NULL)
2215 semsg(_(e_listidx), idx);
2216 }
2217 }
2218 if (error)
2219 li = NULL;
2220 }
2221
2222 for ( ; li != NULL; li = li->li_next)
2223 if (tv_equal(&li->li_tv, &argvars[1], ic, FALSE))
2224 ++n;
2225 }
2226 }
2227 else if (argvars[0].v_type == VAR_DICT)
2228 {
2229 int todo;
2230 dict_T *d;
2231 hashitem_T *hi;
2232
2233 if ((d = argvars[0].vval.v_dict) != NULL)
2234 {
2235 if (argvars[2].v_type != VAR_UNKNOWN)
2236 {
2237 if (argvars[3].v_type != VAR_UNKNOWN)
2238 emsg(_(e_invarg));
2239 }
2240
2241 todo = error ? 0 : (int)d->dv_hashtab.ht_used;
2242 for (hi = d->dv_hashtab.ht_array; todo > 0; ++hi)
2243 {
2244 if (!HASHITEM_EMPTY(hi))
2245 {
2246 --todo;
2247 if (tv_equal(&HI2DI(hi)->di_tv, &argvars[1], ic, FALSE))
2248 ++n;
2249 }
2250 }
2251 }
2252 }
2253 else
2254 semsg(_(e_listdictarg), "count()");
2255 rettv->vval.v_number = n;
2256 }
2257
2258 /*
2259 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function 2100 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
2260 * 2101 *
2261 * Checks the existence of a cscope connection. 2102 * Checks the existence of a cscope connection.
2262 */ 2103 */
2263 static void 2104 static void
3039 expand_filename(&eap, &cmdstr, &errormsg); 2880 expand_filename(&eap, &cmdstr, &errormsg);
3040 if (errormsg != NULL && *errormsg != NUL) 2881 if (errormsg != NULL && *errormsg != NUL)
3041 emsg(errormsg); 2882 emsg(errormsg);
3042 2883
3043 rettv->vval.v_string = cmdstr; 2884 rettv->vval.v_string = cmdstr;
3044 }
3045
3046 /*
3047 * "extend(list, list [, idx])" function
3048 * "extend(dict, dict [, action])" function
3049 */
3050 static void
3051 f_extend(typval_T *argvars, typval_T *rettv)
3052 {
3053 char_u *arg_errmsg = (char_u *)N_("extend() argument");
3054
3055 if (argvars[0].v_type == VAR_LIST && argvars[1].v_type == VAR_LIST)
3056 {
3057 list_T *l1, *l2;
3058 listitem_T *item;
3059 long before;
3060 int error = FALSE;
3061
3062 l1 = argvars[0].vval.v_list;
3063 l2 = argvars[1].vval.v_list;
3064 if (l1 != NULL && !var_check_lock(l1->lv_lock, arg_errmsg, TRUE)
3065 && l2 != NULL)
3066 {
3067 if (argvars[2].v_type != VAR_UNKNOWN)
3068 {
3069 before = (long)tv_get_number_chk(&argvars[2], &error);
3070 if (error)
3071 return; /* type error; errmsg already given */
3072
3073 if (before == l1->lv_len)
3074 item = NULL;
3075 else
3076 {
3077 item = list_find(l1, before);
3078 if (item == NULL)
3079 {
3080 semsg(_(e_listidx), before);
3081 return;
3082 }
3083 }
3084 }
3085 else
3086 item = NULL;
3087 list_extend(l1, l2, item);
3088
3089 copy_tv(&argvars[0], rettv);
3090 }
3091 }
3092 else if (argvars[0].v_type == VAR_DICT && argvars[1].v_type == VAR_DICT)
3093 {
3094 dict_T *d1, *d2;
3095 char_u *action;
3096 int i;
3097
3098 d1 = argvars[0].vval.v_dict;
3099 d2 = argvars[1].vval.v_dict;
3100 if (d1 != NULL && !var_check_lock(d1->dv_lock, arg_errmsg, TRUE)
3101 && d2 != NULL)
3102 {
3103 /* Check the third argument. */
3104 if (argvars[2].v_type != VAR_UNKNOWN)
3105 {
3106 static char *(av[]) = {"keep", "force", "error"};
3107
3108 action = tv_get_string_chk(&argvars[2]);
3109 if (action == NULL)
3110 return; /* type error; errmsg already given */
3111 for (i = 0; i < 3; ++i)
3112 if (STRCMP(action, av[i]) == 0)
3113 break;
3114 if (i == 3)
3115 {
3116 semsg(_(e_invarg2), action);
3117 return;
3118 }
3119 }
3120 else
3121 action = (char_u *)"force";
3122
3123 dict_extend(d1, d2, action);
3124
3125 copy_tv(&argvars[0], rettv);
3126 }
3127 }
3128 else
3129 semsg(_(e_listdictarg), "extend()");
3130 } 2885 }
3131 2886
3132 /* 2887 /*
3133 * "feedkeys()" function 2888 * "feedkeys()" function
3134 */ 2889 */
4057 dict_add_number(dict, "until", last_csearch_until()); 3812 dict_add_number(dict, "until", last_csearch_until());
4058 } 3813 }
4059 } 3814 }
4060 3815
4061 /* 3816 /*
4062 * "getcmdline()" function
4063 */
4064 static void
4065 f_getcmdline(typval_T *argvars UNUSED, typval_T *rettv)
4066 {
4067 rettv->v_type = VAR_STRING;
4068 rettv->vval.v_string = get_cmdline_str();
4069 }
4070
4071 /*
4072 * "getcmdpos()" function
4073 */
4074 static void
4075 f_getcmdpos(typval_T *argvars UNUSED, typval_T *rettv)
4076 {
4077 rettv->vval.v_number = get_cmdline_pos() + 1;
4078 }
4079
4080 /*
4081 * "getcmdtype()" function
4082 */
4083 static void
4084 f_getcmdtype(typval_T *argvars UNUSED, typval_T *rettv)
4085 {
4086 rettv->v_type = VAR_STRING;
4087 rettv->vval.v_string = alloc(2);
4088 if (rettv->vval.v_string != NULL)
4089 {
4090 rettv->vval.v_string[0] = get_cmdline_type();
4091 rettv->vval.v_string[1] = NUL;
4092 }
4093 }
4094
4095 /*
4096 * "getcmdwintype()" function 3817 * "getcmdwintype()" function
4097 */ 3818 */
4098 static void 3819 static void
4099 f_getcmdwintype(typval_T *argvars UNUSED, typval_T *rettv) 3820 f_getcmdwintype(typval_T *argvars UNUSED, typval_T *rettv)
4100 { 3821 {
5730 ++cmdline_star; 5451 ++cmdline_star;
5731 ++inputsecret_flag; 5452 ++inputsecret_flag;
5732 f_input(argvars, rettv); 5453 f_input(argvars, rettv);
5733 --cmdline_star; 5454 --cmdline_star;
5734 --inputsecret_flag; 5455 --inputsecret_flag;
5735 }
5736
5737 /*
5738 * "insert()" function
5739 */
5740 static void
5741 f_insert(typval_T *argvars, typval_T *rettv)
5742 {
5743 long before = 0;
5744 listitem_T *item;
5745 list_T *l;
5746 int error = FALSE;
5747
5748 if (argvars[0].v_type == VAR_BLOB)
5749 {
5750 int val, len;
5751 char_u *p;
5752
5753 len = blob_len(argvars[0].vval.v_blob);
5754 if (argvars[2].v_type != VAR_UNKNOWN)
5755 {
5756 before = (long)tv_get_number_chk(&argvars[2], &error);
5757 if (error)
5758 return; // type error; errmsg already given
5759 if (before < 0 || before > len)
5760 {
5761 semsg(_(e_invarg2), tv_get_string(&argvars[2]));
5762 return;
5763 }
5764 }
5765 val = tv_get_number_chk(&argvars[1], &error);
5766 if (error)
5767 return;
5768 if (val < 0 || val > 255)
5769 {
5770 semsg(_(e_invarg2), tv_get_string(&argvars[1]));
5771 return;
5772 }
5773
5774 if (ga_grow(&argvars[0].vval.v_blob->bv_ga, 1) == FAIL)
5775 return;
5776 p = (char_u *)argvars[0].vval.v_blob->bv_ga.ga_data;
5777 mch_memmove(p + before + 1, p + before, (size_t)len - before);
5778 *(p + before) = val;
5779 ++argvars[0].vval.v_blob->bv_ga.ga_len;
5780
5781 copy_tv(&argvars[0], rettv);
5782 }
5783 else if (argvars[0].v_type != VAR_LIST)
5784 semsg(_(e_listblobarg), "insert()");
5785 else if ((l = argvars[0].vval.v_list) != NULL
5786 && !var_check_lock(l->lv_lock,
5787 (char_u *)N_("insert() argument"), TRUE))
5788 {
5789 if (argvars[2].v_type != VAR_UNKNOWN)
5790 before = (long)tv_get_number_chk(&argvars[2], &error);
5791 if (error)
5792 return; /* type error; errmsg already given */
5793
5794 if (before == l->lv_len)
5795 item = NULL;
5796 else
5797 {
5798 item = list_find(l, before);
5799 if (item == NULL)
5800 {
5801 semsg(_(e_listidx), before);
5802 l = NULL;
5803 }
5804 }
5805 if (l != NULL)
5806 {
5807 list_insert_tv(l, &argvars[1], item);
5808 copy_tv(&argvars[0], rettv);
5809 }
5810 }
5811 } 5456 }
5812 5457
5813 /* 5458 /*
5814 * "invert(expr)" function 5459 * "invert(expr)" function
5815 */ 5460 */
7360 emsg(_("E942: +clientserver feature not available")); 7005 emsg(_("E942: +clientserver feature not available"));
7361 #endif 7006 #endif
7362 } 7007 }
7363 7008
7364 /* 7009 /*
7365 * "remove()" function
7366 */
7367 static void
7368 f_remove(typval_T *argvars, typval_T *rettv)
7369 {
7370 char_u *arg_errmsg = (char_u *)N_("remove() argument");
7371
7372 if (argvars[0].v_type == VAR_DICT)
7373 dict_remove(argvars, rettv, arg_errmsg);
7374 else if (argvars[0].v_type == VAR_BLOB)
7375 blob_remove(argvars, rettv);
7376 else if (argvars[0].v_type == VAR_LIST)
7377 list_remove(argvars, rettv, arg_errmsg);
7378 else
7379 semsg(_(e_listdictblobarg), "remove()");
7380 }
7381
7382 /*
7383 * "rename({from}, {to})" function 7010 * "rename({from}, {to})" function
7384 */ 7011 */
7385 static void 7012 static void
7386 f_rename(typval_T *argvars, typval_T *rettv) 7013 f_rename(typval_T *argvars, typval_T *rettv)
7387 { 7014 {
7434 mch_memmove(r + i * slen, p, (size_t)slen); 7061 mch_memmove(r + i * slen, p, (size_t)slen);
7435 r[len] = NUL; 7062 r[len] = NUL;
7436 } 7063 }
7437 7064
7438 rettv->vval.v_string = r; 7065 rettv->vval.v_string = r;
7439 }
7440 }
7441
7442 /*
7443 * "reverse({list})" function
7444 */
7445 static void
7446 f_reverse(typval_T *argvars, typval_T *rettv)
7447 {
7448 list_T *l;
7449 listitem_T *li, *ni;
7450
7451 if (argvars[0].v_type == VAR_BLOB)
7452 {
7453 blob_T *b = argvars[0].vval.v_blob;
7454 int i, len = blob_len(b);
7455
7456 for (i = 0; i < len / 2; i++)
7457 {
7458 int tmp = blob_get(b, i);
7459
7460 blob_set(b, i, blob_get(b, len - i - 1));
7461 blob_set(b, len - i - 1, tmp);
7462 }
7463 rettv_blob_set(rettv, b);
7464 return;
7465 }
7466
7467 if (argvars[0].v_type != VAR_LIST)
7468 semsg(_(e_listblobarg), "reverse()");
7469 else if ((l = argvars[0].vval.v_list) != NULL
7470 && !var_check_lock(l->lv_lock,
7471 (char_u *)N_("reverse() argument"), TRUE))
7472 {
7473 li = l->lv_last;
7474 l->lv_first = l->lv_last = NULL;
7475 l->lv_len = 0;
7476 while (li != NULL)
7477 {
7478 ni = li->li_prev;
7479 list_append(l, li);
7480 li = ni;
7481 }
7482 rettv_list_set(rettv, l);
7483 l->lv_idx = l->lv_len - l->lv_idx - 1;
7484 } 7066 }
7485 } 7067 }
7486 7068
7487 #define SP_NOMOVE 0x01 /* don't move cursor */ 7069 #define SP_NOMOVE 0x01 /* don't move cursor */
7488 #define SP_REPEAT 0x02 /* repeat to find outer pair */ 7070 #define SP_REPEAT 0x02 /* repeat to find outer pair */
8285 set_csearch_until(!!tv_get_number(&di->di_tv)); 7867 set_csearch_until(!!tv_get_number(&di->di_tv));
8286 } 7868 }
8287 } 7869 }
8288 7870
8289 /* 7871 /*
8290 * "setcmdpos()" function
8291 */
8292 static void
8293 f_setcmdpos(typval_T *argvars, typval_T *rettv)
8294 {
8295 int pos = (int)tv_get_number(&argvars[0]) - 1;
8296
8297 if (pos >= 0)
8298 rettv->vval.v_number = set_cmdline_pos(pos);
8299 }
8300
8301 /*
8302 * "setenv()" function 7872 * "setenv()" function
8303 */ 7873 */
8304 static void 7874 static void
8305 f_setenv(typval_T *argvars, typval_T *rettv UNUSED) 7875 f_setenv(typval_T *argvars, typval_T *rettv UNUSED)
8306 { 7876 {
10571 } 10141 }
10572 rettv->vval.v_number = n; 10142 rettv->vval.v_number = n;
10573 } 10143 }
10574 10144
10575 /* 10145 /*
10576 * "undofile(name)" function
10577 */
10578 static void
10579 f_undofile(typval_T *argvars UNUSED, typval_T *rettv)
10580 {
10581 rettv->v_type = VAR_STRING;
10582 #ifdef FEAT_PERSISTENT_UNDO
10583 {
10584 char_u *fname = tv_get_string(&argvars[0]);
10585
10586 if (*fname == NUL)
10587 {
10588 /* If there is no file name there will be no undo file. */
10589 rettv->vval.v_string = NULL;
10590 }
10591 else
10592 {
10593 char_u *ffname = FullName_save(fname, TRUE);
10594
10595 if (ffname != NULL)
10596 rettv->vval.v_string = u_get_undo_file_name(ffname, FALSE);
10597 vim_free(ffname);
10598 }
10599 }
10600 #else
10601 rettv->vval.v_string = NULL;
10602 #endif
10603 }
10604
10605 /*
10606 * "undotree()" function
10607 */
10608 static void
10609 f_undotree(typval_T *argvars UNUSED, typval_T *rettv)
10610 {
10611 if (rettv_dict_alloc(rettv) == OK)
10612 {
10613 dict_T *dict = rettv->vval.v_dict;
10614 list_T *list;
10615
10616 dict_add_number(dict, "synced", (long)curbuf->b_u_synced);
10617 dict_add_number(dict, "seq_last", curbuf->b_u_seq_last);
10618 dict_add_number(dict, "save_last", (long)curbuf->b_u_save_nr_last);
10619 dict_add_number(dict, "seq_cur", curbuf->b_u_seq_cur);
10620 dict_add_number(dict, "time_cur", (long)curbuf->b_u_time_cur);
10621 dict_add_number(dict, "save_cur", (long)curbuf->b_u_save_nr_cur);
10622
10623 list = list_alloc();
10624 if (list != NULL)
10625 {
10626 u_eval_tree(curbuf->b_u_oldhead, list);
10627 dict_add_list(dict, "entries", list);
10628 }
10629 }
10630 }
10631
10632 /*
10633 * "virtcol(string)" function 10146 * "virtcol(string)" function
10634 */ 10147 */
10635 static void 10148 static void
10636 f_virtcol(typval_T *argvars, typval_T *rettv) 10149 f_virtcol(typval_T *argvars, typval_T *rettv)
10637 { 10150 {