From edcc73e766438facc88db19000f054aa52ab8b13 Mon Sep 17 00:00:00 2001 From: Peter Hodge Date: Fri, 26 Jan 2018 20:36:11 +0100 Subject: API: Implement buffer updates Originally written by @phodge in https://github.com/neovim/neovim/pull/5269. --- src/nvim/CMakeLists.txt | 1 + src/nvim/api/buffer.c | 31 +++++++- src/nvim/buffer.c | 8 ++ src/nvim/buffer_defs.h | 6 ++ src/nvim/diff.c | 2 +- src/nvim/ex_cmds.c | 40 +++++++--- src/nvim/fold.c | 27 ++++++- src/nvim/liveupdate.c | 195 ++++++++++++++++++++++++++++++++++++++++++++++++ src/nvim/liveupdate.h | 13 ++++ src/nvim/misc1.c | 32 ++++++-- src/nvim/normal.c | 2 +- src/nvim/ops.c | 30 ++++---- src/nvim/terminal.c | 3 +- src/nvim/undo.c | 30 +++++--- 14 files changed, 371 insertions(+), 49 deletions(-) create mode 100644 src/nvim/liveupdate.c create mode 100644 src/nvim/liveupdate.h (limited to 'src') diff --git a/src/nvim/CMakeLists.txt b/src/nvim/CMakeLists.txt index 2d803792c8..a8a52a8093 100644 --- a/src/nvim/CMakeLists.txt +++ b/src/nvim/CMakeLists.txt @@ -142,6 +142,7 @@ set(CONV_SOURCES message.c regexp.c screen.c + liveupdate.c search.c spell.c spellfile.c diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c index fa4ad27e60..159683db9e 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/liveupdate.h" #ifdef INCLUDE_GENERATED_DECLARATIONS # include "api/buffer.c.generated.h" @@ -75,6 +76,34 @@ String buffer_get_line(Buffer buffer, Integer index, Error *err) return rv; } +/// Activate live updates from this buffer to the current channel. +/// +/// +/// @param buffer The buffer handle +/// @param enabled True turns on live updates, False turns them off. +/// @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 +/// loaded; otherwise True. +Boolean nvim_buf_live_updates(uint64_t channel_id, + Buffer buffer, + Boolean enabled, + Error *err) + FUNC_API_SINCE(3) FUNC_API_REMOTE_ONLY +{ + buf_T *buf = find_buffer_by_handle(buffer, err); + + if (!buf) { + return false; + } + + if (enabled) { + return liveupdate_register(buf, channel_id); + } + + liveupdate_unregister(buf, channel_id); + return true; +} + /// Sets a buffer line /// /// @deprecated use nvim_buf_set_lines instead. @@ -407,7 +436,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..124e479686 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/liveupdate.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 live updates for the current buffer + liveupdate_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; + + liveupdate_unregister_all(buf); } /* @@ -1735,6 +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); 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..9f6ac15308 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 live updates for this + // buffer. + kvec_t(uint64_t) liveupdate_channels; }; /* 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/ex_cmds.c b/src/nvim/ex_cmds.c index f575d58f05..d68dbc8676 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/liveupdate.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); @@ -745,7 +746,7 @@ 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); + changed_lines(first_line, 0, last_line + 1, 0L, true); curwin->w_p_list = save_list; /* restore 'list' */ @@ -806,6 +807,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 +830,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 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); + } /* * Now we delete the original text -- webb @@ -858,9 +866,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 LiveUpdate regarding lines that were deleted + if (kv_size(curbuf->liveupdate_channels)) { + liveupdate_send_changes(curbuf, line1 + extra, 0, num_lines, true); } return OK; @@ -2428,6 +2441,7 @@ int do_ecmd( goto theend; } u_unchanged(curbuf); + liveupdate_unregister_all(curbuf); buf_freeall(curbuf, BFA_KEEP_UNDO); // Tell readfile() not to clear or reload undo info. @@ -3154,7 +3168,8 @@ static char_u *sub_parse_flags(char_u *cmd, subflags_T *subflags, /// The usual escapes are supported as described in the regexp docs. /// /// @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 send_liveupdate_changedtick) { long i = 0; regmmatch_T regmatch; @@ -4000,7 +4015,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->liveupdate_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); + } } xfree(sub_firstline); /* may have to free allocated copy of the line */ @@ -6246,7 +6268,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 +6292,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 ad9cd4d562..5758a298ac 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/liveupdate.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 LiveUpdate at the end + if (kv_size(curbuf->liveupdate_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, + 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->liveupdate_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 + // 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); + } } /* foldAddMarker() {{{2 */ diff --git a/src/nvim/liveupdate.c b/src/nvim/liveupdate.c new file mode 100644 index 0000000000..79318e4255 --- /dev/null +++ b/src/nvim/liveupdate.c @@ -0,0 +1,195 @@ +#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) +{ + // 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); + + // send through the full channel contents now + Array linedata = ARRAY_DICT_INIT; + 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); + + channel_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); + channel_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); + } +} + +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); + + // how many lines are being swapped out + args.items[3] = INTEGER_OBJ(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 (!channel_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 + channel_send_event(channelid, "LiveUpdateTick", args); + } +} diff --git a/src/nvim/liveupdate.h b/src/nvim/liveupdate.h new file mode 100644 index 0000000000..bbee4b3766 --- /dev/null +++ b/src/nvim/liveupdate.h @@ -0,0 +1,13 @@ +#ifndef NVIM_LIVEUPDATE_H +#define NVIM_LIVEUPDATE_H + +#include "nvim/buffer_defs.h" + +bool liveupdate_register(buf_T *buf, uint64_t channel_id); +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 28455f0ba9..a3b2d5e7a4 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/liveupdate.h" #include "nvim/main.h" #include "nvim/mark.h" #include "nvim/mbyte.h" @@ -835,7 +836,7 @@ open_line ( saved_line = NULL; if (did_append) { changed_lines(curwin->w_cursor.lnum, curwin->w_cursor.col, - curwin->w_cursor.lnum + 1, 1L); + curwin->w_cursor.lnum + 1, 1L, true); did_append = FALSE; /* Move marks after the line break to the new line. */ @@ -853,8 +854,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; @@ -1819,6 +1821,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->liveupdate_channels)) { + liveupdate_send_changes(curbuf, lnum, 1, 1, true); + } /* Diff highlighting in other diff windows may need to be updated too. */ if (curwin->w_p_diff) { @@ -1859,7 +1865,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); } /* @@ -1872,7 +1878,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); } /* @@ -1882,7 +1888,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); } /* @@ -1893,7 +1899,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); } /* @@ -1913,7 +1919,11 @@ 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) */ + long xtra, /* number of extra lines (negative when deleting) */ + bool send_liveupdate // some callers like undo/redo call changed_lines() + // and then increment b_changedtick *again*. This flag + // allows these callers to send the LiveUpdate events + // after they're done modifying b_changedtick. ) { changed_lines_buf(curbuf, lnum, lnume, xtra); @@ -1937,6 +1947,12 @@ changed_lines ( } changed_common(lnum, col, lnume, xtra); + + if (send_liveupdate && kv_size(curbuf->liveupdate_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); + } } /// 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..692713af73 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; } @@ -634,8 +634,8 @@ void op_reindent(oparg_T *oap, Indenter how) * there is no change still need to remove the Visual highlighting. */ if (last_changed != 0) changed_lines(first_changed, 0, - oap->is_VIsual ? start_lnum + oap->line_count : - last_changed + 1, 0L); + oap->is_VIsual ? start_lnum + oap->line_count : + last_changed + 1, 0L, true); else if (oap->is_VIsual) redraw_curbuf_later(INVERTED); @@ -1455,7 +1455,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 +1822,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; @@ -1857,7 +1857,7 @@ void op_tilde(oparg_T *oap) } if (did_change) - changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L); + 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 +1881,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 +2264,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 +3033,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 +3210,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 +3693,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 +4363,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 +4419,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 39cb2b6372..735f5a3829 100644 --- a/src/nvim/terminal.c +++ b/src/nvim/terminal.c @@ -1234,7 +1234,8 @@ 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); + // Note: don't send LiveUpdate 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 e1ae4b4cc0..27d745a254 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/liveupdate.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); + // don't send a LiveUpdate for this undo is part of 'inccommand' playing with + // buffer contents + u_doit(count, true, false); if (curbuf->b_u_curhead == NULL) { // nothing was undone. @@ -1732,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) +static void u_doit(int startcount, bool quiet, bool send_liveupdate) { int count = startcount; @@ -1768,7 +1771,7 @@ static void u_doit(int startcount, bool quiet) break; } - u_undoredo(true); + u_undoredo(true, send_liveupdate); } else { if (curbuf->b_u_curhead == NULL || get_undolevel() <= 0) { beep_flush(); /* nothing to redo */ @@ -1779,7 +1782,7 @@ static void u_doit(int startcount, bool quiet) break; } - u_undoredo(FALSE); + u_undoredo(false, send_liveupdate); /* Advance for next redo. Set "newhead" when at the end of the * redoable changes. */ @@ -2026,7 +2029,7 @@ 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); + u_undoredo(true, true); uhp->uh_walk = nomark; /* don't go back down here */ } @@ -2082,7 +2085,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. */ @@ -2114,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) +static void u_undoredo(int undo, bool send_liveupdate) { char_u **newarray = NULL; linenr_T oldsize; @@ -2242,7 +2245,7 @@ static void u_undoredo(int undo) } } - changed_lines(top + 1, 0, bot, newsize - oldsize); + changed_lines(top + 1, 0, bot, newsize - oldsize, send_liveupdate); /* set '[ and '] mark */ if (top + 1 < curbuf->b_op_start.lnum) @@ -2277,6 +2280,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 LiveUpdate with just the new value of + // b:changedtick + if (send_liveupdate && kv_size(curbuf->liveupdate_channels)) { + liveupdate_send_tick(curbuf); + } + /* * restore marks from before undo/redo */ -- cgit From 9e97f14de2e693a204db39331d59778f1b4802a6 Mon Sep 17 00:00:00 2001 From: KillTheMule Date: Fri, 26 Jan 2018 14:44:38 +0100 Subject: Update to latest master --- src/nvim/liveupdate.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'src') diff --git a/src/nvim/liveupdate.c b/src/nvim/liveupdate.c index 79318e4255..953c5b52b3 100644 --- a/src/nvim/liveupdate.c +++ b/src/nvim/liveupdate.c @@ -54,7 +54,7 @@ bool liveupdate_register(buf_T *buf, uint64_t channel_id) args.items[2] = ARRAY_OBJ(linedata); args.items[3] = BOOLEAN_OBJ(false); - channel_send_event(channel_id, "LiveUpdateStart", args); + rpc_send_event(channel_id, "LiveUpdateStart", args); return true; } @@ -64,7 +64,7 @@ void liveupdate_send_end(buf_T *buf, uint64_t channelid) args.size = 1; args.items = xcalloc(sizeof(Object), args.size); args.items[0] = BUFFER_OBJ(buf->handle); - channel_send_event(channelid, "LiveUpdateEnd", args); + rpc_send_event(channelid, "LiveUpdateEnd", args); } void liveupdate_unregister(buf_T *buf, uint64_t channelid) @@ -155,7 +155,7 @@ void liveupdate_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added, } } args.items[4] = ARRAY_OBJ(linedata); - if (!channel_send_event(channelid, "LiveUpdate", args)) { + 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. @@ -190,6 +190,6 @@ void liveupdate_send_tick(buf_T *buf) args.items[1] = INTEGER_OBJ(buf->b_changedtick); // don't try and clean up dead channels here - channel_send_event(channelid, "LiveUpdateTick", args); + rpc_send_event(channelid, "LiveUpdateTick", args); } } -- cgit From bafae1c427cb1eeb52e4caa641ad134c1e062e8e Mon Sep 17 00:00:00 2001 From: KillTheMule Date: Fri, 26 Jan 2018 15:49:35 +0100 Subject: Add argument to not send a buffers content when updates are enabled Add a test. --- src/nvim/api/buffer.c | 3 ++- src/nvim/liveupdate.c | 26 ++++++++++++++------------ src/nvim/liveupdate.h | 2 +- 3 files changed, 17 insertions(+), 14 deletions(-) (limited to 'src') diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c index 159683db9e..e594e4975c 100644 --- a/src/nvim/api/buffer.c +++ b/src/nvim/api/buffer.c @@ -87,6 +87,7 @@ String buffer_get_line(Buffer buffer, Integer index, Error *err) Boolean nvim_buf_live_updates(uint64_t channel_id, Buffer buffer, Boolean enabled, + Boolean send_buffer, Error *err) FUNC_API_SINCE(3) FUNC_API_REMOTE_ONLY { @@ -97,7 +98,7 @@ Boolean nvim_buf_live_updates(uint64_t channel_id, } if (enabled) { - return liveupdate_register(buf, channel_id); + return liveupdate_register(buf, channel_id, send_buffer); } liveupdate_unregister(buf, channel_id); diff --git a/src/nvim/liveupdate.c b/src/nvim/liveupdate.c index 953c5b52b3..9679d72569 100644 --- a/src/nvim/liveupdate.c +++ b/src/nvim/liveupdate.c @@ -6,7 +6,7 @@ // 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 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) { @@ -27,21 +27,23 @@ bool liveupdate_register(buf_T *buf, uint64_t channel_id) // append the channelid to the list kv_push(buf->liveupdate_channels, channel_id); - // send through the full channel contents now Array linedata = ARRAY_DICT_INIT; - 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; + 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)); + 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'); + // Vim represents NULs as NLs, but this may confuse clients. + strchrsub(str.data.string.data, '\n', '\0'); - linedata.items[i] = str; + linedata.items[i] = str; + } } Array args = ARRAY_DICT_INIT; diff --git a/src/nvim/liveupdate.h b/src/nvim/liveupdate.h index bbee4b3766..77fb420bf0 100644 --- a/src/nvim/liveupdate.h +++ b/src/nvim/liveupdate.h @@ -3,7 +3,7 @@ #include "nvim/buffer_defs.h" -bool liveupdate_register(buf_T *buf, uint64_t channel_id); +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, -- cgit From 71816e584cef01c195797e738e1d6dba1de39102 Mon Sep 17 00:00:00 2001 From: KillTheMule Date: Fri, 26 Jan 2018 16:52:51 +0100 Subject: Adjust FUNC_API_SINCE for nvim_buf_live_updates --- src/nvim/api/buffer.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src') diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c index e594e4975c..44e274484a 100644 --- a/src/nvim/api/buffer.c +++ b/src/nvim/api/buffer.c @@ -89,7 +89,7 @@ Boolean nvim_buf_live_updates(uint64_t channel_id, Boolean enabled, Boolean send_buffer, Error *err) - FUNC_API_SINCE(3) FUNC_API_REMOTE_ONLY + FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY { buf_T *buf = find_buffer_by_handle(buffer, err); -- cgit From 8bcc01195968b84d1a74ecb82598bdf538004404 Mon Sep 17 00:00:00 2001 From: KillTheMule Date: Fri, 26 Jan 2018 17:42:51 +0100 Subject: Make separate functions to start/stop live updates --- src/nvim/api/buffer.c | 28 ++++++++++++++++++++++------ 1 file changed, 22 insertions(+), 6 deletions(-) (limited to 'src') diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c index 44e274484a..2c7480a16b 100644 --- a/src/nvim/api/buffer.c +++ b/src/nvim/api/buffer.c @@ -78,15 +78,14 @@ String buffer_get_line(Buffer buffer, Integer index, Error *err) /// Activate live updates from this buffer to the current channel. /// -/// /// @param buffer The buffer handle -/// @param enabled True turns on live updates, False turns them off. +/// @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 /// loaded; otherwise True. -Boolean nvim_buf_live_updates(uint64_t channel_id, +Boolean nvim_buf_live_updates_start(uint64_t channel_id, Buffer buffer, - Boolean enabled, Boolean send_buffer, Error *err) FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY @@ -97,8 +96,25 @@ Boolean nvim_buf_live_updates(uint64_t channel_id, return false; } - if (enabled) { - return liveupdate_register(buf, channel_id, send_buffer); + return liveupdate_register(buf, channel_id, send_buffer); + +} +// +/// Deactivate live 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 +/// isn't loaded; otherwise True. +Boolean nvim_buf_live_updates_stop(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; } liveupdate_unregister(buf, channel_id); -- cgit From 37b8e95fd69ba4991454f79802bfe1bccf7c827a Mon Sep 17 00:00:00 2001 From: KillTheMule Date: Fri, 26 Jan 2018 20:25:53 +0100 Subject: Lint --- src/nvim/api/buffer.c | 11 +++++------ src/nvim/buffer.c | 6 +++--- src/nvim/ex_cmds.c | 3 ++- src/nvim/misc1.c | 14 +++++++------- src/nvim/ops.c | 8 +++++--- src/nvim/undo.c | 2 +- 6 files changed, 23 insertions(+), 21 deletions(-) (limited to 'src') diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c index 2c7480a16b..6778227a27 100644 --- a/src/nvim/api/buffer.c +++ b/src/nvim/api/buffer.c @@ -85,9 +85,9 @@ String buffer_get_line(Buffer buffer, Integer index, Error *err) /// @return False when live 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) + Buffer buffer, + Boolean send_buffer, + Error *err) FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY { buf_T *buf = find_buffer_by_handle(buffer, err); @@ -97,7 +97,6 @@ Boolean nvim_buf_live_updates_start(uint64_t channel_id, } return liveupdate_register(buf, channel_id, send_buffer); - } // /// Deactivate live updates from this buffer to the current channel. @@ -107,8 +106,8 @@ Boolean nvim_buf_live_updates_start(uint64_t channel_id, /// @return False when live 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) + Buffer buffer, + Error *err) FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY { buf_T *buf = find_buffer_by_handle(buffer, err); diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c index 124e479686..e7ff25ce6b 100644 --- a/src/nvim/buffer.c +++ b/src/nvim/buffer.c @@ -1738,9 +1738,9 @@ 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->liveupdate_channels); kv_init(buf->liveupdate_channels); if (!(flags & BLN_DUMMY)) { diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c index d68dbc8676..e418e0c20e 100644 --- a/src/nvim/ex_cmds.c +++ b/src/nvim/ex_cmds.c @@ -745,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) + if (first_line != 0) { changed_lines(first_line, 0, last_line + 1, 0L, true); + } curwin->w_p_list = save_list; /* restore 'list' */ diff --git a/src/nvim/misc1.c b/src/nvim/misc1.c index a3b2d5e7a4..e2094d7293 100644 --- a/src/nvim/misc1.c +++ b/src/nvim/misc1.c @@ -837,7 +837,7 @@ open_line ( if (did_append) { changed_lines(curwin->w_cursor.lnum, curwin->w_cursor.col, curwin->w_cursor.lnum + 1, 1L, true); - did_append = FALSE; + did_append = false; /* Move marks after the line break to the new line. */ if (flags & OPENLINE_MARKFIX) @@ -1914,12 +1914,12 @@ 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 send_liveupdate // some callers like undo/redo call changed_lines() // and then increment b_changedtick *again*. This flag // allows these callers to send the LiveUpdate events diff --git a/src/nvim/ops.c b/src/nvim/ops.c index 692713af73..c9e8344ac1 100644 --- a/src/nvim/ops.c +++ b/src/nvim/ops.c @@ -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, true); - else if (oap->is_VIsual) + } else if (oap->is_VIsual) { redraw_curbuf_later(INVERTED); + } if (oap->line_count > p_report) { i = oap->line_count - (i + 1); @@ -1856,8 +1857,9 @@ void op_tilde(oparg_T *oap) did_change |= one_change; } - if (did_change) + 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; diff --git a/src/nvim/undo.c b/src/nvim/undo.c index 27d745a254..1c14e93211 100644 --- a/src/nvim/undo.c +++ b/src/nvim/undo.c @@ -2030,7 +2030,7 @@ void undo_time(long step, int sec, int file, int absolute) break; curbuf->b_u_curhead = uhp; u_undoredo(true, true); - uhp->uh_walk = nomark; /* don't go back down here */ + uhp->uh_walk = nomark; // don't go back down here } /* -- cgit From 0476e0aef3a82879961acd515b8587fc1b941597 Mon Sep 17 00:00:00 2001 From: KillTheMule Date: Sat, 27 Jan 2018 14:49:16 +0100 Subject: Make LiveUpdate return lastline instead of numreplaced In analogy to `nvim_buf_set_lines`. --- src/nvim/liveupdate.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/nvim/liveupdate.c b/src/nvim/liveupdate.c index 9679d72569..6bff75217b 100644 --- a/src/nvim/liveupdate.c +++ b/src/nvim/liveupdate.c @@ -137,8 +137,8 @@ void liveupdate_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added, // the first line that changed (zero-indexed) args.items[2] = INTEGER_OBJ(firstline - 1); - // how many lines are being swapped out - args.items[3] = INTEGER_OBJ(num_removed); + // 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; -- cgit From 61f467499b6b1bbadda7100fc0c2f0ac4c77a933 Mon Sep 17 00:00:00 2001 From: KillTheMule Date: Sun, 28 Jan 2018 14:41:32 +0100 Subject: Bump up buffer capacity to 2GB --- src/nvim/event/wstream.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src') 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; -- cgit From 995a2fad8c32b2063a600ffb8fef1c01100b8ac6 Mon Sep 17 00:00:00 2001 From: KillTheMule Date: Mon, 29 Jan 2018 19:50:45 +0100 Subject: Fix memory leak --- src/nvim/liveupdate.c | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'src') diff --git a/src/nvim/liveupdate.c b/src/nvim/liveupdate.c index 6bff75217b..d587567e3f 100644 --- a/src/nvim/liveupdate.c +++ b/src/nvim/liveupdate.c @@ -98,6 +98,11 @@ void liveupdate_unregister(buf_T *buf, uint64_t channelid) // 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); + } } } -- cgit 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 From 2106bada5bbd6de4729a8714d011e0eca61cee35 Mon Sep 17 00:00:00 2001 From: KillTheMule Date: Sun, 11 Feb 2018 23:02:53 +0100 Subject: Enable -Wconversion --- src/nvim/CMakeLists.txt | 1 - src/nvim/api/buffer.c | 10 +++++----- src/nvim/buffer_updates.c | 22 +++++++++++++++++----- src/nvim/buffer_updates.h | 11 +++++++---- src/nvim/ex_cmds.c | 2 +- src/nvim/fold.c | 6 +++--- src/nvim/misc1.c | 6 +++--- src/nvim/undo.c | 4 ++-- 8 files changed, 38 insertions(+), 24 deletions(-) (limited to 'src') diff --git a/src/nvim/CMakeLists.txt b/src/nvim/CMakeLists.txt index 97495eec6d..2d803792c8 100644 --- a/src/nvim/CMakeLists.txt +++ b/src/nvim/CMakeLists.txt @@ -142,7 +142,6 @@ set(CONV_SOURCES message.c regexp.c screen.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 d59ce1ce3d..f6a6534560 100644 --- a/src/nvim/api/buffer.c +++ b/src/nvim/api/buffer.c @@ -85,9 +85,9 @@ String buffer_get_line(Buffer buffer, Integer index, Error *err) /// @return False when updates couldn't be enabled because the buffer isn't /// loaded; otherwise True. Boolean nvim_buf_attach(uint64_t channel_id, - Buffer buffer, - Boolean send_buffer, - Error *err) + Buffer buffer, + Boolean send_buffer, + Error *err) FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY { buf_T *buf = find_buffer_by_handle(buffer, err); @@ -106,8 +106,8 @@ Boolean nvim_buf_attach(uint64_t channel_id, /// @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) + Buffer buffer, + Error *err) FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY { buf_T *buf = find_buffer_by_handle(buffer, err); diff --git a/src/nvim/buffer_updates.c b/src/nvim/buffer_updates.c index d7bb11d125..3d0c969491 100644 --- a/src/nvim/buffer_updates.c +++ b/src/nvim/buffer_updates.c @@ -2,6 +2,7 @@ #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 @@ -30,7 +31,10 @@ bool buffer_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer) Array linedata = ARRAY_DICT_INIT; if (send_buffer) { // collect buffer contents - size_t line_count = buf->b_ml.ml_line_count; + // 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; linedata.size = line_count; linedata.items = xcalloc(sizeof(Object), line_count); for (size_t i = 0; i < line_count; i++) { @@ -118,8 +122,11 @@ 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_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; @@ -148,8 +155,13 @@ void buffer_updates_send_changes(buf_T *buf, linenr_T firstline, int64_t num_add // 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); + // 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); diff --git a/src/nvim/buffer_updates.h b/src/nvim/buffer_updates.h index 8fe33a0ebe..63ae2d3984 100644 --- a/src/nvim/buffer_updates.h +++ b/src/nvim/buffer_updates.h @@ -1,13 +1,16 @@ -#ifndef BUFFER_UPDATES_H -#define BUFFER_UPDATES_H +#ifndef NVIM_BUFFER_UPDATES_H +#define NVIM_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_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 fdb8c87213..3960412782 100644 --- a/src/nvim/ex_cmds.c +++ b/src/nvim/ex_cmds.c @@ -4022,7 +4022,7 @@ skip: int64_t num_added = last_line - first_line; int64_t num_removed = num_added - i; buffer_updates_send_changes(curbuf, first_line, num_added, num_removed, - send_buffer_update_changedtick); + send_buffer_update_changedtick); } } diff --git a/src/nvim/fold.c b/src/nvim/fold.c index 2cf1c6f394..9869e0fd30 100644 --- a/src/nvim/fold.c +++ b/src/nvim/fold.c @@ -754,7 +754,7 @@ deleteFold ( // notification that includes every line that was part of the fold int64_t num_changed = last_lnum - first_lnum; buffer_updates_send_changes(curbuf, first_lnum, num_changed, - num_changed, true); + num_changed, true); } } } @@ -1607,8 +1607,8 @@ static void foldCreateMarkers(linenr_T start, linenr_T end) 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_update - // anyway since it won't do any harm. + // 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; buffer_updates_send_changes(curbuf, start, num_changed, num_changed, true); } diff --git a/src/nvim/misc1.c b/src/nvim/misc1.c index 7c9e728c92..47ec3eff32 100644 --- a/src/nvim/misc1.c +++ b/src/nvim/misc1.c @@ -1921,9 +1921,9 @@ changed_lines( linenr_T lnume, // line below last changed line long xtra, // number of extra lines (negative when deleting) 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 nvim_buf_update events - // after they're done modifying b_changedtick. + // and then increment b_changedtick *again*. This flag + // allows these callers to send the nvim_buf_update events + // after they're done modifying b_changedtick. ) { changed_lines_buf(curbuf, lnum, lnume, xtra); diff --git a/src/nvim/undo.c b/src/nvim/undo.c index 9da9693c90..ed4515398d 100644 --- a/src/nvim/undo.c +++ b/src/nvim/undo.c @@ -1698,8 +1698,8 @@ bool u_undo_and_forget(int count) count = 1; } undo_undoes = true; - // don't send a nvim_buf_update for this undo is part of 'inccommand' playing with - // buffer contents + // don't send a nvim_buf_update for this undo is part of 'inccommand' playing + // with buffer contents u_doit(count, true, false); if (curbuf->b_u_curhead == NULL) { -- cgit From e7451f8a91e0a9452fc3c3627ac60dc80288252c Mon Sep 17 00:00:00 2001 From: KillTheMule Date: Tue, 24 Apr 2018 20:38:00 +0200 Subject: Some renamings and doc changes --- src/nvim/api/buffer.c | 4 ++-- src/nvim/buffer.c | 4 ++-- src/nvim/buffer_updates.c | 20 ++++++++++---------- src/nvim/buffer_updates.h | 10 +++++----- src/nvim/ex_cmds.c | 13 +++++++------ src/nvim/fold.c | 4 ++-- src/nvim/misc1.c | 8 ++++---- src/nvim/undo.c | 35 +++++++++++++++++++---------------- 8 files changed, 51 insertions(+), 47 deletions(-) (limited to 'src') diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c index f6a6534560..756367f801 100644 --- a/src/nvim/api/buffer.c +++ b/src/nvim/api/buffer.c @@ -96,7 +96,7 @@ Boolean nvim_buf_attach(uint64_t channel_id, return false; } - return buffer_updates_register(buf, channel_id, send_buffer); + return buf_updates_register(buf, channel_id, send_buffer); } // /// Deactivate updates from this buffer to the current channel. @@ -116,7 +116,7 @@ Boolean nvim_buf_detach(uint64_t channel_id, return false; } - buffer_updates_unregister(buf, channel_id); + buf_updates_unregister(buf, channel_id); return true; } diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c index e5b7128248..af77a9891b 100644 --- a/src/nvim/buffer.c +++ b/src/nvim/buffer.c @@ -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 - buffer_updates_unregister_all(buf); + buf_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; - buffer_updates_unregister_all(buf); + buf_updates_unregister_all(buf); } /* diff --git a/src/nvim/buffer_updates.c b/src/nvim/buffer_updates.c index 3d0c969491..830c1bfe7b 100644 --- a/src/nvim/buffer_updates.c +++ b/src/nvim/buffer_updates.c @@ -7,7 +7,7 @@ // 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) +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) { @@ -64,7 +64,7 @@ bool buffer_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer) return true; } -void buffer_updates_send_end(buf_T *buf, uint64_t channelid) +void buf_updates_send_end(buf_T *buf, uint64_t channelid) { Array args = ARRAY_DICT_INIT; args.size = 1; @@ -73,7 +73,7 @@ void buffer_updates_send_end(buf_T *buf, uint64_t channelid) rpc_send_event(channelid, "nvim_buf_updates_end", args); } -void buffer_updates_unregister(buf_T *buf, uint64_t channelid) +void buf_updates_unregister(buf_T *buf, uint64_t channelid) { size_t size = kv_size(buf->update_channels); if (!size) { @@ -101,7 +101,7 @@ void buffer_updates_unregister(buf_T *buf, uint64_t channelid) buf->update_channels.size -= found; // make a new copy of the active array without the channelid in it - buffer_updates_send_end(buf, channelid); + buf_updates_send_end(buf, channelid); if (found == size) { kv_destroy(buf->update_channels); @@ -110,19 +110,19 @@ void buffer_updates_unregister(buf_T *buf, uint64_t channelid) } } -void buffer_updates_unregister_all(buf_T *buf) +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++) { - buffer_updates_send_end(buf, kv_A(buf->update_channels, i)); + buf_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, +void buf_updates_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added, int64_t num_removed, @@ -187,11 +187,11 @@ void buffer_updates_send_changes(buf_T *buf, // cleared up quickly. if (badchannelid != 0) { ELOG("Disabling live updates for dead channel %llu", badchannelid); - buffer_updates_unregister(buf, badchannelid); + buf_updates_unregister(buf, badchannelid); } } -void buffer_updates_send_tick(buf_T *buf) +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++) { @@ -209,6 +209,6 @@ void buffer_updates_send_tick(buf_T *buf) 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); + rpc_send_event(channelid, "nvim_buf_changedtick", args); } } diff --git a/src/nvim/buffer_updates.h b/src/nvim/buffer_updates.h index 63ae2d3984..23804809f1 100644 --- a/src/nvim/buffer_updates.h +++ b/src/nvim/buffer_updates.h @@ -3,14 +3,14 @@ #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, +bool buf_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer); +void buf_updates_unregister(buf_T *buf, uint64_t channel_id); +void buf_updates_unregister_all(buf_T *buf); +void buf_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); +void buf_updates_changedtick(buf_T *buf); #endif // NVIM_BUFFER_UPDATES_H diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c index 3960412782..e342ae44aa 100644 --- a/src/nvim/ex_cmds.c +++ b/src/nvim/ex_cmds.c @@ -835,7 +835,7 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest) // 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); + buf_updates_send_changes(curbuf, dest + 1, num_lines, 0, true); } /* @@ -874,7 +874,7 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest) // 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); + buf_updates_send_changes(curbuf, line1 + extra, 0, num_lines, true); } return OK; @@ -2442,7 +2442,7 @@ int do_ecmd( goto theend; } u_unchanged(curbuf); - buffer_updates_unregister_all(curbuf); + buf_updates_unregister_all(curbuf); buf_freeall(curbuf, BFA_KEEP_UNDO); // Tell readfile() not to clear or reload undo info. @@ -3168,9 +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, - bool send_buffer_update_changedtick) + bool do_buf_event) { long i = 0; regmmatch_T regmatch; @@ -4021,8 +4022,8 @@ skip: if (kv_size(curbuf->update_channels)) { int64_t num_added = last_line - first_line; int64_t num_removed = num_added - i; - buffer_updates_send_changes(curbuf, first_line, num_added, num_removed, - send_buffer_update_changedtick); + buf_updates_send_changes(curbuf, first_line, num_added, num_removed, + do_buf_event); } } diff --git a/src/nvim/fold.c b/src/nvim/fold.c index 9869e0fd30..4d947d9b07 100644 --- a/src/nvim/fold.c +++ b/src/nvim/fold.c @@ -753,7 +753,7 @@ deleteFold ( // 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; - buffer_updates_send_changes(curbuf, first_lnum, num_changed, + buf_updates_send_changes(curbuf, first_lnum, num_changed, num_changed, true); } } @@ -1610,7 +1610,7 @@ static void foldCreateMarkers(linenr_T start, linenr_T end) // 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; - buffer_updates_send_changes(curbuf, start, num_changed, num_changed, true); + buf_updates_send_changes(curbuf, start, num_changed, num_changed, true); } } diff --git a/src/nvim/misc1.c b/src/nvim/misc1.c index 47ec3eff32..de68031135 100644 --- a/src/nvim/misc1.c +++ b/src/nvim/misc1.c @@ -1823,7 +1823,7 @@ void changed_bytes(linenr_T lnum, colnr_T col) changed_common(lnum, col, lnum + 1, 0L); // notify any channels that are watching if (kv_size(curbuf->update_channels)) { - buffer_updates_send_changes(curbuf, lnum, 1, 1, true); + buf_updates_send_changes(curbuf, lnum, 1, 1, true); } /* Diff highlighting in other diff windows may need to be updated too. */ @@ -1920,7 +1920,7 @@ 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_update // some callers like undo/redo call changed_lines() + 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_update events // after they're done modifying b_changedtick. @@ -1948,10 +1948,10 @@ changed_lines( changed_common(lnum, col, lnume, xtra); - if (send_update && kv_size(curbuf->update_channels)) { + if (do_buf_event && kv_size(curbuf->update_channels)) { int64_t num_added = (int64_t)(lnume + xtra - lnum); int64_t num_removed = lnume - lnum; - buffer_updates_send_changes(curbuf, lnum, num_added, num_removed, true); + buf_updates_send_changes(curbuf, lnum, num_added, num_removed, true); } } diff --git a/src/nvim/undo.c b/src/nvim/undo.c index ed4515398d..985c6873a4 100644 --- a/src/nvim/undo.c +++ b/src/nvim/undo.c @@ -1735,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, bool send_update) +/// +/// @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; @@ -1771,7 +1775,7 @@ static void u_doit(int startcount, bool quiet, bool send_update) break; } - u_undoredo(true, send_update); + u_undoredo(true, do_buf_event); } else { if (curbuf->b_u_curhead == NULL || get_undolevel() <= 0) { beep_flush(); /* nothing to redo */ @@ -1782,7 +1786,7 @@ static void u_doit(int startcount, bool quiet, bool send_update) break; } - u_undoredo(false, send_update); + u_undoredo(false, do_buf_event); /* Advance for next redo. Set "newhead" when at the end of the * redoable changes. */ @@ -2108,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, bool send_update) +/// 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; @@ -2245,7 +2248,7 @@ static void u_undoredo(int undo, bool send_update) } } - changed_lines(top + 1, 0, bot, newsize - oldsize, send_update); + changed_lines(top + 1, 0, bot, newsize - oldsize, do_buf_event); /* set '[ and '] mark */ if (top + 1 < curbuf->b_op_start.lnum) @@ -2283,8 +2286,8 @@ static void u_undoredo(int undo, bool send_update) // because the calls to changed()/unchanged() above will bump b_changedtick // again, we need to send a nvim_buf_update with just the new value of // b:changedtick - if (send_update && kv_size(curbuf->update_channels)) { - buffer_updates_send_tick(curbuf); + if (do_buf_event && kv_size(curbuf->update_channels)) { + buf_updates_changedtick(curbuf); } /* -- cgit From 491efc89d2e8da319077f7c6d93f07a01b543ab0 Mon Sep 17 00:00:00 2001 From: KillTheMule Date: Tue, 24 Apr 2018 21:45:36 +0200 Subject: Lint --- src/nvim/buffer_updates.c | 8 ++++---- src/nvim/buffer_updates.h | 8 ++++---- src/nvim/ex_cmds.c | 2 +- src/nvim/fold.c | 2 +- 4 files changed, 10 insertions(+), 10 deletions(-) (limited to 'src') diff --git a/src/nvim/buffer_updates.c b/src/nvim/buffer_updates.c index 830c1bfe7b..8eac695efe 100644 --- a/src/nvim/buffer_updates.c +++ b/src/nvim/buffer_updates.c @@ -123,10 +123,10 @@ void buf_updates_unregister_all(buf_T *buf) } void buf_updates_send_changes(buf_T *buf, - linenr_T firstline, - int64_t num_added, - int64_t num_removed, - bool send_tick) + 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; diff --git a/src/nvim/buffer_updates.h b/src/nvim/buffer_updates.h index 23804809f1..d052b8effb 100644 --- a/src/nvim/buffer_updates.h +++ b/src/nvim/buffer_updates.h @@ -7,10 +7,10 @@ bool buf_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer); void buf_updates_unregister(buf_T *buf, uint64_t channel_id); void buf_updates_unregister_all(buf_T *buf); void buf_updates_send_changes(buf_T *buf, - linenr_T firstline, - int64_t num_added, - int64_t num_removed, - bool send_tick); + linenr_T firstline, + int64_t num_added, + int64_t num_removed, + bool send_tick); void buf_updates_changedtick(buf_T *buf); #endif // NVIM_BUFFER_UPDATES_H diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c index e342ae44aa..0638c10dc0 100644 --- a/src/nvim/ex_cmds.c +++ b/src/nvim/ex_cmds.c @@ -4023,7 +4023,7 @@ skip: 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); + do_buf_event); } } diff --git a/src/nvim/fold.c b/src/nvim/fold.c index 4d947d9b07..32ba665f64 100644 --- a/src/nvim/fold.c +++ b/src/nvim/fold.c @@ -754,7 +754,7 @@ deleteFold ( // 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); + num_changed, true); } } } -- cgit From 8ef3fb4e738c4021a1c779252a1dac53e09324fc Mon Sep 17 00:00:00 2001 From: KillTheMule Date: Thu, 10 May 2018 14:25:59 +0200 Subject: Use autogenerated declarations --- src/nvim/buffer_updates.h | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) (limited to 'src') diff --git a/src/nvim/buffer_updates.h b/src/nvim/buffer_updates.h index d052b8effb..b2d0a62270 100644 --- a/src/nvim/buffer_updates.h +++ b/src/nvim/buffer_updates.h @@ -3,14 +3,8 @@ #include "nvim/buffer_defs.h" -bool buf_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer); -void buf_updates_unregister(buf_T *buf, uint64_t channel_id); -void buf_updates_unregister_all(buf_T *buf); -void buf_updates_send_changes(buf_T *buf, - linenr_T firstline, - int64_t num_added, - int64_t num_removed, - bool send_tick); -void buf_updates_changedtick(buf_T *buf); +#ifdef INCLUDE_GENERATED_DECLARATIONS +# include "buffer_updates.h.generated.h" +#endif #endif // NVIM_BUFFER_UPDATES_H -- cgit From ad151847f179e51d70cbde9440e765c2a451a7f6 Mon Sep 17 00:00:00 2001 From: KillTheMule Date: Thu, 10 May 2018 15:47:00 +0200 Subject: Unify updates_start and updates to lines_event Also rename changedtick -> changedtick_event --- src/nvim/buffer_updates.c | 54 +++++++++++++++++++++++++++++------------------ 1 file changed, 33 insertions(+), 21 deletions(-) (limited to 'src') diff --git a/src/nvim/buffer_updates.c b/src/nvim/buffer_updates.c index 8eac695efe..71ca800ee5 100644 --- a/src/nvim/buffer_updates.c +++ b/src/nvim/buffer_updates.c @@ -28,39 +28,50 @@ bool buf_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer) // append the channelid to the list kv_push(buf->update_channels, channel_id); + 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(-1); + // the last line that was changed + args.items[3] = INTEGER_OBJ(-1); Array linedata = ARRAY_DICT_INIT; + if (send_buffer) { // 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; - 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)); + if (line_count >= 1) { + args.items[2] = INTEGER_OBJ(0); + + 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; - // Vim represents NULs as NLs, but this may confuse clients. - strchrsub(str.data.string.data, '\n', '\0'); + const char *bufstr = (char *)ml_get_buf(buf, lnum, false); + Object str = STRING_OBJ(cstr_to_string(bufstr)); - linedata.items[i] = str; + // 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); + args.items[4] = ARRAY_OBJ(linedata); + args.items[5] = BOOLEAN_OBJ(false); - rpc_send_event(channel_id, "nvim_buf_updates_start", args); + rpc_send_event(channel_id, "nvim_buf_lines_event", args); return true; } @@ -137,7 +148,7 @@ void buf_updates_send_changes(buf_T *buf, // send through the changes now channel contents now Array args = ARRAY_DICT_INIT; - args.size = 5; + args.size = 6; args.items = xcalloc(sizeof(Object), args.size); // the first argument is always the buffer handle @@ -174,7 +185,8 @@ void buf_updates_send_changes(buf_T *buf, } } args.items[4] = ARRAY_OBJ(linedata); - if (!rpc_send_event(channelid, "nvim_buf_update", args)) { + 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. -- cgit From 0bee3925ab5186211f10c823d4f149d4d16eb7a5 Mon Sep 17 00:00:00 2001 From: KillTheMule Date: Thu, 10 May 2018 23:13:58 +0200 Subject: Send changedtick as first event if buffer contents weren't requested --- src/nvim/api/buffer.c | 4 +++- src/nvim/buffer_updates.c | 50 +++++++++++++++++++++++++---------------------- 2 files changed, 30 insertions(+), 24 deletions(-) (limited to 'src') diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c index 756367f801..12d1feb370 100644 --- a/src/nvim/api/buffer.c +++ b/src/nvim/api/buffer.c @@ -80,7 +80,9 @@ String buffer_get_line(Buffer buffer, Integer index, Error *err) /// /// @param buffer The buffer handle /// @param send_buffer Set to true if the initial notification should contain -/// the whole buffer +/// 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[out] err Details of an error that may have occurred /// @return False when updates couldn't be enabled because the buffer isn't /// loaded; otherwise True. diff --git a/src/nvim/buffer_updates.c b/src/nvim/buffer_updates.c index 71ca800ee5..2852561ce0 100644 --- a/src/nvim/buffer_updates.c +++ b/src/nvim/buffer_updates.c @@ -28,20 +28,20 @@ bool buf_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer) // append the channelid to the list kv_push(buf->update_channels, channel_id); - 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(-1); - // the last line that was changed - args.items[3] = INTEGER_OBJ(-1); - Array linedata = ARRAY_DICT_INIT; - 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 @@ -50,8 +50,6 @@ bool buf_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer) size_t line_count = (size_t)buf->b_ml.ml_line_count; if (line_count >= 1) { - args.items[2] = INTEGER_OBJ(0); - linedata.size = line_count; linedata.items = xcalloc(sizeof(Object), line_count); for (size_t i = 0; i < line_count; i++) { @@ -66,12 +64,15 @@ bool buf_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer) linedata.items[i] = str; } } - } - args.items[4] = ARRAY_OBJ(linedata); - args.items[5] = BOOLEAN_OBJ(false); + 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); + } - rpc_send_event(channel_id, "nvim_buf_lines_event", args); return true; } @@ -207,9 +208,13 @@ 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 channelid = kv_A(buf->update_channels, i); + uint64_t channel_id = kv_A(buf->update_channels, i); + buf_updates_changedtick_single(buf, channel_id); + } +} - // send through the changes now channel contents now +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); @@ -221,6 +226,5 @@ void buf_updates_changedtick(buf_T *buf) args.items[1] = INTEGER_OBJ(buf->b_changedtick); // don't try and clean up dead channels here - rpc_send_event(channelid, "nvim_buf_changedtick", args); - } + rpc_send_event(channel_id, "nvim_buf_changedtick_event", args); } -- cgit From 65e7f6f0b97b02e323488e06bf0f5df93bbcbf93 Mon Sep 17 00:00:00 2001 From: KillTheMule Date: Fri, 18 May 2018 10:09:11 +0200 Subject: Rename some more, fixe borked renaming --- src/nvim/buffer_updates.c | 2 +- src/nvim/ex_cmds.c | 2 +- src/nvim/fold.c | 4 ++-- src/nvim/misc1.c | 6 +++--- src/nvim/terminal.c | 2 +- src/nvim/undo.c | 6 +++--- 6 files changed, 11 insertions(+), 11 deletions(-) (limited to 'src') diff --git a/src/nvim/buffer_updates.c b/src/nvim/buffer_updates.c index 2852561ce0..4774b969c4 100644 --- a/src/nvim/buffer_updates.c +++ b/src/nvim/buffer_updates.c @@ -82,7 +82,7 @@ void buf_updates_send_end(buf_T *buf, uint64_t channelid) 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); + rpc_send_event(channelid, "nvim_buf_detach_event", args); } void buf_updates_unregister(buf_T *buf, uint64_t channelid) diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c index 0638c10dc0..1d98f171b4 100644 --- a/src/nvim/ex_cmds.c +++ b/src/nvim/ex_cmds.c @@ -872,7 +872,7 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest) changed_lines(dest + 1, 0, line1 + num_lines, 0L, false); } - // send nvim_buf_update regarding lines that were deleted + // 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); } diff --git a/src/nvim/fold.c b/src/nvim/fold.c index 32ba665f64..b8ace511e8 100644 --- a/src/nvim/fold.c +++ b/src/nvim/fold.c @@ -746,7 +746,7 @@ deleteFold ( if (last_lnum > 0) { changed_lines(first_lnum, (colnr_T)0, last_lnum, 0L, false); - // send one nvim_buf_update at the end + // 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 @@ -1608,7 +1608,7 @@ static void foldCreateMarkers(linenr_T start, linenr_T end) 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_update anyway since it won't do any harm. + // 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); } diff --git a/src/nvim/misc1.c b/src/nvim/misc1.c index de68031135..6c5c47b91f 100644 --- a/src/nvim/misc1.c +++ b/src/nvim/misc1.c @@ -1921,9 +1921,9 @@ changed_lines( 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_update events - // after they're done modifying b_changedtick. + // 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); diff --git a/src/nvim/terminal.c b/src/nvim/terminal.c index 9ab537d8b9..c29f0b3927 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 nvim_buf_update event for a :terminal buffer + // Note: don't send nvim_buf_lines_event 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 985c6873a4..44bcefb332 100644 --- a/src/nvim/undo.c +++ b/src/nvim/undo.c @@ -1698,8 +1698,8 @@ bool u_undo_and_forget(int count) count = 1; } undo_undoes = true; - // don't send a nvim_buf_update for this undo is part of 'inccommand' playing - // with buffer contents + // don't send a nvim_buf_lines_event for this undo is part of 'inccommand' + // playing with buffer contents u_doit(count, true, false); if (curbuf->b_u_curhead == NULL) { @@ -2284,7 +2284,7 @@ static void u_undoredo(int undo, bool do_buf_event) } // because the calls to changed()/unchanged() above will bump b_changedtick - // again, we need to send a nvim_buf_update with just the new value of + // 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); -- cgit From 333679ad0ea6cb387debeae37645ecc0a830de25 Mon Sep 17 00:00:00 2001 From: KillTheMule Date: Mon, 21 May 2018 20:42:59 +0200 Subject: Add empty options dict to buf_attach --- src/nvim/api/buffer.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) (limited to 'src') diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c index 12d1feb370..215859a499 100644 --- a/src/nvim/api/buffer.c +++ b/src/nvim/api/buffer.c @@ -83,15 +83,22 @@ String buffer_get_line(Buffer buffer, Integer index, Error *err) /// 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; otherwise True. +/// 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) { -- cgit From 2ca62239675b0c1e68b01aae1a0d45567b15e319 Mon Sep 17 00:00:00 2001 From: KillTheMule Date: Mon, 21 May 2018 21:40:51 +0200 Subject: API: Accept empty lists as dictionaries --- src/nvim/generators/gen_api_dispatch.lua | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'src') 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;') -- cgit