terminal: 'scrollback'

Closes #2637

8 files changed, 122 insertions, 102 deletions

diff --git a/src/.valgrind.supp b/src/.valgrind.supp
index 8b630fcaaf..cce22bd632 100644
--- a/src/.valgrind.supp
+++ b/src/.valgrind.supp
@@ -10,7 +10,7 @@
   Memcheck:Leak
   fun:malloc
   fun:uv_spawn
-  fun:pipe_process_spawn
+  fun:libuv_process_spawn
   fun:process_spawn
   fun:job_start
 }
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 57c2368523..49644d70ef 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -5845,8 +5845,8 @@ bool garbage_collect(bool testing)
     garbage_collect_at_exit = false;
   }
 
-  // We advance by two because we add one for items referenced through
-  // previous_funccal.
+  // We advance by two (COPYID_INC) because we add one for items referenced
+  // through previous_funccal.
   const int copyID = get_copyID();
 
   // 1. Go through all accessible variables and mark all lists and dicts
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index e79939ab10..a51de5fe3c 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -7420,22 +7420,20 @@ static void nv_esc(cmdarg_T *cap)
     restart_edit = 'a';
 }
 
-/*
- * Handle "A", "a", "I", "i" and <Insert> commands.
- */
+/// Handle "A", "a", "I", "i" and <Insert> commands.
 static void nv_edit(cmdarg_T *cap)
 {
-  /* <Insert> is equal to "i" */
-  if (cap->cmdchar == K_INS || cap->cmdchar == K_KINS)
+  // <Insert> is equal to "i"
+  if (cap->cmdchar == K_INS || cap->cmdchar == K_KINS) {
     cap->cmdchar = 'i';
+  }
 
-  /* in Visual mode "A" and "I" are an operator */
-  if (VIsual_active && (cap->cmdchar == 'A' || cap->cmdchar == 'I'))
+  // in Visual mode "A" and "I" are an operator
+  if (VIsual_active && (cap->cmdchar == 'A' || cap->cmdchar == 'I')) {
     v_visop(cap);
-
-  /* in Visual mode and after an operator "a" and "i" are for text objects */
-  else if ((cap->cmdchar == 'a' || cap->cmdchar == 'i')
-           && (cap->oap->op_type != OP_NOP || VIsual_active)) {
+  // in Visual mode and after an operator "a" and "i" are for text objects
+  } else if ((cap->cmdchar == 'a' || cap->cmdchar == 'i')
+             && (cap->oap->op_type != OP_NOP || VIsual_active)) {
     nv_object(cap);
   } else if (!curbuf->b_p_ma && !p_im && !curbuf->terminal) {
     // Only give this error when 'insertmode' is off.
diff --git a/src/nvim/option.c b/src/nvim/option.c
index 7d0a16b051..8990b59f57 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -3994,16 +3994,7 @@ set_num_option (
   /*
    * Number options that need some action when changed
    */
-  if (pp == &p_scbk) {
-    // 'scrollback'
-    if (p_scbk < 1) {
-      errmsg = e_invarg;
-      p_scbk = 0;
-    } else if (p_scbk > 100000) {
-      errmsg = e_invarg;
-      p_scbk = 100000;
-    }
-  } else if (pp == &p_wh || pp == &p_hh) {
+  if (pp == &p_wh || pp == &p_hh) {
     if (p_wh < 1) {
       errmsg = e_positive;
       p_wh = 1;
@@ -4205,7 +4196,19 @@ set_num_option (
     FOR_ALL_TAB_WINDOWS(tp, wp) {
       check_colorcolumn(wp);
     }
-
+  } else if (pp == &curbuf->b_p_scbk) {
+    // 'scrollback'
+    if (!curbuf->terminal) {
+      errmsg = e_invarg;
+      curbuf->b_p_scbk = -1;
+    } else {
+      if (curbuf->b_p_scbk < -1 || curbuf->b_p_scbk > 100000) {
+        errmsg = e_invarg;
+        curbuf->b_p_scbk = 1000;
+      }
+      // Force the scrollback to take effect.
+      terminal_resize(curbuf->terminal, UINT16_MAX, UINT16_MAX);
+    }
   }
 
   /*
@@ -5641,7 +5644,7 @@ void buf_copy_options(buf_T *buf, int flags)
       buf->b_p_ai = p_ai;
       buf->b_p_ai_nopaste = p_ai_nopaste;
       buf->b_p_sw = p_sw;
-      buf->b_p_scbk = p_scbk;
+      buf->b_p_scbk = -1;
       buf->b_p_tw = p_tw;
       buf->b_p_tw_nopaste = p_tw_nopaste;
       buf->b_p_tw_nobin = p_tw_nobin;
diff --git a/src/nvim/options.lua b/src/nvim/options.lua
index 3208979446..e12860c0cc 100644
--- a/src/nvim/options.lua
+++ b/src/nvim/options.lua
@@ -1918,7 +1918,7 @@ return {
       vi_def=true,
       varname='p_scbk',
       redraw={'current_buffer'},
-      defaults={if_true={vi=1000}}
+      defaults={if_true={vi=-1}}
     },
     {
       full_name='scrollbind', abbreviation='scb',
diff --git a/src/nvim/screen.c b/src/nvim/screen.c
index 6df443754b..f981fcb875 100644
--- a/src/nvim/screen.c
+++ b/src/nvim/screen.c
@@ -7113,8 +7113,9 @@ void showruler(int always)
   }
   if ((*p_stl != NUL || *curwin->w_p_stl != NUL) && curwin->w_status_height) {
     redraw_custom_statusline(curwin);
-  } else
+  } else {
     win_redr_ruler(curwin, always);
+  }
 
   if (need_maketitle
       || (p_icon && (stl_syntax & STL_IN_ICON))
diff --git a/src/nvim/terminal.c b/src/nvim/terminal.c
index e56b5da183..f156cd6abf 100644
--- a/src/nvim/terminal.c
+++ b/src/nvim/terminal.c
@@ -1,18 +1,17 @@
-// VT220/xterm-like terminal emulator implementation for nvim. Powered by
-// libvterm (http://www.leonerd.org.uk/code/libvterm/).
+// VT220/xterm-like terminal emulator.
+// Powered by libvterm http://www.leonerd.org.uk/code/libvterm
 //
 // libvterm is a pure C99 terminal emulation library with abstract input and
 // display. This means that the library needs to read data from the master fd
 // and feed VTerm instances, which will invoke user callbacks with screen
 // update instructions that must be mirrored to the real display.
 //
-// Keys are pressed in VTerm instances by calling
+// Keys are sent to VTerm instances by calling
 // vterm_keyboard_key/vterm_keyboard_unichar, which generates byte streams that
 // must be fed back to the master fd.
 //
-// This implementation uses nvim buffers as the display mechanism for both
-// the visible screen and the scrollback buffer. When focused, the window
-// "pins" to the bottom of the buffer and mirrors libvterm screen state.
+// Nvim buffers are used as the display mechanism for both the visible screen
+// and the scrollback buffer.
 //
 // When a line becomes invisible due to a decrease in screen height or because
 // a line was pushed up during normal terminal output, we store the line
@@ -23,18 +22,17 @@
 // scrollback buffer, which is mirrored in the nvim buffer displaying lines
 // that were previously invisible.
 //
-// The vterm->nvim synchronization is performed in intervals of 10
-// milliseconds. This is done to minimize screen updates when receiving large
-// bursts of data.
+// The vterm->nvim synchronization is performed in intervals of 10 milliseconds,
+// to minimize screen updates when receiving large bursts of data.
 //
 // This module is decoupled from the processes that normally feed it data, so
 // it's possible to use it as a general purpose console buffer (possibly as a
 // log/display mechanism for nvim in the future)
 //
-// Inspired by vimshell (http://www.wana.at/vimshell/) and
-// Conque (https://code.google.com/p/conque/). Libvterm usage instructions (plus
-// some extra code) were taken from
-// pangoterm (http://www.leonerd.org.uk/code/pangoterm/)
+// Inspired by: vimshell http://www.wana.at/vimshell
+//              Conque https://code.google.com/p/conque
+// Some code from pangoterm http://www.leonerd.org.uk/code/pangoterm
+
 #include <assert.h>
 #include <stdio.h>
 #include <stdint.h>
@@ -87,10 +85,10 @@ typedef struct terminal_state {
 # include "terminal.c.generated.h"
 #endif
 
-#define SCROLLBACK_BUFFER_DEFAULT_SIZE 1000
+#define SB_MAX 100000  // Maximum 'scrollback' value.
+
 // Delay for refreshing the terminal buffer after receiving updates from
-// libvterm. This is greatly improves performance when receiving large bursts
-// of data.
+// libvterm. Improves performance when receiving large bursts of data.
 #define REFRESH_DELAY 10
 
 static TimeWatcher refresh_timer;
@@ -102,27 +100,23 @@ typedef struct {
 } ScrollbackLine;
 
 struct terminal {
-  // options passed to terminal_open
-  TerminalOptions opts;
-  // libvterm structures
+  TerminalOptions opts;  // options passed to terminal_open
   VTerm *vt;
   VTermScreen *vts;
   // buffer used to:
   //  - convert VTermScreen cell arrays into utf8 strings
   //  - receive data from libvterm as a result of key presses.
   char textbuf[0x1fff];
-  // Scrollback buffer storage for libvterm.
-  // TODO(tarruda): Use a doubly-linked list
-  ScrollbackLine **sb_buffer;
-  // number of rows pushed to sb_buffer
-  size_t sb_current;
-  // sb_buffer size;
-  size_t sb_size;
+
+  ScrollbackLine **sb_buffer;       // Scrollback buffer storage for libvterm
+  size_t sb_current;                // number of rows pushed to sb_buffer
+  size_t sb_size;                   // sb_buffer size
   // "virtual index" that points to the first sb_buffer row that we need to
   // push to the terminal buffer when refreshing the scrollback. When negative,
   // it actually points to entries that are no longer in sb_buffer (because the
   // window height has increased) and must be deleted from the terminal buffer
   int sb_pending;
+
   // buf_T instance that acts as a "drawing surface" for libvterm
   // we can't store a direct reference to the buffer because the
   // refresh_timer_cb may be called after the buffer was freed, and there's
@@ -130,20 +124,18 @@ struct terminal {
   handle_T buf_handle;
   // program exited
   bool closed, destroy;
+
   // some vterm properties
   bool forward_mouse;
-  // invalid rows libvterm screen
-  int invalid_start, invalid_end;
+  int invalid_start, invalid_end;   // invalid rows in libvterm screen
   struct {
     int row, col;
     bool visible;
   } cursor;
-  // which mouse button is pressed
-  int pressed_button;
-  // pending width/height
-  bool pending_resize;
-  // With a reference count of 0 the terminal can be freed.
-  size_t refcount;
+  int pressed_button;               // which mouse button is pressed
+  bool pending_resize;              // pending width/height
+
+  size_t refcount;                  // reference count
 };
 
 static VTermScreenCallbacks vterm_screen_callbacks = {
@@ -238,28 +230,21 @@ Terminal *terminal_open(TerminalOptions opts)
   refresh_screen(rv, curbuf);
   set_option_value((uint8_t *)"buftype", 0, (uint8_t *)"terminal", OPT_LOCAL);
 
-  // some sane settings for terminal buffers
+  // Default settings for terminal buffers
   curbuf->b_p_ma = false;   // 'nomodifiable'
   curbuf->b_p_ul = -1;      // disable undo
+  curbuf->b_p_scbk = 1000;  // 'scrollback'
   set_option_value((uint8_t *)"wrap", false, NULL, OPT_LOCAL);
   set_option_value((uint8_t *)"number", false, NULL, OPT_LOCAL);
   set_option_value((uint8_t *)"relativenumber", false, NULL, OPT_LOCAL);
   buf_set_term_title(curbuf, (char *)curbuf->b_ffname);
   RESET_BINDING(curwin);
 
-  // Apply TermOpen autocmds so the user can configure the terminal
+  // Apply TermOpen autocmds _before_ configuring the scrollback buffer.
   apply_autocmds(EVENT_TERMOPEN, NULL, NULL, false, curbuf);
 
-  // Configure the scrollback buffer. Try to get the size from:
-  //
-  // - b:terminal_scrollback_buffer_size
-  // - g:terminal_scrollback_buffer_size
-  // - SCROLLBACK_BUFFER_DEFAULT_SIZE
-  //
-  // but limit to 100k.
-  int size = get_config_int("terminal_scrollback_buffer_size");
-  rv->sb_size = size > 0 ? (size_t)size : SCROLLBACK_BUFFER_DEFAULT_SIZE;
-  rv->sb_size = MIN(rv->sb_size, 100000);
+  // Configure the scrollback buffer.
+  rv->sb_size = curbuf->b_p_scbk < 0 ? SB_MAX : (size_t)curbuf->b_p_scbk;;
   rv->sb_buffer = xmalloc(sizeof(ScrollbackLine *) * rv->sb_size);
 
   if (!true_color) {
@@ -338,22 +323,22 @@ void terminal_close(Terminal *term, char *msg)
 void terminal_resize(Terminal *term, uint16_t width, uint16_t height)
 {
   if (term->closed) {
-    // will be called after exited if two windows display the same terminal and
-    // one of the is closed as a consequence of pressing a key.
+    // If two windows display the same terminal and one is closed by keypress.
     return;
   }
+  bool force = width == UINT16_MAX || height == UINT16_MAX;
   int curwidth, curheight;
   vterm_get_size(term->vt, &curheight, &curwidth);
 
-  if (!width) {
+  if (force || !width) {
     width = (uint16_t)curwidth;
   }
 
-  if (!height) {
+  if (force || !height) {
     height = (uint16_t)curheight;
   }
 
-  if (curheight == height && curwidth == width) {
+  if (!force && curheight == height && curwidth == width) {
     return;
   }
 
@@ -671,10 +656,15 @@ static int term_bell(void *data)
   return 1;
 }
 
-// the scrollback push/pop handlers were copied almost verbatim from pangoterm
+// Scrollback push handler (from pangoterm).
 static int term_sb_push(int cols, const VTermScreenCell *cells, void *data)
 {
   Terminal *term = data;
+
+  if (!term->sb_size) {
+    return 0;
+  }
+
   // copy vterm cells into sb_buffer
   size_t c = (size_t)cols;
   ScrollbackLine *sbrow = NULL;
@@ -686,10 +676,12 @@ static int term_sb_push(int cols, const VTermScreenCell *cells, void *data)
       xfree(term->sb_buffer[term->sb_current - 1]);
     }
 
+    // Make room at the start by shifting to the right.
     memmove(term->sb_buffer + 1, term->sb_buffer,
         sizeof(term->sb_buffer[0]) * (term->sb_current - 1));
 
   } else if (term->sb_current > 0) {
+    // Make room at the start by shifting to the right.
     memmove(term->sb_buffer + 1, term->sb_buffer,
         sizeof(term->sb_buffer[0]) * term->sb_current);
   }
@@ -699,6 +691,7 @@ static int term_sb_push(int cols, const VTermScreenCell *cells, void *data)
     sbrow->cols = c;
   }
 
+  // New row is added at the start of the storage buffer.
   term->sb_buffer[0] = sbrow;
   if (term->sb_current < term->sb_size) {
     term->sb_current++;
@@ -714,6 +707,11 @@ static int term_sb_push(int cols, const VTermScreenCell *cells, void *data)
   return 1;
 }
 
+/// Scrollback pop handler (from pangoterm).
+///
+/// @param cols
+/// @param cells  VTerm state to update.
+/// @param data   Terminal
 static int term_sb_pop(int cols, VTermScreenCell *cells, void *data)
 {
   Terminal *term = data;
@@ -726,24 +724,24 @@ static int term_sb_pop(int cols, VTermScreenCell *cells, void *data)
     term->sb_pending--;
   }
 
-  // restore vterm state
-  size_t c = (size_t)cols;
   ScrollbackLine *sbrow = term->sb_buffer[0];
   term->sb_current--;
+  // Forget the "popped" row by shifting the rest onto it.
   memmove(term->sb_buffer, term->sb_buffer + 1,
       sizeof(term->sb_buffer[0]) * (term->sb_current));
 
-  size_t cols_to_copy = c;
+  size_t cols_to_copy = (size_t)cols;
   if (cols_to_copy > sbrow->cols) {
     cols_to_copy = sbrow->cols;
   }
 
   // copy to vterm state
   memcpy(cells, sbrow->cells, sizeof(cells[0]) * cols_to_copy);
-  for (size_t col = cols_to_copy; col < c; col++) {
+  for (size_t col = cols_to_copy; col < (size_t)cols; col++) {
     cells[col].chars[0] = 0;
     cells[col].width = 1;
   }
+
   xfree(sbrow);
   pmap_put(ptr_t)(invalidated_terminals, term, NULL);
 
@@ -889,7 +887,7 @@ static bool send_mouse_event(Terminal *term, int c)
 // terminal buffer refresh & misc {{{
 
 
-void fetch_row(Terminal *term, int row, int end_col)
+static void fetch_row(Terminal *term, int row, int end_col)
 {
   int col = 0;
   size_t line_len = 0;
@@ -977,8 +975,7 @@ static void refresh_terminal(Terminal *term)
   });
   adjust_topline(term, buf, pending_resize);
 }
-// libuv timer callback. This will enqueue on_refresh to be processed as an
-// event.
+// Calls refresh_terminal() on all invalidated_terminals.
 static void refresh_timer_cb(TimeWatcher *watcher, void *data)
 {
   if (exiting) {  // Cannot redraw (requires event loop) during teardown/exit.
@@ -1012,7 +1009,37 @@ static void refresh_size(Terminal *term, buf_T *buf)
   term->opts.resize_cb((uint16_t)width, (uint16_t)height, term->opts.data);
 }
 
-// Refresh the scrollback of a invalidated terminal
+/// Adjusts scrollback storage after 'scrollback' option changed.
+static void on_scrollback_option_changed(Terminal *term, buf_T *buf)
+{
+  const size_t scbk = curbuf->b_p_scbk < 0
+                      ? SB_MAX : (size_t)MAX(1, curbuf->b_p_scbk);
+  assert(term->sb_current < SIZE_MAX);
+  if (term->sb_pending > 0) {  // Pending rows must be processed first.
+    abort();
+  }
+
+  // Delete lines exceeding the new 'scrollback' limit.
+  if (scbk < term->sb_current) {
+    size_t diff = term->sb_current - scbk;
+    for (size_t i = 0; i < diff; i++) {
+      ml_delete(1, false);
+      term->sb_current--;
+      xfree(term->sb_buffer[term->sb_current]);
+    }
+    deleted_lines(1, (long)diff);
+  }
+
+  // Resize the scrollback storage.
+  size_t sb_region = sizeof(ScrollbackLine *) * scbk;
+  if (scbk != term->sb_size) {
+    term->sb_buffer = xrealloc(term->sb_buffer, sb_region);
+  }
+
+  term->sb_size = scbk;
+}
+
+// Refresh the scrollback of an invalidated terminal.
 static void refresh_scrollback(Terminal *term, buf_T *buf)
 {
   int width, height;
@@ -1041,6 +1068,8 @@ static void refresh_scrollback(Terminal *term, buf_T *buf)
     ml_delete(buf->b_ml.ml_line_count, false);
     deleted_lines(buf->b_ml.ml_line_count, 1);
   }
+
+  on_scrollback_option_changed(term, buf);
 }
 
 // Refresh the screen (visible part of the buffer when the terminal is
@@ -1052,8 +1081,7 @@ static void refresh_screen(Terminal *term, buf_T *buf)
   int height;
   int width;
   vterm_get_size(term->vt, &height, &width);
-  // It's possible that the terminal height decreased and `term->invalid_end`
-  // doesn't reflect it yet
+  // Terminal height may have decreased before `invalid_end` reflects it.
   term->invalid_end = MIN(term->invalid_end, height);
 
   for (int r = term->invalid_start, linenr = row_to_linenr(term, r);
@@ -1182,17 +1210,6 @@ static char *get_config_string(char *key)
   return NULL;
 }
 
-static int get_config_int(char *key)
-{
-  Object obj;
-  GET_CONFIG_VALUE(key, obj);
-  if (obj.type == kObjectTypeInteger) {
-    return (int)obj.data.integer;
-  }
-  api_free_object(obj);
-  return 0;
-}
-
 // }}}
 
 // vim: foldmethod=marker
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index 82ae0e8cf5..c95a795587 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -308,8 +308,9 @@ bool undo_allowed(void)
 /// Get the 'undolevels' value for the current buffer.
 static long get_undolevel(void)
 {
-  if (curbuf->b_p_ul == NO_LOCAL_UNDOLEVEL)
+  if (curbuf->b_p_ul == NO_LOCAL_UNDOLEVEL) {
     return p_ul;
+  }
   return curbuf->b_p_ul;
 }