blob: 1f9a7f2173b45f79900956982d80ee9968fc360e [file] [log] [blame]
Bram Moolenaar071d4272004-06-13 20:20:40 +00001/* vi:set ts=8 sts=4 sw=4:
2 *
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 * ex_cmds.c: some functions for command line commands
12 */
13
Bram Moolenaarc236c162008-07-13 17:41:49 +000014#if defined(MSDOS) || defined(WIN16) || defined(WIN32) || defined(_WIN64)
Bram Moolenaar8c8de832008-06-24 22:58:06 +000015# include "vimio.h" /* for mch_open(), must be before vim.h */
Bram Moolenaara5792f52005-11-23 21:25:05 +000016#endif
Bram Moolenaar8c8de832008-06-24 22:58:06 +000017
18#include "vim.h"
Bram Moolenaar071d4272004-06-13 20:20:40 +000019#include "version.h"
20
21#ifdef FEAT_EX_EXTRA
22static int linelen __ARGS((int *has_tab));
23#endif
24static void do_filter __ARGS((linenr_T line1, linenr_T line2, exarg_T *eap, char_u *cmd, int do_in, int do_out));
25#ifdef FEAT_VIMINFO
26static char_u *viminfo_filename __ARGS((char_u *));
Bram Moolenaard812df62008-11-09 12:46:09 +000027static void do_viminfo __ARGS((FILE *fp_in, FILE *fp_out, int flags));
Bram Moolenaar071d4272004-06-13 20:20:40 +000028static int viminfo_encoding __ARGS((vir_T *virp));
29static int read_viminfo_up_to_marks __ARGS((vir_T *virp, int forceit, int writing));
30#endif
31
32static int check_overwrite __ARGS((exarg_T *eap, buf_T *buf, char_u *fname, char_u *ffname, int other));
33static int check_readonly __ARGS((int *forceit, buf_T *buf));
34#ifdef FEAT_AUTOCMD
35static void delbuf_msg __ARGS((char_u *name));
36#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +000037static int
38#ifdef __BORLANDC__
39 _RTLENTRYF
40#endif
41 help_compare __ARGS((const void *s1, const void *s2));
42
43/*
44 * ":ascii" and "ga".
45 */
Bram Moolenaar071d4272004-06-13 20:20:40 +000046 void
47do_ascii(eap)
Bram Moolenaar0c094b92009-05-14 20:20:33 +000048 exarg_T *eap UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +000049{
50 int c;
Bram Moolenaar1418a0d2009-01-13 15:58:01 +000051 int cval;
Bram Moolenaar071d4272004-06-13 20:20:40 +000052 char buf1[20];
53 char buf2[20];
54 char_u buf3[7];
55#ifdef FEAT_MBYTE
Bram Moolenaar362e1a32006-03-06 23:29:24 +000056 int cc[MAX_MCO];
57 int ci = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +000058 int len;
59
60 if (enc_utf8)
Bram Moolenaar362e1a32006-03-06 23:29:24 +000061 c = utfc_ptr2char(ml_get_cursor(), cc);
Bram Moolenaar071d4272004-06-13 20:20:40 +000062 else
63#endif
64 c = gchar_cursor();
65 if (c == NUL)
66 {
67 MSG("NUL");
68 return;
69 }
70
71#ifdef FEAT_MBYTE
72 IObuff[0] = NUL;
73 if (!has_mbyte || (enc_dbcs != 0 && c < 0x100) || c < 0x80)
74#endif
75 {
76 if (c == NL) /* NUL is stored as NL */
77 c = NUL;
Bram Moolenaar1418a0d2009-01-13 15:58:01 +000078 if (c == CAR && get_fileformat(curbuf) == EOL_MAC)
79 cval = NL; /* NL is stored as CR */
80 else
81 cval = c;
Bram Moolenaar071d4272004-06-13 20:20:40 +000082 if (vim_isprintc_strict(c) && (c < ' '
83#ifndef EBCDIC
84 || c > '~'
85#endif
86 ))
87 {
88 transchar_nonprint(buf3, c);
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +000089 vim_snprintf(buf1, sizeof(buf1), " <%s>", (char *)buf3);
Bram Moolenaar071d4272004-06-13 20:20:40 +000090 }
91 else
92 buf1[0] = NUL;
93#ifndef EBCDIC
94 if (c >= 0x80)
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +000095 vim_snprintf(buf2, sizeof(buf2), " <M-%s>",
96 (char *)transchar(c & 0x7f));
Bram Moolenaar071d4272004-06-13 20:20:40 +000097 else
98#endif
99 buf2[0] = NUL;
Bram Moolenaar555b2802005-05-19 21:08:39 +0000100 vim_snprintf((char *)IObuff, IOSIZE,
101 _("<%s>%s%s %d, Hex %02x, Octal %03o"),
Bram Moolenaar1418a0d2009-01-13 15:58:01 +0000102 transchar(c), buf1, buf2, cval, cval, cval);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000103#ifdef FEAT_MBYTE
Bram Moolenaar1f788e72006-09-05 16:30:40 +0000104 if (enc_utf8)
105 c = cc[ci++];
106 else
107 c = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000108#endif
109 }
110
111#ifdef FEAT_MBYTE
112 /* Repeat for combining characters. */
113 while (has_mbyte && (c >= 0x100 || (enc_utf8 && c >= 0x80)))
114 {
115 len = (int)STRLEN(IObuff);
116 /* This assumes every multi-byte char is printable... */
117 if (len > 0)
118 IObuff[len++] = ' ';
119 IObuff[len++] = '<';
Bram Moolenaar1f788e72006-09-05 16:30:40 +0000120 if (enc_utf8 && utf_iscomposing(c)
Bram Moolenaar4770d092006-01-12 23:22:24 +0000121# ifdef USE_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +0000122 && !gui.in_use
Bram Moolenaar4770d092006-01-12 23:22:24 +0000123# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000124 )
125 IObuff[len++] = ' '; /* draw composing char on top of a space */
Bram Moolenaar555b2802005-05-19 21:08:39 +0000126 len += (*mb_char2bytes)(c, IObuff + len);
127 vim_snprintf((char *)IObuff + len, IOSIZE - len,
Bram Moolenaar071d4272004-06-13 20:20:40 +0000128 c < 0x10000 ? _("> %d, Hex %04x, Octal %o")
129 : _("> %d, Hex %08x, Octal %o"), c, c, c);
Bram Moolenaar362e1a32006-03-06 23:29:24 +0000130 if (ci == MAX_MCO)
131 break;
Bram Moolenaar1f788e72006-09-05 16:30:40 +0000132 if (enc_utf8)
133 c = cc[ci++];
134 else
135 c = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000136 }
137#endif
138
139 msg(IObuff);
140}
141
142#if defined(FEAT_EX_EXTRA) || defined(PROTO)
143/*
144 * ":left", ":center" and ":right": align text.
145 */
146 void
147ex_align(eap)
148 exarg_T *eap;
149{
150 pos_T save_curpos;
151 int len;
152 int indent = 0;
153 int new_indent;
154 int has_tab;
155 int width;
156
157#ifdef FEAT_RIGHTLEFT
158 if (curwin->w_p_rl)
159 {
160 /* switch left and right aligning */
161 if (eap->cmdidx == CMD_right)
162 eap->cmdidx = CMD_left;
163 else if (eap->cmdidx == CMD_left)
164 eap->cmdidx = CMD_right;
165 }
166#endif
167
168 width = atoi((char *)eap->arg);
169 save_curpos = curwin->w_cursor;
170 if (eap->cmdidx == CMD_left) /* width is used for new indent */
171 {
172 if (width >= 0)
173 indent = width;
174 }
175 else
176 {
177 /*
178 * if 'textwidth' set, use it
179 * else if 'wrapmargin' set, use it
180 * if invalid value, use 80
181 */
182 if (width <= 0)
183 width = curbuf->b_p_tw;
184 if (width == 0 && curbuf->b_p_wm > 0)
185 width = W_WIDTH(curwin) - curbuf->b_p_wm;
186 if (width <= 0)
187 width = 80;
188 }
189
190 if (u_save((linenr_T)(eap->line1 - 1), (linenr_T)(eap->line2 + 1)) == FAIL)
191 return;
192
193 for (curwin->w_cursor.lnum = eap->line1;
194 curwin->w_cursor.lnum <= eap->line2; ++curwin->w_cursor.lnum)
195 {
196 if (eap->cmdidx == CMD_left) /* left align */
197 new_indent = indent;
198 else
199 {
Bram Moolenaar89d40322006-08-29 15:30:07 +0000200 has_tab = FALSE; /* avoid uninit warnings */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000201 len = linelen(eap->cmdidx == CMD_right ? &has_tab
202 : NULL) - get_indent();
203
204 if (len <= 0) /* skip blank lines */
205 continue;
206
207 if (eap->cmdidx == CMD_center)
208 new_indent = (width - len) / 2;
209 else
210 {
211 new_indent = width - len; /* right align */
212
213 /*
214 * Make sure that embedded TABs don't make the text go too far
215 * to the right.
216 */
217 if (has_tab)
218 while (new_indent > 0)
219 {
220 (void)set_indent(new_indent, 0);
221 if (linelen(NULL) <= width)
222 {
223 /*
224 * Now try to move the line as much as possible to
225 * the right. Stop when it moves too far.
226 */
227 do
228 (void)set_indent(++new_indent, 0);
229 while (linelen(NULL) <= width);
230 --new_indent;
231 break;
232 }
233 --new_indent;
234 }
235 }
236 }
237 if (new_indent < 0)
238 new_indent = 0;
239 (void)set_indent(new_indent, 0); /* set indent */
240 }
241 changed_lines(eap->line1, 0, eap->line2 + 1, 0L);
242 curwin->w_cursor = save_curpos;
243 beginline(BL_WHITE | BL_FIX);
244}
245
246/*
247 * Get the length of the current line, excluding trailing white space.
248 */
249 static int
250linelen(has_tab)
251 int *has_tab;
252{
253 char_u *line;
254 char_u *first;
255 char_u *last;
256 int save;
257 int len;
258
259 /* find the first non-blank character */
260 line = ml_get_curline();
261 first = skipwhite(line);
262
263 /* find the character after the last non-blank character */
264 for (last = first + STRLEN(first);
265 last > first && vim_iswhite(last[-1]); --last)
266 ;
267 save = *last;
268 *last = NUL;
269 len = linetabsize(line); /* get line length */
270 if (has_tab != NULL) /* check for embedded TAB */
271 *has_tab = (vim_strrchr(first, TAB) != NULL);
272 *last = save;
273
274 return len;
275}
276
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000277/* Buffer for two lines used during sorting. They are allocated to
278 * contain the longest line being sorted. */
279static char_u *sortbuf1;
280static char_u *sortbuf2;
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000281
282static int sort_ic; /* ignore case */
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000283static int sort_nr; /* sort on number */
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000284static int sort_rx; /* sort on regex instead of skipping it */
285
286static int sort_abort; /* flag to indicate if sorting has been interrupted */
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000287
288/* Struct to store info to be sorted. */
289typedef struct
290{
291 linenr_T lnum; /* line number */
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000292 long start_col_nr; /* starting column number or number */
293 long end_col_nr; /* ending column number */
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000294} sorti_T;
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000295
296static int
297#ifdef __BORLANDC__
298_RTLENTRYF
299#endif
300sort_compare __ARGS((const void *s1, const void *s2));
301
302 static int
303#ifdef __BORLANDC__
304_RTLENTRYF
305#endif
306sort_compare(s1, s2)
307 const void *s1;
308 const void *s2;
309{
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000310 sorti_T l1 = *(sorti_T *)s1;
311 sorti_T l2 = *(sorti_T *)s2;
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000312 int result = 0;
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000313
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000314 /* If the user interrupts, there's no way to stop qsort() immediately, but
Bram Moolenaarb21e5842006-04-16 18:30:08 +0000315 * if we return 0 every time, qsort will assume it's done sorting and
316 * exit. */
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000317 if (sort_abort)
318 return 0;
319 fast_breakcheck();
320 if (got_int)
321 sort_abort = TRUE;
322
Bram Moolenaarb21e5842006-04-16 18:30:08 +0000323 /* When sorting numbers "start_col_nr" is the number, not the column
324 * number. */
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000325 if (sort_nr)
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000326 result = l1.start_col_nr - l2.start_col_nr;
327 else
328 {
Bram Moolenaarb21e5842006-04-16 18:30:08 +0000329 /* We need to copy one line into "sortbuf1", because there is no
330 * guarantee that the first pointer becomes invalid when obtaining the
331 * second one. */
332 STRNCPY(sortbuf1, ml_get(l1.lnum) + l1.start_col_nr,
333 l1.end_col_nr - l1.start_col_nr + 1);
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000334 sortbuf1[l1.end_col_nr - l1.start_col_nr] = 0;
Bram Moolenaarb21e5842006-04-16 18:30:08 +0000335 STRNCPY(sortbuf2, ml_get(l2.lnum) + l2.start_col_nr,
336 l2.end_col_nr - l2.start_col_nr + 1);
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000337 sortbuf2[l2.end_col_nr - l2.start_col_nr] = 0;
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000338
Bram Moolenaarb21e5842006-04-16 18:30:08 +0000339 result = sort_ic ? STRICMP(sortbuf1, sortbuf2)
340 : STRCMP(sortbuf1, sortbuf2);
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000341 }
Bram Moolenaarb21e5842006-04-16 18:30:08 +0000342
343 /* If two lines have the same value, preserve the original line order. */
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000344 if (result == 0)
Bram Moolenaarb21e5842006-04-16 18:30:08 +0000345 return (int)(l1.lnum - l2.lnum);
346 return result;
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000347}
348
349/*
350 * ":sort".
351 */
352 void
353ex_sort(eap)
354 exarg_T *eap;
355{
356 regmatch_T regmatch;
357 int len;
358 linenr_T lnum;
359 long maxlen = 0;
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000360 sorti_T *nrs;
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +0000361 size_t count = (size_t)(eap->line2 - eap->line1 + 1);
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000362 size_t i;
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000363 char_u *p;
364 char_u *s;
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000365 char_u *s2;
366 char_u c; /* temporary character storage */
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000367 int unique = FALSE;
368 long deleted;
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000369 colnr_T start_col;
370 colnr_T end_col;
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000371 int sort_oct; /* sort on octal number */
372 int sort_hex; /* sort on hex number */
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000373
Bram Moolenaar48c99162008-02-18 18:42:52 +0000374 /* Sorting one line is really quick! */
375 if (count <= 1)
376 return;
377
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000378 if (u_save((linenr_T)(eap->line1 - 1), (linenr_T)(eap->line2 + 1)) == FAIL)
379 return;
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000380 sortbuf1 = NULL;
381 sortbuf2 = NULL;
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000382 regmatch.regprog = NULL;
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000383 nrs = (sorti_T *)lalloc((long_u)(count * sizeof(sorti_T)), TRUE);
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000384 if (nrs == NULL)
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000385 goto sortend;
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000386
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000387 sort_abort = sort_ic = sort_rx = sort_nr = sort_oct = sort_hex = 0;
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000388
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000389 for (p = eap->arg; *p != NUL; ++p)
390 {
391 if (vim_iswhite(*p))
392 ;
393 else if (*p == 'i')
394 sort_ic = TRUE;
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000395 else if (*p == 'r')
396 sort_rx = TRUE;
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000397 else if (*p == 'n')
398 sort_nr = 2;
399 else if (*p == 'o')
400 sort_oct = 2;
401 else if (*p == 'x')
402 sort_hex = 2;
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000403 else if (*p == 'u')
404 unique = TRUE;
Bram Moolenaar0e6830e2005-05-27 20:23:44 +0000405 else if (*p == '"') /* comment start */
406 break;
407 else if (check_nextcmd(p) != NULL)
408 {
409 eap->nextcmd = check_nextcmd(p);
410 break;
411 }
412 else if (!ASCII_ISALPHA(*p) && regmatch.regprog == NULL)
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000413 {
414 s = skip_regexp(p + 1, *p, TRUE, NULL);
415 if (*s != *p)
416 {
417 EMSG(_(e_invalpat));
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000418 goto sortend;
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000419 }
420 *s = NUL;
Bram Moolenaar1256e722007-07-10 15:26:20 +0000421 /* Use last search pattern if sort pattern is empty. */
422 if (s == p + 1 && last_search_pat() != NULL)
423 regmatch.regprog = vim_regcomp(last_search_pat(), RE_MAGIC);
424 else
425 regmatch.regprog = vim_regcomp(p + 1, RE_MAGIC);
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000426 if (regmatch.regprog == NULL)
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000427 goto sortend;
Bram Moolenaar0e6830e2005-05-27 20:23:44 +0000428 p = s; /* continue after the regexp */
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000429 regmatch.rm_ic = p_ic;
430 }
431 else
432 {
433 EMSG2(_(e_invarg2), p);
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000434 goto sortend;
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000435 }
436 }
437
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000438 /* Can only have one of 'n', 'o' and 'x'. */
439 if (sort_nr + sort_oct + sort_hex > 2)
440 {
441 EMSG(_(e_invarg));
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000442 goto sortend;
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000443 }
444
445 /* From here on "sort_nr" is used as a flag for any number sorting. */
446 sort_nr += sort_oct + sort_hex;
447
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000448 /*
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000449 * Make an array with all line numbers. This avoids having to copy all
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000450 * the lines into allocated memory.
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000451 * When sorting on strings "start_col_nr" is the offset in the line, for
452 * numbers sorting it's the number to sort on. This means the pattern
453 * matching and number conversion only has to be done once per line.
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000454 * Also get the longest line length for allocating "sortbuf".
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000455 */
456 for (lnum = eap->line1; lnum <= eap->line2; ++lnum)
457 {
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000458 s = ml_get(lnum);
Bram Moolenaara93fa7e2006-04-17 22:14:47 +0000459 len = (int)STRLEN(s);
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000460 if (maxlen < len)
461 maxlen = len;
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000462
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000463 start_col = 0;
464 end_col = len;
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000465 if (regmatch.regprog != NULL && vim_regexec(&regmatch, s, 0))
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000466 {
467 if (sort_rx)
468 {
Bram Moolenaara93fa7e2006-04-17 22:14:47 +0000469 start_col = (colnr_T)(regmatch.startp[0] - s);
470 end_col = (colnr_T)(regmatch.endp[0] - s);
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000471 }
472 else
Bram Moolenaara93fa7e2006-04-17 22:14:47 +0000473 start_col = (colnr_T)(regmatch.endp[0] - s);
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000474 }
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000475 else
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000476 if (regmatch.regprog != NULL)
477 end_col = 0;
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000478
479 if (sort_nr)
480 {
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000481 /* Make sure vim_str2nr doesn't read any digits past the end
482 * of the match, by temporarily terminating the string there */
483 s2 = s + end_col;
484 c = *s2;
485 (*s2) = 0;
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000486 /* Sorting on number: Store the number itself. */
Bram Moolenaar1387a602008-07-24 19:31:11 +0000487 p = s + start_col;
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000488 if (sort_hex)
Bram Moolenaar1387a602008-07-24 19:31:11 +0000489 s = skiptohex(p);
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000490 else
Bram Moolenaar1387a602008-07-24 19:31:11 +0000491 s = skiptodigit(p);
492 if (s > p && s[-1] == '-')
493 --s; /* include preceding negative sign */
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000494 vim_str2nr(s, NULL, NULL, sort_oct, sort_hex,
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000495 &nrs[lnum - eap->line1].start_col_nr, NULL);
496 (*s2) = c;
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000497 }
498 else
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000499 {
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000500 /* Store the column to sort at. */
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000501 nrs[lnum - eap->line1].start_col_nr = start_col;
502 nrs[lnum - eap->line1].end_col_nr = end_col;
503 }
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000504
505 nrs[lnum - eap->line1].lnum = lnum;
Bram Moolenaarae5bce12005-08-15 21:41:48 +0000506
507 if (regmatch.regprog != NULL)
508 fast_breakcheck();
509 if (got_int)
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000510 goto sortend;
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000511 }
512
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000513 /* Allocate a buffer that can hold the longest line. */
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000514 sortbuf1 = alloc((unsigned)maxlen + 1);
515 if (sortbuf1 == NULL)
516 goto sortend;
517 sortbuf2 = alloc((unsigned)maxlen + 1);
518 if (sortbuf2 == NULL)
519 goto sortend;
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000520
Bram Moolenaarae5bce12005-08-15 21:41:48 +0000521 /* Sort the array of line numbers. Note: can't be interrupted! */
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000522 qsort((void *)nrs, count, sizeof(sorti_T), sort_compare);
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000523
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000524 if (sort_abort)
525 goto sortend;
526
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000527 /* Insert the lines in the sorted order below the last one. */
528 lnum = eap->line2;
529 for (i = 0; i < count; ++i)
530 {
531 s = ml_get(nrs[eap->forceit ? count - i - 1 : i].lnum);
532 if (!unique || i == 0
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000533 || (sort_ic ? STRICMP(s, sortbuf1) : STRCMP(s, sortbuf1)) != 0)
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000534 {
535 if (ml_append(lnum++, s, (colnr_T)0, FALSE) == FAIL)
536 break;
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000537 if (unique)
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000538 STRCPY(sortbuf1, s);
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000539 }
Bram Moolenaarae5bce12005-08-15 21:41:48 +0000540 fast_breakcheck();
541 if (got_int)
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000542 goto sortend;
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000543 }
544
545 /* delete the original lines if appending worked */
546 if (i == count)
547 for (i = 0; i < count; ++i)
548 ml_delete(eap->line1, FALSE);
549 else
550 count = 0;
551
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000552 /* Adjust marks for deleted (or added) lines and prepare for displaying. */
Bram Moolenaara93fa7e2006-04-17 22:14:47 +0000553 deleted = (long)(count - (lnum - eap->line2));
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000554 if (deleted > 0)
555 mark_adjust(eap->line2 - deleted, eap->line2, (long)MAXLNUM, -deleted);
556 else if (deleted < 0)
557 mark_adjust(eap->line2, MAXLNUM, -deleted, 0L);
558 changed_lines(eap->line1, 0, eap->line2 + 1, -deleted);
Bram Moolenaar54ee7752005-05-31 22:22:17 +0000559
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000560 curwin->w_cursor.lnum = eap->line1;
561 beginline(BL_WHITE | BL_FIX);
562
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000563sortend:
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000564 vim_free(nrs);
Bram Moolenaar4c3f5362006-04-11 21:38:50 +0000565 vim_free(sortbuf1);
566 vim_free(sortbuf2);
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000567 vim_free(regmatch.regprog);
Bram Moolenaarae5bce12005-08-15 21:41:48 +0000568 if (got_int)
569 EMSG(_(e_interr));
Bram Moolenaar67fe1a12005-05-22 22:12:58 +0000570}
571
Bram Moolenaar071d4272004-06-13 20:20:40 +0000572/*
573 * ":retab".
574 */
575 void
576ex_retab(eap)
577 exarg_T *eap;
578{
579 linenr_T lnum;
580 int got_tab = FALSE;
581 long num_spaces = 0;
582 long num_tabs;
583 long len;
584 long col;
585 long vcol;
586 long start_col = 0; /* For start of white-space string */
587 long start_vcol = 0; /* For start of white-space string */
588 int temp;
589 long old_len;
590 char_u *ptr;
591 char_u *new_line = (char_u *)1; /* init to non-NULL */
592 int did_undo; /* called u_save for current line */
593 int new_ts;
594 int save_list;
595 linenr_T first_line = 0; /* first changed line */
596 linenr_T last_line = 0; /* last changed line */
597
598 save_list = curwin->w_p_list;
599 curwin->w_p_list = 0; /* don't want list mode here */
600
601 new_ts = getdigits(&(eap->arg));
602 if (new_ts < 0)
603 {
604 EMSG(_(e_positive));
605 return;
606 }
607 if (new_ts == 0)
608 new_ts = curbuf->b_p_ts;
609 for (lnum = eap->line1; !got_int && lnum <= eap->line2; ++lnum)
610 {
611 ptr = ml_get(lnum);
612 col = 0;
613 vcol = 0;
614 did_undo = FALSE;
615 for (;;)
616 {
617 if (vim_iswhite(ptr[col]))
618 {
619 if (!got_tab && num_spaces == 0)
620 {
621 /* First consecutive white-space */
622 start_vcol = vcol;
623 start_col = col;
624 }
625 if (ptr[col] == ' ')
626 num_spaces++;
627 else
628 got_tab = TRUE;
629 }
630 else
631 {
632 if (got_tab || (eap->forceit && num_spaces > 1))
633 {
634 /* Retabulate this string of white-space */
635
636 /* len is virtual length of white string */
637 len = num_spaces = vcol - start_vcol;
638 num_tabs = 0;
639 if (!curbuf->b_p_et)
640 {
641 temp = new_ts - (start_vcol % new_ts);
642 if (num_spaces >= temp)
643 {
644 num_spaces -= temp;
645 num_tabs++;
646 }
647 num_tabs += num_spaces / new_ts;
648 num_spaces -= (num_spaces / new_ts) * new_ts;
649 }
650 if (curbuf->b_p_et || got_tab ||
651 (num_spaces + num_tabs < len))
652 {
653 if (did_undo == FALSE)
654 {
655 did_undo = TRUE;
656 if (u_save((linenr_T)(lnum - 1),
657 (linenr_T)(lnum + 1)) == FAIL)
658 {
659 new_line = NULL; /* flag out-of-memory */
660 break;
661 }
662 }
663
664 /* len is actual number of white characters used */
665 len = num_spaces + num_tabs;
666 old_len = (long)STRLEN(ptr);
667 new_line = lalloc(old_len - col + start_col + len + 1,
668 TRUE);
669 if (new_line == NULL)
670 break;
671 if (start_col > 0)
672 mch_memmove(new_line, ptr, (size_t)start_col);
673 mch_memmove(new_line + start_col + len,
674 ptr + col, (size_t)(old_len - col + 1));
675 ptr = new_line + start_col;
676 for (col = 0; col < len; col++)
677 ptr[col] = (col < num_tabs) ? '\t' : ' ';
678 ml_replace(lnum, new_line, FALSE);
679 if (first_line == 0)
680 first_line = lnum;
681 last_line = lnum;
682 ptr = new_line;
683 col = start_col + len;
684 }
685 }
686 got_tab = FALSE;
687 num_spaces = 0;
688 }
689 if (ptr[col] == NUL)
690 break;
691 vcol += chartabsize(ptr + col, (colnr_T)vcol);
692#ifdef FEAT_MBYTE
693 if (has_mbyte)
Bram Moolenaar0fa313a2005-08-10 21:07:57 +0000694 col += (*mb_ptr2len)(ptr + col);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000695 else
696#endif
697 ++col;
698 }
699 if (new_line == NULL) /* out of memory */
700 break;
701 line_breakcheck();
702 }
703 if (got_int)
704 EMSG(_(e_interr));
705
706 if (curbuf->b_p_ts != new_ts)
707 redraw_curbuf_later(NOT_VALID);
708 if (first_line != 0)
709 changed_lines(first_line, 0, last_line + 1, 0L);
710
711 curwin->w_p_list = save_list; /* restore 'list' */
712
713 curbuf->b_p_ts = new_ts;
714 coladvance(curwin->w_curswant);
715
716 u_clearline();
717}
718#endif
719
720/*
721 * :move command - move lines line1-line2 to line dest
722 *
723 * return FAIL for failure, OK otherwise
724 */
725 int
726do_move(line1, line2, dest)
727 linenr_T line1;
728 linenr_T line2;
729 linenr_T dest;
730{
731 char_u *str;
732 linenr_T l;
733 linenr_T extra; /* Num lines added before line1 */
734 linenr_T num_lines; /* Num lines moved */
735 linenr_T last_line; /* Last line in file after adding new text */
736
737 if (dest >= line1 && dest < line2)
738 {
739 EMSG(_("E134: Move lines into themselves"));
740 return FAIL;
741 }
742
743 num_lines = line2 - line1 + 1;
744
745 /*
746 * First we copy the old text to its new location -- webb
747 * Also copy the flag that ":global" command uses.
748 */
749 if (u_save(dest, dest + 1) == FAIL)
750 return FAIL;
751 for (extra = 0, l = line1; l <= line2; l++)
752 {
753 str = vim_strsave(ml_get(l + extra));
754 if (str != NULL)
755 {
756 ml_append(dest + l - line1, str, (colnr_T)0, FALSE);
757 vim_free(str);
758 if (dest < line1)
759 extra++;
760 }
761 }
762
763 /*
764 * Now we must be careful adjusting our marks so that we don't overlap our
765 * mark_adjust() calls.
766 *
767 * We adjust the marks within the old text so that they refer to the
768 * last lines of the file (temporarily), because we know no other marks
769 * will be set there since these line numbers did not exist until we added
770 * our new lines.
771 *
772 * Then we adjust the marks on lines between the old and new text positions
773 * (either forwards or backwards).
774 *
775 * And Finally we adjust the marks we put at the end of the file back to
776 * their final destination at the new text position -- webb
777 */
778 last_line = curbuf->b_ml.ml_line_count;
779 mark_adjust(line1, line2, last_line - line2, 0L);
780 if (dest >= line2)
781 {
782 mark_adjust(line2 + 1, dest, -num_lines, 0L);
783 curbuf->b_op_start.lnum = dest - num_lines + 1;
784 curbuf->b_op_end.lnum = dest;
785 }
786 else
787 {
788 mark_adjust(dest + 1, line1 - 1, num_lines, 0L);
789 curbuf->b_op_start.lnum = dest + 1;
790 curbuf->b_op_end.lnum = dest + num_lines;
791 }
792 curbuf->b_op_start.col = curbuf->b_op_end.col = 0;
793 mark_adjust(last_line - num_lines + 1, last_line,
794 -(last_line - dest - extra), 0L);
795
796 /*
797 * Now we delete the original text -- webb
798 */
799 if (u_save(line1 + extra - 1, line2 + extra + 1) == FAIL)
800 return FAIL;
801
802 for (l = line1; l <= line2; l++)
803 ml_delete(line1 + extra, TRUE);
804
805 if (!global_busy && num_lines > p_report)
806 {
807 if (num_lines == 1)
808 MSG(_("1 line moved"));
809 else
810 smsg((char_u *)_("%ld lines moved"), num_lines);
811 }
812
813 /*
814 * Leave the cursor on the last of the moved lines.
815 */
816 if (dest >= line1)
817 curwin->w_cursor.lnum = dest;
818 else
819 curwin->w_cursor.lnum = dest + (line2 - line1) + 1;
820
821 if (line1 < dest)
822 changed_lines(line1, 0, dest + num_lines + 1, 0L);
823 else
824 changed_lines(dest + 1, 0, line1 + num_lines, 0L);
825
826 return OK;
827}
828
829/*
830 * ":copy"
831 */
832 void
833ex_copy(line1, line2, n)
834 linenr_T line1;
835 linenr_T line2;
836 linenr_T n;
837{
838 linenr_T count;
839 char_u *p;
840
841 count = line2 - line1 + 1;
842 curbuf->b_op_start.lnum = n + 1;
843 curbuf->b_op_end.lnum = n + count;
844 curbuf->b_op_start.col = curbuf->b_op_end.col = 0;
845
846 /*
847 * there are three situations:
848 * 1. destination is above line1
849 * 2. destination is between line1 and line2
850 * 3. destination is below line2
851 *
852 * n = destination (when starting)
853 * curwin->w_cursor.lnum = destination (while copying)
854 * line1 = start of source (while copying)
855 * line2 = end of source (while copying)
856 */
857 if (u_save(n, n + 1) == FAIL)
858 return;
859
860 curwin->w_cursor.lnum = n;
861 while (line1 <= line2)
862 {
863 /* need to use vim_strsave() because the line will be unlocked within
864 * ml_append() */
865 p = vim_strsave(ml_get(line1));
866 if (p != NULL)
867 {
868 ml_append(curwin->w_cursor.lnum, p, (colnr_T)0, FALSE);
869 vim_free(p);
870 }
871 /* situation 2: skip already copied lines */
872 if (line1 == n)
873 line1 = curwin->w_cursor.lnum;
874 ++line1;
875 if (curwin->w_cursor.lnum < line1)
876 ++line1;
877 if (curwin->w_cursor.lnum < line2)
878 ++line2;
879 ++curwin->w_cursor.lnum;
880 }
881
882 appended_lines_mark(n, count);
883
884 msgmore((long)count);
885}
886
Bram Moolenaarf461c8e2005-06-25 23:04:51 +0000887static char_u *prevcmd = NULL; /* the previous command */
888
889#if defined(EXITFREE) || defined(PROTO)
890 void
891free_prev_shellcmd()
892{
893 vim_free(prevcmd);
894}
895#endif
896
Bram Moolenaar071d4272004-06-13 20:20:40 +0000897/*
898 * Handle the ":!cmd" command. Also for ":r !cmd" and ":w !cmd"
899 * Bangs in the argument are replaced with the previously entered command.
900 * Remember the argument.
901 *
902 * RISCOS: Bangs only replaced when followed by a space, since many
903 * pathnames contain one.
904 */
905 void
906do_bang(addr_count, eap, forceit, do_in, do_out)
907 int addr_count;
908 exarg_T *eap;
909 int forceit;
910 int do_in, do_out;
911{
912 char_u *arg = eap->arg; /* command */
913 linenr_T line1 = eap->line1; /* start of range */
914 linenr_T line2 = eap->line2; /* end of range */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000915 char_u *newcmd = NULL; /* the new command */
916 int free_newcmd = FALSE; /* need to free() newcmd */
917 int ins_prevcmd;
918 char_u *t;
919 char_u *p;
920 char_u *trailarg;
921 int len;
922 int scroll_save = msg_scroll;
923
924 /*
925 * Disallow shell commands for "rvim".
926 * Disallow shell commands from .exrc and .vimrc in current directory for
927 * security reasons.
928 */
929 if (check_restricted() || check_secure())
930 return;
931
932 if (addr_count == 0) /* :! */
933 {
934 msg_scroll = FALSE; /* don't scroll here */
935 autowrite_all();
936 msg_scroll = scroll_save;
937 }
938
939 /*
940 * Try to find an embedded bang, like in :!<cmd> ! [args]
941 * (:!! is indicated by the 'forceit' variable)
942 */
943 ins_prevcmd = forceit;
944 trailarg = arg;
945 do
946 {
947 len = (int)STRLEN(trailarg) + 1;
948 if (newcmd != NULL)
949 len += (int)STRLEN(newcmd);
950 if (ins_prevcmd)
951 {
952 if (prevcmd == NULL)
953 {
954 EMSG(_(e_noprev));
955 vim_free(newcmd);
956 return;
957 }
958 len += (int)STRLEN(prevcmd);
959 }
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +0000960 if ((t = alloc((unsigned)len)) == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000961 {
962 vim_free(newcmd);
963 return;
964 }
965 *t = NUL;
966 if (newcmd != NULL)
967 STRCAT(t, newcmd);
968 if (ins_prevcmd)
969 STRCAT(t, prevcmd);
970 p = t + STRLEN(t);
971 STRCAT(t, trailarg);
972 vim_free(newcmd);
973 newcmd = t;
974
975 /*
976 * Scan the rest of the argument for '!', which is replaced by the
977 * previous command. "\!" is replaced by "!" (this is vi compatible).
978 */
979 trailarg = NULL;
980 while (*p)
981 {
982 if (*p == '!'
983#ifdef RISCOS
984 && (p[1] == ' ' || p[1] == NUL)
985#endif
986 )
987 {
988 if (p > newcmd && p[-1] == '\\')
Bram Moolenaar8c8de832008-06-24 22:58:06 +0000989 STRMOVE(p - 1, p);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000990 else
991 {
992 trailarg = p;
993 *trailarg++ = NUL;
994 ins_prevcmd = TRUE;
995 break;
996 }
997 }
998 ++p;
999 }
1000 } while (trailarg != NULL);
1001
1002 vim_free(prevcmd);
1003 prevcmd = newcmd;
1004
1005 if (bangredo) /* put cmd in redo buffer for ! command */
1006 {
Bram Moolenaarebefac62005-12-28 22:39:57 +00001007 AppendToRedobuffLit(prevcmd, -1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001008 AppendToRedobuff((char_u *)"\n");
1009 bangredo = FALSE;
1010 }
1011 /*
1012 * Add quotes around the command, for shells that need them.
1013 */
1014 if (*p_shq != NUL)
1015 {
1016 newcmd = alloc((unsigned)(STRLEN(prevcmd) + 2 * STRLEN(p_shq) + 1));
1017 if (newcmd == NULL)
1018 return;
1019 STRCPY(newcmd, p_shq);
1020 STRCAT(newcmd, prevcmd);
1021 STRCAT(newcmd, p_shq);
1022 free_newcmd = TRUE;
1023 }
1024 if (addr_count == 0) /* :! */
1025 {
1026 /* echo the command */
1027 msg_start();
1028 msg_putchar(':');
1029 msg_putchar('!');
1030 msg_outtrans(newcmd);
1031 msg_clr_eos();
1032 windgoto(msg_row, msg_col);
1033
1034 do_shell(newcmd, 0);
1035 }
1036 else /* :range! */
Bram Moolenaarade00832006-03-10 21:46:58 +00001037 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001038 /* Careful: This may recursively call do_bang() again! (because of
1039 * autocommands) */
1040 do_filter(line1, line2, eap, newcmd, do_in, do_out);
Bram Moolenaarade00832006-03-10 21:46:58 +00001041#ifdef FEAT_AUTOCMD
1042 apply_autocmds(EVENT_SHELLFILTERPOST, NULL, NULL, FALSE, curbuf);
1043#endif
1044 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001045 if (free_newcmd)
1046 vim_free(newcmd);
1047}
1048
1049/*
1050 * do_filter: filter lines through a command given by the user
1051 *
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00001052 * We mostly use temp files and the call_shell() routine here. This would
1053 * normally be done using pipes on a UNIX machine, but this is more portable
1054 * to non-unix machines. The call_shell() routine needs to be able
Bram Moolenaar071d4272004-06-13 20:20:40 +00001055 * to deal with redirection somehow, and should handle things like looking
1056 * at the PATH env. variable, and adding reasonable extensions to the
1057 * command name given by the user. All reasonable versions of call_shell()
1058 * do this.
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00001059 * Alternatively, if on Unix and redirecting input or output, but not both,
1060 * and the 'shelltemp' option isn't set, use pipes.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001061 * We use input redirection if do_in is TRUE.
1062 * We use output redirection if do_out is TRUE.
1063 */
1064 static void
1065do_filter(line1, line2, eap, cmd, do_in, do_out)
1066 linenr_T line1, line2;
1067 exarg_T *eap; /* for forced 'ff' and 'fenc' */
1068 char_u *cmd;
1069 int do_in, do_out;
1070{
1071 char_u *itmp = NULL;
1072 char_u *otmp = NULL;
1073 linenr_T linecount;
1074 linenr_T read_linecount;
1075 pos_T cursor_save;
1076 char_u *cmd_buf;
1077#ifdef FEAT_AUTOCMD
1078 buf_T *old_curbuf = curbuf;
1079#endif
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00001080 int shell_flags = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001081
1082 if (*cmd == NUL) /* no filter command */
1083 return;
1084
1085#ifdef WIN3264
1086 /*
1087 * Check if external commands are allowed now.
1088 */
1089 if (can_end_termcap_mode(TRUE) == FALSE)
1090 return;
1091#endif
1092
1093 cursor_save = curwin->w_cursor;
1094 linecount = line2 - line1 + 1;
1095 curwin->w_cursor.lnum = line1;
1096 curwin->w_cursor.col = 0;
1097 changed_line_abv_curs();
1098 invalidate_botline();
1099
1100 /*
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00001101 * When using temp files:
1102 * 1. * Form temp file names
1103 * 2. * Write the lines to a temp file
1104 * 3. Run the filter command on the temp file
1105 * 4. * Read the output of the command into the buffer
1106 * 5. * Delete the original lines to be filtered
1107 * 6. * Remove the temp files
1108 *
1109 * When writing the input with a pipe or when catching the output with a
1110 * pipe only need to do 3.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001111 */
1112
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00001113 if (do_out)
1114 shell_flags |= SHELL_DOOUT;
1115
1116#if !defined(USE_SYSTEM) && defined(UNIX)
1117 if (!do_in && do_out && !p_stmp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001118 {
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00001119 /* Use a pipe to fetch stdout of the command, do not use a temp file. */
1120 shell_flags |= SHELL_READ;
1121 curwin->w_cursor.lnum = line2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001122 }
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00001123 else if (do_in && !do_out && !p_stmp)
1124 {
1125 /* Use a pipe to write stdin of the command, do not use a temp file. */
1126 shell_flags |= SHELL_WRITE;
1127 curbuf->b_op_start.lnum = line1;
1128 curbuf->b_op_end.lnum = line2;
1129 }
1130 else if (do_in && do_out && !p_stmp)
1131 {
1132 /* Use a pipe to write stdin and fetch stdout of the command, do not
1133 * use a temp file. */
1134 shell_flags |= SHELL_READ|SHELL_WRITE;
1135 curbuf->b_op_start.lnum = line1;
1136 curbuf->b_op_end.lnum = line2;
1137 curwin->w_cursor.lnum = line2;
1138 }
1139 else
1140#endif
1141 if ((do_in && (itmp = vim_tempname('i')) == NULL)
1142 || (do_out && (otmp = vim_tempname('o')) == NULL))
1143 {
1144 EMSG(_(e_notmp));
1145 goto filterend;
1146 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001147
1148/*
1149 * The writing and reading of temp files will not be shown.
1150 * Vi also doesn't do this and the messages are not very informative.
1151 */
1152 ++no_wait_return; /* don't call wait_return() while busy */
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00001153 if (itmp != NULL && buf_write(curbuf, itmp, NULL, line1, line2, eap,
Bram Moolenaar071d4272004-06-13 20:20:40 +00001154 FALSE, FALSE, FALSE, TRUE) == FAIL)
1155 {
1156 msg_putchar('\n'); /* keep message from buf_write() */
1157 --no_wait_return;
1158#if defined(FEAT_AUTOCMD) && defined(FEAT_EVAL)
1159 if (!aborting())
1160#endif
1161 (void)EMSG2(_(e_notcreate), itmp); /* will call wait_return */
1162 goto filterend;
1163 }
1164#ifdef FEAT_AUTOCMD
1165 if (curbuf != old_curbuf)
1166 goto filterend;
1167#endif
1168
1169 if (!do_out)
1170 msg_putchar('\n');
1171
Bram Moolenaara9aafe52008-05-07 11:10:28 +00001172 /* Create the shell command in allocated memory. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001173 cmd_buf = make_filter_cmd(cmd, itmp, otmp);
1174 if (cmd_buf == NULL)
1175 goto filterend;
1176
1177 windgoto((int)Rows - 1, 0);
1178 cursor_on();
1179
1180 /*
1181 * When not redirecting the output the command can write anything to the
1182 * screen. If 'shellredir' is equal to ">", screen may be messed up by
1183 * stderr output of external command. Clear the screen later.
1184 * If do_in is FALSE, this could be something like ":r !cat", which may
1185 * also mess up the screen, clear it later.
1186 */
1187 if (!do_out || STRCMP(p_srr, ">") == 0 || !do_in)
1188 redraw_later_clear();
1189
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00001190 if (do_out)
1191 {
1192 if (u_save((linenr_T)(line2), (linenr_T)(line2 + 1)) == FAIL)
Bram Moolenaara9aafe52008-05-07 11:10:28 +00001193 {
1194 vim_free(cmd_buf);
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00001195 goto error;
Bram Moolenaara9aafe52008-05-07 11:10:28 +00001196 }
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00001197 redraw_curbuf_later(VALID);
1198 }
1199 read_linecount = curbuf->b_ml.ml_line_count;
1200
Bram Moolenaar071d4272004-06-13 20:20:40 +00001201 /*
1202 * When call_shell() fails wait_return() is called to give the user a
1203 * chance to read the error messages. Otherwise errors are ignored, so you
1204 * can see the error messages from the command that appear on stdout; use
1205 * 'u' to fix the text
1206 * Switch to cooked mode when not redirecting stdin, avoids that something
1207 * like ":r !cat" hangs.
1208 * Pass on the SHELL_DOOUT flag when the output is being redirected.
1209 */
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00001210 if (call_shell(cmd_buf, SHELL_FILTER | SHELL_COOKED | shell_flags))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001211 {
1212 redraw_later_clear();
1213 wait_return(FALSE);
1214 }
1215 vim_free(cmd_buf);
1216
1217 did_check_timestamps = FALSE;
1218 need_check_timestamps = TRUE;
1219
1220 /* When interrupting the shell command, it may still have produced some
1221 * useful output. Reset got_int here, so that readfile() won't cancel
1222 * reading. */
1223 ui_breakcheck();
1224 got_int = FALSE;
1225
1226 if (do_out)
1227 {
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00001228 if (otmp != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001229 {
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00001230 if (readfile(otmp, NULL, line2, (linenr_T)0, (linenr_T)MAXLNUM,
1231 eap, READ_FILTER) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001232 {
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00001233#if defined(FEAT_AUTOCMD) && defined(FEAT_EVAL)
1234 if (!aborting())
Bram Moolenaar071d4272004-06-13 20:20:40 +00001235#endif
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00001236 {
1237 msg_putchar('\n');
1238 EMSG2(_(e_notread), otmp);
1239 }
1240 goto error;
1241 }
1242#ifdef FEAT_AUTOCMD
1243 if (curbuf != old_curbuf)
1244 goto filterend;
1245#endif
1246 }
1247
1248 read_linecount = curbuf->b_ml.ml_line_count - read_linecount;
1249
1250 if (shell_flags & SHELL_READ)
1251 {
1252 curbuf->b_op_start.lnum = line2 + 1;
1253 curbuf->b_op_end.lnum = curwin->w_cursor.lnum;
1254 appended_lines_mark(line2, read_linecount);
1255 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001256
1257 if (do_in)
1258 {
1259 if (cmdmod.keepmarks || vim_strchr(p_cpo, CPO_REMMARK) == NULL)
1260 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001261 if (read_linecount >= linecount)
1262 /* move all marks from old lines to new lines */
1263 mark_adjust(line1, line2, linecount, 0L);
1264 else
1265 {
1266 /* move marks from old lines to new lines, delete marks
1267 * that are in deleted lines */
1268 mark_adjust(line1, line1 + read_linecount - 1,
1269 linecount, 0L);
1270 mark_adjust(line1 + read_linecount, line2, MAXLNUM, 0L);
1271 }
1272 }
1273
1274 /*
1275 * Put cursor on first filtered line for ":range!cmd".
1276 * Adjust '[ and '] (set by buf_write()).
1277 */
1278 curwin->w_cursor.lnum = line1;
1279 del_lines(linecount, TRUE);
1280 curbuf->b_op_start.lnum -= linecount; /* adjust '[ */
1281 curbuf->b_op_end.lnum -= linecount; /* adjust '] */
1282 write_lnum_adjust(-linecount); /* adjust last line
1283 for next write */
Bram Moolenaar8c711452005-01-14 21:53:12 +00001284#ifdef FEAT_FOLDING
1285 foldUpdate(curwin, curbuf->b_op_start.lnum, curbuf->b_op_end.lnum);
1286#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001287 }
1288 else
1289 {
1290 /*
1291 * Put cursor on last new line for ":r !cmd".
1292 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001293 linecount = curbuf->b_op_end.lnum - curbuf->b_op_start.lnum + 1;
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00001294 curwin->w_cursor.lnum = curbuf->b_op_end.lnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001295 }
Bram Moolenaar8c711452005-01-14 21:53:12 +00001296
Bram Moolenaar071d4272004-06-13 20:20:40 +00001297 beginline(BL_WHITE | BL_FIX); /* cursor on first non-blank */
1298 --no_wait_return;
1299
1300 if (linecount > p_report)
1301 {
1302 if (do_in)
1303 {
Bram Moolenaar555b2802005-05-19 21:08:39 +00001304 vim_snprintf((char *)msg_buf, sizeof(msg_buf),
1305 _("%ld lines filtered"), (long)linecount);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001306 if (msg(msg_buf) && !msg_scroll)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001307 /* save message to display it after redraw */
Bram Moolenaar238a5642006-02-21 22:12:05 +00001308 set_keep_msg(msg_buf, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001309 }
1310 else
1311 msgmore((long)linecount);
1312 }
1313 }
1314 else
1315 {
1316error:
1317 /* put cursor back in same position for ":w !cmd" */
1318 curwin->w_cursor = cursor_save;
1319 --no_wait_return;
1320 wait_return(FALSE);
1321 }
1322
1323filterend:
1324
1325#ifdef FEAT_AUTOCMD
1326 if (curbuf != old_curbuf)
1327 {
1328 --no_wait_return;
1329 EMSG(_("E135: *Filter* Autocommands must not change current buffer"));
1330 }
1331#endif
1332 if (itmp != NULL)
1333 mch_remove(itmp);
1334 if (otmp != NULL)
1335 mch_remove(otmp);
1336 vim_free(itmp);
1337 vim_free(otmp);
1338}
1339
1340/*
1341 * Call a shell to execute a command.
1342 * When "cmd" is NULL start an interactive shell.
1343 */
1344 void
1345do_shell(cmd, flags)
1346 char_u *cmd;
1347 int flags; /* may be SHELL_DOOUT when output is redirected */
1348{
1349 buf_T *buf;
1350#ifndef FEAT_GUI_MSWIN
1351 int save_nwr;
1352#endif
1353#ifdef MSWIN
1354 int winstart = FALSE;
1355#endif
1356
1357 /*
1358 * Disallow shell commands for "rvim".
1359 * Disallow shell commands from .exrc and .vimrc in current directory for
1360 * security reasons.
1361 */
1362 if (check_restricted() || check_secure())
1363 {
1364 msg_end();
1365 return;
1366 }
1367
1368#ifdef MSWIN
1369 /*
1370 * Check if external commands are allowed now.
1371 */
1372 if (can_end_termcap_mode(TRUE) == FALSE)
1373 return;
1374
1375 /*
1376 * Check if ":!start" is used.
1377 */
1378 if (cmd != NULL)
1379 winstart = (STRNICMP(cmd, "start ", 6) == 0);
1380#endif
1381
1382 /*
1383 * For autocommands we want to get the output on the current screen, to
1384 * avoid having to type return below.
1385 */
1386 msg_putchar('\r'); /* put cursor at start of line */
1387#ifdef FEAT_AUTOCMD
1388 if (!autocmd_busy)
1389#endif
1390 {
1391#ifdef MSWIN
1392 if (!winstart)
1393#endif
1394 stoptermcap();
1395 }
1396#ifdef MSWIN
1397 if (!winstart)
1398#endif
1399 msg_putchar('\n'); /* may shift screen one line up */
1400
1401 /* warning message before calling the shell */
1402 if (p_warn
1403#ifdef FEAT_AUTOCMD
1404 && !autocmd_busy
1405#endif
1406 && msg_silent == 0)
1407 for (buf = firstbuf; buf; buf = buf->b_next)
1408 if (bufIsChanged(buf))
1409 {
1410#ifdef FEAT_GUI_MSWIN
1411 if (!winstart)
1412 starttermcap(); /* don't want a message box here */
1413#endif
1414 MSG_PUTS(_("[No write since last change]\n"));
1415#ifdef FEAT_GUI_MSWIN
1416 if (!winstart)
1417 stoptermcap();
1418#endif
1419 break;
1420 }
1421
1422 /* This windgoto is required for when the '\n' resulted in a "delete line
1423 * 1" command to the terminal. */
1424 if (!swapping_screen())
1425 windgoto(msg_row, msg_col);
1426 cursor_on();
1427 (void)call_shell(cmd, SHELL_COOKED | flags);
1428 did_check_timestamps = FALSE;
1429 need_check_timestamps = TRUE;
1430
1431 /*
1432 * put the message cursor at the end of the screen, avoids wait_return()
1433 * to overwrite the text that the external command showed
1434 */
1435 if (!swapping_screen())
1436 {
1437 msg_row = Rows - 1;
1438 msg_col = 0;
1439 }
1440
1441#ifdef FEAT_AUTOCMD
1442 if (autocmd_busy)
1443 {
1444 if (msg_silent == 0)
1445 redraw_later_clear();
1446 }
1447 else
1448#endif
1449 {
1450 /*
1451 * For ":sh" there is no need to call wait_return(), just redraw.
1452 * Also for the Win32 GUI (the output is in a console window).
1453 * Otherwise there is probably text on the screen that the user wants
1454 * to read before redrawing, so call wait_return().
1455 */
1456#ifndef FEAT_GUI_MSWIN
1457 if (cmd == NULL
1458# ifdef WIN3264
1459 || (winstart && !need_wait_return)
1460# endif
1461 )
1462 {
1463 if (msg_silent == 0)
1464 redraw_later_clear();
1465 need_wait_return = FALSE;
1466 }
1467 else
1468 {
1469 /*
1470 * If we switch screens when starttermcap() is called, we really
1471 * want to wait for "hit return to continue".
1472 */
1473 save_nwr = no_wait_return;
1474 if (swapping_screen())
1475 no_wait_return = FALSE;
1476# ifdef AMIGA
1477 wait_return(term_console ? -1 : msg_silent == 0); /* see below */
1478# else
1479 wait_return(msg_silent == 0);
1480# endif
1481 no_wait_return = save_nwr;
1482 }
1483#endif /* FEAT_GUI_W32 */
1484
1485#ifdef MSWIN
1486 if (!winstart) /* if winstart==TRUE, never stopped termcap! */
1487#endif
1488 starttermcap(); /* start termcap if not done by wait_return() */
1489
1490 /*
1491 * In an Amiga window redrawing is caused by asking the window size.
1492 * If we got an interrupt this will not work. The chance that the
1493 * window size is wrong is very small, but we need to redraw the
1494 * screen. Don't do this if ':' hit in wait_return(). THIS IS UGLY
1495 * but it saves an extra redraw.
1496 */
1497#ifdef AMIGA
1498 if (skip_redraw) /* ':' hit in wait_return() */
1499 {
1500 if (msg_silent == 0)
1501 redraw_later_clear();
1502 }
1503 else if (term_console)
1504 {
1505 OUT_STR(IF_EB("\033[0 q", ESC_STR "[0 q")); /* get window size */
1506 if (got_int && msg_silent == 0)
1507 redraw_later_clear(); /* if got_int is TRUE, redraw needed */
1508 else
1509 must_redraw = 0; /* no extra redraw needed */
1510 }
1511#endif
1512 }
1513
1514 /* display any error messages now */
1515 display_errors();
Bram Moolenaarade00832006-03-10 21:46:58 +00001516
1517#ifdef FEAT_AUTOCMD
1518 apply_autocmds(EVENT_SHELLCMDPOST, NULL, NULL, FALSE, curbuf);
1519#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001520}
1521
1522/*
1523 * Create a shell command from a command string, input redirection file and
1524 * output redirection file.
1525 * Returns an allocated string with the shell command, or NULL for failure.
1526 */
1527 char_u *
1528make_filter_cmd(cmd, itmp, otmp)
1529 char_u *cmd; /* command */
1530 char_u *itmp; /* NULL or name of input file */
1531 char_u *otmp; /* NULL or name of output file */
1532{
1533 char_u *buf;
1534 long_u len;
1535
1536 len = (long_u)STRLEN(cmd) + 3; /* "()" + NUL */
1537 if (itmp != NULL)
1538 len += (long_u)STRLEN(itmp) + 9; /* " { < " + " } " */
1539 if (otmp != NULL)
1540 len += (long_u)STRLEN(otmp) + (long_u)STRLEN(p_srr) + 2; /* " " */
1541 buf = lalloc(len, TRUE);
1542 if (buf == NULL)
1543 return NULL;
1544
1545#if (defined(UNIX) && !defined(ARCHIE)) || defined(OS2)
1546 /*
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00001547 * Put braces around the command (for concatenated commands) when
1548 * redirecting input and/or output.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001549 */
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00001550 if (itmp != NULL || otmp != NULL)
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00001551 vim_snprintf((char *)buf, len, "(%s)", (char *)cmd);
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00001552 else
1553 STRCPY(buf, cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001554 if (itmp != NULL)
1555 {
1556 STRCAT(buf, " < ");
1557 STRCAT(buf, itmp);
1558 }
1559#else
1560 /*
1561 * for shells that don't understand braces around commands, at least allow
1562 * the use of commands in a pipe.
1563 */
1564 STRCPY(buf, cmd);
1565 if (itmp != NULL)
1566 {
1567 char_u *p;
1568
1569 /*
1570 * If there is a pipe, we have to put the '<' in front of it.
1571 * Don't do this when 'shellquote' is not empty, otherwise the
1572 * redirection would be inside the quotes.
1573 */
1574 if (*p_shq == NUL)
1575 {
1576 p = vim_strchr(buf, '|');
1577 if (p != NULL)
1578 *p = NUL;
1579 }
1580# ifdef RISCOS
1581 STRCAT(buf, " { < "); /* Use RISC OS notation for input. */
1582 STRCAT(buf, itmp);
1583 STRCAT(buf, " } ");
1584# else
1585 STRCAT(buf, " <"); /* " < " causes problems on Amiga */
1586 STRCAT(buf, itmp);
1587# endif
1588 if (*p_shq == NUL)
1589 {
1590 p = vim_strchr(cmd, '|');
1591 if (p != NULL)
1592 {
1593 STRCAT(buf, " "); /* insert a space before the '|' for DOS */
1594 STRCAT(buf, p);
1595 }
1596 }
1597 }
1598#endif
1599 if (otmp != NULL)
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00001600 append_redir(buf, (int)len, p_srr, otmp);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001601
1602 return buf;
1603}
1604
1605/*
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00001606 * Append output redirection for file "fname" to the end of string buffer
1607 * "buf[buflen]"
Bram Moolenaar071d4272004-06-13 20:20:40 +00001608 * Works with the 'shellredir' and 'shellpipe' options.
1609 * The caller should make sure that there is enough room:
1610 * STRLEN(opt) + STRLEN(fname) + 3
1611 */
1612 void
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00001613append_redir(buf, buflen, opt, fname)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001614 char_u *buf;
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00001615 int buflen;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001616 char_u *opt;
1617 char_u *fname;
1618{
1619 char_u *p;
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00001620 char_u *end;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001621
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00001622 end = buf + STRLEN(buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001623 /* find "%s", skipping "%%" */
1624 for (p = opt; (p = vim_strchr(p, '%')) != NULL; ++p)
1625 if (p[1] == 's')
1626 break;
1627 if (p != NULL)
1628 {
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00001629 *end = ' '; /* not really needed? Not with sh, ksh or bash */
1630 vim_snprintf((char *)end + 1, (size_t)(buflen - (end + 1 - buf)),
1631 (char *)opt, (char *)fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001632 }
1633 else
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00001634 vim_snprintf((char *)end, (size_t)(buflen - (end - buf)),
Bram Moolenaar071d4272004-06-13 20:20:40 +00001635#ifdef FEAT_QUICKFIX
1636# ifndef RISCOS
1637 opt != p_sp ? " %s%s" :
1638# endif
1639 " %s %s",
1640#else
1641# ifndef RISCOS
1642 " %s%s", /* " > %s" causes problems on Amiga */
1643# else
1644 " %s %s", /* But is needed for 'shellpipe' and RISC OS */
1645# endif
1646#endif
1647 (char *)opt, (char *)fname);
1648}
1649
1650#ifdef FEAT_VIMINFO
1651
1652static int no_viminfo __ARGS((void));
1653static int viminfo_errcnt;
1654
1655 static int
1656no_viminfo()
1657{
1658 /* "vim -i NONE" does not read or write a viminfo file */
1659 return (use_viminfo != NULL && STRCMP(use_viminfo, "NONE") == 0);
1660}
1661
1662/*
1663 * Report an error for reading a viminfo file.
1664 * Count the number of errors. When there are more than 10, return TRUE.
1665 */
1666 int
1667viminfo_error(errnum, message, line)
1668 char *errnum;
1669 char *message;
1670 char_u *line;
1671{
Bram Moolenaar555b2802005-05-19 21:08:39 +00001672 vim_snprintf((char *)IObuff, IOSIZE, _("%sviminfo: %s in line: "),
1673 errnum, message);
Bram Moolenaar6c964832007-12-09 18:38:35 +00001674 STRNCAT(IObuff, line, IOSIZE - STRLEN(IObuff) - 1);
Bram Moolenaar758711c2005-02-02 23:11:38 +00001675 if (IObuff[STRLEN(IObuff) - 1] == '\n')
1676 IObuff[STRLEN(IObuff) - 1] = NUL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001677 emsg(IObuff);
1678 if (++viminfo_errcnt >= 10)
1679 {
1680 EMSG(_("E136: viminfo: Too many errors, skipping rest of file"));
1681 return TRUE;
1682 }
1683 return FALSE;
1684}
1685
1686/*
1687 * read_viminfo() -- Read the viminfo file. Registers etc. which are already
Bram Moolenaard812df62008-11-09 12:46:09 +00001688 * set are not over-written unless "flags" includes VIF_FORCEIT. -- webb
Bram Moolenaar071d4272004-06-13 20:20:40 +00001689 */
1690 int
Bram Moolenaard812df62008-11-09 12:46:09 +00001691read_viminfo(file, flags)
1692 char_u *file; /* file name or NULL to use default name */
1693 int flags; /* VIF_WANT_INFO et al. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001694{
1695 FILE *fp;
1696 char_u *fname;
1697
1698 if (no_viminfo())
1699 return FAIL;
1700
Bram Moolenaard812df62008-11-09 12:46:09 +00001701 fname = viminfo_filename(file); /* get file name in allocated buffer */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001702 if (fname == NULL)
1703 return FAIL;
1704 fp = mch_fopen((char *)fname, READBIN);
1705
1706 if (p_verbose > 0)
Bram Moolenaar54ee7752005-05-31 22:22:17 +00001707 {
1708 verbose_enter();
Bram Moolenaar555b2802005-05-19 21:08:39 +00001709 smsg((char_u *)_("Reading viminfo file \"%s\"%s%s%s"),
1710 fname,
Bram Moolenaard812df62008-11-09 12:46:09 +00001711 (flags & VIF_WANT_INFO) ? _(" info") : "",
1712 (flags & VIF_WANT_MARKS) ? _(" marks") : "",
1713 (flags & VIF_GET_OLDFILES) ? _(" oldfiles") : "",
Bram Moolenaar555b2802005-05-19 21:08:39 +00001714 fp == NULL ? _(" FAILED") : "");
Bram Moolenaar54ee7752005-05-31 22:22:17 +00001715 verbose_leave();
1716 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001717
1718 vim_free(fname);
1719 if (fp == NULL)
1720 return FAIL;
1721
1722 viminfo_errcnt = 0;
Bram Moolenaard812df62008-11-09 12:46:09 +00001723 do_viminfo(fp, NULL, flags);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001724
1725 fclose(fp);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001726 return OK;
1727}
1728
1729/*
1730 * write_viminfo() -- Write the viminfo file. The old one is read in first so
1731 * that effectively a merge of current info and old info is done. This allows
1732 * multiple vims to run simultaneously, without losing any marks etc. If
1733 * forceit is TRUE, then the old file is not read in, and only internal info is
1734 * written to the file. -- webb
1735 */
1736 void
1737write_viminfo(file, forceit)
1738 char_u *file;
1739 int forceit;
1740{
1741 char_u *fname;
1742 FILE *fp_in = NULL; /* input viminfo file, if any */
1743 FILE *fp_out = NULL; /* output viminfo file */
1744 char_u *tempname = NULL; /* name of temp viminfo file */
1745 struct stat st_new; /* mch_stat() of potential new file */
1746 char_u *wp;
1747#if defined(UNIX) || defined(VMS)
1748 mode_t umask_save;
1749#endif
1750#ifdef UNIX
1751 int shortname = FALSE; /* use 8.3 file name */
1752 struct stat st_old; /* mch_stat() of existing viminfo file */
1753#endif
Bram Moolenaarbca84a12005-12-14 22:08:35 +00001754#ifdef WIN3264
1755 long perm = -1;
1756#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001757
1758 if (no_viminfo())
1759 return;
1760
1761 fname = viminfo_filename(file); /* may set to default if NULL */
1762 if (fname == NULL)
1763 return;
1764
1765 fp_in = mch_fopen((char *)fname, READBIN);
1766 if (fp_in == NULL)
1767 {
1768 /* if it does exist, but we can't read it, don't try writing */
1769 if (mch_stat((char *)fname, &st_new) == 0)
1770 goto end;
1771#if defined(UNIX) || defined(VMS)
1772 /*
1773 * For Unix we create the .viminfo non-accessible for others,
1774 * because it may contain text from non-accessible documents.
1775 */
1776 umask_save = umask(077);
1777#endif
1778 fp_out = mch_fopen((char *)fname, WRITEBIN);
1779#if defined(UNIX) || defined(VMS)
1780 (void)umask(umask_save);
1781#endif
1782 }
1783 else
1784 {
1785 /*
1786 * There is an existing viminfo file. Create a temporary file to
1787 * write the new viminfo into, in the same directory as the
1788 * existing viminfo file, which will be renamed later.
1789 */
1790#ifdef UNIX
1791 /*
1792 * For Unix we check the owner of the file. It's not very nice to
1793 * overwrite a user's viminfo file after a "su root", with a
1794 * viminfo file that the user can't read.
1795 */
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00001796 st_old.st_dev = (dev_t)0;
Bram Moolenaar6f192452007-11-08 19:49:02 +00001797 st_old.st_ino = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001798 st_old.st_mode = 0600;
Bram Moolenaar311d9822007-02-27 15:48:28 +00001799 if (mch_stat((char *)fname, &st_old) == 0
1800 && getuid() != ROOT_UID
Bram Moolenaar12625ca2005-11-25 19:58:47 +00001801 && !(st_old.st_uid == getuid()
Bram Moolenaar071d4272004-06-13 20:20:40 +00001802 ? (st_old.st_mode & 0200)
1803 : (st_old.st_gid == getgid()
1804 ? (st_old.st_mode & 0020)
1805 : (st_old.st_mode & 0002))))
1806 {
Bram Moolenaar89d40322006-08-29 15:30:07 +00001807 int tt = msg_didany;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001808
1809 /* avoid a wait_return for this message, it's annoying */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001810 EMSG2(_("E137: Viminfo file is not writable: %s"), fname);
1811 msg_didany = tt;
Bram Moolenaareb3593b2006-04-22 22:33:57 +00001812 fclose(fp_in);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001813 goto end;
1814 }
1815#endif
Bram Moolenaarbca84a12005-12-14 22:08:35 +00001816#ifdef WIN3264
1817 /* Get the file attributes of the existing viminfo file. */
1818 perm = mch_getperm(fname);
1819#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001820
1821 /*
1822 * Make tempname.
1823 * May try twice: Once normal and once with shortname set, just in
1824 * case somebody puts his viminfo file in an 8.3 filesystem.
1825 */
1826 for (;;)
1827 {
1828 tempname = buf_modname(
1829#ifdef UNIX
1830 shortname,
1831#else
1832# ifdef SHORT_FNAME
1833 TRUE,
1834# else
1835# ifdef FEAT_GUI_W32
1836 gui_is_win32s(),
1837# else
1838 FALSE,
1839# endif
1840# endif
1841#endif
1842 fname,
1843#ifdef VMS
1844 (char_u *)"-tmp",
1845#else
1846# ifdef RISCOS
1847 (char_u *)"/tmp",
1848# else
1849 (char_u *)".tmp",
1850# endif
1851#endif
1852 FALSE);
1853 if (tempname == NULL) /* out of memory */
1854 break;
1855
1856 /*
1857 * Check if tempfile already exists. Never overwrite an
1858 * existing file!
1859 */
1860 if (mch_stat((char *)tempname, &st_new) == 0)
1861 {
1862#ifdef UNIX
1863 /*
1864 * Check if tempfile is same as original file. May happen
1865 * when modname() gave the same file back. E.g. silly
1866 * link, or file name-length reached. Try again with
1867 * shortname set.
1868 */
Bram Moolenaar12625ca2005-11-25 19:58:47 +00001869 if (!shortname && st_new.st_dev == st_old.st_dev
1870 && st_new.st_ino == st_old.st_ino)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001871 {
1872 vim_free(tempname);
1873 tempname = NULL;
1874 shortname = TRUE;
1875 continue;
1876 }
1877#endif
1878 /*
1879 * Try another name. Change one character, just before
1880 * the extension. This should also work for an 8.3
1881 * file name, when after adding the extension it still is
1882 * the same file as the original.
1883 */
1884 wp = tempname + STRLEN(tempname) - 5;
1885 if (wp < gettail(tempname)) /* empty file name? */
1886 wp = gettail(tempname);
1887 for (*wp = 'z'; mch_stat((char *)tempname, &st_new) == 0;
1888 --*wp)
1889 {
1890 /*
1891 * They all exist? Must be something wrong! Don't
1892 * write the viminfo file then.
1893 */
1894 if (*wp == 'a')
1895 {
1896 vim_free(tempname);
1897 tempname = NULL;
1898 break;
1899 }
1900 }
1901 }
1902 break;
1903 }
1904
1905 if (tempname != NULL)
1906 {
Bram Moolenaar114216c2006-03-14 23:08:30 +00001907#ifdef VMS
1908 /* fdopen() fails for some reason */
Bram Moolenaarcf034472006-03-15 23:07:59 +00001909 umask_save = umask(077);
1910 fp_out = mch_fopen((char *)tempname, WRITEBIN);
1911 (void)umask(umask_save);
Bram Moolenaar114216c2006-03-14 23:08:30 +00001912#else
Bram Moolenaara5792f52005-11-23 21:25:05 +00001913 int fd;
1914
1915 /* Use mch_open() to be able to use O_NOFOLLOW and set file
Bram Moolenaarbca84a12005-12-14 22:08:35 +00001916 * protection:
Bram Moolenaar997fb4b2006-02-17 21:53:23 +00001917 * Unix: same as original file, but strip s-bit. Reset umask to
1918 * avoid it getting in the way.
Bram Moolenaarbca84a12005-12-14 22:08:35 +00001919 * Others: r&w for user only. */
Bram Moolenaar114216c2006-03-14 23:08:30 +00001920# ifdef UNIX
Bram Moolenaar997fb4b2006-02-17 21:53:23 +00001921 umask_save = umask(0);
Bram Moolenaara5792f52005-11-23 21:25:05 +00001922 fd = mch_open((char *)tempname,
1923 O_CREAT|O_EXTRA|O_EXCL|O_WRONLY|O_NOFOLLOW,
Bram Moolenaarbba577a2005-11-28 23:05:55 +00001924 (int)((st_old.st_mode & 0777) | 0600));
Bram Moolenaar997fb4b2006-02-17 21:53:23 +00001925 (void)umask(umask_save);
Bram Moolenaar114216c2006-03-14 23:08:30 +00001926# else
Bram Moolenaarbba577a2005-11-28 23:05:55 +00001927 fd = mch_open((char *)tempname,
Bram Moolenaar997fb4b2006-02-17 21:53:23 +00001928 O_CREAT|O_EXTRA|O_EXCL|O_WRONLY|O_NOFOLLOW, 0600);
Bram Moolenaar114216c2006-03-14 23:08:30 +00001929# endif
Bram Moolenaara5792f52005-11-23 21:25:05 +00001930 if (fd < 0)
1931 fp_out = NULL;
1932 else
1933 fp_out = fdopen(fd, WRITEBIN);
Bram Moolenaar114216c2006-03-14 23:08:30 +00001934#endif /* VMS */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001935
1936 /*
1937 * If we can't create in the same directory, try creating a
1938 * "normal" temp file.
1939 */
1940 if (fp_out == NULL)
1941 {
1942 vim_free(tempname);
1943 if ((tempname = vim_tempname('o')) != NULL)
1944 fp_out = mch_fopen((char *)tempname, WRITEBIN);
1945 }
Bram Moolenaara5792f52005-11-23 21:25:05 +00001946
1947#if defined(UNIX) && defined(HAVE_FCHOWN)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001948 /*
Bram Moolenaara5792f52005-11-23 21:25:05 +00001949 * Make sure the owner can read/write it. This only works for
1950 * root.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001951 */
1952 if (fp_out != NULL)
Bram Moolenaarfe86f2d2008-11-28 20:29:07 +00001953 ignored = fchown(fileno(fp_out), st_old.st_uid, st_old.st_gid);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001954#endif
1955 }
1956 }
1957
1958 /*
1959 * Check if the new viminfo file can be written to.
1960 */
1961 if (fp_out == NULL)
1962 {
1963 EMSG2(_("E138: Can't write viminfo file %s!"),
Bram Moolenaar75c50c42005-06-04 22:06:24 +00001964 (fp_in == NULL || tempname == NULL) ? fname : tempname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001965 if (fp_in != NULL)
1966 fclose(fp_in);
1967 goto end;
1968 }
1969
1970 if (p_verbose > 0)
Bram Moolenaar54ee7752005-05-31 22:22:17 +00001971 {
1972 verbose_enter();
Bram Moolenaar555b2802005-05-19 21:08:39 +00001973 smsg((char_u *)_("Writing viminfo file \"%s\""), fname);
Bram Moolenaar54ee7752005-05-31 22:22:17 +00001974 verbose_leave();
1975 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001976
1977 viminfo_errcnt = 0;
Bram Moolenaard812df62008-11-09 12:46:09 +00001978 do_viminfo(fp_in, fp_out, forceit ? 0 : (VIF_WANT_INFO | VIF_WANT_MARKS));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001979
1980 fclose(fp_out); /* errors are ignored !? */
1981 if (fp_in != NULL)
1982 {
1983 fclose(fp_in);
Bram Moolenaarbca84a12005-12-14 22:08:35 +00001984
Bram Moolenaar071d4272004-06-13 20:20:40 +00001985 /*
Bram Moolenaarbca84a12005-12-14 22:08:35 +00001986 * In case of an error keep the original viminfo file.
1987 * Otherwise rename the newly written file.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001988 */
1989 if (viminfo_errcnt || vim_rename(tempname, fname) == -1)
1990 mch_remove(tempname);
Bram Moolenaarbca84a12005-12-14 22:08:35 +00001991
1992#ifdef WIN3264
1993 /* If the viminfo file was hidden then also hide the new file. */
1994 if (perm > 0 && (perm & FILE_ATTRIBUTE_HIDDEN))
1995 mch_hide(fname);
1996#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001997 }
Bram Moolenaarbca84a12005-12-14 22:08:35 +00001998
Bram Moolenaar071d4272004-06-13 20:20:40 +00001999end:
2000 vim_free(fname);
2001 vim_free(tempname);
2002}
2003
2004/*
2005 * Get the viminfo file name to use.
2006 * If "file" is given and not empty, use it (has already been expanded by
2007 * cmdline functions).
2008 * Otherwise use "-i file_name", value from 'viminfo' or the default, and
2009 * expand environment variables.
2010 * Returns an allocated string. NULL when out of memory.
2011 */
2012 static char_u *
2013viminfo_filename(file)
2014 char_u *file;
2015{
2016 if (file == NULL || *file == NUL)
2017 {
2018 if (use_viminfo != NULL)
2019 file = use_viminfo;
2020 else if ((file = find_viminfo_parameter('n')) == NULL || *file == NUL)
2021 {
2022#ifdef VIMINFO_FILE2
2023 /* don't use $HOME when not defined (turned into "c:/"!). */
2024# ifdef VMS
2025 if (mch_getenv((char_u *)"SYS$LOGIN") == NULL)
2026# else
2027 if (mch_getenv((char_u *)"HOME") == NULL)
2028# endif
2029 {
2030 /* don't use $VIM when not available. */
2031 expand_env((char_u *)"$VIM", NameBuff, MAXPATHL);
2032 if (STRCMP("$VIM", NameBuff) != 0) /* $VIM was expanded */
2033 file = (char_u *)VIMINFO_FILE2;
2034 else
2035 file = (char_u *)VIMINFO_FILE;
2036 }
2037 else
2038#endif
2039 file = (char_u *)VIMINFO_FILE;
2040 }
2041 expand_env(file, NameBuff, MAXPATHL);
2042 file = NameBuff;
2043 }
2044 return vim_strsave(file);
2045}
2046
2047/*
2048 * do_viminfo() -- Should only be called from read_viminfo() & write_viminfo().
2049 */
2050 static void
Bram Moolenaard812df62008-11-09 12:46:09 +00002051do_viminfo(fp_in, fp_out, flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002052 FILE *fp_in;
2053 FILE *fp_out;
Bram Moolenaard812df62008-11-09 12:46:09 +00002054 int flags;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002055{
2056 int count = 0;
2057 int eof = FALSE;
2058 vir_T vir;
2059
2060 if ((vir.vir_line = alloc(LSIZE)) == NULL)
2061 return;
2062 vir.vir_fd = fp_in;
2063#ifdef FEAT_MBYTE
2064 vir.vir_conv.vc_type = CONV_NONE;
2065#endif
2066
2067 if (fp_in != NULL)
2068 {
Bram Moolenaard812df62008-11-09 12:46:09 +00002069 if (flags & VIF_WANT_INFO)
2070 eof = read_viminfo_up_to_marks(&vir,
2071 flags & VIF_FORCEIT, fp_out != NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002072 else
2073 /* Skip info, find start of marks */
2074 while (!(eof = viminfo_readline(&vir))
2075 && vir.vir_line[0] != '>')
2076 ;
2077 }
2078 if (fp_out != NULL)
2079 {
2080 /* Write the info: */
2081 fprintf(fp_out, _("# This viminfo file was generated by Vim %s.\n"),
2082 VIM_VERSION_MEDIUM);
2083 fprintf(fp_out, _("# You may edit it if you're careful!\n\n"));
2084#ifdef FEAT_MBYTE
2085 fprintf(fp_out, _("# Value of 'encoding' when this file was written\n"));
2086 fprintf(fp_out, "*encoding=%s\n\n", p_enc);
2087#endif
2088 write_viminfo_search_pattern(fp_out);
2089 write_viminfo_sub_string(fp_out);
2090#ifdef FEAT_CMDHIST
2091 write_viminfo_history(fp_out);
2092#endif
2093 write_viminfo_registers(fp_out);
2094#ifdef FEAT_EVAL
2095 write_viminfo_varlist(fp_out);
2096#endif
2097 write_viminfo_filemarks(fp_out);
2098 write_viminfo_bufferlist(fp_out);
2099 count = write_viminfo_marks(fp_out);
2100 }
Bram Moolenaard812df62008-11-09 12:46:09 +00002101 if (fp_in != NULL
2102 && (flags & (VIF_WANT_MARKS | VIF_GET_OLDFILES | VIF_FORCEIT)))
2103 copy_viminfo_marks(&vir, fp_out, count, eof, flags);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002104
2105 vim_free(vir.vir_line);
2106#ifdef FEAT_MBYTE
2107 if (vir.vir_conv.vc_type != CONV_NONE)
2108 convert_setup(&vir.vir_conv, NULL, NULL);
2109#endif
2110}
2111
2112/*
2113 * read_viminfo_up_to_marks() -- Only called from do_viminfo(). Reads in the
2114 * first part of the viminfo file which contains everything but the marks that
2115 * are local to a file. Returns TRUE when end-of-file is reached. -- webb
2116 */
2117 static int
2118read_viminfo_up_to_marks(virp, forceit, writing)
2119 vir_T *virp;
2120 int forceit;
2121 int writing;
2122{
2123 int eof;
2124 buf_T *buf;
2125
2126#ifdef FEAT_CMDHIST
2127 prepare_viminfo_history(forceit ? 9999 : 0);
2128#endif
2129 eof = viminfo_readline(virp);
2130 while (!eof && virp->vir_line[0] != '>')
2131 {
2132 switch (virp->vir_line[0])
2133 {
2134 /* Characters reserved for future expansion, ignored now */
2135 case '+': /* "+40 /path/dir file", for running vim without args */
2136 case '|': /* to be defined */
2137 case '^': /* to be defined */
2138 case '<': /* long line - ignored */
2139 /* A comment or empty line. */
2140 case NUL:
2141 case '\r':
2142 case '\n':
2143 case '#':
2144 eof = viminfo_readline(virp);
2145 break;
2146 case '*': /* "*encoding=value" */
2147 eof = viminfo_encoding(virp);
2148 break;
2149 case '!': /* global variable */
2150#ifdef FEAT_EVAL
2151 eof = read_viminfo_varlist(virp, writing);
2152#else
2153 eof = viminfo_readline(virp);
2154#endif
2155 break;
2156 case '%': /* entry for buffer list */
2157 eof = read_viminfo_bufferlist(virp, writing);
2158 break;
2159 case '"':
2160 eof = read_viminfo_register(virp, forceit);
2161 break;
2162 case '/': /* Search string */
2163 case '&': /* Substitute search string */
2164 case '~': /* Last search string, followed by '/' or '&' */
2165 eof = read_viminfo_search_pattern(virp, forceit);
2166 break;
2167 case '$':
2168 eof = read_viminfo_sub_string(virp, forceit);
2169 break;
2170 case ':':
2171 case '?':
2172 case '=':
2173 case '@':
2174#ifdef FEAT_CMDHIST
2175 eof = read_viminfo_history(virp);
2176#else
2177 eof = viminfo_readline(virp);
2178#endif
2179 break;
2180 case '-':
2181 case '\'':
2182 eof = read_viminfo_filemark(virp, forceit);
2183 break;
2184 default:
2185 if (viminfo_error("E575: ", _("Illegal starting char"),
2186 virp->vir_line))
2187 eof = TRUE;
2188 else
2189 eof = viminfo_readline(virp);
2190 break;
2191 }
2192 }
2193
2194#ifdef FEAT_CMDHIST
2195 /* Finish reading history items. */
2196 finish_viminfo_history();
2197#endif
2198
2199 /* Change file names to buffer numbers for fmarks. */
2200 for (buf = firstbuf; buf != NULL; buf = buf->b_next)
2201 fmarks_check_names(buf);
2202
2203 return eof;
2204}
2205
2206/*
2207 * Compare the 'encoding' value in the viminfo file with the current value of
2208 * 'encoding'. If different and the 'c' flag is in 'viminfo', setup for
2209 * conversion of text with iconv() in viminfo_readstring().
2210 */
2211 static int
2212viminfo_encoding(virp)
2213 vir_T *virp;
2214{
2215#ifdef FEAT_MBYTE
2216 char_u *p;
2217 int i;
2218
2219 if (get_viminfo_parameter('c') != 0)
2220 {
2221 p = vim_strchr(virp->vir_line, '=');
2222 if (p != NULL)
2223 {
2224 /* remove trailing newline */
2225 ++p;
2226 for (i = 0; vim_isprintc(p[i]); ++i)
2227 ;
2228 p[i] = NUL;
2229
2230 convert_setup(&virp->vir_conv, p, p_enc);
2231 }
2232 }
2233#endif
2234 return viminfo_readline(virp);
2235}
2236
2237/*
2238 * Read a line from the viminfo file.
2239 * Returns TRUE for end-of-file;
2240 */
2241 int
2242viminfo_readline(virp)
2243 vir_T *virp;
2244{
2245 return vim_fgets(virp->vir_line, LSIZE, virp->vir_fd);
2246}
2247
2248/*
2249 * check string read from viminfo file
2250 * remove '\n' at the end of the line
2251 * - replace CTRL-V CTRL-V with CTRL-V
2252 * - replace CTRL-V 'n' with '\n'
2253 *
2254 * Check for a long line as written by viminfo_writestring().
2255 *
2256 * Return the string in allocated memory (NULL when out of memory).
2257 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002258 char_u *
2259viminfo_readstring(virp, off, convert)
2260 vir_T *virp;
2261 int off; /* offset for virp->vir_line */
Bram Moolenaar2c4278f2009-05-17 11:33:22 +00002262 int convert UNUSED; /* convert the string */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002263{
2264 char_u *retval;
2265 char_u *s, *d;
2266 long len;
2267
2268 if (virp->vir_line[off] == Ctrl_V && vim_isdigit(virp->vir_line[off + 1]))
2269 {
2270 len = atol((char *)virp->vir_line + off + 1);
2271 retval = lalloc(len, TRUE);
2272 if (retval == NULL)
2273 {
2274 /* Line too long? File messed up? Skip next line. */
2275 (void)vim_fgets(virp->vir_line, 10, virp->vir_fd);
2276 return NULL;
2277 }
2278 (void)vim_fgets(retval, (int)len, virp->vir_fd);
2279 s = retval + 1; /* Skip the leading '<' */
2280 }
2281 else
2282 {
2283 retval = vim_strsave(virp->vir_line + off);
2284 if (retval == NULL)
2285 return NULL;
2286 s = retval;
2287 }
2288
2289 /* Change CTRL-V CTRL-V to CTRL-V and CTRL-V n to \n in-place. */
2290 d = retval;
2291 while (*s != NUL && *s != '\n')
2292 {
2293 if (s[0] == Ctrl_V && s[1] != NUL)
2294 {
2295 if (s[1] == 'n')
2296 *d++ = '\n';
2297 else
2298 *d++ = Ctrl_V;
2299 s += 2;
2300 }
2301 else
2302 *d++ = *s++;
2303 }
2304 *d = NUL;
2305
2306#ifdef FEAT_MBYTE
2307 if (convert && virp->vir_conv.vc_type != CONV_NONE && *retval != NUL)
2308 {
2309 d = string_convert(&virp->vir_conv, retval, NULL);
2310 if (d != NULL)
2311 {
2312 vim_free(retval);
2313 retval = d;
2314 }
2315 }
2316#endif
2317
2318 return retval;
2319}
2320
2321/*
2322 * write string to viminfo file
2323 * - replace CTRL-V with CTRL-V CTRL-V
2324 * - replace '\n' with CTRL-V 'n'
2325 * - add a '\n' at the end
2326 *
2327 * For a long line:
2328 * - write " CTRL-V <length> \n " in first line
2329 * - write " < <string> \n " in second line
2330 */
2331 void
2332viminfo_writestring(fd, p)
2333 FILE *fd;
2334 char_u *p;
2335{
2336 int c;
2337 char_u *s;
2338 int len = 0;
2339
2340 for (s = p; *s != NUL; ++s)
2341 {
2342 if (*s == Ctrl_V || *s == '\n')
2343 ++len;
2344 ++len;
2345 }
2346
2347 /* If the string will be too long, write its length and put it in the next
2348 * line. Take into account that some room is needed for what comes before
2349 * the string (e.g., variable name). Add something to the length for the
2350 * '<', NL and trailing NUL. */
2351 if (len > LSIZE / 2)
2352 fprintf(fd, IF_EB("\026%d\n<", CTRL_V_STR "%d\n<"), len + 3);
2353
2354 while ((c = *p++) != NUL)
2355 {
2356 if (c == Ctrl_V || c == '\n')
2357 {
2358 putc(Ctrl_V, fd);
2359 if (c == '\n')
2360 c = 'n';
2361 }
2362 putc(c, fd);
2363 }
2364 putc('\n', fd);
2365}
2366#endif /* FEAT_VIMINFO */
2367
2368/*
2369 * Implementation of ":fixdel", also used by get_stty().
2370 * <BS> resulting <Del>
2371 * ^? ^H
2372 * not ^? ^?
2373 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002374 void
2375do_fixdel(eap)
Bram Moolenaar0c094b92009-05-14 20:20:33 +00002376 exarg_T *eap UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002377{
2378 char_u *p;
2379
2380 p = find_termcode((char_u *)"kb");
2381 add_termcode((char_u *)"kD", p != NULL
2382 && *p == DEL ? (char_u *)CTRL_H_STR : DEL_STR, FALSE);
2383}
2384
2385 void
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00002386print_line_no_prefix(lnum, use_number, list)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002387 linenr_T lnum;
2388 int use_number;
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00002389 int list;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002390{
Bram Moolenaar592e0a22004-07-03 16:05:59 +00002391 char_u numbuf[30];
Bram Moolenaar071d4272004-06-13 20:20:40 +00002392
2393 if (curwin->w_p_nu || use_number)
2394 {
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00002395 vim_snprintf((char *)numbuf, sizeof(numbuf),
2396 "%*ld ", number_width(curwin), (long)lnum);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002397 msg_puts_attr(numbuf, hl_attr(HLF_N)); /* Highlight line nrs */
2398 }
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00002399 msg_prt_line(ml_get(lnum), list);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002400}
2401
2402/*
2403 * Print a text line. Also in silent mode ("ex -s").
2404 */
2405 void
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00002406print_line(lnum, use_number, list)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002407 linenr_T lnum;
2408 int use_number;
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00002409 int list;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002410{
2411 int save_silent = silent_mode;
2412
Bram Moolenaar071d4272004-06-13 20:20:40 +00002413 msg_start();
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00002414 silent_mode = FALSE;
2415 info_message = TRUE; /* use mch_msg(), not mch_errmsg() */
2416 print_line_no_prefix(lnum, use_number, list);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002417 if (save_silent)
2418 {
2419 msg_putchar('\n');
2420 cursor_on(); /* msg_start() switches it off */
2421 out_flush();
2422 silent_mode = save_silent;
2423 }
Bram Moolenaar65b9a6a2009-02-04 12:14:51 +00002424 info_message = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002425}
2426
2427/*
2428 * ":file[!] [fname]".
2429 */
2430 void
2431ex_file(eap)
2432 exarg_T *eap;
2433{
2434 char_u *fname, *sfname, *xfname;
2435 buf_T *buf;
2436
Bram Moolenaar325b7a22004-07-05 15:58:32 +00002437 /* ":0file" removes the file name. Check for illegal uses ":3file",
2438 * "0file name", etc. */
2439 if (eap->addr_count > 0
2440 && (*eap->arg != NUL
2441 || eap->line2 > 0
2442 || eap->addr_count > 1))
2443 {
2444 EMSG(_(e_invarg));
2445 return;
2446 }
2447
2448 if (*eap->arg != NUL || eap->addr_count == 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002449 {
2450#ifdef FEAT_AUTOCMD
2451 buf = curbuf;
2452 apply_autocmds(EVENT_BUFFILEPRE, NULL, NULL, FALSE, curbuf);
2453 /* buffer changed, don't change name now */
2454 if (buf != curbuf)
2455 return;
2456# ifdef FEAT_EVAL
2457 if (aborting()) /* autocmds may abort script processing */
2458 return;
2459# endif
2460#endif
2461 /*
2462 * The name of the current buffer will be changed.
2463 * A new (unlisted) buffer entry needs to be made to hold the old file
2464 * name, which will become the alternate file name.
Bram Moolenaar7b0294c2004-10-11 10:16:09 +00002465 * But don't set the alternate file name if the buffer didn't have a
2466 * name.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002467 */
2468 fname = curbuf->b_ffname;
2469 sfname = curbuf->b_sfname;
2470 xfname = curbuf->b_fname;
2471 curbuf->b_ffname = NULL;
2472 curbuf->b_sfname = NULL;
2473 if (setfname(curbuf, eap->arg, NULL, TRUE) == FAIL)
2474 {
2475 curbuf->b_ffname = fname;
2476 curbuf->b_sfname = sfname;
2477 return;
2478 }
2479 curbuf->b_flags |= BF_NOTEDITED;
Bram Moolenaar7b0294c2004-10-11 10:16:09 +00002480 if (xfname != NULL && *xfname != NUL)
2481 {
2482 buf = buflist_new(fname, xfname, curwin->w_cursor.lnum, 0);
2483 if (buf != NULL && !cmdmod.keepalt)
2484 curwin->w_alt_fnum = buf->b_fnum;
2485 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002486 vim_free(fname);
2487 vim_free(sfname);
2488#ifdef FEAT_AUTOCMD
2489 apply_autocmds(EVENT_BUFFILEPOST, NULL, NULL, FALSE, curbuf);
2490#endif
Bram Moolenaar498efdb2006-09-05 14:31:54 +00002491 /* Change directories when the 'acd' option is set. */
2492 DO_AUTOCHDIR
Bram Moolenaar071d4272004-06-13 20:20:40 +00002493 }
2494 /* print full file name if :cd used */
2495 fileinfo(FALSE, FALSE, eap->forceit);
2496}
2497
2498/*
2499 * ":update".
2500 */
2501 void
2502ex_update(eap)
2503 exarg_T *eap;
2504{
2505 if (curbufIsChanged())
2506 (void)do_write(eap);
2507}
2508
2509/*
2510 * ":write" and ":saveas".
2511 */
2512 void
2513ex_write(eap)
2514 exarg_T *eap;
2515{
2516 if (eap->usefilter) /* input lines to shell command */
2517 do_bang(1, eap, FALSE, TRUE, FALSE);
2518 else
2519 (void)do_write(eap);
2520}
2521
2522/*
2523 * write current buffer to file 'eap->arg'
2524 * if 'eap->append' is TRUE, append to the file
2525 *
2526 * if *eap->arg == NUL write to current file
2527 *
2528 * return FAIL for failure, OK otherwise
2529 */
2530 int
2531do_write(eap)
2532 exarg_T *eap;
2533{
2534 int other;
2535 char_u *fname = NULL; /* init to shut up gcc */
2536 char_u *ffname;
2537 int retval = FAIL;
2538 char_u *free_fname = NULL;
2539#ifdef FEAT_BROWSE
2540 char_u *browse_file = NULL;
2541#endif
2542 buf_T *alt_buf = NULL;
2543
2544 if (not_writing()) /* check 'write' option */
2545 return FAIL;
2546
2547 ffname = eap->arg;
2548#ifdef FEAT_BROWSE
2549 if (cmdmod.browse)
2550 {
Bram Moolenaar7b0294c2004-10-11 10:16:09 +00002551 browse_file = do_browse(BROWSE_SAVE, (char_u *)_("Save As"), ffname,
Bram Moolenaar071d4272004-06-13 20:20:40 +00002552 NULL, NULL, NULL, curbuf);
2553 if (browse_file == NULL)
2554 goto theend;
2555 ffname = browse_file;
2556 }
2557#endif
2558 if (*ffname == NUL)
2559 {
2560 if (eap->cmdidx == CMD_saveas)
2561 {
2562 EMSG(_(e_argreq));
2563 goto theend;
2564 }
2565 other = FALSE;
2566 }
2567 else
2568 {
2569 fname = ffname;
2570 free_fname = fix_fname(ffname);
2571 /*
2572 * When out-of-memory, keep unexpanded file name, because we MUST be
2573 * able to write the file in this situation.
2574 */
2575 if (free_fname != NULL)
2576 ffname = free_fname;
2577 other = otherfile(ffname);
2578 }
2579
2580 /*
2581 * If we have a new file, put its name in the list of alternate file names.
2582 */
2583 if (other)
2584 {
2585 if (vim_strchr(p_cpo, CPO_ALTWRITE) != NULL
2586 || eap->cmdidx == CMD_saveas)
2587 alt_buf = setaltfname(ffname, fname, (linenr_T)1);
2588 else
2589 alt_buf = buflist_findname(ffname);
2590 if (alt_buf != NULL && alt_buf->b_ml.ml_mfp != NULL)
2591 {
2592 /* Overwriting a file that is loaded in another buffer is not a
2593 * good idea. */
Bram Moolenaar0e4d8772005-06-07 21:12:49 +00002594 EMSG(_(e_bufloaded));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002595 goto theend;
2596 }
2597 }
2598
2599 /*
2600 * Writing to the current file is not allowed in readonly mode
2601 * and a file name is required.
2602 * "nofile" and "nowrite" buffers cannot be written implicitly either.
2603 */
2604 if (!other && (
2605#ifdef FEAT_QUICKFIX
2606 bt_dontwrite_msg(curbuf) ||
2607#endif
2608 check_fname() == FAIL || check_readonly(&eap->forceit, curbuf)))
2609 goto theend;
2610
2611 if (!other)
2612 {
2613 ffname = curbuf->b_ffname;
2614 fname = curbuf->b_fname;
2615 /*
2616 * Not writing the whole file is only allowed with '!'.
2617 */
2618 if ( (eap->line1 != 1
2619 || eap->line2 != curbuf->b_ml.ml_line_count)
2620 && !eap->forceit
2621 && !eap->append
2622 && !p_wa)
2623 {
2624#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
2625 if (p_confirm || cmdmod.confirm)
2626 {
2627 if (vim_dialog_yesno(VIM_QUESTION, NULL,
2628 (char_u *)_("Write partial file?"), 2) != VIM_YES)
2629 goto theend;
2630 eap->forceit = TRUE;
2631 }
2632 else
2633#endif
2634 {
2635 EMSG(_("E140: Use ! to write partial buffer"));
2636 goto theend;
2637 }
2638 }
2639 }
2640
2641 if (check_overwrite(eap, curbuf, fname, ffname, other) == OK)
2642 {
2643 if (eap->cmdidx == CMD_saveas && alt_buf != NULL)
2644 {
2645#ifdef FEAT_AUTOCMD
2646 buf_T *was_curbuf = curbuf;
2647
2648 apply_autocmds(EVENT_BUFFILEPRE, NULL, NULL, FALSE, curbuf);
Bram Moolenaar269ec652004-07-29 08:43:53 +00002649 apply_autocmds(EVENT_BUFFILEPRE, NULL, NULL, FALSE, alt_buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002650# ifdef FEAT_EVAL
2651 if (curbuf != was_curbuf || aborting())
2652# else
2653 if (curbuf != was_curbuf)
2654# endif
2655 {
2656 /* buffer changed, don't change name now */
2657 retval = FAIL;
2658 goto theend;
2659 }
2660#endif
2661 /* Exchange the file names for the current and the alternate
2662 * buffer. This makes it look like we are now editing the buffer
2663 * under the new name. Must be done before buf_write(), because
2664 * if there is no file name and 'cpo' contains 'F', it will set
2665 * the file name. */
2666 fname = alt_buf->b_fname;
2667 alt_buf->b_fname = curbuf->b_fname;
2668 curbuf->b_fname = fname;
2669 fname = alt_buf->b_ffname;
2670 alt_buf->b_ffname = curbuf->b_ffname;
2671 curbuf->b_ffname = fname;
2672 fname = alt_buf->b_sfname;
2673 alt_buf->b_sfname = curbuf->b_sfname;
2674 curbuf->b_sfname = fname;
2675 buf_name_changed(curbuf);
2676#ifdef FEAT_AUTOCMD
2677 apply_autocmds(EVENT_BUFFILEPOST, NULL, NULL, FALSE, curbuf);
Bram Moolenaar269ec652004-07-29 08:43:53 +00002678 apply_autocmds(EVENT_BUFFILEPOST, NULL, NULL, FALSE, alt_buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002679 if (!alt_buf->b_p_bl)
2680 {
2681 alt_buf->b_p_bl = TRUE;
2682 apply_autocmds(EVENT_BUFADD, NULL, NULL, FALSE, alt_buf);
2683 }
2684# ifdef FEAT_EVAL
2685 if (curbuf != was_curbuf || aborting())
2686# else
2687 if (curbuf != was_curbuf)
2688# endif
2689 {
2690 /* buffer changed, don't write the file */
2691 retval = FAIL;
2692 goto theend;
2693 }
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00002694
2695 /* If 'filetype' was empty try detecting it now. */
2696 if (*curbuf->b_p_ft == NUL)
2697 {
Bram Moolenaar910f66f2006-04-05 20:41:53 +00002698 if (au_has_group((char_u *)"filetypedetect"))
2699 (void)do_doautocmd((char_u *)"filetypedetect BufRead",
2700 TRUE);
Bram Moolenaara3227e22006-03-08 21:32:40 +00002701 do_modelines(0);
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00002702 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002703#endif
2704 }
2705
2706 retval = buf_write(curbuf, ffname, fname, eap->line1, eap->line2,
2707 eap, eap->append, eap->forceit, TRUE, FALSE);
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00002708
Bram Moolenaar910f66f2006-04-05 20:41:53 +00002709 /* After ":saveas fname" reset 'readonly'. */
Bram Moolenaar498efdb2006-09-05 14:31:54 +00002710 if (eap->cmdidx == CMD_saveas)
2711 {
2712 if (retval == OK)
Bram Moolenaar4352f132009-02-11 15:03:45 +00002713 {
Bram Moolenaar498efdb2006-09-05 14:31:54 +00002714 curbuf->b_p_ro = FALSE;
Bram Moolenaar4352f132009-02-11 15:03:45 +00002715#ifdef FEAT_WINDOWS
2716 redraw_tabline = TRUE;
2717#endif
2718 }
Bram Moolenaar498efdb2006-09-05 14:31:54 +00002719 /* Change directories when the 'acd' option is set. */
2720 DO_AUTOCHDIR
2721 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002722 }
2723
2724theend:
2725#ifdef FEAT_BROWSE
2726 vim_free(browse_file);
2727#endif
2728 vim_free(free_fname);
2729 return retval;
2730}
2731
2732/*
2733 * Check if it is allowed to overwrite a file. If b_flags has BF_NOTEDITED,
2734 * BF_NEW or BF_READERR, check for overwriting current file.
2735 * May set eap->forceit if a dialog says it's OK to overwrite.
2736 * Return OK if it's OK, FAIL if it is not.
2737 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002738 static int
2739check_overwrite(eap, buf, fname, ffname, other)
2740 exarg_T *eap;
2741 buf_T *buf;
2742 char_u *fname; /* file name to be used (can differ from
2743 buf->ffname) */
2744 char_u *ffname; /* full path version of fname */
2745 int other; /* writing under other name */
2746{
2747 /*
2748 * write to other file or b_flags set or not writing the whole file:
2749 * overwriting only allowed with '!'
2750 */
2751 if ( (other
2752 || (buf->b_flags & BF_NOTEDITED)
2753 || ((buf->b_flags & BF_NEW)
2754 && vim_strchr(p_cpo, CPO_OVERNEW) == NULL)
2755 || (buf->b_flags & BF_READERR))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002756 && !p_wa
Bram Moolenaar11717bb2007-12-08 21:21:18 +00002757#ifdef FEAT_QUICKFIX
2758 && !bt_nofile(buf)
2759#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002760 && vim_fexists(ffname))
2761 {
Bram Moolenaar04a09c12005-08-01 22:02:32 +00002762 if (!eap->forceit && !eap->append)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002763 {
Bram Moolenaar04a09c12005-08-01 22:02:32 +00002764#ifdef UNIX
Bram Moolenaar0ac93792006-01-21 22:16:51 +00002765 /* with UNIX it is possible to open a directory */
Bram Moolenaar04a09c12005-08-01 22:02:32 +00002766 if (mch_isdir(ffname))
2767 {
2768 EMSG2(_(e_isadir2), ffname);
2769 return FAIL;
2770 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002771#endif
2772#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
Bram Moolenaar04a09c12005-08-01 22:02:32 +00002773 if (p_confirm || cmdmod.confirm)
2774 {
2775 char_u buff[IOSIZE];
Bram Moolenaar071d4272004-06-13 20:20:40 +00002776
Bram Moolenaar04a09c12005-08-01 22:02:32 +00002777 dialog_msg(buff, _("Overwrite existing file \"%s\"?"), fname);
2778 if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 2) != VIM_YES)
2779 return FAIL;
2780 eap->forceit = TRUE;
2781 }
2782 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00002783#endif
Bram Moolenaar04a09c12005-08-01 22:02:32 +00002784 {
2785 EMSG(_(e_exists));
2786 return FAIL;
2787 }
2788 }
2789
2790 /* For ":w! filename" check that no swap file exists for "filename". */
2791 if (other && !emsg_silent)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002792 {
Bram Moolenaar04a09c12005-08-01 22:02:32 +00002793 char_u dir[MAXPATHL];
2794 char_u *p;
2795 int r;
2796 char_u *swapname;
2797
2798 /* We only try the first entry in 'directory', without checking if
2799 * it's writable. If the "." directory is not writable the write
2800 * will probably fail anyway.
2801 * Use 'shortname' of the current buffer, since there is no buffer
2802 * for the written file. */
2803 if (*p_dir == NUL)
2804 STRCPY(dir, ".");
2805 else
2806 {
2807 p = p_dir;
2808 copy_option_part(&p, dir, MAXPATHL, ",");
2809 }
2810 swapname = makeswapname(fname, ffname, curbuf, dir);
2811 r = vim_fexists(swapname);
Bram Moolenaar04a09c12005-08-01 22:02:32 +00002812 if (r)
2813 {
2814#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
2815 if (p_confirm || cmdmod.confirm)
2816 {
2817 char_u buff[IOSIZE];
2818
2819 dialog_msg(buff,
2820 _("Swap file \"%s\" exists, overwrite anyway?"),
2821 swapname);
2822 if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 2)
2823 != VIM_YES)
Bram Moolenaar910f66f2006-04-05 20:41:53 +00002824 {
2825 vim_free(swapname);
Bram Moolenaar04a09c12005-08-01 22:02:32 +00002826 return FAIL;
Bram Moolenaar910f66f2006-04-05 20:41:53 +00002827 }
Bram Moolenaar04a09c12005-08-01 22:02:32 +00002828 eap->forceit = TRUE;
2829 }
2830 else
2831#endif
2832 {
2833 EMSG2(_("E768: Swap file exists: %s (:silent! overrides)"),
2834 swapname);
Bram Moolenaar910f66f2006-04-05 20:41:53 +00002835 vim_free(swapname);
Bram Moolenaar04a09c12005-08-01 22:02:32 +00002836 return FAIL;
2837 }
2838 }
Bram Moolenaar910f66f2006-04-05 20:41:53 +00002839 vim_free(swapname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002840 }
2841 }
2842 return OK;
2843}
2844
2845/*
2846 * Handle ":wnext", ":wNext" and ":wprevious" commands.
2847 */
2848 void
2849ex_wnext(eap)
2850 exarg_T *eap;
2851{
2852 int i;
2853
2854 if (eap->cmd[1] == 'n')
2855 i = curwin->w_arg_idx + (int)eap->line2;
2856 else
2857 i = curwin->w_arg_idx - (int)eap->line2;
2858 eap->line1 = 1;
2859 eap->line2 = curbuf->b_ml.ml_line_count;
2860 if (do_write(eap) != FAIL)
2861 do_argfile(eap, i);
2862}
2863
2864/*
2865 * ":wall", ":wqall" and ":xall": Write all changed files (and exit).
2866 */
2867 void
2868do_wqall(eap)
2869 exarg_T *eap;
2870{
2871 buf_T *buf;
2872 int error = 0;
2873 int save_forceit = eap->forceit;
2874
2875 if (eap->cmdidx == CMD_xall || eap->cmdidx == CMD_wqall)
2876 exiting = TRUE;
2877
2878 for (buf = firstbuf; buf != NULL; buf = buf->b_next)
2879 {
2880 if (bufIsChanged(buf))
2881 {
2882 /*
2883 * Check if there is a reason the buffer cannot be written:
2884 * 1. if the 'write' option is set
2885 * 2. if there is no file name (even after browsing)
2886 * 3. if the 'readonly' is set (even after a dialog)
2887 * 4. if overwriting is allowed (even after a dialog)
2888 */
2889 if (not_writing())
2890 {
2891 ++error;
2892 break;
2893 }
2894#ifdef FEAT_BROWSE
2895 /* ":browse wall": ask for file name if there isn't one */
2896 if (buf->b_ffname == NULL && cmdmod.browse)
2897 browse_save_fname(buf);
2898#endif
2899 if (buf->b_ffname == NULL)
2900 {
2901 EMSGN(_("E141: No file name for buffer %ld"), (long)buf->b_fnum);
2902 ++error;
2903 }
2904 else if (check_readonly(&eap->forceit, buf)
2905 || check_overwrite(eap, buf, buf->b_fname, buf->b_ffname,
2906 FALSE) == FAIL)
2907 {
2908 ++error;
2909 }
2910 else
2911 {
2912 if (buf_write_all(buf, eap->forceit) == FAIL)
2913 ++error;
2914#ifdef FEAT_AUTOCMD
2915 /* an autocommand may have deleted the buffer */
2916 if (!buf_valid(buf))
2917 buf = firstbuf;
2918#endif
2919 }
2920 eap->forceit = save_forceit; /* check_overwrite() may set it */
2921 }
2922 }
2923 if (exiting)
2924 {
2925 if (!error)
2926 getout(0); /* exit Vim */
2927 not_exiting();
2928 }
2929}
2930
2931/*
2932 * Check the 'write' option.
2933 * Return TRUE and give a message when it's not st.
2934 */
2935 int
2936not_writing()
2937{
2938 if (p_write)
2939 return FALSE;
2940 EMSG(_("E142: File not written: Writing is disabled by 'write' option"));
2941 return TRUE;
2942}
2943
2944/*
Bram Moolenaar5386a122007-06-28 20:02:32 +00002945 * Check if a buffer is read-only (either 'readonly' option is set or file is
2946 * read-only). Ask for overruling in a dialog. Return TRUE and give an error
2947 * message when the buffer is readonly.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002948 */
2949 static int
2950check_readonly(forceit, buf)
2951 int *forceit;
2952 buf_T *buf;
2953{
Bram Moolenaar5386a122007-06-28 20:02:32 +00002954 struct stat st;
2955
2956 /* Handle a file being readonly when the 'readonly' option is set or when
2957 * the file exists and permissions are read-only.
2958 * We will send 0777 to check_file_readonly(), as the "perm" variable is
2959 * important for device checks but not here. */
2960 if (!*forceit && (buf->b_p_ro
2961 || (mch_stat((char *)buf->b_ffname, &st) >= 0
2962 && check_file_readonly(buf->b_ffname, 0777))))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002963 {
2964#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
2965 if ((p_confirm || cmdmod.confirm) && buf->b_fname != NULL)
2966 {
2967 char_u buff[IOSIZE];
2968
Bram Moolenaar5386a122007-06-28 20:02:32 +00002969 if (buf->b_p_ro)
2970 dialog_msg(buff, _("'readonly' option is set for \"%s\".\nDo you wish to write anyway?"),
2971 buf->b_fname);
2972 else
2973 dialog_msg(buff, _("File permissions of \"%s\" are read-only.\nIt may still be possible to write it.\nDo you wish to try?"),
Bram Moolenaar071d4272004-06-13 20:20:40 +00002974 buf->b_fname);
2975
2976 if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 2) == VIM_YES)
2977 {
2978 /* Set forceit, to force the writing of a readonly file */
2979 *forceit = TRUE;
2980 return FALSE;
2981 }
2982 else
2983 return TRUE;
2984 }
2985 else
2986#endif
Bram Moolenaar5386a122007-06-28 20:02:32 +00002987 if (buf->b_p_ro)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002988 EMSG(_(e_readonly));
Bram Moolenaar5386a122007-06-28 20:02:32 +00002989 else
2990 EMSG2(_("E505: \"%s\" is read-only (add ! to override)"),
2991 buf->b_fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002992 return TRUE;
2993 }
Bram Moolenaar5386a122007-06-28 20:02:32 +00002994
Bram Moolenaar071d4272004-06-13 20:20:40 +00002995 return FALSE;
2996}
2997
2998/*
Bram Moolenaar8ada17c2006-01-19 22:16:24 +00002999 * Try to abandon current file and edit a new or existing file.
3000 * 'fnum' is the number of the file, if zero use ffname/sfname.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003001 *
Bram Moolenaar8ada17c2006-01-19 22:16:24 +00003002 * Return 1 for "normal" error, 2 for "not written" error, 0 for success
Bram Moolenaareb1b6792007-08-21 13:29:28 +00003003 * -1 for successfully opening another file.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003004 * 'lnum' is the line number for the cursor in the new file (if non-zero).
3005 */
3006 int
3007getfile(fnum, ffname, sfname, setpm, lnum, forceit)
3008 int fnum;
3009 char_u *ffname;
3010 char_u *sfname;
3011 int setpm;
3012 linenr_T lnum;
3013 int forceit;
3014{
3015 int other;
3016 int retval;
3017 char_u *free_me = NULL;
3018
Bram Moolenaarb71eaae2006-01-20 23:10:18 +00003019 if (text_locked())
Bram Moolenaar071d4272004-06-13 20:20:40 +00003020 return 1;
Bram Moolenaar910f66f2006-04-05 20:41:53 +00003021#ifdef FEAT_AUTOCMD
3022 if (curbuf_locked())
3023 return 1;
3024#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003025
3026 if (fnum == 0)
3027 {
3028 /* make ffname full path, set sfname */
3029 fname_expand(curbuf, &ffname, &sfname);
3030 other = otherfile(ffname);
3031 free_me = ffname; /* has been allocated, free() later */
3032 }
3033 else
3034 other = (fnum != curbuf->b_fnum);
3035
3036 if (other)
3037 ++no_wait_return; /* don't wait for autowrite message */
3038 if (other && !forceit && curbuf->b_nwindows == 1 && !P_HID(curbuf)
3039 && curbufIsChanged() && autowrite(curbuf, forceit) == FAIL)
3040 {
3041#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
3042 if (p_confirm && p_write)
3043 dialog_changed(curbuf, FALSE);
3044 if (curbufIsChanged())
3045#endif
3046 {
3047 if (other)
3048 --no_wait_return;
3049 EMSG(_(e_nowrtmsg));
3050 retval = 2; /* file has been changed */
3051 goto theend;
3052 }
3053 }
3054 if (other)
3055 --no_wait_return;
3056 if (setpm)
3057 setpcmark();
3058 if (!other)
3059 {
3060 if (lnum != 0)
3061 curwin->w_cursor.lnum = lnum;
3062 check_cursor_lnum();
3063 beginline(BL_SOL | BL_FIX);
3064 retval = 0; /* it's in the same file */
3065 }
3066 else if (do_ecmd(fnum, ffname, sfname, NULL, lnum,
Bram Moolenaar701f7af2008-11-15 13:12:07 +00003067 (P_HID(curbuf) ? ECMD_HIDE : 0) + (forceit ? ECMD_FORCEIT : 0),
3068 curwin) == OK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003069 retval = -1; /* opened another file */
3070 else
3071 retval = 1; /* error encountered */
3072
3073theend:
3074 vim_free(free_me);
3075 return retval;
3076}
3077
3078/*
3079 * start editing a new file
3080 *
3081 * fnum: file number; if zero use ffname/sfname
3082 * ffname: the file name
3083 * - full path if sfname used,
3084 * - any file name if sfname is NULL
3085 * - empty string to re-edit with the same file name (but may be
3086 * in a different directory)
3087 * - NULL to start an empty buffer
3088 * sfname: the short file name (or NULL)
3089 * eap: contains the command to be executed after loading the file and
3090 * forced 'ff' and 'fenc'
3091 * newlnum: if > 0: put cursor on this line number (if possible)
3092 * if ECMD_LASTL: use last position in loaded file
3093 * if ECMD_LAST: use last position in all files
3094 * if ECMD_ONE: use first line
3095 * flags:
3096 * ECMD_HIDE: if TRUE don't free the current buffer
3097 * ECMD_SET_HELP: set b_help flag of (new) buffer before opening file
3098 * ECMD_OLDBUF: use existing buffer if it exists
3099 * ECMD_FORCEIT: ! used for Ex command
3100 * ECMD_ADDBUF: don't edit, just add to buffer list
Bram Moolenaar701f7af2008-11-15 13:12:07 +00003101 * oldwin: Should be "curwin" when editing a new buffer in the current
3102 * window, NULL when splitting the window first. When not NULL info
3103 * of the previous buffer for "oldwin" is stored.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003104 *
3105 * return FAIL for failure, OK otherwise
3106 */
3107 int
Bram Moolenaar701f7af2008-11-15 13:12:07 +00003108do_ecmd(fnum, ffname, sfname, eap, newlnum, flags, oldwin)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003109 int fnum;
3110 char_u *ffname;
3111 char_u *sfname;
3112 exarg_T *eap; /* can be NULL! */
3113 linenr_T newlnum;
3114 int flags;
Bram Moolenaar701f7af2008-11-15 13:12:07 +00003115 win_T *oldwin;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003116{
3117 int other_file; /* TRUE if editing another file */
3118 int oldbuf; /* TRUE if using existing buffer */
3119#ifdef FEAT_AUTOCMD
3120 int auto_buf = FALSE; /* TRUE if autocommands brought us
3121 into the buffer unexpectedly */
3122 char_u *new_name = NULL;
Bram Moolenaar1f35bf92006-03-07 22:38:47 +00003123 int did_set_swapcommand = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003124#endif
3125 buf_T *buf;
3126#if defined(FEAT_AUTOCMD) || defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
3127 buf_T *old_curbuf = curbuf;
3128#endif
3129 char_u *free_fname = NULL;
3130#ifdef FEAT_BROWSE
3131 char_u *browse_file = NULL;
3132#endif
3133 int retval = FAIL;
3134 long n;
3135 linenr_T lnum;
3136 linenr_T topline = 0;
3137 int newcol = -1;
3138 int solcol = -1;
3139 pos_T *pos;
3140#ifdef FEAT_SUN_WORKSHOP
3141 char_u *cp;
3142#endif
3143 char_u *command = NULL;
Bram Moolenaar706cdeb2007-05-06 21:55:31 +00003144#ifdef FEAT_SPELL
3145 int did_get_winopts = FALSE;
3146#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003147
3148 if (eap != NULL)
3149 command = eap->do_ecmd_cmd;
3150
3151 if (fnum != 0)
3152 {
3153 if (fnum == curbuf->b_fnum) /* file is already being edited */
3154 return OK; /* nothing to do */
3155 other_file = TRUE;
3156 }
3157 else
3158 {
3159#ifdef FEAT_BROWSE
3160 if (cmdmod.browse)
3161 {
Bram Moolenaar15bfa092008-07-24 16:45:38 +00003162# ifdef FEAT_AUTOCMD
Bram Moolenaar0be6e642005-08-04 21:32:22 +00003163 if (
Bram Moolenaar15bfa092008-07-24 16:45:38 +00003164# ifdef FEAT_GUI
Bram Moolenaar0be6e642005-08-04 21:32:22 +00003165 !gui.in_use &&
Bram Moolenaar15bfa092008-07-24 16:45:38 +00003166# endif
Bram Moolenaar0be6e642005-08-04 21:32:22 +00003167 au_has_group((char_u *)"FileExplorer"))
3168 {
3169 /* No browsing supported but we do have the file explorer:
3170 * Edit the directory. */
3171 if (ffname == NULL || !mch_isdir(ffname))
3172 ffname = (char_u *)".";
3173 }
3174 else
Bram Moolenaar15bfa092008-07-24 16:45:38 +00003175# endif
Bram Moolenaar0be6e642005-08-04 21:32:22 +00003176 {
3177 browse_file = do_browse(0, (char_u *)_("Edit File"), ffname,
Bram Moolenaar071d4272004-06-13 20:20:40 +00003178 NULL, NULL, NULL, curbuf);
Bram Moolenaar0be6e642005-08-04 21:32:22 +00003179 if (browse_file == NULL)
3180 goto theend;
3181 ffname = browse_file;
3182 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003183 }
3184#endif
3185 /* if no short name given, use ffname for short name */
3186 if (sfname == NULL)
3187 sfname = ffname;
3188#ifdef USE_FNAME_CASE
3189# ifdef USE_LONG_FNAME
3190 if (USE_LONG_FNAME)
3191# endif
Bram Moolenaar342337a2005-07-21 21:11:17 +00003192 if (sfname != NULL)
3193 fname_case(sfname, 0); /* set correct case for sfname */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003194#endif
3195
3196#ifdef FEAT_LISTCMDS
3197 if ((flags & ECMD_ADDBUF) && (ffname == NULL || *ffname == NUL))
3198 goto theend;
3199#endif
3200
3201 if (ffname == NULL)
3202 other_file = TRUE;
3203 /* there is no file name */
3204 else if (*ffname == NUL && curbuf->b_ffname == NULL)
3205 other_file = FALSE;
3206 else
3207 {
3208 if (*ffname == NUL) /* re-edit with same file name */
3209 {
3210 ffname = curbuf->b_ffname;
3211 sfname = curbuf->b_fname;
3212 }
3213 free_fname = fix_fname(ffname); /* may expand to full path name */
3214 if (free_fname != NULL)
3215 ffname = free_fname;
3216 other_file = otherfile(ffname);
3217#ifdef FEAT_SUN_WORKSHOP
3218 if (usingSunWorkShop && p_acd
3219 && (cp = vim_strrchr(sfname, '/')) != NULL)
3220 sfname = ++cp;
3221#endif
3222 }
3223 }
3224
3225 /*
3226 * if the file was changed we may not be allowed to abandon it
3227 * - if we are going to re-edit the same file
3228 * - or if we are the only window on this file and if ECMD_HIDE is FALSE
3229 */
3230 if ( ((!other_file && !(flags & ECMD_OLDBUF))
3231 || (curbuf->b_nwindows == 1
3232 && !(flags & (ECMD_HIDE | ECMD_ADDBUF))))
3233 && check_changed(curbuf, p_awa, !other_file,
3234 (flags & ECMD_FORCEIT), FALSE))
3235 {
3236 if (fnum == 0 && other_file && ffname != NULL)
3237 (void)setaltfname(ffname, sfname, newlnum < 0 ? 0 : newlnum);
3238 goto theend;
3239 }
3240
3241#ifdef FEAT_VISUAL
3242 /*
3243 * End Visual mode before switching to another buffer, so the text can be
3244 * copied into the GUI selection buffer.
3245 */
3246 reset_VIsual();
3247#endif
3248
Bram Moolenaar1f35bf92006-03-07 22:38:47 +00003249#ifdef FEAT_AUTOCMD
3250 if ((command != NULL || newlnum > (linenr_T)0)
3251 && *get_vim_var_str(VV_SWAPCOMMAND) == NUL)
3252 {
3253 int len;
3254 char_u *p;
3255
3256 /* Set v:swapcommand for the SwapExists autocommands. */
3257 if (command != NULL)
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00003258 len = (int)STRLEN(command) + 3;
Bram Moolenaar1f35bf92006-03-07 22:38:47 +00003259 else
3260 len = 30;
3261 p = alloc((unsigned)len);
3262 if (p != NULL)
3263 {
3264 if (command != NULL)
3265 vim_snprintf((char *)p, len, ":%s\r", command);
3266 else
3267 vim_snprintf((char *)p, len, "%ldG", (long)newlnum);
3268 set_vim_var_string(VV_SWAPCOMMAND, p, -1);
3269 did_set_swapcommand = TRUE;
3270 vim_free(p);
3271 }
3272 }
3273#endif
3274
Bram Moolenaar071d4272004-06-13 20:20:40 +00003275 /*
3276 * If we are starting to edit another file, open a (new) buffer.
3277 * Otherwise we re-use the current buffer.
3278 */
3279 if (other_file)
3280 {
3281#ifdef FEAT_LISTCMDS
3282 if (!(flags & ECMD_ADDBUF))
3283#endif
3284 {
Bram Moolenaard4755bb2004-09-02 19:12:26 +00003285 if (!cmdmod.keepalt)
3286 curwin->w_alt_fnum = curbuf->b_fnum;
Bram Moolenaar701f7af2008-11-15 13:12:07 +00003287 if (oldwin != NULL)
3288 buflist_altfpos(oldwin);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003289 }
3290
3291 if (fnum)
3292 buf = buflist_findnr(fnum);
3293 else
3294 {
3295#ifdef FEAT_LISTCMDS
3296 if (flags & ECMD_ADDBUF)
3297 {
3298 linenr_T tlnum = 1L;
3299
3300 if (command != NULL)
3301 {
3302 tlnum = atol((char *)command);
3303 if (tlnum <= 0)
3304 tlnum = 1L;
3305 }
3306 (void)buflist_new(ffname, sfname, tlnum, BLN_LISTED);
3307 goto theend;
3308 }
3309#endif
3310 buf = buflist_new(ffname, sfname, 0L,
3311 BLN_CURBUF | ((flags & ECMD_SET_HELP) ? 0 : BLN_LISTED));
3312 }
3313 if (buf == NULL)
3314 goto theend;
3315 if (buf->b_ml.ml_mfp == NULL) /* no memfile yet */
3316 {
3317 oldbuf = FALSE;
3318 buf->b_nwindows = 0;
3319 }
3320 else /* existing memfile */
3321 {
3322 oldbuf = TRUE;
3323 (void)buf_check_timestamp(buf, FALSE);
3324 /* Check if autocommands made buffer invalid or changed the current
3325 * buffer. */
3326 if (!buf_valid(buf)
3327#ifdef FEAT_AUTOCMD
3328 || curbuf != old_curbuf
3329#endif
3330 )
3331 goto theend;
3332#ifdef FEAT_EVAL
3333 if (aborting()) /* autocmds may abort script processing */
3334 goto theend;
3335#endif
3336 }
3337
3338 /* May jump to last used line number for a loaded buffer or when asked
3339 * for explicitly */
3340 if ((oldbuf && newlnum == ECMD_LASTL) || newlnum == ECMD_LAST)
3341 {
3342 pos = buflist_findfpos(buf);
3343 newlnum = pos->lnum;
3344 solcol = pos->col;
3345 }
3346
3347 /*
3348 * Make the (new) buffer the one used by the current window.
3349 * If the old buffer becomes unused, free it if ECMD_HIDE is FALSE.
3350 * If the current buffer was empty and has no file name, curbuf
3351 * is returned by buflist_new().
3352 */
3353 if (buf != curbuf)
3354 {
3355#ifdef FEAT_AUTOCMD
3356 /*
3357 * Be careful: The autocommands may delete any buffer and change
3358 * the current buffer.
3359 * - If the buffer we are going to edit is deleted, give up.
3360 * - If the current buffer is deleted, prefer to load the new
3361 * buffer when loading a buffer is required. This avoids
3362 * loading another buffer which then must be closed again.
3363 * - If we ended up in the new buffer already, need to skip a few
3364 * things, set auto_buf.
3365 */
3366 if (buf->b_fname != NULL)
3367 new_name = vim_strsave(buf->b_fname);
3368 au_new_curbuf = buf;
3369 apply_autocmds(EVENT_BUFLEAVE, NULL, NULL, FALSE, curbuf);
3370 if (!buf_valid(buf)) /* new buffer has been deleted */
3371 {
3372 delbuf_msg(new_name); /* frees new_name */
3373 goto theend;
3374 }
3375# ifdef FEAT_EVAL
3376 if (aborting()) /* autocmds may abort script processing */
3377 {
3378 vim_free(new_name);
3379 goto theend;
3380 }
3381# endif
3382 if (buf == curbuf) /* already in new buffer */
3383 auto_buf = TRUE;
3384 else
3385 {
3386 if (curbuf == old_curbuf)
3387#endif
3388 buf_copy_options(buf, BCO_ENTER);
3389
3390 /* close the link to the current buffer */
Bram Moolenaar779b74b2006-04-10 14:55:34 +00003391 u_sync(FALSE);
Bram Moolenaar701f7af2008-11-15 13:12:07 +00003392 close_buffer(oldwin, curbuf,
Bram Moolenaar071d4272004-06-13 20:20:40 +00003393 (flags & ECMD_HIDE) ? 0 : DOBUF_UNLOAD);
3394
3395#ifdef FEAT_AUTOCMD
3396# ifdef FEAT_EVAL
3397 if (aborting()) /* autocmds may abort script processing */
3398 {
3399 vim_free(new_name);
3400 goto theend;
3401 }
3402# endif
3403 /* Be careful again, like above. */
3404 if (!buf_valid(buf)) /* new buffer has been deleted */
3405 {
3406 delbuf_msg(new_name); /* frees new_name */
3407 goto theend;
3408 }
3409 if (buf == curbuf) /* already in new buffer */
3410 auto_buf = TRUE;
3411 else
3412#endif
3413 {
3414 curwin->w_buffer = buf;
3415 curbuf = buf;
3416 ++curbuf->b_nwindows;
3417 /* set 'fileformat' */
3418 if (*p_ffs && !oldbuf)
3419 set_fileformat(default_fileformat(), OPT_LOCAL);
3420 }
3421
3422 /* May get the window options from the last time this buffer
3423 * was in this window (or another window). If not used
3424 * before, reset the local window options to the global
3425 * values. Also restores old folding stuff. */
Bram Moolenaarb1269f12007-06-19 09:51:25 +00003426 get_winopts(curbuf);
Bram Moolenaar706cdeb2007-05-06 21:55:31 +00003427#ifdef FEAT_SPELL
3428 did_get_winopts = TRUE;
3429#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003430
3431#ifdef FEAT_AUTOCMD
3432 }
3433 vim_free(new_name);
3434 au_new_curbuf = NULL;
3435#endif
3436 }
3437 else
3438 ++curbuf->b_nwindows;
3439
3440 curwin->w_pcmark.lnum = 1;
3441 curwin->w_pcmark.col = 0;
3442 }
3443 else /* !other_file */
3444 {
3445 if (
3446#ifdef FEAT_LISTCMDS
3447 (flags & ECMD_ADDBUF) ||
3448#endif
3449 check_fname() == FAIL)
3450 goto theend;
3451 oldbuf = (flags & ECMD_OLDBUF);
3452 }
3453
3454 if ((flags & ECMD_SET_HELP) || keep_help_flag)
3455 {
3456 char_u *p;
3457
3458 curbuf->b_help = TRUE;
3459#ifdef FEAT_QUICKFIX
3460 set_string_option_direct((char_u *)"buftype", -1,
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00003461 (char_u *)"help", OPT_FREE|OPT_LOCAL, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003462#endif
3463
3464 /*
3465 * Always set these options after jumping to a help tag, because the
3466 * user may have an autocommand that gets in the way.
3467 * Accept all ASCII chars for keywords, except ' ', '*', '"', '|', and
3468 * latin1 word characters (for translated help files).
3469 * Only set it when needed, buf_init_chartab() is some work.
3470 */
3471 p =
3472#ifdef EBCDIC
3473 (char_u *)"65-255,^*,^|,^\"";
3474#else
3475 (char_u *)"!-~,^*,^|,^\",192-255";
3476#endif
3477 if (STRCMP(curbuf->b_p_isk, p) != 0)
3478 {
3479 set_string_option_direct((char_u *)"isk", -1, p,
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00003480 OPT_FREE|OPT_LOCAL, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003481 check_buf_options(curbuf);
3482 (void)buf_init_chartab(curbuf, FALSE);
3483 }
3484
3485 curbuf->b_p_ts = 8; /* 'tabstop' is 8 */
3486 curwin->w_p_list = FALSE; /* no list mode */
3487
3488 curbuf->b_p_ma = FALSE; /* not modifiable */
3489 curbuf->b_p_bin = FALSE; /* reset 'bin' before reading file */
3490 curwin->w_p_nu = 0; /* no line numbers */
Bram Moolenaar64486672010-05-16 15:46:46 +02003491 curwin->w_p_rnu = 0; /* no relative line numbers */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003492#ifdef FEAT_SCROLLBIND
3493 curwin->w_p_scb = FALSE; /* no scroll binding */
3494#endif
3495#ifdef FEAT_ARABIC
3496 curwin->w_p_arab = FALSE; /* no arabic mode */
3497#endif
3498#ifdef FEAT_RIGHTLEFT
3499 curwin->w_p_rl = FALSE; /* help window is left-to-right */
3500#endif
3501#ifdef FEAT_FOLDING
3502 curwin->w_p_fen = FALSE; /* No folding in the help window */
3503#endif
3504#ifdef FEAT_DIFF
3505 curwin->w_p_diff = FALSE; /* No 'diff' */
3506#endif
Bram Moolenaara1956f62006-03-12 22:18:00 +00003507#ifdef FEAT_SPELL
Bram Moolenaar9a50b1b2005-06-27 22:48:21 +00003508 curwin->w_p_spell = FALSE; /* No spell checking */
3509#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003510
3511#ifdef FEAT_AUTOCMD
3512 buf = curbuf;
3513#endif
3514 set_buflisted(FALSE);
3515 }
3516 else
3517 {
3518#ifdef FEAT_AUTOCMD
3519 buf = curbuf;
3520#endif
3521 /* Don't make a buffer listed if it's a help buffer. Useful when
3522 * using CTRL-O to go back to a help file. */
3523 if (!curbuf->b_help)
3524 set_buflisted(TRUE);
3525 }
3526
3527#ifdef FEAT_AUTOCMD
3528 /* If autocommands change buffers under our fingers, forget about
3529 * editing the file. */
3530 if (buf != curbuf)
3531 goto theend;
3532# ifdef FEAT_EVAL
3533 if (aborting()) /* autocmds may abort script processing */
3534 goto theend;
3535# endif
3536
3537 /* Since we are starting to edit a file, consider the filetype to be
3538 * unset. Helps for when an autocommand changes files and expects syntax
3539 * highlighting to work in the other file. */
3540 did_filetype = FALSE;
3541#endif
3542
3543/*
3544 * other_file oldbuf
3545 * FALSE FALSE re-edit same file, buffer is re-used
3546 * FALSE TRUE re-edit same file, nothing changes
3547 * TRUE FALSE start editing new file, new buffer
3548 * TRUE TRUE start editing in existing buffer (nothing to do)
3549 */
3550 if (!other_file && !oldbuf) /* re-use the buffer */
3551 {
3552 set_last_cursor(curwin); /* may set b_last_cursor */
3553 if (newlnum == ECMD_LAST || newlnum == ECMD_LASTL)
3554 {
3555 newlnum = curwin->w_cursor.lnum;
3556 solcol = curwin->w_cursor.col;
3557 }
3558#ifdef FEAT_AUTOCMD
3559 buf = curbuf;
3560 if (buf->b_fname != NULL)
3561 new_name = vim_strsave(buf->b_fname);
3562 else
3563 new_name = NULL;
3564#endif
3565 buf_freeall(curbuf, FALSE, FALSE); /* free all things for buffer */
3566#ifdef FEAT_AUTOCMD
3567 /* If autocommands deleted the buffer we were going to re-edit, give
3568 * up and jump to the end. */
3569 if (!buf_valid(buf))
3570 {
3571 delbuf_msg(new_name); /* frees new_name */
3572 goto theend;
3573 }
3574 vim_free(new_name);
3575
3576 /* If autocommands change buffers under our fingers, forget about
3577 * re-editing the file. Should do the buf_clear_file(), but perhaps
3578 * the autocommands changed the buffer... */
3579 if (buf != curbuf)
3580 goto theend;
3581# ifdef FEAT_EVAL
3582 if (aborting()) /* autocmds may abort script processing */
3583 goto theend;
3584# endif
3585#endif
3586 buf_clear_file(curbuf);
3587 curbuf->b_op_start.lnum = 0; /* clear '[ and '] marks */
3588 curbuf->b_op_end.lnum = 0;
3589 }
3590
3591/*
3592 * If we get here we are sure to start editing
3593 */
3594 /* don't redraw until the cursor is in the right line */
3595 ++RedrawingDisabled;
3596
3597 /* Assume success now */
3598 retval = OK;
3599
3600 /*
3601 * Reset cursor position, could be used by autocommands.
3602 */
3603 check_cursor();
3604
3605 /*
3606 * Check if we are editing the w_arg_idx file in the argument list.
3607 */
3608 check_arg_idx(curwin);
3609
3610#ifdef FEAT_AUTOCMD
3611 if (!auto_buf)
3612#endif
3613 {
3614 /*
3615 * Set cursor and init window before reading the file and executing
3616 * autocommands. This allows for the autocommands to position the
3617 * cursor.
3618 */
Bram Moolenaarfaa959a2006-02-20 21:37:40 +00003619 curwin_init();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003620
3621#ifdef FEAT_FOLDING
Bram Moolenaareb1b6792007-08-21 13:29:28 +00003622 /* It's possible that all lines in the buffer changed. Need to update
3623 * automatic folding for all windows where it's used. */
3624# ifdef FEAT_WINDOWS
3625 {
3626 win_T *win;
3627 tabpage_T *tp;
3628
3629 FOR_ALL_TAB_WINDOWS(tp, win)
3630 if (win->w_buffer == curbuf)
3631 foldUpdateAll(win);
3632 }
3633# else
Bram Moolenaar071d4272004-06-13 20:20:40 +00003634 foldUpdateAll(curwin);
Bram Moolenaareb1b6792007-08-21 13:29:28 +00003635# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003636#endif
3637
Bram Moolenaar498efdb2006-09-05 14:31:54 +00003638 /* Change directories when the 'acd' option is set. */
3639 DO_AUTOCHDIR
3640
Bram Moolenaar071d4272004-06-13 20:20:40 +00003641 /*
3642 * Careful: open_buffer() and apply_autocmds() may change the current
3643 * buffer and window.
3644 */
3645 lnum = curwin->w_cursor.lnum;
3646 topline = curwin->w_topline;
3647 if (!oldbuf) /* need to read the file */
3648 {
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00003649#if defined(HAS_SWAP_EXISTS_ACTION)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003650 swap_exists_action = SEA_DIALOG;
3651#endif
3652 curbuf->b_flags |= BF_CHECK_RO; /* set/reset 'ro' flag */
3653
3654 /*
3655 * Open the buffer and read the file.
3656 */
3657#if defined(FEAT_AUTOCMD) && defined(FEAT_EVAL)
3658 if (should_abort(open_buffer(FALSE, eap)))
3659 retval = FAIL;
3660#else
3661 (void)open_buffer(FALSE, eap);
3662#endif
3663
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00003664#if defined(HAS_SWAP_EXISTS_ACTION)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003665 if (swap_exists_action == SEA_QUIT)
3666 retval = FAIL;
3667 handle_swap_exists(old_curbuf);
3668#endif
3669 }
3670#ifdef FEAT_AUTOCMD
3671 else
3672 {
Bram Moolenaar15d0a8c2004-09-06 17:44:46 +00003673 /* Read the modelines, but only to set window-local options. Any
3674 * buffer-local options have already been set and may have been
3675 * changed by the user. */
Bram Moolenaara3227e22006-03-08 21:32:40 +00003676 do_modelines(OPT_WINONLY);
Bram Moolenaar15d0a8c2004-09-06 17:44:46 +00003677
Bram Moolenaar071d4272004-06-13 20:20:40 +00003678 apply_autocmds_retval(EVENT_BUFENTER, NULL, NULL, FALSE, curbuf,
3679 &retval);
3680 apply_autocmds_retval(EVENT_BUFWINENTER, NULL, NULL, FALSE, curbuf,
3681 &retval);
3682 }
3683 check_arg_idx(curwin);
3684#endif
3685
3686 /*
3687 * If autocommands change the cursor position or topline, we should
3688 * keep it.
3689 */
3690 if (curwin->w_cursor.lnum != lnum)
3691 {
3692 newlnum = curwin->w_cursor.lnum;
3693 newcol = curwin->w_cursor.col;
3694 }
3695 if (curwin->w_topline == topline)
3696 topline = 0;
3697
3698 /* Even when cursor didn't move we need to recompute topline. */
3699 changed_line_abv_curs();
3700
3701#ifdef FEAT_TITLE
3702 maketitle();
3703#endif
3704 }
3705
3706#ifdef FEAT_DIFF
3707 /* Tell the diff stuff that this buffer is new and/or needs updating.
3708 * Also needed when re-editing the same buffer, because unloading will
3709 * have removed it as a diff buffer. */
Bram Moolenaar997fb4b2006-02-17 21:53:23 +00003710 if (curwin->w_p_diff)
3711 {
3712 diff_buf_add(curbuf);
3713 diff_invalidate(curbuf);
3714 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003715#endif
3716
Bram Moolenaar706cdeb2007-05-06 21:55:31 +00003717#ifdef FEAT_SPELL
3718 /* If the window options were changed may need to set the spell language.
3719 * Can only do this after the buffer has been properly setup. */
Bram Moolenaarb1269f12007-06-19 09:51:25 +00003720 if (did_get_winopts && curwin->w_p_spell && *curbuf->b_p_spl != NUL)
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00003721 (void)did_set_spelllang(curbuf);
Bram Moolenaar706cdeb2007-05-06 21:55:31 +00003722#endif
3723
Bram Moolenaar071d4272004-06-13 20:20:40 +00003724 if (command == NULL)
3725 {
3726 if (newcol >= 0) /* position set by autocommands */
3727 {
3728 curwin->w_cursor.lnum = newlnum;
3729 curwin->w_cursor.col = newcol;
3730 check_cursor();
3731 }
3732 else if (newlnum > 0) /* line number from caller or old position */
3733 {
3734 curwin->w_cursor.lnum = newlnum;
3735 check_cursor_lnum();
3736 if (solcol >= 0 && !p_sol)
3737 {
3738 /* 'sol' is off: Use last known column. */
3739 curwin->w_cursor.col = solcol;
3740 check_cursor_col();
3741#ifdef FEAT_VIRTUALEDIT
3742 curwin->w_cursor.coladd = 0;
3743#endif
3744 curwin->w_set_curswant = TRUE;
3745 }
3746 else
3747 beginline(BL_SOL | BL_FIX);
3748 }
3749 else /* no line number, go to last line in Ex mode */
3750 {
3751 if (exmode_active)
3752 curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
3753 beginline(BL_WHITE | BL_FIX);
3754 }
3755 }
3756
3757#ifdef FEAT_WINDOWS
3758 /* Check if cursors in other windows on the same buffer are still valid */
3759 check_lnums(FALSE);
3760#endif
3761
3762 /*
3763 * Did not read the file, need to show some info about the file.
3764 * Do this after setting the cursor.
3765 */
3766 if (oldbuf
3767#ifdef FEAT_AUTOCMD
3768 && !auto_buf
3769#endif
3770 )
3771 {
3772 int msg_scroll_save = msg_scroll;
3773
3774 /* Obey the 'O' flag in 'cpoptions': overwrite any previous file
3775 * message. */
3776 if (shortmess(SHM_OVERALL) && !exiting && p_verbose == 0)
3777 msg_scroll = FALSE;
3778 if (!msg_scroll) /* wait a bit when overwriting an error msg */
3779 check_for_delay(FALSE);
3780 msg_start();
3781 msg_scroll = msg_scroll_save;
3782 msg_scrolled_ign = TRUE;
3783
3784 fileinfo(FALSE, TRUE, FALSE);
3785
3786 msg_scrolled_ign = FALSE;
3787 }
3788
3789 if (command != NULL)
3790 do_cmdline(command, NULL, NULL, DOCMD_VERBOSE);
3791
3792#ifdef FEAT_KEYMAP
3793 if (curbuf->b_kmap_state & KEYMAP_INIT)
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00003794 (void)keymap_init();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003795#endif
3796
3797 --RedrawingDisabled;
3798 if (!skip_redraw)
3799 {
3800 n = p_so;
3801 if (topline == 0 && command == NULL)
3802 p_so = 999; /* force cursor halfway the window */
3803 update_topline();
3804#ifdef FEAT_SCROLLBIND
3805 curwin->w_scbind_pos = curwin->w_topline;
3806#endif
3807 p_so = n;
3808 redraw_curbuf_later(NOT_VALID); /* redraw this buffer later */
3809 }
3810
3811 if (p_im)
3812 need_start_insertmode = TRUE;
3813
Bram Moolenaar498efdb2006-09-05 14:31:54 +00003814 /* Change directories when the 'acd' option is set. */
3815 DO_AUTOCHDIR
Bram Moolenaar071d4272004-06-13 20:20:40 +00003816
Bram Moolenaar7b89edc2006-04-06 20:21:51 +00003817#if defined(FEAT_SUN_WORKSHOP) || defined(FEAT_NETBEANS_INTG)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003818 if (gui.in_use && curbuf->b_ffname != NULL)
3819 {
3820# ifdef FEAT_SUN_WORKSHOP
3821 if (usingSunWorkShop)
3822 workshop_file_opened((char *)curbuf->b_ffname, curbuf->b_p_ro);
3823# endif
3824# ifdef FEAT_NETBEANS_INTG
Bram Moolenaardd87969c2007-08-21 13:07:12 +00003825 if (usingNetbeans && ((flags & ECMD_SET_HELP) != ECMD_SET_HELP))
Bram Moolenaar35a9aaa2004-10-24 19:23:07 +00003826 netbeans_file_opened(curbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003827# endif
3828 }
3829#endif
3830
3831theend:
Bram Moolenaar1f35bf92006-03-07 22:38:47 +00003832#ifdef FEAT_AUTOCMD
3833 if (did_set_swapcommand)
3834 set_vim_var_string(VV_SWAPCOMMAND, NULL, -1);
3835#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003836#ifdef FEAT_BROWSE
3837 vim_free(browse_file);
3838#endif
3839 vim_free(free_fname);
3840 return retval;
3841}
3842
3843#ifdef FEAT_AUTOCMD
3844 static void
3845delbuf_msg(name)
3846 char_u *name;
3847{
3848 EMSG2(_("E143: Autocommands unexpectedly deleted new buffer %s"),
3849 name == NULL ? (char_u *)"" : name);
3850 vim_free(name);
3851 au_new_curbuf = NULL;
3852}
3853#endif
3854
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00003855static int append_indent = 0; /* autoindent for first line */
3856
Bram Moolenaar071d4272004-06-13 20:20:40 +00003857/*
3858 * ":insert" and ":append", also used by ":change"
3859 */
3860 void
3861ex_append(eap)
3862 exarg_T *eap;
3863{
3864 char_u *theline;
3865 int did_undo = FALSE;
3866 linenr_T lnum = eap->line2;
Bram Moolenaar81bf7082005-02-12 14:31:42 +00003867 int indent = 0;
3868 char_u *p;
3869 int vcol;
3870 int empty = (curbuf->b_ml.ml_flags & ML_EMPTY);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003871
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00003872 /* the ! flag toggles autoindent */
3873 if (eap->forceit)
3874 curbuf->b_p_ai = !curbuf->b_p_ai;
3875
3876 /* First autoindent comes from the line we start on */
3877 if (eap->cmdidx != CMD_change && curbuf->b_p_ai && lnum > 0)
3878 append_indent = get_indent_lnum(lnum);
3879
Bram Moolenaar071d4272004-06-13 20:20:40 +00003880 if (eap->cmdidx != CMD_append)
3881 --lnum;
3882
Bram Moolenaar81bf7082005-02-12 14:31:42 +00003883 /* when the buffer is empty append to line 0 and delete the dummy line */
3884 if (empty && lnum == 1)
3885 lnum = 0;
3886
Bram Moolenaar071d4272004-06-13 20:20:40 +00003887 State = INSERT; /* behave like in Insert mode */
3888 if (curbuf->b_p_iminsert == B_IMODE_LMAP)
3889 State |= LANGMAP;
Bram Moolenaar81bf7082005-02-12 14:31:42 +00003890
Bram Moolenaard8e9bb22005-07-09 21:14:46 +00003891 for (;;)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003892 {
3893 msg_scroll = TRUE;
3894 need_wait_return = FALSE;
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00003895 if (curbuf->b_p_ai)
3896 {
3897 if (append_indent >= 0)
3898 {
3899 indent = append_indent;
3900 append_indent = -1;
3901 }
3902 else if (lnum > 0)
3903 indent = get_indent_lnum(lnum);
3904 }
3905 ex_keep_indent = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003906 if (eap->getline == NULL)
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00003907 {
3908 /* No getline() function, use the lines that follow. This ends
3909 * when there is no more. */
3910 if (eap->nextcmd == NULL || *eap->nextcmd == NUL)
3911 break;
3912 p = vim_strchr(eap->nextcmd, NL);
3913 if (p == NULL)
3914 p = eap->nextcmd + STRLEN(eap->nextcmd);
3915 theline = vim_strnsave(eap->nextcmd, (int)(p - eap->nextcmd));
3916 if (*p != NUL)
3917 ++p;
3918 eap->nextcmd = p;
3919 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003920 else
3921 theline = eap->getline(
3922#ifdef FEAT_EVAL
Bram Moolenaar3d60ec22005-01-05 22:19:46 +00003923 eap->cstack->cs_looplevel > 0 ? -1 :
Bram Moolenaar071d4272004-06-13 20:20:40 +00003924#endif
Bram Moolenaar81bf7082005-02-12 14:31:42 +00003925 NUL, eap->cookie, indent);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003926 lines_left = Rows - 1;
Bram Moolenaar81bf7082005-02-12 14:31:42 +00003927 if (theline == NULL)
3928 break;
3929
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00003930 /* Using ^ CTRL-D in getexmodeline() makes us repeat the indent. */
3931 if (ex_keep_indent)
3932 append_indent = indent;
3933
Bram Moolenaar81bf7082005-02-12 14:31:42 +00003934 /* Look for the "." after automatic indent. */
3935 vcol = 0;
3936 for (p = theline; indent > vcol; ++p)
3937 {
3938 if (*p == ' ')
3939 ++vcol;
3940 else if (*p == TAB)
3941 vcol += 8 - vcol % 8;
3942 else
3943 break;
3944 }
3945 if ((p[0] == '.' && p[1] == NUL)
Bram Moolenaareaa48e72005-06-08 22:07:37 +00003946 || (!did_undo && u_save(lnum, lnum + 1 + (empty ? 1 : 0))
3947 == FAIL))
Bram Moolenaar071d4272004-06-13 20:20:40 +00003948 {
3949 vim_free(theline);
3950 break;
3951 }
3952
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00003953 /* don't use autoindent if nothing was typed. */
3954 if (p[0] == NUL)
3955 theline[0] = NUL;
3956
Bram Moolenaar071d4272004-06-13 20:20:40 +00003957 did_undo = TRUE;
3958 ml_append(lnum, theline, (colnr_T)0, FALSE);
3959 appended_lines_mark(lnum, 1L);
3960
3961 vim_free(theline);
3962 ++lnum;
Bram Moolenaar81bf7082005-02-12 14:31:42 +00003963
3964 if (empty)
3965 {
3966 ml_delete(2L, FALSE);
3967 empty = FALSE;
3968 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003969 }
3970 State = NORMAL;
3971
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00003972 if (eap->forceit)
3973 curbuf->b_p_ai = !curbuf->b_p_ai;
3974
Bram Moolenaar071d4272004-06-13 20:20:40 +00003975 /* "start" is set to eap->line2+1 unless that position is invalid (when
Bram Moolenaar45667512007-05-10 19:24:43 +00003976 * eap->line2 pointed to the end of the buffer and nothing was appended)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003977 * "end" is set to lnum when something has been appended, otherwise
3978 * it is the same than "start" -- Acevedo */
3979 curbuf->b_op_start.lnum = (eap->line2 < curbuf->b_ml.ml_line_count) ?
3980 eap->line2 + 1 : curbuf->b_ml.ml_line_count;
3981 if (eap->cmdidx != CMD_append)
3982 --curbuf->b_op_start.lnum;
3983 curbuf->b_op_end.lnum = (eap->line2 < lnum)
3984 ? lnum : curbuf->b_op_start.lnum;
3985 curbuf->b_op_start.col = curbuf->b_op_end.col = 0;
3986 curwin->w_cursor.lnum = lnum;
3987 check_cursor_lnum();
3988 beginline(BL_SOL | BL_FIX);
3989
3990 need_wait_return = FALSE; /* don't use wait_return() now */
3991 ex_no_reprint = TRUE;
3992}
3993
3994/*
3995 * ":change"
3996 */
3997 void
3998ex_change(eap)
3999 exarg_T *eap;
4000{
4001 linenr_T lnum;
4002
4003 if (eap->line2 >= eap->line1
4004 && u_save(eap->line1 - 1, eap->line2 + 1) == FAIL)
4005 return;
4006
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004007 /* the ! flag toggles autoindent */
4008 if (eap->forceit ? !curbuf->b_p_ai : curbuf->b_p_ai)
4009 append_indent = get_indent_lnum(eap->line1);
4010
Bram Moolenaar071d4272004-06-13 20:20:40 +00004011 for (lnum = eap->line2; lnum >= eap->line1; --lnum)
4012 {
4013 if (curbuf->b_ml.ml_flags & ML_EMPTY) /* nothing to delete */
4014 break;
4015 ml_delete(eap->line1, FALSE);
4016 }
Bram Moolenaarcdcaa582009-07-09 18:06:49 +00004017
4018 /* make sure the cursor is not beyond the end of the file now */
4019 check_cursor_lnum();
Bram Moolenaar071d4272004-06-13 20:20:40 +00004020 deleted_lines_mark(eap->line1, (long)(eap->line2 - lnum));
4021
4022 /* ":append" on the line above the deleted lines. */
4023 eap->line2 = eap->line1;
4024 ex_append(eap);
4025}
4026
4027 void
4028ex_z(eap)
4029 exarg_T *eap;
4030{
4031 char_u *x;
Bram Moolenaar81bf7082005-02-12 14:31:42 +00004032 int bigness;
4033 char_u *kind;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004034 int minus = 0;
4035 linenr_T start, end, curs, i;
4036 int j;
4037 linenr_T lnum = eap->line2;
4038
Bram Moolenaar81bf7082005-02-12 14:31:42 +00004039 /* Vi compatible: ":z!" uses display height, without a count uses
4040 * 'scroll' */
4041 if (eap->forceit)
4042 bigness = curwin->w_height;
4043 else if (firstwin == lastwin)
4044 bigness = curwin->w_p_scr * 2;
Bram Moolenaar78a15312009-05-15 19:33:18 +00004045#ifdef FEAT_WINDOWS
Bram Moolenaar81bf7082005-02-12 14:31:42 +00004046 else
4047 bigness = curwin->w_height - 3;
Bram Moolenaar78a15312009-05-15 19:33:18 +00004048#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004049 if (bigness < 1)
4050 bigness = 1;
4051
4052 x = eap->arg;
Bram Moolenaar81bf7082005-02-12 14:31:42 +00004053 kind = x;
4054 if (*kind == '-' || *kind == '+' || *kind == '='
4055 || *kind == '^' || *kind == '.')
4056 ++x;
4057 while (*x == '-' || *x == '+')
Bram Moolenaar071d4272004-06-13 20:20:40 +00004058 ++x;
4059
4060 if (*x != 0)
4061 {
4062 if (!VIM_ISDIGIT(*x))
4063 {
4064 EMSG(_("E144: non-numeric argument to :z"));
4065 return;
4066 }
4067 else
Bram Moolenaar81bf7082005-02-12 14:31:42 +00004068 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00004069 bigness = atoi((char *)x);
Bram Moolenaar81bf7082005-02-12 14:31:42 +00004070 p_window = bigness;
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004071 if (*kind == '=')
4072 bigness += 2;
Bram Moolenaar81bf7082005-02-12 14:31:42 +00004073 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004074 }
4075
Bram Moolenaar81bf7082005-02-12 14:31:42 +00004076 /* the number of '-' and '+' multiplies the distance */
4077 if (*kind == '-' || *kind == '+')
4078 for (x = kind + 1; *x == *kind; ++x)
4079 ;
4080
4081 switch (*kind)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004082 {
4083 case '-':
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00004084 start = lnum - bigness * (linenr_T)(x - kind);
Bram Moolenaar81bf7082005-02-12 14:31:42 +00004085 end = start + bigness;
4086 curs = end;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004087 break;
4088
4089 case '=':
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00004090 start = lnum - (bigness + 1) / 2 + 1;
4091 end = lnum + (bigness + 1) / 2 - 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004092 curs = lnum;
4093 minus = 1;
4094 break;
4095
4096 case '^':
4097 start = lnum - bigness * 2;
4098 end = lnum - bigness;
4099 curs = lnum - bigness;
4100 break;
4101
4102 case '.':
Bram Moolenaar2a8d1f82005-02-05 21:43:56 +00004103 start = lnum - (bigness + 1) / 2 + 1;
4104 end = lnum + (bigness + 1) / 2 - 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004105 curs = end;
4106 break;
4107
4108 default: /* '+' */
4109 start = lnum;
Bram Moolenaar81bf7082005-02-12 14:31:42 +00004110 if (*kind == '+')
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00004111 start += bigness * (linenr_T)(x - kind - 1) + 1;
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004112 else if (eap->addr_count == 0)
4113 ++start;
4114 end = start + bigness - 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004115 curs = end;
4116 break;
4117 }
4118
4119 if (start < 1)
4120 start = 1;
4121
4122 if (end > curbuf->b_ml.ml_line_count)
4123 end = curbuf->b_ml.ml_line_count;
4124
4125 if (curs > curbuf->b_ml.ml_line_count)
4126 curs = curbuf->b_ml.ml_line_count;
4127
4128 for (i = start; i <= end; i++)
4129 {
4130 if (minus && i == lnum)
4131 {
4132 msg_putchar('\n');
4133
4134 for (j = 1; j < Columns; j++)
4135 msg_putchar('-');
4136 }
4137
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004138 print_line(i, eap->flags & EXFLAG_NR, eap->flags & EXFLAG_LIST);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004139
4140 if (minus && i == lnum)
4141 {
4142 msg_putchar('\n');
4143
4144 for (j = 1; j < Columns; j++)
4145 msg_putchar('-');
4146 }
4147 }
4148
4149 curwin->w_cursor.lnum = curs;
4150 ex_no_reprint = TRUE;
4151}
4152
4153/*
4154 * Check if the restricted flag is set.
4155 * If so, give an error message and return TRUE.
4156 * Otherwise, return FALSE.
4157 */
4158 int
4159check_restricted()
4160{
4161 if (restricted)
4162 {
4163 EMSG(_("E145: Shell commands not allowed in rvim"));
4164 return TRUE;
4165 }
4166 return FALSE;
4167}
4168
4169/*
4170 * Check if the secure flag is set (.exrc or .vimrc in current directory).
4171 * If so, give an error message and return TRUE.
4172 * Otherwise, return FALSE.
4173 */
4174 int
4175check_secure()
4176{
4177 if (secure)
4178 {
4179 secure = 2;
4180 EMSG(_(e_curdir));
4181 return TRUE;
4182 }
4183#ifdef HAVE_SANDBOX
4184 /*
4185 * In the sandbox more things are not allowed, including the things
4186 * disallowed in secure mode.
4187 */
4188 if (sandbox != 0)
4189 {
4190 EMSG(_(e_sandbox));
4191 return TRUE;
4192 }
4193#endif
4194 return FALSE;
4195}
4196
4197static char_u *old_sub = NULL; /* previous substitute pattern */
4198static int global_need_beginline; /* call beginline() after ":g" */
4199
Bram Moolenaar071d4272004-06-13 20:20:40 +00004200/* do_sub()
4201 *
4202 * Perform a substitution from line eap->line1 to line eap->line2 using the
4203 * command pointed to by eap->arg which should be of the form:
4204 *
4205 * /pattern/substitution/{flags}
4206 *
4207 * The usual escapes are supported as described in the regexp docs.
4208 */
4209 void
4210do_sub(eap)
4211 exarg_T *eap;
4212{
4213 linenr_T lnum;
4214 long i = 0;
4215 regmmatch_T regmatch;
4216 static int do_all = FALSE; /* do multiple substitutions per line */
4217 static int do_ask = FALSE; /* ask for confirmation */
Bram Moolenaar05159a02005-02-26 23:04:13 +00004218 static int do_count = FALSE; /* count only */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004219 static int do_error = TRUE; /* if false, ignore errors */
4220 static int do_print = FALSE; /* print last line with subs. */
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004221 static int do_list = FALSE; /* list last line with subs. */
4222 static int do_number = FALSE; /* list last line with line nr*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00004223 static int do_ic = 0; /* ignore case flag */
4224 char_u *pat = NULL, *sub = NULL; /* init for GCC */
4225 int delimiter;
4226 int sublen;
4227 int got_quit = FALSE;
4228 int got_match = FALSE;
4229 int temp;
4230 int which_pat;
4231 char_u *cmd;
4232 int save_State;
Bram Moolenaar81bf7082005-02-12 14:31:42 +00004233 linenr_T first_line = 0; /* first changed line */
4234 linenr_T last_line= 0; /* below last changed line AFTER the
Bram Moolenaar071d4272004-06-13 20:20:40 +00004235 * change */
4236 linenr_T old_line_count = curbuf->b_ml.ml_line_count;
4237 linenr_T line2;
Bram Moolenaar81bf7082005-02-12 14:31:42 +00004238 long nmatch; /* number of lines in match */
Bram Moolenaar81bf7082005-02-12 14:31:42 +00004239 char_u *sub_firstline; /* allocated copy of first sub line */
4240 int endcolumn = FALSE; /* cursor in last column when done */
Bram Moolenaar05159a02005-02-26 23:04:13 +00004241 pos_T old_cursor = curwin->w_cursor;
Bram Moolenaar46475522010-03-23 17:36:29 +01004242 int start_nsubs;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004243
4244 cmd = eap->arg;
4245 if (!global_busy)
4246 {
4247 sub_nsubs = 0;
4248 sub_nlines = 0;
4249 }
Bram Moolenaar46475522010-03-23 17:36:29 +01004250 start_nsubs = sub_nsubs;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004251
Bram Moolenaar071d4272004-06-13 20:20:40 +00004252 if (eap->cmdidx == CMD_tilde)
4253 which_pat = RE_LAST; /* use last used regexp */
4254 else
4255 which_pat = RE_SUBST; /* use last substitute regexp */
4256
4257 /* new pattern and substitution */
4258 if (eap->cmd[0] == 's' && *cmd != NUL && !vim_iswhite(*cmd)
4259 && vim_strchr((char_u *)"0123456789cegriIp|\"", *cmd) == NULL)
4260 {
4261 /* don't accept alphanumeric for separator */
4262 if (isalpha(*cmd))
4263 {
4264 EMSG(_("E146: Regular expressions can't be delimited by letters"));
4265 return;
4266 }
4267 /*
4268 * undocumented vi feature:
4269 * "\/sub/" and "\?sub?" use last used search pattern (almost like
4270 * //sub/r). "\&sub&" use last substitute pattern (like //sub/).
4271 */
4272 if (*cmd == '\\')
4273 {
4274 ++cmd;
4275 if (vim_strchr((char_u *)"/?&", *cmd) == NULL)
4276 {
4277 EMSG(_(e_backslash));
4278 return;
4279 }
4280 if (*cmd != '&')
4281 which_pat = RE_SEARCH; /* use last '/' pattern */
4282 pat = (char_u *)""; /* empty search pattern */
4283 delimiter = *cmd++; /* remember delimiter character */
4284 }
4285 else /* find the end of the regexp */
4286 {
Bram Moolenaar3a169c32008-01-02 12:59:21 +00004287#ifdef FEAT_FKMAP /* reverse the flow of the Farsi characters */
4288 if (p_altkeymap && curwin->w_p_rl)
4289 lrF_sub(cmd);
4290#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004291 which_pat = RE_LAST; /* use last used regexp */
4292 delimiter = *cmd++; /* remember delimiter character */
4293 pat = cmd; /* remember start of search pat */
4294 cmd = skip_regexp(cmd, delimiter, p_magic, &eap->arg);
4295 if (cmd[0] == delimiter) /* end delimiter found */
4296 *cmd++ = NUL; /* replace it with a NUL */
4297 }
4298
4299 /*
4300 * Small incompatibility: vi sees '\n' as end of the command, but in
4301 * Vim we want to use '\n' to find/substitute a NUL.
4302 */
4303 sub = cmd; /* remember the start of the substitution */
4304
4305 while (cmd[0])
4306 {
4307 if (cmd[0] == delimiter) /* end delimiter found */
4308 {
4309 *cmd++ = NUL; /* replace it with a NUL */
4310 break;
4311 }
4312 if (cmd[0] == '\\' && cmd[1] != 0) /* skip escaped characters */
4313 ++cmd;
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00004314 mb_ptr_adv(cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004315 }
4316
4317 if (!eap->skip)
4318 {
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004319 /* In POSIX vi ":s/pat/%/" uses the previous subst. string. */
4320 if (STRCMP(sub, "%") == 0
4321 && vim_strchr(p_cpo, CPO_SUBPERCENT) != NULL)
4322 {
4323 if (old_sub == NULL) /* there is no previous command */
4324 {
4325 EMSG(_(e_nopresub));
4326 return;
4327 }
4328 sub = old_sub;
4329 }
4330 else
4331 {
4332 vim_free(old_sub);
4333 old_sub = vim_strsave(sub);
4334 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004335 }
4336 }
4337 else if (!eap->skip) /* use previous pattern and substitution */
4338 {
4339 if (old_sub == NULL) /* there is no previous command */
4340 {
4341 EMSG(_(e_nopresub));
4342 return;
4343 }
4344 pat = NULL; /* search_regcomp() will use previous pattern */
4345 sub = old_sub;
Bram Moolenaarb11bd7e2005-02-07 22:05:52 +00004346
4347 /* Vi compatibility quirk: repeating with ":s" keeps the cursor in the
4348 * last column after using "$". */
4349 endcolumn = (curwin->w_curswant == MAXCOL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004350 }
4351
4352 /*
4353 * Find trailing options. When '&' is used, keep old options.
4354 */
4355 if (*cmd == '&')
4356 ++cmd;
4357 else
4358 {
4359 if (!p_ed)
4360 {
4361 if (p_gd) /* default is global on */
4362 do_all = TRUE;
4363 else
4364 do_all = FALSE;
4365 do_ask = FALSE;
4366 }
4367 do_error = TRUE;
4368 do_print = FALSE;
Bram Moolenaarcc016f52005-12-10 20:23:46 +00004369 do_count = FALSE;
Bram Moolenaarfe40d1a2007-07-24 09:16:38 +00004370 do_number = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004371 do_ic = 0;
4372 }
4373 while (*cmd)
4374 {
4375 /*
4376 * Note that 'g' and 'c' are always inverted, also when p_ed is off.
4377 * 'r' is never inverted.
4378 */
4379 if (*cmd == 'g')
4380 do_all = !do_all;
4381 else if (*cmd == 'c')
4382 do_ask = !do_ask;
Bram Moolenaar05159a02005-02-26 23:04:13 +00004383 else if (*cmd == 'n')
4384 do_count = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004385 else if (*cmd == 'e')
4386 do_error = !do_error;
4387 else if (*cmd == 'r') /* use last used regexp */
4388 which_pat = RE_LAST;
4389 else if (*cmd == 'p')
4390 do_print = TRUE;
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004391 else if (*cmd == '#')
4392 {
4393 do_print = TRUE;
4394 do_number = TRUE;
4395 }
4396 else if (*cmd == 'l')
4397 {
4398 do_print = TRUE;
4399 do_list = TRUE;
4400 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004401 else if (*cmd == 'i') /* ignore case */
4402 do_ic = 'i';
4403 else if (*cmd == 'I') /* don't ignore case */
4404 do_ic = 'I';
4405 else
4406 break;
4407 ++cmd;
4408 }
Bram Moolenaar05159a02005-02-26 23:04:13 +00004409 if (do_count)
4410 do_ask = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004411
4412 /*
4413 * check for a trailing count
4414 */
4415 cmd = skipwhite(cmd);
4416 if (VIM_ISDIGIT(*cmd))
4417 {
4418 i = getdigits(&cmd);
4419 if (i <= 0 && !eap->skip && do_error)
4420 {
4421 EMSG(_(e_zerocount));
4422 return;
4423 }
4424 eap->line1 = eap->line2;
4425 eap->line2 += i - 1;
4426 if (eap->line2 > curbuf->b_ml.ml_line_count)
4427 eap->line2 = curbuf->b_ml.ml_line_count;
4428 }
4429
4430 /*
4431 * check for trailing command or garbage
4432 */
4433 cmd = skipwhite(cmd);
4434 if (*cmd && *cmd != '"') /* if not end-of-line or comment */
4435 {
4436 eap->nextcmd = check_nextcmd(cmd);
4437 if (eap->nextcmd == NULL)
4438 {
4439 EMSG(_(e_trailing));
4440 return;
4441 }
4442 }
4443
4444 if (eap->skip) /* not executing commands, only parsing */
4445 return;
4446
Bram Moolenaar61660ea2006-04-07 21:40:07 +00004447 if (!do_count && !curbuf->b_p_ma)
4448 {
Bram Moolenaar779b74b2006-04-10 14:55:34 +00004449 /* Substitution is not allowed in non-'modifiable' buffer */
Bram Moolenaar61660ea2006-04-07 21:40:07 +00004450 EMSG(_(e_modifiable));
4451 return;
4452 }
4453
Bram Moolenaar071d4272004-06-13 20:20:40 +00004454 if (search_regcomp(pat, RE_SUBST, which_pat, SEARCH_HIS, &regmatch) == FAIL)
4455 {
4456 if (do_error)
4457 EMSG(_(e_invcmd));
4458 return;
4459 }
4460
4461 /* the 'i' or 'I' flag overrules 'ignorecase' and 'smartcase' */
4462 if (do_ic == 'i')
4463 regmatch.rmm_ic = TRUE;
4464 else if (do_ic == 'I')
4465 regmatch.rmm_ic = FALSE;
4466
4467 sub_firstline = NULL;
4468
4469 /*
4470 * ~ in the substitute pattern is replaced with the old pattern.
4471 * We do it here once to avoid it to be replaced over and over again.
4472 * But don't do it when it starts with "\=", then it's an expression.
4473 */
4474 if (!(sub[0] == '\\' && sub[1] == '='))
4475 sub = regtilde(sub, p_magic);
4476
4477 /*
4478 * Check for a match on each line.
4479 */
4480 line2 = eap->line2;
4481 for (lnum = eap->line1; lnum <= line2 && !(got_quit
4482#if defined(FEAT_EVAL) && defined(FEAT_AUTOCMD)
4483 || aborting()
4484#endif
4485 ); ++lnum)
4486 {
Bram Moolenaar91a4e822008-01-19 14:59:58 +00004487 nmatch = vim_regexec_multi(&regmatch, curwin, curbuf, lnum,
4488 (colnr_T)0, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004489 if (nmatch)
4490 {
4491 colnr_T copycol;
4492 colnr_T matchcol;
4493 colnr_T prev_matchcol = MAXCOL;
4494 char_u *new_end, *new_start = NULL;
4495 unsigned new_start_len = 0;
4496 char_u *p1;
4497 int did_sub = FALSE;
4498 int lastone;
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00004499 int len, copy_len, needed_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004500 long nmatch_tl = 0; /* nr of lines matched below lnum */
4501 int do_again; /* do it again after joining lines */
Bram Moolenaar8299df92004-07-10 09:47:34 +00004502 int skip_match = FALSE;
Bram Moolenaarbd7cc032008-01-09 21:40:50 +00004503 linenr_T sub_firstlnum; /* nr of first sub line */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004504
4505 /*
4506 * The new text is build up step by step, to avoid too much
4507 * copying. There are these pieces:
Bram Moolenaara9aafe52008-05-07 11:10:28 +00004508 * sub_firstline The old text, unmodified.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004509 * copycol Column in the old text where we started
4510 * looking for a match; from here old text still
4511 * needs to be copied to the new text.
4512 * matchcol Column number of the old text where to look
4513 * for the next match. It's just after the
4514 * previous match or one further.
4515 * prev_matchcol Column just after the previous match (if any).
4516 * Mostly equal to matchcol, except for the first
4517 * match and after skipping an empty match.
4518 * regmatch.*pos Where the pattern matched in the old text.
4519 * new_start The new text, all that has been produced so
4520 * far.
4521 * new_end The new text, where to append new text.
4522 *
Bram Moolenaarbd7cc032008-01-09 21:40:50 +00004523 * lnum The line number where we found the start of
4524 * the match. Can be below the line we searched
4525 * when there is a \n before a \zs in the
4526 * pattern.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004527 * sub_firstlnum The line number in the buffer where to look
4528 * for a match. Can be different from "lnum"
4529 * when the pattern or substitute string contains
4530 * line breaks.
4531 *
4532 * Special situations:
4533 * - When the substitute string contains a line break, the part up
4534 * to the line break is inserted in the text, but the copy of
4535 * the original line is kept. "sub_firstlnum" is adjusted for
4536 * the inserted lines.
4537 * - When the matched pattern contains a line break, the old line
4538 * is taken from the line at the end of the pattern. The lines
4539 * in the match are deleted later, "sub_firstlnum" is adjusted
4540 * accordingly.
4541 *
4542 * The new text is built up in new_start[]. It has some extra
4543 * room to avoid using alloc()/free() too often. new_start_len is
Bram Moolenaar61abfd12007-09-13 16:26:47 +00004544 * the length of the allocated memory at new_start.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004545 *
4546 * Make a copy of the old line, so it won't be taken away when
4547 * updating the screen or handling a multi-line match. The "old_"
4548 * pointers point into this copy.
4549 */
Bram Moolenaarbd7cc032008-01-09 21:40:50 +00004550 sub_firstlnum = lnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004551 copycol = 0;
4552 matchcol = 0;
4553
4554 /* At first match, remember current cursor position. */
4555 if (!got_match)
4556 {
4557 setpcmark();
4558 got_match = TRUE;
4559 }
4560
4561 /*
4562 * Loop until nothing more to replace in this line.
4563 * 1. Handle match with empty string.
4564 * 2. If do_ask is set, ask for confirmation.
4565 * 3. substitute the string.
4566 * 4. if do_all is set, find next match
4567 * 5. break if there isn't another match in this line
4568 */
4569 for (;;)
4570 {
Bram Moolenaarbd7cc032008-01-09 21:40:50 +00004571 /* Advance "lnum" to the line where the match starts. The
4572 * match does not start in the first line when there is a line
4573 * break before \zs. */
4574 if (regmatch.startpos[0].lnum > 0)
4575 {
4576 lnum += regmatch.startpos[0].lnum;
4577 sub_firstlnum += regmatch.startpos[0].lnum;
4578 nmatch -= regmatch.startpos[0].lnum;
4579 vim_free(sub_firstline);
4580 sub_firstline = NULL;
4581 }
4582
4583 if (sub_firstline == NULL)
4584 {
4585 sub_firstline = vim_strsave(ml_get(sub_firstlnum));
4586 if (sub_firstline == NULL)
4587 {
4588 vim_free(new_start);
4589 goto outofmem;
4590 }
4591 }
4592
Bram Moolenaar071d4272004-06-13 20:20:40 +00004593 /* Save the line number of the last change for the final
4594 * cursor position (just like Vi). */
4595 curwin->w_cursor.lnum = lnum;
4596 do_again = FALSE;
4597
4598 /*
4599 * 1. Match empty string does not count, except for first
4600 * match. This reproduces the strange vi behaviour.
4601 * This also catches endless loops.
4602 */
4603 if (matchcol == prev_matchcol
4604 && regmatch.endpos[0].lnum == 0
4605 && matchcol == regmatch.endpos[0].col)
4606 {
Bram Moolenaar8299df92004-07-10 09:47:34 +00004607 if (sub_firstline[matchcol] == NUL)
4608 /* We already were at the end of the line. Don't look
4609 * for a match in this line again. */
4610 skip_match = TRUE;
4611 else
4612 ++matchcol; /* search for a match at next column */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004613 goto skip;
4614 }
4615
4616 /* Normally we continue searching for a match just after the
4617 * previous match. */
4618 matchcol = regmatch.endpos[0].col;
4619 prev_matchcol = matchcol;
4620
4621 /*
Bram Moolenaar05159a02005-02-26 23:04:13 +00004622 * 2. If do_count is set only increase the counter.
4623 * If do_ask is set, ask for confirmation.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004624 */
Bram Moolenaar05159a02005-02-26 23:04:13 +00004625 if (do_count)
4626 {
4627 /* For a multi-line match, put matchcol at the NUL at
4628 * the end of the line and set nmatch to one, so that
4629 * we continue looking for a match on the next line.
4630 * Avoids that ":s/\nB\@=//gc" get stuck. */
4631 if (nmatch > 1)
4632 {
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00004633 matchcol = (colnr_T)STRLEN(sub_firstline);
Bram Moolenaar05159a02005-02-26 23:04:13 +00004634 nmatch = 1;
Bram Moolenaar12ddc3e2008-01-04 13:53:09 +00004635 skip_match = TRUE;
Bram Moolenaar05159a02005-02-26 23:04:13 +00004636 }
4637 sub_nsubs++;
4638 did_sub = TRUE;
4639 goto skip;
4640 }
4641
Bram Moolenaar071d4272004-06-13 20:20:40 +00004642 if (do_ask)
4643 {
Bram Moolenaar985cb442009-05-14 19:51:46 +00004644 int typed = 0;
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00004645
Bram Moolenaar071d4272004-06-13 20:20:40 +00004646 /* change State to CONFIRM, so that the mouse works
4647 * properly */
4648 save_State = State;
4649 State = CONFIRM;
4650#ifdef FEAT_MOUSE
4651 setmouse(); /* disable mouse in xterm */
4652#endif
4653 curwin->w_cursor.col = regmatch.startpos[0].col;
4654
4655 /* When 'cpoptions' contains "u" don't sync undo when
4656 * asking for confirmation. */
4657 if (vim_strchr(p_cpo, CPO_UNDO) != NULL)
4658 ++no_u_sync;
4659
4660 /*
4661 * Loop until 'y', 'n', 'q', CTRL-E or CTRL-Y typed.
4662 */
4663 while (do_ask)
4664 {
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004665 if (exmode_active)
4666 {
4667 char_u *resp;
4668 colnr_T sc, ec;
4669
4670 print_line_no_prefix(lnum, FALSE, FALSE);
4671
4672 getvcol(curwin, &curwin->w_cursor, &sc, NULL, NULL);
4673 curwin->w_cursor.col = regmatch.endpos[0].col - 1;
4674 getvcol(curwin, &curwin->w_cursor, NULL, NULL, &ec);
4675 msg_start();
Bram Moolenaar05159a02005-02-26 23:04:13 +00004676 for (i = 0; i < (long)sc; ++i)
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004677 msg_putchar(' ');
Bram Moolenaar05159a02005-02-26 23:04:13 +00004678 for ( ; i <= (long)ec; ++i)
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004679 msg_putchar('^');
4680
4681 resp = getexmodeline('?', NULL, 0);
4682 if (resp != NULL)
4683 {
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00004684 typed = *resp;
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004685 vim_free(resp);
4686 }
4687 }
4688 else
4689 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00004690#ifdef FEAT_FOLDING
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004691 int save_p_fen = curwin->w_p_fen;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004692
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004693 curwin->w_p_fen = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004694#endif
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004695 /* Invert the matched string.
4696 * Remove the inversion afterwards. */
4697 temp = RedrawingDisabled;
4698 RedrawingDisabled = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004699
Bram Moolenaarbd7cc032008-01-09 21:40:50 +00004700 search_match_lines = regmatch.endpos[0].lnum
4701 - regmatch.startpos[0].lnum;
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004702 search_match_endcol = regmatch.endpos[0].col;
4703 highlight_match = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004704
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004705 update_topline();
4706 validate_cursor();
Bram Moolenaara1956f62006-03-12 22:18:00 +00004707 update_screen(SOME_VALID);
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004708 highlight_match = FALSE;
Bram Moolenaara1956f62006-03-12 22:18:00 +00004709 redraw_later(SOME_VALID);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004710
4711#ifdef FEAT_FOLDING
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004712 curwin->w_p_fen = save_p_fen;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004713#endif
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004714 if (msg_row == Rows - 1)
4715 msg_didout = FALSE; /* avoid a scroll-up */
4716 msg_starthere();
4717 i = msg_scroll;
4718 msg_scroll = 0; /* truncate msg when
4719 needed */
4720 msg_no_more = TRUE;
4721 /* write message same highlighting as for
4722 * wait_return */
4723 smsg_attr(hl_attr(HLF_R),
4724 (char_u *)_("replace with %s (y/n/a/q/l/^E/^Y)?"), sub);
4725 msg_no_more = FALSE;
4726 msg_scroll = i;
4727 showruler(TRUE);
4728 windgoto(msg_row, msg_col);
4729 RedrawingDisabled = temp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004730
4731#ifdef USE_ON_FLY_SCROLL
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004732 dont_scroll = FALSE; /* allow scrolling here */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004733#endif
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004734 ++no_mapping; /* don't map this key */
4735 ++allow_keys; /* allow special keys */
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00004736 typed = plain_vgetc();
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004737 --allow_keys;
4738 --no_mapping;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004739
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00004740 /* clear the question */
4741 msg_didout = FALSE; /* don't scroll up */
4742 msg_col = 0;
4743 gotocmdline(TRUE);
4744 }
4745
Bram Moolenaar071d4272004-06-13 20:20:40 +00004746 need_wait_return = FALSE; /* no hit-return prompt */
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00004747 if (typed == 'q' || typed == ESC || typed == Ctrl_C
Bram Moolenaar071d4272004-06-13 20:20:40 +00004748#ifdef UNIX
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00004749 || typed == intr_char
Bram Moolenaar071d4272004-06-13 20:20:40 +00004750#endif
4751 )
4752 {
4753 got_quit = TRUE;
4754 break;
4755 }
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00004756 if (typed == 'n')
Bram Moolenaar071d4272004-06-13 20:20:40 +00004757 break;
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00004758 if (typed == 'y')
Bram Moolenaar071d4272004-06-13 20:20:40 +00004759 break;
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00004760 if (typed == 'l')
Bram Moolenaar071d4272004-06-13 20:20:40 +00004761 {
4762 /* last: replace and then stop */
4763 do_all = FALSE;
4764 line2 = lnum;
4765 break;
4766 }
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00004767 if (typed == 'a')
Bram Moolenaar071d4272004-06-13 20:20:40 +00004768 {
4769 do_ask = FALSE;
4770 break;
4771 }
4772#ifdef FEAT_INS_EXPAND
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00004773 if (typed == Ctrl_E)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004774 scrollup_clamp();
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00004775 else if (typed == Ctrl_Y)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004776 scrolldown_clamp();
4777#endif
4778 }
4779 State = save_State;
4780#ifdef FEAT_MOUSE
4781 setmouse();
4782#endif
4783 if (vim_strchr(p_cpo, CPO_UNDO) != NULL)
4784 --no_u_sync;
4785
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00004786 if (typed == 'n')
Bram Moolenaar071d4272004-06-13 20:20:40 +00004787 {
4788 /* For a multi-line match, put matchcol at the NUL at
4789 * the end of the line and set nmatch to one, so that
4790 * we continue looking for a match on the next line.
Bram Moolenaarc432b502007-03-15 20:38:26 +00004791 * Avoids that ":%s/\nB\@=//gc" and ":%s/\n/,\r/gc"
4792 * get stuck when pressing 'n'. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004793 if (nmatch > 1)
4794 {
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00004795 matchcol = (colnr_T)STRLEN(sub_firstline);
Bram Moolenaarc432b502007-03-15 20:38:26 +00004796 skip_match = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004797 }
4798 goto skip;
4799 }
4800 if (got_quit)
4801 break;
4802 }
4803
4804 /* Move the cursor to the start of the match, so that we can
4805 * use "\=col("."). */
4806 curwin->w_cursor.col = regmatch.startpos[0].col;
4807
4808 /*
4809 * 3. substitute the string.
4810 */
4811 /* get length of substitution part */
Bram Moolenaarbd7cc032008-01-09 21:40:50 +00004812 sublen = vim_regsub_multi(&regmatch,
4813 sub_firstlnum - regmatch.startpos[0].lnum,
Bram Moolenaar071d4272004-06-13 20:20:40 +00004814 sub, sub_firstline, FALSE, p_magic, TRUE);
4815
Bram Moolenaar4463f292005-09-25 22:20:24 +00004816 /* When the match included the "$" of the last line it may
Bram Moolenaar910f66f2006-04-05 20:41:53 +00004817 * go beyond the last line of the buffer. */
Bram Moolenaar4463f292005-09-25 22:20:24 +00004818 if (nmatch > curbuf->b_ml.ml_line_count - sub_firstlnum + 1)
4819 {
4820 nmatch = curbuf->b_ml.ml_line_count - sub_firstlnum + 1;
4821 skip_match = TRUE;
4822 }
4823
Bram Moolenaar071d4272004-06-13 20:20:40 +00004824 /* Need room for:
4825 * - result so far in new_start (not for first sub in line)
4826 * - original text up to match
4827 * - length of substituted part
4828 * - original text after match
4829 */
4830 if (nmatch == 1)
4831 p1 = sub_firstline;
4832 else
4833 {
4834 p1 = ml_get(sub_firstlnum + nmatch - 1);
4835 nmatch_tl += nmatch - 1;
4836 }
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00004837 copy_len = regmatch.startpos[0].col - copycol;
4838 needed_len = copy_len + ((unsigned)STRLEN(p1)
4839 - regmatch.endpos[0].col) + sublen + 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004840 if (new_start == NULL)
4841 {
4842 /*
4843 * Get some space for a temporary buffer to do the
4844 * substitution into (and some extra space to avoid
4845 * too many calls to alloc()/free()).
4846 */
4847 new_start_len = needed_len + 50;
4848 if ((new_start = alloc_check(new_start_len)) == NULL)
4849 goto outofmem;
4850 *new_start = NUL;
4851 new_end = new_start;
4852 }
4853 else
4854 {
4855 /*
4856 * Check if the temporary buffer is long enough to do the
4857 * substitution into. If not, make it larger (with a bit
4858 * extra to avoid too many calls to alloc()/free()).
4859 */
4860 len = (unsigned)STRLEN(new_start);
4861 needed_len += len;
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00004862 if (needed_len > (int)new_start_len)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004863 {
4864 new_start_len = needed_len + 50;
4865 if ((p1 = alloc_check(new_start_len)) == NULL)
4866 {
4867 vim_free(new_start);
4868 goto outofmem;
4869 }
4870 mch_memmove(p1, new_start, (size_t)(len + 1));
4871 vim_free(new_start);
4872 new_start = p1;
4873 }
4874 new_end = new_start + len;
4875 }
4876
4877 /*
4878 * copy the text up to the part that matched
4879 */
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00004880 mch_memmove(new_end, sub_firstline + copycol, (size_t)copy_len);
4881 new_end += copy_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004882
Bram Moolenaarbd7cc032008-01-09 21:40:50 +00004883 (void)vim_regsub_multi(&regmatch,
4884 sub_firstlnum - regmatch.startpos[0].lnum,
Bram Moolenaar071d4272004-06-13 20:20:40 +00004885 sub, new_end, TRUE, p_magic, TRUE);
4886 sub_nsubs++;
4887 did_sub = TRUE;
4888
4889 /* Move the cursor to the start of the line, to avoid that it
4890 * is beyond the end of the line after the substitution. */
4891 curwin->w_cursor.col = 0;
4892
4893 /* For a multi-line match, make a copy of the last matched
4894 * line and continue in that one. */
4895 if (nmatch > 1)
4896 {
4897 sub_firstlnum += nmatch - 1;
4898 vim_free(sub_firstline);
4899 sub_firstline = vim_strsave(ml_get(sub_firstlnum));
4900 /* When going beyond the last line, stop substituting. */
4901 if (sub_firstlnum <= line2)
4902 do_again = TRUE;
4903 else
4904 do_all = FALSE;
4905 }
4906
4907 /* Remember next character to be copied. */
4908 copycol = regmatch.endpos[0].col;
4909
Bram Moolenaar910f66f2006-04-05 20:41:53 +00004910 if (skip_match)
4911 {
4912 /* Already hit end of the buffer, sub_firstlnum is one
4913 * less than what it ought to be. */
4914 vim_free(sub_firstline);
4915 sub_firstline = vim_strsave((char_u *)"");
4916 copycol = 0;
4917 }
4918
Bram Moolenaar071d4272004-06-13 20:20:40 +00004919 /*
4920 * Now the trick is to replace CTRL-M chars with a real line
4921 * break. This would make it impossible to insert a CTRL-M in
4922 * the text. The line break can be avoided by preceding the
4923 * CTRL-M with a backslash. To be able to insert a backslash,
4924 * they must be doubled in the string and are halved here.
4925 * That is Vi compatible.
4926 */
4927 for (p1 = new_end; *p1; ++p1)
4928 {
4929 if (p1[0] == '\\' && p1[1] != NUL) /* remove backslash */
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004930 STRMOVE(p1, p1 + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004931 else if (*p1 == CAR)
4932 {
4933 if (u_inssub(lnum) == OK) /* prepare for undo */
4934 {
4935 *p1 = NUL; /* truncate up to the CR */
4936 ml_append(lnum - 1, new_start,
4937 (colnr_T)(p1 - new_start + 1), FALSE);
4938 mark_adjust(lnum + 1, (linenr_T)MAXLNUM, 1L, 0L);
4939 if (do_ask)
4940 appended_lines(lnum - 1, 1L);
4941 else
4942 {
4943 if (first_line == 0)
4944 first_line = lnum;
4945 last_line = lnum + 1;
4946 }
4947 /* All line numbers increase. */
4948 ++sub_firstlnum;
4949 ++lnum;
4950 ++line2;
4951 /* move the cursor to the new line, like Vi */
4952 ++curwin->w_cursor.lnum;
Bram Moolenaarf9ffd182007-11-20 17:04:29 +00004953 /* copy the rest */
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004954 STRMOVE(new_start, p1 + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004955 p1 = new_start - 1;
4956 }
4957 }
4958#ifdef FEAT_MBYTE
4959 else if (has_mbyte)
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00004960 p1 += (*mb_ptr2len)(p1) - 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004961#endif
4962 }
4963
4964 /*
4965 * 4. If do_all is set, find next match.
4966 * Prevent endless loop with patterns that match empty
4967 * strings, e.g. :s/$/pat/g or :s/[a-z]* /(&)/g.
4968 * But ":s/\n/#/" is OK.
4969 */
4970skip:
4971 /* We already know that we did the last subst when we are at
4972 * the end of the line, except that a pattern like
Bram Moolenaarbd7cc032008-01-09 21:40:50 +00004973 * "bar\|\nfoo" may match at the NUL. "lnum" can be below
4974 * "line2" when there is a \zs in the pattern after a line
4975 * break. */
Bram Moolenaar8299df92004-07-10 09:47:34 +00004976 lastone = (skip_match
4977 || got_int
4978 || got_quit
Bram Moolenaarbd7cc032008-01-09 21:40:50 +00004979 || lnum > line2
Bram Moolenaar8299df92004-07-10 09:47:34 +00004980 || !(do_all || do_again)
4981 || (sub_firstline[matchcol] == NUL && nmatch <= 1
4982 && !re_multiline(regmatch.regprog)));
Bram Moolenaar071d4272004-06-13 20:20:40 +00004983 nmatch = -1;
4984
4985 /*
4986 * Replace the line in the buffer when needed. This is
4987 * skipped when there are more matches.
4988 * The check for nmatch_tl is needed for when multi-line
4989 * matching must replace the lines before trying to do another
4990 * match, otherwise "\@<=" won't work.
4991 * When asking the user we like to show the already replaced
4992 * text, but don't do it when "\<@=" or "\<@!" is used, it
4993 * changes what matches.
Bram Moolenaarbd7cc032008-01-09 21:40:50 +00004994 * When the match starts below where we start searching also
4995 * need to replace the line first (using \zs after \n).
Bram Moolenaar071d4272004-06-13 20:20:40 +00004996 */
4997 if (lastone
4998 || (do_ask && !re_lookbehind(regmatch.regprog))
4999 || nmatch_tl > 0
5000 || (nmatch = vim_regexec_multi(&regmatch, curwin,
Bram Moolenaar91a4e822008-01-19 14:59:58 +00005001 curbuf, sub_firstlnum,
5002 matchcol, NULL)) == 0
Bram Moolenaarbd7cc032008-01-09 21:40:50 +00005003 || regmatch.startpos[0].lnum > 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005004 {
5005 if (new_start != NULL)
5006 {
5007 /*
5008 * Copy the rest of the line, that didn't match.
5009 * "matchcol" has to be adjusted, we use the end of
5010 * the line as reference, because the substitute may
5011 * have changed the number of characters. Same for
5012 * "prev_matchcol".
5013 */
5014 STRCAT(new_start, sub_firstline + copycol);
5015 matchcol = (colnr_T)STRLEN(sub_firstline) - matchcol;
5016 prev_matchcol = (colnr_T)STRLEN(sub_firstline)
5017 - prev_matchcol;
5018
5019 if (u_savesub(lnum) != OK)
5020 break;
5021 ml_replace(lnum, new_start, TRUE);
5022
5023 if (nmatch_tl > 0)
5024 {
5025 /*
5026 * Matched lines have now been substituted and are
5027 * useless, delete them. The part after the match
5028 * has been appended to new_start, we don't need
5029 * it in the buffer.
5030 */
5031 ++lnum;
5032 if (u_savedel(lnum, nmatch_tl) != OK)
5033 break;
5034 for (i = 0; i < nmatch_tl; ++i)
5035 ml_delete(lnum, (int)FALSE);
5036 mark_adjust(lnum, lnum + nmatch_tl - 1,
5037 (long)MAXLNUM, -nmatch_tl);
5038 if (do_ask)
5039 deleted_lines(lnum, nmatch_tl);
5040 --lnum;
5041 line2 -= nmatch_tl; /* nr of lines decreases */
5042 nmatch_tl = 0;
5043 }
5044
5045 /* When asking, undo is saved each time, must also set
5046 * changed flag each time. */
5047 if (do_ask)
5048 changed_bytes(lnum, 0);
5049 else
5050 {
5051 if (first_line == 0)
5052 first_line = lnum;
5053 last_line = lnum + 1;
5054 }
5055
5056 sub_firstlnum = lnum;
5057 vim_free(sub_firstline); /* free the temp buffer */
5058 sub_firstline = new_start;
5059 new_start = NULL;
5060 matchcol = (colnr_T)STRLEN(sub_firstline) - matchcol;
5061 prev_matchcol = (colnr_T)STRLEN(sub_firstline)
5062 - prev_matchcol;
5063 copycol = 0;
5064 }
5065 if (nmatch == -1 && !lastone)
5066 nmatch = vim_regexec_multi(&regmatch, curwin, curbuf,
Bram Moolenaar91a4e822008-01-19 14:59:58 +00005067 sub_firstlnum, matchcol, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005068
5069 /*
5070 * 5. break if there isn't another match in this line
5071 */
5072 if (nmatch <= 0)
Bram Moolenaarbd7cc032008-01-09 21:40:50 +00005073 {
5074 /* If the match found didn't start where we were
5075 * searching, do the next search in the line where we
5076 * found the match. */
5077 if (nmatch == -1)
5078 lnum -= regmatch.startpos[0].lnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005079 break;
Bram Moolenaarbd7cc032008-01-09 21:40:50 +00005080 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005081 }
5082
5083 line_breakcheck();
5084 }
5085
5086 if (did_sub)
5087 ++sub_nlines;
Bram Moolenaarda2bd6f2008-09-14 19:41:30 +00005088 vim_free(new_start); /* for when substitute was cancelled */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005089 vim_free(sub_firstline); /* free the copy of the original line */
5090 sub_firstline = NULL;
5091 }
5092
5093 line_breakcheck();
5094 }
5095
5096 if (first_line != 0)
5097 {
5098 /* Need to subtract the number of added lines from "last_line" to get
5099 * the line number before the change (same as adding the number of
5100 * deleted lines). */
5101 i = curbuf->b_ml.ml_line_count - old_line_count;
5102 changed_lines(first_line, 0, last_line - i, i);
5103 }
5104
5105outofmem:
5106 vim_free(sub_firstline); /* may have to free allocated copy of the line */
Bram Moolenaar05159a02005-02-26 23:04:13 +00005107
5108 /* ":s/pat//n" doesn't move the cursor */
5109 if (do_count)
5110 curwin->w_cursor = old_cursor;
5111
Bram Moolenaar46475522010-03-23 17:36:29 +01005112 if (sub_nsubs > start_nsubs)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005113 {
5114 /* Set the '[ and '] marks. */
5115 curbuf->b_op_start.lnum = eap->line1;
5116 curbuf->b_op_end.lnum = line2;
5117 curbuf->b_op_start.col = curbuf->b_op_end.col = 0;
5118
5119 if (!global_busy)
5120 {
Bram Moolenaarb11bd7e2005-02-07 22:05:52 +00005121 if (endcolumn)
5122 coladvance((colnr_T)MAXCOL);
5123 else
5124 beginline(BL_WHITE | BL_FIX);
Bram Moolenaar05159a02005-02-26 23:04:13 +00005125 if (!do_sub_msg(do_count) && do_ask)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005126 MSG("");
5127 }
5128 else
5129 global_need_beginline = TRUE;
5130 if (do_print)
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00005131 print_line(curwin->w_cursor.lnum, do_number, do_list);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005132 }
5133 else if (!global_busy)
5134 {
5135 if (got_int) /* interrupted */
5136 EMSG(_(e_interr));
5137 else if (got_match) /* did find something but nothing substituted */
5138 MSG("");
5139 else if (do_error) /* nothing found */
5140 EMSG2(_(e_patnotf2), get_search_pat());
5141 }
5142
5143 vim_free(regmatch.regprog);
5144}
5145
5146/*
5147 * Give message for number of substitutions.
5148 * Can also be used after a ":global" command.
5149 * Return TRUE if a message was given.
5150 */
Bram Moolenaar8aff23a2005-08-19 20:40:30 +00005151 int
Bram Moolenaar05159a02005-02-26 23:04:13 +00005152do_sub_msg(count_only)
5153 int count_only; /* used 'n' flag for ":s" */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005154{
Bram Moolenaar555b2802005-05-19 21:08:39 +00005155 int len = 0;
5156
Bram Moolenaar071d4272004-06-13 20:20:40 +00005157 /*
5158 * Only report substitutions when:
5159 * - more than 'report' substitutions
5160 * - command was typed by user, or number of changed lines > 'report'
5161 * - giving messages is not disabled by 'lazyredraw'
5162 */
Bram Moolenaar05159a02005-02-26 23:04:13 +00005163 if (((sub_nsubs > p_report && (KeyTyped || sub_nlines > 1 || p_report < 1))
5164 || count_only)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005165 && messaging())
5166 {
5167 if (got_int)
Bram Moolenaar555b2802005-05-19 21:08:39 +00005168 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00005169 STRCPY(msg_buf, _("(Interrupted) "));
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00005170 len = (int)STRLEN(msg_buf);
Bram Moolenaar555b2802005-05-19 21:08:39 +00005171 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005172 if (sub_nsubs == 1)
Bram Moolenaar555b2802005-05-19 21:08:39 +00005173 vim_snprintf((char *)msg_buf + len, sizeof(msg_buf) - len,
5174 "%s", count_only ? _("1 match") : _("1 substitution"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00005175 else
Bram Moolenaar555b2802005-05-19 21:08:39 +00005176 vim_snprintf((char *)msg_buf + len, sizeof(msg_buf) - len,
Bram Moolenaar05159a02005-02-26 23:04:13 +00005177 count_only ? _("%ld matches") : _("%ld substitutions"),
Bram Moolenaar071d4272004-06-13 20:20:40 +00005178 sub_nsubs);
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00005179 len = (int)STRLEN(msg_buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005180 if (sub_nlines == 1)
Bram Moolenaar555b2802005-05-19 21:08:39 +00005181 vim_snprintf((char *)msg_buf + len, sizeof(msg_buf) - len,
5182 "%s", _(" on 1 line"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00005183 else
Bram Moolenaar555b2802005-05-19 21:08:39 +00005184 vim_snprintf((char *)msg_buf + len, sizeof(msg_buf) - len,
5185 _(" on %ld lines"), (long)sub_nlines);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005186 if (msg(msg_buf))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005187 /* save message to display it after redraw */
Bram Moolenaar238a5642006-02-21 22:12:05 +00005188 set_keep_msg(msg_buf, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005189 return TRUE;
5190 }
5191 if (got_int)
5192 {
5193 EMSG(_(e_interr));
5194 return TRUE;
5195 }
5196 return FALSE;
5197}
5198
5199/*
5200 * Execute a global command of the form:
5201 *
5202 * g/pattern/X : execute X on all lines where pattern matches
5203 * v/pattern/X : execute X on all lines where pattern does not match
5204 *
5205 * where 'X' is an EX command
5206 *
5207 * The command character (as well as the trailing slash) is optional, and
5208 * is assumed to be 'p' if missing.
5209 *
5210 * This is implemented in two passes: first we scan the file for the pattern and
5211 * set a mark for each line that (not) matches. secondly we execute the command
5212 * for each line that has a mark. This is required because after deleting
5213 * lines we do not know where to search for the next match.
5214 */
5215 void
5216ex_global(eap)
5217 exarg_T *eap;
5218{
5219 linenr_T lnum; /* line number according to old situation */
Bram Moolenaar05159a02005-02-26 23:04:13 +00005220 int ndone = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005221 int type; /* first char of cmd: 'v' or 'g' */
5222 char_u *cmd; /* command argument */
5223
5224 char_u delim; /* delimiter, normally '/' */
5225 char_u *pat;
5226 regmmatch_T regmatch;
5227 int match;
5228 int which_pat;
5229
5230 if (global_busy)
5231 {
5232 EMSG(_("E147: Cannot do :global recursive")); /* will increment global_busy */
5233 return;
5234 }
5235
5236 if (eap->forceit) /* ":global!" is like ":vglobal" */
5237 type = 'v';
5238 else
5239 type = *eap->cmd;
5240 cmd = eap->arg;
5241 which_pat = RE_LAST; /* default: use last used regexp */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005242
5243 /*
5244 * undocumented vi feature:
5245 * "\/" and "\?": use previous search pattern.
5246 * "\&": use previous substitute pattern.
5247 */
5248 if (*cmd == '\\')
5249 {
5250 ++cmd;
5251 if (vim_strchr((char_u *)"/?&", *cmd) == NULL)
5252 {
5253 EMSG(_(e_backslash));
5254 return;
5255 }
5256 if (*cmd == '&')
5257 which_pat = RE_SUBST; /* use previous substitute pattern */
5258 else
5259 which_pat = RE_SEARCH; /* use previous search pattern */
5260 ++cmd;
5261 pat = (char_u *)"";
5262 }
5263 else if (*cmd == NUL)
5264 {
5265 EMSG(_("E148: Regular expression missing from global"));
5266 return;
5267 }
5268 else
5269 {
5270 delim = *cmd; /* get the delimiter */
5271 if (delim)
5272 ++cmd; /* skip delimiter if there is one */
5273 pat = cmd; /* remember start of pattern */
5274 cmd = skip_regexp(cmd, delim, p_magic, &eap->arg);
5275 if (cmd[0] == delim) /* end delimiter found */
5276 *cmd++ = NUL; /* replace it with a NUL */
5277 }
5278
5279#ifdef FEAT_FKMAP /* when in Farsi mode, reverse the character flow */
5280 if (p_altkeymap && curwin->w_p_rl)
5281 lrFswap(pat,0);
5282#endif
5283
5284 if (search_regcomp(pat, RE_BOTH, which_pat, SEARCH_HIS, &regmatch) == FAIL)
5285 {
5286 EMSG(_(e_invcmd));
5287 return;
5288 }
5289
5290 /*
5291 * pass 1: set marks for each (not) matching line
5292 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005293 for (lnum = eap->line1; lnum <= eap->line2 && !got_int; ++lnum)
5294 {
5295 /* a match on this line? */
Bram Moolenaar91a4e822008-01-19 14:59:58 +00005296 match = vim_regexec_multi(&regmatch, curwin, curbuf, lnum,
5297 (colnr_T)0, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005298 if ((type == 'g' && match) || (type == 'v' && !match))
5299 {
5300 ml_setmarked(lnum);
5301 ndone++;
5302 }
5303 line_breakcheck();
5304 }
5305
5306 /*
5307 * pass 2: execute the command for each line that has been marked
5308 */
5309 if (got_int)
5310 MSG(_(e_interr));
5311 else if (ndone == 0)
5312 {
5313 if (type == 'v')
Bram Moolenaar555b2802005-05-19 21:08:39 +00005314 smsg((char_u *)_("Pattern found in every line: %s"), pat);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005315 else
Bram Moolenaar555b2802005-05-19 21:08:39 +00005316 smsg((char_u *)_(e_patnotf2), pat);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005317 }
5318 else
5319 global_exe(cmd);
5320
5321 ml_clearmarked(); /* clear rest of the marks */
5322 vim_free(regmatch.regprog);
5323}
5324
5325/*
5326 * Execute "cmd" on lines marked with ml_setmarked().
5327 */
5328 void
5329global_exe(cmd)
5330 char_u *cmd;
5331{
5332 linenr_T old_lcount; /* b_ml.ml_line_count before the command */
5333 linenr_T lnum; /* line number according to old situation */
5334
5335 /*
5336 * Set current position only once for a global command.
5337 * If global_busy is set, setpcmark() will not do anything.
5338 * If there is an error, global_busy will be incremented.
5339 */
5340 setpcmark();
5341
5342 /* When the command writes a message, don't overwrite the command. */
5343 msg_didout = TRUE;
5344
Bram Moolenaard25bc232010-03-23 17:49:24 +01005345 sub_nsubs = 0;
5346 sub_nlines = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005347 global_need_beginline = FALSE;
5348 global_busy = 1;
5349 old_lcount = curbuf->b_ml.ml_line_count;
5350 while (!got_int && (lnum = ml_firstmarked()) != 0 && global_busy == 1)
5351 {
5352 curwin->w_cursor.lnum = lnum;
5353 curwin->w_cursor.col = 0;
5354 if (*cmd == NUL || *cmd == '\n')
5355 do_cmdline((char_u *)"p", NULL, NULL, DOCMD_NOWAIT);
5356 else
5357 do_cmdline(cmd, NULL, NULL, DOCMD_NOWAIT);
5358 ui_breakcheck();
5359 }
5360
5361 global_busy = 0;
5362 if (global_need_beginline)
5363 beginline(BL_WHITE | BL_FIX);
5364 else
5365 check_cursor(); /* cursor may be beyond the end of the line */
5366
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00005367 /* the cursor may not have moved in the text but a change in a previous
5368 * line may move it on the screen */
5369 changed_line_abv_curs();
5370
Bram Moolenaar071d4272004-06-13 20:20:40 +00005371 /* If it looks like no message was written, allow overwriting the
5372 * command with the report for number of changes. */
5373 if (msg_col == 0 && msg_scrolled == 0)
5374 msg_didout = FALSE;
5375
Bram Moolenaar45667512007-05-10 19:24:43 +00005376 /* If substitutes done, report number of substitutes, otherwise report
Bram Moolenaar071d4272004-06-13 20:20:40 +00005377 * number of extra or deleted lines. */
Bram Moolenaar05159a02005-02-26 23:04:13 +00005378 if (!do_sub_msg(FALSE))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005379 msgmore(curbuf->b_ml.ml_line_count - old_lcount);
5380}
5381
5382#ifdef FEAT_VIMINFO
5383 int
5384read_viminfo_sub_string(virp, force)
5385 vir_T *virp;
5386 int force;
5387{
5388 if (old_sub != NULL && force)
5389 vim_free(old_sub);
5390 if (force || old_sub == NULL)
5391 old_sub = viminfo_readstring(virp, 1, TRUE);
5392 return viminfo_readline(virp);
5393}
5394
5395 void
5396write_viminfo_sub_string(fp)
5397 FILE *fp;
5398{
5399 if (get_viminfo_parameter('/') != 0 && old_sub != NULL)
5400 {
5401 fprintf(fp, _("\n# Last Substitute String:\n$"));
5402 viminfo_writestring(fp, old_sub);
5403 }
5404}
5405#endif /* FEAT_VIMINFO */
5406
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00005407#if defined(EXITFREE) || defined(PROTO)
5408 void
5409free_old_sub()
5410{
5411 vim_free(old_sub);
5412}
5413#endif
5414
Bram Moolenaar071d4272004-06-13 20:20:40 +00005415#if (defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)) || defined(PROTO)
5416/*
5417 * Set up for a tagpreview.
Bram Moolenaara5b6ad12006-03-11 21:36:59 +00005418 * Return TRUE when it was created.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005419 */
Bram Moolenaara5b6ad12006-03-11 21:36:59 +00005420 int
Bram Moolenaard2cec5b2006-03-28 21:08:56 +00005421prepare_tagpreview(undo_sync)
5422 int undo_sync; /* sync undo when leaving the window */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005423{
5424 win_T *wp;
5425
5426# ifdef FEAT_GUI
5427 need_mouse_correct = TRUE;
5428# endif
5429
5430 /*
5431 * If there is already a preview window open, use that one.
5432 */
5433 if (!curwin->w_p_pvw)
5434 {
5435 for (wp = firstwin; wp != NULL; wp = wp->w_next)
5436 if (wp->w_p_pvw)
5437 break;
5438 if (wp != NULL)
Bram Moolenaard2cec5b2006-03-28 21:08:56 +00005439 win_enter(wp, undo_sync);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005440 else
5441 {
5442 /*
5443 * There is no preview window open yet. Create one.
5444 */
5445 if (win_split(g_do_tagpreview > 0 ? g_do_tagpreview : 0, 0)
5446 == FAIL)
Bram Moolenaara5b6ad12006-03-11 21:36:59 +00005447 return FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005448 curwin->w_p_pvw = TRUE;
5449 curwin->w_p_wfh = TRUE;
5450# ifdef FEAT_SCROLLBIND
5451 curwin->w_p_scb = FALSE; /* don't take over 'scrollbind' */
5452# endif
5453# ifdef FEAT_DIFF
5454 curwin->w_p_diff = FALSE; /* no 'diff' */
5455# endif
5456# ifdef FEAT_FOLDING
5457 curwin->w_p_fdc = 0; /* no 'foldcolumn' */
5458# endif
Bram Moolenaara5b6ad12006-03-11 21:36:59 +00005459 return TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005460 }
5461 }
Bram Moolenaara5b6ad12006-03-11 21:36:59 +00005462 return FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005463}
5464
5465#endif
5466
5467
5468/*
5469 * ":help": open a read-only window on a help file
5470 */
5471 void
5472ex_help(eap)
5473 exarg_T *eap;
5474{
5475 char_u *arg;
5476 char_u *tag;
5477 FILE *helpfd; /* file descriptor of help file */
5478 int n;
5479 int i;
5480#ifdef FEAT_WINDOWS
5481 win_T *wp;
5482#endif
5483 int num_matches;
5484 char_u **matches;
5485 char_u *p;
5486 int empty_fnum = 0;
5487 int alt_fnum = 0;
5488 buf_T *buf;
5489#ifdef FEAT_MULTI_LANG
5490 int len;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005491 char_u *lang;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005492#endif
5493
5494 if (eap != NULL)
5495 {
5496 /*
5497 * A ":help" command ends at the first LF, or at a '|' that is
5498 * followed by some text. Set nextcmd to the following command.
5499 */
5500 for (arg = eap->arg; *arg; ++arg)
5501 {
5502 if (*arg == '\n' || *arg == '\r'
5503 || (*arg == '|' && arg[1] != NUL && arg[1] != '|'))
5504 {
5505 *arg++ = NUL;
5506 eap->nextcmd = arg;
5507 break;
5508 }
5509 }
5510 arg = eap->arg;
5511
5512 if (eap->forceit && *arg == NUL)
5513 {
5514 EMSG(_("E478: Don't panic!"));
5515 return;
5516 }
5517
5518 if (eap->skip) /* not executing commands */
5519 return;
5520 }
5521 else
5522 arg = (char_u *)"";
5523
5524 /* remove trailing blanks */
5525 p = arg + STRLEN(arg) - 1;
5526 while (p > arg && vim_iswhite(*p) && p[-1] != '\\')
5527 *p-- = NUL;
5528
5529#ifdef FEAT_MULTI_LANG
5530 /* Check for a specified language */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005531 lang = check_help_lang(arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005532#endif
5533
5534 /* When no argument given go to the index. */
5535 if (*arg == NUL)
5536 arg = (char_u *)"help.txt";
5537
5538 /*
5539 * Check if there is a match for the argument.
5540 */
5541 n = find_help_tags(arg, &num_matches, &matches,
5542 eap != NULL && eap->forceit);
5543
5544 i = 0;
5545#ifdef FEAT_MULTI_LANG
5546 if (n != FAIL && lang != NULL)
5547 /* Find first item with the requested language. */
5548 for (i = 0; i < num_matches; ++i)
5549 {
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00005550 len = (int)STRLEN(matches[i]);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005551 if (len > 3 && matches[i][len - 3] == '@'
5552 && STRICMP(matches[i] + len - 2, lang) == 0)
5553 break;
5554 }
5555#endif
5556 if (i >= num_matches || n == FAIL)
5557 {
5558#ifdef FEAT_MULTI_LANG
5559 if (lang != NULL)
5560 EMSG3(_("E661: Sorry, no '%s' help for %s"), lang, arg);
5561 else
5562#endif
5563 EMSG2(_("E149: Sorry, no help for %s"), arg);
5564 if (n != FAIL)
5565 FreeWild(num_matches, matches);
5566 return;
5567 }
5568
5569 /* The first match (in the requested language) is the best match. */
5570 tag = vim_strsave(matches[i]);
5571 FreeWild(num_matches, matches);
5572
5573#ifdef FEAT_GUI
5574 need_mouse_correct = TRUE;
5575#endif
5576
5577 /*
5578 * Re-use an existing help window or open a new one.
Bram Moolenaar2a3f7ee2006-02-23 21:34:44 +00005579 * Always open a new one for ":tab help".
Bram Moolenaar071d4272004-06-13 20:20:40 +00005580 */
Bram Moolenaar2a3f7ee2006-02-23 21:34:44 +00005581 if (!curwin->w_buffer->b_help
5582#ifdef FEAT_WINDOWS
5583 || cmdmod.tab != 0
5584#endif
5585 )
Bram Moolenaar071d4272004-06-13 20:20:40 +00005586 {
5587#ifdef FEAT_WINDOWS
Bram Moolenaar2a3f7ee2006-02-23 21:34:44 +00005588 if (cmdmod.tab != 0)
5589 wp = NULL;
5590 else
5591 for (wp = firstwin; wp != NULL; wp = wp->w_next)
5592 if (wp->w_buffer != NULL && wp->w_buffer->b_help)
5593 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005594 if (wp != NULL && wp->w_buffer->b_nwindows > 0)
5595 win_enter(wp, TRUE);
5596 else
5597#endif
5598 {
5599 /*
5600 * There is no help window yet.
5601 * Try to open the file specified by the "helpfile" option.
5602 */
5603 if ((helpfd = mch_fopen((char *)p_hf, READBIN)) == NULL)
5604 {
Bram Moolenaar555b2802005-05-19 21:08:39 +00005605 smsg((char_u *)_("Sorry, help file \"%s\" not found"), p_hf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005606 goto erret;
5607 }
5608 fclose(helpfd);
5609
5610#ifdef FEAT_WINDOWS
5611 /* Split off help window; put it at far top if no position
Bram Moolenaar2a3f7ee2006-02-23 21:34:44 +00005612 * specified, the current window is vertically split and
5613 * narrow. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005614 n = WSP_HELP;
5615# ifdef FEAT_VERTSPLIT
5616 if (cmdmod.split == 0 && curwin->w_width != Columns
Bram Moolenaar2a3f7ee2006-02-23 21:34:44 +00005617 && curwin->w_width < 80)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005618 n |= WSP_TOP;
5619# endif
5620 if (win_split(0, n) == FAIL)
Bram Moolenaar2a3f7ee2006-02-23 21:34:44 +00005621 goto erret;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005622#else
5623 /* use current window */
5624 if (!can_abandon(curbuf, FALSE))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005625 goto erret;
Bram Moolenaar2a3f7ee2006-02-23 21:34:44 +00005626#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005627
5628#ifdef FEAT_WINDOWS
5629 if (curwin->w_height < p_hh)
5630 win_setheight((int)p_hh);
5631#endif
5632
5633 /*
5634 * Open help file (do_ecmd() will set b_help flag, readfile() will
5635 * set b_p_ro flag).
5636 * Set the alternate file to the previously edited file.
5637 */
5638 alt_fnum = curbuf->b_fnum;
5639 (void)do_ecmd(0, NULL, NULL, NULL, ECMD_LASTL,
Bram Moolenaar701f7af2008-11-15 13:12:07 +00005640 ECMD_HIDE + ECMD_SET_HELP,
5641#ifdef FEAT_WINDOWS
5642 NULL /* buffer is still open, don't store info */
5643#else
5644 curwin
5645#endif
5646 );
Bram Moolenaard4755bb2004-09-02 19:12:26 +00005647 if (!cmdmod.keepalt)
5648 curwin->w_alt_fnum = alt_fnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005649 empty_fnum = curbuf->b_fnum;
5650 }
5651 }
5652
5653 if (!p_im)
5654 restart_edit = 0; /* don't want insert mode in help file */
5655
5656 if (tag != NULL)
5657 do_tag(tag, DT_HELP, 1, FALSE, TRUE);
5658
Bram Moolenaar910f66f2006-04-05 20:41:53 +00005659 /* Delete the empty buffer if we're not using it. Careful: autocommands
5660 * may have jumped to another window, check that the buffer is not in a
5661 * window. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005662 if (empty_fnum != 0 && curbuf->b_fnum != empty_fnum)
5663 {
5664 buf = buflist_findnr(empty_fnum);
Bram Moolenaar910f66f2006-04-05 20:41:53 +00005665 if (buf != NULL && buf->b_nwindows == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005666 wipe_buffer(buf, TRUE);
5667 }
5668
5669 /* keep the previous alternate file */
Bram Moolenaard4755bb2004-09-02 19:12:26 +00005670 if (alt_fnum != 0 && curwin->w_alt_fnum == empty_fnum && !cmdmod.keepalt)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005671 curwin->w_alt_fnum = alt_fnum;
5672
5673erret:
5674 vim_free(tag);
5675}
5676
5677
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005678#if defined(FEAT_MULTI_LANG) || defined(PROTO)
5679/*
5680 * In an argument search for a language specifiers in the form "@xx".
5681 * Changes the "@" to NUL if found, and returns a pointer to "xx".
5682 * Returns NULL if not found.
5683 */
5684 char_u *
5685check_help_lang(arg)
5686 char_u *arg;
5687{
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00005688 int len = (int)STRLEN(arg);
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005689
5690 if (len >= 3 && arg[len - 3] == '@' && ASCII_ISALPHA(arg[len - 2])
5691 && ASCII_ISALPHA(arg[len - 1]))
5692 {
5693 arg[len - 3] = NUL; /* remove the '@' */
5694 return arg + len - 2;
5695 }
5696 return NULL;
5697}
5698#endif
5699
Bram Moolenaar071d4272004-06-13 20:20:40 +00005700/*
5701 * Return a heuristic indicating how well the given string matches. The
5702 * smaller the number, the better the match. This is the order of priorities,
5703 * from best match to worst match:
5704 * - Match with least alpha-numeric characters is better.
5705 * - Match with least total characters is better.
5706 * - Match towards the start is better.
5707 * - Match starting with "+" is worse (feature instead of command)
5708 * Assumption is made that the matched_string passed has already been found to
5709 * match some string for which help is requested. webb.
5710 */
5711 int
5712help_heuristic(matched_string, offset, wrong_case)
5713 char_u *matched_string;
5714 int offset; /* offset for match */
5715 int wrong_case; /* no matching case */
5716{
5717 int num_letters;
5718 char_u *p;
5719
5720 num_letters = 0;
5721 for (p = matched_string; *p; p++)
5722 if (ASCII_ISALNUM(*p))
5723 num_letters++;
5724
5725 /*
5726 * Multiply the number of letters by 100 to give it a much bigger
5727 * weighting than the number of characters.
5728 * If there only is a match while ignoring case, add 5000.
5729 * If the match starts in the middle of a word, add 10000 to put it
5730 * somewhere in the last half.
5731 * If the match is more than 2 chars from the start, multiply by 200 to
5732 * put it after matches at the start.
5733 */
5734 if (ASCII_ISALNUM(matched_string[offset]) && offset > 0
5735 && ASCII_ISALNUM(matched_string[offset - 1]))
5736 offset += 10000;
5737 else if (offset > 2)
5738 offset *= 200;
5739 if (wrong_case)
5740 offset += 5000;
5741 /* Features are less interesting than the subjects themselves, but "+"
5742 * alone is not a feature. */
5743 if (matched_string[0] == '+' && matched_string[1] != NUL)
5744 offset += 100;
5745 return (int)(100 * num_letters + STRLEN(matched_string) + offset);
5746}
5747
5748/*
5749 * Compare functions for qsort() below, that checks the help heuristics number
5750 * that has been put after the tagname by find_tags().
5751 */
5752 static int
5753#ifdef __BORLANDC__
5754_RTLENTRYF
5755#endif
5756help_compare(s1, s2)
5757 const void *s1;
5758 const void *s2;
5759{
5760 char *p1;
5761 char *p2;
5762
5763 p1 = *(char **)s1 + strlen(*(char **)s1) + 1;
5764 p2 = *(char **)s2 + strlen(*(char **)s2) + 1;
5765 return strcmp(p1, p2);
5766}
5767
5768/*
5769 * Find all help tags matching "arg", sort them and return in matches[], with
5770 * the number of matches in num_matches.
5771 * The matches will be sorted with a "best" match algorithm.
5772 * When "keep_lang" is TRUE try keeping the language of the current buffer.
5773 */
5774 int
5775find_help_tags(arg, num_matches, matches, keep_lang)
5776 char_u *arg;
5777 int *num_matches;
5778 char_u ***matches;
5779 int keep_lang;
5780{
5781 char_u *s, *d;
5782 int i;
5783 static char *(mtable[]) = {"*", "g*", "[*", "]*", ":*",
Bram Moolenaar231334e2005-07-25 20:46:57 +00005784 "/*", "/\\*", "\"*", "**",
5785 "/\\(\\)",
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00005786 "?", ":?", "?<CR>", "g?", "g?g?", "g??", "z?",
Bram Moolenaarf4630b62005-05-20 21:31:17 +00005787 "/\\?", "/\\z(\\)", "\\=", ":s\\=",
Bram Moolenaar071d4272004-06-13 20:20:40 +00005788 "[count]", "[quotex]", "[range]",
5789 "[pattern]", "\\|", "\\%$"};
5790 static char *(rtable[]) = {"star", "gstar", "[star", "]star", ":star",
Bram Moolenaar231334e2005-07-25 20:46:57 +00005791 "/star", "/\\\\star", "quotestar", "starstar",
5792 "/\\\\(\\\\)",
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00005793 "?", ":?", "?<CR>", "g?", "g?g?", "g??", "z?",
Bram Moolenaarf4630b62005-05-20 21:31:17 +00005794 "/\\\\?", "/\\\\z(\\\\)", "\\\\=", ":s\\\\=",
Bram Moolenaar071d4272004-06-13 20:20:40 +00005795 "\\[count]", "\\[quotex]", "\\[range]",
5796 "\\[pattern]", "\\\\bar", "/\\\\%\\$"};
5797 int flags;
5798
5799 d = IObuff; /* assume IObuff is long enough! */
5800
5801 /*
5802 * Recognize a few exceptions to the rule. Some strings that contain '*'
5803 * with "star". Otherwise '*' is recognized as a wildcard.
5804 */
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00005805 for (i = (int)(sizeof(mtable) / sizeof(char *)); --i >= 0; )
Bram Moolenaar071d4272004-06-13 20:20:40 +00005806 if (STRCMP(arg, mtable[i]) == 0)
5807 {
5808 STRCPY(d, rtable[i]);
5809 break;
5810 }
5811
5812 if (i < 0) /* no match in table */
5813 {
5814 /* Replace "\S" with "/\\S", etc. Otherwise every tag is matched.
5815 * Also replace "\%^" and "\%(", they match every tag too.
5816 * Also "\zs", "\z1", etc.
5817 * Also "\@<", "\@=", "\@<=", etc.
5818 * And also "\_$" and "\_^". */
5819 if (arg[0] == '\\'
5820 && ((arg[1] != NUL && arg[2] == NUL)
5821 || (vim_strchr((char_u *)"%_z@", arg[1]) != NULL
5822 && arg[2] != NUL)))
5823 {
5824 STRCPY(d, "/\\\\");
5825 STRCPY(d + 3, arg + 1);
5826 /* Check for "/\\_$", should be "/\\_\$" */
5827 if (d[3] == '_' && d[4] == '$')
5828 STRCPY(d + 4, "\\$");
5829 }
5830 else
5831 {
5832 /* replace "[:...:]" with "\[:...:]"; "[+...]" with "\[++...]" */
5833 if (arg[0] == '[' && (arg[1] == ':'
5834 || (arg[1] == '+' && arg[2] == '+')))
5835 *d++ = '\\';
5836
5837 for (s = arg; *s; ++s)
5838 {
5839 /*
5840 * Replace "|" with "bar" and '"' with "quote" to match the name of
5841 * the tags for these commands.
5842 * Replace "*" with ".*" and "?" with "." to match command line
5843 * completion.
5844 * Insert a backslash before '~', '$' and '.' to avoid their
5845 * special meaning.
5846 */
5847 if (d - IObuff > IOSIZE - 10) /* getting too long!? */
5848 break;
5849 switch (*s)
5850 {
5851 case '|': STRCPY(d, "bar");
5852 d += 3;
5853 continue;
5854 case '"': STRCPY(d, "quote");
5855 d += 5;
5856 continue;
5857 case '*': *d++ = '.';
5858 break;
5859 case '?': *d++ = '.';
5860 continue;
5861 case '$':
5862 case '.':
5863 case '~': *d++ = '\\';
5864 break;
5865 }
5866
5867 /*
5868 * Replace "^x" by "CTRL-X". Don't do this for "^_" to make
5869 * ":help i_^_CTRL-D" work.
5870 * Insert '-' before and after "CTRL-X" when applicable.
5871 */
5872 if (*s < ' ' || (*s == '^' && s[1] && (ASCII_ISALPHA(s[1])
5873 || vim_strchr((char_u *)"?@[\\]^", s[1]) != NULL)))
5874 {
5875 if (d > IObuff && d[-1] != '_')
5876 *d++ = '_'; /* prepend a '_' */
5877 STRCPY(d, "CTRL-");
5878 d += 5;
5879 if (*s < ' ')
5880 {
5881#ifdef EBCDIC
5882 *d++ = CtrlChar(*s);
5883#else
5884 *d++ = *s + '@';
5885#endif
5886 if (d[-1] == '\\')
5887 *d++ = '\\'; /* double a backslash */
5888 }
5889 else
5890 *d++ = *++s;
5891 if (s[1] != NUL && s[1] != '_')
5892 *d++ = '_'; /* append a '_' */
5893 continue;
5894 }
5895 else if (*s == '^') /* "^" or "CTRL-^" or "^_" */
5896 *d++ = '\\';
5897
5898 /*
5899 * Insert a backslash before a backslash after a slash, for search
5900 * pattern tags: "/\|" --> "/\\|".
5901 */
5902 else if (s[0] == '\\' && s[1] != '\\'
5903 && *arg == '/' && s == arg + 1)
5904 *d++ = '\\';
5905
5906 /* "CTRL-\_" -> "CTRL-\\_" to avoid the special meaning of "\_" in
5907 * "CTRL-\_CTRL-N" */
5908 if (STRNICMP(s, "CTRL-\\_", 7) == 0)
5909 {
5910 STRCPY(d, "CTRL-\\\\");
5911 d += 7;
5912 s += 6;
5913 }
5914
5915 *d++ = *s;
5916
5917 /*
5918 * If tag starts with ', toss everything after a second '. Fixes
5919 * CTRL-] on 'option'. (would include the trailing '.').
5920 */
5921 if (*s == '\'' && s > arg && *arg == '\'')
5922 break;
5923 }
5924 *d = NUL;
5925 }
5926 }
5927
5928 *matches = (char_u **)"";
5929 *num_matches = 0;
5930 flags = TAG_HELP | TAG_REGEXP | TAG_NAMES | TAG_VERBOSE;
5931 if (keep_lang)
5932 flags |= TAG_KEEP_LANG;
Bram Moolenaarc62e2fe2008-08-06 13:03:07 +00005933 if (find_tags(IObuff, num_matches, matches, flags, (int)MAXCOL, NULL) == OK
Bram Moolenaar071d4272004-06-13 20:20:40 +00005934 && *num_matches > 0)
Bram Moolenaarc62e2fe2008-08-06 13:03:07 +00005935 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00005936 /* Sort the matches found on the heuristic number that is after the
5937 * tag name. */
5938 qsort((void *)*matches, (size_t)*num_matches,
5939 sizeof(char_u *), help_compare);
Bram Moolenaarc62e2fe2008-08-06 13:03:07 +00005940 /* Delete more than TAG_MANY to reduce the size of the listing. */
5941 while (*num_matches > TAG_MANY)
5942 vim_free((*matches)[--*num_matches]);
5943 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005944 return OK;
5945}
5946
5947/*
5948 * After reading a help file: May cleanup a help buffer when syntax
5949 * highlighting is not used.
5950 */
5951 void
5952fix_help_buffer()
5953{
5954 linenr_T lnum;
5955 char_u *line;
5956 int in_example = FALSE;
5957 int len;
5958 char_u *p;
5959 char_u *rt;
5960 int mustfree;
5961
5962 /* set filetype to "help". */
5963 set_option_value((char_u *)"ft", 0L, (char_u *)"help", OPT_LOCAL);
5964
5965#ifdef FEAT_SYN_HL
5966 if (!syntax_present(curbuf))
5967#endif
5968 {
5969 for (lnum = 1; lnum <= curbuf->b_ml.ml_line_count; ++lnum)
5970 {
5971 line = ml_get_buf(curbuf, lnum, FALSE);
5972 len = (int)STRLEN(line);
5973 if (in_example && len > 0 && !vim_iswhite(line[0]))
5974 {
5975 /* End of example: non-white or '<' in first column. */
5976 if (line[0] == '<')
5977 {
5978 /* blank-out a '<' in the first column */
5979 line = ml_get_buf(curbuf, lnum, TRUE);
5980 line[0] = ' ';
5981 }
5982 in_example = FALSE;
5983 }
5984 if (!in_example && len > 0)
5985 {
5986 if (line[len - 1] == '>' && (len == 1 || line[len - 2] == ' '))
5987 {
5988 /* blank-out a '>' in the last column (start of example) */
5989 line = ml_get_buf(curbuf, lnum, TRUE);
5990 line[len - 1] = ' ';
5991 in_example = TRUE;
5992 }
5993 else if (line[len - 1] == '~')
5994 {
5995 /* blank-out a '~' at the end of line (header marker) */
5996 line = ml_get_buf(curbuf, lnum, TRUE);
5997 line[len - 1] = ' ';
5998 }
5999 }
6000 }
6001 }
6002
6003 /*
6004 * In the "help.txt" file, add the locally added help files.
6005 * This uses the very first line in the help file.
6006 */
6007 if (fnamecmp(gettail(curbuf->b_fname), "help.txt") == 0)
6008 {
6009 for (lnum = 1; lnum < curbuf->b_ml.ml_line_count; ++lnum)
6010 {
6011 line = ml_get_buf(curbuf, lnum, FALSE);
6012 if (strstr((char *)line, "*local-additions*") != NULL)
6013 {
6014 /* Go through all directories in 'runtimepath', skipping
6015 * $VIMRUNTIME. */
6016 p = p_rtp;
6017 while (*p != NUL)
6018 {
6019 copy_option_part(&p, NameBuff, MAXPATHL, ",");
6020 mustfree = FALSE;
6021 rt = vim_getenv((char_u *)"VIMRUNTIME", &mustfree);
6022 if (fullpathcmp(rt, NameBuff, FALSE) != FPC_SAME)
6023 {
6024 int fcount;
6025 char_u **fnames;
6026 FILE *fd;
6027 char_u *s;
6028 int fi;
6029#ifdef FEAT_MBYTE
6030 vimconv_T vc;
6031 char_u *cp;
6032#endif
6033
6034 /* Find all "doc/ *.txt" files in this directory. */
6035 add_pathsep(NameBuff);
6036 STRCAT(NameBuff, "doc/*.txt");
6037 if (gen_expand_wildcards(1, &NameBuff, &fcount,
6038 &fnames, EW_FILE|EW_SILENT) == OK
6039 && fcount > 0)
6040 {
6041 for (fi = 0; fi < fcount; ++fi)
6042 {
Bram Moolenaarbfd8fc02005-09-20 23:22:24 +00006043 fd = mch_fopen((char *)fnames[fi], "r");
Bram Moolenaar071d4272004-06-13 20:20:40 +00006044 if (fd != NULL)
6045 {
6046 vim_fgets(IObuff, IOSIZE, fd);
6047 if (IObuff[0] == '*'
6048 && (s = vim_strchr(IObuff + 1, '*'))
6049 != NULL)
6050 {
6051#ifdef FEAT_MBYTE
6052 int this_utf = MAYBE;
6053#endif
6054 /* Change tag definition to a
6055 * reference and remove <CR>/<NL>. */
6056 IObuff[0] = '|';
6057 *s = '|';
6058 while (*s != NUL)
6059 {
6060 if (*s == '\r' || *s == '\n')
6061 *s = NUL;
6062#ifdef FEAT_MBYTE
6063 /* The text is utf-8 when a byte
6064 * above 127 is found and no
6065 * illegal byte sequence is found.
6066 */
6067 if (*s >= 0x80 && this_utf != FALSE)
6068 {
6069 int l;
6070
6071 this_utf = TRUE;
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00006072 l = utf_ptr2len(s);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006073 if (l == 1)
6074 this_utf = FALSE;
6075 s += l - 1;
6076 }
6077#endif
6078 ++s;
6079 }
6080#ifdef FEAT_MBYTE
6081 /* The help file is latin1 or utf-8;
6082 * conversion to the current
6083 * 'encoding' may be required. */
6084 vc.vc_type = CONV_NONE;
6085 convert_setup(&vc, (char_u *)(
6086 this_utf == TRUE ? "utf-8"
6087 : "latin1"), p_enc);
6088 if (vc.vc_type == CONV_NONE)
6089 /* No conversion needed. */
6090 cp = IObuff;
6091 else
6092 {
6093 /* Do the conversion. If it fails
6094 * use the unconverted text. */
6095 cp = string_convert(&vc, IObuff,
6096 NULL);
6097 if (cp == NULL)
6098 cp = IObuff;
6099 }
6100 convert_setup(&vc, NULL, NULL);
6101
6102 ml_append(lnum, cp, (colnr_T)0, FALSE);
6103 if (cp != IObuff)
6104 vim_free(cp);
6105#else
6106 ml_append(lnum, IObuff, (colnr_T)0,
6107 FALSE);
6108#endif
6109 ++lnum;
6110 }
6111 fclose(fd);
6112 }
6113 }
6114 FreeWild(fcount, fnames);
6115 }
6116 }
6117 if (mustfree)
6118 vim_free(rt);
6119 }
6120 break;
6121 }
6122 }
6123 }
6124}
6125
Bram Moolenaarb5bf5b82004-12-24 14:35:23 +00006126/*
6127 * ":exusage"
6128 */
Bram Moolenaarb5bf5b82004-12-24 14:35:23 +00006129 void
6130ex_exusage(eap)
Bram Moolenaar0c094b92009-05-14 20:20:33 +00006131 exarg_T *eap UNUSED;
Bram Moolenaarb5bf5b82004-12-24 14:35:23 +00006132{
6133 do_cmdline_cmd((char_u *)"help ex-cmd-index");
6134}
6135
6136/*
6137 * ":viusage"
6138 */
Bram Moolenaarb5bf5b82004-12-24 14:35:23 +00006139 void
6140ex_viusage(eap)
Bram Moolenaar0c094b92009-05-14 20:20:33 +00006141 exarg_T *eap UNUSED;
Bram Moolenaarb5bf5b82004-12-24 14:35:23 +00006142{
6143 do_cmdline_cmd((char_u *)"help normal-index");
6144}
6145
Bram Moolenaar071d4272004-06-13 20:20:40 +00006146#if defined(FEAT_EX_EXTRA) || defined(PROTO)
Bram Moolenaar426e5c92008-01-11 20:02:02 +00006147static void helptags_one __ARGS((char_u *dir, char_u *ext, char_u *lang, int add_help_tags));
Bram Moolenaar071d4272004-06-13 20:20:40 +00006148
6149/*
6150 * ":helptags"
6151 */
6152 void
6153ex_helptags(eap)
6154 exarg_T *eap;
6155{
6156 garray_T ga;
6157 int i, j;
6158 int len;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006159#ifdef FEAT_MULTI_LANG
Bram Moolenaar071d4272004-06-13 20:20:40 +00006160 char_u lang[2];
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006161#endif
Bram Moolenaar0e253142008-01-13 12:31:34 +00006162 expand_T xpc;
6163 char_u *dirname;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006164 char_u ext[5];
6165 char_u fname[8];
6166 int filecount;
6167 char_u **files;
Bram Moolenaar426e5c92008-01-11 20:02:02 +00006168 int add_help_tags = FALSE;
6169
6170 /* Check for ":helptags ++t {dir}". */
6171 if (STRNCMP(eap->arg, "++t", 3) == 0 && vim_iswhite(eap->arg[3]))
6172 {
6173 add_help_tags = TRUE;
6174 eap->arg = skipwhite(eap->arg + 3);
6175 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006176
Bram Moolenaar0e253142008-01-13 12:31:34 +00006177 ExpandInit(&xpc);
6178 xpc.xp_context = EXPAND_DIRECTORIES;
6179 dirname = ExpandOne(&xpc, eap->arg, NULL,
6180 WILD_LIST_NOTFOUND|WILD_SILENT, WILD_EXPAND_FREE);
6181 if (dirname == NULL || !mch_isdir(dirname))
Bram Moolenaar071d4272004-06-13 20:20:40 +00006182 {
6183 EMSG2(_("E150: Not a directory: %s"), eap->arg);
6184 return;
6185 }
6186
6187#ifdef FEAT_MULTI_LANG
6188 /* Get a list of all files in the directory. */
Bram Moolenaar0e253142008-01-13 12:31:34 +00006189 STRCPY(NameBuff, dirname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006190 add_pathsep(NameBuff);
6191 STRCAT(NameBuff, "*");
6192 if (gen_expand_wildcards(1, &NameBuff, &filecount, &files,
6193 EW_FILE|EW_SILENT) == FAIL
6194 || filecount == 0)
6195 {
6196 EMSG2("E151: No match: %s", NameBuff);
Bram Moolenaar0e253142008-01-13 12:31:34 +00006197 vim_free(dirname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006198 return;
6199 }
6200
6201 /* Go over all files in the directory to find out what languages are
6202 * present. */
6203 ga_init2(&ga, 1, 10);
6204 for (i = 0; i < filecount; ++i)
6205 {
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00006206 len = (int)STRLEN(files[i]);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006207 if (len > 4)
6208 {
6209 if (STRICMP(files[i] + len - 4, ".txt") == 0)
6210 {
6211 /* ".txt" -> language "en" */
6212 lang[0] = 'e';
6213 lang[1] = 'n';
6214 }
6215 else if (files[i][len - 4] == '.'
6216 && ASCII_ISALPHA(files[i][len - 3])
6217 && ASCII_ISALPHA(files[i][len - 2])
6218 && TOLOWER_ASC(files[i][len - 1]) == 'x')
6219 {
6220 /* ".abx" -> language "ab" */
6221 lang[0] = TOLOWER_ASC(files[i][len - 3]);
6222 lang[1] = TOLOWER_ASC(files[i][len - 2]);
6223 }
6224 else
6225 continue;
6226
6227 /* Did we find this language already? */
6228 for (j = 0; j < ga.ga_len; j += 2)
6229 if (STRNCMP(lang, ((char_u *)ga.ga_data) + j, 2) == 0)
6230 break;
6231 if (j == ga.ga_len)
6232 {
6233 /* New language, add it. */
6234 if (ga_grow(&ga, 2) == FAIL)
6235 break;
6236 ((char_u *)ga.ga_data)[ga.ga_len++] = lang[0];
6237 ((char_u *)ga.ga_data)[ga.ga_len++] = lang[1];
Bram Moolenaar071d4272004-06-13 20:20:40 +00006238 }
6239 }
6240 }
6241
6242 /*
6243 * Loop over the found languages to generate a tags file for each one.
6244 */
6245 for (j = 0; j < ga.ga_len; j += 2)
6246 {
6247 STRCPY(fname, "tags-xx");
6248 fname[5] = ((char_u *)ga.ga_data)[j];
6249 fname[6] = ((char_u *)ga.ga_data)[j + 1];
6250 if (fname[5] == 'e' && fname[6] == 'n')
6251 {
6252 /* English is an exception: use ".txt" and "tags". */
6253 fname[4] = NUL;
6254 STRCPY(ext, ".txt");
6255 }
6256 else
6257 {
6258 /* Language "ab" uses ".abx" and "tags-ab". */
6259 STRCPY(ext, ".xxx");
6260 ext[1] = fname[5];
6261 ext[2] = fname[6];
6262 }
Bram Moolenaar0e253142008-01-13 12:31:34 +00006263 helptags_one(dirname, ext, fname, add_help_tags);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006264 }
6265
6266 ga_clear(&ga);
6267 FreeWild(filecount, files);
6268
6269#else
6270 /* No language support, just use "*.txt" and "tags". */
Bram Moolenaar0e253142008-01-13 12:31:34 +00006271 helptags_one(dirname, (char_u *)".txt", (char_u *)"tags", add_help_tags);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006272#endif
Bram Moolenaar0e253142008-01-13 12:31:34 +00006273 vim_free(dirname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006274}
6275
6276 static void
Bram Moolenaar426e5c92008-01-11 20:02:02 +00006277helptags_one(dir, ext, tagfname, add_help_tags)
6278 char_u *dir; /* doc directory */
6279 char_u *ext; /* suffix, ".txt", ".itx", ".frx", etc. */
6280 char_u *tagfname; /* "tags" for English, "tags-fr" for French. */
6281 int add_help_tags; /* add "help-tags" tag */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006282{
6283 FILE *fd_tags;
6284 FILE *fd;
6285 garray_T ga;
6286 int filecount;
6287 char_u **files;
6288 char_u *p1, *p2;
6289 int fi;
6290 char_u *s;
6291 int i;
6292 char_u *fname;
6293# ifdef FEAT_MBYTE
6294 int utf8 = MAYBE;
6295 int this_utf8;
6296 int firstline;
6297 int mix = FALSE; /* detected mixed encodings */
6298# endif
6299
6300 /*
6301 * Find all *.txt files.
6302 */
6303 STRCPY(NameBuff, dir);
6304 add_pathsep(NameBuff);
6305 STRCAT(NameBuff, "*");
6306 STRCAT(NameBuff, ext);
6307 if (gen_expand_wildcards(1, &NameBuff, &filecount, &files,
6308 EW_FILE|EW_SILENT) == FAIL
6309 || filecount == 0)
6310 {
6311 if (!got_int)
6312 EMSG2("E151: No match: %s", NameBuff);
6313 return;
6314 }
6315
6316 /*
6317 * Open the tags file for writing.
6318 * Do this before scanning through all the files.
6319 */
6320 STRCPY(NameBuff, dir);
6321 add_pathsep(NameBuff);
6322 STRCAT(NameBuff, tagfname);
Bram Moolenaarbfd8fc02005-09-20 23:22:24 +00006323 fd_tags = mch_fopen((char *)NameBuff, "w");
Bram Moolenaar071d4272004-06-13 20:20:40 +00006324 if (fd_tags == NULL)
6325 {
6326 EMSG2(_("E152: Cannot open %s for writing"), NameBuff);
6327 FreeWild(filecount, files);
6328 return;
6329 }
6330
6331 /*
Bram Moolenaar426e5c92008-01-11 20:02:02 +00006332 * If using the "++t" argument or generating tags for "$VIMRUNTIME/doc"
6333 * add the "help-tags" tag.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006334 */
6335 ga_init2(&ga, (int)sizeof(char_u *), 100);
Bram Moolenaar426e5c92008-01-11 20:02:02 +00006336 if (add_help_tags || fullpathcmp((char_u *)"$VIMRUNTIME/doc",
6337 dir, FALSE) == FPC_SAME)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006338 {
6339 if (ga_grow(&ga, 1) == FAIL)
6340 got_int = TRUE;
6341 else
6342 {
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00006343 s = alloc(18 + (unsigned)STRLEN(tagfname));
Bram Moolenaar071d4272004-06-13 20:20:40 +00006344 if (s == NULL)
6345 got_int = TRUE;
6346 else
6347 {
6348 sprintf((char *)s, "help-tags\t%s\t1\n", tagfname);
6349 ((char_u **)ga.ga_data)[ga.ga_len] = s;
6350 ++ga.ga_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006351 }
6352 }
6353 }
6354
6355 /*
6356 * Go over all the files and extract the tags.
6357 */
6358 for (fi = 0; fi < filecount && !got_int; ++fi)
6359 {
Bram Moolenaarbfd8fc02005-09-20 23:22:24 +00006360 fd = mch_fopen((char *)files[fi], "r");
Bram Moolenaar071d4272004-06-13 20:20:40 +00006361 if (fd == NULL)
6362 {
6363 EMSG2(_("E153: Unable to open %s for reading"), files[fi]);
6364 continue;
6365 }
6366 fname = gettail(files[fi]);
6367
6368# ifdef FEAT_MBYTE
6369 firstline = TRUE;
6370# endif
6371 while (!vim_fgets(IObuff, IOSIZE, fd) && !got_int)
6372 {
6373# ifdef FEAT_MBYTE
6374 if (firstline)
6375 {
6376 /* Detect utf-8 file by a non-ASCII char in the first line. */
6377 this_utf8 = MAYBE;
6378 for (s = IObuff; *s != NUL; ++s)
6379 if (*s >= 0x80)
6380 {
6381 int l;
6382
6383 this_utf8 = TRUE;
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00006384 l = utf_ptr2len(s);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006385 if (l == 1)
6386 {
6387 /* Illegal UTF-8 byte sequence. */
6388 this_utf8 = FALSE;
6389 break;
6390 }
6391 s += l - 1;
6392 }
6393 if (this_utf8 == MAYBE) /* only ASCII characters found */
6394 this_utf8 = FALSE;
6395 if (utf8 == MAYBE) /* first file */
6396 utf8 = this_utf8;
6397 else if (utf8 != this_utf8)
6398 {
6399 EMSG2(_("E670: Mix of help file encodings within a language: %s"), files[fi]);
6400 mix = !got_int;
6401 got_int = TRUE;
6402 }
6403 firstline = FALSE;
6404 }
6405# endif
6406 p1 = vim_strchr(IObuff, '*'); /* find first '*' */
6407 while (p1 != NULL)
6408 {
6409 p2 = vim_strchr(p1 + 1, '*'); /* find second '*' */
6410 if (p2 != NULL && p2 > p1 + 1) /* skip "*" and "**" */
6411 {
6412 for (s = p1 + 1; s < p2; ++s)
6413 if (*s == ' ' || *s == '\t' || *s == '|')
6414 break;
6415
6416 /*
6417 * Only accept a *tag* when it consists of valid
6418 * characters, there is white space before it and is
6419 * followed by a white character or end-of-line.
6420 */
6421 if (s == p2
6422 && (p1 == IObuff || p1[-1] == ' ' || p1[-1] == '\t')
6423 && (vim_strchr((char_u *)" \t\n\r", s[1]) != NULL
6424 || s[1] == '\0'))
6425 {
6426 *p2 = '\0';
6427 ++p1;
6428 if (ga_grow(&ga, 1) == FAIL)
6429 {
6430 got_int = TRUE;
6431 break;
6432 }
6433 s = alloc((unsigned)(p2 - p1 + STRLEN(fname) + 2));
6434 if (s == NULL)
6435 {
6436 got_int = TRUE;
6437 break;
6438 }
6439 ((char_u **)ga.ga_data)[ga.ga_len] = s;
6440 ++ga.ga_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006441 sprintf((char *)s, "%s\t%s", p1, fname);
6442
6443 /* find next '*' */
6444 p2 = vim_strchr(p2 + 1, '*');
6445 }
6446 }
6447 p1 = p2;
6448 }
6449 line_breakcheck();
6450 }
6451
6452 fclose(fd);
6453 }
6454
6455 FreeWild(filecount, files);
6456
6457 if (!got_int)
6458 {
6459 /*
6460 * Sort the tags.
6461 */
6462 sort_strings((char_u **)ga.ga_data, ga.ga_len);
6463
6464 /*
6465 * Check for duplicates.
6466 */
6467 for (i = 1; i < ga.ga_len; ++i)
6468 {
6469 p1 = ((char_u **)ga.ga_data)[i - 1];
6470 p2 = ((char_u **)ga.ga_data)[i];
6471 while (*p1 == *p2)
6472 {
6473 if (*p2 == '\t')
6474 {
6475 *p2 = NUL;
Bram Moolenaar555b2802005-05-19 21:08:39 +00006476 vim_snprintf((char *)NameBuff, MAXPATHL,
Bram Moolenaar071d4272004-06-13 20:20:40 +00006477 _("E154: Duplicate tag \"%s\" in file %s/%s"),
6478 ((char_u **)ga.ga_data)[i], dir, p2 + 1);
6479 EMSG(NameBuff);
6480 *p2 = '\t';
6481 break;
6482 }
6483 ++p1;
6484 ++p2;
6485 }
6486 }
6487
6488# ifdef FEAT_MBYTE
6489 if (utf8 == TRUE)
6490 fprintf(fd_tags, "!_TAG_FILE_ENCODING\tutf-8\t//\n");
6491# endif
6492
6493 /*
6494 * Write the tags into the file.
6495 */
6496 for (i = 0; i < ga.ga_len; ++i)
6497 {
6498 s = ((char_u **)ga.ga_data)[i];
Bram Moolenaarf6210482007-07-25 20:56:39 +00006499 if (STRNCMP(s, "help-tags\t", 10) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006500 /* help-tags entry was added in formatted form */
Bram Moolenaarf6210482007-07-25 20:56:39 +00006501 fputs((char *)s, fd_tags);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006502 else
6503 {
6504 fprintf(fd_tags, "%s\t/*", s);
6505 for (p1 = s; *p1 != '\t'; ++p1)
6506 {
6507 /* insert backslash before '\\' and '/' */
6508 if (*p1 == '\\' || *p1 == '/')
6509 putc('\\', fd_tags);
6510 putc(*p1, fd_tags);
6511 }
6512 fprintf(fd_tags, "*\n");
6513 }
6514 }
6515 }
6516#ifdef FEAT_MBYTE
6517 if (mix)
6518 got_int = FALSE; /* continue with other languages */
6519#endif
6520
6521 for (i = 0; i < ga.ga_len; ++i)
6522 vim_free(((char_u **)ga.ga_data)[i]);
6523 ga_clear(&ga);
6524 fclose(fd_tags); /* there is no check for an error... */
6525}
6526#endif
6527
6528#if defined(FEAT_SIGNS) || defined(PROTO)
6529
6530/*
6531 * Struct to hold the sign properties.
6532 */
6533typedef struct sign sign_T;
6534
6535struct sign
6536{
6537 sign_T *sn_next; /* next sign in list */
6538 int sn_typenr; /* type number of sign (negative if not equal
6539 to name) */
6540 char_u *sn_name; /* name of sign */
6541 char_u *sn_icon; /* name of pixmap */
6542#ifdef FEAT_SIGN_ICONS
6543 void *sn_image; /* icon image */
6544#endif
6545 char_u *sn_text; /* text used instead of pixmap */
6546 int sn_line_hl; /* highlight ID for line */
6547 int sn_text_hl; /* highlight ID for text */
6548};
6549
Bram Moolenaar071d4272004-06-13 20:20:40 +00006550static sign_T *first_sign = NULL;
6551static int last_sign_typenr = MAX_TYPENR; /* is decremented */
6552
Bram Moolenaar985cb442009-05-14 19:51:46 +00006553static int sign_cmd_idx __ARGS((char_u *begin_cmd, char_u *end_cmd));
Bram Moolenaar071d4272004-06-13 20:20:40 +00006554static void sign_list_defined __ARGS((sign_T *sp));
Bram Moolenaarde0dfed2009-02-24 03:30:14 +00006555static void sign_undefine __ARGS((sign_T *sp, sign_T *sp_prev));
Bram Moolenaar071d4272004-06-13 20:20:40 +00006556
Bram Moolenaar3c65e312009-04-29 16:47:23 +00006557static char *cmds[] = {
6558 "define",
6559#define SIGNCMD_DEFINE 0
6560 "undefine",
6561#define SIGNCMD_UNDEFINE 1
6562 "list",
6563#define SIGNCMD_LIST 2
6564 "place",
6565#define SIGNCMD_PLACE 3
6566 "unplace",
6567#define SIGNCMD_UNPLACE 4
6568 "jump",
6569#define SIGNCMD_JUMP 5
6570 NULL
6571#define SIGNCMD_LAST 6
6572};
6573
6574/*
6575 * Find index of a ":sign" subcmd from its name.
6576 * "*end_cmd" must be writable.
6577 */
6578 static int
6579sign_cmd_idx(begin_cmd, end_cmd)
Bram Moolenaar985cb442009-05-14 19:51:46 +00006580 char_u *begin_cmd; /* begin of sign subcmd */
6581 char_u *end_cmd; /* just after sign subcmd */
Bram Moolenaar3c65e312009-04-29 16:47:23 +00006582{
6583 int idx;
6584 char save = *end_cmd;
6585
6586 *end_cmd = NUL;
6587 for (idx = 0; ; ++idx)
6588 if (cmds[idx] == NULL || STRCMP(begin_cmd, cmds[idx]) == 0)
6589 break;
6590 *end_cmd = save;
6591 return idx;
6592}
6593
Bram Moolenaar071d4272004-06-13 20:20:40 +00006594/*
6595 * ":sign" command
6596 */
6597 void
6598ex_sign(eap)
6599 exarg_T *eap;
6600{
6601 char_u *arg = eap->arg;
6602 char_u *p;
6603 int idx;
6604 sign_T *sp;
6605 sign_T *sp_prev;
6606 buf_T *buf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006607
6608 /* Parse the subcommand. */
6609 p = skiptowhite(arg);
Bram Moolenaar3c65e312009-04-29 16:47:23 +00006610 idx = sign_cmd_idx(arg, p);
6611 if (idx == SIGNCMD_LAST)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006612 {
Bram Moolenaar3c65e312009-04-29 16:47:23 +00006613 EMSG2(_("E160: Unknown sign command: %s"), arg);
6614 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006615 }
6616 arg = skipwhite(p);
6617
6618 if (idx <= SIGNCMD_LIST)
6619 {
6620 /*
6621 * Define, undefine or list signs.
6622 */
6623 if (idx == SIGNCMD_LIST && *arg == NUL)
6624 {
6625 /* ":sign list": list all defined signs */
6626 for (sp = first_sign; sp != NULL; sp = sp->sn_next)
6627 sign_list_defined(sp);
6628 }
6629 else if (*arg == NUL)
6630 EMSG(_("E156: Missing sign name"));
6631 else
6632 {
6633 p = skiptowhite(arg);
6634 if (*p != NUL)
6635 *p++ = NUL;
6636 sp_prev = NULL;
6637 for (sp = first_sign; sp != NULL; sp = sp->sn_next)
6638 {
6639 if (STRCMP(sp->sn_name, arg) == 0)
6640 break;
6641 sp_prev = sp;
6642 }
6643 if (idx == SIGNCMD_DEFINE)
6644 {
6645 /* ":sign define {name} ...": define a sign */
6646 if (sp == NULL)
6647 {
6648 /* Allocate a new sign. */
6649 sp = (sign_T *)alloc_clear((unsigned)sizeof(sign_T));
6650 if (sp == NULL)
6651 return;
6652 if (sp_prev == NULL)
6653 first_sign = sp;
6654 else
6655 sp_prev->sn_next = sp;
6656 sp->sn_name = vim_strnsave(arg, (int)(p - arg));
6657
6658 /* If the name is a number use that for the typenr,
6659 * otherwise use a negative number. */
6660 if (VIM_ISDIGIT(*arg))
6661 sp->sn_typenr = atoi((char *)arg);
6662 else
6663 {
6664 sign_T *lp;
6665 int start = last_sign_typenr;
6666
6667 for (lp = first_sign; lp != NULL; lp = lp->sn_next)
6668 {
6669 if (lp->sn_typenr == last_sign_typenr)
6670 {
6671 --last_sign_typenr;
6672 if (last_sign_typenr == 0)
6673 last_sign_typenr = MAX_TYPENR;
6674 if (last_sign_typenr == start)
6675 {
6676 EMSG(_("E612: Too many signs defined"));
6677 return;
6678 }
6679 lp = first_sign;
6680 continue;
6681 }
6682 }
6683
6684 sp->sn_typenr = last_sign_typenr--;
6685 if (last_sign_typenr == 0)
6686 last_sign_typenr = MAX_TYPENR; /* wrap around */
6687 }
6688 }
6689
6690 /* set values for a defined sign. */
6691 for (;;)
6692 {
6693 arg = skipwhite(p);
6694 if (*arg == NUL)
6695 break;
6696 p = skiptowhite_esc(arg);
6697 if (STRNCMP(arg, "icon=", 5) == 0)
6698 {
6699 arg += 5;
6700 vim_free(sp->sn_icon);
6701 sp->sn_icon = vim_strnsave(arg, (int)(p - arg));
6702 backslash_halve(sp->sn_icon);
6703#ifdef FEAT_SIGN_ICONS
6704 if (gui.in_use)
6705 {
6706 out_flush();
6707 if (sp->sn_image != NULL)
6708 gui_mch_destroy_sign(sp->sn_image);
6709 sp->sn_image = gui_mch_register_sign(sp->sn_icon);
6710 }
6711#endif
6712 }
6713 else if (STRNCMP(arg, "text=", 5) == 0)
6714 {
6715 char_u *s;
6716 int cells;
6717 int len;
6718
6719 arg += 5;
6720#ifdef FEAT_MBYTE
6721 /* Count cells and check for non-printable chars */
6722 if (has_mbyte)
6723 {
6724 cells = 0;
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00006725 for (s = arg; s < p; s += (*mb_ptr2len)(s))
Bram Moolenaar071d4272004-06-13 20:20:40 +00006726 {
6727 if (!vim_isprintc((*mb_ptr2char)(s)))
6728 break;
6729 cells += (*mb_ptr2cells)(s);
6730 }
6731 }
6732 else
6733#endif
6734 {
6735 for (s = arg; s < p; ++s)
6736 if (!vim_isprintc(*s))
6737 break;
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00006738 cells = (int)(s - arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006739 }
6740 /* Currently must be one or two display cells */
6741 if (s != p || cells < 1 || cells > 2)
6742 {
6743 *p = NUL;
6744 EMSG2(_("E239: Invalid sign text: %s"), arg);
6745 return;
6746 }
6747
6748 vim_free(sp->sn_text);
6749 /* Allocate one byte more if we need to pad up
6750 * with a space. */
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00006751 len = (int)(p - arg + ((cells == 1) ? 1 : 0));
Bram Moolenaar071d4272004-06-13 20:20:40 +00006752 sp->sn_text = vim_strnsave(arg, len);
6753
6754 if (sp->sn_text != NULL && cells == 1)
6755 STRCPY(sp->sn_text + len - 1, " ");
6756 }
6757 else if (STRNCMP(arg, "linehl=", 7) == 0)
6758 {
6759 arg += 7;
6760 sp->sn_line_hl = syn_check_group(arg, (int)(p - arg));
6761 }
6762 else if (STRNCMP(arg, "texthl=", 7) == 0)
6763 {
6764 arg += 7;
6765 sp->sn_text_hl = syn_check_group(arg, (int)(p - arg));
6766 }
6767 else
6768 {
6769 EMSG2(_(e_invarg2), arg);
6770 return;
6771 }
6772 }
6773 }
6774 else if (sp == NULL)
6775 EMSG2(_("E155: Unknown sign: %s"), arg);
6776 else if (idx == SIGNCMD_LIST)
6777 /* ":sign list {name}" */
6778 sign_list_defined(sp);
6779 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00006780 /* ":sign undefine {name}" */
Bram Moolenaarde0dfed2009-02-24 03:30:14 +00006781 sign_undefine(sp, sp_prev);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006782 }
6783 }
6784 else
6785 {
6786 int id = -1;
6787 linenr_T lnum = -1;
6788 char_u *sign_name = NULL;
6789 char_u *arg1;
6790
6791 if (*arg == NUL)
6792 {
6793 if (idx == SIGNCMD_PLACE)
6794 {
6795 /* ":sign place": list placed signs in all buffers */
6796 sign_list_placed(NULL);
6797 }
6798 else if (idx == SIGNCMD_UNPLACE)
6799 {
6800 /* ":sign unplace": remove placed sign at cursor */
6801 id = buf_findsign_id(curwin->w_buffer, curwin->w_cursor.lnum);
6802 if (id > 0)
6803 {
6804 buf_delsign(curwin->w_buffer, id);
6805 update_debug_sign(curwin->w_buffer, curwin->w_cursor.lnum);
6806 }
6807 else
6808 EMSG(_("E159: Missing sign number"));
6809 }
6810 else
6811 EMSG(_(e_argreq));
6812 return;
6813 }
6814
6815 if (idx == SIGNCMD_UNPLACE && arg[0] == '*' && arg[1] == NUL)
6816 {
6817 /* ":sign unplace *": remove all placed signs */
6818 buf_delete_all_signs();
6819 return;
6820 }
6821
6822 /* first arg could be placed sign id */
6823 arg1 = arg;
6824 if (VIM_ISDIGIT(*arg))
6825 {
6826 id = getdigits(&arg);
6827 if (!vim_iswhite(*arg) && *arg != NUL)
6828 {
6829 id = -1;
6830 arg = arg1;
6831 }
6832 else
6833 {
6834 arg = skipwhite(arg);
6835 if (idx == SIGNCMD_UNPLACE && *arg == NUL)
6836 {
6837 /* ":sign unplace {id}": remove placed sign by number */
6838 for (buf = firstbuf; buf != NULL; buf = buf->b_next)
6839 if ((lnum = buf_delsign(buf, id)) != 0)
6840 update_debug_sign(buf, lnum);
6841 return;
6842 }
6843 }
6844 }
6845
6846 /*
6847 * Check for line={lnum} name={name} and file={fname} or buffer={nr}.
6848 * Leave "arg" pointing to {fname}.
6849 */
6850 for (;;)
6851 {
6852 if (STRNCMP(arg, "line=", 5) == 0)
6853 {
6854 arg += 5;
6855 lnum = atoi((char *)arg);
6856 arg = skiptowhite(arg);
6857 }
6858 else if (STRNCMP(arg, "name=", 5) == 0)
6859 {
6860 arg += 5;
6861 sign_name = arg;
6862 arg = skiptowhite(arg);
6863 if (*arg != NUL)
6864 *arg++ = NUL;
6865 }
6866 else if (STRNCMP(arg, "file=", 5) == 0)
6867 {
6868 arg += 5;
6869 buf = buflist_findname(arg);
6870 break;
6871 }
6872 else if (STRNCMP(arg, "buffer=", 7) == 0)
6873 {
6874 arg += 7;
6875 buf = buflist_findnr((int)getdigits(&arg));
6876 if (*skipwhite(arg) != NUL)
6877 EMSG(_(e_trailing));
6878 break;
6879 }
6880 else
6881 {
6882 EMSG(_(e_invarg));
6883 return;
6884 }
6885 arg = skipwhite(arg);
6886 }
6887
6888 if (buf == NULL)
6889 {
6890 EMSG2(_("E158: Invalid buffer name: %s"), arg);
6891 }
6892 else if (id <= 0)
6893 {
6894 if (lnum >= 0 || sign_name != NULL)
6895 EMSG(_(e_invarg));
6896 else
6897 /* ":sign place file={fname}": list placed signs in one file */
6898 sign_list_placed(buf);
6899 }
6900 else if (idx == SIGNCMD_JUMP)
6901 {
6902 /* ":sign jump {id} file={fname}" */
6903 if (lnum >= 0 || sign_name != NULL)
6904 EMSG(_(e_invarg));
6905 else if ((lnum = buf_findsign(buf, id)) > 0)
6906 { /* goto a sign ... */
6907 if (buf_jump_open_win(buf) != NULL)
6908 { /* ... in a current window */
6909 curwin->w_cursor.lnum = lnum;
6910 check_cursor_lnum();
6911 beginline(BL_WHITE);
6912 }
6913 else
6914 { /* ... not currently in a window */
6915 char_u *cmd;
6916
6917 cmd = alloc((unsigned)STRLEN(buf->b_fname) + 25);
6918 if (cmd == NULL)
6919 return;
6920 sprintf((char *)cmd, "e +%ld %s", (long)lnum, buf->b_fname);
6921 do_cmdline_cmd(cmd);
6922 vim_free(cmd);
6923 }
6924#ifdef FEAT_FOLDING
6925 foldOpenCursor();
6926#endif
6927 }
6928 else
6929 EMSGN(_("E157: Invalid sign ID: %ld"), id);
6930 }
6931 else if (idx == SIGNCMD_UNPLACE)
6932 {
6933 /* ":sign unplace {id} file={fname}" */
6934 if (lnum >= 0 || sign_name != NULL)
6935 EMSG(_(e_invarg));
6936 else
6937 {
6938 lnum = buf_delsign(buf, id);
6939 update_debug_sign(buf, lnum);
6940 }
6941 }
6942 /* idx == SIGNCMD_PLACE */
6943 else if (sign_name != NULL)
6944 {
6945 for (sp = first_sign; sp != NULL; sp = sp->sn_next)
6946 if (STRCMP(sp->sn_name, sign_name) == 0)
6947 break;
6948 if (sp == NULL)
6949 {
6950 EMSG2(_("E155: Unknown sign: %s"), sign_name);
6951 return;
6952 }
6953 if (lnum > 0)
6954 /* ":sign place {id} line={lnum} name={name} file={fname}":
6955 * place a sign */
6956 buf_addsign(buf, id, lnum, sp->sn_typenr);
6957 else
6958 /* ":sign place {id} file={fname}": change sign type */
6959 lnum = buf_change_sign_type(buf, id, sp->sn_typenr);
6960 update_debug_sign(buf, lnum);
6961 }
6962 else
6963 EMSG(_(e_invarg));
6964 }
6965}
6966
6967#if defined(FEAT_SIGN_ICONS) || defined(PROTO)
6968/*
6969 * Allocate the icons. Called when the GUI has started. Allows defining
6970 * signs before it starts.
6971 */
6972 void
6973sign_gui_started()
6974{
6975 sign_T *sp;
6976
6977 for (sp = first_sign; sp != NULL; sp = sp->sn_next)
6978 if (sp->sn_icon != NULL)
6979 sp->sn_image = gui_mch_register_sign(sp->sn_icon);
6980}
6981#endif
6982
6983/*
6984 * List one sign.
6985 */
6986 static void
6987sign_list_defined(sp)
6988 sign_T *sp;
6989{
6990 char_u *p;
6991
Bram Moolenaar555b2802005-05-19 21:08:39 +00006992 smsg((char_u *)"sign %s", sp->sn_name);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006993 if (sp->sn_icon != NULL)
6994 {
6995 MSG_PUTS(" icon=");
6996 msg_outtrans(sp->sn_icon);
6997#ifdef FEAT_SIGN_ICONS
6998 if (sp->sn_image == NULL)
6999 MSG_PUTS(_(" (NOT FOUND)"));
7000#else
7001 MSG_PUTS(_(" (not supported)"));
7002#endif
7003 }
7004 if (sp->sn_text != NULL)
7005 {
7006 MSG_PUTS(" text=");
7007 msg_outtrans(sp->sn_text);
7008 }
7009 if (sp->sn_line_hl > 0)
7010 {
7011 MSG_PUTS(" linehl=");
7012 p = get_highlight_name(NULL, sp->sn_line_hl - 1);
7013 if (p == NULL)
7014 MSG_PUTS("NONE");
7015 else
7016 msg_puts(p);
7017 }
7018 if (sp->sn_text_hl > 0)
7019 {
7020 MSG_PUTS(" texthl=");
7021 p = get_highlight_name(NULL, sp->sn_text_hl - 1);
7022 if (p == NULL)
7023 MSG_PUTS("NONE");
7024 else
7025 msg_puts(p);
7026 }
7027}
7028
7029/*
Bram Moolenaarde0dfed2009-02-24 03:30:14 +00007030 * Undefine a sign and free its memory.
7031 */
7032 static void
7033sign_undefine(sp, sp_prev)
7034 sign_T *sp;
7035 sign_T *sp_prev;
7036{
7037 vim_free(sp->sn_name);
7038 vim_free(sp->sn_icon);
7039#ifdef FEAT_SIGN_ICONS
7040 if (sp->sn_image != NULL)
7041 {
7042 out_flush();
7043 gui_mch_destroy_sign(sp->sn_image);
7044 }
7045#endif
7046 vim_free(sp->sn_text);
7047 if (sp_prev == NULL)
7048 first_sign = sp->sn_next;
7049 else
7050 sp_prev->sn_next = sp->sn_next;
7051 vim_free(sp);
7052}
7053
7054/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00007055 * Get highlighting attribute for sign "typenr".
7056 * If "line" is TRUE: line highl, if FALSE: text highl.
7057 */
7058 int
7059sign_get_attr(typenr, line)
7060 int typenr;
7061 int line;
7062{
7063 sign_T *sp;
7064
7065 for (sp = first_sign; sp != NULL; sp = sp->sn_next)
7066 if (sp->sn_typenr == typenr)
7067 {
7068 if (line)
7069 {
7070 if (sp->sn_line_hl > 0)
7071 return syn_id2attr(sp->sn_line_hl);
7072 }
7073 else
7074 {
7075 if (sp->sn_text_hl > 0)
7076 return syn_id2attr(sp->sn_text_hl);
7077 }
7078 break;
7079 }
7080 return 0;
7081}
7082
7083/*
7084 * Get text mark for sign "typenr".
7085 * Returns NULL if there isn't one.
7086 */
7087 char_u *
7088sign_get_text(typenr)
7089 int typenr;
7090{
7091 sign_T *sp;
7092
7093 for (sp = first_sign; sp != NULL; sp = sp->sn_next)
7094 if (sp->sn_typenr == typenr)
7095 return sp->sn_text;
7096 return NULL;
7097}
7098
7099#if defined(FEAT_SIGN_ICONS) || defined(PROTO)
7100 void *
7101sign_get_image(typenr)
7102 int typenr; /* the attribute which may have a sign */
7103{
7104 sign_T *sp;
7105
7106 for (sp = first_sign; sp != NULL; sp = sp->sn_next)
7107 if (sp->sn_typenr == typenr)
7108 return sp->sn_image;
7109 return NULL;
7110}
7111#endif
7112
7113/*
7114 * Get the name of a sign by its typenr.
7115 */
7116 char_u *
7117sign_typenr2name(typenr)
7118 int typenr;
7119{
7120 sign_T *sp;
7121
7122 for (sp = first_sign; sp != NULL; sp = sp->sn_next)
7123 if (sp->sn_typenr == typenr)
7124 return sp->sn_name;
7125 return (char_u *)_("[Deleted]");
7126}
7127
Bram Moolenaarde0dfed2009-02-24 03:30:14 +00007128#if defined(EXITFREE) || defined(PROTO)
7129/*
7130 * Undefine/free all signs.
7131 */
7132 void
7133free_signs()
7134{
7135 while (first_sign != NULL)
7136 sign_undefine(first_sign, NULL);
7137}
7138#endif
7139
Bram Moolenaar3c65e312009-04-29 16:47:23 +00007140#if defined(FEAT_CMDL_COMPL) || defined(PROTO)
7141static enum
7142{
7143 EXP_SUBCMD, /* expand :sign sub-commands */
7144 EXP_DEFINE, /* expand :sign define {name} args */
7145 EXP_PLACE, /* expand :sign place {id} args */
7146 EXP_UNPLACE, /* expand :sign unplace" */
7147 EXP_SIGN_NAMES /* expand with name of placed signs */
7148} expand_what;
7149
7150/*
7151 * Function given to ExpandGeneric() to obtain the sign command
7152 * expansion.
7153 */
Bram Moolenaar3c65e312009-04-29 16:47:23 +00007154 char_u *
7155get_sign_name(xp, idx)
Bram Moolenaar0c094b92009-05-14 20:20:33 +00007156 expand_T *xp UNUSED;
Bram Moolenaar3c65e312009-04-29 16:47:23 +00007157 int idx;
7158{
7159 sign_T *sp;
7160 int current_idx;
7161
7162 switch (expand_what)
7163 {
7164 case EXP_SUBCMD:
7165 return (char_u *)cmds[idx];
7166 case EXP_DEFINE:
7167 {
7168 char *define_arg[] =
7169 {
7170 "icon=", "linehl=", "text=", "texthl=", NULL
7171 };
7172 return (char_u *)define_arg[idx];
7173 }
7174 case EXP_PLACE:
7175 {
7176 char *place_arg[] =
7177 {
7178 "line=", "name=", "file=", "buffer=", NULL
7179 };
7180 return (char_u *)place_arg[idx];
7181 }
7182 case EXP_UNPLACE:
7183 {
7184 char *unplace_arg[] = { "file=", "buffer=", NULL };
7185 return (char_u *)unplace_arg[idx];
7186 }
7187 case EXP_SIGN_NAMES:
7188 /* Complete with name of signs already defined */
7189 current_idx = 0;
7190 for (sp = first_sign; sp != NULL; sp = sp->sn_next)
7191 if (current_idx++ == idx)
7192 return sp->sn_name;
7193 return NULL;
7194 default:
7195 return NULL;
7196 }
7197}
7198
7199/*
7200 * Handle command line completion for :sign command.
7201 */
7202 void
7203set_context_in_sign_cmd(xp, arg)
7204 expand_T *xp;
7205 char_u *arg;
7206{
7207 char_u *p;
7208 char_u *end_subcmd;
7209 char_u *last;
7210 int cmd_idx;
7211 char_u *begin_subcmd_args;
7212
7213 /* Default: expand subcommands. */
7214 xp->xp_context = EXPAND_SIGN;
7215 expand_what = EXP_SUBCMD;
7216 xp->xp_pattern = arg;
7217
7218 end_subcmd = skiptowhite(arg);
7219 if (*end_subcmd == NUL)
7220 /* expand subcmd name
7221 * :sign {subcmd}<CTRL-D>*/
7222 return;
7223
7224 cmd_idx = sign_cmd_idx(arg, end_subcmd);
7225
7226 /* :sign {subcmd} {subcmd_args}
7227 * |
7228 * begin_subcmd_args */
7229 begin_subcmd_args = skipwhite(end_subcmd);
7230 p = skiptowhite(begin_subcmd_args);
7231 if (*p == NUL)
7232 {
7233 /*
7234 * Expand first argument of subcmd when possible.
7235 * For ":jump {id}" and ":unplace {id}", we could
7236 * possibly expand the ids of all signs already placed.
7237 */
7238 xp->xp_pattern = begin_subcmd_args;
7239 switch (cmd_idx)
7240 {
7241 case SIGNCMD_LIST:
7242 case SIGNCMD_UNDEFINE:
7243 /* :sign list <CTRL-D>
7244 * :sign undefine <CTRL-D> */
7245 expand_what = EXP_SIGN_NAMES;
7246 break;
7247 default:
7248 xp->xp_context = EXPAND_NOTHING;
7249 }
7250 return;
7251 }
7252
7253 /* expand last argument of subcmd */
7254
7255 /* :sign define {name} {args}...
7256 * |
7257 * p */
7258
7259 /* Loop until reaching last argument. */
7260 do
7261 {
7262 p = skipwhite(p);
7263 last = p;
7264 p = skiptowhite(p);
7265 } while (*p != NUL);
7266
7267 p = vim_strchr(last, '=');
7268
7269 /* :sign define {name} {args}... {last}=
7270 * | |
7271 * last p */
7272 if (p == NUL)
7273 {
7274 /* Expand last argument name (before equal sign). */
7275 xp->xp_pattern = last;
7276 switch (cmd_idx)
7277 {
7278 case SIGNCMD_DEFINE:
7279 expand_what = EXP_DEFINE;
7280 break;
7281 case SIGNCMD_PLACE:
7282 expand_what = EXP_PLACE;
7283 break;
7284 case SIGNCMD_JUMP:
7285 case SIGNCMD_UNPLACE:
7286 expand_what = EXP_UNPLACE;
7287 break;
7288 default:
7289 xp->xp_context = EXPAND_NOTHING;
7290 }
7291 }
7292 else
7293 {
7294 /* Expand last argument value (after equal sign). */
7295 xp->xp_pattern = p + 1;
7296 switch (cmd_idx)
7297 {
7298 case SIGNCMD_DEFINE:
7299 if (STRNCMP(last, "texthl", p - last) == 0 ||
7300 STRNCMP(last, "linehl", p - last) == 0)
7301 xp->xp_context = EXPAND_HIGHLIGHT;
7302 else if (STRNCMP(last, "icon", p - last) == 0)
7303 xp->xp_context = EXPAND_FILES;
7304 else
7305 xp->xp_context = EXPAND_NOTHING;
7306 break;
7307 case SIGNCMD_PLACE:
7308 if (STRNCMP(last, "name", p - last) == 0)
7309 expand_what = EXP_SIGN_NAMES;
7310 else
7311 xp->xp_context = EXPAND_NOTHING;
7312 break;
7313 default:
7314 xp->xp_context = EXPAND_NOTHING;
7315 }
7316 }
7317}
7318#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007319#endif
7320
7321#if defined(FEAT_GUI) || defined(FEAT_CLIENTSERVER) || defined(PROTO)
7322/*
7323 * ":drop"
7324 * Opens the first argument in a window. When there are two or more arguments
7325 * the argument list is redefined.
7326 */
7327 void
7328ex_drop(eap)
7329 exarg_T *eap;
7330{
7331 int split = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007332 win_T *wp;
7333 buf_T *buf;
Bram Moolenaara5b6ad12006-03-11 21:36:59 +00007334# ifdef FEAT_WINDOWS
7335 tabpage_T *tp;
7336# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007337
7338 /*
7339 * Check if the first argument is already being edited in a window. If
7340 * so, jump to that window.
7341 * We would actually need to check all arguments, but that's complicated
7342 * and mostly only one file is dropped.
7343 * This also ignores wildcards, since it is very unlikely the user is
7344 * editing a file name with a wildcard character.
7345 */
Bram Moolenaara5b6ad12006-03-11 21:36:59 +00007346 set_arglist(eap->arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007347
Bram Moolenaarb01a8b72007-02-13 02:47:22 +00007348 /*
7349 * Expanding wildcards may result in an empty argument list. E.g. when
7350 * editing "foo.pyc" and ".pyc" is in 'wildignore'. Assume that we
7351 * already did an error message for this.
7352 */
7353 if (ARGCOUNT == 0)
7354 return;
7355
Bram Moolenaara5b6ad12006-03-11 21:36:59 +00007356# ifdef FEAT_WINDOWS
7357 if (cmdmod.tab)
7358 {
7359 /* ":tab drop file ...": open a tab for each argument that isn't
7360 * edited in a window yet. It's like ":tab all" but without closing
7361 * windows or tabs. */
7362 ex_all(eap);
7363 }
7364 else
7365# endif
7366 {
7367 /* ":drop file ...": Edit the first argument. Jump to an existing
7368 * window if possible, edit in current window if the current buffer
7369 * can be abandoned, otherwise open a new window. */
7370 buf = buflist_findnr(ARGLIST[0].ae_fnum);
7371
7372 FOR_ALL_TAB_WINDOWS(tp, wp)
7373 {
7374 if (wp->w_buffer == buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007375 {
Bram Moolenaara5b6ad12006-03-11 21:36:59 +00007376# ifdef FEAT_WINDOWS
Bram Moolenaar779b74b2006-04-10 14:55:34 +00007377 goto_tabpage_win(tp, wp);
Bram Moolenaara5b6ad12006-03-11 21:36:59 +00007378# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007379 curwin->w_arg_idx = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007380 return;
7381 }
7382 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007383
Bram Moolenaara5b6ad12006-03-11 21:36:59 +00007384 /*
7385 * Check whether the current buffer is changed. If so, we will need
7386 * to split the current window or data could be lost.
7387 * Skip the check if the 'hidden' option is set, as in this case the
7388 * buffer won't be lost.
7389 */
7390 if (!P_HID(curbuf))
7391 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00007392# ifdef FEAT_WINDOWS
Bram Moolenaara5b6ad12006-03-11 21:36:59 +00007393 ++emsg_off;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007394# endif
Bram Moolenaara5b6ad12006-03-11 21:36:59 +00007395 split = check_changed(curbuf, TRUE, FALSE, FALSE, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007396# ifdef FEAT_WINDOWS
Bram Moolenaara5b6ad12006-03-11 21:36:59 +00007397 --emsg_off;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007398# else
Bram Moolenaara5b6ad12006-03-11 21:36:59 +00007399 if (split)
7400 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007401# endif
Bram Moolenaara5b6ad12006-03-11 21:36:59 +00007402 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007403
Bram Moolenaara5b6ad12006-03-11 21:36:59 +00007404 /* Fake a ":sfirst" or ":first" command edit the first argument. */
7405 if (split)
7406 {
7407 eap->cmdidx = CMD_sfirst;
7408 eap->cmd[0] = 's';
7409 }
7410 else
7411 eap->cmdidx = CMD_first;
7412 ex_rewind(eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007413 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007414}
7415#endif