From 9be19b770d7802e62ab1a084996ac2192b71fd70 Mon Sep 17 00:00:00 2001 From: Björn Linse Date: Fri, 7 Feb 2020 19:54:29 +0100 Subject: api: set_text: first stab at nvim_buf_set_text --- src/nvim/api/buffer.c | 188 +++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 171 insertions(+), 17 deletions(-) (limited to 'src') diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c index f1151d196a..bc84e2144b 100644 --- a/src/nvim/api/buffer.c +++ b/src/nvim/api/buffer.c @@ -362,22 +362,9 @@ void nvim_buf_set_lines(uint64_t channel_id, return; } - for (size_t i = 0; i < replacement.size; i++) { - if (replacement.items[i].type != kObjectTypeString) { - api_set_error(err, - kErrorTypeValidation, - "All items in the replacement array must be strings"); - return; - } - // Disallow newlines in the middle of the line. - if (channel_id != VIML_INTERNAL_CALL) { - const String l = replacement.items[i].data.string; - if (memchr(l.data, NL, l.size)) { - api_set_error(err, kErrorTypeValidation, - "String cannot contain newlines"); - return; - } - } + bool disallow_nl = (channel_id != VIML_INTERNAL_CALL); + if (!check_string_array(replacement, disallow_nl, err)) { + return; } size_t new_len = replacement.size; @@ -466,7 +453,7 @@ void nvim_buf_set_lines(uint64_t channel_id, // Adjust marks. Invalidate any which lie in the // changed range, and move any in the remainder of the buffer. - // Only adjust marks if we managed to switch to a window that holds + // Only adjust mapks if we managed to switch to a window that holds // the buffer, otherwise line numbers will be invalid. mark_adjust((linenr_T)start, (linenr_T)(end - 1), @@ -487,6 +474,173 @@ end: try_end(err); } +void nvim_buf_set_text(uint64_t channel_id, + Buffer buffer, + Integer start_row, + Integer start_col, + Integer end_row, + Integer end_col, + ArrayOf(String) replacement, + Error *err) + FUNC_API_SINCE(7) +{ + // TODO: treat [] as [''] for convenience + assert(replacement.size > 0); + buf_T *buf = find_buffer_by_handle(buffer, err); + if (!buf) { + return; + } + size_t new_len = replacement.size; + + // TODO: do the nl-for-NUL dance as well? + bool disallow_nl = (channel_id != VIML_INTERNAL_CALL); + if (!check_string_array(replacement, disallow_nl, err)) { + return; + } + + // TODO: check range is ordered and everything! + // start_row, end_row within buffer len (except add text past the end?) + char *str_at_start = (char *)ml_get_buf(buf, start_row+1, false); + if (start_col < 0 || (size_t)start_col > strlen(str_at_start)) { + api_set_error(err, kErrorTypeValidation, "start_col out of bounds"); + return; + } + + char *str_at_end = (char *)ml_get_buf(buf, end_row+1, false); + size_t len_at_end = strlen(str_at_end); + if (end_col < 0 || (size_t)end_col > len_at_end) { + api_set_error(err, kErrorTypeValidation, "end_col out of bounds"); + return; + } + + String first_item = replacement.items[0].data.string; + String last_item = replacement.items[replacement.size-1].data.string; + size_t firstlen = (size_t)start_col+first_item.size; + size_t last_part_len = strlen(str_at_end) - (size_t)end_col; + if (replacement.size == 1) { + firstlen += last_part_len; + } + char *first = xmallocz(firstlen), *last = NULL; + memcpy(first, str_at_start, (size_t)start_col); + memcpy(first+start_col, first_item.data, first_item.size); + if (replacement.size == 1) { + memcpy(first+start_col+first_item.size, str_at_end+end_col, last_part_len); + } else { + last = xmallocz(last_item.size+last_part_len); + memcpy(last, last_item.data, last_item.size); + memcpy(last+last_item.size, str_at_end+end_col, last_part_len); + } + + char **lines = (new_len != 0) ? xcalloc(new_len, sizeof(char *)) : NULL; + lines[0] = first; + for (size_t i = 1; i < new_len-1; i++) { + lines[i] = replacement.items[i].data.string.data; + } + if (replacement.size > 1) { + lines[replacement.size-1] = last; + } + + try_start(); + aco_save_T aco; + aucmd_prepbuf(&aco, (buf_T *)buf); + + if (!MODIFIABLE(buf)) { + api_set_error(err, kErrorTypeException, "Buffer is not 'modifiable'"); + goto end; + } + + // TODO: dubbel KOLLA KOLLA indexen här + if (u_save((linenr_T)start_row, (linenr_T)end_row+2) == FAIL) { + api_set_error(err, kErrorTypeException, "Failed to save undo information"); + goto end; + } + + + ptrdiff_t extra = 0; // lines added to text, can be negative + size_t old_len = (size_t)(end_row-start_row+1); + + // If the size of the range is reducing (ie, new_len < old_len) we + // need to delete some old_len. We do this at the start, by + // repeatedly deleting line "start". + size_t to_delete = (new_len < old_len) ? (size_t)(old_len - new_len) : 0; + for (size_t i = 0; i < to_delete; i++) { + if (ml_delete((linenr_T)start_row+1, false) == FAIL) { + api_set_error(err, kErrorTypeException, "Failed to delete line"); + goto end; + } + } + + if (to_delete > 0) { + extra -= (ptrdiff_t)to_delete; + } + + // For as long as possible, replace the existing old_len with the + // new old_len. This is a more efficient operation, as it requires + // less memory allocation and freeing. + size_t to_replace = old_len < new_len ? old_len : new_len; + for (size_t i = 0; i < to_replace; i++) { + int64_t lnum = start_row + 1 + (int64_t)i; + + if (lnum >= MAXLNUM) { + api_set_error(err, kErrorTypeValidation, "Index value is too high"); + goto end; + } + + if (ml_replace((linenr_T)lnum, (char_u *)lines[i], false) == FAIL) { + api_set_error(err, kErrorTypeException, "Failed to replace line"); + goto end; + } + // Mark lines that haven't been passed to the buffer as they need + // to be freed later + lines[i] = NULL; + } + + // Now we may need to insert the remaining new old_len + for (size_t i = to_replace; i < new_len; i++) { + int64_t lnum = start_row + (int64_t)i; + + if (lnum >= MAXLNUM) { + api_set_error(err, kErrorTypeValidation, "Index value is too high"); + goto end; + } + + if (ml_append((linenr_T)lnum, (char_u *)lines[i], 0, false) == FAIL) { + api_set_error(err, kErrorTypeException, "Failed to insert line"); + goto end; + } + + // Same as with replacing, but we also need to free lines + xfree(lines[i]); + lines[i] = NULL; + extra++; + } + + // Adjust marks. Invalidate any which lie in the + // changed range, and move any in the remainder of the buffer. + // Only adjust mapks if we managed to switch to a window that holds + // the buffer, otherwise line numbers will be invalid. + mark_adjust((linenr_T)start_row, + (linenr_T)end_row, + MAXLNUM, + (long)extra, + kExtmarkNOOP); + + colnr_T col_extent = (colnr_T)(end_col + - ((end_row > start_col) ? start_col : 0)); + extmark_splice(buf, (int)start_row, (colnr_T)start_col, + (int)(end_row-start_row), col_extent, + (int)new_len-1, (colnr_T)last_item.size, kExtmarkUndo); + + changed_lines((linenr_T)start_row+1, 0, (linenr_T)end_row+1, (long)extra, true); + + // TODO: adjust cursor like an extmark ( i e it was inside last_part_len) + fix_cursor((linenr_T)start_row+1, (linenr_T)end_row+1, (linenr_T)extra); + +end: + aucmd_restbuf(&aco); + try_end(err); +} + /// Returns the byte offset of a line (0-indexed). |api-indexing| /// /// Line 1 (index=0) has offset 0. UTF-8 bytes are counted. EOL is one byte. -- cgit From 29ad2ebc1688176a1c7acaa81103dac289de0ad1 Mon Sep 17 00:00:00 2001 From: Blaž Hrastnik Date: Mon, 4 May 2020 10:30:59 +0900 Subject: api: set_text: fix validation and some issues fix double free because intermediary lines weren't xmemdup'd. NL-for-NUL dance. Normalize row indices and perform more validation. Adjust the cursor position if it's on the right side of the replacement. Tests and documentation. --- src/nvim/api/buffer.c | 93 +++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 71 insertions(+), 22 deletions(-) (limited to 'src') diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c index bc84e2144b..7fa30e7a7d 100644 --- a/src/nvim/api/buffer.c +++ b/src/nvim/api/buffer.c @@ -453,7 +453,7 @@ void nvim_buf_set_lines(uint64_t channel_id, // Adjust marks. Invalidate any which lie in the // changed range, and move any in the remainder of the buffer. - // Only adjust mapks if we managed to switch to a window that holds + // Only adjust marks if we managed to switch to a window that holds // the buffer, otherwise line numbers will be invalid. mark_adjust((linenr_T)start, (linenr_T)(end - 1), @@ -474,6 +474,23 @@ end: try_end(err); } +/// Sets (replaces) a range in the buffer. +/// +/// Indexing is zero-based, end-exclusive. +/// +/// To insert text at a given index, set `start` and `end` ranges to the same +/// index. To delete a range, set `replacement` to an empty array. +/// +/// Prefer nvim_buf_set_lines when modifying entire lines. +/// +/// @param channel_id +/// @param buffer Buffer handle, or 0 for current buffer +/// @param start_row First line index +/// @param start_column Last column +/// @param end_row Last line index (exclusive) +/// @param end_column Last column +/// @param replacement Array of lines to use as replacement +/// @param[out] err Error details, if any void nvim_buf_set_text(uint64_t channel_id, Buffer buffer, Integer start_row, @@ -490,29 +507,48 @@ void nvim_buf_set_text(uint64_t channel_id, if (!buf) { return; } - size_t new_len = replacement.size; - // TODO: do the nl-for-NUL dance as well? - bool disallow_nl = (channel_id != VIML_INTERNAL_CALL); - if (!check_string_array(replacement, disallow_nl, err)) { + bool oob = false; + + // check range is ordered and everything! + // start_row, end_row within buffer len (except add text past the end?) + start_row = normalize_index(buf, start_row, &oob); + if (oob) { + api_set_error(err, kErrorTypeValidation, "start_row out of bounds"); return; } - // TODO: check range is ordered and everything! - // start_row, end_row within buffer len (except add text past the end?) - char *str_at_start = (char *)ml_get_buf(buf, start_row+1, false); + end_row = normalize_index(buf, end_row, &oob); + /* if (oob) { */ + /* api_set_error(err, kErrorTypeValidation, "end_row out of bounds"); */ + /* return; */ + /* } */ + + char *str_at_start = (char *)ml_get_buf(buf, start_row, false); if (start_col < 0 || (size_t)start_col > strlen(str_at_start)) { api_set_error(err, kErrorTypeValidation, "start_col out of bounds"); return; } - char *str_at_end = (char *)ml_get_buf(buf, end_row+1, false); + char *str_at_end = (char *)ml_get_buf(buf, end_row, false); size_t len_at_end = strlen(str_at_end); if (end_col < 0 || (size_t)end_col > len_at_end) { api_set_error(err, kErrorTypeValidation, "end_col out of bounds"); return; } + if (start_row > end_row || (end_row == start_row && start_col > end_col)) { + api_set_error(err, kErrorTypeValidation, "start is higher than end"); + return; + } + + bool disallow_nl = (channel_id != VIML_INTERNAL_CALL); + if (!check_string_array(replacement, disallow_nl, err)) { + return; + } + + size_t new_len = replacement.size; + String first_item = replacement.items[0].data.string; String last_item = replacement.items[replacement.size-1].data.string; size_t firstlen = (size_t)start_col+first_item.size; @@ -523,18 +559,26 @@ void nvim_buf_set_text(uint64_t channel_id, char *first = xmallocz(firstlen), *last = NULL; memcpy(first, str_at_start, (size_t)start_col); memcpy(first+start_col, first_item.data, first_item.size); + memchrsub(first+start_col, NUL, NL, first_item.size); if (replacement.size == 1) { memcpy(first+start_col+first_item.size, str_at_end+end_col, last_part_len); } else { last = xmallocz(last_item.size+last_part_len); memcpy(last, last_item.data, last_item.size); + memchrsub(last, NUL, NL, last_item.size); memcpy(last+last_item.size, str_at_end+end_col, last_part_len); } char **lines = (new_len != 0) ? xcalloc(new_len, sizeof(char *)) : NULL; lines[0] = first; for (size_t i = 1; i < new_len-1; i++) { - lines[i] = replacement.items[i].data.string.data; + const String l = replacement.items[i].data.string; + + // Fill lines[i] with l's contents. Convert NULs to newlines as required by + // NL-used-for-NUL. + lines[i] = xmemdupz(l.data, l.size); + memchrsub(lines[i], NUL, NL, l.size); + /* lines[i] = replacement.items[i].data.string.data; */ } if (replacement.size > 1) { lines[replacement.size-1] = last; @@ -549,13 +593,11 @@ void nvim_buf_set_text(uint64_t channel_id, goto end; } - // TODO: dubbel KOLLA KOLLA indexen här - if (u_save((linenr_T)start_row, (linenr_T)end_row+2) == FAIL) { + if (u_save((linenr_T)start_row - 1, (linenr_T)end_row) == FAIL) { api_set_error(err, kErrorTypeException, "Failed to save undo information"); goto end; } - ptrdiff_t extra = 0; // lines added to text, can be negative size_t old_len = (size_t)(end_row-start_row+1); @@ -564,7 +606,7 @@ void nvim_buf_set_text(uint64_t channel_id, // repeatedly deleting line "start". size_t to_delete = (new_len < old_len) ? (size_t)(old_len - new_len) : 0; for (size_t i = 0; i < to_delete; i++) { - if (ml_delete((linenr_T)start_row+1, false) == FAIL) { + if (ml_delete((linenr_T)start_row, false) == FAIL) { api_set_error(err, kErrorTypeException, "Failed to delete line"); goto end; } @@ -579,7 +621,7 @@ void nvim_buf_set_text(uint64_t channel_id, // less memory allocation and freeing. size_t to_replace = old_len < new_len ? old_len : new_len; for (size_t i = 0; i < to_replace; i++) { - int64_t lnum = start_row + 1 + (int64_t)i; + int64_t lnum = start_row + (int64_t)i; if (lnum >= MAXLNUM) { api_set_error(err, kErrorTypeValidation, "Index value is too high"); @@ -597,7 +639,7 @@ void nvim_buf_set_text(uint64_t channel_id, // Now we may need to insert the remaining new old_len for (size_t i = to_replace; i < new_len; i++) { - int64_t lnum = start_row + (int64_t)i; + int64_t lnum = start_row + (int64_t)i - 1; if (lnum >= MAXLNUM) { api_set_error(err, kErrorTypeValidation, "Index value is too high"); @@ -617,7 +659,7 @@ void nvim_buf_set_text(uint64_t channel_id, // Adjust marks. Invalidate any which lie in the // changed range, and move any in the remainder of the buffer. - // Only adjust mapks if we managed to switch to a window that holds + // Only adjust marks if we managed to switch to a window that holds // the buffer, otherwise line numbers will be invalid. mark_adjust((linenr_T)start_row, (linenr_T)end_row, @@ -626,17 +668,24 @@ void nvim_buf_set_text(uint64_t channel_id, kExtmarkNOOP); colnr_T col_extent = (colnr_T)(end_col - - ((end_row > start_col) ? start_col : 0)); - extmark_splice(buf, (int)start_row, (colnr_T)start_col, + - ((end_col > start_col) ? start_col : 0)); + extmark_splice(buf, (int)start_row-1, (colnr_T)start_col, (int)(end_row-start_row), col_extent, (int)new_len-1, (colnr_T)last_item.size, kExtmarkUndo); - changed_lines((linenr_T)start_row+1, 0, (linenr_T)end_row+1, (long)extra, true); + changed_lines((linenr_T)start_row, 0, (linenr_T)end_row, (long)extra, true); - // TODO: adjust cursor like an extmark ( i e it was inside last_part_len) - fix_cursor((linenr_T)start_row+1, (linenr_T)end_row+1, (linenr_T)extra); + // adjust cursor like an extmark ( i e it was inside last_part_len) + if (curwin->w_cursor.lnum == end_row && curwin->w_cursor.col > end_col) { + curwin->w_cursor.col -= col_extent - (colnr_T)last_item.size; + } + fix_cursor((linenr_T)start_row, (linenr_T)end_row, (linenr_T)extra); end: + for (size_t i = 0; i < new_len; i++) { + xfree(lines[i]); + } + xfree(lines); aucmd_restbuf(&aco); try_end(err); } -- cgit From 45b14f88db1b332938f4a73be28966ae60563a50 Mon Sep 17 00:00:00 2001 From: Tony Chen Date: Mon, 21 Dec 2020 17:51:52 -0800 Subject: api: set_text: rebase, update to new api, and add more tests --- src/nvim/api/buffer.c | 66 ++++++++++++++++++++++++++++++++++++++++++++------- src/nvim/extmark.c | 17 +++++++++++++ 2 files changed, 75 insertions(+), 8 deletions(-) (limited to 'src') diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c index 7fa30e7a7d..21a7e897a9 100644 --- a/src/nvim/api/buffer.c +++ b/src/nvim/api/buffer.c @@ -309,6 +309,27 @@ end: return rv; } +static bool check_string_array(Array arr, bool disallow_nl, Error *err) +{ + for (size_t i = 0; i < arr.size; i++) { + if (arr.items[i].type != kObjectTypeString) { + api_set_error(err, + kErrorTypeValidation, + "All items in the replacement array must be strings"); + return false; + } + // Disallow newlines in the middle of the line. + if (disallow_nl) { + const String l = arr.items[i].data.string; + if (memchr(l.data, NL, l.size)) { + api_set_error(err, kErrorTypeValidation, + "String cannot contain newlines"); + return false; + } + } + } + return true; +} /// Sets (replaces) a line-range in the buffer. /// @@ -519,10 +540,10 @@ void nvim_buf_set_text(uint64_t channel_id, } end_row = normalize_index(buf, end_row, &oob); - /* if (oob) { */ - /* api_set_error(err, kErrorTypeValidation, "end_row out of bounds"); */ - /* return; */ - /* } */ + if (oob) { + api_set_error(err, kErrorTypeValidation, "end_row out of bounds"); + return; + } char *str_at_start = (char *)ml_get_buf(buf, start_row, false); if (start_col < 0 || (size_t)start_col > strlen(str_at_start)) { @@ -547,10 +568,36 @@ void nvim_buf_set_text(uint64_t channel_id, return; } + bcount_t new_byte = 0; + bcount_t old_byte = 0; + + // calculate byte size of old region before it gets modified/deleted + if (start_row == end_row) { + old_byte = (bcount_t)end_col - start_col; + } else { + char_u *line; + old_byte += (bcount_t)strlen(str_at_start) - start_col; + for (size_t i = 0; i < (bcount_t)end_row - start_row; i++){ + int64_t lnum = start_row + (int64_t)i; + + if (lnum >= MAXLNUM) { + api_set_error(err, kErrorTypeValidation, "Index value is too high"); + goto end; + } + + line = ml_get_buf(buf, lnum, false); + old_byte += (bcount_t)(strlen((char *)line)); + } + old_byte += end_col; + } + size_t new_len = replacement.size; String first_item = replacement.items[0].data.string; String last_item = replacement.items[replacement.size-1].data.string; + + new_byte += (bcount_t)(first_item.size); + size_t firstlen = (size_t)start_col+first_item.size; size_t last_part_len = strlen(str_at_end) - (size_t)end_col; if (replacement.size == 1) { @@ -578,10 +625,11 @@ void nvim_buf_set_text(uint64_t channel_id, // NL-used-for-NUL. lines[i] = xmemdupz(l.data, l.size); memchrsub(lines[i], NUL, NL, l.size); - /* lines[i] = replacement.items[i].data.string.data; */ + new_byte += (bcount_t)(l.size); } if (replacement.size > 1) { lines[replacement.size-1] = last; + new_byte += (bcount_t)(last_item.size); } try_start(); @@ -593,7 +641,7 @@ void nvim_buf_set_text(uint64_t channel_id, goto end; } - if (u_save((linenr_T)start_row - 1, (linenr_T)end_row) == FAIL) { + if (u_save((linenr_T)start_row - 1, (linenr_T)end_row + 1) == FAIL) { api_set_error(err, kErrorTypeException, "Failed to save undo information"); goto end; } @@ -670,8 +718,10 @@ void nvim_buf_set_text(uint64_t channel_id, colnr_T col_extent = (colnr_T)(end_col - ((end_col > start_col) ? start_col : 0)); extmark_splice(buf, (int)start_row-1, (colnr_T)start_col, - (int)(end_row-start_row), col_extent, - (int)new_len-1, (colnr_T)last_item.size, kExtmarkUndo); + (int)(end_row-start_row), col_extent, (bcount_t)(old_byte), + (int)new_len-1, (colnr_T)last_item.size, (bcount_t)new_byte, + kExtmarkUndo); + changed_lines((linenr_T)start_row, 0, (linenr_T)end_row, (long)extra, true); diff --git a/src/nvim/extmark.c b/src/nvim/extmark.c index ba685b158e..b2d8532cd7 100644 --- a/src/nvim/extmark.c +++ b/src/nvim/extmark.c @@ -560,6 +560,23 @@ void extmark_adjust(buf_T *buf, new_row, 0, new_byte, undo); } +// Adjust extmarks following a text edit. +// +// @param buf +// @param start_row Start row of the region to be changed +// @param start_col Start col of the region to be changed +// @param old_row End row of the region to be changed. +// Encoded as an offset to start_row. +// @param old_col End col of the region to be changed. Encodes +// an offset from start_col if old_row = 0; otherwise, +// encodes the end column of the old region. +// @param old_byte Byte extent of the region to be changed. +// @param new_row Row offset of the new region. +// @param new_col Col offset of the new region. Encodes an offset from +// start_col if new_row = 0; otherwise, encodes +// the end column of the new region. +// @param new_byte Byte extent of the new region. +// @param undo void extmark_splice(buf_T *buf, int start_row, colnr_T start_col, int old_row, colnr_T old_col, bcount_t old_byte, -- cgit From f7d01a65d50a4783527acd2de3998b65e7b78331 Mon Sep 17 00:00:00 2001 From: chentau Date: Mon, 21 Dec 2020 18:24:15 -0800 Subject: api: set_text: more tests, and fixing lint removing pending virtcol tests Allow passing in empty array as a shorthand for array with empty string; add more documentation add check for start_row as well --- src/nvim/api/buffer.c | 52 +++++++++++++++++++++++++++++---------------------- 1 file changed, 30 insertions(+), 22 deletions(-) (limited to 'src') diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c index 21a7e897a9..1916d720a7 100644 --- a/src/nvim/api/buffer.c +++ b/src/nvim/api/buffer.c @@ -495,21 +495,24 @@ end: try_end(err); } -/// Sets (replaces) a range in the buffer. +/// Sets (replaces) a range in the buffer, retaining any extmarks +/// that may lie in that range. /// -/// Indexing is zero-based, end-exclusive. +/// Indexing is zero-based; end_row is inclusive, while end_col is +/// exclusive. /// /// To insert text at a given index, set `start` and `end` ranges to the same -/// index. To delete a range, set `replacement` to an empty array. +/// index. To delete a range, set `replacement` to an array containing +/// an empty string, or simply an empty array. /// -/// Prefer nvim_buf_set_lines when modifying entire lines. +/// Prefer nvim_buf_set_lines when adding or deleting entire lines. /// /// @param channel_id /// @param buffer Buffer handle, or 0 for current buffer /// @param start_row First line index /// @param start_column Last column -/// @param end_row Last line index (exclusive) -/// @param end_column Last column +/// @param end_row Last line index (inclusive) +/// @param end_column Last column (exclusive) /// @param replacement Array of lines to use as replacement /// @param[out] err Error details, if any void nvim_buf_set_text(uint64_t channel_id, @@ -522,8 +525,12 @@ void nvim_buf_set_text(uint64_t channel_id, Error *err) FUNC_API_SINCE(7) { - // TODO: treat [] as [''] for convenience - assert(replacement.size > 0); + if (replacement.size == 0) { + String s = { .data = "", .size = 0 }; + ADD(replacement, STRING_OBJ(s)); + replacement.size = 1; + } + buf_T *buf = find_buffer_by_handle(buffer, err); if (!buf) { return; @@ -534,13 +541,13 @@ void nvim_buf_set_text(uint64_t channel_id, // check range is ordered and everything! // start_row, end_row within buffer len (except add text past the end?) start_row = normalize_index(buf, start_row, &oob); - if (oob) { + if (oob || start_row == buf->b_ml.ml_line_count + 1) { api_set_error(err, kErrorTypeValidation, "start_row out of bounds"); return; } end_row = normalize_index(buf, end_row, &oob); - if (oob) { + if (oob || end_row == buf->b_ml.ml_line_count + 1) { api_set_error(err, kErrorTypeValidation, "end_row out of bounds"); return; } @@ -568,6 +575,8 @@ void nvim_buf_set_text(uint64_t channel_id, return; } + size_t new_len = replacement.size; + bcount_t new_byte = 0; bcount_t old_byte = 0; @@ -575,29 +584,25 @@ void nvim_buf_set_text(uint64_t channel_id, if (start_row == end_row) { old_byte = (bcount_t)end_col - start_col; } else { - char_u *line; + const char *bufline; old_byte += (bcount_t)strlen(str_at_start) - start_col; - for (size_t i = 0; i < (bcount_t)end_row - start_row; i++){ - int64_t lnum = start_row + (int64_t)i; + for (int64_t i = 0; i < end_row - start_row; i++) { + int64_t lnum = start_row + i; if (lnum >= MAXLNUM) { api_set_error(err, kErrorTypeValidation, "Index value is too high"); goto end; } - line = ml_get_buf(buf, lnum, false); - old_byte += (bcount_t)(strlen((char *)line)); + bufline = (char *)ml_get_buf(buf, lnum, false); + old_byte += (bcount_t)(strlen(bufline)); } - old_byte += end_col; + old_byte += (bcount_t)end_col; } - size_t new_len = replacement.size; - String first_item = replacement.items[0].data.string; String last_item = replacement.items[replacement.size-1].data.string; - new_byte += (bcount_t)(first_item.size); - size_t firstlen = (size_t)start_col+first_item.size; size_t last_part_len = strlen(str_at_end) - (size_t)end_col; if (replacement.size == 1) { @@ -618,6 +623,7 @@ void nvim_buf_set_text(uint64_t channel_id, char **lines = (new_len != 0) ? xcalloc(new_len, sizeof(char *)) : NULL; lines[0] = first; + new_byte += (bcount_t)(first_item.size); for (size_t i = 1; i < new_len-1; i++) { const String l = replacement.items[i].data.string; @@ -641,6 +647,8 @@ void nvim_buf_set_text(uint64_t channel_id, goto end; } + // Small note about undo states: unlike set_lines, we want to save the + // undo state of one past the end_row, since end_row is inclusive. if (u_save((linenr_T)start_row - 1, (linenr_T)end_row + 1) == FAIL) { api_set_error(err, kErrorTypeException, "Failed to save undo information"); goto end; @@ -718,8 +726,8 @@ void nvim_buf_set_text(uint64_t channel_id, colnr_T col_extent = (colnr_T)(end_col - ((end_col > start_col) ? start_col : 0)); extmark_splice(buf, (int)start_row-1, (colnr_T)start_col, - (int)(end_row-start_row), col_extent, (bcount_t)(old_byte), - (int)new_len-1, (colnr_T)last_item.size, (bcount_t)new_byte, + (int)(end_row-start_row), col_extent, old_byte, + (int)new_len-1, (colnr_T)last_item.size, new_byte, kExtmarkUndo); -- cgit From 39d098f9f9dc244a84958202e221ed0bdc6ee88a Mon Sep 17 00:00:00 2001 From: Björn Linse Date: Wed, 30 Dec 2020 11:31:17 +0100 Subject: api: set_text: fix some byte count issues add byte count tests update documentation --- src/nvim/api/buffer.c | 53 +++++++++++++++++++++------------------------------ 1 file changed, 22 insertions(+), 31 deletions(-) (limited to 'src') diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c index 1916d720a7..8d82d22040 100644 --- a/src/nvim/api/buffer.c +++ b/src/nvim/api/buffer.c @@ -495,40 +495,38 @@ end: try_end(err); } -/// Sets (replaces) a range in the buffer, retaining any extmarks -/// that may lie in that range. +/// Sets (replaces) a range in the buffer /// -/// Indexing is zero-based; end_row is inclusive, while end_col is -/// exclusive. +/// This is recommended over nvim_buf_set_lines when only modifying parts of a +/// line, as extmarks will be preserved on non-modified parts of the touched +/// lines. +/// +/// Indexing is zero-based and end-exclusive. /// /// To insert text at a given index, set `start` and `end` ranges to the same /// index. To delete a range, set `replacement` to an array containing /// an empty string, or simply an empty array. /// -/// Prefer nvim_buf_set_lines when adding or deleting entire lines. +/// Prefer nvim_buf_set_lines when adding or deleting entire lines only. /// /// @param channel_id /// @param buffer Buffer handle, or 0 for current buffer /// @param start_row First line index /// @param start_column Last column -/// @param end_row Last line index (inclusive) -/// @param end_column Last column (exclusive) +/// @param end_row Last line index +/// @param end_column Last column /// @param replacement Array of lines to use as replacement /// @param[out] err Error details, if any -void nvim_buf_set_text(uint64_t channel_id, - Buffer buffer, - Integer start_row, - Integer start_col, - Integer end_row, - Integer end_col, - ArrayOf(String) replacement, - Error *err) +void nvim_buf_set_text(uint64_t channel_id, Buffer buffer, + Integer start_row, Integer start_col, + Integer end_row, Integer end_col, + ArrayOf(String) replacement, Error *err) FUNC_API_SINCE(7) { + FIXED_TEMP_ARRAY(scratch, 1); if (replacement.size == 0) { - String s = { .data = "", .size = 0 }; - ADD(replacement, STRING_OBJ(s)); - replacement.size = 1; + scratch.items[0] = STRING_OBJ(STATIC_CSTR_AS_STRING("")); + replacement = scratch; } buf_T *buf = find_buffer_by_handle(buffer, err); @@ -586,18 +584,13 @@ void nvim_buf_set_text(uint64_t channel_id, } else { const char *bufline; old_byte += (bcount_t)strlen(str_at_start) - start_col; - for (int64_t i = 0; i < end_row - start_row; i++) { + for (int64_t i = 1; i < end_row - start_row; i++) { int64_t lnum = start_row + i; - if (lnum >= MAXLNUM) { - api_set_error(err, kErrorTypeValidation, "Index value is too high"); - goto end; - } - bufline = (char *)ml_get_buf(buf, lnum, false); - old_byte += (bcount_t)(strlen(bufline)); + old_byte += (bcount_t)(strlen(bufline))+1; } - old_byte += (bcount_t)end_col; + old_byte += (bcount_t)end_col+1; } String first_item = replacement.items[0].data.string; @@ -631,11 +624,11 @@ void nvim_buf_set_text(uint64_t channel_id, // NL-used-for-NUL. lines[i] = xmemdupz(l.data, l.size); memchrsub(lines[i], NUL, NL, l.size); - new_byte += (bcount_t)(l.size); + new_byte += (bcount_t)(l.size)+1; } if (replacement.size > 1) { lines[replacement.size-1] = last; - new_byte += (bcount_t)(last_item.size); + new_byte += (bcount_t)(last_item.size)+1; } try_start(); @@ -715,8 +708,6 @@ void nvim_buf_set_text(uint64_t channel_id, // Adjust marks. Invalidate any which lie in the // changed range, and move any in the remainder of the buffer. - // Only adjust marks if we managed to switch to a window that holds - // the buffer, otherwise line numbers will be invalid. mark_adjust((linenr_T)start_row, (linenr_T)end_row, MAXLNUM, @@ -724,7 +715,7 @@ void nvim_buf_set_text(uint64_t channel_id, kExtmarkNOOP); colnr_T col_extent = (colnr_T)(end_col - - ((end_col > start_col) ? start_col : 0)); + - ((end_row == start_row) ? start_col : 0)); extmark_splice(buf, (int)start_row-1, (colnr_T)start_col, (int)(end_row-start_row), col_extent, old_byte, (int)new_len-1, (colnr_T)last_item.size, new_byte, -- cgit