1 /* vi:set ts=8 sts=4 sw=4:
3 * VIM - Vi IMproved by Bram Moolenaar
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.
11 * ex_cmds.c: some functions for command line commands
14 #if defined(MSDOS) || defined(WIN16) || defined(WIN32) || defined(_WIN64)
15 # include "vimio.h" /* for mch_open(), must be before vim.h */
22 static int linelen
__ARGS((int *has_tab
));
24 static void do_filter
__ARGS((linenr_T line1
, linenr_T line2
, exarg_T
*eap
, char_u
*cmd
, int do_in
, int do_out
));
26 static char_u
*viminfo_filename
__ARGS((char_u
*));
27 static void do_viminfo
__ARGS((FILE *fp_in
, FILE *fp_out
, int flags
));
28 static int viminfo_encoding
__ARGS((vir_T
*virp
));
29 static int read_viminfo_up_to_marks
__ARGS((vir_T
*virp
, int forceit
, int writing
));
32 static int check_overwrite
__ARGS((exarg_T
*eap
, buf_T
*buf
, char_u
*fname
, char_u
*ffname
, int other
));
33 static int check_readonly
__ARGS((int *forceit
, buf_T
*buf
));
35 static void delbuf_msg
__ARGS((char_u
*name
));
41 help_compare
__ARGS((const void *s1
, const void *s2
));
61 c
= utfc_ptr2char(ml_get_cursor(), cc
);
73 if (!has_mbyte
|| (enc_dbcs
!= 0 && c
< 0x100) || c
< 0x80)
76 if (c
== NL
) /* NUL is stored as NL */
78 if (c
== CAR
&& get_fileformat(curbuf
) == EOL_MAC
)
79 cval
= NL
; /* NL is stored as CR */
82 if (vim_isprintc_strict(c
) && (c
< ' '
88 transchar_nonprint(buf3
, c
);
89 vim_snprintf(buf1
, sizeof(buf1
), " <%s>", (char *)buf3
);
95 vim_snprintf(buf2
, sizeof(buf2
), " <M-%s>",
96 (char *)transchar(c
& 0x7f));
100 vim_snprintf((char *)IObuff
, IOSIZE
,
101 _("<%s>%s%s %d, Hex %02x, Octal %03o"),
102 transchar(c
), buf1
, buf2
, cval
, cval
, cval
);
112 /* Repeat for combining characters. */
113 while (has_mbyte
&& (c
>= 0x100 || (enc_utf8
&& c
>= 0x80)))
115 len
= (int)STRLEN(IObuff
);
116 /* This assumes every multi-byte char is printable... */
120 if (enc_utf8
&& utf_iscomposing(c
)
125 IObuff
[len
++] = ' '; /* draw composing char on top of a space */
126 len
+= (*mb_char2bytes
)(c
, IObuff
+ len
);
127 vim_snprintf((char *)IObuff
+ len
, IOSIZE
- len
,
128 c
< 0x10000 ? _("> %d, Hex %04x, Octal %o")
129 : _("> %d, Hex %08x, Octal %o"), c
, c
, c
);
142 #if defined(FEAT_EX_EXTRA) || defined(PROTO)
144 * ":left", ":center" and ":right": align text.
157 #ifdef FEAT_RIGHTLEFT
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
;
168 width
= atoi((char *)eap
->arg
);
169 save_curpos
= curwin
->w_cursor
;
170 if (eap
->cmdidx
== CMD_left
) /* width is used for new indent */
178 * if 'textwidth' set, use it
179 * else if 'wrapmargin' set, use it
180 * if invalid value, use 80
183 width
= curbuf
->b_p_tw
;
184 if (width
== 0 && curbuf
->b_p_wm
> 0)
185 width
= W_WIDTH(curwin
) - curbuf
->b_p_wm
;
190 if (u_save((linenr_T
)(eap
->line1
- 1), (linenr_T
)(eap
->line2
+ 1)) == FAIL
)
193 for (curwin
->w_cursor
.lnum
= eap
->line1
;
194 curwin
->w_cursor
.lnum
<= eap
->line2
; ++curwin
->w_cursor
.lnum
)
196 if (eap
->cmdidx
== CMD_left
) /* left align */
200 has_tab
= FALSE
; /* avoid uninit warnings */
201 len
= linelen(eap
->cmdidx
== CMD_right
? &has_tab
202 : NULL
) - get_indent();
204 if (len
<= 0) /* skip blank lines */
207 if (eap
->cmdidx
== CMD_center
)
208 new_indent
= (width
- len
) / 2;
211 new_indent
= width
- len
; /* right align */
214 * Make sure that embedded TABs don't make the text go too far
218 while (new_indent
> 0)
220 (void)set_indent(new_indent
, 0);
221 if (linelen(NULL
) <= width
)
224 * Now try to move the line as much as possible to
225 * the right. Stop when it moves too far.
228 (void)set_indent(++new_indent
, 0);
229 while (linelen(NULL
) <= width
);
239 (void)set_indent(new_indent
, 0); /* set indent */
241 changed_lines(eap
->line1
, 0, eap
->line2
+ 1, 0L);
242 curwin
->w_cursor
= save_curpos
;
243 beginline(BL_WHITE
| BL_FIX
);
247 * Get the length of the current line, excluding trailing white space.
259 /* find the first non-blank character */
260 line
= ml_get_curline();
261 first
= skipwhite(line
);
263 /* find the character after the last non-blank character */
264 for (last
= first
+ STRLEN(first
);
265 last
> first
&& vim_iswhite(last
[-1]); --last
)
269 len
= linetabsize(line
, curwin
->w_cursor
.lnum
); /* get line length */
270 if (has_tab
!= NULL
) /* check for embedded TAB */
271 *has_tab
= (vim_strrchr(first
, TAB
) != NULL
);
277 /* Buffer for two lines used during sorting. They are allocated to
278 * contain the longest line being sorted. */
279 static char_u
*sortbuf1
;
280 static char_u
*sortbuf2
;
282 static int sort_ic
; /* ignore case */
283 static int sort_nr
; /* sort on number */
284 static int sort_rx
; /* sort on regex instead of skipping it */
286 static int sort_abort
; /* flag to indicate if sorting has been interrupted */
288 /* Struct to store info to be sorted. */
291 linenr_T lnum
; /* line number */
292 long start_col_nr
; /* starting column number or number */
293 long end_col_nr
; /* ending column number */
300 sort_compare
__ARGS((const void *s1
, const void *s2
));
310 sorti_T l1
= *(sorti_T
*)s1
;
311 sorti_T l2
= *(sorti_T
*)s2
;
314 /* If the user interrupts, there's no way to stop qsort() immediately, but
315 * if we return 0 every time, qsort will assume it's done sorting and
323 /* When sorting numbers "start_col_nr" is the number, not the column
326 result
= l1
.start_col_nr
- l2
.start_col_nr
;
329 /* We need to copy one line into "sortbuf1", because there is no
330 * guarantee that the first pointer becomes invalid when obtaining the
332 STRNCPY(sortbuf1
, ml_get(l1
.lnum
) + l1
.start_col_nr
,
333 l1
.end_col_nr
- l1
.start_col_nr
+ 1);
334 sortbuf1
[l1
.end_col_nr
- l1
.start_col_nr
] = 0;
335 STRNCPY(sortbuf2
, ml_get(l2
.lnum
) + l2
.start_col_nr
,
336 l2
.end_col_nr
- l2
.start_col_nr
+ 1);
337 sortbuf2
[l2
.end_col_nr
- l2
.start_col_nr
] = 0;
339 result
= sort_ic
? STRICMP(sortbuf1
, sortbuf2
)
340 : STRCMP(sortbuf1
, sortbuf2
);
343 /* If two lines have the same value, preserve the original line order. */
345 return (int)(l1
.lnum
- l2
.lnum
);
361 size_t count
= (size_t)(eap
->line2
- eap
->line1
+ 1);
366 char_u c
; /* temporary character storage */
371 int sort_oct
; /* sort on octal number */
372 int sort_hex
; /* sort on hex number */
374 /* Sorting one line is really quick! */
378 if (u_save((linenr_T
)(eap
->line1
- 1), (linenr_T
)(eap
->line2
+ 1)) == FAIL
)
382 regmatch
.regprog
= NULL
;
383 nrs
= (sorti_T
*)lalloc((long_u
)(count
* sizeof(sorti_T
)), TRUE
);
387 sort_abort
= sort_ic
= sort_rx
= sort_nr
= sort_oct
= sort_hex
= 0;
389 for (p
= eap
->arg
; *p
!= NUL
; ++p
)
405 else if (*p
== '"') /* comment start */
407 else if (check_nextcmd(p
) != NULL
)
409 eap
->nextcmd
= check_nextcmd(p
);
412 else if (!ASCII_ISALPHA(*p
) && regmatch
.regprog
== NULL
)
414 s
= skip_regexp(p
+ 1, *p
, TRUE
, NULL
);
421 /* 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
);
425 regmatch
.regprog
= vim_regcomp(p
+ 1, RE_MAGIC
);
426 if (regmatch
.regprog
== NULL
)
428 p
= s
; /* continue after the regexp */
429 regmatch
.rm_ic
= p_ic
;
433 EMSG2(_(e_invarg2
), p
);
438 /* Can only have one of 'n', 'o' and 'x'. */
439 if (sort_nr
+ sort_oct
+ sort_hex
> 2)
445 /* From here on "sort_nr" is used as a flag for any number sorting. */
446 sort_nr
+= sort_oct
+ sort_hex
;
449 * Make an array with all line numbers. This avoids having to copy all
450 * the lines into allocated memory.
451 * 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.
454 * Also get the longest line length for allocating "sortbuf".
456 for (lnum
= eap
->line1
; lnum
<= eap
->line2
; ++lnum
)
459 len
= (int)STRLEN(s
);
465 if (regmatch
.regprog
!= NULL
&& vim_regexec(®match
, s
, 0))
469 start_col
= (colnr_T
)(regmatch
.startp
[0] - s
);
470 end_col
= (colnr_T
)(regmatch
.endp
[0] - s
);
473 start_col
= (colnr_T
)(regmatch
.endp
[0] - s
);
476 if (regmatch
.regprog
!= NULL
)
481 /* Make sure vim_str2nr doesn't read any digits past the end
482 * of the match, by temporarily terminating the string there */
486 /* Sorting on number: Store the number itself. */
492 if (s
> p
&& s
[-1] == '-')
493 --s
; /* include preceding negative sign */
494 vim_str2nr(s
, NULL
, NULL
, sort_oct
, sort_hex
,
495 &nrs
[lnum
- eap
->line1
].start_col_nr
, NULL
);
500 /* Store the column to sort at. */
501 nrs
[lnum
- eap
->line1
].start_col_nr
= start_col
;
502 nrs
[lnum
- eap
->line1
].end_col_nr
= end_col
;
505 nrs
[lnum
- eap
->line1
].lnum
= lnum
;
507 if (regmatch
.regprog
!= NULL
)
513 /* Allocate a buffer that can hold the longest line. */
514 sortbuf1
= alloc((unsigned)maxlen
+ 1);
515 if (sortbuf1
== NULL
)
517 sortbuf2
= alloc((unsigned)maxlen
+ 1);
518 if (sortbuf2
== NULL
)
521 /* Sort the array of line numbers. Note: can't be interrupted! */
522 qsort((void *)nrs
, count
, sizeof(sorti_T
), sort_compare
);
527 /* Insert the lines in the sorted order below the last one. */
529 for (i
= 0; i
< count
; ++i
)
531 s
= ml_get(nrs
[eap
->forceit
? count
- i
- 1 : i
].lnum
);
532 if (!unique
|| i
== 0
533 || (sort_ic
? STRICMP(s
, sortbuf1
) : STRCMP(s
, sortbuf1
)) != 0)
535 if (ml_append(lnum
++, s
, (colnr_T
)0, FALSE
) == FAIL
)
545 /* delete the original lines if appending worked */
547 for (i
= 0; i
< count
; ++i
)
548 ml_delete(eap
->line1
, FALSE
);
552 /* Adjust marks for deleted (or added) lines and prepare for displaying. */
553 deleted
= (long)(count
- (lnum
- eap
->line2
));
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
);
560 curwin
->w_cursor
.lnum
= eap
->line1
;
561 beginline(BL_WHITE
| BL_FIX
);
567 vim_free(regmatch
.regprog
);
586 long start_col
= 0; /* For start of white-space string */
587 long start_vcol
= 0; /* For start of white-space string */
590 char_u
*new_line
= (char_u
*)1; /* init to non-NULL */
591 int did_undo
; /* called u_save for current line */
594 char_u
*new_ts_str
; /* string value of tab argument */
600 linenr_T first_line
= 0; /* first changed line */
601 linenr_T last_line
= 0; /* last changed line */
603 save_list
= curwin
->w_p_list
;
604 curwin
->w_p_list
= 0; /* don't want list mode here */
607 new_ts_str
= eap
->arg
;
608 if (vim_isdigit(*(eap
->arg
)) && !tabstop_set(eap
->arg
, &new_ts
))
613 while (vim_isdigit(*(eap
->arg
)) || *(eap
->arg
) == ',')
616 /* This ensures that either new_ts and new_ts_str are freshly allocated,
617 * or new_ts points to an existing array and new_ts_str is null.
621 new_ts
= curbuf
->b_p_vts_ary
;
625 new_ts_str
= vim_strnsave(new_ts_str
, eap
->arg
- new_ts_str
);
627 new_ts
= getdigits(&(eap
->arg
));
634 new_ts
= curbuf
->b_p_ts
;
636 for (lnum
= eap
->line1
; !got_int
&& lnum
<= eap
->line2
; ++lnum
)
644 if (vim_iswhite(ptr
[col
]))
646 if (!got_tab
&& num_spaces
== 0)
648 /* First consecutive white-space */
659 if (got_tab
|| (eap
->forceit
&& num_spaces
> 1))
661 /* Retabulate this string of white-space */
663 /* len is virtual length of white string */
664 len
= num_spaces
= vcol
- start_vcol
;
670 tabstop_fromto(start_vcol
, vcol
,
671 tabstop_count(new_ts
)? 0: curbuf
->b_p_ts
,
677 temp
= new_ts
- (start_vcol
% new_ts
);
678 if (num_spaces
>= temp
)
683 num_tabs
+= num_spaces
/ new_ts
;
684 num_spaces
-= (num_spaces
/ new_ts
) * new_ts
;
687 if (curbuf
->b_p_et
|| got_tab
||
688 (num_spaces
+ num_tabs
< len
))
690 if (did_undo
== FALSE
)
693 if (u_save((linenr_T
)(lnum
- 1),
694 (linenr_T
)(lnum
+ 1)) == FAIL
)
696 new_line
= NULL
; /* flag out-of-memory */
701 /* len is actual number of white characters used */
702 len
= num_spaces
+ num_tabs
;
703 old_len
= (long)STRLEN(ptr
);
704 new_line
= lalloc(old_len
- col
+ start_col
+ len
+ 1,
706 if (new_line
== NULL
)
709 mch_memmove(new_line
, ptr
, (size_t)start_col
);
710 mch_memmove(new_line
+ start_col
+ len
,
711 ptr
+ col
, (size_t)(old_len
- col
+ 1));
712 ptr
= new_line
+ start_col
;
713 for (col
= 0; col
< len
; col
++)
714 ptr
[col
] = (col
< num_tabs
) ? '\t' : ' ';
715 ml_replace(lnum
, new_line
, FALSE
);
720 col
= start_col
+ len
;
728 vcol
+= chartabsize(ptr
+ col
, (colnr_T
)vcol
);
731 col
+= (*mb_ptr2len
)(ptr
+ col
);
736 if (new_line
== NULL
) /* out of memory */
744 /* If a single value was given then it can be considered equal to
745 * either the value of 'tabstop' or the value of 'vartabstop'.
747 if (tabstop_count(curbuf
->b_p_vts_ary
) == 0
748 && tabstop_count(new_ts
) == 1
749 && curbuf
->b_p_ts
== tabstop_first(new_ts
))
751 else if (tabstop_count(curbuf
->b_p_vts_ary
) > 0
752 && tabstop_eq(curbuf
->b_p_vts_ary
, new_ts
))
755 redraw_curbuf_later(NOT_VALID
);
757 if (curbuf
->b_p_ts
!= new_ts
)
758 redraw_curbuf_later(NOT_VALID
);
761 changed_lines(first_line
, 0, last_line
+ 1, 0L);
763 curwin
->w_p_list
= save_list
; /* restore 'list' */
766 if (new_ts_str
!= NULL
) /* set the new tabstop */
768 /* If 'vartabstop' is in use or if the value given to retab has more
769 * than one tabstop then update 'vartabstop'.
771 int* old_vts_ary
= curbuf
->b_p_vts_ary
;
772 if (tabstop_count(old_vts_ary
) > 0 || tabstop_count(new_ts
) > 1) {
773 set_string_option_direct((char_u
*)"vts", -1, new_ts_str
,
774 OPT_FREE
|OPT_LOCAL
, 0);
775 vim_free(new_ts_str
);
776 curbuf
->b_p_vts_ary
= new_ts
;
777 vim_free(old_vts_ary
);
779 /* If 'vartabstop' wasn't in use and a single value was given to
780 * retab then update 'tabstop'.
784 curbuf
->b_p_ts
= tabstop_first(new_ts
);
789 curbuf
->b_p_ts
= new_ts
;
791 coladvance(curwin
->w_curswant
);
798 * :move command - move lines line1-line2 to line dest
800 * return FAIL for failure, OK otherwise
803 do_move(line1
, line2
, dest
)
810 linenr_T extra
; /* Num lines added before line1 */
811 linenr_T num_lines
; /* Num lines moved */
812 linenr_T last_line
; /* Last line in file after adding new text */
814 if (dest
>= line1
&& dest
< line2
)
816 EMSG(_("E134: Move lines into themselves"));
820 num_lines
= line2
- line1
+ 1;
823 * First we copy the old text to its new location -- webb
824 * Also copy the flag that ":global" command uses.
826 if (u_save(dest
, dest
+ 1) == FAIL
)
828 for (extra
= 0, l
= line1
; l
<= line2
; l
++)
830 str
= vim_strsave(ml_get(l
+ extra
));
833 ml_append(dest
+ l
- line1
, str
, (colnr_T
)0, FALSE
);
841 * Now we must be careful adjusting our marks so that we don't overlap our
842 * mark_adjust() calls.
844 * We adjust the marks within the old text so that they refer to the
845 * last lines of the file (temporarily), because we know no other marks
846 * will be set there since these line numbers did not exist until we added
849 * Then we adjust the marks on lines between the old and new text positions
850 * (either forwards or backwards).
852 * And Finally we adjust the marks we put at the end of the file back to
853 * their final destination at the new text position -- webb
855 last_line
= curbuf
->b_ml
.ml_line_count
;
856 mark_adjust(line1
, line2
, last_line
- line2
, 0L);
859 mark_adjust(line2
+ 1, dest
, -num_lines
, 0L);
860 curbuf
->b_op_start
.lnum
= dest
- num_lines
+ 1;
861 curbuf
->b_op_end
.lnum
= dest
;
865 mark_adjust(dest
+ 1, line1
- 1, num_lines
, 0L);
866 curbuf
->b_op_start
.lnum
= dest
+ 1;
867 curbuf
->b_op_end
.lnum
= dest
+ num_lines
;
869 curbuf
->b_op_start
.col
= curbuf
->b_op_end
.col
= 0;
870 mark_adjust(last_line
- num_lines
+ 1, last_line
,
871 -(last_line
- dest
- extra
), 0L);
874 * Now we delete the original text -- webb
876 if (u_save(line1
+ extra
- 1, line2
+ extra
+ 1) == FAIL
)
879 for (l
= line1
; l
<= line2
; l
++)
880 ml_delete(line1
+ extra
, TRUE
);
882 if (!global_busy
&& num_lines
> p_report
)
885 MSG(_("1 line moved"));
887 smsg((char_u
*)_("%ld lines moved"), num_lines
);
891 * Leave the cursor on the last of the moved lines.
894 curwin
->w_cursor
.lnum
= dest
;
896 curwin
->w_cursor
.lnum
= dest
+ (line2
- line1
) + 1;
899 changed_lines(line1
, 0, dest
+ num_lines
+ 1, 0L);
901 changed_lines(dest
+ 1, 0, line1
+ num_lines
, 0L);
910 ex_copy(line1
, line2
, n
)
918 count
= line2
- line1
+ 1;
919 curbuf
->b_op_start
.lnum
= n
+ 1;
920 curbuf
->b_op_end
.lnum
= n
+ count
;
921 curbuf
->b_op_start
.col
= curbuf
->b_op_end
.col
= 0;
924 * there are three situations:
925 * 1. destination is above line1
926 * 2. destination is between line1 and line2
927 * 3. destination is below line2
929 * n = destination (when starting)
930 * curwin->w_cursor.lnum = destination (while copying)
931 * line1 = start of source (while copying)
932 * line2 = end of source (while copying)
934 if (u_save(n
, n
+ 1) == FAIL
)
937 curwin
->w_cursor
.lnum
= n
;
938 while (line1
<= line2
)
940 /* need to use vim_strsave() because the line will be unlocked within
942 p
= vim_strsave(ml_get(line1
));
945 ml_append(curwin
->w_cursor
.lnum
, p
, (colnr_T
)0, FALSE
);
948 /* situation 2: skip already copied lines */
950 line1
= curwin
->w_cursor
.lnum
;
952 if (curwin
->w_cursor
.lnum
< line1
)
954 if (curwin
->w_cursor
.lnum
< line2
)
956 ++curwin
->w_cursor
.lnum
;
959 appended_lines_mark(n
, count
);
961 msgmore((long)count
);
964 static char_u
*prevcmd
= NULL
; /* the previous command */
966 #if defined(EXITFREE) || defined(PROTO)
975 * Handle the ":!cmd" command. Also for ":r !cmd" and ":w !cmd"
976 * Bangs in the argument are replaced with the previously entered command.
977 * Remember the argument.
979 * RISCOS: Bangs only replaced when followed by a space, since many
980 * pathnames contain one.
983 do_bang(addr_count
, eap
, forceit
, do_in
, do_out
)
989 char_u
*arg
= eap
->arg
; /* command */
990 linenr_T line1
= eap
->line1
; /* start of range */
991 linenr_T line2
= eap
->line2
; /* end of range */
992 char_u
*newcmd
= NULL
; /* the new command */
993 int free_newcmd
= FALSE
; /* need to free() newcmd */
999 int scroll_save
= msg_scroll
;
1002 * Disallow shell commands for "rvim".
1003 * Disallow shell commands from .exrc and .vimrc in current directory for
1006 if (check_restricted() || check_secure())
1009 if (addr_count
== 0) /* :! */
1011 msg_scroll
= FALSE
; /* don't scroll here */
1013 msg_scroll
= scroll_save
;
1017 * Try to find an embedded bang, like in :!<cmd> ! [args]
1018 * (:!! is indicated by the 'forceit' variable)
1020 ins_prevcmd
= forceit
;
1024 len
= (int)STRLEN(trailarg
) + 1;
1026 len
+= (int)STRLEN(newcmd
);
1029 if (prevcmd
== NULL
)
1035 len
+= (int)STRLEN(prevcmd
);
1037 if ((t
= alloc((unsigned)len
)) == NULL
)
1048 STRCAT(t
, trailarg
);
1053 * Scan the rest of the argument for '!', which is replaced by the
1054 * previous command. "\!" is replaced by "!" (this is vi compatible).
1061 && (p
[1] == ' ' || p
[1] == NUL
)
1065 if (p
> newcmd
&& p
[-1] == '\\')
1077 } while (trailarg
!= NULL
);
1082 if (bangredo
) /* put cmd in redo buffer for ! command */
1084 AppendToRedobuffLit(prevcmd
, -1);
1085 AppendToRedobuff((char_u
*)"\n");
1089 * Add quotes around the command, for shells that need them.
1093 newcmd
= alloc((unsigned)(STRLEN(prevcmd
) + 2 * STRLEN(p_shq
) + 1));
1096 STRCPY(newcmd
, p_shq
);
1097 STRCAT(newcmd
, prevcmd
);
1098 STRCAT(newcmd
, p_shq
);
1101 if (addr_count
== 0) /* :! */
1103 /* echo the command */
1107 msg_outtrans(newcmd
);
1109 windgoto(msg_row
, msg_col
);
1111 do_shell(newcmd
, 0);
1115 /* Careful: This may recursively call do_bang() again! (because of
1117 do_filter(line1
, line2
, eap
, newcmd
, do_in
, do_out
);
1119 apply_autocmds(EVENT_SHELLFILTERPOST
, NULL
, NULL
, FALSE
, curbuf
);
1127 * do_filter: filter lines through a command given by the user
1129 * We mostly use temp files and the call_shell() routine here. This would
1130 * normally be done using pipes on a UNIX machine, but this is more portable
1131 * to non-unix machines. The call_shell() routine needs to be able
1132 * to deal with redirection somehow, and should handle things like looking
1133 * at the PATH env. variable, and adding reasonable extensions to the
1134 * command name given by the user. All reasonable versions of call_shell()
1136 * Alternatively, if on Unix and redirecting input or output, but not both,
1137 * and the 'shelltemp' option isn't set, use pipes.
1138 * We use input redirection if do_in is TRUE.
1139 * We use output redirection if do_out is TRUE.
1142 do_filter(line1
, line2
, eap
, cmd
, do_in
, do_out
)
1143 linenr_T line1
, line2
;
1144 exarg_T
*eap
; /* for forced 'ff' and 'fenc' */
1148 char_u
*itmp
= NULL
;
1149 char_u
*otmp
= NULL
;
1151 linenr_T read_linecount
;
1155 buf_T
*old_curbuf
= curbuf
;
1157 int shell_flags
= 0;
1159 if (*cmd
== NUL
) /* no filter command */
1164 * Check if external commands are allowed now.
1166 if (can_end_termcap_mode(TRUE
) == FALSE
)
1170 cursor_save
= curwin
->w_cursor
;
1171 linecount
= line2
- line1
+ 1;
1172 curwin
->w_cursor
.lnum
= line1
;
1173 curwin
->w_cursor
.col
= 0;
1174 changed_line_abv_curs();
1175 invalidate_botline();
1178 * When using temp files:
1179 * 1. * Form temp file names
1180 * 2. * Write the lines to a temp file
1181 * 3. Run the filter command on the temp file
1182 * 4. * Read the output of the command into the buffer
1183 * 5. * Delete the original lines to be filtered
1184 * 6. * Remove the temp files
1186 * When writing the input with a pipe or when catching the output with a
1187 * pipe only need to do 3.
1191 shell_flags
|= SHELL_DOOUT
;
1193 #if !defined(USE_SYSTEM) && defined(UNIX)
1194 if (!do_in
&& do_out
&& !p_stmp
)
1196 /* Use a pipe to fetch stdout of the command, do not use a temp file. */
1197 shell_flags
|= SHELL_READ
;
1198 curwin
->w_cursor
.lnum
= line2
;
1200 else if (do_in
&& !do_out
&& !p_stmp
)
1202 /* Use a pipe to write stdin of the command, do not use a temp file. */
1203 shell_flags
|= SHELL_WRITE
;
1204 curbuf
->b_op_start
.lnum
= line1
;
1205 curbuf
->b_op_end
.lnum
= line2
;
1207 else if (do_in
&& do_out
&& !p_stmp
)
1209 /* Use a pipe to write stdin and fetch stdout of the command, do not
1210 * use a temp file. */
1211 shell_flags
|= SHELL_READ
|SHELL_WRITE
;
1212 curbuf
->b_op_start
.lnum
= line1
;
1213 curbuf
->b_op_end
.lnum
= line2
;
1214 curwin
->w_cursor
.lnum
= line2
;
1218 if ((do_in
&& (itmp
= vim_tempname('i')) == NULL
)
1219 || (do_out
&& (otmp
= vim_tempname('o')) == NULL
))
1226 * The writing and reading of temp files will not be shown.
1227 * Vi also doesn't do this and the messages are not very informative.
1229 ++no_wait_return
; /* don't call wait_return() while busy */
1230 if (itmp
!= NULL
&& buf_write(curbuf
, itmp
, NULL
, line1
, line2
, eap
,
1231 FALSE
, FALSE
, FALSE
, TRUE
) == FAIL
)
1233 msg_putchar('\n'); /* keep message from buf_write() */
1235 #if defined(FEAT_AUTOCMD) && defined(FEAT_EVAL)
1238 (void)EMSG2(_(e_notcreate
), itmp
); /* will call wait_return */
1242 if (curbuf
!= old_curbuf
)
1249 /* Create the shell command in allocated memory. */
1250 cmd_buf
= make_filter_cmd(cmd
, itmp
, otmp
);
1251 if (cmd_buf
== NULL
)
1254 windgoto((int)Rows
- 1, 0);
1258 * When not redirecting the output the command can write anything to the
1259 * screen. If 'shellredir' is equal to ">", screen may be messed up by
1260 * stderr output of external command. Clear the screen later.
1261 * If do_in is FALSE, this could be something like ":r !cat", which may
1262 * also mess up the screen, clear it later.
1264 if (!do_out
|| STRCMP(p_srr
, ">") == 0 || !do_in
)
1265 redraw_later_clear();
1269 if (u_save((linenr_T
)(line2
), (linenr_T
)(line2
+ 1)) == FAIL
)
1274 redraw_curbuf_later(VALID
);
1276 read_linecount
= curbuf
->b_ml
.ml_line_count
;
1279 * When call_shell() fails wait_return() is called to give the user a
1280 * chance to read the error messages. Otherwise errors are ignored, so you
1281 * can see the error messages from the command that appear on stdout; use
1282 * 'u' to fix the text
1283 * Switch to cooked mode when not redirecting stdin, avoids that something
1284 * like ":r !cat" hangs.
1285 * Pass on the SHELL_DOOUT flag when the output is being redirected.
1287 if (call_shell(cmd_buf
, SHELL_FILTER
| SHELL_COOKED
| shell_flags
))
1289 redraw_later_clear();
1294 did_check_timestamps
= FALSE
;
1295 need_check_timestamps
= TRUE
;
1297 /* When interrupting the shell command, it may still have produced some
1298 * useful output. Reset got_int here, so that readfile() won't cancel
1307 if (readfile(otmp
, NULL
, line2
, (linenr_T
)0, (linenr_T
)MAXLNUM
,
1308 eap
, READ_FILTER
) == FAIL
)
1310 #if defined(FEAT_AUTOCMD) && defined(FEAT_EVAL)
1315 EMSG2(_(e_notread
), otmp
);
1320 if (curbuf
!= old_curbuf
)
1325 read_linecount
= curbuf
->b_ml
.ml_line_count
- read_linecount
;
1327 if (shell_flags
& SHELL_READ
)
1329 curbuf
->b_op_start
.lnum
= line2
+ 1;
1330 curbuf
->b_op_end
.lnum
= curwin
->w_cursor
.lnum
;
1331 appended_lines_mark(line2
, read_linecount
);
1336 if (cmdmod
.keepmarks
|| vim_strchr(p_cpo
, CPO_REMMARK
) == NULL
)
1338 if (read_linecount
>= linecount
)
1339 /* move all marks from old lines to new lines */
1340 mark_adjust(line1
, line2
, linecount
, 0L);
1343 /* move marks from old lines to new lines, delete marks
1344 * that are in deleted lines */
1345 mark_adjust(line1
, line1
+ read_linecount
- 1,
1347 mark_adjust(line1
+ read_linecount
, line2
, MAXLNUM
, 0L);
1352 * Put cursor on first filtered line for ":range!cmd".
1353 * Adjust '[ and '] (set by buf_write()).
1355 curwin
->w_cursor
.lnum
= line1
;
1356 del_lines(linecount
, TRUE
);
1357 curbuf
->b_op_start
.lnum
-= linecount
; /* adjust '[ */
1358 curbuf
->b_op_end
.lnum
-= linecount
; /* adjust '] */
1359 write_lnum_adjust(-linecount
); /* adjust last line
1362 foldUpdate(curwin
, curbuf
->b_op_start
.lnum
, curbuf
->b_op_end
.lnum
);
1368 * Put cursor on last new line for ":r !cmd".
1370 linecount
= curbuf
->b_op_end
.lnum
- curbuf
->b_op_start
.lnum
+ 1;
1371 curwin
->w_cursor
.lnum
= curbuf
->b_op_end
.lnum
;
1374 beginline(BL_WHITE
| BL_FIX
); /* cursor on first non-blank */
1377 if (linecount
> p_report
)
1381 vim_snprintf((char *)msg_buf
, sizeof(msg_buf
),
1382 _("%ld lines filtered"), (long)linecount
);
1383 if (msg(msg_buf
) && !msg_scroll
)
1384 /* save message to display it after redraw */
1385 set_keep_msg(msg_buf
, 0);
1388 msgmore((long)linecount
);
1394 /* put cursor back in same position for ":w !cmd" */
1395 curwin
->w_cursor
= cursor_save
;
1403 if (curbuf
!= old_curbuf
)
1406 EMSG(_("E135: *Filter* Autocommands must not change current buffer"));
1418 * Call a shell to execute a command.
1419 * When "cmd" is NULL start an interactive shell.
1422 do_shell(cmd
, flags
)
1424 int flags
; /* may be SHELL_DOOUT when output is redirected */
1427 #ifndef FEAT_GUI_MSWIN
1431 int winstart
= FALSE
;
1435 * Disallow shell commands for "rvim".
1436 * Disallow shell commands from .exrc and .vimrc in current directory for
1439 if (check_restricted() || check_secure())
1447 * Check if external commands are allowed now.
1449 if (can_end_termcap_mode(TRUE
) == FALSE
)
1453 * Check if ":!start" is used.
1456 winstart
= (STRNICMP(cmd
, "start ", 6) == 0);
1460 * For autocommands we want to get the output on the current screen, to
1461 * avoid having to type return below.
1463 msg_putchar('\r'); /* put cursor at start of line */
1476 msg_putchar('\n'); /* may shift screen one line up */
1478 /* warning message before calling the shell */
1484 for (buf
= firstbuf
; buf
; buf
= buf
->b_next
)
1485 if (bufIsChanged(buf
))
1487 #ifdef FEAT_GUI_MSWIN
1489 starttermcap(); /* don't want a message box here */
1491 MSG_PUTS(_("[No write since last change]\n"));
1492 #ifdef FEAT_GUI_MSWIN
1499 /* This windgoto is required for when the '\n' resulted in a "delete line
1500 * 1" command to the terminal. */
1501 if (!swapping_screen())
1502 windgoto(msg_row
, msg_col
);
1504 (void)call_shell(cmd
, SHELL_COOKED
| flags
);
1505 did_check_timestamps
= FALSE
;
1506 need_check_timestamps
= TRUE
;
1509 * put the message cursor at the end of the screen, avoids wait_return()
1510 * to overwrite the text that the external command showed
1512 if (!swapping_screen())
1521 if (msg_silent
== 0)
1522 redraw_later_clear();
1528 * For ":sh" there is no need to call wait_return(), just redraw.
1529 * Also for the Win32 GUI (the output is in a console window).
1530 * Otherwise there is probably text on the screen that the user wants
1531 * to read before redrawing, so call wait_return().
1533 #ifndef FEAT_GUI_MSWIN
1536 || (winstart
&& !need_wait_return
)
1540 if (msg_silent
== 0)
1541 redraw_later_clear();
1542 need_wait_return
= FALSE
;
1547 * If we switch screens when starttermcap() is called, we really
1548 * want to wait for "hit return to continue".
1550 save_nwr
= no_wait_return
;
1551 if (swapping_screen())
1552 no_wait_return
= FALSE
;
1554 wait_return(term_console
? -1 : msg_silent
== 0); /* see below */
1556 wait_return(msg_silent
== 0);
1558 no_wait_return
= save_nwr
;
1560 #endif /* FEAT_GUI_W32 */
1563 if (!winstart
) /* if winstart==TRUE, never stopped termcap! */
1565 starttermcap(); /* start termcap if not done by wait_return() */
1568 * In an Amiga window redrawing is caused by asking the window size.
1569 * If we got an interrupt this will not work. The chance that the
1570 * window size is wrong is very small, but we need to redraw the
1571 * screen. Don't do this if ':' hit in wait_return(). THIS IS UGLY
1572 * but it saves an extra redraw.
1575 if (skip_redraw
) /* ':' hit in wait_return() */
1577 if (msg_silent
== 0)
1578 redraw_later_clear();
1580 else if (term_console
)
1582 OUT_STR(IF_EB("\033[0 q", ESC_STR
"[0 q")); /* get window size */
1583 if (got_int
&& msg_silent
== 0)
1584 redraw_later_clear(); /* if got_int is TRUE, redraw needed */
1586 must_redraw
= 0; /* no extra redraw needed */
1591 /* display any error messages now */
1595 apply_autocmds(EVENT_SHELLCMDPOST
, NULL
, NULL
, FALSE
, curbuf
);
1600 * Create a shell command from a command string, input redirection file and
1601 * output redirection file.
1602 * Returns an allocated string with the shell command, or NULL for failure.
1605 make_filter_cmd(cmd
, itmp
, otmp
)
1606 char_u
*cmd
; /* command */
1607 char_u
*itmp
; /* NULL or name of input file */
1608 char_u
*otmp
; /* NULL or name of output file */
1613 len
= (long_u
)STRLEN(cmd
) + 3; /* "()" + NUL */
1615 len
+= (long_u
)STRLEN(itmp
) + 9; /* " { < " + " } " */
1617 len
+= (long_u
)STRLEN(otmp
) + (long_u
)STRLEN(p_srr
) + 2; /* " " */
1618 buf
= lalloc(len
, TRUE
);
1622 #if (defined(UNIX) && !defined(ARCHIE)) || defined(OS2)
1624 * Put braces around the command (for concatenated commands) when
1625 * redirecting input and/or output.
1627 if (itmp
!= NULL
|| otmp
!= NULL
)
1628 vim_snprintf((char *)buf
, len
, "(%s)", (char *)cmd
);
1638 * for shells that don't understand braces around commands, at least allow
1639 * the use of commands in a pipe.
1647 * If there is a pipe, we have to put the '<' in front of it.
1648 * Don't do this when 'shellquote' is not empty, otherwise the
1649 * redirection would be inside the quotes.
1653 p
= vim_strchr(buf
, '|');
1658 STRCAT(buf
, " { < "); /* Use RISC OS notation for input. */
1662 STRCAT(buf
, " <"); /* " < " causes problems on Amiga */
1667 p
= vim_strchr(cmd
, '|');
1670 STRCAT(buf
, " "); /* insert a space before the '|' for DOS */
1677 append_redir(buf
, (int)len
, p_srr
, otmp
);
1683 * Append output redirection for file "fname" to the end of string buffer
1685 * Works with the 'shellredir' and 'shellpipe' options.
1686 * The caller should make sure that there is enough room:
1687 * STRLEN(opt) + STRLEN(fname) + 3
1690 append_redir(buf
, buflen
, opt
, fname
)
1699 end
= buf
+ STRLEN(buf
);
1700 /* find "%s", skipping "%%" */
1701 for (p
= opt
; (p
= vim_strchr(p
, '%')) != NULL
; ++p
)
1706 *end
= ' '; /* not really needed? Not with sh, ksh or bash */
1707 vim_snprintf((char *)end
+ 1, (size_t)(buflen
- (end
+ 1 - buf
)),
1708 (char *)opt
, (char *)fname
);
1711 vim_snprintf((char *)end
, (size_t)(buflen
- (end
- buf
)),
1712 #ifdef FEAT_QUICKFIX
1714 opt
!= p_sp
? " %s%s" :
1719 " %s%s", /* " > %s" causes problems on Amiga */
1721 " %s %s", /* But is needed for 'shellpipe' and RISC OS */
1724 (char *)opt
, (char *)fname
);
1729 static int no_viminfo
__ARGS((void));
1730 static int viminfo_errcnt
;
1735 /* "vim -i NONE" does not read or write a viminfo file */
1736 return (use_viminfo
!= NULL
&& STRCMP(use_viminfo
, "NONE") == 0);
1740 * Report an error for reading a viminfo file.
1741 * Count the number of errors. When there are more than 10, return TRUE.
1744 viminfo_error(errnum
, message
, line
)
1749 vim_snprintf((char *)IObuff
, IOSIZE
, _("%sviminfo: %s in line: "),
1751 STRNCAT(IObuff
, line
, IOSIZE
- STRLEN(IObuff
) - 1);
1752 if (IObuff
[STRLEN(IObuff
) - 1] == '\n')
1753 IObuff
[STRLEN(IObuff
) - 1] = NUL
;
1755 if (++viminfo_errcnt
>= 10)
1757 EMSG(_("E136: viminfo: Too many errors, skipping rest of file"));
1764 * read_viminfo() -- Read the viminfo file. Registers etc. which are already
1765 * set are not over-written unless "flags" includes VIF_FORCEIT. -- webb
1768 read_viminfo(file
, flags
)
1769 char_u
*file
; /* file name or NULL to use default name */
1770 int flags
; /* VIF_WANT_INFO et al. */
1778 fname
= viminfo_filename(file
); /* get file name in allocated buffer */
1781 fp
= mch_fopen((char *)fname
, READBIN
);
1786 smsg((char_u
*)_("Reading viminfo file \"%s\"%s%s%s"),
1788 (flags
& VIF_WANT_INFO
) ? _(" info") : "",
1789 (flags
& VIF_WANT_MARKS
) ? _(" marks") : "",
1790 (flags
& VIF_GET_OLDFILES
) ? _(" oldfiles") : "",
1791 fp
== NULL
? _(" FAILED") : "");
1800 do_viminfo(fp
, NULL
, flags
);
1807 * write_viminfo() -- Write the viminfo file. The old one is read in first so
1808 * that effectively a merge of current info and old info is done. This allows
1809 * multiple vims to run simultaneously, without losing any marks etc. If
1810 * forceit is TRUE, then the old file is not read in, and only internal info is
1811 * written to the file. -- webb
1814 write_viminfo(file
, forceit
)
1819 FILE *fp_in
= NULL
; /* input viminfo file, if any */
1820 FILE *fp_out
= NULL
; /* output viminfo file */
1821 char_u
*tempname
= NULL
; /* name of temp viminfo file */
1822 struct stat st_new
; /* mch_stat() of potential new file */
1824 #if defined(UNIX) || defined(VMS)
1828 int shortname
= FALSE
; /* use 8.3 file name */
1829 struct stat st_old
; /* mch_stat() of existing viminfo file */
1838 fname
= viminfo_filename(file
); /* may set to default if NULL */
1842 fp_in
= mch_fopen((char *)fname
, READBIN
);
1845 /* if it does exist, but we can't read it, don't try writing */
1846 if (mch_stat((char *)fname
, &st_new
) == 0)
1848 #if defined(UNIX) || defined(VMS)
1850 * For Unix we create the .viminfo non-accessible for others,
1851 * because it may contain text from non-accessible documents.
1853 umask_save
= umask(077);
1855 fp_out
= mch_fopen((char *)fname
, WRITEBIN
);
1856 #if defined(UNIX) || defined(VMS)
1857 (void)umask(umask_save
);
1863 * There is an existing viminfo file. Create a temporary file to
1864 * write the new viminfo into, in the same directory as the
1865 * existing viminfo file, which will be renamed later.
1869 * For Unix we check the owner of the file. It's not very nice to
1870 * overwrite a user's viminfo file after a "su root", with a
1871 * viminfo file that the user can't read.
1873 st_old
.st_dev
= (dev_t
)0;
1875 st_old
.st_mode
= 0600;
1876 if (mch_stat((char *)fname
, &st_old
) == 0
1877 && getuid() != ROOT_UID
1878 && !(st_old
.st_uid
== getuid()
1879 ? (st_old
.st_mode
& 0200)
1880 : (st_old
.st_gid
== getgid()
1881 ? (st_old
.st_mode
& 0020)
1882 : (st_old
.st_mode
& 0002))))
1884 int tt
= msg_didany
;
1886 /* avoid a wait_return for this message, it's annoying */
1887 EMSG2(_("E137: Viminfo file is not writable: %s"), fname
);
1894 /* Get the file attributes of the existing viminfo file. */
1895 perm
= mch_getperm(fname
);
1900 * May try twice: Once normal and once with shortname set, just in
1901 * case somebody puts his viminfo file in an 8.3 filesystem.
1905 tempname
= buf_modname(
1912 # ifdef FEAT_GUI_W32
1930 if (tempname
== NULL
) /* out of memory */
1934 * Check if tempfile already exists. Never overwrite an
1937 if (mch_stat((char *)tempname
, &st_new
) == 0)
1941 * Check if tempfile is same as original file. May happen
1942 * when modname() gave the same file back. E.g. silly
1943 * link, or file name-length reached. Try again with
1946 if (!shortname
&& st_new
.st_dev
== st_old
.st_dev
1947 && st_new
.st_ino
== st_old
.st_ino
)
1956 * Try another name. Change one character, just before
1957 * the extension. This should also work for an 8.3
1958 * file name, when after adding the extension it still is
1959 * the same file as the original.
1961 wp
= tempname
+ STRLEN(tempname
) - 5;
1962 if (wp
< gettail(tempname
)) /* empty file name? */
1963 wp
= gettail(tempname
);
1964 for (*wp
= 'z'; mch_stat((char *)tempname
, &st_new
) == 0;
1968 * They all exist? Must be something wrong! Don't
1969 * write the viminfo file then.
1982 if (tempname
!= NULL
)
1985 /* fdopen() fails for some reason */
1986 umask_save
= umask(077);
1987 fp_out
= mch_fopen((char *)tempname
, WRITEBIN
);
1988 (void)umask(umask_save
);
1992 /* Use mch_open() to be able to use O_NOFOLLOW and set file
1994 * Unix: same as original file, but strip s-bit. Reset umask to
1995 * avoid it getting in the way.
1996 * Others: r&w for user only. */
1998 umask_save
= umask(0);
1999 fd
= mch_open((char *)tempname
,
2000 O_CREAT
|O_EXTRA
|O_EXCL
|O_WRONLY
|O_NOFOLLOW
,
2001 (int)((st_old
.st_mode
& 0777) | 0600));
2002 (void)umask(umask_save
);
2004 fd
= mch_open((char *)tempname
,
2005 O_CREAT
|O_EXTRA
|O_EXCL
|O_WRONLY
|O_NOFOLLOW
, 0600);
2010 fp_out
= fdopen(fd
, WRITEBIN
);
2014 * If we can't create in the same directory, try creating a
2015 * "normal" temp file.
2020 if ((tempname
= vim_tempname('o')) != NULL
)
2021 fp_out
= mch_fopen((char *)tempname
, WRITEBIN
);
2024 #if defined(UNIX) && defined(HAVE_FCHOWN)
2026 * Make sure the owner can read/write it. This only works for
2030 ignored
= fchown(fileno(fp_out
), st_old
.st_uid
, st_old
.st_gid
);
2036 * Check if the new viminfo file can be written to.
2040 EMSG2(_("E138: Can't write viminfo file %s!"),
2041 (fp_in
== NULL
|| tempname
== NULL
) ? fname
: tempname
);
2050 smsg((char_u
*)_("Writing viminfo file \"%s\""), fname
);
2055 do_viminfo(fp_in
, fp_out
, forceit
? 0 : (VIF_WANT_INFO
| VIF_WANT_MARKS
));
2057 fclose(fp_out
); /* errors are ignored !? */
2063 * In case of an error keep the original viminfo file.
2064 * Otherwise rename the newly written file.
2066 if (viminfo_errcnt
|| vim_rename(tempname
, fname
) == -1)
2067 mch_remove(tempname
);
2070 /* If the viminfo file was hidden then also hide the new file. */
2071 if (perm
> 0 && (perm
& FILE_ATTRIBUTE_HIDDEN
))
2082 * Get the viminfo file name to use.
2083 * If "file" is given and not empty, use it (has already been expanded by
2084 * cmdline functions).
2085 * Otherwise use "-i file_name", value from 'viminfo' or the default, and
2086 * expand environment variables.
2087 * Returns an allocated string. NULL when out of memory.
2090 viminfo_filename(file
)
2093 if (file
== NULL
|| *file
== NUL
)
2095 if (use_viminfo
!= NULL
)
2097 else if ((file
= find_viminfo_parameter('n')) == NULL
|| *file
== NUL
)
2099 #ifdef VIMINFO_FILE2
2100 /* don't use $HOME when not defined (turned into "c:/"!). */
2102 if (mch_getenv((char_u
*)"SYS$LOGIN") == NULL
)
2104 if (mch_getenv((char_u
*)"HOME") == NULL
)
2107 /* don't use $VIM when not available. */
2108 expand_env((char_u
*)"$VIM", NameBuff
, MAXPATHL
);
2109 if (STRCMP("$VIM", NameBuff
) != 0) /* $VIM was expanded */
2110 file
= (char_u
*)VIMINFO_FILE2
;
2112 file
= (char_u
*)VIMINFO_FILE
;
2116 file
= (char_u
*)VIMINFO_FILE
;
2118 expand_env(file
, NameBuff
, MAXPATHL
);
2121 return vim_strsave(file
);
2125 * do_viminfo() -- Should only be called from read_viminfo() & write_viminfo().
2128 do_viminfo(fp_in
, fp_out
, flags
)
2137 if ((vir
.vir_line
= alloc(LSIZE
)) == NULL
)
2141 vir
.vir_conv
.vc_type
= CONV_NONE
;
2146 if (flags
& VIF_WANT_INFO
)
2147 eof
= read_viminfo_up_to_marks(&vir
,
2148 flags
& VIF_FORCEIT
, fp_out
!= NULL
);
2150 /* Skip info, find start of marks */
2151 while (!(eof
= viminfo_readline(&vir
))
2152 && vir
.vir_line
[0] != '>')
2157 /* Write the info: */
2158 fprintf(fp_out
, _("# This viminfo file was generated by Vim %s.\n"),
2159 VIM_VERSION_MEDIUM
);
2160 fprintf(fp_out
, _("# You may edit it if you're careful!\n\n"));
2162 fprintf(fp_out
, _("# Value of 'encoding' when this file was written\n"));
2163 fprintf(fp_out
, "*encoding=%s\n\n", p_enc
);
2165 write_viminfo_search_pattern(fp_out
);
2166 write_viminfo_sub_string(fp_out
);
2168 write_viminfo_history(fp_out
);
2170 write_viminfo_registers(fp_out
);
2172 write_viminfo_varlist(fp_out
);
2174 write_viminfo_filemarks(fp_out
);
2175 write_viminfo_bufferlist(fp_out
);
2176 count
= write_viminfo_marks(fp_out
);
2179 && (flags
& (VIF_WANT_MARKS
| VIF_GET_OLDFILES
| VIF_FORCEIT
)))
2180 copy_viminfo_marks(&vir
, fp_out
, count
, eof
, flags
);
2182 vim_free(vir
.vir_line
);
2184 if (vir
.vir_conv
.vc_type
!= CONV_NONE
)
2185 convert_setup(&vir
.vir_conv
, NULL
, NULL
);
2190 * read_viminfo_up_to_marks() -- Only called from do_viminfo(). Reads in the
2191 * first part of the viminfo file which contains everything but the marks that
2192 * are local to a file. Returns TRUE when end-of-file is reached. -- webb
2195 read_viminfo_up_to_marks(virp
, forceit
, writing
)
2204 prepare_viminfo_history(forceit
? 9999 : 0);
2206 eof
= viminfo_readline(virp
);
2207 while (!eof
&& virp
->vir_line
[0] != '>')
2209 switch (virp
->vir_line
[0])
2211 /* Characters reserved for future expansion, ignored now */
2212 case '+': /* "+40 /path/dir file", for running vim without args */
2213 case '|': /* to be defined */
2214 case '^': /* to be defined */
2215 case '<': /* long line - ignored */
2216 /* A comment or empty line. */
2221 eof
= viminfo_readline(virp
);
2223 case '*': /* "*encoding=value" */
2224 eof
= viminfo_encoding(virp
);
2226 case '!': /* global variable */
2228 eof
= read_viminfo_varlist(virp
, writing
);
2230 eof
= viminfo_readline(virp
);
2233 case '%': /* entry for buffer list */
2234 eof
= read_viminfo_bufferlist(virp
, writing
);
2237 eof
= read_viminfo_register(virp
, forceit
);
2239 case '/': /* Search string */
2240 case '&': /* Substitute search string */
2241 case '~': /* Last search string, followed by '/' or '&' */
2242 eof
= read_viminfo_search_pattern(virp
, forceit
);
2245 eof
= read_viminfo_sub_string(virp
, forceit
);
2252 eof
= read_viminfo_history(virp
);
2254 eof
= viminfo_readline(virp
);
2259 eof
= read_viminfo_filemark(virp
, forceit
);
2262 if (viminfo_error("E575: ", _("Illegal starting char"),
2266 eof
= viminfo_readline(virp
);
2272 /* Finish reading history items. */
2273 finish_viminfo_history();
2276 /* Change file names to buffer numbers for fmarks. */
2277 for (buf
= firstbuf
; buf
!= NULL
; buf
= buf
->b_next
)
2278 fmarks_check_names(buf
);
2284 * Compare the 'encoding' value in the viminfo file with the current value of
2285 * 'encoding'. If different and the 'c' flag is in 'viminfo', setup for
2286 * conversion of text with iconv() in viminfo_readstring().
2289 viminfo_encoding(virp
)
2296 if (get_viminfo_parameter('c') != 0)
2298 p
= vim_strchr(virp
->vir_line
, '=');
2301 /* remove trailing newline */
2303 for (i
= 0; vim_isprintc(p
[i
]); ++i
)
2307 convert_setup(&virp
->vir_conv
, p
, p_enc
);
2311 return viminfo_readline(virp
);
2315 * Read a line from the viminfo file.
2316 * Returns TRUE for end-of-file;
2319 viminfo_readline(virp
)
2322 return vim_fgets(virp
->vir_line
, LSIZE
, virp
->vir_fd
);
2326 * check string read from viminfo file
2327 * remove '\n' at the end of the line
2328 * - replace CTRL-V CTRL-V with CTRL-V
2329 * - replace CTRL-V 'n' with '\n'
2331 * Check for a long line as written by viminfo_writestring().
2333 * Return the string in allocated memory (NULL when out of memory).
2336 viminfo_readstring(virp
, off
, convert
)
2338 int off
; /* offset for virp->vir_line */
2339 int convert UNUSED
; /* convert the string */
2345 if (virp
->vir_line
[off
] == Ctrl_V
&& vim_isdigit(virp
->vir_line
[off
+ 1]))
2347 len
= atol((char *)virp
->vir_line
+ off
+ 1);
2348 retval
= lalloc(len
, TRUE
);
2351 /* Line too long? File messed up? Skip next line. */
2352 (void)vim_fgets(virp
->vir_line
, 10, virp
->vir_fd
);
2355 (void)vim_fgets(retval
, (int)len
, virp
->vir_fd
);
2356 s
= retval
+ 1; /* Skip the leading '<' */
2360 retval
= vim_strsave(virp
->vir_line
+ off
);
2366 /* Change CTRL-V CTRL-V to CTRL-V and CTRL-V n to \n in-place. */
2368 while (*s
!= NUL
&& *s
!= '\n')
2370 if (s
[0] == Ctrl_V
&& s
[1] != NUL
)
2384 if (convert
&& virp
->vir_conv
.vc_type
!= CONV_NONE
&& *retval
!= NUL
)
2386 d
= string_convert(&virp
->vir_conv
, retval
, NULL
);
2399 * write string to viminfo file
2400 * - replace CTRL-V with CTRL-V CTRL-V
2401 * - replace '\n' with CTRL-V 'n'
2402 * - add a '\n' at the end
2405 * - write " CTRL-V <length> \n " in first line
2406 * - write " < <string> \n " in second line
2409 viminfo_writestring(fd
, p
)
2417 for (s
= p
; *s
!= NUL
; ++s
)
2419 if (*s
== Ctrl_V
|| *s
== '\n')
2424 /* If the string will be too long, write its length and put it in the next
2425 * line. Take into account that some room is needed for what comes before
2426 * the string (e.g., variable name). Add something to the length for the
2427 * '<', NL and trailing NUL. */
2428 if (len
> LSIZE
/ 2)
2429 fprintf(fd
, IF_EB("\026%d\n<", CTRL_V_STR
"%d\n<"), len
+ 3);
2431 while ((c
= *p
++) != NUL
)
2433 if (c
== Ctrl_V
|| c
== '\n')
2443 #endif /* FEAT_VIMINFO */
2446 * Implementation of ":fixdel", also used by get_stty().
2447 * <BS> resulting <Del>
2453 exarg_T
*eap UNUSED
;
2457 p
= find_termcode((char_u
*)"kb");
2458 add_termcode((char_u
*)"kD", p
!= NULL
2459 && *p
== DEL
? (char_u
*)CTRL_H_STR
: DEL_STR
, FALSE
);
2463 print_line_no_prefix(lnum
, use_number
, list
)
2470 if (curwin
->w_p_nu
|| use_number
)
2472 vim_snprintf((char *)numbuf
, sizeof(numbuf
),
2473 "%*ld ", number_width(curwin
), (long)lnum
);
2474 msg_puts_attr(numbuf
, hl_attr(HLF_N
)); /* Highlight line nrs */
2476 msg_prt_line(ml_get(lnum
), list
);
2480 * Print a text line. Also in silent mode ("ex -s").
2483 print_line(lnum
, use_number
, list
)
2488 int save_silent
= silent_mode
;
2491 silent_mode
= FALSE
;
2492 info_message
= TRUE
; /* use mch_msg(), not mch_errmsg() */
2493 print_line_no_prefix(lnum
, use_number
, list
);
2497 cursor_on(); /* msg_start() switches it off */
2499 silent_mode
= save_silent
;
2501 info_message
= FALSE
;
2505 * ":file[!] [fname]".
2511 char_u
*fname
, *sfname
, *xfname
;
2514 /* ":0file" removes the file name. Check for illegal uses ":3file",
2515 * "0file name", etc. */
2516 if (eap
->addr_count
> 0
2517 && (*eap
->arg
!= NUL
2519 || eap
->addr_count
> 1))
2525 if (*eap
->arg
!= NUL
|| eap
->addr_count
== 1)
2529 apply_autocmds(EVENT_BUFFILEPRE
, NULL
, NULL
, FALSE
, curbuf
);
2530 /* buffer changed, don't change name now */
2534 if (aborting()) /* autocmds may abort script processing */
2539 * The name of the current buffer will be changed.
2540 * A new (unlisted) buffer entry needs to be made to hold the old file
2541 * name, which will become the alternate file name.
2542 * But don't set the alternate file name if the buffer didn't have a
2545 fname
= curbuf
->b_ffname
;
2546 sfname
= curbuf
->b_sfname
;
2547 xfname
= curbuf
->b_fname
;
2548 curbuf
->b_ffname
= NULL
;
2549 curbuf
->b_sfname
= NULL
;
2550 if (setfname(curbuf
, eap
->arg
, NULL
, TRUE
) == FAIL
)
2552 curbuf
->b_ffname
= fname
;
2553 curbuf
->b_sfname
= sfname
;
2556 curbuf
->b_flags
|= BF_NOTEDITED
;
2557 if (xfname
!= NULL
&& *xfname
!= NUL
)
2559 buf
= buflist_new(fname
, xfname
, curwin
->w_cursor
.lnum
, 0);
2560 if (buf
!= NULL
&& !cmdmod
.keepalt
)
2561 curwin
->w_alt_fnum
= buf
->b_fnum
;
2566 apply_autocmds(EVENT_BUFFILEPOST
, NULL
, NULL
, FALSE
, curbuf
);
2568 /* Change directories when the 'acd' option is set. */
2571 /* print full file name if :cd used */
2572 fileinfo(FALSE
, FALSE
, eap
->forceit
);
2582 if (curbufIsChanged())
2583 (void)do_write(eap
);
2587 * ":write" and ":saveas".
2593 if (eap
->usefilter
) /* input lines to shell command */
2594 do_bang(1, eap
, FALSE
, TRUE
, FALSE
);
2596 (void)do_write(eap
);
2600 * write current buffer to file 'eap->arg'
2601 * if 'eap->append' is TRUE, append to the file
2603 * if *eap->arg == NUL write to current file
2605 * return FAIL for failure, OK otherwise
2612 char_u
*fname
= NULL
; /* init to shut up gcc */
2615 char_u
*free_fname
= NULL
;
2617 char_u
*browse_file
= NULL
;
2619 buf_T
*alt_buf
= NULL
;
2621 if (not_writing()) /* check 'write' option */
2628 browse_file
= do_browse(BROWSE_SAVE
, (char_u
*)_("Save As"), ffname
,
2629 NULL
, NULL
, NULL
, curbuf
);
2630 if (browse_file
== NULL
)
2632 ffname
= browse_file
;
2637 if (eap
->cmdidx
== CMD_saveas
)
2647 free_fname
= fix_fname(ffname
);
2649 * When out-of-memory, keep unexpanded file name, because we MUST be
2650 * able to write the file in this situation.
2652 if (free_fname
!= NULL
)
2653 ffname
= free_fname
;
2654 other
= otherfile(ffname
);
2658 * If we have a new file, put its name in the list of alternate file names.
2662 if (vim_strchr(p_cpo
, CPO_ALTWRITE
) != NULL
2663 || eap
->cmdidx
== CMD_saveas
)
2664 alt_buf
= setaltfname(ffname
, fname
, (linenr_T
)1);
2666 alt_buf
= buflist_findname(ffname
);
2667 if (alt_buf
!= NULL
&& alt_buf
->b_ml
.ml_mfp
!= NULL
)
2669 /* Overwriting a file that is loaded in another buffer is not a
2671 EMSG(_(e_bufloaded
));
2677 * Writing to the current file is not allowed in readonly mode
2678 * and a file name is required.
2679 * "nofile" and "nowrite" buffers cannot be written implicitly either.
2682 #ifdef FEAT_QUICKFIX
2683 bt_dontwrite_msg(curbuf
) ||
2685 check_fname() == FAIL
|| check_readonly(&eap
->forceit
, curbuf
)))
2690 ffname
= curbuf
->b_ffname
;
2691 fname
= curbuf
->b_fname
;
2693 * Not writing the whole file is only allowed with '!'.
2695 if ( (eap
->line1
!= 1
2696 || eap
->line2
!= curbuf
->b_ml
.ml_line_count
)
2701 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
2702 if (p_confirm
|| cmdmod
.confirm
)
2704 if (vim_dialog_yesno(VIM_QUESTION
, NULL
,
2705 (char_u
*)_("Write partial file?"), 2) != VIM_YES
)
2707 eap
->forceit
= TRUE
;
2712 EMSG(_("E140: Use ! to write partial buffer"));
2718 if (check_overwrite(eap
, curbuf
, fname
, ffname
, other
) == OK
)
2720 if (eap
->cmdidx
== CMD_saveas
&& alt_buf
!= NULL
)
2723 buf_T
*was_curbuf
= curbuf
;
2725 apply_autocmds(EVENT_BUFFILEPRE
, NULL
, NULL
, FALSE
, curbuf
);
2726 apply_autocmds(EVENT_BUFFILEPRE
, NULL
, NULL
, FALSE
, alt_buf
);
2728 if (curbuf
!= was_curbuf
|| aborting())
2730 if (curbuf
!= was_curbuf
)
2733 /* buffer changed, don't change name now */
2738 /* Exchange the file names for the current and the alternate
2739 * buffer. This makes it look like we are now editing the buffer
2740 * under the new name. Must be done before buf_write(), because
2741 * if there is no file name and 'cpo' contains 'F', it will set
2743 fname
= alt_buf
->b_fname
;
2744 alt_buf
->b_fname
= curbuf
->b_fname
;
2745 curbuf
->b_fname
= fname
;
2746 fname
= alt_buf
->b_ffname
;
2747 alt_buf
->b_ffname
= curbuf
->b_ffname
;
2748 curbuf
->b_ffname
= fname
;
2749 fname
= alt_buf
->b_sfname
;
2750 alt_buf
->b_sfname
= curbuf
->b_sfname
;
2751 curbuf
->b_sfname
= fname
;
2752 buf_name_changed(curbuf
);
2754 apply_autocmds(EVENT_BUFFILEPOST
, NULL
, NULL
, FALSE
, curbuf
);
2755 apply_autocmds(EVENT_BUFFILEPOST
, NULL
, NULL
, FALSE
, alt_buf
);
2756 if (!alt_buf
->b_p_bl
)
2758 alt_buf
->b_p_bl
= TRUE
;
2759 apply_autocmds(EVENT_BUFADD
, NULL
, NULL
, FALSE
, alt_buf
);
2762 if (curbuf
!= was_curbuf
|| aborting())
2764 if (curbuf
!= was_curbuf
)
2767 /* buffer changed, don't write the file */
2772 /* If 'filetype' was empty try detecting it now. */
2773 if (*curbuf
->b_p_ft
== NUL
)
2775 if (au_has_group((char_u
*)"filetypedetect"))
2776 (void)do_doautocmd((char_u
*)"filetypedetect BufRead",
2783 retval
= buf_write(curbuf
, ffname
, fname
, eap
->line1
, eap
->line2
,
2784 eap
, eap
->append
, eap
->forceit
, TRUE
, FALSE
);
2786 /* After ":saveas fname" reset 'readonly'. */
2787 if (eap
->cmdidx
== CMD_saveas
)
2791 curbuf
->b_p_ro
= FALSE
;
2793 redraw_tabline
= TRUE
;
2796 /* Change directories when the 'acd' option is set. */
2800 #ifdef FEAT_PERSISTENT_UNDO
2801 if (curbuf
->b_p_udf
)
2802 u_wundo(ffname
, curbuf
);
2807 vim_free(browse_file
);
2809 vim_free(free_fname
);
2814 * Check if it is allowed to overwrite a file. If b_flags has BF_NOTEDITED,
2815 * BF_NEW or BF_READERR, check for overwriting current file.
2816 * May set eap->forceit if a dialog says it's OK to overwrite.
2817 * Return OK if it's OK, FAIL if it is not.
2820 check_overwrite(eap
, buf
, fname
, ffname
, other
)
2823 char_u
*fname
; /* file name to be used (can differ from
2825 char_u
*ffname
; /* full path version of fname */
2826 int other
; /* writing under other name */
2829 * write to other file or b_flags set or not writing the whole file:
2830 * overwriting only allowed with '!'
2833 || (buf
->b_flags
& BF_NOTEDITED
)
2834 || ((buf
->b_flags
& BF_NEW
)
2835 && vim_strchr(p_cpo
, CPO_OVERNEW
) == NULL
)
2836 || (buf
->b_flags
& BF_READERR
))
2838 #ifdef FEAT_QUICKFIX
2841 && vim_fexists(ffname
))
2843 if (!eap
->forceit
&& !eap
->append
)
2846 /* with UNIX it is possible to open a directory */
2847 if (mch_isdir(ffname
))
2849 EMSG2(_(e_isadir2
), ffname
);
2853 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
2854 if (p_confirm
|| cmdmod
.confirm
)
2856 char_u buff
[IOSIZE
];
2858 dialog_msg(buff
, _("Overwrite existing file \"%s\"?"), fname
);
2859 if (vim_dialog_yesno(VIM_QUESTION
, NULL
, buff
, 2) != VIM_YES
)
2861 eap
->forceit
= TRUE
;
2871 /* For ":w! filename" check that no swap file exists for "filename". */
2872 if (other
&& !emsg_silent
)
2874 char_u dir
[MAXPATHL
];
2879 /* We only try the first entry in 'directory', without checking if
2880 * it's writable. If the "." directory is not writable the write
2881 * will probably fail anyway.
2882 * Use 'shortname' of the current buffer, since there is no buffer
2883 * for the written file. */
2889 copy_option_part(&p
, dir
, MAXPATHL
, ",");
2891 swapname
= makeswapname(fname
, ffname
, curbuf
, dir
);
2892 r
= vim_fexists(swapname
);
2895 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
2896 if (p_confirm
|| cmdmod
.confirm
)
2898 char_u buff
[IOSIZE
];
2901 _("Swap file \"%s\" exists, overwrite anyway?"),
2903 if (vim_dialog_yesno(VIM_QUESTION
, NULL
, buff
, 2)
2909 eap
->forceit
= TRUE
;
2914 EMSG2(_("E768: Swap file exists: %s (:silent! overrides)"),
2927 * Handle ":wnext", ":wNext" and ":wprevious" commands.
2935 if (eap
->cmd
[1] == 'n')
2936 i
= curwin
->w_arg_idx
+ (int)eap
->line2
;
2938 i
= curwin
->w_arg_idx
- (int)eap
->line2
;
2940 eap
->line2
= curbuf
->b_ml
.ml_line_count
;
2941 if (do_write(eap
) != FAIL
)
2946 * ":wall", ":wqall" and ":xall": Write all changed files (and exit).
2954 int save_forceit
= eap
->forceit
;
2956 if (eap
->cmdidx
== CMD_xall
|| eap
->cmdidx
== CMD_wqall
)
2959 for (buf
= firstbuf
; buf
!= NULL
; buf
= buf
->b_next
)
2961 if (bufIsChanged(buf
))
2964 * Check if there is a reason the buffer cannot be written:
2965 * 1. if the 'write' option is set
2966 * 2. if there is no file name (even after browsing)
2967 * 3. if the 'readonly' is set (even after a dialog)
2968 * 4. if overwriting is allowed (even after a dialog)
2976 /* ":browse wall": ask for file name if there isn't one */
2977 if (buf
->b_ffname
== NULL
&& cmdmod
.browse
)
2978 browse_save_fname(buf
);
2980 if (buf
->b_ffname
== NULL
)
2982 EMSGN(_("E141: No file name for buffer %ld"), (long)buf
->b_fnum
);
2985 else if (check_readonly(&eap
->forceit
, buf
)
2986 || check_overwrite(eap
, buf
, buf
->b_fname
, buf
->b_ffname
,
2993 if (buf_write_all(buf
, eap
->forceit
) == FAIL
)
2996 /* an autocommand may have deleted the buffer */
2997 if (!buf_valid(buf
))
3001 eap
->forceit
= save_forceit
; /* check_overwrite() may set it */
3007 getout(0); /* exit Vim */
3013 * Check the 'write' option.
3014 * Return TRUE and give a message when it's not st.
3021 EMSG(_("E142: File not written: Writing is disabled by 'write' option"));
3026 * Check if a buffer is read-only (either 'readonly' option is set or file is
3027 * read-only). Ask for overruling in a dialog. Return TRUE and give an error
3028 * message when the buffer is readonly.
3031 check_readonly(forceit
, buf
)
3037 /* Handle a file being readonly when the 'readonly' option is set or when
3038 * the file exists and permissions are read-only.
3039 * We will send 0777 to check_file_readonly(), as the "perm" variable is
3040 * important for device checks but not here. */
3041 if (!*forceit
&& (buf
->b_p_ro
3042 || (mch_stat((char *)buf
->b_ffname
, &st
) >= 0
3043 && check_file_readonly(buf
->b_ffname
, 0777))))
3045 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
3046 if ((p_confirm
|| cmdmod
.confirm
) && buf
->b_fname
!= NULL
)
3048 char_u buff
[IOSIZE
];
3051 dialog_msg(buff
, _("'readonly' option is set for \"%s\".\nDo you wish to write anyway?"),
3054 dialog_msg(buff
, _("File permissions of \"%s\" are read-only.\nIt may still be possible to write it.\nDo you wish to try?"),
3057 if (vim_dialog_yesno(VIM_QUESTION
, NULL
, buff
, 2) == VIM_YES
)
3059 /* Set forceit, to force the writing of a readonly file */
3069 EMSG(_(e_readonly
));
3071 EMSG2(_("E505: \"%s\" is read-only (add ! to override)"),
3080 * Try to abandon current file and edit a new or existing file.
3081 * 'fnum' is the number of the file, if zero use ffname/sfname.
3083 * Return 1 for "normal" error, 2 for "not written" error, 0 for success
3084 * -1 for successfully opening another file.
3085 * 'lnum' is the line number for the cursor in the new file (if non-zero).
3088 getfile(fnum
, ffname
, sfname
, setpm
, lnum
, forceit
)
3098 char_u
*free_me
= NULL
;
3103 if (curbuf_locked())
3109 /* make ffname full path, set sfname */
3110 fname_expand(curbuf
, &ffname
, &sfname
);
3111 other
= otherfile(ffname
);
3112 free_me
= ffname
; /* has been allocated, free() later */
3115 other
= (fnum
!= curbuf
->b_fnum
);
3118 ++no_wait_return
; /* don't wait for autowrite message */
3119 if (other
&& !forceit
&& curbuf
->b_nwindows
== 1 && !P_HID(curbuf
)
3120 && curbufIsChanged() && autowrite(curbuf
, forceit
) == FAIL
)
3122 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
3123 if (p_confirm
&& p_write
)
3124 dialog_changed(curbuf
, FALSE
);
3125 if (curbufIsChanged())
3130 EMSG(_(e_nowrtmsg
));
3131 retval
= 2; /* file has been changed */
3142 curwin
->w_cursor
.lnum
= lnum
;
3143 check_cursor_lnum();
3144 beginline(BL_SOL
| BL_FIX
);
3145 retval
= 0; /* it's in the same file */
3147 else if (do_ecmd(fnum
, ffname
, sfname
, NULL
, lnum
,
3148 (P_HID(curbuf
) ? ECMD_HIDE
: 0) + (forceit
? ECMD_FORCEIT
: 0),
3150 retval
= -1; /* opened another file */
3152 retval
= 1; /* error encountered */
3160 * start editing a new file
3162 * fnum: file number; if zero use ffname/sfname
3163 * ffname: the file name
3164 * - full path if sfname used,
3165 * - any file name if sfname is NULL
3166 * - empty string to re-edit with the same file name (but may be
3167 * in a different directory)
3168 * - NULL to start an empty buffer
3169 * sfname: the short file name (or NULL)
3170 * eap: contains the command to be executed after loading the file and
3171 * forced 'ff' and 'fenc'
3172 * newlnum: if > 0: put cursor on this line number (if possible)
3173 * if ECMD_LASTL: use last position in loaded file
3174 * if ECMD_LAST: use last position in all files
3175 * if ECMD_ONE: use first line
3177 * ECMD_HIDE: if TRUE don't free the current buffer
3178 * ECMD_SET_HELP: set b_help flag of (new) buffer before opening file
3179 * ECMD_OLDBUF: use existing buffer if it exists
3180 * ECMD_FORCEIT: ! used for Ex command
3181 * ECMD_ADDBUF: don't edit, just add to buffer list
3182 * oldwin: Should be "curwin" when editing a new buffer in the current
3183 * window, NULL when splitting the window first. When not NULL info
3184 * of the previous buffer for "oldwin" is stored.
3186 * return FAIL for failure, OK otherwise
3189 do_ecmd(fnum
, ffname
, sfname
, eap
, newlnum
, flags
, oldwin
)
3193 exarg_T
*eap
; /* can be NULL! */
3198 int other_file
; /* TRUE if editing another file */
3199 int oldbuf
; /* TRUE if using existing buffer */
3201 int auto_buf
= FALSE
; /* TRUE if autocommands brought us
3202 into the buffer unexpectedly */
3203 char_u
*new_name
= NULL
;
3204 int did_set_swapcommand
= FALSE
;
3207 #if defined(FEAT_AUTOCMD) || defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
3208 buf_T
*old_curbuf
= curbuf
;
3210 char_u
*free_fname
= NULL
;
3212 char_u
*browse_file
= NULL
;
3217 linenr_T topline
= 0;
3221 #ifdef FEAT_SUN_WORKSHOP
3224 char_u
*command
= NULL
;
3226 int did_get_winopts
= FALSE
;
3230 command
= eap
->do_ecmd_cmd
;
3234 if (fnum
== curbuf
->b_fnum
) /* file is already being edited */
3235 return OK
; /* nothing to do */
3243 # ifdef FEAT_AUTOCMD
3248 au_has_group((char_u
*)"FileExplorer"))
3250 /* No browsing supported but we do have the file explorer:
3251 * Edit the directory. */
3252 if (ffname
== NULL
|| !mch_isdir(ffname
))
3253 ffname
= (char_u
*)".";
3258 browse_file
= do_browse(0, (char_u
*)_("Edit File"), ffname
,
3259 NULL
, NULL
, NULL
, curbuf
);
3260 if (browse_file
== NULL
)
3262 ffname
= browse_file
;
3266 /* if no short name given, use ffname for short name */
3269 #ifdef USE_FNAME_CASE
3270 # ifdef USE_LONG_FNAME
3274 fname_case(sfname
, 0); /* set correct case for sfname */
3277 #ifdef FEAT_LISTCMDS
3278 if ((flags
& ECMD_ADDBUF
) && (ffname
== NULL
|| *ffname
== NUL
))
3284 /* there is no file name */
3285 else if (*ffname
== NUL
&& curbuf
->b_ffname
== NULL
)
3289 if (*ffname
== NUL
) /* re-edit with same file name */
3291 ffname
= curbuf
->b_ffname
;
3292 sfname
= curbuf
->b_fname
;
3294 free_fname
= fix_fname(ffname
); /* may expand to full path name */
3295 if (free_fname
!= NULL
)
3296 ffname
= free_fname
;
3297 other_file
= otherfile(ffname
);
3298 #ifdef FEAT_SUN_WORKSHOP
3299 if (usingSunWorkShop
&& p_acd
3300 && (cp
= vim_strrchr(sfname
, '/')) != NULL
)
3307 * if the file was changed we may not be allowed to abandon it
3308 * - if we are going to re-edit the same file
3309 * - or if we are the only window on this file and if ECMD_HIDE is FALSE
3311 if ( ((!other_file
&& !(flags
& ECMD_OLDBUF
))
3312 || (curbuf
->b_nwindows
== 1
3313 && !(flags
& (ECMD_HIDE
| ECMD_ADDBUF
))))
3314 && check_changed(curbuf
, p_awa
, !other_file
,
3315 (flags
& ECMD_FORCEIT
), FALSE
))
3317 if (fnum
== 0 && other_file
&& ffname
!= NULL
)
3318 (void)setaltfname(ffname
, sfname
, newlnum
< 0 ? 0 : newlnum
);
3324 * End Visual mode before switching to another buffer, so the text can be
3325 * copied into the GUI selection buffer.
3331 if ((command
!= NULL
|| newlnum
> (linenr_T
)0)
3332 && *get_vim_var_str(VV_SWAPCOMMAND
) == NUL
)
3337 /* Set v:swapcommand for the SwapExists autocommands. */
3338 if (command
!= NULL
)
3339 len
= (int)STRLEN(command
) + 3;
3342 p
= alloc((unsigned)len
);
3345 if (command
!= NULL
)
3346 vim_snprintf((char *)p
, len
, ":%s\r", command
);
3348 vim_snprintf((char *)p
, len
, "%ldG", (long)newlnum
);
3349 set_vim_var_string(VV_SWAPCOMMAND
, p
, -1);
3350 did_set_swapcommand
= TRUE
;
3357 * If we are starting to edit another file, open a (new) buffer.
3358 * Otherwise we re-use the current buffer.
3362 #ifdef FEAT_LISTCMDS
3363 if (!(flags
& ECMD_ADDBUF
))
3366 if (!cmdmod
.keepalt
)
3367 curwin
->w_alt_fnum
= curbuf
->b_fnum
;
3369 buflist_altfpos(oldwin
);
3373 buf
= buflist_findnr(fnum
);
3376 #ifdef FEAT_LISTCMDS
3377 if (flags
& ECMD_ADDBUF
)
3379 linenr_T tlnum
= 1L;
3381 if (command
!= NULL
)
3383 tlnum
= atol((char *)command
);
3387 (void)buflist_new(ffname
, sfname
, tlnum
, BLN_LISTED
);
3391 buf
= buflist_new(ffname
, sfname
, 0L,
3392 BLN_CURBUF
| ((flags
& ECMD_SET_HELP
) ? 0 : BLN_LISTED
));
3396 if (buf
->b_ml
.ml_mfp
== NULL
) /* no memfile yet */
3399 buf
->b_nwindows
= 0;
3401 else /* existing memfile */
3404 (void)buf_check_timestamp(buf
, FALSE
);
3405 /* Check if autocommands made buffer invalid or changed the current
3409 || curbuf
!= old_curbuf
3414 if (aborting()) /* autocmds may abort script processing */
3419 /* May jump to last used line number for a loaded buffer or when asked
3421 if ((oldbuf
&& newlnum
== ECMD_LASTL
) || newlnum
== ECMD_LAST
)
3423 pos
= buflist_findfpos(buf
);
3424 newlnum
= pos
->lnum
;
3429 * Make the (new) buffer the one used by the current window.
3430 * If the old buffer becomes unused, free it if ECMD_HIDE is FALSE.
3431 * If the current buffer was empty and has no file name, curbuf
3432 * is returned by buflist_new().
3438 * Be careful: The autocommands may delete any buffer and change
3439 * the current buffer.
3440 * - If the buffer we are going to edit is deleted, give up.
3441 * - If the current buffer is deleted, prefer to load the new
3442 * buffer when loading a buffer is required. This avoids
3443 * loading another buffer which then must be closed again.
3444 * - If we ended up in the new buffer already, need to skip a few
3445 * things, set auto_buf.
3447 if (buf
->b_fname
!= NULL
)
3448 new_name
= vim_strsave(buf
->b_fname
);
3449 au_new_curbuf
= buf
;
3450 apply_autocmds(EVENT_BUFLEAVE
, NULL
, NULL
, FALSE
, curbuf
);
3451 if (!buf_valid(buf
)) /* new buffer has been deleted */
3453 delbuf_msg(new_name
); /* frees new_name */
3457 if (aborting()) /* autocmds may abort script processing */
3463 if (buf
== curbuf
) /* already in new buffer */
3467 if (curbuf
== old_curbuf
)
3469 buf_copy_options(buf
, BCO_ENTER
);
3471 /* close the link to the current buffer */
3473 close_buffer(oldwin
, curbuf
,
3474 (flags
& ECMD_HIDE
) ? 0 : DOBUF_UNLOAD
);
3478 if (aborting()) /* autocmds may abort script processing */
3484 /* Be careful again, like above. */
3485 if (!buf_valid(buf
)) /* new buffer has been deleted */
3487 delbuf_msg(new_name
); /* frees new_name */
3490 if (buf
== curbuf
) /* already in new buffer */
3495 curwin
->w_buffer
= buf
;
3497 ++curbuf
->b_nwindows
;
3498 /* set 'fileformat' */
3499 if (*p_ffs
&& !oldbuf
)
3500 set_fileformat(default_fileformat(), OPT_LOCAL
);
3503 /* May get the window options from the last time this buffer
3504 * was in this window (or another window). If not used
3505 * before, reset the local window options to the global
3506 * values. Also restores old folding stuff. */
3507 get_winopts(curbuf
);
3509 did_get_winopts
= TRUE
;
3515 au_new_curbuf
= NULL
;
3519 ++curbuf
->b_nwindows
;
3521 curwin
->w_pcmark
.lnum
= 1;
3522 curwin
->w_pcmark
.col
= 0;
3524 else /* !other_file */
3527 #ifdef FEAT_LISTCMDS
3528 (flags
& ECMD_ADDBUF
) ||
3530 check_fname() == FAIL
)
3532 oldbuf
= (flags
& ECMD_OLDBUF
);
3535 if ((flags
& ECMD_SET_HELP
) || keep_help_flag
)
3539 curbuf
->b_help
= TRUE
;
3540 #ifdef FEAT_QUICKFIX
3541 set_string_option_direct((char_u
*)"buftype", -1,
3542 (char_u
*)"help", OPT_FREE
|OPT_LOCAL
, 0);
3546 * Always set these options after jumping to a help tag, because the
3547 * user may have an autocommand that gets in the way.
3548 * Accept all ASCII chars for keywords, except ' ', '*', '"', '|', and
3549 * latin1 word characters (for translated help files).
3550 * Only set it when needed, buf_init_chartab() is some work.
3554 (char_u
*)"65-255,^*,^|,^\"";
3556 (char_u
*)"!-~,^*,^|,^\",192-255";
3558 if (STRCMP(curbuf
->b_p_isk
, p
) != 0)
3560 set_string_option_direct((char_u
*)"isk", -1, p
,
3561 OPT_FREE
|OPT_LOCAL
, 0);
3562 check_buf_options(curbuf
);
3563 (void)buf_init_chartab(curbuf
, FALSE
);
3566 curbuf
->b_p_ts
= 8; /* 'tabstop' is 8 */
3567 curwin
->w_p_list
= FALSE
; /* no list mode */
3569 curbuf
->b_p_ma
= FALSE
; /* not modifiable */
3570 curbuf
->b_p_bin
= FALSE
; /* reset 'bin' before reading file */
3571 curwin
->w_p_nu
= 0; /* no line numbers */
3572 curwin
->w_p_rnu
= 0; /* no relative line numbers */
3573 #ifdef FEAT_SCROLLBIND
3574 curwin
->w_p_scb
= FALSE
; /* no scroll binding */
3577 curwin
->w_p_arab
= FALSE
; /* no arabic mode */
3579 #ifdef FEAT_RIGHTLEFT
3580 curwin
->w_p_rl
= FALSE
; /* help window is left-to-right */
3583 curwin
->w_p_fen
= FALSE
; /* No folding in the help window */
3586 curwin
->w_p_diff
= FALSE
; /* No 'diff' */
3589 curwin
->w_p_spell
= FALSE
; /* No spell checking */
3595 set_buflisted(FALSE
);
3602 /* Don't make a buffer listed if it's a help buffer. Useful when
3603 * using CTRL-O to go back to a help file. */
3604 if (!curbuf
->b_help
)
3605 set_buflisted(TRUE
);
3609 /* If autocommands change buffers under our fingers, forget about
3610 * editing the file. */
3614 if (aborting()) /* autocmds may abort script processing */
3618 /* Since we are starting to edit a file, consider the filetype to be
3619 * unset. Helps for when an autocommand changes files and expects syntax
3620 * highlighting to work in the other file. */
3621 did_filetype
= FALSE
;
3626 * FALSE FALSE re-edit same file, buffer is re-used
3627 * FALSE TRUE re-edit same file, nothing changes
3628 * TRUE FALSE start editing new file, new buffer
3629 * TRUE TRUE start editing in existing buffer (nothing to do)
3631 if (!other_file
&& !oldbuf
) /* re-use the buffer */
3633 set_last_cursor(curwin
); /* may set b_last_cursor */
3634 if (newlnum
== ECMD_LAST
|| newlnum
== ECMD_LASTL
)
3636 newlnum
= curwin
->w_cursor
.lnum
;
3637 solcol
= curwin
->w_cursor
.col
;
3641 if (buf
->b_fname
!= NULL
)
3642 new_name
= vim_strsave(buf
->b_fname
);
3646 buf_freeall(curbuf
, FALSE
, FALSE
); /* free all things for buffer */
3648 /* If autocommands deleted the buffer we were going to re-edit, give
3649 * up and jump to the end. */
3650 if (!buf_valid(buf
))
3652 delbuf_msg(new_name
); /* frees new_name */
3657 /* If autocommands change buffers under our fingers, forget about
3658 * re-editing the file. Should do the buf_clear_file(), but perhaps
3659 * the autocommands changed the buffer... */
3663 if (aborting()) /* autocmds may abort script processing */
3667 buf_clear_file(curbuf
);
3668 curbuf
->b_op_start
.lnum
= 0; /* clear '[ and '] marks */
3669 curbuf
->b_op_end
.lnum
= 0;
3673 * If we get here we are sure to start editing
3675 /* don't redraw until the cursor is in the right line */
3676 ++RedrawingDisabled
;
3678 /* Assume success now */
3682 * Reset cursor position, could be used by autocommands.
3687 * Check if we are editing the w_arg_idx file in the argument list.
3689 check_arg_idx(curwin
);
3696 * Set cursor and init window before reading the file and executing
3697 * autocommands. This allows for the autocommands to position the
3703 /* It's possible that all lines in the buffer changed. Need to update
3704 * automatic folding for all windows where it's used. */
3705 # ifdef FEAT_WINDOWS
3710 FOR_ALL_TAB_WINDOWS(tp
, win
)
3711 if (win
->w_buffer
== curbuf
)
3715 foldUpdateAll(curwin
);
3719 /* Change directories when the 'acd' option is set. */
3723 * Careful: open_buffer() and apply_autocmds() may change the current
3724 * buffer and window.
3726 lnum
= curwin
->w_cursor
.lnum
;
3727 topline
= curwin
->w_topline
;
3728 if (!oldbuf
) /* need to read the file */
3730 #if defined(HAS_SWAP_EXISTS_ACTION)
3731 swap_exists_action
= SEA_DIALOG
;
3733 curbuf
->b_flags
|= BF_CHECK_RO
; /* set/reset 'ro' flag */
3736 * Open the buffer and read the file.
3738 #if defined(FEAT_AUTOCMD) && defined(FEAT_EVAL)
3739 if (should_abort(open_buffer(FALSE
, eap
)))
3742 (void)open_buffer(FALSE
, eap
);
3745 #if defined(HAS_SWAP_EXISTS_ACTION)
3746 if (swap_exists_action
== SEA_QUIT
)
3748 handle_swap_exists(old_curbuf
);
3750 #ifdef FEAT_PERSISTENT_UNDO
3751 if (curbuf
->b_p_udf
&& !curbuf
->b_p_ro
) {
3759 /* Read the modelines, but only to set window-local options. Any
3760 * buffer-local options have already been set and may have been
3761 * changed by the user. */
3762 do_modelines(OPT_WINONLY
);
3764 apply_autocmds_retval(EVENT_BUFENTER
, NULL
, NULL
, FALSE
, curbuf
,
3766 apply_autocmds_retval(EVENT_BUFWINENTER
, NULL
, NULL
, FALSE
, curbuf
,
3769 check_arg_idx(curwin
);
3773 * If autocommands change the cursor position or topline, we should
3776 if (curwin
->w_cursor
.lnum
!= lnum
)
3778 newlnum
= curwin
->w_cursor
.lnum
;
3779 newcol
= curwin
->w_cursor
.col
;
3781 if (curwin
->w_topline
== topline
)
3784 /* Even when cursor didn't move we need to recompute topline. */
3785 changed_line_abv_curs();
3793 /* Tell the diff stuff that this buffer is new and/or needs updating.
3794 * Also needed when re-editing the same buffer, because unloading will
3795 * have removed it as a diff buffer. */
3796 if (curwin
->w_p_diff
)
3798 diff_buf_add(curbuf
);
3799 diff_invalidate(curbuf
);
3804 /* If the window options were changed may need to set the spell language.
3805 * Can only do this after the buffer has been properly setup. */
3806 if (did_get_winopts
&& curwin
->w_p_spell
&& *curbuf
->b_p_spl
!= NUL
)
3807 (void)did_set_spelllang(curbuf
);
3810 if (command
== NULL
)
3812 if (newcol
>= 0) /* position set by autocommands */
3814 curwin
->w_cursor
.lnum
= newlnum
;
3815 curwin
->w_cursor
.col
= newcol
;
3818 else if (newlnum
> 0) /* line number from caller or old position */
3820 curwin
->w_cursor
.lnum
= newlnum
;
3821 check_cursor_lnum();
3822 if (solcol
>= 0 && !p_sol
)
3824 /* 'sol' is off: Use last known column. */
3825 curwin
->w_cursor
.col
= solcol
;
3827 #ifdef FEAT_VIRTUALEDIT
3828 curwin
->w_cursor
.coladd
= 0;
3830 curwin
->w_set_curswant
= TRUE
;
3833 beginline(BL_SOL
| BL_FIX
);
3835 else /* no line number, go to last line in Ex mode */
3838 curwin
->w_cursor
.lnum
= curbuf
->b_ml
.ml_line_count
;
3839 beginline(BL_WHITE
| BL_FIX
);
3844 /* Check if cursors in other windows on the same buffer are still valid */
3849 * Did not read the file, need to show some info about the file.
3850 * Do this after setting the cursor.
3858 int msg_scroll_save
= msg_scroll
;
3860 /* Obey the 'O' flag in 'cpoptions': overwrite any previous file
3862 if (shortmess(SHM_OVERALL
) && !exiting
&& p_verbose
== 0)
3864 if (!msg_scroll
) /* wait a bit when overwriting an error msg */
3865 check_for_delay(FALSE
);
3867 msg_scroll
= msg_scroll_save
;
3868 msg_scrolled_ign
= TRUE
;
3870 fileinfo(FALSE
, TRUE
, FALSE
);
3872 msg_scrolled_ign
= FALSE
;
3875 if (command
!= NULL
)
3876 do_cmdline(command
, NULL
, NULL
, DOCMD_VERBOSE
);
3879 if (curbuf
->b_kmap_state
& KEYMAP_INIT
)
3880 (void)keymap_init();
3883 --RedrawingDisabled
;
3887 if (topline
== 0 && command
== NULL
)
3888 p_so
= 999; /* force cursor halfway the window */
3890 #ifdef FEAT_SCROLLBIND
3891 curwin
->w_scbind_pos
= curwin
->w_topline
;
3894 redraw_curbuf_later(NOT_VALID
); /* redraw this buffer later */
3898 need_start_insertmode
= TRUE
;
3900 /* Change directories when the 'acd' option is set. */
3903 #if defined(FEAT_SUN_WORKSHOP) || defined(FEAT_NETBEANS_INTG)
3904 if (gui
.in_use
&& curbuf
->b_ffname
!= NULL
)
3906 # ifdef FEAT_SUN_WORKSHOP
3907 if (usingSunWorkShop
)
3908 workshop_file_opened((char *)curbuf
->b_ffname
, curbuf
->b_p_ro
);
3910 # ifdef FEAT_NETBEANS_INTG
3911 if (usingNetbeans
&& ((flags
& ECMD_SET_HELP
) != ECMD_SET_HELP
))
3912 netbeans_file_opened(curbuf
);
3919 if (did_set_swapcommand
)
3920 set_vim_var_string(VV_SWAPCOMMAND
, NULL
, -1);
3923 vim_free(browse_file
);
3925 vim_free(free_fname
);
3934 EMSG2(_("E143: Autocommands unexpectedly deleted new buffer %s"),
3935 name
== NULL
? (char_u
*)"" : name
);
3937 au_new_curbuf
= NULL
;
3941 static int append_indent
= 0; /* autoindent for first line */
3944 * ":insert" and ":append", also used by ":change"
3951 int did_undo
= FALSE
;
3952 linenr_T lnum
= eap
->line2
;
3956 int empty
= (curbuf
->b_ml
.ml_flags
& ML_EMPTY
);
3958 /* the ! flag toggles autoindent */
3960 curbuf
->b_p_ai
= !curbuf
->b_p_ai
;
3962 /* First autoindent comes from the line we start on */
3963 if (eap
->cmdidx
!= CMD_change
&& curbuf
->b_p_ai
&& lnum
> 0)
3964 append_indent
= get_indent_lnum(lnum
);
3966 if (eap
->cmdidx
!= CMD_append
)
3969 /* when the buffer is empty append to line 0 and delete the dummy line */
3970 if (empty
&& lnum
== 1)
3973 State
= INSERT
; /* behave like in Insert mode */
3974 if (curbuf
->b_p_iminsert
== B_IMODE_LMAP
)
3980 need_wait_return
= FALSE
;
3983 if (append_indent
>= 0)
3985 indent
= append_indent
;
3989 indent
= get_indent_lnum(lnum
);
3991 ex_keep_indent
= FALSE
;
3992 if (eap
->getline
== NULL
)
3994 /* No getline() function, use the lines that follow. This ends
3995 * when there is no more. */
3996 if (eap
->nextcmd
== NULL
|| *eap
->nextcmd
== NUL
)
3998 p
= vim_strchr(eap
->nextcmd
, NL
);
4000 p
= eap
->nextcmd
+ STRLEN(eap
->nextcmd
);
4001 theline
= vim_strnsave(eap
->nextcmd
, (int)(p
- eap
->nextcmd
));
4007 theline
= eap
->getline(
4009 eap
->cstack
->cs_looplevel
> 0 ? -1 :
4011 NUL
, eap
->cookie
, indent
);
4012 lines_left
= Rows
- 1;
4013 if (theline
== NULL
)
4016 /* Using ^ CTRL-D in getexmodeline() makes us repeat the indent. */
4018 append_indent
= indent
;
4020 /* Look for the "." after automatic indent. */
4022 for (p
= theline
; indent
> vcol
; ++p
)
4027 vcol
+= 8 - vcol
% 8;
4031 if ((p
[0] == '.' && p
[1] == NUL
)
4032 || (!did_undo
&& u_save(lnum
, lnum
+ 1 + (empty
? 1 : 0))
4039 /* don't use autoindent if nothing was typed. */
4044 ml_append(lnum
, theline
, (colnr_T
)0, FALSE
);
4045 appended_lines_mark(lnum
, 1L);
4052 ml_delete(2L, FALSE
);
4059 curbuf
->b_p_ai
= !curbuf
->b_p_ai
;
4061 /* "start" is set to eap->line2+1 unless that position is invalid (when
4062 * eap->line2 pointed to the end of the buffer and nothing was appended)
4063 * "end" is set to lnum when something has been appended, otherwise
4064 * it is the same than "start" -- Acevedo */
4065 curbuf
->b_op_start
.lnum
= (eap
->line2
< curbuf
->b_ml
.ml_line_count
) ?
4066 eap
->line2
+ 1 : curbuf
->b_ml
.ml_line_count
;
4067 if (eap
->cmdidx
!= CMD_append
)
4068 --curbuf
->b_op_start
.lnum
;
4069 curbuf
->b_op_end
.lnum
= (eap
->line2
< lnum
)
4070 ? lnum
: curbuf
->b_op_start
.lnum
;
4071 curbuf
->b_op_start
.col
= curbuf
->b_op_end
.col
= 0;
4072 curwin
->w_cursor
.lnum
= lnum
;
4073 check_cursor_lnum();
4074 beginline(BL_SOL
| BL_FIX
);
4076 need_wait_return
= FALSE
; /* don't use wait_return() now */
4077 ex_no_reprint
= TRUE
;
4089 if (eap
->line2
>= eap
->line1
4090 && u_save(eap
->line1
- 1, eap
->line2
+ 1) == FAIL
)
4093 /* the ! flag toggles autoindent */
4094 if (eap
->forceit
? !curbuf
->b_p_ai
: curbuf
->b_p_ai
)
4095 append_indent
= get_indent_lnum(eap
->line1
);
4097 for (lnum
= eap
->line2
; lnum
>= eap
->line1
; --lnum
)
4099 if (curbuf
->b_ml
.ml_flags
& ML_EMPTY
) /* nothing to delete */
4101 ml_delete(eap
->line1
, FALSE
);
4104 /* make sure the cursor is not beyond the end of the file now */
4105 check_cursor_lnum();
4106 deleted_lines_mark(eap
->line1
, (long)(eap
->line2
- lnum
));
4108 /* ":append" on the line above the deleted lines. */
4109 eap
->line2
= eap
->line1
;
4121 linenr_T start
, end
, curs
, i
;
4123 linenr_T lnum
= eap
->line2
;
4125 /* Vi compatible: ":z!" uses display height, without a count uses
4128 bigness
= curwin
->w_height
;
4129 else if (firstwin
== lastwin
)
4130 bigness
= curwin
->w_p_scr
* 2;
4133 bigness
= curwin
->w_height
- 3;
4140 if (*kind
== '-' || *kind
== '+' || *kind
== '='
4141 || *kind
== '^' || *kind
== '.')
4143 while (*x
== '-' || *x
== '+')
4148 if (!VIM_ISDIGIT(*x
))
4150 EMSG(_("E144: non-numeric argument to :z"));
4155 bigness
= atoi((char *)x
);
4162 /* the number of '-' and '+' multiplies the distance */
4163 if (*kind
== '-' || *kind
== '+')
4164 for (x
= kind
+ 1; *x
== *kind
; ++x
)
4170 start
= lnum
- bigness
* (linenr_T
)(x
- kind
);
4171 end
= start
+ bigness
;
4176 start
= lnum
- (bigness
+ 1) / 2 + 1;
4177 end
= lnum
+ (bigness
+ 1) / 2 - 1;
4183 start
= lnum
- bigness
* 2;
4184 end
= lnum
- bigness
;
4185 curs
= lnum
- bigness
;
4189 start
= lnum
- (bigness
+ 1) / 2 + 1;
4190 end
= lnum
+ (bigness
+ 1) / 2 - 1;
4197 start
+= bigness
* (linenr_T
)(x
- kind
- 1) + 1;
4198 else if (eap
->addr_count
== 0)
4200 end
= start
+ bigness
- 1;
4208 if (end
> curbuf
->b_ml
.ml_line_count
)
4209 end
= curbuf
->b_ml
.ml_line_count
;
4211 if (curs
> curbuf
->b_ml
.ml_line_count
)
4212 curs
= curbuf
->b_ml
.ml_line_count
;
4214 for (i
= start
; i
<= end
; i
++)
4216 if (minus
&& i
== lnum
)
4220 for (j
= 1; j
< Columns
; j
++)
4224 print_line(i
, eap
->flags
& EXFLAG_NR
, eap
->flags
& EXFLAG_LIST
);
4226 if (minus
&& i
== lnum
)
4230 for (j
= 1; j
< Columns
; j
++)
4235 curwin
->w_cursor
.lnum
= curs
;
4236 ex_no_reprint
= TRUE
;
4240 * Check if the restricted flag is set.
4241 * If so, give an error message and return TRUE.
4242 * Otherwise, return FALSE.
4249 EMSG(_("E145: Shell commands not allowed in rvim"));
4256 * Check if the secure flag is set (.exrc or .vimrc in current directory).
4257 * If so, give an error message and return TRUE.
4258 * Otherwise, return FALSE.
4271 * In the sandbox more things are not allowed, including the things
4272 * disallowed in secure mode.
4283 static char_u
*old_sub
= NULL
; /* previous substitute pattern */
4284 static int global_need_beginline
; /* call beginline() after ":g" */
4288 * Perform a substitution from line eap->line1 to line eap->line2 using the
4289 * command pointed to by eap->arg which should be of the form:
4291 * /pattern/substitution/{flags}
4293 * The usual escapes are supported as described in the regexp docs.
4301 regmmatch_T regmatch
;
4302 static int do_all
= FALSE
; /* do multiple substitutions per line */
4303 static int do_ask
= FALSE
; /* ask for confirmation */
4304 static int do_count
= FALSE
; /* count only */
4305 static int do_error
= TRUE
; /* if false, ignore errors */
4306 static int do_print
= FALSE
; /* print last line with subs. */
4307 static int do_list
= FALSE
; /* list last line with subs. */
4308 static int do_number
= FALSE
; /* list last line with line nr*/
4309 static int do_ic
= 0; /* ignore case flag */
4310 char_u
*pat
= NULL
, *sub
= NULL
; /* init for GCC */
4313 int got_quit
= FALSE
;
4314 int got_match
= FALSE
;
4319 linenr_T first_line
= 0; /* first changed line */
4320 linenr_T last_line
= 0; /* below last changed line AFTER the
4322 linenr_T old_line_count
= curbuf
->b_ml
.ml_line_count
;
4324 long nmatch
; /* number of lines in match */
4325 char_u
*sub_firstline
; /* allocated copy of first sub line */
4326 int endcolumn
= FALSE
; /* cursor in last column when done */
4327 pos_T old_cursor
= curwin
->w_cursor
;
4336 start_nsubs
= sub_nsubs
;
4338 if (eap
->cmdidx
== CMD_tilde
)
4339 which_pat
= RE_LAST
; /* use last used regexp */
4341 which_pat
= RE_SUBST
; /* use last substitute regexp */
4343 /* new pattern and substitution */
4344 if (eap
->cmd
[0] == 's' && *cmd
!= NUL
&& !vim_iswhite(*cmd
)
4345 && vim_strchr((char_u
*)"0123456789cegriIp|\"", *cmd
) == NULL
)
4347 /* don't accept alphanumeric for separator */
4350 EMSG(_("E146: Regular expressions can't be delimited by letters"));
4354 * undocumented vi feature:
4355 * "\/sub/" and "\?sub?" use last used search pattern (almost like
4356 * //sub/r). "\&sub&" use last substitute pattern (like //sub/).
4361 if (vim_strchr((char_u
*)"/?&", *cmd
) == NULL
)
4363 EMSG(_(e_backslash
));
4367 which_pat
= RE_SEARCH
; /* use last '/' pattern */
4368 pat
= (char_u
*)""; /* empty search pattern */
4369 delimiter
= *cmd
++; /* remember delimiter character */
4371 else /* find the end of the regexp */
4373 #ifdef FEAT_FKMAP /* reverse the flow of the Farsi characters */
4374 if (p_altkeymap
&& curwin
->w_p_rl
)
4377 which_pat
= RE_LAST
; /* use last used regexp */
4378 delimiter
= *cmd
++; /* remember delimiter character */
4379 pat
= cmd
; /* remember start of search pat */
4380 cmd
= skip_regexp(cmd
, delimiter
, p_magic
, &eap
->arg
);
4381 if (cmd
[0] == delimiter
) /* end delimiter found */
4382 *cmd
++ = NUL
; /* replace it with a NUL */
4386 * Small incompatibility: vi sees '\n' as end of the command, but in
4387 * Vim we want to use '\n' to find/substitute a NUL.
4389 sub
= cmd
; /* remember the start of the substitution */
4393 if (cmd
[0] == delimiter
) /* end delimiter found */
4395 *cmd
++ = NUL
; /* replace it with a NUL */
4398 if (cmd
[0] == '\\' && cmd
[1] != 0) /* skip escaped characters */
4405 /* In POSIX vi ":s/pat/%/" uses the previous subst. string. */
4406 if (STRCMP(sub
, "%") == 0
4407 && vim_strchr(p_cpo
, CPO_SUBPERCENT
) != NULL
)
4409 if (old_sub
== NULL
) /* there is no previous command */
4411 EMSG(_(e_nopresub
));
4419 old_sub
= vim_strsave(sub
);
4423 else if (!eap
->skip
) /* use previous pattern and substitution */
4425 if (old_sub
== NULL
) /* there is no previous command */
4427 EMSG(_(e_nopresub
));
4430 pat
= NULL
; /* search_regcomp() will use previous pattern */
4433 /* Vi compatibility quirk: repeating with ":s" keeps the cursor in the
4434 * last column after using "$". */
4435 endcolumn
= (curwin
->w_curswant
== MAXCOL
);
4439 * Find trailing options. When '&' is used, keep old options.
4447 if (p_gd
) /* default is global on */
4462 * Note that 'g' and 'c' are always inverted, also when p_ed is off.
4463 * 'r' is never inverted.
4467 else if (*cmd
== 'c')
4469 else if (*cmd
== 'n')
4471 else if (*cmd
== 'e')
4472 do_error
= !do_error
;
4473 else if (*cmd
== 'r') /* use last used regexp */
4474 which_pat
= RE_LAST
;
4475 else if (*cmd
== 'p')
4477 else if (*cmd
== '#')
4482 else if (*cmd
== 'l')
4487 else if (*cmd
== 'i') /* ignore case */
4489 else if (*cmd
== 'I') /* don't ignore case */
4499 * check for a trailing count
4501 cmd
= skipwhite(cmd
);
4502 if (VIM_ISDIGIT(*cmd
))
4504 i
= getdigits(&cmd
);
4505 if (i
<= 0 && !eap
->skip
&& do_error
)
4507 EMSG(_(e_zerocount
));
4510 eap
->line1
= eap
->line2
;
4511 eap
->line2
+= i
- 1;
4512 if (eap
->line2
> curbuf
->b_ml
.ml_line_count
)
4513 eap
->line2
= curbuf
->b_ml
.ml_line_count
;
4517 * check for trailing command or garbage
4519 cmd
= skipwhite(cmd
);
4520 if (*cmd
&& *cmd
!= '"') /* if not end-of-line or comment */
4522 eap
->nextcmd
= check_nextcmd(cmd
);
4523 if (eap
->nextcmd
== NULL
)
4525 EMSG(_(e_trailing
));
4530 if (eap
->skip
) /* not executing commands, only parsing */
4533 if (!do_count
&& !curbuf
->b_p_ma
)
4535 /* Substitution is not allowed in non-'modifiable' buffer */
4536 EMSG(_(e_modifiable
));
4540 if (search_regcomp(pat
, RE_SUBST
, which_pat
, SEARCH_HIS
, ®match
) == FAIL
)
4547 /* the 'i' or 'I' flag overrules 'ignorecase' and 'smartcase' */
4549 regmatch
.rmm_ic
= TRUE
;
4550 else if (do_ic
== 'I')
4551 regmatch
.rmm_ic
= FALSE
;
4553 sub_firstline
= NULL
;
4556 * ~ in the substitute pattern is replaced with the old pattern.
4557 * We do it here once to avoid it to be replaced over and over again.
4558 * But don't do it when it starts with "\=", then it's an expression.
4560 if (!(sub
[0] == '\\' && sub
[1] == '='))
4561 sub
= regtilde(sub
, p_magic
);
4564 * Check for a match on each line.
4567 for (lnum
= eap
->line1
; lnum
<= line2
&& !(got_quit
4568 #if defined(FEAT_EVAL) && defined(FEAT_AUTOCMD)
4573 nmatch
= vim_regexec_multi(®match
, curwin
, curbuf
, lnum
,
4579 colnr_T prev_matchcol
= MAXCOL
;
4580 char_u
*new_end
, *new_start
= NULL
;
4581 unsigned new_start_len
= 0;
4583 int did_sub
= FALSE
;
4585 int len
, copy_len
, needed_len
;
4586 long nmatch_tl
= 0; /* nr of lines matched below lnum */
4587 int do_again
; /* do it again after joining lines */
4588 int skip_match
= FALSE
;
4589 linenr_T sub_firstlnum
; /* nr of first sub line */
4592 * The new text is build up step by step, to avoid too much
4593 * copying. There are these pieces:
4594 * sub_firstline The old text, unmodified.
4595 * copycol Column in the old text where we started
4596 * looking for a match; from here old text still
4597 * needs to be copied to the new text.
4598 * matchcol Column number of the old text where to look
4599 * for the next match. It's just after the
4600 * previous match or one further.
4601 * prev_matchcol Column just after the previous match (if any).
4602 * Mostly equal to matchcol, except for the first
4603 * match and after skipping an empty match.
4604 * regmatch.*pos Where the pattern matched in the old text.
4605 * new_start The new text, all that has been produced so
4607 * new_end The new text, where to append new text.
4609 * lnum The line number where we found the start of
4610 * the match. Can be below the line we searched
4611 * when there is a \n before a \zs in the
4613 * sub_firstlnum The line number in the buffer where to look
4614 * for a match. Can be different from "lnum"
4615 * when the pattern or substitute string contains
4618 * Special situations:
4619 * - When the substitute string contains a line break, the part up
4620 * to the line break is inserted in the text, but the copy of
4621 * the original line is kept. "sub_firstlnum" is adjusted for
4622 * the inserted lines.
4623 * - When the matched pattern contains a line break, the old line
4624 * is taken from the line at the end of the pattern. The lines
4625 * in the match are deleted later, "sub_firstlnum" is adjusted
4628 * The new text is built up in new_start[]. It has some extra
4629 * room to avoid using alloc()/free() too often. new_start_len is
4630 * the length of the allocated memory at new_start.
4632 * Make a copy of the old line, so it won't be taken away when
4633 * updating the screen or handling a multi-line match. The "old_"
4634 * pointers point into this copy.
4636 sub_firstlnum
= lnum
;
4640 /* At first match, remember current cursor position. */
4648 * Loop until nothing more to replace in this line.
4649 * 1. Handle match with empty string.
4650 * 2. If do_ask is set, ask for confirmation.
4651 * 3. substitute the string.
4652 * 4. if do_all is set, find next match
4653 * 5. break if there isn't another match in this line
4657 /* Advance "lnum" to the line where the match starts. The
4658 * match does not start in the first line when there is a line
4659 * break before \zs. */
4660 if (regmatch
.startpos
[0].lnum
> 0)
4662 lnum
+= regmatch
.startpos
[0].lnum
;
4663 sub_firstlnum
+= regmatch
.startpos
[0].lnum
;
4664 nmatch
-= regmatch
.startpos
[0].lnum
;
4665 vim_free(sub_firstline
);
4666 sub_firstline
= NULL
;
4669 if (sub_firstline
== NULL
)
4671 sub_firstline
= vim_strsave(ml_get(sub_firstlnum
));
4672 if (sub_firstline
== NULL
)
4674 vim_free(new_start
);
4679 /* Save the line number of the last change for the final
4680 * cursor position (just like Vi). */
4681 curwin
->w_cursor
.lnum
= lnum
;
4685 * 1. Match empty string does not count, except for first
4686 * match. This reproduces the strange vi behaviour.
4687 * This also catches endless loops.
4689 if (matchcol
== prev_matchcol
4690 && regmatch
.endpos
[0].lnum
== 0
4691 && matchcol
== regmatch
.endpos
[0].col
)
4693 if (sub_firstline
[matchcol
] == NUL
)
4694 /* We already were at the end of the line. Don't look
4695 * for a match in this line again. */
4698 ++matchcol
; /* search for a match at next column */
4702 /* Normally we continue searching for a match just after the
4703 * previous match. */
4704 matchcol
= regmatch
.endpos
[0].col
;
4705 prev_matchcol
= matchcol
;
4708 * 2. If do_count is set only increase the counter.
4709 * If do_ask is set, ask for confirmation.
4713 /* For a multi-line match, put matchcol at the NUL at
4714 * the end of the line and set nmatch to one, so that
4715 * we continue looking for a match on the next line.
4716 * Avoids that ":s/\nB\@=//gc" get stuck. */
4719 matchcol
= (colnr_T
)STRLEN(sub_firstline
);
4732 /* change State to CONFIRM, so that the mouse works
4737 setmouse(); /* disable mouse in xterm */
4739 curwin
->w_cursor
.col
= regmatch
.startpos
[0].col
;
4741 /* When 'cpoptions' contains "u" don't sync undo when
4742 * asking for confirmation. */
4743 if (vim_strchr(p_cpo
, CPO_UNDO
) != NULL
)
4747 * Loop until 'y', 'n', 'q', CTRL-E or CTRL-Y typed.
4756 print_line_no_prefix(lnum
, FALSE
, FALSE
);
4758 getvcol(curwin
, &curwin
->w_cursor
, &sc
, NULL
, NULL
);
4759 curwin
->w_cursor
.col
= regmatch
.endpos
[0].col
- 1;
4760 getvcol(curwin
, &curwin
->w_cursor
, NULL
, NULL
, &ec
);
4762 for (i
= 0; i
< (long)sc
; ++i
)
4764 for ( ; i
<= (long)ec
; ++i
)
4767 resp
= getexmodeline('?', NULL
, 0);
4777 int save_p_fen
= curwin
->w_p_fen
;
4779 curwin
->w_p_fen
= FALSE
;
4781 /* Invert the matched string.
4782 * Remove the inversion afterwards. */
4783 temp
= RedrawingDisabled
;
4784 RedrawingDisabled
= 0;
4786 search_match_lines
= regmatch
.endpos
[0].lnum
4787 - regmatch
.startpos
[0].lnum
;
4788 search_match_endcol
= regmatch
.endpos
[0].col
;
4789 highlight_match
= TRUE
;
4793 update_screen(SOME_VALID
);
4794 highlight_match
= FALSE
;
4795 redraw_later(SOME_VALID
);
4798 curwin
->w_p_fen
= save_p_fen
;
4800 if (msg_row
== Rows
- 1)
4801 msg_didout
= FALSE
; /* avoid a scroll-up */
4804 msg_scroll
= 0; /* truncate msg when
4807 /* write message same highlighting as for
4809 smsg_attr(hl_attr(HLF_R
),
4810 (char_u
*)_("replace with %s (y/n/a/q/l/^E/^Y)?"), sub
);
4811 msg_no_more
= FALSE
;
4814 windgoto(msg_row
, msg_col
);
4815 RedrawingDisabled
= temp
;
4817 #ifdef USE_ON_FLY_SCROLL
4818 dont_scroll
= FALSE
; /* allow scrolling here */
4820 ++no_mapping
; /* don't map this key */
4821 ++allow_keys
; /* allow special keys */
4822 typed
= plain_vgetc();
4826 /* clear the question */
4827 msg_didout
= FALSE
; /* don't scroll up */
4832 need_wait_return
= FALSE
; /* no hit-return prompt */
4833 if (typed
== 'q' || typed
== ESC
|| typed
== Ctrl_C
4835 || typed
== intr_char
4848 /* last: replace and then stop */
4858 #ifdef FEAT_INS_EXPAND
4859 if (typed
== Ctrl_E
)
4861 else if (typed
== Ctrl_Y
)
4869 if (vim_strchr(p_cpo
, CPO_UNDO
) != NULL
)
4874 /* For a multi-line match, put matchcol at the NUL at
4875 * the end of the line and set nmatch to one, so that
4876 * we continue looking for a match on the next line.
4877 * Avoids that ":%s/\nB\@=//gc" and ":%s/\n/,\r/gc"
4878 * get stuck when pressing 'n'. */
4881 matchcol
= (colnr_T
)STRLEN(sub_firstline
);
4890 /* Move the cursor to the start of the match, so that we can
4891 * use "\=col("."). */
4892 curwin
->w_cursor
.col
= regmatch
.startpos
[0].col
;
4895 * 3. substitute the string.
4897 /* get length of substitution part */
4898 sublen
= vim_regsub_multi(®match
,
4899 sub_firstlnum
- regmatch
.startpos
[0].lnum
,
4900 sub
, sub_firstline
, FALSE
, p_magic
, TRUE
);
4902 /* When the match included the "$" of the last line it may
4903 * go beyond the last line of the buffer. */
4904 if (nmatch
> curbuf
->b_ml
.ml_line_count
- sub_firstlnum
+ 1)
4906 nmatch
= curbuf
->b_ml
.ml_line_count
- sub_firstlnum
+ 1;
4911 * - result so far in new_start (not for first sub in line)
4912 * - original text up to match
4913 * - length of substituted part
4914 * - original text after match
4920 p1
= ml_get(sub_firstlnum
+ nmatch
- 1);
4921 nmatch_tl
+= nmatch
- 1;
4923 copy_len
= regmatch
.startpos
[0].col
- copycol
;
4924 needed_len
= copy_len
+ ((unsigned)STRLEN(p1
)
4925 - regmatch
.endpos
[0].col
) + sublen
+ 1;
4926 if (new_start
== NULL
)
4929 * Get some space for a temporary buffer to do the
4930 * substitution into (and some extra space to avoid
4931 * too many calls to alloc()/free()).
4933 new_start_len
= needed_len
+ 50;
4934 if ((new_start
= alloc_check(new_start_len
)) == NULL
)
4937 new_end
= new_start
;
4942 * Check if the temporary buffer is long enough to do the
4943 * substitution into. If not, make it larger (with a bit
4944 * extra to avoid too many calls to alloc()/free()).
4946 len
= (unsigned)STRLEN(new_start
);
4948 if (needed_len
> (int)new_start_len
)
4950 new_start_len
= needed_len
+ 50;
4951 if ((p1
= alloc_check(new_start_len
)) == NULL
)
4953 vim_free(new_start
);
4956 mch_memmove(p1
, new_start
, (size_t)(len
+ 1));
4957 vim_free(new_start
);
4960 new_end
= new_start
+ len
;
4964 * copy the text up to the part that matched
4966 mch_memmove(new_end
, sub_firstline
+ copycol
, (size_t)copy_len
);
4967 new_end
+= copy_len
;
4969 (void)vim_regsub_multi(®match
,
4970 sub_firstlnum
- regmatch
.startpos
[0].lnum
,
4971 sub
, new_end
, TRUE
, p_magic
, TRUE
);
4975 /* Move the cursor to the start of the line, to avoid that it
4976 * is beyond the end of the line after the substitution. */
4977 curwin
->w_cursor
.col
= 0;
4979 /* For a multi-line match, make a copy of the last matched
4980 * line and continue in that one. */
4983 sub_firstlnum
+= nmatch
- 1;
4984 vim_free(sub_firstline
);
4985 sub_firstline
= vim_strsave(ml_get(sub_firstlnum
));
4986 /* When going beyond the last line, stop substituting. */
4987 if (sub_firstlnum
<= line2
)
4993 /* Remember next character to be copied. */
4994 copycol
= regmatch
.endpos
[0].col
;
4998 /* Already hit end of the buffer, sub_firstlnum is one
4999 * less than what it ought to be. */
5000 vim_free(sub_firstline
);
5001 sub_firstline
= vim_strsave((char_u
*)"");
5006 * Now the trick is to replace CTRL-M chars with a real line
5007 * break. This would make it impossible to insert a CTRL-M in
5008 * the text. The line break can be avoided by preceding the
5009 * CTRL-M with a backslash. To be able to insert a backslash,
5010 * they must be doubled in the string and are halved here.
5011 * That is Vi compatible.
5013 for (p1
= new_end
; *p1
; ++p1
)
5015 if (p1
[0] == '\\' && p1
[1] != NUL
) /* remove backslash */
5016 STRMOVE(p1
, p1
+ 1);
5017 else if (*p1
== CAR
)
5019 if (u_inssub(lnum
) == OK
) /* prepare for undo */
5021 *p1
= NUL
; /* truncate up to the CR */
5022 ml_append(lnum
- 1, new_start
,
5023 (colnr_T
)(p1
- new_start
+ 1), FALSE
);
5024 mark_adjust(lnum
+ 1, (linenr_T
)MAXLNUM
, 1L, 0L);
5026 appended_lines(lnum
- 1, 1L);
5029 if (first_line
== 0)
5031 last_line
= lnum
+ 1;
5033 /* All line numbers increase. */
5037 /* move the cursor to the new line, like Vi */
5038 ++curwin
->w_cursor
.lnum
;
5040 STRMOVE(new_start
, p1
+ 1);
5046 p1
+= (*mb_ptr2len
)(p1
) - 1;
5051 * 4. If do_all is set, find next match.
5052 * Prevent endless loop with patterns that match empty
5053 * strings, e.g. :s/$/pat/g or :s/[a-z]* /(&)/g.
5054 * But ":s/\n/#/" is OK.
5057 /* We already know that we did the last subst when we are at
5058 * the end of the line, except that a pattern like
5059 * "bar\|\nfoo" may match at the NUL. "lnum" can be below
5060 * "line2" when there is a \zs in the pattern after a line
5062 lastone
= (skip_match
5066 || !(do_all
|| do_again
)
5067 || (sub_firstline
[matchcol
] == NUL
&& nmatch
<= 1
5068 && !re_multiline(regmatch
.regprog
)));
5072 * Replace the line in the buffer when needed. This is
5073 * skipped when there are more matches.
5074 * The check for nmatch_tl is needed for when multi-line
5075 * matching must replace the lines before trying to do another
5076 * match, otherwise "\@<=" won't work.
5077 * When asking the user we like to show the already replaced
5078 * text, but don't do it when "\<@=" or "\<@!" is used, it
5079 * changes what matches.
5080 * When the match starts below where we start searching also
5081 * need to replace the line first (using \zs after \n).
5084 || (do_ask
&& !re_lookbehind(regmatch
.regprog
))
5086 || (nmatch
= vim_regexec_multi(®match
, curwin
,
5087 curbuf
, sub_firstlnum
,
5088 matchcol
, NULL
)) == 0
5089 || regmatch
.startpos
[0].lnum
> 0)
5091 if (new_start
!= NULL
)
5094 * Copy the rest of the line, that didn't match.
5095 * "matchcol" has to be adjusted, we use the end of
5096 * the line as reference, because the substitute may
5097 * have changed the number of characters. Same for
5100 STRCAT(new_start
, sub_firstline
+ copycol
);
5101 matchcol
= (colnr_T
)STRLEN(sub_firstline
) - matchcol
;
5102 prev_matchcol
= (colnr_T
)STRLEN(sub_firstline
)
5105 if (u_savesub(lnum
) != OK
)
5107 ml_replace(lnum
, new_start
, TRUE
);
5112 * Matched lines have now been substituted and are
5113 * useless, delete them. The part after the match
5114 * has been appended to new_start, we don't need
5118 if (u_savedel(lnum
, nmatch_tl
) != OK
)
5120 for (i
= 0; i
< nmatch_tl
; ++i
)
5121 ml_delete(lnum
, (int)FALSE
);
5122 mark_adjust(lnum
, lnum
+ nmatch_tl
- 1,
5123 (long)MAXLNUM
, -nmatch_tl
);
5125 deleted_lines(lnum
, nmatch_tl
);
5127 line2
-= nmatch_tl
; /* nr of lines decreases */
5131 /* When asking, undo is saved each time, must also set
5132 * changed flag each time. */
5134 changed_bytes(lnum
, 0);
5137 if (first_line
== 0)
5139 last_line
= lnum
+ 1;
5142 sub_firstlnum
= lnum
;
5143 vim_free(sub_firstline
); /* free the temp buffer */
5144 sub_firstline
= new_start
;
5146 matchcol
= (colnr_T
)STRLEN(sub_firstline
) - matchcol
;
5147 prev_matchcol
= (colnr_T
)STRLEN(sub_firstline
)
5151 if (nmatch
== -1 && !lastone
)
5152 nmatch
= vim_regexec_multi(®match
, curwin
, curbuf
,
5153 sub_firstlnum
, matchcol
, NULL
);
5156 * 5. break if there isn't another match in this line
5160 /* If the match found didn't start where we were
5161 * searching, do the next search in the line where we
5162 * found the match. */
5164 lnum
-= regmatch
.startpos
[0].lnum
;
5174 vim_free(new_start
); /* for when substitute was cancelled */
5175 vim_free(sub_firstline
); /* free the copy of the original line */
5176 sub_firstline
= NULL
;
5182 if (first_line
!= 0)
5184 /* Need to subtract the number of added lines from "last_line" to get
5185 * the line number before the change (same as adding the number of
5186 * deleted lines). */
5187 i
= curbuf
->b_ml
.ml_line_count
- old_line_count
;
5188 changed_lines(first_line
, 0, last_line
- i
, i
);
5192 vim_free(sub_firstline
); /* may have to free allocated copy of the line */
5194 /* ":s/pat//n" doesn't move the cursor */
5196 curwin
->w_cursor
= old_cursor
;
5198 if (sub_nsubs
> start_nsubs
)
5200 /* Set the '[ and '] marks. */
5201 curbuf
->b_op_start
.lnum
= eap
->line1
;
5202 curbuf
->b_op_end
.lnum
= line2
;
5203 curbuf
->b_op_start
.col
= curbuf
->b_op_end
.col
= 0;
5208 coladvance((colnr_T
)MAXCOL
);
5210 beginline(BL_WHITE
| BL_FIX
);
5211 if (!do_sub_msg(do_count
) && do_ask
)
5215 global_need_beginline
= TRUE
;
5217 print_line(curwin
->w_cursor
.lnum
, do_number
, do_list
);
5219 else if (!global_busy
)
5221 if (got_int
) /* interrupted */
5223 else if (got_match
) /* did find something but nothing substituted */
5225 else if (do_error
) /* nothing found */
5226 EMSG2(_(e_patnotf2
), get_search_pat());
5229 vim_free(regmatch
.regprog
);
5233 * Give message for number of substitutions.
5234 * Can also be used after a ":global" command.
5235 * Return TRUE if a message was given.
5238 do_sub_msg(count_only
)
5239 int count_only
; /* used 'n' flag for ":s" */
5244 * Only report substitutions when:
5245 * - more than 'report' substitutions
5246 * - command was typed by user, or number of changed lines > 'report'
5247 * - giving messages is not disabled by 'lazyredraw'
5249 if (((sub_nsubs
> p_report
&& (KeyTyped
|| sub_nlines
> 1 || p_report
< 1))
5255 STRCPY(msg_buf
, _("(Interrupted) "));
5256 len
= (int)STRLEN(msg_buf
);
5259 vim_snprintf((char *)msg_buf
+ len
, sizeof(msg_buf
) - len
,
5260 "%s", count_only
? _("1 match") : _("1 substitution"));
5262 vim_snprintf((char *)msg_buf
+ len
, sizeof(msg_buf
) - len
,
5263 count_only
? _("%ld matches") : _("%ld substitutions"),
5265 len
= (int)STRLEN(msg_buf
);
5266 if (sub_nlines
== 1)
5267 vim_snprintf((char *)msg_buf
+ len
, sizeof(msg_buf
) - len
,
5268 "%s", _(" on 1 line"));
5270 vim_snprintf((char *)msg_buf
+ len
, sizeof(msg_buf
) - len
,
5271 _(" on %ld lines"), (long)sub_nlines
);
5273 /* save message to display it after redraw */
5274 set_keep_msg(msg_buf
, 0);
5286 * Execute a global command of the form:
5288 * g/pattern/X : execute X on all lines where pattern matches
5289 * v/pattern/X : execute X on all lines where pattern does not match
5291 * where 'X' is an EX command
5293 * The command character (as well as the trailing slash) is optional, and
5294 * is assumed to be 'p' if missing.
5296 * This is implemented in two passes: first we scan the file for the pattern and
5297 * set a mark for each line that (not) matches. secondly we execute the command
5298 * for each line that has a mark. This is required because after deleting
5299 * lines we do not know where to search for the next match.
5305 linenr_T lnum
; /* line number according to old situation */
5307 int type
; /* first char of cmd: 'v' or 'g' */
5308 char_u
*cmd
; /* command argument */
5310 char_u delim
; /* delimiter, normally '/' */
5312 regmmatch_T regmatch
;
5318 EMSG(_("E147: Cannot do :global recursive")); /* will increment global_busy */
5322 if (eap
->forceit
) /* ":global!" is like ":vglobal" */
5327 which_pat
= RE_LAST
; /* default: use last used regexp */
5330 * undocumented vi feature:
5331 * "\/" and "\?": use previous search pattern.
5332 * "\&": use previous substitute pattern.
5337 if (vim_strchr((char_u
*)"/?&", *cmd
) == NULL
)
5339 EMSG(_(e_backslash
));
5343 which_pat
= RE_SUBST
; /* use previous substitute pattern */
5345 which_pat
= RE_SEARCH
; /* use previous search pattern */
5349 else if (*cmd
== NUL
)
5351 EMSG(_("E148: Regular expression missing from global"));
5356 delim
= *cmd
; /* get the delimiter */
5358 ++cmd
; /* skip delimiter if there is one */
5359 pat
= cmd
; /* remember start of pattern */
5360 cmd
= skip_regexp(cmd
, delim
, p_magic
, &eap
->arg
);
5361 if (cmd
[0] == delim
) /* end delimiter found */
5362 *cmd
++ = NUL
; /* replace it with a NUL */
5365 #ifdef FEAT_FKMAP /* when in Farsi mode, reverse the character flow */
5366 if (p_altkeymap
&& curwin
->w_p_rl
)
5370 if (search_regcomp(pat
, RE_BOTH
, which_pat
, SEARCH_HIS
, ®match
) == FAIL
)
5377 * pass 1: set marks for each (not) matching line
5379 for (lnum
= eap
->line1
; lnum
<= eap
->line2
&& !got_int
; ++lnum
)
5381 /* a match on this line? */
5382 match
= vim_regexec_multi(®match
, curwin
, curbuf
, lnum
,
5384 if ((type
== 'g' && match
) || (type
== 'v' && !match
))
5393 * pass 2: execute the command for each line that has been marked
5397 else if (ndone
== 0)
5400 smsg((char_u
*)_("Pattern found in every line: %s"), pat
);
5402 smsg((char_u
*)_(e_patnotf2
), pat
);
5407 ml_clearmarked(); /* clear rest of the marks */
5408 vim_free(regmatch
.regprog
);
5412 * Execute "cmd" on lines marked with ml_setmarked().
5418 linenr_T old_lcount
; /* b_ml.ml_line_count before the command */
5419 linenr_T lnum
; /* line number according to old situation */
5422 * Set current position only once for a global command.
5423 * If global_busy is set, setpcmark() will not do anything.
5424 * If there is an error, global_busy will be incremented.
5428 /* When the command writes a message, don't overwrite the command. */
5433 global_need_beginline
= FALSE
;
5435 old_lcount
= curbuf
->b_ml
.ml_line_count
;
5436 while (!got_int
&& (lnum
= ml_firstmarked()) != 0 && global_busy
== 1)
5438 curwin
->w_cursor
.lnum
= lnum
;
5439 curwin
->w_cursor
.col
= 0;
5440 if (*cmd
== NUL
|| *cmd
== '\n')
5441 do_cmdline((char_u
*)"p", NULL
, NULL
, DOCMD_NOWAIT
);
5443 do_cmdline(cmd
, NULL
, NULL
, DOCMD_NOWAIT
);
5448 if (global_need_beginline
)
5449 beginline(BL_WHITE
| BL_FIX
);
5451 check_cursor(); /* cursor may be beyond the end of the line */
5453 /* the cursor may not have moved in the text but a change in a previous
5454 * line may move it on the screen */
5455 changed_line_abv_curs();
5457 /* If it looks like no message was written, allow overwriting the
5458 * command with the report for number of changes. */
5459 if (msg_col
== 0 && msg_scrolled
== 0)
5462 /* If substitutes done, report number of substitutes, otherwise report
5463 * number of extra or deleted lines. */
5464 if (!do_sub_msg(FALSE
))
5465 msgmore(curbuf
->b_ml
.ml_line_count
- old_lcount
);
5470 read_viminfo_sub_string(virp
, force
)
5474 if (old_sub
!= NULL
&& force
)
5476 if (force
|| old_sub
== NULL
)
5477 old_sub
= viminfo_readstring(virp
, 1, TRUE
);
5478 return viminfo_readline(virp
);
5482 write_viminfo_sub_string(fp
)
5485 if (get_viminfo_parameter('/') != 0 && old_sub
!= NULL
)
5487 fprintf(fp
, _("\n# Last Substitute String:\n$"));
5488 viminfo_writestring(fp
, old_sub
);
5491 #endif /* FEAT_VIMINFO */
5493 #if defined(EXITFREE) || defined(PROTO)
5501 #if (defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)) || defined(PROTO)
5503 * Set up for a tagpreview.
5504 * Return TRUE when it was created.
5507 prepare_tagpreview(undo_sync
)
5508 int undo_sync
; /* sync undo when leaving the window */
5513 need_mouse_correct
= TRUE
;
5517 * If there is already a preview window open, use that one.
5519 if (!curwin
->w_p_pvw
)
5521 for (wp
= firstwin
; wp
!= NULL
; wp
= wp
->w_next
)
5525 win_enter(wp
, undo_sync
);
5529 * There is no preview window open yet. Create one.
5531 if (win_split(g_do_tagpreview
> 0 ? g_do_tagpreview
: 0, 0)
5534 curwin
->w_p_pvw
= TRUE
;
5535 curwin
->w_p_wfh
= TRUE
;
5536 # ifdef FEAT_SCROLLBIND
5537 curwin
->w_p_scb
= FALSE
; /* don't take over 'scrollbind' */
5540 curwin
->w_p_diff
= FALSE
; /* no 'diff' */
5542 # ifdef FEAT_FOLDING
5543 curwin
->w_p_fdc
= 0; /* no 'foldcolumn' */
5555 * ":help": open a read-only window on a help file
5563 FILE *helpfd
; /* file descriptor of help file */
5575 #ifdef FEAT_MULTI_LANG
5583 * A ":help" command ends at the first LF, or at a '|' that is
5584 * followed by some text. Set nextcmd to the following command.
5586 for (arg
= eap
->arg
; *arg
; ++arg
)
5588 if (*arg
== '\n' || *arg
== '\r'
5589 || (*arg
== '|' && arg
[1] != NUL
&& arg
[1] != '|'))
5598 if (eap
->forceit
&& *arg
== NUL
)
5600 EMSG(_("E478: Don't panic!"));
5604 if (eap
->skip
) /* not executing commands */
5610 /* remove trailing blanks */
5611 p
= arg
+ STRLEN(arg
) - 1;
5612 while (p
> arg
&& vim_iswhite(*p
) && p
[-1] != '\\')
5615 #ifdef FEAT_MULTI_LANG
5616 /* Check for a specified language */
5617 lang
= check_help_lang(arg
);
5620 /* When no argument given go to the index. */
5622 arg
= (char_u
*)"help.txt";
5625 * Check if there is a match for the argument.
5627 n
= find_help_tags(arg
, &num_matches
, &matches
,
5628 eap
!= NULL
&& eap
->forceit
);
5631 #ifdef FEAT_MULTI_LANG
5632 if (n
!= FAIL
&& lang
!= NULL
)
5633 /* Find first item with the requested language. */
5634 for (i
= 0; i
< num_matches
; ++i
)
5636 len
= (int)STRLEN(matches
[i
]);
5637 if (len
> 3 && matches
[i
][len
- 3] == '@'
5638 && STRICMP(matches
[i
] + len
- 2, lang
) == 0)
5642 if (i
>= num_matches
|| n
== FAIL
)
5644 #ifdef FEAT_MULTI_LANG
5646 EMSG3(_("E661: Sorry, no '%s' help for %s"), lang
, arg
);
5649 EMSG2(_("E149: Sorry, no help for %s"), arg
);
5651 FreeWild(num_matches
, matches
);
5655 /* The first match (in the requested language) is the best match. */
5656 tag
= vim_strsave(matches
[i
]);
5657 FreeWild(num_matches
, matches
);
5660 need_mouse_correct
= TRUE
;
5664 * Re-use an existing help window or open a new one.
5665 * Always open a new one for ":tab help".
5667 if (!curwin
->w_buffer
->b_help
5674 if (cmdmod
.tab
!= 0)
5677 for (wp
= firstwin
; wp
!= NULL
; wp
= wp
->w_next
)
5678 if (wp
->w_buffer
!= NULL
&& wp
->w_buffer
->b_help
)
5680 if (wp
!= NULL
&& wp
->w_buffer
->b_nwindows
> 0)
5681 win_enter(wp
, TRUE
);
5686 * There is no help window yet.
5687 * Try to open the file specified by the "helpfile" option.
5689 if ((helpfd
= mch_fopen((char *)p_hf
, READBIN
)) == NULL
)
5691 smsg((char_u
*)_("Sorry, help file \"%s\" not found"), p_hf
);
5697 /* Split off help window; put it at far top if no position
5698 * specified, the current window is vertically split and
5701 # ifdef FEAT_VERTSPLIT
5702 if (cmdmod
.split
== 0 && curwin
->w_width
!= Columns
5703 && curwin
->w_width
< 80)
5706 if (win_split(0, n
) == FAIL
)
5709 /* use current window */
5710 if (!can_abandon(curbuf
, FALSE
))
5715 if (curwin
->w_height
< p_hh
)
5716 win_setheight((int)p_hh
);
5720 * Open help file (do_ecmd() will set b_help flag, readfile() will
5722 * Set the alternate file to the previously edited file.
5724 alt_fnum
= curbuf
->b_fnum
;
5725 (void)do_ecmd(0, NULL
, NULL
, NULL
, ECMD_LASTL
,
5726 ECMD_HIDE
+ ECMD_SET_HELP
,
5728 NULL
/* buffer is still open, don't store info */
5733 if (!cmdmod
.keepalt
)
5734 curwin
->w_alt_fnum
= alt_fnum
;
5735 empty_fnum
= curbuf
->b_fnum
;
5740 restart_edit
= 0; /* don't want insert mode in help file */
5743 do_tag(tag
, DT_HELP
, 1, FALSE
, TRUE
);
5745 /* Delete the empty buffer if we're not using it. Careful: autocommands
5746 * may have jumped to another window, check that the buffer is not in a
5748 if (empty_fnum
!= 0 && curbuf
->b_fnum
!= empty_fnum
)
5750 buf
= buflist_findnr(empty_fnum
);
5751 if (buf
!= NULL
&& buf
->b_nwindows
== 0)
5752 wipe_buffer(buf
, TRUE
);
5755 /* keep the previous alternate file */
5756 if (alt_fnum
!= 0 && curwin
->w_alt_fnum
== empty_fnum
&& !cmdmod
.keepalt
)
5757 curwin
->w_alt_fnum
= alt_fnum
;
5764 #if defined(FEAT_MULTI_LANG) || defined(PROTO)
5766 * In an argument search for a language specifiers in the form "@xx".
5767 * Changes the "@" to NUL if found, and returns a pointer to "xx".
5768 * Returns NULL if not found.
5771 check_help_lang(arg
)
5774 int len
= (int)STRLEN(arg
);
5776 if (len
>= 3 && arg
[len
- 3] == '@' && ASCII_ISALPHA(arg
[len
- 2])
5777 && ASCII_ISALPHA(arg
[len
- 1]))
5779 arg
[len
- 3] = NUL
; /* remove the '@' */
5780 return arg
+ len
- 2;
5787 * Return a heuristic indicating how well the given string matches. The
5788 * smaller the number, the better the match. This is the order of priorities,
5789 * from best match to worst match:
5790 * - Match with least alpha-numeric characters is better.
5791 * - Match with least total characters is better.
5792 * - Match towards the start is better.
5793 * - Match starting with "+" is worse (feature instead of command)
5794 * Assumption is made that the matched_string passed has already been found to
5795 * match some string for which help is requested. webb.
5798 help_heuristic(matched_string
, offset
, wrong_case
)
5799 char_u
*matched_string
;
5800 int offset
; /* offset for match */
5801 int wrong_case
; /* no matching case */
5807 for (p
= matched_string
; *p
; p
++)
5808 if (ASCII_ISALNUM(*p
))
5812 * Multiply the number of letters by 100 to give it a much bigger
5813 * weighting than the number of characters.
5814 * If there only is a match while ignoring case, add 5000.
5815 * If the match starts in the middle of a word, add 10000 to put it
5816 * somewhere in the last half.
5817 * If the match is more than 2 chars from the start, multiply by 200 to
5818 * put it after matches at the start.
5820 if (ASCII_ISALNUM(matched_string
[offset
]) && offset
> 0
5821 && ASCII_ISALNUM(matched_string
[offset
- 1]))
5823 else if (offset
> 2)
5827 /* Features are less interesting than the subjects themselves, but "+"
5828 * alone is not a feature. */
5829 if (matched_string
[0] == '+' && matched_string
[1] != NUL
)
5831 return (int)(100 * num_letters
+ STRLEN(matched_string
) + offset
);
5835 * Compare functions for qsort() below, that checks the help heuristics number
5836 * that has been put after the tagname by find_tags().
5842 help_compare(s1
, s2
)
5849 p1
= *(char **)s1
+ strlen(*(char **)s1
) + 1;
5850 p2
= *(char **)s2
+ strlen(*(char **)s2
) + 1;
5851 return strcmp(p1
, p2
);
5855 * Find all help tags matching "arg", sort them and return in matches[], with
5856 * the number of matches in num_matches.
5857 * The matches will be sorted with a "best" match algorithm.
5858 * When "keep_lang" is TRUE try keeping the language of the current buffer.
5861 find_help_tags(arg
, num_matches
, matches
, keep_lang
)
5869 static char *(mtable
[]) = {"*", "g*", "[*", "]*", ":*",
5870 "/*", "/\\*", "\"*", "**",
5872 "?", ":?", "?<CR>", "g?", "g?g?", "g??", "z?",
5873 "/\\?", "/\\z(\\)", "\\=", ":s\\=",
5874 "[count]", "[quotex]", "[range]",
5875 "[pattern]", "\\|", "\\%$"};
5876 static char *(rtable
[]) = {"star", "gstar", "[star", "]star", ":star",
5877 "/star", "/\\\\star", "quotestar", "starstar",
5879 "?", ":?", "?<CR>", "g?", "g?g?", "g??", "z?",
5880 "/\\\\?", "/\\\\z(\\\\)", "\\\\=", ":s\\\\=",
5881 "\\[count]", "\\[quotex]", "\\[range]",
5882 "\\[pattern]", "\\\\bar", "/\\\\%\\$"};
5885 d
= IObuff
; /* assume IObuff is long enough! */
5888 * Recognize a few exceptions to the rule. Some strings that contain '*'
5889 * with "star". Otherwise '*' is recognized as a wildcard.
5891 for (i
= (int)(sizeof(mtable
) / sizeof(char *)); --i
>= 0; )
5892 if (STRCMP(arg
, mtable
[i
]) == 0)
5894 STRCPY(d
, rtable
[i
]);
5898 if (i
< 0) /* no match in table */
5900 /* Replace "\S" with "/\\S", etc. Otherwise every tag is matched.
5901 * Also replace "\%^" and "\%(", they match every tag too.
5902 * Also "\zs", "\z1", etc.
5903 * Also "\@<", "\@=", "\@<=", etc.
5904 * And also "\_$" and "\_^". */
5906 && ((arg
[1] != NUL
&& arg
[2] == NUL
)
5907 || (vim_strchr((char_u
*)"%_z@", arg
[1]) != NULL
5911 STRCPY(d
+ 3, arg
+ 1);
5912 /* Check for "/\\_$", should be "/\\_\$" */
5913 if (d
[3] == '_' && d
[4] == '$')
5914 STRCPY(d
+ 4, "\\$");
5918 /* replace "[:...:]" with "\[:...:]"; "[+...]" with "\[++...]" */
5919 if (arg
[0] == '[' && (arg
[1] == ':'
5920 || (arg
[1] == '+' && arg
[2] == '+')))
5923 for (s
= arg
; *s
; ++s
)
5926 * Replace "|" with "bar" and '"' with "quote" to match the name of
5927 * the tags for these commands.
5928 * Replace "*" with ".*" and "?" with "." to match command line
5930 * Insert a backslash before '~', '$' and '.' to avoid their
5933 if (d
- IObuff
> IOSIZE
- 10) /* getting too long!? */
5937 case '|': STRCPY(d
, "bar");
5940 case '"': STRCPY(d
, "quote");
5943 case '*': *d
++ = '.';
5945 case '?': *d
++ = '.';
5949 case '~': *d
++ = '\\';
5954 * Replace "^x" by "CTRL-X". Don't do this for "^_" to make
5955 * ":help i_^_CTRL-D" work.
5956 * Insert '-' before and after "CTRL-X" when applicable.
5958 if (*s
< ' ' || (*s
== '^' && s
[1] && (ASCII_ISALPHA(s
[1])
5959 || vim_strchr((char_u
*)"?@[\\]^", s
[1]) != NULL
)))
5961 if (d
> IObuff
&& d
[-1] != '_')
5962 *d
++ = '_'; /* prepend a '_' */
5968 *d
++ = CtrlChar(*s
);
5973 *d
++ = '\\'; /* double a backslash */
5977 if (s
[1] != NUL
&& s
[1] != '_')
5978 *d
++ = '_'; /* append a '_' */
5981 else if (*s
== '^') /* "^" or "CTRL-^" or "^_" */
5985 * Insert a backslash before a backslash after a slash, for search
5986 * pattern tags: "/\|" --> "/\\|".
5988 else if (s
[0] == '\\' && s
[1] != '\\'
5989 && *arg
== '/' && s
== arg
+ 1)
5992 /* "CTRL-\_" -> "CTRL-\\_" to avoid the special meaning of "\_" in
5993 * "CTRL-\_CTRL-N" */
5994 if (STRNICMP(s
, "CTRL-\\_", 7) == 0)
5996 STRCPY(d
, "CTRL-\\\\");
6004 * If tag starts with ', toss everything after a second '. Fixes
6005 * CTRL-] on 'option'. (would include the trailing '.').
6007 if (*s
== '\'' && s
> arg
&& *arg
== '\'')
6014 *matches
= (char_u
**)"";
6016 flags
= TAG_HELP
| TAG_REGEXP
| TAG_NAMES
| TAG_VERBOSE
| TAG_DONT_USE_TFU
;
6018 flags
|= TAG_KEEP_LANG
;
6019 if (find_tags(IObuff
, num_matches
, matches
, flags
, (int)MAXCOL
, NULL
) == OK
6020 && *num_matches
> 0)
6022 /* Sort the matches found on the heuristic number that is after the
6024 qsort((void *)*matches
, (size_t)*num_matches
,
6025 sizeof(char_u
*), help_compare
);
6026 /* Delete more than TAG_MANY to reduce the size of the listing. */
6027 while (*num_matches
> TAG_MANY
)
6028 vim_free((*matches
)[--*num_matches
]);
6034 * After reading a help file: May cleanup a help buffer when syntax
6035 * highlighting is not used.
6042 int in_example
= FALSE
;
6048 /* set filetype to "help". */
6049 set_option_value((char_u
*)"ft", 0L, (char_u
*)"help", OPT_LOCAL
);
6052 if (!syntax_present(curbuf
))
6055 for (lnum
= 1; lnum
<= curbuf
->b_ml
.ml_line_count
; ++lnum
)
6057 line
= ml_get_buf(curbuf
, lnum
, FALSE
);
6058 len
= (int)STRLEN(line
);
6059 if (in_example
&& len
> 0 && !vim_iswhite(line
[0]))
6061 /* End of example: non-white or '<' in first column. */
6064 /* blank-out a '<' in the first column */
6065 line
= ml_get_buf(curbuf
, lnum
, TRUE
);
6070 if (!in_example
&& len
> 0)
6072 if (line
[len
- 1] == '>' && (len
== 1 || line
[len
- 2] == ' '))
6074 /* blank-out a '>' in the last column (start of example) */
6075 line
= ml_get_buf(curbuf
, lnum
, TRUE
);
6076 line
[len
- 1] = ' ';
6079 else if (line
[len
- 1] == '~')
6081 /* blank-out a '~' at the end of line (header marker) */
6082 line
= ml_get_buf(curbuf
, lnum
, TRUE
);
6083 line
[len
- 1] = ' ';
6090 * In the "help.txt" file, add the locally added help files.
6091 * This uses the very first line in the help file.
6093 if (fnamecmp(gettail(curbuf
->b_fname
), "help.txt") == 0)
6095 for (lnum
= 1; lnum
< curbuf
->b_ml
.ml_line_count
; ++lnum
)
6097 line
= ml_get_buf(curbuf
, lnum
, FALSE
);
6098 if (strstr((char *)line
, "*local-additions*") != NULL
)
6100 /* Go through all directories in 'runtimepath', skipping
6105 copy_option_part(&p
, NameBuff
, MAXPATHL
, ",");
6107 rt
= vim_getenv((char_u
*)"VIMRUNTIME", &mustfree
);
6108 if (fullpathcmp(rt
, NameBuff
, FALSE
) != FPC_SAME
)
6120 /* Find all "doc/ *.txt" files in this directory. */
6121 add_pathsep(NameBuff
);
6122 STRCAT(NameBuff
, "doc/*.txt");
6123 if (gen_expand_wildcards(1, &NameBuff
, &fcount
,
6124 &fnames
, EW_FILE
|EW_SILENT
) == OK
6127 for (fi
= 0; fi
< fcount
; ++fi
)
6129 fd
= mch_fopen((char *)fnames
[fi
], "r");
6132 vim_fgets(IObuff
, IOSIZE
, fd
);
6133 if (IObuff
[0] == '*'
6134 && (s
= vim_strchr(IObuff
+ 1, '*'))
6138 int this_utf
= MAYBE
;
6140 /* Change tag definition to a
6141 * reference and remove <CR>/<NL>. */
6146 if (*s
== '\r' || *s
== '\n')
6149 /* The text is utf-8 when a byte
6150 * above 127 is found and no
6151 * illegal byte sequence is found.
6153 if (*s
>= 0x80 && this_utf
!= FALSE
)
6167 /* The help file is latin1 or utf-8;
6168 * conversion to the current
6169 * 'encoding' may be required. */
6170 vc
.vc_type
= CONV_NONE
;
6171 convert_setup(&vc
, (char_u
*)(
6172 this_utf
== TRUE
? "utf-8"
6173 : "latin1"), p_enc
);
6174 if (vc
.vc_type
== CONV_NONE
)
6175 /* No conversion needed. */
6179 /* Do the conversion. If it fails
6180 * use the unconverted text. */
6181 cp
= string_convert(&vc
, IObuff
,
6186 convert_setup(&vc
, NULL
, NULL
);
6188 ml_append(lnum
, cp
, (colnr_T
)0, FALSE
);
6192 ml_append(lnum
, IObuff
, (colnr_T
)0,
6200 FreeWild(fcount
, fnames
);
6217 exarg_T
*eap UNUSED
;
6219 do_cmdline_cmd((char_u
*)"help ex-cmd-index");
6227 exarg_T
*eap UNUSED
;
6229 do_cmdline_cmd((char_u
*)"help normal-index");
6232 #if defined(FEAT_EX_EXTRA) || defined(PROTO)
6233 static void helptags_one
__ARGS((char_u
*dir
, char_u
*ext
, char_u
*lang
, int add_help_tags
));
6245 #ifdef FEAT_MULTI_LANG
6254 int add_help_tags
= FALSE
;
6256 /* Check for ":helptags ++t {dir}". */
6257 if (STRNCMP(eap
->arg
, "++t", 3) == 0 && vim_iswhite(eap
->arg
[3]))
6259 add_help_tags
= TRUE
;
6260 eap
->arg
= skipwhite(eap
->arg
+ 3);
6264 xpc
.xp_context
= EXPAND_DIRECTORIES
;
6265 dirname
= ExpandOne(&xpc
, eap
->arg
, NULL
,
6266 WILD_LIST_NOTFOUND
|WILD_SILENT
, WILD_EXPAND_FREE
);
6267 if (dirname
== NULL
|| !mch_isdir(dirname
))
6269 EMSG2(_("E150: Not a directory: %s"), eap
->arg
);
6273 #ifdef FEAT_MULTI_LANG
6274 /* Get a list of all files in the directory. */
6275 STRCPY(NameBuff
, dirname
);
6276 add_pathsep(NameBuff
);
6277 STRCAT(NameBuff
, "*");
6278 if (gen_expand_wildcards(1, &NameBuff
, &filecount
, &files
,
6279 EW_FILE
|EW_SILENT
) == FAIL
6282 EMSG2("E151: No match: %s", NameBuff
);
6287 /* Go over all files in the directory to find out what languages are
6289 ga_init2(&ga
, 1, 10);
6290 for (i
= 0; i
< filecount
; ++i
)
6292 len
= (int)STRLEN(files
[i
]);
6295 if (STRICMP(files
[i
] + len
- 4, ".txt") == 0)
6297 /* ".txt" -> language "en" */
6301 else if (files
[i
][len
- 4] == '.'
6302 && ASCII_ISALPHA(files
[i
][len
- 3])
6303 && ASCII_ISALPHA(files
[i
][len
- 2])
6304 && TOLOWER_ASC(files
[i
][len
- 1]) == 'x')
6306 /* ".abx" -> language "ab" */
6307 lang
[0] = TOLOWER_ASC(files
[i
][len
- 3]);
6308 lang
[1] = TOLOWER_ASC(files
[i
][len
- 2]);
6313 /* Did we find this language already? */
6314 for (j
= 0; j
< ga
.ga_len
; j
+= 2)
6315 if (STRNCMP(lang
, ((char_u
*)ga
.ga_data
) + j
, 2) == 0)
6319 /* New language, add it. */
6320 if (ga_grow(&ga
, 2) == FAIL
)
6322 ((char_u
*)ga
.ga_data
)[ga
.ga_len
++] = lang
[0];
6323 ((char_u
*)ga
.ga_data
)[ga
.ga_len
++] = lang
[1];
6329 * Loop over the found languages to generate a tags file for each one.
6331 for (j
= 0; j
< ga
.ga_len
; j
+= 2)
6333 STRCPY(fname
, "tags-xx");
6334 fname
[5] = ((char_u
*)ga
.ga_data
)[j
];
6335 fname
[6] = ((char_u
*)ga
.ga_data
)[j
+ 1];
6336 if (fname
[5] == 'e' && fname
[6] == 'n')
6338 /* English is an exception: use ".txt" and "tags". */
6340 STRCPY(ext
, ".txt");
6344 /* Language "ab" uses ".abx" and "tags-ab". */
6345 STRCPY(ext
, ".xxx");
6349 helptags_one(dirname
, ext
, fname
, add_help_tags
);
6353 FreeWild(filecount
, files
);
6356 /* No language support, just use "*.txt" and "tags". */
6357 helptags_one(dirname
, (char_u
*)".txt", (char_u
*)"tags", add_help_tags
);
6363 helptags_one(dir
, ext
, tagfname
, add_help_tags
)
6364 char_u
*dir
; /* doc directory */
6365 char_u
*ext
; /* suffix, ".txt", ".itx", ".frx", etc. */
6366 char_u
*tagfname
; /* "tags" for English, "tags-fr" for French. */
6367 int add_help_tags
; /* add "help-tags" tag */
6383 int mix
= FALSE
; /* detected mixed encodings */
6387 * Find all *.txt files.
6389 STRCPY(NameBuff
, dir
);
6390 add_pathsep(NameBuff
);
6391 STRCAT(NameBuff
, "*");
6392 STRCAT(NameBuff
, ext
);
6393 if (gen_expand_wildcards(1, &NameBuff
, &filecount
, &files
,
6394 EW_FILE
|EW_SILENT
) == FAIL
6398 EMSG2("E151: No match: %s", NameBuff
);
6403 * Open the tags file for writing.
6404 * Do this before scanning through all the files.
6406 STRCPY(NameBuff
, dir
);
6407 add_pathsep(NameBuff
);
6408 STRCAT(NameBuff
, tagfname
);
6409 fd_tags
= mch_fopen((char *)NameBuff
, "w");
6410 if (fd_tags
== NULL
)
6412 EMSG2(_("E152: Cannot open %s for writing"), NameBuff
);
6413 FreeWild(filecount
, files
);
6418 * If using the "++t" argument or generating tags for "$VIMRUNTIME/doc"
6419 * add the "help-tags" tag.
6421 ga_init2(&ga
, (int)sizeof(char_u
*), 100);
6422 if (add_help_tags
|| fullpathcmp((char_u
*)"$VIMRUNTIME/doc",
6423 dir
, FALSE
) == FPC_SAME
)
6425 if (ga_grow(&ga
, 1) == FAIL
)
6429 s
= alloc(18 + (unsigned)STRLEN(tagfname
));
6434 sprintf((char *)s
, "help-tags\t%s\t1\n", tagfname
);
6435 ((char_u
**)ga
.ga_data
)[ga
.ga_len
] = s
;
6442 * Go over all the files and extract the tags.
6444 for (fi
= 0; fi
< filecount
&& !got_int
; ++fi
)
6446 fd
= mch_fopen((char *)files
[fi
], "r");
6449 EMSG2(_("E153: Unable to open %s for reading"), files
[fi
]);
6452 fname
= gettail(files
[fi
]);
6457 while (!vim_fgets(IObuff
, IOSIZE
, fd
) && !got_int
)
6462 /* Detect utf-8 file by a non-ASCII char in the first line. */
6464 for (s
= IObuff
; *s
!= NUL
; ++s
)
6473 /* Illegal UTF-8 byte sequence. */
6479 if (this_utf8
== MAYBE
) /* only ASCII characters found */
6481 if (utf8
== MAYBE
) /* first file */
6483 else if (utf8
!= this_utf8
)
6485 EMSG2(_("E670: Mix of help file encodings within a language: %s"), files
[fi
]);
6492 p1
= vim_strchr(IObuff
, '*'); /* find first '*' */
6495 p2
= vim_strchr(p1
+ 1, '*'); /* find second '*' */
6496 if (p2
!= NULL
&& p2
> p1
+ 1) /* skip "*" and "**" */
6498 for (s
= p1
+ 1; s
< p2
; ++s
)
6499 if (*s
== ' ' || *s
== '\t' || *s
== '|')
6503 * Only accept a *tag* when it consists of valid
6504 * characters, there is white space before it and is
6505 * followed by a white character or end-of-line.
6508 && (p1
== IObuff
|| p1
[-1] == ' ' || p1
[-1] == '\t')
6509 && (vim_strchr((char_u
*)" \t\n\r", s
[1]) != NULL
6514 if (ga_grow(&ga
, 1) == FAIL
)
6519 s
= alloc((unsigned)(p2
- p1
+ STRLEN(fname
) + 2));
6525 ((char_u
**)ga
.ga_data
)[ga
.ga_len
] = s
;
6527 sprintf((char *)s
, "%s\t%s", p1
, fname
);
6530 p2
= vim_strchr(p2
+ 1, '*');
6541 FreeWild(filecount
, files
);
6548 sort_strings((char_u
**)ga
.ga_data
, ga
.ga_len
);
6551 * Check for duplicates.
6553 for (i
= 1; i
< ga
.ga_len
; ++i
)
6555 p1
= ((char_u
**)ga
.ga_data
)[i
- 1];
6556 p2
= ((char_u
**)ga
.ga_data
)[i
];
6562 vim_snprintf((char *)NameBuff
, MAXPATHL
,
6563 _("E154: Duplicate tag \"%s\" in file %s/%s"),
6564 ((char_u
**)ga
.ga_data
)[i
], dir
, p2
+ 1);
6576 fprintf(fd_tags
, "!_TAG_FILE_ENCODING\tutf-8\t//\n");
6580 * Write the tags into the file.
6582 for (i
= 0; i
< ga
.ga_len
; ++i
)
6584 s
= ((char_u
**)ga
.ga_data
)[i
];
6585 if (STRNCMP(s
, "help-tags\t", 10) == 0)
6586 /* help-tags entry was added in formatted form */
6587 fputs((char *)s
, fd_tags
);
6590 fprintf(fd_tags
, "%s\t/*", s
);
6591 for (p1
= s
; *p1
!= '\t'; ++p1
)
6593 /* insert backslash before '\\' and '/' */
6594 if (*p1
== '\\' || *p1
== '/')
6595 putc('\\', fd_tags
);
6598 fprintf(fd_tags
, "*\n");
6604 got_int
= FALSE
; /* continue with other languages */
6607 for (i
= 0; i
< ga
.ga_len
; ++i
)
6608 vim_free(((char_u
**)ga
.ga_data
)[i
]);
6610 fclose(fd_tags
); /* there is no check for an error... */
6614 #if defined(FEAT_SIGNS) || defined(PROTO)
6617 * Struct to hold the sign properties.
6619 typedef struct sign sign_T
;
6623 sign_T
*sn_next
; /* next sign in list */
6624 int sn_typenr
; /* type number of sign (negative if not equal
6626 char_u
*sn_name
; /* name of sign */
6627 char_u
*sn_icon
; /* name of pixmap */
6628 #ifdef FEAT_SIGN_ICONS
6629 void *sn_image
; /* icon image */
6631 char_u
*sn_text
; /* text used instead of pixmap */
6632 int sn_line_hl
; /* highlight ID for line */
6633 int sn_text_hl
; /* highlight ID for text */
6636 static sign_T
*first_sign
= NULL
;
6637 static int last_sign_typenr
= MAX_TYPENR
; /* is decremented */
6639 static int sign_cmd_idx
__ARGS((char_u
*begin_cmd
, char_u
*end_cmd
));
6640 static void sign_list_defined
__ARGS((sign_T
*sp
));
6641 static void sign_undefine
__ARGS((sign_T
*sp
, sign_T
*sp_prev
));
6643 static char *cmds
[] = {
6645 #define SIGNCMD_DEFINE 0
6647 #define SIGNCMD_UNDEFINE 1
6649 #define SIGNCMD_LIST 2
6651 #define SIGNCMD_PLACE 3
6653 #define SIGNCMD_UNPLACE 4
6655 #define SIGNCMD_JUMP 5
6657 #define SIGNCMD_LAST 6
6661 * Find index of a ":sign" subcmd from its name.
6662 * "*end_cmd" must be writable.
6665 sign_cmd_idx(begin_cmd
, end_cmd
)
6666 char_u
*begin_cmd
; /* begin of sign subcmd */
6667 char_u
*end_cmd
; /* just after sign subcmd */
6670 char save
= *end_cmd
;
6673 for (idx
= 0; ; ++idx
)
6674 if (cmds
[idx
] == NULL
|| STRCMP(begin_cmd
, cmds
[idx
]) == 0)
6687 char_u
*arg
= eap
->arg
;
6694 /* Parse the subcommand. */
6695 p
= skiptowhite(arg
);
6696 idx
= sign_cmd_idx(arg
, p
);
6697 if (idx
== SIGNCMD_LAST
)
6699 EMSG2(_("E160: Unknown sign command: %s"), arg
);
6704 if (idx
<= SIGNCMD_LIST
)
6707 * Define, undefine or list signs.
6709 if (idx
== SIGNCMD_LIST
&& *arg
== NUL
)
6711 /* ":sign list": list all defined signs */
6712 for (sp
= first_sign
; sp
!= NULL
; sp
= sp
->sn_next
)
6713 sign_list_defined(sp
);
6715 else if (*arg
== NUL
)
6716 EMSG(_("E156: Missing sign name"));
6719 p
= skiptowhite(arg
);
6723 for (sp
= first_sign
; sp
!= NULL
; sp
= sp
->sn_next
)
6725 if (STRCMP(sp
->sn_name
, arg
) == 0)
6729 if (idx
== SIGNCMD_DEFINE
)
6731 /* ":sign define {name} ...": define a sign */
6734 /* Allocate a new sign. */
6735 sp
= (sign_T
*)alloc_clear((unsigned)sizeof(sign_T
));
6738 if (sp_prev
== NULL
)
6741 sp_prev
->sn_next
= sp
;
6742 sp
->sn_name
= vim_strnsave(arg
, (int)(p
- arg
));
6744 /* If the name is a number use that for the typenr,
6745 * otherwise use a negative number. */
6746 if (VIM_ISDIGIT(*arg
))
6747 sp
->sn_typenr
= atoi((char *)arg
);
6751 int start
= last_sign_typenr
;
6753 for (lp
= first_sign
; lp
!= NULL
; lp
= lp
->sn_next
)
6755 if (lp
->sn_typenr
== last_sign_typenr
)
6758 if (last_sign_typenr
== 0)
6759 last_sign_typenr
= MAX_TYPENR
;
6760 if (last_sign_typenr
== start
)
6762 EMSG(_("E612: Too many signs defined"));
6770 sp
->sn_typenr
= last_sign_typenr
--;
6771 if (last_sign_typenr
== 0)
6772 last_sign_typenr
= MAX_TYPENR
; /* wrap around */
6776 /* set values for a defined sign. */
6782 p
= skiptowhite_esc(arg
);
6783 if (STRNCMP(arg
, "icon=", 5) == 0)
6786 vim_free(sp
->sn_icon
);
6787 sp
->sn_icon
= vim_strnsave(arg
, (int)(p
- arg
));
6788 backslash_halve(sp
->sn_icon
);
6789 #ifdef FEAT_SIGN_ICONS
6793 if (sp
->sn_image
!= NULL
)
6794 gui_mch_destroy_sign(sp
->sn_image
);
6795 sp
->sn_image
= gui_mch_register_sign(sp
->sn_icon
);
6799 else if (STRNCMP(arg
, "text=", 5) == 0)
6807 /* Count cells and check for non-printable chars */
6811 for (s
= arg
; s
< p
; s
+= (*mb_ptr2len
)(s
))
6813 if (!vim_isprintc((*mb_ptr2char
)(s
)))
6815 cells
+= (*mb_ptr2cells
)(s
);
6821 for (s
= arg
; s
< p
; ++s
)
6822 if (!vim_isprintc(*s
))
6824 cells
= (int)(s
- arg
);
6826 /* Currently must be one or two display cells */
6827 if (s
!= p
|| cells
< 1 || cells
> 2)
6830 EMSG2(_("E239: Invalid sign text: %s"), arg
);
6834 vim_free(sp
->sn_text
);
6835 /* Allocate one byte more if we need to pad up
6837 len
= (int)(p
- arg
+ ((cells
== 1) ? 1 : 0));
6838 sp
->sn_text
= vim_strnsave(arg
, len
);
6840 if (sp
->sn_text
!= NULL
&& cells
== 1)
6841 STRCPY(sp
->sn_text
+ len
- 1, " ");
6843 else if (STRNCMP(arg
, "linehl=", 7) == 0)
6846 sp
->sn_line_hl
= syn_check_group(arg
, (int)(p
- arg
));
6848 else if (STRNCMP(arg
, "texthl=", 7) == 0)
6851 sp
->sn_text_hl
= syn_check_group(arg
, (int)(p
- arg
));
6855 EMSG2(_(e_invarg2
), arg
);
6860 else if (sp
== NULL
)
6861 EMSG2(_("E155: Unknown sign: %s"), arg
);
6862 else if (idx
== SIGNCMD_LIST
)
6863 /* ":sign list {name}" */
6864 sign_list_defined(sp
);
6866 /* ":sign undefine {name}" */
6867 sign_undefine(sp
, sp_prev
);
6874 char_u
*sign_name
= NULL
;
6879 if (idx
== SIGNCMD_PLACE
)
6881 /* ":sign place": list placed signs in all buffers */
6882 sign_list_placed(NULL
);
6884 else if (idx
== SIGNCMD_UNPLACE
)
6886 /* ":sign unplace": remove placed sign at cursor */
6887 id
= buf_findsign_id(curwin
->w_buffer
, curwin
->w_cursor
.lnum
);
6890 buf_delsign(curwin
->w_buffer
, id
);
6891 update_debug_sign(curwin
->w_buffer
, curwin
->w_cursor
.lnum
);
6894 EMSG(_("E159: Missing sign number"));
6901 if (idx
== SIGNCMD_UNPLACE
&& arg
[0] == '*' && arg
[1] == NUL
)
6903 /* ":sign unplace *": remove all placed signs */
6904 buf_delete_all_signs();
6908 /* first arg could be placed sign id */
6910 if (VIM_ISDIGIT(*arg
))
6912 id
= getdigits(&arg
);
6913 if (!vim_iswhite(*arg
) && *arg
!= NUL
)
6920 arg
= skipwhite(arg
);
6921 if (idx
== SIGNCMD_UNPLACE
&& *arg
== NUL
)
6923 /* ":sign unplace {id}": remove placed sign by number */
6924 for (buf
= firstbuf
; buf
!= NULL
; buf
= buf
->b_next
)
6925 if ((lnum
= buf_delsign(buf
, id
)) != 0)
6926 update_debug_sign(buf
, lnum
);
6933 * Check for line={lnum} name={name} and file={fname} or buffer={nr}.
6934 * Leave "arg" pointing to {fname}.
6938 if (STRNCMP(arg
, "line=", 5) == 0)
6941 lnum
= atoi((char *)arg
);
6942 arg
= skiptowhite(arg
);
6944 else if (STRNCMP(arg
, "name=", 5) == 0)
6948 arg
= skiptowhite(arg
);
6952 else if (STRNCMP(arg
, "file=", 5) == 0)
6955 buf
= buflist_findname(arg
);
6958 else if (STRNCMP(arg
, "buffer=", 7) == 0)
6961 buf
= buflist_findnr((int)getdigits(&arg
));
6962 if (*skipwhite(arg
) != NUL
)
6963 EMSG(_(e_trailing
));
6971 arg
= skipwhite(arg
);
6976 EMSG2(_("E158: Invalid buffer name: %s"), arg
);
6980 if (lnum
>= 0 || sign_name
!= NULL
)
6983 /* ":sign place file={fname}": list placed signs in one file */
6984 sign_list_placed(buf
);
6986 else if (idx
== SIGNCMD_JUMP
)
6988 /* ":sign jump {id} file={fname}" */
6989 if (lnum
>= 0 || sign_name
!= NULL
)
6991 else if ((lnum
= buf_findsign(buf
, id
)) > 0)
6992 { /* goto a sign ... */
6993 if (buf_jump_open_win(buf
) != NULL
)
6994 { /* ... in a current window */
6995 curwin
->w_cursor
.lnum
= lnum
;
6996 check_cursor_lnum();
6997 beginline(BL_WHITE
);
7000 { /* ... not currently in a window */
7003 cmd
= alloc((unsigned)STRLEN(buf
->b_fname
) + 25);
7006 sprintf((char *)cmd
, "e +%ld %s", (long)lnum
, buf
->b_fname
);
7007 do_cmdline_cmd(cmd
);
7015 EMSGN(_("E157: Invalid sign ID: %ld"), id
);
7017 else if (idx
== SIGNCMD_UNPLACE
)
7019 /* ":sign unplace {id} file={fname}" */
7020 if (lnum
>= 0 || sign_name
!= NULL
)
7024 lnum
= buf_delsign(buf
, id
);
7025 update_debug_sign(buf
, lnum
);
7028 /* idx == SIGNCMD_PLACE */
7029 else if (sign_name
!= NULL
)
7031 for (sp
= first_sign
; sp
!= NULL
; sp
= sp
->sn_next
)
7032 if (STRCMP(sp
->sn_name
, sign_name
) == 0)
7036 EMSG2(_("E155: Unknown sign: %s"), sign_name
);
7040 /* ":sign place {id} line={lnum} name={name} file={fname}":
7042 buf_addsign(buf
, id
, lnum
, sp
->sn_typenr
);
7044 /* ":sign place {id} file={fname}": change sign type */
7045 lnum
= buf_change_sign_type(buf
, id
, sp
->sn_typenr
);
7046 update_debug_sign(buf
, lnum
);
7053 #if defined(FEAT_SIGN_ICONS) || defined(PROTO)
7055 * Allocate the icons. Called when the GUI has started. Allows defining
7056 * signs before it starts.
7063 for (sp
= first_sign
; sp
!= NULL
; sp
= sp
->sn_next
)
7064 if (sp
->sn_icon
!= NULL
)
7065 sp
->sn_image
= gui_mch_register_sign(sp
->sn_icon
);
7073 sign_list_defined(sp
)
7078 smsg((char_u
*)"sign %s", sp
->sn_name
);
7079 if (sp
->sn_icon
!= NULL
)
7082 msg_outtrans(sp
->sn_icon
);
7083 #ifdef FEAT_SIGN_ICONS
7084 if (sp
->sn_image
== NULL
)
7085 MSG_PUTS(_(" (NOT FOUND)"));
7087 MSG_PUTS(_(" (not supported)"));
7090 if (sp
->sn_text
!= NULL
)
7093 msg_outtrans(sp
->sn_text
);
7095 if (sp
->sn_line_hl
> 0)
7097 MSG_PUTS(" linehl=");
7098 p
= get_highlight_name(NULL
, sp
->sn_line_hl
- 1);
7104 if (sp
->sn_text_hl
> 0)
7106 MSG_PUTS(" texthl=");
7107 p
= get_highlight_name(NULL
, sp
->sn_text_hl
- 1);
7116 * Undefine a sign and free its memory.
7119 sign_undefine(sp
, sp_prev
)
7123 vim_free(sp
->sn_name
);
7124 vim_free(sp
->sn_icon
);
7125 #ifdef FEAT_SIGN_ICONS
7126 if (sp
->sn_image
!= NULL
)
7129 gui_mch_destroy_sign(sp
->sn_image
);
7132 vim_free(sp
->sn_text
);
7133 if (sp_prev
== NULL
)
7134 first_sign
= sp
->sn_next
;
7136 sp_prev
->sn_next
= sp
->sn_next
;
7141 * Get highlighting attribute for sign "typenr".
7142 * If "line" is TRUE: line highl, if FALSE: text highl.
7145 sign_get_attr(typenr
, line
)
7151 for (sp
= first_sign
; sp
!= NULL
; sp
= sp
->sn_next
)
7152 if (sp
->sn_typenr
== typenr
)
7156 if (sp
->sn_line_hl
> 0)
7157 return syn_id2attr(sp
->sn_line_hl
);
7161 if (sp
->sn_text_hl
> 0)
7162 return syn_id2attr(sp
->sn_text_hl
);
7170 * Get text mark for sign "typenr".
7171 * Returns NULL if there isn't one.
7174 sign_get_text(typenr
)
7179 for (sp
= first_sign
; sp
!= NULL
; sp
= sp
->sn_next
)
7180 if (sp
->sn_typenr
== typenr
)
7185 #if defined(FEAT_SIGN_ICONS) || defined(PROTO)
7187 sign_get_image(typenr
)
7188 int typenr
; /* the attribute which may have a sign */
7192 for (sp
= first_sign
; sp
!= NULL
; sp
= sp
->sn_next
)
7193 if (sp
->sn_typenr
== typenr
)
7194 return sp
->sn_image
;
7200 * Get the name of a sign by its typenr.
7203 sign_typenr2name(typenr
)
7208 for (sp
= first_sign
; sp
!= NULL
; sp
= sp
->sn_next
)
7209 if (sp
->sn_typenr
== typenr
)
7211 return (char_u
*)_("[Deleted]");
7214 #if defined(EXITFREE) || defined(PROTO)
7216 * Undefine/free all signs.
7221 while (first_sign
!= NULL
)
7222 sign_undefine(first_sign
, NULL
);
7226 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
7229 EXP_SUBCMD
, /* expand :sign sub-commands */
7230 EXP_DEFINE
, /* expand :sign define {name} args */
7231 EXP_PLACE
, /* expand :sign place {id} args */
7232 EXP_UNPLACE
, /* expand :sign unplace" */
7233 EXP_SIGN_NAMES
/* expand with name of placed signs */
7237 * Function given to ExpandGeneric() to obtain the sign command
7241 get_sign_name(xp
, idx
)
7242 expand_T
*xp UNUSED
;
7248 switch (expand_what
)
7251 return (char_u
*)cmds
[idx
];
7254 char *define_arg
[] =
7256 "icon=", "linehl=", "text=", "texthl=", NULL
7258 return (char_u
*)define_arg
[idx
];
7264 "line=", "name=", "file=", "buffer=", NULL
7266 return (char_u
*)place_arg
[idx
];
7270 char *unplace_arg
[] = { "file=", "buffer=", NULL
};
7271 return (char_u
*)unplace_arg
[idx
];
7273 case EXP_SIGN_NAMES
:
7274 /* Complete with name of signs already defined */
7276 for (sp
= first_sign
; sp
!= NULL
; sp
= sp
->sn_next
)
7277 if (current_idx
++ == idx
)
7286 * Handle command line completion for :sign command.
7289 set_context_in_sign_cmd(xp
, arg
)
7297 char_u
*begin_subcmd_args
;
7299 /* Default: expand subcommands. */
7300 xp
->xp_context
= EXPAND_SIGN
;
7301 expand_what
= EXP_SUBCMD
;
7302 xp
->xp_pattern
= arg
;
7304 end_subcmd
= skiptowhite(arg
);
7305 if (*end_subcmd
== NUL
)
7306 /* expand subcmd name
7307 * :sign {subcmd}<CTRL-D>*/
7310 cmd_idx
= sign_cmd_idx(arg
, end_subcmd
);
7312 /* :sign {subcmd} {subcmd_args}
7314 * begin_subcmd_args */
7315 begin_subcmd_args
= skipwhite(end_subcmd
);
7316 p
= skiptowhite(begin_subcmd_args
);
7320 * Expand first argument of subcmd when possible.
7321 * For ":jump {id}" and ":unplace {id}", we could
7322 * possibly expand the ids of all signs already placed.
7324 xp
->xp_pattern
= begin_subcmd_args
;
7328 case SIGNCMD_UNDEFINE
:
7329 /* :sign list <CTRL-D>
7330 * :sign undefine <CTRL-D> */
7331 expand_what
= EXP_SIGN_NAMES
;
7334 xp
->xp_context
= EXPAND_NOTHING
;
7339 /* expand last argument of subcmd */
7341 /* :sign define {name} {args}...
7345 /* Loop until reaching last argument. */
7351 } while (*p
!= NUL
);
7353 p
= vim_strchr(last
, '=');
7355 /* :sign define {name} {args}... {last}=
7360 /* Expand last argument name (before equal sign). */
7361 xp
->xp_pattern
= last
;
7364 case SIGNCMD_DEFINE
:
7365 expand_what
= EXP_DEFINE
;
7368 expand_what
= EXP_PLACE
;
7371 case SIGNCMD_UNPLACE
:
7372 expand_what
= EXP_UNPLACE
;
7375 xp
->xp_context
= EXPAND_NOTHING
;
7380 /* Expand last argument value (after equal sign). */
7381 xp
->xp_pattern
= p
+ 1;
7384 case SIGNCMD_DEFINE
:
7385 if (STRNCMP(last
, "texthl", p
- last
) == 0 ||
7386 STRNCMP(last
, "linehl", p
- last
) == 0)
7387 xp
->xp_context
= EXPAND_HIGHLIGHT
;
7388 else if (STRNCMP(last
, "icon", p
- last
) == 0)
7389 xp
->xp_context
= EXPAND_FILES
;
7391 xp
->xp_context
= EXPAND_NOTHING
;
7394 if (STRNCMP(last
, "name", p
- last
) == 0)
7395 expand_what
= EXP_SIGN_NAMES
;
7397 xp
->xp_context
= EXPAND_NOTHING
;
7400 xp
->xp_context
= EXPAND_NOTHING
;
7407 #if defined(FEAT_GUI) || defined(FEAT_CLIENTSERVER) || defined(PROTO)
7410 * Opens the first argument in a window. When there are two or more arguments
7411 * the argument list is redefined.
7420 # ifdef FEAT_WINDOWS
7425 * Check if the first argument is already being edited in a window. If
7426 * so, jump to that window.
7427 * We would actually need to check all arguments, but that's complicated
7428 * and mostly only one file is dropped.
7429 * This also ignores wildcards, since it is very unlikely the user is
7430 * editing a file name with a wildcard character.
7432 set_arglist(eap
->arg
);
7435 * Expanding wildcards may result in an empty argument list. E.g. when
7436 * editing "foo.pyc" and ".pyc" is in 'wildignore'. Assume that we
7437 * already did an error message for this.
7442 # ifdef FEAT_WINDOWS
7445 /* ":tab drop file ...": open a tab for each argument that isn't
7446 * edited in a window yet. It's like ":tab all" but without closing
7447 * windows or tabs. */
7453 /* ":drop file ...": Edit the first argument. Jump to an existing
7454 * window if possible, edit in current window if the current buffer
7455 * can be abandoned, otherwise open a new window. */
7456 buf
= buflist_findnr(ARGLIST
[0].ae_fnum
);
7458 FOR_ALL_TAB_WINDOWS(tp
, wp
)
7460 if (wp
->w_buffer
== buf
)
7462 # ifdef FEAT_WINDOWS
7463 goto_tabpage_win(tp
, wp
);
7465 curwin
->w_arg_idx
= 0;
7471 * Check whether the current buffer is changed. If so, we will need
7472 * to split the current window or data could be lost.
7473 * Skip the check if the 'hidden' option is set, as in this case the
7474 * buffer won't be lost.
7478 # ifdef FEAT_WINDOWS
7481 split
= check_changed(curbuf
, TRUE
, FALSE
, FALSE
, FALSE
);
7482 # ifdef FEAT_WINDOWS
7490 /* Fake a ":sfirst" or ":first" command edit the first argument. */
7493 eap
->cmdidx
= CMD_sfirst
;
7497 eap
->cmdidx
= CMD_first
;