Bram Moolenaar | edf3f97 | 2016-08-29 22:49:24 +0200 | [diff] [blame] | 1 | /* vi:set ts=8 sts=4 sw=4 noet: |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2 | * |
| 3 | * VIM - Vi IMproved by Bram Moolenaar |
| 4 | * |
| 5 | * Do ":help uganda" in Vim to read copying and usage conditions. |
| 6 | * Do ":help credits" in Vim to see a list of people who contributed. |
| 7 | * See README.txt for an overview of the Vim source code. |
| 8 | */ |
| 9 | |
| 10 | /* |
| 11 | * ops.c: implementation of various operators: op_shift, op_delete, op_tilde, |
Bram Moolenaar | 032a2d0 | 2020-12-22 17:59:35 +0100 | [diff] [blame] | 12 | * op_change, op_yank, do_join |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 13 | */ |
| 14 | |
| 15 | #include "vim.h" |
| 16 | |
Bram Moolenaar | baaa7e9 | 2016-01-29 22:47:03 +0100 | [diff] [blame] | 17 | static void shift_block(oparg_T *oap, int amount); |
Bram Moolenaar | baaa7e9 | 2016-01-29 22:47:03 +0100 | [diff] [blame] | 18 | static void mb_adjust_opend(oparg_T *oap); |
Bram Moolenaar | baaa7e9 | 2016-01-29 22:47:03 +0100 | [diff] [blame] | 19 | static int do_addsub(int op_type, pos_T *pos, int length, linenr_T Prenum1); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 20 | |
Bram Moolenaar | f273245 | 2018-06-03 14:47:35 +0200 | [diff] [blame] | 21 | // 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 25 | /* |
| 26 | * The names of operators. |
| 27 | * IMPORTANT: Index must correspond with defines in vim.h!!! |
Bram Moolenaar | f273245 | 2018-06-03 14:47:35 +0200 | [diff] [blame] | 28 | * The third field holds OPF_ flags. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 29 | */ |
| 30 | static char opchars[][3] = |
| 31 | { |
Bram Moolenaar | f273245 | 2018-06-03 14:47:35 +0200 | [diff] [blame] | 32 | {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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 62 | }; |
| 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 Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 69 | get_op_type(int char1, int char2) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 70 | { |
| 71 | int i; |
| 72 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 73 | if (char1 == 'r') // ignore second character |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 74 | return OP_REPLACE; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 75 | if (char1 == '~') // when tilde is an operator |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 76 | return OP_TILDE; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 77 | if (char1 == 'g' && char2 == Ctrl_A) // add |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 78 | return OP_NR_ADD; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 79 | if (char1 == 'g' && char2 == Ctrl_X) // subtract |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 80 | return OP_NR_SUB; |
Christian Brabandt | 544a38e | 2021-06-10 19:39:11 +0200 | [diff] [blame] | 81 | if (char1 == 'z' && char2 == 'y') // OP_YANK |
| 82 | return OP_YANK; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 83 | for (i = 0; ; ++i) |
Bram Moolenaar | 2efb323 | 2017-12-19 12:27:23 +0100 | [diff] [blame] | 84 | { |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 85 | if (opchars[i][0] == char1 && opchars[i][1] == char2) |
| 86 | break; |
K.Takata | eeec254 | 2021-06-02 13:28:16 +0200 | [diff] [blame] | 87 | if (i == (int)ARRAY_LENGTH(opchars) - 1) |
Bram Moolenaar | 2efb323 | 2017-12-19 12:27:23 +0100 | [diff] [blame] | 88 | { |
| 89 | internal_error("get_op_type()"); |
| 90 | break; |
| 91 | } |
| 92 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 93 | return i; |
| 94 | } |
| 95 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 96 | /* |
| 97 | * Return TRUE if operator "op" always works on whole lines. |
| 98 | */ |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 99 | static int |
Bram Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 100 | op_on_lines(int op) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 101 | { |
Bram Moolenaar | f273245 | 2018-06-03 14:47:35 +0200 | [diff] [blame] | 102 | return opchars[op][2] & OPF_LINES; |
| 103 | } |
| 104 | |
Bram Moolenaar | 113e107 | 2019-01-20 15:30:40 +0100 | [diff] [blame] | 105 | #if defined(FEAT_JOB_CHANNEL) || defined(PROTO) |
Bram Moolenaar | f273245 | 2018-06-03 14:47:35 +0200 | [diff] [blame] | 106 | /* |
| 107 | * Return TRUE if operator "op" changes text. |
| 108 | */ |
| 109 | int |
| 110 | op_is_change(int op) |
| 111 | { |
| 112 | return opchars[op][2] & OPF_CHANGE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 113 | } |
Bram Moolenaar | 113e107 | 2019-01-20 15:30:40 +0100 | [diff] [blame] | 114 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 115 | |
| 116 | /* |
| 117 | * Get first operator command character. |
| 118 | * Returns 'g' or 'z' if there is another command character. |
| 119 | */ |
| 120 | int |
Bram Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 121 | get_op_char(int optype) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 122 | { |
| 123 | return opchars[optype][0]; |
| 124 | } |
| 125 | |
| 126 | /* |
| 127 | * Get second operator command character. |
| 128 | */ |
| 129 | int |
Bram Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 130 | get_extra_op_char(int optype) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 131 | { |
| 132 | return opchars[optype][1]; |
| 133 | } |
| 134 | |
| 135 | /* |
| 136 | * op_shift - handle a shift operation |
| 137 | */ |
| 138 | void |
Bram Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 139 | op_shift(oparg_T *oap, int curs_top, int amount) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 140 | { |
| 141 | long i; |
| 142 | int first_char; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 143 | int block_col = 0; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 144 | |
| 145 | if (u_save((linenr_T)(oap->start.lnum - 1), |
| 146 | (linenr_T)(oap->end.lnum + 1)) == FAIL) |
| 147 | return; |
| 148 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 149 | if (oap->block_mode) |
| 150 | block_col = curwin->w_cursor.col; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 151 | |
| 152 | for (i = oap->line_count; --i >= 0; ) |
| 153 | { |
| 154 | first_char = *ml_get_curline(); |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 155 | if (first_char == NUL) // empty line |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 156 | curwin->w_cursor.col = 0; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 157 | else if (oap->block_mode) |
| 158 | shift_block(oap, amount); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 159 | else |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 160 | // 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 162 | if (first_char != '#' || !preprocs_left()) |
Bram Moolenaar | 8e145b8 | 2022-05-21 20:17:31 +0100 | [diff] [blame] | 163 | shift_line(oap->op_type == OP_LSHIFT, p_sr, amount, FALSE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 164 | ++curwin->w_cursor.lnum; |
| 165 | } |
| 166 | |
| 167 | changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 168 | if (oap->block_mode) |
| 169 | { |
| 170 | curwin->w_cursor.lnum = oap->start.lnum; |
| 171 | curwin->w_cursor.col = block_col; |
| 172 | } |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 173 | else if (curs_top) // put cursor on first line, for ">>" |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 174 | { |
| 175 | curwin->w_cursor.lnum = oap->start.lnum; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 176 | beginline(BL_SOL | BL_FIX); // shift_line() may have set cursor.col |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 177 | } |
| 178 | else |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 179 | --curwin->w_cursor.lnum; // put cursor on last line, for ":>" |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 180 | |
Bram Moolenaar | 54b2bfa | 2017-01-02 14:57:08 +0100 | [diff] [blame] | 181 | #ifdef FEAT_FOLDING |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 182 | // The cursor line is not in a closed fold |
Bram Moolenaar | 54b2bfa | 2017-01-02 14:57:08 +0100 | [diff] [blame] | 183 | foldOpenCursor(); |
| 184 | #endif |
| 185 | |
| 186 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 187 | if (oap->line_count > p_report) |
| 188 | { |
Bram Moolenaar | da6e891 | 2018-08-21 15:12:14 +0200 | [diff] [blame] | 189 | char *op; |
| 190 | char *msg_line_single; |
| 191 | char *msg_line_plural; |
| 192 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 193 | if (oap->op_type == OP_RSHIFT) |
Bram Moolenaar | da6e891 | 2018-08-21 15:12:14 +0200 | [diff] [blame] | 194 | op = ">"; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 195 | else |
Bram Moolenaar | da6e891 | 2018-08-21 15:12:14 +0200 | [diff] [blame] | 196 | 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 Moolenaar | e4fc746 | 2020-03-15 19:17:50 +0100 | [diff] [blame] | 204 | msg_attr_keep((char *)IObuff, 0, TRUE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 205 | } |
| 206 | |
Bram Moolenaar | e100440 | 2020-10-24 20:49:43 +0200 | [diff] [blame] | 207 | if ((cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) |
Bram Moolenaar | f4a1d1c | 2019-11-16 13:50:25 +0100 | [diff] [blame] | 208 | { |
| 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 216 | } |
| 217 | |
| 218 | /* |
Bram Moolenaar | 870ba5f | 2019-01-11 14:37:20 +0100 | [diff] [blame] | 219 | * Shift the current line one shiftwidth left (if left != 0) or right |
| 220 | * leaves cursor on first blank in the line. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 221 | */ |
| 222 | void |
Bram Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 223 | shift_line( |
| 224 | int left, |
| 225 | int round, |
| 226 | int amount, |
Bram Moolenaar | 8c96af9 | 2019-09-28 19:05:57 +0200 | [diff] [blame] | 227 | int call_changed_bytes) // call changed_bytes() |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 228 | { |
| 229 | int count; |
| 230 | int i, j; |
Bram Moolenaar | dac1347 | 2019-09-16 21:06:21 +0200 | [diff] [blame] | 231 | int sw_val = (int)get_sw_value_indent(curbuf); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 232 | |
Bram Moolenaar | 8c96af9 | 2019-09-28 19:05:57 +0200 | [diff] [blame] | 233 | count = get_indent(); // get current indent |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 234 | |
Bram Moolenaar | 8c96af9 | 2019-09-28 19:05:57 +0200 | [diff] [blame] | 235 | if (round) // round off indent |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 236 | { |
Bram Moolenaar | 8c96af9 | 2019-09-28 19:05:57 +0200 | [diff] [blame] | 237 | 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 240 | --amount; |
| 241 | if (left) |
| 242 | { |
| 243 | i -= amount; |
| 244 | if (i < 0) |
| 245 | i = 0; |
| 246 | } |
| 247 | else |
| 248 | i += amount; |
Bram Moolenaar | dac1347 | 2019-09-16 21:06:21 +0200 | [diff] [blame] | 249 | count = i * sw_val; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 250 | } |
Bram Moolenaar | 8c96af9 | 2019-09-28 19:05:57 +0200 | [diff] [blame] | 251 | else // original vi indent |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 252 | { |
| 253 | if (left) |
| 254 | { |
Bram Moolenaar | dac1347 | 2019-09-16 21:06:21 +0200 | [diff] [blame] | 255 | count -= sw_val * amount; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 256 | if (count < 0) |
| 257 | count = 0; |
| 258 | } |
| 259 | else |
Bram Moolenaar | dac1347 | 2019-09-16 21:06:21 +0200 | [diff] [blame] | 260 | count += sw_val * amount; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 261 | } |
| 262 | |
Bram Moolenaar | 8c96af9 | 2019-09-28 19:05:57 +0200 | [diff] [blame] | 263 | // Set new indent |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 264 | if (State & VREPLACE_FLAG) |
Bram Moolenaar | 21b17e7 | 2008-01-16 19:03:13 +0000 | [diff] [blame] | 265 | change_indent(INDENT_SET, count, FALSE, NUL, call_changed_bytes); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 266 | else |
Bram Moolenaar | 21b17e7 | 2008-01-16 19:03:13 +0000 | [diff] [blame] | 267 | (void)set_indent(count, call_changed_bytes ? SIN_CHANGED : 0); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 268 | } |
| 269 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 270 | /* |
| 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 Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 275 | shift_block(oparg_T *oap, int amount) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 276 | { |
| 277 | int left = (oap->op_type == OP_LSHIFT); |
| 278 | int oldstate = State; |
Bram Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 279 | int total; |
| 280 | char_u *newp, *oldp; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 281 | int oldcol = curwin->w_cursor.col; |
Bram Moolenaar | dac1347 | 2019-09-16 21:06:21 +0200 | [diff] [blame] | 282 | int sw_val = (int)get_sw_value_indent(curbuf); |
| 283 | int ts_val = (int)curbuf->b_p_ts; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 284 | struct block_def bd; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 285 | int incr; |
Bram Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 286 | colnr_T ws_vcol; |
LemonBoy | 4b93674 | 2022-05-13 21:56:28 +0100 | [diff] [blame] | 287 | int added; |
| 288 | unsigned new_line_len; // the length of the line after the |
| 289 | // block shift |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 290 | #ifdef FEAT_RIGHTLEFT |
| 291 | int old_p_ri = p_ri; |
| 292 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 293 | p_ri = 0; // don't want revins in indent |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 294 | #endif |
| 295 | |
Bram Moolenaar | 2495910 | 2022-05-07 20:01:16 +0100 | [diff] [blame] | 296 | State = MODE_INSERT; // don't want MODE_REPLACE for State |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 297 | block_prep(oap, &bd, curwin->w_cursor.lnum, TRUE); |
| 298 | if (bd.is_short) |
| 299 | return; |
| 300 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 301 | // total is number of screen columns to be inserted/removed |
Bram Moolenaar | dac1347 | 2019-09-16 21:06:21 +0200 | [diff] [blame] | 302 | total = (int)((unsigned)amount * (unsigned)sw_val); |
| 303 | if ((total / sw_val) != amount) |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 304 | return; // multiplication overflow |
Bram Moolenaar | bae5a17 | 2017-08-06 15:42:06 +0200 | [diff] [blame] | 305 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 306 | oldp = ml_get_curline(); |
| 307 | |
| 308 | if (!left) |
| 309 | { |
LemonBoy | 4b93674 | 2022-05-13 21:56:28 +0100 | [diff] [blame] | 310 | int tabs = 0, spaces = 0; |
| 311 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 312 | /* |
| 313 | * 1. Get start vcol |
| 314 | * 2. Total ws vcols |
| 315 | * 3. Divvy into TABs & spp |
| 316 | * 4. Construct new string |
| 317 | */ |
Bram Moolenaar | 4b96df5 | 2020-01-26 22:00:26 +0100 | [diff] [blame] | 318 | total += bd.pre_whitesp; // all virtual WS up to & incl a split TAB |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 319 | ws_vcol = bd.start_vcol - bd.pre_whitesp; |
| 320 | if (bd.startspaces) |
| 321 | { |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 322 | if (has_mbyte) |
Bram Moolenaar | 20b4f46 | 2016-03-05 17:25:39 +0100 | [diff] [blame] | 323 | { |
| 324 | if ((*mb_ptr2len)(bd.textstart) == 1) |
| 325 | ++bd.textstart; |
| 326 | else |
| 327 | { |
| 328 | ws_vcol = 0; |
| 329 | bd.startspaces = 0; |
| 330 | } |
| 331 | } |
Bram Moolenaar | be1138b | 2009-11-11 16:22:28 +0000 | [diff] [blame] | 332 | else |
Bram Moolenaar | be1138b | 2009-11-11 16:22:28 +0000 | [diff] [blame] | 333 | ++bd.textstart; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 334 | } |
Bram Moolenaar | 1c46544 | 2017-03-12 20:10:05 +0100 | [diff] [blame] | 335 | for ( ; VIM_ISWHITE(*bd.textstart); ) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 336 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 337 | // TODO: is passing bd.textstart for start of the line OK? |
=?UTF-8?q?Dundar=20G=C3=B6c?= | 420fabc | 2022-01-28 15:28:04 +0000 | [diff] [blame] | 338 | incr = lbr_chartabsize_adv(bd.textstart, &bd.textstart, bd.start_vcol); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 339 | total += incr; |
| 340 | bd.start_vcol += incr; |
| 341 | } |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 342 | // OK, now total=all the VWS reqd, and textstart points at the 1st |
| 343 | // non-ws char in the block. |
Bram Moolenaar | 04958cb | 2018-06-23 19:23:02 +0200 | [diff] [blame] | 344 | #ifdef FEAT_VARTABS |
| 345 | if (!curbuf->b_p_et) |
Bram Moolenaar | dac1347 | 2019-09-16 21:06:21 +0200 | [diff] [blame] | 346 | tabstop_fromto(ws_vcol, ws_vcol + total, |
LemonBoy | 4b93674 | 2022-05-13 21:56:28 +0100 | [diff] [blame] | 347 | ts_val, curbuf->b_p_vts_array, &tabs, &spaces); |
Bram Moolenaar | 04958cb | 2018-06-23 19:23:02 +0200 | [diff] [blame] | 348 | else |
LemonBoy | 4b93674 | 2022-05-13 21:56:28 +0100 | [diff] [blame] | 349 | spaces = total; |
Bram Moolenaar | 04958cb | 2018-06-23 19:23:02 +0200 | [diff] [blame] | 350 | #else |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 351 | if (!curbuf->b_p_et) |
LemonBoy | 4b93674 | 2022-05-13 21:56:28 +0100 | [diff] [blame] | 352 | 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 355 | else |
LemonBoy | 4b93674 | 2022-05-13 21:56:28 +0100 | [diff] [blame] | 356 | spaces = total; |
Bram Moolenaar | 04958cb | 2018-06-23 19:23:02 +0200 | [diff] [blame] | 357 | #endif |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 358 | // if we're splitting a TAB, allow for it |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 359 | bd.textcol -= bd.pre_whitesp_c - (bd.startspaces != 0); |
LemonBoy | 4b93674 | 2022-05-13 21:56:28 +0100 | [diff] [blame] | 360 | |
| 361 | new_line_len = bd.textcol + tabs + spaces + (int)STRLEN(bd.textstart); |
| 362 | newp = alloc(new_line_len + 1); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 363 | if (newp == NULL) |
| 364 | return; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 365 | mch_memmove(newp, oldp, (size_t)bd.textcol); |
LemonBoy | 4b93674 | 2022-05-13 21:56:28 +0100 | [diff] [blame] | 366 | 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 370 | } |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 371 | else // left |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 372 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 373 | 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 Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 380 | size_t block_space_width; |
| 381 | size_t shift_amount; |
| 382 | char_u *non_white = bd.textstart; |
| 383 | colnr_T non_white_col; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 384 | |
Bram Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 385 | /* |
| 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 392 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 393 | // 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 Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 396 | if (bd.startspaces) |
Bram Moolenaar | 91acfff | 2017-03-12 19:22:36 +0100 | [diff] [blame] | 397 | MB_PTR_ADV(non_white); |
Bram Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 398 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 399 | // The character's column is in "bd.start_vcol". |
Bram Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 400 | non_white_col = bd.start_vcol; |
| 401 | |
Bram Moolenaar | 1c46544 | 2017-03-12 20:10:05 +0100 | [diff] [blame] | 402 | while (VIM_ISWHITE(*non_white)) |
Bram Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 403 | { |
Bram Moolenaar | 597a422 | 2014-06-25 14:39:50 +0200 | [diff] [blame] | 404 | incr = lbr_chartabsize_adv(bd.textstart, &non_white, non_white_col); |
Bram Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 405 | non_white_col += incr; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 406 | } |
| 407 | |
Bram Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 408 | block_space_width = non_white_col - oap->start_vcol; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 409 | // We will shift by "total" or "block_space_width", whichever is less. |
Bram Moolenaar | 92a990b | 2009-04-22 15:45:05 +0000 | [diff] [blame] | 410 | shift_amount = (block_space_width < (size_t)total |
| 411 | ? block_space_width : (size_t)total); |
Bram Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 412 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 413 | // The column to which we will shift the text. |
Bram Moolenaar | 92a990b | 2009-04-22 15:45:05 +0000 | [diff] [blame] | 414 | destination_col = (colnr_T)(non_white_col - shift_amount); |
Bram Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 415 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 416 | // Now let's find out how much of the beginning of the line we can |
| 417 | // reuse without modification. |
Bram Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 418 | verbatim_copy_end = bd.textstart; |
| 419 | verbatim_copy_width = bd.start_vcol; |
| 420 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 421 | // 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 Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 424 | if (bd.startspaces) |
| 425 | verbatim_copy_width -= bd.start_char_vcols; |
| 426 | while (verbatim_copy_width < destination_col) |
| 427 | { |
Bram Moolenaar | 597a422 | 2014-06-25 14:39:50 +0200 | [diff] [blame] | 428 | char_u *line = verbatim_copy_end; |
| 429 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 430 | // TODO: is passing verbatim_copy_end for start of the line OK? |
Bram Moolenaar | 597a422 | 2014-06-25 14:39:50 +0200 | [diff] [blame] | 431 | incr = lbr_chartabsize(line, verbatim_copy_end, |
| 432 | verbatim_copy_width); |
Bram Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 433 | if (verbatim_copy_width + incr > destination_col) |
| 434 | break; |
| 435 | verbatim_copy_width += incr; |
Bram Moolenaar | 91acfff | 2017-03-12 19:22:36 +0100 | [diff] [blame] | 436 | MB_PTR_ADV(verbatim_copy_end); |
Bram Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 437 | } |
| 438 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 439 | // 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 Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 442 | fill = destination_col - verbatim_copy_width; |
| 443 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 444 | // 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 Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 448 | new_line_len = (unsigned)(verbatim_copy_end - oldp) |
| 449 | + fill |
LemonBoy | 4b93674 | 2022-05-13 21:56:28 +0100 | [diff] [blame] | 450 | + (unsigned)STRLEN(non_white); |
Bram Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 451 | |
LemonBoy | 4b93674 | 2022-05-13 21:56:28 +0100 | [diff] [blame] | 452 | newp = alloc(new_line_len + 1); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 453 | if (newp == NULL) |
| 454 | return; |
Bram Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 455 | mch_memmove(newp, oldp, (size_t)(verbatim_copy_end - oldp)); |
Bram Moolenaar | 2536d4f | 2015-07-17 13:22:51 +0200 | [diff] [blame] | 456 | vim_memset(newp + (verbatim_copy_end - oldp), ' ', (size_t)fill); |
LemonBoy | 4b93674 | 2022-05-13 21:56:28 +0100 | [diff] [blame] | 457 | // Note that STRMOVE() copies the trailing NUL. |
Bram Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 458 | STRMOVE(newp + (verbatim_copy_end - oldp) + fill, non_white); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 459 | } |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 460 | // replace the line |
LemonBoy | 4b93674 | 2022-05-13 21:56:28 +0100 | [diff] [blame] | 461 | added = new_line_len - (int)STRLEN(oldp); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 462 | ml_replace(curwin->w_cursor.lnum, newp, FALSE); |
LemonBoy | 4b93674 | 2022-05-13 21:56:28 +0100 | [diff] [blame] | 463 | inserted_bytes(curwin->w_cursor.lnum, bd.textcol, added); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 464 | State = oldstate; |
| 465 | curwin->w_cursor.col = oldcol; |
| 466 | #ifdef FEAT_RIGHTLEFT |
| 467 | p_ri = old_p_ri; |
| 468 | #endif |
| 469 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 470 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 471 | /* |
| 472 | * Insert string "s" (b_insert ? before : after) block :AKelly |
| 473 | * Caller must prepare for undo. |
| 474 | */ |
| 475 | static void |
Bram Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 476 | block_insert( |
| 477 | oparg_T *oap, |
| 478 | char_u *s, |
| 479 | int b_insert, |
| 480 | struct block_def *bdp) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 481 | { |
Bram Moolenaar | dac1347 | 2019-09-16 21:06:21 +0200 | [diff] [blame] | 482 | int ts_val; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 483 | 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 Moolenaar | 8b51b7f | 2020-09-15 21:34:18 +0200 | [diff] [blame] | 486 | colnr_T startcol; // column where insert starts |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 487 | unsigned s_len; // STRLEN(s) |
| 488 | char_u *newp, *oldp; // new, old lines |
| 489 | linenr_T lnum; // loop var |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 490 | int oldstate = State; |
| 491 | |
Bram Moolenaar | 2495910 | 2022-05-07 20:01:16 +0100 | [diff] [blame] | 492 | State = MODE_INSERT; // don't want MODE_REPLACE for State |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 493 | 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 499 | continue; // OP_INSERT, line ends before block start |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 500 | |
| 501 | oldp = ml_get(lnum); |
| 502 | |
| 503 | if (b_insert) |
| 504 | { |
Bram Moolenaar | dac1347 | 2019-09-16 21:06:21 +0200 | [diff] [blame] | 505 | ts_val = bdp->start_char_vcols; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 506 | spaces = bdp->startspaces; |
| 507 | if (spaces != 0) |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 508 | count = ts_val - 1; // we're cutting a TAB |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 509 | offset = bdp->textcol; |
| 510 | } |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 511 | else // append |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 512 | { |
Bram Moolenaar | dac1347 | 2019-09-16 21:06:21 +0200 | [diff] [blame] | 513 | ts_val = bdp->end_char_vcols; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 514 | if (!bdp->is_short) // spaces = padding after block |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 515 | { |
Bram Moolenaar | dac1347 | 2019-09-16 21:06:21 +0200 | [diff] [blame] | 516 | spaces = (bdp->endspaces ? ts_val - bdp->endspaces : 0); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 517 | if (spaces != 0) |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 518 | count = ts_val - 1; // we're cutting a TAB |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 519 | offset = bdp->textcol + bdp->textlen - (spaces != 0); |
| 520 | } |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 521 | else // spaces = padding to block edge |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 522 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 523 | // if $ used, just append to EOL (ie spaces==0) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 524 | 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 Moolenaar | b5cf6c3 | 2014-08-16 18:36:43 +0200 | [diff] [blame] | 531 | if (has_mbyte && spaces > 0) |
Bram Moolenaar | 57df9e8 | 2022-01-20 12:10:48 +0000 | [diff] [blame] | 532 | // avoid copying part of a multi-byte character |
| 533 | offset -= (*mb_head_off)(oldp, oldp + offset); |
Bram Moolenaar | fc3f23b | 2014-12-17 18:35:42 +0100 | [diff] [blame] | 534 | |
Bram Moolenaar | 4067bd3 | 2021-06-29 18:54:35 +0200 | [diff] [blame] | 535 | if (spaces < 0) // can happen when the cursor was moved |
| 536 | spaces = 0; |
Bram Moolenaar | b5cf6c3 | 2014-08-16 18:36:43 +0200 | [diff] [blame] | 537 | |
Bram Moolenaar | 9f8c304 | 2022-01-17 17:30:21 +0000 | [diff] [blame] | 538 | // 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 542 | if (newp == NULL) |
| 543 | continue; |
| 544 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 545 | // copy up to shifted part |
Bram Moolenaar | 9f8c304 | 2022-01-17 17:30:21 +0000 | [diff] [blame] | 546 | mch_memmove(newp, oldp, (size_t)offset); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 547 | oldp += offset; |
| 548 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 549 | // insert pre-padding |
Bram Moolenaar | 2536d4f | 2015-07-17 13:22:51 +0200 | [diff] [blame] | 550 | vim_memset(newp + offset, ' ', (size_t)spaces); |
Bram Moolenaar | 8b51b7f | 2020-09-15 21:34:18 +0200 | [diff] [blame] | 551 | startcol = offset + spaces; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 552 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 553 | // copy the new text |
Bram Moolenaar | 8b51b7f | 2020-09-15 21:34:18 +0200 | [diff] [blame] | 554 | mch_memmove(newp + startcol, s, (size_t)s_len); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 555 | offset += s_len; |
| 556 | |
Bram Moolenaar | 9f8c304 | 2022-01-17 17:30:21 +0000 | [diff] [blame] | 557 | if (spaces > 0 && !bdp->is_short) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 558 | { |
Bram Moolenaar | 9f8c304 | 2022-01-17 17:30:21 +0000 | [diff] [blame] | 559 | 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 572 | } |
| 573 | |
| 574 | if (spaces > 0) |
| 575 | offset += count; |
Bram Moolenaar | c1a11ed | 2008-06-24 22:09:24 +0000 | [diff] [blame] | 576 | STRMOVE(newp + offset, oldp); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 577 | |
| 578 | ml_replace(lnum, newp, FALSE); |
| 579 | |
Bram Moolenaar | 8b51b7f | 2020-09-15 21:34:18 +0200 | [diff] [blame] | 580 | if (b_insert) |
| 581 | // correct any text properties |
| 582 | inserted_bytes(lnum, startcol, s_len); |
| 583 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 584 | if (lnum == oap->end.lnum) |
| 585 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 586 | // Set "']" mark to the end of the block instead of the end of |
| 587 | // the insert in the first line. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 588 | curbuf->b_op_end.lnum = oap->end.lnum; |
| 589 | curbuf->b_op_end.col = offset; |
| 590 | } |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 591 | } // for all lnum |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 592 | |
| 593 | changed_lines(oap->start.lnum + 1, 0, oap->end.lnum + 1, 0L); |
| 594 | |
| 595 | State = oldstate; |
| 596 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 597 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 598 | /* |
Bram Moolenaar | d04b750 | 2010-07-08 22:27:55 +0200 | [diff] [blame] | 599 | * Handle a delete operation. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 600 | * |
Bram Moolenaar | d04b750 | 2010-07-08 22:27:55 +0200 | [diff] [blame] | 601 | * Return FAIL if undo failed, OK otherwise. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 602 | */ |
| 603 | int |
Bram Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 604 | op_delete(oparg_T *oap) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 605 | { |
| 606 | int n; |
| 607 | linenr_T lnum; |
| 608 | char_u *ptr; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 609 | char_u *newp, *oldp; |
| 610 | struct block_def bd; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 611 | linenr_T old_lcount = curbuf->b_ml.ml_line_count; |
| 612 | int did_yank = FALSE; |
| 613 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 614 | if (curbuf->b_ml.ml_flags & ML_EMPTY) // nothing to do |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 615 | return OK; |
| 616 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 617 | // Nothing to delete, return here. Do prepare undo, for op_change(). |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 618 | if (oap->empty) |
| 619 | return u_save_cursor(); |
| 620 | |
| 621 | if (!curbuf->b_p_ma) |
| 622 | { |
Bram Moolenaar | 108010a | 2021-06-27 22:03:33 +0200 | [diff] [blame] | 623 | emsg(_(e_cannot_make_changes_modifiable_is_off)); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 624 | return FAIL; |
| 625 | } |
| 626 | |
Shougo Matsushita | 4ede01f | 2022-01-20 15:26:03 +0000 | [diff] [blame] | 627 | if (VIsual_select && oap->is_VIsual) |
| 628 | // use register given with CTRL_R, defaults to zero |
Bram Moolenaar | 6ed545e | 2022-05-09 20:09:23 +0100 | [diff] [blame] | 629 | oap->regname = VIsual_select_reg; |
Shougo Matsushita | 4ede01f | 2022-01-20 15:26:03 +0000 | [diff] [blame] | 630 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 631 | #ifdef FEAT_CLIPBOARD |
| 632 | adjust_clip_reg(&oap->regname); |
| 633 | #endif |
| 634 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 635 | if (has_mbyte) |
| 636 | mb_adjust_opend(oap); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 637 | |
Bram Moolenaar | d04b750 | 2010-07-08 22:27:55 +0200 | [diff] [blame] | 638 | /* |
| 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 643 | if ( oap->motion_type == MCHAR |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 644 | && !oap->is_VIsual |
Bram Moolenaar | ec2dad6 | 2005-01-02 11:36:03 +0000 | [diff] [blame] | 645 | && !oap->block_mode |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 646 | && oap->line_count > 1 |
Bram Moolenaar | 64a7230 | 2012-01-10 13:46:22 +0100 | [diff] [blame] | 647 | && oap->motion_force == NUL |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 648 | && oap->op_type == OP_DELETE) |
| 649 | { |
Bram Moolenaar | 44286ca | 2011-07-15 17:51:34 +0200 | [diff] [blame] | 650 | ptr = ml_get(oap->end.lnum) + oap->end.col; |
| 651 | if (*ptr != NUL) |
| 652 | ptr += oap->inclusive; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 653 | ptr = skipwhite(ptr); |
| 654 | if (*ptr == NUL && inindent(0)) |
| 655 | oap->motion_type = MLINE; |
| 656 | } |
| 657 | |
Bram Moolenaar | d04b750 | 2010-07-08 22:27:55 +0200 | [diff] [blame] | 658 | /* |
| 659 | * Check for trying to delete (e.g. "D") in an empty line. |
| 660 | * Note: For the change operator it is ok. |
| 661 | */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 662 | 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 Moolenaar | 87e25fd | 2005-07-27 21:13:01 +0000 | [diff] [blame] | 668 | * It's an error to operate on an empty region, when 'E' included in |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 669 | * 'cpoptions' (Vi compatible). |
| 670 | */ |
Bram Moolenaar | 87e25fd | 2005-07-27 21:13:01 +0000 | [diff] [blame] | 671 | if (virtual_op) |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 672 | // Virtual editing: Nothing gets deleted, but we set the '[ and '] |
| 673 | // marks as if it happened. |
Bram Moolenaar | 87e25fd | 2005-07-27 21:13:01 +0000 | [diff] [blame] | 674 | goto setmarks; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 675 | if (vim_strchr(p_cpo, CPO_EMPTYREGION) != NULL) |
| 676 | beep_flush(); |
| 677 | return OK; |
| 678 | } |
| 679 | |
Bram Moolenaar | d04b750 | 2010-07-08 22:27:55 +0200 | [diff] [blame] | 680 | /* |
| 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 685 | if (oap->regname != '_') |
| 686 | { |
| 687 | if (oap->regname != 0) |
| 688 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 689 | // check for read-only register |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 690 | if (!valid_yank_reg(oap->regname, TRUE)) |
| 691 | { |
| 692 | beep_flush(); |
| 693 | return OK; |
| 694 | } |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 695 | get_yank_register(oap->regname, TRUE); // yank into specif'd reg. |
| 696 | if (op_yank(oap, TRUE, FALSE) == OK) // yank without message |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 697 | did_yank = TRUE; |
| 698 | } |
Christian Brabandt | 78eb9cc | 2021-09-14 18:55:51 +0200 | [diff] [blame] | 699 | else |
| 700 | reset_y_append(); // not appending to unnamed register |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 701 | |
| 702 | /* |
| 703 | * Put deleted text into register 1 and shift number registers if the |
Bram Moolenaar | 9d7fdd4 | 2019-03-08 09:50:52 +0100 | [diff] [blame] | 704 | * delete contains a line break, or when using a specific operator (Vi |
| 705 | * compatible) |
Bram Moolenaar | 7c82130 | 2012-09-05 14:18:45 +0200 | [diff] [blame] | 706 | * Use the register name from before adjust_clip_reg() may have |
| 707 | * changed it. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 708 | */ |
Bram Moolenaar | 9d7fdd4 | 2019-03-08 09:50:52 +0100 | [diff] [blame] | 709 | if (oap->motion_type == MLINE || oap->line_count > 1 |
| 710 | || oap->use_reg_one) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 711 | { |
Bram Moolenaar | a189184 | 2017-02-04 21:34:31 +0100 | [diff] [blame] | 712 | shift_delete_registers(); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 713 | if (op_yank(oap, TRUE, FALSE) == OK) |
| 714 | did_yank = TRUE; |
| 715 | } |
| 716 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 717 | // Yank into small delete register when no named register specified |
| 718 | // and the delete is within one line. |
Bram Moolenaar | 84298db | 2012-04-20 13:46:08 +0200 | [diff] [blame] | 719 | if (( |
| 720 | #ifdef FEAT_CLIPBOARD |
Bram Moolenaar | bfe3bf8 | 2012-06-13 17:28:55 +0200 | [diff] [blame] | 721 | ((clip_unnamed & CLIP_UNNAMED) && oap->regname == '*') || |
| 722 | ((clip_unnamed & CLIP_UNNAMED_PLUS) && oap->regname == '+') || |
Bram Moolenaar | 84298db | 2012-04-20 13:46:08 +0200 | [diff] [blame] | 723 | #endif |
| 724 | oap->regname == 0) && oap->motion_type != MLINE |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 725 | && 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 744 | msg_silent = 0; // must display the prompt |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 745 | n = ask_yesno((char_u *)_("cannot yank; delete anyway"), TRUE); |
| 746 | msg_silent = msg_silent_save; |
| 747 | if (n != 'y') |
| 748 | { |
Bram Moolenaar | 436b5ad | 2021-12-31 22:49:24 +0000 | [diff] [blame] | 749 | emsg(_(e_command_aborted)); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 750 | return FAIL; |
| 751 | } |
| 752 | } |
Bram Moolenaar | 7e1652c | 2017-12-16 18:27:02 +0100 | [diff] [blame] | 753 | |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 754 | #if defined(FEAT_EVAL) |
Bram Moolenaar | 7e1652c | 2017-12-16 18:27:02 +0100 | [diff] [blame] | 755 | if (did_yank && has_textyankpost()) |
Bram Moolenaar | 4aea03e | 2019-09-25 22:37:17 +0200 | [diff] [blame] | 756 | yank_do_autocmd(oap, get_y_current()); |
Bram Moolenaar | 7e1652c | 2017-12-16 18:27:02 +0100 | [diff] [blame] | 757 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 758 | } |
| 759 | |
Bram Moolenaar | d04b750 | 2010-07-08 22:27:55 +0200 | [diff] [blame] | 760 | /* |
| 761 | * block mode delete |
| 762 | */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 763 | 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 772 | if (bd.textlen == 0) // nothing to delete |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 773 | continue; |
| 774 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 775 | // Adjust cursor position for tab replaced by spaces and 'lbr'. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 776 | if (lnum == curwin->w_cursor.lnum) |
| 777 | { |
| 778 | curwin->w_cursor.col = bd.textcol + bd.startspaces; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 779 | curwin->w_cursor.coladd = 0; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 780 | } |
| 781 | |
Bram Moolenaar | 8055d17 | 2019-05-17 22:57:26 +0200 | [diff] [blame] | 782 | // "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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 785 | n = bd.textlen - bd.startspaces - bd.endspaces; |
| 786 | oldp = ml_get(lnum); |
Bram Moolenaar | 964b374 | 2019-05-24 18:54:09 +0200 | [diff] [blame] | 787 | newp = alloc(STRLEN(oldp) + 1 - n); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 788 | if (newp == NULL) |
| 789 | continue; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 790 | // copy up to deleted part |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 791 | mch_memmove(newp, oldp, (size_t)bd.textcol); |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 792 | // insert spaces |
Bram Moolenaar | 2536d4f | 2015-07-17 13:22:51 +0200 | [diff] [blame] | 793 | vim_memset(newp + bd.textcol, ' ', |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 794 | (size_t)(bd.startspaces + bd.endspaces)); |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 795 | // copy the part after the deleted part |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 796 | oldp += bd.textcol + bd.textlen; |
Bram Moolenaar | c1a11ed | 2008-06-24 22:09:24 +0000 | [diff] [blame] | 797 | STRMOVE(newp + bd.textcol + bd.startspaces + bd.endspaces, oldp); |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 798 | // replace the line |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 799 | ml_replace(lnum, newp, FALSE); |
Bram Moolenaar | 8055d17 | 2019-05-17 22:57:26 +0200 | [diff] [blame] | 800 | |
Bram Moolenaar | 05ad5ff | 2019-11-30 22:48:27 +0100 | [diff] [blame] | 801 | #ifdef FEAT_PROP_POPUP |
Bram Moolenaar | 8055d17 | 2019-05-17 22:57:26 +0200 | [diff] [blame] | 802 | if (curbuf->b_has_textprop && n != 0) |
Bram Moolenaar | f3333b0 | 2019-05-19 22:53:40 +0200 | [diff] [blame] | 803 | adjust_prop_columns(lnum, bd.textcol, -n, 0); |
Bram Moolenaar | 8055d17 | 2019-05-17 22:57:26 +0200 | [diff] [blame] | 804 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 805 | } |
| 806 | |
| 807 | check_cursor_col(); |
| 808 | changed_lines(curwin->w_cursor.lnum, curwin->w_cursor.col, |
| 809 | oap->end.lnum + 1, 0L); |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 810 | oap->line_count = 0; // no lines deleted |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 811 | } |
Bram Moolenaar | f7ff6e8 | 2014-03-23 15:13:05 +0100 | [diff] [blame] | 812 | else if (oap->motion_type == MLINE) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 813 | { |
| 814 | if (oap->op_type == OP_CHANGE) |
| 815 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 816 | // 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 819 | 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 828 | if (curbuf->b_p_ai) // don't delete indent |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 829 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 830 | beginline(BL_WHITE); // cursor on first non-white |
| 831 | did_ai = TRUE; // delete the indent when ESC hit |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 832 | ai_col = curwin->w_cursor.col; |
| 833 | } |
| 834 | else |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 835 | 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 838 | if (oap->line_count > 1) |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 839 | u_clearline(); // "U" command not possible after "2cc" |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 840 | } |
| 841 | else |
| 842 | { |
| 843 | del_lines(oap->line_count, TRUE); |
| 844 | beginline(BL_WHITE | BL_FIX); |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 845 | u_clearline(); // "U" command not possible after "dd" |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 846 | } |
| 847 | } |
| 848 | else |
| 849 | { |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 850 | if (virtual_op) |
| 851 | { |
| 852 | int endcol = 0; |
| 853 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 854 | // For virtualedit: break the tabs that are partly included. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 855 | if (gchar_pos(&oap->start) == '\t') |
| 856 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 857 | if (u_save_cursor() == FAIL) // save first line for undo |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 858 | 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 872 | // Break a tab only when it's included in the area. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 873 | if (gchar_pos(&oap->end) == '\t' |
| 874 | && (int)oap->end.coladd < oap->inclusive) |
| 875 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 876 | // save last line for undo |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 877 | 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 Moolenaar | 77ccc00 | 2019-10-31 03:21:25 +0100 | [diff] [blame] | 885 | if (has_mbyte) |
| 886 | mb_adjust_opend(oap); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 887 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 888 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 889 | if (oap->line_count == 1) // delete characters within one line |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 890 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 891 | if (u_save_cursor() == FAIL) // save line for undo |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 892 | return FAIL; |
| 893 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 894 | // if 'cpoptions' contains '$', display '$' at end of change |
Bram Moolenaar | f7ff6e8 | 2014-03-23 15:13:05 +0100 | [diff] [blame] | 895 | if ( vim_strchr(p_cpo, CPO_DOLLAR) != NULL |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 896 | && oap->op_type == OP_CHANGE |
| 897 | && oap->end.lnum == curwin->w_cursor.lnum |
Bram Moolenaar | f7ff6e8 | 2014-03-23 15:13:05 +0100 | [diff] [blame] | 898 | && !oap->is_VIsual) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 899 | display_dollar(oap->end.col - !oap->inclusive); |
| 900 | |
| 901 | n = oap->end.col - oap->start.col + 1 - !oap->inclusive; |
| 902 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 903 | if (virtual_op) |
| 904 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 905 | // fix up things for virtualedit-delete: |
| 906 | // break the tabs which are going to get in our way |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 907 | 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 914 | // Delete at least one char (e.g, when on a control char). |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 915 | if (n == 0 && oap->start.coladd != oap->end.coladd) |
| 916 | n = 1; |
| 917 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 918 | // When deleted a char in the line, reset coladd. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 919 | if (gchar_cursor() != NUL) |
| 920 | curwin->w_cursor.coladd = 0; |
| 921 | } |
Bram Moolenaar | d009e86 | 2015-06-09 20:20:03 +0200 | [diff] [blame] | 922 | (void)del_bytes((long)n, !virtual_op, |
| 923 | oap->op_type == OP_DELETE && !oap->is_VIsual); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 924 | } |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 925 | else // delete characters between lines |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 926 | { |
| 927 | pos_T curpos; |
| 928 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 929 | // save deleted and changed lines for undo |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 930 | 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 934 | truncate_line(TRUE); // delete from cursor to end of line |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 935 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 936 | curpos = curwin->w_cursor; // remember curwin->w_cursor |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 937 | ++curwin->w_cursor.lnum; |
| 938 | del_lines((long)(oap->line_count - 2), FALSE); |
| 939 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 940 | // delete from start of line until op_end |
Bram Moolenaar | 44286ca | 2011-07-15 17:51:34 +0200 | [diff] [blame] | 941 | n = (oap->end.col + 1 - !oap->inclusive); |
Bram Moolenaar | d009e86 | 2015-06-09 20:20:03 +0200 | [diff] [blame] | 942 | curwin->w_cursor.col = 0; |
| 943 | (void)del_bytes((long)n, !virtual_op, |
| 944 | oap->op_type == OP_DELETE && !oap->is_VIsual); |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 945 | curwin->w_cursor = curpos; // restore curwin->w_cursor |
Bram Moolenaar | d009e86 | 2015-06-09 20:20:03 +0200 | [diff] [blame] | 946 | (void)do_join(2, FALSE, FALSE, FALSE, FALSE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 947 | } |
Bram Moolenaar | 6b36d2a | 2021-08-23 21:19:01 +0200 | [diff] [blame] | 948 | if (oap->op_type == OP_DELETE) |
| 949 | auto_format(FALSE, TRUE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 950 | } |
| 951 | |
| 952 | msgmore(curbuf->b_ml.ml_line_count - old_lcount); |
| 953 | |
Bram Moolenaar | 87e25fd | 2005-07-27 21:13:01 +0000 | [diff] [blame] | 954 | setmarks: |
Bram Moolenaar | e100440 | 2020-10-24 20:49:43 +0200 | [diff] [blame] | 955 | if ((cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 956 | { |
Bram Moolenaar | f4a1d1c | 2019-11-16 13:50:25 +0100 | [diff] [blame] | 957 | 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 965 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 966 | |
| 967 | return OK; |
| 968 | } |
| 969 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 970 | /* |
| 971 | * Adjust end of operating area for ending on a multi-byte character. |
| 972 | * Used for deletion. |
| 973 | */ |
| 974 | static void |
Bram Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 975 | mb_adjust_opend(oparg_T *oap) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 976 | { |
| 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 985 | |
Bram Moolenaar | 630afe8 | 2018-06-28 19:26:28 +0200 | [diff] [blame] | 986 | /* |
| 987 | * Replace the character under the cursor with "c". |
| 988 | * This takes care of multi-byte characters. |
| 989 | */ |
| 990 | static void |
| 991 | replace_character(int c) |
| 992 | { |
| 993 | int n = State; |
| 994 | |
Bram Moolenaar | 2495910 | 2022-05-07 20:01:16 +0100 | [diff] [blame] | 995 | State = MODE_REPLACE; |
Bram Moolenaar | 630afe8 | 2018-06-28 19:26:28 +0200 | [diff] [blame] | 996 | ins_char(c); |
| 997 | State = n; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 998 | // Backup to the replaced character. |
Bram Moolenaar | 630afe8 | 2018-06-28 19:26:28 +0200 | [diff] [blame] | 999 | dec_cursor(); |
| 1000 | } |
| 1001 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1002 | /* |
| 1003 | * Replace a whole area with one character. |
| 1004 | */ |
| 1005 | int |
Bram Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 1006 | op_replace(oparg_T *oap, int c) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1007 | { |
| 1008 | int n, numc; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1009 | int num_chars; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1010 | char_u *newp, *oldp; |
| 1011 | size_t oldlen; |
| 1012 | struct block_def bd; |
Bram Moolenaar | d982053 | 2013-11-04 01:41:17 +0100 | [diff] [blame] | 1013 | char_u *after_p = NULL; |
Bram Moolenaar | f12519d | 2018-02-06 22:52:49 +0100 | [diff] [blame] | 1014 | int had_ctrl_v_cr = FALSE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1015 | |
| 1016 | if ((curbuf->b_ml.ml_flags & ML_EMPTY ) || oap->empty) |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1017 | return OK; // nothing to do |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1018 | |
Bram Moolenaar | f12519d | 2018-02-06 22:52:49 +0100 | [diff] [blame] | 1019 | 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 Moolenaar | d982053 | 2013-11-04 01:41:17 +0100 | [diff] [blame] | 1029 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1030 | if (has_mbyte) |
| 1031 | mb_adjust_opend(oap); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1032 | |
| 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1045 | curwin->w_cursor.col = 0; // make sure cursor position is valid |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1046 | block_prep(oap, &bd, curwin->w_cursor.lnum, TRUE); |
| 1047 | if (bd.textlen == 0 && (!virtual_op || bd.is_MAX)) |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1048 | continue; // nothing to replace |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1049 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1050 | // 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1055 | if (virtual_op && bd.is_short && *bd.textstart == NUL) |
| 1056 | { |
| 1057 | pos_T vpos; |
| 1058 | |
Bram Moolenaar | a1381de | 2009-11-03 15:44:21 +0000 | [diff] [blame] | 1059 | vpos.lnum = curwin->w_cursor.lnum; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1060 | getvpos(&vpos, oap->start_vcol); |
| 1061 | bd.startspaces += vpos.coladd; |
| 1062 | n = bd.startspaces; |
| 1063 | } |
| 1064 | else |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1065 | // allow for pre spaces |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1066 | n = (bd.startspaces ? bd.start_char_vcols - 1 : 0); |
| 1067 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1068 | // allow for post spp |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1069 | n += (bd.endspaces |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1070 | && !bd.is_oneChar |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1071 | && bd.end_char_vcols > 0) ? bd.end_char_vcols - 1 : 0; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1072 | // Figure out how many characters to replace. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1073 | 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1077 | // A double-wide character can be replaced only up to half the |
| 1078 | // times. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1079 | 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1089 | // Compute bytes needed, move character count to num_chars. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1090 | num_chars = numc; |
| 1091 | numc *= (*mb_char2len)(c); |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1092 | // oldlen includes textlen, so don't double count |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1093 | n += numc - bd.textlen; |
| 1094 | |
| 1095 | oldp = ml_get_curline(); |
| 1096 | oldlen = STRLEN(oldp); |
Bram Moolenaar | 964b374 | 2019-05-24 18:54:09 +0200 | [diff] [blame] | 1097 | newp = alloc(oldlen + 1 + n); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1098 | if (newp == NULL) |
| 1099 | continue; |
| 1100 | vim_memset(newp, NUL, (size_t)(oldlen + 1 + n)); |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1101 | // copy up to deleted part |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1102 | mch_memmove(newp, oldp, (size_t)bd.textcol); |
| 1103 | oldp += bd.textcol + bd.textlen; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1104 | // insert pre-spaces |
Bram Moolenaar | 2536d4f | 2015-07-17 13:22:51 +0200 | [diff] [blame] | 1105 | vim_memset(newp + bd.textcol, ' ', (size_t)bd.startspaces); |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1106 | // insert replacement chars CHECK FOR ALLOCATED SPACE |
| 1107 | // REPLACE_CR_NCHAR/REPLACE_NL_NCHAR is used for entering CR |
| 1108 | // literally. |
Bram Moolenaar | d982053 | 2013-11-04 01:41:17 +0100 | [diff] [blame] | 1109 | if (had_ctrl_v_cr || (c != '\r' && c != '\n')) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1110 | { |
Bram Moolenaar | d982053 | 2013-11-04 01:41:17 +0100 | [diff] [blame] | 1111 | 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 Moolenaar | 2536d4f | 2015-07-17 13:22:51 +0200 | [diff] [blame] | 1118 | vim_memset(newp + STRLEN(newp), c, (size_t)numc); |
Bram Moolenaar | d982053 | 2013-11-04 01:41:17 +0100 | [diff] [blame] | 1119 | if (!bd.is_short) |
| 1120 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1121 | // insert post-spaces |
Bram Moolenaar | 2536d4f | 2015-07-17 13:22:51 +0200 | [diff] [blame] | 1122 | vim_memset(newp + STRLEN(newp), ' ', (size_t)bd.endspaces); |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1123 | // copy the part after the changed part |
Bram Moolenaar | d982053 | 2013-11-04 01:41:17 +0100 | [diff] [blame] | 1124 | STRMOVE(newp + STRLEN(newp), oldp); |
| 1125 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1126 | } |
| 1127 | else |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1128 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1129 | // Replacing with \r or \n means splitting the line. |
Bram Moolenaar | 964b374 | 2019-05-24 18:54:09 +0200 | [diff] [blame] | 1130 | after_p = alloc(oldlen + 1 + n - STRLEN(newp)); |
Bram Moolenaar | d982053 | 2013-11-04 01:41:17 +0100 | [diff] [blame] | 1131 | if (after_p != NULL) |
| 1132 | STRMOVE(after_p, oldp); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1133 | } |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1134 | // replace the line |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1135 | ml_replace(curwin->w_cursor.lnum, newp, FALSE); |
Bram Moolenaar | d982053 | 2013-11-04 01:41:17 +0100 | [diff] [blame] | 1136 | 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1143 | } |
| 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 Moolenaar | b5aedf3 | 2017-03-12 18:23:53 +0100 | [diff] [blame] | 1161 | while (LTOREQ_POS(curwin->w_cursor, oap->end)) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1162 | { |
| 1163 | n = gchar_cursor(); |
| 1164 | if (n != NUL) |
| 1165 | { |
Bram Moolenaar | 8ee6028 | 2021-12-15 21:08:50 +0000 | [diff] [blame] | 1166 | 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1170 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1171 | // This is slow, but it handles replacing a single-byte |
| 1172 | // with a multi-byte and the other way around. |
Bram Moolenaar | db81395 | 2013-03-07 18:50:57 +0100 | [diff] [blame] | 1173 | if (curwin->w_cursor.lnum == oap->end.lnum) |
Bram Moolenaar | 8ee6028 | 2021-12-15 21:08:50 +0000 | [diff] [blame] | 1174 | oap->end.col += new_byte_len - old_byte_len; |
Bram Moolenaar | 630afe8 | 2018-06-28 19:26:28 +0200 | [diff] [blame] | 1175 | replace_character(c); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1176 | } |
| 1177 | else |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1178 | { |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1179 | if (n == TAB) |
| 1180 | { |
| 1181 | int end_vcol = 0; |
| 1182 | |
| 1183 | if (curwin->w_cursor.lnum == oap->end.lnum) |
| 1184 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1185 | // oap->end has to be recalculated when |
| 1186 | // the tab breaks |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1187 | 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 Moolenaar | 630afe8 | 2018-06-28 19:26:28 +0200 | [diff] [blame] | 1194 | PBYTE(curwin->w_cursor, c); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1195 | } |
| 1196 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1197 | 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1205 | // 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1208 | coladvance_force(getviscol2(oap->end.col, oap->end.coladd) + 1); |
| 1209 | curwin->w_cursor.col -= (virtcols + 1); |
| 1210 | for (; virtcols >= 0; virtcols--) |
| 1211 | { |
Bram Moolenaar | 6ed545e | 2022-05-09 20:09:23 +0100 | [diff] [blame] | 1212 | if ((*mb_char2len)(c) > 1) |
Bram Moolenaar | 630afe8 | 2018-06-28 19:26:28 +0200 | [diff] [blame] | 1213 | replace_character(c); |
Bram Moolenaar | 6ed545e | 2022-05-09 20:09:23 +0100 | [diff] [blame] | 1214 | else |
Bram Moolenaar | 630afe8 | 2018-06-28 19:26:28 +0200 | [diff] [blame] | 1215 | PBYTE(curwin->w_cursor, c); |
| 1216 | if (inc(&curwin->w_cursor) == -1) |
| 1217 | break; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1218 | } |
| 1219 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1220 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1221 | // Advance to next character, stop at the end of the file. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1222 | 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 Moolenaar | e100440 | 2020-10-24 20:49:43 +0200 | [diff] [blame] | 1231 | if ((cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) |
Bram Moolenaar | f4a1d1c | 2019-11-16 13:50:25 +0100 | [diff] [blame] | 1232 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1233 | // Set "'[" and "']" marks. |
Bram Moolenaar | f4a1d1c | 2019-11-16 13:50:25 +0100 | [diff] [blame] | 1234 | curbuf->b_op_start = oap->start; |
| 1235 | curbuf->b_op_end = oap->end; |
| 1236 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1237 | |
| 1238 | return OK; |
| 1239 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1240 | |
Bram Moolenaar | baaa7e9 | 2016-01-29 22:47:03 +0100 | [diff] [blame] | 1241 | static int swapchars(int op_type, pos_T *pos, int length); |
Bram Moolenaar | b44df0a | 2008-01-22 15:02:31 +0000 | [diff] [blame] | 1242 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1243 | /* |
| 1244 | * Handle the (non-standard vi) tilde operator. Also for "gu", "gU" and "g?". |
| 1245 | */ |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 1246 | static void |
Bram Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 1247 | op_tilde(oparg_T *oap) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1248 | { |
| 1249 | pos_T pos; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1250 | struct block_def bd; |
Bram Moolenaar | e60c58d | 2008-02-06 13:44:43 +0000 | [diff] [blame] | 1251 | int did_change = FALSE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1252 | |
| 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1258 | if (oap->block_mode) // Visual block mode |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1259 | { |
| 1260 | for (; pos.lnum <= oap->end.lnum; ++pos.lnum) |
| 1261 | { |
Bram Moolenaar | 555b3d5 | 2008-12-03 12:38:36 +0000 | [diff] [blame] | 1262 | int one_change; |
| 1263 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1264 | block_prep(oap, &bd, pos.lnum, FALSE); |
| 1265 | pos.col = bd.textcol; |
Bram Moolenaar | 555b3d5 | 2008-12-03 12:38:36 +0000 | [diff] [blame] | 1266 | one_change = swapchars(oap->op_type, &pos, bd.textlen); |
| 1267 | did_change |= one_change; |
Bram Moolenaar | b44df0a | 2008-01-22 15:02:31 +0000 | [diff] [blame] | 1268 | |
Bram Moolenaar | f7ff6e8 | 2014-03-23 15:13:05 +0100 | [diff] [blame] | 1269 | #ifdef FEAT_NETBEANS_INTG |
Bram Moolenaar | b26e632 | 2010-05-22 21:34:09 +0200 | [diff] [blame] | 1270 | if (netbeans_active() && one_change) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1271 | { |
| 1272 | char_u *ptr = ml_get_buf(curbuf, pos.lnum, FALSE); |
| 1273 | |
Bram Moolenaar | 009b259 | 2004-10-24 19:18:58 +0000 | [diff] [blame] | 1274 | netbeans_removed(curbuf, pos.lnum, bd.textcol, |
| 1275 | (long)bd.textlen); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1276 | netbeans_inserted(curbuf, pos.lnum, bd.textcol, |
Bram Moolenaar | b26e632 | 2010-05-22 21:34:09 +0200 | [diff] [blame] | 1277 | &ptr[bd.textcol], bd.textlen); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1278 | } |
Bram Moolenaar | f7ff6e8 | 2014-03-23 15:13:05 +0100 | [diff] [blame] | 1279 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1280 | } |
| 1281 | if (did_change) |
| 1282 | changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L); |
| 1283 | } |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1284 | else // not block mode |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1285 | { |
| 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 Moolenaar | e60c58d | 2008-02-06 13:44:43 +0000 | [diff] [blame] | 1297 | 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 Moolenaar | b5aedf3 | 2017-03-12 18:23:53 +0100 | [diff] [blame] | 1306 | if (LTOREQ_POS(oap->end, pos) || inc(&pos) == -1) |
Bram Moolenaar | e60c58d | 2008-02-06 13:44:43 +0000 | [diff] [blame] | 1307 | break; |
| 1308 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1309 | 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 Moolenaar | fe15499 | 2022-03-22 20:42:12 +0000 | [diff] [blame] | 1314 | if (netbeans_active()) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1315 | { |
| 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 Moolenaar | a93fa7e | 2006-04-17 22:14:47 +0000 | [diff] [blame] | 1323 | count = (int)STRLEN(ptr) - pos.col; |
Bram Moolenaar | 009b259 | 2004-10-24 19:18:58 +0000 | [diff] [blame] | 1324 | netbeans_removed(curbuf, pos.lnum, pos.col, (long)count); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1325 | netbeans_inserted(curbuf, pos.lnum, pos.col, |
Bram Moolenaar | b26e632 | 2010-05-22 21:34:09 +0200 | [diff] [blame] | 1326 | &ptr[pos.col], count); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1327 | 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 Moolenaar | 009b259 | 2004-10-24 19:18:58 +0000 | [diff] [blame] | 1332 | netbeans_removed(curbuf, pos.lnum, pos.col, (long)count); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1333 | netbeans_inserted(curbuf, pos.lnum, pos.col, |
Bram Moolenaar | b26e632 | 2010-05-22 21:34:09 +0200 | [diff] [blame] | 1334 | &ptr[pos.col], count); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1335 | } |
| 1336 | #endif |
| 1337 | } |
| 1338 | } |
| 1339 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1340 | if (!did_change && oap->is_VIsual) |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1341 | // No change: need to remove the Visual selection |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1342 | redraw_curbuf_later(INVERTED); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1343 | |
Bram Moolenaar | e100440 | 2020-10-24 20:49:43 +0200 | [diff] [blame] | 1344 | if ((cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) |
Bram Moolenaar | f4a1d1c | 2019-11-16 13:50:25 +0100 | [diff] [blame] | 1345 | { |
| 1346 | // Set '[ and '] marks. |
| 1347 | curbuf->b_op_start = oap->start; |
| 1348 | curbuf->b_op_end = oap->end; |
| 1349 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1350 | |
| 1351 | if (oap->line_count > p_report) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 1352 | smsg(NGETTEXT("%ld line changed", "%ld lines changed", |
Bram Moolenaar | da6e891 | 2018-08-21 15:12:14 +0200 | [diff] [blame] | 1353 | oap->line_count), oap->line_count); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1354 | } |
| 1355 | |
| 1356 | /* |
Bram Moolenaar | b44df0a | 2008-01-22 15:02:31 +0000 | [diff] [blame] | 1357 | * 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 Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 1364 | swapchars(int op_type, pos_T *pos, int length) |
Bram Moolenaar | b44df0a | 2008-01-22 15:02:31 +0000 | [diff] [blame] | 1365 | { |
| 1366 | int todo; |
| 1367 | int did_change = 0; |
| 1368 | |
| 1369 | for (todo = length; todo > 0; --todo) |
| 1370 | { |
Bram Moolenaar | b44df0a | 2008-01-22 15:02:31 +0000 | [diff] [blame] | 1371 | if (has_mbyte) |
Bram Moolenaar | f17968b | 2013-08-09 19:48:40 +0200 | [diff] [blame] | 1372 | { |
| 1373 | int len = (*mb_ptr2len)(ml_get_pos(pos)); |
| 1374 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1375 | // we're counting bytes, not characters |
Bram Moolenaar | f17968b | 2013-08-09 19:48:40 +0200 | [diff] [blame] | 1376 | if (len > 0) |
| 1377 | todo -= len - 1; |
| 1378 | } |
Bram Moolenaar | b44df0a | 2008-01-22 15:02:31 +0000 | [diff] [blame] | 1379 | did_change |= swapchar(op_type, pos); |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1380 | if (inc(pos) == -1) // at end of file |
Bram Moolenaar | b44df0a | 2008-01-22 15:02:31 +0000 | [diff] [blame] | 1381 | break; |
| 1382 | } |
| 1383 | return did_change; |
| 1384 | } |
| 1385 | |
| 1386 | /* |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1387 | * 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 Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 1394 | swapchar(int op_type, pos_T *pos) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1395 | { |
| 1396 | int c; |
| 1397 | int nc; |
| 1398 | |
| 1399 | c = gchar_pos(pos); |
| 1400 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1401 | // Only do rot13 encoding for ASCII characters. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1402 | if (c >= 0x80 && op_type == OP_ROT13) |
| 1403 | return FALSE; |
| 1404 | |
Bram Moolenaar | b44df0a | 2008-01-22 15:02:31 +0000 | [diff] [blame] | 1405 | if (op_type == OP_UPPER && c == 0xdf |
| 1406 | && (enc_latin1like || STRCMP(p_enc, "iso-8859-2") == 0)) |
Bram Moolenaar | 6f16eb8 | 2005-08-23 21:02:42 +0000 | [diff] [blame] | 1407 | { |
| 1408 | pos_T sp = curwin->w_cursor; |
| 1409 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1410 | // Special handling of German sharp s: change to "SS". |
Bram Moolenaar | 6f16eb8 | 2005-08-23 21:02:42 +0000 | [diff] [blame] | 1411 | 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1419 | if (enc_dbcs != 0 && c >= 0x100) // No lower/uppercase letter |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1420 | return FALSE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1421 | 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1438 | if (enc_utf8 && (c >= 0x80 || nc >= 0x80)) |
| 1439 | { |
| 1440 | pos_T sp = curwin->w_cursor; |
| 1441 | |
| 1442 | curwin->w_cursor = *pos; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1443 | // don't use del_char(), it also removes composing chars |
Bram Moolenaar | d1cb65e | 2010-08-01 14:22:48 +0200 | [diff] [blame] | 1444 | del_bytes(utf_ptr2len(ml_get_cursor()), FALSE, FALSE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1445 | ins_char(nc); |
| 1446 | curwin->w_cursor = sp; |
| 1447 | } |
| 1448 | else |
Bram Moolenaar | 630afe8 | 2018-06-28 19:26:28 +0200 | [diff] [blame] | 1449 | PBYTE(*pos, nc); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1450 | return TRUE; |
| 1451 | } |
| 1452 | return FALSE; |
| 1453 | } |
| 1454 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1455 | /* |
| 1456 | * op_insert - Insert and append operators for Visual mode. |
| 1457 | */ |
| 1458 | void |
Bram Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 1459 | op_insert(oparg_T *oap, long count1) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1460 | { |
| 1461 | long ins_len, pre_textlen = 0; |
| 1462 | char_u *firstline, *ins_text; |
Bram Moolenaar | 59f4f95 | 2021-11-27 22:47:43 +0000 | [diff] [blame] | 1463 | colnr_T ind_pre_col = 0, ind_post_col; |
| 1464 | int ind_pre_vcol = 0, ind_post_vcol = 0; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1465 | struct block_def bd; |
| 1466 | int i; |
Bram Moolenaar | f2c03d7 | 2015-02-03 18:36:44 +0100 | [diff] [blame] | 1467 | pos_T t1; |
Bram Moolenaar | 4067bd3 | 2021-06-29 18:54:35 +0200 | [diff] [blame] | 1468 | pos_T start_insert; |
| 1469 | // offset when cursor was moved in insert mode |
| 1470 | int offset = 0; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1471 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1472 | // edit() changes this - record it for OP_APPEND |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1473 | bd.is_MAX = (curwin->w_curswant == MAXCOL); |
| 1474 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1475 | // vis block is still marked. Get rid of it now. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1476 | curwin->w_cursor.lnum = oap->start.lnum; |
| 1477 | update_screen(INVERTED); |
| 1478 | |
| 1479 | if (oap->block_mode) |
| 1480 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1481 | // 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 Johnson | 53ba05b | 2021-07-26 22:19:10 +0200 | [diff] [blame] | 1485 | // coladvance_force() uses get_ve_flags() to get the 'virtualedit' |
Gary Johnson | 51ad850 | 2021-08-03 18:33:08 +0200 | [diff] [blame] | 1486 | // 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1488 | if (curwin->w_cursor.coladd > 0) |
| 1489 | { |
Gary Johnson | 51ad850 | 2021-08-03 18:33:08 +0200 | [diff] [blame] | 1490 | int old_ve_flags = curwin->w_ve_flags; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1491 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1492 | if (u_save_cursor() == FAIL) |
| 1493 | return; |
Gary Johnson | 53ba05b | 2021-07-26 22:19:10 +0200 | [diff] [blame] | 1494 | |
Gary Johnson | 51ad850 | 2021-08-03 18:33:08 +0200 | [diff] [blame] | 1495 | curwin->w_ve_flags = VE_ALL; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1496 | 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 Johnson | 51ad850 | 2021-08-03 18:33:08 +0200 | [diff] [blame] | 1500 | curwin->w_ve_flags = old_ve_flags; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1501 | } |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1502 | // Get the info about the block before entering the text |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1503 | block_prep(oap, &bd, oap->start.lnum, TRUE); |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1504 | // Get indent information |
Bram Moolenaar | 59f4f95 | 2021-11-27 22:47:43 +0000 | [diff] [blame] | 1505 | ind_pre_col = (colnr_T)getwhitecols_curline(); |
| 1506 | ind_pre_vcol = get_indent(); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1507 | firstline = ml_get(oap->start.lnum) + bd.textcol; |
Bram Moolenaar | e2e69e4 | 2017-09-02 20:30:35 +0200 | [diff] [blame] | 1508 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1509 | 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 Moolenaar | 29ddebe | 2019-01-26 17:28:26 +0100 | [diff] [blame] | 1516 | if (oap->block_mode && curwin->w_cursor.coladd == 0) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1517 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1518 | // Move the cursor to the character right of the block. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1519 | 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1525 | // First line was too short, make it longer and adjust the |
| 1526 | // values in "bd". |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1527 | 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 Moolenaar | 6a584dc | 2006-06-20 18:29:34 +0000 | [diff] [blame] | 1537 | check_cursor_col(); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1538 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1539 | // Works just like an 'i'nsert on the next character. |
Bram Moolenaar | b5aedf3 | 2017-03-12 18:23:53 +0100 | [diff] [blame] | 1540 | if (!LINEEMPTY(curwin->w_cursor.lnum) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1541 | && oap->start_vcol != oap->end_vcol) |
| 1542 | inc_cursor(); |
| 1543 | } |
| 1544 | } |
| 1545 | |
Bram Moolenaar | f2c03d7 | 2015-02-03 18:36:44 +0100 | [diff] [blame] | 1546 | t1 = oap->start; |
Bram Moolenaar | 4067bd3 | 2021-06-29 18:54:35 +0200 | [diff] [blame] | 1547 | start_insert = curwin->w_cursor; |
Bram Moolenaar | 23fa81d | 2017-02-01 21:50:21 +0100 | [diff] [blame] | 1548 | (void)edit(NUL, FALSE, (linenr_T)count1); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1549 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1550 | // 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 Moolenaar | f2c03d7 | 2015-02-03 18:36:44 +0100 | [diff] [blame] | 1553 | if (t1.lnum == curbuf->b_op_start_orig.lnum |
Bram Moolenaar | b5aedf3 | 2017-03-12 18:23:53 +0100 | [diff] [blame] | 1554 | && LT_POS(curbuf->b_op_start_orig, t1)) |
Bram Moolenaar | f2c03d7 | 2015-02-03 18:36:44 +0100 | [diff] [blame] | 1555 | oap->start = curbuf->b_op_start_orig; |
| 1556 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1557 | // 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 Moolenaar | aacbb00 | 2008-01-03 15:34:40 +0000 | [diff] [blame] | 1560 | if (curwin->w_cursor.lnum != oap->start.lnum || got_int) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1561 | return; |
| 1562 | |
| 1563 | if (oap->block_mode) |
| 1564 | { |
| 1565 | struct block_def bd2; |
Bram Moolenaar | 8c87a2b | 2018-04-10 13:15:47 +0200 | [diff] [blame] | 1566 | int did_indent = FALSE; |
Bram Moolenaar | 35e802e | 2018-04-30 17:21:03 +0200 | [diff] [blame] | 1567 | size_t len; |
| 1568 | int add; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1569 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1570 | // If indent kicked in, the firstline might have changed |
| 1571 | // but only do that, if the indent actually increased. |
Bram Moolenaar | 59f4f95 | 2021-11-27 22:47:43 +0000 | [diff] [blame] | 1572 | ind_post_col = (colnr_T)getwhitecols_curline(); |
| 1573 | if (curbuf->b_op_start.col > ind_pre_col && ind_post_col > ind_pre_col) |
Bram Moolenaar | 4ec86dd | 2017-09-02 23:28:54 +0200 | [diff] [blame] | 1574 | { |
Bram Moolenaar | 59f4f95 | 2021-11-27 22:47:43 +0000 | [diff] [blame] | 1575 | 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 Moolenaar | 8c87a2b | 2018-04-10 13:15:47 +0200 | [diff] [blame] | 1578 | did_indent = TRUE; |
Bram Moolenaar | 4ec86dd | 2017-09-02 23:28:54 +0200 | [diff] [blame] | 1579 | } |
| 1580 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1581 | // 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 Moolenaar | 8c87a2b | 2018-04-10 13:15:47 +0200 | [diff] [blame] | 1584 | if (oap->start.lnum == curbuf->b_op_start_orig.lnum |
| 1585 | && !bd.is_MAX && !did_indent) |
Bram Moolenaar | 3f75e42 | 2013-11-11 01:29:22 +0100 | [diff] [blame] | 1586 | { |
Bram Moolenaar | 4067bd3 | 2021-06-29 18:54:35 +0200 | [diff] [blame] | 1587 | int t = getviscol2(curbuf->b_op_start_orig.col, |
| 1588 | curbuf->b_op_start_orig.coladd); |
| 1589 | |
zeertzjq | 7745f14 | 2022-02-15 11:48:22 +0000 | [diff] [blame] | 1590 | 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 Moolenaar | 3f75e42 | 2013-11-11 01:29:22 +0100 | [diff] [blame] | 1594 | { |
zeertzjq | 7745f14 | 2022-02-15 11:48:22 +0000 | [diff] [blame] | 1595 | oap->start.col = curbuf->b_op_start_orig.col; |
| 1596 | pre_textlen -= t - oap->start_vcol; |
| 1597 | oap->start_vcol = t; |
Bram Moolenaar | 3f75e42 | 2013-11-11 01:29:22 +0100 | [diff] [blame] | 1598 | } |
zeertzjq | 7745f14 | 2022-02-15 11:48:22 +0000 | [diff] [blame] | 1599 | 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 Moolenaar | 3f75e42 | 2013-11-11 01:29:22 +0100 | [diff] [blame] | 1603 | { |
zeertzjq | 7745f14 | 2022-02-15 11:48:22 +0000 | [diff] [blame] | 1604 | oap->start.col = curbuf->b_op_start_orig.col; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1605 | // reset pre_textlen to the value of OP_INSERT |
Bram Moolenaar | 3f75e42 | 2013-11-11 01:29:22 +0100 | [diff] [blame] | 1606 | pre_textlen += bd.textlen; |
Bram Moolenaar | f2c03d7 | 2015-02-03 18:36:44 +0100 | [diff] [blame] | 1607 | pre_textlen -= t - oap->start_vcol; |
zeertzjq | 7745f14 | 2022-02-15 11:48:22 +0000 | [diff] [blame] | 1608 | oap->start_vcol = t; |
| 1609 | oap->op_type = OP_INSERT; |
Bram Moolenaar | 3f75e42 | 2013-11-11 01:29:22 +0100 | [diff] [blame] | 1610 | } |
| 1611 | } |
| 1612 | |
Bram Moolenaar | 59f4f95 | 2021-11-27 22:47:43 +0000 | [diff] [blame] | 1613 | // 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1626 | block_prep(oap, &bd2, oap->start.lnum, TRUE); |
Bram Moolenaar | 59f4f95 | 2021-11-27 22:47:43 +0000 | [diff] [blame] | 1627 | 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1635 | 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 Moolenaar | 35e802e | 2018-04-30 17:21:03 +0200 | [diff] [blame] | 1651 | firstline = ml_get(oap->start.lnum); |
| 1652 | len = STRLEN(firstline); |
| 1653 | add = bd.textcol; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1654 | if (oap->op_type == OP_APPEND) |
Bram Moolenaar | 4067bd3 | 2021-06-29 18:54:35 +0200 | [diff] [blame] | 1655 | { |
Bram Moolenaar | 35e802e | 2018-04-30 17:21:03 +0200 | [diff] [blame] | 1656 | add += bd.textlen; |
Bram Moolenaar | 4067bd3 | 2021-06-29 18:54:35 +0200 | [diff] [blame] | 1657 | // 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 Moolenaar | 35e802e | 2018-04-30 17:21:03 +0200 | [diff] [blame] | 1671 | if ((size_t)add > len) |
| 1672 | firstline += len; // short line, point to the NUL |
| 1673 | else |
| 1674 | firstline += add; |
Bram Moolenaar | 4067bd3 | 2021-06-29 18:54:35 +0200 | [diff] [blame] | 1675 | if (pre_textlen >= 0 && (ins_len = |
| 1676 | (long)STRLEN(firstline) - pre_textlen - offset) > 0) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1677 | { |
Bram Moolenaar | 71ccd03 | 2020-06-12 22:59:11 +0200 | [diff] [blame] | 1678 | ins_text = vim_strnsave(firstline, ins_len); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1679 | if (ins_text != NULL) |
| 1680 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1681 | // block handled here |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1682 | 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1694 | |
| 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 Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 1701 | op_change(oparg_T *oap) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1702 | { |
| 1703 | colnr_T l; |
| 1704 | int retval; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1705 | long offset; |
| 1706 | linenr_T linenr; |
Bram Moolenaar | 53241da | 2007-09-13 20:41:32 +0000 | [diff] [blame] | 1707 | long ins_len; |
| 1708 | long pre_textlen = 0; |
| 1709 | long pre_indent = 0; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1710 | char_u *firstline; |
| 1711 | char_u *ins_text, *newp, *oldp; |
| 1712 | struct block_def bd; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1713 | |
| 1714 | l = oap->start.col; |
| 1715 | if (oap->motion_type == MLINE) |
| 1716 | { |
| 1717 | l = 0; |
Bram Moolenaar | de5cf28 | 2022-05-14 11:52:23 +0100 | [diff] [blame] | 1718 | can_si = may_do_si(); // Like opening a new line, do smart indent |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1719 | } |
| 1720 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1721 | // First delete the text in the region. In an empty buffer only need to |
| 1722 | // save for undo |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1723 | 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 Moolenaar | b5aedf3 | 2017-03-12 18:23:53 +0100 | [diff] [blame] | 1731 | if ((l > curwin->w_cursor.col) && !LINEEMPTY(curwin->w_cursor.lnum) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1732 | && !virtual_op) |
| 1733 | inc_cursor(); |
| 1734 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1735 | // check for still on same line (<CR> in inserted text meaningless) |
| 1736 | // skip blank lines too |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1737 | if (oap->block_mode) |
| 1738 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1739 | // Add spaces before getting the current line length. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1740 | if (virtual_op && (curwin->w_cursor.coladd > 0 |
| 1741 | || gchar_cursor() == NUL)) |
| 1742 | coladvance_force(getviscol()); |
Bram Moolenaar | 53241da | 2007-09-13 20:41:32 +0000 | [diff] [blame] | 1743 | firstline = ml_get(oap->start.lnum); |
| 1744 | pre_textlen = (long)STRLEN(firstline); |
Bram Moolenaar | e2e69e4 | 2017-09-02 20:30:35 +0200 | [diff] [blame] | 1745 | pre_indent = (long)getwhitecols(firstline); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1746 | bd.textcol = curwin->w_cursor.col; |
| 1747 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1748 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1749 | if (oap->motion_type == MLINE) |
| 1750 | fix_indent(); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1751 | |
| 1752 | retval = edit(NUL, FALSE, (linenr_T)1); |
| 1753 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1754 | /* |
Bram Moolenaar | 1cd871b | 2004-12-19 22:46:22 +0000 | [diff] [blame] | 1755 | * In Visual block mode, handle copying the new text to all lines of the |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1756 | * block. |
Bram Moolenaar | aacbb00 | 2008-01-03 15:34:40 +0000 | [diff] [blame] | 1757 | * Don't repeat the insert when Insert mode ended with CTRL-C. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1758 | */ |
Bram Moolenaar | aacbb00 | 2008-01-03 15:34:40 +0000 | [diff] [blame] | 1759 | if (oap->block_mode && oap->start.lnum != oap->end.lnum && !got_int) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1760 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1761 | // Auto-indenting may have changed the indent. If the cursor was past |
| 1762 | // the indent, exclude that indent change from the inserted text. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1763 | firstline = ml_get(oap->start.lnum); |
Bram Moolenaar | b8dc4d4 | 2007-09-25 12:20:19 +0000 | [diff] [blame] | 1764 | if (bd.textcol > (colnr_T)pre_indent) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1765 | { |
Bram Moolenaar | e2e69e4 | 2017-09-02 20:30:35 +0200 | [diff] [blame] | 1766 | long new_indent = (long)getwhitecols(firstline); |
Bram Moolenaar | 53241da | 2007-09-13 20:41:32 +0000 | [diff] [blame] | 1767 | |
| 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1775 | // Subsequent calls to ml_get() flush the firstline data - take a |
| 1776 | // copy of the inserted text. |
Bram Moolenaar | 964b374 | 2019-05-24 18:54:09 +0200 | [diff] [blame] | 1777 | if ((ins_text = alloc(ins_len + 1)) != NULL) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1778 | { |
Bram Moolenaar | ce0842a | 2005-07-18 21:58:11 +0000 | [diff] [blame] | 1779 | vim_strncpy(ins_text, firstline + bd.textcol, (size_t)ins_len); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1780 | 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1786 | pos_T vpos; |
| 1787 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1788 | // If the block starts in virtual space, count the |
| 1789 | // initial coladd offset as part of "startspaces" |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1790 | if (bd.is_short) |
| 1791 | { |
Bram Moolenaar | a1381de | 2009-11-03 15:44:21 +0000 | [diff] [blame] | 1792 | vpos.lnum = linenr; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1793 | (void)getvpos(&vpos, oap->start_vcol); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1794 | } |
| 1795 | else |
| 1796 | vpos.coladd = 0; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1797 | oldp = ml_get(linenr); |
Bram Moolenaar | 964b374 | 2019-05-24 18:54:09 +0200 | [diff] [blame] | 1798 | newp = alloc(STRLEN(oldp) + vpos.coladd + ins_len + 1); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1799 | if (newp == NULL) |
| 1800 | continue; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1801 | // copy up to block start |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1802 | mch_memmove(newp, oldp, (size_t)bd.textcol); |
| 1803 | offset = bd.textcol; |
Bram Moolenaar | 2536d4f | 2015-07-17 13:22:51 +0200 | [diff] [blame] | 1804 | vim_memset(newp + offset, ' ', (size_t)vpos.coladd); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1805 | offset += vpos.coladd; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1806 | mch_memmove(newp + offset, ins_text, (size_t)ins_len); |
| 1807 | offset += ins_len; |
| 1808 | oldp += bd.textcol; |
Bram Moolenaar | c1a11ed | 2008-06-24 22:09:24 +0000 | [diff] [blame] | 1809 | STRMOVE(newp + offset, oldp); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1810 | ml_replace(linenr, newp, FALSE); |
LemonBoy | b559b30 | 2022-05-15 13:08:02 +0100 | [diff] [blame] | 1811 | #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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1817 | } |
| 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 Moolenaar | 6b36d2a | 2021-08-23 21:19:01 +0200 | [diff] [blame] | 1826 | auto_format(FALSE, TRUE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1827 | |
| 1828 | return retval; |
| 1829 | } |
| 1830 | |
| 1831 | /* |
Bram Moolenaar | f193fff | 2006-04-27 00:02:13 +0000 | [diff] [blame] | 1832 | * 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 Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 1836 | adjust_cursor_eol(void) |
Bram Moolenaar | f193fff | 2006-04-27 00:02:13 +0000 | [diff] [blame] | 1837 | { |
Gary Johnson | 53ba05b | 2021-07-26 22:19:10 +0200 | [diff] [blame] | 1838 | unsigned int cur_ve_flags = get_ve_flags(); |
| 1839 | |
Bram Moolenaar | f193fff | 2006-04-27 00:02:13 +0000 | [diff] [blame] | 1840 | if (curwin->w_cursor.col > 0 |
| 1841 | && gchar_cursor() == NUL |
Gary Johnson | 53ba05b | 2021-07-26 22:19:10 +0200 | [diff] [blame] | 1842 | && (cur_ve_flags & VE_ONEMORE) == 0 |
Bram Moolenaar | 2495910 | 2022-05-07 20:01:16 +0100 | [diff] [blame] | 1843 | && !(restart_edit || (State & MODE_INSERT))) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1844 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1845 | // Put the cursor on the last character in the line. |
Bram Moolenaar | a5fac54 | 2005-10-12 20:58:49 +0000 | [diff] [blame] | 1846 | dec_cursor(); |
Bram Moolenaar | f193fff | 2006-04-27 00:02:13 +0000 | [diff] [blame] | 1847 | |
Gary Johnson | 53ba05b | 2021-07-26 22:19:10 +0200 | [diff] [blame] | 1848 | if (cur_ve_flags == VE_ALL) |
Bram Moolenaar | a5792f5 | 2005-11-23 21:25:05 +0000 | [diff] [blame] | 1849 | { |
| 1850 | colnr_T scol, ecol; |
| 1851 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1852 | // Coladd is set to the width of the last character. |
Bram Moolenaar | a5792f5 | 2005-11-23 21:25:05 +0000 | [diff] [blame] | 1853 | getvcol(curwin, &curwin->w_cursor, &scol, NULL, &ecol); |
| 1854 | curwin->w_cursor.coladd = ecol - scol + 1; |
| 1855 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1856 | } |
| 1857 | } |
| 1858 | |
Bram Moolenaar | 8134039 | 2012-06-06 16:12:59 +0200 | [diff] [blame] | 1859 | /* |
| 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 Moolenaar | bfe3bf8 | 2012-06-13 17:28:55 +0200 | [diff] [blame] | 1866 | * comment, |
Bram Moolenaar | 8134039 | 2012-06-06 16:12:59 +0200 | [diff] [blame] | 1867 | * 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 Moolenaar | bfe3bf8 | 2012-06-13 17:28:55 +0200 | [diff] [blame] | 1869 | * comment. |
Bram Moolenaar | 8134039 | 2012-06-06 16:12:59 +0200 | [diff] [blame] | 1870 | */ |
Bram Moolenaar | 025a6b7 | 2017-03-12 20:37:21 +0100 | [diff] [blame] | 1871 | char_u * |
Bram Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 1872 | skip_comment( |
| 1873 | char_u *line, |
| 1874 | int process, |
| 1875 | int include_space, |
| 1876 | int *is_comment) |
Bram Moolenaar | 8134039 | 2012-06-06 16:12:59 +0200 | [diff] [blame] | 1877 | { |
| 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1885 | // 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 Moolenaar | 8134039 | 2012-06-06 16:12:59 +0200 | [diff] [blame] | 1887 | 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1906 | // Find: |
| 1907 | // - COM_END, |
| 1908 | // - colon, |
| 1909 | // whichever comes first. |
Bram Moolenaar | 8134039 | 2012-06-06 16:12:59 +0200 | [diff] [blame] | 1910 | while (*comment_flags) |
| 1911 | { |
Bram Moolenaar | e04a48f | 2012-06-13 14:01:41 +0200 | [diff] [blame] | 1912 | if (*comment_flags == COM_END |
Bram Moolenaar | 8134039 | 2012-06-06 16:12:59 +0200 | [diff] [blame] | 1913 | || *comment_flags == ':') |
Bram Moolenaar | 8134039 | 2012-06-06 16:12:59 +0200 | [diff] [blame] | 1914 | break; |
Bram Moolenaar | 8134039 | 2012-06-06 16:12:59 +0200 | [diff] [blame] | 1915 | ++comment_flags; |
| 1916 | } |
| 1917 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1918 | // 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 Moolenaar | 8134039 | 2012-06-06 16:12:59 +0200 | [diff] [blame] | 1921 | if (*comment_flags == ':' || *comment_flags == NUL) |
| 1922 | line += lead_len; |
| 1923 | |
| 1924 | return line; |
| 1925 | } |
Bram Moolenaar | 8134039 | 2012-06-06 16:12:59 +0200 | [diff] [blame] | 1926 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1927 | /* |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 1928 | * Join 'count' lines (minimal 2) at cursor position. |
| 1929 | * When "save_undo" is TRUE save lines for undo first. |
Bram Moolenaar | d69bd9a | 2014-04-29 12:15:40 +0200 | [diff] [blame] | 1930 | * 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1934 | * |
Bram Moolenaar | 10c5695 | 2007-05-10 18:38:52 +0000 | [diff] [blame] | 1935 | * return FAIL for failure, OK otherwise |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1936 | */ |
| 1937 | int |
Bram Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 1938 | do_join( |
| 1939 | long count, |
| 1940 | int insert_space, |
| 1941 | int save_undo, |
| 1942 | int use_formatoptions UNUSED, |
| 1943 | int setmark) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1944 | { |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 1945 | char_u *curr = NULL; |
Bram Moolenaar | 341ad7a | 2010-10-09 17:23:31 +0200 | [diff] [blame] | 1946 | char_u *curr_start = NULL; |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 1947 | char_u *cend; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1948 | char_u *newp; |
Bram Moolenaar | 87be9be | 2020-05-30 15:32:02 +0200 | [diff] [blame] | 1949 | size_t newp_len; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1950 | char_u *spaces; // number of spaces inserted before a line |
Bram Moolenaar | d43848c | 2010-07-14 14:28:26 +0200 | [diff] [blame] | 1951 | int endcurr1 = NUL; |
| 1952 | int endcurr2 = NUL; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1953 | int currsize = 0; // size of the current line |
| 1954 | int sumsize = 0; // size of the long new line |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1955 | linenr_T t; |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 1956 | colnr_T col = 0; |
| 1957 | int ret = OK; |
Bram Moolenaar | 802053f | 2012-06-06 23:08:38 +0200 | [diff] [blame] | 1958 | int *comments = NULL; |
Bram Moolenaar | 8134039 | 2012-06-06 16:12:59 +0200 | [diff] [blame] | 1959 | int remove_comments = (use_formatoptions == TRUE) |
| 1960 | && has_format_option(FO_REMOVE_COMS); |
| 1961 | int prev_was_comment; |
Bram Moolenaar | 05ad5ff | 2019-11-30 22:48:27 +0100 | [diff] [blame] | 1962 | #ifdef FEAT_PROP_POPUP |
Bram Moolenaar | 87be9be | 2020-05-30 15:32:02 +0200 | [diff] [blame] | 1963 | int propcount = 0; // number of props over all joined lines |
| 1964 | int props_remaining; |
Bram Moolenaar | 80e737c | 2019-05-17 19:56:34 +0200 | [diff] [blame] | 1965 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1966 | |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 1967 | 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1970 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 1971 | // 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 Moolenaar | 18a4ba2 | 2019-05-24 19:39:03 +0200 | [diff] [blame] | 1974 | spaces = lalloc_clear(count, TRUE); |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 1975 | if (spaces == NULL) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1976 | return FAIL; |
Bram Moolenaar | 8134039 | 2012-06-06 16:12:59 +0200 | [diff] [blame] | 1977 | if (remove_comments) |
| 1978 | { |
Bram Moolenaar | c799fe2 | 2019-05-28 23:08:19 +0200 | [diff] [blame] | 1979 | comments = lalloc_clear(count * sizeof(int), TRUE); |
Bram Moolenaar | 8134039 | 2012-06-06 16:12:59 +0200 | [diff] [blame] | 1980 | if (comments == NULL) |
| 1981 | { |
| 1982 | vim_free(spaces); |
| 1983 | return FAIL; |
| 1984 | } |
| 1985 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1986 | |
| 1987 | /* |
Bram Moolenaar | 80e737c | 2019-05-17 19:56:34 +0200 | [diff] [blame] | 1988 | * Don't move anything yet, just compute the final line length |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 1989 | * and setup the array of space strings lengths |
Bram Moolenaar | 80e737c | 2019-05-17 19:56:34 +0200 | [diff] [blame] | 1990 | * This loops forward over the joined lines. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1991 | */ |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 1992 | for (t = 0; t < count; ++t) |
| 1993 | { |
Bram Moolenaar | 341ad7a | 2010-10-09 17:23:31 +0200 | [diff] [blame] | 1994 | curr = curr_start = ml_get((linenr_T)(curwin->w_cursor.lnum + t)); |
Bram Moolenaar | 87be9be | 2020-05-30 15:32:02 +0200 | [diff] [blame] | 1995 | #ifdef FEAT_PROP_POPUP |
| 1996 | propcount += count_props((linenr_T) (curwin->w_cursor.lnum + t), t > 0); |
| 1997 | #endif |
Bram Moolenaar | e100440 | 2020-10-24 20:49:43 +0200 | [diff] [blame] | 1998 | if (t == 0 && setmark && (cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) |
Bram Moolenaar | f92d8a2 | 2014-02-11 19:33:07 +0100 | [diff] [blame] | 1999 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2000 | // Set the '[ mark. |
Bram Moolenaar | f92d8a2 | 2014-02-11 19:33:07 +0100 | [diff] [blame] | 2001 | 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 Moolenaar | 8134039 | 2012-06-06 16:12:59 +0200 | [diff] [blame] | 2004 | if (remove_comments) |
| 2005 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2006 | // We don't want to remove the comment leader if the |
| 2007 | // previous line is not a comment. |
Bram Moolenaar | 8134039 | 2012-06-06 16:12:59 +0200 | [diff] [blame] | 2008 | if (t > 0 && prev_was_comment) |
| 2009 | { |
| 2010 | |
| 2011 | char_u *new_curr = skip_comment(curr, TRUE, insert_space, |
| 2012 | &prev_was_comment); |
Bram Moolenaar | 27ba088 | 2012-06-07 21:09:39 +0200 | [diff] [blame] | 2013 | comments[t] = (int)(new_curr - curr); |
Bram Moolenaar | 8134039 | 2012-06-06 16:12:59 +0200 | [diff] [blame] | 2014 | curr = new_curr; |
| 2015 | } |
| 2016 | else |
| 2017 | curr = skip_comment(curr, FALSE, insert_space, |
| 2018 | &prev_was_comment); |
| 2019 | } |
Bram Moolenaar | 8134039 | 2012-06-06 16:12:59 +0200 | [diff] [blame] | 2020 | |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2021 | if (insert_space && t > 0) |
| 2022 | { |
| 2023 | curr = skipwhite(curr); |
Bram Moolenaar | cc184cf | 2019-11-12 20:31:20 +0100 | [diff] [blame] | 2024 | if (*curr != NUL && *curr != ')' |
Bram Moolenaar | 91b65e4 | 2019-12-17 22:10:58 +0100 | [diff] [blame] | 2025 | && sumsize != 0 && endcurr1 != TAB |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2026 | && (!has_format_option(FO_MBYTE_JOIN) |
| 2027 | || (mb_ptr2char(curr) < 0x100 && endcurr1 < 0x100)) |
| 2028 | && (!has_format_option(FO_MBYTE_JOIN2) |
Bram Moolenaar | e52702f | 2020-06-04 18:22:13 +0200 | [diff] [blame] | 2029 | || (mb_ptr2char(curr) < 0x100 |
| 2030 | && !(enc_utf8 && utf_eat_space(endcurr1))) |
| 2031 | || (endcurr1 < 0x100 |
| 2032 | && !(enc_utf8 && utf_eat_space(mb_ptr2char(curr))))) |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2033 | ) |
| 2034 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2035 | // don't add a space if the line is ending in a space |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2036 | if (endcurr1 == ' ') |
| 2037 | endcurr1 = endcurr2; |
| 2038 | else |
| 2039 | ++spaces[t]; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2040 | // extra space when 'joinspaces' set and line ends in '.' |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2041 | 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 Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2053 | if (has_mbyte) |
| 2054 | { |
| 2055 | cend = curr + currsize; |
Bram Moolenaar | 91acfff | 2017-03-12 19:22:36 +0100 | [diff] [blame] | 2056 | MB_PTR_BACK(curr, cend); |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2057 | endcurr1 = (*mb_ptr2char)(cend); |
| 2058 | if (cend > curr) |
| 2059 | { |
Bram Moolenaar | 91acfff | 2017-03-12 19:22:36 +0100 | [diff] [blame] | 2060 | MB_PTR_BACK(curr, cend); |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2061 | endcurr2 = (*mb_ptr2char)(cend); |
| 2062 | } |
| 2063 | } |
| 2064 | else |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2065 | { |
| 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2078 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2079 | // store the column position before last line |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2080 | col = sumsize - currsize - spaces[count - 1]; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2081 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2082 | // allocate the space for the new line |
Bram Moolenaar | 87be9be | 2020-05-30 15:32:02 +0200 | [diff] [blame] | 2083 | newp_len = sumsize + 1; |
| 2084 | #ifdef FEAT_PROP_POPUP |
| 2085 | newp_len += propcount * sizeof(textprop_T); |
| 2086 | #endif |
| 2087 | newp = alloc(newp_len); |
Bram Moolenaar | 6f10c70 | 2019-08-20 22:58:37 +0200 | [diff] [blame] | 2088 | if (newp == NULL) |
| 2089 | { |
| 2090 | ret = FAIL; |
| 2091 | goto theend; |
| 2092 | } |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2093 | cend = newp + sumsize; |
| 2094 | *cend = 0; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2095 | |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2096 | /* |
| 2097 | * Move affected lines to the new long one. |
Bram Moolenaar | 80e737c | 2019-05-17 19:56:34 +0200 | [diff] [blame] | 2098 | * This loops backwards over the joined lines, including the original line. |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2099 | * |
| 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 Moolenaar | 87be9be | 2020-05-30 15:32:02 +0200 | [diff] [blame] | 2104 | #ifdef FEAT_PROP_POPUP |
| 2105 | props_remaining = propcount; |
| 2106 | #endif |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2107 | for (t = count - 1; ; --t) |
| 2108 | { |
Bram Moolenaar | e1e714e | 2018-12-31 23:58:24 +0100 | [diff] [blame] | 2109 | int spaces_removed; |
| 2110 | |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2111 | cend -= currsize; |
| 2112 | mch_memmove(cend, curr, (size_t)currsize); |
Bram Moolenaar | 87be9be | 2020-05-30 15:32:02 +0200 | [diff] [blame] | 2113 | |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2114 | if (spaces[t] > 0) |
| 2115 | { |
| 2116 | cend -= spaces[t]; |
Bram Moolenaar | 2536d4f | 2015-07-17 13:22:51 +0200 | [diff] [blame] | 2117 | vim_memset(cend, ' ', (size_t)(spaces[t])); |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2118 | } |
Bram Moolenaar | e1e714e | 2018-12-31 23:58:24 +0100 | [diff] [blame] | 2119 | |
| 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?= | 420fabc | 2022-01-28 15:28:04 +0000 | [diff] [blame] | 2124 | mark_col_adjust(curwin->w_cursor.lnum + t, (colnr_T)0, -t, |
Bram Moolenaar | e1e714e | 2018-12-31 23:58:24 +0100 | [diff] [blame] | 2125 | (long)(cend - newp - spaces_removed), spaces_removed); |
Bram Moolenaar | 05ad5ff | 2019-11-30 22:48:27 +0100 | [diff] [blame] | 2126 | #ifdef FEAT_PROP_POPUP |
Bram Moolenaar | 87be9be | 2020-05-30 15:32:02 +0200 | [diff] [blame] | 2127 | 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 Moolenaar | 80e737c | 2019-05-17 19:56:34 +0200 | [diff] [blame] | 2130 | #endif |
| 2131 | |
Bram Moolenaar | 87be9be | 2020-05-30 15:32:02 +0200 | [diff] [blame] | 2132 | if (t == 0) |
| 2133 | break; |
Bram Moolenaar | 341ad7a | 2010-10-09 17:23:31 +0200 | [diff] [blame] | 2134 | curr = curr_start = ml_get((linenr_T)(curwin->w_cursor.lnum + t - 1)); |
Bram Moolenaar | 8134039 | 2012-06-06 16:12:59 +0200 | [diff] [blame] | 2135 | if (remove_comments) |
| 2136 | curr += comments[t - 1]; |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2137 | if (insert_space && t > 1) |
| 2138 | curr = skipwhite(curr); |
| 2139 | currsize = (int)STRLEN(curr); |
| 2140 | } |
Bram Moolenaar | 80e737c | 2019-05-17 19:56:34 +0200 | [diff] [blame] | 2141 | |
Bram Moolenaar | d6a77f9 | 2020-06-01 19:14:12 +0200 | [diff] [blame] | 2142 | ml_replace_len(curwin->w_cursor.lnum, newp, (colnr_T)newp_len, TRUE, FALSE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2143 | |
Bram Moolenaar | e100440 | 2020-10-24 20:49:43 +0200 | [diff] [blame] | 2144 | if (setmark && (cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) |
Bram Moolenaar | d69bd9a | 2014-04-29 12:15:40 +0200 | [diff] [blame] | 2145 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2146 | // Set the '] mark. |
Bram Moolenaar | d69bd9a | 2014-04-29 12:15:40 +0200 | [diff] [blame] | 2147 | curwin->w_buffer->b_op_end.lnum = curwin->w_cursor.lnum; |
Bram Moolenaar | 787880a | 2019-05-17 20:17:40 +0200 | [diff] [blame] | 2148 | curwin->w_buffer->b_op_end.col = (colnr_T)sumsize; |
Bram Moolenaar | d69bd9a | 2014-04-29 12:15:40 +0200 | [diff] [blame] | 2149 | } |
Bram Moolenaar | f92d8a2 | 2014-02-11 19:33:07 +0100 | [diff] [blame] | 2150 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2151 | // Only report the change in the first line here, del_lines() will report |
| 2152 | // the deleted line. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2153 | changed_lines(curwin->w_cursor.lnum, currsize, |
| 2154 | curwin->w_cursor.lnum + 1, 0L); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2155 | /* |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2156 | * Delete following lines. To do this we move the cursor there |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2157 | * 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2159 | */ |
| 2160 | t = curwin->w_cursor.lnum; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2161 | ++curwin->w_cursor.lnum; |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2162 | del_lines(count - 1, FALSE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2163 | curwin->w_cursor.lnum = t; |
| 2164 | |
| 2165 | /* |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2166 | * Set the cursor column: |
| 2167 | * Vi compatible: use the column of the first join |
Bram Moolenaar | cc448b3 | 2010-07-14 16:52:17 +0200 | [diff] [blame] | 2168 | * vim: use the column of the last join |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2169 | */ |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2170 | curwin->w_cursor.col = |
| 2171 | (vim_strchr(p_cpo, CPO_JOINCOL) != NULL ? currsize : col); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2172 | check_cursor_col(); |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2173 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2174 | curwin->w_cursor.coladd = 0; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2175 | curwin->w_set_curswant = TRUE; |
| 2176 | |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2177 | theend: |
| 2178 | vim_free(spaces); |
Bram Moolenaar | 8134039 | 2012-06-06 16:12:59 +0200 | [diff] [blame] | 2179 | if (remove_comments) |
| 2180 | vim_free(comments); |
Bram Moolenaar | 893eaab | 2010-07-10 17:51:46 +0200 | [diff] [blame] | 2181 | return ret; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2182 | } |
| 2183 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2184 | /* |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2185 | * 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 Moolenaar | 9d77dcc | 2009-03-11 15:28:26 +0000 | [diff] [blame] | 2191 | * deleted. |
| 2192 | * for yank and tilde: |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2193 | * - 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 Moolenaar | 4aea03e | 2019-09-25 22:37:17 +0200 | [diff] [blame] | 2197 | void |
Bram Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 2198 | block_prep( |
| 2199 | oparg_T *oap, |
| 2200 | struct block_def *bdp, |
| 2201 | linenr_T lnum, |
| 2202 | int is_del) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2203 | { |
| 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 Moolenaar | 03c3bd9 | 2020-01-23 20:58:09 +0100 | [diff] [blame] | 2210 | #ifdef FEAT_LINEBREAK |
| 2211 | int lbr_saved = curwin->w_p_lbr; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2212 | |
Bram Moolenaar | 03c3bd9 | 2020-01-23 20:58:09 +0100 | [diff] [blame] | 2213 | // Avoid a problem with unwanted linebreaks in block mode. |
| 2214 | curwin->w_p_lbr = FALSE; |
| 2215 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2216 | bdp->startspaces = 0; |
| 2217 | bdp->endspaces = 0; |
| 2218 | bdp->textlen = 0; |
| 2219 | bdp->start_vcol = 0; |
| 2220 | bdp->end_vcol = 0; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2221 | 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2226 | 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2233 | // Count a tab for what it's worth (if list mode not on) |
=?UTF-8?q?Dundar=20G=C3=B6c?= | 420fabc | 2022-01-28 15:28:04 +0000 | [diff] [blame] | 2234 | incr = lbr_chartabsize(line, pstart, bdp->start_vcol); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2235 | bdp->start_vcol += incr; |
Bram Moolenaar | 1c46544 | 2017-03-12 20:10:05 +0100 | [diff] [blame] | 2236 | if (VIM_ISWHITE(*pstart)) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2237 | { |
| 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2246 | prev_pstart = pstart; |
Bram Moolenaar | 91acfff | 2017-03-12 19:22:36 +0100 | [diff] [blame] | 2247 | MB_PTR_ADV(pstart); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2248 | } |
| 2249 | bdp->start_char_vcols = incr; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2250 | if (bdp->start_vcol < oap->start_vcol) // line too short |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2251 | { |
| 2252 | bdp->end_vcol = bdp->start_vcol; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2253 | bdp->is_short = TRUE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2254 | if (!is_del || oap->op_type == OP_APPEND) |
| 2255 | bdp->endspaces = oap->end_vcol - oap->start_vcol + 1; |
| 2256 | } |
| 2257 | else |
| 2258 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2259 | // notice: this converts partly selected Multibyte characters to |
| 2260 | // spaces, too. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2261 | 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2266 | if (bdp->end_vcol > oap->end_vcol) // it's all in one character |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2267 | { |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2268 | bdp->is_oneChar = TRUE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2269 | 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2281 | // 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2284 | 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2295 | // Count a tab for what it's worth (if list mode not on) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2296 | prev_pend = pend; |
=?UTF-8?q?Dundar=20G=C3=B6c?= | 420fabc | 2022-01-28 15:28:04 +0000 | [diff] [blame] | 2297 | incr = lbr_chartabsize_adv(line, &pend, bdp->end_vcol); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2298 | bdp->end_vcol += incr; |
| 2299 | } |
| 2300 | if (bdp->end_vcol <= oap->end_vcol |
| 2301 | && (!is_del |
| 2302 | || oap->op_type == OP_APPEND |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2303 | || oap->op_type == OP_REPLACE)) // line too short |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2304 | { |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2305 | bdp->is_short = TRUE; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2306 | // 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2310 | if (oap->op_type == OP_APPEND || virtual_op) |
| 2311 | bdp->endspaces = oap->end_vcol - bdp->end_vcol |
Bram Moolenaar | 2c7a29c | 2005-12-12 22:02:31 +0000 | [diff] [blame] | 2312 | + oap->inclusive; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2313 | else |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2314 | bdp->endspaces = 0; // replace doesn't add characters |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2315 | } |
| 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2327 | bdp->end_char_vcols = incr; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2328 | 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 Moolenaar | 03c3bd9 | 2020-01-23 20:58:09 +0100 | [diff] [blame] | 2334 | #ifdef FEAT_LINEBREAK |
| 2335 | curwin->w_p_lbr = lbr_saved; |
| 2336 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2337 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2338 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2339 | /* |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2340 | * Handle the add/subtract operator. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2341 | */ |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2342 | void |
Bram Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 2343 | op_addsub( |
| 2344 | oparg_T *oap, |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2345 | linenr_T Prenum1, // Amount of add/subtract |
| 2346 | int g_cmd) // was g<c-a>/g<c-x> |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2347 | { |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2348 | pos_T pos; |
| 2349 | struct block_def bd; |
| 2350 | int change_cnt = 0; |
| 2351 | linenr_T amount = Prenum1; |
| 2352 | |
Bram Moolenaar | 6b73188 | 2018-11-16 20:54:47 +0100 | [diff] [blame] | 2353 | // do_addsub() might trigger re-evaluation of 'foldexpr' halfway, when the |
Bram Moolenaar | bdace83 | 2019-03-02 10:13:42 +0100 | [diff] [blame] | 2354 | // buffer is not completely updated yet. Postpone updating folds until before |
Bram Moolenaar | 6b73188 | 2018-11-16 20:54:47 +0100 | [diff] [blame] | 2355 | // the call to changed_lines(). |
| 2356 | #ifdef FEAT_FOLDING |
| 2357 | disable_fold_update++; |
| 2358 | #endif |
| 2359 | |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2360 | if (!VIsual_active) |
| 2361 | { |
| 2362 | pos = curwin->w_cursor; |
| 2363 | if (u_save_cursor() == FAIL) |
Bram Moolenaar | 6b73188 | 2018-11-16 20:54:47 +0100 | [diff] [blame] | 2364 | { |
| 2365 | #ifdef FEAT_FOLDING |
| 2366 | disable_fold_update--; |
| 2367 | #endif |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2368 | return; |
Bram Moolenaar | 6b73188 | 2018-11-16 20:54:47 +0100 | [diff] [blame] | 2369 | } |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2370 | change_cnt = do_addsub(oap->op_type, &pos, 0, amount); |
Bram Moolenaar | 6b73188 | 2018-11-16 20:54:47 +0100 | [diff] [blame] | 2371 | #ifdef FEAT_FOLDING |
| 2372 | disable_fold_update--; |
| 2373 | #endif |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2374 | if (change_cnt) |
| 2375 | changed_lines(pos.lnum, 0, pos.lnum + 1, 0L); |
| 2376 | } |
| 2377 | else |
| 2378 | { |
Bram Moolenaar | 7ae4fbc | 2016-01-12 21:00:40 +0100 | [diff] [blame] | 2379 | int one_change; |
| 2380 | int length; |
| 2381 | pos_T startpos; |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2382 | |
| 2383 | if (u_save((linenr_T)(oap->start.lnum - 1), |
| 2384 | (linenr_T)(oap->end.lnum + 1)) == FAIL) |
Bram Moolenaar | 6b73188 | 2018-11-16 20:54:47 +0100 | [diff] [blame] | 2385 | { |
| 2386 | #ifdef FEAT_FOLDING |
| 2387 | disable_fold_update--; |
| 2388 | #endif |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2389 | return; |
Bram Moolenaar | 6b73188 | 2018-11-16 20:54:47 +0100 | [diff] [blame] | 2390 | } |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2391 | |
| 2392 | pos = oap->start; |
| 2393 | for (; pos.lnum <= oap->end.lnum; ++pos.lnum) |
| 2394 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2395 | if (oap->block_mode) // Visual block mode |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2396 | { |
| 2397 | block_prep(oap, &bd, pos.lnum, FALSE); |
| 2398 | pos.col = bd.textcol; |
| 2399 | length = bd.textlen; |
| 2400 | } |
Bram Moolenaar | 7ae4fbc | 2016-01-12 21:00:40 +0100 | [diff] [blame] | 2401 | else if (oap->motion_type == MLINE) |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2402 | { |
Bram Moolenaar | 7ae4fbc | 2016-01-12 21:00:40 +0100 | [diff] [blame] | 2403 | curwin->w_cursor.col = 0; |
| 2404 | pos.col = 0; |
| 2405 | length = (colnr_T)STRLEN(ml_get(pos.lnum)); |
| 2406 | } |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2407 | else // oap->motion_type == MCHAR |
Bram Moolenaar | 7ae4fbc | 2016-01-12 21:00:40 +0100 | [diff] [blame] | 2408 | { |
Bram Moolenaar | 5fe6bdf | 2017-12-05 17:22:12 +0100 | [diff] [blame] | 2409 | if (pos.lnum == oap->start.lnum && !oap->inclusive) |
Bram Moolenaar | 7ae4fbc | 2016-01-12 21:00:40 +0100 | [diff] [blame] | 2410 | dec(&(oap->end)); |
| 2411 | length = (colnr_T)STRLEN(ml_get(pos.lnum)); |
| 2412 | pos.col = 0; |
| 2413 | if (pos.lnum == oap->start.lnum) |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2414 | { |
Bram Moolenaar | 7ae4fbc | 2016-01-12 21:00:40 +0100 | [diff] [blame] | 2415 | pos.col += oap->start.col; |
| 2416 | length -= oap->start.col; |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2417 | } |
Bram Moolenaar | 7ae4fbc | 2016-01-12 21:00:40 +0100 | [diff] [blame] | 2418 | if (pos.lnum == oap->end.lnum) |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2419 | { |
Bram Moolenaar | 7ae4fbc | 2016-01-12 21:00:40 +0100 | [diff] [blame] | 2420 | 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 Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2424 | } |
| 2425 | } |
| 2426 | one_change = do_addsub(oap->op_type, &pos, length, amount); |
| 2427 | if (one_change) |
| 2428 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2429 | // Remember the start position of the first change. |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2430 | 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 Lakshmanan | 2ac7184 | 2021-05-31 19:23:01 +0200 | [diff] [blame] | 2438 | char_u *ptr; |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2439 | |
| 2440 | netbeans_removed(curbuf, pos.lnum, pos.col, (long)length); |
Yegappan Lakshmanan | 2ac7184 | 2021-05-31 19:23:01 +0200 | [diff] [blame] | 2441 | ptr = ml_get_buf(curbuf, pos.lnum, FALSE); |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2442 | 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 Moolenaar | 6b73188 | 2018-11-16 20:54:47 +0100 | [diff] [blame] | 2449 | |
| 2450 | #ifdef FEAT_FOLDING |
| 2451 | disable_fold_update--; |
| 2452 | #endif |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2453 | if (change_cnt) |
| 2454 | changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L); |
| 2455 | |
| 2456 | if (!change_cnt && oap->is_VIsual) |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2457 | // No change: need to remove the Visual selection |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2458 | redraw_curbuf_later(INVERTED); |
| 2459 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2460 | // Set '[ mark if something changed. Keep the last end |
| 2461 | // position from do_addsub(). |
Bram Moolenaar | e100440 | 2020-10-24 20:49:43 +0200 | [diff] [blame] | 2462 | if (change_cnt > 0 && (cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2463 | curbuf->b_op_start = startpos; |
| 2464 | |
| 2465 | if (change_cnt > p_report) |
Bram Moolenaar | db99f9f | 2020-03-23 22:12:22 +0100 | [diff] [blame] | 2466 | smsg(NGETTEXT("%d line changed", "%d lines changed", |
Bram Moolenaar | da6e891 | 2018-08-21 15:12:14 +0200 | [diff] [blame] | 2467 | change_cnt), change_cnt); |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2468 | } |
| 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 Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 2478 | do_addsub( |
| 2479 | int op_type, |
| 2480 | pos_T *pos, |
| 2481 | int length, |
| 2482 | linenr_T Prenum1) |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2483 | { |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2484 | int col; |
| 2485 | char_u *buf1; |
| 2486 | char_u buf2[NUMBUFLEN]; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2487 | int pre; // 'X'/'x': hex; '0': octal; 'B'/'b': bin |
| 2488 | static int hexupper = FALSE; // 0xABC |
Bram Moolenaar | 22fcfad | 2016-07-01 18:17:26 +0200 | [diff] [blame] | 2489 | uvarnumber_T n; |
| 2490 | uvarnumber_T oldn; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2491 | char_u *ptr; |
| 2492 | int c; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2493 | int todel; |
Bram Moolenaar | aaad995 | 2020-05-31 15:08:59 +0200 | [diff] [blame] | 2494 | int do_hex; |
| 2495 | int do_oct; |
| 2496 | int do_bin; |
| 2497 | int do_alpha; |
| 2498 | int do_unsigned; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2499 | int firstdigit; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2500 | int subtract; |
Bram Moolenaar | 3a304b2 | 2015-06-25 13:57:36 +0200 | [diff] [blame] | 2501 | int negative = FALSE; |
Bram Moolenaar | 9bb1930 | 2015-07-03 12:44:07 +0200 | [diff] [blame] | 2502 | int was_positive = TRUE; |
Bram Moolenaar | 3a304b2 | 2015-06-25 13:57:36 +0200 | [diff] [blame] | 2503 | int visual = VIsual_active; |
Bram Moolenaar | 3ec3261 | 2015-07-12 15:02:38 +0200 | [diff] [blame] | 2504 | int did_change = FALSE; |
Bram Moolenaar | 7ae4fbc | 2016-01-12 21:00:40 +0100 | [diff] [blame] | 2505 | pos_T save_cursor = curwin->w_cursor; |
Bram Moolenaar | 5d1bc78 | 2015-07-17 13:03:48 +0200 | [diff] [blame] | 2506 | int maxlen = 0; |
Bram Moolenaar | a52dfae | 2016-01-10 20:21:57 +0100 | [diff] [blame] | 2507 | pos_T startpos; |
| 2508 | pos_T endpos; |
Bram Moolenaar | 6c6be9e | 2020-06-12 20:19:44 +0200 | [diff] [blame] | 2509 | colnr_T save_coladd = 0; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2510 | |
Bram Moolenaar | aaad995 | 2020-05-31 15:08:59 +0200 | [diff] [blame] | 2511 | 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2516 | |
Bram Moolenaar | 6c6be9e | 2020-06-12 20:19:44 +0200 | [diff] [blame] | 2517 | if (virtual_active()) |
| 2518 | { |
| 2519 | save_coladd = pos->coladd; |
| 2520 | pos->coladd = 0; |
| 2521 | } |
| 2522 | |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2523 | curwin->w_cursor = *pos; |
| 2524 | ptr = ml_get(pos->lnum); |
| 2525 | col = pos->col; |
| 2526 | |
Bram Moolenaar | 6c6be9e | 2020-06-12 20:19:44 +0200 | [diff] [blame] | 2527 | if (*ptr == NUL || col + !!save_coladd >= (int)STRLEN(ptr)) |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2528 | goto theend; |
| 2529 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2530 | /* |
| 2531 | * First check if we are on a hexadecimal number, after the "0x". |
| 2532 | */ |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2533 | if (!VIsual_active) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2534 | { |
Bram Moolenaar | aaad995 | 2020-05-31 15:08:59 +0200 | [diff] [blame] | 2535 | if (do_bin) |
Bram Moolenaar | 887c1fe | 2016-01-02 17:56:35 +0100 | [diff] [blame] | 2536 | while (col > 0 && vim_isbdigit(ptr[col])) |
Bram Moolenaar | ad5ca9b | 2016-06-20 21:26:08 +0200 | [diff] [blame] | 2537 | { |
Bram Moolenaar | 887c1fe | 2016-01-02 17:56:35 +0100 | [diff] [blame] | 2538 | --col; |
Bram Moolenaar | ad5ca9b | 2016-06-20 21:26:08 +0200 | [diff] [blame] | 2539 | if (has_mbyte) |
| 2540 | col -= (*mb_head_off)(ptr, ptr + col); |
Bram Moolenaar | ad5ca9b | 2016-06-20 21:26:08 +0200 | [diff] [blame] | 2541 | } |
Bram Moolenaar | 887c1fe | 2016-01-02 17:56:35 +0100 | [diff] [blame] | 2542 | |
Bram Moolenaar | aaad995 | 2020-05-31 15:08:59 +0200 | [diff] [blame] | 2543 | if (do_hex) |
Bram Moolenaar | 3a304b2 | 2015-06-25 13:57:36 +0200 | [diff] [blame] | 2544 | while (col > 0 && vim_isxdigit(ptr[col])) |
Bram Moolenaar | ad5ca9b | 2016-06-20 21:26:08 +0200 | [diff] [blame] | 2545 | { |
Bram Moolenaar | 3a304b2 | 2015-06-25 13:57:36 +0200 | [diff] [blame] | 2546 | --col; |
Bram Moolenaar | ad5ca9b | 2016-06-20 21:26:08 +0200 | [diff] [blame] | 2547 | if (has_mbyte) |
| 2548 | col -= (*mb_head_off)(ptr, ptr + col); |
Bram Moolenaar | ad5ca9b | 2016-06-20 21:26:08 +0200 | [diff] [blame] | 2549 | } |
Bram Moolenaar | 887c1fe | 2016-01-02 17:56:35 +0100 | [diff] [blame] | 2550 | |
Bram Moolenaar | aaad995 | 2020-05-31 15:08:59 +0200 | [diff] [blame] | 2551 | if ( do_bin |
| 2552 | && do_hex |
Bram Moolenaar | 887c1fe | 2016-01-02 17:56:35 +0100 | [diff] [blame] | 2553 | && ! ((col > 0 |
| 2554 | && (ptr[col] == 'X' |
| 2555 | || ptr[col] == 'x') |
| 2556 | && ptr[col - 1] == '0' |
Bram Moolenaar | ad5ca9b | 2016-06-20 21:26:08 +0200 | [diff] [blame] | 2557 | && (!has_mbyte || |
| 2558 | !(*mb_head_off)(ptr, ptr + col - 1)) |
Bram Moolenaar | 887c1fe | 2016-01-02 17:56:35 +0100 | [diff] [blame] | 2559 | && vim_isxdigit(ptr[col + 1])))) |
| 2560 | { |
| 2561 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2562 | // In case of binary/hexadecimal pattern overlap match, rescan |
Bram Moolenaar | 887c1fe | 2016-01-02 17:56:35 +0100 | [diff] [blame] | 2563 | |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2564 | col = pos->col; |
Bram Moolenaar | 887c1fe | 2016-01-02 17:56:35 +0100 | [diff] [blame] | 2565 | |
| 2566 | while (col > 0 && vim_isdigit(ptr[col])) |
Bram Moolenaar | ad5ca9b | 2016-06-20 21:26:08 +0200 | [diff] [blame] | 2567 | { |
Bram Moolenaar | 887c1fe | 2016-01-02 17:56:35 +0100 | [diff] [blame] | 2568 | col--; |
Bram Moolenaar | ad5ca9b | 2016-06-20 21:26:08 +0200 | [diff] [blame] | 2569 | if (has_mbyte) |
| 2570 | col -= (*mb_head_off)(ptr, ptr + col); |
Bram Moolenaar | ad5ca9b | 2016-06-20 21:26:08 +0200 | [diff] [blame] | 2571 | } |
Bram Moolenaar | 887c1fe | 2016-01-02 17:56:35 +0100 | [diff] [blame] | 2572 | } |
| 2573 | |
Bram Moolenaar | aaad995 | 2020-05-31 15:08:59 +0200 | [diff] [blame] | 2574 | if (( do_hex |
Bram Moolenaar | 3a304b2 | 2015-06-25 13:57:36 +0200 | [diff] [blame] | 2575 | && col > 0 |
| 2576 | && (ptr[col] == 'X' |
| 2577 | || ptr[col] == 'x') |
| 2578 | && ptr[col - 1] == '0' |
Bram Moolenaar | ad5ca9b | 2016-06-20 21:26:08 +0200 | [diff] [blame] | 2579 | && (!has_mbyte || |
| 2580 | !(*mb_head_off)(ptr, ptr + col - 1)) |
Bram Moolenaar | 887c1fe | 2016-01-02 17:56:35 +0100 | [diff] [blame] | 2581 | && vim_isxdigit(ptr[col + 1])) || |
Bram Moolenaar | aaad995 | 2020-05-31 15:08:59 +0200 | [diff] [blame] | 2582 | ( do_bin |
Bram Moolenaar | 887c1fe | 2016-01-02 17:56:35 +0100 | [diff] [blame] | 2583 | && col > 0 |
| 2584 | && (ptr[col] == 'B' |
| 2585 | || ptr[col] == 'b') |
| 2586 | && ptr[col - 1] == '0' |
Bram Moolenaar | ad5ca9b | 2016-06-20 21:26:08 +0200 | [diff] [blame] | 2587 | && (!has_mbyte || |
| 2588 | !(*mb_head_off)(ptr, ptr + col - 1)) |
Bram Moolenaar | 887c1fe | 2016-01-02 17:56:35 +0100 | [diff] [blame] | 2589 | && vim_isbdigit(ptr[col + 1]))) |
Bram Moolenaar | 3a304b2 | 2015-06-25 13:57:36 +0200 | [diff] [blame] | 2590 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2591 | // Found hexadecimal or binary number, move to its start. |
Bram Moolenaar | 3a304b2 | 2015-06-25 13:57:36 +0200 | [diff] [blame] | 2592 | --col; |
Bram Moolenaar | ad5ca9b | 2016-06-20 21:26:08 +0200 | [diff] [blame] | 2593 | if (has_mbyte) |
| 2594 | col -= (*mb_head_off)(ptr, ptr + col); |
Bram Moolenaar | 3a304b2 | 2015-06-25 13:57:36 +0200 | [diff] [blame] | 2595 | } |
| 2596 | else |
| 2597 | { |
| 2598 | /* |
| 2599 | * Search forward and then backward to find the start of number. |
| 2600 | */ |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2601 | col = pos->col; |
Bram Moolenaar | 3a304b2 | 2015-06-25 13:57:36 +0200 | [diff] [blame] | 2602 | |
| 2603 | while (ptr[col] != NUL |
| 2604 | && !vim_isdigit(ptr[col]) |
Bram Moolenaar | aaad995 | 2020-05-31 15:08:59 +0200 | [diff] [blame] | 2605 | && !(do_alpha && ASCII_ISALPHA(ptr[col]))) |
Bram Moolenaar | 1614a14 | 2019-10-06 22:00:13 +0200 | [diff] [blame] | 2606 | col += mb_ptr2len(ptr + col); |
Bram Moolenaar | 3a304b2 | 2015-06-25 13:57:36 +0200 | [diff] [blame] | 2607 | |
| 2608 | while (col > 0 |
| 2609 | && vim_isdigit(ptr[col - 1]) |
Bram Moolenaar | aaad995 | 2020-05-31 15:08:59 +0200 | [diff] [blame] | 2610 | && !(do_alpha && ASCII_ISALPHA(ptr[col]))) |
Bram Moolenaar | ad5ca9b | 2016-06-20 21:26:08 +0200 | [diff] [blame] | 2611 | { |
Bram Moolenaar | 3a304b2 | 2015-06-25 13:57:36 +0200 | [diff] [blame] | 2612 | --col; |
Bram Moolenaar | ad5ca9b | 2016-06-20 21:26:08 +0200 | [diff] [blame] | 2613 | if (has_mbyte) |
| 2614 | col -= (*mb_head_off)(ptr, ptr + col); |
Bram Moolenaar | ad5ca9b | 2016-06-20 21:26:08 +0200 | [diff] [blame] | 2615 | } |
Bram Moolenaar | 3a304b2 | 2015-06-25 13:57:36 +0200 | [diff] [blame] | 2616 | } |
| 2617 | } |
| 2618 | |
Bram Moolenaar | 5d1bc78 | 2015-07-17 13:03:48 +0200 | [diff] [blame] | 2619 | if (visual) |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2620 | { |
| 2621 | while (ptr[col] != NUL && length > 0 |
| 2622 | && !vim_isdigit(ptr[col]) |
Bram Moolenaar | aaad995 | 2020-05-31 15:08:59 +0200 | [diff] [blame] | 2623 | && !(do_alpha && ASCII_ISALPHA(ptr[col]))) |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2624 | { |
Bram Moolenaar | 1614a14 | 2019-10-06 22:00:13 +0200 | [diff] [blame] | 2625 | int mb_len = mb_ptr2len(ptr + col); |
Bram Moolenaar | ad5ca9b | 2016-06-20 21:26:08 +0200 | [diff] [blame] | 2626 | |
| 2627 | col += mb_len; |
| 2628 | length -= mb_len; |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2629 | } |
| 2630 | |
| 2631 | if (length == 0) |
| 2632 | goto theend; |
| 2633 | |
Bram Moolenaar | ad5ca9b | 2016-06-20 21:26:08 +0200 | [diff] [blame] | 2634 | if (col > pos->col && ptr[col - 1] == '-' |
Bram Moolenaar | aaad995 | 2020-05-31 15:08:59 +0200 | [diff] [blame] | 2635 | && (!has_mbyte || !(*mb_head_off)(ptr, ptr + col - 1)) |
| 2636 | && !do_unsigned) |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2637 | { |
| 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 Moolenaar | aaad995 | 2020-05-31 15:08:59 +0200 | [diff] [blame] | 2647 | if (!VIM_ISDIGIT(firstdigit) && !(do_alpha && ASCII_ISALPHA(firstdigit))) |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2648 | { |
| 2649 | beep_flush(); |
| 2650 | goto theend; |
| 2651 | } |
| 2652 | |
Bram Moolenaar | aaad995 | 2020-05-31 15:08:59 +0200 | [diff] [blame] | 2653 | if (do_alpha && ASCII_ISALPHA(firstdigit)) |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2654 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2655 | // decrement or increment alphabetic character |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2656 | 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 Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2666 | firstdigit -= Prenum1; |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2667 | } |
| 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 Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2678 | firstdigit += Prenum1; |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2679 | } |
| 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 Moolenaar | c8f12c9 | 2020-09-15 20:34:10 +0200 | [diff] [blame] | 2691 | pos_T save_pos; |
| 2692 | int i; |
| 2693 | |
Bram Moolenaar | ad5ca9b | 2016-06-20 21:26:08 +0200 | [diff] [blame] | 2694 | if (col > 0 && ptr[col - 1] == '-' |
Bram Moolenaar | ad5ca9b | 2016-06-20 21:26:08 +0200 | [diff] [blame] | 2695 | && (!has_mbyte || |
| 2696 | !(*mb_head_off)(ptr, ptr + col - 1)) |
Bram Moolenaar | aaad995 | 2020-05-31 15:08:59 +0200 | [diff] [blame] | 2697 | && !visual |
| 2698 | && !do_unsigned) |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2699 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2700 | // negative number |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2701 | --col; |
| 2702 | negative = TRUE; |
| 2703 | } |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2704 | // get the number value (unsigned) |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2705 | 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 Moolenaar | aaad995 | 2020-05-31 15:08:59 +0200 | [diff] [blame] | 2711 | 0 + (do_bin ? STR2NR_BIN : 0) |
| 2712 | + (do_oct ? STR2NR_OCT : 0) |
| 2713 | + (do_hex ? STR2NR_HEX : 0), |
Bram Moolenaar | 16e9b85 | 2019-05-19 19:59:35 +0200 | [diff] [blame] | 2714 | NULL, &n, maxlen, FALSE); |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2715 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2716 | // ignore leading '-' for hex and octal and bin numbers |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2717 | if (pre && negative) |
| 2718 | { |
| 2719 | ++col; |
| 2720 | --length; |
| 2721 | negative = FALSE; |
| 2722 | } |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2723 | // add or subtract |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2724 | 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 Moolenaar | 22fcfad | 2016-07-01 18:17:26 +0200 | [diff] [blame] | 2732 | n -= (uvarnumber_T)Prenum1; |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2733 | else |
Bram Moolenaar | 22fcfad | 2016-07-01 18:17:26 +0200 | [diff] [blame] | 2734 | n += (uvarnumber_T)Prenum1; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2735 | // handle wraparound for decimal numbers |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2736 | if (!pre) |
| 2737 | { |
| 2738 | if (subtract) |
| 2739 | { |
| 2740 | if (n > oldn) |
| 2741 | { |
Bram Moolenaar | 22fcfad | 2016-07-01 18:17:26 +0200 | [diff] [blame] | 2742 | n = 1 + (n ^ (uvarnumber_T)-1); |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2743 | negative ^= TRUE; |
| 2744 | } |
| 2745 | } |
| 2746 | else |
| 2747 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2748 | // add |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2749 | if (n < oldn) |
| 2750 | { |
Bram Moolenaar | 22fcfad | 2016-07-01 18:17:26 +0200 | [diff] [blame] | 2751 | n = (n ^ (uvarnumber_T)-1); |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2752 | negative ^= TRUE; |
| 2753 | } |
| 2754 | } |
| 2755 | if (n == 0) |
| 2756 | negative = FALSE; |
| 2757 | } |
| 2758 | |
Bram Moolenaar | aaad995 | 2020-05-31 15:08:59 +0200 | [diff] [blame] | 2759 | 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 Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2770 | if (visual && !was_positive && !negative && col > 0) |
| 2771 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2772 | // need to remove the '-' |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2773 | 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 Moolenaar | c8f12c9 | 2020-09-15 20:34:10 +0200 | [diff] [blame] | 2792 | |
| 2793 | save_pos = curwin->w_cursor; |
| 2794 | for (i = 0; i < todel; ++i) |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2795 | { |
| 2796 | if (c < 0x100 && isalpha(c)) |
| 2797 | { |
| 2798 | if (isupper(c)) |
| 2799 | hexupper = TRUE; |
| 2800 | else |
| 2801 | hexupper = FALSE; |
| 2802 | } |
Bram Moolenaar | c8f12c9 | 2020-09-15 20:34:10 +0200 | [diff] [blame] | 2803 | inc_cursor(); |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2804 | c = gchar_cursor(); |
| 2805 | } |
Bram Moolenaar | c8f12c9 | 2020-09-15 20:34:10 +0200 | [diff] [blame] | 2806 | curwin->w_cursor = save_pos; |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2807 | |
| 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 Moolenaar | 964b374 | 2019-05-24 18:54:09 +0200 | [diff] [blame] | 2813 | buf1 = alloc(length + NUMBUFLEN); |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2814 | if (buf1 == NULL) |
| 2815 | goto theend; |
| 2816 | ptr = buf1; |
Bram Moolenaar | dc633cf | 2016-04-23 14:33:19 +0200 | [diff] [blame] | 2817 | if (negative && (!visual || was_positive)) |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2818 | *ptr++ = '-'; |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2819 | 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 Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2836 | int bit = 0; |
Bram Moolenaar | 22fcfad | 2016-07-01 18:17:26 +0200 | [diff] [blame] | 2837 | int bits = sizeof(uvarnumber_T) * 8; |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2838 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2839 | // leading zeros |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2840 | 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?= | 420fabc | 2022-01-28 15:28:04 +0000 | [diff] [blame] | 2849 | vim_snprintf((char *)buf2, NUMBUFLEN, "%llu", n); |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2850 | else if (pre == '0') |
=?UTF-8?q?Dundar=20G=C3=B6c?= | 420fabc | 2022-01-28 15:28:04 +0000 | [diff] [blame] | 2851 | vim_snprintf((char *)buf2, NUMBUFLEN, "%llo", n); |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2852 | else if (pre && hexupper) |
=?UTF-8?q?Dundar=20G=C3=B6c?= | 420fabc | 2022-01-28 15:28:04 +0000 | [diff] [blame] | 2853 | vim_snprintf((char *)buf2, NUMBUFLEN, "%llX", n); |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2854 | else |
=?UTF-8?q?Dundar=20G=C3=B6c?= | 420fabc | 2022-01-28 15:28:04 +0000 | [diff] [blame] | 2855 | vim_snprintf((char *)buf2, NUMBUFLEN, "%llx", n); |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2856 | 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 Moolenaar | aaad995 | 2020-05-31 15:08:59 +0200 | [diff] [blame] | 2864 | if (firstdigit == '0' && !(do_oct && pre == 0)) |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2865 | while (length-- > 0) |
| 2866 | *ptr++ = '0'; |
| 2867 | *ptr = NUL; |
Bram Moolenaar | c8f12c9 | 2020-09-15 20:34:10 +0200 | [diff] [blame] | 2868 | |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2869 | STRCAT(buf1, buf2); |
Bram Moolenaar | c8f12c9 | 2020-09-15 20:34:10 +0200 | [diff] [blame] | 2870 | |
| 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2877 | ins_str(buf1); // insert the new number |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2878 | vim_free(buf1); |
Bram Moolenaar | c8f12c9 | 2020-09-15 20:34:10 +0200 | [diff] [blame] | 2879 | |
| 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 Moolenaar | 573545a | 2020-09-16 15:46:08 +0200 | [diff] [blame] | 2889 | curwin->w_cursor.col = (colnr_T)(STRLEN(ml_get_curline()) |
| 2890 | - bytes_after); |
Bram Moolenaar | c8f12c9 | 2020-09-15 20:34:10 +0200 | [diff] [blame] | 2891 | --todel; |
| 2892 | } |
| 2893 | while (todel-- > 0) |
| 2894 | (void)del_char(FALSE); |
| 2895 | |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2896 | endpos = curwin->w_cursor; |
| 2897 | if (did_change && curwin->w_cursor.col) |
| 2898 | --curwin->w_cursor.col; |
| 2899 | } |
| 2900 | |
Bram Moolenaar | e100440 | 2020-10-24 20:49:43 +0200 | [diff] [blame] | 2901 | if (did_change && (cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) |
Bram Moolenaar | a52dfae | 2016-01-10 20:21:57 +0100 | [diff] [blame] | 2902 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2903 | // set the '[ and '] marks |
Bram Moolenaar | a52dfae | 2016-01-10 20:21:57 +0100 | [diff] [blame] | 2904 | 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 Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2909 | |
Bram Moolenaar | 7ae4fbc | 2016-01-12 21:00:40 +0100 | [diff] [blame] | 2910 | theend: |
| 2911 | if (visual) |
| 2912 | curwin->w_cursor = save_cursor; |
Bram Moolenaar | 8e08125 | 2016-03-21 23:13:32 +0100 | [diff] [blame] | 2913 | else if (did_change) |
| 2914 | curwin->w_set_curswant = TRUE; |
Bram Moolenaar | 6c6be9e | 2020-06-12 20:19:44 +0200 | [diff] [blame] | 2915 | else if (virtual_active()) |
| 2916 | curwin->w_cursor.coladd = save_coladd; |
Bram Moolenaar | 7ae4fbc | 2016-01-12 21:00:40 +0100 | [diff] [blame] | 2917 | |
Bram Moolenaar | d79e550 | 2016-01-10 22:13:02 +0100 | [diff] [blame] | 2918 | return did_change; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2919 | } |
| 2920 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2921 | void |
Bram Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 2922 | clear_oparg(oparg_T *oap) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2923 | { |
Bram Moolenaar | a80faa8 | 2020-04-12 19:37:17 +0200 | [diff] [blame] | 2924 | CLEAR_POINTER(oap); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2925 | } |
| 2926 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2927 | /* |
Bram Moolenaar | 7c62692 | 2005-02-07 22:01:03 +0000 | [diff] [blame] | 2928 | * Count the number of bytes, characters and "words" in a line. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2929 | * |
| 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 Moolenaar | 7c62692 | 2005-02-07 22:01:03 +0000 | [diff] [blame] | 2933 | * Return value is byte count; word count for the line is added to "*wc". |
| 2934 | * Char count is added to "*cc". |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2935 | * |
| 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 Moolenaar | 22fcfad | 2016-07-01 18:17:26 +0200 | [diff] [blame] | 2941 | static varnumber_T |
Bram Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 2942 | line_count_info( |
| 2943 | char_u *line, |
Bram Moolenaar | 22fcfad | 2016-07-01 18:17:26 +0200 | [diff] [blame] | 2944 | varnumber_T *wc, |
| 2945 | varnumber_T *cc, |
| 2946 | varnumber_T limit, |
Bram Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 2947 | int eol_size) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2948 | { |
Bram Moolenaar | 22fcfad | 2016-07-01 18:17:26 +0200 | [diff] [blame] | 2949 | varnumber_T i; |
| 2950 | varnumber_T words = 0; |
| 2951 | varnumber_T chars = 0; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2952 | int is_word = 0; |
| 2953 | |
Bram Moolenaar | 88b1ba1 | 2012-06-29 13:34:19 +0200 | [diff] [blame] | 2954 | for (i = 0; i < limit && line[i] != NUL; ) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2955 | { |
| 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 Moolenaar | 7c62692 | 2005-02-07 22:01:03 +0000 | [diff] [blame] | 2966 | ++chars; |
Bram Moolenaar | 0fa313a | 2005-08-10 21:07:57 +0000 | [diff] [blame] | 2967 | i += (*mb_ptr2len)(line + i); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2968 | } |
| 2969 | |
| 2970 | if (is_word) |
| 2971 | words++; |
| 2972 | *wc += words; |
| 2973 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 2974 | // Add eol_size if the end of line was reached before hitting limit. |
Bram Moolenaar | 1cb7e09 | 2011-08-10 12:11:01 +0200 | [diff] [blame] | 2975 | if (i < limit && line[i] == NUL) |
Bram Moolenaar | 7c62692 | 2005-02-07 22:01:03 +0000 | [diff] [blame] | 2976 | { |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2977 | i += eol_size; |
Bram Moolenaar | 7c62692 | 2005-02-07 22:01:03 +0000 | [diff] [blame] | 2978 | chars += eol_size; |
| 2979 | } |
| 2980 | *cc += chars; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2981 | 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 Moolenaar | ed767a2 | 2016-01-03 22:49:16 +0100 | [diff] [blame] | 2988 | * When "dict" is not NULL store the info there instead of showing it. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2989 | */ |
| 2990 | void |
Bram Moolenaar | 9b57814 | 2016-01-30 19:39:49 +0100 | [diff] [blame] | 2991 | cursor_pos_info(dict_T *dict) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2992 | { |
| 2993 | char_u *p; |
Bram Moolenaar | 555b280 | 2005-05-19 21:08:39 +0000 | [diff] [blame] | 2994 | char_u buf1[50]; |
| 2995 | char_u buf2[40]; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2996 | linenr_T lnum; |
Bram Moolenaar | 22fcfad | 2016-07-01 18:17:26 +0200 | [diff] [blame] | 2997 | varnumber_T byte_count = 0; |
Bram Moolenaar | 22fcfad | 2016-07-01 18:17:26 +0200 | [diff] [blame] | 2998 | varnumber_T bom_count = 0; |
Bram Moolenaar | 22fcfad | 2016-07-01 18:17:26 +0200 | [diff] [blame] | 2999 | 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 Moolenaar | 7c62692 | 2005-02-07 22:01:03 +0000 | [diff] [blame] | 3004 | int eol_size; |
Bram Moolenaar | 22fcfad | 2016-07-01 18:17:26 +0200 | [diff] [blame] | 3005 | varnumber_T last_check = 100000L; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3006 | long line_count_selected = 0; |
| 3007 | pos_T min_pos, max_pos; |
| 3008 | oparg_T oparg; |
| 3009 | struct block_def bd; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3010 | |
| 3011 | /* |
| 3012 | * Compute the length of the file in characters. |
| 3013 | */ |
| 3014 | if (curbuf->b_ml.ml_flags & ML_EMPTY) |
| 3015 | { |
Bram Moolenaar | ed767a2 | 2016-01-03 22:49:16 +0100 | [diff] [blame] | 3016 | if (dict == NULL) |
| 3017 | { |
Bram Moolenaar | 32526b3 | 2019-01-19 17:43:09 +0100 | [diff] [blame] | 3018 | msg(_(no_lines_msg)); |
Bram Moolenaar | ed767a2 | 2016-01-03 22:49:16 +0100 | [diff] [blame] | 3019 | return; |
| 3020 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3021 | } |
| 3022 | else |
| 3023 | { |
| 3024 | if (get_fileformat(curbuf) == EOL_DOS) |
| 3025 | eol_size = 2; |
| 3026 | else |
| 3027 | eol_size = 1; |
| 3028 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3029 | if (VIsual_active) |
| 3030 | { |
Bram Moolenaar | b5aedf3 | 2017-03-12 18:23:53 +0100 | [diff] [blame] | 3031 | if (LT_POS(VIsual, curwin->w_cursor)) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3032 | { |
| 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 Moolenaar | 81d0007 | 2009-04-29 15:41:40 +0000 | [diff] [blame] | 3046 | #ifdef FEAT_LINEBREAK |
| 3047 | char_u * saved_sbr = p_sbr; |
Bram Moolenaar | ee85702 | 2019-11-09 23:26:40 +0100 | [diff] [blame] | 3048 | char_u * saved_w_sbr = curwin->w_p_sbr; |
Bram Moolenaar | 81d0007 | 2009-04-29 15:41:40 +0000 | [diff] [blame] | 3049 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 3050 | // Make 'sbr' empty for a moment to get the correct size. |
Bram Moolenaar | 81d0007 | 2009-04-29 15:41:40 +0000 | [diff] [blame] | 3051 | p_sbr = empty_option; |
Bram Moolenaar | ee85702 | 2019-11-09 23:26:40 +0100 | [diff] [blame] | 3052 | curwin->w_p_sbr = empty_option; |
Bram Moolenaar | 81d0007 | 2009-04-29 15:41:40 +0000 | [diff] [blame] | 3053 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3054 | oparg.is_VIsual = 1; |
| 3055 | oparg.block_mode = TRUE; |
| 3056 | oparg.op_type = OP_NOP; |
| 3057 | getvcols(curwin, &min_pos, &max_pos, |
Bram Moolenaar | 5c8837f | 2006-02-25 21:52:33 +0000 | [diff] [blame] | 3058 | &oparg.start_vcol, &oparg.end_vcol); |
Bram Moolenaar | 81d0007 | 2009-04-29 15:41:40 +0000 | [diff] [blame] | 3059 | #ifdef FEAT_LINEBREAK |
| 3060 | p_sbr = saved_sbr; |
Bram Moolenaar | ee85702 | 2019-11-09 23:26:40 +0100 | [diff] [blame] | 3061 | curwin->w_p_sbr = saved_w_sbr; |
Bram Moolenaar | 81d0007 | 2009-04-29 15:41:40 +0000 | [diff] [blame] | 3062 | #endif |
Bram Moolenaar | 5c8837f | 2006-02-25 21:52:33 +0000 | [diff] [blame] | 3063 | if (curwin->w_curswant == MAXCOL) |
| 3064 | oparg.end_vcol = MAXCOL; |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 3065 | // Swap the start, end vcol if needed |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3066 | 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3075 | |
| 3076 | for (lnum = 1; lnum <= curbuf->b_ml.ml_line_count; ++lnum) |
| 3077 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 3078 | // Check for a CTRL-C every 100000 characters. |
Bram Moolenaar | 7c62692 | 2005-02-07 22:01:03 +0000 | [diff] [blame] | 3079 | if (byte_count > last_check) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3080 | { |
| 3081 | ui_breakcheck(); |
| 3082 | if (got_int) |
| 3083 | return; |
Bram Moolenaar | 7c62692 | 2005-02-07 22:01:03 +0000 | [diff] [blame] | 3084 | last_check = byte_count + 100000L; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3085 | } |
| 3086 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 3087 | // Do extra processing for VIsual mode. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3088 | if (VIsual_active |
| 3089 | && lnum >= min_pos.lnum && lnum <= max_pos.lnum) |
| 3090 | { |
Bram Moolenaar | def9e82 | 2004-12-31 20:58:58 +0000 | [diff] [blame] | 3091 | char_u *s = NULL; |
| 3092 | long len = 0L; |
| 3093 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3094 | switch (VIsual_mode) |
| 3095 | { |
| 3096 | case Ctrl_V: |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3097 | virtual_op = virtual_active(); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3098 | block_prep(&oparg, &bd, lnum, 0); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3099 | virtual_op = MAYBE; |
Bram Moolenaar | def9e82 | 2004-12-31 20:58:58 +0000 | [diff] [blame] | 3100 | s = bd.textstart; |
| 3101 | len = (long)bd.textlen; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3102 | break; |
| 3103 | case 'V': |
Bram Moolenaar | def9e82 | 2004-12-31 20:58:58 +0000 | [diff] [blame] | 3104 | s = ml_get(lnum); |
| 3105 | len = MAXCOL; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3106 | 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 Moolenaar | def9e82 | 2004-12-31 20:58:58 +0000 | [diff] [blame] | 3114 | s = ml_get(lnum) + start_col; |
| 3115 | len = end_col; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3116 | } |
| 3117 | break; |
| 3118 | } |
Bram Moolenaar | def9e82 | 2004-12-31 20:58:58 +0000 | [diff] [blame] | 3119 | if (s != NULL) |
| 3120 | { |
Bram Moolenaar | 7c62692 | 2005-02-07 22:01:03 +0000 | [diff] [blame] | 3121 | byte_count_cursor += line_count_info(s, &word_count_cursor, |
| 3122 | &char_count_cursor, len, eol_size); |
Bram Moolenaar | def9e82 | 2004-12-31 20:58:58 +0000 | [diff] [blame] | 3123 | if (lnum == curbuf->b_ml.ml_line_count |
| 3124 | && !curbuf->b_p_eol |
Bram Moolenaar | 34d72d4 | 2015-07-17 14:18:08 +0200 | [diff] [blame] | 3125 | && (curbuf->b_p_bin || !curbuf->b_p_fixeol) |
Bram Moolenaar | ec2dad6 | 2005-01-02 11:36:03 +0000 | [diff] [blame] | 3126 | && (long)STRLEN(s) < len) |
Bram Moolenaar | 7c62692 | 2005-02-07 22:01:03 +0000 | [diff] [blame] | 3127 | byte_count_cursor -= eol_size; |
Bram Moolenaar | def9e82 | 2004-12-31 20:58:58 +0000 | [diff] [blame] | 3128 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3129 | } |
| 3130 | else |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3131 | { |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 3132 | // In non-visual mode, check for the line the cursor is on |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3133 | if (lnum == curwin->w_cursor.lnum) |
| 3134 | { |
| 3135 | word_count_cursor += word_count; |
Bram Moolenaar | 7c62692 | 2005-02-07 22:01:03 +0000 | [diff] [blame] | 3136 | 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 Moolenaar | 22fcfad | 2016-07-01 18:17:26 +0200 | [diff] [blame] | 3140 | (varnumber_T)(curwin->w_cursor.col + 1), |
| 3141 | eol_size); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3142 | } |
| 3143 | } |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 3144 | // Add to the running totals |
Bram Moolenaar | 7c62692 | 2005-02-07 22:01:03 +0000 | [diff] [blame] | 3145 | byte_count += line_count_info(ml_get(lnum), &word_count, |
Bram Moolenaar | 22fcfad | 2016-07-01 18:17:26 +0200 | [diff] [blame] | 3146 | &char_count, (varnumber_T)MAXCOL, |
| 3147 | eol_size); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3148 | } |
| 3149 | |
Bram Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 3150 | // Correction for when last line doesn't have an EOL. |
Bram Moolenaar | 34d72d4 | 2015-07-17 14:18:08 +0200 | [diff] [blame] | 3151 | if (!curbuf->b_p_eol && (curbuf->b_p_bin || !curbuf->b_p_fixeol)) |
Bram Moolenaar | 7c62692 | 2005-02-07 22:01:03 +0000 | [diff] [blame] | 3152 | byte_count -= eol_size; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3153 | |
Bram Moolenaar | ed767a2 | 2016-01-03 22:49:16 +0100 | [diff] [blame] | 3154 | if (dict == NULL) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3155 | { |
Bram Moolenaar | ed767a2 | 2016-01-03 22:49:16 +0100 | [diff] [blame] | 3156 | if (VIsual_active) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3157 | { |
Bram Moolenaar | ed767a2 | 2016-01-03 22:49:16 +0100 | [diff] [blame] | 3158 | 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 Moolenaar | 22fcfad | 2016-07-01 18:17:26 +0200 | [diff] [blame] | 3171 | _("Selected %s%ld of %ld Lines; %lld of %lld Words; %lld of %lld Bytes"), |
Bram Moolenaar | ed767a2 | 2016-01-03 22:49:16 +0100 | [diff] [blame] | 3172 | buf1, line_count_selected, |
| 3173 | (long)curbuf->b_ml.ml_line_count, |
=?UTF-8?q?Dundar=20G=C3=B6c?= | 420fabc | 2022-01-28 15:28:04 +0000 | [diff] [blame] | 3174 | word_count_cursor, |
| 3175 | word_count, |
| 3176 | byte_count_cursor, |
| 3177 | byte_count); |
Bram Moolenaar | ed767a2 | 2016-01-03 22:49:16 +0100 | [diff] [blame] | 3178 | else |
| 3179 | vim_snprintf((char *)IObuff, IOSIZE, |
Bram Moolenaar | 22fcfad | 2016-07-01 18:17:26 +0200 | [diff] [blame] | 3180 | _("Selected %s%ld of %ld Lines; %lld of %lld Words; %lld of %lld Chars; %lld of %lld Bytes"), |
Bram Moolenaar | ed767a2 | 2016-01-03 22:49:16 +0100 | [diff] [blame] | 3181 | buf1, line_count_selected, |
| 3182 | (long)curbuf->b_ml.ml_line_count, |
=?UTF-8?q?Dundar=20G=C3=B6c?= | 420fabc | 2022-01-28 15:28:04 +0000 | [diff] [blame] | 3183 | word_count_cursor, |
| 3184 | word_count, |
| 3185 | char_count_cursor, |
| 3186 | char_count, |
| 3187 | byte_count_cursor, |
| 3188 | byte_count); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3189 | } |
| 3190 | else |
Bram Moolenaar | ed767a2 | 2016-01-03 22:49:16 +0100 | [diff] [blame] | 3191 | { |
| 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3198 | |
Bram Moolenaar | ed767a2 | 2016-01-03 22:49:16 +0100 | [diff] [blame] | 3199 | if (char_count_cursor == byte_count_cursor |
| 3200 | && char_count == byte_count) |
| 3201 | vim_snprintf((char *)IObuff, IOSIZE, |
Bram Moolenaar | 22fcfad | 2016-07-01 18:17:26 +0200 | [diff] [blame] | 3202 | _("Col %s of %s; Line %ld of %ld; Word %lld of %lld; Byte %lld of %lld"), |
Bram Moolenaar | ed767a2 | 2016-01-03 22:49:16 +0100 | [diff] [blame] | 3203 | (char *)buf1, (char *)buf2, |
| 3204 | (long)curwin->w_cursor.lnum, |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3205 | (long)curbuf->b_ml.ml_line_count, |
=?UTF-8?q?Dundar=20G=C3=B6c?= | 420fabc | 2022-01-28 15:28:04 +0000 | [diff] [blame] | 3206 | word_count_cursor, word_count, |
| 3207 | byte_count_cursor, byte_count); |
Bram Moolenaar | ed767a2 | 2016-01-03 22:49:16 +0100 | [diff] [blame] | 3208 | else |
| 3209 | vim_snprintf((char *)IObuff, IOSIZE, |
Bram Moolenaar | 22fcfad | 2016-07-01 18:17:26 +0200 | [diff] [blame] | 3210 | _("Col %s of %s; Line %ld of %ld; Word %lld of %lld; Char %lld of %lld; Byte %lld of %lld"), |
Bram Moolenaar | ed767a2 | 2016-01-03 22:49:16 +0100 | [diff] [blame] | 3211 | (char *)buf1, (char *)buf2, |
| 3212 | (long)curwin->w_cursor.lnum, |
Bram Moolenaar | 7c62692 | 2005-02-07 22:01:03 +0000 | [diff] [blame] | 3213 | (long)curbuf->b_ml.ml_line_count, |
=?UTF-8?q?Dundar=20G=C3=B6c?= | 420fabc | 2022-01-28 15:28:04 +0000 | [diff] [blame] | 3214 | word_count_cursor, word_count, |
| 3215 | char_count_cursor, char_count, |
| 3216 | byte_count_cursor, byte_count); |
Bram Moolenaar | ed767a2 | 2016-01-03 22:49:16 +0100 | [diff] [blame] | 3217 | } |
| 3218 | } |
| 3219 | |
Bram Moolenaar | ed767a2 | 2016-01-03 22:49:16 +0100 | [diff] [blame] | 3220 | bom_count = bomb_size(); |
Bram Moolenaar | dbec749 | 2019-09-13 22:16:21 +0200 | [diff] [blame] | 3221 | if (dict == NULL && bom_count > 0) |
Bram Moolenaar | 08b28b7 | 2019-12-30 20:42:39 +0100 | [diff] [blame] | 3222 | { |
| 3223 | size_t len = STRLEN(IObuff); |
| 3224 | |
| 3225 | vim_snprintf((char *)IObuff + len, IOSIZE - len, |
=?UTF-8?q?Dundar=20G=C3=B6c?= | 420fabc | 2022-01-28 15:28:04 +0000 | [diff] [blame] | 3226 | _("(+%lld for BOM)"), bom_count); |
Bram Moolenaar | 08b28b7 | 2019-12-30 20:42:39 +0100 | [diff] [blame] | 3227 | } |
Bram Moolenaar | ed767a2 | 2016-01-03 22:49:16 +0100 | [diff] [blame] | 3228 | if (dict == NULL) |
| 3229 | { |
Bram Moolenaar | dbec749 | 2019-09-13 22:16:21 +0200 | [diff] [blame] | 3230 | // Don't shorten this message, the user asked for it. |
Bram Moolenaar | ed767a2 | 2016-01-03 22:49:16 +0100 | [diff] [blame] | 3231 | p = p_shm; |
| 3232 | p_shm = (char_u *)""; |
Bram Moolenaar | 32526b3 | 2019-01-19 17:43:09 +0100 | [diff] [blame] | 3233 | msg((char *)IObuff); |
Bram Moolenaar | ed767a2 | 2016-01-03 22:49:16 +0100 | [diff] [blame] | 3234 | p_shm = p; |
| 3235 | } |
| 3236 | } |
Bram Moolenaar | 718272a | 2016-01-03 22:56:45 +0100 | [diff] [blame] | 3237 | #if defined(FEAT_EVAL) |
Bram Moolenaar | ed767a2 | 2016-01-03 22:49:16 +0100 | [diff] [blame] | 3238 | if (dict != NULL) |
| 3239 | { |
Bram Moolenaar | e0be167 | 2018-07-08 16:50:37 +0200 | [diff] [blame] | 3240 | dict_add_number(dict, "words", word_count); |
| 3241 | dict_add_number(dict, "chars", char_count); |
Bram Moolenaar | fc3abf4 | 2019-01-24 15:54:21 +0100 | [diff] [blame] | 3242 | dict_add_number(dict, "bytes", byte_count + bom_count); |
Bram Moolenaar | e0be167 | 2018-07-08 16:50:37 +0200 | [diff] [blame] | 3243 | 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3249 | } |
Bram Moolenaar | 718272a | 2016-01-03 22:56:45 +0100 | [diff] [blame] | 3250 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3251 | } |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3252 | |
| 3253 | /* |
| 3254 | * Handle indent and format operators and visual mode ":". |
| 3255 | */ |
| 3256 | static void |
| 3257 | op_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 Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3289 | if (*get_equalprg() == NUL) |
| 3290 | stuffReadbuff((char_u *)"indent"); |
| 3291 | else |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3292 | 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 Lakshmanan | 777175b | 2021-11-18 22:08:57 +0000 | [diff] [blame] | 3309 | // callback function for 'operatorfunc' |
| 3310 | static callback_T opfunc_cb; |
| 3311 | |
| 3312 | /* |
| 3313 | * Process the 'operatorfunc' option value. |
| 3314 | * Returns OK or FAIL. |
| 3315 | */ |
| 3316 | int |
| 3317 | set_operatorfunc_option(void) |
| 3318 | { |
| 3319 | return option_set_callback_func(p_opfunc, &opfunc_cb); |
| 3320 | } |
| 3321 | |
| 3322 | #if defined(EXITFREE) || defined(PROTO) |
| 3323 | void |
| 3324 | free_operatorfunc_option(void) |
| 3325 | { |
Yegappan Lakshmanan | 6ae8fae | 2021-12-12 16:26:44 +0000 | [diff] [blame] | 3326 | # ifdef FEAT_EVAL |
Yegappan Lakshmanan | 777175b | 2021-11-18 22:08:57 +0000 | [diff] [blame] | 3327 | free_callback(&opfunc_cb); |
Yegappan Lakshmanan | 6ae8fae | 2021-12-12 16:26:44 +0000 | [diff] [blame] | 3328 | # endif |
Yegappan Lakshmanan | 777175b | 2021-11-18 22:08:57 +0000 | [diff] [blame] | 3329 | } |
| 3330 | #endif |
| 3331 | |
Dominique Pelle | 748b308 | 2022-01-08 12:41:16 +0000 | [diff] [blame] | 3332 | #if defined(FEAT_EVAL) || defined(PROTO) |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3333 | /* |
Yegappan Lakshmanan | 6ae8fae | 2021-12-12 16:26:44 +0000 | [diff] [blame] | 3334 | * Mark the global 'operatorfunc' callback with 'copyID' so that it is not |
| 3335 | * garbage collected. |
| 3336 | */ |
| 3337 | int |
| 3338 | set_ref_in_opfunc(int copyID UNUSED) |
| 3339 | { |
| 3340 | int abort = FALSE; |
| 3341 | |
Yegappan Lakshmanan | 6ae8fae | 2021-12-12 16:26:44 +0000 | [diff] [blame] | 3342 | abort = set_ref_in_callback(&opfunc_cb, copyID); |
Yegappan Lakshmanan | 6ae8fae | 2021-12-12 16:26:44 +0000 | [diff] [blame] | 3343 | |
| 3344 | return abort; |
| 3345 | } |
Dominique Pelle | 748b308 | 2022-01-08 12:41:16 +0000 | [diff] [blame] | 3346 | #endif |
Yegappan Lakshmanan | 6ae8fae | 2021-12-12 16:26:44 +0000 | [diff] [blame] | 3347 | |
| 3348 | /* |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3349 | * Handle the "g@" operator: call 'operatorfunc'. |
| 3350 | */ |
| 3351 | static void |
| 3352 | op_function(oparg_T *oap UNUSED) |
| 3353 | { |
| 3354 | #ifdef FEAT_EVAL |
| 3355 | typval_T argv[2]; |
| 3356 | int save_virtual_op = virtual_op; |
naohiro ono | 75c30e9 | 2021-10-19 11:15:41 +0100 | [diff] [blame] | 3357 | int save_finish_op = finish_op; |
Bram Moolenaar | f4a1d1c | 2019-11-16 13:50:25 +0100 | [diff] [blame] | 3358 | pos_T orig_start = curbuf->b_op_start; |
| 3359 | pos_T orig_end = curbuf->b_op_end; |
Yegappan Lakshmanan | 777175b | 2021-11-18 22:08:57 +0000 | [diff] [blame] | 3360 | typval_T rettv; |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3361 | |
| 3362 | if (*p_opfunc == NUL) |
Bram Moolenaar | 677658a | 2022-01-05 16:09:06 +0000 | [diff] [blame] | 3363 | emsg(_(e_operatorfunc_is_empty)); |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3364 | 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 ono | 75c30e9 | 2021-10-19 11:15:41 +0100 | [diff] [blame] | 3386 | // Reset finish_op so that mode() returns the right value. |
| 3387 | finish_op = FALSE; |
| 3388 | |
Yegappan Lakshmanan | 777175b | 2021-11-18 22:08:57 +0000 | [diff] [blame] | 3389 | if (call_callback(&opfunc_cb, 0, &rettv, 1, argv) != FAIL) |
| 3390 | clear_tv(&rettv); |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3391 | |
| 3392 | virtual_op = save_virtual_op; |
naohiro ono | 75c30e9 | 2021-10-19 11:15:41 +0100 | [diff] [blame] | 3393 | finish_op = save_finish_op; |
Bram Moolenaar | e100440 | 2020-10-24 20:49:43 +0200 | [diff] [blame] | 3394 | if (cmdmod.cmod_flags & CMOD_LOCKMARKS) |
Bram Moolenaar | f4a1d1c | 2019-11-16 13:50:25 +0100 | [diff] [blame] | 3395 | { |
| 3396 | curbuf->b_op_start = orig_start; |
| 3397 | curbuf->b_op_end = orig_end; |
| 3398 | } |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3399 | } |
| 3400 | #else |
Bram Moolenaar | 677658a | 2022-01-05 16:09:06 +0000 | [diff] [blame] | 3401 | emsg(_(e_eval_feature_not_available)); |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3402 | #endif |
| 3403 | } |
| 3404 | |
| 3405 | /* |
| 3406 | * Calculate start/end virtual columns for operating in block mode. |
| 3407 | */ |
| 3408 | static void |
| 3409 | get_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 Moolenaar | b3bd1d3 | 2022-01-02 13:05:45 +0000 | [diff] [blame] | 3474 | // Information for redoing the previous Visual selection. |
| 3475 | typedef 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 Moolenaar | e32c3c4 | 2022-01-15 18:26:04 +0000 | [diff] [blame] | 3483 | static int |
| 3484 | is_ex_cmdchar(cmdarg_T *cap) |
| 3485 | { |
| 3486 | return cap->cmdchar == ':' |
| 3487 | || cap->cmdchar == K_COMMAND |
| 3488 | || cap->cmdchar == K_SCRIPT_COMMAND; |
| 3489 | } |
| 3490 | |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3491 | /* |
| 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 |
| 3496 | do_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 Moolenaar | b3bd1d3 | 2022-01-02 13:05:45 +0000 | [diff] [blame] | 3507 | static redo_VIsual_T redo_VIsual = {NUL, 0, 0, 0,0}; |
| 3508 | |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3509 | 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 Moolenaar | c77534c | 2020-11-18 11:34:37 +0100 | [diff] [blame] | 3572 | || (VIsual_active |
Bram Moolenaar | e32c3c4 | 2022-01-15 18:26:04 +0000 | [diff] [blame] | 3573 | && is_ex_cmdchar(cap) && oap->op_type != OP_COLON)) |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3574 | && 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 Moolenaar | e32c3c4 | 2022-01-15 18:26:04 +0000 | [diff] [blame] | 3597 | else if (is_ex_cmdchar(cap)) |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3598 | { |
| 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 Moolenaar | b3bd1d3 | 2022-01-02 13:05:45 +0000 | [diff] [blame] | 3616 | // redo_VIsual.rv_line_count and redo_VIsual.rv_vcol. |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3617 | oap->start = curwin->w_cursor; |
Bram Moolenaar | b3bd1d3 | 2022-01-02 13:05:45 +0000 | [diff] [blame] | 3618 | curwin->w_cursor.lnum += redo_VIsual.rv_line_count - 1; |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3619 | if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count) |
| 3620 | curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count; |
Bram Moolenaar | b3bd1d3 | 2022-01-02 13:05:45 +0000 | [diff] [blame] | 3621 | VIsual_mode = redo_VIsual.rv_mode; |
| 3622 | if (redo_VIsual.rv_vcol == MAXCOL || VIsual_mode == 'v') |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3623 | { |
| 3624 | if (VIsual_mode == 'v') |
| 3625 | { |
Bram Moolenaar | b3bd1d3 | 2022-01-02 13:05:45 +0000 | [diff] [blame] | 3626 | if (redo_VIsual.rv_line_count <= 1) |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3627 | { |
| 3628 | validate_virtcol(); |
| 3629 | curwin->w_curswant = |
Bram Moolenaar | b3bd1d3 | 2022-01-02 13:05:45 +0000 | [diff] [blame] | 3630 | curwin->w_virtcol + redo_VIsual.rv_vcol - 1; |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3631 | } |
| 3632 | else |
Bram Moolenaar | b3bd1d3 | 2022-01-02 13:05:45 +0000 | [diff] [blame] | 3633 | curwin->w_curswant = redo_VIsual.rv_vcol; |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3634 | } |
| 3635 | else |
| 3636 | { |
| 3637 | curwin->w_curswant = MAXCOL; |
| 3638 | } |
| 3639 | coladvance(curwin->w_curswant); |
| 3640 | } |
Bram Moolenaar | b3bd1d3 | 2022-01-02 13:05:45 +0000 | [diff] [blame] | 3641 | cap->count0 = redo_VIsual.rv_count; |
| 3642 | if (redo_VIsual.rv_count != 0) |
| 3643 | cap->count1 = redo_VIsual.rv_count; |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3644 | 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.Takata | 6e1d31e | 2022-02-03 13:05:32 +0000 | [diff] [blame] | 3657 | #ifdef FEAT_EVAL |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3658 | curbuf->b_visual_mode_eval = VIsual_mode; |
K.Takata | 6e1d31e | 2022-02-03 13:05:32 +0000 | [diff] [blame] | 3659 | #endif |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3660 | } |
| 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 Moolenaar | 3b68123 | 2019-12-13 19:35:55 +0100 | [diff] [blame] | 3704 | if ((curwin->w_cursor.col > 0 || oap->inclusive |
| 3705 | || oap->motion_type == MLINE) |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3706 | && 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 Moolenaar | b3bd1d3 | 2022-01-02 13:05:45 +0000 | [diff] [blame] | 3745 | get_op_vcol(oap, redo_VIsual.rv_vcol, TRUE); |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3746 | |
| 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 Moolenaar | 6e0ce17 | 2019-12-05 20:12:41 +0100 | [diff] [blame] | 3792 | get_op_char(oap->op_type), |
| 3793 | get_extra_op_char(oap->op_type), |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3794 | oap->motion_force, cap->cmdchar, cap->nchar); |
Bram Moolenaar | e32c3c4 | 2022-01-15 18:26:04 +0000 | [diff] [blame] | 3795 | else if (!is_ex_cmdchar(cap)) |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3796 | { |
Bram Moolenaar | 2228cd7 | 2021-11-22 14:16:08 +0000 | [diff] [blame] | 3797 | int opchar = get_op_char(oap->op_type); |
| 3798 | int extra_opchar = get_extra_op_char(oap->op_type); |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3799 | 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 Moolenaar | 2228cd7 | 2021-11-22 14:16:08 +0000 | [diff] [blame] | 3806 | |
| 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 Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3814 | } |
| 3815 | if (!redo_VIsual_busy) |
| 3816 | { |
Bram Moolenaar | b3bd1d3 | 2022-01-02 13:05:45 +0000 | [diff] [blame] | 3817 | 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 Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3822 | } |
| 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 Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3863 | setmouse(); |
| 3864 | mouse_dragging = 0; |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3865 | 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 Moolenaar | 5546688 | 2020-11-21 14:16:22 +0100 | [diff] [blame] | 3983 | // 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 Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 3987 | } |
| 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 Brabandt | 544a38e | 2021-06-10 19:39:11 +0200 | [diff] [blame] | 4004 | oap->excl_tr_ws = cap->cmdchar == 'z'; |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 4005 | (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 Moolenaar | 03c3bd9 | 2020-01-23 20:58:09 +0100 | [diff] [blame] | 4031 | curwin->w_p_lbr = lbr_saved; |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 4032 | #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 Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 4052 | // If 'equalprg' is empty, do the indenting internally. |
| 4053 | if (oap->op_type == OP_INDENT && *get_equalprg() == NUL) |
| 4054 | { |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 4055 | if (curbuf->b_p_lisp) |
| 4056 | { |
| 4057 | op_reindent(oap, get_lisp_indent); |
| 4058 | break; |
| 4059 | } |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 4060 | op_reindent(oap, |
Bram Moolenaar | 8e145b8 | 2022-05-21 20:17:31 +0100 | [diff] [blame] | 4061 | #ifdef FEAT_EVAL |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 4062 | *curbuf->b_p_inde != NUL ? get_expr_indent : |
Bram Moolenaar | 8e145b8 | 2022-05-21 20:17:31 +0100 | [diff] [blame] | 4063 | #endif |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 4064 | get_c_indent); |
| 4065 | break; |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 4066 | } |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 4067 | |
| 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 Pelle | 4781d6f | 2021-05-18 21:46:31 +0200 | [diff] [blame] | 4091 | { |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 4092 | if (*p_fp != NUL || *curbuf->b_p_fp != NUL) |
Dominique Pelle | 4781d6f | 2021-05-18 21:46:31 +0200 | [diff] [blame] | 4093 | op_colon(oap); // use external command |
| 4094 | else |
| 4095 | op_format(oap, FALSE); // use internal function |
| 4096 | } |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 4097 | break; |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 4098 | case OP_FORMAT2: |
| 4099 | op_format(oap, TRUE); // use internal function |
| 4100 | break; |
| 4101 | |
| 4102 | case OP_FUNCTION: |
Bram Moolenaar | b3bd1d3 | 2022-01-02 13:05:45 +0000 | [diff] [blame] | 4103 | { |
| 4104 | redo_VIsual_T save_redo_VIsual = redo_VIsual; |
| 4105 | |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 4106 | #ifdef FEAT_LINEBREAK |
Bram Moolenaar | b3bd1d3 | 2022-01-02 13:05:45 +0000 | [diff] [blame] | 4107 | // Restore linebreak, so that when the user edits it looks as |
| 4108 | // before. |
| 4109 | curwin->w_p_lbr = lbr_saved; |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 4110 | #endif |
Bram Moolenaar | b3bd1d3 | 2022-01-02 13:05:45 +0000 | [diff] [blame] | 4111 | // 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 Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 4119 | |
| 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 Moolenaar | 03c3bd9 | 2020-01-23 20:58:09 +0100 | [diff] [blame] | 4138 | curwin->w_p_lbr = lbr_saved; |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 4139 | #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 Moolenaar | 03c3bd9 | 2020-01-23 20:58:09 +0100 | [diff] [blame] | 4169 | curwin->w_p_lbr = lbr_saved; |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 4170 | #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 Moolenaar | b3bd1d3 | 2022-01-02 13:05:45 +0000 | [diff] [blame] | 4214 | op_addsub(oap, cap->count1, redo_VIsual.rv_arg); |
Bram Moolenaar | 792cf5e | 2019-09-30 23:12:16 +0200 | [diff] [blame] | 4215 | 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 | } |