From 6bdcbef2f5acfd9815599c751bd8dcbe3204281f Mon Sep 17 00:00:00 2001 From: KillTheMule Date: Sun, 11 Feb 2018 22:51:29 +0100 Subject: The grand renaming --- src/nvim/CMakeLists.txt | 2 +- src/nvim/api/buffer.c | 28 +++---- src/nvim/buffer.c | 10 +-- src/nvim/buffer_defs.h | 4 +- src/nvim/buffer_updates.c | 202 ++++++++++++++++++++++++++++++++++++++++++++++ src/nvim/buffer_updates.h | 13 +++ src/nvim/ex_cmds.c | 24 +++--- src/nvim/fold.c | 14 ++-- src/nvim/liveupdate.c | 202 ---------------------------------------------- src/nvim/liveupdate.h | 13 --- src/nvim/misc1.c | 14 ++-- src/nvim/terminal.c | 2 +- src/nvim/undo.c | 20 ++--- 13 files changed, 274 insertions(+), 274 deletions(-) create mode 100644 src/nvim/buffer_updates.c create mode 100644 src/nvim/buffer_updates.h delete mode 100644 src/nvim/liveupdate.c delete mode 100644 src/nvim/liveupdate.h (limited to 'src') diff --git a/src/nvim/CMakeLists.txt b/src/nvim/CMakeLists.txt index a8a52a8093..97495eec6d 100644 --- a/src/nvim/CMakeLists.txt +++ b/src/nvim/CMakeLists.txt @@ -142,7 +142,7 @@ set(CONV_SOURCES message.c regexp.c screen.c - liveupdate.c + buffer_updates.c search.c spell.c spellfile.c diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c index 6778227a27..d59ce1ce3d 100644 --- a/src/nvim/api/buffer.c +++ b/src/nvim/api/buffer.c @@ -25,7 +25,7 @@ #include "nvim/window.h" #include "nvim/undo.h" #include "nvim/ex_docmd.h" -#include "nvim/liveupdate.h" +#include "nvim/buffer_updates.h" #ifdef INCLUDE_GENERATED_DECLARATIONS # include "api/buffer.c.generated.h" @@ -76,18 +76,18 @@ String buffer_get_line(Buffer buffer, Integer index, Error *err) return rv; } -/// Activate live updates from this buffer to the current channel. +/// 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 /// @param[out] err Details of an error that may have occurred -/// @return False when live updates couldn't be enabled because the buffer isn't +/// @return False when updates couldn't be enabled because the buffer isn't /// loaded; otherwise True. -Boolean nvim_buf_live_updates_start(uint64_t channel_id, - Buffer buffer, - Boolean send_buffer, - Error *err) +Boolean nvim_buf_attach(uint64_t channel_id, + Buffer buffer, + Boolean send_buffer, + Error *err) FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY { buf_T *buf = find_buffer_by_handle(buffer, err); @@ -96,18 +96,18 @@ Boolean nvim_buf_live_updates_start(uint64_t channel_id, return false; } - return liveupdate_register(buf, channel_id, send_buffer); + return buffer_updates_register(buf, channel_id, send_buffer); } // -/// Deactivate live updates from this buffer to the current channel. +/// 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 live updates couldn't be disabled because the buffer +/// @return False when updates couldn't be disabled because the buffer /// isn't loaded; otherwise True. -Boolean nvim_buf_live_updates_stop(uint64_t channel_id, - Buffer buffer, - Error *err) +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); @@ -116,7 +116,7 @@ Boolean nvim_buf_live_updates_stop(uint64_t channel_id, return false; } - liveupdate_unregister(buf, channel_id); + buffer_updates_unregister(buf, channel_id); return true; } diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c index e7ff25ce6b..e5b7128248 100644 --- a/src/nvim/buffer.c +++ b/src/nvim/buffer.c @@ -73,7 +73,7 @@ #include "nvim/os/os.h" #include "nvim/os/time.h" #include "nvim/os/input.h" -#include "nvim/liveupdate.h" +#include "nvim/buffer_updates.h" typedef enum { kBLSUnchanged = 0, @@ -576,7 +576,7 @@ void close_buffer(win_T *win, buf_T *buf, int action, int abort_if_last) do_autochdir(); // disable live updates for the current buffer - liveupdate_unregister_all(buf); + buffer_updates_unregister_all(buf); /* * Remove the buffer from the list. @@ -789,7 +789,7 @@ free_buffer_stuff ( xfree(buf->b_start_fenc); buf->b_start_fenc = NULL; - liveupdate_unregister_all(buf); + buffer_updates_unregister_all(buf); } /* @@ -1741,8 +1741,8 @@ buf_T * buflist_new(char_u *ffname, char_u *sfname, linenr_T lnum, int flags) 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->liveupdate_channels); - kv_init(buf->liveupdate_channels); + 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 9f6ac15308..50d8c822c1 100644 --- a/src/nvim/buffer_defs.h +++ b/src/nvim/buffer_defs.h @@ -774,9 +774,9 @@ struct file_buffer { kvec_t(BufhlLine *) b_bufhl_move_space; // temporary space for highlights - // array of channelids which have asked to receive live updates for this + // array of channelids which have asked to receive updates for this // buffer. - kvec_t(uint64_t) liveupdate_channels; + 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..d7bb11d125 --- /dev/null +++ b/src/nvim/buffer_updates.c @@ -0,0 +1,202 @@ +#include "nvim/buffer_updates.h" +#include "nvim/memline.h" +#include "nvim/api/private/helpers.h" +#include "nvim/msgpack_rpc/channel.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 buffer_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); + + Array linedata = ARRAY_DICT_INIT; + if (send_buffer) { + // collect buffer contents + size_t line_count = buf->b_ml.ml_line_count; + 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; + } + } + + Array args = ARRAY_DICT_INIT; + args.size = 4; + 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); + args.items[2] = ARRAY_OBJ(linedata); + args.items[3] = BOOLEAN_OBJ(false); + + rpc_send_event(channel_id, "nvim_buf_updates_start", args); + return true; +} + +void buffer_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_updates_end", args); +} + +void buffer_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 + buffer_updates_send_end(buf, channelid); + + if (found == size) { + kv_destroy(buf->update_channels); + kv_init(buf->update_channels); + } + } +} + +void buffer_updates_unregister_all(buf_T *buf) +{ + size_t size = kv_size(buf->update_channels); + if (size) { + for (size_t i = 0; i < size; i++) { + buffer_updates_send_end(buf, kv_A(buf->update_channels, i)); + } + kv_destroy(buf->update_channels); + kv_init(buf->update_channels); + } +} + +void buffer_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 = 5; + 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) { + linedata.size = num_added; + linedata.items = xcalloc(sizeof(Object), 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); + if (!rpc_send_event(channelid, "nvim_buf_update", 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 live updates for dead channel %llu", badchannelid); + buffer_updates_unregister(buf, badchannelid); + } +} + +void buffer_updates_send_tick(buf_T *buf) +{ + // 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 = 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(channelid, "nvim_buf_update_tick", args); + } +} diff --git a/src/nvim/buffer_updates.h b/src/nvim/buffer_updates.h new file mode 100644 index 0000000000..8fe33a0ebe --- /dev/null +++ b/src/nvim/buffer_updates.h @@ -0,0 +1,13 @@ +#ifndef BUFFER_UPDATES_H +#define BUFFER_UPDATES_H + +#include "nvim/buffer_defs.h" + +bool buffer_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer); +void buffer_updates_unregister(buf_T *buf, uint64_t channel_id); +void buffer_updates_unregister_all(buf_T *buf); +void buffer_updates_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added, + int64_t num_removed, bool send_tick); +void buffer_updates_send_tick(buf_T *buf); + +#endif // NVIM_BUFFER_UPDATES_H diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c index e418e0c20e..fdb8c87213 100644 --- a/src/nvim/ex_cmds.c +++ b/src/nvim/ex_cmds.c @@ -35,7 +35,7 @@ #include "nvim/fold.h" #include "nvim/getchar.h" #include "nvim/indent.h" -#include "nvim/liveupdate.h" +#include "nvim/buffer_updates.h" #include "nvim/main.h" #include "nvim/mark.h" #include "nvim/mbyte.h" @@ -833,9 +833,9 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest) -(last_line - dest - extra), 0L, true); changed_lines(last_line - num_lines + 1, 0, last_line + 1, -extra, false); - // send live update regarding the new lines that were added - if (kv_size(curbuf->liveupdate_channels)) { - liveupdate_send_changes(curbuf, dest + 1, num_lines, 0, true); + // send update regarding the new lines that were added + if (kv_size(curbuf->update_channels)) { + buffer_updates_send_changes(curbuf, dest + 1, num_lines, 0, true); } /* @@ -872,9 +872,9 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest) changed_lines(dest + 1, 0, line1 + num_lines, 0L, false); } - // send LiveUpdate regarding lines that were deleted - if (kv_size(curbuf->liveupdate_channels)) { - liveupdate_send_changes(curbuf, line1 + extra, 0, num_lines, true); + // send nvim_buf_update regarding lines that were deleted + if (kv_size(curbuf->update_channels)) { + buffer_updates_send_changes(curbuf, line1 + extra, 0, num_lines, true); } return OK; @@ -2442,7 +2442,7 @@ int do_ecmd( goto theend; } u_unchanged(curbuf); - liveupdate_unregister_all(curbuf); + buffer_updates_unregister_all(curbuf); buf_freeall(curbuf, BFA_KEEP_UNDO); // Tell readfile() not to clear or reload undo info. @@ -3170,7 +3170,7 @@ static char_u *sub_parse_flags(char_u *cmd, subflags_T *subflags, /// /// @return buffer used for 'inccommand' preview static buf_T *do_sub(exarg_T *eap, proftime_T timeout, - bool send_liveupdate_changedtick) + bool send_buffer_update_changedtick) { long i = 0; regmmatch_T regmatch; @@ -4018,11 +4018,11 @@ skip: i = curbuf->b_ml.ml_line_count - old_line_count; changed_lines(first_line, 0, last_line - i, i, false); - if (kv_size(curbuf->liveupdate_channels)) { + if (kv_size(curbuf->update_channels)) { int64_t num_added = last_line - first_line; int64_t num_removed = num_added - i; - liveupdate_send_changes(curbuf, first_line, num_added, num_removed, - send_liveupdate_changedtick); + buffer_updates_send_changes(curbuf, first_line, num_added, num_removed, + send_buffer_update_changedtick); } } diff --git a/src/nvim/fold.c b/src/nvim/fold.c index 5758a298ac..2cf1c6f394 100644 --- a/src/nvim/fold.c +++ b/src/nvim/fold.c @@ -20,7 +20,7 @@ #include "nvim/ex_docmd.h" #include "nvim/func_attr.h" #include "nvim/indent.h" -#include "nvim/liveupdate.h" +#include "nvim/buffer_updates.h" #include "nvim/mark.h" #include "nvim/memline.h" #include "nvim/memory.h" @@ -746,14 +746,14 @@ deleteFold ( if (last_lnum > 0) { changed_lines(first_lnum, (colnr_T)0, last_lnum, 0L, false); - // send one LiveUpdate at the end - if (kv_size(curbuf->liveupdate_channels)) { + // send one nvim_buf_update 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; - liveupdate_send_changes(curbuf, first_lnum, num_changed, + buffer_updates_send_changes(curbuf, first_lnum, num_changed, num_changed, true); } } @@ -1605,12 +1605,12 @@ static void foldCreateMarkers(linenr_T start, linenr_T end) * changed when the start marker is inserted and the end isn't. */ changed_lines(start, (colnr_T)0, end, 0L, false); - if (kv_size(curbuf->liveupdate_channels)) { + 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 LiveUpdate + // u_save() is unable to save the buffer line, but we send the nvim_buf_update // anyway since it won't do any harm. int64_t num_changed = 1 + end - start; - liveupdate_send_changes(curbuf, start, num_changed, num_changed, true); + buffer_updates_send_changes(curbuf, start, num_changed, num_changed, true); } } diff --git a/src/nvim/liveupdate.c b/src/nvim/liveupdate.c deleted file mode 100644 index d587567e3f..0000000000 --- a/src/nvim/liveupdate.c +++ /dev/null @@ -1,202 +0,0 @@ -#include "nvim/liveupdate.h" -#include "nvim/memline.h" -#include "nvim/api/private/helpers.h" -#include "nvim/msgpack_rpc/channel.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 liveupdate_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->liveupdate_channels); - if (size) { - for (size_t i = 0; i < size; i++) { - if (kv_A(buf->liveupdate_channels, i) == channel_id) { - // buffer is already registered ... nothing to do - return true; - } - } - } - - // append the channelid to the list - kv_push(buf->liveupdate_channels, channel_id); - - Array linedata = ARRAY_DICT_INIT; - if (send_buffer) { - // collect buffer contents - size_t line_count = buf->b_ml.ml_line_count; - 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; - } - } - - Array args = ARRAY_DICT_INIT; - args.size = 4; - 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); - args.items[2] = ARRAY_OBJ(linedata); - args.items[3] = BOOLEAN_OBJ(false); - - rpc_send_event(channel_id, "LiveUpdateStart", args); - return true; -} - -void liveupdate_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, "LiveUpdateEnd", args); -} - -void liveupdate_unregister(buf_T *buf, uint64_t channelid) -{ - size_t size = kv_size(buf->liveupdate_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->liveupdate_channels, i) == channelid) { - found++; - } else { - // copy item backwards into prior slot if needed - if (i != j) { - kv_A(buf->liveupdate_channels, j) = kv_A(buf->liveupdate_channels, i); - } - j++; - } - } - - if (found) { - // remove X items from the end of the array - buf->liveupdate_channels.size -= found; - - // make a new copy of the active array without the channelid in it - liveupdate_send_end(buf, channelid); - - if (found == size) { - kv_destroy(buf->liveupdate_channels); - kv_init(buf->liveupdate_channels); - } - } -} - -void liveupdate_unregister_all(buf_T *buf) -{ - size_t size = kv_size(buf->liveupdate_channels); - if (size) { - for (size_t i = 0; i < size; i++) { - liveupdate_send_end(buf, kv_A(buf->liveupdate_channels, i)); - } - kv_destroy(buf->liveupdate_channels); - kv_init(buf->liveupdate_channels); - } -} - -void liveupdate_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->liveupdate_channels); i++) { - uint64_t channelid = kv_A(buf->liveupdate_channels, i); - - // send through the changes now channel contents now - Array args = ARRAY_DICT_INIT; - args.size = 5; - 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) { - linedata.size = num_added; - linedata.items = xcalloc(sizeof(Object), 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); - if (!rpc_send_event(channelid, "LiveUpdate", args)) { - // We can't unregister the channel while we're iterating over the - // liveupdate_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 live updates for dead channel %llu", badchannelid); - liveupdate_unregister(buf, badchannelid); - } -} - -void liveupdate_send_tick(buf_T *buf) -{ - // notify each of the active channels - for (size_t i = 0; i < kv_size(buf->liveupdate_channels); i++) { - uint64_t channelid = kv_A(buf->liveupdate_channels, i); - - // send through the changes now channel contents now - 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(channelid, "LiveUpdateTick", args); - } -} diff --git a/src/nvim/liveupdate.h b/src/nvim/liveupdate.h deleted file mode 100644 index 77fb420bf0..0000000000 --- a/src/nvim/liveupdate.h +++ /dev/null @@ -1,13 +0,0 @@ -#ifndef NVIM_LIVEUPDATE_H -#define NVIM_LIVEUPDATE_H - -#include "nvim/buffer_defs.h" - -bool liveupdate_register(buf_T *buf, uint64_t channel_id, bool send_buffer); -void liveupdate_unregister(buf_T *buf, uint64_t channel_id); -void liveupdate_unregister_all(buf_T *buf); -void liveupdate_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added, - int64_t num_removed, bool send_tick); -void liveupdate_send_tick(buf_T *buf); - -#endif // NVIM_LIVEUPDATE_H diff --git a/src/nvim/misc1.c b/src/nvim/misc1.c index e2094d7293..7c9e728c92 100644 --- a/src/nvim/misc1.c +++ b/src/nvim/misc1.c @@ -28,7 +28,7 @@ #include "nvim/getchar.h" #include "nvim/indent.h" #include "nvim/indent_c.h" -#include "nvim/liveupdate.h" +#include "nvim/buffer_updates.h" #include "nvim/main.h" #include "nvim/mark.h" #include "nvim/mbyte.h" @@ -1822,8 +1822,8 @@ 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->liveupdate_channels)) { - liveupdate_send_changes(curbuf, lnum, 1, 1, true); + if (kv_size(curbuf->update_channels)) { + buffer_updates_send_changes(curbuf, lnum, 1, 1, true); } /* Diff highlighting in other diff windows may need to be updated too. */ @@ -1920,9 +1920,9 @@ changed_lines( 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 send_liveupdate // some callers like undo/redo call changed_lines() + bool send_update // some callers like undo/redo call changed_lines() // and then increment b_changedtick *again*. This flag - // allows these callers to send the LiveUpdate events + // allows these callers to send the nvim_buf_update events // after they're done modifying b_changedtick. ) { @@ -1948,10 +1948,10 @@ changed_lines( changed_common(lnum, col, lnume, xtra); - if (send_liveupdate && kv_size(curbuf->liveupdate_channels)) { + if (send_update && kv_size(curbuf->update_channels)) { int64_t num_added = (int64_t)(lnume + xtra - lnum); int64_t num_removed = lnume - lnum; - liveupdate_send_changes(curbuf, lnum, num_added, num_removed, true); + buffer_updates_send_changes(curbuf, lnum, num_added, num_removed, true); } } diff --git a/src/nvim/terminal.c b/src/nvim/terminal.c index 735f5a3829..9ab537d8b9 100644 --- a/src/nvim/terminal.c +++ b/src/nvim/terminal.c @@ -1234,7 +1234,7 @@ 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; - // Note: don't send LiveUpdate event for a :terminal buffer + // Note: don't send nvim_buf_update event for a :terminal buffer changed_lines(change_start, 0, change_end, added, false); term->invalid_start = INT_MAX; term->invalid_end = -1; diff --git a/src/nvim/undo.c b/src/nvim/undo.c index 1c14e93211..9da9693c90 100644 --- a/src/nvim/undo.c +++ b/src/nvim/undo.c @@ -92,7 +92,7 @@ #include "nvim/eval.h" #include "nvim/fileio.h" #include "nvim/fold.h" -#include "nvim/liveupdate.h" +#include "nvim/buffer_updates.h" #include "nvim/mark.h" #include "nvim/memline.h" #include "nvim/message.h" @@ -1698,7 +1698,7 @@ bool u_undo_and_forget(int count) count = 1; } undo_undoes = true; - // don't send a LiveUpdate for this undo is part of 'inccommand' playing with + // don't send a nvim_buf_update for this undo is part of 'inccommand' playing with // buffer contents u_doit(count, true, false); @@ -1735,7 +1735,7 @@ bool u_undo_and_forget(int count) } /// Undo or redo, depending on `undo_undoes`, `count` times. -static void u_doit(int startcount, bool quiet, bool send_liveupdate) +static void u_doit(int startcount, bool quiet, bool send_update) { int count = startcount; @@ -1771,7 +1771,7 @@ static void u_doit(int startcount, bool quiet, bool send_liveupdate) break; } - u_undoredo(true, send_liveupdate); + u_undoredo(true, send_update); } else { if (curbuf->b_u_curhead == NULL || get_undolevel() <= 0) { beep_flush(); /* nothing to redo */ @@ -1782,7 +1782,7 @@ static void u_doit(int startcount, bool quiet, bool send_liveupdate) break; } - u_undoredo(false, send_liveupdate); + u_undoredo(false, send_update); /* Advance for next redo. Set "newhead" when at the end of the * redoable changes. */ @@ -2117,7 +2117,7 @@ void undo_time(long step, int sec, int file, int absolute) * * When "undo" is TRUE we go up in the tree, when FALSE we go down. */ -static void u_undoredo(int undo, bool send_liveupdate) +static void u_undoredo(int undo, bool send_update) { char_u **newarray = NULL; linenr_T oldsize; @@ -2245,7 +2245,7 @@ static void u_undoredo(int undo, bool send_liveupdate) } } - changed_lines(top + 1, 0, bot, newsize - oldsize, send_liveupdate); + changed_lines(top + 1, 0, bot, newsize - oldsize, send_update); /* set '[ and '] mark */ if (top + 1 < curbuf->b_op_start.lnum) @@ -2281,10 +2281,10 @@ static void u_undoredo(int undo, bool send_liveupdate) } // because the calls to changed()/unchanged() above will bump b_changedtick - // again, we need to send a LiveUpdate with just the new value of + // again, we need to send a nvim_buf_update with just the new value of // b:changedtick - if (send_liveupdate && kv_size(curbuf->liveupdate_channels)) { - liveupdate_send_tick(curbuf); + if (send_update && kv_size(curbuf->update_channels)) { + buffer_updates_send_tick(curbuf); } /* -- cgit