blob: fb33971e1b8efca316287aef0de90ac363f85560 [file] [log] [blame]
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001/* vi:set ts=8 sts=4 sw=4 noet:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
9
10/*
11 * change.c: functions related to changing text
12 */
13
14#include "vim.h"
15
16/*
17 * If the file is readonly, give a warning message with the first change.
18 * Don't do this for autocommands.
19 * Doesn't use emsg(), because it flushes the macro buffer.
20 * If we have undone all changes b_changed will be FALSE, but "b_did_warn"
21 * will be TRUE.
22 * "col" is the column for the message; non-zero when in insert mode and
23 * 'showmode' is on.
24 * Careful: may trigger autocommands that reload the buffer.
25 */
26 void
27change_warning(int col)
28{
29 static char *w_readonly = N_("W10: Warning: Changing a readonly file");
30
Yegappan Lakshmanan3f0092c2022-10-16 21:43:07 +010031 if (curbuf->b_did_warn
32 || curbufIsChanged()
33 || autocmd_busy
34 || !curbuf->b_p_ro)
35 return;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +020036
Yegappan Lakshmanan3f0092c2022-10-16 21:43:07 +010037 ++curbuf_lock;
38 apply_autocmds(EVENT_FILECHANGEDRO, NULL, NULL, FALSE, curbuf);
39 --curbuf_lock;
40 if (!curbuf->b_p_ro)
41 return;
42
43 // Do what msg() does, but with a column offset if the warning should
44 // be after the mode message.
45 msg_start();
46 if (msg_row == Rows - 1)
47 msg_col = col;
48 msg_source(HL_ATTR(HLF_W));
49 msg_puts_attr(_(w_readonly), HL_ATTR(HLF_W) | MSG_HIST);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +020050#ifdef FEAT_EVAL
Yegappan Lakshmanan3f0092c2022-10-16 21:43:07 +010051 set_vim_var_string(VV_WARNINGMSG, (char_u *)_(w_readonly), -1);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +020052#endif
Yegappan Lakshmanan3f0092c2022-10-16 21:43:07 +010053 msg_clr_eos();
54 (void)msg_end();
55 if (msg_silent == 0 && !silent_mode
Bram Moolenaar3f86ca02019-05-11 18:30:00 +020056#ifdef FEAT_EVAL
Yegappan Lakshmanan3f0092c2022-10-16 21:43:07 +010057 && time_for_testing != 1
Bram Moolenaar3f86ca02019-05-11 18:30:00 +020058#endif
Yegappan Lakshmanan3f0092c2022-10-16 21:43:07 +010059 )
60 {
61 out_flush();
62 ui_delay(1002L, TRUE); // give the user time to think about it
Bram Moolenaar3f86ca02019-05-11 18:30:00 +020063 }
Yegappan Lakshmanan3f0092c2022-10-16 21:43:07 +010064 curbuf->b_did_warn = TRUE;
65 redraw_cmdline = FALSE; // don't redraw and erase the message
66 if (msg_row < Rows - 1)
67 showmode();
Bram Moolenaar3f86ca02019-05-11 18:30:00 +020068}
69
70/*
71 * Call this function when something in the current buffer is changed.
72 *
73 * Most often called through changed_bytes() and changed_lines(), which also
74 * mark the area of the display to be redrawn.
75 *
76 * Careful: may trigger autocommands that reload the buffer.
77 */
78 void
79changed(void)
80{
81#if defined(FEAT_XIM) && defined(FEAT_GUI_GTK)
82 if (p_imst == IM_ON_THE_SPOT)
83 {
84 // The text of the preediting area is inserted, but this doesn't
85 // mean a change of the buffer yet. That is delayed until the
86 // text is committed. (this means preedit becomes empty)
87 if (im_is_preediting() && !xim_changed_while_preediting)
88 return;
89 xim_changed_while_preediting = FALSE;
90 }
91#endif
92
93 if (!curbuf->b_changed)
94 {
95 int save_msg_scroll = msg_scroll;
96
97 // Give a warning about changing a read-only file. This may also
98 // check-out the file, thus change "curbuf"!
99 change_warning(0);
100
101 // Create a swap file if that is wanted.
102 // Don't do this for "nofile" and "nowrite" buffer types.
Bram Moolenaar6d4b2f52022-08-25 15:11:15 +0100103 if (curbuf->b_may_swap && !bt_dontwrite(curbuf))
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200104 {
105 int save_need_wait_return = need_wait_return;
106
107 need_wait_return = FALSE;
108 ml_open_file(curbuf);
109
110 // The ml_open_file() can cause an ATTENTION message.
111 // Wait two seconds, to make sure the user reads this unexpected
112 // message. Since we could be anywhere, call wait_return() now,
113 // and don't let the emsg() set msg_scroll.
Bram Moolenaar28ee8922020-10-28 20:20:00 +0100114 if (need_wait_return && emsg_silent == 0 && !in_assert_fails)
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200115 {
116 out_flush();
Bram Moolenaareda1da02019-11-17 17:06:33 +0100117 ui_delay(2002L, TRUE);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200118 wait_return(TRUE);
119 msg_scroll = save_msg_scroll;
120 }
121 else
122 need_wait_return = save_need_wait_return;
123 }
124 changed_internal();
125 }
126 ++CHANGEDTICK(curbuf);
127
128#ifdef FEAT_SEARCH_EXTRA
129 // If a pattern is highlighted, the position may now be invalid.
130 highlight_match = FALSE;
131#endif
132}
133
134/*
135 * Internal part of changed(), no user interaction.
136 * Also used for recovery.
137 */
138 void
139changed_internal(void)
140{
141 curbuf->b_changed = TRUE;
142 ml_setflags(curbuf);
143 check_status(curbuf);
144 redraw_tabline = TRUE;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200145 need_maketitle = TRUE; // set window title later
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200146}
147
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200148#ifdef FEAT_EVAL
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200149static long next_listener_id = 0;
150
151/*
Bram Moolenaar4a0a1612019-07-17 22:00:19 +0200152 * Check if the change at "lnum" is above or overlaps with an existing
153 * change. If above then flush changes and invoke listeners.
Bram Moolenaardda41442019-05-16 22:11:47 +0200154 */
Bram Moolenaar55737c22022-02-14 14:51:22 +0000155 static void
Bram Moolenaardda41442019-05-16 22:11:47 +0200156check_recorded_changes(
157 buf_T *buf,
158 linenr_T lnum,
Bram Moolenaardda41442019-05-16 22:11:47 +0200159 linenr_T lnume,
Bram Moolenaar4a0a1612019-07-17 22:00:19 +0200160 long xtra)
Bram Moolenaardda41442019-05-16 22:11:47 +0200161{
Yegappan Lakshmanan3f0092c2022-10-16 21:43:07 +0100162 if (buf->b_recorded_changes == NULL || xtra == 0)
163 return;
Bram Moolenaardda41442019-05-16 22:11:47 +0200164
Yegappan Lakshmanan3f0092c2022-10-16 21:43:07 +0100165 listitem_T *li;
166 linenr_T prev_lnum;
167 linenr_T prev_lnume;
168
169 FOR_ALL_LIST_ITEMS(buf->b_recorded_changes, li)
170 {
171 prev_lnum = (linenr_T)dict_get_number(
172 li->li_tv.vval.v_dict, "lnum");
173 prev_lnume = (linenr_T)dict_get_number(
174 li->li_tv.vval.v_dict, "end");
175 if (prev_lnum >= lnum || prev_lnum > lnume || prev_lnume >= lnum)
Bram Moolenaardda41442019-05-16 22:11:47 +0200176 {
Yegappan Lakshmanan3f0092c2022-10-16 21:43:07 +0100177 // the current change is going to make the line number in
178 // the older change invalid, flush now
179 invoke_listeners(curbuf);
180 break;
Bram Moolenaardda41442019-05-16 22:11:47 +0200181 }
182 }
Bram Moolenaardda41442019-05-16 22:11:47 +0200183}
184
185/*
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200186 * Record a change for listeners added with listener_add().
Bram Moolenaardda41442019-05-16 22:11:47 +0200187 * Always for the current buffer.
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200188 */
189 static void
190may_record_change(
191 linenr_T lnum,
192 colnr_T col,
193 linenr_T lnume,
194 long xtra)
195{
196 dict_T *dict;
197
198 if (curbuf->b_listener == NULL)
199 return;
Bram Moolenaarfe1ade02019-05-14 21:20:36 +0200200
201 // If the new change is going to change the line numbers in already listed
202 // changes, then flush.
Bram Moolenaar55737c22022-02-14 14:51:22 +0000203 check_recorded_changes(curbuf, lnum, lnume, xtra);
Bram Moolenaardda41442019-05-16 22:11:47 +0200204
205 if (curbuf->b_recorded_changes == NULL)
Bram Moolenaarfe1ade02019-05-14 21:20:36 +0200206 {
Bram Moolenaardda41442019-05-16 22:11:47 +0200207 curbuf->b_recorded_changes = list_alloc();
208 if (curbuf->b_recorded_changes == NULL) // out of memory
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200209 return;
Bram Moolenaardda41442019-05-16 22:11:47 +0200210 ++curbuf->b_recorded_changes->lv_refcount;
211 curbuf->b_recorded_changes->lv_lock = VAR_FIXED;
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200212 }
213
214 dict = dict_alloc();
215 if (dict == NULL)
216 return;
217 dict_add_number(dict, "lnum", (varnumber_T)lnum);
218 dict_add_number(dict, "end", (varnumber_T)lnume);
219 dict_add_number(dict, "added", (varnumber_T)xtra);
Bram Moolenaara3347722019-05-11 21:14:24 +0200220 dict_add_number(dict, "col", (varnumber_T)col + 1);
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200221
Bram Moolenaardda41442019-05-16 22:11:47 +0200222 list_append_dict(curbuf->b_recorded_changes, dict);
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200223}
224
225/*
226 * listener_add() function
227 */
228 void
229f_listener_add(typval_T *argvars, typval_T *rettv)
230{
Bram Moolenaar3a97bb32019-06-01 13:28:35 +0200231 callback_T callback;
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200232 listener_T *lnr;
Bram Moolenaara3347722019-05-11 21:14:24 +0200233 buf_T *buf = curbuf;
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200234
Yegappan Lakshmanan5bca9062021-07-24 21:33:26 +0200235 if (in_vim9script() && check_for_opt_buffer_arg(argvars, 1) == FAIL)
236 return;
237
Bram Moolenaar3a97bb32019-06-01 13:28:35 +0200238 callback = get_callback(&argvars[0]);
239 if (callback.cb_name == NULL)
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200240 return;
241
Bram Moolenaara3347722019-05-11 21:14:24 +0200242 if (argvars[1].v_type != VAR_UNKNOWN)
243 {
244 buf = get_buf_arg(&argvars[1]);
245 if (buf == NULL)
Bram Moolenaar3a97bb32019-06-01 13:28:35 +0200246 {
247 free_callback(&callback);
Bram Moolenaara3347722019-05-11 21:14:24 +0200248 return;
Bram Moolenaar3a97bb32019-06-01 13:28:35 +0200249 }
Bram Moolenaara3347722019-05-11 21:14:24 +0200250 }
251
Bram Moolenaarc799fe22019-05-28 23:08:19 +0200252 lnr = ALLOC_CLEAR_ONE(listener_T);
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200253 if (lnr == NULL)
254 {
Bram Moolenaar3a97bb32019-06-01 13:28:35 +0200255 free_callback(&callback);
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200256 return;
257 }
Bram Moolenaara3347722019-05-11 21:14:24 +0200258 lnr->lr_next = buf->b_listener;
259 buf->b_listener = lnr;
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200260
Bram Moolenaar3a97bb32019-06-01 13:28:35 +0200261 set_callback(&lnr->lr_callback, &callback);
Bram Moolenaarc96b7f52022-12-02 15:58:38 +0000262 if (callback.cb_free_name)
263 vim_free(callback.cb_name);
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200264
265 lnr->lr_id = ++next_listener_id;
266 rettv->vval.v_number = lnr->lr_id;
267}
268
269/*
Bram Moolenaarfe1ade02019-05-14 21:20:36 +0200270 * listener_flush() function
271 */
272 void
273f_listener_flush(typval_T *argvars, typval_T *rettv UNUSED)
274{
275 buf_T *buf = curbuf;
276
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +0200277 if (in_vim9script() && check_for_opt_buffer_arg(argvars, 0) == FAIL)
278 return;
279
Bram Moolenaarfe1ade02019-05-14 21:20:36 +0200280 if (argvars[0].v_type != VAR_UNKNOWN)
281 {
282 buf = get_buf_arg(&argvars[0]);
283 if (buf == NULL)
284 return;
285 }
286 invoke_listeners(buf);
287}
288
Bram Moolenaar4b4b1b82021-09-11 15:06:44 +0200289
290 static void
291remove_listener(buf_T *buf, listener_T *lnr, listener_T *prev)
292{
293 if (prev != NULL)
294 prev->lr_next = lnr->lr_next;
295 else
296 buf->b_listener = lnr->lr_next;
297 free_callback(&lnr->lr_callback);
298 vim_free(lnr);
299}
300
Bram Moolenaarfe1ade02019-05-14 21:20:36 +0200301/*
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200302 * listener_remove() function
303 */
304 void
Bram Moolenaar7b73f912019-07-13 13:03:02 +0200305f_listener_remove(typval_T *argvars, typval_T *rettv)
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200306{
307 listener_T *lnr;
308 listener_T *next;
Bram Moolenaar7b73f912019-07-13 13:03:02 +0200309 listener_T *prev;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +0200310 int id;
Bram Moolenaara3347722019-05-11 21:14:24 +0200311 buf_T *buf;
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200312
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +0200313 if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
314 return;
315
316 id = tv_get_number(argvars);
Bram Moolenaar86173482019-10-01 17:02:16 +0200317 FOR_ALL_BUFFERS(buf)
Bram Moolenaar7b73f912019-07-13 13:03:02 +0200318 {
319 prev = NULL;
Bram Moolenaara3347722019-05-11 21:14:24 +0200320 for (lnr = buf->b_listener; lnr != NULL; lnr = next)
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200321 {
Bram Moolenaara3347722019-05-11 21:14:24 +0200322 next = lnr->lr_next;
323 if (lnr->lr_id == id)
324 {
zeertzjqcfe45652022-05-27 17:26:55 +0100325 if (textlock > 0)
Bram Moolenaar4b4b1b82021-09-11 15:06:44 +0200326 {
327 // in invoke_listeners(), clear ID and delete later
328 lnr->lr_id = 0;
329 return;
330 }
331 remove_listener(buf, lnr, prev);
Bram Moolenaar7b73f912019-07-13 13:03:02 +0200332 rettv->vval.v_number = 1;
333 return;
Bram Moolenaara3347722019-05-11 21:14:24 +0200334 }
335 prev = lnr;
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200336 }
Bram Moolenaar7b73f912019-07-13 13:03:02 +0200337 }
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200338}
339
340/*
Bram Moolenaardda41442019-05-16 22:11:47 +0200341 * Called before inserting a line above "lnum"/"lnum3" or deleting line "lnum"
342 * to "lnume".
343 */
344 void
345may_invoke_listeners(buf_T *buf, linenr_T lnum, linenr_T lnume, int added)
346{
Bram Moolenaar4a0a1612019-07-17 22:00:19 +0200347 check_recorded_changes(buf, lnum, lnume, added);
Bram Moolenaardda41442019-05-16 22:11:47 +0200348}
349
350/*
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200351 * Called when a sequence of changes is done: invoke listeners added with
352 * listener_add().
353 */
354 void
Bram Moolenaarfe1ade02019-05-14 21:20:36 +0200355invoke_listeners(buf_T *buf)
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200356{
357 listener_T *lnr;
358 typval_T rettv;
Bram Moolenaarfe1ade02019-05-14 21:20:36 +0200359 typval_T argv[6];
360 listitem_T *li;
361 linenr_T start = MAXLNUM;
362 linenr_T end = 0;
363 linenr_T added = 0;
Bram Moolenaar68a4b042019-05-29 22:28:29 +0200364 int save_updating_screen = updating_screen;
365 static int recursive = FALSE;
Bram Moolenaar4b4b1b82021-09-11 15:06:44 +0200366 listener_T *next;
Yegappan Lakshmanan956be462022-09-02 17:12:07 +0100367 listener_T *prev;
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200368
Bram Moolenaardda41442019-05-16 22:11:47 +0200369 if (buf->b_recorded_changes == NULL // nothing changed
Bram Moolenaar68a4b042019-05-29 22:28:29 +0200370 || buf->b_listener == NULL // no listeners
371 || recursive) // already busy
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200372 return;
Bram Moolenaar68a4b042019-05-29 22:28:29 +0200373 recursive = TRUE;
374
375 // Block messages on channels from being handled, so that they don't make
376 // text changes here.
377 ++updating_screen;
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200378
Bram Moolenaarfe1ade02019-05-14 21:20:36 +0200379 argv[0].v_type = VAR_NUMBER;
380 argv[0].vval.v_number = buf->b_fnum; // a:bufnr
381
Bram Moolenaaraeea7212020-04-02 18:50:46 +0200382 FOR_ALL_LIST_ITEMS(buf->b_recorded_changes, li)
Bram Moolenaarfe1ade02019-05-14 21:20:36 +0200383 {
384 varnumber_T lnum;
385
Bram Moolenaard61efa52022-07-23 09:52:04 +0100386 lnum = dict_get_number(li->li_tv.vval.v_dict, "lnum");
Bram Moolenaarfe1ade02019-05-14 21:20:36 +0200387 if (start > lnum)
388 start = lnum;
Bram Moolenaard61efa52022-07-23 09:52:04 +0100389 lnum = dict_get_number(li->li_tv.vval.v_dict, "end");
Bram Moolenaar336bf2b2019-10-24 20:07:07 +0200390 if (end < lnum)
Bram Moolenaarfe1ade02019-05-14 21:20:36 +0200391 end = lnum;
Bram Moolenaard61efa52022-07-23 09:52:04 +0100392 added += dict_get_number(li->li_tv.vval.v_dict, "added");
Bram Moolenaarfe1ade02019-05-14 21:20:36 +0200393 }
394 argv[1].v_type = VAR_NUMBER;
395 argv[1].vval.v_number = start;
396 argv[2].v_type = VAR_NUMBER;
397 argv[2].vval.v_number = end;
398 argv[3].v_type = VAR_NUMBER;
399 argv[3].vval.v_number = added;
400
401 argv[4].v_type = VAR_LIST;
Bram Moolenaardda41442019-05-16 22:11:47 +0200402 argv[4].vval.v_list = buf->b_recorded_changes;
zeertzjqcfe45652022-05-27 17:26:55 +0100403 ++textlock;
Bram Moolenaarfe1ade02019-05-14 21:20:36 +0200404
405 for (lnr = buf->b_listener; lnr != NULL; lnr = lnr->lr_next)
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200406 {
Bram Moolenaarc6538bc2019-08-03 18:17:11 +0200407 call_callback(&lnr->lr_callback, -1, &rettv, 5, argv);
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200408 clear_tv(&rettv);
409 }
410
Bram Moolenaar4b4b1b82021-09-11 15:06:44 +0200411 // If f_listener_remove() was called may have to remove a listener now.
Yegappan Lakshmanan956be462022-09-02 17:12:07 +0100412 prev = NULL;
Bram Moolenaar4b4b1b82021-09-11 15:06:44 +0200413 for (lnr = buf->b_listener; lnr != NULL; lnr = next)
414 {
Bram Moolenaar4b4b1b82021-09-11 15:06:44 +0200415 next = lnr->lr_next;
416 if (lnr->lr_id == 0)
417 remove_listener(buf, lnr, prev);
418 else
419 prev = lnr;
420 }
421
zeertzjqcfe45652022-05-27 17:26:55 +0100422 --textlock;
Bram Moolenaardda41442019-05-16 22:11:47 +0200423 list_unref(buf->b_recorded_changes);
424 buf->b_recorded_changes = NULL;
Bram Moolenaar68a4b042019-05-29 22:28:29 +0200425
426 if (save_updating_screen)
427 updating_screen = TRUE;
428 else
429 after_updating_screen(TRUE);
430 recursive = FALSE;
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200431}
Bram Moolenaar86173482019-10-01 17:02:16 +0200432
433/*
434 * Remove all listeners associated with "buf".
435 */
436 void
437remove_listeners(buf_T *buf)
438{
439 listener_T *lnr;
440 listener_T *next;
441
442 for (lnr = buf->b_listener; lnr != NULL; lnr = next)
443 {
444 next = lnr->lr_next;
445 free_callback(&lnr->lr_callback);
446 vim_free(lnr);
447 }
448 buf->b_listener = NULL;
449}
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200450#endif
451
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200452/*
453 * Common code for when a change was made.
454 * See changed_lines() for the arguments.
455 * Careful: may trigger autocommands that reload the buffer.
456 */
457 static void
458changed_common(
459 linenr_T lnum,
460 colnr_T col,
461 linenr_T lnume,
462 long xtra)
463{
464 win_T *wp;
465 tabpage_T *tp;
466 int i;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200467 int cols;
468 pos_T *p;
469 int add;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200470
471 // mark the buffer as modified
472 changed();
473
Bram Moolenaar6d2399b2019-05-11 19:14:16 +0200474#ifdef FEAT_EVAL
475 may_record_change(lnum, col, lnume, xtra);
476#endif
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200477#ifdef FEAT_DIFF
478 if (curwin->w_p_diff && diff_internal())
479 curtab->tp_diff_update = TRUE;
480#endif
481
482 // set the '. mark
Bram Moolenaare1004402020-10-24 20:49:43 +0200483 if ((cmdmod.cmod_flags & CMOD_KEEPJUMPS) == 0)
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200484 {
485 curbuf->b_last_change.lnum = lnum;
486 curbuf->b_last_change.col = col;
487
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200488 // Create a new entry if a new undo-able change was started or we
489 // don't have an entry yet.
490 if (curbuf->b_new_change || curbuf->b_changelistlen == 0)
491 {
492 if (curbuf->b_changelistlen == 0)
493 add = TRUE;
494 else
495 {
496 // Don't create a new entry when the line number is the same
497 // as the last one and the column is not too far away. Avoids
498 // creating many entries for typing "xxxxx".
499 p = &curbuf->b_changelist[curbuf->b_changelistlen - 1];
500 if (p->lnum != lnum)
501 add = TRUE;
502 else
503 {
504 cols = comp_textwidth(FALSE);
505 if (cols == 0)
506 cols = 79;
507 add = (p->col + cols < col || col + cols < p->col);
508 }
509 }
510 if (add)
511 {
512 // This is the first of a new sequence of undo-able changes
513 // and it's at some distance of the last change. Use a new
514 // position in the changelist.
515 curbuf->b_new_change = FALSE;
516
517 if (curbuf->b_changelistlen == JUMPLISTSIZE)
518 {
519 // changelist is full: remove oldest entry
520 curbuf->b_changelistlen = JUMPLISTSIZE - 1;
521 mch_memmove(curbuf->b_changelist, curbuf->b_changelist + 1,
522 sizeof(pos_T) * (JUMPLISTSIZE - 1));
523 FOR_ALL_TAB_WINDOWS(tp, wp)
524 {
525 // Correct position in changelist for other windows on
526 // this buffer.
527 if (wp->w_buffer == curbuf && wp->w_changelistidx > 0)
528 --wp->w_changelistidx;
529 }
530 }
531 FOR_ALL_TAB_WINDOWS(tp, wp)
532 {
533 // For other windows, if the position in the changelist is
534 // at the end it stays at the end.
535 if (wp->w_buffer == curbuf
536 && wp->w_changelistidx == curbuf->b_changelistlen)
537 ++wp->w_changelistidx;
538 }
539 ++curbuf->b_changelistlen;
540 }
541 }
542 curbuf->b_changelist[curbuf->b_changelistlen - 1] =
543 curbuf->b_last_change;
544 // The current window is always after the last change, so that "g,"
545 // takes you back to it.
546 curwin->w_changelistidx = curbuf->b_changelistlen;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200547 }
548
Bram Moolenaar7ce5b2b2022-05-16 19:40:59 +0100549 if (VIsual_active)
550 check_visual_pos();
551
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200552 FOR_ALL_TAB_WINDOWS(tp, wp)
553 {
554 if (wp->w_buffer == curbuf)
555 {
Bram Moolenaar94377372022-02-16 20:30:52 +0000556 linenr_T last = lnume + xtra - 1; // last line after the change
Luuk van Baal5d01f862023-05-11 19:24:20 +0100557
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200558 // Mark this window to be redrawn later.
Bram Moolenaar471c0fa2022-08-22 15:19:16 +0100559 if (!redraw_not_allowed && wp->w_redr_type < UPD_VALID)
Bram Moolenaara4d158b2022-08-14 14:17:45 +0100560 wp->w_redr_type = UPD_VALID;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200561
zeertzjqf2d90a32024-02-12 20:28:01 +0100562 // When inserting/deleting lines and the window has specific lines
563 // to be redrawn, w_redraw_top and w_redraw_bot may now be invalid,
564 // so just redraw everything.
565 if (xtra != 0 && wp->w_redraw_top != 0)
566 redraw_win_later(wp, UPD_NOT_VALID);
567
Luuk van Baal5d01f862023-05-11 19:24:20 +0100568 // Reset "w_skipcol" if the topline length has become smaller to
569 // such a degree that nothing will be visible anymore, accounting
570 // for 'smoothscroll' <<< or 'listchars' "precedes" marker.
571 if (wp->w_skipcol > 0
572 && (last < wp->w_topline
573 || (wp->w_topline >= lnum
574 && wp->w_topline < lnume
zeertzjq2c47ab82025-02-13 20:34:34 +0100575 && linetabsize_eol(wp, wp->w_topline)
Luuk van Baalcb204e62024-04-02 20:49:45 +0200576 <= wp->w_skipcol + sms_marker_overlap(wp, -1))))
Luuk van Baal5d01f862023-05-11 19:24:20 +0100577 wp->w_skipcol = 0;
578
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200579 // Check if a change in the buffer has invalidated the cached
580 // values for the cursor.
581#ifdef FEAT_FOLDING
582 // Update the folds for this window. Can't postpone this, because
583 // a following operator might work on the whole fold: ">>dd".
Bram Moolenaar94377372022-02-16 20:30:52 +0000584 foldUpdate(wp, lnum, last);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200585
586 // The change may cause lines above or below the change to become
587 // included in a fold. Set lnum/lnume to the first/last line that
588 // might be displayed differently.
589 // Set w_cline_folded here as an efficient way to update it when
590 // inserting lines just above a closed fold.
591 i = hasFoldingWin(wp, lnum, &lnum, NULL, FALSE, NULL);
592 if (wp->w_cursor.lnum == lnum)
593 wp->w_cline_folded = i;
Bram Moolenaar94377372022-02-16 20:30:52 +0000594 i = hasFoldingWin(wp, last, NULL, &last, FALSE, NULL);
595 if (wp->w_cursor.lnum == last)
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200596 wp->w_cline_folded = i;
597
598 // If the changed line is in a range of previously folded lines,
599 // compare with the first line in that range.
600 if (wp->w_cursor.lnum <= lnum)
601 {
602 i = find_wl_entry(wp, lnum);
603 if (i >= 0 && wp->w_cursor.lnum > wp->w_lines[i].wl_lnum)
604 changed_line_abv_curs_win(wp);
605 }
606#endif
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200607 if (wp->w_cursor.lnum > lnum)
608 changed_line_abv_curs_win(wp);
609 else if (wp->w_cursor.lnum == lnum && wp->w_cursor.col >= col)
610 changed_cline_bef_curs_win(wp);
611 if (wp->w_botline >= lnum)
612 {
Bram Moolenaar5bea41d2021-07-13 22:21:44 +0200613 if (xtra < 0)
614 invalidate_botline_win(wp);
615 else
616 // Assume that botline doesn't change (inserted lines make
617 // other lines scroll down below botline).
618 approximate_botline_win(wp);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200619 }
620
621 // Check if any w_lines[] entries have become invalid.
622 // For entries below the change: Correct the lnums for
623 // inserted/deleted lines. Makes it possible to stop displaying
624 // after the change.
625 for (i = 0; i < wp->w_lines_valid; ++i)
626 if (wp->w_lines[i].wl_valid)
627 {
628 if (wp->w_lines[i].wl_lnum >= lnum)
629 {
Bram Moolenaar61fdbfa2023-02-04 13:57:55 +0000630 // Do not change wl_lnum at index zero, it is used to
631 // compare with w_topline. Invalidate it instead.
632 if (wp->w_lines[i].wl_lnum < lnume || i == 0)
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200633 {
634 // line included in change
635 wp->w_lines[i].wl_valid = FALSE;
636 }
637 else if (xtra != 0)
638 {
639 // line below change
640 wp->w_lines[i].wl_lnum += xtra;
641#ifdef FEAT_FOLDING
642 wp->w_lines[i].wl_lastlnum += xtra;
643#endif
644 }
645 }
646#ifdef FEAT_FOLDING
647 else if (wp->w_lines[i].wl_lastlnum >= lnum)
648 {
649 // change somewhere inside this range of folded lines,
650 // may need to be redrawn
651 wp->w_lines[i].wl_valid = FALSE;
652 }
653#endif
654 }
655
656#ifdef FEAT_FOLDING
657 // Take care of side effects for setting w_topline when folds have
658 // changed. Esp. when the buffer was changed in another window.
659 if (hasAnyFolding(wp))
660 set_topline(wp, wp->w_topline);
661#endif
zeertzjq8c979602022-04-07 15:08:01 +0100662 // If lines have been added or removed, relative numbering always
zeertzjq7ce34c92024-02-08 11:34:55 +0100663 // requires an update even if cursor didn't move.
Lewis Russell16246392022-03-29 11:38:17 +0100664 if (wp->w_p_rnu && xtra != 0)
zeertzjq8c979602022-04-07 15:08:01 +0100665 wp->w_last_cursor_lnum_rnu = 0;
zeertzjq7ce34c92024-02-08 11:34:55 +0100666
Bram Moolenaar11a58af2019-10-24 22:32:31 +0200667#ifdef FEAT_SYN_HL
zeertzjq7ce34c92024-02-08 11:34:55 +0100668 if (wp->w_p_cul && wp->w_last_cursorline >= lnum)
Bram Moolenaar11a58af2019-10-24 22:32:31 +0200669 {
zeertzjq7ce34c92024-02-08 11:34:55 +0100670 if (wp->w_last_cursorline < lnume)
671 // If 'cursorline' was inside the change, it has already
672 // been invalidated in w_lines[] by the loop above.
673 wp->w_last_cursorline = 0;
674 else
675 // If 'cursorline' was below the change, adjust its lnum.
676 wp->w_last_cursorline += xtra;
Bram Moolenaar11a58af2019-10-24 22:32:31 +0200677 }
678#endif
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200679 }
Bram Moolenaar368137a2022-05-31 13:43:12 +0100680#ifdef FEAT_SEARCH_EXTRA
681 if (wp == curwin && xtra != 0 && search_hl_has_cursor_lnum >= lnum)
682 search_hl_has_cursor_lnum += xtra;
683#endif
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200684 }
685
686 // Call update_screen() later, which checks out what needs to be redrawn,
687 // since it notices b_mod_set and then uses b_mod_*.
Bram Moolenaar471c0fa2022-08-22 15:19:16 +0100688 set_must_redraw(UPD_VALID);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200689
690 // when the cursor line is changed always trigger CursorMoved
691 if (lnum <= curwin->w_cursor.lnum
692 && lnume + (xtra < 0 ? -xtra : xtra) > curwin->w_cursor.lnum)
693 last_cursormoved.lnum = 0;
694}
695
696 static void
697changedOneline(buf_T *buf, linenr_T lnum)
698{
699 if (buf->b_mod_set)
700 {
701 // find the maximum area that must be redisplayed
702 if (lnum < buf->b_mod_top)
703 buf->b_mod_top = lnum;
704 else if (lnum >= buf->b_mod_bot)
705 buf->b_mod_bot = lnum + 1;
706 }
707 else
708 {
709 // set the area that must be redisplayed to one line
710 buf->b_mod_set = TRUE;
711 buf->b_mod_top = lnum;
712 buf->b_mod_bot = lnum + 1;
713 buf->b_mod_xlines = 0;
714 }
715}
716
717/*
718 * Changed bytes within a single line for the current buffer.
719 * - marks the windows on this buffer to be redisplayed
720 * - marks the buffer changed by calling changed()
721 * - invalidates cached values
722 * Careful: may trigger autocommands that reload the buffer.
723 */
724 void
725changed_bytes(linenr_T lnum, colnr_T col)
726{
727 changedOneline(curbuf, lnum);
728 changed_common(lnum, col, lnum + 1, 0L);
729
Bram Moolenaar26f09ea2022-09-27 16:29:38 +0100730#ifdef FEAT_SPELL
731 // When text has been changed at the end of the line, possibly the start of
732 // the next line may have SpellCap that should be removed or it needs to be
733 // displayed. Schedule the next line for redrawing just in case.
Bram Moolenaarf3ef0262022-10-05 13:29:15 +0100734 // Don't do this when displaying '$' at the end of changed text.
735 if (spell_check_window(curwin)
736 && lnum < curbuf->b_ml.ml_line_count
737 && vim_strchr(p_cpo, CPO_DOLLAR) == NULL)
Bram Moolenaar26f09ea2022-09-27 16:29:38 +0100738 redrawWinline(curwin, lnum + 1);
739#endif
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200740#ifdef FEAT_DIFF
741 // Diff highlighting in other diff windows may need to be updated too.
742 if (curwin->w_p_diff)
743 {
744 win_T *wp;
745 linenr_T wlnum;
746
747 FOR_ALL_WINDOWS(wp)
748 if (wp->w_p_diff && wp != curwin)
749 {
Bram Moolenaara4d158b2022-08-14 14:17:45 +0100750 redraw_win_later(wp, UPD_VALID);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200751 wlnum = diff_lnum_win(lnum, wp);
752 if (wlnum > 0)
753 changedOneline(wp->w_buffer, wlnum);
754 }
755 }
756#endif
757}
758
759/*
760 * Like changed_bytes() but also adjust text properties for "added" bytes.
761 * When "added" is negative text was deleted.
762 */
Bram Moolenaar8b51b7f2020-09-15 21:34:18 +0200763 void
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200764inserted_bytes(linenr_T lnum, colnr_T col, int added UNUSED)
765{
Bram Moolenaar05ad5ff2019-11-30 22:48:27 +0100766#ifdef FEAT_PROP_POPUP
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200767 if (curbuf->b_has_textprop && added != 0)
Bram Moolenaarf3333b02019-05-19 22:53:40 +0200768 adjust_prop_columns(lnum, col, added, 0);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200769#endif
Bram Moolenaar45dd07f2019-05-15 22:45:37 +0200770
771 changed_bytes(lnum, col);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200772}
773
774/*
775 * Appended "count" lines below line "lnum" in the current buffer.
776 * Must be called AFTER the change and after mark_adjust().
777 * Takes care of marking the buffer to be redrawn and sets the changed flag.
778 */
779 void
780appended_lines(linenr_T lnum, long count)
781{
782 changed_lines(lnum + 1, 0, lnum + 1, count);
783}
784
785/*
786 * Like appended_lines(), but adjust marks first.
787 */
788 void
789appended_lines_mark(linenr_T lnum, long count)
790{
Brandon Simmonsda3dd7d2023-01-17 19:48:07 +0000791 mark_adjust(lnum + 1, (linenr_T)MAXLNUM, count, 0L);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200792 changed_lines(lnum + 1, 0, lnum + 1, count);
793}
794
795/*
796 * Deleted "count" lines at line "lnum" in the current buffer.
797 * Must be called AFTER the change and after mark_adjust().
798 * Takes care of marking the buffer to be redrawn and sets the changed flag.
799 */
800 void
801deleted_lines(linenr_T lnum, long count)
802{
803 changed_lines(lnum, 0, lnum + count, -count);
804}
805
806/*
807 * Like deleted_lines(), but adjust marks first.
808 * Make sure the cursor is on a valid line before calling, a GUI callback may
809 * be triggered to display the cursor.
810 */
811 void
812deleted_lines_mark(linenr_T lnum, long count)
813{
814 mark_adjust(lnum, (linenr_T)(lnum + count - 1), (long)MAXLNUM, -count);
815 changed_lines(lnum, 0, lnum + count, -count);
816}
817
818/*
819 * Marks the area to be redrawn after a change.
Bram Moolenaar326c5d32022-08-12 13:05:49 +0100820 * Consider also calling changed_line_display_buf().
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200821 */
Bram Moolenaar1764faa2021-05-16 20:18:57 +0200822 void
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200823changed_lines_buf(
824 buf_T *buf,
825 linenr_T lnum, // first line with change
826 linenr_T lnume, // line below last changed line
827 long xtra) // number of extra lines (negative when deleting)
828{
829 if (buf->b_mod_set)
830 {
831 // find the maximum area that must be redisplayed
832 if (lnum < buf->b_mod_top)
833 buf->b_mod_top = lnum;
834 if (lnum < buf->b_mod_bot)
835 {
836 // adjust old bot position for xtra lines
837 buf->b_mod_bot += xtra;
838 if (buf->b_mod_bot < lnum)
839 buf->b_mod_bot = lnum;
840 }
841 if (lnume + xtra > buf->b_mod_bot)
842 buf->b_mod_bot = lnume + xtra;
843 buf->b_mod_xlines += xtra;
844 }
845 else
846 {
847 // set the area that must be redisplayed
848 buf->b_mod_set = TRUE;
849 buf->b_mod_top = lnum;
850 buf->b_mod_bot = lnume + xtra;
851 buf->b_mod_xlines = xtra;
852 }
853}
854
855/*
856 * Changed lines for the current buffer.
857 * Must be called AFTER the change and after mark_adjust().
858 * - mark the buffer changed by calling changed()
859 * - mark the windows on this buffer to be redisplayed
860 * - invalidate cached values
861 * "lnum" is the first line that needs displaying, "lnume" the first line
862 * below the changed lines (BEFORE the change).
863 * When only inserting lines, "lnum" and "lnume" are equal.
864 * Takes care of calling changed() and updating b_mod_*.
865 * Careful: may trigger autocommands that reload the buffer.
866 */
867 void
868changed_lines(
869 linenr_T lnum, // first line with change
870 colnr_T col, // column in first line with change
871 linenr_T lnume, // line below last changed line
872 long xtra) // number of extra lines (negative when deleting)
873{
874 changed_lines_buf(curbuf, lnum, lnume, xtra);
875
876#ifdef FEAT_DIFF
877 if (xtra == 0 && curwin->w_p_diff && !diff_internal())
878 {
879 // When the number of lines doesn't change then mark_adjust() isn't
880 // called and other diff buffers still need to be marked for
881 // displaying.
882 win_T *wp;
883 linenr_T wlnum;
884
885 FOR_ALL_WINDOWS(wp)
886 if (wp->w_p_diff && wp != curwin)
887 {
Bram Moolenaara4d158b2022-08-14 14:17:45 +0100888 redraw_win_later(wp, UPD_VALID);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200889 wlnum = diff_lnum_win(lnum, wp);
890 if (wlnum > 0)
891 changed_lines_buf(wp->w_buffer, wlnum,
892 lnume - lnum + wlnum, 0L);
893 }
894 }
895#endif
896
897 changed_common(lnum, col, lnume, xtra);
898}
899
900/*
901 * Called when the changed flag must be reset for buffer "buf".
902 * When "ff" is TRUE also reset 'fileformat'.
Bram Moolenaarc024b462019-06-08 18:07:21 +0200903 * When "always_inc_changedtick" is TRUE b:changedtick is incremented also when
904 * the changed flag was off.
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200905 */
906 void
Bram Moolenaarc024b462019-06-08 18:07:21 +0200907unchanged(buf_T *buf, int ff, int always_inc_changedtick)
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200908{
909 if (buf->b_changed || (ff && file_ff_differs(buf, FALSE)))
910 {
911 buf->b_changed = 0;
912 ml_setflags(buf);
913 if (ff)
914 save_file_ff(buf);
915 check_status(buf);
916 redraw_tabline = TRUE;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200917 need_maketitle = TRUE; // set window title later
Bram Moolenaarc024b462019-06-08 18:07:21 +0200918 ++CHANGEDTICK(buf);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200919 }
Bram Moolenaarc024b462019-06-08 18:07:21 +0200920 else if (always_inc_changedtick)
921 ++CHANGEDTICK(buf);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200922#ifdef FEAT_NETBEANS_INTG
923 netbeans_unmodified(buf);
924#endif
925}
926
927/*
Bram Moolenaar7bae0b12019-11-21 22:14:18 +0100928 * Save the current values of 'fileformat' and 'fileencoding', so that we know
929 * the file must be considered changed when the value is different.
930 */
931 void
932save_file_ff(buf_T *buf)
933{
934 buf->b_start_ffc = *buf->b_p_ff;
Bram Moolenaar15775372022-10-29 20:01:52 +0100935 buf->b_start_eof = buf->b_p_eof;
Bram Moolenaar7bae0b12019-11-21 22:14:18 +0100936 buf->b_start_eol = buf->b_p_eol;
937 buf->b_start_bomb = buf->b_p_bomb;
938
Bram Moolenaarc667da52019-11-30 20:52:27 +0100939 // Only use free/alloc when necessary, they take time.
Bram Moolenaar7bae0b12019-11-21 22:14:18 +0100940 if (buf->b_start_fenc == NULL
941 || STRCMP(buf->b_start_fenc, buf->b_p_fenc) != 0)
942 {
943 vim_free(buf->b_start_fenc);
944 buf->b_start_fenc = vim_strsave(buf->b_p_fenc);
945 }
946}
947
948/*
949 * Return TRUE if 'fileformat' and/or 'fileencoding' has a different value
950 * from when editing started (save_file_ff() called).
951 * Also when 'endofline' was changed and 'binary' is set, or when 'bomb' was
952 * changed and 'binary' is not set.
953 * Also when 'endofline' was changed and 'fixeol' is not set.
954 * When "ignore_empty" is true don't consider a new, empty buffer to be
955 * changed.
956 */
957 int
958file_ff_differs(buf_T *buf, int ignore_empty)
959{
Bram Moolenaarc667da52019-11-30 20:52:27 +0100960 // In a buffer that was never loaded the options are not valid.
Bram Moolenaar7bae0b12019-11-21 22:14:18 +0100961 if (buf->b_flags & BF_NEVERLOADED)
962 return FALSE;
963 if (ignore_empty
964 && (buf->b_flags & BF_NEW)
965 && buf->b_ml.ml_line_count == 1
966 && *ml_get_buf(buf, (linenr_T)1, FALSE) == NUL)
967 return FALSE;
968 if (buf->b_start_ffc != *buf->b_p_ff)
969 return TRUE;
Bram Moolenaar15775372022-10-29 20:01:52 +0100970 if ((buf->b_p_bin || !buf->b_p_fixeol)
971 && (buf->b_start_eof != buf->b_p_eof
972 || buf->b_start_eol != buf->b_p_eol))
Bram Moolenaar7bae0b12019-11-21 22:14:18 +0100973 return TRUE;
974 if (!buf->b_p_bin && buf->b_start_bomb != buf->b_p_bomb)
975 return TRUE;
976 if (buf->b_start_fenc == NULL)
977 return (*buf->b_p_fenc != NUL);
978 return (STRCMP(buf->b_start_fenc, buf->b_p_fenc) != 0);
979}
980
981/*
Bram Moolenaar3f86ca02019-05-11 18:30:00 +0200982 * Insert string "p" at the cursor position. Stops at a NUL byte.
983 * Handles Replace mode and multi-byte characters.
984 */
985 void
986ins_bytes(char_u *p)
987{
988 ins_bytes_len(p, (int)STRLEN(p));
989}
990
991/*
992 * Insert string "p" with length "len" at the cursor position.
993 * Handles Replace mode and multi-byte characters.
994 */
995 void
996ins_bytes_len(char_u *p, int len)
997{
998 int i;
999 int n;
1000
1001 if (has_mbyte)
1002 for (i = 0; i < len; i += n)
1003 {
1004 if (enc_utf8)
1005 // avoid reading past p[len]
1006 n = utfc_ptr2len_len(p + i, len - i);
1007 else
1008 n = (*mb_ptr2len)(p + i);
1009 ins_char_bytes(p + i, n);
1010 }
1011 else
1012 for (i = 0; i < len; ++i)
1013 ins_char(p[i]);
1014}
1015
1016/*
1017 * Insert or replace a single character at the cursor position.
Bram Moolenaar24959102022-05-07 20:01:16 +01001018 * When in MODE_REPLACE or MODE_VREPLACE state, replace any existing character.
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001019 * Caller must have prepared for undo.
1020 * For multi-byte characters we get the whole character, the caller must
1021 * convert bytes to a character.
1022 */
1023 void
1024ins_char(int c)
1025{
1026 char_u buf[MB_MAXBYTES + 1];
1027 int n = (*mb_char2bytes)(c, buf);
1028
1029 // When "c" is 0x100, 0x200, etc. we don't want to insert a NUL byte.
1030 // Happens for CTRL-Vu9900.
1031 if (buf[0] == 0)
1032 buf[0] = '\n';
1033
1034 ins_char_bytes(buf, n);
1035}
1036
1037 void
1038ins_char_bytes(char_u *buf, int charlen)
1039{
1040 int c = buf[0];
1041 int newlen; // nr of bytes inserted
1042 int oldlen; // nr of bytes deleted (0 when not replacing)
1043 char_u *p;
1044 char_u *newp;
1045 char_u *oldp;
1046 int linelen; // length of old line including NUL
1047 colnr_T col;
1048 linenr_T lnum = curwin->w_cursor.lnum;
1049 int i;
1050
1051 // Break tabs if needed.
1052 if (virtual_active() && curwin->w_cursor.coladd > 0)
1053 coladvance_force(getviscol());
1054
1055 col = curwin->w_cursor.col;
1056 oldp = ml_get(lnum);
John Marriottbfcc8952024-03-11 22:04:45 +01001057 linelen = (int)ml_get_len(lnum) + 1;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001058
1059 // The lengths default to the values for when not replacing.
1060 oldlen = 0;
1061 newlen = charlen;
1062
1063 if (State & REPLACE_FLAG)
1064 {
1065 if (State & VREPLACE_FLAG)
1066 {
1067 colnr_T new_vcol = 0; // init for GCC
1068 colnr_T vcol;
1069 int old_list;
1070
1071 // Disable 'list' temporarily, unless 'cpo' contains the 'L' flag.
1072 // Returns the old value of list, so when finished,
1073 // curwin->w_p_list should be set back to this.
1074 old_list = curwin->w_p_list;
1075 if (old_list && vim_strchr(p_cpo, CPO_LISTWM) == NULL)
1076 curwin->w_p_list = FALSE;
1077
1078 // In virtual replace mode each character may replace one or more
1079 // characters (zero if it's a TAB). Count the number of bytes to
1080 // be deleted to make room for the new character, counting screen
1081 // cells. May result in adding spaces to fill a gap.
1082 getvcol(curwin, &curwin->w_cursor, NULL, &vcol, NULL);
1083 new_vcol = vcol + chartabsize(buf, vcol);
1084 while (oldp[col + oldlen] != NUL && vcol < new_vcol)
1085 {
1086 vcol += chartabsize(oldp + col + oldlen, vcol);
1087 // Don't need to remove a TAB that takes us to the right
1088 // position.
1089 if (vcol > new_vcol && oldp[col + oldlen] == TAB)
1090 break;
1091 oldlen += (*mb_ptr2len)(oldp + col + oldlen);
1092 // Deleted a bit too much, insert spaces.
1093 if (vcol > new_vcol)
1094 newlen += vcol - new_vcol;
1095 }
1096 curwin->w_p_list = old_list;
1097 }
1098 else if (oldp[col] != NUL)
1099 {
1100 // normal replace
1101 oldlen = (*mb_ptr2len)(oldp + col);
1102 }
1103
1104
1105 // Push the replaced bytes onto the replace stack, so that they can be
1106 // put back when BS is used. The bytes of a multi-byte character are
1107 // done the other way around, so that the first byte is popped off
1108 // first (it tells the byte length of the character).
1109 replace_push(NUL);
1110 for (i = 0; i < oldlen; ++i)
1111 {
1112 if (has_mbyte)
1113 i += replace_push_mb(oldp + col + i) - 1;
1114 else
1115 replace_push(oldp[col + i]);
1116 }
1117 }
1118
Bram Moolenaar964b3742019-05-24 18:54:09 +02001119 newp = alloc(linelen + newlen - oldlen);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001120 if (newp == NULL)
1121 return;
1122
1123 // Copy bytes before the cursor.
1124 if (col > 0)
1125 mch_memmove(newp, oldp, (size_t)col);
1126
1127 // Copy bytes after the changed character(s).
1128 p = newp + col;
1129 if (linelen > col + oldlen)
1130 mch_memmove(p + newlen, oldp + col + oldlen,
1131 (size_t)(linelen - col - oldlen));
1132
1133 // Insert or overwrite the new character.
1134 mch_memmove(p, buf, charlen);
1135 i = charlen;
1136
1137 // Fill with spaces when necessary.
1138 while (i < newlen)
1139 p[i++] = ' ';
1140
1141 // Replace the line in the buffer.
1142 ml_replace(lnum, newp, FALSE);
1143
1144 // mark the buffer as changed and prepare for displaying
LemonBoy0d534d92022-05-21 11:20:42 +01001145 changed_bytes(lnum, col);
1146#ifdef FEAT_PROP_POPUP
1147 if (curbuf->b_has_textprop && newlen != oldlen)
1148 adjust_prop_columns(lnum, col, newlen - oldlen,
1149 State & REPLACE_FLAG ? APC_SUBSTITUTE : 0);
1150#endif
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001151
1152 // If we're in Insert or Replace mode and 'showmatch' is set, then briefly
1153 // show the match for right parens and braces.
Bram Moolenaar24959102022-05-07 20:01:16 +01001154 if (p_sm && (State & MODE_INSERT)
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001155 && msg_silent == 0
Bram Moolenaare2c453d2019-08-21 14:37:09 +02001156 && !ins_compl_active())
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001157 {
1158 if (has_mbyte)
1159 showmatch(mb_ptr2char(buf));
1160 else
1161 showmatch(c);
1162 }
1163
1164#ifdef FEAT_RIGHTLEFT
1165 if (!p_ri || (State & REPLACE_FLAG))
1166#endif
1167 {
1168 // Normal insert: move cursor right
1169 curwin->w_cursor.col += charlen;
1170 }
1171
1172 // TODO: should try to update w_row here, to avoid recomputing it later.
1173}
1174
1175/*
1176 * Insert a string at the cursor position.
1177 * Note: Does NOT handle Replace mode.
1178 * Caller must have prepared for undo.
1179 */
1180 void
1181ins_str(char_u *s)
1182{
1183 char_u *oldp, *newp;
1184 int newlen = (int)STRLEN(s);
1185 int oldlen;
1186 colnr_T col;
1187 linenr_T lnum = curwin->w_cursor.lnum;
1188
1189 if (virtual_active() && curwin->w_cursor.coladd > 0)
1190 coladvance_force(getviscol());
1191
1192 col = curwin->w_cursor.col;
1193 oldp = ml_get(lnum);
John Marriottbfcc8952024-03-11 22:04:45 +01001194 oldlen = (int)ml_get_len(lnum);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001195
Bram Moolenaar964b3742019-05-24 18:54:09 +02001196 newp = alloc(oldlen + newlen + 1);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001197 if (newp == NULL)
1198 return;
1199 if (col > 0)
1200 mch_memmove(newp, oldp, (size_t)col);
1201 mch_memmove(newp + col, s, (size_t)newlen);
1202 mch_memmove(newp + col + newlen, oldp + col, (size_t)(oldlen - col + 1));
1203 ml_replace(lnum, newp, FALSE);
1204 inserted_bytes(lnum, col, newlen);
1205 curwin->w_cursor.col += newlen;
1206}
1207
1208/*
1209 * Delete one character under the cursor.
1210 * If "fixpos" is TRUE, don't leave the cursor on the NUL after the line.
1211 * Caller must have prepared for undo.
1212 *
1213 * return FAIL for failure, OK otherwise
1214 */
1215 int
1216del_char(int fixpos)
1217{
1218 if (has_mbyte)
1219 {
1220 // Make sure the cursor is at the start of a character.
1221 mb_adjust_cursor();
1222 if (*ml_get_cursor() == NUL)
1223 return FAIL;
1224 return del_chars(1L, fixpos);
1225 }
1226 return del_bytes(1L, fixpos, TRUE);
1227}
1228
1229/*
1230 * Like del_bytes(), but delete characters instead of bytes.
1231 */
1232 int
1233del_chars(long count, int fixpos)
1234{
1235 long bytes = 0;
1236 long i;
1237 char_u *p;
1238 int l;
1239
1240 p = ml_get_cursor();
1241 for (i = 0; i < count && *p != NUL; ++i)
1242 {
1243 l = (*mb_ptr2len)(p);
1244 bytes += l;
1245 p += l;
1246 }
1247 return del_bytes(bytes, fixpos, TRUE);
1248}
1249
1250/*
1251 * Delete "count" bytes under the cursor.
1252 * If "fixpos" is TRUE, don't leave the cursor on the NUL after the line.
1253 * Caller must have prepared for undo.
1254 *
1255 * Return FAIL for failure, OK otherwise.
1256 */
1257 int
1258del_bytes(
1259 long count,
1260 int fixpos_arg,
1261 int use_delcombine UNUSED) // 'delcombine' option applies
1262{
1263 char_u *oldp, *newp;
1264 colnr_T oldlen;
1265 colnr_T newlen;
1266 linenr_T lnum = curwin->w_cursor.lnum;
1267 colnr_T col = curwin->w_cursor.col;
1268 int alloc_newp;
1269 long movelen;
1270 int fixpos = fixpos_arg;
1271
1272 oldp = ml_get(lnum);
John Marriottbfcc8952024-03-11 22:04:45 +01001273 oldlen = (int)ml_get_len(lnum);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001274
1275 // Can't do anything when the cursor is on the NUL after the line.
1276 if (col >= oldlen)
1277 return FAIL;
1278
1279 // If "count" is zero there is nothing to do.
1280 if (count == 0)
1281 return OK;
1282
1283 // If "count" is negative the caller must be doing something wrong.
1284 if (count < 1)
1285 {
Bram Moolenaar9a846fb2022-01-01 21:59:18 +00001286 siemsg(e_invalid_count_for_del_bytes_nr, count);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001287 return FAIL;
1288 }
1289
1290 // If 'delcombine' is set and deleting (less than) one character, only
1291 // delete the last combining character.
1292 if (p_deco && use_delcombine && enc_utf8
1293 && utfc_ptr2len(oldp + col) >= count)
1294 {
1295 int cc[MAX_MCO];
1296 int n;
1297
1298 (void)utfc_ptr2char(oldp + col, cc);
1299 if (cc[0] != NUL)
1300 {
1301 // Find the last composing char, there can be several.
1302 n = col;
1303 do
1304 {
1305 col = n;
1306 count = utf_ptr2len(oldp + n);
1307 n += count;
1308 } while (UTF_COMPOSINGLIKE(oldp + col, oldp + n));
1309 fixpos = 0;
1310 }
1311 }
1312
1313 // When count is too big, reduce it.
1314 movelen = (long)oldlen - (long)col - count + 1; // includes trailing NUL
1315 if (movelen <= 1)
1316 {
1317 // If we just took off the last character of a non-blank line, and
1318 // fixpos is TRUE, we don't want to end up positioned at the NUL,
1319 // unless "restart_edit" is set or 'virtualedit' contains "onemore".
1320 if (col > 0 && fixpos && restart_edit == 0
Bram Moolenaar113d9de2022-08-08 15:49:18 +01001321 && (get_ve_flags() & VE_ONEMORE) == 0)
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001322 {
1323 --curwin->w_cursor.col;
1324 curwin->w_cursor.coladd = 0;
1325 if (has_mbyte)
1326 curwin->w_cursor.col -=
1327 (*mb_head_off)(oldp, oldp + curwin->w_cursor.col);
1328 }
1329 count = oldlen - col;
1330 movelen = 1;
1331 }
1332 newlen = oldlen - count;
1333
1334 // If the old line has been allocated the deletion can be done in the
1335 // existing line. Otherwise a new line has to be allocated
1336 // Can't do this when using Netbeans, because we would need to invoke
1337 // netbeans_removed(), which deallocates the line. Let ml_replace() take
1338 // care of notifying Netbeans.
1339#ifdef FEAT_NETBEANS_INTG
1340 if (netbeans_active())
1341 alloc_newp = TRUE;
1342 else
1343#endif
1344 alloc_newp = !ml_line_alloced(); // check if oldp was allocated
1345 if (!alloc_newp)
1346 newp = oldp; // use same allocated memory
1347 else
1348 { // need to allocate a new line
Bram Moolenaar964b3742019-05-24 18:54:09 +02001349 newp = alloc(newlen + 1);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001350 if (newp == NULL)
1351 return FAIL;
1352 mch_memmove(newp, oldp, (size_t)col);
1353 }
1354 mch_memmove(newp + col, oldp + col + count, (size_t)movelen);
1355 if (alloc_newp)
1356 ml_replace(lnum, newp, FALSE);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001357 else
1358 {
Christian Brabandt03acd472024-07-08 21:12:55 +02001359#ifdef FEAT_PROP_POPUP
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001360 // Also move any following text properties.
1361 if (oldlen + 1 < curbuf->b_ml.ml_line_len)
1362 mch_memmove(newp + newlen + 1, oldp + oldlen + 1,
1363 (size_t)curbuf->b_ml.ml_line_len - oldlen - 1);
Christian Brabandt03acd472024-07-08 21:12:55 +02001364#endif
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001365 curbuf->b_ml.ml_line_len -= count;
zeertzjq82e079d2024-03-10 08:55:42 +01001366 curbuf->b_ml.ml_line_textlen = 0;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001367 }
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001368
1369 // mark the buffer as changed and prepare for displaying
Bram Moolenaar12f20032020-02-26 22:06:00 +01001370 inserted_bytes(lnum, col, -count);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001371
1372 return OK;
1373}
1374
1375/*
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001376 * open_line: Add a new line below or above the current line.
1377 *
Bram Moolenaar24959102022-05-07 20:01:16 +01001378 * For MODE_VREPLACE state, we only add a new line when we get to the end of
1379 * the file, otherwise we just start replacing the next line.
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001380 *
Bram Moolenaar24959102022-05-07 20:01:16 +01001381 * Caller must take care of undo. Since MODE_VREPLACE may affect any number of
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001382 * lines however, it may call u_save_cursor() again when starting to change a
1383 * new line.
1384 * "flags": OPENLINE_DELSPACES delete spaces after cursor
1385 * OPENLINE_DO_COM format comments
1386 * OPENLINE_KEEPTRAIL keep trailing spaces
1387 * OPENLINE_MARKFIX adjust mark positions after the line break
1388 * OPENLINE_COM_LIST format comments with list or 2nd line indent
1389 *
1390 * "second_line_indent": indent for after ^^D in Insert mode or if flag
1391 * OPENLINE_COM_LIST
Bram Moolenaar6e371ec2021-12-12 14:16:39 +00001392 * "did_do_comment" is set to TRUE when intentionally putting the comment
dundargocc57b5bc2022-11-02 13:30:51 +00001393 * leader in front of the new line.
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001394 *
1395 * Return OK for success, FAIL for failure
1396 */
1397 int
1398open_line(
1399 int dir, // FORWARD or BACKWARD
1400 int flags,
Bram Moolenaar6e371ec2021-12-12 14:16:39 +00001401 int second_line_indent,
1402 int *did_do_comment UNUSED)
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001403{
1404 char_u *saved_line; // copy of the original line
1405 char_u *next_line = NULL; // copy of the next line
1406 char_u *p_extra = NULL; // what goes to next line
1407 int less_cols = 0; // less columns for mark in new line
LemonBoy788c06a2022-05-14 18:48:05 +01001408 int less_cols_off = 0; // columns to skip for mark and
1409 // textprop adjustment
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001410 pos_T old_cursor; // old cursor position
1411 int newcol = 0; // new cursor column
1412 int newindent = 0; // auto-indent of the new line
1413 int n;
1414 int trunc_line = FALSE; // truncate current line afterwards
1415 int retval = FAIL; // return value
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001416 int extra_len = 0; // length of p_extra string
1417 int lead_len; // length of comment leader
Bram Moolenaar6e371ec2021-12-12 14:16:39 +00001418 int comment_start = 0; // start index of the comment leader
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001419 char_u *lead_flags; // position in 'comments' for comment leader
1420 char_u *leader = NULL; // copy of comment leader
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001421 char_u *allocated = NULL; // allocated memory
1422 char_u *p;
1423 int saved_char = NUL; // init for GCC
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001424 pos_T *pos;
Bram Moolenaard2439e02021-12-12 19:10:44 +00001425 int do_cindent;
Bram Moolenaarde5cf282022-05-14 11:52:23 +01001426 int do_si = may_do_si();
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001427 int no_si = FALSE; // reset did_si afterwards
1428 int first_char = NUL; // init for GCC
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001429 int vreplace_mode;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001430 int did_append; // appended a new line
1431 int saved_pi = curbuf->b_p_pi; // copy of preserveindent setting
Bram Moolenaarebd0e8b2022-09-14 22:13:59 +01001432#ifdef FEAT_PROP_POPUP
1433 int at_eol; // cursor after last character
1434#endif
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001435
1436 // make a copy of the current line so we can mess with it
John Marriottbfcc8952024-03-11 22:04:45 +01001437 saved_line = vim_strnsave(ml_get_curline(), ml_get_curline_len());
Bram Moolenaarc667da52019-11-30 20:52:27 +01001438 if (saved_line == NULL) // out of memory!
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001439 return FALSE;
1440
Bram Moolenaarebd0e8b2022-09-14 22:13:59 +01001441#ifdef FEAT_PROP_POPUP
John Marriottbfcc8952024-03-11 22:04:45 +01001442 at_eol = curwin->w_cursor.col >= (int)ml_get_curline_len();
Bram Moolenaarebd0e8b2022-09-14 22:13:59 +01001443#endif
1444
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001445 if (State & VREPLACE_FLAG)
1446 {
Bram Moolenaar24959102022-05-07 20:01:16 +01001447 // With MODE_VREPLACE we make a copy of the next line, which we will be
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001448 // starting to replace. First make the new line empty and let vim play
1449 // with the indenting and comment leader to its heart's content. Then
1450 // we grab what it ended up putting on the new line, put back the
1451 // original line, and call ins_char() to put each new character onto
1452 // the line, replacing what was there before and pushing the right
1453 // stuff onto the replace stack. -- webb.
1454 if (curwin->w_cursor.lnum < orig_line_count)
John Marriottbfcc8952024-03-11 22:04:45 +01001455 next_line = vim_strnsave(ml_get(curwin->w_cursor.lnum + 1), ml_get_len(curwin->w_cursor.lnum + 1));
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001456 else
1457 next_line = vim_strsave((char_u *)"");
1458 if (next_line == NULL) // out of memory!
1459 goto theend;
1460
Bram Moolenaar24959102022-05-07 20:01:16 +01001461 // In MODE_VREPLACE state, a NL replaces the rest of the line, and
1462 // starts replacing the next line, so push all of the characters left
1463 // on the line onto the replace stack. We'll push any other characters
1464 // that might be replaced at the start of the next line (due to
1465 // autoindent etc) a bit later.
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001466 replace_push(NUL); // Call twice because BS over NL expects it
1467 replace_push(NUL);
1468 p = saved_line + curwin->w_cursor.col;
1469 while (*p != NUL)
1470 {
1471 if (has_mbyte)
1472 p += replace_push_mb(p);
1473 else
1474 replace_push(*p++);
1475 }
1476 saved_line[curwin->w_cursor.col] = NUL;
1477 }
1478
Bram Moolenaar24959102022-05-07 20:01:16 +01001479 if ((State & MODE_INSERT) && (State & VREPLACE_FLAG) == 0)
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001480 {
1481 p_extra = saved_line + curwin->w_cursor.col;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001482 if (do_si) // need first char after new line break
1483 {
1484 p = skipwhite(p_extra);
1485 first_char = *p;
1486 }
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001487 extra_len = (int)STRLEN(p_extra);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001488 saved_char = *p_extra;
1489 *p_extra = NUL;
1490 }
1491
1492 u_clearline(); // cannot do "U" command when adding lines
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001493 did_si = FALSE;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001494 ai_col = 0;
1495
1496 // If we just did an auto-indent, then we didn't type anything on
1497 // the prior line, and it should be truncated. Do this even if 'ai' is not
1498 // set because automatically inserting a comment leader also sets did_ai.
1499 if (dir == FORWARD && did_ai)
1500 trunc_line = TRUE;
1501
1502 // If 'autoindent' and/or 'smartindent' is set, try to figure out what
1503 // indent to use for the new line.
Bram Moolenaar8e145b82022-05-21 20:17:31 +01001504 if (curbuf->b_p_ai || do_si)
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001505 {
1506 // count white space on current line
1507#ifdef FEAT_VARTABS
1508 newindent = get_indent_str_vtab(saved_line, curbuf->b_p_ts,
1509 curbuf->b_p_vts_array, FALSE);
1510#else
1511 newindent = get_indent_str(saved_line, (int)curbuf->b_p_ts, FALSE);
1512#endif
1513 if (newindent == 0 && !(flags & OPENLINE_COM_LIST))
1514 newindent = second_line_indent; // for ^^D command in insert mode
1515
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001516 // Do smart indenting.
1517 // In insert/replace mode (only when dir == FORWARD)
1518 // we may move some text to the next line. If it starts with '{'
1519 // don't add an indent. Fixes inserting a NL before '{' in line
1520 // "if (condition) {"
1521 if (!trunc_line && do_si && *saved_line != NUL
1522 && (p_extra == NULL || first_char != '{'))
1523 {
1524 char_u *ptr;
1525 char_u last_char;
1526
1527 old_cursor = curwin->w_cursor;
1528 ptr = saved_line;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001529 if (flags & OPENLINE_DO_COM)
1530 lead_len = get_leader_len(ptr, NULL, FALSE, TRUE);
1531 else
1532 lead_len = 0;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001533 if (dir == FORWARD)
1534 {
1535 // Skip preprocessor directives, unless they are
1536 // recognised as comments.
Bram Moolenaar8c96af92019-09-28 19:05:57 +02001537 if ( lead_len == 0 && ptr[0] == '#')
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001538 {
1539 while (ptr[0] == '#' && curwin->w_cursor.lnum > 1)
1540 ptr = ml_get(--curwin->w_cursor.lnum);
1541 newindent = get_indent();
1542 }
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001543 if (flags & OPENLINE_DO_COM)
1544 lead_len = get_leader_len(ptr, NULL, FALSE, TRUE);
1545 else
1546 lead_len = 0;
1547 if (lead_len > 0)
1548 {
1549 // This case gets the following right:
1550 // /*
1551 // * A comment (read '\' as '/').
1552 // */
1553 // #define IN_THE_WAY
1554 // This should line up here;
1555 p = skipwhite(ptr);
1556 if (p[0] == '/' && p[1] == '*')
1557 p++;
1558 if (p[0] == '*')
1559 {
1560 for (p++; *p; p++)
1561 {
1562 if (p[0] == '/' && p[-1] == '*')
1563 {
1564 // End of C comment, indent should line up
1565 // with the line containing the start of
Bram Moolenaarfa4873c2022-06-30 22:13:59 +01001566 // the comment.
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001567 curwin->w_cursor.col = (colnr_T)(p - ptr);
1568 if ((pos = findmatch(NULL, NUL)) != NULL)
1569 {
1570 curwin->w_cursor.lnum = pos->lnum;
1571 newindent = get_indent();
Bram Moolenaarfa4873c2022-06-30 22:13:59 +01001572 break;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001573 }
Bram Moolenaarfa4873c2022-06-30 22:13:59 +01001574 // this may make "ptr" invalid, get it again
1575 ptr = ml_get(curwin->w_cursor.lnum);
1576 p = ptr + curwin->w_cursor.col;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001577 }
1578 }
1579 }
1580 }
1581 else // Not a comment line
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001582 {
1583 // Find last non-blank in line
1584 p = ptr + STRLEN(ptr) - 1;
1585 while (p > ptr && VIM_ISWHITE(*p))
1586 --p;
1587 last_char = *p;
1588
1589 // find the character just before the '{' or ';'
1590 if (last_char == '{' || last_char == ';')
1591 {
1592 if (p > ptr)
1593 --p;
1594 while (p > ptr && VIM_ISWHITE(*p))
1595 --p;
1596 }
1597 // Try to catch lines that are split over multiple
1598 // lines. eg:
1599 // if (condition &&
1600 // condition) {
1601 // Should line up here!
1602 // }
1603 if (*p == ')')
1604 {
1605 curwin->w_cursor.col = (colnr_T)(p - ptr);
1606 if ((pos = findmatch(NULL, '(')) != NULL)
1607 {
1608 curwin->w_cursor.lnum = pos->lnum;
1609 newindent = get_indent();
1610 ptr = ml_get_curline();
1611 }
1612 }
1613 // If last character is '{' do indent, without
1614 // checking for "if" and the like.
1615 if (last_char == '{')
1616 {
1617 did_si = TRUE; // do indent
1618 no_si = TRUE; // don't delete it when '{' typed
1619 }
1620 // Look for "if" and the like, use 'cinwords'.
1621 // Don't do this if the previous line ended in ';' or
1622 // '}'.
1623 else if (last_char != ';' && last_char != '}'
1624 && cin_is_cinword(ptr))
1625 did_si = TRUE;
1626 }
1627 }
1628 else // dir == BACKWARD
1629 {
1630 // Skip preprocessor directives, unless they are
1631 // recognised as comments.
Bram Moolenaar8c96af92019-09-28 19:05:57 +02001632 if (lead_len == 0 && ptr[0] == '#')
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001633 {
1634 int was_backslashed = FALSE;
1635
1636 while ((ptr[0] == '#' || was_backslashed) &&
1637 curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count)
1638 {
1639 if (*ptr && ptr[STRLEN(ptr) - 1] == '\\')
1640 was_backslashed = TRUE;
1641 else
1642 was_backslashed = FALSE;
1643 ptr = ml_get(++curwin->w_cursor.lnum);
1644 }
1645 if (was_backslashed)
1646 newindent = 0; // Got to end of file
1647 else
1648 newindent = get_indent();
1649 }
1650 p = skipwhite(ptr);
1651 if (*p == '}') // if line starts with '}': do indent
1652 did_si = TRUE;
1653 else // can delete indent when '{' typed
1654 can_si_back = TRUE;
1655 }
1656 curwin->w_cursor = old_cursor;
1657 }
1658 if (do_si)
1659 can_si = TRUE;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001660
1661 did_ai = TRUE;
1662 }
1663
Bram Moolenaar6e371ec2021-12-12 14:16:39 +00001664 // May do indenting after opening a new line.
1665 do_cindent = !p_paste && (curbuf->b_p_cin
Bram Moolenaar8e145b82022-05-21 20:17:31 +01001666#ifdef FEAT_EVAL
Bram Moolenaar6e371ec2021-12-12 14:16:39 +00001667 || *curbuf->b_p_inde != NUL
Bram Moolenaar8e145b82022-05-21 20:17:31 +01001668#endif
Bram Moolenaar6e371ec2021-12-12 14:16:39 +00001669 )
1670 && in_cinkeys(dir == FORWARD
1671 ? KEY_OPEN_FORW
1672 : KEY_OPEN_BACK, ' ', linewhite(curwin->w_cursor.lnum));
Bram Moolenaar6e371ec2021-12-12 14:16:39 +00001673
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001674 // Find out if the current line starts with a comment leader.
1675 // This may then be inserted in front of the new line.
1676 end_comment_pending = NUL;
1677 if (flags & OPENLINE_DO_COM)
Bram Moolenaar6e371ec2021-12-12 14:16:39 +00001678 {
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001679 lead_len = get_leader_len(saved_line, &lead_flags,
1680 dir == BACKWARD, TRUE);
Bram Moolenaar2bf875f2022-05-07 14:54:11 +01001681 if (lead_len == 0 && curbuf->b_p_cin && do_cindent && dir == FORWARD
Bram Moolenaar7e667782022-05-23 13:10:48 +01001682 && (!has_format_option(FO_NO_OPEN_COMS)
1683 || (flags & OPENLINE_FORMAT)))
Bram Moolenaar6e371ec2021-12-12 14:16:39 +00001684 {
Bram Moolenaar5ea5f372021-12-29 15:15:47 +00001685 // Check for a line comment after code.
Bram Moolenaar6e371ec2021-12-12 14:16:39 +00001686 comment_start = check_linecomment(saved_line);
1687 if (comment_start != MAXCOL)
1688 {
1689 lead_len = get_leader_len(saved_line + comment_start,
Bram Moolenaar5ea5f372021-12-29 15:15:47 +00001690 &lead_flags, FALSE, TRUE);
Bram Moolenaar6e371ec2021-12-12 14:16:39 +00001691 if (lead_len != 0)
1692 {
1693 lead_len += comment_start;
1694 if (did_do_comment != NULL)
1695 *did_do_comment = TRUE;
1696 }
1697 }
1698 }
Bram Moolenaar6e371ec2021-12-12 14:16:39 +00001699 }
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001700 else
1701 lead_len = 0;
1702 if (lead_len > 0)
1703 {
1704 char_u *lead_repl = NULL; // replaces comment leader
1705 int lead_repl_len = 0; // length of *lead_repl
1706 char_u lead_middle[COM_MAX_LEN]; // middle-comment string
1707 char_u lead_end[COM_MAX_LEN]; // end-comment string
1708 char_u *comment_end = NULL; // where lead_end has been found
1709 int extra_space = FALSE; // append extra space
1710 int current_flag;
1711 int require_blank = FALSE; // requires blank after middle
1712 char_u *p2;
1713
1714 // If the comment leader has the start, middle or end flag, it may not
1715 // be used or may be replaced with the middle leader.
1716 for (p = lead_flags; *p && *p != ':'; ++p)
1717 {
1718 if (*p == COM_BLANK)
1719 {
1720 require_blank = TRUE;
1721 continue;
1722 }
1723 if (*p == COM_START || *p == COM_MIDDLE)
1724 {
1725 current_flag = *p;
1726 if (*p == COM_START)
1727 {
1728 // Doing "O" on a start of comment does not insert leader.
1729 if (dir == BACKWARD)
1730 {
1731 lead_len = 0;
1732 break;
1733 }
1734
1735 // find start of middle part
1736 (void)copy_option_part(&p, lead_middle, COM_MAX_LEN, ",");
1737 require_blank = FALSE;
1738 }
1739
1740 // Isolate the strings of the middle and end leader.
Bram Moolenaarc667da52019-11-30 20:52:27 +01001741 while (*p && p[-1] != ':') // find end of middle flags
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001742 {
1743 if (*p == COM_BLANK)
1744 require_blank = TRUE;
1745 ++p;
1746 }
1747 (void)copy_option_part(&p, lead_middle, COM_MAX_LEN, ",");
1748
1749 while (*p && p[-1] != ':') // find end of end flags
1750 {
1751 // Check whether we allow automatic ending of comments
1752 if (*p == COM_AUTO_END)
1753 end_comment_pending = -1; // means we want to set it
1754 ++p;
1755 }
1756 n = copy_option_part(&p, lead_end, COM_MAX_LEN, ",");
1757
1758 if (end_comment_pending == -1) // we can set it now
1759 end_comment_pending = lead_end[n - 1];
1760
1761 // If the end of the comment is in the same line, don't use
1762 // the comment leader.
1763 if (dir == FORWARD)
1764 {
1765 for (p = saved_line + lead_len; *p; ++p)
1766 if (STRNCMP(p, lead_end, n) == 0)
1767 {
1768 comment_end = p;
1769 lead_len = 0;
1770 break;
1771 }
1772 }
1773
1774 // Doing "o" on a start of comment inserts the middle leader.
1775 if (lead_len > 0)
1776 {
1777 if (current_flag == COM_START)
1778 {
1779 lead_repl = lead_middle;
1780 lead_repl_len = (int)STRLEN(lead_middle);
1781 }
1782
1783 // If we have hit RETURN immediately after the start
1784 // comment leader, then put a space after the middle
1785 // comment leader on the next line.
1786 if (!VIM_ISWHITE(saved_line[lead_len - 1])
1787 && ((p_extra != NULL
1788 && (int)curwin->w_cursor.col == lead_len)
1789 || (p_extra == NULL
1790 && saved_line[lead_len] == NUL)
1791 || require_blank))
1792 extra_space = TRUE;
1793 }
1794 break;
1795 }
1796 if (*p == COM_END)
1797 {
1798 // Doing "o" on the end of a comment does not insert leader.
1799 // Remember where the end is, might want to use it to find the
1800 // start (for C-comments).
1801 if (dir == FORWARD)
1802 {
1803 comment_end = skipwhite(saved_line);
1804 lead_len = 0;
1805 break;
1806 }
1807
1808 // Doing "O" on the end of a comment inserts the middle leader.
1809 // Find the string for the middle leader, searching backwards.
1810 while (p > curbuf->b_p_com && *p != ',')
1811 --p;
1812 for (lead_repl = p; lead_repl > curbuf->b_p_com
1813 && lead_repl[-1] != ':'; --lead_repl)
1814 ;
1815 lead_repl_len = (int)(p - lead_repl);
1816
1817 // We can probably always add an extra space when doing "O" on
1818 // the comment-end
1819 extra_space = TRUE;
1820
1821 // Check whether we allow automatic ending of comments
1822 for (p2 = p; *p2 && *p2 != ':'; p2++)
1823 {
1824 if (*p2 == COM_AUTO_END)
1825 end_comment_pending = -1; // means we want to set it
1826 }
1827 if (end_comment_pending == -1)
1828 {
1829 // Find last character in end-comment string
1830 while (*p2 && *p2 != ',')
1831 p2++;
1832 end_comment_pending = p2[-1];
1833 }
1834 break;
1835 }
1836 if (*p == COM_FIRST)
1837 {
1838 // Comment leader for first line only: Don't repeat leader
1839 // when using "O", blank out leader when using "o".
1840 if (dir == BACKWARD)
1841 lead_len = 0;
1842 else
1843 {
1844 lead_repl = (char_u *)"";
1845 lead_repl_len = 0;
1846 }
1847 break;
1848 }
1849 }
1850 if (lead_len)
1851 {
1852 // allocate buffer (may concatenate p_extra later)
1853 leader = alloc(lead_len + lead_repl_len + extra_space + extra_len
1854 + (second_line_indent > 0 ? second_line_indent : 0) + 1);
1855 allocated = leader; // remember to free it later
1856
1857 if (leader == NULL)
1858 lead_len = 0;
1859 else
1860 {
Bram Moolenaar6e371ec2021-12-12 14:16:39 +00001861 int li;
1862
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001863 vim_strncpy(leader, saved_line, lead_len);
1864
Bram Moolenaar6e371ec2021-12-12 14:16:39 +00001865 // TODO: handle multi-byte and double width chars
1866 for (li = 0; li < comment_start; ++li)
1867 if (!VIM_ISWHITE(leader[li]))
1868 leader[li] = ' ';
1869
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02001870 // Replace leader with lead_repl, right or left adjusted
1871 if (lead_repl != NULL)
1872 {
1873 int c = 0;
1874 int off = 0;
1875
1876 for (p = lead_flags; *p != NUL && *p != ':'; )
1877 {
1878 if (*p == COM_RIGHT || *p == COM_LEFT)
1879 c = *p++;
1880 else if (VIM_ISDIGIT(*p) || *p == '-')
1881 off = getdigits(&p);
1882 else
1883 ++p;
1884 }
1885 if (c == COM_RIGHT) // right adjusted leader
1886 {
1887 // find last non-white in the leader to line up with
1888 for (p = leader + lead_len - 1; p > leader
1889 && VIM_ISWHITE(*p); --p)
1890 ;
1891 ++p;
1892
1893 // Compute the length of the replaced characters in
1894 // screen characters, not bytes.
1895 {
1896 int repl_size = vim_strnsize(lead_repl,
1897 lead_repl_len);
1898 int old_size = 0;
1899 char_u *endp = p;
1900 int l;
1901
1902 while (old_size < repl_size && p > leader)
1903 {
1904 MB_PTR_BACK(leader, p);
1905 old_size += ptr2cells(p);
1906 }
1907 l = lead_repl_len - (int)(endp - p);
1908 if (l != 0)
1909 mch_memmove(endp + l, endp,
1910 (size_t)((leader + lead_len) - endp));
1911 lead_len += l;
1912 }
1913 mch_memmove(p, lead_repl, (size_t)lead_repl_len);
1914 if (p + lead_repl_len > leader + lead_len)
1915 p[lead_repl_len] = NUL;
1916
1917 // blank-out any other chars from the old leader.
1918 while (--p >= leader)
1919 {
1920 int l = mb_head_off(leader, p);
1921
1922 if (l > 1)
1923 {
1924 p -= l;
1925 if (ptr2cells(p) > 1)
1926 {
1927 p[1] = ' ';
1928 --l;
1929 }
1930 mch_memmove(p + 1, p + l + 1,
1931 (size_t)((leader + lead_len) - (p + l + 1)));
1932 lead_len -= l;
1933 *p = ' ';
1934 }
1935 else if (!VIM_ISWHITE(*p))
1936 *p = ' ';
1937 }
1938 }
1939 else // left adjusted leader
1940 {
1941 p = skipwhite(leader);
1942
1943 // Compute the length of the replaced characters in
1944 // screen characters, not bytes. Move the part that is
1945 // not to be overwritten.
1946 {
1947 int repl_size = vim_strnsize(lead_repl,
1948 lead_repl_len);
1949 int i;
1950 int l;
1951
1952 for (i = 0; i < lead_len && p[i] != NUL; i += l)
1953 {
1954 l = (*mb_ptr2len)(p + i);
1955 if (vim_strnsize(p, i + l) > repl_size)
1956 break;
1957 }
1958 if (i != lead_repl_len)
1959 {
1960 mch_memmove(p + lead_repl_len, p + i,
1961 (size_t)(lead_len - i - (p - leader)));
1962 lead_len += lead_repl_len - i;
1963 }
1964 }
1965 mch_memmove(p, lead_repl, (size_t)lead_repl_len);
1966
1967 // Replace any remaining non-white chars in the old
1968 // leader by spaces. Keep Tabs, the indent must
1969 // remain the same.
1970 for (p += lead_repl_len; p < leader + lead_len; ++p)
1971 if (!VIM_ISWHITE(*p))
1972 {
1973 // Don't put a space before a TAB.
1974 if (p + 1 < leader + lead_len && p[1] == TAB)
1975 {
1976 --lead_len;
1977 mch_memmove(p, p + 1,
1978 (leader + lead_len) - p);
1979 }
1980 else
1981 {
1982 int l = (*mb_ptr2len)(p);
1983
1984 if (l > 1)
1985 {
1986 if (ptr2cells(p) > 1)
1987 {
1988 // Replace a double-wide char with
1989 // two spaces
1990 --l;
1991 *p++ = ' ';
1992 }
1993 mch_memmove(p + 1, p + l,
1994 (leader + lead_len) - p);
1995 lead_len -= l - 1;
1996 }
1997 *p = ' ';
1998 }
1999 }
2000 *p = NUL;
2001 }
2002
2003 // Recompute the indent, it may have changed.
Bram Moolenaar8e145b82022-05-21 20:17:31 +01002004 if (curbuf->b_p_ai || do_si)
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002005#ifdef FEAT_VARTABS
2006 newindent = get_indent_str_vtab(leader, curbuf->b_p_ts,
2007 curbuf->b_p_vts_array, FALSE);
2008#else
2009 newindent = get_indent_str(leader,
2010 (int)curbuf->b_p_ts, FALSE);
2011#endif
2012
2013 // Add the indent offset
2014 if (newindent + off < 0)
2015 {
2016 off = -newindent;
2017 newindent = 0;
2018 }
2019 else
2020 newindent += off;
2021
2022 // Correct trailing spaces for the shift, so that
2023 // alignment remains equal.
2024 while (off > 0 && lead_len > 0
2025 && leader[lead_len - 1] == ' ')
2026 {
2027 // Don't do it when there is a tab before the space
2028 if (vim_strchr(skipwhite(leader), '\t') != NULL)
2029 break;
2030 --lead_len;
2031 --off;
2032 }
2033
2034 // If the leader ends in white space, don't add an
2035 // extra space
2036 if (lead_len > 0 && VIM_ISWHITE(leader[lead_len - 1]))
2037 extra_space = FALSE;
2038 leader[lead_len] = NUL;
2039 }
2040
2041 if (extra_space)
2042 {
2043 leader[lead_len++] = ' ';
2044 leader[lead_len] = NUL;
2045 }
2046
2047 newcol = lead_len;
2048
2049 // if a new indent will be set below, remove the indent that
2050 // is in the comment leader
Bram Moolenaar8e145b82022-05-21 20:17:31 +01002051 if (newindent || did_si)
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002052 {
2053 while (lead_len && VIM_ISWHITE(*leader))
2054 {
2055 --lead_len;
2056 --newcol;
2057 ++leader;
2058 }
2059 }
2060
2061 }
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002062 did_si = can_si = FALSE;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002063 }
2064 else if (comment_end != NULL)
2065 {
2066 // We have finished a comment, so we don't use the leader.
2067 // If this was a C-comment and 'ai' or 'si' is set do a normal
2068 // indent to align with the line containing the start of the
2069 // comment.
2070 if (comment_end[0] == '*' && comment_end[1] == '/' &&
Bram Moolenaar8e145b82022-05-21 20:17:31 +01002071 (curbuf->b_p_ai || do_si))
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002072 {
2073 old_cursor = curwin->w_cursor;
2074 curwin->w_cursor.col = (colnr_T)(comment_end - saved_line);
2075 if ((pos = findmatch(NULL, NUL)) != NULL)
2076 {
2077 curwin->w_cursor.lnum = pos->lnum;
2078 newindent = get_indent();
2079 }
2080 curwin->w_cursor = old_cursor;
2081 }
2082 }
2083 }
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002084
Bram Moolenaar24959102022-05-07 20:01:16 +01002085 // (State == MODE_INSERT || State == MODE_REPLACE), only when dir == FORWARD
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002086 if (p_extra != NULL)
2087 {
2088 *p_extra = saved_char; // restore char that NUL replaced
2089
2090 // When 'ai' set or "flags" has OPENLINE_DELSPACES, skip to the first
2091 // non-blank.
2092 //
Bram Moolenaar24959102022-05-07 20:01:16 +01002093 // When in MODE_REPLACE state, put the deleted blanks on the replace
2094 // stack, preceded by a NUL, so they can be put back when a BS is
2095 // entered.
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002096 if (REPLACE_NORMAL(State))
Bram Moolenaarc667da52019-11-30 20:52:27 +01002097 replace_push(NUL); // end of extra blanks
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002098 if (curbuf->b_p_ai || (flags & OPENLINE_DELSPACES))
2099 {
2100 while ((*p_extra == ' ' || *p_extra == '\t')
2101 && (!enc_utf8
2102 || !utf_iscomposing(utf_ptr2char(p_extra + 1))))
2103 {
2104 if (REPLACE_NORMAL(State))
2105 replace_push(*p_extra);
2106 ++p_extra;
2107 ++less_cols_off;
2108 }
2109 }
2110
2111 // columns for marks adjusted for removed columns
2112 less_cols = (int)(p_extra - saved_line);
2113 }
2114
2115 if (p_extra == NULL)
2116 p_extra = (char_u *)""; // append empty line
2117
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002118 // concatenate leader and p_extra, if there is a leader
2119 if (lead_len)
2120 {
2121 if (flags & OPENLINE_COM_LIST && second_line_indent > 0)
2122 {
2123 int i;
2124 int padding = second_line_indent
2125 - (newindent + (int)STRLEN(leader));
2126
2127 // Here whitespace is inserted after the comment char.
2128 // Below, set_indent(newindent, SIN_INSERT) will insert the
2129 // whitespace needed before the comment char.
2130 for (i = 0; i < padding; i++)
2131 {
2132 STRCAT(leader, " ");
2133 less_cols--;
2134 newcol++;
2135 }
2136 }
2137 STRCAT(leader, p_extra);
2138 p_extra = leader;
2139 did_ai = TRUE; // So truncating blanks works with comments
2140 less_cols -= lead_len;
2141 }
2142 else
2143 end_comment_pending = NUL; // turns out there was no leader
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002144
2145 old_cursor = curwin->w_cursor;
2146 if (dir == BACKWARD)
2147 --curwin->w_cursor.lnum;
2148 if (!(State & VREPLACE_FLAG) || old_cursor.lnum >= orig_line_count)
2149 {
2150 if (ml_append(curwin->w_cursor.lnum, p_extra, (colnr_T)0, FALSE)
2151 == FAIL)
2152 goto theend;
2153 // Postpone calling changed_lines(), because it would mess up folding
2154 // with markers.
Brandon Simmonsda3dd7d2023-01-17 19:48:07 +00002155 mark_adjust(curwin->w_cursor.lnum + 1, (linenr_T)MAXLNUM, 1L, 0L);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002156 did_append = TRUE;
Bram Moolenaar05ad5ff2019-11-30 22:48:27 +01002157#ifdef FEAT_PROP_POPUP
Bram Moolenaar24959102022-05-07 20:01:16 +01002158 if ((State & MODE_INSERT) && (State & VREPLACE_FLAG) == 0)
LemonBoy788c06a2022-05-14 18:48:05 +01002159 // Properties after the split move to the next line.
Bram Moolenaar45dd07f2019-05-15 22:45:37 +02002160 adjust_props_for_split(curwin->w_cursor.lnum, curwin->w_cursor.lnum,
Bram Moolenaarebd0e8b2022-09-14 22:13:59 +01002161 curwin->w_cursor.col + 1, 0, at_eol);
Bram Moolenaar45dd07f2019-05-15 22:45:37 +02002162#endif
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002163 }
2164 else
2165 {
Bram Moolenaar24959102022-05-07 20:01:16 +01002166 // In MODE_VREPLACE state we are starting to replace the next line.
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002167 curwin->w_cursor.lnum++;
2168 if (curwin->w_cursor.lnum >= Insstart.lnum + vr_lines_changed)
2169 {
2170 // In case we NL to a new line, BS to the previous one, and NL
2171 // again, we don't want to save the new line for undo twice.
Bram Moolenaarc667da52019-11-30 20:52:27 +01002172 (void)u_save_cursor(); // errors are ignored!
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002173 vr_lines_changed++;
2174 }
2175 ml_replace(curwin->w_cursor.lnum, p_extra, TRUE);
2176 changed_bytes(curwin->w_cursor.lnum, 0);
2177 curwin->w_cursor.lnum--;
2178 did_append = FALSE;
2179 }
2180
Bram Moolenaar8e145b82022-05-21 20:17:31 +01002181 if (newindent || did_si)
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002182 {
2183 ++curwin->w_cursor.lnum;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002184 if (did_si)
2185 {
2186 int sw = (int)get_sw_value(curbuf);
2187
2188 if (p_sr)
2189 newindent -= newindent % sw;
2190 newindent += sw;
2191 }
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002192 // Copy the indent
2193 if (curbuf->b_p_ci)
2194 {
2195 (void)copy_indent(newindent, saved_line);
2196
2197 // Set the 'preserveindent' option so that any further screwing
2198 // with the line doesn't entirely destroy our efforts to preserve
2199 // it. It gets restored at the function end.
2200 curbuf->b_p_pi = TRUE;
2201 }
2202 else
2203 (void)set_indent(newindent, SIN_INSERT);
2204 less_cols -= curwin->w_cursor.col;
2205
2206 ai_col = curwin->w_cursor.col;
2207
Bram Moolenaar24959102022-05-07 20:01:16 +01002208 // In MODE_REPLACE state, for each character in the new indent, there
2209 // must be a NUL on the replace stack, for when it is deleted with BS
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002210 if (REPLACE_NORMAL(State))
2211 for (n = 0; n < (int)curwin->w_cursor.col; ++n)
2212 replace_push(NUL);
2213 newcol += curwin->w_cursor.col;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002214 if (no_si)
2215 did_si = FALSE;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002216 }
2217
Bram Moolenaar24959102022-05-07 20:01:16 +01002218 // In MODE_REPLACE state, for each character in the extra leader, there
2219 // must be a NUL on the replace stack, for when it is deleted with BS.
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002220 if (REPLACE_NORMAL(State))
2221 while (lead_len-- > 0)
2222 replace_push(NUL);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002223
2224 curwin->w_cursor = old_cursor;
2225
2226 if (dir == FORWARD)
2227 {
Bram Moolenaar24959102022-05-07 20:01:16 +01002228 if (trunc_line || (State & MODE_INSERT))
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002229 {
2230 // truncate current line at cursor
2231 saved_line[curwin->w_cursor.col] = NUL;
2232 // Remove trailing white space, unless OPENLINE_KEEPTRAIL used.
2233 if (trunc_line && !(flags & OPENLINE_KEEPTRAIL))
2234 truncate_spaces(saved_line);
2235 ml_replace(curwin->w_cursor.lnum, saved_line, FALSE);
2236 saved_line = NULL;
2237 if (did_append)
2238 {
2239 changed_lines(curwin->w_cursor.lnum, curwin->w_cursor.col,
2240 curwin->w_cursor.lnum + 1, 1L);
2241 did_append = FALSE;
2242
2243 // Move marks after the line break to the new line.
2244 if (flags & OPENLINE_MARKFIX)
2245 mark_col_adjust(curwin->w_cursor.lnum,
2246 curwin->w_cursor.col + less_cols_off,
2247 1L, (long)-less_cols, 0);
LemonBoy788c06a2022-05-14 18:48:05 +01002248#ifdef FEAT_PROP_POPUP
2249 // Keep into account the deleted blanks on the new line.
2250 if (curbuf->b_has_textprop && less_cols_off != 0)
2251 adjust_prop_columns(curwin->w_cursor.lnum + 1, 0,
2252 -less_cols_off, 0);
2253#endif
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002254 }
2255 else
2256 changed_bytes(curwin->w_cursor.lnum, curwin->w_cursor.col);
2257 }
2258
2259 // Put the cursor on the new line. Careful: the scrollup() above may
2260 // have moved w_cursor, we must use old_cursor.
2261 curwin->w_cursor.lnum = old_cursor.lnum + 1;
2262 }
2263 if (did_append)
2264 changed_lines(curwin->w_cursor.lnum, 0, curwin->w_cursor.lnum, 1L);
2265
2266 curwin->w_cursor.col = newcol;
2267 curwin->w_cursor.coladd = 0;
2268
Bram Moolenaar24959102022-05-07 20:01:16 +01002269 // In MODE_VREPLACE state, we are handling the replace stack ourselves, so
2270 // stop fixthisline() from doing it (via change_indent()) by telling it
2271 // we're in normal MODE_INSERT state.
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002272 if (State & VREPLACE_FLAG)
2273 {
2274 vreplace_mode = State; // So we know to put things right later
Bram Moolenaar24959102022-05-07 20:01:16 +01002275 State = MODE_INSERT;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002276 }
2277 else
2278 vreplace_mode = 0;
Bram Moolenaar8e145b82022-05-21 20:17:31 +01002279
Bram Moolenaar49846fb2022-10-15 16:05:33 +01002280 if (!p_paste)
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002281 {
Bram Moolenaar49846fb2022-10-15 16:05:33 +01002282 if (leader == NULL
2283 && !use_indentexpr_for_lisp()
2284 && curbuf->b_p_lisp
2285 && curbuf->b_p_ai)
2286 {
2287 // do lisp indenting
2288 fixthisline(get_lisp_indent);
2289 ai_col = (colnr_T)getwhitecols_curline();
2290 }
2291 else if (do_cindent || (curbuf->b_p_ai && use_indentexpr_for_lisp()))
2292 {
2293 // do 'cindent' or 'indentexpr' indenting
2294 do_c_expr_indent();
2295 ai_col = (colnr_T)getwhitecols_curline();
2296 }
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002297 }
Bram Moolenaar8e145b82022-05-21 20:17:31 +01002298
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002299 if (vreplace_mode != 0)
2300 State = vreplace_mode;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002301
Bram Moolenaar24959102022-05-07 20:01:16 +01002302 // Finally, MODE_VREPLACE gets the stuff on the new line, then puts back
2303 // the original line, and inserts the new stuff char by char, pushing old
2304 // stuff onto the replace stack (via ins_char()).
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002305 if (State & VREPLACE_FLAG)
2306 {
2307 // Put new line in p_extra
John Marriottbfcc8952024-03-11 22:04:45 +01002308 p_extra = vim_strnsave(ml_get_curline(), ml_get_curline_len());
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002309 if (p_extra == NULL)
2310 goto theend;
2311
2312 // Put back original line
2313 ml_replace(curwin->w_cursor.lnum, next_line, FALSE);
2314
2315 // Insert new stuff into line again
2316 curwin->w_cursor.col = 0;
2317 curwin->w_cursor.coladd = 0;
2318 ins_bytes(p_extra); // will call changed_bytes()
2319 vim_free(p_extra);
2320 next_line = NULL;
2321 }
2322
2323 retval = OK; // success!
2324theend:
2325 curbuf->b_p_pi = saved_pi;
2326 vim_free(saved_line);
2327 vim_free(next_line);
2328 vim_free(allocated);
2329 return retval;
2330}
2331
2332/*
2333 * Delete from cursor to end of line.
2334 * Caller must have prepared for undo.
2335 * If "fixpos" is TRUE fix the cursor position when done.
2336 *
2337 * Return FAIL for failure, OK otherwise.
2338 */
2339 int
2340truncate_line(int fixpos)
2341{
2342 char_u *newp;
2343 linenr_T lnum = curwin->w_cursor.lnum;
2344 colnr_T col = curwin->w_cursor.col;
LemonBoyd0b1a092022-05-12 18:45:18 +01002345 char_u *old_line;
2346 int deleted;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002347
LemonBoyd0b1a092022-05-12 18:45:18 +01002348 old_line = ml_get(lnum);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002349 if (col == 0)
2350 newp = vim_strsave((char_u *)"");
2351 else
LemonBoyd0b1a092022-05-12 18:45:18 +01002352 newp = vim_strnsave(old_line, col);
John Marriottbfcc8952024-03-11 22:04:45 +01002353 deleted = (int)ml_get_len(lnum) - col;
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002354
2355 if (newp == NULL)
2356 return FAIL;
2357
2358 ml_replace(lnum, newp, FALSE);
2359
2360 // mark the buffer as changed and prepare for displaying
LemonBoyd0b1a092022-05-12 18:45:18 +01002361 inserted_bytes(lnum, curwin->w_cursor.col, -deleted);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002362
2363 // If "fixpos" is TRUE we don't want to end up positioned at the NUL.
2364 if (fixpos && curwin->w_cursor.col > 0)
2365 --curwin->w_cursor.col;
2366
2367 return OK;
2368}
2369
2370/*
2371 * Delete "nlines" lines at the cursor.
2372 * Saves the lines for undo first if "undo" is TRUE.
2373 */
2374 void
2375del_lines(long nlines, int undo)
2376{
2377 long n;
2378 linenr_T first = curwin->w_cursor.lnum;
2379
2380 if (nlines <= 0)
2381 return;
2382
2383 // save the deleted lines for undo
2384 if (undo && u_savedel(first, nlines) == FAIL)
2385 return;
2386
2387 for (n = 0; n < nlines; )
2388 {
2389 if (curbuf->b_ml.ml_flags & ML_EMPTY) // nothing to delete
2390 break;
2391
Bram Moolenaarca70c072020-05-30 20:30:46 +02002392 ml_delete_flags(first, ML_DEL_MESSAGE);
Bram Moolenaar3f86ca02019-05-11 18:30:00 +02002393 ++n;
2394
2395 // If we delete the last line in the file, stop
2396 if (first > curbuf->b_ml.ml_line_count)
2397 break;
2398 }
2399
2400 // Correct the cursor position before calling deleted_lines_mark(), it may
2401 // trigger a callback to display the cursor.
2402 curwin->w_cursor.col = 0;
2403 check_cursor_lnum();
2404
2405 // adjust marks, mark the buffer as changed and prepare for displaying
2406 deleted_lines_mark(first, n);
2407}