If at least two escape sequences were read, the beginning of the
second sequence would be off by one and the sequence would be
misinterpreted.
An escape sequence could be split in two parts and be
misinterpreted, when saved in a ring buffer with wrap around.
Fixes#2936
Extract the RBuffer class from rstream.c and reimplement it as a ring buffer,
a more efficient version that doesn't need to relocate memory.
The old rbuffer_read/rbuffer_write interfaces are kept for simple
reading/writing, and the RBUFFER_UNTIL_{FULL,EMPTY} macros are introduced to
hide wrapping logic when more control is required(such as passing the buffer
pointer to a library function that writes directly to the pointer)
Also add a basic infrastructure for writing helper C files that are only
compiled in the unit test library, and use this to write unit tests for RBuffer
which contains some macros that can't be accessed directly by luajit.
Helped-by: oni-link <knil.ino@gmail.com>
Reviewed-by: oni-link <knil.ino@gmail.com>
Reviewed-by: Scott Prager <splinterofchaos@gmail.com>
Reviewed-by: Justin M. Keyes <justinkz@gmail.com>
Reviewed-by: Michael Reed <m.reed@mykolab.com>
Making an environment variable empty can be a way of unsetting it for
platforms that don't support unsetenv(). In most cases, we treat empty
variables as having been unset. For all others, use os_env_exists().
When maximizing the window, often only lines would be detected properly
with the `try_resize` handler being called immediately.
Fixes https://github.com/neovim/neovim/issues/2322.
We already use wrappers for allocation, the new `xfree` function is the
equivalent for deallocation and provides a way to fully replace the malloc
implementation used by Neovim.
Instead of selecting stderr on startup if stdin is not a tty, first try reading
from it and only switch to stderr when reading fails. With this behavior we
support commands like:
```
echo q | nvim -es
```
and
```
ls *.md | xargs nvim
```
Fixed small bugs in rstream.c to make this happen.
Even though assuming nvim is busy most times is simpler, it has a problem: A lot
of unnecessary busy_start/busy_stop notifications are sent to the UI. That's
because in the majority of scenarios almost no time is spent between
`event_poll` calls.
This restores the normal behavior which is to call busy_start only when nvim is
going to perform some task that can take a significant amount of time. Also
improve the usage of buffering in the TUI when changing the cursor state.
Since #2158 all connected UIs are informed about the busy state of nvim.
This can be used to decide whether to hide or show the cursor (in one
place).
In the TUI, this is tui_flush(). To prevent cursor flashing, the
terminal is always redrawn with an invisible cursor. After that the
cursor is shown if necessary. In the current implementation
a cursor-hide command will always be the first command in the next
redraw, to prevent flashing. This is not necessary.
Instead we start the TUI with a hidden cursor and only need to hide the
cursor in the next redraw, if the cursor was shown in the last redraw.
Otherwise the cursor is still hidden.
So instead of sending every redraw the cursor-hide command, we only need
to send the command while not busy(a state in nvim with low frequency).
Switching cursor off is only necessary in two occasions:
- When redrawing to avoid terminal flickering
- When the editor is busy
The first can now be handled by the TUI, so most calls to ui_cursor_off can be
removed from the core.
So, before this commit it was only necessary to switch the cursor off to notify
the user that nvim was running some long operation. Now the cursor_{on,off}
functions have been replaced by busy_{stop,start} which can be handled in a
UI-specific way(turning the cursor off or showing a busy indicator, for
example).
To make things even more simpler, nvim is always busy except when waiting for
user input or other asynchronous events: It automatically switches to a non-busy
state when the event loop is about to be entered for more than 100 milliseconds.
`ui_busy_start` can be called when its not desired to change the busy state in
the event loop (As its now done by functions that perform blocking shell
invocations).
The current will segfault for large chunks of output because the output buffer
will be overrun.
Using unibi_format is simple because we can simply flush the buffer when its
full.
Many common terminals that set TERM=xterm and $COLORTERM support 256 colors. If
this is detected, use force the hardcoded xterm's setaf/setab capabilities.
For unibilium extension indexes, use signed integer type initialized with -1 to
distinguish from the first extension string which will always have index 0.
- Add xterm/iterm sequences for changing cursor shape(with tmux wrapping).
Enabled by setting the NVIM_TUI_ENABLE_CURSOR_SHAPE environment variable.
- Remove nvim_override parameter from unibi_out. In the future another way of
overriding the terminal strings will be added.
