blob: c6230c4027ffa95cecfa928230507e0c8d4086c2 [file] [log] [blame]
Bram Moolenaaredf3f972016-08-29 22:49:24 +02001/* vi:set ts=8 sts=4 sw=4 noet:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
9
10/*
11 * Code to handle user-settable options. This is all pretty much table-
12 * driven. Checklist for adding a new option:
13 * - Put it in the options array below (copy an existing entry).
14 * - For a global option: Add a variable for it in option.h.
15 * - For a buffer or window local option:
16 * - Add a PV_XX entry to the enum below.
17 * - Add a variable to the window or buffer struct in structs.h.
18 * - For a window option, add some code to copy_winopt().
19 * - For a buffer option, add some code to buf_copy_options().
20 * - For a buffer string option, add code to check_buf_options().
21 * - If it's a numeric option, add any necessary bounds checks to do_set().
22 * - If it's a list of flags, add some code in do_set(), search for WW_ALL.
23 * - When adding an option with expansion (P_EXPAND), but with a different
24 * default for Vi and Vim (no P_VI_DEF), add some code at VIMEXP.
Bram Moolenaarcea912a2016-10-12 14:20:24 +020025 * - Add documentation! One line in doc/quickref.txt, full description in
Bram Moolenaar071d4272004-06-13 20:20:40 +000026 * options.txt, and any other related places.
27 * - Add an entry in runtime/optwin.vim.
28 * When making changes:
29 * - Adjust the help for the option in doc/option.txt.
30 * - When an entry has the P_VIM flag, or is lacking the P_VI_DEF flag, add a
31 * comment at the help for the 'compatible' option.
32 */
33
34#define IN_OPTION_C
35#include "vim.h"
Bram Moolenaar0eddca42019-09-12 22:26:43 +020036#include "optiondefs.h"
Bram Moolenaar071d4272004-06-13 20:20:40 +000037
Bram Moolenaarbaaa7e92016-01-29 22:47:03 +010038static void set_options_default(int opt_flags);
Bram Moolenaar4bfa8af2018-02-03 15:14:46 +010039static void set_string_default_esc(char *name, char_u *val, int escape);
Bram Moolenaarb00ef052020-09-12 14:53:53 +020040static char_u *find_dup_item(char_u *origval, char_u *newval, long_u flags);
Bram Moolenaarbaaa7e92016-01-29 22:47:03 +010041static char_u *option_expand(int opt_idx, char_u *val);
42static void didset_options(void);
43static void didset_options2(void);
Bram Moolenaard1f56e62006-02-22 21:25:37 +000044#if defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaarbaaa7e92016-01-29 22:47:03 +010045static long_u *insecure_flag(int opt_idx, int opt_flags);
Bram Moolenaard1f56e62006-02-22 21:25:37 +000046#else
47# define insecure_flag(opt_idx, opt_flags) (&options[opt_idx].flags)
48#endif
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010049static char *set_bool_option(int opt_idx, char_u *varp, int value, int opt_flags);
50static char *set_num_option(int opt_idx, char_u *varp, long value, char *errbuf, size_t errbuflen, int opt_flags);
Bram Moolenaar9cf4b502018-07-23 04:12:03 +020051static int find_key_option(char_u *arg_arg, int has_lt);
Bram Moolenaarbaaa7e92016-01-29 22:47:03 +010052static void showoptions(int all, int opt_flags);
Bram Moolenaarcacc6a52019-05-30 15:22:43 +020053static int optval_default(struct vimoption *, char_u *varp, int compatible);
Bram Moolenaarbaaa7e92016-01-29 22:47:03 +010054static void showoneopt(struct vimoption *, int opt_flags);
Bram Moolenaared18f2c2019-01-24 20:30:52 +010055static int put_setstring(FILE *fd, char *cmd, char *name, char_u **valuep, long_u flags);
Bram Moolenaarbaaa7e92016-01-29 22:47:03 +010056static int put_setnum(FILE *fd, char *cmd, char *name, long *valuep);
57static int put_setbool(FILE *fd, char *cmd, char *name, int value);
Bram Moolenaardac13472019-09-16 21:06:21 +020058static int istermoption(struct vimoption *p);
Bram Moolenaarbaaa7e92016-01-29 22:47:03 +010059static char_u *get_varp_scope(struct vimoption *p, int opt_flags);
60static char_u *get_varp(struct vimoption *);
Bram Moolenaar5843f5f2019-08-20 20:13:45 +020061static void check_win_options(win_T *win);
Bram Moolenaarbaaa7e92016-01-29 22:47:03 +010062static void option_value2string(struct vimoption *, int opt_flags);
63static void check_winopt(winopt_T *wop);
64static int wc_use_keyname(char_u *varp, long *wcp);
Bram Moolenaarbaaa7e92016-01-29 22:47:03 +010065static void paste_option_changed(void);
66static void compatible_set(void);
Bram Moolenaar071d4272004-06-13 20:20:40 +000067
68/*
69 * Initialize the options, first part.
70 *
71 * Called only once from main(), just after creating the first buffer.
Bram Moolenaar07268702018-03-01 21:57:32 +010072 * If "clean_arg" is TRUE Vim was started with --clean.
Bram Moolenaar071d4272004-06-13 20:20:40 +000073 */
74 void
Bram Moolenaar07268702018-03-01 21:57:32 +010075set_init_1(int clean_arg)
Bram Moolenaar071d4272004-06-13 20:20:40 +000076{
77 char_u *p;
78 int opt_idx;
Bram Moolenaara93fa7e2006-04-17 22:14:47 +000079 long_u n;
Bram Moolenaar071d4272004-06-13 20:20:40 +000080
81#ifdef FEAT_LANGMAP
82 langmap_init();
83#endif
84
Bram Moolenaar6e0ce172019-12-05 20:12:41 +010085 // Be Vi compatible by default
Bram Moolenaar071d4272004-06-13 20:20:40 +000086 p_cp = TRUE;
87
Bram Moolenaar6e0ce172019-12-05 20:12:41 +010088 // Use POSIX compatibility when $VIM_POSIX is set.
Bram Moolenaar4399ef42005-02-12 14:29:27 +000089 if (mch_getenv((char_u *)"VIM_POSIX") != NULL)
Bram Moolenaar26a60b42005-02-22 08:49:11 +000090 {
Bram Moolenaar4399ef42005-02-12 14:29:27 +000091 set_string_default("cpo", (char_u *)CPO_ALL);
Bram Moolenaar9dfa3132019-05-04 21:08:40 +020092 set_string_default("shm", (char_u *)SHM_POSIX);
Bram Moolenaar26a60b42005-02-22 08:49:11 +000093 }
Bram Moolenaar4399ef42005-02-12 14:29:27 +000094
Bram Moolenaar071d4272004-06-13 20:20:40 +000095 /*
96 * Find default value for 'shell' option.
Bram Moolenaar7c626922005-02-07 22:01:03 +000097 * Don't use it if it is empty.
Bram Moolenaar071d4272004-06-13 20:20:40 +000098 */
Bram Moolenaar7c626922005-02-07 22:01:03 +000099 if (((p = mch_getenv((char_u *)"SHELL")) != NULL && *p != NUL)
Bram Moolenaar48e330a2016-02-23 14:53:34 +0100100#if defined(MSWIN)
Bram Moolenaar7c626922005-02-07 22:01:03 +0000101 || ((p = mch_getenv((char_u *)"COMSPEC")) != NULL && *p != NUL)
Bram Moolenaar6aa2cd42016-02-16 15:06:59 +0100102 || ((p = (char_u *)default_shell()) != NULL && *p != NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000103#endif
Bram Moolenaar7c626922005-02-07 22:01:03 +0000104 )
Bram Moolenaar2efc44b2019-10-05 12:09:32 +0200105#if defined(MSWIN)
106 {
107 // For MS-Windows put the path in quotes instead of escaping spaces.
108 char_u *cmd;
109 size_t len;
110
111 if (vim_strchr(p, ' ') != NULL)
112 {
113 len = STRLEN(p) + 3; // two quotes and a trailing NUL
114 cmd = alloc(len);
Bram Moolenaar1671de32019-10-05 21:35:16 +0200115 if (cmd != NULL)
116 {
117 vim_snprintf((char *)cmd, len, "\"%s\"", p);
118 set_string_default("sh", cmd);
119 vim_free(cmd);
120 }
Bram Moolenaar2efc44b2019-10-05 12:09:32 +0200121 }
122 else
123 set_string_default("sh", p);
124 }
125#else
Bram Moolenaar4bfa8af2018-02-03 15:14:46 +0100126 set_string_default_esc("sh", p, TRUE);
Bram Moolenaar2efc44b2019-10-05 12:09:32 +0200127#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000128
129#ifdef FEAT_WILDIGN
130 /*
131 * Set the default for 'backupskip' to include environment variables for
132 * temp files.
133 */
134 {
135# ifdef UNIX
136 static char *(names[4]) = {"", "TMPDIR", "TEMP", "TMP"};
137# else
138 static char *(names[3]) = {"TMPDIR", "TEMP", "TMP"};
139# endif
Bram Moolenaar05159a02005-02-26 23:04:13 +0000140 int len;
141 garray_T ga;
142 int mustfree;
Bram Moolenaarb00ef052020-09-12 14:53:53 +0200143 char_u *item;
144
145 opt_idx = findoption((char_u *)"backupskip");
Bram Moolenaar071d4272004-06-13 20:20:40 +0000146
147 ga_init2(&ga, 1, 100);
K.Takataeeec2542021-06-02 13:28:16 +0200148 for (n = 0; n < (long)ARRAY_LENGTH(names); ++n)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000149 {
Bram Moolenaar05159a02005-02-26 23:04:13 +0000150 mustfree = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000151# ifdef UNIX
152 if (*names[n] == NUL)
Bram Moolenaarb8e22a02018-04-12 21:37:34 +0200153# ifdef MACOS_X
154 p = (char_u *)"/private/tmp";
155# else
Bram Moolenaar071d4272004-06-13 20:20:40 +0000156 p = (char_u *)"/tmp";
Bram Moolenaarb8e22a02018-04-12 21:37:34 +0200157# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000158 else
159# endif
Bram Moolenaar05159a02005-02-26 23:04:13 +0000160 p = vim_getenv((char_u *)names[n], &mustfree);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000161 if (p != NULL && *p != NUL)
162 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100163 // First time count the NUL, otherwise count the ','.
Bram Moolenaara93fa7e2006-04-17 22:14:47 +0000164 len = (int)STRLEN(p) + 3;
Bram Moolenaarb00ef052020-09-12 14:53:53 +0200165 item = alloc(len);
166 STRCPY(item, p);
167 add_pathsep(item);
168 STRCAT(item, "*");
169 if (find_dup_item(ga.ga_data, item, options[opt_idx].flags)
170 == NULL
171 && ga_grow(&ga, len) == OK)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000172 {
173 if (ga.ga_len > 0)
174 STRCAT(ga.ga_data, ",");
Bram Moolenaarb00ef052020-09-12 14:53:53 +0200175 STRCAT(ga.ga_data, item);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000176 ga.ga_len += len;
177 }
Bram Moolenaarb00ef052020-09-12 14:53:53 +0200178 vim_free(item);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000179 }
Bram Moolenaar05159a02005-02-26 23:04:13 +0000180 if (mustfree)
181 vim_free(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000182 }
183 if (ga.ga_data != NULL)
184 {
185 set_string_default("bsk", ga.ga_data);
186 vim_free(ga.ga_data);
187 }
188 }
189#endif
190
191 /*
192 * 'maxmemtot' and 'maxmem' may have to be adjusted for available memory
193 */
194 opt_idx = findoption((char_u *)"maxmemtot");
Bram Moolenaarfc1421e2006-04-20 22:17:20 +0000195 if (opt_idx >= 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000196 {
Bram Moolenaarfc1421e2006-04-20 22:17:20 +0000197#if !defined(HAVE_AVAIL_MEM) && !defined(HAVE_TOTAL_MEM)
198 if (options[opt_idx].def_val[VI_DEFAULT] == (char_u *)0L)
199#endif
200 {
Bram Moolenaar071d4272004-06-13 20:20:40 +0000201#ifdef HAVE_AVAIL_MEM
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100202 // Use amount of memory available at this moment.
Bram Moolenaar11b73d62012-06-29 15:51:30 +0200203 n = (mch_avail_mem(FALSE) >> 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000204#else
205# ifdef HAVE_TOTAL_MEM
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100206 // Use amount of memory available to Vim.
Bram Moolenaar914572a2007-05-01 11:37:47 +0000207 n = (mch_total_mem(FALSE) >> 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000208# else
Bram Moolenaarfc1421e2006-04-20 22:17:20 +0000209 n = (0x7fffffff >> 11);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000210# endif
211#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000212 options[opt_idx].def_val[VI_DEFAULT] = (char_u *)n;
Bram Moolenaarfc1421e2006-04-20 22:17:20 +0000213 opt_idx = findoption((char_u *)"maxmem");
214 if (opt_idx >= 0)
215 {
216#if !defined(HAVE_AVAIL_MEM) && !defined(HAVE_TOTAL_MEM)
Bram Moolenaar35be4532015-12-11 22:38:36 +0100217 if ((long)(long_i)options[opt_idx].def_val[VI_DEFAULT] > (long)n
218 || (long)(long_i)options[opt_idx].def_val[VI_DEFAULT] == 0L)
Bram Moolenaarfc1421e2006-04-20 22:17:20 +0000219#endif
220 options[opt_idx].def_val[VI_DEFAULT] = (char_u *)n;
221 }
222 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000223 }
224
Bram Moolenaar071d4272004-06-13 20:20:40 +0000225#ifdef FEAT_SEARCHPATH
226 {
227 char_u *cdpath;
228 char_u *buf;
229 int i;
230 int j;
Bram Moolenaar05159a02005-02-26 23:04:13 +0000231 int mustfree = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000232
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100233 // Initialize the 'cdpath' option's default value.
Bram Moolenaar05159a02005-02-26 23:04:13 +0000234 cdpath = vim_getenv((char_u *)"CDPATH", &mustfree);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000235 if (cdpath != NULL)
236 {
Bram Moolenaar964b3742019-05-24 18:54:09 +0200237 buf = alloc((STRLEN(cdpath) << 1) + 2);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000238 if (buf != NULL)
239 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100240 buf[0] = ','; // start with ",", current dir first
Bram Moolenaar071d4272004-06-13 20:20:40 +0000241 j = 1;
242 for (i = 0; cdpath[i] != NUL; ++i)
243 {
244 if (vim_ispathlistsep(cdpath[i]))
245 buf[j++] = ',';
246 else
247 {
248 if (cdpath[i] == ' ' || cdpath[i] == ',')
249 buf[j++] = '\\';
250 buf[j++] = cdpath[i];
251 }
252 }
253 buf[j] = NUL;
254 opt_idx = findoption((char_u *)"cdpath");
Bram Moolenaarfc1421e2006-04-20 22:17:20 +0000255 if (opt_idx >= 0)
256 {
257 options[opt_idx].def_val[VI_DEFAULT] = buf;
258 options[opt_idx].flags |= P_DEF_ALLOCED;
259 }
Bram Moolenaara9d52e32010-07-31 16:44:19 +0200260 else
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100261 vim_free(buf); // cannot happen
Bram Moolenaar071d4272004-06-13 20:20:40 +0000262 }
Bram Moolenaar05159a02005-02-26 23:04:13 +0000263 if (mustfree)
264 vim_free(cdpath);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000265 }
266 }
267#endif
268
Bram Moolenaare7fedb62015-12-31 19:07:19 +0100269#if defined(FEAT_POSTSCRIPT) && (defined(MSWIN) || defined(VMS) || defined(EBCDIC) || defined(MAC) || defined(hpux))
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100270 // Set print encoding on platforms that don't default to latin1
Bram Moolenaar071d4272004-06-13 20:20:40 +0000271 set_string_default("penc",
Bram Moolenaare7fedb62015-12-31 19:07:19 +0100272# if defined(MSWIN)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000273 (char_u *)"cp1252"
274# else
275# ifdef VMS
276 (char_u *)"dec-mcs"
277# else
278# ifdef EBCDIC
279 (char_u *)"ebcdic-uk"
280# else
281# ifdef MAC
282 (char_u *)"mac-roman"
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100283# else // HPUX
Bram Moolenaar071d4272004-06-13 20:20:40 +0000284 (char_u *)"hp-roman8"
285# endif
286# endif
287# endif
288# endif
289 );
290#endif
291
292#ifdef FEAT_POSTSCRIPT
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100293 // 'printexpr' must be allocated to be able to evaluate it.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000294 set_string_default("pexpr",
Bram Moolenaar48e330a2016-02-23 14:53:34 +0100295# if defined(MSWIN)
Bram Moolenaared203462004-06-16 11:19:22 +0000296 (char_u *)"system('copy' . ' ' . v:fname_in . (&printdevice == '' ? ' LPT1:' : (' \"' . &printdevice . '\"'))) . delete(v:fname_in)"
Bram Moolenaar071d4272004-06-13 20:20:40 +0000297# else
298# ifdef VMS
299 (char_u *)"system('print/delete' . (&printdevice == '' ? '' : ' /queue=' . &printdevice) . ' ' . v:fname_in)"
300
301# else
302 (char_u *)"system('lpr' . (&printdevice == '' ? '' : ' -P' . &printdevice) . ' ' . v:fname_in) . delete(v:fname_in) + v:shell_error"
303# endif
304# endif
305 );
306#endif
307
308 /*
309 * Set all the options (except the terminal options) to their default
310 * value. Also set the global value for local options.
311 */
312 set_options_default(0);
313
Bram Moolenaar07268702018-03-01 21:57:32 +0100314#ifdef CLEAN_RUNTIMEPATH
315 if (clean_arg)
316 {
317 opt_idx = findoption((char_u *)"runtimepath");
318 if (opt_idx >= 0)
319 {
320 options[opt_idx].def_val[VI_DEFAULT] = (char_u *)CLEAN_RUNTIMEPATH;
321 p_rtp = (char_u *)CLEAN_RUNTIMEPATH;
322 }
323 opt_idx = findoption((char_u *)"packpath");
324 if (opt_idx >= 0)
325 {
326 options[opt_idx].def_val[VI_DEFAULT] = (char_u *)CLEAN_RUNTIMEPATH;
327 p_pp = (char_u *)CLEAN_RUNTIMEPATH;
328 }
329 }
330#endif
331
Bram Moolenaar071d4272004-06-13 20:20:40 +0000332#ifdef FEAT_GUI
333 if (found_reverse_arg)
334 set_option_value((char_u *)"bg", 0L, (char_u *)"dark", 0);
335#endif
336
337 curbuf->b_p_initialized = TRUE;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100338 curbuf->b_p_ar = -1; // no local 'autoread' value
Bram Moolenaarf5a2fd82013-11-06 05:26:15 +0100339 curbuf->b_p_ul = NO_LOCAL_UNDOLEVEL;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000340 check_buf_options(curbuf);
341 check_win_options(curwin);
342 check_options();
343
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100344 // Must be before option_expand(), because that one needs vim_isIDc()
Bram Moolenaar071d4272004-06-13 20:20:40 +0000345 didset_options();
346
Bram Moolenaarb9a02fc2006-03-12 22:08:12 +0000347#ifdef FEAT_SPELL
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100348 // Use the current chartab for the generic chartab. This is not in
349 // didset_options() because it only depends on 'encoding'.
Bram Moolenaar6bb68362005-03-22 23:03:44 +0000350 init_spell_chartab();
351#endif
352
Bram Moolenaar071d4272004-06-13 20:20:40 +0000353 /*
354 * Expand environment variables and things like "~" for the defaults.
355 * If option_expand() returns non-NULL the variable is expanded. This can
356 * only happen for non-indirect options.
357 * Also set the default to the expanded value, so ":set" does not list
358 * them.
359 * Don't set the P_ALLOCED flag, because we don't want to free the
360 * default.
361 */
Bram Moolenaardac13472019-09-16 21:06:21 +0200362 for (opt_idx = 0; !istermoption_idx(opt_idx); opt_idx++)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000363 {
364 if ((options[opt_idx].flags & P_GETTEXT)
365 && options[opt_idx].var != NULL)
366 p = (char_u *)_(*(char **)options[opt_idx].var);
367 else
368 p = option_expand(opt_idx, NULL);
369 if (p != NULL && (p = vim_strsave(p)) != NULL)
370 {
371 *(char_u **)options[opt_idx].var = p;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100372 // VIMEXP
373 // Defaults for all expanded options are currently the same for Vi
374 // and Vim. When this changes, add some code here! Also need to
375 // split P_DEF_ALLOCED in two.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000376 if (options[opt_idx].flags & P_DEF_ALLOCED)
377 vim_free(options[opt_idx].def_val[VI_DEFAULT]);
378 options[opt_idx].def_val[VI_DEFAULT] = p;
379 options[opt_idx].flags |= P_DEF_ALLOCED;
380 }
381 }
382
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100383 save_file_ff(curbuf); // Buffer is unchanged
Bram Moolenaar071d4272004-06-13 20:20:40 +0000384
Bram Moolenaar071d4272004-06-13 20:20:40 +0000385#if defined(FEAT_ARABIC)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100386 // Detect use of mlterm.
387 // Mlterm is a terminal emulator akin to xterm that has some special
388 // abilities (bidi namely).
389 // NOTE: mlterm's author is being asked to 'set' a variable
390 // instead of an environment variable due to inheritance.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000391 if (mch_getenv((char_u *)"MLTERM") != NULL)
392 set_option_value((char_u *)"tbidi", 1L, NULL, 0);
393#endif
394
Bram Moolenaare68c25c2015-08-25 15:39:55 +0200395 didset_options2();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000396
Bram Moolenaar4f974752019-02-17 17:44:42 +0100397# if defined(MSWIN) && defined(FEAT_GETTEXT)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000398 /*
399 * If $LANG isn't set, try to get a good value for it. This makes the
400 * right language be used automatically. Don't do this for English.
401 */
402 if (mch_getenv((char_u *)"LANG") == NULL)
403 {
404 char buf[20];
405
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100406 // Could use LOCALE_SISO639LANGNAME, but it's not in Win95.
407 // LOCALE_SABBREVLANGNAME gives us three letters, like "enu", we use
408 // only the first two.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000409 n = GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVLANGNAME,
410 (LPTSTR)buf, 20);
411 if (n >= 2 && STRNICMP(buf, "en", 2) != 0)
412 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100413 // There are a few exceptions (probably more)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000414 if (STRNICMP(buf, "cht", 3) == 0 || STRNICMP(buf, "zht", 3) == 0)
415 STRCPY(buf, "zh_TW");
416 else if (STRNICMP(buf, "chs", 3) == 0
417 || STRNICMP(buf, "zhc", 3) == 0)
418 STRCPY(buf, "zh_CN");
419 else if (STRNICMP(buf, "jp", 2) == 0)
420 STRCPY(buf, "ja");
421 else
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100422 buf[2] = NUL; // truncate to two-letter code
Bram Moolenaar6aa2cd42016-02-16 15:06:59 +0100423 vim_setenv((char_u *)"LANG", (char_u *)buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000424 }
425 }
Bram Moolenaar26a60b42005-02-22 08:49:11 +0000426# else
Bram Moolenaar9d47f172006-03-15 23:03:01 +0000427# ifdef MACOS_CONVERT
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100428 // Moved to os_mac_conv.c to avoid dependency problems.
Bram Moolenaarc1a11ed2008-06-24 22:09:24 +0000429 mac_lang_init();
Bram Moolenaar26a60b42005-02-22 08:49:11 +0000430# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000431# endif
432
K.Takataf883d902021-05-30 18:04:19 +0200433# ifdef MSWIN
434 // MS-Windows has builtin support for conversion to and from Unicode, using
435 // "utf-8" for 'encoding' should work best for most users.
436 p = vim_strsave((char_u *)ENC_DFLT);
437# else
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100438 // enc_locale() will try to find the encoding of the current locale.
K.Takataf883d902021-05-30 18:04:19 +0200439 // This works best for properly configured systems, old and new.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000440 p = enc_locale();
K.Takataf883d902021-05-30 18:04:19 +0200441# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000442 if (p != NULL)
443 {
444 char_u *save_enc;
445
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100446 // Try setting 'encoding' and check if the value is valid.
K.Takataf883d902021-05-30 18:04:19 +0200447 // If not, go back to the default encoding.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000448 save_enc = p_enc;
449 p_enc = p;
Bram Moolenaar733f0a22007-03-02 18:56:27 +0000450 if (STRCMP(p_enc, "gb18030") == 0)
451 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100452 // We don't support "gb18030", but "cp936" is a good substitute
453 // for practical purposes, thus use that. It's not an alias to
454 // still support conversion between gb18030 and utf-8.
Bram Moolenaar733f0a22007-03-02 18:56:27 +0000455 p_enc = vim_strsave((char_u *)"cp936");
456 vim_free(p);
457 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000458 if (mb_init() == NULL)
459 {
460 opt_idx = findoption((char_u *)"encoding");
Bram Moolenaarfc1421e2006-04-20 22:17:20 +0000461 if (opt_idx >= 0)
462 {
463 options[opt_idx].def_val[VI_DEFAULT] = p_enc;
464 options[opt_idx].flags |= P_DEF_ALLOCED;
465 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000466
Bram Moolenaard0573012017-10-28 21:11:06 +0200467#if defined(MSWIN) || defined(MACOS_X) || defined(VMS)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100468 if (STRCMP(p_enc, "latin1") == 0 || enc_utf8)
Bram Moolenaarc0197e22004-09-13 20:26:32 +0000469 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100470 // Adjust the default for 'isprint' and 'iskeyword' to match
471 // latin1. Also set the defaults for when 'nocompatible' is
472 // set.
Bram Moolenaarc0197e22004-09-13 20:26:32 +0000473 set_string_option_direct((char_u *)"isp", -1,
Bram Moolenaar4ea8fe12006-03-09 22:32:39 +0000474 ISP_LATIN1, OPT_FREE, SID_NONE);
Bram Moolenaar362e1a32006-03-06 23:29:24 +0000475 set_string_option_direct((char_u *)"isk", -1,
476 ISK_LATIN1, OPT_FREE, SID_NONE);
477 opt_idx = findoption((char_u *)"isp");
Bram Moolenaarfc1421e2006-04-20 22:17:20 +0000478 if (opt_idx >= 0)
479 options[opt_idx].def_val[VIM_DEFAULT] = ISP_LATIN1;
Bram Moolenaar362e1a32006-03-06 23:29:24 +0000480 opt_idx = findoption((char_u *)"isk");
Bram Moolenaarfc1421e2006-04-20 22:17:20 +0000481 if (opt_idx >= 0)
482 options[opt_idx].def_val[VIM_DEFAULT] = ISK_LATIN1;
Bram Moolenaarc0197e22004-09-13 20:26:32 +0000483 (void)init_chartab();
484 }
485#endif
486
Bram Moolenaarafde13b2019-04-28 19:46:49 +0200487#if defined(MSWIN) && (!defined(FEAT_GUI) || defined(VIMDLL))
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100488 // Win32 console: When GetACP() returns a different value from
489 // GetConsoleCP() set 'termencoding'.
Bram Moolenaarafde13b2019-04-28 19:46:49 +0200490 if (
491# ifdef VIMDLL
492 (!gui.in_use && !gui.starting) &&
493# endif
494 GetACP() != GetConsoleCP())
Bram Moolenaar071d4272004-06-13 20:20:40 +0000495 {
496 char buf[50];
497
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100498 // Win32 console: In ConPTY, GetConsoleCP() returns zero.
499 // Use an alternative value.
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +0100500 if (GetConsoleCP() == 0)
501 sprintf(buf, "cp%ld", (long)GetACP());
502 else
503 sprintf(buf, "cp%ld", (long)GetConsoleCP());
Bram Moolenaar071d4272004-06-13 20:20:40 +0000504 p_tenc = vim_strsave((char_u *)buf);
505 if (p_tenc != NULL)
506 {
507 opt_idx = findoption((char_u *)"termencoding");
Bram Moolenaarfc1421e2006-04-20 22:17:20 +0000508 if (opt_idx >= 0)
509 {
510 options[opt_idx].def_val[VI_DEFAULT] = p_tenc;
511 options[opt_idx].flags |= P_DEF_ALLOCED;
512 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000513 convert_setup(&input_conv, p_tenc, p_enc);
514 convert_setup(&output_conv, p_enc, p_tenc);
515 }
516 else
517 p_tenc = empty_option;
518 }
Bram Moolenaarfc3abf42019-01-24 15:54:21 +0100519#endif
Bram Moolenaar4f974752019-02-17 17:44:42 +0100520#if defined(MSWIN)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100521 // $HOME may have characters in active code page.
Bram Moolenaar05159a02005-02-26 23:04:13 +0000522 init_homedir();
Bram Moolenaarfc3abf42019-01-24 15:54:21 +0100523#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000524 }
525 else
526 {
527 vim_free(p_enc);
528 p_enc = save_enc;
529 }
530 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000531
532#ifdef FEAT_MULTI_LANG
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100533 // Set the default for 'helplang'.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000534 set_helplang_default(get_mess_lang());
535#endif
536}
537
Bram Moolenaar5ffefbb2021-06-13 20:27:36 +0200538static char_u *fencs_utf8_default = (char_u *)"ucs-bom,utf-8,default,latin1";
539
540/*
541 * Set the "fileencodings" option to the default value for when 'encoding' is
542 * utf-8.
543 */
544 void
545set_fencs_unicode()
546{
547 set_string_option_direct((char_u *)"fencs", -1, fencs_utf8_default,
548 OPT_FREE, 0);
549}
550
Bram Moolenaar071d4272004-06-13 20:20:40 +0000551/*
552 * Set an option to its default value.
553 * This does not take care of side effects!
554 */
555 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100556set_option_default(
557 int opt_idx,
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100558 int opt_flags, // OPT_FREE, OPT_LOCAL and/or OPT_GLOBAL
559 int compatible) // use Vi default value
Bram Moolenaar071d4272004-06-13 20:20:40 +0000560{
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100561 char_u *varp; // pointer to variable for current option
562 int dvi; // index in def_val[]
Bram Moolenaar071d4272004-06-13 20:20:40 +0000563 long_u flags;
Bram Moolenaard1f56e62006-02-22 21:25:37 +0000564 long_u *flagsp;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000565 int both = (opt_flags & (OPT_LOCAL | OPT_GLOBAL)) == 0;
566
567 varp = get_varp_scope(&(options[opt_idx]), both ? OPT_LOCAL : opt_flags);
568 flags = options[opt_idx].flags;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100569 if (varp != NULL) // skip hidden option, nothing to do for it
Bram Moolenaar071d4272004-06-13 20:20:40 +0000570 {
571 dvi = ((flags & P_VI_DEF) || compatible) ? VI_DEFAULT : VIM_DEFAULT;
572 if (flags & P_STRING)
573 {
Bram Moolenaar5ffefbb2021-06-13 20:27:36 +0200574 // 'fencs' default value depends on 'encoding'
575 if (options[opt_idx].var == (char_u *)&p_fencs && enc_utf8)
576 set_fencs_unicode();
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100577 // Use set_string_option_direct() for local options to handle
578 // freeing and allocating the value.
Bram Moolenaar5ffefbb2021-06-13 20:27:36 +0200579 else if (options[opt_idx].indir != PV_NONE)
Bram Moolenaarb833c1e2018-05-05 16:36:06 +0200580 set_string_option_direct(NULL, opt_idx,
581 options[opt_idx].def_val[dvi], opt_flags, 0);
582 else
Bram Moolenaar071d4272004-06-13 20:20:40 +0000583 {
Bram Moolenaarb833c1e2018-05-05 16:36:06 +0200584 if ((opt_flags & OPT_FREE) && (flags & P_ALLOCED))
585 free_string_option(*(char_u **)(varp));
586 *(char_u **)varp = options[opt_idx].def_val[dvi];
587 options[opt_idx].flags &= ~P_ALLOCED;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000588 }
589 }
590 else if (flags & P_NUM)
591 {
Bram Moolenaar5fc1a8b2006-10-17 16:34:24 +0000592 if (options[opt_idx].indir == PV_SCROLL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000593 win_comp_scroll(curwin);
594 else
595 {
Bram Moolenaar375e3392019-01-31 18:26:10 +0100596 long def_val = (long)(long_i)options[opt_idx].def_val[dvi];
597
598 if ((long *)varp == &curwin->w_p_so
599 || (long *)varp == &curwin->w_p_siso)
600 // 'scrolloff' and 'sidescrolloff' local values have a
601 // different default value than the global default.
602 *(long *)varp = -1;
603 else
604 *(long *)varp = def_val;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100605 // May also set global value for local option.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000606 if (both)
607 *(long *)get_varp_scope(&(options[opt_idx]), OPT_GLOBAL) =
Bram Moolenaar375e3392019-01-31 18:26:10 +0100608 def_val;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000609 }
610 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100611 else // P_BOOL
Bram Moolenaar071d4272004-06-13 20:20:40 +0000612 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100613 // the cast to long is required for Manx C, long_i is needed for
614 // MSVC
Bram Moolenaareb3593b2006-04-22 22:33:57 +0000615 *(int *)varp = (int)(long)(long_i)options[opt_idx].def_val[dvi];
Bram Moolenaar8243a792007-05-01 17:05:03 +0000616#ifdef UNIX
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100617 // 'modeline' defaults to off for root
Bram Moolenaar8243a792007-05-01 17:05:03 +0000618 if (options[opt_idx].indir == PV_ML && getuid() == ROOT_UID)
619 *(int *)varp = FALSE;
620#endif
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100621 // May also set global value for local option.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000622 if (both)
623 *(int *)get_varp_scope(&(options[opt_idx]), OPT_GLOBAL) =
624 *(int *)varp;
625 }
Bram Moolenaarb71eaae2006-01-20 23:10:18 +0000626
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100627 // The default value is not insecure.
Bram Moolenaard1f56e62006-02-22 21:25:37 +0000628 flagsp = insecure_flag(opt_idx, opt_flags);
629 *flagsp = *flagsp & ~P_INSECURE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000630 }
631
632#ifdef FEAT_EVAL
Bram Moolenaarf29c1c62018-09-10 21:05:02 +0200633 set_option_sctx_idx(opt_idx, opt_flags, current_sctx);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000634#endif
635}
636
637/*
638 * Set all options (except terminal options) to their default value.
Bram Moolenaarb341dda2015-08-25 12:56:31 +0200639 * When "opt_flags" is non-zero skip 'encoding'.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000640 */
641 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100642set_options_default(
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100643 int opt_flags) // OPT_FREE, OPT_LOCAL and/or OPT_GLOBAL
Bram Moolenaar071d4272004-06-13 20:20:40 +0000644{
645 int i;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000646 win_T *wp;
Bram Moolenaarf740b292006-02-16 22:11:02 +0000647 tabpage_T *tp;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000648
Bram Moolenaardac13472019-09-16 21:06:21 +0200649 for (i = 0; !istermoption_idx(i); i++)
Bram Moolenaarb341dda2015-08-25 12:56:31 +0200650 if (!(options[i].flags & P_NODEFAULT)
Bram Moolenaare68c25c2015-08-25 15:39:55 +0200651 && (opt_flags == 0
Bram Moolenaarfc3abf42019-01-24 15:54:21 +0100652 || (options[i].var != (char_u *)&p_enc
Bram Moolenaar5ea87a02015-08-26 23:24:09 +0200653# if defined(FEAT_CRYPT)
Bram Moolenaare68c25c2015-08-25 15:39:55 +0200654 && options[i].var != (char_u *)&p_cm
Bram Moolenaar80606872015-08-25 21:27:35 +0200655 && options[i].var != (char_u *)&p_key
Bram Moolenaar5ea87a02015-08-26 23:24:09 +0200656# endif
Bram Moolenaarfc3abf42019-01-24 15:54:21 +0100657 )))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000658 set_option_default(i, opt_flags, p_cp);
659
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100660 // The 'scroll' option must be computed for all windows.
Bram Moolenaarf740b292006-02-16 22:11:02 +0000661 FOR_ALL_TAB_WINDOWS(tp, wp)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000662 win_comp_scroll(wp);
Bram Moolenaar5a4eceb2014-09-09 17:33:07 +0200663#ifdef FEAT_CINDENT
664 parse_cino(curbuf);
665#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000666}
667
668/*
669 * Set the Vi-default value of a string option.
670 * Used for 'sh', 'backupskip' and 'term'.
Bram Moolenaar4bfa8af2018-02-03 15:14:46 +0100671 * When "escape" is TRUE escape spaces with a backslash.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000672 */
Bram Moolenaar4bfa8af2018-02-03 15:14:46 +0100673 static void
674set_string_default_esc(char *name, char_u *val, int escape)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000675{
676 char_u *p;
677 int opt_idx;
678
Bram Moolenaar4bfa8af2018-02-03 15:14:46 +0100679 if (escape && vim_strchr(val, ' ') != NULL)
680 p = vim_strsave_escaped(val, (char_u *)" ");
681 else
682 p = vim_strsave(val);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100683 if (p != NULL) // we don't want a NULL
Bram Moolenaar071d4272004-06-13 20:20:40 +0000684 {
685 opt_idx = findoption((char_u *)name);
Bram Moolenaarfc1421e2006-04-20 22:17:20 +0000686 if (opt_idx >= 0)
687 {
688 if (options[opt_idx].flags & P_DEF_ALLOCED)
689 vim_free(options[opt_idx].def_val[VI_DEFAULT]);
690 options[opt_idx].def_val[VI_DEFAULT] = p;
691 options[opt_idx].flags |= P_DEF_ALLOCED;
692 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000693 }
694}
695
Bram Moolenaar4bfa8af2018-02-03 15:14:46 +0100696 void
697set_string_default(char *name, char_u *val)
698{
699 set_string_default_esc(name, val, FALSE);
700}
701
Bram Moolenaar071d4272004-06-13 20:20:40 +0000702/*
Bram Moolenaarb00ef052020-09-12 14:53:53 +0200703 * For an option value that contains comma separated items, find "newval" in
704 * "origval". Return NULL if not found.
705 */
706 static char_u *
707find_dup_item(char_u *origval, char_u *newval, long_u flags)
708{
Bram Moolenaar8f13d822020-09-12 21:04:23 +0200709 int bs = 0;
Bram Moolenaarb00ef052020-09-12 14:53:53 +0200710 size_t newlen;
711 char_u *s;
712
713 if (origval == NULL)
714 return NULL;
715
716 newlen = STRLEN(newval);
717 for (s = origval; *s != NUL; ++s)
718 {
719 if ((!(flags & P_COMMA)
720 || s == origval
721 || (s[-1] == ',' && !(bs & 1)))
722 && STRNCMP(s, newval, newlen) == 0
723 && (!(flags & P_COMMA)
724 || s[newlen] == ','
725 || s[newlen] == NUL))
726 return s;
727 // Count backslashes. Only a comma with an even number of backslashes
728 // or a single backslash preceded by a comma before it is recognized as
729 // a separator.
730 if ((s > origval + 1
731 && s[-1] == '\\'
732 && s[-2] != ',')
733 || (s == origval + 1
734 && s[-1] == '\\'))
735 ++bs;
736 else
737 bs = 0;
738 }
739 return NULL;
740}
741
742/*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000743 * Set the Vi-default value of a number option.
744 * Used for 'lines' and 'columns'.
745 */
746 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100747set_number_default(char *name, long val)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000748{
Bram Moolenaarfc1421e2006-04-20 22:17:20 +0000749 int opt_idx;
750
751 opt_idx = findoption((char_u *)name);
752 if (opt_idx >= 0)
Bram Moolenaareb3593b2006-04-22 22:33:57 +0000753 options[opt_idx].def_val[VI_DEFAULT] = (char_u *)(long_i)val;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000754}
755
Bram Moolenaarcacc6a52019-05-30 15:22:43 +0200756/*
757 * Set all window-local and buffer-local options to the Vim default.
758 * local-global options will use the global value.
Bram Moolenaar46451042019-08-24 15:50:46 +0200759 * When "do_buffer" is FALSE don't set buffer-local options.
Bram Moolenaarcacc6a52019-05-30 15:22:43 +0200760 */
761 void
Bram Moolenaar46451042019-08-24 15:50:46 +0200762set_local_options_default(win_T *wp, int do_buffer)
Bram Moolenaarcacc6a52019-05-30 15:22:43 +0200763{
764 win_T *save_curwin = curwin;
765 int i;
766
767 curwin = wp;
768 curbuf = curwin->w_buffer;
769 block_autocmds();
770
Bram Moolenaardac13472019-09-16 21:06:21 +0200771 for (i = 0; !istermoption_idx(i); i++)
Bram Moolenaarcacc6a52019-05-30 15:22:43 +0200772 {
773 struct vimoption *p = &(options[i]);
774 char_u *varp = get_varp_scope(p, OPT_LOCAL);
775
776 if (p->indir != PV_NONE
Bram Moolenaar46451042019-08-24 15:50:46 +0200777 && (do_buffer || (p->indir & PV_BUF) == 0)
Bram Moolenaarcacc6a52019-05-30 15:22:43 +0200778 && !(options[i].flags & P_NODEFAULT)
779 && !optval_default(p, varp, FALSE))
Bram Moolenaar86173482019-10-01 17:02:16 +0200780 set_option_default(i, OPT_FREE|OPT_LOCAL, FALSE);
Bram Moolenaarcacc6a52019-05-30 15:22:43 +0200781 }
782
783 unblock_autocmds();
784 curwin = save_curwin;
785 curbuf = curwin->w_buffer;
786}
787
Bram Moolenaarf461c8e2005-06-25 23:04:51 +0000788#if defined(EXITFREE) || defined(PROTO)
789/*
790 * Free all options.
791 */
792 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100793free_all_options(void)
Bram Moolenaarf461c8e2005-06-25 23:04:51 +0000794{
795 int i;
796
Bram Moolenaardac13472019-09-16 21:06:21 +0200797 for (i = 0; !istermoption_idx(i); i++)
Bram Moolenaarf461c8e2005-06-25 23:04:51 +0000798 {
799 if (options[i].indir == PV_NONE)
800 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100801 // global option: free value and default value.
Bram Moolenaar67391142017-02-19 21:07:04 +0100802 if ((options[i].flags & P_ALLOCED) && options[i].var != NULL)
Bram Moolenaarf461c8e2005-06-25 23:04:51 +0000803 free_string_option(*(char_u **)options[i].var);
804 if (options[i].flags & P_DEF_ALLOCED)
805 free_string_option(options[i].def_val[VI_DEFAULT]);
806 }
807 else if (options[i].var != VAR_WIN
808 && (options[i].flags & P_STRING))
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100809 // buffer-local option: free global value
Bram Moolenaar77111e22021-07-29 21:11:30 +0200810 clear_string_option((char_u **)options[i].var);
Bram Moolenaarf461c8e2005-06-25 23:04:51 +0000811 }
Yegappan Lakshmanan777175b2021-11-18 22:08:57 +0000812 free_operatorfunc_option();
Yegappan Lakshmanan19916a82021-11-24 16:32:55 +0000813 free_tagfunc_option();
Bram Moolenaarf461c8e2005-06-25 23:04:51 +0000814}
815#endif
816
817
Bram Moolenaar071d4272004-06-13 20:20:40 +0000818/*
819 * Initialize the options, part two: After getting Rows and Columns and
820 * setting 'term'.
821 */
822 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100823set_init_2(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000824{
Bram Moolenaar4399ef42005-02-12 14:29:27 +0000825 int idx;
826
Bram Moolenaar071d4272004-06-13 20:20:40 +0000827 /*
Bram Moolenaaraf2d20c2017-10-29 15:26:57 +0100828 * 'scroll' defaults to half the window height. The stored default is zero,
829 * which results in the actual value computed from the window height.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000830 */
Bram Moolenaar26a60b42005-02-22 08:49:11 +0000831 idx = findoption((char_u *)"scroll");
Bram Moolenaarfc1421e2006-04-20 22:17:20 +0000832 if (idx >= 0 && !(options[idx].flags & P_WAS_SET))
Bram Moolenaar26a60b42005-02-22 08:49:11 +0000833 set_option_default(idx, OPT_LOCAL, p_cp);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000834 comp_col();
835
Bram Moolenaar4399ef42005-02-12 14:29:27 +0000836 /*
837 * 'window' is only for backwards compatibility with Vi.
838 * Default is Rows - 1.
839 */
Bram Moolenaard68071d2006-05-02 22:08:30 +0000840 if (!option_was_set((char_u *)"window"))
Bram Moolenaar4399ef42005-02-12 14:29:27 +0000841 p_window = Rows - 1;
842 set_number_default("window", Rows - 1);
843
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100844 // For DOS console the default is always black.
Bram Moolenaar4f974752019-02-17 17:44:42 +0100845#if !((defined(MSWIN)) && !defined(FEAT_GUI))
Bram Moolenaarf740b292006-02-16 22:11:02 +0000846 /*
847 * If 'background' wasn't set by the user, try guessing the value,
848 * depending on the terminal name. Only need to check for terminals
849 * with a dark background, that can handle color.
850 */
851 idx = findoption((char_u *)"bg");
Bram Moolenaarfc1421e2006-04-20 22:17:20 +0000852 if (idx >= 0 && !(options[idx].flags & P_WAS_SET)
853 && *term_bg_default() == 'd')
Bram Moolenaar071d4272004-06-13 20:20:40 +0000854 {
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +0000855 set_string_option_direct(NULL, idx, (char_u *)"dark", OPT_FREE, 0);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100856 // don't mark it as set, when starting the GUI it may be
857 // changed again
Bram Moolenaarf740b292006-02-16 22:11:02 +0000858 options[idx].flags &= ~P_WAS_SET;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000859 }
860#endif
Bram Moolenaar58d98232005-07-23 22:25:46 +0000861
862#ifdef CURSOR_SHAPE
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100863 parse_shape_opt(SHAPE_CURSOR); // set cursor shapes from 'guicursor'
Bram Moolenaar58d98232005-07-23 22:25:46 +0000864#endif
865#ifdef FEAT_MOUSESHAPE
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100866 parse_shape_opt(SHAPE_MOUSE); // set mouse shapes from 'mouseshape'
Bram Moolenaar58d98232005-07-23 22:25:46 +0000867#endif
868#ifdef FEAT_PRINTER
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100869 (void)parse_printoptions(); // parse 'printoptions' default value
Bram Moolenaar58d98232005-07-23 22:25:46 +0000870#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000871}
872
873/*
874 * Initialize the options, part three: After reading the .vimrc
875 */
876 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100877set_init_3(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000878{
Bram Moolenaar4f974752019-02-17 17:44:42 +0100879#if defined(UNIX) || defined(MSWIN)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000880/*
881 * Set 'shellpipe' and 'shellredir', depending on the 'shell' option.
882 * This is done after other initializations, where 'shell' might have been
883 * set, but only if they have not been set before.
884 */
885 char_u *p;
886 int idx_srr;
887 int do_srr;
Bram Moolenaare7fedb62015-12-31 19:07:19 +0100888# ifdef FEAT_QUICKFIX
Bram Moolenaar071d4272004-06-13 20:20:40 +0000889 int idx_sp;
890 int do_sp;
Bram Moolenaare7fedb62015-12-31 19:07:19 +0100891# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000892
893 idx_srr = findoption((char_u *)"srr");
Bram Moolenaarfc1421e2006-04-20 22:17:20 +0000894 if (idx_srr < 0)
895 do_srr = FALSE;
896 else
897 do_srr = !(options[idx_srr].flags & P_WAS_SET);
Bram Moolenaare7fedb62015-12-31 19:07:19 +0100898# ifdef FEAT_QUICKFIX
Bram Moolenaar071d4272004-06-13 20:20:40 +0000899 idx_sp = findoption((char_u *)"sp");
Bram Moolenaarfc1421e2006-04-20 22:17:20 +0000900 if (idx_sp < 0)
901 do_sp = FALSE;
902 else
903 do_sp = !(options[idx_sp].flags & P_WAS_SET);
Bram Moolenaare7fedb62015-12-31 19:07:19 +0100904# endif
Bram Moolenaar75a8d742014-05-07 15:10:21 +0200905 p = get_isolated_shell_name();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000906 if (p != NULL)
907 {
908 /*
909 * Default for p_sp is "| tee", for p_srr is ">".
910 * For known shells it is changed here to include stderr.
911 */
912 if ( fnamecmp(p, "csh") == 0
913 || fnamecmp(p, "tcsh") == 0
Bram Moolenaar4f974752019-02-17 17:44:42 +0100914# if defined(MSWIN) // also check with .exe extension
Bram Moolenaar071d4272004-06-13 20:20:40 +0000915 || fnamecmp(p, "csh.exe") == 0
916 || fnamecmp(p, "tcsh.exe") == 0
917# endif
918 )
919 {
Bram Moolenaare7fedb62015-12-31 19:07:19 +0100920# if defined(FEAT_QUICKFIX)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000921 if (do_sp)
922 {
Bram Moolenaar4f974752019-02-17 17:44:42 +0100923# ifdef MSWIN
Bram Moolenaar071d4272004-06-13 20:20:40 +0000924 p_sp = (char_u *)">&";
Bram Moolenaare7fedb62015-12-31 19:07:19 +0100925# else
Bram Moolenaar071d4272004-06-13 20:20:40 +0000926 p_sp = (char_u *)"|& tee";
Bram Moolenaare7fedb62015-12-31 19:07:19 +0100927# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000928 options[idx_sp].def_val[VI_DEFAULT] = p_sp;
929 }
Bram Moolenaare7fedb62015-12-31 19:07:19 +0100930# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000931 if (do_srr)
932 {
933 p_srr = (char_u *)">&";
934 options[idx_srr].def_val[VI_DEFAULT] = p_srr;
935 }
936 }
Mike Williams12795022021-06-28 20:53:58 +0200937# ifdef MSWIN
Mike Williamsa3d1b292021-06-30 20:56:00 +0200938 // Windows PowerShell output is UTF-16 with BOM so re-encode to the
939 // current codepage.
Mike Williams12795022021-06-28 20:53:58 +0200940 else if ( fnamecmp(p, "powershell") == 0
941 || fnamecmp(p, "powershell.exe") == 0
942 )
943 {
944# if defined(FEAT_QUICKFIX)
945 if (do_sp)
946 {
947 p_sp = (char_u *)"2>&1 | Out-File -Encoding default";
948 options[idx_sp].def_val[VI_DEFAULT] = p_sp;
949 }
950# endif
951 if (do_srr)
952 {
953 p_srr = (char_u *)"2>&1 | Out-File -Encoding default";
954 options[idx_srr].def_val[VI_DEFAULT] = p_srr;
955 }
956 }
957#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000958 else
Natanael Copa56318362021-05-06 18:46:35 +0200959 // Always use POSIX shell style redirection if we reach this
Bram Moolenaar071d4272004-06-13 20:20:40 +0000960 if ( fnamecmp(p, "sh") == 0
961 || fnamecmp(p, "ksh") == 0
Bram Moolenaarf1fda2d2011-04-28 12:57:36 +0200962 || fnamecmp(p, "mksh") == 0
963 || fnamecmp(p, "pdksh") == 0
Bram Moolenaar071d4272004-06-13 20:20:40 +0000964 || fnamecmp(p, "zsh") == 0
Bram Moolenaarc1e37902006-04-18 21:55:01 +0000965 || fnamecmp(p, "zsh-beta") == 0
Bram Moolenaar071d4272004-06-13 20:20:40 +0000966 || fnamecmp(p, "bash") == 0
Bram Moolenaar75a8d742014-05-07 15:10:21 +0200967 || fnamecmp(p, "fish") == 0
Natanael Copa56318362021-05-06 18:46:35 +0200968 || fnamecmp(p, "ash") == 0
969 || fnamecmp(p, "dash") == 0
Mike Williamsa3d1b292021-06-30 20:56:00 +0200970 || fnamecmp(p, "pwsh") == 0
Bram Moolenaar4f974752019-02-17 17:44:42 +0100971# ifdef MSWIN
Bram Moolenaar071d4272004-06-13 20:20:40 +0000972 || fnamecmp(p, "cmd") == 0
973 || fnamecmp(p, "sh.exe") == 0
974 || fnamecmp(p, "ksh.exe") == 0
Bram Moolenaarf1fda2d2011-04-28 12:57:36 +0200975 || fnamecmp(p, "mksh.exe") == 0
976 || fnamecmp(p, "pdksh.exe") == 0
Bram Moolenaar071d4272004-06-13 20:20:40 +0000977 || fnamecmp(p, "zsh.exe") == 0
Bram Moolenaarc1e37902006-04-18 21:55:01 +0000978 || fnamecmp(p, "zsh-beta.exe") == 0
Bram Moolenaar071d4272004-06-13 20:20:40 +0000979 || fnamecmp(p, "bash.exe") == 0
980 || fnamecmp(p, "cmd.exe") == 0
Natanael Copa56318362021-05-06 18:46:35 +0200981 || fnamecmp(p, "dash.exe") == 0
Mike Williamsa3d1b292021-06-30 20:56:00 +0200982 || fnamecmp(p, "pwsh.exe") == 0
Bram Moolenaar071d4272004-06-13 20:20:40 +0000983# endif
Bram Moolenaare7fedb62015-12-31 19:07:19 +0100984 )
Bram Moolenaar071d4272004-06-13 20:20:40 +0000985 {
Bram Moolenaare7fedb62015-12-31 19:07:19 +0100986# if defined(FEAT_QUICKFIX)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000987 if (do_sp)
988 {
Bram Moolenaar4f974752019-02-17 17:44:42 +0100989# ifdef MSWIN
Bram Moolenaar071d4272004-06-13 20:20:40 +0000990 p_sp = (char_u *)">%s 2>&1";
Bram Moolenaare7fedb62015-12-31 19:07:19 +0100991# else
Mike Williamsa3d1b292021-06-30 20:56:00 +0200992 if (fnamecmp(p, "pwsh") == 0)
993 p_sp = (char_u *)">%s 2>&1";
994 else
995 p_sp = (char_u *)"2>&1| tee";
Bram Moolenaare7fedb62015-12-31 19:07:19 +0100996# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000997 options[idx_sp].def_val[VI_DEFAULT] = p_sp;
998 }
Bram Moolenaare7fedb62015-12-31 19:07:19 +0100999# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001000 if (do_srr)
1001 {
1002 p_srr = (char_u *)">%s 2>&1";
1003 options[idx_srr].def_val[VI_DEFAULT] = p_srr;
1004 }
1005 }
1006 vim_free(p);
1007 }
1008#endif
1009
Bram Moolenaar4f974752019-02-17 17:44:42 +01001010#if defined(MSWIN)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001011 /*
Bram Moolenaara64ba222012-02-12 23:23:31 +01001012 * Set 'shellcmdflag', 'shellxquote', and 'shellquote' depending on the
1013 * 'shell' option.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001014 * This is done after other initializations, where 'shell' might have been
Mike Williams12795022021-06-28 20:53:58 +02001015 * set, but only if they have not been set before.
1016 * Default values depend on shell (cmd.exe is default shell):
1017 *
1018 * p_shcf p_sxq
1019 * cmd.exe - "/c" "("
1020 * powershell.exe - "-Command" "\""
Mike Williamsa3d1b292021-06-30 20:56:00 +02001021 * pwsh.exe - "-c" "\""
Mike Williams12795022021-06-28 20:53:58 +02001022 * "sh" like shells - "-c" "\""
1023 *
1024 * For Win32 p_sxq is set instead of p_shq to include shell redirection.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001025 */
Mike Williams12795022021-06-28 20:53:58 +02001026 if (strstr((char *)gettail(p_sh), "powershell") != NULL)
1027 {
1028 int idx_opt;
1029
1030 idx_opt = findoption((char_u *)"shcf");
1031 if (idx_opt >= 0 && !(options[idx_opt].flags & P_WAS_SET))
1032 {
1033 p_shcf = (char_u*)"-Command";
1034 options[idx_opt].def_val[VI_DEFAULT] = p_shcf;
1035 }
1036
1037 idx_opt = findoption((char_u *)"sxq");
1038 if (idx_opt >= 0 && !(options[idx_opt].flags & P_WAS_SET))
1039 {
1040 p_sxq = (char_u*)"\"";
1041 options[idx_opt].def_val[VI_DEFAULT] = p_sxq;
1042 }
1043 }
1044 else if (strstr((char *)gettail(p_sh), "sh") != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001045 {
1046 int idx3;
1047
1048 idx3 = findoption((char_u *)"shcf");
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00001049 if (idx3 >= 0 && !(options[idx3].flags & P_WAS_SET))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001050 {
1051 p_shcf = (char_u *)"-c";
1052 options[idx3].def_val[VI_DEFAULT] = p_shcf;
1053 }
1054
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001055 // Somehow Win32 requires the quotes around the redirection too
Bram Moolenaar071d4272004-06-13 20:20:40 +00001056 idx3 = findoption((char_u *)"sxq");
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00001057 if (idx3 >= 0 && !(options[idx3].flags & P_WAS_SET))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001058 {
1059 p_sxq = (char_u *)"\"";
1060 options[idx3].def_val[VI_DEFAULT] = p_sxq;
1061 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001062 }
Bram Moolenaara64ba222012-02-12 23:23:31 +01001063 else if (strstr((char *)gettail(p_sh), "cmd.exe") != NULL)
1064 {
1065 int idx3;
1066
1067 /*
1068 * cmd.exe on Windows will strip the first and last double quote given
1069 * on the command line, e.g. most of the time things like:
1070 * cmd /c "my path/to/echo" "my args to echo"
1071 * become:
1072 * my path/to/echo" "my args to echo
1073 * when executed.
1074 *
Bram Moolenaar034b1152012-02-19 18:19:30 +01001075 * To avoid this, set shellxquote to surround the command in
1076 * parenthesis. This appears to make most commands work, without
1077 * breaking commands that worked previously, such as
1078 * '"path with spaces/cmd" "a&b"'.
Bram Moolenaara64ba222012-02-12 23:23:31 +01001079 */
Bram Moolenaara64ba222012-02-12 23:23:31 +01001080 idx3 = findoption((char_u *)"sxq");
1081 if (idx3 >= 0 && !(options[idx3].flags & P_WAS_SET))
1082 {
Bram Moolenaar034b1152012-02-19 18:19:30 +01001083 p_sxq = (char_u *)"(";
Bram Moolenaara64ba222012-02-12 23:23:31 +01001084 options[idx3].def_val[VI_DEFAULT] = p_sxq;
1085 }
1086
Bram Moolenaara64ba222012-02-12 23:23:31 +01001087 idx3 = findoption((char_u *)"shcf");
1088 if (idx3 >= 0 && !(options[idx3].flags & P_WAS_SET))
1089 {
Bram Moolenaar034b1152012-02-19 18:19:30 +01001090 p_shcf = (char_u *)"/c";
Bram Moolenaara64ba222012-02-12 23:23:31 +01001091 options[idx3].def_val[VI_DEFAULT] = p_shcf;
1092 }
1093 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001094#endif
1095
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01001096 if (BUFEMPTY())
Bram Moolenaar364fa5c2016-03-20 17:53:25 +01001097 {
1098 int idx_ffs = findoption((char_u *)"ffs");
1099
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001100 // Apply the first entry of 'fileformats' to the initial buffer.
Bram Moolenaar364fa5c2016-03-20 17:53:25 +01001101 if (idx_ffs >= 0 && (options[idx_ffs].flags & P_WAS_SET))
1102 set_fileformat(default_fileformat(), OPT_LOCAL);
1103 }
1104
Bram Moolenaar071d4272004-06-13 20:20:40 +00001105 set_title_defaults();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001106}
1107
1108#if defined(FEAT_MULTI_LANG) || defined(PROTO)
1109/*
1110 * When 'helplang' is still at its default value, set it to "lang".
1111 * Only the first two characters of "lang" are used.
1112 */
1113 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01001114set_helplang_default(char_u *lang)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001115{
1116 int idx;
1117
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001118 if (lang == NULL || STRLEN(lang) < 2) // safety check
Bram Moolenaar071d4272004-06-13 20:20:40 +00001119 return;
1120 idx = findoption((char_u *)"hlg");
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00001121 if (idx >= 0 && !(options[idx].flags & P_WAS_SET))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001122 {
1123 if (options[idx].flags & P_ALLOCED)
1124 free_string_option(p_hlg);
1125 p_hlg = vim_strsave(lang);
1126 if (p_hlg == NULL)
1127 p_hlg = empty_option;
1128 else
Bram Moolenaarab79bcb2004-07-18 21:34:53 +00001129 {
Bram Moolenaardcd71cb2018-11-04 14:40:47 +01001130 // zh_CN becomes "cn", zh_TW becomes "tw"
Bram Moolenaarab79bcb2004-07-18 21:34:53 +00001131 if (STRNICMP(p_hlg, "zh_", 3) == 0 && STRLEN(p_hlg) >= 5)
1132 {
1133 p_hlg[0] = TOLOWER_ASC(p_hlg[3]);
1134 p_hlg[1] = TOLOWER_ASC(p_hlg[4]);
1135 }
Bram Moolenaardcd71cb2018-11-04 14:40:47 +01001136 // any C like setting, such as C.UTF-8, becomes "en"
1137 else if (STRLEN(p_hlg) >= 1 && *p_hlg == 'C')
1138 {
1139 p_hlg[0] = 'e';
1140 p_hlg[1] = 'n';
1141 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001142 p_hlg[2] = NUL;
Bram Moolenaarab79bcb2004-07-18 21:34:53 +00001143 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001144 options[idx].flags |= P_ALLOCED;
1145 }
1146}
1147#endif
1148
Bram Moolenaar071d4272004-06-13 20:20:40 +00001149/*
1150 * 'title' and 'icon' only default to true if they have not been set or reset
1151 * in .vimrc and we can read the old value.
1152 * When 'title' and 'icon' have been reset in .vimrc, we won't even check if
1153 * they can be reset. This reduces startup time when using X on a remote
1154 * machine.
1155 */
1156 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01001157set_title_defaults(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001158{
1159 int idx1;
1160 long val;
1161
1162 /*
1163 * If GUI is (going to be) used, we can always set the window title and
1164 * icon name. Saves a bit of time, because the X11 display server does
1165 * not need to be contacted.
1166 */
1167 idx1 = findoption((char_u *)"title");
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00001168 if (idx1 >= 0 && !(options[idx1].flags & P_WAS_SET))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001169 {
1170#ifdef FEAT_GUI
1171 if (gui.starting || gui.in_use)
1172 val = TRUE;
1173 else
1174#endif
1175 val = mch_can_restore_title();
Bram Moolenaareb3593b2006-04-22 22:33:57 +00001176 options[idx1].def_val[VI_DEFAULT] = (char_u *)(long_i)val;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001177 p_title = val;
1178 }
1179 idx1 = findoption((char_u *)"icon");
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00001180 if (idx1 >= 0 && !(options[idx1].flags & P_WAS_SET))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001181 {
1182#ifdef FEAT_GUI
1183 if (gui.starting || gui.in_use)
1184 val = TRUE;
1185 else
1186#endif
1187 val = mch_can_restore_icon();
Bram Moolenaareb3593b2006-04-22 22:33:57 +00001188 options[idx1].def_val[VI_DEFAULT] = (char_u *)(long_i)val;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001189 p_icon = val;
1190 }
1191}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001192
Bram Moolenaar6b915c02020-01-18 15:53:19 +01001193 void
1194ex_set(exarg_T *eap)
1195{
1196 int flags = 0;
1197
1198 if (eap->cmdidx == CMD_setlocal)
1199 flags = OPT_LOCAL;
1200 else if (eap->cmdidx == CMD_setglobal)
1201 flags = OPT_GLOBAL;
1202#if defined(FEAT_EVAL) && defined(FEAT_BROWSE)
Bram Moolenaare1004402020-10-24 20:49:43 +02001203 if ((cmdmod.cmod_flags & CMOD_BROWSE) && flags == 0)
Bram Moolenaar6b915c02020-01-18 15:53:19 +01001204 ex_options(eap);
1205 else
1206#endif
1207 {
1208 if (eap->forceit)
1209 flags |= OPT_ONECOLUMN;
1210 (void)do_set(eap->arg, flags);
1211 }
1212}
1213
Bram Moolenaar071d4272004-06-13 20:20:40 +00001214/*
1215 * Parse 'arg' for option settings.
1216 *
1217 * 'arg' may be IObuff, but only when no errors can be present and option
1218 * does not need to be expanded with option_expand().
1219 * "opt_flags":
1220 * 0 for ":set"
Bram Moolenaar15a24f02021-12-03 20:43:24 +00001221 * OPT_GLOBAL for ":setglobal"
1222 * OPT_LOCAL for ":setlocal" and a modeline
1223 * OPT_MODELINE for a modeline
1224 * OPT_WINONLY to only set window-local options
1225 * OPT_NOWIN to skip setting window-local options
1226 * OPT_ONECOLUMN do not use multiple columns
Bram Moolenaar071d4272004-06-13 20:20:40 +00001227 *
1228 * returns FAIL if an error is detected, OK otherwise
1229 */
1230 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01001231do_set(
Bram Moolenaar1594f312021-07-08 16:40:13 +02001232 char_u *arg_start, // option string (may be written to!)
Bram Moolenaar9b578142016-01-30 19:39:49 +01001233 int opt_flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001234{
Bram Moolenaar1594f312021-07-08 16:40:13 +02001235 char_u *arg = arg_start;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001236 int opt_idx;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001237 char *errmsg;
1238 char errbuf[80];
Bram Moolenaar071d4272004-06-13 20:20:40 +00001239 char_u *startarg;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001240 int prefix; // 1: nothing, 0: "no", 2: "inv" in front of name
1241 int nextchar; // next non-white char after option name
1242 int afterchar; // character just after option name
Bram Moolenaar071d4272004-06-13 20:20:40 +00001243 int len;
1244 int i;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02001245 varnumber_T value;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001246 int key;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001247 long_u flags; // flags for current option
1248 char_u *varp = NULL; // pointer to variable for current option
1249 int did_show = FALSE; // already showed one value
1250 int adding; // "opt+=arg"
1251 int prepending; // "opt^=arg"
1252 int removing; // "opt-=arg"
Bram Moolenaar071d4272004-06-13 20:20:40 +00001253 int cp_val = 0;
1254 char_u key_name[2];
1255
1256 if (*arg == NUL)
1257 {
1258 showoptions(0, opt_flags);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001259 did_show = TRUE;
1260 goto theend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001261 }
1262
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001263 while (*arg != NUL) // loop to process all options
Bram Moolenaar071d4272004-06-13 20:20:40 +00001264 {
1265 errmsg = NULL;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001266 startarg = arg; // remember for error message
Bram Moolenaar071d4272004-06-13 20:20:40 +00001267
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001268 if (STRNCMP(arg, "all", 3) == 0 && !isalpha(arg[3])
1269 && !(opt_flags & OPT_MODELINE))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001270 {
1271 /*
1272 * ":set all" show all options.
1273 * ":set all&" set all options to their default value.
1274 */
1275 arg += 3;
1276 if (*arg == '&')
1277 {
1278 ++arg;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001279 // Only for :set command set global value of local options.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001280 set_options_default(OPT_FREE | opt_flags);
Bram Moolenaare68c25c2015-08-25 15:39:55 +02001281 didset_options();
1282 didset_options2();
Bram Moolenaarb341dda2015-08-25 12:56:31 +02001283 redraw_all_later(CLEAR);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001284 }
1285 else
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001286 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001287 showoptions(1, opt_flags);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001288 did_show = TRUE;
1289 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001290 }
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001291 else if (STRNCMP(arg, "termcap", 7) == 0 && !(opt_flags & OPT_MODELINE))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001292 {
1293 showoptions(2, opt_flags);
Bram Moolenaar15a24f02021-12-03 20:43:24 +00001294 show_termcodes(opt_flags);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001295 did_show = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001296 arg += 7;
1297 }
1298 else
1299 {
1300 prefix = 1;
Bram Moolenaar2a7b9ee2009-06-16 15:50:33 +00001301 if (STRNCMP(arg, "no", 2) == 0 && STRNCMP(arg, "novice", 6) != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001302 {
1303 prefix = 0;
1304 arg += 2;
1305 }
1306 else if (STRNCMP(arg, "inv", 3) == 0)
1307 {
1308 prefix = 2;
1309 arg += 3;
1310 }
1311
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001312 // find end of name
Bram Moolenaar071d4272004-06-13 20:20:40 +00001313 key = 0;
1314 if (*arg == '<')
1315 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001316 opt_idx = -1;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001317 // look out for <t_>;>
Bram Moolenaar071d4272004-06-13 20:20:40 +00001318 if (arg[1] == 't' && arg[2] == '_' && arg[3] && arg[4])
1319 len = 5;
1320 else
1321 {
1322 len = 1;
1323 while (arg[len] != NUL && arg[len] != '>')
1324 ++len;
1325 }
1326 if (arg[len] != '>')
1327 {
1328 errmsg = e_invarg;
1329 goto skip;
1330 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001331 arg[len] = NUL; // put NUL after name
1332 if (arg[1] == 't' && arg[2] == '_') // could be term code
Bram Moolenaar071d4272004-06-13 20:20:40 +00001333 opt_idx = findoption(arg + 1);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001334 arg[len++] = '>'; // restore '>'
Bram Moolenaar071d4272004-06-13 20:20:40 +00001335 if (opt_idx == -1)
Bram Moolenaar9cf4b502018-07-23 04:12:03 +02001336 key = find_key_option(arg + 1, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001337 }
1338 else
1339 {
1340 len = 0;
1341 /*
1342 * The two characters after "t_" may not be alphanumeric.
1343 */
1344 if (arg[0] == 't' && arg[1] == '_' && arg[2] && arg[3])
1345 len = 4;
1346 else
1347 while (ASCII_ISALNUM(arg[len]) || arg[len] == '_')
1348 ++len;
1349 nextchar = arg[len];
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001350 arg[len] = NUL; // put NUL after name
Bram Moolenaar071d4272004-06-13 20:20:40 +00001351 opt_idx = findoption(arg);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001352 arg[len] = nextchar; // restore nextchar
Bram Moolenaar071d4272004-06-13 20:20:40 +00001353 if (opt_idx == -1)
Bram Moolenaar9cf4b502018-07-23 04:12:03 +02001354 key = find_key_option(arg, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001355 }
1356
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001357 // remember character after option name
Bram Moolenaar071d4272004-06-13 20:20:40 +00001358 afterchar = arg[len];
1359
Bram Moolenaardeb108b2021-07-08 17:35:36 +02001360 if (in_vim9script())
1361 {
1362 char_u *p = skipwhite(arg + len);
1363
1364 // disallow white space before =val, +=val, -=val, ^=val
1365 if (p > arg + len && (p[0] == '='
1366 || (vim_strchr((char_u *)"+-^", p[0]) != NULL
1367 && p[1] == '=')))
1368 {
1369 errmsg = e_no_white_space_allowed_between_option_and;
1370 arg = p;
1371 startarg = p;
1372 goto skip;
1373 }
1374 }
1375 else
Bram Moolenaar208f0b42021-06-20 12:40:08 +02001376 // skip white space, allow ":set ai ?", ":set hlsearch !"
1377 while (VIM_ISWHITE(arg[len]))
1378 ++len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001379
1380 adding = FALSE;
1381 prepending = FALSE;
1382 removing = FALSE;
1383 if (arg[len] != NUL && arg[len + 1] == '=')
1384 {
1385 if (arg[len] == '+')
1386 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001387 adding = TRUE; // "+="
Bram Moolenaar071d4272004-06-13 20:20:40 +00001388 ++len;
1389 }
1390 else if (arg[len] == '^')
1391 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001392 prepending = TRUE; // "^="
Bram Moolenaar071d4272004-06-13 20:20:40 +00001393 ++len;
1394 }
1395 else if (arg[len] == '-')
1396 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001397 removing = TRUE; // "-="
Bram Moolenaar071d4272004-06-13 20:20:40 +00001398 ++len;
1399 }
1400 }
1401 nextchar = arg[len];
1402
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001403 if (opt_idx == -1 && key == 0) // found a mismatch: skip
Bram Moolenaar071d4272004-06-13 20:20:40 +00001404 {
Bram Moolenaar1594f312021-07-08 16:40:13 +02001405 if (in_vim9script() && arg > arg_start
1406 && vim_strchr((char_u *)"!&<", *arg) != NULL)
1407 errmsg = e_no_white_space_allowed_between_option_and;
1408 else
1409 errmsg = N_("E518: Unknown option");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001410 goto skip;
1411 }
1412
1413 if (opt_idx >= 0)
1414 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001415 if (options[opt_idx].var == NULL) // hidden option: skip
Bram Moolenaar071d4272004-06-13 20:20:40 +00001416 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001417 // Only give an error message when requesting the value of
1418 // a hidden option, ignore setting it.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001419 if (vim_strchr((char_u *)"=:!&<", nextchar) == NULL
1420 && (!(options[opt_idx].flags & P_BOOL)
1421 || nextchar == '?'))
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001422 errmsg = N_("E519: Option not supported");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001423 goto skip;
1424 }
1425
1426 flags = options[opt_idx].flags;
1427 varp = get_varp_scope(&(options[opt_idx]), opt_flags);
1428 }
1429 else
1430 {
1431 flags = P_STRING;
1432 if (key < 0)
1433 {
1434 key_name[0] = KEY2TERMCAP0(key);
1435 key_name[1] = KEY2TERMCAP1(key);
1436 }
1437 else
1438 {
1439 key_name[0] = KS_KEY;
1440 key_name[1] = (key & 0xff);
1441 }
1442 }
1443
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001444 // Skip all options that are not window-local (used when showing
1445 // an already loaded buffer in a window).
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00001446 if ((opt_flags & OPT_WINONLY)
1447 && (opt_idx < 0 || options[opt_idx].var != VAR_WIN))
1448 goto skip;
1449
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001450 // Skip all options that are window-local (used for :vimgrep).
Bram Moolenaara3227e22006-03-08 21:32:40 +00001451 if ((opt_flags & OPT_NOWIN) && opt_idx >= 0
1452 && options[opt_idx].var == VAR_WIN)
1453 goto skip;
1454
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001455 // Disallow changing some options from modelines.
Bram Moolenaar1bf0ddc2009-02-11 15:47:05 +00001456 if (opt_flags & OPT_MODELINE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001457 {
Bram Moolenaar865242e2010-07-14 21:12:05 +02001458 if (flags & (P_SECURE | P_NO_ML))
Bram Moolenaar1bf0ddc2009-02-11 15:47:05 +00001459 {
Bram Moolenaar994b89d2020-08-07 19:12:41 +02001460 errmsg = N_("E520: Not allowed in a modeline");
Bram Moolenaar1bf0ddc2009-02-11 15:47:05 +00001461 goto skip;
1462 }
Bram Moolenaar110289e2019-05-23 15:38:06 +02001463 if ((flags & P_MLE) && !p_mle)
1464 {
Bram Moolenaar994b89d2020-08-07 19:12:41 +02001465 errmsg = N_("E992: Not allowed in a modeline when 'modelineexpr' is off");
Bram Moolenaar110289e2019-05-23 15:38:06 +02001466 goto skip;
1467 }
Bram Moolenaarf69d9a32009-02-11 21:48:40 +00001468#ifdef FEAT_DIFF
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001469 // In diff mode some options are overruled. This avoids that
1470 // 'foldmethod' becomes "marker" instead of "diff" and that
1471 // "wrap" gets set.
Bram Moolenaar1bf0ddc2009-02-11 15:47:05 +00001472 if (curwin->w_p_diff
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001473 && opt_idx >= 0 // shut up coverity warning
Bram Moolenaara6c07602017-03-05 21:18:27 +01001474 && (
1475#ifdef FEAT_FOLDING
1476 options[opt_idx].indir == PV_FDM ||
1477#endif
1478 options[opt_idx].indir == PV_WRAP))
Bram Moolenaar1bf0ddc2009-02-11 15:47:05 +00001479 goto skip;
Bram Moolenaarf69d9a32009-02-11 21:48:40 +00001480#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001481 }
1482
1483#ifdef HAVE_SANDBOX
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001484 // Disallow changing some options in the sandbox
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00001485 if (sandbox != 0 && (flags & P_SECURE))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001486 {
Bram Moolenaard8e44472021-07-21 22:20:33 +02001487 errmsg = e_not_allowed_in_sandbox;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001488 goto skip;
1489 }
1490#endif
1491
1492 if (vim_strchr((char_u *)"?=:!&<", nextchar) != NULL)
1493 {
1494 arg += len;
1495 cp_val = p_cp;
1496 if (nextchar == '&' && arg[1] == 'v' && arg[2] == 'i')
1497 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001498 if (arg[3] == 'm') // "opt&vim": set to Vim default
Bram Moolenaar071d4272004-06-13 20:20:40 +00001499 {
1500 cp_val = FALSE;
1501 arg += 3;
1502 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001503 else // "opt&vi": set to Vi default
Bram Moolenaar071d4272004-06-13 20:20:40 +00001504 {
1505 cp_val = TRUE;
1506 arg += 2;
1507 }
1508 }
1509 if (vim_strchr((char_u *)"?!&<", nextchar) != NULL
Bram Moolenaar1c465442017-03-12 20:10:05 +01001510 && arg[1] != NUL && !VIM_ISWHITE(arg[1]))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001511 {
1512 errmsg = e_trailing;
1513 goto skip;
1514 }
1515 }
1516
1517 /*
Bram Moolenaara80faa82020-04-12 19:37:17 +02001518 * allow '=' and ':' for historical reasons (MSDOS command.com
Bram Moolenaar48e330a2016-02-23 14:53:34 +01001519 * allows only one '=' character per "set" command line. grrr. (jw)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001520 */
1521 if (nextchar == '?'
1522 || (prefix == 1
1523 && vim_strchr((char_u *)"=:&<", nextchar) == NULL
1524 && !(flags & P_BOOL)))
1525 {
1526 /*
1527 * print value
1528 */
1529 if (did_show)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001530 msg_putchar('\n'); // cursor below last one
Bram Moolenaar071d4272004-06-13 20:20:40 +00001531 else
1532 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001533 gotocmdline(TRUE); // cursor at status line
1534 did_show = TRUE; // remember that we did a line
Bram Moolenaar071d4272004-06-13 20:20:40 +00001535 }
1536 if (opt_idx >= 0)
1537 {
1538 showoneopt(&options[opt_idx], opt_flags);
1539#ifdef FEAT_EVAL
1540 if (p_verbose > 0)
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00001541 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001542 // Mention where the option was last set.
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00001543 if (varp == options[opt_idx].var)
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02001544 last_set_msg(options[opt_idx].script_ctx);
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00001545 else if ((int)options[opt_idx].indir & PV_WIN)
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02001546 last_set_msg(curwin->w_p_script_ctx[
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00001547 (int)options[opt_idx].indir & PV_MASK]);
1548 else if ((int)options[opt_idx].indir & PV_BUF)
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02001549 last_set_msg(curbuf->b_p_script_ctx[
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00001550 (int)options[opt_idx].indir & PV_MASK]);
1551 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001552#endif
1553 }
1554 else
1555 {
1556 char_u *p;
1557
1558 p = find_termcode(key_name);
1559 if (p == NULL)
1560 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001561 errmsg = N_("E846: Key code not set");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001562 goto skip;
1563 }
1564 else
1565 (void)show_one_termcode(key_name, p, TRUE);
1566 }
1567 if (nextchar != '?'
Bram Moolenaar1c465442017-03-12 20:10:05 +01001568 && nextchar != NUL && !VIM_ISWHITE(afterchar))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001569 errmsg = e_trailing;
1570 }
1571 else
1572 {
Bram Moolenaar247bb7e2018-11-20 14:27:07 +01001573 int value_is_replaced = !prepending && !adding && !removing;
Bram Moolenaar916a8182018-11-25 02:18:29 +01001574 int value_checked = FALSE;
Bram Moolenaar247bb7e2018-11-20 14:27:07 +01001575
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001576 if (flags & P_BOOL) // boolean
Bram Moolenaar071d4272004-06-13 20:20:40 +00001577 {
1578 if (nextchar == '=' || nextchar == ':')
1579 {
1580 errmsg = e_invarg;
1581 goto skip;
1582 }
1583
1584 /*
1585 * ":set opt!": invert
1586 * ":set opt&": reset to default value
1587 * ":set opt<": reset to global value
1588 */
1589 if (nextchar == '!')
1590 value = *(int *)(varp) ^ 1;
1591 else if (nextchar == '&')
Bram Moolenaareb3593b2006-04-22 22:33:57 +00001592 value = (int)(long)(long_i)options[opt_idx].def_val[
Bram Moolenaar071d4272004-06-13 20:20:40 +00001593 ((flags & P_VI_DEF) || cp_val)
1594 ? VI_DEFAULT : VIM_DEFAULT];
1595 else if (nextchar == '<')
1596 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001597 // For 'autoread' -1 means to use global value.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001598 if ((int *)varp == &curbuf->b_p_ar
1599 && opt_flags == OPT_LOCAL)
1600 value = -1;
1601 else
1602 value = *(int *)get_varp_scope(&(options[opt_idx]),
1603 OPT_GLOBAL);
1604 }
1605 else
1606 {
1607 /*
1608 * ":set invopt": invert
1609 * ":set opt" or ":set noopt": set or reset
1610 */
Bram Moolenaar1c465442017-03-12 20:10:05 +01001611 if (nextchar != NUL && !VIM_ISWHITE(afterchar))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001612 {
1613 errmsg = e_trailing;
1614 goto skip;
1615 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001616 if (prefix == 2) // inv
Bram Moolenaar071d4272004-06-13 20:20:40 +00001617 value = *(int *)(varp) ^ 1;
1618 else
1619 value = prefix;
1620 }
1621
1622 errmsg = set_bool_option(opt_idx, varp, (int)value,
1623 opt_flags);
1624 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001625 else // numeric or string
Bram Moolenaar071d4272004-06-13 20:20:40 +00001626 {
1627 if (vim_strchr((char_u *)"=:&<", nextchar) == NULL
1628 || prefix != 1)
1629 {
1630 errmsg = e_invarg;
1631 goto skip;
1632 }
1633
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001634 if (flags & P_NUM) // numeric
Bram Moolenaar071d4272004-06-13 20:20:40 +00001635 {
1636 /*
1637 * Different ways to set a number option:
1638 * & set to default value
1639 * < set to global value
1640 * <xx> accept special key codes for 'wildchar'
1641 * c accept any non-digit for 'wildchar'
1642 * [-]0-9 set number
1643 * other error
1644 */
1645 ++arg;
1646 if (nextchar == '&')
Bram Moolenaareb3593b2006-04-22 22:33:57 +00001647 value = (long)(long_i)options[opt_idx].def_val[
Bram Moolenaar071d4272004-06-13 20:20:40 +00001648 ((flags & P_VI_DEF) || cp_val)
1649 ? VI_DEFAULT : VIM_DEFAULT];
1650 else if (nextchar == '<')
Bram Moolenaarf5a2fd82013-11-06 05:26:15 +01001651 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001652 // For 'undolevels' NO_LOCAL_UNDOLEVEL means to
1653 // use the global value.
Bram Moolenaarf5a2fd82013-11-06 05:26:15 +01001654 if ((long *)varp == &curbuf->b_p_ul
1655 && opt_flags == OPT_LOCAL)
1656 value = NO_LOCAL_UNDOLEVEL;
1657 else
1658 value = *(long *)get_varp_scope(
1659 &(options[opt_idx]), OPT_GLOBAL);
1660 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001661 else if (((long *)varp == &p_wc
1662 || (long *)varp == &p_wcm)
1663 && (*arg == '<'
1664 || *arg == '^'
Bram Moolenaar1c465442017-03-12 20:10:05 +01001665 || (*arg != NUL
1666 && (!arg[1] || VIM_ISWHITE(arg[1]))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001667 && !VIM_ISDIGIT(*arg))))
1668 {
Bram Moolenaardbe948d2017-07-23 22:50:51 +02001669 value = string_to_key(arg, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001670 if (value == 0 && (long *)varp != &p_wcm)
1671 {
1672 errmsg = e_invarg;
1673 goto skip;
1674 }
1675 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001676 else if (*arg == '-' || VIM_ISDIGIT(*arg))
1677 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001678 // Allow negative (for 'undolevels'), octal and
1679 // hex numbers.
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01001680 vim_str2nr(arg, NULL, &i, STR2NR_ALL,
Bram Moolenaar16e9b852019-05-19 19:59:35 +02001681 &value, NULL, 0, TRUE);
Bram Moolenaar06e2c812019-06-12 19:05:48 +02001682 if (i == 0 || (arg[i] != NUL
1683 && !VIM_ISWHITE(arg[i])))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001684 {
Bram Moolenaar16e9b852019-05-19 19:59:35 +02001685 errmsg = N_("E521: Number required after =");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001686 goto skip;
1687 }
1688 }
1689 else
1690 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001691 errmsg = N_("E521: Number required after =");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001692 goto skip;
1693 }
1694
1695 if (adding)
1696 value = *(long *)varp + value;
1697 if (prepending)
1698 value = *(long *)varp * value;
1699 if (removing)
1700 value = *(long *)varp - value;
1701 errmsg = set_num_option(opt_idx, varp, value,
Bram Moolenaar555b2802005-05-19 21:08:39 +00001702 errbuf, sizeof(errbuf), opt_flags);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001703 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001704 else if (opt_idx >= 0) // string
Bram Moolenaar071d4272004-06-13 20:20:40 +00001705 {
Bram Moolenaar8efa0262017-08-20 15:47:20 +02001706 char_u *save_arg = NULL;
1707 char_u *s = NULL;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001708 char_u *oldval = NULL; // previous value if *varp
Bram Moolenaar8efa0262017-08-20 15:47:20 +02001709 char_u *newval;
1710 char_u *origval = NULL;
Bram Moolenaard7c96872019-06-15 17:12:48 +02001711 char_u *origval_l = NULL;
1712 char_u *origval_g = NULL;
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001713#if defined(FEAT_EVAL)
Bram Moolenaar8efa0262017-08-20 15:47:20 +02001714 char_u *saved_origval = NULL;
Bram Moolenaard7c96872019-06-15 17:12:48 +02001715 char_u *saved_origval_l = NULL;
1716 char_u *saved_origval_g = NULL;
Bram Moolenaar8efa0262017-08-20 15:47:20 +02001717 char_u *saved_newval = NULL;
Bram Moolenaar53744302015-07-17 17:38:22 +02001718#endif
Bram Moolenaar8efa0262017-08-20 15:47:20 +02001719 unsigned newlen;
1720 int comma;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001721 int new_value_alloced; // new string option
1722 // was allocated
Bram Moolenaar071d4272004-06-13 20:20:40 +00001723
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001724 // When using ":set opt=val" for a global option
1725 // with a local value the local value will be
1726 // reset, use the global value here.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001727 if ((opt_flags & (OPT_LOCAL | OPT_GLOBAL)) == 0
Bram Moolenaara23ccb82006-02-27 00:08:02 +00001728 && ((int)options[opt_idx].indir & PV_BOTH))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001729 varp = options[opt_idx].var;
1730
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001731 // The old value is kept until we are sure that the
1732 // new value is valid.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001733 oldval = *(char_u **)varp;
Bram Moolenaar8efa0262017-08-20 15:47:20 +02001734
Bram Moolenaard7c96872019-06-15 17:12:48 +02001735 if ((opt_flags & (OPT_LOCAL | OPT_GLOBAL)) == 0)
1736 {
1737 origval_l = *(char_u **)get_varp_scope(
1738 &(options[opt_idx]), OPT_LOCAL);
1739 origval_g = *(char_u **)get_varp_scope(
1740 &(options[opt_idx]), OPT_GLOBAL);
1741
1742 // A global-local string option might have an empty
1743 // option as value to indicate that the global
1744 // value should be used.
1745 if (((int)options[opt_idx].indir & PV_BOTH)
1746 && origval_l == empty_option)
1747 origval_l = origval_g;
1748 }
1749
1750 // When setting the local value of a global
1751 // option, the old value may be the global value.
Bram Moolenaar8efa0262017-08-20 15:47:20 +02001752 if (((int)options[opt_idx].indir & PV_BOTH)
1753 && (opt_flags & OPT_LOCAL))
1754 origval = *(char_u **)get_varp(
1755 &options[opt_idx]);
1756 else
1757 origval = oldval;
1758
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001759 if (nextchar == '&') // set to default val
Bram Moolenaar071d4272004-06-13 20:20:40 +00001760 {
1761 newval = options[opt_idx].def_val[
1762 ((flags & P_VI_DEF) || cp_val)
1763 ? VI_DEFAULT : VIM_DEFAULT];
1764 if ((char_u **)varp == &p_bg)
1765 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001766 // guess the value of 'background'
Bram Moolenaar071d4272004-06-13 20:20:40 +00001767#ifdef FEAT_GUI
1768 if (gui.in_use)
1769 newval = gui_bg_default();
1770 else
1771#endif
Bram Moolenaarf740b292006-02-16 22:11:02 +00001772 newval = term_bg_default();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001773 }
Bram Moolenaar5ffefbb2021-06-13 20:27:36 +02001774 else if ((char_u **)varp == &p_fencs && enc_utf8)
1775 newval = fencs_utf8_default;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001776
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001777 // expand environment variables and ~ (since the
1778 // default value was already expanded, only
1779 // required when an environment variable was set
1780 // later
Bram Moolenaar071d4272004-06-13 20:20:40 +00001781 if (newval == NULL)
1782 newval = empty_option;
1783 else
1784 {
1785 s = option_expand(opt_idx, newval);
1786 if (s == NULL)
1787 s = newval;
1788 newval = vim_strsave(s);
1789 }
1790 new_value_alloced = TRUE;
1791 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001792 else if (nextchar == '<') // set to global val
Bram Moolenaar071d4272004-06-13 20:20:40 +00001793 {
1794 newval = vim_strsave(*(char_u **)get_varp_scope(
1795 &(options[opt_idx]), OPT_GLOBAL));
1796 new_value_alloced = TRUE;
1797 }
1798 else
1799 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001800 ++arg; // jump to after the '=' or ':'
Bram Moolenaar071d4272004-06-13 20:20:40 +00001801
1802 /*
1803 * Set 'keywordprg' to ":help" if an empty
1804 * value was passed to :set by the user.
1805 * Misuse errbuf[] for the resulting string.
1806 */
1807 if (varp == (char_u *)&p_kp
1808 && (*arg == NUL || *arg == ' '))
1809 {
1810 STRCPY(errbuf, ":help");
1811 save_arg = arg;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001812 arg = (char_u *)errbuf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001813 }
1814 /*
Bram Moolenaar4e5ccfa2011-11-30 11:15:47 +01001815 * Convert 'backspace' number to string, for
1816 * adding, prepending and removing string.
1817 */
1818 else if (varp == (char_u *)&p_bs
1819 && VIM_ISDIGIT(**(char_u **)varp))
1820 {
1821 i = getdigits((char_u **)varp);
1822 switch (i)
1823 {
1824 case 0:
1825 *(char_u **)varp = empty_option;
1826 break;
1827 case 1:
1828 *(char_u **)varp = vim_strsave(
1829 (char_u *)"indent,eol");
1830 break;
1831 case 2:
1832 *(char_u **)varp = vim_strsave(
1833 (char_u *)"indent,eol,start");
1834 break;
Bram Moolenaaraa0489e2020-04-17 19:41:21 +02001835 case 3:
1836 *(char_u **)varp = vim_strsave(
1837 (char_u *)"indent,eol,nostop");
1838 break;
Bram Moolenaar4e5ccfa2011-11-30 11:15:47 +01001839 }
1840 vim_free(oldval);
Bram Moolenaaredbc0d42017-08-20 16:11:51 +02001841 if (origval == oldval)
1842 origval = *(char_u **)varp;
Bram Moolenaard7c96872019-06-15 17:12:48 +02001843 if (origval_l == oldval)
1844 origval_l = *(char_u **)varp;
1845 if (origval_g == oldval)
1846 origval_g = *(char_u **)varp;
Bram Moolenaar4e5ccfa2011-11-30 11:15:47 +01001847 oldval = *(char_u **)varp;
1848 }
1849 /*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001850 * Convert 'whichwrap' number to string, for
1851 * backwards compatibility with Vim 3.0.
1852 * Misuse errbuf[] for the resulting string.
1853 */
1854 else if (varp == (char_u *)&p_ww
1855 && VIM_ISDIGIT(*arg))
1856 {
1857 *errbuf = NUL;
1858 i = getdigits(&arg);
1859 if (i & 1)
1860 STRCAT(errbuf, "b,");
1861 if (i & 2)
1862 STRCAT(errbuf, "s,");
1863 if (i & 4)
1864 STRCAT(errbuf, "h,l,");
1865 if (i & 8)
1866 STRCAT(errbuf, "<,>,");
1867 if (i & 16)
1868 STRCAT(errbuf, "[,],");
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001869 if (*errbuf != NUL) // remove trailing ,
Bram Moolenaar071d4272004-06-13 20:20:40 +00001870 errbuf[STRLEN(errbuf) - 1] = NUL;
1871 save_arg = arg;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001872 arg = (char_u *)errbuf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001873 }
1874 /*
1875 * Remove '>' before 'dir' and 'bdir', for
1876 * backwards compatibility with version 3.0
1877 */
1878 else if ( *arg == '>'
1879 && (varp == (char_u *)&p_dir
1880 || varp == (char_u *)&p_bdir))
1881 {
1882 ++arg;
1883 }
1884
Bram Moolenaar071d4272004-06-13 20:20:40 +00001885 /*
1886 * Copy the new string into allocated memory.
1887 * Can't use set_string_option_direct(), because
1888 * we need to remove the backslashes.
1889 */
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001890 // get a bit too much
Bram Moolenaar071d4272004-06-13 20:20:40 +00001891 newlen = (unsigned)STRLEN(arg) + 1;
1892 if (adding || prepending || removing)
1893 newlen += (unsigned)STRLEN(origval) + 1;
1894 newval = alloc(newlen);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001895 if (newval == NULL) // out of mem, don't change
Bram Moolenaar071d4272004-06-13 20:20:40 +00001896 break;
1897 s = newval;
1898
1899 /*
1900 * Copy the string, skip over escaped chars.
1901 * For MS-DOS and WIN32 backslashes before normal
1902 * file name characters are not removed, and keep
1903 * backslash at start, for "\\machine\path", but
1904 * do remove it for "\\\\machine\\path".
1905 * The reverse is found in ExpandOldSetting().
1906 */
Bram Moolenaar1c465442017-03-12 20:10:05 +01001907 while (*arg && !VIM_ISWHITE(*arg))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001908 {
1909 if (*arg == '\\' && arg[1] != NUL
1910#ifdef BACKSLASH_IN_FILENAME
1911 && !((flags & P_EXPAND)
1912 && vim_isfilec(arg[1])
Bram Moolenaar994b89d2020-08-07 19:12:41 +02001913 && !VIM_ISWHITE(arg[1])
Bram Moolenaar071d4272004-06-13 20:20:40 +00001914 && (arg[1] != '\\'
1915 || (s == newval
1916 && arg[2] != '\\')))
1917#endif
1918 )
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001919 ++arg; // remove backslash
Bram Moolenaar071d4272004-06-13 20:20:40 +00001920 if (has_mbyte
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00001921 && (i = (*mb_ptr2len)(arg)) > 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001922 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001923 // copy multibyte char
Bram Moolenaar071d4272004-06-13 20:20:40 +00001924 mch_memmove(s, arg, (size_t)i);
1925 arg += i;
1926 s += i;
1927 }
1928 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00001929 *s++ = *arg++;
1930 }
1931 *s = NUL;
1932
1933 /*
1934 * Expand environment variables and ~.
1935 * Don't do it when adding without inserting a
1936 * comma.
1937 */
1938 if (!(adding || prepending || removing)
1939 || (flags & P_COMMA))
1940 {
1941 s = option_expand(opt_idx, newval);
1942 if (s != NULL)
1943 {
1944 vim_free(newval);
1945 newlen = (unsigned)STRLEN(s) + 1;
1946 if (adding || prepending || removing)
1947 newlen += (unsigned)STRLEN(origval) + 1;
1948 newval = alloc(newlen);
1949 if (newval == NULL)
1950 break;
1951 STRCPY(newval, s);
1952 }
1953 }
1954
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001955 // locate newval[] in origval[] when removing it
1956 // and when adding to avoid duplicates
1957 i = 0; // init for GCC
Bram Moolenaar071d4272004-06-13 20:20:40 +00001958 if (removing || (flags & P_NODUP))
1959 {
1960 i = (int)STRLEN(newval);
Bram Moolenaarb00ef052020-09-12 14:53:53 +02001961 s = find_dup_item(origval, newval, flags);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001962
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001963 // do not add if already there
Bram Moolenaarb00ef052020-09-12 14:53:53 +02001964 if ((adding || prepending) && s != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001965 {
1966 prepending = FALSE;
1967 adding = FALSE;
1968 STRCPY(newval, origval);
1969 }
Bram Moolenaarb00ef052020-09-12 14:53:53 +02001970
1971 // if no duplicate, move pointer to end of
1972 // original value
1973 if (s == NULL)
1974 s = origval + (int)STRLEN(origval);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001975 }
1976
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001977 // concatenate the two strings; add a ',' if
1978 // needed
Bram Moolenaar071d4272004-06-13 20:20:40 +00001979 if (adding || prepending)
1980 {
1981 comma = ((flags & P_COMMA) && *origval != NUL
1982 && *newval != NUL);
1983 if (adding)
1984 {
1985 i = (int)STRLEN(origval);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001986 // strip a trailing comma, would get 2
Bram Moolenaar17467472015-11-10 17:50:24 +01001987 if (comma && i > 1
1988 && (flags & P_ONECOMMA) == P_ONECOMMA
1989 && origval[i - 1] == ','
1990 && origval[i - 2] != '\\')
Bram Moolenaara7b7b1c2015-06-19 14:06:43 +02001991 i--;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001992 mch_memmove(newval + i + comma, newval,
1993 STRLEN(newval) + 1);
1994 mch_memmove(newval, origval, (size_t)i);
1995 }
1996 else
1997 {
1998 i = (int)STRLEN(newval);
Bram Moolenaarc1a11ed2008-06-24 22:09:24 +00001999 STRMOVE(newval + i + comma, origval);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002000 }
2001 if (comma)
2002 newval[i] = ',';
2003 }
2004
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002005 // Remove newval[] from origval[]. (Note: "i" has
2006 // been set above and is used here).
Bram Moolenaar071d4272004-06-13 20:20:40 +00002007 if (removing)
2008 {
2009 STRCPY(newval, origval);
2010 if (*s)
2011 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002012 // may need to remove a comma
Bram Moolenaar071d4272004-06-13 20:20:40 +00002013 if (flags & P_COMMA)
2014 {
2015 if (s == origval)
2016 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002017 // include comma after string
Bram Moolenaar071d4272004-06-13 20:20:40 +00002018 if (s[i] == ',')
2019 ++i;
2020 }
2021 else
2022 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002023 // include comma before string
Bram Moolenaar071d4272004-06-13 20:20:40 +00002024 --s;
2025 ++i;
2026 }
2027 }
Bram Moolenaarc1a11ed2008-06-24 22:09:24 +00002028 STRMOVE(newval + (s - origval), s + i);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002029 }
2030 }
2031
2032 if (flags & P_FLAGLIST)
2033 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002034 // Remove flags that appear twice.
Bram Moolenaaraaaf57d2017-02-05 14:13:20 +01002035 for (s = newval; *s;)
Bram Moolenaarc8ce6152016-08-07 13:48:20 +02002036 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002037 // if options have P_FLAGLIST and
2038 // P_ONECOMMA such as 'whichwrap'
Bram Moolenaarc8ce6152016-08-07 13:48:20 +02002039 if (flags & P_ONECOMMA)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002040 {
Bram Moolenaarc8ce6152016-08-07 13:48:20 +02002041 if (*s != ',' && *(s + 1) == ','
2042 && vim_strchr(s + 2, *s) != NULL)
2043 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002044 // Remove the duplicated value and
2045 // the next comma.
Bram Moolenaarc8ce6152016-08-07 13:48:20 +02002046 STRMOVE(s, s + 2);
Bram Moolenaaraaaf57d2017-02-05 14:13:20 +01002047 continue;
Bram Moolenaarc8ce6152016-08-07 13:48:20 +02002048 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002049 }
Bram Moolenaarc8ce6152016-08-07 13:48:20 +02002050 else
2051 {
2052 if ((!(flags & P_COMMA) || *s != ',')
2053 && vim_strchr(s + 1, *s) != NULL)
2054 {
2055 STRMOVE(s, s + 1);
Bram Moolenaaraaaf57d2017-02-05 14:13:20 +01002056 continue;
Bram Moolenaarc8ce6152016-08-07 13:48:20 +02002057 }
2058 }
Bram Moolenaaraaaf57d2017-02-05 14:13:20 +01002059 ++s;
Bram Moolenaarc8ce6152016-08-07 13:48:20 +02002060 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002061 }
2062
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002063 if (save_arg != NULL) // number for 'whichwrap'
Bram Moolenaar071d4272004-06-13 20:20:40 +00002064 arg = save_arg;
2065 new_value_alloced = TRUE;
2066 }
2067
Bram Moolenaar8efa0262017-08-20 15:47:20 +02002068 /*
2069 * Set the new value.
2070 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002071 *(char_u **)(varp) = newval;
2072
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01002073#if defined(FEAT_EVAL)
Bram Moolenaar5cbb8db2015-07-17 23:08:29 +02002074 if (!starting
2075# ifdef FEAT_CRYPT
2076 && options[opt_idx].indir != PV_KEY
2077# endif
Bram Moolenaar182a17b2017-06-25 20:57:18 +02002078 && origval != NULL && newval != NULL)
2079 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002080 // origval may be freed by
2081 // did_set_string_option(), make a copy.
Bram Moolenaar53744302015-07-17 17:38:22 +02002082 saved_origval = vim_strsave(origval);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002083 // newval (and varp) may become invalid if the
2084 // buffer is closed by autocommands.
Bram Moolenaar182a17b2017-06-25 20:57:18 +02002085 saved_newval = vim_strsave(newval);
Bram Moolenaard7c96872019-06-15 17:12:48 +02002086 if (origval_l != NULL)
2087 saved_origval_l = vim_strsave(origval_l);
2088 if (origval_g != NULL)
2089 saved_origval_g = vim_strsave(origval_g);
Bram Moolenaar182a17b2017-06-25 20:57:18 +02002090 }
Bram Moolenaar53744302015-07-17 17:38:22 +02002091#endif
2092
Bram Moolenaar247bb7e2018-11-20 14:27:07 +01002093 {
2094 long_u *p = insecure_flag(opt_idx, opt_flags);
Bram Moolenaar48f377a2018-12-21 13:03:28 +01002095 int secure_saved = secure;
Bram Moolenaar247bb7e2018-11-20 14:27:07 +01002096
2097 // When an option is set in the sandbox, from a
2098 // modeline or in secure mode, then deal with side
2099 // effects in secure mode. Also when the value was
2100 // set with the P_INSECURE flag and is not
2101 // completely replaced.
Bram Moolenaar82b033e2019-03-24 14:02:04 +01002102 if ((opt_flags & OPT_MODELINE)
Bram Moolenaar247bb7e2018-11-20 14:27:07 +01002103#ifdef HAVE_SANDBOX
Bram Moolenaar82b033e2019-03-24 14:02:04 +01002104 || sandbox != 0
Bram Moolenaar247bb7e2018-11-20 14:27:07 +01002105#endif
Bram Moolenaar82b033e2019-03-24 14:02:04 +01002106 || (!value_is_replaced && (*p & P_INSECURE)))
2107 secure = 1;
Bram Moolenaar247bb7e2018-11-20 14:27:07 +01002108
Bram Moolenaar48f377a2018-12-21 13:03:28 +01002109 // Handle side effects, and set the global value
2110 // for ":set" on local options. Note: when setting
2111 // 'syntax' or 'filetype' autocommands may be
2112 // triggered that can cause havoc.
2113 errmsg = did_set_string_option(
2114 opt_idx, (char_u **)varp,
Bram Moolenaar916a8182018-11-25 02:18:29 +01002115 new_value_alloced, oldval, errbuf,
2116 opt_flags, &value_checked);
Bram Moolenaar247bb7e2018-11-20 14:27:07 +01002117
Bram Moolenaar48f377a2018-12-21 13:03:28 +01002118 secure = secure_saved;
Bram Moolenaar247bb7e2018-11-20 14:27:07 +01002119 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002120
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01002121#if defined(FEAT_EVAL)
Bram Moolenaar8efa0262017-08-20 15:47:20 +02002122 if (errmsg == NULL)
Bram Moolenaard7c96872019-06-15 17:12:48 +02002123 trigger_optionsset_string(
2124 opt_idx, opt_flags, saved_origval,
2125 saved_origval_l, saved_origval_g,
2126 saved_newval);
Bram Moolenaar8efa0262017-08-20 15:47:20 +02002127 vim_free(saved_origval);
Bram Moolenaard7c96872019-06-15 17:12:48 +02002128 vim_free(saved_origval_l);
2129 vim_free(saved_origval_g);
Bram Moolenaar8efa0262017-08-20 15:47:20 +02002130 vim_free(saved_newval);
2131#endif
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002132 // If error detected, print the error message.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002133 if (errmsg != NULL)
2134 goto skip;
2135 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002136 else // key code option
Bram Moolenaar071d4272004-06-13 20:20:40 +00002137 {
2138 char_u *p;
2139
2140 if (nextchar == '&')
2141 {
2142 if (add_termcap_entry(key_name, TRUE) == FAIL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002143 errmsg = N_("E522: Not found in termcap");
Bram Moolenaar071d4272004-06-13 20:20:40 +00002144 }
2145 else
2146 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002147 ++arg; // jump to after the '=' or ':'
Bram Moolenaar1c465442017-03-12 20:10:05 +01002148 for (p = arg; *p && !VIM_ISWHITE(*p); ++p)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002149 if (*p == '\\' && p[1] != NUL)
2150 ++p;
2151 nextchar = *p;
2152 *p = NUL;
2153 add_termcode(key_name, arg, FALSE);
2154 *p = nextchar;
2155 }
2156 if (full_screen)
2157 ttest(FALSE);
2158 redraw_all_later(CLEAR);
2159 }
2160 }
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00002161
Bram Moolenaar071d4272004-06-13 20:20:40 +00002162 if (opt_idx >= 0)
Bram Moolenaar916a8182018-11-25 02:18:29 +01002163 did_set_option(
2164 opt_idx, opt_flags, value_is_replaced, value_checked);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002165 }
2166
2167skip:
2168 /*
2169 * Advance to next argument.
2170 * - skip until a blank found, taking care of backslashes
2171 * - skip blanks
2172 * - skip one "=val" argument (for hidden options ":set gfn =xx")
2173 */
2174 for (i = 0; i < 2 ; ++i)
2175 {
Bram Moolenaar1c465442017-03-12 20:10:05 +01002176 while (*arg != NUL && !VIM_ISWHITE(*arg))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002177 if (*arg++ == '\\' && *arg != NUL)
2178 ++arg;
2179 arg = skipwhite(arg);
2180 if (*arg != '=')
2181 break;
2182 }
2183 }
2184
2185 if (errmsg != NULL)
2186 {
Bram Moolenaarce0842a2005-07-18 21:58:11 +00002187 vim_strncpy(IObuff, (char_u *)_(errmsg), IOSIZE - 1);
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00002188 i = (int)STRLEN(IObuff) + 2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002189 if (i + (arg - startarg) < IOSIZE)
2190 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002191 // append the argument with the error
Bram Moolenaar071d4272004-06-13 20:20:40 +00002192 STRCAT(IObuff, ": ");
2193 mch_memmove(IObuff + i, startarg, (arg - startarg));
2194 IObuff[i + (arg - startarg)] = NUL;
2195 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002196 // make sure all characters are printable
Bram Moolenaar071d4272004-06-13 20:20:40 +00002197 trans_characters(IObuff, IOSIZE);
2198
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002199 ++no_wait_return; // wait_return done later
2200 emsg((char *)IObuff); // show error highlighted
Bram Moolenaar071d4272004-06-13 20:20:40 +00002201 --no_wait_return;
2202
2203 return FAIL;
2204 }
2205
2206 arg = skipwhite(arg);
2207 }
2208
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002209theend:
2210 if (silent_mode && did_show)
2211 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002212 // After displaying option values in silent mode.
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002213 silent_mode = FALSE;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002214 info_message = TRUE; // use mch_msg(), not mch_errmsg()
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002215 msg_putchar('\n');
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002216 cursor_on(); // msg_start() switches it off
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002217 out_flush();
2218 silent_mode = TRUE;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002219 info_message = FALSE; // use mch_msg(), not mch_errmsg()
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002220 }
2221
Bram Moolenaar071d4272004-06-13 20:20:40 +00002222 return OK;
2223}
2224
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00002225/*
2226 * Call this when an option has been given a new value through a user command.
2227 * Sets the P_WAS_SET flag and takes care of the P_INSECURE flag.
2228 */
Bram Moolenaardac13472019-09-16 21:06:21 +02002229 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002230did_set_option(
2231 int opt_idx,
Bram Moolenaar916a8182018-11-25 02:18:29 +01002232 int opt_flags, // possibly with OPT_MODELINE
2233 int new_value, // value was replaced completely
2234 int value_checked) // value was checked to be safe, no need to set the
2235 // P_INSECURE flag.
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00002236{
Bram Moolenaard1f56e62006-02-22 21:25:37 +00002237 long_u *p;
2238
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00002239 options[opt_idx].flags |= P_WAS_SET;
2240
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002241 // When an option is set in the sandbox, from a modeline or in secure mode
2242 // set the P_INSECURE flag. Otherwise, if a new value is stored reset the
2243 // flag.
Bram Moolenaard1f56e62006-02-22 21:25:37 +00002244 p = insecure_flag(opt_idx, opt_flags);
Bram Moolenaar916a8182018-11-25 02:18:29 +01002245 if (!value_checked && (secure
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00002246#ifdef HAVE_SANDBOX
2247 || sandbox != 0
2248#endif
Bram Moolenaar916a8182018-11-25 02:18:29 +01002249 || (opt_flags & OPT_MODELINE)))
Bram Moolenaard1f56e62006-02-22 21:25:37 +00002250 *p = *p | P_INSECURE;
2251 else if (new_value)
2252 *p = *p & ~P_INSECURE;
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00002253}
2254
Bram Moolenaar071d4272004-06-13 20:20:40 +00002255/*
2256 * Convert a key name or string into a key value.
2257 * Used for 'wildchar' and 'cedit' options.
Bram Moolenaardbe948d2017-07-23 22:50:51 +02002258 * When "multi_byte" is TRUE allow for multi-byte characters.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002259 */
Bram Moolenaardbe948d2017-07-23 22:50:51 +02002260 int
2261string_to_key(char_u *arg, int multi_byte)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002262{
2263 if (*arg == '<')
Bram Moolenaar9cf4b502018-07-23 04:12:03 +02002264 return find_key_option(arg + 1, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002265 if (*arg == '^')
2266 return Ctrl_chr(arg[1]);
Bram Moolenaardbe948d2017-07-23 22:50:51 +02002267 if (multi_byte)
2268 return PTR2CHAR(arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002269 return *arg;
2270}
2271
Bram Moolenaar071d4272004-06-13 20:20:40 +00002272/*
2273 * When changing 'title', 'titlestring', 'icon' or 'iconstring', call
2274 * maketitle() to create and display it.
2275 * When switching the title or icon off, call mch_restore_title() to get
2276 * the old value back.
2277 */
Bram Moolenaardac13472019-09-16 21:06:21 +02002278 void
Bram Moolenaar84a93082018-06-16 22:58:15 +02002279did_set_title(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002280{
2281 if (starting != NO_SCREEN
2282#ifdef FEAT_GUI
2283 && !gui.starting
2284#endif
2285 )
Bram Moolenaar071d4272004-06-13 20:20:40 +00002286 maketitle();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002287}
Bram Moolenaar071d4272004-06-13 20:20:40 +00002288
2289/*
2290 * set_options_bin - called when 'bin' changes value.
2291 */
2292 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002293set_options_bin(
2294 int oldval,
2295 int newval,
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002296 int opt_flags) // OPT_LOCAL and/or OPT_GLOBAL
Bram Moolenaar071d4272004-06-13 20:20:40 +00002297{
2298 /*
2299 * The option values that are changed when 'bin' changes are
2300 * copied when 'bin is set and restored when 'bin' is reset.
2301 */
2302 if (newval)
2303 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002304 if (!oldval) // switched on
Bram Moolenaar071d4272004-06-13 20:20:40 +00002305 {
2306 if (!(opt_flags & OPT_GLOBAL))
2307 {
2308 curbuf->b_p_tw_nobin = curbuf->b_p_tw;
2309 curbuf->b_p_wm_nobin = curbuf->b_p_wm;
2310 curbuf->b_p_ml_nobin = curbuf->b_p_ml;
2311 curbuf->b_p_et_nobin = curbuf->b_p_et;
2312 }
2313 if (!(opt_flags & OPT_LOCAL))
2314 {
2315 p_tw_nobin = p_tw;
2316 p_wm_nobin = p_wm;
2317 p_ml_nobin = p_ml;
2318 p_et_nobin = p_et;
2319 }
2320 }
2321
2322 if (!(opt_flags & OPT_GLOBAL))
2323 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002324 curbuf->b_p_tw = 0; // no automatic line wrap
2325 curbuf->b_p_wm = 0; // no automatic line wrap
2326 curbuf->b_p_ml = 0; // no modelines
2327 curbuf->b_p_et = 0; // no expandtab
Bram Moolenaar071d4272004-06-13 20:20:40 +00002328 }
2329 if (!(opt_flags & OPT_LOCAL))
2330 {
2331 p_tw = 0;
2332 p_wm = 0;
2333 p_ml = FALSE;
2334 p_et = FALSE;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002335 p_bin = TRUE; // needed when called for the "-b" argument
Bram Moolenaar071d4272004-06-13 20:20:40 +00002336 }
2337 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002338 else if (oldval) // switched off
Bram Moolenaar071d4272004-06-13 20:20:40 +00002339 {
2340 if (!(opt_flags & OPT_GLOBAL))
2341 {
2342 curbuf->b_p_tw = curbuf->b_p_tw_nobin;
2343 curbuf->b_p_wm = curbuf->b_p_wm_nobin;
2344 curbuf->b_p_ml = curbuf->b_p_ml_nobin;
2345 curbuf->b_p_et = curbuf->b_p_et_nobin;
2346 }
2347 if (!(opt_flags & OPT_LOCAL))
2348 {
2349 p_tw = p_tw_nobin;
2350 p_wm = p_wm_nobin;
2351 p_ml = p_ml_nobin;
2352 p_et = p_et_nobin;
2353 }
2354 }
2355}
2356
Bram Moolenaar071d4272004-06-13 20:20:40 +00002357/*
2358 * Expand environment variables for some string options.
2359 * These string options cannot be indirect!
2360 * If "val" is NULL expand the current value of the option.
2361 * Return pointer to NameBuff, or NULL when not expanded.
2362 */
2363 static char_u *
Bram Moolenaar9b578142016-01-30 19:39:49 +01002364option_expand(int opt_idx, char_u *val)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002365{
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002366 // if option doesn't need expansion nothing to do
Bram Moolenaar071d4272004-06-13 20:20:40 +00002367 if (!(options[opt_idx].flags & P_EXPAND) || options[opt_idx].var == NULL)
2368 return NULL;
2369
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002370 // If val is longer than MAXPATHL no meaningful expansion can be done,
2371 // expand_env() would truncate the string.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002372 if (val != NULL && STRLEN(val) > MAXPATHL)
2373 return NULL;
2374
2375 if (val == NULL)
2376 val = *(char_u **)options[opt_idx].var;
2377
2378 /*
2379 * Expanding this with NameBuff, expand_env() must not be passed IObuff.
2380 * Escape spaces when expanding 'tags', they are used to separate file
2381 * names.
Bram Moolenaar24bbcfe2005-06-28 23:32:02 +00002382 * For 'spellsuggest' expand after "file:".
Bram Moolenaar071d4272004-06-13 20:20:40 +00002383 */
2384 expand_env_esc(val, NameBuff, MAXPATHL,
Bram Moolenaar9f0545d2007-09-26 20:36:32 +00002385 (char_u **)options[opt_idx].var == &p_tags, FALSE,
Bram Moolenaarb9a02fc2006-03-12 22:08:12 +00002386#ifdef FEAT_SPELL
Bram Moolenaar24bbcfe2005-06-28 23:32:02 +00002387 (char_u **)options[opt_idx].var == &p_sps ? (char_u *)"file:" :
2388#endif
2389 NULL);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002390 if (STRCMP(NameBuff, val) == 0) // they are the same
Bram Moolenaar071d4272004-06-13 20:20:40 +00002391 return NULL;
2392
2393 return NameBuff;
2394}
2395
2396/*
2397 * After setting various option values: recompute variables that depend on
2398 * option values.
2399 */
2400 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002401didset_options(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002402{
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002403 // initialize the table for 'iskeyword' et.al.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002404 (void)init_chartab();
2405
Bram Moolenaardac13472019-09-16 21:06:21 +02002406 didset_string_options();
2407
Bram Moolenaarb9a02fc2006-03-12 22:08:12 +00002408#ifdef FEAT_SPELL
Bram Moolenaar8aff23a2005-08-19 20:40:30 +00002409 (void)spell_check_msm();
Bram Moolenaar24bbcfe2005-06-28 23:32:02 +00002410 (void)spell_check_sps();
Bram Moolenaar860cae12010-06-05 23:22:07 +02002411 (void)compile_cap_prog(curwin->w_s);
Bram Moolenaare68c25c2015-08-25 15:39:55 +02002412 (void)did_set_spell_option(TRUE);
Bram Moolenaard857f0e2005-06-21 22:37:39 +00002413#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002414#ifdef FEAT_CMDWIN
Bram Moolenaar010ee962019-09-25 20:37:36 +02002415 // set cedit_key
Bram Moolenaar071d4272004-06-13 20:20:40 +00002416 (void)check_cedit();
2417#endif
Bram Moolenaar597a4222014-06-25 14:39:50 +02002418#ifdef FEAT_LINEBREAK
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002419 // initialize the table for 'breakat'.
Bram Moolenaare68c25c2015-08-25 15:39:55 +02002420 fill_breakat_flags();
2421#endif
Bram Moolenaar010ee962019-09-25 20:37:36 +02002422 after_copy_winopt(curwin);
Bram Moolenaare68c25c2015-08-25 15:39:55 +02002423}
2424
2425/*
2426 * More side effects of setting options.
2427 */
2428 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002429didset_options2(void)
Bram Moolenaare68c25c2015-08-25 15:39:55 +02002430{
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002431 // Initialize the highlight_attr[] table.
Bram Moolenaare68c25c2015-08-25 15:39:55 +02002432 (void)highlight_changed();
2433
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002434 // Parse default for 'wildmode'
Bram Moolenaare68c25c2015-08-25 15:39:55 +02002435 check_opt_wim();
2436
Bram Moolenaareed9d462021-02-15 20:38:25 +01002437 // Parse default for 'listchars'.
2438 (void)set_chars_option(curwin, &curwin->w_p_lcs);
2439
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002440 // Parse default for 'fillchars'.
Bram Moolenaareed9d462021-02-15 20:38:25 +01002441 (void)set_chars_option(curwin, &p_fcs);
Bram Moolenaare68c25c2015-08-25 15:39:55 +02002442
2443#ifdef FEAT_CLIPBOARD
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002444 // Parse default for 'clipboard'
Bram Moolenaare68c25c2015-08-25 15:39:55 +02002445 (void)check_clipboard_option();
2446#endif
Bram Moolenaar04958cb2018-06-23 19:23:02 +02002447#ifdef FEAT_VARTABS
Bram Moolenaar55c77cf2019-02-16 19:05:11 +01002448 vim_free(curbuf->b_p_vsts_array);
Bram Moolenaarb7081e12021-09-04 18:47:28 +02002449 (void)tabstop_set(curbuf->b_p_vsts, &curbuf->b_p_vsts_array);
Bram Moolenaar55c77cf2019-02-16 19:05:11 +01002450 vim_free(curbuf->b_p_vts_array);
Bram Moolenaarb7081e12021-09-04 18:47:28 +02002451 (void)tabstop_set(curbuf->b_p_vts, &curbuf->b_p_vts_array);
Bram Moolenaar04958cb2018-06-23 19:23:02 +02002452#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002453}
2454
2455/*
2456 * Check for string options that are NULL (normally only termcap options).
2457 */
2458 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002459check_options(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002460{
2461 int opt_idx;
2462
2463 for (opt_idx = 0; options[opt_idx].fullname != NULL; opt_idx++)
2464 if ((options[opt_idx].flags & P_STRING) && options[opt_idx].var != NULL)
2465 check_string_option((char_u **)get_varp(&(options[opt_idx])));
2466}
2467
2468/*
Bram Moolenaar35bc7d62018-10-02 14:45:10 +02002469 * Return the option index found by a pointer into term_strings[].
2470 * Return -1 if not found.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002471 */
Bram Moolenaar35bc7d62018-10-02 14:45:10 +02002472 int
2473get_term_opt_idx(char_u **p)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002474{
Bram Moolenaar35bc7d62018-10-02 14:45:10 +02002475 int opt_idx;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002476
2477 for (opt_idx = 1; options[opt_idx].fullname != NULL; opt_idx++)
2478 if (options[opt_idx].var == (char_u *)p)
Bram Moolenaar35bc7d62018-10-02 14:45:10 +02002479 return opt_idx;
2480 return -1; // cannot happen: didn't find it!
2481}
2482
2483/*
2484 * Mark a terminal option as allocated, found by a pointer into term_strings[].
2485 * Return the option index or -1 if not found.
2486 */
2487 int
2488set_term_option_alloced(char_u **p)
2489{
2490 int opt_idx = get_term_opt_idx(p);
2491
2492 if (opt_idx >= 0)
2493 options[opt_idx].flags |= P_ALLOCED;
2494 return opt_idx;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002495}
2496
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00002497#if defined(FEAT_EVAL) || defined(PROTO)
2498/*
2499 * Return TRUE when option "opt" was set from a modeline or in secure mode.
2500 * Return FALSE when it wasn't.
2501 * Return -1 for an unknown option.
2502 */
2503 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01002504was_set_insecurely(char_u *opt, int opt_flags)
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00002505{
2506 int idx = findoption(opt);
Bram Moolenaard1f56e62006-02-22 21:25:37 +00002507 long_u *flagp;
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00002508
2509 if (idx >= 0)
Bram Moolenaard1f56e62006-02-22 21:25:37 +00002510 {
2511 flagp = insecure_flag(idx, opt_flags);
2512 return (*flagp & P_INSECURE) != 0;
2513 }
Bram Moolenaar95f09602016-11-10 20:01:45 +01002514 internal_error("was_set_insecurely()");
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00002515 return -1;
2516}
Bram Moolenaard1f56e62006-02-22 21:25:37 +00002517
2518/*
2519 * Get a pointer to the flags used for the P_INSECURE flag of option
2520 * "opt_idx". For some local options a local flags field is used.
Bram Moolenaard5e8c922021-02-02 21:10:01 +01002521 * NOTE: Caller must make sure that "curwin" is set to the window from which
2522 * the option is used.
Bram Moolenaard1f56e62006-02-22 21:25:37 +00002523 */
2524 static long_u *
Bram Moolenaar9b578142016-01-30 19:39:49 +01002525insecure_flag(int opt_idx, int opt_flags)
Bram Moolenaard1f56e62006-02-22 21:25:37 +00002526{
2527 if (opt_flags & OPT_LOCAL)
2528 switch ((int)options[opt_idx].indir)
2529 {
2530#ifdef FEAT_STL_OPT
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00002531 case PV_STL: return &curwin->w_p_stl_flags;
Bram Moolenaard1f56e62006-02-22 21:25:37 +00002532#endif
2533#ifdef FEAT_EVAL
Bram Moolenaar2e978902006-05-13 12:37:50 +00002534# ifdef FEAT_FOLDING
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00002535 case PV_FDE: return &curwin->w_p_fde_flags;
2536 case PV_FDT: return &curwin->w_p_fdt_flags;
Bram Moolenaar2e978902006-05-13 12:37:50 +00002537# endif
Bram Moolenaar9b2200a2006-03-20 21:55:45 +00002538# ifdef FEAT_BEVAL
2539 case PV_BEXPR: return &curbuf->b_p_bexpr_flags;
2540# endif
Bram Moolenaard1f56e62006-02-22 21:25:37 +00002541# if defined(FEAT_CINDENT)
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00002542 case PV_INDE: return &curbuf->b_p_inde_flags;
Bram Moolenaard1f56e62006-02-22 21:25:37 +00002543# endif
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00002544 case PV_FEX: return &curbuf->b_p_fex_flags;
Bram Moolenaard1f56e62006-02-22 21:25:37 +00002545# ifdef FEAT_FIND_ID
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00002546 case PV_INEX: return &curbuf->b_p_inex_flags;
Bram Moolenaard1f56e62006-02-22 21:25:37 +00002547# endif
2548#endif
2549 }
2550
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002551 // Nothing special, return global flags field.
Bram Moolenaard1f56e62006-02-22 21:25:37 +00002552 return &options[opt_idx].flags;
2553}
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00002554#endif
2555
Bram Moolenaar1f26d2f2009-02-11 10:35:36 +00002556/*
2557 * Redraw the window title and/or tab page text later.
2558 */
Bram Moolenaardac13472019-09-16 21:06:21 +02002559void redraw_titles(void)
Bram Moolenaar1f26d2f2009-02-11 10:35:36 +00002560{
2561 need_maketitle = TRUE;
Bram Moolenaar1f26d2f2009-02-11 10:35:36 +00002562 redraw_tabline = TRUE;
Bram Moolenaar1f26d2f2009-02-11 10:35:36 +00002563}
Bram Moolenaar1f26d2f2009-02-11 10:35:36 +00002564
Bram Moolenaar071d4272004-06-13 20:20:40 +00002565/*
Bram Moolenaar8f130ed2019-04-10 22:15:19 +02002566 * Return TRUE if "val" is a valid name: only consists of alphanumeric ASCII
2567 * characters or characters in "allowed".
2568 */
Bram Moolenaare677df82019-09-02 22:31:11 +02002569 int
Bram Moolenaar8f130ed2019-04-10 22:15:19 +02002570valid_name(char_u *val, char *allowed)
2571{
2572 char_u *s;
2573
2574 for (s = val; *s != NUL; ++s)
2575 if (!ASCII_ISALNUM(*s) && vim_strchr((char_u *)allowed, *s) == NULL)
2576 return FALSE;
2577 return TRUE;
2578}
2579
Bram Moolenaard1f56e62006-02-22 21:25:37 +00002580#if defined(FEAT_EVAL) || defined(PROTO)
2581/*
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02002582 * Set the script_ctx for an option, taking care of setting the buffer- or
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00002583 * window-local value.
Bram Moolenaard1f56e62006-02-22 21:25:37 +00002584 */
Bram Moolenaardac13472019-09-16 21:06:21 +02002585 void
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02002586set_option_sctx_idx(int opt_idx, int opt_flags, sctx_T script_ctx)
Bram Moolenaard1f56e62006-02-22 21:25:37 +00002587{
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00002588 int both = (opt_flags & (OPT_LOCAL | OPT_GLOBAL)) == 0;
2589 int indir = (int)options[opt_idx].indir;
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02002590 sctx_T new_script_ctx = script_ctx;
2591
Bram Moolenaar51258742020-05-03 17:19:33 +02002592 // Modeline already has the line number set.
2593 if (!(opt_flags & OPT_MODELINE))
2594 new_script_ctx.sc_lnum += SOURCING_LNUM;
Bram Moolenaard1f56e62006-02-22 21:25:37 +00002595
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002596 // Remember where the option was set. For local options need to do that
2597 // in the buffer or window structure.
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00002598 if (both || (opt_flags & OPT_GLOBAL) || (indir & (PV_BUF|PV_WIN)) == 0)
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02002599 options[opt_idx].script_ctx = new_script_ctx;
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00002600 if (both || (opt_flags & OPT_LOCAL))
2601 {
2602 if (indir & PV_BUF)
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02002603 curbuf->b_p_script_ctx[indir & PV_MASK] = new_script_ctx;
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00002604 else if (indir & PV_WIN)
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02002605 curwin->w_p_script_ctx[indir & PV_MASK] = new_script_ctx;
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00002606 }
Bram Moolenaard1f56e62006-02-22 21:25:37 +00002607}
Bram Moolenaar35bc7d62018-10-02 14:45:10 +02002608
2609/*
2610 * Set the script_ctx for a termcap option.
2611 * "name" must be the two character code, e.g. "RV".
2612 * When "name" is NULL use "opt_idx".
2613 */
2614 void
2615set_term_option_sctx_idx(char *name, int opt_idx)
2616{
2617 char_u buf[5];
2618 int idx;
2619
2620 if (name == NULL)
2621 idx = opt_idx;
2622 else
2623 {
2624 buf[0] = 't';
2625 buf[1] = '_';
2626 buf[2] = name[0];
2627 buf[3] = name[1];
2628 buf[4] = 0;
2629 idx = findoption(buf);
2630 }
2631 if (idx >= 0)
2632 set_option_sctx_idx(idx, OPT_GLOBAL, current_sctx);
2633}
Bram Moolenaard1f56e62006-02-22 21:25:37 +00002634#endif
2635
Bram Moolenaarf4140482020-02-15 23:06:45 +01002636#if defined(FEAT_EVAL)
2637/*
2638 * Apply the OptionSet autocommand.
2639 */
2640 static void
2641apply_optionset_autocmd(
2642 int opt_idx,
2643 long opt_flags,
2644 long oldval,
2645 long oldval_g,
2646 long newval,
2647 char *errmsg)
2648{
2649 char_u buf_old[12], buf_old_global[12], buf_new[12], buf_type[12];
2650
2651 // Don't do this while starting up, failure or recursively.
2652 if (starting || errmsg != NULL || *get_vim_var_str(VV_OPTION_TYPE) != NUL)
2653 return;
2654
2655 vim_snprintf((char *)buf_old, sizeof(buf_old), "%ld", oldval);
2656 vim_snprintf((char *)buf_old_global, sizeof(buf_old_global), "%ld",
2657 oldval_g);
2658 vim_snprintf((char *)buf_new, sizeof(buf_new), "%ld", newval);
2659 vim_snprintf((char *)buf_type, sizeof(buf_type), "%s",
2660 (opt_flags & OPT_LOCAL) ? "local" : "global");
2661 set_vim_var_string(VV_OPTION_NEW, buf_new, -1);
2662 set_vim_var_string(VV_OPTION_OLD, buf_old, -1);
2663 set_vim_var_string(VV_OPTION_TYPE, buf_type, -1);
2664 if (opt_flags & OPT_LOCAL)
2665 {
2666 set_vim_var_string(VV_OPTION_COMMAND, (char_u *)"setlocal", -1);
2667 set_vim_var_string(VV_OPTION_OLDLOCAL, buf_old, -1);
2668 }
2669 if (opt_flags & OPT_GLOBAL)
2670 {
2671 set_vim_var_string(VV_OPTION_COMMAND, (char_u *)"setglobal", -1);
2672 set_vim_var_string(VV_OPTION_OLDGLOBAL, buf_old, -1);
2673 }
2674 if ((opt_flags & (OPT_LOCAL | OPT_GLOBAL)) == 0)
2675 {
2676 set_vim_var_string(VV_OPTION_COMMAND, (char_u *)"set", -1);
2677 set_vim_var_string(VV_OPTION_OLDLOCAL, buf_old, -1);
2678 set_vim_var_string(VV_OPTION_OLDGLOBAL, buf_old_global, -1);
2679 }
2680 if (opt_flags & OPT_MODELINE)
2681 {
2682 set_vim_var_string(VV_OPTION_COMMAND, (char_u *)"modeline", -1);
2683 set_vim_var_string(VV_OPTION_OLDLOCAL, buf_old, -1);
2684 }
2685 apply_autocmds(EVENT_OPTIONSET, (char_u *)options[opt_idx].fullname,
2686 NULL, FALSE, NULL);
2687 reset_v_option_vars();
2688}
2689#endif
2690
Bram Moolenaar071d4272004-06-13 20:20:40 +00002691/*
2692 * Set the value of a boolean option, and take care of side effects.
2693 * Returns NULL for success, or an error message for an error.
2694 */
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002695 static char *
Bram Moolenaar9b578142016-01-30 19:39:49 +01002696set_bool_option(
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002697 int opt_idx, // index in options[] table
2698 char_u *varp, // pointer to the option variable
2699 int value, // new value
2700 int opt_flags) // OPT_LOCAL and/or OPT_GLOBAL
Bram Moolenaar071d4272004-06-13 20:20:40 +00002701{
2702 int old_value = *(int *)varp;
Bram Moolenaar983f2f12019-06-16 16:41:41 +02002703#if defined(FEAT_EVAL)
Bram Moolenaard7c96872019-06-15 17:12:48 +02002704 int old_global_value = 0;
Bram Moolenaar983f2f12019-06-16 16:41:41 +02002705#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002706
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002707 // Disallow changing some options from secure mode
Bram Moolenaar071d4272004-06-13 20:20:40 +00002708 if ((secure
2709#ifdef HAVE_SANDBOX
2710 || sandbox != 0
2711#endif
2712 ) && (options[opt_idx].flags & P_SECURE))
2713 return e_secure;
2714
Bram Moolenaar983f2f12019-06-16 16:41:41 +02002715#if defined(FEAT_EVAL)
Bram Moolenaard7c96872019-06-15 17:12:48 +02002716 // Save the global value before changing anything. This is needed as for
2717 // a global-only option setting the "local value" in fact sets the global
2718 // value (since there is only one value).
2719 if ((opt_flags & (OPT_LOCAL | OPT_GLOBAL)) == 0)
2720 old_global_value = *(int *)get_varp_scope(&(options[opt_idx]),
2721 OPT_GLOBAL);
Bram Moolenaar983f2f12019-06-16 16:41:41 +02002722#endif
Bram Moolenaard7c96872019-06-15 17:12:48 +02002723
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002724 *(int *)varp = value; // set the new value
Bram Moolenaar071d4272004-06-13 20:20:40 +00002725#ifdef FEAT_EVAL
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002726 // Remember where the option was set.
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02002727 set_option_sctx_idx(opt_idx, opt_flags, current_sctx);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002728#endif
2729
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00002730#ifdef FEAT_GUI
2731 need_mouse_correct = TRUE;
2732#endif
2733
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002734 // May set global value for local option.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002735 if ((opt_flags & (OPT_LOCAL | OPT_GLOBAL)) == 0)
2736 *(int *)get_varp_scope(&(options[opt_idx]), OPT_GLOBAL) = value;
2737
2738 /*
2739 * Handle side effects of changing a bool option.
2740 */
2741
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002742 // 'compatible'
Bram Moolenaar071d4272004-06-13 20:20:40 +00002743 if ((int *)varp == &p_cp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002744 compatible_set();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002745
Bram Moolenaar920694c2016-08-21 17:45:02 +02002746#ifdef FEAT_LANGMAP
2747 if ((int *)varp == &p_lrm)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002748 // 'langremap' -> !'langnoremap'
Bram Moolenaar920694c2016-08-21 17:45:02 +02002749 p_lnr = !p_lrm;
2750 else if ((int *)varp == &p_lnr)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002751 // 'langnoremap' -> !'langremap'
Bram Moolenaar920694c2016-08-21 17:45:02 +02002752 p_lrm = !p_lnr;
2753#endif
2754
Bram Moolenaar8c63e0e2018-09-25 22:17:54 +02002755#ifdef FEAT_SYN_HL
2756 else if ((int *)varp == &curwin->w_p_cul && !value && old_value)
2757 reset_cursorline();
2758#endif
2759
Bram Moolenaar374d32d2012-01-04 19:34:37 +01002760#ifdef FEAT_PERSISTENT_UNDO
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002761 // 'undofile'
Bram Moolenaar374d32d2012-01-04 19:34:37 +01002762 else if ((int *)varp == &curbuf->b_p_udf || (int *)varp == &p_udf)
2763 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002764 // Only take action when the option was set. When reset we do not
2765 // delete the undo file, the option may be set again without making
2766 // any changes in between.
Bram Moolenaare8d8fd22012-10-21 03:46:05 +02002767 if (curbuf->b_p_udf || p_udf)
Bram Moolenaar374d32d2012-01-04 19:34:37 +01002768 {
Bram Moolenaare8d8fd22012-10-21 03:46:05 +02002769 char_u hash[UNDO_HASH_SIZE];
2770 buf_T *save_curbuf = curbuf;
2771
Bram Moolenaar29323592016-07-24 22:04:11 +02002772 FOR_ALL_BUFFERS(curbuf)
Bram Moolenaar374d32d2012-01-04 19:34:37 +01002773 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002774 // When 'undofile' is set globally: for every buffer, otherwise
2775 // only for the current buffer: Try to read in the undofile,
2776 // if one exists, the buffer wasn't changed and the buffer was
2777 // loaded
Bram Moolenaare8d8fd22012-10-21 03:46:05 +02002778 if ((curbuf == save_curbuf
2779 || (opt_flags & OPT_GLOBAL) || opt_flags == 0)
2780 && !curbufIsChanged() && curbuf->b_ml.ml_mfp != NULL)
2781 {
Christian Brabandtf573c6e2021-06-20 14:02:16 +02002782#ifdef FEAT_CRYPT
2783 if (crypt_get_method_nr(curbuf) == CRYPT_M_SOD)
2784 continue;
2785#endif
Bram Moolenaare8d8fd22012-10-21 03:46:05 +02002786 u_compute_hash(hash);
2787 u_read_undo(NULL, hash, curbuf->b_fname);
2788 }
Bram Moolenaar374d32d2012-01-04 19:34:37 +01002789 }
Bram Moolenaare8d8fd22012-10-21 03:46:05 +02002790 curbuf = save_curbuf;
Bram Moolenaar374d32d2012-01-04 19:34:37 +01002791 }
Bram Moolenaar374d32d2012-01-04 19:34:37 +01002792 }
2793#endif
2794
Bram Moolenaar071d4272004-06-13 20:20:40 +00002795 else if ((int *)varp == &curbuf->b_p_ro)
2796 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002797 // when 'readonly' is reset globally, also reset readonlymode
Bram Moolenaar071d4272004-06-13 20:20:40 +00002798 if (!curbuf->b_p_ro && (opt_flags & OPT_LOCAL) == 0)
2799 readonlymode = FALSE;
Bram Moolenaard5cdbeb2005-10-10 20:59:28 +00002800
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002801 // when 'readonly' is set may give W10 again
Bram Moolenaard5cdbeb2005-10-10 20:59:28 +00002802 if (curbuf->b_p_ro)
2803 curbuf->b_did_warn = FALSE;
2804
Bram Moolenaar1f26d2f2009-02-11 10:35:36 +00002805 redraw_titles();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002806 }
2807
Bram Moolenaar9c449722010-07-20 18:44:27 +02002808#ifdef FEAT_GUI
2809 else if ((int *)varp == &p_mh)
2810 {
2811 if (!p_mh)
2812 gui_mch_mousehide(FALSE);
2813 }
2814#endif
2815
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002816 // when 'modifiable' is changed, redraw the window title
Bram Moolenaar071d4272004-06-13 20:20:40 +00002817 else if ((int *)varp == &curbuf->b_p_ma)
Bram Moolenaar1f26d2f2009-02-11 10:35:36 +00002818 {
Bram Moolenaar423802d2017-07-30 16:52:24 +02002819# ifdef FEAT_TERMINAL
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002820 // Cannot set 'modifiable' when in Terminal mode.
Bram Moolenaard7db27b2018-03-07 23:02:33 +01002821 if (curbuf->b_p_ma && (term_in_normal_mode() || (bt_terminal(curbuf)
2822 && curbuf->b_term != NULL && !term_is_finished(curbuf))))
Bram Moolenaar423802d2017-07-30 16:52:24 +02002823 {
2824 curbuf->b_p_ma = FALSE;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002825 return N_("E946: Cannot make a terminal with running job modifiable");
Bram Moolenaar423802d2017-07-30 16:52:24 +02002826 }
2827# endif
Bram Moolenaar1f26d2f2009-02-11 10:35:36 +00002828 redraw_titles();
2829 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002830 // when 'endofline' is changed, redraw the window title
Bram Moolenaar071d4272004-06-13 20:20:40 +00002831 else if ((int *)varp == &curbuf->b_p_eol)
Bram Moolenaar1f26d2f2009-02-11 10:35:36 +00002832 {
2833 redraw_titles();
2834 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002835 // when 'fixeol' is changed, redraw the window title
Bram Moolenaar34d72d42015-07-17 14:18:08 +02002836 else if ((int *)varp == &curbuf->b_p_fixeol)
2837 {
2838 redraw_titles();
2839 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002840 // when 'bomb' is changed, redraw the window title and tab page text
Bram Moolenaar83eb8852007-08-12 13:51:26 +00002841 else if ((int *)varp == &curbuf->b_p_bomb)
Bram Moolenaar1f26d2f2009-02-11 10:35:36 +00002842 {
2843 redraw_titles();
2844 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002845
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002846 // when 'bin' is set also set some other options
Bram Moolenaar071d4272004-06-13 20:20:40 +00002847 else if ((int *)varp == &curbuf->b_p_bin)
2848 {
2849 set_options_bin(old_value, curbuf->b_p_bin, opt_flags);
Bram Moolenaar1f26d2f2009-02-11 10:35:36 +00002850 redraw_titles();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002851 }
2852
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002853 // when 'buflisted' changes, trigger autocommands
Bram Moolenaar071d4272004-06-13 20:20:40 +00002854 else if ((int *)varp == &curbuf->b_p_bl && old_value != curbuf->b_p_bl)
2855 {
2856 apply_autocmds(curbuf->b_p_bl ? EVENT_BUFADD : EVENT_BUFDELETE,
2857 NULL, NULL, TRUE, curbuf);
2858 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002859
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002860 // when 'swf' is set, create swapfile, when reset remove swapfile
Bram Moolenaar071d4272004-06-13 20:20:40 +00002861 else if ((int *)varp == &curbuf->b_p_swf)
2862 {
2863 if (curbuf->b_p_swf && p_uc)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002864 ml_open_file(curbuf); // create the swap file
Bram Moolenaar071d4272004-06-13 20:20:40 +00002865 else
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002866 // no need to reset curbuf->b_may_swap, ml_open_file() will check
2867 // buf->b_p_swf
2868 mf_close_file(curbuf, TRUE); // remove the swap file
Bram Moolenaar071d4272004-06-13 20:20:40 +00002869 }
2870
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002871 // when 'terse' is set change 'shortmess'
Bram Moolenaar071d4272004-06-13 20:20:40 +00002872 else if ((int *)varp == &p_terse)
2873 {
2874 char_u *p;
2875
2876 p = vim_strchr(p_shm, SHM_SEARCH);
2877
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002878 // insert 's' in p_shm
Bram Moolenaar071d4272004-06-13 20:20:40 +00002879 if (p_terse && p == NULL)
2880 {
2881 STRCPY(IObuff, p_shm);
2882 STRCAT(IObuff, "s");
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00002883 set_string_option_direct((char_u *)"shm", -1, IObuff, OPT_FREE, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002884 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002885 // remove 's' from p_shm
Bram Moolenaar071d4272004-06-13 20:20:40 +00002886 else if (!p_terse && p != NULL)
Bram Moolenaarc1a11ed2008-06-24 22:09:24 +00002887 STRMOVE(p, p + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002888 }
2889
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002890 // when 'paste' is set or reset also change other options
Bram Moolenaar071d4272004-06-13 20:20:40 +00002891 else if ((int *)varp == &p_paste)
2892 {
2893 paste_option_changed();
2894 }
2895
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002896 // when 'insertmode' is set from an autocommand need to do work here
Bram Moolenaar071d4272004-06-13 20:20:40 +00002897 else if ((int *)varp == &p_im)
2898 {
2899 if (p_im)
2900 {
2901 if ((State & INSERT) == 0)
2902 need_start_insertmode = TRUE;
2903 stop_insert_mode = FALSE;
2904 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002905 // only reset if it was set previously
Bram Moolenaar00672e12016-06-26 18:38:13 +02002906 else if (old_value)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002907 {
2908 need_start_insertmode = FALSE;
2909 stop_insert_mode = TRUE;
Bram Moolenaard12f5c12006-01-25 22:10:52 +00002910 if (restart_edit != 0 && mode_displayed)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002911 clear_cmdline = TRUE; // remove "(insert)"
Bram Moolenaar071d4272004-06-13 20:20:40 +00002912 restart_edit = 0;
2913 }
2914 }
2915
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002916 // when 'ignorecase' is set or reset and 'hlsearch' is set, redraw
Bram Moolenaar071d4272004-06-13 20:20:40 +00002917 else if ((int *)varp == &p_ic && p_hls)
2918 {
Bram Moolenaarb9a02fc2006-03-12 22:08:12 +00002919 redraw_all_later(SOME_VALID);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002920 }
2921
2922#ifdef FEAT_SEARCH_EXTRA
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002923 // when 'hlsearch' is set or reset: reset no_hlsearch
Bram Moolenaar071d4272004-06-13 20:20:40 +00002924 else if ((int *)varp == &p_hls)
2925 {
Bram Moolenaar451fc7b2018-04-27 22:53:07 +02002926 set_no_hlsearch(FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002927 }
2928#endif
2929
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002930 // when 'scrollbind' is set: snapshot the current position to avoid a jump
2931 // at the end of normal_cmd()
Bram Moolenaar071d4272004-06-13 20:20:40 +00002932 else if ((int *)varp == &curwin->w_p_scb)
2933 {
2934 if (curwin->w_p_scb)
Bram Moolenaar04c5c9e2013-07-09 13:44:59 +02002935 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00002936 do_check_scrollbind(FALSE);
Bram Moolenaar04c5c9e2013-07-09 13:44:59 +02002937 curwin->w_scbind_pos = curwin->w_topline;
2938 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002939 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002940
Bram Moolenaar4033c552017-09-16 20:54:51 +02002941#if defined(FEAT_QUICKFIX)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002942 // There can be only one window with 'previewwindow' set.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002943 else if ((int *)varp == &curwin->w_p_pvw)
2944 {
2945 if (curwin->w_p_pvw)
2946 {
2947 win_T *win;
2948
Bram Moolenaar29323592016-07-24 22:04:11 +02002949 FOR_ALL_WINDOWS(win)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002950 if (win->w_p_pvw && win != curwin)
2951 {
2952 curwin->w_p_pvw = FALSE;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002953 return N_("E590: A preview window already exists");
Bram Moolenaar071d4272004-06-13 20:20:40 +00002954 }
2955 }
2956 }
2957#endif
2958
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002959 // when 'textmode' is set or reset also change 'fileformat'
Bram Moolenaar071d4272004-06-13 20:20:40 +00002960 else if ((int *)varp == &curbuf->b_p_tx)
2961 {
2962 set_fileformat(curbuf->b_p_tx ? EOL_DOS : EOL_UNIX, opt_flags);
2963 }
2964
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002965 // when 'textauto' is set or reset also change 'fileformats'
Bram Moolenaar071d4272004-06-13 20:20:40 +00002966 else if ((int *)varp == &p_ta)
Bram Moolenaarabab0b02019-03-30 18:47:01 +01002967 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00002968 set_string_option_direct((char_u *)"ffs", -1,
2969 p_ta ? (char_u *)DFLT_FFS_VIM : (char_u *)"",
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00002970 OPT_FREE | opt_flags, 0);
Bram Moolenaarabab0b02019-03-30 18:47:01 +01002971 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002972
2973 /*
2974 * When 'lisp' option changes include/exclude '-' in
2975 * keyword characters.
2976 */
2977#ifdef FEAT_LISP
2978 else if (varp == (char_u *)&(curbuf->b_p_lisp))
2979 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002980 (void)buf_init_chartab(curbuf, FALSE); // ignore errors
Bram Moolenaar071d4272004-06-13 20:20:40 +00002981 }
2982#endif
2983
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002984 // when 'title' changed, may need to change the title; same for 'icon'
Bram Moolenaar84a93082018-06-16 22:58:15 +02002985 else if ((int *)varp == &p_title || (int *)varp == &p_icon)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002986 {
Bram Moolenaar84a93082018-06-16 22:58:15 +02002987 did_set_title();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002988 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002989
2990 else if ((int *)varp == &curbuf->b_changed)
2991 {
2992 if (!value)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002993 save_file_ff(curbuf); // Buffer is unchanged
Bram Moolenaar1f26d2f2009-02-11 10:35:36 +00002994 redraw_titles();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002995 modified_was_set = value;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002996 }
2997
2998#ifdef BACKSLASH_IN_FILENAME
2999 else if ((int *)varp == &p_ssl)
3000 {
3001 if (p_ssl)
3002 {
3003 psepc = '/';
3004 psepcN = '\\';
3005 pseps[0] = '/';
Bram Moolenaar071d4272004-06-13 20:20:40 +00003006 }
3007 else
3008 {
3009 psepc = '\\';
3010 psepcN = '/';
3011 pseps[0] = '\\';
Bram Moolenaar071d4272004-06-13 20:20:40 +00003012 }
3013
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003014 // need to adjust the file name arguments and buffer names.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003015 buflist_slash_adjust();
3016 alist_slash_adjust();
3017# ifdef FEAT_EVAL
3018 scriptnames_slash_adjust();
3019# endif
3020 }
3021#endif
3022
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003023 // If 'wrap' is set, set w_leftcol to zero.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003024 else if ((int *)varp == &curwin->w_p_wrap)
3025 {
3026 if (curwin->w_p_wrap)
3027 curwin->w_leftcol = 0;
3028 }
3029
Bram Moolenaar071d4272004-06-13 20:20:40 +00003030 else if ((int *)varp == &p_ea)
3031 {
3032 if (p_ea && !old_value)
3033 win_equal(curwin, FALSE, 0);
3034 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003035
3036 else if ((int *)varp == &p_wiv)
3037 {
3038 /*
3039 * When 'weirdinvert' changed, set/reset 't_xs'.
3040 * Then set 'weirdinvert' according to value of 't_xs'.
3041 */
3042 if (p_wiv && !old_value)
3043 T_XS = (char_u *)"y";
3044 else if (!p_wiv && old_value)
3045 T_XS = empty_option;
3046 p_wiv = (*T_XS != NUL);
3047 }
3048
Bram Moolenaarc3719bd2017-11-18 22:13:31 +01003049#ifdef FEAT_BEVAL_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00003050 else if ((int *)varp == &p_beval)
3051 {
Bram Moolenaar51b0f372017-11-18 18:52:04 +01003052 if (!balloonEvalForTerm)
3053 {
3054 if (p_beval && !old_value)
3055 gui_mch_enable_beval_area(balloonEval);
3056 else if (!p_beval && old_value)
3057 gui_mch_disable_beval_area(balloonEval);
3058 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003059 }
Bram Moolenaar8dff8182006-04-06 20:18:50 +00003060#endif
Bram Moolenaarc3719bd2017-11-18 22:13:31 +01003061#ifdef FEAT_BEVAL_TERM
Bram Moolenaar51b0f372017-11-18 18:52:04 +01003062 else if ((int *)varp == &p_bevalterm)
3063 {
3064 mch_bevalterm_changed();
3065 }
Bram Moolenaarc3719bd2017-11-18 22:13:31 +01003066#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003067
Bram Moolenaar8dff8182006-04-06 20:18:50 +00003068#ifdef FEAT_AUTOCHDIR
Bram Moolenaar071d4272004-06-13 20:20:40 +00003069 else if ((int *)varp == &p_acd)
3070 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003071 // Change directories when the 'acd' option is set now.
Bram Moolenaar6f470022018-04-10 18:47:20 +02003072 DO_AUTOCHDIR;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003073 }
3074#endif
3075
3076#ifdef FEAT_DIFF
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003077 // 'diff'
Bram Moolenaar071d4272004-06-13 20:20:40 +00003078 else if ((int *)varp == &curwin->w_p_diff)
3079 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003080 // May add or remove the buffer from the list of diff buffers.
Bram Moolenaar2df6dcc2004-07-12 15:53:54 +00003081 diff_buf_adjust(curwin);
3082# ifdef FEAT_FOLDING
Bram Moolenaar071d4272004-06-13 20:20:40 +00003083 if (foldmethodIsDiff(curwin))
3084 foldUpdateAll(curwin);
Bram Moolenaar2df6dcc2004-07-12 15:53:54 +00003085# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003086 }
3087#endif
3088
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01003089#ifdef HAVE_INPUT_METHOD
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003090 // 'imdisable'
Bram Moolenaar071d4272004-06-13 20:20:40 +00003091 else if ((int *)varp == &p_imdisable)
3092 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003093 // Only de-activate it here, it will be enabled when changing mode.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003094 if (p_imdisable)
3095 im_set_active(FALSE);
Bram Moolenaar725a9622011-10-12 16:57:13 +02003096 else if (State & INSERT)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003097 // When the option is set from an autocommand, it may need to take
3098 // effect right away.
Bram Moolenaar725a9622011-10-12 16:57:13 +02003099 im_set_active(curbuf->b_p_iminsert == B_IMODE_IM);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003100 }
3101#endif
3102
Bram Moolenaarb9a02fc2006-03-12 22:08:12 +00003103#ifdef FEAT_SPELL
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003104 // 'spell'
Bram Moolenaar0cb032e2005-04-23 20:52:00 +00003105 else if ((int *)varp == &curwin->w_p_spell)
3106 {
3107 if (curwin->w_p_spell)
3108 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003109 char *errmsg = did_set_spelllang(curwin);
3110
Bram Moolenaar0cb032e2005-04-23 20:52:00 +00003111 if (errmsg != NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003112 emsg(_(errmsg));
Bram Moolenaar0cb032e2005-04-23 20:52:00 +00003113 }
3114 }
3115#endif
3116
Bram Moolenaar071d4272004-06-13 20:20:40 +00003117#ifdef FEAT_ARABIC
3118 if ((int *)varp == &curwin->w_p_arab)
3119 {
3120 if (curwin->w_p_arab)
3121 {
3122 /*
3123 * 'arabic' is set, handle various sub-settings.
3124 */
3125 if (!p_tbidi)
3126 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003127 // set rightleft mode
Bram Moolenaar071d4272004-06-13 20:20:40 +00003128 if (!curwin->w_p_rl)
3129 {
3130 curwin->w_p_rl = TRUE;
3131 changed_window_setting();
3132 }
3133
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003134 // Enable Arabic shaping (major part of what Arabic requires)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003135 if (!p_arshape)
3136 {
3137 p_arshape = TRUE;
3138 redraw_later_clear();
3139 }
3140 }
3141
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003142 // Arabic requires a utf-8 encoding, inform the user if its not
3143 // set.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003144 if (STRCMP(p_enc, "utf-8") != 0)
Bram Moolenaar2df6dcc2004-07-12 15:53:54 +00003145 {
Bram Moolenaar496c5262009-03-18 14:42:00 +00003146 static char *w_arabic = N_("W17: Arabic requires UTF-8, do ':set encoding=utf-8'");
3147
Bram Moolenaar8820b482017-03-16 17:23:31 +01003148 msg_source(HL_ATTR(HLF_W));
Bram Moolenaar32526b32019-01-19 17:43:09 +01003149 msg_attr(_(w_arabic), HL_ATTR(HLF_W));
Bram Moolenaar496c5262009-03-18 14:42:00 +00003150#ifdef FEAT_EVAL
3151 set_vim_var_string(VV_WARNINGMSG, (char_u *)_(w_arabic), -1);
3152#endif
Bram Moolenaar2df6dcc2004-07-12 15:53:54 +00003153 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003154
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003155 // set 'delcombine'
Bram Moolenaar071d4272004-06-13 20:20:40 +00003156 p_deco = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003157
3158# ifdef FEAT_KEYMAP
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003159 // Force-set the necessary keymap for arabic
Bram Moolenaar071d4272004-06-13 20:20:40 +00003160 set_option_value((char_u *)"keymap", 0L, (char_u *)"arabic",
3161 OPT_LOCAL);
3162# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003163 }
3164 else
3165 {
3166 /*
3167 * 'arabic' is reset, handle various sub-settings.
3168 */
3169 if (!p_tbidi)
3170 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003171 // reset rightleft mode
Bram Moolenaar071d4272004-06-13 20:20:40 +00003172 if (curwin->w_p_rl)
3173 {
3174 curwin->w_p_rl = FALSE;
3175 changed_window_setting();
3176 }
3177
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003178 // 'arabicshape' isn't reset, it is a global option and
3179 // another window may still need it "on".
Bram Moolenaar071d4272004-06-13 20:20:40 +00003180 }
3181
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003182 // 'delcombine' isn't reset, it is a global option and another
3183 // window may still want it "on".
Bram Moolenaar071d4272004-06-13 20:20:40 +00003184
3185# ifdef FEAT_KEYMAP
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003186 // Revert to the default keymap
Bram Moolenaar071d4272004-06-13 20:20:40 +00003187 curbuf->b_p_iminsert = B_IMODE_NONE;
3188 curbuf->b_p_imsearch = B_IMODE_USE_INSERT;
3189# endif
3190 }
Bram Moolenaar801f8b82009-07-29 13:42:05 +00003191 }
3192
Bram Moolenaar319bdbd2009-09-11 13:20:33 +00003193#endif
3194
Bram Moolenaar44826212019-08-22 21:23:20 +02003195#if defined(FEAT_SIGNS) && defined(FEAT_GUI)
3196 else if (((int *)varp == &curwin->w_p_nu
3197 || (int *)varp == &curwin->w_p_rnu)
3198 && gui.in_use
3199 && (*curwin->w_p_scl == 'n' && *(curwin->w_p_scl + 1) == 'u')
3200 && curbuf->b_signlist != NULL)
3201 {
3202 // If the 'number' or 'relativenumber' options are modified and
3203 // 'signcolumn' is set to 'number', then clear the screen for a full
3204 // refresh. Otherwise the sign icons are not displayed properly in the
3205 // number column. If the 'number' option is set and only the
3206 // 'relativenumber' option is toggled, then don't refresh the screen
3207 // (optimization).
3208 if (!(curwin->w_p_nu && ((int *)varp == &curwin->w_p_rnu)))
3209 redraw_all_later(CLEAR);
3210 }
3211#endif
3212
Bram Moolenaar61be73b2016-04-29 22:59:22 +02003213#ifdef FEAT_TERMGUICOLORS
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003214 // 'termguicolors'
Bram Moolenaar61be73b2016-04-29 22:59:22 +02003215 else if ((int *)varp == &p_tgc)
Bram Moolenaar8a633e32016-04-21 21:10:14 +02003216 {
Bram Moolenaarcafafb32018-02-22 21:07:09 +01003217# ifdef FEAT_VTP
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003218 // Do not turn on 'tgc' when 24-bit colors are not supported.
Bram Moolenaarafde13b2019-04-28 19:46:49 +02003219 if (
3220# ifdef VIMDLL
3221 !gui.in_use && !gui.starting &&
3222# endif
3223 !has_vtp_working())
Bram Moolenaarcafafb32018-02-22 21:07:09 +01003224 {
3225 p_tgc = 0;
Bram Moolenaaraa5df7e2019-02-03 14:53:10 +01003226 return N_("E954: 24-bit colors are not supported on this environment");
Bram Moolenaarcafafb32018-02-22 21:07:09 +01003227 }
Bram Moolenaarc5cd8852018-05-01 15:47:38 +02003228 if (is_term_win32())
3229 swap_tcap();
Bram Moolenaarcafafb32018-02-22 21:07:09 +01003230# endif
Bram Moolenaar8a633e32016-04-21 21:10:14 +02003231# ifdef FEAT_GUI
3232 if (!gui.in_use && !gui.starting)
3233# endif
3234 highlight_gui_started();
Bram Moolenaarcafafb32018-02-22 21:07:09 +01003235# ifdef FEAT_VTP
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003236 // reset t_Co
Bram Moolenaarc5cd8852018-05-01 15:47:38 +02003237 if (is_term_win32())
Bram Moolenaarb0eb14f2018-06-28 15:29:52 +02003238 {
3239 control_console_color_rgb();
Bram Moolenaarcafafb32018-02-22 21:07:09 +01003240 set_termname(T_NAME);
Bram Moolenaarb0eb14f2018-06-28 15:29:52 +02003241 init_highlight(TRUE, FALSE);
3242 }
Bram Moolenaarcafafb32018-02-22 21:07:09 +01003243# endif
Bram Moolenaar87fd0922021-11-20 13:47:45 +00003244# ifdef FEAT_TERMINAL
3245 term_update_colors_all();
3246 term_update_wincolor_all();
3247# endif
Bram Moolenaar8a633e32016-04-21 21:10:14 +02003248 }
3249#endif
3250
Bram Moolenaar071d4272004-06-13 20:20:40 +00003251 /*
3252 * End of handling side effects for bool options.
3253 */
3254
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003255 // after handling side effects, call autocommand
Bram Moolenaar53744302015-07-17 17:38:22 +02003256
Bram Moolenaar071d4272004-06-13 20:20:40 +00003257 options[opt_idx].flags |= P_WAS_SET;
3258
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01003259#if defined(FEAT_EVAL)
Bram Moolenaarf4140482020-02-15 23:06:45 +01003260 apply_optionset_autocmd(opt_idx, opt_flags,
3261 (long)(old_value ? TRUE : FALSE),
3262 (long)(old_global_value ? TRUE : FALSE),
3263 (long)(value ? TRUE : FALSE), NULL);
Bram Moolenaar53744302015-07-17 17:38:22 +02003264#endif
3265
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003266 comp_col(); // in case 'ruler' or 'showcmd' changed
Bram Moolenaar913077c2012-03-28 19:59:04 +02003267 if (curwin->w_curswant != MAXCOL
Bram Moolenaar488eb262015-03-13 11:23:50 +01003268 && (options[opt_idx].flags & (P_CURSWANT | P_RALL)) != 0)
Bram Moolenaar913077c2012-03-28 19:59:04 +02003269 curwin->w_set_curswant = TRUE;
Bram Moolenaar37294bd2021-03-10 13:40:08 +01003270
3271 if ((opt_flags & OPT_NO_REDRAW) == 0)
3272 check_redraw(options[opt_idx].flags);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003273
3274 return NULL;
3275}
3276
3277/*
3278 * Set the value of a number option, and take care of side effects.
3279 * Returns NULL for success, or an error message for an error.
3280 */
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003281 static char *
Bram Moolenaar9b578142016-01-30 19:39:49 +01003282set_num_option(
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003283 int opt_idx, // index in options[] table
3284 char_u *varp, // pointer to the option variable
3285 long value, // new value
3286 char *errbuf, // buffer for error messages
3287 size_t errbuflen, // length of "errbuf"
Bram Moolenaar37294bd2021-03-10 13:40:08 +01003288 int opt_flags) // OPT_LOCAL, OPT_GLOBAL,
3289 // OPT_MODELINE, etc.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003290{
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003291 char *errmsg = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003292 long old_value = *(long *)varp;
Bram Moolenaar983f2f12019-06-16 16:41:41 +02003293#if defined(FEAT_EVAL)
Bram Moolenaard7c96872019-06-15 17:12:48 +02003294 long old_global_value = 0; // only used when setting a local and
3295 // global option
Bram Moolenaar983f2f12019-06-16 16:41:41 +02003296#endif
Bram Moolenaard7c96872019-06-15 17:12:48 +02003297 long old_Rows = Rows; // remember old Rows
3298 long old_Columns = Columns; // remember old Columns
Bram Moolenaar071d4272004-06-13 20:20:40 +00003299 long *pp = (long *)varp;
3300
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003301 // Disallow changing some options from secure mode.
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00003302 if ((secure
3303#ifdef HAVE_SANDBOX
3304 || sandbox != 0
Bram Moolenaar071d4272004-06-13 20:20:40 +00003305#endif
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00003306 ) && (options[opt_idx].flags & P_SECURE))
3307 return e_secure;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003308
Bram Moolenaar983f2f12019-06-16 16:41:41 +02003309#if defined(FEAT_EVAL)
Bram Moolenaard7c96872019-06-15 17:12:48 +02003310 // Save the global value before changing anything. This is needed as for
Bram Moolenaar4b96df52020-01-26 22:00:26 +01003311 // a global-only option setting the "local value" in fact sets the global
Bram Moolenaard7c96872019-06-15 17:12:48 +02003312 // value (since there is only one value).
3313 if ((opt_flags & (OPT_LOCAL | OPT_GLOBAL)) == 0)
Bram Moolenaar983f2f12019-06-16 16:41:41 +02003314 old_global_value = *(long *)get_varp_scope(&(options[opt_idx]),
3315 OPT_GLOBAL);
3316#endif
Bram Moolenaard7c96872019-06-15 17:12:48 +02003317
Bram Moolenaar071d4272004-06-13 20:20:40 +00003318 *pp = value;
3319#ifdef FEAT_EVAL
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003320 // Remember where the option was set.
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02003321 set_option_sctx_idx(opt_idx, opt_flags, current_sctx);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003322#endif
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00003323#ifdef FEAT_GUI
3324 need_mouse_correct = TRUE;
3325#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003326
Bram Moolenaar14f24742012-08-08 18:01:05 +02003327 if (curbuf->b_p_sw < 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003328 {
3329 errmsg = e_positive;
Bram Moolenaar04958cb2018-06-23 19:23:02 +02003330#ifdef FEAT_VARTABS
3331 // Use the first 'vartabstop' value, or 'tabstop' if vts isn't in use.
3332 curbuf->b_p_sw = tabstop_count(curbuf->b_p_vts_array) > 0
3333 ? tabstop_first(curbuf->b_p_vts_array)
3334 : curbuf->b_p_ts;
3335#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00003336 curbuf->b_p_sw = curbuf->b_p_ts;
Bram Moolenaar04958cb2018-06-23 19:23:02 +02003337#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003338 }
3339
3340 /*
3341 * Number options that need some action when changed
3342 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003343 if (pp == &p_wh || pp == &p_hh)
3344 {
Bram Moolenaar1c3c1042018-06-12 16:49:30 +02003345 // 'winheight' and 'helpheight'
Bram Moolenaar071d4272004-06-13 20:20:40 +00003346 if (p_wh < 1)
3347 {
3348 errmsg = e_positive;
3349 p_wh = 1;
3350 }
3351 if (p_wmh > p_wh)
3352 {
3353 errmsg = e_winheight;
3354 p_wh = p_wmh;
3355 }
3356 if (p_hh < 0)
3357 {
3358 errmsg = e_positive;
3359 p_hh = 0;
3360 }
3361
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003362 // Change window height NOW
Bram Moolenaar459ca562016-11-10 18:16:33 +01003363 if (!ONE_WINDOW)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003364 {
3365 if (pp == &p_wh && curwin->w_height < p_wh)
3366 win_setheight((int)p_wh);
3367 if (pp == &p_hh && curbuf->b_help && curwin->w_height < p_hh)
3368 win_setheight((int)p_hh);
3369 }
3370 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003371 else if (pp == &p_wmh)
3372 {
Bram Moolenaar1c3c1042018-06-12 16:49:30 +02003373 // 'winminheight'
Bram Moolenaar071d4272004-06-13 20:20:40 +00003374 if (p_wmh < 0)
3375 {
3376 errmsg = e_positive;
3377 p_wmh = 0;
3378 }
3379 if (p_wmh > p_wh)
3380 {
3381 errmsg = e_winheight;
3382 p_wmh = p_wh;
3383 }
3384 win_setminheight();
3385 }
Bram Moolenaar592e0a22004-07-03 16:05:59 +00003386 else if (pp == &p_wiw)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003387 {
Bram Moolenaar1c3c1042018-06-12 16:49:30 +02003388 // 'winwidth'
Bram Moolenaar071d4272004-06-13 20:20:40 +00003389 if (p_wiw < 1)
3390 {
3391 errmsg = e_positive;
3392 p_wiw = 1;
3393 }
3394 if (p_wmw > p_wiw)
3395 {
3396 errmsg = e_winwidth;
3397 p_wiw = p_wmw;
3398 }
3399
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003400 // Change window width NOW
Bram Moolenaar459ca562016-11-10 18:16:33 +01003401 if (!ONE_WINDOW && curwin->w_width < p_wiw)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003402 win_setwidth((int)p_wiw);
3403 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003404 else if (pp == &p_wmw)
3405 {
Bram Moolenaar1c3c1042018-06-12 16:49:30 +02003406 // 'winminwidth'
Bram Moolenaar071d4272004-06-13 20:20:40 +00003407 if (p_wmw < 0)
3408 {
3409 errmsg = e_positive;
3410 p_wmw = 0;
3411 }
3412 if (p_wmw > p_wiw)
3413 {
3414 errmsg = e_winwidth;
3415 p_wmw = p_wiw;
3416 }
Bram Moolenaar1c3c1042018-06-12 16:49:30 +02003417 win_setminwidth();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003418 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003419
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003420 // (re)set last window status line
Bram Moolenaar071d4272004-06-13 20:20:40 +00003421 else if (pp == &p_ls)
3422 {
3423 last_status(FALSE);
3424 }
Bram Moolenaar4c7ed462006-02-15 22:18:42 +00003425
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003426 // (re)set tab page line
Bram Moolenaarfaa959a2006-02-20 21:37:40 +00003427 else if (pp == &p_stal)
Bram Moolenaar4c7ed462006-02-15 22:18:42 +00003428 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003429 shell_new_rows(); // recompute window positions and heights
Bram Moolenaar4c7ed462006-02-15 22:18:42 +00003430 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003431
3432#ifdef FEAT_GUI
3433 else if (pp == &p_linespace)
3434 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003435 // Recompute gui.char_height and resize the Vim window to keep the
3436 // same number of lines.
Bram Moolenaar02743632005-07-25 20:42:36 +00003437 if (gui.in_use && gui_mch_adjust_charheight() == OK)
Bram Moolenaar3964b7e2006-03-27 20:59:33 +00003438 gui_set_shellsize(FALSE, FALSE, RESIZE_VERT);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003439 }
3440#endif
3441
3442#ifdef FEAT_FOLDING
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003443 // 'foldlevel'
Bram Moolenaar071d4272004-06-13 20:20:40 +00003444 else if (pp == &curwin->w_p_fdl)
3445 {
3446 if (curwin->w_p_fdl < 0)
3447 curwin->w_p_fdl = 0;
3448 newFoldLevel();
3449 }
3450
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003451 // 'foldminlines'
Bram Moolenaar071d4272004-06-13 20:20:40 +00003452 else if (pp == &curwin->w_p_fml)
3453 {
3454 foldUpdateAll(curwin);
3455 }
3456
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003457 // 'foldnestmax'
Bram Moolenaar071d4272004-06-13 20:20:40 +00003458 else if (pp == &curwin->w_p_fdn)
3459 {
3460 if (foldmethodIsSyntax(curwin) || foldmethodIsIndent(curwin))
3461 foldUpdateAll(curwin);
3462 }
3463
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003464 // 'foldcolumn'
Bram Moolenaar071d4272004-06-13 20:20:40 +00003465 else if (pp == &curwin->w_p_fdc)
3466 {
3467 if (curwin->w_p_fdc < 0)
3468 {
3469 errmsg = e_positive;
3470 curwin->w_p_fdc = 0;
3471 }
3472 else if (curwin->w_p_fdc > 12)
3473 {
3474 errmsg = e_invarg;
3475 curwin->w_p_fdc = 12;
3476 }
3477 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003478#endif // FEAT_FOLDING
Bram Moolenaar071d4272004-06-13 20:20:40 +00003479
Bram Moolenaar6bcbcc52013-11-05 07:13:41 +01003480#if defined(FEAT_FOLDING) || defined(FEAT_CINDENT)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003481 // 'shiftwidth' or 'tabstop'
Bram Moolenaar071d4272004-06-13 20:20:40 +00003482 else if (pp == &curbuf->b_p_sw || pp == &curbuf->b_p_ts)
3483 {
Bram Moolenaar6bcbcc52013-11-05 07:13:41 +01003484# ifdef FEAT_FOLDING
Bram Moolenaar071d4272004-06-13 20:20:40 +00003485 if (foldmethodIsIndent(curwin))
3486 foldUpdateAll(curwin);
Bram Moolenaar6bcbcc52013-11-05 07:13:41 +01003487# endif
3488# ifdef FEAT_CINDENT
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003489 // When 'shiftwidth' changes, or it's zero and 'tabstop' changes:
3490 // parse 'cinoptions'.
Bram Moolenaar6bcbcc52013-11-05 07:13:41 +01003491 if (pp == &curbuf->b_p_sw || curbuf->b_p_sw == 0)
3492 parse_cino(curbuf);
3493# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003494 }
Bram Moolenaar6bcbcc52013-11-05 07:13:41 +01003495#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003496
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003497 // 'maxcombine'
Bram Moolenaar362e1a32006-03-06 23:29:24 +00003498 else if (pp == &p_mco)
3499 {
3500 if (p_mco > MAX_MCO)
3501 p_mco = MAX_MCO;
3502 else if (p_mco < 0)
3503 p_mco = 0;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003504 screenclear(); // will re-allocate the screen
Bram Moolenaar362e1a32006-03-06 23:29:24 +00003505 }
Bram Moolenaar362e1a32006-03-06 23:29:24 +00003506
Bram Moolenaar071d4272004-06-13 20:20:40 +00003507 else if (pp == &curbuf->b_p_iminsert)
3508 {
3509 if (curbuf->b_p_iminsert < 0 || curbuf->b_p_iminsert > B_IMODE_LAST)
3510 {
3511 errmsg = e_invarg;
3512 curbuf->b_p_iminsert = B_IMODE_NONE;
3513 }
3514 p_iminsert = curbuf->b_p_iminsert;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003515 if (termcap_active) // don't do this in the alternate screen
Bram Moolenaar071d4272004-06-13 20:20:40 +00003516 showmode();
Bram Moolenaar4033c552017-09-16 20:54:51 +02003517#if defined(FEAT_KEYMAP)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003518 // Show/unshow value of 'keymap' in status lines.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003519 status_redraw_curbuf();
3520#endif
3521 }
3522
Bram Moolenaar5c6dbcb2017-08-30 22:00:20 +02003523#if defined(FEAT_XIM) && defined(FEAT_GUI_GTK)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003524 // 'imstyle'
Bram Moolenaar5c6dbcb2017-08-30 22:00:20 +02003525 else if (pp == &p_imst)
3526 {
3527 if (p_imst != IM_ON_THE_SPOT && p_imst != IM_OVER_THE_SPOT)
3528 errmsg = e_invarg;
3529 }
3530#endif
3531
Bram Moolenaar4399ef42005-02-12 14:29:27 +00003532 else if (pp == &p_window)
3533 {
3534 if (p_window < 1)
3535 p_window = 1;
3536 else if (p_window >= Rows)
3537 p_window = Rows - 1;
3538 }
3539
Bram Moolenaar071d4272004-06-13 20:20:40 +00003540 else if (pp == &curbuf->b_p_imsearch)
3541 {
3542 if (curbuf->b_p_imsearch < -1 || curbuf->b_p_imsearch > B_IMODE_LAST)
3543 {
3544 errmsg = e_invarg;
3545 curbuf->b_p_imsearch = B_IMODE_NONE;
3546 }
3547 p_imsearch = curbuf->b_p_imsearch;
3548 }
3549
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003550 // if 'titlelen' has changed, redraw the title
Bram Moolenaar071d4272004-06-13 20:20:40 +00003551 else if (pp == &p_titlelen)
3552 {
3553 if (p_titlelen < 0)
3554 {
3555 errmsg = e_positive;
3556 p_titlelen = 85;
3557 }
3558 if (starting != NO_SCREEN && old_value != p_titlelen)
3559 need_maketitle = TRUE;
3560 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003561
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003562 // if p_ch changed value, change the command line height
Bram Moolenaar071d4272004-06-13 20:20:40 +00003563 else if (pp == &p_ch)
3564 {
3565 if (p_ch < 1)
3566 {
3567 errmsg = e_positive;
3568 p_ch = 1;
3569 }
Bram Moolenaar719939c2007-09-25 12:51:28 +00003570 if (p_ch > Rows - min_rows() + 1)
3571 p_ch = Rows - min_rows() + 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003572
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003573 // Only compute the new window layout when startup has been
3574 // completed. Otherwise the frame sizes may be wrong.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003575 if (p_ch != old_value && full_screen
3576#ifdef FEAT_GUI
3577 && !gui.starting
3578#endif
3579 )
Bram Moolenaarc6fe9192006-04-09 21:54:49 +00003580 command_height();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003581 }
3582
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003583 // when 'updatecount' changes from zero to non-zero, open swap files
Bram Moolenaar071d4272004-06-13 20:20:40 +00003584 else if (pp == &p_uc)
3585 {
3586 if (p_uc < 0)
3587 {
3588 errmsg = e_positive;
3589 p_uc = 100;
3590 }
3591 if (p_uc && !old_value)
3592 ml_open_files();
3593 }
Bram Moolenaar860cae12010-06-05 23:22:07 +02003594#ifdef FEAT_CONCEAL
Bram Moolenaarf5963f72010-07-23 22:10:27 +02003595 else if (pp == &curwin->w_p_cole)
Bram Moolenaar860cae12010-06-05 23:22:07 +02003596 {
Bram Moolenaarf5963f72010-07-23 22:10:27 +02003597 if (curwin->w_p_cole < 0)
Bram Moolenaar860cae12010-06-05 23:22:07 +02003598 {
3599 errmsg = e_positive;
Bram Moolenaarf5963f72010-07-23 22:10:27 +02003600 curwin->w_p_cole = 0;
Bram Moolenaar860cae12010-06-05 23:22:07 +02003601 }
Bram Moolenaarf5963f72010-07-23 22:10:27 +02003602 else if (curwin->w_p_cole > 3)
Bram Moolenaar860cae12010-06-05 23:22:07 +02003603 {
3604 errmsg = e_invarg;
Bram Moolenaarf5963f72010-07-23 22:10:27 +02003605 curwin->w_p_cole = 3;
Bram Moolenaar860cae12010-06-05 23:22:07 +02003606 }
3607 }
3608#endif
Bram Moolenaar2df6dcc2004-07-12 15:53:54 +00003609#ifdef MZSCHEME_GUI_THREADS
Bram Moolenaar325b7a22004-07-05 15:58:32 +00003610 else if (pp == &p_mzq)
3611 mzvim_reset_timer();
3612#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003613
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01003614#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003615 // 'pyxversion'
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +01003616 else if (pp == &p_pyx)
3617 {
3618 if (p_pyx != 0 && p_pyx != 2 && p_pyx != 3)
3619 errmsg = e_invarg;
3620 }
3621#endif
3622
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003623 // sync undo before 'undolevels' changes
Bram Moolenaar071d4272004-06-13 20:20:40 +00003624 else if (pp == &p_ul)
3625 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003626 // use the old value, otherwise u_sync() may not work properly
Bram Moolenaar071d4272004-06-13 20:20:40 +00003627 p_ul = old_value;
Bram Moolenaar779b74b2006-04-10 14:55:34 +00003628 u_sync(TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003629 p_ul = value;
3630 }
Bram Moolenaarf5a2fd82013-11-06 05:26:15 +01003631 else if (pp == &curbuf->b_p_ul)
3632 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003633 // use the old value, otherwise u_sync() may not work properly
Bram Moolenaarf5a2fd82013-11-06 05:26:15 +01003634 curbuf->b_p_ul = old_value;
3635 u_sync(TRUE);
3636 curbuf->b_p_ul = value;
3637 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003638
Bram Moolenaar592e0a22004-07-03 16:05:59 +00003639#ifdef FEAT_LINEBREAK
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003640 // 'numberwidth' must be positive
Bram Moolenaar592e0a22004-07-03 16:05:59 +00003641 else if (pp == &curwin->w_p_nuw)
3642 {
3643 if (curwin->w_p_nuw < 1)
3644 {
3645 errmsg = e_positive;
3646 curwin->w_p_nuw = 1;
3647 }
Bram Moolenaarf8a07122019-07-01 22:06:07 +02003648 if (curwin->w_p_nuw > 20)
Bram Moolenaar592e0a22004-07-03 16:05:59 +00003649 {
3650 errmsg = e_invarg;
Bram Moolenaarf8a07122019-07-01 22:06:07 +02003651 curwin->w_p_nuw = 20;
Bram Moolenaar592e0a22004-07-03 16:05:59 +00003652 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003653 curwin->w_nrwidth_line_count = 0; // trigger a redraw
Bram Moolenaar592e0a22004-07-03 16:05:59 +00003654 }
3655#endif
3656
Bram Moolenaar1a384422010-07-14 19:53:30 +02003657 else if (pp == &curbuf->b_p_tw)
3658 {
3659 if (curbuf->b_p_tw < 0)
3660 {
3661 errmsg = e_positive;
3662 curbuf->b_p_tw = 0;
3663 }
3664#ifdef FEAT_SYN_HL
Bram Moolenaar1a384422010-07-14 19:53:30 +02003665 {
3666 win_T *wp;
3667 tabpage_T *tp;
3668
3669 FOR_ALL_TAB_WINDOWS(tp, wp)
3670 check_colorcolumn(wp);
3671 }
Bram Moolenaar1a384422010-07-14 19:53:30 +02003672#endif
3673 }
3674
Bram Moolenaar071d4272004-06-13 20:20:40 +00003675 /*
3676 * Check the bounds for numeric options here
3677 */
3678 if (Rows < min_rows() && full_screen)
3679 {
3680 if (errbuf != NULL)
3681 {
Bram Moolenaar555b2802005-05-19 21:08:39 +00003682 vim_snprintf((char *)errbuf, errbuflen,
3683 _("E593: Need at least %d lines"), min_rows());
Bram Moolenaar071d4272004-06-13 20:20:40 +00003684 errmsg = errbuf;
3685 }
3686 Rows = min_rows();
3687 }
3688 if (Columns < MIN_COLUMNS && full_screen)
3689 {
3690 if (errbuf != NULL)
3691 {
Bram Moolenaar555b2802005-05-19 21:08:39 +00003692 vim_snprintf((char *)errbuf, errbuflen,
3693 _("E594: Need at least %d columns"), MIN_COLUMNS);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003694 errmsg = errbuf;
3695 }
3696 Columns = MIN_COLUMNS;
3697 }
Bram Moolenaare057d402013-06-30 17:51:51 +02003698 limit_screen_size();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003699
Bram Moolenaar071d4272004-06-13 20:20:40 +00003700 /*
3701 * If the screen (shell) height has been changed, assume it is the
3702 * physical screenheight.
3703 */
3704 if (old_Rows != Rows || old_Columns != Columns)
3705 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003706 // Changing the screen size is not allowed while updating the screen.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003707 if (updating_screen)
3708 *pp = old_value;
3709 else if (full_screen
3710#ifdef FEAT_GUI
3711 && !gui.starting
3712#endif
3713 )
3714 set_shellsize((int)Columns, (int)Rows, TRUE);
3715 else
3716 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003717 // Postpone the resizing; check the size and cmdline position for
3718 // messages.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003719 check_shellsize();
3720 if (cmdline_row > Rows - p_ch && Rows > p_ch)
3721 cmdline_row = Rows - p_ch;
3722 }
Bram Moolenaard68071d2006-05-02 22:08:30 +00003723 if (p_window >= Rows || !option_was_set((char_u *)"window"))
Bram Moolenaar4399ef42005-02-12 14:29:27 +00003724 p_window = Rows - 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003725 }
3726
Bram Moolenaar071d4272004-06-13 20:20:40 +00003727 if (curbuf->b_p_ts <= 0)
3728 {
3729 errmsg = e_positive;
3730 curbuf->b_p_ts = 8;
3731 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003732 if (p_tm < 0)
3733 {
3734 errmsg = e_positive;
3735 p_tm = 0;
3736 }
3737 if ((curwin->w_p_scr <= 0
3738 || (curwin->w_p_scr > curwin->w_height
3739 && curwin->w_height > 0))
3740 && full_screen)
3741 {
3742 if (pp == &(curwin->w_p_scr))
3743 {
3744 if (curwin->w_p_scr != 0)
Bram Moolenaard8e44472021-07-21 22:20:33 +02003745 errmsg = e_invalid_scroll_size;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003746 win_comp_scroll(curwin);
3747 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003748 // If 'scroll' became invalid because of a side effect silently adjust
3749 // it.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003750 else if (curwin->w_p_scr <= 0)
3751 curwin->w_p_scr = 1;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003752 else // curwin->w_p_scr > curwin->w_height
Bram Moolenaar071d4272004-06-13 20:20:40 +00003753 curwin->w_p_scr = curwin->w_height;
3754 }
Bram Moolenaar991e10f2008-10-02 20:48:41 +00003755 if (p_hi < 0)
3756 {
3757 errmsg = e_positive;
3758 p_hi = 0;
3759 }
Bram Moolenaar78159bb2014-06-25 11:48:54 +02003760 else if (p_hi > 10000)
3761 {
3762 errmsg = e_invarg;
3763 p_hi = 10000;
3764 }
Bram Moolenaarfbc0d2e2013-05-19 19:40:29 +02003765 if (p_re < 0 || p_re > 2)
3766 {
3767 errmsg = e_invarg;
3768 p_re = 0;
3769 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003770 if (p_report < 0)
3771 {
3772 errmsg = e_positive;
3773 p_report = 1;
3774 }
Bram Moolenaar1e015462005-09-25 22:16:38 +00003775 if ((p_sj < -100 || p_sj >= Rows) && full_screen)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003776 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003777 if (Rows != old_Rows) // Rows changed, just adjust p_sj
Bram Moolenaar071d4272004-06-13 20:20:40 +00003778 p_sj = Rows / 2;
3779 else
3780 {
Bram Moolenaard8e44472021-07-21 22:20:33 +02003781 errmsg = e_invalid_scroll_size;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003782 p_sj = 1;
3783 }
3784 }
3785 if (p_so < 0 && full_screen)
3786 {
Bram Moolenaar375e3392019-01-31 18:26:10 +01003787 errmsg = e_positive;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003788 p_so = 0;
3789 }
3790 if (p_siso < 0 && full_screen)
3791 {
3792 errmsg = e_positive;
3793 p_siso = 0;
3794 }
3795#ifdef FEAT_CMDWIN
3796 if (p_cwh < 1)
3797 {
3798 errmsg = e_positive;
3799 p_cwh = 1;
3800 }
3801#endif
3802 if (p_ut < 0)
3803 {
3804 errmsg = e_positive;
3805 p_ut = 2000;
3806 }
3807 if (p_ss < 0)
3808 {
3809 errmsg = e_positive;
3810 p_ss = 0;
3811 }
3812
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003813 // May set global value for local option.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003814 if ((opt_flags & (OPT_LOCAL | OPT_GLOBAL)) == 0)
3815 *(long *)get_varp_scope(&(options[opt_idx]), OPT_GLOBAL) = *pp;
3816
3817 options[opt_idx].flags |= P_WAS_SET;
3818
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01003819#if defined(FEAT_EVAL)
Bram Moolenaarf4140482020-02-15 23:06:45 +01003820 apply_optionset_autocmd(opt_idx, opt_flags, old_value, old_global_value,
3821 value, errmsg);
Bram Moolenaar53744302015-07-17 17:38:22 +02003822#endif
3823
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003824 comp_col(); // in case 'columns' or 'ls' changed
Bram Moolenaar913077c2012-03-28 19:59:04 +02003825 if (curwin->w_curswant != MAXCOL
Bram Moolenaar488eb262015-03-13 11:23:50 +01003826 && (options[opt_idx].flags & (P_CURSWANT | P_RALL)) != 0)
Bram Moolenaar913077c2012-03-28 19:59:04 +02003827 curwin->w_set_curswant = TRUE;
Bram Moolenaar37294bd2021-03-10 13:40:08 +01003828 if ((opt_flags & OPT_NO_REDRAW) == 0)
3829 check_redraw(options[opt_idx].flags);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003830
3831 return errmsg;
3832}
3833
3834/*
3835 * Called after an option changed: check if something needs to be redrawn.
3836 */
Bram Moolenaardac13472019-09-16 21:06:21 +02003837 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01003838check_redraw(long_u flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003839{
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003840 // Careful: P_RCLR and P_RALL are a combination of other P_ flags
Bram Moolenaar70b2a562012-01-10 22:26:17 +01003841 int doclear = (flags & P_RCLR) == P_RCLR;
3842 int all = ((flags & P_RALL) == P_RALL || doclear);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003843
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003844 if ((flags & P_RSTAT) || all) // mark all status lines dirty
Bram Moolenaar071d4272004-06-13 20:20:40 +00003845 status_redraw_all();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003846
3847 if ((flags & P_RBUF) || (flags & P_RWIN) || all)
3848 changed_window_setting();
3849 if (flags & P_RBUF)
3850 redraw_curbuf_later(NOT_VALID);
Bram Moolenaara2477fd2016-12-03 15:13:20 +01003851 if (flags & P_RWINONLY)
3852 redraw_later(NOT_VALID);
Bram Moolenaar70b2a562012-01-10 22:26:17 +01003853 if (doclear)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003854 redraw_all_later(CLEAR);
3855 else if (all)
3856 redraw_all_later(NOT_VALID);
3857}
3858
3859/*
3860 * Find index for option 'arg'.
3861 * Return -1 if not found.
3862 */
Bram Moolenaardac13472019-09-16 21:06:21 +02003863 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01003864findoption(char_u *arg)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003865{
3866 int opt_idx;
3867 char *s, *p;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003868 static short quick_tab[27] = {0, 0}; // quick access table
Bram Moolenaar071d4272004-06-13 20:20:40 +00003869 int is_term_opt;
3870
3871 /*
3872 * For first call: Initialize the quick-access table.
3873 * It contains the index for the first option that starts with a certain
3874 * letter. There are 26 letters, plus the first "t_" option.
3875 */
3876 if (quick_tab[1] == 0)
3877 {
3878 p = options[0].fullname;
3879 for (opt_idx = 1; (s = options[opt_idx].fullname) != NULL; opt_idx++)
3880 {
3881 if (s[0] != p[0])
3882 {
3883 if (s[0] == 't' && s[1] == '_')
3884 quick_tab[26] = opt_idx;
3885 else
3886 quick_tab[CharOrdLow(s[0])] = opt_idx;
3887 }
3888 p = s;
3889 }
3890 }
3891
3892 /*
3893 * Check for name starting with an illegal character.
3894 */
3895#ifdef EBCDIC
3896 if (!islower(arg[0]))
3897#else
3898 if (arg[0] < 'a' || arg[0] > 'z')
3899#endif
3900 return -1;
3901
3902 is_term_opt = (arg[0] == 't' && arg[1] == '_');
3903 if (is_term_opt)
3904 opt_idx = quick_tab[26];
3905 else
3906 opt_idx = quick_tab[CharOrdLow(arg[0])];
3907 for ( ; (s = options[opt_idx].fullname) != NULL; opt_idx++)
3908 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003909 if (STRCMP(arg, s) == 0) // match full name
Bram Moolenaar071d4272004-06-13 20:20:40 +00003910 break;
3911 }
3912 if (s == NULL && !is_term_opt)
3913 {
3914 opt_idx = quick_tab[CharOrdLow(arg[0])];
3915 for ( ; options[opt_idx].fullname != NULL; opt_idx++)
3916 {
3917 s = options[opt_idx].shortname;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003918 if (s != NULL && STRCMP(arg, s) == 0) // match short name
Bram Moolenaar071d4272004-06-13 20:20:40 +00003919 break;
3920 s = NULL;
3921 }
3922 }
3923 if (s == NULL)
3924 opt_idx = -1;
3925 return opt_idx;
3926}
3927
Bram Moolenaar325b7a22004-07-05 15:58:32 +00003928#if defined(FEAT_EVAL) || defined(FEAT_TCL) || defined(FEAT_MZSCHEME)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003929/*
3930 * Get the value for an option.
3931 *
3932 * Returns:
Bram Moolenaardd1f4262020-12-31 17:41:01 +01003933 * Number option: gov_number, *numval gets value.
Bram Moolenaara7251492021-01-02 16:53:13 +01003934 * Toggle option: gov_bool, *numval gets value.
Bram Moolenaardd1f4262020-12-31 17:41:01 +01003935 * String option: gov_string, *stringval gets allocated string.
3936 * Hidden Number option: gov_hidden_number.
3937 * Hidden Toggle option: gov_hidden_bool.
3938 * Hidden String option: gov_hidden_string.
3939 * Unknown option: gov_unknown.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003940 */
Bram Moolenaardd1f4262020-12-31 17:41:01 +01003941 getoption_T
Bram Moolenaar9b578142016-01-30 19:39:49 +01003942get_option_value(
3943 char_u *name,
3944 long *numval,
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003945 char_u **stringval, // NULL when only checking existence
Bram Moolenaar9b578142016-01-30 19:39:49 +01003946 int opt_flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003947{
3948 int opt_idx;
3949 char_u *varp;
3950
3951 opt_idx = findoption(name);
Bram Moolenaardd1f4262020-12-31 17:41:01 +01003952 if (opt_idx < 0) // option not in the table
Bram Moolenaare353c402017-02-04 19:49:16 +01003953 {
3954 int key;
3955
3956 if (STRLEN(name) == 4 && name[0] == 't' && name[1] == '_'
Bram Moolenaardd1f4262020-12-31 17:41:01 +01003957 && (key = find_key_option(name, FALSE)) != 0)
Bram Moolenaare353c402017-02-04 19:49:16 +01003958 {
3959 char_u key_name[2];
3960 char_u *p;
3961
Bram Moolenaardd1f4262020-12-31 17:41:01 +01003962 // check for a terminal option
Bram Moolenaare353c402017-02-04 19:49:16 +01003963 if (key < 0)
3964 {
3965 key_name[0] = KEY2TERMCAP0(key);
3966 key_name[1] = KEY2TERMCAP1(key);
3967 }
3968 else
3969 {
3970 key_name[0] = KS_KEY;
3971 key_name[1] = (key & 0xff);
3972 }
3973 p = find_termcode(key_name);
3974 if (p != NULL)
3975 {
3976 if (stringval != NULL)
3977 *stringval = vim_strsave(p);
Bram Moolenaardd1f4262020-12-31 17:41:01 +01003978 return gov_string;
Bram Moolenaare353c402017-02-04 19:49:16 +01003979 }
3980 }
Bram Moolenaardd1f4262020-12-31 17:41:01 +01003981 return gov_unknown;
Bram Moolenaare353c402017-02-04 19:49:16 +01003982 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003983
3984 varp = get_varp_scope(&(options[opt_idx]), opt_flags);
3985
3986 if (options[opt_idx].flags & P_STRING)
3987 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003988 if (varp == NULL) // hidden option
Bram Moolenaardd1f4262020-12-31 17:41:01 +01003989 return gov_hidden_string;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003990 if (stringval != NULL)
3991 {
3992#ifdef FEAT_CRYPT
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003993 // never return the value of the crypt key
Bram Moolenaarc1a11ed2008-06-24 22:09:24 +00003994 if ((char_u **)varp == &curbuf->b_p_key
3995 && **(char_u **)(varp) != NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003996 *stringval = vim_strsave((char_u *)"*****");
3997 else
3998#endif
3999 *stringval = vim_strsave(*(char_u **)(varp));
4000 }
Bram Moolenaardd1f4262020-12-31 17:41:01 +01004001 return gov_string;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004002 }
4003
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004004 if (varp == NULL) // hidden option
Bram Moolenaardd1f4262020-12-31 17:41:01 +01004005 return (options[opt_idx].flags & P_NUM)
4006 ? gov_hidden_number : gov_hidden_bool;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004007 if (options[opt_idx].flags & P_NUM)
4008 *numval = *(long *)varp;
4009 else
4010 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004011 // Special case: 'modified' is b_changed, but we also want to consider
4012 // it set when 'ff' or 'fenc' changed.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004013 if ((int *)varp == &curbuf->b_changed)
4014 *numval = curbufIsChanged();
4015 else
Bram Moolenaar2acfbed2016-07-01 23:14:02 +02004016 *numval = (long) *(int *)varp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004017 }
Bram Moolenaardd1f4262020-12-31 17:41:01 +01004018 return (options[opt_idx].flags & P_NUM) ? gov_number : gov_bool;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004019}
4020#endif
4021
Bram Moolenaar1028f4d2014-01-14 16:55:00 +01004022#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3) || defined(PROTO)
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02004023/*
4024 * Returns the option attributes and its value. Unlike the above function it
4025 * will return either global value or local value of the option depending on
4026 * what was requested, but it will never return global value if it was
4027 * requested to return local one and vice versa. Neither it will return
4028 * buffer-local value if it was requested to return window-local one.
4029 *
4030 * Pretends that option is absent if it is not present in the requested scope
4031 * (i.e. has no global, window-local or buffer-local value depending on
4032 * opt_type). Uses
4033 *
4034 * Returned flags:
Bram Moolenaar75a8d742014-05-07 15:10:21 +02004035 * 0 hidden or unknown option, also option that does not have requested
4036 * type (see SREQ_* in vim.h)
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02004037 * see SOPT_* in vim.h for other flags
4038 *
4039 * Possible opt_type values: see SREQ_* in vim.h
4040 */
4041 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01004042get_option_value_strict(
4043 char_u *name,
4044 long *numval,
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004045 char_u **stringval, // NULL when only obtaining attributes
Bram Moolenaar9b578142016-01-30 19:39:49 +01004046 int opt_type,
4047 void *from)
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02004048{
4049 int opt_idx;
Bram Moolenaar68001862013-05-11 13:45:05 +02004050 char_u *varp = NULL;
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02004051 struct vimoption *p;
4052 int r = 0;
4053
4054 opt_idx = findoption(name);
4055 if (opt_idx < 0)
4056 return 0;
4057
4058 p = &(options[opt_idx]);
4059
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004060 // Hidden option
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02004061 if (p->var == NULL)
4062 return 0;
4063
4064 if (p->flags & P_BOOL)
4065 r |= SOPT_BOOL;
4066 else if (p->flags & P_NUM)
4067 r |= SOPT_NUM;
4068 else if (p->flags & P_STRING)
4069 r |= SOPT_STRING;
4070
4071 if (p->indir == PV_NONE)
4072 {
4073 if (opt_type == SREQ_GLOBAL)
4074 r |= SOPT_GLOBAL;
4075 else
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004076 return 0; // Did not request global-only option
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02004077 }
4078 else
4079 {
4080 if (p->indir & PV_BOTH)
4081 r |= SOPT_GLOBAL;
4082 else if (opt_type == SREQ_GLOBAL)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004083 return 0; // Requested global option
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02004084
4085 if (p->indir & PV_WIN)
4086 {
4087 if (opt_type == SREQ_BUF)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004088 return 0; // Did not request window-local option
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02004089 else
4090 r |= SOPT_WIN;
4091 }
4092 else if (p->indir & PV_BUF)
4093 {
4094 if (opt_type == SREQ_WIN)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004095 return 0; // Did not request buffer-local option
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02004096 else
4097 r |= SOPT_BUF;
4098 }
4099 }
4100
4101 if (stringval == NULL)
4102 return r;
4103
4104 if (opt_type == SREQ_GLOBAL)
4105 varp = p->var;
4106 else
4107 {
4108 if (opt_type == SREQ_BUF)
4109 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004110 // Special case: 'modified' is b_changed, but we also want to
4111 // consider it set when 'ff' or 'fenc' changed.
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02004112 if (p->indir == PV_MOD)
4113 {
Bram Moolenaardefe6422018-06-24 15:14:07 +02004114 *numval = bufIsChanged((buf_T *)from);
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02004115 varp = NULL;
4116 }
4117#ifdef FEAT_CRYPT
4118 else if (p->indir == PV_KEY)
4119 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004120 // never return the value of the crypt key
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02004121 *stringval = NULL;
4122 varp = NULL;
4123 }
4124#endif
4125 else
4126 {
Bram Moolenaardefe6422018-06-24 15:14:07 +02004127 buf_T *save_curbuf = curbuf;
4128
4129 // only getting a pointer, no need to use aucmd_prepbuf()
4130 curbuf = (buf_T *)from;
4131 curwin->w_buffer = curbuf;
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02004132 varp = get_varp(p);
Bram Moolenaardefe6422018-06-24 15:14:07 +02004133 curbuf = save_curbuf;
4134 curwin->w_buffer = curbuf;
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02004135 }
4136 }
4137 else if (opt_type == SREQ_WIN)
4138 {
Bram Moolenaardefe6422018-06-24 15:14:07 +02004139 win_T *save_curwin = curwin;
4140
4141 curwin = (win_T *)from;
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02004142 curbuf = curwin->w_buffer;
4143 varp = get_varp(p);
4144 curwin = save_curwin;
4145 curbuf = curwin->w_buffer;
4146 }
4147 if (varp == p->var)
4148 return (r | SOPT_UNSET);
4149 }
4150
4151 if (varp != NULL)
4152 {
4153 if (p->flags & P_STRING)
4154 *stringval = vim_strsave(*(char_u **)(varp));
4155 else if (p->flags & P_NUM)
4156 *numval = *(long *) varp;
4157 else
4158 *numval = *(int *)varp;
4159 }
4160
4161 return r;
4162}
Bram Moolenaar1028f4d2014-01-14 16:55:00 +01004163
4164/*
Bram Moolenaarb8ee25a2014-09-23 15:45:08 +02004165 * Iterate over options. First argument is a pointer to a pointer to a
4166 * structure inside options[] array, second is option type like in the above
4167 * function.
Bram Moolenaar1028f4d2014-01-14 16:55:00 +01004168 *
Bram Moolenaarb8ee25a2014-09-23 15:45:08 +02004169 * If first argument points to NULL it is assumed that iteration just started
Bram Moolenaar1028f4d2014-01-14 16:55:00 +01004170 * and caller needs the very first value.
Bram Moolenaarb8ee25a2014-09-23 15:45:08 +02004171 * If first argument points to the end marker function returns NULL and sets
Bram Moolenaar1028f4d2014-01-14 16:55:00 +01004172 * first argument to NULL.
4173 *
4174 * Returns full option name for current option on each call.
4175 */
4176 char_u *
Bram Moolenaar9b578142016-01-30 19:39:49 +01004177option_iter_next(void **option, int opt_type)
Bram Moolenaar1028f4d2014-01-14 16:55:00 +01004178{
4179 struct vimoption *ret = NULL;
4180 do
4181 {
4182 if (*option == NULL)
4183 *option = (void *) options;
4184 else if (((struct vimoption *) (*option))->fullname == NULL)
4185 {
4186 *option = NULL;
4187 return NULL;
4188 }
4189 else
4190 *option = (void *) (((struct vimoption *) (*option)) + 1);
4191
4192 ret = ((struct vimoption *) (*option));
4193
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004194 // Hidden option
Bram Moolenaar1028f4d2014-01-14 16:55:00 +01004195 if (ret->var == NULL)
4196 {
4197 ret = NULL;
4198 continue;
4199 }
4200
4201 switch (opt_type)
4202 {
4203 case SREQ_GLOBAL:
4204 if (!(ret->indir == PV_NONE || ret->indir & PV_BOTH))
4205 ret = NULL;
4206 break;
4207 case SREQ_BUF:
4208 if (!(ret->indir & PV_BUF))
4209 ret = NULL;
4210 break;
4211 case SREQ_WIN:
4212 if (!(ret->indir & PV_WIN))
4213 ret = NULL;
4214 break;
4215 default:
Bram Moolenaar95f09602016-11-10 20:01:45 +01004216 internal_error("option_iter_next()");
Bram Moolenaar1028f4d2014-01-14 16:55:00 +01004217 return NULL;
4218 }
4219 }
4220 while (ret == NULL);
4221
4222 return (char_u *)ret->fullname;
4223}
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02004224#endif
4225
Bram Moolenaar071d4272004-06-13 20:20:40 +00004226/*
Bram Moolenaardac13472019-09-16 21:06:21 +02004227 * Return the flags for the option at 'opt_idx'.
4228 */
4229 long_u
4230get_option_flags(int opt_idx)
4231{
4232 return options[opt_idx].flags;
4233}
4234
4235/*
4236 * Set a flag for the option at 'opt_idx'.
4237 */
4238 void
4239set_option_flag(int opt_idx, long_u flag)
4240{
4241 options[opt_idx].flags |= flag;
4242}
4243
4244/*
4245 * Clear a flag for the option at 'opt_idx'.
4246 */
4247 void
4248clear_option_flag(int opt_idx, long_u flag)
4249{
4250 options[opt_idx].flags &= ~flag;
4251}
4252
4253/*
4254 * Returns TRUE if the option at 'opt_idx' is a global option
4255 */
4256 int
4257is_global_option(int opt_idx)
4258{
4259 return options[opt_idx].indir == PV_NONE;
4260}
4261
4262/*
4263 * Returns TRUE if the option at 'opt_idx' is a global option which also has a
4264 * local value.
4265 */
4266 int
4267is_global_local_option(int opt_idx)
4268{
4269 return options[opt_idx].indir & PV_BOTH;
4270}
4271
4272/*
4273 * Returns TRUE if the option at 'opt_idx' is a window-local option
4274 */
4275 int
4276is_window_local_option(int opt_idx)
4277{
4278 return options[opt_idx].var == VAR_WIN;
4279}
4280
4281/*
4282 * Returns TRUE if the option at 'opt_idx' is a hidden option
4283 */
4284 int
4285is_hidden_option(int opt_idx)
4286{
4287 return options[opt_idx].var == NULL;
4288}
4289
4290#if defined(FEAT_CRYPT) || defined(PROTO)
4291/*
4292 * Returns TRUE if the option at 'opt_idx' is a crypt key option
4293 */
4294 int
4295is_crypt_key_option(int opt_idx)
4296{
4297 return options[opt_idx].indir == PV_KEY;
4298}
4299#endif
4300
4301/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00004302 * Set the value of option "name".
4303 * Use "string" for string options, use "number" for other options.
Bram Moolenaarc96ebe72013-05-21 22:38:18 +02004304 *
4305 * Returns NULL on success or error message on error.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004306 */
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004307 char *
Bram Moolenaar9b578142016-01-30 19:39:49 +01004308set_option_value(
4309 char_u *name,
4310 long number,
4311 char_u *string,
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004312 int opt_flags) // OPT_LOCAL or 0 (both)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004313{
4314 int opt_idx;
4315 char_u *varp;
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00004316 long_u flags;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004317
4318 opt_idx = findoption(name);
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00004319 if (opt_idx < 0)
Bram Moolenaare353c402017-02-04 19:49:16 +01004320 {
4321 int key;
4322
4323 if (STRLEN(name) == 4 && name[0] == 't' && name[1] == '_'
Bram Moolenaar9cf4b502018-07-23 04:12:03 +02004324 && (key = find_key_option(name, FALSE)) != 0)
Bram Moolenaare353c402017-02-04 19:49:16 +01004325 {
4326 char_u key_name[2];
4327
4328 if (key < 0)
4329 {
4330 key_name[0] = KEY2TERMCAP0(key);
4331 key_name[1] = KEY2TERMCAP1(key);
4332 }
4333 else
4334 {
4335 key_name[0] = KS_KEY;
4336 key_name[1] = (key & 0xff);
4337 }
4338 add_termcode(key_name, string, FALSE);
4339 if (full_screen)
4340 ttest(FALSE);
4341 redraw_all_later(CLEAR);
4342 return NULL;
4343 }
4344
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004345 semsg(_("E355: Unknown option: %s"), name);
Bram Moolenaare353c402017-02-04 19:49:16 +01004346 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004347 else
4348 {
4349 flags = options[opt_idx].flags;
4350#ifdef HAVE_SANDBOX
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004351 // Disallow changing some options in the sandbox
Bram Moolenaar071d4272004-06-13 20:20:40 +00004352 if (sandbox > 0 && (flags & P_SECURE))
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004353 {
Bram Moolenaard8e44472021-07-21 22:20:33 +02004354 emsg(_(e_not_allowed_in_sandbox));
Bram Moolenaarc96ebe72013-05-21 22:38:18 +02004355 return NULL;
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004356 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004357#endif
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004358 if (flags & P_STRING)
Bram Moolenaarc96ebe72013-05-21 22:38:18 +02004359 return set_string_option(opt_idx, string, opt_flags);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004360 else
4361 {
Bram Moolenaarb3163762008-07-08 15:15:08 +00004362 varp = get_varp_scope(&(options[opt_idx]), opt_flags);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004363 if (varp != NULL) // hidden option is not changed
Bram Moolenaar071d4272004-06-13 20:20:40 +00004364 {
Bram Moolenaar96bb6212007-06-19 18:52:53 +00004365 if (number == 0 && string != NULL)
4366 {
Bram Moolenaarfe86f2d2008-11-28 20:29:07 +00004367 int idx;
Bram Moolenaar96bb6212007-06-19 18:52:53 +00004368
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004369 // Either we are given a string or we are setting option
4370 // to zero.
Bram Moolenaarfe86f2d2008-11-28 20:29:07 +00004371 for (idx = 0; string[idx] == '0'; ++idx)
Bram Moolenaar96bb6212007-06-19 18:52:53 +00004372 ;
Bram Moolenaarfe86f2d2008-11-28 20:29:07 +00004373 if (string[idx] != NUL || idx == 0)
Bram Moolenaar96bb6212007-06-19 18:52:53 +00004374 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004375 // There's another character after zeros or the string
4376 // is empty. In both cases, we are trying to set a
4377 // num option using a string.
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004378 semsg(_("E521: Number required: &%s = '%s'"),
Bram Moolenaar96bb6212007-06-19 18:52:53 +00004379 name, string);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004380 return NULL; // do nothing as we hit an error
Bram Moolenaar96bb6212007-06-19 18:52:53 +00004381
4382 }
4383 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004384 if (flags & P_NUM)
Bram Moolenaarc96ebe72013-05-21 22:38:18 +02004385 return set_num_option(opt_idx, varp, number,
Bram Moolenaar555b2802005-05-19 21:08:39 +00004386 NULL, 0, opt_flags);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004387 else
Bram Moolenaarc96ebe72013-05-21 22:38:18 +02004388 return set_bool_option(opt_idx, varp, (int)number,
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00004389 opt_flags);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004390 }
4391 }
4392 }
Bram Moolenaarc96ebe72013-05-21 22:38:18 +02004393 return NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004394}
4395
4396/*
4397 * Get the terminal code for a terminal option.
4398 * Returns NULL when not found.
4399 */
4400 char_u *
Bram Moolenaar9b578142016-01-30 19:39:49 +01004401get_term_code(char_u *tname)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004402{
4403 int opt_idx;
4404 char_u *varp;
4405
4406 if (tname[0] != 't' || tname[1] != '_' ||
4407 tname[2] == NUL || tname[3] == NUL)
4408 return NULL;
4409 if ((opt_idx = findoption(tname)) >= 0)
4410 {
4411 varp = get_varp(&(options[opt_idx]));
4412 if (varp != NULL)
4413 varp = *(char_u **)(varp);
4414 return varp;
4415 }
4416 return find_termcode(tname + 2);
4417}
4418
4419 char_u *
Bram Moolenaar9b578142016-01-30 19:39:49 +01004420get_highlight_default(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004421{
4422 int i;
4423
4424 i = findoption((char_u *)"hl");
4425 if (i >= 0)
4426 return options[i].def_val[VI_DEFAULT];
4427 return (char_u *)NULL;
4428}
4429
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00004430 char_u *
Bram Moolenaar9b578142016-01-30 19:39:49 +01004431get_encoding_default(void)
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00004432{
4433 int i;
4434
4435 i = findoption((char_u *)"enc");
4436 if (i >= 0)
4437 return options[i].def_val[VI_DEFAULT];
4438 return (char_u *)NULL;
4439}
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00004440
Bram Moolenaar071d4272004-06-13 20:20:40 +00004441/*
4442 * Translate a string like "t_xx", "<t_xx>" or "<S-Tab>" to a key number.
Bram Moolenaar9cf4b502018-07-23 04:12:03 +02004443 * When "has_lt" is true there is a '<' before "*arg_arg".
4444 * Returns 0 when the key is not recognized.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004445 */
4446 static int
Bram Moolenaar9cf4b502018-07-23 04:12:03 +02004447find_key_option(char_u *arg_arg, int has_lt)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004448{
Bram Moolenaar9cf4b502018-07-23 04:12:03 +02004449 int key = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004450 int modifiers;
Bram Moolenaar9cf4b502018-07-23 04:12:03 +02004451 char_u *arg = arg_arg;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004452
4453 /*
4454 * Don't use get_special_key_code() for t_xx, we don't want it to call
4455 * add_termcap_entry().
4456 */
4457 if (arg[0] == 't' && arg[1] == '_' && arg[2] && arg[3])
4458 key = TERMCAP2KEY(arg[2], arg[3]);
Bram Moolenaar9cf4b502018-07-23 04:12:03 +02004459 else if (has_lt)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004460 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004461 --arg; // put arg at the '<'
Bram Moolenaar071d4272004-06-13 20:20:40 +00004462 modifiers = 0;
Bram Moolenaarebe9d342020-05-30 21:52:54 +02004463 key = find_special_key(&arg, &modifiers,
4464 FSK_KEYCODE | FSK_KEEP_X_KEY | FSK_SIMPLIFY, NULL);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004465 if (modifiers) // can't handle modifiers here
Bram Moolenaar071d4272004-06-13 20:20:40 +00004466 key = 0;
4467 }
4468 return key;
4469}
4470
4471/*
4472 * if 'all' == 0: show changed options
4473 * if 'all' == 1: show all normal options
4474 * if 'all' == 2: show all terminal options
4475 */
4476 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +01004477showoptions(
4478 int all,
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004479 int opt_flags) // OPT_LOCAL and/or OPT_GLOBAL
Bram Moolenaar071d4272004-06-13 20:20:40 +00004480{
4481 struct vimoption *p;
4482 int col;
4483 int isterm;
4484 char_u *varp;
4485 struct vimoption **items;
4486 int item_count;
4487 int run;
4488 int row, rows;
4489 int cols;
4490 int i;
4491 int len;
4492
4493#define INC 20
4494#define GAP 3
4495
Bram Moolenaar6b915c02020-01-18 15:53:19 +01004496 items = ALLOC_MULT(struct vimoption *, OPTION_COUNT);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004497 if (items == NULL)
4498 return;
4499
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004500 // Highlight title
Bram Moolenaar071d4272004-06-13 20:20:40 +00004501 if (all == 2)
Bram Moolenaar32526b32019-01-19 17:43:09 +01004502 msg_puts_title(_("\n--- Terminal codes ---"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00004503 else if (opt_flags & OPT_GLOBAL)
Bram Moolenaar32526b32019-01-19 17:43:09 +01004504 msg_puts_title(_("\n--- Global option values ---"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00004505 else if (opt_flags & OPT_LOCAL)
Bram Moolenaar32526b32019-01-19 17:43:09 +01004506 msg_puts_title(_("\n--- Local option values ---"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00004507 else
Bram Moolenaar32526b32019-01-19 17:43:09 +01004508 msg_puts_title(_("\n--- Options ---"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00004509
4510 /*
Bram Moolenaar6b915c02020-01-18 15:53:19 +01004511 * Do the loop two times:
Bram Moolenaar071d4272004-06-13 20:20:40 +00004512 * 1. display the short items
4513 * 2. display the long items (only strings and numbers)
Bram Moolenaar6b915c02020-01-18 15:53:19 +01004514 * When "opt_flags" has OPT_ONECOLUMN do everything in run 2.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004515 */
4516 for (run = 1; run <= 2 && !got_int; ++run)
4517 {
4518 /*
4519 * collect the items in items[]
4520 */
4521 item_count = 0;
4522 for (p = &options[0]; p->fullname != NULL; p++)
4523 {
Bram Moolenaarf86db782018-10-25 13:31:37 +02004524 // apply :filter /pat/
Bram Moolenaar6b915c02020-01-18 15:53:19 +01004525 if (message_filtered((char_u *)p->fullname))
Bram Moolenaarf86db782018-10-25 13:31:37 +02004526 continue;
4527
Bram Moolenaar071d4272004-06-13 20:20:40 +00004528 varp = NULL;
4529 isterm = istermoption(p);
Bram Moolenaar6b915c02020-01-18 15:53:19 +01004530 if ((opt_flags & (OPT_LOCAL | OPT_GLOBAL)) != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004531 {
4532 if (p->indir != PV_NONE && !isterm)
4533 varp = get_varp_scope(p, opt_flags);
4534 }
4535 else
4536 varp = get_varp(p);
4537 if (varp != NULL
4538 && ((all == 2 && isterm)
4539 || (all == 1 && !isterm)
Bram Moolenaarcacc6a52019-05-30 15:22:43 +02004540 || (all == 0 && !optval_default(p, varp, p_cp))))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004541 {
Bram Moolenaar6b915c02020-01-18 15:53:19 +01004542 if (opt_flags & OPT_ONECOLUMN)
4543 len = Columns;
4544 else if (p->flags & P_BOOL)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004545 len = 1; // a toggle option fits always
Bram Moolenaar071d4272004-06-13 20:20:40 +00004546 else
4547 {
4548 option_value2string(p, opt_flags);
4549 len = (int)STRLEN(p->fullname) + vim_strsize(NameBuff) + 1;
4550 }
4551 if ((len <= INC - GAP && run == 1) ||
4552 (len > INC - GAP && run == 2))
4553 items[item_count++] = p;
4554 }
4555 }
4556
4557 /*
4558 * display the items
4559 */
4560 if (run == 1)
4561 {
4562 cols = (Columns + GAP - 3) / INC;
4563 if (cols == 0)
4564 cols = 1;
4565 rows = (item_count + cols - 1) / cols;
4566 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004567 else // run == 2
Bram Moolenaar071d4272004-06-13 20:20:40 +00004568 rows = item_count;
4569 for (row = 0; row < rows && !got_int; ++row)
4570 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004571 msg_putchar('\n'); // go to next line
4572 if (got_int) // 'q' typed in more
Bram Moolenaar071d4272004-06-13 20:20:40 +00004573 break;
4574 col = 0;
4575 for (i = row; i < item_count; i += rows)
4576 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004577 msg_col = col; // make columns
Bram Moolenaar071d4272004-06-13 20:20:40 +00004578 showoneopt(items[i], opt_flags);
4579 col += INC;
4580 }
4581 out_flush();
4582 ui_breakcheck();
4583 }
4584 }
4585 vim_free(items);
4586}
4587
4588/*
4589 * Return TRUE if option "p" has its default value.
4590 */
4591 static int
Bram Moolenaarcacc6a52019-05-30 15:22:43 +02004592optval_default(struct vimoption *p, char_u *varp, int compatible)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004593{
4594 int dvi;
4595
4596 if (varp == NULL)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004597 return TRUE; // hidden option is always at default
Bram Moolenaarcacc6a52019-05-30 15:22:43 +02004598 dvi = ((p->flags & P_VI_DEF) || compatible) ? VI_DEFAULT : VIM_DEFAULT;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004599 if (p->flags & P_NUM)
Bram Moolenaareb3593b2006-04-22 22:33:57 +00004600 return (*(long *)varp == (long)(long_i)p->def_val[dvi]);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004601 if (p->flags & P_BOOL)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004602 // the cast to long is required for Manx C, long_i is
4603 // needed for MSVC
Bram Moolenaareb3593b2006-04-22 22:33:57 +00004604 return (*(int *)varp == (int)(long)(long_i)p->def_val[dvi]);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004605 // P_STRING
Bram Moolenaar071d4272004-06-13 20:20:40 +00004606 return (STRCMP(*(char_u **)varp, p->def_val[dvi]) == 0);
4607}
4608
4609/*
4610 * showoneopt: show the value of one option
4611 * must not be called with a hidden option!
4612 */
4613 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +01004614showoneopt(
4615 struct vimoption *p,
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004616 int opt_flags) // OPT_LOCAL or OPT_GLOBAL
Bram Moolenaar071d4272004-06-13 20:20:40 +00004617{
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004618 char_u *varp;
4619 int save_silent = silent_mode;
4620
4621 silent_mode = FALSE;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004622 info_message = TRUE; // use mch_msg(), not mch_errmsg()
Bram Moolenaar071d4272004-06-13 20:20:40 +00004623
4624 varp = get_varp_scope(p, opt_flags);
4625
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004626 // for 'modified' we also need to check if 'ff' or 'fenc' changed.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004627 if ((p->flags & P_BOOL) && ((int *)varp == &curbuf->b_changed
4628 ? !curbufIsChanged() : !*(int *)varp))
Bram Moolenaar32526b32019-01-19 17:43:09 +01004629 msg_puts("no");
Bram Moolenaar071d4272004-06-13 20:20:40 +00004630 else if ((p->flags & P_BOOL) && *(int *)varp < 0)
Bram Moolenaar32526b32019-01-19 17:43:09 +01004631 msg_puts("--");
Bram Moolenaar071d4272004-06-13 20:20:40 +00004632 else
Bram Moolenaar32526b32019-01-19 17:43:09 +01004633 msg_puts(" ");
4634 msg_puts(p->fullname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004635 if (!(p->flags & P_BOOL))
4636 {
4637 msg_putchar('=');
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004638 // put value string in NameBuff
Bram Moolenaar071d4272004-06-13 20:20:40 +00004639 option_value2string(p, opt_flags);
4640 msg_outtrans(NameBuff);
4641 }
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004642
4643 silent_mode = save_silent;
4644 info_message = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004645}
4646
4647/*
4648 * Write modified options as ":set" commands to a file.
4649 *
4650 * There are three values for "opt_flags":
4651 * OPT_GLOBAL: Write global option values and fresh values of
4652 * buffer-local options (used for start of a session
4653 * file).
4654 * OPT_GLOBAL + OPT_LOCAL: Idem, add fresh values of window-local options for
4655 * curwin (used for a vimrc file).
4656 * OPT_LOCAL: Write buffer-local option values for curbuf, fresh
4657 * and local values for window-local options of
4658 * curwin. Local values are also written when at the
4659 * default value, because a modeline or autocommand
4660 * may have set them when doing ":edit file" and the
4661 * user has set them back at the default or fresh
4662 * value.
4663 * When "local_only" is TRUE, don't write fresh
4664 * values, only local values (for ":mkview").
4665 * (fresh value = value used for a new buffer or window for a local option).
4666 *
4667 * Return FAIL on error, OK otherwise.
4668 */
4669 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01004670makeset(FILE *fd, int opt_flags, int local_only)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004671{
4672 struct vimoption *p;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004673 char_u *varp; // currently used value
4674 char_u *varp_fresh; // local value
4675 char_u *varp_local = NULL; // fresh value
Bram Moolenaar071d4272004-06-13 20:20:40 +00004676 char *cmd;
4677 int round;
Bram Moolenaar7fd16022007-09-06 14:35:35 +00004678 int pri;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004679
4680 /*
4681 * The options that don't have a default (terminal name, columns, lines)
4682 * are never written. Terminal options are also not written.
Bram Moolenaar7fd16022007-09-06 14:35:35 +00004683 * Do the loop over "options[]" twice: once for options with the
4684 * P_PRI_MKRC flag and once without.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004685 */
Bram Moolenaar7fd16022007-09-06 14:35:35 +00004686 for (pri = 1; pri >= 0; --pri)
4687 {
4688 for (p = &options[0]; !istermoption(p); p++)
4689 if (!(p->flags & P_NO_MKRC)
4690 && !istermoption(p)
4691 && ((pri == 1) == ((p->flags & P_PRI_MKRC) != 0)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004692 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004693 // skip global option when only doing locals
Bram Moolenaar071d4272004-06-13 20:20:40 +00004694 if (p->indir == PV_NONE && !(opt_flags & OPT_GLOBAL))
4695 continue;
4696
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004697 // Do not store options like 'bufhidden' and 'syntax' in a vimrc
4698 // file, they are always buffer-specific.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004699 if ((opt_flags & OPT_GLOBAL) && (p->flags & P_NOGLOB))
4700 continue;
4701
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004702 // Global values are only written when not at the default value.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004703 varp = get_varp_scope(p, opt_flags);
Bram Moolenaarcacc6a52019-05-30 15:22:43 +02004704 if ((opt_flags & OPT_GLOBAL) && optval_default(p, varp, p_cp))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004705 continue;
4706
Bram Moolenaard23b7142021-04-17 21:04:34 +02004707 if ((opt_flags & OPT_SKIPRTP) && (p->var == (char_u *)&p_rtp
4708 || p->var == (char_u *)&p_pp))
Bram Moolenaar635bd602021-04-16 19:58:22 +02004709 continue;
4710
Bram Moolenaar071d4272004-06-13 20:20:40 +00004711 round = 2;
4712 if (p->indir != PV_NONE)
4713 {
4714 if (p->var == VAR_WIN)
4715 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004716 // skip window-local option when only doing globals
Bram Moolenaar071d4272004-06-13 20:20:40 +00004717 if (!(opt_flags & OPT_LOCAL))
4718 continue;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004719 // When fresh value of window-local option is not at the
4720 // default, need to write it too.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004721 if (!(opt_flags & OPT_GLOBAL) && !local_only)
4722 {
4723 varp_fresh = get_varp_scope(p, OPT_GLOBAL);
Bram Moolenaarcacc6a52019-05-30 15:22:43 +02004724 if (!optval_default(p, varp_fresh, p_cp))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004725 {
4726 round = 1;
4727 varp_local = varp;
4728 varp = varp_fresh;
4729 }
4730 }
4731 }
4732 }
4733
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004734 // Round 1: fresh value for window-local options.
4735 // Round 2: other values
Bram Moolenaar071d4272004-06-13 20:20:40 +00004736 for ( ; round <= 2; varp = varp_local, ++round)
4737 {
4738 if (round == 1 || (opt_flags & OPT_GLOBAL))
4739 cmd = "set";
4740 else
4741 cmd = "setlocal";
4742
4743 if (p->flags & P_BOOL)
4744 {
4745 if (put_setbool(fd, cmd, p->fullname, *(int *)varp) == FAIL)
4746 return FAIL;
4747 }
4748 else if (p->flags & P_NUM)
4749 {
4750 if (put_setnum(fd, cmd, p->fullname, (long *)varp) == FAIL)
4751 return FAIL;
4752 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004753 else // P_STRING
Bram Moolenaar071d4272004-06-13 20:20:40 +00004754 {
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00004755 int do_endif = FALSE;
4756
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004757 // Don't set 'syntax' and 'filetype' again if the value is
4758 // already right, avoids reloading the syntax file.
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00004759 if (
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01004760#if defined(FEAT_SYN_HL)
4761 p->indir == PV_SYN ||
4762#endif
4763 p->indir == PV_FT)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004764 {
4765 if (fprintf(fd, "if &%s != '%s'", p->fullname,
4766 *(char_u **)(varp)) < 0
4767 || put_eol(fd) < 0)
4768 return FAIL;
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00004769 do_endif = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004770 }
4771 if (put_setstring(fd, cmd, p->fullname, (char_u **)varp,
Bram Moolenaared18f2c2019-01-24 20:30:52 +01004772 p->flags) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004773 return FAIL;
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00004774 if (do_endif)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004775 {
4776 if (put_line(fd, "endif") == FAIL)
4777 return FAIL;
4778 }
4779 }
4780 }
4781 }
Bram Moolenaar7fd16022007-09-06 14:35:35 +00004782 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004783 return OK;
4784}
4785
4786#if defined(FEAT_FOLDING) || defined(PROTO)
4787/*
4788 * Generate set commands for the local fold options only. Used when
4789 * 'sessionoptions' or 'viewoptions' contains "folds" but not "options".
4790 */
4791 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01004792makefoldset(FILE *fd)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004793{
Bram Moolenaared18f2c2019-01-24 20:30:52 +01004794 if (put_setstring(fd, "setlocal", "fdm", &curwin->w_p_fdm, 0) == FAIL
Bram Moolenaar071d4272004-06-13 20:20:40 +00004795# ifdef FEAT_EVAL
Bram Moolenaared18f2c2019-01-24 20:30:52 +01004796 || put_setstring(fd, "setlocal", "fde", &curwin->w_p_fde, 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004797 == FAIL
4798# endif
Bram Moolenaared18f2c2019-01-24 20:30:52 +01004799 || put_setstring(fd, "setlocal", "fmr", &curwin->w_p_fmr, 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004800 == FAIL
Bram Moolenaared18f2c2019-01-24 20:30:52 +01004801 || put_setstring(fd, "setlocal", "fdi", &curwin->w_p_fdi, 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004802 == FAIL
4803 || put_setnum(fd, "setlocal", "fdl", &curwin->w_p_fdl) == FAIL
4804 || put_setnum(fd, "setlocal", "fml", &curwin->w_p_fml) == FAIL
4805 || put_setnum(fd, "setlocal", "fdn", &curwin->w_p_fdn) == FAIL
4806 || put_setbool(fd, "setlocal", "fen", curwin->w_p_fen) == FAIL
4807 )
4808 return FAIL;
4809
4810 return OK;
4811}
4812#endif
4813
4814 static int
Bram Moolenaar9b578142016-01-30 19:39:49 +01004815put_setstring(
4816 FILE *fd,
4817 char *cmd,
4818 char *name,
4819 char_u **valuep,
Bram Moolenaared18f2c2019-01-24 20:30:52 +01004820 long_u flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004821{
4822 char_u *s;
Bram Moolenaared18f2c2019-01-24 20:30:52 +01004823 char_u *buf = NULL;
4824 char_u *part = NULL;
4825 char_u *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004826
4827 if (fprintf(fd, "%s %s=", cmd, name) < 0)
4828 return FAIL;
4829 if (*valuep != NULL)
4830 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004831 // Output 'pastetoggle' as key names. For other
4832 // options some characters have to be escaped with
4833 // CTRL-V or backslash
Bram Moolenaar071d4272004-06-13 20:20:40 +00004834 if (valuep == &p_pt)
4835 {
4836 s = *valuep;
4837 while (*s != NUL)
Bram Moolenaar7d96acd2008-06-09 15:07:54 +00004838 if (put_escstr(fd, str2special(&s, FALSE), 2) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004839 return FAIL;
4840 }
Bram Moolenaared18f2c2019-01-24 20:30:52 +01004841 // expand the option value, replace $HOME by ~
4842 else if ((flags & P_EXPAND) != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004843 {
Bram Moolenaared18f2c2019-01-24 20:30:52 +01004844 int size = (int)STRLEN(*valuep) + 1;
4845
4846 // replace home directory in the whole option value into "buf"
4847 buf = alloc(size);
Bram Moolenaarf8441472011-04-28 17:24:58 +02004848 if (buf == NULL)
Bram Moolenaared18f2c2019-01-24 20:30:52 +01004849 goto fail;
4850 home_replace(NULL, *valuep, buf, size, FALSE);
4851
4852 // If the option value is longer than MAXPATHL, we need to append
Bram Moolenaar32aa1022019-11-02 22:54:41 +01004853 // each comma separated part of the option separately, so that it
Bram Moolenaared18f2c2019-01-24 20:30:52 +01004854 // can be expanded when read back.
4855 if (size >= MAXPATHL && (flags & P_COMMA) != 0
4856 && vim_strchr(*valuep, ',') != NULL)
4857 {
4858 part = alloc(size);
4859 if (part == NULL)
4860 goto fail;
4861
4862 // write line break to clear the option, e.g. ':set rtp='
4863 if (put_eol(fd) == FAIL)
4864 goto fail;
4865
4866 p = buf;
4867 while (*p != NUL)
4868 {
4869 // for each comma separated option part, append value to
4870 // the option, :set rtp+=value
4871 if (fprintf(fd, "%s %s+=", cmd, name) < 0)
4872 goto fail;
4873 (void)copy_option_part(&p, part, size, ",");
4874 if (put_escstr(fd, part, 2) == FAIL || put_eol(fd) == FAIL)
4875 goto fail;
4876 }
4877 vim_free(buf);
4878 vim_free(part);
4879 return OK;
4880 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004881 if (put_escstr(fd, buf, 2) == FAIL)
Bram Moolenaarf8441472011-04-28 17:24:58 +02004882 {
4883 vim_free(buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004884 return FAIL;
Bram Moolenaarf8441472011-04-28 17:24:58 +02004885 }
4886 vim_free(buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004887 }
4888 else if (put_escstr(fd, *valuep, 2) == FAIL)
4889 return FAIL;
4890 }
4891 if (put_eol(fd) < 0)
4892 return FAIL;
4893 return OK;
Bram Moolenaared18f2c2019-01-24 20:30:52 +01004894fail:
4895 vim_free(buf);
4896 vim_free(part);
4897 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004898}
4899
4900 static int
Bram Moolenaar9b578142016-01-30 19:39:49 +01004901put_setnum(
4902 FILE *fd,
4903 char *cmd,
4904 char *name,
4905 long *valuep)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004906{
4907 long wc;
4908
4909 if (fprintf(fd, "%s %s=", cmd, name) < 0)
4910 return FAIL;
4911 if (wc_use_keyname((char_u *)valuep, &wc))
4912 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004913 // print 'wildchar' and 'wildcharm' as a key name
Bram Moolenaar071d4272004-06-13 20:20:40 +00004914 if (fputs((char *)get_special_key_name((int)wc, 0), fd) < 0)
4915 return FAIL;
4916 }
4917 else if (fprintf(fd, "%ld", *valuep) < 0)
4918 return FAIL;
4919 if (put_eol(fd) < 0)
4920 return FAIL;
4921 return OK;
4922}
4923
4924 static int
Bram Moolenaar9b578142016-01-30 19:39:49 +01004925put_setbool(
4926 FILE *fd,
4927 char *cmd,
4928 char *name,
4929 int value)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004930{
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004931 if (value < 0) // global/local option using global value
Bram Moolenaar893de922007-10-02 18:40:57 +00004932 return OK;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004933 if (fprintf(fd, "%s %s%s", cmd, value ? "" : "no", name) < 0
4934 || put_eol(fd) < 0)
4935 return FAIL;
4936 return OK;
4937}
4938
4939/*
4940 * Clear all the terminal options.
4941 * If the option has been allocated, free the memory.
4942 * Terminal options are never hidden or indirect.
4943 */
4944 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01004945clear_termoptions(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004946{
Bram Moolenaar071d4272004-06-13 20:20:40 +00004947 /*
4948 * Reset a few things before clearing the old options. This may cause
4949 * outputting a few things that the terminal doesn't understand, but the
4950 * screen will be cleared later, so this is OK.
4951 */
Bram Moolenaara1cb1d12019-10-17 23:00:07 +02004952 mch_setmouse(FALSE); // switch mouse off
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004953 mch_restore_title(SAVE_RESTORE_BOTH); // restore window titles
Bram Moolenaar071d4272004-06-13 20:20:40 +00004954#if defined(FEAT_XCLIPBOARD) && defined(FEAT_GUI)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004955 // When starting the GUI close the display opened for the clipboard.
4956 // After restoring the title, because that will need the display.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004957 if (gui.starting)
4958 clear_xterm_clip();
4959#endif
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01004960 stoptermcap(); // stop termcap mode
Bram Moolenaar071d4272004-06-13 20:20:40 +00004961
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00004962 free_termoptions();
4963}
4964
4965 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01004966free_termoptions(void)
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00004967{
4968 struct vimoption *p;
4969
Bram Moolenaar35bc7d62018-10-02 14:45:10 +02004970 for (p = options; p->fullname != NULL; p++)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004971 if (istermoption(p))
4972 {
4973 if (p->flags & P_ALLOCED)
4974 free_string_option(*(char_u **)(p->var));
4975 if (p->flags & P_DEF_ALLOCED)
4976 free_string_option(p->def_val[VI_DEFAULT]);
4977 *(char_u **)(p->var) = empty_option;
4978 p->def_val[VI_DEFAULT] = empty_option;
4979 p->flags &= ~(P_ALLOCED|P_DEF_ALLOCED);
Bram Moolenaar35bc7d62018-10-02 14:45:10 +02004980#ifdef FEAT_EVAL
4981 // remember where the option was cleared
4982 set_option_sctx_idx((int)(p - options), OPT_GLOBAL, current_sctx);
4983#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004984 }
4985 clear_termcodes();
4986}
4987
4988/*
Bram Moolenaar363cb672009-07-22 12:28:17 +00004989 * Free the string for one term option, if it was allocated.
4990 * Set the string to empty_option and clear allocated flag.
4991 * "var" points to the option value.
4992 */
4993 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01004994free_one_termoption(char_u *var)
Bram Moolenaar363cb672009-07-22 12:28:17 +00004995{
4996 struct vimoption *p;
4997
4998 for (p = &options[0]; p->fullname != NULL; p++)
4999 if (p->var == var)
5000 {
5001 if (p->flags & P_ALLOCED)
5002 free_string_option(*(char_u **)(p->var));
5003 *(char_u **)(p->var) = empty_option;
5004 p->flags &= ~P_ALLOCED;
5005 break;
5006 }
5007}
5008
5009/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00005010 * Set the terminal option defaults to the current value.
5011 * Used after setting the terminal name.
5012 */
5013 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01005014set_term_defaults(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005015{
5016 struct vimoption *p;
5017
5018 for (p = &options[0]; p->fullname != NULL; p++)
5019 {
5020 if (istermoption(p) && p->def_val[VI_DEFAULT] != *(char_u **)(p->var))
5021 {
5022 if (p->flags & P_DEF_ALLOCED)
5023 {
5024 free_string_option(p->def_val[VI_DEFAULT]);
5025 p->flags &= ~P_DEF_ALLOCED;
5026 }
5027 p->def_val[VI_DEFAULT] = *(char_u **)(p->var);
5028 if (p->flags & P_ALLOCED)
5029 {
5030 p->flags |= P_DEF_ALLOCED;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01005031 p->flags &= ~P_ALLOCED; // don't free the value now
Bram Moolenaar071d4272004-06-13 20:20:40 +00005032 }
5033 }
5034 }
5035}
5036
5037/*
5038 * return TRUE if 'p' starts with 't_'
5039 */
5040 static int
Bram Moolenaar9b578142016-01-30 19:39:49 +01005041istermoption(struct vimoption *p)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005042{
5043 return (p->fullname[0] == 't' && p->fullname[1] == '_');
5044}
5045
Bram Moolenaardac13472019-09-16 21:06:21 +02005046/*
5047 * Returns TRUE if the option at 'opt_idx' starts with 't_'
5048 */
5049 int
5050istermoption_idx(int opt_idx)
5051{
5052 return istermoption(&options[opt_idx]);
5053}
5054
Bram Moolenaar113e1072019-01-20 15:30:40 +01005055#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005056/*
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005057 * Unset local option value, similar to ":set opt<".
5058 */
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005059 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01005060unset_global_local_option(char_u *name, void *from)
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005061{
5062 struct vimoption *p;
5063 int opt_idx;
Bram Moolenaar51ac8a22013-05-06 06:45:47 +02005064 buf_T *buf = (buf_T *)from;
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005065
5066 opt_idx = findoption(name);
Bram Moolenaarbd8539a2015-08-11 18:53:03 +02005067 if (opt_idx < 0)
5068 return;
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005069 p = &(options[opt_idx]);
5070
5071 switch ((int)p->indir)
5072 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01005073 // global option with local value: use local value if it's been set
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005074 case PV_EP:
Bram Moolenaar51ac8a22013-05-06 06:45:47 +02005075 clear_string_option(&buf->b_p_ep);
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005076 break;
5077 case PV_KP:
Bram Moolenaar51ac8a22013-05-06 06:45:47 +02005078 clear_string_option(&buf->b_p_kp);
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005079 break;
5080 case PV_PATH:
Bram Moolenaar51ac8a22013-05-06 06:45:47 +02005081 clear_string_option(&buf->b_p_path);
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005082 break;
5083 case PV_AR:
5084 buf->b_p_ar = -1;
5085 break;
Bram Moolenaarb8ee25a2014-09-23 15:45:08 +02005086 case PV_BKC:
5087 clear_string_option(&buf->b_p_bkc);
5088 buf->b_bkc_flags = 0;
5089 break;
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005090 case PV_TAGS:
Bram Moolenaar51ac8a22013-05-06 06:45:47 +02005091 clear_string_option(&buf->b_p_tags);
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005092 break;
Bram Moolenaar0f6562e2015-11-24 18:48:14 +01005093 case PV_TC:
5094 clear_string_option(&buf->b_p_tc);
5095 buf->b_tc_flags = 0;
5096 break;
Bram Moolenaar375e3392019-01-31 18:26:10 +01005097 case PV_SISO:
5098 curwin->w_p_siso = -1;
5099 break;
5100 case PV_SO:
5101 curwin->w_p_so = -1;
5102 break;
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005103#ifdef FEAT_FIND_ID
5104 case PV_DEF:
Bram Moolenaar51ac8a22013-05-06 06:45:47 +02005105 clear_string_option(&buf->b_p_def);
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005106 break;
5107 case PV_INC:
Bram Moolenaar51ac8a22013-05-06 06:45:47 +02005108 clear_string_option(&buf->b_p_inc);
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005109 break;
5110#endif
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005111 case PV_DICT:
Bram Moolenaar51ac8a22013-05-06 06:45:47 +02005112 clear_string_option(&buf->b_p_dict);
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005113 break;
5114 case PV_TSR:
Bram Moolenaar51ac8a22013-05-06 06:45:47 +02005115 clear_string_option(&buf->b_p_tsr);
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005116 break;
Bram Moolenaarf4d8b762021-10-17 14:13:09 +01005117#ifdef FEAT_COMPL_FUNC
5118 case PV_TSRFU:
5119 clear_string_option(&buf->b_p_tsrfu);
5120 break;
5121#endif
Bram Moolenaar9be7c042017-01-14 14:28:30 +01005122 case PV_FP:
5123 clear_string_option(&buf->b_p_fp);
5124 break;
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005125#ifdef FEAT_QUICKFIX
5126 case PV_EFM:
Bram Moolenaar51ac8a22013-05-06 06:45:47 +02005127 clear_string_option(&buf->b_p_efm);
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005128 break;
5129 case PV_GP:
Bram Moolenaar51ac8a22013-05-06 06:45:47 +02005130 clear_string_option(&buf->b_p_gp);
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005131 break;
5132 case PV_MP:
Bram Moolenaar51ac8a22013-05-06 06:45:47 +02005133 clear_string_option(&buf->b_p_mp);
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005134 break;
5135#endif
5136#if defined(FEAT_BEVAL) && defined(FEAT_EVAL)
5137 case PV_BEXPR:
Bram Moolenaar51ac8a22013-05-06 06:45:47 +02005138 clear_string_option(&buf->b_p_bexpr);
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005139 break;
5140#endif
5141#if defined(FEAT_CRYPT)
5142 case PV_CM:
Bram Moolenaar51ac8a22013-05-06 06:45:47 +02005143 clear_string_option(&buf->b_p_cm);
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005144 break;
5145#endif
Bram Moolenaaree857022019-11-09 23:26:40 +01005146#ifdef FEAT_LINEBREAK
5147 case PV_SBR:
5148 clear_string_option(&((win_T *)from)->w_p_sbr);
5149 break;
5150#endif
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005151#ifdef FEAT_STL_OPT
5152 case PV_STL:
Bram Moolenaar51ac8a22013-05-06 06:45:47 +02005153 clear_string_option(&((win_T *)from)->w_p_stl);
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005154 break;
5155#endif
Bram Moolenaarf5a2fd82013-11-06 05:26:15 +01005156 case PV_UL:
5157 buf->b_p_ul = NO_LOCAL_UNDOLEVEL;
5158 break;
Bram Moolenaaraf6c1312014-03-12 18:55:58 +01005159#ifdef FEAT_LISP
5160 case PV_LW:
5161 clear_string_option(&buf->b_p_lw);
5162 break;
5163#endif
Bram Moolenaar2c7292d2017-03-05 17:43:31 +01005164 case PV_MENC:
5165 clear_string_option(&buf->b_p_menc);
5166 break;
Bram Moolenaareed9d462021-02-15 20:38:25 +01005167 case PV_LCS:
5168 clear_string_option(&((win_T *)from)->w_p_lcs);
5169 set_chars_option((win_T *)from, &((win_T *)from)->w_p_lcs);
5170 redraw_later(NOT_VALID);
5171 break;
Gary Johnson53ba05b2021-07-26 22:19:10 +02005172 case PV_VE:
Gary Johnson51ad8502021-08-03 18:33:08 +02005173 clear_string_option(&((win_T *)from)->w_p_ve);
5174 ((win_T *)from)->w_ve_flags = 0;
Gary Johnson53ba05b2021-07-26 22:19:10 +02005175 break;
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005176 }
5177}
Bram Moolenaar113e1072019-01-20 15:30:40 +01005178#endif
Bram Moolenaar84e0f6c2013-05-06 03:52:55 +02005179
5180/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00005181 * Get pointer to option variable, depending on local or global scope.
5182 */
5183 static char_u *
Bram Moolenaar9b578142016-01-30 19:39:49 +01005184get_varp_scope(struct vimoption *p, int opt_flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005185{
5186 if ((opt_flags & OPT_GLOBAL) && p->indir != PV_NONE)
5187 {
5188 if (p->var == VAR_WIN)
5189 return (char_u *)GLOBAL_WO(get_varp(p));
5190 return p->var;
5191 }
Bram Moolenaara23ccb82006-02-27 00:08:02 +00005192 if ((opt_flags & OPT_LOCAL) && ((int)p->indir & PV_BOTH))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005193 {
5194 switch ((int)p->indir)
5195 {
Bram Moolenaar9be7c042017-01-14 14:28:30 +01005196 case PV_FP: return (char_u *)&(curbuf->b_p_fp);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005197#ifdef FEAT_QUICKFIX
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00005198 case PV_EFM: return (char_u *)&(curbuf->b_p_efm);
5199 case PV_GP: return (char_u *)&(curbuf->b_p_gp);
5200 case PV_MP: return (char_u *)&(curbuf->b_p_mp);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005201#endif
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00005202 case PV_EP: return (char_u *)&(curbuf->b_p_ep);
5203 case PV_KP: return (char_u *)&(curbuf->b_p_kp);
5204 case PV_PATH: return (char_u *)&(curbuf->b_p_path);
Bram Moolenaara23ccb82006-02-27 00:08:02 +00005205 case PV_AR: return (char_u *)&(curbuf->b_p_ar);
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00005206 case PV_TAGS: return (char_u *)&(curbuf->b_p_tags);
Bram Moolenaar0f6562e2015-11-24 18:48:14 +01005207 case PV_TC: return (char_u *)&(curbuf->b_p_tc);
Bram Moolenaar375e3392019-01-31 18:26:10 +01005208 case PV_SISO: return (char_u *)&(curwin->w_p_siso);
5209 case PV_SO: return (char_u *)&(curwin->w_p_so);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005210#ifdef FEAT_FIND_ID
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00005211 case PV_DEF: return (char_u *)&(curbuf->b_p_def);
5212 case PV_INC: return (char_u *)&(curbuf->b_p_inc);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005213#endif
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00005214 case PV_DICT: return (char_u *)&(curbuf->b_p_dict);
5215 case PV_TSR: return (char_u *)&(curbuf->b_p_tsr);
Bram Moolenaarf4d8b762021-10-17 14:13:09 +01005216#ifdef FEAT_COMPL_FUNC
5217 case PV_TSRFU: return (char_u *)&(curbuf->b_p_tsrfu);
5218#endif
Bram Moolenaar9b2200a2006-03-20 21:55:45 +00005219#if defined(FEAT_BEVAL) && defined(FEAT_EVAL)
5220 case PV_BEXPR: return (char_u *)&(curbuf->b_p_bexpr);
5221#endif
Bram Moolenaar49771f42010-07-20 17:32:38 +02005222#if defined(FEAT_CRYPT)
5223 case PV_CM: return (char_u *)&(curbuf->b_p_cm);
5224#endif
Bram Moolenaaree857022019-11-09 23:26:40 +01005225#ifdef FEAT_LINEBREAK
5226 case PV_SBR: return (char_u *)&(curwin->w_p_sbr);
5227#endif
Bram Moolenaarb5bf5b82004-12-24 14:35:23 +00005228#ifdef FEAT_STL_OPT
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00005229 case PV_STL: return (char_u *)&(curwin->w_p_stl);
Bram Moolenaarb5bf5b82004-12-24 14:35:23 +00005230#endif
Bram Moolenaarf5a2fd82013-11-06 05:26:15 +01005231 case PV_UL: return (char_u *)&(curbuf->b_p_ul);
Bram Moolenaaraf6c1312014-03-12 18:55:58 +01005232#ifdef FEAT_LISP
5233 case PV_LW: return (char_u *)&(curbuf->b_p_lw);
5234#endif
Bram Moolenaarb8ee25a2014-09-23 15:45:08 +02005235 case PV_BKC: return (char_u *)&(curbuf->b_p_bkc);
Bram Moolenaar2c7292d2017-03-05 17:43:31 +01005236 case PV_MENC: return (char_u *)&(curbuf->b_p_menc);
Gary Johnson53ba05b2021-07-26 22:19:10 +02005237 case PV_LCS: return (char_u *)&(curwin->w_p_lcs);
Gary Johnson51ad8502021-08-03 18:33:08 +02005238 case PV_VE: return (char_u *)&(curwin->w_p_ve);
Bram Moolenaareed9d462021-02-15 20:38:25 +01005239
Bram Moolenaar071d4272004-06-13 20:20:40 +00005240 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01005241 return NULL; // "cannot happen"
Bram Moolenaar071d4272004-06-13 20:20:40 +00005242 }
5243 return get_varp(p);
5244}
5245
5246/*
Bram Moolenaardac13472019-09-16 21:06:21 +02005247 * Get pointer to option variable at 'opt_idx', depending on local or global
5248 * scope.
5249 */
5250 char_u *
5251get_option_varp_scope(int opt_idx, int opt_flags)
5252{
5253 return get_varp_scope(&(options[opt_idx]), opt_flags);
5254}
5255
5256/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00005257 * Get pointer to option variable.
5258 */
5259 static char_u *
Bram Moolenaar9b578142016-01-30 19:39:49 +01005260get_varp(struct vimoption *p)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005261{
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01005262 // hidden option, always return NULL
Bram Moolenaar071d4272004-06-13 20:20:40 +00005263 if (p->var == NULL)
5264 return NULL;
5265
5266 switch ((int)p->indir)
5267 {
5268 case PV_NONE: return p->var;
5269
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01005270 // global option with local value: use local value if it's been set
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00005271 case PV_EP: return *curbuf->b_p_ep != NUL
Bram Moolenaar071d4272004-06-13 20:20:40 +00005272 ? (char_u *)&curbuf->b_p_ep : p->var;
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00005273 case PV_KP: return *curbuf->b_p_kp != NUL
Bram Moolenaar071d4272004-06-13 20:20:40 +00005274 ? (char_u *)&curbuf->b_p_kp : p->var;
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00005275 case PV_PATH: return *curbuf->b_p_path != NUL
Bram Moolenaar071d4272004-06-13 20:20:40 +00005276 ? (char_u *)&(curbuf->b_p_path) : p->var;
Bram Moolenaara23ccb82006-02-27 00:08:02 +00005277 case PV_AR: return curbuf->b_p_ar >= 0
Bram Moolenaar071d4272004-06-13 20:20:40 +00005278 ? (char_u *)&(curbuf->b_p_ar) : p->var;
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00005279 case PV_TAGS: return *curbuf->b_p_tags != NUL
Bram Moolenaar071d4272004-06-13 20:20:40 +00005280 ? (char_u *)&(curbuf->b_p_tags) : p->var;
Bram Moolenaar0f6562e2015-11-24 18:48:14 +01005281 case PV_TC: return *curbuf->b_p_tc != NUL
5282 ? (char_u *)&(curbuf->b_p_tc) : p->var;
Bram Moolenaarb8ee25a2014-09-23 15:45:08 +02005283 case PV_BKC: return *curbuf->b_p_bkc != NUL
5284 ? (char_u *)&(curbuf->b_p_bkc) : p->var;
Bram Moolenaar375e3392019-01-31 18:26:10 +01005285 case PV_SISO: return curwin->w_p_siso >= 0
5286 ? (char_u *)&(curwin->w_p_siso) : p->var;
5287 case PV_SO: return curwin->w_p_so >= 0
5288 ? (char_u *)&(curwin->w_p_so) : p->var;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005289#ifdef FEAT_FIND_ID
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00005290 case PV_DEF: return *curbuf->b_p_def != NUL
Bram Moolenaar071d4272004-06-13 20:20:40 +00005291 ? (char_u *)&(curbuf->b_p_def) : p->var;
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00005292 case PV_INC: return *curbuf->b_p_inc != NUL
Bram Moolenaar071d4272004-06-13 20:20:40 +00005293 ? (char_u *)&(curbuf->b_p_inc) : p->var;
5294#endif
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00005295 case PV_DICT: return *curbuf->b_p_dict != NUL
Bram Moolenaar071d4272004-06-13 20:20:40 +00005296 ? (char_u *)&(curbuf->b_p_dict) : p->var;
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00005297 case PV_TSR: return *curbuf->b_p_tsr != NUL
Bram Moolenaar071d4272004-06-13 20:20:40 +00005298 ? (char_u *)&(curbuf->b_p_tsr) : p->var;
Bram Moolenaarf4d8b762021-10-17 14:13:09 +01005299#ifdef FEAT_COMPL_FUNC
5300 case PV_TSRFU: return *curbuf->b_p_tsrfu != NUL
5301 ? (char_u *)&(curbuf->b_p_tsrfu) : p->var;
5302#endif
Bram Moolenaar9be7c042017-01-14 14:28:30 +01005303 case PV_FP: return *curbuf->b_p_fp != NUL
5304 ? (char_u *)&(curbuf->b_p_fp) : p->var;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005305#ifdef FEAT_QUICKFIX
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00005306 case PV_EFM: return *curbuf->b_p_efm != NUL
Bram Moolenaar071d4272004-06-13 20:20:40 +00005307 ? (char_u *)&(curbuf->b_p_efm) : p->var;
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00005308 case PV_GP: return *curbuf->b_p_gp != NUL
5309 ? (char_u *)&(curbuf->b_p_gp) : p->var;
5310 case PV_MP: return *curbuf->b_p_mp != NUL
5311 ? (char_u *)&(curbuf->b_p_mp) : p->var;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005312#endif
Bram Moolenaar9b2200a2006-03-20 21:55:45 +00005313#if defined(FEAT_BEVAL) && defined(FEAT_EVAL)
5314 case PV_BEXPR: return *curbuf->b_p_bexpr != NUL
5315 ? (char_u *)&(curbuf->b_p_bexpr) : p->var;
5316#endif
Bram Moolenaar49771f42010-07-20 17:32:38 +02005317#if defined(FEAT_CRYPT)
5318 case PV_CM: return *curbuf->b_p_cm != NUL
5319 ? (char_u *)&(curbuf->b_p_cm) : p->var;
5320#endif
Bram Moolenaaree857022019-11-09 23:26:40 +01005321#ifdef FEAT_LINEBREAK
5322 case PV_SBR: return *curwin->w_p_sbr != NUL
5323 ? (char_u *)&(curwin->w_p_sbr) : p->var;
5324#endif
Bram Moolenaarb5bf5b82004-12-24 14:35:23 +00005325#ifdef FEAT_STL_OPT
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00005326 case PV_STL: return *curwin->w_p_stl != NUL
Bram Moolenaarb5bf5b82004-12-24 14:35:23 +00005327 ? (char_u *)&(curwin->w_p_stl) : p->var;
5328#endif
Bram Moolenaarf5a2fd82013-11-06 05:26:15 +01005329 case PV_UL: return curbuf->b_p_ul != NO_LOCAL_UNDOLEVEL
5330 ? (char_u *)&(curbuf->b_p_ul) : p->var;
Bram Moolenaaraf6c1312014-03-12 18:55:58 +01005331#ifdef FEAT_LISP
5332 case PV_LW: return *curbuf->b_p_lw != NUL
5333 ? (char_u *)&(curbuf->b_p_lw) : p->var;
5334#endif
Bram Moolenaar2c7292d2017-03-05 17:43:31 +01005335 case PV_MENC: return *curbuf->b_p_menc != NUL
5336 ? (char_u *)&(curbuf->b_p_menc) : p->var;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005337#ifdef FEAT_ARABIC
5338 case PV_ARAB: return (char_u *)&(curwin->w_p_arab);
5339#endif
5340 case PV_LIST: return (char_u *)&(curwin->w_p_list);
Bram Moolenaareed9d462021-02-15 20:38:25 +01005341 case PV_LCS: return *curwin->w_p_lcs != NUL
5342 ? (char_u *)&(curwin->w_p_lcs) : p->var;
Gary Johnson51ad8502021-08-03 18:33:08 +02005343 case PV_VE: return *curwin->w_p_ve != NUL
5344 ? (char_u *)&(curwin->w_p_ve) : p->var;
Bram Moolenaarb9a02fc2006-03-12 22:08:12 +00005345#ifdef FEAT_SPELL
Bram Moolenaar217ad922005-03-20 22:37:15 +00005346 case PV_SPELL: return (char_u *)&(curwin->w_p_spell);
5347#endif
Bram Moolenaarb9a02fc2006-03-12 22:08:12 +00005348#ifdef FEAT_SYN_HL
5349 case PV_CUC: return (char_u *)&(curwin->w_p_cuc);
5350 case PV_CUL: return (char_u *)&(curwin->w_p_cul);
Bram Moolenaar410e98a2019-09-09 22:05:49 +02005351 case PV_CULOPT: return (char_u *)&(curwin->w_p_culopt);
Bram Moolenaar1a384422010-07-14 19:53:30 +02005352 case PV_CC: return (char_u *)&(curwin->w_p_cc);
Bram Moolenaarb9a02fc2006-03-12 22:08:12 +00005353#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005354#ifdef FEAT_DIFF
5355 case PV_DIFF: return (char_u *)&(curwin->w_p_diff);
5356#endif
5357#ifdef FEAT_FOLDING
5358 case PV_FDC: return (char_u *)&(curwin->w_p_fdc);
5359 case PV_FEN: return (char_u *)&(curwin->w_p_fen);
5360 case PV_FDI: return (char_u *)&(curwin->w_p_fdi);
5361 case PV_FDL: return (char_u *)&(curwin->w_p_fdl);
5362 case PV_FDM: return (char_u *)&(curwin->w_p_fdm);
5363 case PV_FML: return (char_u *)&(curwin->w_p_fml);
5364 case PV_FDN: return (char_u *)&(curwin->w_p_fdn);
5365# ifdef FEAT_EVAL
5366 case PV_FDE: return (char_u *)&(curwin->w_p_fde);
5367 case PV_FDT: return (char_u *)&(curwin->w_p_fdt);
5368# endif
5369 case PV_FMR: return (char_u *)&(curwin->w_p_fmr);
5370#endif
5371 case PV_NU: return (char_u *)&(curwin->w_p_nu);
Bram Moolenaar64486672010-05-16 15:46:46 +02005372 case PV_RNU: return (char_u *)&(curwin->w_p_rnu);
Bram Moolenaar592e0a22004-07-03 16:05:59 +00005373#ifdef FEAT_LINEBREAK
5374 case PV_NUW: return (char_u *)&(curwin->w_p_nuw);
5375#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005376 case PV_WFH: return (char_u *)&(curwin->w_p_wfh);
Bram Moolenaar97b2ad32006-03-18 21:40:56 +00005377 case PV_WFW: return (char_u *)&(curwin->w_p_wfw);
Bram Moolenaar4033c552017-09-16 20:54:51 +02005378#if defined(FEAT_QUICKFIX)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005379 case PV_PVW: return (char_u *)&(curwin->w_p_pvw);
5380#endif
5381#ifdef FEAT_RIGHTLEFT
5382 case PV_RL: return (char_u *)&(curwin->w_p_rl);
5383 case PV_RLC: return (char_u *)&(curwin->w_p_rlc);
5384#endif
5385 case PV_SCROLL: return (char_u *)&(curwin->w_p_scr);
5386 case PV_WRAP: return (char_u *)&(curwin->w_p_wrap);
5387#ifdef FEAT_LINEBREAK
5388 case PV_LBR: return (char_u *)&(curwin->w_p_lbr);
Bram Moolenaar597a4222014-06-25 14:39:50 +02005389 case PV_BRI: return (char_u *)&(curwin->w_p_bri);
5390 case PV_BRIOPT: return (char_u *)&(curwin->w_p_briopt);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005391#endif
Bram Moolenaar4d784b22019-05-25 19:51:39 +02005392 case PV_WCR: return (char_u *)&(curwin->w_p_wcr);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005393 case PV_SCBIND: return (char_u *)&(curwin->w_p_scb);
Bram Moolenaar860cae12010-06-05 23:22:07 +02005394 case PV_CRBIND: return (char_u *)&(curwin->w_p_crb);
Bram Moolenaar860cae12010-06-05 23:22:07 +02005395#ifdef FEAT_CONCEAL
Bram Moolenaare4f25e42017-07-07 11:54:15 +02005396 case PV_COCU: return (char_u *)&(curwin->w_p_cocu);
5397 case PV_COLE: return (char_u *)&(curwin->w_p_cole);
5398#endif
5399#ifdef FEAT_TERMINAL
Bram Moolenaar6d150f72018-04-21 20:03:20 +02005400 case PV_TWK: return (char_u *)&(curwin->w_p_twk);
5401 case PV_TWS: return (char_u *)&(curwin->w_p_tws);
5402 case PV_TWSL: return (char_u *)&(curbuf->b_p_twsl);
Bram Moolenaar860cae12010-06-05 23:22:07 +02005403#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005404
5405 case PV_AI: return (char_u *)&(curbuf->b_p_ai);
5406 case PV_BIN: return (char_u *)&(curbuf->b_p_bin);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005407 case PV_BOMB: return (char_u *)&(curbuf->b_p_bomb);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005408 case PV_BH: return (char_u *)&(curbuf->b_p_bh);
5409 case PV_BT: return (char_u *)&(curbuf->b_p_bt);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005410 case PV_BL: return (char_u *)&(curbuf->b_p_bl);
5411 case PV_CI: return (char_u *)&(curbuf->b_p_ci);
5412#ifdef FEAT_CINDENT
5413 case PV_CIN: return (char_u *)&(curbuf->b_p_cin);
5414 case PV_CINK: return (char_u *)&(curbuf->b_p_cink);
5415 case PV_CINO: return (char_u *)&(curbuf->b_p_cino);
5416#endif
5417#if defined(FEAT_SMARTINDENT) || defined(FEAT_CINDENT)
5418 case PV_CINW: return (char_u *)&(curbuf->b_p_cinw);
5419#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005420 case PV_COM: return (char_u *)&(curbuf->b_p_com);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005421#ifdef FEAT_FOLDING
5422 case PV_CMS: return (char_u *)&(curbuf->b_p_cms);
5423#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005424 case PV_CPT: return (char_u *)&(curbuf->b_p_cpt);
Bram Moolenaare2c453d2019-08-21 14:37:09 +02005425#ifdef BACKSLASH_IN_FILENAME
Bram Moolenaarac3150d2019-07-28 16:36:39 +02005426 case PV_CSL: return (char_u *)&(curbuf->b_p_csl);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005427#endif
Bram Moolenaarcfbc5ee2004-07-02 15:38:35 +00005428#ifdef FEAT_COMPL_FUNC
5429 case PV_CFU: return (char_u *)&(curbuf->b_p_cfu);
Bram Moolenaare344bea2005-09-01 20:46:49 +00005430 case PV_OFU: return (char_u *)&(curbuf->b_p_ofu);
Bram Moolenaarcfbc5ee2004-07-02 15:38:35 +00005431#endif
Bram Moolenaar45e18cb2019-04-28 18:05:35 +02005432#ifdef FEAT_EVAL
5433 case PV_TFU: return (char_u *)&(curbuf->b_p_tfu);
5434#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005435 case PV_EOL: return (char_u *)&(curbuf->b_p_eol);
Bram Moolenaar34d72d42015-07-17 14:18:08 +02005436 case PV_FIXEOL: return (char_u *)&(curbuf->b_p_fixeol);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005437 case PV_ET: return (char_u *)&(curbuf->b_p_et);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005438 case PV_FENC: return (char_u *)&(curbuf->b_p_fenc);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005439 case PV_FF: return (char_u *)&(curbuf->b_p_ff);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005440 case PV_FT: return (char_u *)&(curbuf->b_p_ft);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005441 case PV_FO: return (char_u *)&(curbuf->b_p_fo);
Bram Moolenaar86b68352004-12-27 21:59:20 +00005442 case PV_FLP: return (char_u *)&(curbuf->b_p_flp);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005443 case PV_IMI: return (char_u *)&(curbuf->b_p_iminsert);
5444 case PV_IMS: return (char_u *)&(curbuf->b_p_imsearch);
5445 case PV_INF: return (char_u *)&(curbuf->b_p_inf);
5446 case PV_ISK: return (char_u *)&(curbuf->b_p_isk);
5447#ifdef FEAT_FIND_ID
5448# ifdef FEAT_EVAL
5449 case PV_INEX: return (char_u *)&(curbuf->b_p_inex);
5450# endif
5451#endif
5452#if defined(FEAT_CINDENT) && defined(FEAT_EVAL)
5453 case PV_INDE: return (char_u *)&(curbuf->b_p_inde);
5454 case PV_INDK: return (char_u *)&(curbuf->b_p_indk);
5455#endif
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00005456#ifdef FEAT_EVAL
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00005457 case PV_FEX: return (char_u *)&(curbuf->b_p_fex);
5458#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005459#ifdef FEAT_CRYPT
5460 case PV_KEY: return (char_u *)&(curbuf->b_p_key);
5461#endif
5462#ifdef FEAT_LISP
5463 case PV_LISP: return (char_u *)&(curbuf->b_p_lisp);
5464#endif
5465 case PV_ML: return (char_u *)&(curbuf->b_p_ml);
5466 case PV_MPS: return (char_u *)&(curbuf->b_p_mps);
5467 case PV_MA: return (char_u *)&(curbuf->b_p_ma);
5468 case PV_MOD: return (char_u *)&(curbuf->b_changed);
5469 case PV_NF: return (char_u *)&(curbuf->b_p_nf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005470 case PV_PI: return (char_u *)&(curbuf->b_p_pi);
Bram Moolenaarcfbc5ee2004-07-02 15:38:35 +00005471#ifdef FEAT_TEXTOBJ
5472 case PV_QE: return (char_u *)&(curbuf->b_p_qe);
5473#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005474 case PV_RO: return (char_u *)&(curbuf->b_p_ro);
5475#ifdef FEAT_SMARTINDENT
5476 case PV_SI: return (char_u *)&(curbuf->b_p_si);
5477#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005478 case PV_SN: return (char_u *)&(curbuf->b_p_sn);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005479 case PV_STS: return (char_u *)&(curbuf->b_p_sts);
5480#ifdef FEAT_SEARCHPATH
5481 case PV_SUA: return (char_u *)&(curbuf->b_p_sua);
5482#endif
5483 case PV_SWF: return (char_u *)&(curbuf->b_p_swf);
5484#ifdef FEAT_SYN_HL
Bram Moolenaar3b56eb32005-07-11 22:40:32 +00005485 case PV_SMC: return (char_u *)&(curbuf->b_p_smc);
Bram Moolenaarb9a02fc2006-03-12 22:08:12 +00005486 case PV_SYN: return (char_u *)&(curbuf->b_p_syn);
5487#endif
5488#ifdef FEAT_SPELL
Bram Moolenaar860cae12010-06-05 23:22:07 +02005489 case PV_SPC: return (char_u *)&(curwin->w_s->b_p_spc);
5490 case PV_SPF: return (char_u *)&(curwin->w_s->b_p_spf);
5491 case PV_SPL: return (char_u *)&(curwin->w_s->b_p_spl);
Bram Moolenaar362b44b2020-06-10 21:47:00 +02005492 case PV_SPO: return (char_u *)&(curwin->w_s->b_p_spo);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005493#endif
5494 case PV_SW: return (char_u *)&(curbuf->b_p_sw);
5495 case PV_TS: return (char_u *)&(curbuf->b_p_ts);
5496 case PV_TW: return (char_u *)&(curbuf->b_p_tw);
5497 case PV_TX: return (char_u *)&(curbuf->b_p_tx);
Bram Moolenaar55debbe2010-05-23 23:34:36 +02005498#ifdef FEAT_PERSISTENT_UNDO
5499 case PV_UDF: return (char_u *)&(curbuf->b_p_udf);
5500#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005501 case PV_WM: return (char_u *)&(curbuf->b_p_wm);
5502#ifdef FEAT_KEYMAP
5503 case PV_KMAP: return (char_u *)&(curbuf->b_p_keymap);
5504#endif
Bram Moolenaar95ec9d62016-08-12 18:29:59 +02005505#ifdef FEAT_SIGNS
5506 case PV_SCL: return (char_u *)&(curwin->w_p_scl);
5507#endif
Bram Moolenaar04958cb2018-06-23 19:23:02 +02005508#ifdef FEAT_VARTABS
5509 case PV_VSTS: return (char_u *)&(curbuf->b_p_vsts);
5510 case PV_VTS: return (char_u *)&(curbuf->b_p_vts);
5511#endif
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005512 default: iemsg(_("E356: get_varp ERROR"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00005513 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01005514 // always return a valid pointer to avoid a crash!
Bram Moolenaar071d4272004-06-13 20:20:40 +00005515 return (char_u *)&(curbuf->b_p_wm);
5516}
5517
5518/*
Bram Moolenaardac13472019-09-16 21:06:21 +02005519 * Return a pointer to the variable for option at 'opt_idx'
5520 */
5521 char_u *
5522get_option_var(int opt_idx)
5523{
5524 return options[opt_idx].var;
5525}
5526
5527/*
5528 * Return the full name of the option at 'opt_idx'
5529 */
5530 char_u *
5531get_option_fullname(int opt_idx)
5532{
5533 return (char_u *)options[opt_idx].fullname;
5534}
5535
5536/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00005537 * Get the value of 'equalprg', either the buffer-local one or the global one.
5538 */
5539 char_u *
Bram Moolenaar9b578142016-01-30 19:39:49 +01005540get_equalprg(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005541{
5542 if (*curbuf->b_p_ep == NUL)
5543 return p_ep;
5544 return curbuf->b_p_ep;
5545}
5546
Bram Moolenaar071d4272004-06-13 20:20:40 +00005547/*
5548 * Copy options from one window to another.
5549 * Used when splitting a window.
5550 */
5551 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01005552win_copy_options(win_T *wp_from, win_T *wp_to)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005553{
5554 copy_winopt(&wp_from->w_onebuf_opt, &wp_to->w_onebuf_opt);
5555 copy_winopt(&wp_from->w_allbuf_opt, &wp_to->w_allbuf_opt);
Bram Moolenaar010ee962019-09-25 20:37:36 +02005556 after_copy_winopt(wp_to);
5557}
5558
5559/*
5560 * After copying window options: update variables depending on options.
5561 */
5562 void
Bram Moolenaar473952e2019-09-28 16:30:04 +02005563after_copy_winopt(win_T *wp UNUSED)
Bram Moolenaar010ee962019-09-25 20:37:36 +02005564{
5565#ifdef FEAT_LINEBREAK
5566 briopt_check(wp);
Bram Moolenaar285ed7e2014-08-24 21:39:49 +02005567#endif
Bram Moolenaar017ba072019-09-14 21:01:23 +02005568#ifdef FEAT_SYN_HL
Bram Moolenaar010ee962019-09-25 20:37:36 +02005569 fill_culopt_flags(NULL, wp);
5570 check_colorcolumn(wp);
Bram Moolenaar017ba072019-09-14 21:01:23 +02005571#endif
Bram Moolenaareed9d462021-02-15 20:38:25 +01005572 set_chars_option(wp, &wp->w_p_lcs);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005573}
Bram Moolenaar071d4272004-06-13 20:20:40 +00005574
5575/*
5576 * Copy the options from one winopt_T to another.
5577 * Doesn't free the old option values in "to", use clear_winopt() for that.
5578 * The 'scroll' option is not copied, because it depends on the window height.
5579 * The 'previewwindow' option is reset, there can be only one preview window.
5580 */
5581 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01005582copy_winopt(winopt_T *from, winopt_T *to)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005583{
5584#ifdef FEAT_ARABIC
5585 to->wo_arab = from->wo_arab;
5586#endif
5587 to->wo_list = from->wo_list;
Bram Moolenaareed9d462021-02-15 20:38:25 +01005588 to->wo_lcs = vim_strsave(from->wo_lcs);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005589 to->wo_nu = from->wo_nu;
Bram Moolenaar64486672010-05-16 15:46:46 +02005590 to->wo_rnu = from->wo_rnu;
Gary Johnson51ad8502021-08-03 18:33:08 +02005591 to->wo_ve = vim_strsave(from->wo_ve);
5592 to->wo_ve_flags = from->wo_ve_flags;
Bram Moolenaar592e0a22004-07-03 16:05:59 +00005593#ifdef FEAT_LINEBREAK
5594 to->wo_nuw = from->wo_nuw;
5595#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005596#ifdef FEAT_RIGHTLEFT
5597 to->wo_rl = from->wo_rl;
5598 to->wo_rlc = vim_strsave(from->wo_rlc);
5599#endif
Bram Moolenaaree857022019-11-09 23:26:40 +01005600#ifdef FEAT_LINEBREAK
5601 to->wo_sbr = vim_strsave(from->wo_sbr);
5602#endif
Bram Moolenaarb5bf5b82004-12-24 14:35:23 +00005603#ifdef FEAT_STL_OPT
5604 to->wo_stl = vim_strsave(from->wo_stl);
5605#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005606 to->wo_wrap = from->wo_wrap;
Bram Moolenaara87aa802013-07-03 15:47:03 +02005607#ifdef FEAT_DIFF
5608 to->wo_wrap_save = from->wo_wrap_save;
5609#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005610#ifdef FEAT_LINEBREAK
5611 to->wo_lbr = from->wo_lbr;
Bram Moolenaar597a4222014-06-25 14:39:50 +02005612 to->wo_bri = from->wo_bri;
5613 to->wo_briopt = vim_strsave(from->wo_briopt);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005614#endif
Bram Moolenaar4d784b22019-05-25 19:51:39 +02005615 to->wo_wcr = vim_strsave(from->wo_wcr);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005616 to->wo_scb = from->wo_scb;
Bram Moolenaara87aa802013-07-03 15:47:03 +02005617 to->wo_scb_save = from->wo_scb_save;
Bram Moolenaar4161dcc2010-12-02 15:33:21 +01005618 to->wo_crb = from->wo_crb;
Bram Moolenaara87aa802013-07-03 15:47:03 +02005619 to->wo_crb_save = from->wo_crb_save;
Bram Moolenaarb9a02fc2006-03-12 22:08:12 +00005620#ifdef FEAT_SPELL
Bram Moolenaar217ad922005-03-20 22:37:15 +00005621 to->wo_spell = from->wo_spell;
5622#endif
Bram Moolenaarb9a02fc2006-03-12 22:08:12 +00005623#ifdef FEAT_SYN_HL
5624 to->wo_cuc = from->wo_cuc;
5625 to->wo_cul = from->wo_cul;
Bram Moolenaar410e98a2019-09-09 22:05:49 +02005626 to->wo_culopt = vim_strsave(from->wo_culopt);
Bram Moolenaar1a384422010-07-14 19:53:30 +02005627 to->wo_cc = vim_strsave(from->wo_cc);
Bram Moolenaarb9a02fc2006-03-12 22:08:12 +00005628#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005629#ifdef FEAT_DIFF
5630 to->wo_diff = from->wo_diff;
Bram Moolenaara87aa802013-07-03 15:47:03 +02005631 to->wo_diff_saved = from->wo_diff_saved;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005632#endif
Bram Moolenaarf5963f72010-07-23 22:10:27 +02005633#ifdef FEAT_CONCEAL
5634 to->wo_cocu = vim_strsave(from->wo_cocu);
Bram Moolenaard497a302010-07-23 22:27:03 +02005635 to->wo_cole = from->wo_cole;
Bram Moolenaarf5963f72010-07-23 22:10:27 +02005636#endif
Bram Moolenaare4f25e42017-07-07 11:54:15 +02005637#ifdef FEAT_TERMINAL
Bram Moolenaar6d150f72018-04-21 20:03:20 +02005638 to->wo_twk = vim_strsave(from->wo_twk);
5639 to->wo_tws = vim_strsave(from->wo_tws);
Bram Moolenaare4f25e42017-07-07 11:54:15 +02005640#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005641#ifdef FEAT_FOLDING
5642 to->wo_fdc = from->wo_fdc;
Bram Moolenaara87aa802013-07-03 15:47:03 +02005643 to->wo_fdc_save = from->wo_fdc_save;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005644 to->wo_fen = from->wo_fen;
Bram Moolenaara87aa802013-07-03 15:47:03 +02005645 to->wo_fen_save = from->wo_fen_save;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005646 to->wo_fdi = vim_strsave(from->wo_fdi);
5647 to->wo_fml = from->wo_fml;
5648 to->wo_fdl = from->wo_fdl;
Bram Moolenaara87aa802013-07-03 15:47:03 +02005649 to->wo_fdl_save = from->wo_fdl_save;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005650 to->wo_fdm = vim_strsave(from->wo_fdm);
Bram Moolenaara87aa802013-07-03 15:47:03 +02005651 to->wo_fdm_save = from->wo_diff_saved
5652 ? vim_strsave(from->wo_fdm_save) : empty_option;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005653 to->wo_fdn = from->wo_fdn;
5654# ifdef FEAT_EVAL
5655 to->wo_fde = vim_strsave(from->wo_fde);
5656 to->wo_fdt = vim_strsave(from->wo_fdt);
5657# endif
5658 to->wo_fmr = vim_strsave(from->wo_fmr);
5659#endif
Bram Moolenaar95ec9d62016-08-12 18:29:59 +02005660#ifdef FEAT_SIGNS
5661 to->wo_scl = vim_strsave(from->wo_scl);
5662#endif
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005663
5664#ifdef FEAT_EVAL
5665 // Copy the script context so that we know where the value was last set.
5666 mch_memmove(to->wo_script_ctx, from->wo_script_ctx,
5667 sizeof(to->wo_script_ctx));
5668#endif
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01005669 check_winopt(to); // don't want NULL pointers
Bram Moolenaar071d4272004-06-13 20:20:40 +00005670}
5671
5672/*
5673 * Check string options in a window for a NULL value.
5674 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02005675 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +01005676check_win_options(win_T *win)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005677{
5678 check_winopt(&win->w_onebuf_opt);
5679 check_winopt(&win->w_allbuf_opt);
5680}
5681
5682/*
5683 * Check for NULL pointers in a winopt_T and replace them with empty_option.
5684 */
Bram Moolenaar8dc907d2014-06-25 14:44:10 +02005685 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +01005686check_winopt(winopt_T *wop UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005687{
5688#ifdef FEAT_FOLDING
5689 check_string_option(&wop->wo_fdi);
5690 check_string_option(&wop->wo_fdm);
Bram Moolenaara87aa802013-07-03 15:47:03 +02005691 check_string_option(&wop->wo_fdm_save);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005692# ifdef FEAT_EVAL
5693 check_string_option(&wop->wo_fde);
5694 check_string_option(&wop->wo_fdt);
5695# endif
5696 check_string_option(&wop->wo_fmr);
5697#endif
Bram Moolenaar95ec9d62016-08-12 18:29:59 +02005698#ifdef FEAT_SIGNS
5699 check_string_option(&wop->wo_scl);
5700#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005701#ifdef FEAT_RIGHTLEFT
5702 check_string_option(&wop->wo_rlc);
5703#endif
Bram Moolenaaree857022019-11-09 23:26:40 +01005704#ifdef FEAT_LINEBREAK
5705 check_string_option(&wop->wo_sbr);
5706#endif
Bram Moolenaarb5bf5b82004-12-24 14:35:23 +00005707#ifdef FEAT_STL_OPT
5708 check_string_option(&wop->wo_stl);
5709#endif
Bram Moolenaar1a384422010-07-14 19:53:30 +02005710#ifdef FEAT_SYN_HL
Bram Moolenaar410e98a2019-09-09 22:05:49 +02005711 check_string_option(&wop->wo_culopt);
Bram Moolenaar1a384422010-07-14 19:53:30 +02005712 check_string_option(&wop->wo_cc);
5713#endif
Bram Moolenaarf5963f72010-07-23 22:10:27 +02005714#ifdef FEAT_CONCEAL
5715 check_string_option(&wop->wo_cocu);
5716#endif
Bram Moolenaare4f25e42017-07-07 11:54:15 +02005717#ifdef FEAT_TERMINAL
Bram Moolenaar6d150f72018-04-21 20:03:20 +02005718 check_string_option(&wop->wo_twk);
5719 check_string_option(&wop->wo_tws);
Bram Moolenaare4f25e42017-07-07 11:54:15 +02005720#endif
Bram Moolenaar597a4222014-06-25 14:39:50 +02005721#ifdef FEAT_LINEBREAK
5722 check_string_option(&wop->wo_briopt);
5723#endif
Bram Moolenaar4d784b22019-05-25 19:51:39 +02005724 check_string_option(&wop->wo_wcr);
Bram Moolenaareed9d462021-02-15 20:38:25 +01005725 check_string_option(&wop->wo_lcs);
Gary Johnson51ad8502021-08-03 18:33:08 +02005726 check_string_option(&wop->wo_ve);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005727}
5728
5729/*
5730 * Free the allocated memory inside a winopt_T.
5731 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005732 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01005733clear_winopt(winopt_T *wop UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005734{
5735#ifdef FEAT_FOLDING
5736 clear_string_option(&wop->wo_fdi);
5737 clear_string_option(&wop->wo_fdm);
Bram Moolenaara87aa802013-07-03 15:47:03 +02005738 clear_string_option(&wop->wo_fdm_save);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005739# ifdef FEAT_EVAL
5740 clear_string_option(&wop->wo_fde);
5741 clear_string_option(&wop->wo_fdt);
5742# endif
5743 clear_string_option(&wop->wo_fmr);
5744#endif
Bram Moolenaar95ec9d62016-08-12 18:29:59 +02005745#ifdef FEAT_SIGNS
5746 clear_string_option(&wop->wo_scl);
5747#endif
Bram Moolenaar597a4222014-06-25 14:39:50 +02005748#ifdef FEAT_LINEBREAK
5749 clear_string_option(&wop->wo_briopt);
5750#endif
Bram Moolenaar4d784b22019-05-25 19:51:39 +02005751 clear_string_option(&wop->wo_wcr);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005752#ifdef FEAT_RIGHTLEFT
5753 clear_string_option(&wop->wo_rlc);
5754#endif
Bram Moolenaaree857022019-11-09 23:26:40 +01005755#ifdef FEAT_LINEBREAK
5756 clear_string_option(&wop->wo_sbr);
5757#endif
Bram Moolenaarb5bf5b82004-12-24 14:35:23 +00005758#ifdef FEAT_STL_OPT
5759 clear_string_option(&wop->wo_stl);
5760#endif
Bram Moolenaar1a384422010-07-14 19:53:30 +02005761#ifdef FEAT_SYN_HL
Bram Moolenaar410e98a2019-09-09 22:05:49 +02005762 clear_string_option(&wop->wo_culopt);
Bram Moolenaar1a384422010-07-14 19:53:30 +02005763 clear_string_option(&wop->wo_cc);
5764#endif
Bram Moolenaarf5963f72010-07-23 22:10:27 +02005765#ifdef FEAT_CONCEAL
5766 clear_string_option(&wop->wo_cocu);
5767#endif
Bram Moolenaare4f25e42017-07-07 11:54:15 +02005768#ifdef FEAT_TERMINAL
Bram Moolenaar6d150f72018-04-21 20:03:20 +02005769 clear_string_option(&wop->wo_twk);
5770 clear_string_option(&wop->wo_tws);
Bram Moolenaare4f25e42017-07-07 11:54:15 +02005771#endif
Bram Moolenaareed9d462021-02-15 20:38:25 +01005772 clear_string_option(&wop->wo_lcs);
Gary Johnson51ad8502021-08-03 18:33:08 +02005773 clear_string_option(&wop->wo_ve);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005774}
5775
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005776#ifdef FEAT_EVAL
5777// Index into the options table for a buffer-local option enum.
5778static int buf_opt_idx[BV_COUNT];
5779# define COPY_OPT_SCTX(buf, bv) buf->b_p_script_ctx[bv] = options[buf_opt_idx[bv]].script_ctx
5780
5781/*
5782 * Initialize buf_opt_idx[] if not done already.
5783 */
5784 static void
5785init_buf_opt_idx(void)
5786{
5787 static int did_init_buf_opt_idx = FALSE;
5788 int i;
5789
5790 if (did_init_buf_opt_idx)
5791 return;
5792 did_init_buf_opt_idx = TRUE;
5793 for (i = 0; !istermoption_idx(i); i++)
5794 if (options[i].indir & PV_BUF)
5795 buf_opt_idx[options[i].indir & PV_MASK] = i;
5796}
5797#else
5798# define COPY_OPT_SCTX(buf, bv)
5799#endif
5800
Bram Moolenaar071d4272004-06-13 20:20:40 +00005801/*
5802 * Copy global option values to local options for one buffer.
5803 * Used when creating a new buffer and sometimes when entering a buffer.
5804 * flags:
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005805 * BCO_ENTER We will enter the buffer "buf".
Bram Moolenaar071d4272004-06-13 20:20:40 +00005806 * BCO_ALWAYS Always copy the options, but only set b_p_initialized when
5807 * appropriate.
5808 * BCO_NOHELP Don't copy the values to a help buffer.
5809 */
5810 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01005811buf_copy_options(buf_T *buf, int flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005812{
5813 int should_copy = TRUE;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01005814 char_u *save_p_isk = NULL; // init for GCC
Bram Moolenaar071d4272004-06-13 20:20:40 +00005815 int dont_do_help;
5816 int did_isk = FALSE;
5817
5818 /*
Bram Moolenaar071d4272004-06-13 20:20:40 +00005819 * Skip this when the option defaults have not been set yet. Happens when
5820 * main() allocates the first buffer.
5821 */
5822 if (p_cpo != NULL)
5823 {
5824 /*
5825 * Always copy when entering and 'cpo' contains 'S'.
5826 * Don't copy when already initialized.
5827 * Don't copy when 'cpo' contains 's' and not entering.
5828 * 'S' BCO_ENTER initialized 's' should_copy
5829 * yes yes X X TRUE
5830 * yes no yes X FALSE
5831 * no X yes X FALSE
5832 * X no no yes FALSE
5833 * X no no no TRUE
5834 * no yes no X TRUE
5835 */
5836 if ((vim_strchr(p_cpo, CPO_BUFOPTGLOB) == NULL || !(flags & BCO_ENTER))
5837 && (buf->b_p_initialized
5838 || (!(flags & BCO_ENTER)
5839 && vim_strchr(p_cpo, CPO_BUFOPT) != NULL)))
5840 should_copy = FALSE;
5841
5842 if (should_copy || (flags & BCO_ALWAYS))
5843 {
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005844#ifdef FEAT_EVAL
Bram Moolenaara80faa82020-04-12 19:37:17 +02005845 CLEAR_FIELD(buf->b_p_script_ctx);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005846 init_buf_opt_idx();
5847#endif
5848 // Don't copy the options specific to a help buffer when
5849 // BCO_NOHELP is given or the options were initialized already
5850 // (jumping back to a help file with CTRL-T or CTRL-O)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005851 dont_do_help = ((flags & BCO_NOHELP) && buf->b_help)
5852 || buf->b_p_initialized;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005853 if (dont_do_help) // don't free b_p_isk
Bram Moolenaar071d4272004-06-13 20:20:40 +00005854 {
5855 save_p_isk = buf->b_p_isk;
5856 buf->b_p_isk = NULL;
5857 }
5858 /*
Bram Moolenaar40385db2018-08-07 22:31:44 +02005859 * Always free the allocated strings. If not already initialized,
5860 * reset 'readonly' and copy 'fileformat'.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005861 */
5862 if (!buf->b_p_initialized)
5863 {
5864 free_buf_options(buf, TRUE);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01005865 buf->b_p_ro = FALSE; // don't copy readonly
Bram Moolenaar071d4272004-06-13 20:20:40 +00005866 buf->b_p_tx = p_tx;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005867 buf->b_p_fenc = vim_strsave(p_fenc);
Bram Moolenaare8ef3a02016-10-12 17:45:29 +02005868 switch (*p_ffs)
5869 {
5870 case 'm':
5871 buf->b_p_ff = vim_strsave((char_u *)FF_MAC); break;
5872 case 'd':
5873 buf->b_p_ff = vim_strsave((char_u *)FF_DOS); break;
5874 case 'u':
5875 buf->b_p_ff = vim_strsave((char_u *)FF_UNIX); break;
5876 default:
5877 buf->b_p_ff = vim_strsave(p_ff);
5878 }
5879 if (buf->b_p_ff != NULL)
5880 buf->b_start_ffc = *buf->b_p_ff;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005881 buf->b_p_bh = empty_option;
5882 buf->b_p_bt = empty_option;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005883 }
5884 else
5885 free_buf_options(buf, FALSE);
5886
5887 buf->b_p_ai = p_ai;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005888 COPY_OPT_SCTX(buf, BV_AI);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005889 buf->b_p_ai_nopaste = p_ai_nopaste;
5890 buf->b_p_sw = p_sw;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005891 COPY_OPT_SCTX(buf, BV_SW);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005892 buf->b_p_tw = p_tw;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005893 COPY_OPT_SCTX(buf, BV_TW);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005894 buf->b_p_tw_nopaste = p_tw_nopaste;
5895 buf->b_p_tw_nobin = p_tw_nobin;
5896 buf->b_p_wm = p_wm;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005897 COPY_OPT_SCTX(buf, BV_WM);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005898 buf->b_p_wm_nopaste = p_wm_nopaste;
5899 buf->b_p_wm_nobin = p_wm_nobin;
5900 buf->b_p_bin = p_bin;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005901 COPY_OPT_SCTX(buf, BV_BIN);
Bram Moolenaare8bb2552005-07-08 22:26:47 +00005902 buf->b_p_bomb = p_bomb;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005903 COPY_OPT_SCTX(buf, BV_BOMB);
Bram Moolenaarb388be02015-07-22 22:19:38 +02005904 buf->b_p_fixeol = p_fixeol;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005905 COPY_OPT_SCTX(buf, BV_FIXEOL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005906 buf->b_p_et = p_et;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005907 COPY_OPT_SCTX(buf, BV_ET);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005908 buf->b_p_et_nobin = p_et_nobin;
Bram Moolenaar54f018c2015-09-15 17:30:40 +02005909 buf->b_p_et_nopaste = p_et_nopaste;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005910 buf->b_p_ml = p_ml;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005911 COPY_OPT_SCTX(buf, BV_ML);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005912 buf->b_p_ml_nobin = p_ml_nobin;
5913 buf->b_p_inf = p_inf;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005914 COPY_OPT_SCTX(buf, BV_INF);
Bram Moolenaare1004402020-10-24 20:49:43 +02005915 if (cmdmod.cmod_flags & CMOD_NOSWAPFILE)
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005916 buf->b_p_swf = FALSE;
5917 else
5918 {
5919 buf->b_p_swf = p_swf;
5920 COPY_OPT_SCTX(buf, BV_INF);
5921 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005922 buf->b_p_cpt = vim_strsave(p_cpt);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005923 COPY_OPT_SCTX(buf, BV_CPT);
Bram Moolenaare2c453d2019-08-21 14:37:09 +02005924#ifdef BACKSLASH_IN_FILENAME
Bram Moolenaarac3150d2019-07-28 16:36:39 +02005925 buf->b_p_csl = vim_strsave(p_csl);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005926 COPY_OPT_SCTX(buf, BV_CSL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005927#endif
Bram Moolenaarcfbc5ee2004-07-02 15:38:35 +00005928#ifdef FEAT_COMPL_FUNC
5929 buf->b_p_cfu = vim_strsave(p_cfu);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005930 COPY_OPT_SCTX(buf, BV_CFU);
Yegappan Lakshmanan8658c752021-12-03 11:09:29 +00005931 set_buflocal_cfu_callback(buf);
Bram Moolenaare344bea2005-09-01 20:46:49 +00005932 buf->b_p_ofu = vim_strsave(p_ofu);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005933 COPY_OPT_SCTX(buf, BV_OFU);
Yegappan Lakshmanan8658c752021-12-03 11:09:29 +00005934 set_buflocal_ofu_callback(buf);
Bram Moolenaarcfbc5ee2004-07-02 15:38:35 +00005935#endif
Bram Moolenaar45e18cb2019-04-28 18:05:35 +02005936#ifdef FEAT_EVAL
5937 buf->b_p_tfu = vim_strsave(p_tfu);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005938 COPY_OPT_SCTX(buf, BV_TFU);
Yegappan Lakshmanan8658c752021-12-03 11:09:29 +00005939 set_buflocal_tfu_callback(buf);
Bram Moolenaar45e18cb2019-04-28 18:05:35 +02005940#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005941 buf->b_p_sts = p_sts;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005942 COPY_OPT_SCTX(buf, BV_STS);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005943 buf->b_p_sts_nopaste = p_sts_nopaste;
Bram Moolenaar04958cb2018-06-23 19:23:02 +02005944#ifdef FEAT_VARTABS
5945 buf->b_p_vsts = vim_strsave(p_vsts);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005946 COPY_OPT_SCTX(buf, BV_VSTS);
Bram Moolenaar04958cb2018-06-23 19:23:02 +02005947 if (p_vsts && p_vsts != empty_option)
Bram Moolenaarb7081e12021-09-04 18:47:28 +02005948 (void)tabstop_set(p_vsts, &buf->b_p_vsts_array);
Bram Moolenaar04958cb2018-06-23 19:23:02 +02005949 else
5950 buf->b_p_vsts_array = 0;
5951 buf->b_p_vsts_nopaste = p_vsts_nopaste
5952 ? vim_strsave(p_vsts_nopaste) : NULL;
5953#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005954 buf->b_p_sn = p_sn;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005955 COPY_OPT_SCTX(buf, BV_SN);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005956 buf->b_p_com = vim_strsave(p_com);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005957 COPY_OPT_SCTX(buf, BV_COM);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005958#ifdef FEAT_FOLDING
5959 buf->b_p_cms = vim_strsave(p_cms);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005960 COPY_OPT_SCTX(buf, BV_CMS);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005961#endif
5962 buf->b_p_fo = vim_strsave(p_fo);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005963 COPY_OPT_SCTX(buf, BV_FO);
Bram Moolenaar86b68352004-12-27 21:59:20 +00005964 buf->b_p_flp = vim_strsave(p_flp);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005965 COPY_OPT_SCTX(buf, BV_FLP);
Bram Moolenaar473952e2019-09-28 16:30:04 +02005966 // NOTE: Valgrind may report a bogus memory leak for 'nrformats'
5967 // when it is set to 8 bytes in defaults.vim.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005968 buf->b_p_nf = vim_strsave(p_nf);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005969 COPY_OPT_SCTX(buf, BV_NF);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005970 buf->b_p_mps = vim_strsave(p_mps);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005971 COPY_OPT_SCTX(buf, BV_MPS);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005972#ifdef FEAT_SMARTINDENT
5973 buf->b_p_si = p_si;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005974 COPY_OPT_SCTX(buf, BV_SI);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005975#endif
5976 buf->b_p_ci = p_ci;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005977 COPY_OPT_SCTX(buf, BV_CI);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005978#ifdef FEAT_CINDENT
5979 buf->b_p_cin = p_cin;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005980 COPY_OPT_SCTX(buf, BV_CIN);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005981 buf->b_p_cink = vim_strsave(p_cink);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005982 COPY_OPT_SCTX(buf, BV_CINK);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005983 buf->b_p_cino = vim_strsave(p_cino);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005984 COPY_OPT_SCTX(buf, BV_CINO);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005985#endif
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005986 // Don't copy 'filetype', it must be detected
Bram Moolenaar071d4272004-06-13 20:20:40 +00005987 buf->b_p_ft = empty_option;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005988 buf->b_p_pi = p_pi;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005989 COPY_OPT_SCTX(buf, BV_PI);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005990#if defined(FEAT_SMARTINDENT) || defined(FEAT_CINDENT)
5991 buf->b_p_cinw = vim_strsave(p_cinw);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005992 COPY_OPT_SCTX(buf, BV_CINW);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005993#endif
5994#ifdef FEAT_LISP
5995 buf->b_p_lisp = p_lisp;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02005996 COPY_OPT_SCTX(buf, BV_LISP);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005997#endif
5998#ifdef FEAT_SYN_HL
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01005999 // Don't copy 'syntax', it must be set
Bram Moolenaar071d4272004-06-13 20:20:40 +00006000 buf->b_p_syn = empty_option;
Bram Moolenaar3b56eb32005-07-11 22:40:32 +00006001 buf->b_p_smc = p_smc;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02006002 COPY_OPT_SCTX(buf, BV_SMC);
Bram Moolenaarb8060fe2016-01-19 22:29:28 +01006003 buf->b_s.b_syn_isk = empty_option;
Bram Moolenaarb9a02fc2006-03-12 22:08:12 +00006004#endif
6005#ifdef FEAT_SPELL
Bram Moolenaard5784f92010-10-13 14:05:35 +02006006 buf->b_s.b_p_spc = vim_strsave(p_spc);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02006007 COPY_OPT_SCTX(buf, BV_SPC);
Bram Moolenaar860cae12010-06-05 23:22:07 +02006008 (void)compile_cap_prog(&buf->b_s);
6009 buf->b_s.b_p_spf = vim_strsave(p_spf);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02006010 COPY_OPT_SCTX(buf, BV_SPF);
Bram Moolenaar860cae12010-06-05 23:22:07 +02006011 buf->b_s.b_p_spl = vim_strsave(p_spl);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02006012 COPY_OPT_SCTX(buf, BV_SPL);
Bram Moolenaar362b44b2020-06-10 21:47:00 +02006013 buf->b_s.b_p_spo = vim_strsave(p_spo);
6014 COPY_OPT_SCTX(buf, BV_SPO);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006015#endif
6016#if defined(FEAT_CINDENT) && defined(FEAT_EVAL)
6017 buf->b_p_inde = vim_strsave(p_inde);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02006018 COPY_OPT_SCTX(buf, BV_INDE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006019 buf->b_p_indk = vim_strsave(p_indk);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02006020 COPY_OPT_SCTX(buf, BV_INDK);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006021#endif
Bram Moolenaar9be7c042017-01-14 14:28:30 +01006022 buf->b_p_fp = empty_option;
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006023#if defined(FEAT_EVAL)
6024 buf->b_p_fex = vim_strsave(p_fex);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02006025 COPY_OPT_SCTX(buf, BV_FEX);
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006026#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006027#ifdef FEAT_CRYPT
6028 buf->b_p_key = vim_strsave(p_key);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02006029 COPY_OPT_SCTX(buf, BV_KEY);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006030#endif
6031#ifdef FEAT_SEARCHPATH
6032 buf->b_p_sua = vim_strsave(p_sua);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02006033 COPY_OPT_SCTX(buf, BV_SUA);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006034#endif
6035#ifdef FEAT_KEYMAP
6036 buf->b_p_keymap = vim_strsave(p_keymap);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02006037 COPY_OPT_SCTX(buf, BV_KMAP);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006038 buf->b_kmap_state |= KEYMAP_INIT;
6039#endif
Bram Moolenaar6d150f72018-04-21 20:03:20 +02006040#ifdef FEAT_TERMINAL
6041 buf->b_p_twsl = p_twsl;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02006042 COPY_OPT_SCTX(buf, BV_TWSL);
Bram Moolenaar6d150f72018-04-21 20:03:20 +02006043#endif
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006044 // This isn't really an option, but copying the langmap and IME
6045 // state from the current buffer is better than resetting it.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006046 buf->b_p_iminsert = p_iminsert;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02006047 COPY_OPT_SCTX(buf, BV_IMI);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006048 buf->b_p_imsearch = p_imsearch;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02006049 COPY_OPT_SCTX(buf, BV_IMS);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006050
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006051 // options that are normally global but also have a local value
6052 // are not copied, start using the global value
Bram Moolenaar071d4272004-06-13 20:20:40 +00006053 buf->b_p_ar = -1;
Bram Moolenaarf5a2fd82013-11-06 05:26:15 +01006054 buf->b_p_ul = NO_LOCAL_UNDOLEVEL;
Bram Moolenaarb8ee25a2014-09-23 15:45:08 +02006055 buf->b_p_bkc = empty_option;
6056 buf->b_bkc_flags = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006057#ifdef FEAT_QUICKFIX
6058 buf->b_p_gp = empty_option;
6059 buf->b_p_mp = empty_option;
6060 buf->b_p_efm = empty_option;
6061#endif
6062 buf->b_p_ep = empty_option;
6063 buf->b_p_kp = empty_option;
6064 buf->b_p_path = empty_option;
6065 buf->b_p_tags = empty_option;
Bram Moolenaar0f6562e2015-11-24 18:48:14 +01006066 buf->b_p_tc = empty_option;
6067 buf->b_tc_flags = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006068#ifdef FEAT_FIND_ID
6069 buf->b_p_def = empty_option;
6070 buf->b_p_inc = empty_option;
6071# ifdef FEAT_EVAL
6072 buf->b_p_inex = vim_strsave(p_inex);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02006073 COPY_OPT_SCTX(buf, BV_INEX);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006074# endif
6075#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006076 buf->b_p_dict = empty_option;
6077 buf->b_p_tsr = empty_option;
Bram Moolenaarf4d8b762021-10-17 14:13:09 +01006078#ifdef FEAT_COMPL_FUNC
6079 buf->b_p_tsrfu = empty_option;
6080#endif
Bram Moolenaarcfbc5ee2004-07-02 15:38:35 +00006081#ifdef FEAT_TEXTOBJ
6082 buf->b_p_qe = vim_strsave(p_qe);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02006083 COPY_OPT_SCTX(buf, BV_QE);
Bram Moolenaarcfbc5ee2004-07-02 15:38:35 +00006084#endif
Bram Moolenaar9b2200a2006-03-20 21:55:45 +00006085#if defined(FEAT_BEVAL) && defined(FEAT_EVAL)
6086 buf->b_p_bexpr = empty_option;
6087#endif
Bram Moolenaar49771f42010-07-20 17:32:38 +02006088#if defined(FEAT_CRYPT)
6089 buf->b_p_cm = empty_option;
6090#endif
Bram Moolenaar55debbe2010-05-23 23:34:36 +02006091#ifdef FEAT_PERSISTENT_UNDO
6092 buf->b_p_udf = p_udf;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02006093 COPY_OPT_SCTX(buf, BV_UDF);
Bram Moolenaar55debbe2010-05-23 23:34:36 +02006094#endif
Bram Moolenaaraf6c1312014-03-12 18:55:58 +01006095#ifdef FEAT_LISP
6096 buf->b_p_lw = empty_option;
6097#endif
Bram Moolenaar2c7292d2017-03-05 17:43:31 +01006098 buf->b_p_menc = empty_option;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006099
6100 /*
6101 * Don't copy the options set by ex_help(), use the saved values,
6102 * when going from a help buffer to a non-help buffer.
6103 * Don't touch these at all when BCO_NOHELP is used and going from
6104 * or to a help buffer.
6105 */
6106 if (dont_do_help)
Bram Moolenaar04958cb2018-06-23 19:23:02 +02006107 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00006108 buf->b_p_isk = save_p_isk;
Bram Moolenaar04958cb2018-06-23 19:23:02 +02006109#ifdef FEAT_VARTABS
6110 if (p_vts && p_vts != empty_option && !buf->b_p_vts_array)
Bram Moolenaarb7081e12021-09-04 18:47:28 +02006111 (void)tabstop_set(p_vts, &buf->b_p_vts_array);
Bram Moolenaar04958cb2018-06-23 19:23:02 +02006112 else
6113 buf->b_p_vts_array = NULL;
6114#endif
6115 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006116 else
6117 {
6118 buf->b_p_isk = vim_strsave(p_isk);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02006119 COPY_OPT_SCTX(buf, BV_ISK);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006120 did_isk = TRUE;
6121 buf->b_p_ts = p_ts;
Bram Moolenaar04958cb2018-06-23 19:23:02 +02006122#ifdef FEAT_VARTABS
6123 buf->b_p_vts = vim_strsave(p_vts);
Bram Moolenaarcfb38142019-10-19 20:18:47 +02006124 COPY_OPT_SCTX(buf, BV_VTS);
Bram Moolenaar04958cb2018-06-23 19:23:02 +02006125 if (p_vts && p_vts != empty_option && !buf->b_p_vts_array)
Bram Moolenaarb7081e12021-09-04 18:47:28 +02006126 (void)tabstop_set(p_vts, &buf->b_p_vts_array);
Bram Moolenaar04958cb2018-06-23 19:23:02 +02006127 else
6128 buf->b_p_vts_array = NULL;
6129#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006130 buf->b_help = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006131 if (buf->b_p_bt[0] == 'h')
6132 clear_string_option(&buf->b_p_bt);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006133 buf->b_p_ma = p_ma;
Bram Moolenaarcfb38142019-10-19 20:18:47 +02006134 COPY_OPT_SCTX(buf, BV_MA);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006135 }
6136 }
6137
6138 /*
6139 * When the options should be copied (ignoring BCO_ALWAYS), set the
6140 * flag that indicates that the options have been initialized.
6141 */
6142 if (should_copy)
6143 buf->b_p_initialized = TRUE;
6144 }
6145
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006146 check_buf_options(buf); // make sure we don't have NULLs
Bram Moolenaar071d4272004-06-13 20:20:40 +00006147 if (did_isk)
6148 (void)buf_init_chartab(buf, FALSE);
6149}
6150
6151/*
6152 * Reset the 'modifiable' option and its default value.
6153 */
6154 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01006155reset_modifiable(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006156{
6157 int opt_idx;
6158
6159 curbuf->b_p_ma = FALSE;
6160 p_ma = FALSE;
6161 opt_idx = findoption((char_u *)"ma");
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00006162 if (opt_idx >= 0)
6163 options[opt_idx].def_val[VI_DEFAULT] = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006164}
6165
6166/*
6167 * Set the global value for 'iminsert' to the local value.
6168 */
6169 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01006170set_iminsert_global(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006171{
6172 p_iminsert = curbuf->b_p_iminsert;
6173}
6174
6175/*
6176 * Set the global value for 'imsearch' to the local value.
6177 */
6178 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01006179set_imsearch_global(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006180{
6181 p_imsearch = curbuf->b_p_imsearch;
6182}
6183
Bram Moolenaar071d4272004-06-13 20:20:40 +00006184static int expand_option_idx = -1;
6185static char_u expand_option_name[5] = {'t', '_', NUL, NUL, NUL};
6186static int expand_option_flags = 0;
6187
6188 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01006189set_context_in_set_cmd(
6190 expand_T *xp,
6191 char_u *arg,
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006192 int opt_flags) // OPT_GLOBAL and/or OPT_LOCAL
Bram Moolenaar071d4272004-06-13 20:20:40 +00006193{
6194 int nextchar;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006195 long_u flags = 0; // init for GCC
6196 int opt_idx = 0; // init for GCC
Bram Moolenaar071d4272004-06-13 20:20:40 +00006197 char_u *p;
6198 char_u *s;
6199 int is_term_option = FALSE;
6200 int key;
6201
6202 expand_option_flags = opt_flags;
6203
6204 xp->xp_context = EXPAND_SETTINGS;
6205 if (*arg == NUL)
6206 {
6207 xp->xp_pattern = arg;
6208 return;
6209 }
6210 p = arg + STRLEN(arg) - 1;
6211 if (*p == ' ' && *(p - 1) != '\\')
6212 {
6213 xp->xp_pattern = p + 1;
6214 return;
6215 }
6216 while (p > arg)
6217 {
6218 s = p;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006219 // count number of backslashes before ' ' or ','
Bram Moolenaar071d4272004-06-13 20:20:40 +00006220 if (*p == ' ' || *p == ',')
6221 {
6222 while (s > arg && *(s - 1) == '\\')
6223 --s;
6224 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006225 // break at a space with an even number of backslashes
Bram Moolenaar071d4272004-06-13 20:20:40 +00006226 if (*p == ' ' && ((p - s) & 1) == 0)
6227 {
6228 ++p;
6229 break;
6230 }
6231 --p;
6232 }
Bram Moolenaar2a7b9ee2009-06-16 15:50:33 +00006233 if (STRNCMP(p, "no", 2) == 0 && STRNCMP(p, "novice", 6) != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006234 {
6235 xp->xp_context = EXPAND_BOOL_SETTINGS;
6236 p += 2;
6237 }
6238 if (STRNCMP(p, "inv", 3) == 0)
6239 {
6240 xp->xp_context = EXPAND_BOOL_SETTINGS;
6241 p += 3;
6242 }
6243 xp->xp_pattern = arg = p;
6244 if (*arg == '<')
6245 {
6246 while (*p != '>')
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006247 if (*p++ == NUL) // expand terminal option name
Bram Moolenaar071d4272004-06-13 20:20:40 +00006248 return;
6249 key = get_special_key_code(arg + 1);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006250 if (key == 0) // unknown name
Bram Moolenaar071d4272004-06-13 20:20:40 +00006251 {
6252 xp->xp_context = EXPAND_NOTHING;
6253 return;
6254 }
6255 nextchar = *++p;
6256 is_term_option = TRUE;
6257 expand_option_name[2] = KEY2TERMCAP0(key);
6258 expand_option_name[3] = KEY2TERMCAP1(key);
6259 }
6260 else
6261 {
6262 if (p[0] == 't' && p[1] == '_')
6263 {
6264 p += 2;
6265 if (*p != NUL)
6266 ++p;
6267 if (*p == NUL)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006268 return; // expand option name
Bram Moolenaar071d4272004-06-13 20:20:40 +00006269 nextchar = *++p;
6270 is_term_option = TRUE;
6271 expand_option_name[2] = p[-2];
6272 expand_option_name[3] = p[-1];
6273 }
6274 else
6275 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006276 // Allow * wildcard
Bram Moolenaar071d4272004-06-13 20:20:40 +00006277 while (ASCII_ISALNUM(*p) || *p == '_' || *p == '*')
6278 p++;
6279 if (*p == NUL)
6280 return;
6281 nextchar = *p;
6282 *p = NUL;
6283 opt_idx = findoption(arg);
6284 *p = nextchar;
6285 if (opt_idx == -1 || options[opt_idx].var == NULL)
6286 {
6287 xp->xp_context = EXPAND_NOTHING;
6288 return;
6289 }
6290 flags = options[opt_idx].flags;
6291 if (flags & P_BOOL)
6292 {
6293 xp->xp_context = EXPAND_NOTHING;
6294 return;
6295 }
6296 }
6297 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006298 // handle "-=" and "+="
Bram Moolenaar071d4272004-06-13 20:20:40 +00006299 if ((nextchar == '-' || nextchar == '+' || nextchar == '^') && p[1] == '=')
6300 {
6301 ++p;
6302 nextchar = '=';
6303 }
6304 if ((nextchar != '=' && nextchar != ':')
6305 || xp->xp_context == EXPAND_BOOL_SETTINGS)
6306 {
6307 xp->xp_context = EXPAND_UNSUCCESSFUL;
6308 return;
6309 }
6310 if (xp->xp_context != EXPAND_BOOL_SETTINGS && p[1] == NUL)
6311 {
6312 xp->xp_context = EXPAND_OLD_SETTING;
6313 if (is_term_option)
6314 expand_option_idx = -1;
6315 else
6316 expand_option_idx = opt_idx;
6317 xp->xp_pattern = p + 1;
6318 return;
6319 }
6320 xp->xp_context = EXPAND_NOTHING;
6321 if (is_term_option || (flags & P_NUM))
6322 return;
6323
6324 xp->xp_pattern = p + 1;
6325
6326 if (flags & P_EXPAND)
6327 {
6328 p = options[opt_idx].var;
6329 if (p == (char_u *)&p_bdir
6330 || p == (char_u *)&p_dir
6331 || p == (char_u *)&p_path
Bram Moolenaarf6fee0e2016-02-21 23:02:49 +01006332 || p == (char_u *)&p_pp
Bram Moolenaar071d4272004-06-13 20:20:40 +00006333 || p == (char_u *)&p_rtp
6334#ifdef FEAT_SEARCHPATH
6335 || p == (char_u *)&p_cdpath
6336#endif
6337#ifdef FEAT_SESSION
6338 || p == (char_u *)&p_vdir
6339#endif
6340 )
6341 {
6342 xp->xp_context = EXPAND_DIRECTORIES;
6343 if (p == (char_u *)&p_path
6344#ifdef FEAT_SEARCHPATH
6345 || p == (char_u *)&p_cdpath
6346#endif
6347 )
6348 xp->xp_backslash = XP_BS_THREE;
6349 else
6350 xp->xp_backslash = XP_BS_ONE;
6351 }
Bram Moolenaard5e8c922021-02-02 21:10:01 +01006352 else if (p == (char_u *)&p_ft)
6353 {
6354 xp->xp_context = EXPAND_FILETYPE;
6355 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006356 else
6357 {
6358 xp->xp_context = EXPAND_FILES;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006359 // for 'tags' need three backslashes for a space
Bram Moolenaar071d4272004-06-13 20:20:40 +00006360 if (p == (char_u *)&p_tags)
6361 xp->xp_backslash = XP_BS_THREE;
6362 else
6363 xp->xp_backslash = XP_BS_ONE;
6364 }
6365 }
6366
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006367 // For an option that is a list of file names, find the start of the
6368 // last file name.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006369 for (p = arg + STRLEN(arg) - 1; p > xp->xp_pattern; --p)
6370 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006371 // count number of backslashes before ' ' or ','
Bram Moolenaar071d4272004-06-13 20:20:40 +00006372 if (*p == ' ' || *p == ',')
6373 {
6374 s = p;
6375 while (s > xp->xp_pattern && *(s - 1) == '\\')
6376 --s;
6377 if ((*p == ' ' && (xp->xp_backslash == XP_BS_THREE && (p - s) < 3))
6378 || (*p == ',' && (flags & P_COMMA) && ((p - s) & 1) == 0))
6379 {
6380 xp->xp_pattern = p + 1;
6381 break;
6382 }
6383 }
Bram Moolenaar24bbcfe2005-06-28 23:32:02 +00006384
Bram Moolenaarb9a02fc2006-03-12 22:08:12 +00006385#ifdef FEAT_SPELL
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006386 // for 'spellsuggest' start at "file:"
Bram Moolenaar24bbcfe2005-06-28 23:32:02 +00006387 if (options[opt_idx].var == (char_u *)&p_sps
6388 && STRNCMP(p, "file:", 5) == 0)
6389 {
6390 xp->xp_pattern = p + 5;
6391 break;
6392 }
6393#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006394 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006395}
6396
6397 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01006398ExpandSettings(
6399 expand_T *xp,
6400 regmatch_T *regmatch,
6401 int *num_file,
6402 char_u ***file)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006403{
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006404 int num_normal = 0; // Nr of matching non-term-code settings
6405 int num_term = 0; // Nr of matching terminal code settings
Bram Moolenaar071d4272004-06-13 20:20:40 +00006406 int opt_idx;
6407 int match;
6408 int count = 0;
6409 char_u *str;
6410 int loop;
6411 int is_term_opt;
6412 char_u name_buf[MAX_KEY_NAME_LEN];
6413 static char *(names[]) = {"all", "termcap"};
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006414 int ic = regmatch->rm_ic; // remember the ignore-case flag
Bram Moolenaar071d4272004-06-13 20:20:40 +00006415
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006416 // do this loop twice:
6417 // loop == 0: count the number of matching options
6418 // loop == 1: copy the matching options into allocated memory
Bram Moolenaar071d4272004-06-13 20:20:40 +00006419 for (loop = 0; loop <= 1; ++loop)
6420 {
6421 regmatch->rm_ic = ic;
6422 if (xp->xp_context != EXPAND_BOOL_SETTINGS)
6423 {
K.Takataeeec2542021-06-02 13:28:16 +02006424 for (match = 0; match < (int)ARRAY_LENGTH(names); ++match)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006425 if (vim_regexec(regmatch, (char_u *)names[match], (colnr_T)0))
6426 {
6427 if (loop == 0)
6428 num_normal++;
6429 else
6430 (*file)[count++] = vim_strsave((char_u *)names[match]);
6431 }
6432 }
6433 for (opt_idx = 0; (str = (char_u *)options[opt_idx].fullname) != NULL;
6434 opt_idx++)
6435 {
6436 if (options[opt_idx].var == NULL)
6437 continue;
6438 if (xp->xp_context == EXPAND_BOOL_SETTINGS
6439 && !(options[opt_idx].flags & P_BOOL))
6440 continue;
Bram Moolenaardac13472019-09-16 21:06:21 +02006441 is_term_opt = istermoption_idx(opt_idx);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006442 if (is_term_opt && num_normal > 0)
6443 continue;
6444 match = FALSE;
6445 if (vim_regexec(regmatch, str, (colnr_T)0)
6446 || (options[opt_idx].shortname != NULL
6447 && vim_regexec(regmatch,
6448 (char_u *)options[opt_idx].shortname, (colnr_T)0)))
6449 match = TRUE;
6450 else if (is_term_opt)
6451 {
6452 name_buf[0] = '<';
6453 name_buf[1] = 't';
6454 name_buf[2] = '_';
6455 name_buf[3] = str[2];
6456 name_buf[4] = str[3];
6457 name_buf[5] = '>';
6458 name_buf[6] = NUL;
6459 if (vim_regexec(regmatch, name_buf, (colnr_T)0))
6460 {
6461 match = TRUE;
6462 str = name_buf;
6463 }
6464 }
6465 if (match)
6466 {
6467 if (loop == 0)
6468 {
6469 if (is_term_opt)
6470 num_term++;
6471 else
6472 num_normal++;
6473 }
6474 else
6475 (*file)[count++] = vim_strsave(str);
6476 }
6477 }
6478 /*
6479 * Check terminal key codes, these are not in the option table
6480 */
6481 if (xp->xp_context != EXPAND_BOOL_SETTINGS && num_normal == 0)
6482 {
6483 for (opt_idx = 0; (str = get_termcode(opt_idx)) != NULL; opt_idx++)
6484 {
6485 if (!isprint(str[0]) || !isprint(str[1]))
6486 continue;
6487
6488 name_buf[0] = 't';
6489 name_buf[1] = '_';
6490 name_buf[2] = str[0];
6491 name_buf[3] = str[1];
6492 name_buf[4] = NUL;
6493
6494 match = FALSE;
6495 if (vim_regexec(regmatch, name_buf, (colnr_T)0))
6496 match = TRUE;
6497 else
6498 {
6499 name_buf[0] = '<';
6500 name_buf[1] = 't';
6501 name_buf[2] = '_';
6502 name_buf[3] = str[0];
6503 name_buf[4] = str[1];
6504 name_buf[5] = '>';
6505 name_buf[6] = NUL;
6506
6507 if (vim_regexec(regmatch, name_buf, (colnr_T)0))
6508 match = TRUE;
6509 }
6510 if (match)
6511 {
6512 if (loop == 0)
6513 num_term++;
6514 else
6515 (*file)[count++] = vim_strsave(name_buf);
6516 }
6517 }
6518
6519 /*
6520 * Check special key names.
6521 */
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006522 regmatch->rm_ic = TRUE; // ignore case here
Bram Moolenaar071d4272004-06-13 20:20:40 +00006523 for (opt_idx = 0; (str = get_key_name(opt_idx)) != NULL; opt_idx++)
6524 {
6525 name_buf[0] = '<';
6526 STRCPY(name_buf + 1, str);
6527 STRCAT(name_buf, ">");
6528
6529 if (vim_regexec(regmatch, name_buf, (colnr_T)0))
6530 {
6531 if (loop == 0)
6532 num_term++;
6533 else
6534 (*file)[count++] = vim_strsave(name_buf);
6535 }
6536 }
6537 }
6538 if (loop == 0)
6539 {
6540 if (num_normal > 0)
6541 *num_file = num_normal;
6542 else if (num_term > 0)
6543 *num_file = num_term;
6544 else
6545 return OK;
Bram Moolenaarc799fe22019-05-28 23:08:19 +02006546 *file = ALLOC_MULT(char_u *, *num_file);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006547 if (*file == NULL)
6548 {
6549 *file = (char_u **)"";
6550 return FAIL;
6551 }
6552 }
6553 }
6554 return OK;
6555}
6556
6557 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01006558ExpandOldSetting(int *num_file, char_u ***file)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006559{
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006560 char_u *var = NULL; // init for GCC
Bram Moolenaar071d4272004-06-13 20:20:40 +00006561 char_u *buf;
6562
6563 *num_file = 0;
Bram Moolenaarc799fe22019-05-28 23:08:19 +02006564 *file = ALLOC_ONE(char_u *);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006565 if (*file == NULL)
6566 return FAIL;
6567
6568 /*
6569 * For a terminal key code expand_option_idx is < 0.
6570 */
6571 if (expand_option_idx < 0)
6572 {
6573 var = find_termcode(expand_option_name + 2);
6574 if (var == NULL)
6575 expand_option_idx = findoption(expand_option_name);
6576 }
6577
6578 if (expand_option_idx >= 0)
6579 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006580 // put string of option value in NameBuff
Bram Moolenaar071d4272004-06-13 20:20:40 +00006581 option_value2string(&options[expand_option_idx], expand_option_flags);
6582 var = NameBuff;
6583 }
6584 else if (var == NULL)
6585 var = (char_u *)"";
6586
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006587 // A backslash is required before some characters. This is the reverse of
6588 // what happens in do_set().
Bram Moolenaar071d4272004-06-13 20:20:40 +00006589 buf = vim_strsave_escaped(var, escape_chars);
6590
6591 if (buf == NULL)
6592 {
Bram Moolenaard23a8232018-02-10 18:45:26 +01006593 VIM_CLEAR(*file);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006594 return FAIL;
6595 }
6596
6597#ifdef BACKSLASH_IN_FILENAME
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006598 // For MS-Windows et al. we don't double backslashes at the start and
6599 // before a file name character.
Bram Moolenaar91acfff2017-03-12 19:22:36 +01006600 for (var = buf; *var != NUL; MB_PTR_ADV(var))
Bram Moolenaar071d4272004-06-13 20:20:40 +00006601 if (var[0] == '\\' && var[1] == '\\'
6602 && expand_option_idx >= 0
6603 && (options[expand_option_idx].flags & P_EXPAND)
6604 && vim_isfilec(var[2])
6605 && (var[2] != '\\' || (var == buf && var[4] != '\\')))
Bram Moolenaarc1a11ed2008-06-24 22:09:24 +00006606 STRMOVE(var, var + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006607#endif
6608
6609 *file[0] = buf;
6610 *num_file = 1;
6611 return OK;
6612}
Bram Moolenaar071d4272004-06-13 20:20:40 +00006613
6614/*
6615 * Get the value for the numeric or string option *opp in a nice format into
6616 * NameBuff[]. Must not be called with a hidden option!
6617 */
6618 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +01006619option_value2string(
6620 struct vimoption *opp,
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006621 int opt_flags) // OPT_GLOBAL and/or OPT_LOCAL
Bram Moolenaar071d4272004-06-13 20:20:40 +00006622{
6623 char_u *varp;
6624
6625 varp = get_varp_scope(opp, opt_flags);
6626
6627 if (opp->flags & P_NUM)
6628 {
6629 long wc = 0;
6630
6631 if (wc_use_keyname(varp, &wc))
6632 STRCPY(NameBuff, get_special_key_name((int)wc, 0));
6633 else if (wc != 0)
6634 STRCPY(NameBuff, transchar((int)wc));
6635 else
6636 sprintf((char *)NameBuff, "%ld", *(long *)varp);
6637 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006638 else // P_STRING
Bram Moolenaar071d4272004-06-13 20:20:40 +00006639 {
6640 varp = *(char_u **)(varp);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006641 if (varp == NULL) // just in case
Bram Moolenaar071d4272004-06-13 20:20:40 +00006642 NameBuff[0] = NUL;
6643#ifdef FEAT_CRYPT
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006644 // don't show the actual value of 'key', only that it's set
Bram Moolenaareb3593b2006-04-22 22:33:57 +00006645 else if (opp->var == (char_u *)&p_key && *varp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006646 STRCPY(NameBuff, "*****");
6647#endif
6648 else if (opp->flags & P_EXPAND)
6649 home_replace(NULL, varp, NameBuff, MAXPATHL, FALSE);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006650 // Translate 'pastetoggle' into special key names
Bram Moolenaar071d4272004-06-13 20:20:40 +00006651 else if ((char_u **)opp->var == &p_pt)
6652 str2specialbuf(p_pt, NameBuff, MAXPATHL);
6653 else
Bram Moolenaarce0842a2005-07-18 21:58:11 +00006654 vim_strncpy(NameBuff, varp, MAXPATHL - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006655 }
6656}
6657
6658/*
6659 * Return TRUE if "varp" points to 'wildchar' or 'wildcharm' and it can be
6660 * printed as a keyname.
6661 * "*wcp" is set to the value of the option if it's 'wildchar' or 'wildcharm'.
6662 */
6663 static int
Bram Moolenaar9b578142016-01-30 19:39:49 +01006664wc_use_keyname(char_u *varp, long *wcp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006665{
6666 if (((long *)varp == &p_wc) || ((long *)varp == &p_wcm))
6667 {
6668 *wcp = *(long *)varp;
6669 if (IS_SPECIAL(*wcp) || find_special_key_in_table((int)*wcp) >= 0)
6670 return TRUE;
6671 }
6672 return FALSE;
6673}
6674
Bram Moolenaar071d4272004-06-13 20:20:40 +00006675/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00006676 * Return TRUE if "x" is present in 'shortmess' option, or
6677 * 'shortmess' contains 'a' and "x" is present in SHM_A.
6678 */
6679 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01006680shortmess(int x)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006681{
Bram Moolenaar7f29f7a2012-02-29 13:51:37 +01006682 return p_shm != NULL &&
6683 ( vim_strchr(p_shm, x) != NULL
Bram Moolenaar071d4272004-06-13 20:20:40 +00006684 || (vim_strchr(p_shm, 'a') != NULL
6685 && vim_strchr((char_u *)SHM_A, x) != NULL));
6686}
6687
6688/*
6689 * paste_option_changed() - Called after p_paste was set or reset.
6690 */
6691 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +01006692paste_option_changed(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006693{
6694 static int old_p_paste = FALSE;
6695 static int save_sm = 0;
Bram Moolenaar54f018c2015-09-15 17:30:40 +02006696 static int save_sta = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006697#ifdef FEAT_CMDL_INFO
6698 static int save_ru = 0;
6699#endif
6700#ifdef FEAT_RIGHTLEFT
6701 static int save_ri = 0;
6702 static int save_hkmap = 0;
6703#endif
6704 buf_T *buf;
6705
6706 if (p_paste)
6707 {
6708 /*
6709 * Paste switched from off to on.
6710 * Save the current values, so they can be restored later.
6711 */
6712 if (!old_p_paste)
6713 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006714 // save options for each buffer
Bram Moolenaar29323592016-07-24 22:04:11 +02006715 FOR_ALL_BUFFERS(buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006716 {
6717 buf->b_p_tw_nopaste = buf->b_p_tw;
6718 buf->b_p_wm_nopaste = buf->b_p_wm;
6719 buf->b_p_sts_nopaste = buf->b_p_sts;
6720 buf->b_p_ai_nopaste = buf->b_p_ai;
Bram Moolenaar54f018c2015-09-15 17:30:40 +02006721 buf->b_p_et_nopaste = buf->b_p_et;
Bram Moolenaar04958cb2018-06-23 19:23:02 +02006722#ifdef FEAT_VARTABS
6723 if (buf->b_p_vsts_nopaste)
6724 vim_free(buf->b_p_vsts_nopaste);
6725 buf->b_p_vsts_nopaste = buf->b_p_vsts && buf->b_p_vsts != empty_option
6726 ? vim_strsave(buf->b_p_vsts) : NULL;
6727#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006728 }
6729
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006730 // save global options
Bram Moolenaar071d4272004-06-13 20:20:40 +00006731 save_sm = p_sm;
Bram Moolenaar54f018c2015-09-15 17:30:40 +02006732 save_sta = p_sta;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006733#ifdef FEAT_CMDL_INFO
6734 save_ru = p_ru;
6735#endif
6736#ifdef FEAT_RIGHTLEFT
6737 save_ri = p_ri;
6738 save_hkmap = p_hkmap;
6739#endif
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006740 // save global values for local buffer options
Bram Moolenaar54f018c2015-09-15 17:30:40 +02006741 p_ai_nopaste = p_ai;
6742 p_et_nopaste = p_et;
6743 p_sts_nopaste = p_sts;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006744 p_tw_nopaste = p_tw;
6745 p_wm_nopaste = p_wm;
Bram Moolenaar04958cb2018-06-23 19:23:02 +02006746#ifdef FEAT_VARTABS
6747 if (p_vsts_nopaste)
6748 vim_free(p_vsts_nopaste);
6749 p_vsts_nopaste = p_vsts && p_vsts != empty_option ? vim_strsave(p_vsts) : NULL;
6750#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006751 }
6752
6753 /*
6754 * Always set the option values, also when 'paste' is set when it is
6755 * already on.
6756 */
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006757 // set options for each buffer
Bram Moolenaar29323592016-07-24 22:04:11 +02006758 FOR_ALL_BUFFERS(buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006759 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006760 buf->b_p_tw = 0; // textwidth is 0
6761 buf->b_p_wm = 0; // wrapmargin is 0
6762 buf->b_p_sts = 0; // softtabstop is 0
6763 buf->b_p_ai = 0; // no auto-indent
6764 buf->b_p_et = 0; // no expandtab
Bram Moolenaar04958cb2018-06-23 19:23:02 +02006765#ifdef FEAT_VARTABS
6766 if (buf->b_p_vsts)
6767 free_string_option(buf->b_p_vsts);
6768 buf->b_p_vsts = empty_option;
6769 if (buf->b_p_vsts_array)
6770 vim_free(buf->b_p_vsts_array);
6771 buf->b_p_vsts_array = 0;
6772#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006773 }
6774
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006775 // set global options
6776 p_sm = 0; // no showmatch
6777 p_sta = 0; // no smarttab
Bram Moolenaar071d4272004-06-13 20:20:40 +00006778#ifdef FEAT_CMDL_INFO
Bram Moolenaar071d4272004-06-13 20:20:40 +00006779 if (p_ru)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006780 status_redraw_all(); // redraw to remove the ruler
6781 p_ru = 0; // no ruler
Bram Moolenaar071d4272004-06-13 20:20:40 +00006782#endif
6783#ifdef FEAT_RIGHTLEFT
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006784 p_ri = 0; // no reverse insert
6785 p_hkmap = 0; // no Hebrew keyboard
Bram Moolenaar071d4272004-06-13 20:20:40 +00006786#endif
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006787 // set global values for local buffer options
Bram Moolenaar071d4272004-06-13 20:20:40 +00006788 p_tw = 0;
6789 p_wm = 0;
6790 p_sts = 0;
6791 p_ai = 0;
Bram Moolenaar04958cb2018-06-23 19:23:02 +02006792#ifdef FEAT_VARTABS
6793 if (p_vsts)
6794 free_string_option(p_vsts);
6795 p_vsts = empty_option;
6796#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006797 }
6798
6799 /*
6800 * Paste switched from on to off: Restore saved values.
6801 */
6802 else if (old_p_paste)
6803 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006804 // restore options for each buffer
Bram Moolenaar29323592016-07-24 22:04:11 +02006805 FOR_ALL_BUFFERS(buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006806 {
6807 buf->b_p_tw = buf->b_p_tw_nopaste;
6808 buf->b_p_wm = buf->b_p_wm_nopaste;
6809 buf->b_p_sts = buf->b_p_sts_nopaste;
6810 buf->b_p_ai = buf->b_p_ai_nopaste;
Bram Moolenaar54f018c2015-09-15 17:30:40 +02006811 buf->b_p_et = buf->b_p_et_nopaste;
Bram Moolenaar04958cb2018-06-23 19:23:02 +02006812#ifdef FEAT_VARTABS
6813 if (buf->b_p_vsts)
6814 free_string_option(buf->b_p_vsts);
6815 buf->b_p_vsts = buf->b_p_vsts_nopaste
6816 ? vim_strsave(buf->b_p_vsts_nopaste) : empty_option;
6817 if (buf->b_p_vsts_array)
6818 vim_free(buf->b_p_vsts_array);
6819 if (buf->b_p_vsts && buf->b_p_vsts != empty_option)
Bram Moolenaarb7081e12021-09-04 18:47:28 +02006820 (void)tabstop_set(buf->b_p_vsts, &buf->b_p_vsts_array);
Bram Moolenaar04958cb2018-06-23 19:23:02 +02006821 else
6822 buf->b_p_vsts_array = 0;
6823#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006824 }
6825
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006826 // restore global options
Bram Moolenaar071d4272004-06-13 20:20:40 +00006827 p_sm = save_sm;
Bram Moolenaar54f018c2015-09-15 17:30:40 +02006828 p_sta = save_sta;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006829#ifdef FEAT_CMDL_INFO
Bram Moolenaar071d4272004-06-13 20:20:40 +00006830 if (p_ru != save_ru)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006831 status_redraw_all(); // redraw to draw the ruler
Bram Moolenaar071d4272004-06-13 20:20:40 +00006832 p_ru = save_ru;
6833#endif
6834#ifdef FEAT_RIGHTLEFT
6835 p_ri = save_ri;
6836 p_hkmap = save_hkmap;
6837#endif
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006838 // set global values for local buffer options
Bram Moolenaar54f018c2015-09-15 17:30:40 +02006839 p_ai = p_ai_nopaste;
6840 p_et = p_et_nopaste;
6841 p_sts = p_sts_nopaste;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006842 p_tw = p_tw_nopaste;
6843 p_wm = p_wm_nopaste;
Bram Moolenaar04958cb2018-06-23 19:23:02 +02006844#ifdef FEAT_VARTABS
6845 if (p_vsts)
6846 free_string_option(p_vsts);
6847 p_vsts = p_vsts_nopaste ? vim_strsave(p_vsts_nopaste) : empty_option;
6848#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006849 }
6850
6851 old_p_paste = p_paste;
6852}
6853
6854/*
6855 * vimrc_found() - Called when a ".vimrc" or "VIMINIT" has been found.
6856 *
6857 * Reset 'compatible' and set the values for options that didn't get set yet
6858 * to the Vim defaults.
6859 * Don't do this if the 'compatible' option has been set or reset before.
Bram Moolenaar910f66f2006-04-05 20:41:53 +00006860 * When "fname" is not NULL, use it to set $"envname" when it wasn't set yet.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006861 */
6862 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01006863vimrc_found(char_u *fname, char_u *envname)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006864{
Bram Moolenaar910f66f2006-04-05 20:41:53 +00006865 int opt_idx;
Bram Moolenaar4c3f5362006-04-11 21:38:50 +00006866 int dofree = FALSE;
Bram Moolenaar910f66f2006-04-05 20:41:53 +00006867 char_u *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006868
6869 if (!option_was_set((char_u *)"cp"))
6870 {
6871 p_cp = FALSE;
Bram Moolenaardac13472019-09-16 21:06:21 +02006872 for (opt_idx = 0; !istermoption_idx(opt_idx); opt_idx++)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006873 if (!(options[opt_idx].flags & (P_WAS_SET|P_VI_DEF)))
6874 set_option_default(opt_idx, OPT_FREE, FALSE);
6875 didset_options();
Bram Moolenaare68c25c2015-08-25 15:39:55 +02006876 didset_options2();
Bram Moolenaar071d4272004-06-13 20:20:40 +00006877 }
Bram Moolenaar910f66f2006-04-05 20:41:53 +00006878
6879 if (fname != NULL)
6880 {
6881 p = vim_getenv(envname, &dofree);
6882 if (p == NULL)
6883 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006884 // Set $MYVIMRC to the first vimrc file found.
Bram Moolenaar910f66f2006-04-05 20:41:53 +00006885 p = FullName_save(fname, FALSE);
6886 if (p != NULL)
6887 {
6888 vim_setenv(envname, p);
6889 vim_free(p);
6890 }
6891 }
6892 else if (dofree)
6893 vim_free(p);
6894 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006895}
6896
6897/*
6898 * Set 'compatible' on or off. Called for "-C" and "-N" command line arg.
6899 */
6900 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01006901change_compatible(int on)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006902{
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00006903 int opt_idx;
6904
Bram Moolenaar071d4272004-06-13 20:20:40 +00006905 if (p_cp != on)
6906 {
6907 p_cp = on;
6908 compatible_set();
6909 }
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00006910 opt_idx = findoption((char_u *)"cp");
6911 if (opt_idx >= 0)
6912 options[opt_idx].flags |= P_WAS_SET;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006913}
6914
6915/*
6916 * Return TRUE when option "name" has been set.
Bram Moolenaar1a4a75c2013-07-28 16:03:06 +02006917 * Only works correctly for global options.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006918 */
6919 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01006920option_was_set(char_u *name)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006921{
6922 int idx;
6923
6924 idx = findoption(name);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01006925 if (idx < 0) // unknown option
Bram Moolenaar071d4272004-06-13 20:20:40 +00006926 return FALSE;
6927 if (options[idx].flags & P_WAS_SET)
6928 return TRUE;
6929 return FALSE;
6930}
6931
6932/*
Bram Moolenaar15d55de2012-12-05 14:43:02 +01006933 * Reset the flag indicating option "name" was set.
6934 */
Bram Moolenaarfe8ef982018-09-13 20:31:54 +02006935 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01006936reset_option_was_set(char_u *name)
Bram Moolenaar15d55de2012-12-05 14:43:02 +01006937{
6938 int idx = findoption(name);
6939
6940 if (idx >= 0)
Bram Moolenaarfe8ef982018-09-13 20:31:54 +02006941 {
Bram Moolenaar15d55de2012-12-05 14:43:02 +01006942 options[idx].flags &= ~P_WAS_SET;
Bram Moolenaarfe8ef982018-09-13 20:31:54 +02006943 return OK;
6944 }
6945 return FAIL;
Bram Moolenaar15d55de2012-12-05 14:43:02 +01006946}
6947
6948/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00006949 * compatible_set() - Called when 'compatible' has been set or unset.
6950 *
6951 * When 'compatible' set: Set all relevant options (those that have the P_VIM)
6952 * flag) to a Vi compatible value.
6953 * When 'compatible' is unset: Set all options that have a different default
6954 * for Vim (without the P_VI_DEF flag) to that default.
6955 */
6956 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +01006957compatible_set(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006958{
6959 int opt_idx;
6960
Bram Moolenaardac13472019-09-16 21:06:21 +02006961 for (opt_idx = 0; !istermoption_idx(opt_idx); opt_idx++)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006962 if ( ((options[opt_idx].flags & P_VIM) && p_cp)
6963 || (!(options[opt_idx].flags & P_VI_DEF) && !p_cp))
6964 set_option_default(opt_idx, OPT_FREE, p_cp);
6965 didset_options();
Bram Moolenaare68c25c2015-08-25 15:39:55 +02006966 didset_options2();
Bram Moolenaar071d4272004-06-13 20:20:40 +00006967}
6968
Bram Moolenaardac13472019-09-16 21:06:21 +02006969#if defined(FEAT_LINEBREAK) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006970
Bram Moolenaar071d4272004-06-13 20:20:40 +00006971/*
6972 * fill_breakat_flags() -- called when 'breakat' changes value.
6973 */
Bram Moolenaardac13472019-09-16 21:06:21 +02006974 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01006975fill_breakat_flags(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006976{
Bram Moolenaarac6e65f2005-08-29 22:25:38 +00006977 char_u *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006978 int i;
6979
6980 for (i = 0; i < 256; i++)
6981 breakat_flags[i] = FALSE;
6982
6983 if (p_breakat != NULL)
Bram Moolenaarac6e65f2005-08-29 22:25:38 +00006984 for (p = p_breakat; *p; p++)
6985 breakat_flags[*p] = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006986}
Bram Moolenaar071d4272004-06-13 20:20:40 +00006987#endif
6988
6989/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00006990 * Check if backspacing over something is allowed.
6991 */
6992 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01006993can_bs(
Bram Moolenaaraa0489e2020-04-17 19:41:21 +02006994 int what) // BS_INDENT, BS_EOL, BS_START or BS_NOSTOP
Bram Moolenaar071d4272004-06-13 20:20:40 +00006995{
Bram Moolenaar6b810d92018-06-04 17:28:44 +02006996#ifdef FEAT_JOB_CHANNEL
6997 if (what == BS_START && bt_prompt(curbuf))
6998 return FALSE;
6999#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007000 switch (*p_bs)
7001 {
Bram Moolenaaraa0489e2020-04-17 19:41:21 +02007002 case '3': return TRUE;
7003 case '2': return (what != BS_NOSTOP);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007004 case '1': return (what != BS_START);
7005 case '0': return FALSE;
7006 }
7007 return vim_strchr(p_bs, what) != NULL;
7008}
7009
7010/*
Bram Moolenaar375e3392019-01-31 18:26:10 +01007011 * Return the effective 'scrolloff' value for the current window, using the
7012 * global value when appropriate.
7013 */
7014 long
7015get_scrolloff_value(void)
7016{
7017 return curwin->w_p_so < 0 ? p_so : curwin->w_p_so;
7018}
7019
7020/*
7021 * Return the effective 'sidescrolloff' value for the current window, using the
7022 * global value when appropriate.
7023 */
7024 long
7025get_sidescrolloff_value(void)
7026{
7027 return curwin->w_p_siso < 0 ? p_siso : curwin->w_p_siso;
7028}
7029
7030/*
Bram Moolenaarb8ee25a2014-09-23 15:45:08 +02007031 * Get the local or global value of 'backupcopy'.
7032 */
7033 unsigned int
Bram Moolenaar9b578142016-01-30 19:39:49 +01007034get_bkc_value(buf_T *buf)
Bram Moolenaarb8ee25a2014-09-23 15:45:08 +02007035{
7036 return buf->b_bkc_flags ? buf->b_bkc_flags : bkc_flags;
7037}
Bram Moolenaar95ec9d62016-08-12 18:29:59 +02007038
Gary Johnson53ba05b2021-07-26 22:19:10 +02007039/*
7040 * Get the local or global value of the 'virtualedit' flags.
7041 */
7042 unsigned int
7043get_ve_flags(void)
7044{
Gary Johnson51ad8502021-08-03 18:33:08 +02007045 return (curwin->w_ve_flags ? curwin->w_ve_flags : ve_flags)
7046 & ~(VE_NONE | VE_NONEU);
Gary Johnson53ba05b2021-07-26 22:19:10 +02007047}
7048
Bram Moolenaaree857022019-11-09 23:26:40 +01007049#if defined(FEAT_LINEBREAK) || defined(PROTO)
7050/*
7051 * Get the local or global value of 'showbreak'.
7052 */
7053 char_u *
7054get_showbreak_value(win_T *win)
7055{
7056 if (win->w_p_sbr == NULL || *win->w_p_sbr == NUL)
7057 return p_sbr;
7058 if (STRCMP(win->w_p_sbr, "NONE") == 0)
7059 return empty_option;
7060 return win->w_p_sbr;
7061}
7062#endif
7063
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02007064#if defined(FEAT_EVAL) || defined(PROTO)
7065/*
7066 * Get window or buffer local options.
7067 */
7068 dict_T *
7069get_winbuf_options(int bufopt)
7070{
7071 dict_T *d;
7072 int opt_idx;
7073
7074 d = dict_alloc();
7075 if (d == NULL)
7076 return NULL;
7077
Bram Moolenaardac13472019-09-16 21:06:21 +02007078 for (opt_idx = 0; !istermoption_idx(opt_idx); opt_idx++)
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02007079 {
7080 struct vimoption *opt = &options[opt_idx];
7081
7082 if ((bufopt && (opt->indir & PV_BUF))
7083 || (!bufopt && (opt->indir & PV_WIN)))
7084 {
7085 char_u *varp = get_varp(opt);
7086
7087 if (varp != NULL)
7088 {
7089 if (opt->flags & P_STRING)
Bram Moolenaare0be1672018-07-08 16:50:37 +02007090 dict_add_string(d, opt->fullname, *(char_u **)varp);
Bram Moolenaar789a5c02016-09-12 19:51:11 +02007091 else if (opt->flags & P_NUM)
Bram Moolenaare0be1672018-07-08 16:50:37 +02007092 dict_add_number(d, opt->fullname, *(long *)varp);
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02007093 else
Bram Moolenaare0be1672018-07-08 16:50:37 +02007094 dict_add_number(d, opt->fullname, *(int *)varp);
Bram Moolenaarb5ae48e2016-08-12 22:23:25 +02007095 }
7096 }
7097 }
7098
7099 return d;
7100}
7101#endif
Bram Moolenaar017ba072019-09-14 21:01:23 +02007102
Bram Moolenaardac13472019-09-16 21:06:21 +02007103#if defined(FEAT_SYN_HL) || defined(PROTO)
Bram Moolenaar017ba072019-09-14 21:01:23 +02007104/*
7105 * This is called when 'culopt' is changed
7106 */
Bram Moolenaardac13472019-09-16 21:06:21 +02007107 int
Bram Moolenaar017ba072019-09-14 21:01:23 +02007108fill_culopt_flags(char_u *val, win_T *wp)
7109{
7110 char_u *p;
7111 char_u culopt_flags_new = 0;
7112
7113 if (val == NULL)
7114 p = wp->w_p_culopt;
7115 else
7116 p = val;
7117 while (*p != NUL)
7118 {
7119 if (STRNCMP(p, "line", 4) == 0)
7120 {
7121 p += 4;
7122 culopt_flags_new |= CULOPT_LINE;
7123 }
7124 else if (STRNCMP(p, "both", 4) == 0)
7125 {
7126 p += 4;
7127 culopt_flags_new |= CULOPT_LINE | CULOPT_NBR;
7128 }
7129 else if (STRNCMP(p, "number", 6) == 0)
7130 {
7131 p += 6;
7132 culopt_flags_new |= CULOPT_NBR;
7133 }
7134 else if (STRNCMP(p, "screenline", 10) == 0)
7135 {
7136 p += 10;
7137 culopt_flags_new |= CULOPT_SCRLINE;
7138 }
7139
7140 if (*p != ',' && *p != NUL)
7141 return FAIL;
7142 if (*p == ',')
7143 ++p;
7144 }
7145
7146 // Can't have both "line" and "screenline".
7147 if ((culopt_flags_new & CULOPT_LINE) && (culopt_flags_new & CULOPT_SCRLINE))
7148 return FAIL;
7149 wp->w_p_culopt_flags = culopt_flags_new;
7150
7151 return OK;
7152}
7153#endif
Bram Moolenaarf4e20992020-12-21 19:59:08 +01007154
7155/*
7156 * Get the value of 'magic' adjusted for Vim9 script.
7157 */
7158 int
7159magic_isset(void)
7160{
7161 switch (magic_overruled)
7162 {
Bram Moolenaard93a7fc2021-01-04 12:42:13 +01007163 case OPTION_MAGIC_ON: return TRUE;
7164 case OPTION_MAGIC_OFF: return FALSE;
7165 case OPTION_MAGIC_NOT_SET: break;
Bram Moolenaarf4e20992020-12-21 19:59:08 +01007166 }
7167#ifdef FEAT_EVAL
7168 if (in_vim9script())
7169 return TRUE;
7170#endif
7171 return p_magic;
7172}
Yegappan Lakshmanan777175b2021-11-18 22:08:57 +00007173
7174/*
7175 * Set the callback function value for an option that accepts a function name,
7176 * lambda, et al. (e.g. 'operatorfunc', 'tagfunc', etc.)
7177 * Returns OK if the option is successfully set to a function, otherwise
7178 * returns FAIL.
7179 */
7180 int
7181option_set_callback_func(char_u *optval UNUSED, callback_T *optcb UNUSED)
7182{
7183#ifdef FEAT_EVAL
7184 typval_T *tv;
7185 callback_T cb;
7186
7187 if (optval == NULL || *optval == NUL)
7188 {
7189 free_callback(optcb);
7190 return OK;
7191 }
7192
Yegappan Lakshmanan05e59e32021-12-01 10:30:07 +00007193 if (*optval == '{' || (in_vim9script() && *optval == '(')
Yegappan Lakshmanan777175b2021-11-18 22:08:57 +00007194 || (STRNCMP(optval, "function(", 9) == 0)
7195 || (STRNCMP(optval, "funcref(", 8) == 0))
7196 // Lambda expression or a funcref
7197 tv = eval_expr(optval, NULL);
7198 else
7199 // treat everything else as a function name string
7200 tv = alloc_string_tv(vim_strsave(optval));
7201 if (tv == NULL)
7202 return FAIL;
7203
7204 cb = get_callback(tv);
7205 if (cb.cb_name == NULL)
7206 {
7207 free_tv(tv);
7208 return FAIL;
7209 }
7210
7211 free_callback(optcb);
7212 set_callback(optcb, &cb);
7213 free_tv(tv);
7214 return OK;
7215#else
7216 return FAIL;
7217#endif
7218}