aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/nvim/api/buffer.c56
-rw-r--r--src/nvim/buffer.c14
-rw-r--r--src/nvim/buffer_defs.h6
-rw-r--r--src/nvim/buffer_updates.c233
-rw-r--r--src/nvim/buffer_updates.h10
-rw-r--r--src/nvim/diff.c2
-rw-r--r--src/nvim/event/wstream.c2
-rw-r--r--src/nvim/ex_cmds.c44
-rw-r--r--src/nvim/fold.c27
-rw-r--r--src/nvim/generators/gen_api_dispatch.lua5
-rw-r--r--src/nvim/misc1.c44
-rw-r--r--src/nvim/normal.c2
-rw-r--r--src/nvim/ops.c38
-rw-r--r--src/nvim/terminal.c4
-rw-r--r--src/nvim/undo.c53
15 files changed, 467 insertions, 73 deletions
diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index fa4ad27e60..215859a499 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -25,6 +25,7 @@
#include "nvim/window.h"
#include "nvim/undo.h"
#include "nvim/ex_docmd.h"
+#include "nvim/buffer_updates.h"
#ifdef INCLUDE_GENERATED_DECLARATIONS
# include "api/buffer.c.generated.h"
@@ -75,6 +76,59 @@ String buffer_get_line(Buffer buffer, Integer index, Error *err)
return rv;
}
+/// Activate updates from this buffer to the current channel.
+///
+/// @param buffer The buffer handle
+/// @param send_buffer Set to true if the initial notification should contain
+/// the whole buffer. If so, the first notification will be a
+/// `nvim_buf_lines_event`. Otherwise, the first notification will be
+/// a `nvim_buf_changedtick_event`
+/// @param opts Optional parameters. Currently not used.
+/// @param[out] err Details of an error that may have occurred
+/// @return False when updates couldn't be enabled because the buffer isn't
+/// loaded or `opts` contained an invalid key; otherwise True.
+Boolean nvim_buf_attach(uint64_t channel_id,
+ Buffer buffer,
+ Boolean send_buffer,
+ Dictionary opts,
+ Error *err)
+ FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY
+{
+ if (opts.size > 0) {
+ api_set_error(err, kErrorTypeValidation, "dict isn't empty");
+ return false;
+ }
+
+ buf_T *buf = find_buffer_by_handle(buffer, err);
+
+ if (!buf) {
+ return false;
+ }
+
+ return buf_updates_register(buf, channel_id, send_buffer);
+}
+//
+/// Deactivate updates from this buffer to the current channel.
+///
+/// @param buffer The buffer handle
+/// @param[out] err Details of an error that may have occurred
+/// @return False when updates couldn't be disabled because the buffer
+/// isn't loaded; otherwise True.
+Boolean nvim_buf_detach(uint64_t channel_id,
+ Buffer buffer,
+ Error *err)
+ FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY
+{
+ buf_T *buf = find_buffer_by_handle(buffer, err);
+
+ if (!buf) {
+ return false;
+ }
+
+ buf_updates_unregister(buf, channel_id);
+ return true;
+}
+
/// Sets a buffer line
///
/// @deprecated use nvim_buf_set_lines instead.
@@ -407,7 +461,7 @@ void nvim_buf_set_lines(uint64_t channel_id,
false);
}
- changed_lines((linenr_T)start, 0, (linenr_T)end, (long)extra);
+ changed_lines((linenr_T)start, 0, (linenr_T)end, (long)extra, true);
if (save_curbuf.br_buf == NULL) {
fix_cursor((linenr_T)start, (linenr_T)end, (linenr_T)extra);
diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index ba63822837..838f267dcd 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -73,6 +73,7 @@
#include "nvim/os/os.h"
#include "nvim/os/time.h"
#include "nvim/os/input.h"
+#include "nvim/buffer_updates.h"
typedef enum {
kBLSUnchanged = 0,
@@ -574,6 +575,9 @@ void close_buffer(win_T *win, buf_T *buf, int action, int abort_if_last)
/* Change directories when the 'acd' option is set. */
do_autochdir();
+ // disable buffer updates for the current buffer
+ buf_updates_unregister_all(buf);
+
/*
* Remove the buffer from the list.
*/
@@ -784,6 +788,8 @@ free_buffer_stuff (
map_clear_int(buf, MAP_ALL_MODES, true, true); // clear local abbrevs
xfree(buf->b_start_fenc);
buf->b_start_fenc = NULL;
+
+ buf_updates_unregister_all(buf);
}
/*
@@ -1732,9 +1738,11 @@ buf_T * buflist_new(char_u *ffname, char_u *sfname, linenr_T lnum, int flags)
if (flags & BLN_DUMMY)
buf->b_flags |= BF_DUMMY;
buf_clear_file(buf);
- clrallmarks(buf); /* clear marks */
- fmarks_check_names(buf); /* check file marks for this file */
- buf->b_p_bl = (flags & BLN_LISTED) ? TRUE : FALSE; /* init 'buflisted' */
+ clrallmarks(buf); // clear marks
+ fmarks_check_names(buf); // check file marks for this file
+ buf->b_p_bl = (flags & BLN_LISTED) ? true : false; // init 'buflisted'
+ kv_destroy(buf->update_channels);
+ kv_init(buf->update_channels);
if (!(flags & BLN_DUMMY)) {
// Tricky: these autocommands may change the buffer list. They could also
// split the window with re-using the one empty buffer. This may result in
diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index 807baf02c1..50d8c822c1 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -38,6 +38,8 @@ typedef struct {
#include "nvim/api/private/defs.h"
// for Map(K, V)
#include "nvim/map.h"
+// for kvec
+#include "nvim/lib/kvec.h"
#define MODIFIABLE(buf) (buf->b_p_ma)
@@ -771,6 +773,10 @@ struct file_buffer {
BufhlInfo b_bufhl_info; // buffer stored highlights
kvec_t(BufhlLine *) b_bufhl_move_space; // temporary space for highlights
+
+ // array of channelids which have asked to receive updates for this
+ // buffer.
+ kvec_t(uint64_t) update_channels;
};
/*
diff --git a/src/nvim/buffer_updates.c b/src/nvim/buffer_updates.c
new file mode 100644
index 0000000000..157f80e55a
--- /dev/null
+++ b/src/nvim/buffer_updates.c
@@ -0,0 +1,233 @@
+// This is an open source non-commercial project. Dear PVS-Studio, please check
+// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+#include "nvim/buffer_updates.h"
+#include "nvim/memline.h"
+#include "nvim/api/private/helpers.h"
+#include "nvim/msgpack_rpc/channel.h"
+#include "nvim/assert.h"
+
+// Register a channel. Return True if the channel was added, or already added.
+// Return False if the channel couldn't be added because the buffer is
+// unloaded.
+bool buf_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer)
+{
+ // must fail if the buffer isn't loaded
+ if (buf->b_ml.ml_mfp == NULL) {
+ return false;
+ }
+
+ // count how many channels are currently watching the buffer
+ size_t size = kv_size(buf->update_channels);
+ if (size) {
+ for (size_t i = 0; i < size; i++) {
+ if (kv_A(buf->update_channels, i) == channel_id) {
+ // buffer is already registered ... nothing to do
+ return true;
+ }
+ }
+ }
+
+ // append the channelid to the list
+ kv_push(buf->update_channels, channel_id);
+
+ if (send_buffer) {
+ Array args = ARRAY_DICT_INIT;
+ args.size = 6;
+ args.items = xcalloc(sizeof(Object), args.size);
+
+ // the first argument is always the buffer handle
+ args.items[0] = BUFFER_OBJ(buf->handle);
+ args.items[1] = INTEGER_OBJ(buf->b_changedtick);
+ // the first line that changed (zero-indexed)
+ args.items[2] = INTEGER_OBJ(0);
+ // the last line that was changed
+ args.items[3] = INTEGER_OBJ(-1);
+ Array linedata = ARRAY_DICT_INIT;
+
+ // collect buffer contents
+
+ // True now, but a compile time reminder for future systems we support
+ STATIC_ASSERT(SIZE_MAX >= MAXLNUM, "size_t to small to hold the number of"
+ " lines in a buffer");
+ size_t line_count = (size_t)buf->b_ml.ml_line_count;
+
+ if (line_count >= 1) {
+ linedata.size = line_count;
+ linedata.items = xcalloc(sizeof(Object), line_count);
+ for (size_t i = 0; i < line_count; i++) {
+ linenr_T lnum = 1 + (linenr_T)i;
+
+ const char *bufstr = (char *)ml_get_buf(buf, lnum, false);
+ Object str = STRING_OBJ(cstr_to_string(bufstr));
+
+ // Vim represents NULs as NLs, but this may confuse clients.
+ strchrsub(str.data.string.data, '\n', '\0');
+
+ linedata.items[i] = str;
+ }
+ }
+
+ args.items[4] = ARRAY_OBJ(linedata);
+ args.items[5] = BOOLEAN_OBJ(false);
+
+ rpc_send_event(channel_id, "nvim_buf_lines_event", args);
+ } else {
+ buf_updates_changedtick_single(buf, channel_id);
+ }
+
+ return true;
+}
+
+void buf_updates_send_end(buf_T *buf, uint64_t channelid)
+{
+ Array args = ARRAY_DICT_INIT;
+ args.size = 1;
+ args.items = xcalloc(sizeof(Object), args.size);
+ args.items[0] = BUFFER_OBJ(buf->handle);
+ rpc_send_event(channelid, "nvim_buf_detach_event", args);
+}
+
+void buf_updates_unregister(buf_T *buf, uint64_t channelid)
+{
+ size_t size = kv_size(buf->update_channels);
+ if (!size) {
+ return;
+ }
+
+ // go through list backwards and remove the channel id each time it appears
+ // (it should never appear more than once)
+ size_t j = 0;
+ size_t found = 0;
+ for (size_t i = 0; i < size; i++) {
+ if (kv_A(buf->update_channels, i) == channelid) {
+ found++;
+ } else {
+ // copy item backwards into prior slot if needed
+ if (i != j) {
+ kv_A(buf->update_channels, j) = kv_A(buf->update_channels, i);
+ }
+ j++;
+ }
+ }
+
+ if (found) {
+ // remove X items from the end of the array
+ buf->update_channels.size -= found;
+
+ // make a new copy of the active array without the channelid in it
+ buf_updates_send_end(buf, channelid);
+
+ if (found == size) {
+ kv_destroy(buf->update_channels);
+ kv_init(buf->update_channels);
+ }
+ }
+}
+
+void buf_updates_unregister_all(buf_T *buf)
+{
+ size_t size = kv_size(buf->update_channels);
+ if (size) {
+ for (size_t i = 0; i < size; i++) {
+ buf_updates_send_end(buf, kv_A(buf->update_channels, i));
+ }
+ kv_destroy(buf->update_channels);
+ kv_init(buf->update_channels);
+ }
+}
+
+void buf_updates_send_changes(buf_T *buf,
+ linenr_T firstline,
+ int64_t num_added,
+ int64_t num_removed,
+ bool send_tick)
+{
+ // if one the channels doesn't work, put its ID here so we can remove it later
+ uint64_t badchannelid = 0;
+
+ // notify each of the active channels
+ for (size_t i = 0; i < kv_size(buf->update_channels); i++) {
+ uint64_t channelid = kv_A(buf->update_channels, i);
+
+ // send through the changes now channel contents now
+ Array args = ARRAY_DICT_INIT;
+ args.size = 6;
+ args.items = xcalloc(sizeof(Object), args.size);
+
+ // the first argument is always the buffer handle
+ args.items[0] = BUFFER_OBJ(buf->handle);
+
+ // next argument is b:changedtick
+ args.items[1] = send_tick ? INTEGER_OBJ(buf->b_changedtick) : NIL;
+
+ // the first line that changed (zero-indexed)
+ args.items[2] = INTEGER_OBJ(firstline - 1);
+
+ // the last line that was changed
+ args.items[3] = INTEGER_OBJ(firstline - 1 + num_removed);
+
+ // linedata of lines being swapped in
+ Array linedata = ARRAY_DICT_INIT;
+ if (num_added > 0) {
+ // True now, but a compile time reminder for future systems we support
+ // Note that `num_added` is a `int64_t`, but still must be lower than
+ // `MAX_LNUM`
+ STATIC_ASSERT(SIZE_MAX >= MAXLNUM, "size_t to small to hold the number "
+ "of lines in a buffer");
+ linedata.size = (size_t)num_added;
+ linedata.items = xcalloc(sizeof(Object), (size_t)num_added);
+ for (int64_t i = 0; i < num_added; i++) {
+ int64_t lnum = firstline + i;
+ const char *bufstr = (char *)ml_get_buf(buf, (linenr_T)lnum, false);
+ Object str = STRING_OBJ(cstr_to_string(bufstr));
+
+ // Vim represents NULs as NLs, but this may confuse clients.
+ strchrsub(str.data.string.data, '\n', '\0');
+
+ linedata.items[i] = str;
+ }
+ }
+ args.items[4] = ARRAY_OBJ(linedata);
+ args.items[5] = BOOLEAN_OBJ(false);
+ if (!rpc_send_event(channelid, "nvim_buf_lines_event", args)) {
+ // We can't unregister the channel while we're iterating over the
+ // update_channels array, so we remember its ID to unregister it at
+ // the end.
+ badchannelid = channelid;
+ }
+ }
+
+ // We can only ever remove one dead channel at a time. This is OK because the
+ // change notifications are so frequent that many dead channels will be
+ // cleared up quickly.
+ if (badchannelid != 0) {
+ ELOG("Disabling buffer updates for dead channel %llu", badchannelid);
+ buf_updates_unregister(buf, badchannelid);
+ }
+}
+
+void buf_updates_changedtick(buf_T *buf)
+{
+ // notify each of the active channels
+ for (size_t i = 0; i < kv_size(buf->update_channels); i++) {
+ uint64_t channel_id = kv_A(buf->update_channels, i);
+ buf_updates_changedtick_single(buf, channel_id);
+ }
+}
+
+void buf_updates_changedtick_single(buf_T *buf, uint64_t channel_id)
+{
+ Array args = ARRAY_DICT_INIT;
+ args.size = 2;
+ args.items = xcalloc(sizeof(Object), args.size);
+
+ // the first argument is always the buffer handle
+ args.items[0] = BUFFER_OBJ(buf->handle);
+
+ // next argument is b:changedtick
+ args.items[1] = INTEGER_OBJ(buf->b_changedtick);
+
+ // don't try and clean up dead channels here
+ rpc_send_event(channel_id, "nvim_buf_changedtick_event", args);
+}
diff --git a/src/nvim/buffer_updates.h b/src/nvim/buffer_updates.h
new file mode 100644
index 0000000000..b2d0a62270
--- /dev/null
+++ b/src/nvim/buffer_updates.h
@@ -0,0 +1,10 @@
+#ifndef NVIM_BUFFER_UPDATES_H
+#define NVIM_BUFFER_UPDATES_H
+
+#include "nvim/buffer_defs.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "buffer_updates.h.generated.h"
+#endif
+
+#endif // NVIM_BUFFER_UPDATES_H
diff --git a/src/nvim/diff.c b/src/nvim/diff.c
index f9e40ed06f..61e0b76558 100644
--- a/src/nvim/diff.c
+++ b/src/nvim/diff.c
@@ -2344,7 +2344,7 @@ void ex_diffgetput(exarg_T *eap)
}
}
}
- changed_lines(lnum, 0, lnum + count, (long)added);
+ changed_lines(lnum, 0, lnum + count, (long)added, true);
if (dfree != NULL) {
// Diff is deleted, update folds in other windows.
diff --git a/src/nvim/event/wstream.c b/src/nvim/event/wstream.c
index d2fb52243c..2baa667e7d 100644
--- a/src/nvim/event/wstream.c
+++ b/src/nvim/event/wstream.c
@@ -14,7 +14,7 @@
#include "nvim/vim.h"
#include "nvim/memory.h"
-#define DEFAULT_MAXMEM 1024 * 1024 * 10
+#define DEFAULT_MAXMEM 1024 * 1024 * 2000
typedef struct {
Stream *stream;
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index f575d58f05..1d98f171b4 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -35,6 +35,7 @@
#include "nvim/fold.h"
#include "nvim/getchar.h"
#include "nvim/indent.h"
+#include "nvim/buffer_updates.h"
#include "nvim/main.h"
#include "nvim/mark.h"
#include "nvim/mbyte.h"
@@ -279,7 +280,7 @@ void ex_align(exarg_T *eap)
new_indent = 0;
(void)set_indent(new_indent, 0); /* set indent */
}
- changed_lines(eap->line1, 0, eap->line2 + 1, 0L);
+ changed_lines(eap->line1, 0, eap->line2 + 1, 0L, true);
curwin->w_cursor = save_curpos;
beginline(BL_WHITE | BL_FIX);
}
@@ -612,7 +613,7 @@ void ex_sort(exarg_T *eap)
} else if (deleted < 0) {
mark_adjust(eap->line2, MAXLNUM, -deleted, 0L, false);
}
- changed_lines(eap->line1, 0, eap->line2 + 1, -deleted);
+ changed_lines(eap->line1, 0, eap->line2 + 1, -deleted, true);
curwin->w_cursor.lnum = eap->line1;
beginline(BL_WHITE | BL_FIX);
@@ -744,8 +745,9 @@ void ex_retab(exarg_T *eap)
if (curbuf->b_p_ts != new_ts)
redraw_curbuf_later(NOT_VALID);
- if (first_line != 0)
- changed_lines(first_line, 0, last_line + 1, 0L);
+ if (first_line != 0) {
+ changed_lines(first_line, 0, last_line + 1, 0L, true);
+ }
curwin->w_p_list = save_list; /* restore 'list' */
@@ -806,6 +808,7 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
*/
last_line = curbuf->b_ml.ml_line_count;
mark_adjust_nofold(line1, line2, last_line - line2, 0L, true);
+ changed_lines(last_line - num_lines + 1, 0, last_line + 1, num_lines, false);
if (dest >= line2) {
mark_adjust_nofold(line2 + 1, dest, -num_lines, 0L, false);
FOR_ALL_TAB_WINDOWS(tab, win) {
@@ -828,6 +831,12 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
curbuf->b_op_start.col = curbuf->b_op_end.col = 0;
mark_adjust_nofold(last_line - num_lines + 1, last_line,
-(last_line - dest - extra), 0L, true);
+ changed_lines(last_line - num_lines + 1, 0, last_line + 1, -extra, false);
+
+ // send update regarding the new lines that were added
+ if (kv_size(curbuf->update_channels)) {
+ buf_updates_send_changes(curbuf, dest + 1, num_lines, 0, true);
+ }
/*
* Now we delete the original text -- webb
@@ -858,9 +867,14 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
last_line = curbuf->b_ml.ml_line_count;
if (dest > last_line + 1)
dest = last_line + 1;
- changed_lines(line1, 0, dest, 0L);
+ changed_lines(line1, 0, dest, 0L, false);
} else {
- changed_lines(dest + 1, 0, line1 + num_lines, 0L);
+ changed_lines(dest + 1, 0, line1 + num_lines, 0L, false);
+ }
+
+ // send nvim_buf_lines_event regarding lines that were deleted
+ if (kv_size(curbuf->update_channels)) {
+ buf_updates_send_changes(curbuf, line1 + extra, 0, num_lines, true);
}
return OK;
@@ -2428,6 +2442,7 @@ int do_ecmd(
goto theend;
}
u_unchanged(curbuf);
+ buf_updates_unregister_all(curbuf);
buf_freeall(curbuf, BFA_KEEP_UNDO);
// Tell readfile() not to clear or reload undo info.
@@ -3153,8 +3168,10 @@ static char_u *sub_parse_flags(char_u *cmd, subflags_T *subflags,
///
/// The usual escapes are supported as described in the regexp docs.
///
+/// @param do_buf_event If `true`, send buffer updates.
/// @return buffer used for 'inccommand' preview
-static buf_T *do_sub(exarg_T *eap, proftime_T timeout)
+static buf_T *do_sub(exarg_T *eap, proftime_T timeout,
+ bool do_buf_event)
{
long i = 0;
regmmatch_T regmatch;
@@ -4000,7 +4017,14 @@ skip:
* the line number before the change (same as adding the number of
* deleted lines). */
i = curbuf->b_ml.ml_line_count - old_line_count;
- changed_lines(first_line, 0, last_line - i, i);
+ changed_lines(first_line, 0, last_line - i, i, false);
+
+ if (kv_size(curbuf->update_channels)) {
+ int64_t num_added = last_line - first_line;
+ int64_t num_removed = num_added - i;
+ buf_updates_send_changes(curbuf, first_line, num_added, num_removed,
+ do_buf_event);
+ }
}
xfree(sub_firstline); /* may have to free allocated copy of the line */
@@ -6246,7 +6270,7 @@ void ex_substitute(exarg_T *eap)
{
bool preview = (State & CMDPREVIEW);
if (*p_icm == NUL || !preview) { // 'inccommand' is disabled
- (void)do_sub(eap, profile_zero());
+ (void)do_sub(eap, profile_zero(), true);
return;
}
@@ -6270,7 +6294,7 @@ void ex_substitute(exarg_T *eap)
// Don't show search highlighting during live substitution
bool save_hls = p_hls;
p_hls = false;
- buf_T *preview_buf = do_sub(eap, profile_setlimit(p_rdt));
+ buf_T *preview_buf = do_sub(eap, profile_setlimit(p_rdt), false);
p_hls = save_hls;
if (save_changedtick != curbuf->b_changedtick) {
diff --git a/src/nvim/fold.c b/src/nvim/fold.c
index 316fbef47c..52ed2fe3dc 100644
--- a/src/nvim/fold.c
+++ b/src/nvim/fold.c
@@ -20,6 +20,7 @@
#include "nvim/ex_docmd.h"
#include "nvim/func_attr.h"
#include "nvim/indent.h"
+#include "nvim/buffer_updates.h"
#include "nvim/mark.h"
#include "nvim/memline.h"
#include "nvim/memory.h"
@@ -742,8 +743,20 @@ deleteFold (
/* Deleting markers may make cursor column invalid. */
check_cursor_col();
- if (last_lnum > 0)
- changed_lines(first_lnum, (colnr_T)0, last_lnum, 0L);
+ if (last_lnum > 0) {
+ changed_lines(first_lnum, (colnr_T)0, last_lnum, 0L, false);
+
+ // send one nvim_buf_lines_event at the end
+ if (kv_size(curbuf->update_channels)) {
+ // last_lnum is the line *after* the last line of the outermost fold
+ // that was modified. Note also that deleting a fold might only require
+ // the modification of the *first* line of the fold, but we send through a
+ // notification that includes every line that was part of the fold
+ int64_t num_changed = last_lnum - first_lnum;
+ buf_updates_send_changes(curbuf, first_lnum, num_changed,
+ num_changed, true);
+ }
+ }
}
/* clearFolding() {{{2 */
@@ -1590,7 +1603,15 @@ static void foldCreateMarkers(linenr_T start, linenr_T end)
/* Update both changes here, to avoid all folds after the start are
* changed when the start marker is inserted and the end isn't. */
- changed_lines(start, (colnr_T)0, end, 0L);
+ changed_lines(start, (colnr_T)0, end, 0L, false);
+
+ if (kv_size(curbuf->update_channels)) {
+ // Note: foldAddMarker() may not actually change start and/or end if
+ // u_save() is unable to save the buffer line, but we send the
+ // nvim_buf_lines_event anyway since it won't do any harm.
+ int64_t num_changed = 1 + end - start;
+ buf_updates_send_changes(curbuf, start, num_changed, num_changed, true);
+ }
}
/* foldAddMarker() {{{2 */
diff --git a/src/nvim/generators/gen_api_dispatch.lua b/src/nvim/generators/gen_api_dispatch.lua
index 2ee1e5d4c5..15fcafb584 100644
--- a/src/nvim/generators/gen_api_dispatch.lua
+++ b/src/nvim/generators/gen_api_dispatch.lua
@@ -223,6 +223,11 @@ for i = 1, #functions do
output:write('\n } else if (args.items['..(j - 1)..'].type == kObjectTypeInteger && args.items['..(j - 1)..'].data.integer >= 0) {')
output:write('\n '..converted..' = (handle_T)args.items['..(j - 1)..'].data.integer;')
end
+ -- accept empty lua tables as empty dictionarys
+ if rt:match('^Dictionary') then
+ output:write('\n } else if (args.items['..(j - 1)..'].type == kObjectTypeArray && args.items['..(j - 1)..'].data.array.size == 0) {')
+ output:write('\n '..converted..' = (Dictionary)ARRAY_DICT_INIT;')
+ end
output:write('\n } else {')
output:write('\n api_set_error(error, kErrorTypeException, "Wrong type for argument '..j..', expecting '..param[1]..'");')
output:write('\n goto cleanup;')
diff --git a/src/nvim/misc1.c b/src/nvim/misc1.c
index dc59aa1281..70733e5564 100644
--- a/src/nvim/misc1.c
+++ b/src/nvim/misc1.c
@@ -28,6 +28,7 @@
#include "nvim/getchar.h"
#include "nvim/indent.h"
#include "nvim/indent_c.h"
+#include "nvim/buffer_updates.h"
#include "nvim/main.h"
#include "nvim/mark.h"
#include "nvim/mbyte.h"
@@ -836,8 +837,8 @@ open_line (
saved_line = NULL;
if (did_append) {
changed_lines(curwin->w_cursor.lnum, curwin->w_cursor.col,
- curwin->w_cursor.lnum + 1, 1L);
- did_append = FALSE;
+ curwin->w_cursor.lnum + 1, 1L, true);
+ did_append = false;
/* Move marks after the line break to the new line. */
if (flags & OPENLINE_MARKFIX)
@@ -854,8 +855,9 @@ open_line (
*/
curwin->w_cursor.lnum = old_cursor.lnum + 1;
}
- if (did_append)
- changed_lines(curwin->w_cursor.lnum, 0, curwin->w_cursor.lnum, 1L);
+ if (did_append) {
+ changed_lines(curwin->w_cursor.lnum, 0, curwin->w_cursor.lnum, 1L, true);
+ }
curwin->w_cursor.col = newcol;
curwin->w_cursor.coladd = 0;
@@ -1820,6 +1822,10 @@ void changed_bytes(linenr_T lnum, colnr_T col)
{
changedOneline(curbuf, lnum);
changed_common(lnum, col, lnum + 1, 0L);
+ // notify any channels that are watching
+ if (kv_size(curbuf->update_channels)) {
+ buf_updates_send_changes(curbuf, lnum, 1, 1, true);
+ }
/* Diff highlighting in other diff windows may need to be updated too. */
if (curwin->w_p_diff) {
@@ -1860,7 +1866,7 @@ static void changedOneline(buf_T *buf, linenr_T lnum)
*/
void appended_lines(linenr_T lnum, long count)
{
- changed_lines(lnum + 1, 0, lnum + 1, count);
+ changed_lines(lnum + 1, 0, lnum + 1, count, true);
}
/*
@@ -1873,7 +1879,7 @@ void appended_lines_mark(linenr_T lnum, long count)
if (lnum + count < curbuf->b_ml.ml_line_count || curwin->w_p_diff) {
mark_adjust(lnum + 1, (linenr_T)MAXLNUM, count, 0L, false);
}
- changed_lines(lnum + 1, 0, lnum + 1, count);
+ changed_lines(lnum + 1, 0, lnum + 1, count, true);
}
/*
@@ -1883,7 +1889,7 @@ void appended_lines_mark(linenr_T lnum, long count)
*/
void deleted_lines(linenr_T lnum, long count)
{
- changed_lines(lnum, 0, lnum + count, -count);
+ changed_lines(lnum, 0, lnum + count, -count, true);
}
/*
@@ -1894,7 +1900,7 @@ void deleted_lines(linenr_T lnum, long count)
void deleted_lines_mark(linenr_T lnum, long count)
{
mark_adjust(lnum, (linenr_T)(lnum + count - 1), (long)MAXLNUM, -count, false);
- changed_lines(lnum, 0, lnum + count, -count);
+ changed_lines(lnum, 0, lnum + count, -count, true);
}
/*
@@ -1909,12 +1915,16 @@ void deleted_lines_mark(linenr_T lnum, long count)
* Takes care of calling changed() and updating b_mod_*.
* Careful: may trigger autocommands that reload the buffer.
*/
-void
-changed_lines (
- linenr_T lnum, /* first line with change */
- colnr_T col, /* column in first line with change */
- linenr_T lnume, /* line below last changed line */
- long xtra /* number of extra lines (negative when deleting) */
+void
+changed_lines(
+ linenr_T lnum, // first line with change
+ colnr_T col, // column in first line with change
+ linenr_T lnume, // line below last changed line
+ long xtra, // number of extra lines (negative when deleting)
+ bool do_buf_event // some callers like undo/redo call changed_lines()
+ // and then increment b_changedtick *again*. This flag
+ // allows these callers to send the nvim_buf_lines_event
+ // events after they're done modifying b_changedtick.
)
{
changed_lines_buf(curbuf, lnum, lnume, xtra);
@@ -1938,6 +1948,12 @@ changed_lines (
}
changed_common(lnum, col, lnume, xtra);
+
+ if (do_buf_event && kv_size(curbuf->update_channels)) {
+ int64_t num_added = (int64_t)(lnume + xtra - lnum);
+ int64_t num_removed = lnume - lnum;
+ buf_updates_send_changes(curbuf, lnum, num_added, num_removed, true);
+ }
}
/// Mark line range in buffer as changed.
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index a2aaf8f9af..a995535da2 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -6140,7 +6140,7 @@ static void n_swapchar(cmdarg_T *cap)
curwin->w_set_curswant = true;
if (did_change) {
changed_lines(startpos.lnum, startpos.col, curwin->w_cursor.lnum + 1,
- 0L);
+ 0L, true);
curbuf->b_op_start = startpos;
curbuf->b_op_end = curwin->w_cursor;
if (curbuf->b_op_end.col > 0)
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index d874768dfc..c9e8344ac1 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -214,7 +214,7 @@ void op_shift(oparg_T *oap, int curs_top, int amount)
++curwin->w_cursor.lnum;
}
- changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L);
+ changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L, true);
if (oap->motion_type == kMTBlockWise) {
curwin->w_cursor.lnum = oap->start.lnum;
@@ -570,7 +570,7 @@ static void block_insert(oparg_T *oap, char_u *s, int b_insert, struct block_def
}
} /* for all lnum */
- changed_lines(oap->start.lnum + 1, 0, oap->end.lnum + 1, 0L);
+ changed_lines(oap->start.lnum + 1, 0, oap->end.lnum + 1, 0L, true);
State = oldstate;
}
@@ -632,12 +632,13 @@ void op_reindent(oparg_T *oap, Indenter how)
/* Mark changed lines so that they will be redrawn. When Visual
* highlighting was present, need to continue until the last line. When
* there is no change still need to remove the Visual highlighting. */
- if (last_changed != 0)
+ if (last_changed != 0) {
changed_lines(first_changed, 0,
- oap->is_VIsual ? start_lnum + oap->line_count :
- last_changed + 1, 0L);
- else if (oap->is_VIsual)
+ oap->is_VIsual ? start_lnum + oap->line_count :
+ last_changed + 1, 0L, true);
+ } else if (oap->is_VIsual) {
redraw_curbuf_later(INVERTED);
+ }
if (oap->line_count > p_report) {
i = oap->line_count - (i + 1);
@@ -1455,7 +1456,7 @@ int op_delete(oparg_T *oap)
check_cursor_col();
changed_lines(curwin->w_cursor.lnum, curwin->w_cursor.col,
- oap->end.lnum + 1, 0L);
+ oap->end.lnum + 1, 0L, true);
oap->line_count = 0; // no lines deleted
} else if (oap->motion_type == kMTLineWise) {
if (oap->op_type == OP_CHANGE) {
@@ -1822,7 +1823,7 @@ int op_replace(oparg_T *oap, int c)
curwin->w_cursor = oap->start;
check_cursor();
- changed_lines(oap->start.lnum, oap->start.col, oap->end.lnum + 1, 0L);
+ changed_lines(oap->start.lnum, oap->start.col, oap->end.lnum + 1, 0L, true);
/* Set "'[" and "']" marks. */
curbuf->b_op_start = oap->start;
@@ -1856,8 +1857,9 @@ void op_tilde(oparg_T *oap)
did_change |= one_change;
}
- if (did_change)
- changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L);
+ if (did_change) {
+ changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L, true);
+ }
} else { // not block mode
if (oap->motion_type == kMTLineWise) {
oap->start.col = 0;
@@ -1881,7 +1883,7 @@ void op_tilde(oparg_T *oap)
}
if (did_change) {
changed_lines(oap->start.lnum, oap->start.col, oap->end.lnum + 1,
- 0L);
+ 0L, true);
}
}
@@ -2264,7 +2266,7 @@ int op_change(oparg_T *oap)
}
}
check_cursor();
- changed_lines(oap->start.lnum + 1, 0, oap->end.lnum + 1, 0L);
+ changed_lines(oap->start.lnum + 1, 0, oap->end.lnum + 1, 0L, true);
xfree(ins_text);
}
}
@@ -3033,7 +3035,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
curwin->w_cursor.col += bd.startspaces;
}
- changed_lines(lnum, 0, curwin->w_cursor.lnum, nr_lines);
+ changed_lines(lnum, 0, curwin->w_cursor.lnum, nr_lines, true);
/* Set '[ mark. */
curbuf->b_op_start = curwin->w_cursor;
@@ -3210,10 +3212,10 @@ error:
// note changed text for displaying and folding
if (y_type == kMTCharWise) {
changed_lines(curwin->w_cursor.lnum, col,
- curwin->w_cursor.lnum + 1, nr_lines);
+ curwin->w_cursor.lnum + 1, nr_lines, true);
} else {
changed_lines(curbuf->b_op_start.lnum, 0,
- curbuf->b_op_start.lnum, nr_lines);
+ curbuf->b_op_start.lnum, nr_lines, true);
}
/* put '] mark at last inserted character */
@@ -3693,7 +3695,7 @@ int do_join(size_t count,
/* Only report the change in the first line here, del_lines() will report
* the deleted line. */
changed_lines(curwin->w_cursor.lnum, currsize,
- curwin->w_cursor.lnum + 1, 0L);
+ curwin->w_cursor.lnum + 1, 0L, true);
/*
* Delete following lines. To do this we move the cursor there
@@ -4363,7 +4365,7 @@ void op_addsub(oparg_T *oap, linenr_T Prenum1, bool g_cmd)
}
change_cnt = do_addsub(oap->op_type, &pos, 0, amount);
if (change_cnt) {
- changed_lines(pos.lnum, 0, pos.lnum + 1, 0L);
+ changed_lines(pos.lnum, 0, pos.lnum + 1, 0L, true);
}
} else {
int one_change;
@@ -4419,7 +4421,7 @@ void op_addsub(oparg_T *oap, linenr_T Prenum1, bool g_cmd)
}
}
if (change_cnt) {
- changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L);
+ changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L, true);
}
if (!change_cnt && oap->is_VIsual) {
diff --git a/src/nvim/terminal.c b/src/nvim/terminal.c
index 7f1bff75b4..c2370de0f8 100644
--- a/src/nvim/terminal.c
+++ b/src/nvim/terminal.c
@@ -1239,7 +1239,9 @@ static void refresh_screen(Terminal *term, buf_T *buf)
int change_start = row_to_linenr(term, term->invalid_start);
int change_end = change_start + changed;
- changed_lines(change_start, 0, change_end, added);
+ changed_lines(change_start, 0, change_end, added,
+ // Don't send nvim_buf_lines_event for :terminal buffer.
+ false);
term->invalid_start = INT_MAX;
term->invalid_end = -1;
}
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index e1ae4b4cc0..8b290edd1f 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -92,6 +92,7 @@
#include "nvim/eval.h"
#include "nvim/fileio.h"
#include "nvim/fold.h"
+#include "nvim/buffer_updates.h"
#include "nvim/mark.h"
#include "nvim/memline.h"
#include "nvim/message.h"
@@ -1672,7 +1673,7 @@ void u_undo(int count)
undo_undoes = TRUE;
else
undo_undoes = !undo_undoes;
- u_doit(count, false);
+ u_doit(count, false, true);
}
/*
@@ -1685,7 +1686,7 @@ void u_redo(int count)
undo_undoes = false;
}
- u_doit(count, false);
+ u_doit(count, false, true);
}
/// Undo and remove the branch from the undo tree.
@@ -1697,7 +1698,9 @@ bool u_undo_and_forget(int count)
count = 1;
}
undo_undoes = true;
- u_doit(count, true);
+ u_doit(count, true,
+ // Don't send nvim_buf_lines_event for u_undo_and_forget().
+ false);
if (curbuf->b_u_curhead == NULL) {
// nothing was undone.
@@ -1732,7 +1735,11 @@ bool u_undo_and_forget(int count)
}
/// Undo or redo, depending on `undo_undoes`, `count` times.
-static void u_doit(int startcount, bool quiet)
+///
+/// @param startcount How often to undo or redo
+/// @param quiet If `true`, don't show messages
+/// @param do_buf_event If `true`, send the changedtick with the buffer updates
+static void u_doit(int startcount, bool quiet, bool do_buf_event)
{
int count = startcount;
@@ -1768,7 +1775,7 @@ static void u_doit(int startcount, bool quiet)
break;
}
- u_undoredo(true);
+ u_undoredo(true, do_buf_event);
} else {
if (curbuf->b_u_curhead == NULL || get_undolevel() <= 0) {
beep_flush(); /* nothing to redo */
@@ -1779,7 +1786,7 @@ static void u_doit(int startcount, bool quiet)
break;
}
- u_undoredo(FALSE);
+ u_undoredo(false, do_buf_event);
/* Advance for next redo. Set "newhead" when at the end of the
* redoable changes. */
@@ -2026,8 +2033,8 @@ void undo_time(long step, int sec, int file, int absolute)
|| (uhp->uh_seq == target && !above))
break;
curbuf->b_u_curhead = uhp;
- u_undoredo(TRUE);
- uhp->uh_walk = nomark; /* don't go back down here */
+ u_undoredo(true, true);
+ uhp->uh_walk = nomark; // don't go back down here
}
/*
@@ -2082,7 +2089,7 @@ void undo_time(long step, int sec, int file, int absolute)
break;
}
- u_undoredo(FALSE);
+ u_undoredo(false, true);
/* Advance "curhead" to below the header we last used. If it
* becomes NULL then we need to set "newhead" to this leaf. */
@@ -2105,16 +2112,15 @@ void undo_time(long step, int sec, int file, int absolute)
u_undo_end(did_undo, absolute, false);
}
-/*
- * u_undoredo: common code for undo and redo
- *
- * The lines in the file are replaced by the lines in the entry list at
- * curbuf->b_u_curhead. The replaced lines in the file are saved in the entry
- * list for the next undo/redo.
- *
- * When "undo" is TRUE we go up in the tree, when FALSE we go down.
- */
-static void u_undoredo(int undo)
+/// u_undoredo: common code for undo and redo
+///
+/// The lines in the file are replaced by the lines in the entry list at
+/// curbuf->b_u_curhead. The replaced lines in the file are saved in the entry
+/// list for the next undo/redo.
+///
+/// @param undo If `true`, go up the tree. Down if `false`.
+/// @param do_buf_event If `true`, send buffer updates.
+static void u_undoredo(int undo, bool do_buf_event)
{
char_u **newarray = NULL;
linenr_T oldsize;
@@ -2242,7 +2248,7 @@ static void u_undoredo(int undo)
}
}
- changed_lines(top + 1, 0, bot, newsize - oldsize);
+ changed_lines(top + 1, 0, bot, newsize - oldsize, do_buf_event);
/* set '[ and '] mark */
if (top + 1 < curbuf->b_op_start.lnum)
@@ -2277,6 +2283,13 @@ static void u_undoredo(int undo)
unchanged(curbuf, FALSE);
}
+ // because the calls to changed()/unchanged() above will bump b_changedtick
+ // again, we need to send a nvim_buf_lines_event with just the new value of
+ // b:changedtick
+ if (do_buf_event && kv_size(curbuf->update_channels)) {
+ buf_updates_changedtick(curbuf);
+ }
+
/*
* restore marks from before undo/redo
*/
generated by cgit (git 2.34.1) at 2025-04-29 07:35:53 +0000