blob: b9308789e19eb792b6d5b8da6e5582184386a02d [file] [log] [blame]
Bram Moolenaaredf3f972016-08-29 22:49:24 +02001/* vi:set ts=8 sts=4 sw=4 noet:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
9
10/*
11 * ops.c: implementation of various operators: op_shift, op_delete, op_tilde,
Bram Moolenaar032a2d02020-12-22 17:59:35 +010012 * op_change, op_yank, do_join
Bram Moolenaar071d4272004-06-13 20:20:40 +000013 */
14
15#include "vim.h"
16
Bram Moolenaarbaaa7e92016-01-29 22:47:03 +010017static void shift_block(oparg_T *oap, int amount);
Bram Moolenaarbaaa7e92016-01-29 22:47:03 +010018static void mb_adjust_opend(oparg_T *oap);
Bram Moolenaarbaaa7e92016-01-29 22:47:03 +010019static int do_addsub(int op_type, pos_T *pos, int length, linenr_T Prenum1);
Bram Moolenaar071d4272004-06-13 20:20:40 +000020
Bram Moolenaarf2732452018-06-03 14:47:35 +020021// Flags for third item in "opchars".
22#define OPF_LINES 1 // operator always works on lines
23#define OPF_CHANGE 2 // operator changes text
24
Bram Moolenaar071d4272004-06-13 20:20:40 +000025/*
26 * The names of operators.
27 * IMPORTANT: Index must correspond with defines in vim.h!!!
Bram Moolenaarf2732452018-06-03 14:47:35 +020028 * The third field holds OPF_ flags.
Bram Moolenaar071d4272004-06-13 20:20:40 +000029 */
30static char opchars[][3] =
31{
Bram Moolenaarf2732452018-06-03 14:47:35 +020032 {NUL, NUL, 0}, // OP_NOP
33 {'d', NUL, OPF_CHANGE}, // OP_DELETE
34 {'y', NUL, 0}, // OP_YANK
35 {'c', NUL, OPF_CHANGE}, // OP_CHANGE
36 {'<', NUL, OPF_LINES | OPF_CHANGE}, // OP_LSHIFT
37 {'>', NUL, OPF_LINES | OPF_CHANGE}, // OP_RSHIFT
38 {'!', NUL, OPF_LINES | OPF_CHANGE}, // OP_FILTER
39 {'g', '~', OPF_CHANGE}, // OP_TILDE
40 {'=', NUL, OPF_LINES | OPF_CHANGE}, // OP_INDENT
41 {'g', 'q', OPF_LINES | OPF_CHANGE}, // OP_FORMAT
42 {':', NUL, OPF_LINES}, // OP_COLON
43 {'g', 'U', OPF_CHANGE}, // OP_UPPER
44 {'g', 'u', OPF_CHANGE}, // OP_LOWER
45 {'J', NUL, OPF_LINES | OPF_CHANGE}, // DO_JOIN
46 {'g', 'J', OPF_LINES | OPF_CHANGE}, // DO_JOIN_NS
47 {'g', '?', OPF_CHANGE}, // OP_ROT13
48 {'r', NUL, OPF_CHANGE}, // OP_REPLACE
49 {'I', NUL, OPF_CHANGE}, // OP_INSERT
50 {'A', NUL, OPF_CHANGE}, // OP_APPEND
51 {'z', 'f', OPF_LINES}, // OP_FOLD
52 {'z', 'o', OPF_LINES}, // OP_FOLDOPEN
53 {'z', 'O', OPF_LINES}, // OP_FOLDOPENREC
54 {'z', 'c', OPF_LINES}, // OP_FOLDCLOSE
55 {'z', 'C', OPF_LINES}, // OP_FOLDCLOSEREC
56 {'z', 'd', OPF_LINES}, // OP_FOLDDEL
57 {'z', 'D', OPF_LINES}, // OP_FOLDDELREC
58 {'g', 'w', OPF_LINES | OPF_CHANGE}, // OP_FORMAT2
59 {'g', '@', OPF_CHANGE}, // OP_FUNCTION
60 {Ctrl_A, NUL, OPF_CHANGE}, // OP_NR_ADD
61 {Ctrl_X, NUL, OPF_CHANGE}, // OP_NR_SUB
Bram Moolenaar071d4272004-06-13 20:20:40 +000062};
63
64/*
65 * Translate a command name into an operator type.
66 * Must only be called with a valid operator name!
67 */
68 int
Bram Moolenaar9b578142016-01-30 19:39:49 +010069get_op_type(int char1, int char2)
Bram Moolenaar071d4272004-06-13 20:20:40 +000070{
71 int i;
72
Bram Moolenaar6e0ce172019-12-05 20:12:41 +010073 if (char1 == 'r') // ignore second character
Bram Moolenaar071d4272004-06-13 20:20:40 +000074 return OP_REPLACE;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +010075 if (char1 == '~') // when tilde is an operator
Bram Moolenaar071d4272004-06-13 20:20:40 +000076 return OP_TILDE;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +010077 if (char1 == 'g' && char2 == Ctrl_A) // add
Bram Moolenaard79e5502016-01-10 22:13:02 +010078 return OP_NR_ADD;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +010079 if (char1 == 'g' && char2 == Ctrl_X) // subtract
Bram Moolenaard79e5502016-01-10 22:13:02 +010080 return OP_NR_SUB;
Christian Brabandt544a38e2021-06-10 19:39:11 +020081 if (char1 == 'z' && char2 == 'y') // OP_YANK
82 return OP_YANK;
Bram Moolenaar071d4272004-06-13 20:20:40 +000083 for (i = 0; ; ++i)
Bram Moolenaar2efb3232017-12-19 12:27:23 +010084 {
Bram Moolenaar071d4272004-06-13 20:20:40 +000085 if (opchars[i][0] == char1 && opchars[i][1] == char2)
86 break;
K.Takataeeec2542021-06-02 13:28:16 +020087 if (i == (int)ARRAY_LENGTH(opchars) - 1)
Bram Moolenaar2efb3232017-12-19 12:27:23 +010088 {
89 internal_error("get_op_type()");
90 break;
91 }
92 }
Bram Moolenaar071d4272004-06-13 20:20:40 +000093 return i;
94}
95
Bram Moolenaar071d4272004-06-13 20:20:40 +000096/*
97 * Return TRUE if operator "op" always works on whole lines.
98 */
Bram Moolenaar792cf5e2019-09-30 23:12:16 +020099 static int
Bram Moolenaar9b578142016-01-30 19:39:49 +0100100op_on_lines(int op)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000101{
Bram Moolenaarf2732452018-06-03 14:47:35 +0200102 return opchars[op][2] & OPF_LINES;
103}
104
Bram Moolenaar113e1072019-01-20 15:30:40 +0100105#if defined(FEAT_JOB_CHANNEL) || defined(PROTO)
Bram Moolenaarf2732452018-06-03 14:47:35 +0200106/*
107 * Return TRUE if operator "op" changes text.
108 */
109 int
110op_is_change(int op)
111{
112 return opchars[op][2] & OPF_CHANGE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000113}
Bram Moolenaar113e1072019-01-20 15:30:40 +0100114#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000115
116/*
117 * Get first operator command character.
118 * Returns 'g' or 'z' if there is another command character.
119 */
120 int
Bram Moolenaar9b578142016-01-30 19:39:49 +0100121get_op_char(int optype)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000122{
123 return opchars[optype][0];
124}
125
126/*
127 * Get second operator command character.
128 */
129 int
Bram Moolenaar9b578142016-01-30 19:39:49 +0100130get_extra_op_char(int optype)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000131{
132 return opchars[optype][1];
133}
134
135/*
136 * op_shift - handle a shift operation
137 */
138 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100139op_shift(oparg_T *oap, int curs_top, int amount)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000140{
141 long i;
142 int first_char;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000143 int block_col = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000144
145 if (u_save((linenr_T)(oap->start.lnum - 1),
146 (linenr_T)(oap->end.lnum + 1)) == FAIL)
147 return;
148
Bram Moolenaar071d4272004-06-13 20:20:40 +0000149 if (oap->block_mode)
150 block_col = curwin->w_cursor.col;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000151
152 for (i = oap->line_count; --i >= 0; )
153 {
154 first_char = *ml_get_curline();
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100155 if (first_char == NUL) // empty line
Bram Moolenaar071d4272004-06-13 20:20:40 +0000156 curwin->w_cursor.col = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000157 else if (oap->block_mode)
158 shift_block(oap, amount);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000159 else
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100160 // Move the line right if it doesn't start with '#', 'smartindent'
161 // isn't set or 'cindent' isn't set or '#' isn't in 'cino'.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000162 if (first_char != '#' || !preprocs_left())
Bram Moolenaar8e145b82022-05-21 20:17:31 +0100163 shift_line(oap->op_type == OP_LSHIFT, p_sr, amount, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000164 ++curwin->w_cursor.lnum;
165 }
166
167 changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000168 if (oap->block_mode)
169 {
170 curwin->w_cursor.lnum = oap->start.lnum;
171 curwin->w_cursor.col = block_col;
172 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100173 else if (curs_top) // put cursor on first line, for ">>"
Bram Moolenaar071d4272004-06-13 20:20:40 +0000174 {
175 curwin->w_cursor.lnum = oap->start.lnum;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100176 beginline(BL_SOL | BL_FIX); // shift_line() may have set cursor.col
Bram Moolenaar071d4272004-06-13 20:20:40 +0000177 }
178 else
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100179 --curwin->w_cursor.lnum; // put cursor on last line, for ":>"
Bram Moolenaar071d4272004-06-13 20:20:40 +0000180
Bram Moolenaar54b2bfa2017-01-02 14:57:08 +0100181#ifdef FEAT_FOLDING
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100182 // The cursor line is not in a closed fold
Bram Moolenaar54b2bfa2017-01-02 14:57:08 +0100183 foldOpenCursor();
184#endif
185
186
Bram Moolenaar071d4272004-06-13 20:20:40 +0000187 if (oap->line_count > p_report)
188 {
Bram Moolenaarda6e8912018-08-21 15:12:14 +0200189 char *op;
190 char *msg_line_single;
191 char *msg_line_plural;
192
Bram Moolenaar071d4272004-06-13 20:20:40 +0000193 if (oap->op_type == OP_RSHIFT)
Bram Moolenaarda6e8912018-08-21 15:12:14 +0200194 op = ">";
Bram Moolenaar071d4272004-06-13 20:20:40 +0000195 else
Bram Moolenaarda6e8912018-08-21 15:12:14 +0200196 op = "<";
197 msg_line_single = NGETTEXT("%ld line %sed %d time",
198 "%ld line %sed %d times", amount);
199 msg_line_plural = NGETTEXT("%ld lines %sed %d time",
200 "%ld lines %sed %d times", amount);
201 vim_snprintf((char *)IObuff, IOSIZE,
202 NGETTEXT(msg_line_single, msg_line_plural, oap->line_count),
203 oap->line_count, op, amount);
Bram Moolenaare4fc7462020-03-15 19:17:50 +0100204 msg_attr_keep((char *)IObuff, 0, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000205 }
206
Bram Moolenaare1004402020-10-24 20:49:43 +0200207 if ((cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0)
Bram Moolenaarf4a1d1c2019-11-16 13:50:25 +0100208 {
209 // Set "'[" and "']" marks.
210 curbuf->b_op_start = oap->start;
211 curbuf->b_op_end.lnum = oap->end.lnum;
212 curbuf->b_op_end.col = (colnr_T)STRLEN(ml_get(oap->end.lnum));
213 if (curbuf->b_op_end.col > 0)
214 --curbuf->b_op_end.col;
215 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000216}
217
218/*
Bram Moolenaar870ba5f2019-01-11 14:37:20 +0100219 * Shift the current line one shiftwidth left (if left != 0) or right
220 * leaves cursor on first blank in the line.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000221 */
222 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100223shift_line(
224 int left,
225 int round,
226 int amount,
Bram Moolenaar8c96af92019-09-28 19:05:57 +0200227 int call_changed_bytes) // call changed_bytes()
Bram Moolenaar071d4272004-06-13 20:20:40 +0000228{
229 int count;
230 int i, j;
Bram Moolenaardac13472019-09-16 21:06:21 +0200231 int sw_val = (int)get_sw_value_indent(curbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000232
Bram Moolenaar8c96af92019-09-28 19:05:57 +0200233 count = get_indent(); // get current indent
Bram Moolenaar071d4272004-06-13 20:20:40 +0000234
Bram Moolenaar8c96af92019-09-28 19:05:57 +0200235 if (round) // round off indent
Bram Moolenaar071d4272004-06-13 20:20:40 +0000236 {
Bram Moolenaar8c96af92019-09-28 19:05:57 +0200237 i = count / sw_val; // number of 'shiftwidth' rounded down
238 j = count % sw_val; // extra spaces
239 if (j && left) // first remove extra spaces
Bram Moolenaar071d4272004-06-13 20:20:40 +0000240 --amount;
241 if (left)
242 {
243 i -= amount;
244 if (i < 0)
245 i = 0;
246 }
247 else
248 i += amount;
Bram Moolenaardac13472019-09-16 21:06:21 +0200249 count = i * sw_val;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000250 }
Bram Moolenaar8c96af92019-09-28 19:05:57 +0200251 else // original vi indent
Bram Moolenaar071d4272004-06-13 20:20:40 +0000252 {
253 if (left)
254 {
Bram Moolenaardac13472019-09-16 21:06:21 +0200255 count -= sw_val * amount;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000256 if (count < 0)
257 count = 0;
258 }
259 else
Bram Moolenaardac13472019-09-16 21:06:21 +0200260 count += sw_val * amount;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000261 }
262
Bram Moolenaar8c96af92019-09-28 19:05:57 +0200263 // Set new indent
Bram Moolenaar071d4272004-06-13 20:20:40 +0000264 if (State & VREPLACE_FLAG)
Bram Moolenaar21b17e72008-01-16 19:03:13 +0000265 change_indent(INDENT_SET, count, FALSE, NUL, call_changed_bytes);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000266 else
Bram Moolenaar21b17e72008-01-16 19:03:13 +0000267 (void)set_indent(count, call_changed_bytes ? SIN_CHANGED : 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000268}
269
Bram Moolenaar071d4272004-06-13 20:20:40 +0000270/*
271 * Shift one line of the current block one shiftwidth right or left.
272 * Leaves cursor on first character in block.
273 */
274 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100275shift_block(oparg_T *oap, int amount)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000276{
277 int left = (oap->op_type == OP_LSHIFT);
278 int oldstate = State;
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000279 int total;
280 char_u *newp, *oldp;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000281 int oldcol = curwin->w_cursor.col;
Bram Moolenaardac13472019-09-16 21:06:21 +0200282 int sw_val = (int)get_sw_value_indent(curbuf);
283 int ts_val = (int)curbuf->b_p_ts;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000284 struct block_def bd;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000285 int incr;
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000286 colnr_T ws_vcol;
LemonBoy4b936742022-05-13 21:56:28 +0100287 int added;
288 unsigned new_line_len; // the length of the line after the
289 // block shift
Bram Moolenaar071d4272004-06-13 20:20:40 +0000290#ifdef FEAT_RIGHTLEFT
291 int old_p_ri = p_ri;
292
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100293 p_ri = 0; // don't want revins in indent
Bram Moolenaar071d4272004-06-13 20:20:40 +0000294#endif
295
Bram Moolenaar24959102022-05-07 20:01:16 +0100296 State = MODE_INSERT; // don't want MODE_REPLACE for State
Bram Moolenaar071d4272004-06-13 20:20:40 +0000297 block_prep(oap, &bd, curwin->w_cursor.lnum, TRUE);
298 if (bd.is_short)
299 return;
300
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100301 // total is number of screen columns to be inserted/removed
Bram Moolenaardac13472019-09-16 21:06:21 +0200302 total = (int)((unsigned)amount * (unsigned)sw_val);
303 if ((total / sw_val) != amount)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100304 return; // multiplication overflow
Bram Moolenaarbae5a172017-08-06 15:42:06 +0200305
Bram Moolenaar071d4272004-06-13 20:20:40 +0000306 oldp = ml_get_curline();
307
308 if (!left)
309 {
LemonBoy4b936742022-05-13 21:56:28 +0100310 int tabs = 0, spaces = 0;
311
Bram Moolenaar071d4272004-06-13 20:20:40 +0000312 /*
313 * 1. Get start vcol
314 * 2. Total ws vcols
315 * 3. Divvy into TABs & spp
316 * 4. Construct new string
317 */
Bram Moolenaar4b96df52020-01-26 22:00:26 +0100318 total += bd.pre_whitesp; // all virtual WS up to & incl a split TAB
Bram Moolenaar071d4272004-06-13 20:20:40 +0000319 ws_vcol = bd.start_vcol - bd.pre_whitesp;
320 if (bd.startspaces)
321 {
Bram Moolenaar071d4272004-06-13 20:20:40 +0000322 if (has_mbyte)
Bram Moolenaar20b4f462016-03-05 17:25:39 +0100323 {
324 if ((*mb_ptr2len)(bd.textstart) == 1)
325 ++bd.textstart;
326 else
327 {
328 ws_vcol = 0;
329 bd.startspaces = 0;
330 }
331 }
Bram Moolenaarbe1138b2009-11-11 16:22:28 +0000332 else
Bram Moolenaarbe1138b2009-11-11 16:22:28 +0000333 ++bd.textstart;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000334 }
Bram Moolenaar1c465442017-03-12 20:10:05 +0100335 for ( ; VIM_ISWHITE(*bd.textstart); )
Bram Moolenaar071d4272004-06-13 20:20:40 +0000336 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100337 // TODO: is passing bd.textstart for start of the line OK?
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +0000338 incr = lbr_chartabsize_adv(bd.textstart, &bd.textstart, bd.start_vcol);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000339 total += incr;
340 bd.start_vcol += incr;
341 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100342 // OK, now total=all the VWS reqd, and textstart points at the 1st
343 // non-ws char in the block.
Bram Moolenaar04958cb2018-06-23 19:23:02 +0200344#ifdef FEAT_VARTABS
345 if (!curbuf->b_p_et)
Bram Moolenaardac13472019-09-16 21:06:21 +0200346 tabstop_fromto(ws_vcol, ws_vcol + total,
LemonBoy4b936742022-05-13 21:56:28 +0100347 ts_val, curbuf->b_p_vts_array, &tabs, &spaces);
Bram Moolenaar04958cb2018-06-23 19:23:02 +0200348 else
LemonBoy4b936742022-05-13 21:56:28 +0100349 spaces = total;
Bram Moolenaar04958cb2018-06-23 19:23:02 +0200350#else
Bram Moolenaar071d4272004-06-13 20:20:40 +0000351 if (!curbuf->b_p_et)
LemonBoy4b936742022-05-13 21:56:28 +0100352 tabs = ((ws_vcol % ts_val) + total) / ts_val; // number of tabs
353 if (tabs > 0)
354 spaces = ((ws_vcol % ts_val) + total) % ts_val; // number of spp
Bram Moolenaar071d4272004-06-13 20:20:40 +0000355 else
LemonBoy4b936742022-05-13 21:56:28 +0100356 spaces = total;
Bram Moolenaar04958cb2018-06-23 19:23:02 +0200357#endif
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100358 // if we're splitting a TAB, allow for it
Bram Moolenaar071d4272004-06-13 20:20:40 +0000359 bd.textcol -= bd.pre_whitesp_c - (bd.startspaces != 0);
LemonBoy4b936742022-05-13 21:56:28 +0100360
361 new_line_len = bd.textcol + tabs + spaces + (int)STRLEN(bd.textstart);
362 newp = alloc(new_line_len + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000363 if (newp == NULL)
364 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000365 mch_memmove(newp, oldp, (size_t)bd.textcol);
LemonBoy4b936742022-05-13 21:56:28 +0100366 vim_memset(newp + bd.textcol, TAB, (size_t)tabs);
367 vim_memset(newp + bd.textcol + tabs, ' ', (size_t)spaces);
368 // Note that STRMOVE() copies the trailing NUL.
369 STRMOVE(newp + bd.textcol + tabs + spaces, bd.textstart);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000370 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100371 else // left
Bram Moolenaar071d4272004-06-13 20:20:40 +0000372 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100373 colnr_T destination_col; // column to which text in block will
374 // be shifted
375 char_u *verbatim_copy_end; // end of the part of the line which is
376 // copied verbatim
377 colnr_T verbatim_copy_width;// the (displayed) width of this part
378 // of line
379 unsigned fill; // nr of spaces that replace a TAB
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000380 size_t block_space_width;
381 size_t shift_amount;
382 char_u *non_white = bd.textstart;
383 colnr_T non_white_col;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000384
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000385 /*
386 * Firstly, let's find the first non-whitespace character that is
387 * displayed after the block's start column and the character's column
388 * number. Also, let's calculate the width of all the whitespace
389 * characters that are displayed in the block and precede the searched
390 * non-whitespace character.
391 */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000392
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100393 // If "bd.startspaces" is set, "bd.textstart" points to the character,
394 // the part of which is displayed at the block's beginning. Let's start
395 // searching from the next character.
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000396 if (bd.startspaces)
Bram Moolenaar91acfff2017-03-12 19:22:36 +0100397 MB_PTR_ADV(non_white);
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000398
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100399 // The character's column is in "bd.start_vcol".
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000400 non_white_col = bd.start_vcol;
401
Bram Moolenaar1c465442017-03-12 20:10:05 +0100402 while (VIM_ISWHITE(*non_white))
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000403 {
Bram Moolenaar597a4222014-06-25 14:39:50 +0200404 incr = lbr_chartabsize_adv(bd.textstart, &non_white, non_white_col);
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000405 non_white_col += incr;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000406 }
407
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000408 block_space_width = non_white_col - oap->start_vcol;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100409 // We will shift by "total" or "block_space_width", whichever is less.
Bram Moolenaar92a990b2009-04-22 15:45:05 +0000410 shift_amount = (block_space_width < (size_t)total
411 ? block_space_width : (size_t)total);
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000412
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100413 // The column to which we will shift the text.
Bram Moolenaar92a990b2009-04-22 15:45:05 +0000414 destination_col = (colnr_T)(non_white_col - shift_amount);
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000415
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100416 // Now let's find out how much of the beginning of the line we can
417 // reuse without modification.
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000418 verbatim_copy_end = bd.textstart;
419 verbatim_copy_width = bd.start_vcol;
420
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100421 // If "bd.startspaces" is set, "bd.textstart" points to the character
422 // preceding the block. We have to subtract its width to obtain its
423 // column number.
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000424 if (bd.startspaces)
425 verbatim_copy_width -= bd.start_char_vcols;
426 while (verbatim_copy_width < destination_col)
427 {
Bram Moolenaar597a4222014-06-25 14:39:50 +0200428 char_u *line = verbatim_copy_end;
429
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100430 // TODO: is passing verbatim_copy_end for start of the line OK?
Bram Moolenaar597a4222014-06-25 14:39:50 +0200431 incr = lbr_chartabsize(line, verbatim_copy_end,
432 verbatim_copy_width);
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000433 if (verbatim_copy_width + incr > destination_col)
434 break;
435 verbatim_copy_width += incr;
Bram Moolenaar91acfff2017-03-12 19:22:36 +0100436 MB_PTR_ADV(verbatim_copy_end);
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000437 }
438
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100439 // If "destination_col" is different from the width of the initial
440 // part of the line that will be copied, it means we encountered a tab
441 // character, which we will have to partly replace with spaces.
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000442 fill = destination_col - verbatim_copy_width;
443
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100444 // The replacement line will consist of:
445 // - the beginning of the original line up to "verbatim_copy_end",
446 // - "fill" number of spaces,
447 // - the rest of the line, pointed to by non_white.
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000448 new_line_len = (unsigned)(verbatim_copy_end - oldp)
449 + fill
LemonBoy4b936742022-05-13 21:56:28 +0100450 + (unsigned)STRLEN(non_white);
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000451
LemonBoy4b936742022-05-13 21:56:28 +0100452 newp = alloc(new_line_len + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000453 if (newp == NULL)
454 return;
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000455 mch_memmove(newp, oldp, (size_t)(verbatim_copy_end - oldp));
Bram Moolenaar2536d4f2015-07-17 13:22:51 +0200456 vim_memset(newp + (verbatim_copy_end - oldp), ' ', (size_t)fill);
LemonBoy4b936742022-05-13 21:56:28 +0100457 // Note that STRMOVE() copies the trailing NUL.
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +0000458 STRMOVE(newp + (verbatim_copy_end - oldp) + fill, non_white);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000459 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100460 // replace the line
LemonBoy4b936742022-05-13 21:56:28 +0100461 added = new_line_len - (int)STRLEN(oldp);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000462 ml_replace(curwin->w_cursor.lnum, newp, FALSE);
LemonBoy4b936742022-05-13 21:56:28 +0100463 inserted_bytes(curwin->w_cursor.lnum, bd.textcol, added);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000464 State = oldstate;
465 curwin->w_cursor.col = oldcol;
466#ifdef FEAT_RIGHTLEFT
467 p_ri = old_p_ri;
468#endif
469}
Bram Moolenaar071d4272004-06-13 20:20:40 +0000470
Bram Moolenaar071d4272004-06-13 20:20:40 +0000471/*
472 * Insert string "s" (b_insert ? before : after) block :AKelly
473 * Caller must prepare for undo.
474 */
475 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100476block_insert(
477 oparg_T *oap,
478 char_u *s,
479 int b_insert,
480 struct block_def *bdp)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000481{
Bram Moolenaardac13472019-09-16 21:06:21 +0200482 int ts_val;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100483 int count = 0; // extra spaces to replace a cut TAB
484 int spaces = 0; // non-zero if cutting a TAB
485 colnr_T offset; // pointer along new line
Bram Moolenaar8b51b7f2020-09-15 21:34:18 +0200486 colnr_T startcol; // column where insert starts
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100487 unsigned s_len; // STRLEN(s)
488 char_u *newp, *oldp; // new, old lines
489 linenr_T lnum; // loop var
Bram Moolenaar071d4272004-06-13 20:20:40 +0000490 int oldstate = State;
491
Bram Moolenaar24959102022-05-07 20:01:16 +0100492 State = MODE_INSERT; // don't want MODE_REPLACE for State
Bram Moolenaar071d4272004-06-13 20:20:40 +0000493 s_len = (unsigned)STRLEN(s);
494
495 for (lnum = oap->start.lnum + 1; lnum <= oap->end.lnum; lnum++)
496 {
497 block_prep(oap, bdp, lnum, TRUE);
498 if (bdp->is_short && b_insert)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100499 continue; // OP_INSERT, line ends before block start
Bram Moolenaar071d4272004-06-13 20:20:40 +0000500
501 oldp = ml_get(lnum);
502
503 if (b_insert)
504 {
Bram Moolenaardac13472019-09-16 21:06:21 +0200505 ts_val = bdp->start_char_vcols;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000506 spaces = bdp->startspaces;
507 if (spaces != 0)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100508 count = ts_val - 1; // we're cutting a TAB
Bram Moolenaar071d4272004-06-13 20:20:40 +0000509 offset = bdp->textcol;
510 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100511 else // append
Bram Moolenaar071d4272004-06-13 20:20:40 +0000512 {
Bram Moolenaardac13472019-09-16 21:06:21 +0200513 ts_val = bdp->end_char_vcols;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100514 if (!bdp->is_short) // spaces = padding after block
Bram Moolenaar071d4272004-06-13 20:20:40 +0000515 {
Bram Moolenaardac13472019-09-16 21:06:21 +0200516 spaces = (bdp->endspaces ? ts_val - bdp->endspaces : 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000517 if (spaces != 0)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100518 count = ts_val - 1; // we're cutting a TAB
Bram Moolenaar071d4272004-06-13 20:20:40 +0000519 offset = bdp->textcol + bdp->textlen - (spaces != 0);
520 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100521 else // spaces = padding to block edge
Bram Moolenaar071d4272004-06-13 20:20:40 +0000522 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100523 // if $ used, just append to EOL (ie spaces==0)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000524 if (!bdp->is_MAX)
525 spaces = (oap->end_vcol - bdp->end_vcol) + 1;
526 count = spaces;
527 offset = bdp->textcol + bdp->textlen;
528 }
529 }
530
Bram Moolenaarb5cf6c32014-08-16 18:36:43 +0200531 if (has_mbyte && spaces > 0)
Bram Moolenaar57df9e82022-01-20 12:10:48 +0000532 // avoid copying part of a multi-byte character
533 offset -= (*mb_head_off)(oldp, oldp + offset);
Bram Moolenaarfc3f23b2014-12-17 18:35:42 +0100534
Bram Moolenaar4067bd32021-06-29 18:54:35 +0200535 if (spaces < 0) // can happen when the cursor was moved
536 spaces = 0;
Bram Moolenaarb5cf6c32014-08-16 18:36:43 +0200537
Bram Moolenaar9f8c3042022-01-17 17:30:21 +0000538 // Make sure the allocated size matches what is actually copied below.
539 newp = alloc(STRLEN(oldp) + spaces + s_len
540 + (spaces > 0 && !bdp->is_short ? ts_val - spaces : 0)
541 + count + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000542 if (newp == NULL)
543 continue;
544
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100545 // copy up to shifted part
Bram Moolenaar9f8c3042022-01-17 17:30:21 +0000546 mch_memmove(newp, oldp, (size_t)offset);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000547 oldp += offset;
548
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100549 // insert pre-padding
Bram Moolenaar2536d4f2015-07-17 13:22:51 +0200550 vim_memset(newp + offset, ' ', (size_t)spaces);
Bram Moolenaar8b51b7f2020-09-15 21:34:18 +0200551 startcol = offset + spaces;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000552
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100553 // copy the new text
Bram Moolenaar8b51b7f2020-09-15 21:34:18 +0200554 mch_memmove(newp + startcol, s, (size_t)s_len);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000555 offset += s_len;
556
Bram Moolenaar9f8c3042022-01-17 17:30:21 +0000557 if (spaces > 0 && !bdp->is_short)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000558 {
Bram Moolenaar9f8c3042022-01-17 17:30:21 +0000559 if (*oldp == TAB)
560 {
561 // insert post-padding
562 vim_memset(newp + offset + spaces, ' ',
563 (size_t)(ts_val - spaces));
564 // we're splitting a TAB, don't copy it
565 oldp++;
566 // We allowed for that TAB, remember this now
567 count++;
568 }
569 else
570 // Not a TAB, no extra spaces
571 count = spaces;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000572 }
573
574 if (spaces > 0)
575 offset += count;
Bram Moolenaarc1a11ed2008-06-24 22:09:24 +0000576 STRMOVE(newp + offset, oldp);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000577
578 ml_replace(lnum, newp, FALSE);
579
Bram Moolenaar8b51b7f2020-09-15 21:34:18 +0200580 if (b_insert)
581 // correct any text properties
582 inserted_bytes(lnum, startcol, s_len);
583
Bram Moolenaar071d4272004-06-13 20:20:40 +0000584 if (lnum == oap->end.lnum)
585 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100586 // Set "']" mark to the end of the block instead of the end of
587 // the insert in the first line.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000588 curbuf->b_op_end.lnum = oap->end.lnum;
589 curbuf->b_op_end.col = offset;
590 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100591 } // for all lnum
Bram Moolenaar071d4272004-06-13 20:20:40 +0000592
593 changed_lines(oap->start.lnum + 1, 0, oap->end.lnum + 1, 0L);
594
595 State = oldstate;
596}
Bram Moolenaar071d4272004-06-13 20:20:40 +0000597
Bram Moolenaar071d4272004-06-13 20:20:40 +0000598/*
Bram Moolenaard04b7502010-07-08 22:27:55 +0200599 * Handle a delete operation.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000600 *
Bram Moolenaard04b7502010-07-08 22:27:55 +0200601 * Return FAIL if undo failed, OK otherwise.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000602 */
603 int
Bram Moolenaar9b578142016-01-30 19:39:49 +0100604op_delete(oparg_T *oap)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000605{
606 int n;
607 linenr_T lnum;
608 char_u *ptr;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000609 char_u *newp, *oldp;
610 struct block_def bd;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000611 linenr_T old_lcount = curbuf->b_ml.ml_line_count;
612 int did_yank = FALSE;
613
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100614 if (curbuf->b_ml.ml_flags & ML_EMPTY) // nothing to do
Bram Moolenaar071d4272004-06-13 20:20:40 +0000615 return OK;
616
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100617 // Nothing to delete, return here. Do prepare undo, for op_change().
Bram Moolenaar071d4272004-06-13 20:20:40 +0000618 if (oap->empty)
619 return u_save_cursor();
620
621 if (!curbuf->b_p_ma)
622 {
Bram Moolenaar108010a2021-06-27 22:03:33 +0200623 emsg(_(e_cannot_make_changes_modifiable_is_off));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000624 return FAIL;
625 }
626
Shougo Matsushita4ede01f2022-01-20 15:26:03 +0000627 if (VIsual_select && oap->is_VIsual)
628 // use register given with CTRL_R, defaults to zero
Bram Moolenaar6ed545e2022-05-09 20:09:23 +0100629 oap->regname = VIsual_select_reg;
Shougo Matsushita4ede01f2022-01-20 15:26:03 +0000630
Bram Moolenaar071d4272004-06-13 20:20:40 +0000631#ifdef FEAT_CLIPBOARD
632 adjust_clip_reg(&oap->regname);
633#endif
634
Bram Moolenaar071d4272004-06-13 20:20:40 +0000635 if (has_mbyte)
636 mb_adjust_opend(oap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000637
Bram Moolenaard04b7502010-07-08 22:27:55 +0200638 /*
639 * Imitate the strange Vi behaviour: If the delete spans more than one
640 * line and motion_type == MCHAR and the result is a blank line, make the
641 * delete linewise. Don't do this for the change command or Visual mode.
642 */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000643 if ( oap->motion_type == MCHAR
Bram Moolenaar071d4272004-06-13 20:20:40 +0000644 && !oap->is_VIsual
Bram Moolenaarec2dad62005-01-02 11:36:03 +0000645 && !oap->block_mode
Bram Moolenaar071d4272004-06-13 20:20:40 +0000646 && oap->line_count > 1
Bram Moolenaar64a72302012-01-10 13:46:22 +0100647 && oap->motion_force == NUL
Bram Moolenaar071d4272004-06-13 20:20:40 +0000648 && oap->op_type == OP_DELETE)
649 {
Bram Moolenaar44286ca2011-07-15 17:51:34 +0200650 ptr = ml_get(oap->end.lnum) + oap->end.col;
651 if (*ptr != NUL)
652 ptr += oap->inclusive;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000653 ptr = skipwhite(ptr);
654 if (*ptr == NUL && inindent(0))
655 oap->motion_type = MLINE;
656 }
657
Bram Moolenaard04b7502010-07-08 22:27:55 +0200658 /*
659 * Check for trying to delete (e.g. "D") in an empty line.
660 * Note: For the change operator it is ok.
661 */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000662 if ( oap->motion_type == MCHAR
663 && oap->line_count == 1
664 && oap->op_type == OP_DELETE
665 && *ml_get(oap->start.lnum) == NUL)
666 {
667 /*
Bram Moolenaar87e25fd2005-07-27 21:13:01 +0000668 * It's an error to operate on an empty region, when 'E' included in
Bram Moolenaar071d4272004-06-13 20:20:40 +0000669 * 'cpoptions' (Vi compatible).
670 */
Bram Moolenaar87e25fd2005-07-27 21:13:01 +0000671 if (virtual_op)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100672 // Virtual editing: Nothing gets deleted, but we set the '[ and ']
673 // marks as if it happened.
Bram Moolenaar87e25fd2005-07-27 21:13:01 +0000674 goto setmarks;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000675 if (vim_strchr(p_cpo, CPO_EMPTYREGION) != NULL)
676 beep_flush();
677 return OK;
678 }
679
Bram Moolenaard04b7502010-07-08 22:27:55 +0200680 /*
681 * Do a yank of whatever we're about to delete.
682 * If a yank register was specified, put the deleted text into that
683 * register. For the black hole register '_' don't yank anything.
684 */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000685 if (oap->regname != '_')
686 {
687 if (oap->regname != 0)
688 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100689 // check for read-only register
Bram Moolenaar071d4272004-06-13 20:20:40 +0000690 if (!valid_yank_reg(oap->regname, TRUE))
691 {
692 beep_flush();
693 return OK;
694 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100695 get_yank_register(oap->regname, TRUE); // yank into specif'd reg.
696 if (op_yank(oap, TRUE, FALSE) == OK) // yank without message
Bram Moolenaar071d4272004-06-13 20:20:40 +0000697 did_yank = TRUE;
698 }
Christian Brabandt78eb9cc2021-09-14 18:55:51 +0200699 else
700 reset_y_append(); // not appending to unnamed register
Bram Moolenaar071d4272004-06-13 20:20:40 +0000701
702 /*
703 * Put deleted text into register 1 and shift number registers if the
Bram Moolenaar9d7fdd42019-03-08 09:50:52 +0100704 * delete contains a line break, or when using a specific operator (Vi
705 * compatible)
Bram Moolenaar7c821302012-09-05 14:18:45 +0200706 * Use the register name from before adjust_clip_reg() may have
707 * changed it.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000708 */
Bram Moolenaar9d7fdd42019-03-08 09:50:52 +0100709 if (oap->motion_type == MLINE || oap->line_count > 1
710 || oap->use_reg_one)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000711 {
Bram Moolenaara1891842017-02-04 21:34:31 +0100712 shift_delete_registers();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000713 if (op_yank(oap, TRUE, FALSE) == OK)
714 did_yank = TRUE;
715 }
716
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100717 // Yank into small delete register when no named register specified
718 // and the delete is within one line.
Bram Moolenaar84298db2012-04-20 13:46:08 +0200719 if ((
720#ifdef FEAT_CLIPBOARD
Bram Moolenaarbfe3bf82012-06-13 17:28:55 +0200721 ((clip_unnamed & CLIP_UNNAMED) && oap->regname == '*') ||
722 ((clip_unnamed & CLIP_UNNAMED_PLUS) && oap->regname == '+') ||
Bram Moolenaar84298db2012-04-20 13:46:08 +0200723#endif
724 oap->regname == 0) && oap->motion_type != MLINE
Bram Moolenaar071d4272004-06-13 20:20:40 +0000725 && oap->line_count == 1)
726 {
727 oap->regname = '-';
728 get_yank_register(oap->regname, TRUE);
729 if (op_yank(oap, TRUE, FALSE) == OK)
730 did_yank = TRUE;
731 oap->regname = 0;
732 }
733
734 /*
735 * If there's too much stuff to fit in the yank register, then get a
736 * confirmation before doing the delete. This is crude, but simple.
737 * And it avoids doing a delete of something we can't put back if we
738 * want.
739 */
740 if (!did_yank)
741 {
742 int msg_silent_save = msg_silent;
743
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100744 msg_silent = 0; // must display the prompt
Bram Moolenaar071d4272004-06-13 20:20:40 +0000745 n = ask_yesno((char_u *)_("cannot yank; delete anyway"), TRUE);
746 msg_silent = msg_silent_save;
747 if (n != 'y')
748 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +0000749 emsg(_(e_command_aborted));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000750 return FAIL;
751 }
752 }
Bram Moolenaar7e1652c2017-12-16 18:27:02 +0100753
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100754#if defined(FEAT_EVAL)
Bram Moolenaar7e1652c2017-12-16 18:27:02 +0100755 if (did_yank && has_textyankpost())
Bram Moolenaar4aea03e2019-09-25 22:37:17 +0200756 yank_do_autocmd(oap, get_y_current());
Bram Moolenaar7e1652c2017-12-16 18:27:02 +0100757#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000758 }
759
Bram Moolenaard04b7502010-07-08 22:27:55 +0200760 /*
761 * block mode delete
762 */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000763 if (oap->block_mode)
764 {
765 if (u_save((linenr_T)(oap->start.lnum - 1),
766 (linenr_T)(oap->end.lnum + 1)) == FAIL)
767 return FAIL;
768
769 for (lnum = curwin->w_cursor.lnum; lnum <= oap->end.lnum; ++lnum)
770 {
771 block_prep(oap, &bd, lnum, TRUE);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100772 if (bd.textlen == 0) // nothing to delete
Bram Moolenaar071d4272004-06-13 20:20:40 +0000773 continue;
774
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100775 // Adjust cursor position for tab replaced by spaces and 'lbr'.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000776 if (lnum == curwin->w_cursor.lnum)
777 {
778 curwin->w_cursor.col = bd.textcol + bd.startspaces;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000779 curwin->w_cursor.coladd = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000780 }
781
Bram Moolenaar8055d172019-05-17 22:57:26 +0200782 // "n" == number of chars deleted
783 // If we delete a TAB, it may be replaced by several characters.
784 // Thus the number of characters may increase!
Bram Moolenaar071d4272004-06-13 20:20:40 +0000785 n = bd.textlen - bd.startspaces - bd.endspaces;
786 oldp = ml_get(lnum);
Bram Moolenaar964b3742019-05-24 18:54:09 +0200787 newp = alloc(STRLEN(oldp) + 1 - n);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000788 if (newp == NULL)
789 continue;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100790 // copy up to deleted part
Bram Moolenaar071d4272004-06-13 20:20:40 +0000791 mch_memmove(newp, oldp, (size_t)bd.textcol);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100792 // insert spaces
Bram Moolenaar2536d4f2015-07-17 13:22:51 +0200793 vim_memset(newp + bd.textcol, ' ',
Bram Moolenaar071d4272004-06-13 20:20:40 +0000794 (size_t)(bd.startspaces + bd.endspaces));
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100795 // copy the part after the deleted part
Bram Moolenaar071d4272004-06-13 20:20:40 +0000796 oldp += bd.textcol + bd.textlen;
Bram Moolenaarc1a11ed2008-06-24 22:09:24 +0000797 STRMOVE(newp + bd.textcol + bd.startspaces + bd.endspaces, oldp);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100798 // replace the line
Bram Moolenaar071d4272004-06-13 20:20:40 +0000799 ml_replace(lnum, newp, FALSE);
Bram Moolenaar8055d172019-05-17 22:57:26 +0200800
Bram Moolenaar05ad5ff2019-11-30 22:48:27 +0100801#ifdef FEAT_PROP_POPUP
Bram Moolenaar8055d172019-05-17 22:57:26 +0200802 if (curbuf->b_has_textprop && n != 0)
Bram Moolenaarf3333b02019-05-19 22:53:40 +0200803 adjust_prop_columns(lnum, bd.textcol, -n, 0);
Bram Moolenaar8055d172019-05-17 22:57:26 +0200804#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000805 }
806
807 check_cursor_col();
808 changed_lines(curwin->w_cursor.lnum, curwin->w_cursor.col,
809 oap->end.lnum + 1, 0L);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100810 oap->line_count = 0; // no lines deleted
Bram Moolenaar071d4272004-06-13 20:20:40 +0000811 }
Bram Moolenaarf7ff6e82014-03-23 15:13:05 +0100812 else if (oap->motion_type == MLINE)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000813 {
814 if (oap->op_type == OP_CHANGE)
815 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100816 // Delete the lines except the first one. Temporarily move the
817 // cursor to the next line. Save the current line number, if the
818 // last line is deleted it may be changed.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000819 if (oap->line_count > 1)
820 {
821 lnum = curwin->w_cursor.lnum;
822 ++curwin->w_cursor.lnum;
823 del_lines((long)(oap->line_count - 1), TRUE);
824 curwin->w_cursor.lnum = lnum;
825 }
826 if (u_save_cursor() == FAIL)
827 return FAIL;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100828 if (curbuf->b_p_ai) // don't delete indent
Bram Moolenaar071d4272004-06-13 20:20:40 +0000829 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100830 beginline(BL_WHITE); // cursor on first non-white
831 did_ai = TRUE; // delete the indent when ESC hit
Bram Moolenaar071d4272004-06-13 20:20:40 +0000832 ai_col = curwin->w_cursor.col;
833 }
834 else
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100835 beginline(0); // cursor in column 0
836 truncate_line(FALSE); // delete the rest of the line
837 // leave cursor past last char in line
Bram Moolenaar071d4272004-06-13 20:20:40 +0000838 if (oap->line_count > 1)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100839 u_clearline(); // "U" command not possible after "2cc"
Bram Moolenaar071d4272004-06-13 20:20:40 +0000840 }
841 else
842 {
843 del_lines(oap->line_count, TRUE);
844 beginline(BL_WHITE | BL_FIX);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100845 u_clearline(); // "U" command not possible after "dd"
Bram Moolenaar071d4272004-06-13 20:20:40 +0000846 }
847 }
848 else
849 {
Bram Moolenaar071d4272004-06-13 20:20:40 +0000850 if (virtual_op)
851 {
852 int endcol = 0;
853
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100854 // For virtualedit: break the tabs that are partly included.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000855 if (gchar_pos(&oap->start) == '\t')
856 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100857 if (u_save_cursor() == FAIL) // save first line for undo
Bram Moolenaar071d4272004-06-13 20:20:40 +0000858 return FAIL;
859 if (oap->line_count == 1)
860 endcol = getviscol2(oap->end.col, oap->end.coladd);
861 coladvance_force(getviscol2(oap->start.col, oap->start.coladd));
862 oap->start = curwin->w_cursor;
863 if (oap->line_count == 1)
864 {
865 coladvance(endcol);
866 oap->end.col = curwin->w_cursor.col;
867 oap->end.coladd = curwin->w_cursor.coladd;
868 curwin->w_cursor = oap->start;
869 }
870 }
871
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100872 // Break a tab only when it's included in the area.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000873 if (gchar_pos(&oap->end) == '\t'
874 && (int)oap->end.coladd < oap->inclusive)
875 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100876 // save last line for undo
Bram Moolenaar071d4272004-06-13 20:20:40 +0000877 if (u_save((linenr_T)(oap->end.lnum - 1),
878 (linenr_T)(oap->end.lnum + 1)) == FAIL)
879 return FAIL;
880 curwin->w_cursor = oap->end;
881 coladvance_force(getviscol2(oap->end.col, oap->end.coladd));
882 oap->end = curwin->w_cursor;
883 curwin->w_cursor = oap->start;
884 }
Bram Moolenaar77ccc002019-10-31 03:21:25 +0100885 if (has_mbyte)
886 mb_adjust_opend(oap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000887 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000888
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100889 if (oap->line_count == 1) // delete characters within one line
Bram Moolenaar071d4272004-06-13 20:20:40 +0000890 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100891 if (u_save_cursor() == FAIL) // save line for undo
Bram Moolenaar071d4272004-06-13 20:20:40 +0000892 return FAIL;
893
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100894 // if 'cpoptions' contains '$', display '$' at end of change
Bram Moolenaarf7ff6e82014-03-23 15:13:05 +0100895 if ( vim_strchr(p_cpo, CPO_DOLLAR) != NULL
Bram Moolenaar071d4272004-06-13 20:20:40 +0000896 && oap->op_type == OP_CHANGE
897 && oap->end.lnum == curwin->w_cursor.lnum
Bram Moolenaarf7ff6e82014-03-23 15:13:05 +0100898 && !oap->is_VIsual)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000899 display_dollar(oap->end.col - !oap->inclusive);
900
901 n = oap->end.col - oap->start.col + 1 - !oap->inclusive;
902
Bram Moolenaar071d4272004-06-13 20:20:40 +0000903 if (virtual_op)
904 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100905 // fix up things for virtualedit-delete:
906 // break the tabs which are going to get in our way
Bram Moolenaar071d4272004-06-13 20:20:40 +0000907 char_u *curline = ml_get_curline();
908 int len = (int)STRLEN(curline);
909
910 if (oap->end.coladd != 0
911 && (int)oap->end.col >= len - 1
912 && !(oap->start.coladd && (int)oap->end.col >= len - 1))
913 n++;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100914 // Delete at least one char (e.g, when on a control char).
Bram Moolenaar071d4272004-06-13 20:20:40 +0000915 if (n == 0 && oap->start.coladd != oap->end.coladd)
916 n = 1;
917
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100918 // When deleted a char in the line, reset coladd.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000919 if (gchar_cursor() != NUL)
920 curwin->w_cursor.coladd = 0;
921 }
Bram Moolenaard009e862015-06-09 20:20:03 +0200922 (void)del_bytes((long)n, !virtual_op,
923 oap->op_type == OP_DELETE && !oap->is_VIsual);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000924 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100925 else // delete characters between lines
Bram Moolenaar071d4272004-06-13 20:20:40 +0000926 {
927 pos_T curpos;
928
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100929 // save deleted and changed lines for undo
Bram Moolenaar071d4272004-06-13 20:20:40 +0000930 if (u_save((linenr_T)(curwin->w_cursor.lnum - 1),
931 (linenr_T)(curwin->w_cursor.lnum + oap->line_count)) == FAIL)
932 return FAIL;
933
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100934 truncate_line(TRUE); // delete from cursor to end of line
Bram Moolenaar071d4272004-06-13 20:20:40 +0000935
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100936 curpos = curwin->w_cursor; // remember curwin->w_cursor
Bram Moolenaar071d4272004-06-13 20:20:40 +0000937 ++curwin->w_cursor.lnum;
938 del_lines((long)(oap->line_count - 2), FALSE);
939
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100940 // delete from start of line until op_end
Bram Moolenaar44286ca2011-07-15 17:51:34 +0200941 n = (oap->end.col + 1 - !oap->inclusive);
Bram Moolenaard009e862015-06-09 20:20:03 +0200942 curwin->w_cursor.col = 0;
943 (void)del_bytes((long)n, !virtual_op,
944 oap->op_type == OP_DELETE && !oap->is_VIsual);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100945 curwin->w_cursor = curpos; // restore curwin->w_cursor
Bram Moolenaard009e862015-06-09 20:20:03 +0200946 (void)do_join(2, FALSE, FALSE, FALSE, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000947 }
Bram Moolenaar6b36d2a2021-08-23 21:19:01 +0200948 if (oap->op_type == OP_DELETE)
949 auto_format(FALSE, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000950 }
951
952 msgmore(curbuf->b_ml.ml_line_count - old_lcount);
953
Bram Moolenaar87e25fd2005-07-27 21:13:01 +0000954setmarks:
Bram Moolenaare1004402020-10-24 20:49:43 +0200955 if ((cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000956 {
Bram Moolenaarf4a1d1c2019-11-16 13:50:25 +0100957 if (oap->block_mode)
958 {
959 curbuf->b_op_end.lnum = oap->end.lnum;
960 curbuf->b_op_end.col = oap->start.col;
961 }
962 else
963 curbuf->b_op_end = oap->start;
964 curbuf->b_op_start = oap->start;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000965 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000966
967 return OK;
968}
969
Bram Moolenaar071d4272004-06-13 20:20:40 +0000970/*
971 * Adjust end of operating area for ending on a multi-byte character.
972 * Used for deletion.
973 */
974 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100975mb_adjust_opend(oparg_T *oap)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000976{
977 char_u *p;
978
979 if (oap->inclusive)
980 {
981 p = ml_get(oap->end.lnum);
982 oap->end.col += mb_tail_off(p, p + oap->end.col);
983 }
984}
Bram Moolenaar071d4272004-06-13 20:20:40 +0000985
Bram Moolenaar630afe82018-06-28 19:26:28 +0200986/*
987 * Replace the character under the cursor with "c".
988 * This takes care of multi-byte characters.
989 */
990 static void
991replace_character(int c)
992{
993 int n = State;
994
Bram Moolenaar24959102022-05-07 20:01:16 +0100995 State = MODE_REPLACE;
Bram Moolenaar630afe82018-06-28 19:26:28 +0200996 ins_char(c);
997 State = n;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +0100998 // Backup to the replaced character.
Bram Moolenaar630afe82018-06-28 19:26:28 +0200999 dec_cursor();
1000}
1001
Bram Moolenaar071d4272004-06-13 20:20:40 +00001002/*
1003 * Replace a whole area with one character.
1004 */
1005 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01001006op_replace(oparg_T *oap, int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001007{
1008 int n, numc;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001009 int num_chars;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001010 char_u *newp, *oldp;
1011 size_t oldlen;
1012 struct block_def bd;
Bram Moolenaard9820532013-11-04 01:41:17 +01001013 char_u *after_p = NULL;
Bram Moolenaarf12519d2018-02-06 22:52:49 +01001014 int had_ctrl_v_cr = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001015
1016 if ((curbuf->b_ml.ml_flags & ML_EMPTY ) || oap->empty)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001017 return OK; // nothing to do
Bram Moolenaar071d4272004-06-13 20:20:40 +00001018
Bram Moolenaarf12519d2018-02-06 22:52:49 +01001019 if (c == REPLACE_CR_NCHAR)
1020 {
1021 had_ctrl_v_cr = TRUE;
1022 c = CAR;
1023 }
1024 else if (c == REPLACE_NL_NCHAR)
1025 {
1026 had_ctrl_v_cr = TRUE;
1027 c = NL;
1028 }
Bram Moolenaard9820532013-11-04 01:41:17 +01001029
Bram Moolenaar071d4272004-06-13 20:20:40 +00001030 if (has_mbyte)
1031 mb_adjust_opend(oap);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001032
1033 if (u_save((linenr_T)(oap->start.lnum - 1),
1034 (linenr_T)(oap->end.lnum + 1)) == FAIL)
1035 return FAIL;
1036
1037 /*
1038 * block mode replace
1039 */
1040 if (oap->block_mode)
1041 {
1042 bd.is_MAX = (curwin->w_curswant == MAXCOL);
1043 for ( ; curwin->w_cursor.lnum <= oap->end.lnum; ++curwin->w_cursor.lnum)
1044 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001045 curwin->w_cursor.col = 0; // make sure cursor position is valid
Bram Moolenaar071d4272004-06-13 20:20:40 +00001046 block_prep(oap, &bd, curwin->w_cursor.lnum, TRUE);
1047 if (bd.textlen == 0 && (!virtual_op || bd.is_MAX))
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001048 continue; // nothing to replace
Bram Moolenaar071d4272004-06-13 20:20:40 +00001049
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001050 // n == number of extra chars required
1051 // If we split a TAB, it may be replaced by several characters.
1052 // Thus the number of characters may increase!
1053 // If the range starts in virtual space, count the initial
1054 // coladd offset as part of "startspaces"
Bram Moolenaar071d4272004-06-13 20:20:40 +00001055 if (virtual_op && bd.is_short && *bd.textstart == NUL)
1056 {
1057 pos_T vpos;
1058
Bram Moolenaara1381de2009-11-03 15:44:21 +00001059 vpos.lnum = curwin->w_cursor.lnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001060 getvpos(&vpos, oap->start_vcol);
1061 bd.startspaces += vpos.coladd;
1062 n = bd.startspaces;
1063 }
1064 else
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001065 // allow for pre spaces
Bram Moolenaar071d4272004-06-13 20:20:40 +00001066 n = (bd.startspaces ? bd.start_char_vcols - 1 : 0);
1067
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001068 // allow for post spp
Bram Moolenaar071d4272004-06-13 20:20:40 +00001069 n += (bd.endspaces
Bram Moolenaar071d4272004-06-13 20:20:40 +00001070 && !bd.is_oneChar
Bram Moolenaar071d4272004-06-13 20:20:40 +00001071 && bd.end_char_vcols > 0) ? bd.end_char_vcols - 1 : 0;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001072 // Figure out how many characters to replace.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001073 numc = oap->end_vcol - oap->start_vcol + 1;
1074 if (bd.is_short && (!virtual_op || bd.is_MAX))
1075 numc -= (oap->end_vcol - bd.end_vcol) + 1;
1076
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001077 // A double-wide character can be replaced only up to half the
1078 // times.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001079 if ((*mb_char2cells)(c) > 1)
1080 {
1081 if ((numc & 1) && !bd.is_short)
1082 {
1083 ++bd.endspaces;
1084 ++n;
1085 }
1086 numc = numc / 2;
1087 }
1088
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001089 // Compute bytes needed, move character count to num_chars.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001090 num_chars = numc;
1091 numc *= (*mb_char2len)(c);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001092 // oldlen includes textlen, so don't double count
Bram Moolenaar071d4272004-06-13 20:20:40 +00001093 n += numc - bd.textlen;
1094
1095 oldp = ml_get_curline();
1096 oldlen = STRLEN(oldp);
Bram Moolenaar964b3742019-05-24 18:54:09 +02001097 newp = alloc(oldlen + 1 + n);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001098 if (newp == NULL)
1099 continue;
1100 vim_memset(newp, NUL, (size_t)(oldlen + 1 + n));
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001101 // copy up to deleted part
Bram Moolenaar071d4272004-06-13 20:20:40 +00001102 mch_memmove(newp, oldp, (size_t)bd.textcol);
1103 oldp += bd.textcol + bd.textlen;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001104 // insert pre-spaces
Bram Moolenaar2536d4f2015-07-17 13:22:51 +02001105 vim_memset(newp + bd.textcol, ' ', (size_t)bd.startspaces);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001106 // insert replacement chars CHECK FOR ALLOCATED SPACE
1107 // REPLACE_CR_NCHAR/REPLACE_NL_NCHAR is used for entering CR
1108 // literally.
Bram Moolenaard9820532013-11-04 01:41:17 +01001109 if (had_ctrl_v_cr || (c != '\r' && c != '\n'))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001110 {
Bram Moolenaard9820532013-11-04 01:41:17 +01001111 if (has_mbyte)
1112 {
1113 n = (int)STRLEN(newp);
1114 while (--num_chars >= 0)
1115 n += (*mb_char2bytes)(c, newp + n);
1116 }
1117 else
Bram Moolenaar2536d4f2015-07-17 13:22:51 +02001118 vim_memset(newp + STRLEN(newp), c, (size_t)numc);
Bram Moolenaard9820532013-11-04 01:41:17 +01001119 if (!bd.is_short)
1120 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001121 // insert post-spaces
Bram Moolenaar2536d4f2015-07-17 13:22:51 +02001122 vim_memset(newp + STRLEN(newp), ' ', (size_t)bd.endspaces);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001123 // copy the part after the changed part
Bram Moolenaard9820532013-11-04 01:41:17 +01001124 STRMOVE(newp + STRLEN(newp), oldp);
1125 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001126 }
1127 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00001128 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001129 // Replacing with \r or \n means splitting the line.
Bram Moolenaar964b3742019-05-24 18:54:09 +02001130 after_p = alloc(oldlen + 1 + n - STRLEN(newp));
Bram Moolenaard9820532013-11-04 01:41:17 +01001131 if (after_p != NULL)
1132 STRMOVE(after_p, oldp);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001133 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001134 // replace the line
Bram Moolenaar071d4272004-06-13 20:20:40 +00001135 ml_replace(curwin->w_cursor.lnum, newp, FALSE);
Bram Moolenaard9820532013-11-04 01:41:17 +01001136 if (after_p != NULL)
1137 {
1138 ml_append(curwin->w_cursor.lnum++, after_p, 0, FALSE);
1139 appended_lines_mark(curwin->w_cursor.lnum, 1L);
1140 oap->end.lnum++;
1141 vim_free(after_p);
1142 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001143 }
1144 }
1145 else
1146 {
1147 /*
1148 * MCHAR and MLINE motion replace.
1149 */
1150 if (oap->motion_type == MLINE)
1151 {
1152 oap->start.col = 0;
1153 curwin->w_cursor.col = 0;
1154 oap->end.col = (colnr_T)STRLEN(ml_get(oap->end.lnum));
1155 if (oap->end.col)
1156 --oap->end.col;
1157 }
1158 else if (!oap->inclusive)
1159 dec(&(oap->end));
1160
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01001161 while (LTOREQ_POS(curwin->w_cursor, oap->end))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001162 {
1163 n = gchar_cursor();
1164 if (n != NUL)
1165 {
Bram Moolenaar8ee60282021-12-15 21:08:50 +00001166 int new_byte_len = (*mb_char2len)(c);
1167 int old_byte_len = mb_ptr2len(ml_get_cursor());
1168
1169 if (new_byte_len > 1 || old_byte_len > 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001170 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001171 // This is slow, but it handles replacing a single-byte
1172 // with a multi-byte and the other way around.
Bram Moolenaardb813952013-03-07 18:50:57 +01001173 if (curwin->w_cursor.lnum == oap->end.lnum)
Bram Moolenaar8ee60282021-12-15 21:08:50 +00001174 oap->end.col += new_byte_len - old_byte_len;
Bram Moolenaar630afe82018-06-28 19:26:28 +02001175 replace_character(c);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001176 }
1177 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00001178 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001179 if (n == TAB)
1180 {
1181 int end_vcol = 0;
1182
1183 if (curwin->w_cursor.lnum == oap->end.lnum)
1184 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001185 // oap->end has to be recalculated when
1186 // the tab breaks
Bram Moolenaar071d4272004-06-13 20:20:40 +00001187 end_vcol = getviscol2(oap->end.col,
1188 oap->end.coladd);
1189 }
1190 coladvance_force(getviscol());
1191 if (curwin->w_cursor.lnum == oap->end.lnum)
1192 getvpos(&oap->end, end_vcol);
1193 }
Bram Moolenaar630afe82018-06-28 19:26:28 +02001194 PBYTE(curwin->w_cursor, c);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001195 }
1196 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001197 else if (virtual_op && curwin->w_cursor.lnum == oap->end.lnum)
1198 {
1199 int virtcols = oap->end.coladd;
1200
1201 if (curwin->w_cursor.lnum == oap->start.lnum
1202 && oap->start.col == oap->end.col && oap->start.coladd)
1203 virtcols -= oap->start.coladd;
1204
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001205 // oap->end has been trimmed so it's effectively inclusive;
1206 // as a result an extra +1 must be counted so we don't
1207 // trample the NUL byte.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001208 coladvance_force(getviscol2(oap->end.col, oap->end.coladd) + 1);
1209 curwin->w_cursor.col -= (virtcols + 1);
1210 for (; virtcols >= 0; virtcols--)
1211 {
Bram Moolenaar6ed545e2022-05-09 20:09:23 +01001212 if ((*mb_char2len)(c) > 1)
Bram Moolenaar630afe82018-06-28 19:26:28 +02001213 replace_character(c);
Bram Moolenaar6ed545e2022-05-09 20:09:23 +01001214 else
Bram Moolenaar630afe82018-06-28 19:26:28 +02001215 PBYTE(curwin->w_cursor, c);
1216 if (inc(&curwin->w_cursor) == -1)
1217 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001218 }
1219 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001220
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001221 // Advance to next character, stop at the end of the file.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001222 if (inc_cursor() == -1)
1223 break;
1224 }
1225 }
1226
1227 curwin->w_cursor = oap->start;
1228 check_cursor();
1229 changed_lines(oap->start.lnum, oap->start.col, oap->end.lnum + 1, 0L);
1230
Bram Moolenaare1004402020-10-24 20:49:43 +02001231 if ((cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0)
Bram Moolenaarf4a1d1c2019-11-16 13:50:25 +01001232 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001233 // Set "'[" and "']" marks.
Bram Moolenaarf4a1d1c2019-11-16 13:50:25 +01001234 curbuf->b_op_start = oap->start;
1235 curbuf->b_op_end = oap->end;
1236 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001237
1238 return OK;
1239}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001240
Bram Moolenaarbaaa7e92016-01-29 22:47:03 +01001241static int swapchars(int op_type, pos_T *pos, int length);
Bram Moolenaarb44df0a2008-01-22 15:02:31 +00001242
Bram Moolenaar071d4272004-06-13 20:20:40 +00001243/*
1244 * Handle the (non-standard vi) tilde operator. Also for "gu", "gU" and "g?".
1245 */
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02001246 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +01001247op_tilde(oparg_T *oap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001248{
1249 pos_T pos;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001250 struct block_def bd;
Bram Moolenaare60c58d2008-02-06 13:44:43 +00001251 int did_change = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001252
1253 if (u_save((linenr_T)(oap->start.lnum - 1),
1254 (linenr_T)(oap->end.lnum + 1)) == FAIL)
1255 return;
1256
1257 pos = oap->start;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001258 if (oap->block_mode) // Visual block mode
Bram Moolenaar071d4272004-06-13 20:20:40 +00001259 {
1260 for (; pos.lnum <= oap->end.lnum; ++pos.lnum)
1261 {
Bram Moolenaar555b3d52008-12-03 12:38:36 +00001262 int one_change;
1263
Bram Moolenaar071d4272004-06-13 20:20:40 +00001264 block_prep(oap, &bd, pos.lnum, FALSE);
1265 pos.col = bd.textcol;
Bram Moolenaar555b3d52008-12-03 12:38:36 +00001266 one_change = swapchars(oap->op_type, &pos, bd.textlen);
1267 did_change |= one_change;
Bram Moolenaarb44df0a2008-01-22 15:02:31 +00001268
Bram Moolenaarf7ff6e82014-03-23 15:13:05 +01001269#ifdef FEAT_NETBEANS_INTG
Bram Moolenaarb26e6322010-05-22 21:34:09 +02001270 if (netbeans_active() && one_change)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001271 {
1272 char_u *ptr = ml_get_buf(curbuf, pos.lnum, FALSE);
1273
Bram Moolenaar009b2592004-10-24 19:18:58 +00001274 netbeans_removed(curbuf, pos.lnum, bd.textcol,
1275 (long)bd.textlen);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001276 netbeans_inserted(curbuf, pos.lnum, bd.textcol,
Bram Moolenaarb26e6322010-05-22 21:34:09 +02001277 &ptr[bd.textcol], bd.textlen);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001278 }
Bram Moolenaarf7ff6e82014-03-23 15:13:05 +01001279#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001280 }
1281 if (did_change)
1282 changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L);
1283 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001284 else // not block mode
Bram Moolenaar071d4272004-06-13 20:20:40 +00001285 {
1286 if (oap->motion_type == MLINE)
1287 {
1288 oap->start.col = 0;
1289 pos.col = 0;
1290 oap->end.col = (colnr_T)STRLEN(ml_get(oap->end.lnum));
1291 if (oap->end.col)
1292 --oap->end.col;
1293 }
1294 else if (!oap->inclusive)
1295 dec(&(oap->end));
1296
Bram Moolenaare60c58d2008-02-06 13:44:43 +00001297 if (pos.lnum == oap->end.lnum)
1298 did_change = swapchars(oap->op_type, &pos,
1299 oap->end.col - pos.col + 1);
1300 else
1301 for (;;)
1302 {
1303 did_change |= swapchars(oap->op_type, &pos,
1304 pos.lnum == oap->end.lnum ? oap->end.col + 1:
1305 (int)STRLEN(ml_get_pos(&pos)));
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01001306 if (LTOREQ_POS(oap->end, pos) || inc(&pos) == -1)
Bram Moolenaare60c58d2008-02-06 13:44:43 +00001307 break;
1308 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001309 if (did_change)
1310 {
1311 changed_lines(oap->start.lnum, oap->start.col, oap->end.lnum + 1,
1312 0L);
1313#ifdef FEAT_NETBEANS_INTG
Bram Moolenaarfe154992022-03-22 20:42:12 +00001314 if (netbeans_active())
Bram Moolenaar071d4272004-06-13 20:20:40 +00001315 {
1316 char_u *ptr;
1317 int count;
1318
1319 pos = oap->start;
1320 while (pos.lnum < oap->end.lnum)
1321 {
1322 ptr = ml_get_buf(curbuf, pos.lnum, FALSE);
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00001323 count = (int)STRLEN(ptr) - pos.col;
Bram Moolenaar009b2592004-10-24 19:18:58 +00001324 netbeans_removed(curbuf, pos.lnum, pos.col, (long)count);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001325 netbeans_inserted(curbuf, pos.lnum, pos.col,
Bram Moolenaarb26e6322010-05-22 21:34:09 +02001326 &ptr[pos.col], count);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001327 pos.col = 0;
1328 pos.lnum++;
1329 }
1330 ptr = ml_get_buf(curbuf, pos.lnum, FALSE);
1331 count = oap->end.col - pos.col + 1;
Bram Moolenaar009b2592004-10-24 19:18:58 +00001332 netbeans_removed(curbuf, pos.lnum, pos.col, (long)count);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001333 netbeans_inserted(curbuf, pos.lnum, pos.col,
Bram Moolenaarb26e6322010-05-22 21:34:09 +02001334 &ptr[pos.col], count);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001335 }
1336#endif
1337 }
1338 }
1339
Bram Moolenaar071d4272004-06-13 20:20:40 +00001340 if (!did_change && oap->is_VIsual)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001341 // No change: need to remove the Visual selection
Bram Moolenaar071d4272004-06-13 20:20:40 +00001342 redraw_curbuf_later(INVERTED);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001343
Bram Moolenaare1004402020-10-24 20:49:43 +02001344 if ((cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0)
Bram Moolenaarf4a1d1c2019-11-16 13:50:25 +01001345 {
1346 // Set '[ and '] marks.
1347 curbuf->b_op_start = oap->start;
1348 curbuf->b_op_end = oap->end;
1349 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001350
1351 if (oap->line_count > p_report)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001352 smsg(NGETTEXT("%ld line changed", "%ld lines changed",
Bram Moolenaarda6e8912018-08-21 15:12:14 +02001353 oap->line_count), oap->line_count);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001354}
1355
1356/*
Bram Moolenaarb44df0a2008-01-22 15:02:31 +00001357 * Invoke swapchar() on "length" bytes at position "pos".
1358 * "pos" is advanced to just after the changed characters.
1359 * "length" is rounded up to include the whole last multi-byte character.
1360 * Also works correctly when the number of bytes changes.
1361 * Returns TRUE if some character was changed.
1362 */
1363 static int
Bram Moolenaar9b578142016-01-30 19:39:49 +01001364swapchars(int op_type, pos_T *pos, int length)
Bram Moolenaarb44df0a2008-01-22 15:02:31 +00001365{
1366 int todo;
1367 int did_change = 0;
1368
1369 for (todo = length; todo > 0; --todo)
1370 {
Bram Moolenaarb44df0a2008-01-22 15:02:31 +00001371 if (has_mbyte)
Bram Moolenaarf17968b2013-08-09 19:48:40 +02001372 {
1373 int len = (*mb_ptr2len)(ml_get_pos(pos));
1374
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001375 // we're counting bytes, not characters
Bram Moolenaarf17968b2013-08-09 19:48:40 +02001376 if (len > 0)
1377 todo -= len - 1;
1378 }
Bram Moolenaarb44df0a2008-01-22 15:02:31 +00001379 did_change |= swapchar(op_type, pos);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001380 if (inc(pos) == -1) // at end of file
Bram Moolenaarb44df0a2008-01-22 15:02:31 +00001381 break;
1382 }
1383 return did_change;
1384}
1385
1386/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001387 * If op_type == OP_UPPER: make uppercase,
1388 * if op_type == OP_LOWER: make lowercase,
1389 * if op_type == OP_ROT13: do rot13 encoding,
1390 * else swap case of character at 'pos'
1391 * returns TRUE when something actually changed.
1392 */
1393 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01001394swapchar(int op_type, pos_T *pos)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001395{
1396 int c;
1397 int nc;
1398
1399 c = gchar_pos(pos);
1400
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001401 // Only do rot13 encoding for ASCII characters.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001402 if (c >= 0x80 && op_type == OP_ROT13)
1403 return FALSE;
1404
Bram Moolenaarb44df0a2008-01-22 15:02:31 +00001405 if (op_type == OP_UPPER && c == 0xdf
1406 && (enc_latin1like || STRCMP(p_enc, "iso-8859-2") == 0))
Bram Moolenaar6f16eb82005-08-23 21:02:42 +00001407 {
1408 pos_T sp = curwin->w_cursor;
1409
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001410 // Special handling of German sharp s: change to "SS".
Bram Moolenaar6f16eb82005-08-23 21:02:42 +00001411 curwin->w_cursor = *pos;
1412 del_char(FALSE);
1413 ins_char('S');
1414 ins_char('S');
1415 curwin->w_cursor = sp;
1416 inc(pos);
1417 }
1418
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001419 if (enc_dbcs != 0 && c >= 0x100) // No lower/uppercase letter
Bram Moolenaar071d4272004-06-13 20:20:40 +00001420 return FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001421 nc = c;
1422 if (MB_ISLOWER(c))
1423 {
1424 if (op_type == OP_ROT13)
1425 nc = ROT13(c, 'a');
1426 else if (op_type != OP_LOWER)
1427 nc = MB_TOUPPER(c);
1428 }
1429 else if (MB_ISUPPER(c))
1430 {
1431 if (op_type == OP_ROT13)
1432 nc = ROT13(c, 'A');
1433 else if (op_type != OP_UPPER)
1434 nc = MB_TOLOWER(c);
1435 }
1436 if (nc != c)
1437 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001438 if (enc_utf8 && (c >= 0x80 || nc >= 0x80))
1439 {
1440 pos_T sp = curwin->w_cursor;
1441
1442 curwin->w_cursor = *pos;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001443 // don't use del_char(), it also removes composing chars
Bram Moolenaard1cb65e2010-08-01 14:22:48 +02001444 del_bytes(utf_ptr2len(ml_get_cursor()), FALSE, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001445 ins_char(nc);
1446 curwin->w_cursor = sp;
1447 }
1448 else
Bram Moolenaar630afe82018-06-28 19:26:28 +02001449 PBYTE(*pos, nc);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001450 return TRUE;
1451 }
1452 return FALSE;
1453}
1454
Bram Moolenaar071d4272004-06-13 20:20:40 +00001455/*
1456 * op_insert - Insert and append operators for Visual mode.
1457 */
1458 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01001459op_insert(oparg_T *oap, long count1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001460{
1461 long ins_len, pre_textlen = 0;
1462 char_u *firstline, *ins_text;
Bram Moolenaar59f4f952021-11-27 22:47:43 +00001463 colnr_T ind_pre_col = 0, ind_post_col;
1464 int ind_pre_vcol = 0, ind_post_vcol = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001465 struct block_def bd;
1466 int i;
Bram Moolenaarf2c03d72015-02-03 18:36:44 +01001467 pos_T t1;
Bram Moolenaar4067bd32021-06-29 18:54:35 +02001468 pos_T start_insert;
1469 // offset when cursor was moved in insert mode
1470 int offset = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001471
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001472 // edit() changes this - record it for OP_APPEND
Bram Moolenaar071d4272004-06-13 20:20:40 +00001473 bd.is_MAX = (curwin->w_curswant == MAXCOL);
1474
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001475 // vis block is still marked. Get rid of it now.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001476 curwin->w_cursor.lnum = oap->start.lnum;
1477 update_screen(INVERTED);
1478
1479 if (oap->block_mode)
1480 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001481 // When 'virtualedit' is used, need to insert the extra spaces before
1482 // doing block_prep(). When only "block" is used, virtual edit is
1483 // already disabled, but still need it when calling
1484 // coladvance_force().
Gary Johnson53ba05b2021-07-26 22:19:10 +02001485 // coladvance_force() uses get_ve_flags() to get the 'virtualedit'
Gary Johnson51ad8502021-08-03 18:33:08 +02001486 // state for the current window. To override that state, we need to
1487 // set the window-local value of ve_flags rather than the global value.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001488 if (curwin->w_cursor.coladd > 0)
1489 {
Gary Johnson51ad8502021-08-03 18:33:08 +02001490 int old_ve_flags = curwin->w_ve_flags;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001491
Bram Moolenaar071d4272004-06-13 20:20:40 +00001492 if (u_save_cursor() == FAIL)
1493 return;
Gary Johnson53ba05b2021-07-26 22:19:10 +02001494
Gary Johnson51ad8502021-08-03 18:33:08 +02001495 curwin->w_ve_flags = VE_ALL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001496 coladvance_force(oap->op_type == OP_APPEND
1497 ? oap->end_vcol + 1 : getviscol());
1498 if (oap->op_type == OP_APPEND)
1499 --curwin->w_cursor.col;
Gary Johnson51ad8502021-08-03 18:33:08 +02001500 curwin->w_ve_flags = old_ve_flags;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001501 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001502 // Get the info about the block before entering the text
Bram Moolenaar071d4272004-06-13 20:20:40 +00001503 block_prep(oap, &bd, oap->start.lnum, TRUE);
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001504 // Get indent information
Bram Moolenaar59f4f952021-11-27 22:47:43 +00001505 ind_pre_col = (colnr_T)getwhitecols_curline();
1506 ind_pre_vcol = get_indent();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001507 firstline = ml_get(oap->start.lnum) + bd.textcol;
Bram Moolenaare2e69e42017-09-02 20:30:35 +02001508
Bram Moolenaar071d4272004-06-13 20:20:40 +00001509 if (oap->op_type == OP_APPEND)
1510 firstline += bd.textlen;
1511 pre_textlen = (long)STRLEN(firstline);
1512 }
1513
1514 if (oap->op_type == OP_APPEND)
1515 {
Bram Moolenaar29ddebe2019-01-26 17:28:26 +01001516 if (oap->block_mode && curwin->w_cursor.coladd == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001517 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001518 // Move the cursor to the character right of the block.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001519 curwin->w_set_curswant = TRUE;
1520 while (*ml_get_cursor() != NUL
1521 && (curwin->w_cursor.col < bd.textcol + bd.textlen))
1522 ++curwin->w_cursor.col;
1523 if (bd.is_short && !bd.is_MAX)
1524 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001525 // First line was too short, make it longer and adjust the
1526 // values in "bd".
Bram Moolenaar071d4272004-06-13 20:20:40 +00001527 if (u_save_cursor() == FAIL)
1528 return;
1529 for (i = 0; i < bd.endspaces; ++i)
1530 ins_char(' ');
1531 bd.textlen += bd.endspaces;
1532 }
1533 }
1534 else
1535 {
1536 curwin->w_cursor = oap->end;
Bram Moolenaar6a584dc2006-06-20 18:29:34 +00001537 check_cursor_col();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001538
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001539 // Works just like an 'i'nsert on the next character.
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01001540 if (!LINEEMPTY(curwin->w_cursor.lnum)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001541 && oap->start_vcol != oap->end_vcol)
1542 inc_cursor();
1543 }
1544 }
1545
Bram Moolenaarf2c03d72015-02-03 18:36:44 +01001546 t1 = oap->start;
Bram Moolenaar4067bd32021-06-29 18:54:35 +02001547 start_insert = curwin->w_cursor;
Bram Moolenaar23fa81d2017-02-01 21:50:21 +01001548 (void)edit(NUL, FALSE, (linenr_T)count1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001549
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001550 // When a tab was inserted, and the characters in front of the tab
1551 // have been converted to a tab as well, the column of the cursor
1552 // might have actually been reduced, so need to adjust here.
Bram Moolenaarf2c03d72015-02-03 18:36:44 +01001553 if (t1.lnum == curbuf->b_op_start_orig.lnum
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01001554 && LT_POS(curbuf->b_op_start_orig, t1))
Bram Moolenaarf2c03d72015-02-03 18:36:44 +01001555 oap->start = curbuf->b_op_start_orig;
1556
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001557 // If user has moved off this line, we don't know what to do, so do
1558 // nothing.
1559 // Also don't repeat the insert when Insert mode ended with CTRL-C.
Bram Moolenaaraacbb002008-01-03 15:34:40 +00001560 if (curwin->w_cursor.lnum != oap->start.lnum || got_int)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001561 return;
1562
1563 if (oap->block_mode)
1564 {
1565 struct block_def bd2;
Bram Moolenaar8c87a2b2018-04-10 13:15:47 +02001566 int did_indent = FALSE;
Bram Moolenaar35e802e2018-04-30 17:21:03 +02001567 size_t len;
1568 int add;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001569
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001570 // If indent kicked in, the firstline might have changed
1571 // but only do that, if the indent actually increased.
Bram Moolenaar59f4f952021-11-27 22:47:43 +00001572 ind_post_col = (colnr_T)getwhitecols_curline();
1573 if (curbuf->b_op_start.col > ind_pre_col && ind_post_col > ind_pre_col)
Bram Moolenaar4ec86dd2017-09-02 23:28:54 +02001574 {
Bram Moolenaar59f4f952021-11-27 22:47:43 +00001575 bd.textcol += ind_post_col - ind_pre_col;
1576 ind_post_vcol = get_indent();
1577 bd.start_vcol += ind_post_vcol - ind_pre_vcol;
Bram Moolenaar8c87a2b2018-04-10 13:15:47 +02001578 did_indent = TRUE;
Bram Moolenaar4ec86dd2017-09-02 23:28:54 +02001579 }
1580
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001581 // The user may have moved the cursor before inserting something, try
1582 // to adjust the block for that. But only do it, if the difference
1583 // does not come from indent kicking in.
Bram Moolenaar8c87a2b2018-04-10 13:15:47 +02001584 if (oap->start.lnum == curbuf->b_op_start_orig.lnum
1585 && !bd.is_MAX && !did_indent)
Bram Moolenaar3f75e422013-11-11 01:29:22 +01001586 {
Bram Moolenaar4067bd32021-06-29 18:54:35 +02001587 int t = getviscol2(curbuf->b_op_start_orig.col,
1588 curbuf->b_op_start_orig.coladd);
1589
zeertzjq7745f142022-02-15 11:48:22 +00001590 if (oap->op_type == OP_INSERT
1591 && oap->start.col + oap->start.coladd
1592 != curbuf->b_op_start_orig.col
1593 + curbuf->b_op_start_orig.coladd)
Bram Moolenaar3f75e422013-11-11 01:29:22 +01001594 {
zeertzjq7745f142022-02-15 11:48:22 +00001595 oap->start.col = curbuf->b_op_start_orig.col;
1596 pre_textlen -= t - oap->start_vcol;
1597 oap->start_vcol = t;
Bram Moolenaar3f75e422013-11-11 01:29:22 +01001598 }
zeertzjq7745f142022-02-15 11:48:22 +00001599 else if (oap->op_type == OP_APPEND
1600 && oap->start.col + oap->start.coladd
1601 >= curbuf->b_op_start_orig.col
1602 + curbuf->b_op_start_orig.coladd)
Bram Moolenaar3f75e422013-11-11 01:29:22 +01001603 {
zeertzjq7745f142022-02-15 11:48:22 +00001604 oap->start.col = curbuf->b_op_start_orig.col;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001605 // reset pre_textlen to the value of OP_INSERT
Bram Moolenaar3f75e422013-11-11 01:29:22 +01001606 pre_textlen += bd.textlen;
Bram Moolenaarf2c03d72015-02-03 18:36:44 +01001607 pre_textlen -= t - oap->start_vcol;
zeertzjq7745f142022-02-15 11:48:22 +00001608 oap->start_vcol = t;
1609 oap->op_type = OP_INSERT;
Bram Moolenaar3f75e422013-11-11 01:29:22 +01001610 }
1611 }
1612
Bram Moolenaar59f4f952021-11-27 22:47:43 +00001613 // Spaces and tabs in the indent may have changed to other spaces and
1614 // tabs. Get the starting column again and correct the length.
1615 // Don't do this when "$" used, end-of-line will have changed.
1616 //
1617 // if indent was added and the inserted text was after the indent,
1618 // correct the selection for the new indent.
1619 if (did_indent && bd.textcol - ind_post_col > 0)
1620 {
1621 oap->start.col += ind_post_col - ind_pre_col;
1622 oap->start_vcol += ind_post_vcol - ind_pre_vcol;
1623 oap->end.col += ind_post_col - ind_pre_col;
1624 oap->end_vcol += ind_post_vcol - ind_pre_vcol;
1625 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001626 block_prep(oap, &bd2, oap->start.lnum, TRUE);
Bram Moolenaar59f4f952021-11-27 22:47:43 +00001627 if (did_indent && bd.textcol - ind_post_col > 0)
1628 {
1629 // undo for where "oap" is used below
1630 oap->start.col -= ind_post_col - ind_pre_col;
1631 oap->start_vcol -= ind_post_vcol - ind_pre_vcol;
1632 oap->end.col -= ind_post_col - ind_pre_col;
1633 oap->end_vcol -= ind_post_vcol - ind_pre_vcol;
1634 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001635 if (!bd.is_MAX || bd2.textlen < bd.textlen)
1636 {
1637 if (oap->op_type == OP_APPEND)
1638 {
1639 pre_textlen += bd2.textlen - bd.textlen;
1640 if (bd2.endspaces)
1641 --bd2.textlen;
1642 }
1643 bd.textcol = bd2.textcol;
1644 bd.textlen = bd2.textlen;
1645 }
1646
1647 /*
1648 * Subsequent calls to ml_get() flush the firstline data - take a
1649 * copy of the required string.
1650 */
Bram Moolenaar35e802e2018-04-30 17:21:03 +02001651 firstline = ml_get(oap->start.lnum);
1652 len = STRLEN(firstline);
1653 add = bd.textcol;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001654 if (oap->op_type == OP_APPEND)
Bram Moolenaar4067bd32021-06-29 18:54:35 +02001655 {
Bram Moolenaar35e802e2018-04-30 17:21:03 +02001656 add += bd.textlen;
Bram Moolenaar4067bd32021-06-29 18:54:35 +02001657 // account for pressing cursor in insert mode when '$' was used
1658 if (bd.is_MAX
1659 && (start_insert.lnum == Insstart.lnum
1660 && start_insert.col > Insstart.col))
1661 {
1662 offset = (start_insert.col - Insstart.col);
1663 add -= offset;
1664 if (oap->end_vcol > offset)
1665 oap->end_vcol -= (offset + 1);
1666 else
1667 // moved outside of the visual block, what to do?
1668 return;
1669 }
1670 }
Bram Moolenaar35e802e2018-04-30 17:21:03 +02001671 if ((size_t)add > len)
1672 firstline += len; // short line, point to the NUL
1673 else
1674 firstline += add;
Bram Moolenaar4067bd32021-06-29 18:54:35 +02001675 if (pre_textlen >= 0 && (ins_len =
1676 (long)STRLEN(firstline) - pre_textlen - offset) > 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001677 {
Bram Moolenaar71ccd032020-06-12 22:59:11 +02001678 ins_text = vim_strnsave(firstline, ins_len);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001679 if (ins_text != NULL)
1680 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001681 // block handled here
Bram Moolenaar071d4272004-06-13 20:20:40 +00001682 if (u_save(oap->start.lnum,
1683 (linenr_T)(oap->end.lnum + 1)) == OK)
1684 block_insert(oap, ins_text, (oap->op_type == OP_INSERT),
1685 &bd);
1686
1687 curwin->w_cursor.col = oap->start.col;
1688 check_cursor();
1689 vim_free(ins_text);
1690 }
1691 }
1692 }
1693}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001694
1695/*
1696 * op_change - handle a change operation
1697 *
1698 * return TRUE if edit() returns because of a CTRL-O command
1699 */
1700 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01001701op_change(oparg_T *oap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001702{
1703 colnr_T l;
1704 int retval;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001705 long offset;
1706 linenr_T linenr;
Bram Moolenaar53241da2007-09-13 20:41:32 +00001707 long ins_len;
1708 long pre_textlen = 0;
1709 long pre_indent = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001710 char_u *firstline;
1711 char_u *ins_text, *newp, *oldp;
1712 struct block_def bd;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001713
1714 l = oap->start.col;
1715 if (oap->motion_type == MLINE)
1716 {
1717 l = 0;
Bram Moolenaarde5cf282022-05-14 11:52:23 +01001718 can_si = may_do_si(); // Like opening a new line, do smart indent
Bram Moolenaar071d4272004-06-13 20:20:40 +00001719 }
1720
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001721 // First delete the text in the region. In an empty buffer only need to
1722 // save for undo
Bram Moolenaar071d4272004-06-13 20:20:40 +00001723 if (curbuf->b_ml.ml_flags & ML_EMPTY)
1724 {
1725 if (u_save_cursor() == FAIL)
1726 return FALSE;
1727 }
1728 else if (op_delete(oap) == FAIL)
1729 return FALSE;
1730
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01001731 if ((l > curwin->w_cursor.col) && !LINEEMPTY(curwin->w_cursor.lnum)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001732 && !virtual_op)
1733 inc_cursor();
1734
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001735 // check for still on same line (<CR> in inserted text meaningless)
1736 // skip blank lines too
Bram Moolenaar071d4272004-06-13 20:20:40 +00001737 if (oap->block_mode)
1738 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001739 // Add spaces before getting the current line length.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001740 if (virtual_op && (curwin->w_cursor.coladd > 0
1741 || gchar_cursor() == NUL))
1742 coladvance_force(getviscol());
Bram Moolenaar53241da2007-09-13 20:41:32 +00001743 firstline = ml_get(oap->start.lnum);
1744 pre_textlen = (long)STRLEN(firstline);
Bram Moolenaare2e69e42017-09-02 20:30:35 +02001745 pre_indent = (long)getwhitecols(firstline);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001746 bd.textcol = curwin->w_cursor.col;
1747 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001748
Bram Moolenaar071d4272004-06-13 20:20:40 +00001749 if (oap->motion_type == MLINE)
1750 fix_indent();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001751
1752 retval = edit(NUL, FALSE, (linenr_T)1);
1753
Bram Moolenaar071d4272004-06-13 20:20:40 +00001754 /*
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001755 * In Visual block mode, handle copying the new text to all lines of the
Bram Moolenaar071d4272004-06-13 20:20:40 +00001756 * block.
Bram Moolenaaraacbb002008-01-03 15:34:40 +00001757 * Don't repeat the insert when Insert mode ended with CTRL-C.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001758 */
Bram Moolenaaraacbb002008-01-03 15:34:40 +00001759 if (oap->block_mode && oap->start.lnum != oap->end.lnum && !got_int)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001760 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001761 // Auto-indenting may have changed the indent. If the cursor was past
1762 // the indent, exclude that indent change from the inserted text.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001763 firstline = ml_get(oap->start.lnum);
Bram Moolenaarb8dc4d42007-09-25 12:20:19 +00001764 if (bd.textcol > (colnr_T)pre_indent)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001765 {
Bram Moolenaare2e69e42017-09-02 20:30:35 +02001766 long new_indent = (long)getwhitecols(firstline);
Bram Moolenaar53241da2007-09-13 20:41:32 +00001767
1768 pre_textlen += new_indent - pre_indent;
1769 bd.textcol += new_indent - pre_indent;
1770 }
1771
1772 ins_len = (long)STRLEN(firstline) - pre_textlen;
1773 if (ins_len > 0)
1774 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001775 // Subsequent calls to ml_get() flush the firstline data - take a
1776 // copy of the inserted text.
Bram Moolenaar964b3742019-05-24 18:54:09 +02001777 if ((ins_text = alloc(ins_len + 1)) != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001778 {
Bram Moolenaarce0842a2005-07-18 21:58:11 +00001779 vim_strncpy(ins_text, firstline + bd.textcol, (size_t)ins_len);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001780 for (linenr = oap->start.lnum + 1; linenr <= oap->end.lnum;
1781 linenr++)
1782 {
1783 block_prep(oap, &bd, linenr, TRUE);
1784 if (!bd.is_short || virtual_op)
1785 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001786 pos_T vpos;
1787
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001788 // If the block starts in virtual space, count the
1789 // initial coladd offset as part of "startspaces"
Bram Moolenaar071d4272004-06-13 20:20:40 +00001790 if (bd.is_short)
1791 {
Bram Moolenaara1381de2009-11-03 15:44:21 +00001792 vpos.lnum = linenr;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001793 (void)getvpos(&vpos, oap->start_vcol);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001794 }
1795 else
1796 vpos.coladd = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001797 oldp = ml_get(linenr);
Bram Moolenaar964b3742019-05-24 18:54:09 +02001798 newp = alloc(STRLEN(oldp) + vpos.coladd + ins_len + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001799 if (newp == NULL)
1800 continue;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001801 // copy up to block start
Bram Moolenaar071d4272004-06-13 20:20:40 +00001802 mch_memmove(newp, oldp, (size_t)bd.textcol);
1803 offset = bd.textcol;
Bram Moolenaar2536d4f2015-07-17 13:22:51 +02001804 vim_memset(newp + offset, ' ', (size_t)vpos.coladd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001805 offset += vpos.coladd;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001806 mch_memmove(newp + offset, ins_text, (size_t)ins_len);
1807 offset += ins_len;
1808 oldp += bd.textcol;
Bram Moolenaarc1a11ed2008-06-24 22:09:24 +00001809 STRMOVE(newp + offset, oldp);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001810 ml_replace(linenr, newp, FALSE);
LemonBoyb559b302022-05-15 13:08:02 +01001811#ifdef FEAT_PROP_POPUP
1812 // Shift the properties for linenr as edit() would do.
1813 if (curbuf->b_has_textprop)
1814 adjust_prop_columns(linenr, bd.textcol,
1815 vpos.coladd + ins_len, 0);
1816#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001817 }
1818 }
1819 check_cursor();
1820
1821 changed_lines(oap->start.lnum + 1, 0, oap->end.lnum + 1, 0L);
1822 }
1823 vim_free(ins_text);
1824 }
1825 }
Bram Moolenaar6b36d2a2021-08-23 21:19:01 +02001826 auto_format(FALSE, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001827
1828 return retval;
1829}
1830
1831/*
Bram Moolenaarf193fff2006-04-27 00:02:13 +00001832 * When the cursor is on the NUL past the end of the line and it should not be
1833 * there move it left.
1834 */
1835 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01001836adjust_cursor_eol(void)
Bram Moolenaarf193fff2006-04-27 00:02:13 +00001837{
Gary Johnson53ba05b2021-07-26 22:19:10 +02001838 unsigned int cur_ve_flags = get_ve_flags();
1839
Bram Moolenaarf193fff2006-04-27 00:02:13 +00001840 if (curwin->w_cursor.col > 0
1841 && gchar_cursor() == NUL
Gary Johnson53ba05b2021-07-26 22:19:10 +02001842 && (cur_ve_flags & VE_ONEMORE) == 0
Bram Moolenaar24959102022-05-07 20:01:16 +01001843 && !(restart_edit || (State & MODE_INSERT)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001844 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001845 // Put the cursor on the last character in the line.
Bram Moolenaara5fac542005-10-12 20:58:49 +00001846 dec_cursor();
Bram Moolenaarf193fff2006-04-27 00:02:13 +00001847
Gary Johnson53ba05b2021-07-26 22:19:10 +02001848 if (cur_ve_flags == VE_ALL)
Bram Moolenaara5792f52005-11-23 21:25:05 +00001849 {
1850 colnr_T scol, ecol;
1851
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001852 // Coladd is set to the width of the last character.
Bram Moolenaara5792f52005-11-23 21:25:05 +00001853 getvcol(curwin, &curwin->w_cursor, &scol, NULL, &ecol);
1854 curwin->w_cursor.coladd = ecol - scol + 1;
1855 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001856 }
1857}
1858
Bram Moolenaar81340392012-06-06 16:12:59 +02001859/*
1860 * If "process" is TRUE and the line begins with a comment leader (possibly
1861 * after some white space), return a pointer to the text after it. Put a boolean
1862 * value indicating whether the line ends with an unclosed comment in
1863 * "is_comment".
1864 * line - line to be processed,
1865 * process - if FALSE, will only check whether the line ends with an unclosed
Bram Moolenaarbfe3bf82012-06-13 17:28:55 +02001866 * comment,
Bram Moolenaar81340392012-06-06 16:12:59 +02001867 * include_space - whether to also skip space following the comment leader,
1868 * is_comment - will indicate whether the current line ends with an unclosed
Bram Moolenaarbfe3bf82012-06-13 17:28:55 +02001869 * comment.
Bram Moolenaar81340392012-06-06 16:12:59 +02001870 */
Bram Moolenaar025a6b72017-03-12 20:37:21 +01001871 char_u *
Bram Moolenaar9b578142016-01-30 19:39:49 +01001872skip_comment(
1873 char_u *line,
1874 int process,
1875 int include_space,
1876 int *is_comment)
Bram Moolenaar81340392012-06-06 16:12:59 +02001877{
1878 char_u *comment_flags = NULL;
1879 int lead_len;
1880 int leader_offset = get_last_leader_offset(line, &comment_flags);
1881
1882 *is_comment = FALSE;
1883 if (leader_offset != -1)
1884 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001885 // Let's check whether the line ends with an unclosed comment.
1886 // If the last comment leader has COM_END in flags, there's no comment.
Bram Moolenaar81340392012-06-06 16:12:59 +02001887 while (*comment_flags)
1888 {
1889 if (*comment_flags == COM_END
1890 || *comment_flags == ':')
1891 break;
1892 ++comment_flags;
1893 }
1894 if (*comment_flags != COM_END)
1895 *is_comment = TRUE;
1896 }
1897
1898 if (process == FALSE)
1899 return line;
1900
1901 lead_len = get_leader_len(line, &comment_flags, FALSE, include_space);
1902
1903 if (lead_len == 0)
1904 return line;
1905
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001906 // Find:
1907 // - COM_END,
1908 // - colon,
1909 // whichever comes first.
Bram Moolenaar81340392012-06-06 16:12:59 +02001910 while (*comment_flags)
1911 {
Bram Moolenaare04a48f2012-06-13 14:01:41 +02001912 if (*comment_flags == COM_END
Bram Moolenaar81340392012-06-06 16:12:59 +02001913 || *comment_flags == ':')
Bram Moolenaar81340392012-06-06 16:12:59 +02001914 break;
Bram Moolenaar81340392012-06-06 16:12:59 +02001915 ++comment_flags;
1916 }
1917
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001918 // If we found a colon, it means that we are not processing a line
1919 // starting with a closing part of a three-part comment. That's good,
1920 // because we don't want to remove those as this would be annoying.
Bram Moolenaar81340392012-06-06 16:12:59 +02001921 if (*comment_flags == ':' || *comment_flags == NUL)
1922 line += lead_len;
1923
1924 return line;
1925}
Bram Moolenaar81340392012-06-06 16:12:59 +02001926
Bram Moolenaar071d4272004-06-13 20:20:40 +00001927/*
Bram Moolenaar893eaab2010-07-10 17:51:46 +02001928 * Join 'count' lines (minimal 2) at cursor position.
1929 * When "save_undo" is TRUE save lines for undo first.
Bram Moolenaard69bd9a2014-04-29 12:15:40 +02001930 * Set "use_formatoptions" to FALSE when e.g. processing backspace and comment
1931 * leaders should not be removed.
1932 * When setmark is TRUE, sets the '[ and '] mark, else, the caller is expected
1933 * to set those marks.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001934 *
Bram Moolenaar10c56952007-05-10 18:38:52 +00001935 * return FAIL for failure, OK otherwise
Bram Moolenaar071d4272004-06-13 20:20:40 +00001936 */
1937 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01001938do_join(
1939 long count,
1940 int insert_space,
1941 int save_undo,
1942 int use_formatoptions UNUSED,
1943 int setmark)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001944{
Bram Moolenaar893eaab2010-07-10 17:51:46 +02001945 char_u *curr = NULL;
Bram Moolenaar341ad7a2010-10-09 17:23:31 +02001946 char_u *curr_start = NULL;
Bram Moolenaar893eaab2010-07-10 17:51:46 +02001947 char_u *cend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001948 char_u *newp;
Bram Moolenaar87be9be2020-05-30 15:32:02 +02001949 size_t newp_len;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001950 char_u *spaces; // number of spaces inserted before a line
Bram Moolenaard43848c2010-07-14 14:28:26 +02001951 int endcurr1 = NUL;
1952 int endcurr2 = NUL;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001953 int currsize = 0; // size of the current line
1954 int sumsize = 0; // size of the long new line
Bram Moolenaar071d4272004-06-13 20:20:40 +00001955 linenr_T t;
Bram Moolenaar893eaab2010-07-10 17:51:46 +02001956 colnr_T col = 0;
1957 int ret = OK;
Bram Moolenaar802053f2012-06-06 23:08:38 +02001958 int *comments = NULL;
Bram Moolenaar81340392012-06-06 16:12:59 +02001959 int remove_comments = (use_formatoptions == TRUE)
1960 && has_format_option(FO_REMOVE_COMS);
1961 int prev_was_comment;
Bram Moolenaar05ad5ff2019-11-30 22:48:27 +01001962#ifdef FEAT_PROP_POPUP
Bram Moolenaar87be9be2020-05-30 15:32:02 +02001963 int propcount = 0; // number of props over all joined lines
1964 int props_remaining;
Bram Moolenaar80e737c2019-05-17 19:56:34 +02001965#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001966
Bram Moolenaar893eaab2010-07-10 17:51:46 +02001967 if (save_undo && u_save((linenr_T)(curwin->w_cursor.lnum - 1),
1968 (linenr_T)(curwin->w_cursor.lnum + count)) == FAIL)
1969 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001970
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01001971 // Allocate an array to store the number of spaces inserted before each
1972 // line. We will use it to pre-compute the length of the new line and the
1973 // proper placement of each original line in the new one.
Bram Moolenaar18a4ba22019-05-24 19:39:03 +02001974 spaces = lalloc_clear(count, TRUE);
Bram Moolenaar893eaab2010-07-10 17:51:46 +02001975 if (spaces == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001976 return FAIL;
Bram Moolenaar81340392012-06-06 16:12:59 +02001977 if (remove_comments)
1978 {
Bram Moolenaarc799fe22019-05-28 23:08:19 +02001979 comments = lalloc_clear(count * sizeof(int), TRUE);
Bram Moolenaar81340392012-06-06 16:12:59 +02001980 if (comments == NULL)
1981 {
1982 vim_free(spaces);
1983 return FAIL;
1984 }
1985 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001986
1987 /*
Bram Moolenaar80e737c2019-05-17 19:56:34 +02001988 * Don't move anything yet, just compute the final line length
Bram Moolenaar893eaab2010-07-10 17:51:46 +02001989 * and setup the array of space strings lengths
Bram Moolenaar80e737c2019-05-17 19:56:34 +02001990 * This loops forward over the joined lines.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001991 */
Bram Moolenaar893eaab2010-07-10 17:51:46 +02001992 for (t = 0; t < count; ++t)
1993 {
Bram Moolenaar341ad7a2010-10-09 17:23:31 +02001994 curr = curr_start = ml_get((linenr_T)(curwin->w_cursor.lnum + t));
Bram Moolenaar87be9be2020-05-30 15:32:02 +02001995#ifdef FEAT_PROP_POPUP
1996 propcount += count_props((linenr_T) (curwin->w_cursor.lnum + t), t > 0);
1997#endif
Bram Moolenaare1004402020-10-24 20:49:43 +02001998 if (t == 0 && setmark && (cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0)
Bram Moolenaarf92d8a22014-02-11 19:33:07 +01001999 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002000 // Set the '[ mark.
Bram Moolenaarf92d8a22014-02-11 19:33:07 +01002001 curwin->w_buffer->b_op_start.lnum = curwin->w_cursor.lnum;
2002 curwin->w_buffer->b_op_start.col = (colnr_T)STRLEN(curr);
2003 }
Bram Moolenaar81340392012-06-06 16:12:59 +02002004 if (remove_comments)
2005 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002006 // We don't want to remove the comment leader if the
2007 // previous line is not a comment.
Bram Moolenaar81340392012-06-06 16:12:59 +02002008 if (t > 0 && prev_was_comment)
2009 {
2010
2011 char_u *new_curr = skip_comment(curr, TRUE, insert_space,
2012 &prev_was_comment);
Bram Moolenaar27ba0882012-06-07 21:09:39 +02002013 comments[t] = (int)(new_curr - curr);
Bram Moolenaar81340392012-06-06 16:12:59 +02002014 curr = new_curr;
2015 }
2016 else
2017 curr = skip_comment(curr, FALSE, insert_space,
2018 &prev_was_comment);
2019 }
Bram Moolenaar81340392012-06-06 16:12:59 +02002020
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002021 if (insert_space && t > 0)
2022 {
2023 curr = skipwhite(curr);
Bram Moolenaarcc184cf2019-11-12 20:31:20 +01002024 if (*curr != NUL && *curr != ')'
Bram Moolenaar91b65e42019-12-17 22:10:58 +01002025 && sumsize != 0 && endcurr1 != TAB
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002026 && (!has_format_option(FO_MBYTE_JOIN)
2027 || (mb_ptr2char(curr) < 0x100 && endcurr1 < 0x100))
2028 && (!has_format_option(FO_MBYTE_JOIN2)
Bram Moolenaare52702f2020-06-04 18:22:13 +02002029 || (mb_ptr2char(curr) < 0x100
2030 && !(enc_utf8 && utf_eat_space(endcurr1)))
2031 || (endcurr1 < 0x100
2032 && !(enc_utf8 && utf_eat_space(mb_ptr2char(curr)))))
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002033 )
2034 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002035 // don't add a space if the line is ending in a space
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002036 if (endcurr1 == ' ')
2037 endcurr1 = endcurr2;
2038 else
2039 ++spaces[t];
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002040 // extra space when 'joinspaces' set and line ends in '.'
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002041 if ( p_js
2042 && (endcurr1 == '.'
2043 || (vim_strchr(p_cpo, CPO_JOINSP) == NULL
2044 && (endcurr1 == '?' || endcurr1 == '!'))))
2045 ++spaces[t];
2046 }
2047 }
2048 currsize = (int)STRLEN(curr);
2049 sumsize += currsize + spaces[t];
2050 endcurr1 = endcurr2 = NUL;
2051 if (insert_space && currsize > 0)
2052 {
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002053 if (has_mbyte)
2054 {
2055 cend = curr + currsize;
Bram Moolenaar91acfff2017-03-12 19:22:36 +01002056 MB_PTR_BACK(curr, cend);
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002057 endcurr1 = (*mb_ptr2char)(cend);
2058 if (cend > curr)
2059 {
Bram Moolenaar91acfff2017-03-12 19:22:36 +01002060 MB_PTR_BACK(curr, cend);
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002061 endcurr2 = (*mb_ptr2char)(cend);
2062 }
2063 }
2064 else
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002065 {
2066 endcurr1 = *(curr + currsize - 1);
2067 if (currsize > 1)
2068 endcurr2 = *(curr + currsize - 2);
2069 }
2070 }
2071 line_breakcheck();
2072 if (got_int)
2073 {
2074 ret = FAIL;
2075 goto theend;
2076 }
2077 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002078
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002079 // store the column position before last line
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002080 col = sumsize - currsize - spaces[count - 1];
Bram Moolenaar071d4272004-06-13 20:20:40 +00002081
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002082 // allocate the space for the new line
Bram Moolenaar87be9be2020-05-30 15:32:02 +02002083 newp_len = sumsize + 1;
2084#ifdef FEAT_PROP_POPUP
2085 newp_len += propcount * sizeof(textprop_T);
2086#endif
2087 newp = alloc(newp_len);
Bram Moolenaar6f10c702019-08-20 22:58:37 +02002088 if (newp == NULL)
2089 {
2090 ret = FAIL;
2091 goto theend;
2092 }
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002093 cend = newp + sumsize;
2094 *cend = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002095
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002096 /*
2097 * Move affected lines to the new long one.
Bram Moolenaar80e737c2019-05-17 19:56:34 +02002098 * This loops backwards over the joined lines, including the original line.
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002099 *
2100 * Move marks from each deleted line to the joined line, adjusting the
2101 * column. This is not Vi compatible, but Vi deletes the marks, thus that
2102 * should not really be a problem.
2103 */
Bram Moolenaar87be9be2020-05-30 15:32:02 +02002104#ifdef FEAT_PROP_POPUP
2105 props_remaining = propcount;
2106#endif
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002107 for (t = count - 1; ; --t)
2108 {
Bram Moolenaare1e714e2018-12-31 23:58:24 +01002109 int spaces_removed;
2110
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002111 cend -= currsize;
2112 mch_memmove(cend, curr, (size_t)currsize);
Bram Moolenaar87be9be2020-05-30 15:32:02 +02002113
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002114 if (spaces[t] > 0)
2115 {
2116 cend -= spaces[t];
Bram Moolenaar2536d4f2015-07-17 13:22:51 +02002117 vim_memset(cend, ' ', (size_t)(spaces[t]));
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002118 }
Bram Moolenaare1e714e2018-12-31 23:58:24 +01002119
2120 // If deleting more spaces than adding, the cursor moves no more than
2121 // what is added if it is inside these spaces.
2122 spaces_removed = (curr - curr_start) - spaces[t];
2123
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00002124 mark_col_adjust(curwin->w_cursor.lnum + t, (colnr_T)0, -t,
Bram Moolenaare1e714e2018-12-31 23:58:24 +01002125 (long)(cend - newp - spaces_removed), spaces_removed);
Bram Moolenaar05ad5ff2019-11-30 22:48:27 +01002126#ifdef FEAT_PROP_POPUP
Bram Moolenaar87be9be2020-05-30 15:32:02 +02002127 prepend_joined_props(newp + sumsize + 1, propcount, &props_remaining,
2128 curwin->w_cursor.lnum + t, t == count - 1,
2129 (long)(cend - newp), spaces_removed);
Bram Moolenaar80e737c2019-05-17 19:56:34 +02002130#endif
2131
Bram Moolenaar87be9be2020-05-30 15:32:02 +02002132 if (t == 0)
2133 break;
Bram Moolenaar341ad7a2010-10-09 17:23:31 +02002134 curr = curr_start = ml_get((linenr_T)(curwin->w_cursor.lnum + t - 1));
Bram Moolenaar81340392012-06-06 16:12:59 +02002135 if (remove_comments)
2136 curr += comments[t - 1];
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002137 if (insert_space && t > 1)
2138 curr = skipwhite(curr);
2139 currsize = (int)STRLEN(curr);
2140 }
Bram Moolenaar80e737c2019-05-17 19:56:34 +02002141
Bram Moolenaard6a77f92020-06-01 19:14:12 +02002142 ml_replace_len(curwin->w_cursor.lnum, newp, (colnr_T)newp_len, TRUE, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002143
Bram Moolenaare1004402020-10-24 20:49:43 +02002144 if (setmark && (cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0)
Bram Moolenaard69bd9a2014-04-29 12:15:40 +02002145 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002146 // Set the '] mark.
Bram Moolenaard69bd9a2014-04-29 12:15:40 +02002147 curwin->w_buffer->b_op_end.lnum = curwin->w_cursor.lnum;
Bram Moolenaar787880a2019-05-17 20:17:40 +02002148 curwin->w_buffer->b_op_end.col = (colnr_T)sumsize;
Bram Moolenaard69bd9a2014-04-29 12:15:40 +02002149 }
Bram Moolenaarf92d8a22014-02-11 19:33:07 +01002150
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002151 // Only report the change in the first line here, del_lines() will report
2152 // the deleted line.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002153 changed_lines(curwin->w_cursor.lnum, currsize,
2154 curwin->w_cursor.lnum + 1, 0L);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002155 /*
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002156 * Delete following lines. To do this we move the cursor there
Bram Moolenaar071d4272004-06-13 20:20:40 +00002157 * briefly, and then move it back. After del_lines() the cursor may
2158 * have moved up (last line deleted), so the current lnum is kept in t.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002159 */
2160 t = curwin->w_cursor.lnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002161 ++curwin->w_cursor.lnum;
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002162 del_lines(count - 1, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002163 curwin->w_cursor.lnum = t;
2164
2165 /*
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002166 * Set the cursor column:
2167 * Vi compatible: use the column of the first join
Bram Moolenaarcc448b32010-07-14 16:52:17 +02002168 * vim: use the column of the last join
Bram Moolenaar071d4272004-06-13 20:20:40 +00002169 */
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002170 curwin->w_cursor.col =
2171 (vim_strchr(p_cpo, CPO_JOINCOL) != NULL ? currsize : col);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002172 check_cursor_col();
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002173
Bram Moolenaar071d4272004-06-13 20:20:40 +00002174 curwin->w_cursor.coladd = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002175 curwin->w_set_curswant = TRUE;
2176
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002177theend:
2178 vim_free(spaces);
Bram Moolenaar81340392012-06-06 16:12:59 +02002179 if (remove_comments)
2180 vim_free(comments);
Bram Moolenaar893eaab2010-07-10 17:51:46 +02002181 return ret;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002182}
2183
Bram Moolenaar071d4272004-06-13 20:20:40 +00002184/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00002185 * prepare a few things for block mode yank/delete/tilde
2186 *
2187 * for delete:
2188 * - textlen includes the first/last char to be (partly) deleted
2189 * - start/endspaces is the number of columns that are taken by the
2190 * first/last deleted char minus the number of columns that have to be
Bram Moolenaar9d77dcc2009-03-11 15:28:26 +00002191 * deleted.
2192 * for yank and tilde:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002193 * - textlen includes the first/last char to be wholly yanked
2194 * - start/endspaces is the number of columns of the first/last yanked char
2195 * that are to be yanked.
2196 */
Bram Moolenaar4aea03e2019-09-25 22:37:17 +02002197 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002198block_prep(
2199 oparg_T *oap,
2200 struct block_def *bdp,
2201 linenr_T lnum,
2202 int is_del)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002203{
2204 int incr = 0;
2205 char_u *pend;
2206 char_u *pstart;
2207 char_u *line;
2208 char_u *prev_pstart;
2209 char_u *prev_pend;
Bram Moolenaar03c3bd92020-01-23 20:58:09 +01002210#ifdef FEAT_LINEBREAK
2211 int lbr_saved = curwin->w_p_lbr;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002212
Bram Moolenaar03c3bd92020-01-23 20:58:09 +01002213 // Avoid a problem with unwanted linebreaks in block mode.
2214 curwin->w_p_lbr = FALSE;
2215#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002216 bdp->startspaces = 0;
2217 bdp->endspaces = 0;
2218 bdp->textlen = 0;
2219 bdp->start_vcol = 0;
2220 bdp->end_vcol = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002221 bdp->is_short = FALSE;
2222 bdp->is_oneChar = FALSE;
2223 bdp->pre_whitesp = 0;
2224 bdp->pre_whitesp_c = 0;
2225 bdp->end_char_vcols = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002226 bdp->start_char_vcols = 0;
2227
2228 line = ml_get(lnum);
2229 pstart = line;
2230 prev_pstart = line;
2231 while (bdp->start_vcol < oap->start_vcol && *pstart)
2232 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002233 // Count a tab for what it's worth (if list mode not on)
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00002234 incr = lbr_chartabsize(line, pstart, bdp->start_vcol);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002235 bdp->start_vcol += incr;
Bram Moolenaar1c465442017-03-12 20:10:05 +01002236 if (VIM_ISWHITE(*pstart))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002237 {
2238 bdp->pre_whitesp += incr;
2239 bdp->pre_whitesp_c++;
2240 }
2241 else
2242 {
2243 bdp->pre_whitesp = 0;
2244 bdp->pre_whitesp_c = 0;
2245 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002246 prev_pstart = pstart;
Bram Moolenaar91acfff2017-03-12 19:22:36 +01002247 MB_PTR_ADV(pstart);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002248 }
2249 bdp->start_char_vcols = incr;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002250 if (bdp->start_vcol < oap->start_vcol) // line too short
Bram Moolenaar071d4272004-06-13 20:20:40 +00002251 {
2252 bdp->end_vcol = bdp->start_vcol;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002253 bdp->is_short = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002254 if (!is_del || oap->op_type == OP_APPEND)
2255 bdp->endspaces = oap->end_vcol - oap->start_vcol + 1;
2256 }
2257 else
2258 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002259 // notice: this converts partly selected Multibyte characters to
2260 // spaces, too.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002261 bdp->startspaces = bdp->start_vcol - oap->start_vcol;
2262 if (is_del && bdp->startspaces)
2263 bdp->startspaces = bdp->start_char_vcols - bdp->startspaces;
2264 pend = pstart;
2265 bdp->end_vcol = bdp->start_vcol;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002266 if (bdp->end_vcol > oap->end_vcol) // it's all in one character
Bram Moolenaar071d4272004-06-13 20:20:40 +00002267 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00002268 bdp->is_oneChar = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002269 if (oap->op_type == OP_INSERT)
2270 bdp->endspaces = bdp->start_char_vcols - bdp->startspaces;
2271 else if (oap->op_type == OP_APPEND)
2272 {
2273 bdp->startspaces += oap->end_vcol - oap->start_vcol + 1;
2274 bdp->endspaces = bdp->start_char_vcols - bdp->startspaces;
2275 }
2276 else
2277 {
2278 bdp->startspaces = oap->end_vcol - oap->start_vcol + 1;
2279 if (is_del && oap->op_type != OP_LSHIFT)
2280 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002281 // just putting the sum of those two into
2282 // bdp->startspaces doesn't work for Visual replace,
2283 // so we have to split the tab in two
Bram Moolenaar071d4272004-06-13 20:20:40 +00002284 bdp->startspaces = bdp->start_char_vcols
2285 - (bdp->start_vcol - oap->start_vcol);
2286 bdp->endspaces = bdp->end_vcol - oap->end_vcol - 1;
2287 }
2288 }
2289 }
2290 else
2291 {
2292 prev_pend = pend;
2293 while (bdp->end_vcol <= oap->end_vcol && *pend != NUL)
2294 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002295 // Count a tab for what it's worth (if list mode not on)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002296 prev_pend = pend;
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00002297 incr = lbr_chartabsize_adv(line, &pend, bdp->end_vcol);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002298 bdp->end_vcol += incr;
2299 }
2300 if (bdp->end_vcol <= oap->end_vcol
2301 && (!is_del
2302 || oap->op_type == OP_APPEND
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002303 || oap->op_type == OP_REPLACE)) // line too short
Bram Moolenaar071d4272004-06-13 20:20:40 +00002304 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00002305 bdp->is_short = TRUE;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002306 // Alternative: include spaces to fill up the block.
2307 // Disadvantage: can lead to trailing spaces when the line is
2308 // short where the text is put
2309 // if (!is_del || oap->op_type == OP_APPEND)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002310 if (oap->op_type == OP_APPEND || virtual_op)
2311 bdp->endspaces = oap->end_vcol - bdp->end_vcol
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00002312 + oap->inclusive;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002313 else
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002314 bdp->endspaces = 0; // replace doesn't add characters
Bram Moolenaar071d4272004-06-13 20:20:40 +00002315 }
2316 else if (bdp->end_vcol > oap->end_vcol)
2317 {
2318 bdp->endspaces = bdp->end_vcol - oap->end_vcol - 1;
2319 if (!is_del && bdp->endspaces)
2320 {
2321 bdp->endspaces = incr - bdp->endspaces;
2322 if (pend != pstart)
2323 pend = prev_pend;
2324 }
2325 }
2326 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002327 bdp->end_char_vcols = incr;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002328 if (is_del && bdp->startspaces)
2329 pstart = prev_pstart;
2330 bdp->textlen = (int)(pend - pstart);
2331 }
2332 bdp->textcol = (colnr_T) (pstart - line);
2333 bdp->textstart = pstart;
Bram Moolenaar03c3bd92020-01-23 20:58:09 +01002334#ifdef FEAT_LINEBREAK
2335 curwin->w_p_lbr = lbr_saved;
2336#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002337}
Bram Moolenaar071d4272004-06-13 20:20:40 +00002338
Bram Moolenaar071d4272004-06-13 20:20:40 +00002339/*
Bram Moolenaard79e5502016-01-10 22:13:02 +01002340 * Handle the add/subtract operator.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002341 */
Bram Moolenaard79e5502016-01-10 22:13:02 +01002342 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002343op_addsub(
2344 oparg_T *oap,
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002345 linenr_T Prenum1, // Amount of add/subtract
2346 int g_cmd) // was g<c-a>/g<c-x>
Bram Moolenaar071d4272004-06-13 20:20:40 +00002347{
Bram Moolenaard79e5502016-01-10 22:13:02 +01002348 pos_T pos;
2349 struct block_def bd;
2350 int change_cnt = 0;
2351 linenr_T amount = Prenum1;
2352
Bram Moolenaar6b731882018-11-16 20:54:47 +01002353 // do_addsub() might trigger re-evaluation of 'foldexpr' halfway, when the
Bram Moolenaarbdace832019-03-02 10:13:42 +01002354 // buffer is not completely updated yet. Postpone updating folds until before
Bram Moolenaar6b731882018-11-16 20:54:47 +01002355 // the call to changed_lines().
2356#ifdef FEAT_FOLDING
2357 disable_fold_update++;
2358#endif
2359
Bram Moolenaard79e5502016-01-10 22:13:02 +01002360 if (!VIsual_active)
2361 {
2362 pos = curwin->w_cursor;
2363 if (u_save_cursor() == FAIL)
Bram Moolenaar6b731882018-11-16 20:54:47 +01002364 {
2365#ifdef FEAT_FOLDING
2366 disable_fold_update--;
2367#endif
Bram Moolenaard79e5502016-01-10 22:13:02 +01002368 return;
Bram Moolenaar6b731882018-11-16 20:54:47 +01002369 }
Bram Moolenaard79e5502016-01-10 22:13:02 +01002370 change_cnt = do_addsub(oap->op_type, &pos, 0, amount);
Bram Moolenaar6b731882018-11-16 20:54:47 +01002371#ifdef FEAT_FOLDING
2372 disable_fold_update--;
2373#endif
Bram Moolenaard79e5502016-01-10 22:13:02 +01002374 if (change_cnt)
2375 changed_lines(pos.lnum, 0, pos.lnum + 1, 0L);
2376 }
2377 else
2378 {
Bram Moolenaar7ae4fbc2016-01-12 21:00:40 +01002379 int one_change;
2380 int length;
2381 pos_T startpos;
Bram Moolenaard79e5502016-01-10 22:13:02 +01002382
2383 if (u_save((linenr_T)(oap->start.lnum - 1),
2384 (linenr_T)(oap->end.lnum + 1)) == FAIL)
Bram Moolenaar6b731882018-11-16 20:54:47 +01002385 {
2386#ifdef FEAT_FOLDING
2387 disable_fold_update--;
2388#endif
Bram Moolenaard79e5502016-01-10 22:13:02 +01002389 return;
Bram Moolenaar6b731882018-11-16 20:54:47 +01002390 }
Bram Moolenaard79e5502016-01-10 22:13:02 +01002391
2392 pos = oap->start;
2393 for (; pos.lnum <= oap->end.lnum; ++pos.lnum)
2394 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002395 if (oap->block_mode) // Visual block mode
Bram Moolenaard79e5502016-01-10 22:13:02 +01002396 {
2397 block_prep(oap, &bd, pos.lnum, FALSE);
2398 pos.col = bd.textcol;
2399 length = bd.textlen;
2400 }
Bram Moolenaar7ae4fbc2016-01-12 21:00:40 +01002401 else if (oap->motion_type == MLINE)
Bram Moolenaard79e5502016-01-10 22:13:02 +01002402 {
Bram Moolenaar7ae4fbc2016-01-12 21:00:40 +01002403 curwin->w_cursor.col = 0;
2404 pos.col = 0;
2405 length = (colnr_T)STRLEN(ml_get(pos.lnum));
2406 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002407 else // oap->motion_type == MCHAR
Bram Moolenaar7ae4fbc2016-01-12 21:00:40 +01002408 {
Bram Moolenaar5fe6bdf2017-12-05 17:22:12 +01002409 if (pos.lnum == oap->start.lnum && !oap->inclusive)
Bram Moolenaar7ae4fbc2016-01-12 21:00:40 +01002410 dec(&(oap->end));
2411 length = (colnr_T)STRLEN(ml_get(pos.lnum));
2412 pos.col = 0;
2413 if (pos.lnum == oap->start.lnum)
Bram Moolenaard79e5502016-01-10 22:13:02 +01002414 {
Bram Moolenaar7ae4fbc2016-01-12 21:00:40 +01002415 pos.col += oap->start.col;
2416 length -= oap->start.col;
Bram Moolenaard79e5502016-01-10 22:13:02 +01002417 }
Bram Moolenaar7ae4fbc2016-01-12 21:00:40 +01002418 if (pos.lnum == oap->end.lnum)
Bram Moolenaard79e5502016-01-10 22:13:02 +01002419 {
Bram Moolenaar7ae4fbc2016-01-12 21:00:40 +01002420 length = (int)STRLEN(ml_get(oap->end.lnum));
2421 if (oap->end.col >= length)
2422 oap->end.col = length - 1;
2423 length = oap->end.col - pos.col + 1;
Bram Moolenaard79e5502016-01-10 22:13:02 +01002424 }
2425 }
2426 one_change = do_addsub(oap->op_type, &pos, length, amount);
2427 if (one_change)
2428 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002429 // Remember the start position of the first change.
Bram Moolenaard79e5502016-01-10 22:13:02 +01002430 if (change_cnt == 0)
2431 startpos = curbuf->b_op_start;
2432 ++change_cnt;
2433 }
2434
2435#ifdef FEAT_NETBEANS_INTG
2436 if (netbeans_active() && one_change)
2437 {
Yegappan Lakshmanan2ac71842021-05-31 19:23:01 +02002438 char_u *ptr;
Bram Moolenaard79e5502016-01-10 22:13:02 +01002439
2440 netbeans_removed(curbuf, pos.lnum, pos.col, (long)length);
Yegappan Lakshmanan2ac71842021-05-31 19:23:01 +02002441 ptr = ml_get_buf(curbuf, pos.lnum, FALSE);
Bram Moolenaard79e5502016-01-10 22:13:02 +01002442 netbeans_inserted(curbuf, pos.lnum, pos.col,
2443 &ptr[pos.col], length);
2444 }
2445#endif
2446 if (g_cmd && one_change)
2447 amount += Prenum1;
2448 }
Bram Moolenaar6b731882018-11-16 20:54:47 +01002449
2450#ifdef FEAT_FOLDING
2451 disable_fold_update--;
2452#endif
Bram Moolenaard79e5502016-01-10 22:13:02 +01002453 if (change_cnt)
2454 changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L);
2455
2456 if (!change_cnt && oap->is_VIsual)
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002457 // No change: need to remove the Visual selection
Bram Moolenaard79e5502016-01-10 22:13:02 +01002458 redraw_curbuf_later(INVERTED);
2459
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002460 // Set '[ mark if something changed. Keep the last end
2461 // position from do_addsub().
Bram Moolenaare1004402020-10-24 20:49:43 +02002462 if (change_cnt > 0 && (cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0)
Bram Moolenaard79e5502016-01-10 22:13:02 +01002463 curbuf->b_op_start = startpos;
2464
2465 if (change_cnt > p_report)
Bram Moolenaardb99f9f2020-03-23 22:12:22 +01002466 smsg(NGETTEXT("%d line changed", "%d lines changed",
Bram Moolenaarda6e8912018-08-21 15:12:14 +02002467 change_cnt), change_cnt);
Bram Moolenaard79e5502016-01-10 22:13:02 +01002468 }
2469}
2470
2471/*
2472 * Add or subtract 'Prenum1' from a number in a line
2473 * op_type is OP_NR_ADD or OP_NR_SUB
2474 *
2475 * Returns TRUE if some character was changed.
2476 */
2477 static int
Bram Moolenaar9b578142016-01-30 19:39:49 +01002478do_addsub(
2479 int op_type,
2480 pos_T *pos,
2481 int length,
2482 linenr_T Prenum1)
Bram Moolenaard79e5502016-01-10 22:13:02 +01002483{
Bram Moolenaar071d4272004-06-13 20:20:40 +00002484 int col;
2485 char_u *buf1;
2486 char_u buf2[NUMBUFLEN];
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002487 int pre; // 'X'/'x': hex; '0': octal; 'B'/'b': bin
2488 static int hexupper = FALSE; // 0xABC
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02002489 uvarnumber_T n;
2490 uvarnumber_T oldn;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002491 char_u *ptr;
2492 int c;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002493 int todel;
Bram Moolenaaraaad9952020-05-31 15:08:59 +02002494 int do_hex;
2495 int do_oct;
2496 int do_bin;
2497 int do_alpha;
2498 int do_unsigned;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002499 int firstdigit;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002500 int subtract;
Bram Moolenaar3a304b22015-06-25 13:57:36 +02002501 int negative = FALSE;
Bram Moolenaar9bb19302015-07-03 12:44:07 +02002502 int was_positive = TRUE;
Bram Moolenaar3a304b22015-06-25 13:57:36 +02002503 int visual = VIsual_active;
Bram Moolenaar3ec32612015-07-12 15:02:38 +02002504 int did_change = FALSE;
Bram Moolenaar7ae4fbc2016-01-12 21:00:40 +01002505 pos_T save_cursor = curwin->w_cursor;
Bram Moolenaar5d1bc782015-07-17 13:03:48 +02002506 int maxlen = 0;
Bram Moolenaara52dfae2016-01-10 20:21:57 +01002507 pos_T startpos;
2508 pos_T endpos;
Bram Moolenaar6c6be9e2020-06-12 20:19:44 +02002509 colnr_T save_coladd = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002510
Bram Moolenaaraaad9952020-05-31 15:08:59 +02002511 do_hex = (vim_strchr(curbuf->b_p_nf, 'x') != NULL); // "heX"
2512 do_oct = (vim_strchr(curbuf->b_p_nf, 'o') != NULL); // "Octal"
2513 do_bin = (vim_strchr(curbuf->b_p_nf, 'b') != NULL); // "Bin"
2514 do_alpha = (vim_strchr(curbuf->b_p_nf, 'p') != NULL); // "alPha"
2515 do_unsigned = (vim_strchr(curbuf->b_p_nf, 'u') != NULL); // "Unsigned"
Bram Moolenaar071d4272004-06-13 20:20:40 +00002516
Bram Moolenaar6c6be9e2020-06-12 20:19:44 +02002517 if (virtual_active())
2518 {
2519 save_coladd = pos->coladd;
2520 pos->coladd = 0;
2521 }
2522
Bram Moolenaard79e5502016-01-10 22:13:02 +01002523 curwin->w_cursor = *pos;
2524 ptr = ml_get(pos->lnum);
2525 col = pos->col;
2526
Bram Moolenaar6c6be9e2020-06-12 20:19:44 +02002527 if (*ptr == NUL || col + !!save_coladd >= (int)STRLEN(ptr))
Bram Moolenaard79e5502016-01-10 22:13:02 +01002528 goto theend;
2529
Bram Moolenaar071d4272004-06-13 20:20:40 +00002530 /*
2531 * First check if we are on a hexadecimal number, after the "0x".
2532 */
Bram Moolenaard79e5502016-01-10 22:13:02 +01002533 if (!VIsual_active)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002534 {
Bram Moolenaaraaad9952020-05-31 15:08:59 +02002535 if (do_bin)
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002536 while (col > 0 && vim_isbdigit(ptr[col]))
Bram Moolenaarad5ca9b2016-06-20 21:26:08 +02002537 {
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002538 --col;
Bram Moolenaarad5ca9b2016-06-20 21:26:08 +02002539 if (has_mbyte)
2540 col -= (*mb_head_off)(ptr, ptr + col);
Bram Moolenaarad5ca9b2016-06-20 21:26:08 +02002541 }
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002542
Bram Moolenaaraaad9952020-05-31 15:08:59 +02002543 if (do_hex)
Bram Moolenaar3a304b22015-06-25 13:57:36 +02002544 while (col > 0 && vim_isxdigit(ptr[col]))
Bram Moolenaarad5ca9b2016-06-20 21:26:08 +02002545 {
Bram Moolenaar3a304b22015-06-25 13:57:36 +02002546 --col;
Bram Moolenaarad5ca9b2016-06-20 21:26:08 +02002547 if (has_mbyte)
2548 col -= (*mb_head_off)(ptr, ptr + col);
Bram Moolenaarad5ca9b2016-06-20 21:26:08 +02002549 }
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002550
Bram Moolenaaraaad9952020-05-31 15:08:59 +02002551 if ( do_bin
2552 && do_hex
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002553 && ! ((col > 0
2554 && (ptr[col] == 'X'
2555 || ptr[col] == 'x')
2556 && ptr[col - 1] == '0'
Bram Moolenaarad5ca9b2016-06-20 21:26:08 +02002557 && (!has_mbyte ||
2558 !(*mb_head_off)(ptr, ptr + col - 1))
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002559 && vim_isxdigit(ptr[col + 1]))))
2560 {
2561
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002562 // In case of binary/hexadecimal pattern overlap match, rescan
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002563
Bram Moolenaard79e5502016-01-10 22:13:02 +01002564 col = pos->col;
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002565
2566 while (col > 0 && vim_isdigit(ptr[col]))
Bram Moolenaarad5ca9b2016-06-20 21:26:08 +02002567 {
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002568 col--;
Bram Moolenaarad5ca9b2016-06-20 21:26:08 +02002569 if (has_mbyte)
2570 col -= (*mb_head_off)(ptr, ptr + col);
Bram Moolenaarad5ca9b2016-06-20 21:26:08 +02002571 }
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002572 }
2573
Bram Moolenaaraaad9952020-05-31 15:08:59 +02002574 if (( do_hex
Bram Moolenaar3a304b22015-06-25 13:57:36 +02002575 && col > 0
2576 && (ptr[col] == 'X'
2577 || ptr[col] == 'x')
2578 && ptr[col - 1] == '0'
Bram Moolenaarad5ca9b2016-06-20 21:26:08 +02002579 && (!has_mbyte ||
2580 !(*mb_head_off)(ptr, ptr + col - 1))
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002581 && vim_isxdigit(ptr[col + 1])) ||
Bram Moolenaaraaad9952020-05-31 15:08:59 +02002582 ( do_bin
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002583 && col > 0
2584 && (ptr[col] == 'B'
2585 || ptr[col] == 'b')
2586 && ptr[col - 1] == '0'
Bram Moolenaarad5ca9b2016-06-20 21:26:08 +02002587 && (!has_mbyte ||
2588 !(*mb_head_off)(ptr, ptr + col - 1))
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002589 && vim_isbdigit(ptr[col + 1])))
Bram Moolenaar3a304b22015-06-25 13:57:36 +02002590 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002591 // Found hexadecimal or binary number, move to its start.
Bram Moolenaar3a304b22015-06-25 13:57:36 +02002592 --col;
Bram Moolenaarad5ca9b2016-06-20 21:26:08 +02002593 if (has_mbyte)
2594 col -= (*mb_head_off)(ptr, ptr + col);
Bram Moolenaar3a304b22015-06-25 13:57:36 +02002595 }
2596 else
2597 {
2598 /*
2599 * Search forward and then backward to find the start of number.
2600 */
Bram Moolenaard79e5502016-01-10 22:13:02 +01002601 col = pos->col;
Bram Moolenaar3a304b22015-06-25 13:57:36 +02002602
2603 while (ptr[col] != NUL
2604 && !vim_isdigit(ptr[col])
Bram Moolenaaraaad9952020-05-31 15:08:59 +02002605 && !(do_alpha && ASCII_ISALPHA(ptr[col])))
Bram Moolenaar1614a142019-10-06 22:00:13 +02002606 col += mb_ptr2len(ptr + col);
Bram Moolenaar3a304b22015-06-25 13:57:36 +02002607
2608 while (col > 0
2609 && vim_isdigit(ptr[col - 1])
Bram Moolenaaraaad9952020-05-31 15:08:59 +02002610 && !(do_alpha && ASCII_ISALPHA(ptr[col])))
Bram Moolenaarad5ca9b2016-06-20 21:26:08 +02002611 {
Bram Moolenaar3a304b22015-06-25 13:57:36 +02002612 --col;
Bram Moolenaarad5ca9b2016-06-20 21:26:08 +02002613 if (has_mbyte)
2614 col -= (*mb_head_off)(ptr, ptr + col);
Bram Moolenaarad5ca9b2016-06-20 21:26:08 +02002615 }
Bram Moolenaar3a304b22015-06-25 13:57:36 +02002616 }
2617 }
2618
Bram Moolenaar5d1bc782015-07-17 13:03:48 +02002619 if (visual)
Bram Moolenaard79e5502016-01-10 22:13:02 +01002620 {
2621 while (ptr[col] != NUL && length > 0
2622 && !vim_isdigit(ptr[col])
Bram Moolenaaraaad9952020-05-31 15:08:59 +02002623 && !(do_alpha && ASCII_ISALPHA(ptr[col])))
Bram Moolenaard79e5502016-01-10 22:13:02 +01002624 {
Bram Moolenaar1614a142019-10-06 22:00:13 +02002625 int mb_len = mb_ptr2len(ptr + col);
Bram Moolenaarad5ca9b2016-06-20 21:26:08 +02002626
2627 col += mb_len;
2628 length -= mb_len;
Bram Moolenaard79e5502016-01-10 22:13:02 +01002629 }
2630
2631 if (length == 0)
2632 goto theend;
2633
Bram Moolenaarad5ca9b2016-06-20 21:26:08 +02002634 if (col > pos->col && ptr[col - 1] == '-'
Bram Moolenaaraaad9952020-05-31 15:08:59 +02002635 && (!has_mbyte || !(*mb_head_off)(ptr, ptr + col - 1))
2636 && !do_unsigned)
Bram Moolenaard79e5502016-01-10 22:13:02 +01002637 {
2638 negative = TRUE;
2639 was_positive = FALSE;
2640 }
2641 }
2642
2643 /*
2644 * If a number was found, and saving for undo works, replace the number.
2645 */
2646 firstdigit = ptr[col];
Bram Moolenaaraaad9952020-05-31 15:08:59 +02002647 if (!VIM_ISDIGIT(firstdigit) && !(do_alpha && ASCII_ISALPHA(firstdigit)))
Bram Moolenaard79e5502016-01-10 22:13:02 +01002648 {
2649 beep_flush();
2650 goto theend;
2651 }
2652
Bram Moolenaaraaad9952020-05-31 15:08:59 +02002653 if (do_alpha && ASCII_ISALPHA(firstdigit))
Bram Moolenaard79e5502016-01-10 22:13:02 +01002654 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002655 // decrement or increment alphabetic character
Bram Moolenaard79e5502016-01-10 22:13:02 +01002656 if (op_type == OP_NR_SUB)
2657 {
2658 if (CharOrd(firstdigit) < Prenum1)
2659 {
2660 if (isupper(firstdigit))
2661 firstdigit = 'A';
2662 else
2663 firstdigit = 'a';
2664 }
2665 else
Bram Moolenaard79e5502016-01-10 22:13:02 +01002666 firstdigit -= Prenum1;
Bram Moolenaard79e5502016-01-10 22:13:02 +01002667 }
2668 else
2669 {
2670 if (26 - CharOrd(firstdigit) - 1 < Prenum1)
2671 {
2672 if (isupper(firstdigit))
2673 firstdigit = 'Z';
2674 else
2675 firstdigit = 'z';
2676 }
2677 else
Bram Moolenaard79e5502016-01-10 22:13:02 +01002678 firstdigit += Prenum1;
Bram Moolenaard79e5502016-01-10 22:13:02 +01002679 }
2680 curwin->w_cursor.col = col;
2681 if (!did_change)
2682 startpos = curwin->w_cursor;
2683 did_change = TRUE;
2684 (void)del_char(FALSE);
2685 ins_char(firstdigit);
2686 endpos = curwin->w_cursor;
2687 curwin->w_cursor.col = col;
2688 }
2689 else
2690 {
Bram Moolenaarc8f12c92020-09-15 20:34:10 +02002691 pos_T save_pos;
2692 int i;
2693
Bram Moolenaarad5ca9b2016-06-20 21:26:08 +02002694 if (col > 0 && ptr[col - 1] == '-'
Bram Moolenaarad5ca9b2016-06-20 21:26:08 +02002695 && (!has_mbyte ||
2696 !(*mb_head_off)(ptr, ptr + col - 1))
Bram Moolenaaraaad9952020-05-31 15:08:59 +02002697 && !visual
2698 && !do_unsigned)
Bram Moolenaard79e5502016-01-10 22:13:02 +01002699 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002700 // negative number
Bram Moolenaard79e5502016-01-10 22:13:02 +01002701 --col;
2702 negative = TRUE;
2703 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002704 // get the number value (unsigned)
Bram Moolenaard79e5502016-01-10 22:13:02 +01002705 if (visual && VIsual_mode != 'V')
2706 maxlen = (curbuf->b_visual.vi_curswant == MAXCOL
2707 ? (int)STRLEN(ptr) - col
2708 : length);
2709
2710 vim_str2nr(ptr + col, &pre, &length,
Bram Moolenaaraaad9952020-05-31 15:08:59 +02002711 0 + (do_bin ? STR2NR_BIN : 0)
2712 + (do_oct ? STR2NR_OCT : 0)
2713 + (do_hex ? STR2NR_HEX : 0),
Bram Moolenaar16e9b852019-05-19 19:59:35 +02002714 NULL, &n, maxlen, FALSE);
Bram Moolenaard79e5502016-01-10 22:13:02 +01002715
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002716 // ignore leading '-' for hex and octal and bin numbers
Bram Moolenaard79e5502016-01-10 22:13:02 +01002717 if (pre && negative)
2718 {
2719 ++col;
2720 --length;
2721 negative = FALSE;
2722 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002723 // add or subtract
Bram Moolenaard79e5502016-01-10 22:13:02 +01002724 subtract = FALSE;
2725 if (op_type == OP_NR_SUB)
2726 subtract ^= TRUE;
2727 if (negative)
2728 subtract ^= TRUE;
2729
2730 oldn = n;
2731 if (subtract)
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02002732 n -= (uvarnumber_T)Prenum1;
Bram Moolenaard79e5502016-01-10 22:13:02 +01002733 else
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02002734 n += (uvarnumber_T)Prenum1;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002735 // handle wraparound for decimal numbers
Bram Moolenaard79e5502016-01-10 22:13:02 +01002736 if (!pre)
2737 {
2738 if (subtract)
2739 {
2740 if (n > oldn)
2741 {
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02002742 n = 1 + (n ^ (uvarnumber_T)-1);
Bram Moolenaard79e5502016-01-10 22:13:02 +01002743 negative ^= TRUE;
2744 }
2745 }
2746 else
2747 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002748 // add
Bram Moolenaard79e5502016-01-10 22:13:02 +01002749 if (n < oldn)
2750 {
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02002751 n = (n ^ (uvarnumber_T)-1);
Bram Moolenaard79e5502016-01-10 22:13:02 +01002752 negative ^= TRUE;
2753 }
2754 }
2755 if (n == 0)
2756 negative = FALSE;
2757 }
2758
Bram Moolenaaraaad9952020-05-31 15:08:59 +02002759 if (do_unsigned && negative)
2760 {
2761 if (subtract)
2762 // sticking at zero.
2763 n = (uvarnumber_T)0;
2764 else
2765 // sticking at 2^64 - 1.
2766 n = (uvarnumber_T)(-1);
2767 negative = FALSE;
2768 }
2769
Bram Moolenaard79e5502016-01-10 22:13:02 +01002770 if (visual && !was_positive && !negative && col > 0)
2771 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002772 // need to remove the '-'
Bram Moolenaard79e5502016-01-10 22:13:02 +01002773 col--;
2774 length++;
2775 }
2776
2777 /*
2778 * Delete the old number.
2779 */
2780 curwin->w_cursor.col = col;
2781 if (!did_change)
2782 startpos = curwin->w_cursor;
2783 did_change = TRUE;
2784 todel = length;
2785 c = gchar_cursor();
2786 /*
2787 * Don't include the '-' in the length, only the length of the
2788 * part after it is kept the same.
2789 */
2790 if (c == '-')
2791 --length;
Bram Moolenaarc8f12c92020-09-15 20:34:10 +02002792
2793 save_pos = curwin->w_cursor;
2794 for (i = 0; i < todel; ++i)
Bram Moolenaard79e5502016-01-10 22:13:02 +01002795 {
2796 if (c < 0x100 && isalpha(c))
2797 {
2798 if (isupper(c))
2799 hexupper = TRUE;
2800 else
2801 hexupper = FALSE;
2802 }
Bram Moolenaarc8f12c92020-09-15 20:34:10 +02002803 inc_cursor();
Bram Moolenaard79e5502016-01-10 22:13:02 +01002804 c = gchar_cursor();
2805 }
Bram Moolenaarc8f12c92020-09-15 20:34:10 +02002806 curwin->w_cursor = save_pos;
Bram Moolenaard79e5502016-01-10 22:13:02 +01002807
2808 /*
2809 * Prepare the leading characters in buf1[].
2810 * When there are many leading zeros it could be very long.
2811 * Allocate a bit too much.
2812 */
Bram Moolenaar964b3742019-05-24 18:54:09 +02002813 buf1 = alloc(length + NUMBUFLEN);
Bram Moolenaard79e5502016-01-10 22:13:02 +01002814 if (buf1 == NULL)
2815 goto theend;
2816 ptr = buf1;
Bram Moolenaardc633cf2016-04-23 14:33:19 +02002817 if (negative && (!visual || was_positive))
Bram Moolenaard79e5502016-01-10 22:13:02 +01002818 *ptr++ = '-';
Bram Moolenaard79e5502016-01-10 22:13:02 +01002819 if (pre)
2820 {
2821 *ptr++ = '0';
2822 --length;
2823 }
2824 if (pre == 'b' || pre == 'B' ||
2825 pre == 'x' || pre == 'X')
2826 {
2827 *ptr++ = pre;
2828 --length;
2829 }
2830
2831 /*
2832 * Put the number characters in buf2[].
2833 */
2834 if (pre == 'b' || pre == 'B')
2835 {
Bram Moolenaard79e5502016-01-10 22:13:02 +01002836 int bit = 0;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02002837 int bits = sizeof(uvarnumber_T) * 8;
Bram Moolenaard79e5502016-01-10 22:13:02 +01002838
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002839 // leading zeros
Bram Moolenaard79e5502016-01-10 22:13:02 +01002840 for (bit = bits; bit > 0; bit--)
2841 if ((n >> (bit - 1)) & 0x1) break;
2842
2843 for (i = 0; bit > 0; bit--)
2844 buf2[i++] = ((n >> (bit - 1)) & 0x1) ? '1' : '0';
2845
2846 buf2[i] = '\0';
2847 }
2848 else if (pre == 0)
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00002849 vim_snprintf((char *)buf2, NUMBUFLEN, "%llu", n);
Bram Moolenaard79e5502016-01-10 22:13:02 +01002850 else if (pre == '0')
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00002851 vim_snprintf((char *)buf2, NUMBUFLEN, "%llo", n);
Bram Moolenaard79e5502016-01-10 22:13:02 +01002852 else if (pre && hexupper)
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00002853 vim_snprintf((char *)buf2, NUMBUFLEN, "%llX", n);
Bram Moolenaard79e5502016-01-10 22:13:02 +01002854 else
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00002855 vim_snprintf((char *)buf2, NUMBUFLEN, "%llx", n);
Bram Moolenaard79e5502016-01-10 22:13:02 +01002856 length -= (int)STRLEN(buf2);
2857
2858 /*
2859 * Adjust number of zeros to the new number of digits, so the
2860 * total length of the number remains the same.
2861 * Don't do this when
2862 * the result may look like an octal number.
2863 */
Bram Moolenaaraaad9952020-05-31 15:08:59 +02002864 if (firstdigit == '0' && !(do_oct && pre == 0))
Bram Moolenaard79e5502016-01-10 22:13:02 +01002865 while (length-- > 0)
2866 *ptr++ = '0';
2867 *ptr = NUL;
Bram Moolenaarc8f12c92020-09-15 20:34:10 +02002868
Bram Moolenaard79e5502016-01-10 22:13:02 +01002869 STRCAT(buf1, buf2);
Bram Moolenaarc8f12c92020-09-15 20:34:10 +02002870
2871 // Insert just after the first character to be removed, so that any
2872 // text properties will be adjusted. Then delete the old number
2873 // afterwards.
2874 save_pos = curwin->w_cursor;
2875 if (todel > 0)
2876 inc_cursor();
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002877 ins_str(buf1); // insert the new number
Bram Moolenaard79e5502016-01-10 22:13:02 +01002878 vim_free(buf1);
Bram Moolenaarc8f12c92020-09-15 20:34:10 +02002879
2880 // del_char() will also mark line needing displaying
2881 if (todel > 0)
2882 {
2883 int bytes_after = (int)STRLEN(ml_get_curline())
2884 - curwin->w_cursor.col;
2885
2886 // Delete the one character before the insert.
2887 curwin->w_cursor = save_pos;
2888 (void)del_char(FALSE);
Bram Moolenaar573545a2020-09-16 15:46:08 +02002889 curwin->w_cursor.col = (colnr_T)(STRLEN(ml_get_curline())
2890 - bytes_after);
Bram Moolenaarc8f12c92020-09-15 20:34:10 +02002891 --todel;
2892 }
2893 while (todel-- > 0)
2894 (void)del_char(FALSE);
2895
Bram Moolenaard79e5502016-01-10 22:13:02 +01002896 endpos = curwin->w_cursor;
2897 if (did_change && curwin->w_cursor.col)
2898 --curwin->w_cursor.col;
2899 }
2900
Bram Moolenaare1004402020-10-24 20:49:43 +02002901 if (did_change && (cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0)
Bram Moolenaara52dfae2016-01-10 20:21:57 +01002902 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002903 // set the '[ and '] marks
Bram Moolenaara52dfae2016-01-10 20:21:57 +01002904 curbuf->b_op_start = startpos;
2905 curbuf->b_op_end = endpos;
2906 if (curbuf->b_op_end.col > 0)
2907 --curbuf->b_op_end.col;
2908 }
Bram Moolenaard79e5502016-01-10 22:13:02 +01002909
Bram Moolenaar7ae4fbc2016-01-12 21:00:40 +01002910theend:
2911 if (visual)
2912 curwin->w_cursor = save_cursor;
Bram Moolenaar8e081252016-03-21 23:13:32 +01002913 else if (did_change)
2914 curwin->w_set_curswant = TRUE;
Bram Moolenaar6c6be9e2020-06-12 20:19:44 +02002915 else if (virtual_active())
2916 curwin->w_cursor.coladd = save_coladd;
Bram Moolenaar7ae4fbc2016-01-12 21:00:40 +01002917
Bram Moolenaard79e5502016-01-10 22:13:02 +01002918 return did_change;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002919}
2920
Bram Moolenaar071d4272004-06-13 20:20:40 +00002921 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002922clear_oparg(oparg_T *oap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002923{
Bram Moolenaara80faa82020-04-12 19:37:17 +02002924 CLEAR_POINTER(oap);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002925}
2926
Bram Moolenaar071d4272004-06-13 20:20:40 +00002927/*
Bram Moolenaar7c626922005-02-07 22:01:03 +00002928 * Count the number of bytes, characters and "words" in a line.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002929 *
2930 * "Words" are counted by looking for boundaries between non-space and
2931 * space characters. (it seems to produce results that match 'wc'.)
2932 *
Bram Moolenaar7c626922005-02-07 22:01:03 +00002933 * Return value is byte count; word count for the line is added to "*wc".
2934 * Char count is added to "*cc".
Bram Moolenaar071d4272004-06-13 20:20:40 +00002935 *
2936 * The function will only examine the first "limit" characters in the
2937 * line, stopping if it encounters an end-of-line (NUL byte). In that
2938 * case, eol_size will be added to the character count to account for
2939 * the size of the EOL character.
2940 */
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02002941 static varnumber_T
Bram Moolenaar9b578142016-01-30 19:39:49 +01002942line_count_info(
2943 char_u *line,
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02002944 varnumber_T *wc,
2945 varnumber_T *cc,
2946 varnumber_T limit,
Bram Moolenaar9b578142016-01-30 19:39:49 +01002947 int eol_size)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002948{
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02002949 varnumber_T i;
2950 varnumber_T words = 0;
2951 varnumber_T chars = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002952 int is_word = 0;
2953
Bram Moolenaar88b1ba12012-06-29 13:34:19 +02002954 for (i = 0; i < limit && line[i] != NUL; )
Bram Moolenaar071d4272004-06-13 20:20:40 +00002955 {
2956 if (is_word)
2957 {
2958 if (vim_isspace(line[i]))
2959 {
2960 words++;
2961 is_word = 0;
2962 }
2963 }
2964 else if (!vim_isspace(line[i]))
2965 is_word = 1;
Bram Moolenaar7c626922005-02-07 22:01:03 +00002966 ++chars;
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00002967 i += (*mb_ptr2len)(line + i);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002968 }
2969
2970 if (is_word)
2971 words++;
2972 *wc += words;
2973
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01002974 // Add eol_size if the end of line was reached before hitting limit.
Bram Moolenaar1cb7e092011-08-10 12:11:01 +02002975 if (i < limit && line[i] == NUL)
Bram Moolenaar7c626922005-02-07 22:01:03 +00002976 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00002977 i += eol_size;
Bram Moolenaar7c626922005-02-07 22:01:03 +00002978 chars += eol_size;
2979 }
2980 *cc += chars;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002981 return i;
2982}
2983
2984/*
2985 * Give some info about the position of the cursor (for "g CTRL-G").
2986 * In Visual mode, give some info about the selected region. (In this case,
2987 * the *_count_cursor variables store running totals for the selection.)
Bram Moolenaared767a22016-01-03 22:49:16 +01002988 * When "dict" is not NULL store the info there instead of showing it.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002989 */
2990 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002991cursor_pos_info(dict_T *dict)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002992{
2993 char_u *p;
Bram Moolenaar555b2802005-05-19 21:08:39 +00002994 char_u buf1[50];
2995 char_u buf2[40];
Bram Moolenaar071d4272004-06-13 20:20:40 +00002996 linenr_T lnum;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02002997 varnumber_T byte_count = 0;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02002998 varnumber_T bom_count = 0;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02002999 varnumber_T byte_count_cursor = 0;
3000 varnumber_T char_count = 0;
3001 varnumber_T char_count_cursor = 0;
3002 varnumber_T word_count = 0;
3003 varnumber_T word_count_cursor = 0;
Bram Moolenaar7c626922005-02-07 22:01:03 +00003004 int eol_size;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02003005 varnumber_T last_check = 100000L;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003006 long line_count_selected = 0;
3007 pos_T min_pos, max_pos;
3008 oparg_T oparg;
3009 struct block_def bd;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003010
3011 /*
3012 * Compute the length of the file in characters.
3013 */
3014 if (curbuf->b_ml.ml_flags & ML_EMPTY)
3015 {
Bram Moolenaared767a22016-01-03 22:49:16 +01003016 if (dict == NULL)
3017 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01003018 msg(_(no_lines_msg));
Bram Moolenaared767a22016-01-03 22:49:16 +01003019 return;
3020 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003021 }
3022 else
3023 {
3024 if (get_fileformat(curbuf) == EOL_DOS)
3025 eol_size = 2;
3026 else
3027 eol_size = 1;
3028
Bram Moolenaar071d4272004-06-13 20:20:40 +00003029 if (VIsual_active)
3030 {
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01003031 if (LT_POS(VIsual, curwin->w_cursor))
Bram Moolenaar071d4272004-06-13 20:20:40 +00003032 {
3033 min_pos = VIsual;
3034 max_pos = curwin->w_cursor;
3035 }
3036 else
3037 {
3038 min_pos = curwin->w_cursor;
3039 max_pos = VIsual;
3040 }
3041 if (*p_sel == 'e' && max_pos.col > 0)
3042 --max_pos.col;
3043
3044 if (VIsual_mode == Ctrl_V)
3045 {
Bram Moolenaar81d00072009-04-29 15:41:40 +00003046#ifdef FEAT_LINEBREAK
3047 char_u * saved_sbr = p_sbr;
Bram Moolenaaree857022019-11-09 23:26:40 +01003048 char_u * saved_w_sbr = curwin->w_p_sbr;
Bram Moolenaar81d00072009-04-29 15:41:40 +00003049
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003050 // Make 'sbr' empty for a moment to get the correct size.
Bram Moolenaar81d00072009-04-29 15:41:40 +00003051 p_sbr = empty_option;
Bram Moolenaaree857022019-11-09 23:26:40 +01003052 curwin->w_p_sbr = empty_option;
Bram Moolenaar81d00072009-04-29 15:41:40 +00003053#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003054 oparg.is_VIsual = 1;
3055 oparg.block_mode = TRUE;
3056 oparg.op_type = OP_NOP;
3057 getvcols(curwin, &min_pos, &max_pos,
Bram Moolenaar5c8837f2006-02-25 21:52:33 +00003058 &oparg.start_vcol, &oparg.end_vcol);
Bram Moolenaar81d00072009-04-29 15:41:40 +00003059#ifdef FEAT_LINEBREAK
3060 p_sbr = saved_sbr;
Bram Moolenaaree857022019-11-09 23:26:40 +01003061 curwin->w_p_sbr = saved_w_sbr;
Bram Moolenaar81d00072009-04-29 15:41:40 +00003062#endif
Bram Moolenaar5c8837f2006-02-25 21:52:33 +00003063 if (curwin->w_curswant == MAXCOL)
3064 oparg.end_vcol = MAXCOL;
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003065 // Swap the start, end vcol if needed
Bram Moolenaar071d4272004-06-13 20:20:40 +00003066 if (oparg.end_vcol < oparg.start_vcol)
3067 {
3068 oparg.end_vcol += oparg.start_vcol;
3069 oparg.start_vcol = oparg.end_vcol - oparg.start_vcol;
3070 oparg.end_vcol -= oparg.start_vcol;
3071 }
3072 }
3073 line_count_selected = max_pos.lnum - min_pos.lnum + 1;
3074 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003075
3076 for (lnum = 1; lnum <= curbuf->b_ml.ml_line_count; ++lnum)
3077 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003078 // Check for a CTRL-C every 100000 characters.
Bram Moolenaar7c626922005-02-07 22:01:03 +00003079 if (byte_count > last_check)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003080 {
3081 ui_breakcheck();
3082 if (got_int)
3083 return;
Bram Moolenaar7c626922005-02-07 22:01:03 +00003084 last_check = byte_count + 100000L;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003085 }
3086
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003087 // Do extra processing for VIsual mode.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003088 if (VIsual_active
3089 && lnum >= min_pos.lnum && lnum <= max_pos.lnum)
3090 {
Bram Moolenaardef9e822004-12-31 20:58:58 +00003091 char_u *s = NULL;
3092 long len = 0L;
3093
Bram Moolenaar071d4272004-06-13 20:20:40 +00003094 switch (VIsual_mode)
3095 {
3096 case Ctrl_V:
Bram Moolenaar071d4272004-06-13 20:20:40 +00003097 virtual_op = virtual_active();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003098 block_prep(&oparg, &bd, lnum, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003099 virtual_op = MAYBE;
Bram Moolenaardef9e822004-12-31 20:58:58 +00003100 s = bd.textstart;
3101 len = (long)bd.textlen;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003102 break;
3103 case 'V':
Bram Moolenaardef9e822004-12-31 20:58:58 +00003104 s = ml_get(lnum);
3105 len = MAXCOL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003106 break;
3107 case 'v':
3108 {
3109 colnr_T start_col = (lnum == min_pos.lnum)
3110 ? min_pos.col : 0;
3111 colnr_T end_col = (lnum == max_pos.lnum)
3112 ? max_pos.col - start_col + 1 : MAXCOL;
3113
Bram Moolenaardef9e822004-12-31 20:58:58 +00003114 s = ml_get(lnum) + start_col;
3115 len = end_col;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003116 }
3117 break;
3118 }
Bram Moolenaardef9e822004-12-31 20:58:58 +00003119 if (s != NULL)
3120 {
Bram Moolenaar7c626922005-02-07 22:01:03 +00003121 byte_count_cursor += line_count_info(s, &word_count_cursor,
3122 &char_count_cursor, len, eol_size);
Bram Moolenaardef9e822004-12-31 20:58:58 +00003123 if (lnum == curbuf->b_ml.ml_line_count
3124 && !curbuf->b_p_eol
Bram Moolenaar34d72d42015-07-17 14:18:08 +02003125 && (curbuf->b_p_bin || !curbuf->b_p_fixeol)
Bram Moolenaarec2dad62005-01-02 11:36:03 +00003126 && (long)STRLEN(s) < len)
Bram Moolenaar7c626922005-02-07 22:01:03 +00003127 byte_count_cursor -= eol_size;
Bram Moolenaardef9e822004-12-31 20:58:58 +00003128 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003129 }
3130 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00003131 {
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003132 // In non-visual mode, check for the line the cursor is on
Bram Moolenaar071d4272004-06-13 20:20:40 +00003133 if (lnum == curwin->w_cursor.lnum)
3134 {
3135 word_count_cursor += word_count;
Bram Moolenaar7c626922005-02-07 22:01:03 +00003136 char_count_cursor += char_count;
3137 byte_count_cursor = byte_count +
3138 line_count_info(ml_get(lnum),
3139 &word_count_cursor, &char_count_cursor,
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02003140 (varnumber_T)(curwin->w_cursor.col + 1),
3141 eol_size);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003142 }
3143 }
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003144 // Add to the running totals
Bram Moolenaar7c626922005-02-07 22:01:03 +00003145 byte_count += line_count_info(ml_get(lnum), &word_count,
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02003146 &char_count, (varnumber_T)MAXCOL,
3147 eol_size);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003148 }
3149
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003150 // Correction for when last line doesn't have an EOL.
Bram Moolenaar34d72d42015-07-17 14:18:08 +02003151 if (!curbuf->b_p_eol && (curbuf->b_p_bin || !curbuf->b_p_fixeol))
Bram Moolenaar7c626922005-02-07 22:01:03 +00003152 byte_count -= eol_size;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003153
Bram Moolenaared767a22016-01-03 22:49:16 +01003154 if (dict == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003155 {
Bram Moolenaared767a22016-01-03 22:49:16 +01003156 if (VIsual_active)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003157 {
Bram Moolenaared767a22016-01-03 22:49:16 +01003158 if (VIsual_mode == Ctrl_V && curwin->w_curswant < MAXCOL)
3159 {
3160 getvcols(curwin, &min_pos, &max_pos, &min_pos.col,
3161 &max_pos.col);
3162 vim_snprintf((char *)buf1, sizeof(buf1), _("%ld Cols; "),
3163 (long)(oparg.end_vcol - oparg.start_vcol + 1));
3164 }
3165 else
3166 buf1[0] = NUL;
3167
3168 if (char_count_cursor == byte_count_cursor
3169 && char_count == byte_count)
3170 vim_snprintf((char *)IObuff, IOSIZE,
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02003171 _("Selected %s%ld of %ld Lines; %lld of %lld Words; %lld of %lld Bytes"),
Bram Moolenaared767a22016-01-03 22:49:16 +01003172 buf1, line_count_selected,
3173 (long)curbuf->b_ml.ml_line_count,
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00003174 word_count_cursor,
3175 word_count,
3176 byte_count_cursor,
3177 byte_count);
Bram Moolenaared767a22016-01-03 22:49:16 +01003178 else
3179 vim_snprintf((char *)IObuff, IOSIZE,
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02003180 _("Selected %s%ld of %ld Lines; %lld of %lld Words; %lld of %lld Chars; %lld of %lld Bytes"),
Bram Moolenaared767a22016-01-03 22:49:16 +01003181 buf1, line_count_selected,
3182 (long)curbuf->b_ml.ml_line_count,
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00003183 word_count_cursor,
3184 word_count,
3185 char_count_cursor,
3186 char_count,
3187 byte_count_cursor,
3188 byte_count);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003189 }
3190 else
Bram Moolenaared767a22016-01-03 22:49:16 +01003191 {
3192 p = ml_get_curline();
3193 validate_virtcol();
3194 col_print(buf1, sizeof(buf1), (int)curwin->w_cursor.col + 1,
3195 (int)curwin->w_virtcol + 1);
3196 col_print(buf2, sizeof(buf2), (int)STRLEN(p),
3197 linetabsize(p));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003198
Bram Moolenaared767a22016-01-03 22:49:16 +01003199 if (char_count_cursor == byte_count_cursor
3200 && char_count == byte_count)
3201 vim_snprintf((char *)IObuff, IOSIZE,
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02003202 _("Col %s of %s; Line %ld of %ld; Word %lld of %lld; Byte %lld of %lld"),
Bram Moolenaared767a22016-01-03 22:49:16 +01003203 (char *)buf1, (char *)buf2,
3204 (long)curwin->w_cursor.lnum,
Bram Moolenaar071d4272004-06-13 20:20:40 +00003205 (long)curbuf->b_ml.ml_line_count,
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00003206 word_count_cursor, word_count,
3207 byte_count_cursor, byte_count);
Bram Moolenaared767a22016-01-03 22:49:16 +01003208 else
3209 vim_snprintf((char *)IObuff, IOSIZE,
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02003210 _("Col %s of %s; Line %ld of %ld; Word %lld of %lld; Char %lld of %lld; Byte %lld of %lld"),
Bram Moolenaared767a22016-01-03 22:49:16 +01003211 (char *)buf1, (char *)buf2,
3212 (long)curwin->w_cursor.lnum,
Bram Moolenaar7c626922005-02-07 22:01:03 +00003213 (long)curbuf->b_ml.ml_line_count,
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00003214 word_count_cursor, word_count,
3215 char_count_cursor, char_count,
3216 byte_count_cursor, byte_count);
Bram Moolenaared767a22016-01-03 22:49:16 +01003217 }
3218 }
3219
Bram Moolenaared767a22016-01-03 22:49:16 +01003220 bom_count = bomb_size();
Bram Moolenaardbec7492019-09-13 22:16:21 +02003221 if (dict == NULL && bom_count > 0)
Bram Moolenaar08b28b72019-12-30 20:42:39 +01003222 {
3223 size_t len = STRLEN(IObuff);
3224
3225 vim_snprintf((char *)IObuff + len, IOSIZE - len,
=?UTF-8?q?Dundar=20G=C3=B6c?=420fabc2022-01-28 15:28:04 +00003226 _("(+%lld for BOM)"), bom_count);
Bram Moolenaar08b28b72019-12-30 20:42:39 +01003227 }
Bram Moolenaared767a22016-01-03 22:49:16 +01003228 if (dict == NULL)
3229 {
Bram Moolenaardbec7492019-09-13 22:16:21 +02003230 // Don't shorten this message, the user asked for it.
Bram Moolenaared767a22016-01-03 22:49:16 +01003231 p = p_shm;
3232 p_shm = (char_u *)"";
Bram Moolenaar32526b32019-01-19 17:43:09 +01003233 msg((char *)IObuff);
Bram Moolenaared767a22016-01-03 22:49:16 +01003234 p_shm = p;
3235 }
3236 }
Bram Moolenaar718272a2016-01-03 22:56:45 +01003237#if defined(FEAT_EVAL)
Bram Moolenaared767a22016-01-03 22:49:16 +01003238 if (dict != NULL)
3239 {
Bram Moolenaare0be1672018-07-08 16:50:37 +02003240 dict_add_number(dict, "words", word_count);
3241 dict_add_number(dict, "chars", char_count);
Bram Moolenaarfc3abf42019-01-24 15:54:21 +01003242 dict_add_number(dict, "bytes", byte_count + bom_count);
Bram Moolenaare0be1672018-07-08 16:50:37 +02003243 dict_add_number(dict, VIsual_active ? "visual_bytes" : "cursor_bytes",
3244 byte_count_cursor);
3245 dict_add_number(dict, VIsual_active ? "visual_chars" : "cursor_chars",
3246 char_count_cursor);
3247 dict_add_number(dict, VIsual_active ? "visual_words" : "cursor_words",
3248 word_count_cursor);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003249 }
Bram Moolenaar718272a2016-01-03 22:56:45 +01003250#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003251}
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003252
3253/*
3254 * Handle indent and format operators and visual mode ":".
3255 */
3256 static void
3257op_colon(oparg_T *oap)
3258{
3259 stuffcharReadbuff(':');
3260 if (oap->is_VIsual)
3261 stuffReadbuff((char_u *)"'<,'>");
3262 else
3263 {
3264 // Make the range look nice, so it can be repeated.
3265 if (oap->start.lnum == curwin->w_cursor.lnum)
3266 stuffcharReadbuff('.');
3267 else
3268 stuffnumReadbuff((long)oap->start.lnum);
3269 if (oap->end.lnum != oap->start.lnum)
3270 {
3271 stuffcharReadbuff(',');
3272 if (oap->end.lnum == curwin->w_cursor.lnum)
3273 stuffcharReadbuff('.');
3274 else if (oap->end.lnum == curbuf->b_ml.ml_line_count)
3275 stuffcharReadbuff('$');
3276 else if (oap->start.lnum == curwin->w_cursor.lnum)
3277 {
3278 stuffReadbuff((char_u *)".+");
3279 stuffnumReadbuff((long)oap->line_count - 1);
3280 }
3281 else
3282 stuffnumReadbuff((long)oap->end.lnum);
3283 }
3284 }
3285 if (oap->op_type != OP_COLON)
3286 stuffReadbuff((char_u *)"!");
3287 if (oap->op_type == OP_INDENT)
3288 {
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003289 if (*get_equalprg() == NUL)
3290 stuffReadbuff((char_u *)"indent");
3291 else
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003292 stuffReadbuff(get_equalprg());
3293 stuffReadbuff((char_u *)"\n");
3294 }
3295 else if (oap->op_type == OP_FORMAT)
3296 {
3297 if (*curbuf->b_p_fp != NUL)
3298 stuffReadbuff(curbuf->b_p_fp);
3299 else if (*p_fp != NUL)
3300 stuffReadbuff(p_fp);
3301 else
3302 stuffReadbuff((char_u *)"fmt");
3303 stuffReadbuff((char_u *)"\n']");
3304 }
3305
3306 // do_cmdline() does the rest
3307}
3308
Yegappan Lakshmanan777175b2021-11-18 22:08:57 +00003309// callback function for 'operatorfunc'
3310static callback_T opfunc_cb;
3311
3312/*
3313 * Process the 'operatorfunc' option value.
3314 * Returns OK or FAIL.
3315 */
3316 int
3317set_operatorfunc_option(void)
3318{
3319 return option_set_callback_func(p_opfunc, &opfunc_cb);
3320}
3321
3322#if defined(EXITFREE) || defined(PROTO)
3323 void
3324free_operatorfunc_option(void)
3325{
Yegappan Lakshmanan6ae8fae2021-12-12 16:26:44 +00003326# ifdef FEAT_EVAL
Yegappan Lakshmanan777175b2021-11-18 22:08:57 +00003327 free_callback(&opfunc_cb);
Yegappan Lakshmanan6ae8fae2021-12-12 16:26:44 +00003328# endif
Yegappan Lakshmanan777175b2021-11-18 22:08:57 +00003329}
3330#endif
3331
Dominique Pelle748b3082022-01-08 12:41:16 +00003332#if defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003333/*
Yegappan Lakshmanan6ae8fae2021-12-12 16:26:44 +00003334 * Mark the global 'operatorfunc' callback with 'copyID' so that it is not
3335 * garbage collected.
3336 */
3337 int
3338set_ref_in_opfunc(int copyID UNUSED)
3339{
3340 int abort = FALSE;
3341
Yegappan Lakshmanan6ae8fae2021-12-12 16:26:44 +00003342 abort = set_ref_in_callback(&opfunc_cb, copyID);
Yegappan Lakshmanan6ae8fae2021-12-12 16:26:44 +00003343
3344 return abort;
3345}
Dominique Pelle748b3082022-01-08 12:41:16 +00003346#endif
Yegappan Lakshmanan6ae8fae2021-12-12 16:26:44 +00003347
3348/*
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003349 * Handle the "g@" operator: call 'operatorfunc'.
3350 */
3351 static void
3352op_function(oparg_T *oap UNUSED)
3353{
3354#ifdef FEAT_EVAL
3355 typval_T argv[2];
3356 int save_virtual_op = virtual_op;
naohiro ono75c30e92021-10-19 11:15:41 +01003357 int save_finish_op = finish_op;
Bram Moolenaarf4a1d1c2019-11-16 13:50:25 +01003358 pos_T orig_start = curbuf->b_op_start;
3359 pos_T orig_end = curbuf->b_op_end;
Yegappan Lakshmanan777175b2021-11-18 22:08:57 +00003360 typval_T rettv;
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003361
3362 if (*p_opfunc == NUL)
Bram Moolenaar677658a2022-01-05 16:09:06 +00003363 emsg(_(e_operatorfunc_is_empty));
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003364 else
3365 {
3366 // Set '[ and '] marks to text to be operated on.
3367 curbuf->b_op_start = oap->start;
3368 curbuf->b_op_end = oap->end;
3369 if (oap->motion_type != MLINE && !oap->inclusive)
3370 // Exclude the end position.
3371 decl(&curbuf->b_op_end);
3372
3373 argv[0].v_type = VAR_STRING;
3374 if (oap->block_mode)
3375 argv[0].vval.v_string = (char_u *)"block";
3376 else if (oap->motion_type == MLINE)
3377 argv[0].vval.v_string = (char_u *)"line";
3378 else
3379 argv[0].vval.v_string = (char_u *)"char";
3380 argv[1].v_type = VAR_UNKNOWN;
3381
3382 // Reset virtual_op so that 'virtualedit' can be changed in the
3383 // function.
3384 virtual_op = MAYBE;
3385
naohiro ono75c30e92021-10-19 11:15:41 +01003386 // Reset finish_op so that mode() returns the right value.
3387 finish_op = FALSE;
3388
Yegappan Lakshmanan777175b2021-11-18 22:08:57 +00003389 if (call_callback(&opfunc_cb, 0, &rettv, 1, argv) != FAIL)
3390 clear_tv(&rettv);
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003391
3392 virtual_op = save_virtual_op;
naohiro ono75c30e92021-10-19 11:15:41 +01003393 finish_op = save_finish_op;
Bram Moolenaare1004402020-10-24 20:49:43 +02003394 if (cmdmod.cmod_flags & CMOD_LOCKMARKS)
Bram Moolenaarf4a1d1c2019-11-16 13:50:25 +01003395 {
3396 curbuf->b_op_start = orig_start;
3397 curbuf->b_op_end = orig_end;
3398 }
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003399 }
3400#else
Bram Moolenaar677658a2022-01-05 16:09:06 +00003401 emsg(_(e_eval_feature_not_available));
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003402#endif
3403}
3404
3405/*
3406 * Calculate start/end virtual columns for operating in block mode.
3407 */
3408 static void
3409get_op_vcol(
3410 oparg_T *oap,
3411 colnr_T redo_VIsual_vcol,
3412 int initial) // when TRUE adjust position for 'selectmode'
3413{
3414 colnr_T start, end;
3415
3416 if (VIsual_mode != Ctrl_V
3417 || (!initial && oap->end.col < curwin->w_width))
3418 return;
3419
3420 oap->block_mode = TRUE;
3421
3422 // prevent from moving onto a trail byte
3423 if (has_mbyte)
3424 mb_adjustpos(curwin->w_buffer, &oap->end);
3425
3426 getvvcol(curwin, &(oap->start), &oap->start_vcol, NULL, &oap->end_vcol);
3427
3428 if (!redo_VIsual_busy)
3429 {
3430 getvvcol(curwin, &(oap->end), &start, NULL, &end);
3431
3432 if (start < oap->start_vcol)
3433 oap->start_vcol = start;
3434 if (end > oap->end_vcol)
3435 {
3436 if (initial && *p_sel == 'e' && start >= 1
3437 && start - 1 >= oap->end_vcol)
3438 oap->end_vcol = start - 1;
3439 else
3440 oap->end_vcol = end;
3441 }
3442 }
3443
3444 // if '$' was used, get oap->end_vcol from longest line
3445 if (curwin->w_curswant == MAXCOL)
3446 {
3447 curwin->w_cursor.col = MAXCOL;
3448 oap->end_vcol = 0;
3449 for (curwin->w_cursor.lnum = oap->start.lnum;
3450 curwin->w_cursor.lnum <= oap->end.lnum;
3451 ++curwin->w_cursor.lnum)
3452 {
3453 getvvcol(curwin, &curwin->w_cursor, NULL, NULL, &end);
3454 if (end > oap->end_vcol)
3455 oap->end_vcol = end;
3456 }
3457 }
3458 else if (redo_VIsual_busy)
3459 oap->end_vcol = oap->start_vcol + redo_VIsual_vcol - 1;
3460 // Correct oap->end.col and oap->start.col to be the
3461 // upper-left and lower-right corner of the block area.
3462 //
3463 // (Actually, this does convert column positions into character
3464 // positions)
3465 curwin->w_cursor.lnum = oap->end.lnum;
3466 coladvance(oap->end_vcol);
3467 oap->end = curwin->w_cursor;
3468
3469 curwin->w_cursor = oap->start;
3470 coladvance(oap->start_vcol);
3471 oap->start = curwin->w_cursor;
3472}
3473
Bram Moolenaarb3bd1d32022-01-02 13:05:45 +00003474// Information for redoing the previous Visual selection.
3475typedef struct {
3476 int rv_mode; // 'v', 'V', or Ctrl-V
3477 linenr_T rv_line_count; // number of lines
3478 colnr_T rv_vcol; // number of cols or end column
3479 long rv_count; // count for Visual operator
3480 int rv_arg; // extra argument
3481} redo_VIsual_T;
3482
Bram Moolenaare32c3c42022-01-15 18:26:04 +00003483 static int
3484is_ex_cmdchar(cmdarg_T *cap)
3485{
3486 return cap->cmdchar == ':'
3487 || cap->cmdchar == K_COMMAND
3488 || cap->cmdchar == K_SCRIPT_COMMAND;
3489}
3490
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003491/*
3492 * Handle an operator after Visual mode or when the movement is finished.
3493 * "gui_yank" is true when yanking text for the clipboard.
3494 */
3495 void
3496do_pending_operator(cmdarg_T *cap, int old_col, int gui_yank)
3497{
3498 oparg_T *oap = cap->oap;
3499 pos_T old_cursor;
3500 int empty_region_error;
3501 int restart_edit_save;
3502#ifdef FEAT_LINEBREAK
3503 int lbr_saved = curwin->w_p_lbr;
3504#endif
3505
3506 // The visual area is remembered for redo
Bram Moolenaarb3bd1d32022-01-02 13:05:45 +00003507 static redo_VIsual_T redo_VIsual = {NUL, 0, 0, 0,0};
3508
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003509 int include_line_break = FALSE;
3510
3511#if defined(FEAT_CLIPBOARD)
3512 // Yank the visual area into the GUI selection register before we operate
3513 // on it and lose it forever.
3514 // Don't do it if a specific register was specified, so that ""x"*P works.
3515 // This could call do_pending_operator() recursively, but that's OK
3516 // because gui_yank will be TRUE for the nested call.
3517 if ((clip_star.available || clip_plus.available)
3518 && oap->op_type != OP_NOP
3519 && !gui_yank
3520 && VIsual_active
3521 && !redo_VIsual_busy
3522 && oap->regname == 0)
3523 clip_auto_select();
3524#endif
3525 old_cursor = curwin->w_cursor;
3526
3527 // If an operation is pending, handle it...
3528 if ((finish_op || VIsual_active) && oap->op_type != OP_NOP)
3529 {
3530 // Yank can be redone when 'y' is in 'cpoptions', but not when yanking
3531 // for the clipboard.
3532 int redo_yank = vim_strchr(p_cpo, CPO_YANK) != NULL && !gui_yank;
3533
3534#ifdef FEAT_LINEBREAK
3535 // Avoid a problem with unwanted linebreaks in block mode.
3536 if (curwin->w_p_lbr)
3537 curwin->w_valid &= ~VALID_VIRTCOL;
3538 curwin->w_p_lbr = FALSE;
3539#endif
3540 oap->is_VIsual = VIsual_active;
3541 if (oap->motion_force == 'V')
3542 oap->motion_type = MLINE;
3543 else if (oap->motion_force == 'v')
3544 {
3545 // If the motion was linewise, "inclusive" will not have been set.
3546 // Use "exclusive" to be consistent. Makes "dvj" work nice.
3547 if (oap->motion_type == MLINE)
3548 oap->inclusive = FALSE;
3549 // If the motion already was characterwise, toggle "inclusive"
3550 else if (oap->motion_type == MCHAR)
3551 oap->inclusive = !oap->inclusive;
3552 oap->motion_type = MCHAR;
3553 }
3554 else if (oap->motion_force == Ctrl_V)
3555 {
3556 // Change line- or characterwise motion into Visual block mode.
3557 if (!VIsual_active)
3558 {
3559 VIsual_active = TRUE;
3560 VIsual = oap->start;
3561 }
3562 VIsual_mode = Ctrl_V;
3563 VIsual_select = FALSE;
3564 VIsual_reselect = FALSE;
3565 }
3566
3567 // Only redo yank when 'y' flag is in 'cpoptions'.
3568 // Never redo "zf" (define fold).
3569 if ((redo_yank || oap->op_type != OP_YANK)
3570 && ((!VIsual_active || oap->motion_force)
3571 // Also redo Operator-pending Visual mode mappings
Bram Moolenaarc77534c2020-11-18 11:34:37 +01003572 || (VIsual_active
Bram Moolenaare32c3c42022-01-15 18:26:04 +00003573 && is_ex_cmdchar(cap) && oap->op_type != OP_COLON))
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003574 && cap->cmdchar != 'D'
3575#ifdef FEAT_FOLDING
3576 && oap->op_type != OP_FOLD
3577 && oap->op_type != OP_FOLDOPEN
3578 && oap->op_type != OP_FOLDOPENREC
3579 && oap->op_type != OP_FOLDCLOSE
3580 && oap->op_type != OP_FOLDCLOSEREC
3581 && oap->op_type != OP_FOLDDEL
3582 && oap->op_type != OP_FOLDDELREC
3583#endif
3584 )
3585 {
3586 prep_redo(oap->regname, cap->count0,
3587 get_op_char(oap->op_type), get_extra_op_char(oap->op_type),
3588 oap->motion_force, cap->cmdchar, cap->nchar);
3589 if (cap->cmdchar == '/' || cap->cmdchar == '?') // was a search
3590 {
3591 // If 'cpoptions' does not contain 'r', insert the search
3592 // pattern to really repeat the same command.
3593 if (vim_strchr(p_cpo, CPO_REDO) == NULL)
3594 AppendToRedobuffLit(cap->searchbuf, -1);
3595 AppendToRedobuff(NL_STR);
3596 }
Bram Moolenaare32c3c42022-01-15 18:26:04 +00003597 else if (is_ex_cmdchar(cap))
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003598 {
3599 // do_cmdline() has stored the first typed line in
3600 // "repeat_cmdline". When several lines are typed repeating
3601 // won't be possible.
3602 if (repeat_cmdline == NULL)
3603 ResetRedobuff();
3604 else
3605 {
3606 AppendToRedobuffLit(repeat_cmdline, -1);
3607 AppendToRedobuff(NL_STR);
3608 VIM_CLEAR(repeat_cmdline);
3609 }
3610 }
3611 }
3612
3613 if (redo_VIsual_busy)
3614 {
3615 // Redo of an operation on a Visual area. Use the same size from
Bram Moolenaarb3bd1d32022-01-02 13:05:45 +00003616 // redo_VIsual.rv_line_count and redo_VIsual.rv_vcol.
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003617 oap->start = curwin->w_cursor;
Bram Moolenaarb3bd1d32022-01-02 13:05:45 +00003618 curwin->w_cursor.lnum += redo_VIsual.rv_line_count - 1;
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003619 if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count)
3620 curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
Bram Moolenaarb3bd1d32022-01-02 13:05:45 +00003621 VIsual_mode = redo_VIsual.rv_mode;
3622 if (redo_VIsual.rv_vcol == MAXCOL || VIsual_mode == 'v')
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003623 {
3624 if (VIsual_mode == 'v')
3625 {
Bram Moolenaarb3bd1d32022-01-02 13:05:45 +00003626 if (redo_VIsual.rv_line_count <= 1)
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003627 {
3628 validate_virtcol();
3629 curwin->w_curswant =
Bram Moolenaarb3bd1d32022-01-02 13:05:45 +00003630 curwin->w_virtcol + redo_VIsual.rv_vcol - 1;
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003631 }
3632 else
Bram Moolenaarb3bd1d32022-01-02 13:05:45 +00003633 curwin->w_curswant = redo_VIsual.rv_vcol;
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003634 }
3635 else
3636 {
3637 curwin->w_curswant = MAXCOL;
3638 }
3639 coladvance(curwin->w_curswant);
3640 }
Bram Moolenaarb3bd1d32022-01-02 13:05:45 +00003641 cap->count0 = redo_VIsual.rv_count;
3642 if (redo_VIsual.rv_count != 0)
3643 cap->count1 = redo_VIsual.rv_count;
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003644 else
3645 cap->count1 = 1;
3646 }
3647 else if (VIsual_active)
3648 {
3649 if (!gui_yank)
3650 {
3651 // Save the current VIsual area for '< and '> marks, and "gv"
3652 curbuf->b_visual.vi_start = VIsual;
3653 curbuf->b_visual.vi_end = curwin->w_cursor;
3654 curbuf->b_visual.vi_mode = VIsual_mode;
3655 restore_visual_mode();
3656 curbuf->b_visual.vi_curswant = curwin->w_curswant;
K.Takata6e1d31e2022-02-03 13:05:32 +00003657#ifdef FEAT_EVAL
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003658 curbuf->b_visual_mode_eval = VIsual_mode;
K.Takata6e1d31e2022-02-03 13:05:32 +00003659#endif
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003660 }
3661
3662 // In Select mode, a linewise selection is operated upon like a
3663 // characterwise selection.
3664 // Special case: gH<Del> deletes the last line.
3665 if (VIsual_select && VIsual_mode == 'V'
3666 && cap->oap->op_type != OP_DELETE)
3667 {
3668 if (LT_POS(VIsual, curwin->w_cursor))
3669 {
3670 VIsual.col = 0;
3671 curwin->w_cursor.col =
3672 (colnr_T)STRLEN(ml_get(curwin->w_cursor.lnum));
3673 }
3674 else
3675 {
3676 curwin->w_cursor.col = 0;
3677 VIsual.col = (colnr_T)STRLEN(ml_get(VIsual.lnum));
3678 }
3679 VIsual_mode = 'v';
3680 }
3681 // If 'selection' is "exclusive", backup one character for
3682 // charwise selections.
3683 else if (VIsual_mode == 'v')
3684 include_line_break = unadjust_for_sel();
3685
3686 oap->start = VIsual;
3687 if (VIsual_mode == 'V')
3688 {
3689 oap->start.col = 0;
3690 oap->start.coladd = 0;
3691 }
3692 }
3693
3694 // Set oap->start to the first position of the operated text, oap->end
3695 // to the end of the operated text. w_cursor is equal to oap->start.
3696 if (LT_POS(oap->start, curwin->w_cursor))
3697 {
3698#ifdef FEAT_FOLDING
3699 // Include folded lines completely.
3700 if (!VIsual_active)
3701 {
3702 if (hasFolding(oap->start.lnum, &oap->start.lnum, NULL))
3703 oap->start.col = 0;
Bram Moolenaar3b681232019-12-13 19:35:55 +01003704 if ((curwin->w_cursor.col > 0 || oap->inclusive
3705 || oap->motion_type == MLINE)
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003706 && hasFolding(curwin->w_cursor.lnum, NULL,
3707 &curwin->w_cursor.lnum))
3708 curwin->w_cursor.col = (colnr_T)STRLEN(ml_get_curline());
3709 }
3710#endif
3711 oap->end = curwin->w_cursor;
3712 curwin->w_cursor = oap->start;
3713
3714 // w_virtcol may have been updated; if the cursor goes back to its
3715 // previous position w_virtcol becomes invalid and isn't updated
3716 // automatically.
3717 curwin->w_valid &= ~VALID_VIRTCOL;
3718 }
3719 else
3720 {
3721#ifdef FEAT_FOLDING
3722 // Include folded lines completely.
3723 if (!VIsual_active && oap->motion_type == MLINE)
3724 {
3725 if (hasFolding(curwin->w_cursor.lnum, &curwin->w_cursor.lnum,
3726 NULL))
3727 curwin->w_cursor.col = 0;
3728 if (hasFolding(oap->start.lnum, NULL, &oap->start.lnum))
3729 oap->start.col = (colnr_T)STRLEN(ml_get(oap->start.lnum));
3730 }
3731#endif
3732 oap->end = oap->start;
3733 oap->start = curwin->w_cursor;
3734 }
3735
3736 // Just in case lines were deleted that make the position invalid.
3737 check_pos(curwin->w_buffer, &oap->end);
3738 oap->line_count = oap->end.lnum - oap->start.lnum + 1;
3739
3740 // Set "virtual_op" before resetting VIsual_active.
3741 virtual_op = virtual_active();
3742
3743 if (VIsual_active || redo_VIsual_busy)
3744 {
Bram Moolenaarb3bd1d32022-01-02 13:05:45 +00003745 get_op_vcol(oap, redo_VIsual.rv_vcol, TRUE);
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003746
3747 if (!redo_VIsual_busy && !gui_yank)
3748 {
3749 // Prepare to reselect and redo Visual: this is based on the
3750 // size of the Visual text
3751 resel_VIsual_mode = VIsual_mode;
3752 if (curwin->w_curswant == MAXCOL)
3753 resel_VIsual_vcol = MAXCOL;
3754 else
3755 {
3756 if (VIsual_mode != Ctrl_V)
3757 getvvcol(curwin, &(oap->end),
3758 NULL, NULL, &oap->end_vcol);
3759 if (VIsual_mode == Ctrl_V || oap->line_count <= 1)
3760 {
3761 if (VIsual_mode != Ctrl_V)
3762 getvvcol(curwin, &(oap->start),
3763 &oap->start_vcol, NULL, NULL);
3764 resel_VIsual_vcol = oap->end_vcol - oap->start_vcol + 1;
3765 }
3766 else
3767 resel_VIsual_vcol = oap->end_vcol;
3768 }
3769 resel_VIsual_line_count = oap->line_count;
3770 }
3771
3772 // can't redo yank (unless 'y' is in 'cpoptions') and ":"
3773 if ((redo_yank || oap->op_type != OP_YANK)
3774 && oap->op_type != OP_COLON
3775#ifdef FEAT_FOLDING
3776 && oap->op_type != OP_FOLD
3777 && oap->op_type != OP_FOLDOPEN
3778 && oap->op_type != OP_FOLDOPENREC
3779 && oap->op_type != OP_FOLDCLOSE
3780 && oap->op_type != OP_FOLDCLOSEREC
3781 && oap->op_type != OP_FOLDDEL
3782 && oap->op_type != OP_FOLDDELREC
3783#endif
3784 && oap->motion_force == NUL
3785 )
3786 {
3787 // Prepare for redoing. Only use the nchar field for "r",
3788 // otherwise it might be the second char of the operator.
3789 if (cap->cmdchar == 'g' && (cap->nchar == 'n'
3790 || cap->nchar == 'N'))
3791 prep_redo(oap->regname, cap->count0,
Bram Moolenaar6e0ce172019-12-05 20:12:41 +01003792 get_op_char(oap->op_type),
3793 get_extra_op_char(oap->op_type),
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003794 oap->motion_force, cap->cmdchar, cap->nchar);
Bram Moolenaare32c3c42022-01-15 18:26:04 +00003795 else if (!is_ex_cmdchar(cap))
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003796 {
Bram Moolenaar2228cd72021-11-22 14:16:08 +00003797 int opchar = get_op_char(oap->op_type);
3798 int extra_opchar = get_extra_op_char(oap->op_type);
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003799 int nchar = oap->op_type == OP_REPLACE ? cap->nchar : NUL;
3800
3801 // reverse what nv_replace() did
3802 if (nchar == REPLACE_CR_NCHAR)
3803 nchar = CAR;
3804 else if (nchar == REPLACE_NL_NCHAR)
3805 nchar = NL;
Bram Moolenaar2228cd72021-11-22 14:16:08 +00003806
3807 if (opchar == 'g' && extra_opchar == '@')
3808 // also repeat the count for 'operatorfunc'
3809 prep_redo_num2(oap->regname, 0L, NUL, 'v',
3810 cap->count0, opchar, extra_opchar, nchar);
3811 else
3812 prep_redo(oap->regname, 0L, NUL, 'v',
3813 opchar, extra_opchar, nchar);
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003814 }
3815 if (!redo_VIsual_busy)
3816 {
Bram Moolenaarb3bd1d32022-01-02 13:05:45 +00003817 redo_VIsual.rv_mode = resel_VIsual_mode;
3818 redo_VIsual.rv_vcol = resel_VIsual_vcol;
3819 redo_VIsual.rv_line_count = resel_VIsual_line_count;
3820 redo_VIsual.rv_count = cap->count0;
3821 redo_VIsual.rv_arg = cap->arg;
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003822 }
3823 }
3824
3825 // oap->inclusive defaults to TRUE.
3826 // If oap->end is on a NUL (empty line) oap->inclusive becomes
3827 // FALSE. This makes "d}P" and "v}dP" work the same.
3828 if (oap->motion_force == NUL || oap->motion_type == MLINE)
3829 oap->inclusive = TRUE;
3830 if (VIsual_mode == 'V')
3831 oap->motion_type = MLINE;
3832 else
3833 {
3834 oap->motion_type = MCHAR;
3835 if (VIsual_mode != Ctrl_V && *ml_get_pos(&(oap->end)) == NUL
3836 && (include_line_break || !virtual_op))
3837 {
3838 oap->inclusive = FALSE;
3839 // Try to include the newline, unless it's an operator
3840 // that works on lines only.
3841 if (*p_sel != 'o'
3842 && !op_on_lines(oap->op_type)
3843 && oap->end.lnum < curbuf->b_ml.ml_line_count)
3844 {
3845 ++oap->end.lnum;
3846 oap->end.col = 0;
3847 oap->end.coladd = 0;
3848 ++oap->line_count;
3849 }
3850 }
3851 }
3852
3853 redo_VIsual_busy = FALSE;
3854
3855 // Switch Visual off now, so screen updating does
3856 // not show inverted text when the screen is redrawn.
3857 // With OP_YANK and sometimes with OP_COLON and OP_FILTER there is
3858 // no screen redraw, so it is done here to remove the inverted
3859 // part.
3860 if (!gui_yank)
3861 {
3862 VIsual_active = FALSE;
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003863 setmouse();
3864 mouse_dragging = 0;
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003865 may_clear_cmdline();
3866 if ((oap->op_type == OP_YANK
3867 || oap->op_type == OP_COLON
3868 || oap->op_type == OP_FUNCTION
3869 || oap->op_type == OP_FILTER)
3870 && oap->motion_force == NUL)
3871 {
3872#ifdef FEAT_LINEBREAK
3873 // make sure redrawing is correct
3874 curwin->w_p_lbr = lbr_saved;
3875#endif
3876 redraw_curbuf_later(INVERTED);
3877 }
3878 }
3879 }
3880
3881 // Include the trailing byte of a multi-byte char.
3882 if (has_mbyte && oap->inclusive)
3883 {
3884 int l;
3885
3886 l = (*mb_ptr2len)(ml_get_pos(&oap->end));
3887 if (l > 1)
3888 oap->end.col += l - 1;
3889 }
3890 curwin->w_set_curswant = TRUE;
3891
3892 // oap->empty is set when start and end are the same. The inclusive
3893 // flag affects this too, unless yanking and the end is on a NUL.
3894 oap->empty = (oap->motion_type == MCHAR
3895 && (!oap->inclusive
3896 || (oap->op_type == OP_YANK
3897 && gchar_pos(&oap->end) == NUL))
3898 && EQUAL_POS(oap->start, oap->end)
3899 && !(virtual_op && oap->start.coladd != oap->end.coladd));
3900 // For delete, change and yank, it's an error to operate on an
3901 // empty region, when 'E' included in 'cpoptions' (Vi compatible).
3902 empty_region_error = (oap->empty
3903 && vim_strchr(p_cpo, CPO_EMPTYREGION) != NULL);
3904
3905 // Force a redraw when operating on an empty Visual region, when
3906 // 'modifiable is off or creating a fold.
3907 if (oap->is_VIsual && (oap->empty || !curbuf->b_p_ma
3908#ifdef FEAT_FOLDING
3909 || oap->op_type == OP_FOLD
3910#endif
3911 ))
3912 {
3913#ifdef FEAT_LINEBREAK
3914 curwin->w_p_lbr = lbr_saved;
3915#endif
3916 redraw_curbuf_later(INVERTED);
3917 }
3918
3919 // If the end of an operator is in column one while oap->motion_type
3920 // is MCHAR and oap->inclusive is FALSE, we put op_end after the last
3921 // character in the previous line. If op_start is on or before the
3922 // first non-blank in the line, the operator becomes linewise
3923 // (strange, but that's the way vi does it).
3924 if ( oap->motion_type == MCHAR
3925 && oap->inclusive == FALSE
3926 && !(cap->retval & CA_NO_ADJ_OP_END)
3927 && oap->end.col == 0
3928 && (!oap->is_VIsual || *p_sel == 'o')
3929 && !oap->block_mode
3930 && oap->line_count > 1)
3931 {
3932 oap->end_adjusted = TRUE; // remember that we did this
3933 --oap->line_count;
3934 --oap->end.lnum;
3935 if (inindent(0))
3936 oap->motion_type = MLINE;
3937 else
3938 {
3939 oap->end.col = (colnr_T)STRLEN(ml_get(oap->end.lnum));
3940 if (oap->end.col)
3941 {
3942 --oap->end.col;
3943 oap->inclusive = TRUE;
3944 }
3945 }
3946 }
3947 else
3948 oap->end_adjusted = FALSE;
3949
3950 switch (oap->op_type)
3951 {
3952 case OP_LSHIFT:
3953 case OP_RSHIFT:
3954 op_shift(oap, TRUE, oap->is_VIsual ? (int)cap->count1 : 1);
3955 auto_format(FALSE, TRUE);
3956 break;
3957
3958 case OP_JOIN_NS:
3959 case OP_JOIN:
3960 if (oap->line_count < 2)
3961 oap->line_count = 2;
3962 if (curwin->w_cursor.lnum + oap->line_count - 1 >
3963 curbuf->b_ml.ml_line_count)
3964 beep_flush();
3965 else
3966 {
3967 (void)do_join(oap->line_count, oap->op_type == OP_JOIN,
3968 TRUE, TRUE, TRUE);
3969 auto_format(FALSE, TRUE);
3970 }
3971 break;
3972
3973 case OP_DELETE:
3974 VIsual_reselect = FALSE; // don't reselect now
3975 if (empty_region_error)
3976 {
3977 vim_beep(BO_OPER);
3978 CancelRedo();
3979 }
3980 else
3981 {
3982 (void)op_delete(oap);
Bram Moolenaar55466882020-11-21 14:16:22 +01003983 // save cursor line for undo if it wasn't saved yet
3984 if (oap->motion_type == MLINE && has_format_option(FO_AUTO)
3985 && u_save_cursor() == OK)
3986 auto_format(FALSE, TRUE);
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02003987 }
3988 break;
3989
3990 case OP_YANK:
3991 if (empty_region_error)
3992 {
3993 if (!gui_yank)
3994 {
3995 vim_beep(BO_OPER);
3996 CancelRedo();
3997 }
3998 }
3999 else
4000 {
4001#ifdef FEAT_LINEBREAK
4002 curwin->w_p_lbr = lbr_saved;
4003#endif
Christian Brabandt544a38e2021-06-10 19:39:11 +02004004 oap->excl_tr_ws = cap->cmdchar == 'z';
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02004005 (void)op_yank(oap, FALSE, !gui_yank);
4006 }
4007 check_cursor_col();
4008 break;
4009
4010 case OP_CHANGE:
4011 VIsual_reselect = FALSE; // don't reselect now
4012 if (empty_region_error)
4013 {
4014 vim_beep(BO_OPER);
4015 CancelRedo();
4016 }
4017 else
4018 {
4019 // This is a new edit command, not a restart. Need to
4020 // remember it to make 'insertmode' work with mappings for
4021 // Visual mode. But do this only once and not when typed and
4022 // 'insertmode' isn't set.
4023 if (p_im || !KeyTyped)
4024 restart_edit_save = restart_edit;
4025 else
4026 restart_edit_save = 0;
4027 restart_edit = 0;
4028#ifdef FEAT_LINEBREAK
4029 // Restore linebreak, so that when the user edits it looks as
4030 // before.
Bram Moolenaar03c3bd92020-01-23 20:58:09 +01004031 curwin->w_p_lbr = lbr_saved;
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02004032#endif
4033 // Reset finish_op now, don't want it set inside edit().
4034 finish_op = FALSE;
4035 if (op_change(oap)) // will call edit()
4036 cap->retval |= CA_COMMAND_BUSY;
4037 if (restart_edit == 0)
4038 restart_edit = restart_edit_save;
4039 }
4040 break;
4041
4042 case OP_FILTER:
4043 if (vim_strchr(p_cpo, CPO_FILTER) != NULL)
4044 AppendToRedobuff((char_u *)"!\r"); // use any last used !cmd
4045 else
4046 bangredo = TRUE; // do_bang() will put cmd in redo buffer
4047 // FALLTHROUGH
4048
4049 case OP_INDENT:
4050 case OP_COLON:
4051
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02004052 // If 'equalprg' is empty, do the indenting internally.
4053 if (oap->op_type == OP_INDENT && *get_equalprg() == NUL)
4054 {
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02004055 if (curbuf->b_p_lisp)
4056 {
4057 op_reindent(oap, get_lisp_indent);
4058 break;
4059 }
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02004060 op_reindent(oap,
Bram Moolenaar8e145b82022-05-21 20:17:31 +01004061#ifdef FEAT_EVAL
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02004062 *curbuf->b_p_inde != NUL ? get_expr_indent :
Bram Moolenaar8e145b82022-05-21 20:17:31 +01004063#endif
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02004064 get_c_indent);
4065 break;
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02004066 }
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02004067
4068 op_colon(oap);
4069 break;
4070
4071 case OP_TILDE:
4072 case OP_UPPER:
4073 case OP_LOWER:
4074 case OP_ROT13:
4075 if (empty_region_error)
4076 {
4077 vim_beep(BO_OPER);
4078 CancelRedo();
4079 }
4080 else
4081 op_tilde(oap);
4082 check_cursor_col();
4083 break;
4084
4085 case OP_FORMAT:
4086#if defined(FEAT_EVAL)
4087 if (*curbuf->b_p_fex != NUL)
4088 op_formatexpr(oap); // use expression
4089 else
4090#endif
Dominique Pelle4781d6f2021-05-18 21:46:31 +02004091 {
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02004092 if (*p_fp != NUL || *curbuf->b_p_fp != NUL)
Dominique Pelle4781d6f2021-05-18 21:46:31 +02004093 op_colon(oap); // use external command
4094 else
4095 op_format(oap, FALSE); // use internal function
4096 }
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02004097 break;
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02004098 case OP_FORMAT2:
4099 op_format(oap, TRUE); // use internal function
4100 break;
4101
4102 case OP_FUNCTION:
Bram Moolenaarb3bd1d32022-01-02 13:05:45 +00004103 {
4104 redo_VIsual_T save_redo_VIsual = redo_VIsual;
4105
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02004106#ifdef FEAT_LINEBREAK
Bram Moolenaarb3bd1d32022-01-02 13:05:45 +00004107 // Restore linebreak, so that when the user edits it looks as
4108 // before.
4109 curwin->w_p_lbr = lbr_saved;
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02004110#endif
Bram Moolenaarb3bd1d32022-01-02 13:05:45 +00004111 // call 'operatorfunc'
4112 op_function(oap);
4113
4114 // Restore the info for redoing Visual mode, the function may
4115 // invoke another operator and unintentionally change it.
4116 redo_VIsual = save_redo_VIsual;
4117 break;
4118 }
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02004119
4120 case OP_INSERT:
4121 case OP_APPEND:
4122 VIsual_reselect = FALSE; // don't reselect now
4123 if (empty_region_error)
4124 {
4125 vim_beep(BO_OPER);
4126 CancelRedo();
4127 }
4128 else
4129 {
4130 // This is a new edit command, not a restart. Need to
4131 // remember it to make 'insertmode' work with mappings for
4132 // Visual mode. But do this only once.
4133 restart_edit_save = restart_edit;
4134 restart_edit = 0;
4135#ifdef FEAT_LINEBREAK
4136 // Restore linebreak, so that when the user edits it looks as
4137 // before.
Bram Moolenaar03c3bd92020-01-23 20:58:09 +01004138 curwin->w_p_lbr = lbr_saved;
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02004139#endif
4140 op_insert(oap, cap->count1);
4141#ifdef FEAT_LINEBREAK
4142 // Reset linebreak, so that formatting works correctly.
4143 curwin->w_p_lbr = FALSE;
4144#endif
4145
4146 // TODO: when inserting in several lines, should format all
4147 // the lines.
4148 auto_format(FALSE, TRUE);
4149
4150 if (restart_edit == 0)
4151 restart_edit = restart_edit_save;
4152 else
4153 cap->retval |= CA_COMMAND_BUSY;
4154 }
4155 break;
4156
4157 case OP_REPLACE:
4158 VIsual_reselect = FALSE; // don't reselect now
4159 if (empty_region_error)
4160 {
4161 vim_beep(BO_OPER);
4162 CancelRedo();
4163 }
4164 else
4165 {
4166#ifdef FEAT_LINEBREAK
4167 // Restore linebreak, so that when the user edits it looks as
4168 // before.
Bram Moolenaar03c3bd92020-01-23 20:58:09 +01004169 curwin->w_p_lbr = lbr_saved;
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02004170#endif
4171 op_replace(oap, cap->nchar);
4172 }
4173 break;
4174
4175#ifdef FEAT_FOLDING
4176 case OP_FOLD:
4177 VIsual_reselect = FALSE; // don't reselect now
4178 foldCreate(oap->start.lnum, oap->end.lnum);
4179 break;
4180
4181 case OP_FOLDOPEN:
4182 case OP_FOLDOPENREC:
4183 case OP_FOLDCLOSE:
4184 case OP_FOLDCLOSEREC:
4185 VIsual_reselect = FALSE; // don't reselect now
4186 opFoldRange(oap->start.lnum, oap->end.lnum,
4187 oap->op_type == OP_FOLDOPEN
4188 || oap->op_type == OP_FOLDOPENREC,
4189 oap->op_type == OP_FOLDOPENREC
4190 || oap->op_type == OP_FOLDCLOSEREC,
4191 oap->is_VIsual);
4192 break;
4193
4194 case OP_FOLDDEL:
4195 case OP_FOLDDELREC:
4196 VIsual_reselect = FALSE; // don't reselect now
4197 deleteFold(oap->start.lnum, oap->end.lnum,
4198 oap->op_type == OP_FOLDDELREC, oap->is_VIsual);
4199 break;
4200#endif
4201 case OP_NR_ADD:
4202 case OP_NR_SUB:
4203 if (empty_region_error)
4204 {
4205 vim_beep(BO_OPER);
4206 CancelRedo();
4207 }
4208 else
4209 {
4210 VIsual_active = TRUE;
4211#ifdef FEAT_LINEBREAK
4212 curwin->w_p_lbr = lbr_saved;
4213#endif
Bram Moolenaarb3bd1d32022-01-02 13:05:45 +00004214 op_addsub(oap, cap->count1, redo_VIsual.rv_arg);
Bram Moolenaar792cf5e2019-09-30 23:12:16 +02004215 VIsual_active = FALSE;
4216 }
4217 check_cursor_col();
4218 break;
4219 default:
4220 clearopbeep(oap);
4221 }
4222 virtual_op = MAYBE;
4223 if (!gui_yank)
4224 {
4225 // if 'sol' not set, go back to old column for some commands
4226 if (!p_sol && oap->motion_type == MLINE && !oap->end_adjusted
4227 && (oap->op_type == OP_LSHIFT || oap->op_type == OP_RSHIFT
4228 || oap->op_type == OP_DELETE))
4229 {
4230#ifdef FEAT_LINEBREAK
4231 curwin->w_p_lbr = FALSE;
4232#endif
4233 coladvance(curwin->w_curswant = old_col);
4234 }
4235 }
4236 else
4237 {
4238 curwin->w_cursor = old_cursor;
4239 }
4240 oap->block_mode = FALSE;
4241 clearop(oap);
4242 motion_force = NUL;
4243 }
4244#ifdef FEAT_LINEBREAK
4245 curwin->w_p_lbr = lbr_saved;
4246#endif
4247}