mirror of https://github.com/neovim/neovim.git
3191 lines
94 KiB
C
3191 lines
94 KiB
C
// getchar.c: Code related to getting a character from the user or a script
|
|
// file, manipulations with redo buffer and stuff buffer.
|
|
|
|
#include <assert.h>
|
|
#include <lauxlib.h>
|
|
#include <limits.h>
|
|
#include <stdbool.h>
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "nvim/api/private/defs.h"
|
|
#include "nvim/api/private/helpers.h"
|
|
#include "nvim/ascii_defs.h"
|
|
#include "nvim/buffer_defs.h"
|
|
#include "nvim/charset.h"
|
|
#include "nvim/cursor.h"
|
|
#include "nvim/drawscreen.h"
|
|
#include "nvim/edit.h"
|
|
#include "nvim/errors.h"
|
|
#include "nvim/eval.h"
|
|
#include "nvim/eval/typval.h"
|
|
#include "nvim/eval/typval_defs.h"
|
|
#include "nvim/event/loop.h"
|
|
#include "nvim/event/multiqueue.h"
|
|
#include "nvim/ex_cmds.h"
|
|
#include "nvim/ex_docmd.h"
|
|
#include "nvim/ex_getln.h"
|
|
#include "nvim/garray.h"
|
|
#include "nvim/garray_defs.h"
|
|
#include "nvim/getchar.h"
|
|
#include "nvim/gettext_defs.h"
|
|
#include "nvim/globals.h"
|
|
#include "nvim/input.h"
|
|
#include "nvim/insexpand.h"
|
|
#include "nvim/keycodes.h"
|
|
#include "nvim/lua/executor.h"
|
|
#include "nvim/main.h"
|
|
#include "nvim/mapping.h"
|
|
#include "nvim/mapping_defs.h"
|
|
#include "nvim/mbyte.h"
|
|
#include "nvim/mbyte_defs.h"
|
|
#include "nvim/memline.h"
|
|
#include "nvim/memory.h"
|
|
#include "nvim/message.h"
|
|
#include "nvim/mouse.h"
|
|
#include "nvim/move.h"
|
|
#include "nvim/normal.h"
|
|
#include "nvim/normal_defs.h"
|
|
#include "nvim/ops.h"
|
|
#include "nvim/option_vars.h"
|
|
#include "nvim/os/fileio.h"
|
|
#include "nvim/os/input.h"
|
|
#include "nvim/os/os.h"
|
|
#include "nvim/os/os_defs.h"
|
|
#include "nvim/plines.h"
|
|
#include "nvim/pos_defs.h"
|
|
#include "nvim/state.h"
|
|
#include "nvim/state_defs.h"
|
|
#include "nvim/strings.h"
|
|
#include "nvim/types_defs.h"
|
|
#include "nvim/ui.h"
|
|
#include "nvim/undo.h"
|
|
#include "nvim/vim_defs.h"
|
|
|
|
/// State for adding bytes to a recording or 'showcmd'.
|
|
typedef struct {
|
|
uint8_t buf[MB_MAXBYTES * 3 + 4];
|
|
int prev_c;
|
|
size_t buflen;
|
|
unsigned pending_special;
|
|
unsigned pending_mbyte;
|
|
} gotchars_state_T;
|
|
|
|
/// Index in scriptin
|
|
static int curscript = -1;
|
|
/// Streams to read script from
|
|
static FileDescriptor scriptin[NSCRIPT] = { 0 };
|
|
|
|
// These buffers are used for storing:
|
|
// - stuffed characters: A command that is translated into another command.
|
|
// - redo characters: will redo the last change.
|
|
// - recorded characters: for the "q" command.
|
|
//
|
|
// The bytes are stored like in the typeahead buffer:
|
|
// - K_SPECIAL introduces a special key (two more bytes follow). A literal
|
|
// K_SPECIAL is stored as K_SPECIAL KS_SPECIAL KE_FILLER.
|
|
// These translations are also done on multi-byte characters!
|
|
//
|
|
// Escaping K_SPECIAL is done by inchar().
|
|
// Un-escaping is done by vgetc().
|
|
|
|
#define MINIMAL_SIZE 20 // minimal size for b_str
|
|
|
|
static buffheader_T redobuff = { { NULL, { NUL } }, NULL, 0, 0 };
|
|
static buffheader_T old_redobuff = { { NULL, { NUL } }, NULL, 0, 0 };
|
|
static buffheader_T recordbuff = { { NULL, { NUL } }, NULL, 0, 0 };
|
|
|
|
/// First read ahead buffer. Used for translated commands.
|
|
static buffheader_T readbuf1 = { { NULL, { NUL } }, NULL, 0, 0 };
|
|
|
|
/// Second read ahead buffer. Used for redo.
|
|
static buffheader_T readbuf2 = { { NULL, { NUL } }, NULL, 0, 0 };
|
|
|
|
/// Buffer used to store typed characters for vim.on_key().
|
|
static kvec_withinit_t(char, MAXMAPLEN) on_key_buf = KVI_INITIAL_VALUE(on_key_buf);
|
|
|
|
/// Number of following bytes that should not be stored for vim.on_key().
|
|
static size_t no_on_key_len = 0;
|
|
|
|
static int typeahead_char = 0; ///< typeahead char that's not flushed
|
|
|
|
/// When block_redo is true the redo buffer will not be changed.
|
|
/// Used by edit() to repeat insertions.
|
|
static bool block_redo = false;
|
|
|
|
static int KeyNoremap = 0; ///< remapping flags
|
|
|
|
/// Variables used by vgetorpeek() and flush_buffers()
|
|
///
|
|
/// typebuf.tb_buf[] contains all characters that are not consumed yet.
|
|
/// typebuf.tb_buf[typebuf.tb_off] is the first valid character.
|
|
/// typebuf.tb_buf[typebuf.tb_off + typebuf.tb_len - 1] is the last valid char.
|
|
/// typebuf.tb_buf[typebuf.tb_off + typebuf.tb_len] must be NUL.
|
|
/// The head of the buffer may contain the result of mappings, abbreviations
|
|
/// and @a commands. The length of this part is typebuf.tb_maplen.
|
|
/// typebuf.tb_silent is the part where <silent> applies.
|
|
/// After the head are characters that come from the terminal.
|
|
/// typebuf.tb_no_abbr_cnt is the number of characters in typebuf.tb_buf that
|
|
/// should not be considered for abbreviations.
|
|
/// Some parts of typebuf.tb_buf may not be mapped. These parts are remembered
|
|
/// in typebuf.tb_noremap[], which is the same length as typebuf.tb_buf and
|
|
/// contains RM_NONE for the characters that are not to be remapped.
|
|
/// typebuf.tb_noremap[typebuf.tb_off] is the first valid flag.
|
|
enum {
|
|
RM_YES = 0, ///< tb_noremap: remap
|
|
RM_NONE = 1, ///< tb_noremap: don't remap
|
|
RM_SCRIPT = 2, ///< tb_noremap: remap local script mappings
|
|
RM_ABBR = 4, ///< tb_noremap: don't remap, do abbrev.
|
|
};
|
|
|
|
// typebuf.tb_buf has three parts: room in front (for result of mappings), the
|
|
// middle for typeahead and room for new characters (which needs to be 3 *
|
|
// MAXMAPLEN for the Amiga).
|
|
#define TYPELEN_INIT (5 * (MAXMAPLEN + 3))
|
|
static uint8_t typebuf_init[TYPELEN_INIT]; ///< initial typebuf.tb_buf
|
|
static uint8_t noremapbuf_init[TYPELEN_INIT]; ///< initial typebuf.tb_noremap
|
|
|
|
static size_t last_recorded_len = 0; ///< number of last recorded chars
|
|
|
|
enum {
|
|
KEYLEN_PART_KEY = -1, ///< keylen value for incomplete key-code
|
|
KEYLEN_PART_MAP = -2, ///< keylen value for incomplete mapping
|
|
};
|
|
|
|
#ifdef INCLUDE_GENERATED_DECLARATIONS
|
|
# include "getchar.c.generated.h"
|
|
#endif
|
|
|
|
static const char e_recursive_mapping[] = N_("E223: Recursive mapping");
|
|
static const char e_cmd_mapping_must_end_with_cr[]
|
|
= N_("E1255: <Cmd> mapping must end with <CR>");
|
|
static const char e_cmd_mapping_must_end_with_cr_before_second_cmd[]
|
|
= N_("E1136: <Cmd> mapping must end with <CR> before second <Cmd>");
|
|
|
|
/// Free and clear a buffer.
|
|
static void free_buff(buffheader_T *buf)
|
|
{
|
|
buffblock_T *np;
|
|
|
|
for (buffblock_T *p = buf->bh_first.b_next; p != NULL; p = np) {
|
|
np = p->b_next;
|
|
xfree(p);
|
|
}
|
|
buf->bh_first.b_next = NULL;
|
|
buf->bh_curr = NULL;
|
|
}
|
|
|
|
/// Return the contents of a buffer as a single string.
|
|
/// K_SPECIAL in the returned string is escaped.
|
|
///
|
|
/// @param dozero count == zero is not an error
|
|
static char *get_buffcont(buffheader_T *buffer, int dozero)
|
|
{
|
|
size_t count = 0;
|
|
char *p = NULL;
|
|
|
|
// compute the total length of the string
|
|
for (const buffblock_T *bp = buffer->bh_first.b_next;
|
|
bp != NULL; bp = bp->b_next) {
|
|
count += strlen(bp->b_str);
|
|
}
|
|
|
|
if (count > 0 || dozero) {
|
|
p = xmalloc(count + 1);
|
|
char *p2 = p;
|
|
for (const buffblock_T *bp = buffer->bh_first.b_next;
|
|
bp != NULL; bp = bp->b_next) {
|
|
for (const char *str = bp->b_str; *str;) {
|
|
*p2++ = *str++;
|
|
}
|
|
}
|
|
*p2 = NUL;
|
|
}
|
|
return p;
|
|
}
|
|
|
|
/// Return the contents of the record buffer as a single string
|
|
/// and clear the record buffer.
|
|
/// K_SPECIAL in the returned string is escaped.
|
|
char *get_recorded(void)
|
|
{
|
|
char *p = get_buffcont(&recordbuff, true);
|
|
free_buff(&recordbuff);
|
|
|
|
// Remove the characters that were added the last time, these must be the
|
|
// (possibly mapped) characters that stopped the recording.
|
|
size_t len = strlen(p);
|
|
if (len >= last_recorded_len) {
|
|
len -= last_recorded_len;
|
|
p[len] = NUL;
|
|
}
|
|
|
|
// When stopping recording from Insert mode with CTRL-O q, also remove the
|
|
// CTRL-O.
|
|
if (len > 0 && restart_edit != 0 && p[len - 1] == Ctrl_O) {
|
|
p[len - 1] = NUL;
|
|
}
|
|
|
|
return p;
|
|
}
|
|
|
|
/// Return the contents of the redo buffer as a single string.
|
|
/// K_SPECIAL in the returned string is escaped.
|
|
char *get_inserted(void)
|
|
{
|
|
return get_buffcont(&redobuff, false);
|
|
}
|
|
|
|
/// Add string after the current block of the given buffer
|
|
///
|
|
/// K_SPECIAL should have been escaped already.
|
|
///
|
|
/// @param[out] buf Buffer to add to.
|
|
/// @param[in] s String to add.
|
|
/// @param[in] slen String length or -1 for NUL-terminated string.
|
|
static void add_buff(buffheader_T *const buf, const char *const s, ptrdiff_t slen)
|
|
{
|
|
if (slen < 0) {
|
|
slen = (ptrdiff_t)strlen(s);
|
|
}
|
|
if (slen == 0) { // don't add empty strings
|
|
return;
|
|
}
|
|
|
|
if (buf->bh_first.b_next == NULL) { // first add to list
|
|
buf->bh_space = 0;
|
|
buf->bh_curr = &(buf->bh_first);
|
|
} else if (buf->bh_curr == NULL) { // buffer has already been read
|
|
iemsg(_("E222: Add to read buffer"));
|
|
return;
|
|
} else if (buf->bh_index != 0) {
|
|
memmove(buf->bh_first.b_next->b_str,
|
|
buf->bh_first.b_next->b_str + buf->bh_index,
|
|
strlen(buf->bh_first.b_next->b_str + buf->bh_index) + 1);
|
|
}
|
|
buf->bh_index = 0;
|
|
|
|
size_t len;
|
|
if (buf->bh_space >= (size_t)slen) {
|
|
len = strlen(buf->bh_curr->b_str);
|
|
xmemcpyz(buf->bh_curr->b_str + len, s, (size_t)slen);
|
|
buf->bh_space -= (size_t)slen;
|
|
} else {
|
|
if (slen < MINIMAL_SIZE) {
|
|
len = MINIMAL_SIZE;
|
|
} else {
|
|
len = (size_t)slen;
|
|
}
|
|
buffblock_T *p = xmalloc(offsetof(buffblock_T, b_str) + len + 1);
|
|
buf->bh_space = len - (size_t)slen;
|
|
xmemcpyz(p->b_str, s, (size_t)slen);
|
|
|
|
p->b_next = buf->bh_curr->b_next;
|
|
buf->bh_curr->b_next = p;
|
|
buf->bh_curr = p;
|
|
}
|
|
}
|
|
|
|
/// Delete "slen" bytes from the end of "buf".
|
|
/// Only works when it was just added.
|
|
static void delete_buff_tail(buffheader_T *buf, int slen)
|
|
{
|
|
if (buf->bh_curr == NULL) {
|
|
return; // nothing to delete
|
|
}
|
|
int len = (int)strlen(buf->bh_curr->b_str);
|
|
if (len < slen) {
|
|
return;
|
|
}
|
|
|
|
buf->bh_curr->b_str[len - slen] = NUL;
|
|
buf->bh_space += (size_t)slen;
|
|
}
|
|
|
|
/// Add number "n" to buffer "buf".
|
|
static void add_num_buff(buffheader_T *buf, int n)
|
|
{
|
|
char number[32];
|
|
snprintf(number, sizeof(number), "%d", n);
|
|
add_buff(buf, number, -1);
|
|
}
|
|
|
|
/// Add character 'c' to buffer "buf".
|
|
/// Translates special keys, NUL, K_SPECIAL and multibyte characters.
|
|
static void add_char_buff(buffheader_T *buf, int c)
|
|
{
|
|
uint8_t bytes[MB_MAXBYTES + 1];
|
|
|
|
int len;
|
|
if (IS_SPECIAL(c)) {
|
|
len = 1;
|
|
} else {
|
|
len = utf_char2bytes(c, (char *)bytes);
|
|
}
|
|
|
|
for (int i = 0; i < len; i++) {
|
|
if (!IS_SPECIAL(c)) {
|
|
c = bytes[i];
|
|
}
|
|
|
|
char temp[4];
|
|
if (IS_SPECIAL(c) || c == K_SPECIAL || c == NUL) {
|
|
// Translate special key code into three byte sequence.
|
|
temp[0] = (char)K_SPECIAL;
|
|
temp[1] = (char)K_SECOND(c);
|
|
temp[2] = (char)K_THIRD(c);
|
|
temp[3] = NUL;
|
|
} else {
|
|
temp[0] = (char)c;
|
|
temp[1] = NUL;
|
|
}
|
|
add_buff(buf, temp, -1);
|
|
}
|
|
}
|
|
|
|
/// Get one byte from the read buffers. Use readbuf1 one first, use readbuf2
|
|
/// if that one is empty.
|
|
/// If advance == true go to the next char.
|
|
/// No translation is done K_SPECIAL is escaped.
|
|
static int read_readbuffers(bool advance)
|
|
{
|
|
int c = read_readbuf(&readbuf1, advance);
|
|
if (c == NUL) {
|
|
c = read_readbuf(&readbuf2, advance);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
static int read_readbuf(buffheader_T *buf, bool advance)
|
|
{
|
|
if (buf->bh_first.b_next == NULL) { // buffer is empty
|
|
return NUL;
|
|
}
|
|
|
|
buffblock_T *const curr = buf->bh_first.b_next;
|
|
uint8_t c = (uint8_t)curr->b_str[buf->bh_index];
|
|
|
|
if (advance) {
|
|
if (curr->b_str[++buf->bh_index] == NUL) {
|
|
buf->bh_first.b_next = curr->b_next;
|
|
xfree(curr);
|
|
buf->bh_index = 0;
|
|
}
|
|
}
|
|
return c;
|
|
}
|
|
|
|
/// Prepare the read buffers for reading (if they contain something).
|
|
static void start_stuff(void)
|
|
{
|
|
if (readbuf1.bh_first.b_next != NULL) {
|
|
readbuf1.bh_curr = &(readbuf1.bh_first);
|
|
readbuf1.bh_space = 0;
|
|
}
|
|
if (readbuf2.bh_first.b_next != NULL) {
|
|
readbuf2.bh_curr = &(readbuf2.bh_first);
|
|
readbuf2.bh_space = 0;
|
|
}
|
|
}
|
|
|
|
/// @return true if the stuff buffer is empty.
|
|
bool stuff_empty(void)
|
|
FUNC_ATTR_PURE
|
|
{
|
|
return (readbuf1.bh_first.b_next == NULL && readbuf2.bh_first.b_next == NULL);
|
|
}
|
|
|
|
/// @return true if readbuf1 is empty. There may still be redo characters in
|
|
/// redbuf2.
|
|
bool readbuf1_empty(void)
|
|
FUNC_ATTR_PURE
|
|
{
|
|
return (readbuf1.bh_first.b_next == NULL);
|
|
}
|
|
|
|
/// Set a typeahead character that won't be flushed.
|
|
void typeahead_noflush(int c)
|
|
{
|
|
typeahead_char = c;
|
|
}
|
|
|
|
/// Remove the contents of the stuff buffer and the mapped characters in the
|
|
/// typeahead buffer (used in case of an error). If "flush_typeahead" is true,
|
|
/// flush all typeahead characters (used when interrupted by a CTRL-C).
|
|
void flush_buffers(flush_buffers_T flush_typeahead)
|
|
{
|
|
init_typebuf();
|
|
|
|
start_stuff();
|
|
while (read_readbuffers(true) != NUL) {}
|
|
|
|
if (flush_typeahead == FLUSH_MINIMAL) {
|
|
// remove mapped characters at the start only
|
|
typebuf.tb_off += typebuf.tb_maplen;
|
|
typebuf.tb_len -= typebuf.tb_maplen;
|
|
} else {
|
|
// remove typeahead
|
|
if (flush_typeahead == FLUSH_INPUT) {
|
|
// We have to get all characters, because we may delete the first
|
|
// part of an escape sequence. In an xterm we get one char at a
|
|
// time and we have to get them all.
|
|
while (inchar(typebuf.tb_buf, typebuf.tb_buflen - 1, 10) != 0) {}
|
|
}
|
|
typebuf.tb_off = MAXMAPLEN;
|
|
typebuf.tb_len = 0;
|
|
// Reset the flag that text received from a client or from feedkeys()
|
|
// was inserted in the typeahead buffer.
|
|
typebuf_was_filled = false;
|
|
}
|
|
typebuf.tb_maplen = 0;
|
|
typebuf.tb_silent = 0;
|
|
cmd_silent = false;
|
|
typebuf.tb_no_abbr_cnt = 0;
|
|
if (++typebuf.tb_change_cnt == 0) {
|
|
typebuf.tb_change_cnt = 1;
|
|
}
|
|
}
|
|
|
|
/// flush map and typeahead buffers and give a warning for an error
|
|
void beep_flush(void)
|
|
{
|
|
if (emsg_silent == 0) {
|
|
flush_buffers(FLUSH_MINIMAL);
|
|
vim_beep(BO_ERROR);
|
|
}
|
|
}
|
|
|
|
/// The previous contents of the redo buffer is kept in old_redobuffer.
|
|
/// This is used for the CTRL-O <.> command in insert mode.
|
|
void ResetRedobuff(void)
|
|
{
|
|
if (block_redo) {
|
|
return;
|
|
}
|
|
|
|
free_buff(&old_redobuff);
|
|
old_redobuff = redobuff;
|
|
redobuff.bh_first.b_next = NULL;
|
|
}
|
|
|
|
/// Discard the contents of the redo buffer and restore the previous redo
|
|
/// buffer.
|
|
void CancelRedo(void)
|
|
{
|
|
if (block_redo) {
|
|
return;
|
|
}
|
|
|
|
free_buff(&redobuff);
|
|
redobuff = old_redobuff;
|
|
old_redobuff.bh_first.b_next = NULL;
|
|
start_stuff();
|
|
while (read_readbuffers(true) != NUL) {}
|
|
}
|
|
|
|
/// Save redobuff and old_redobuff to save_redobuff and save_old_redobuff.
|
|
/// Used before executing autocommands and user functions.
|
|
void saveRedobuff(save_redo_T *save_redo)
|
|
{
|
|
save_redo->sr_redobuff = redobuff;
|
|
redobuff.bh_first.b_next = NULL;
|
|
save_redo->sr_old_redobuff = old_redobuff;
|
|
old_redobuff.bh_first.b_next = NULL;
|
|
|
|
// Make a copy, so that ":normal ." in a function works.
|
|
char *const s = get_buffcont(&save_redo->sr_redobuff, false);
|
|
if (s == NULL) {
|
|
return;
|
|
}
|
|
|
|
add_buff(&redobuff, s, -1);
|
|
xfree(s);
|
|
}
|
|
|
|
/// Restore redobuff and old_redobuff from save_redobuff and save_old_redobuff.
|
|
/// Used after executing autocommands and user functions.
|
|
void restoreRedobuff(save_redo_T *save_redo)
|
|
{
|
|
free_buff(&redobuff);
|
|
redobuff = save_redo->sr_redobuff;
|
|
free_buff(&old_redobuff);
|
|
old_redobuff = save_redo->sr_old_redobuff;
|
|
}
|
|
|
|
/// Append "s" to the redo buffer.
|
|
/// K_SPECIAL should already have been escaped.
|
|
void AppendToRedobuff(const char *s)
|
|
{
|
|
if (!block_redo) {
|
|
add_buff(&redobuff, s, -1);
|
|
}
|
|
}
|
|
|
|
/// Append to Redo buffer literally, escaping special characters with CTRL-V.
|
|
/// K_SPECIAL is escaped as well.
|
|
///
|
|
/// @param str String to append
|
|
/// @param len Length of `str` or -1 for up to the NUL.
|
|
void AppendToRedobuffLit(const char *str, int len)
|
|
{
|
|
if (block_redo) {
|
|
return;
|
|
}
|
|
|
|
const char *s = str;
|
|
while (len < 0 ? *s != NUL : s - str < len) {
|
|
// Put a string of normal characters in the redo buffer (that's
|
|
// faster).
|
|
const char *start = s;
|
|
while (*s >= ' ' && *s < DEL && (len < 0 || s - str < len)) {
|
|
s++;
|
|
}
|
|
|
|
// Don't put '0' or '^' as last character, just in case a CTRL-D is
|
|
// typed next.
|
|
if (*s == NUL && (s[-1] == '0' || s[-1] == '^')) {
|
|
s--;
|
|
}
|
|
if (s > start) {
|
|
add_buff(&redobuff, start, s - start);
|
|
}
|
|
|
|
if (*s == NUL || (len >= 0 && s - str >= len)) {
|
|
break;
|
|
}
|
|
|
|
// Handle a special or multibyte character.
|
|
// Composing chars separately are handled separately.
|
|
const int c = mb_cptr2char_adv(&s);
|
|
if (c < ' ' || c == DEL || (*s == NUL && (c == '0' || c == '^'))) {
|
|
add_char_buff(&redobuff, Ctrl_V);
|
|
}
|
|
|
|
// CTRL-V '0' must be inserted as CTRL-V 048.
|
|
if (*s == NUL && c == '0') {
|
|
add_buff(&redobuff, "048", 3);
|
|
} else {
|
|
add_char_buff(&redobuff, c);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Append "s" to the redo buffer, leaving 3-byte special key codes unmodified
|
|
/// and escaping other K_SPECIAL bytes.
|
|
void AppendToRedobuffSpec(const char *s)
|
|
{
|
|
if (block_redo) {
|
|
return;
|
|
}
|
|
|
|
while (*s != NUL) {
|
|
if ((uint8_t)(*s) == K_SPECIAL && s[1] != NUL && s[2] != NUL) {
|
|
// Insert special key literally.
|
|
add_buff(&redobuff, s, 3);
|
|
s += 3;
|
|
} else {
|
|
add_char_buff(&redobuff, mb_cptr2char_adv(&s));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Append a character to the redo buffer.
|
|
/// Translates special keys, NUL, K_SPECIAL and multibyte characters.
|
|
void AppendCharToRedobuff(int c)
|
|
{
|
|
if (!block_redo) {
|
|
add_char_buff(&redobuff, c);
|
|
}
|
|
}
|
|
|
|
// Append a number to the redo buffer.
|
|
void AppendNumberToRedobuff(int n)
|
|
{
|
|
if (!block_redo) {
|
|
add_num_buff(&redobuff, n);
|
|
}
|
|
}
|
|
|
|
/// Append string "s" to the stuff buffer.
|
|
/// K_SPECIAL must already have been escaped.
|
|
void stuffReadbuff(const char *s)
|
|
{
|
|
add_buff(&readbuf1, s, -1);
|
|
}
|
|
|
|
/// Append string "s" to the redo stuff buffer.
|
|
/// @remark K_SPECIAL must already have been escaped.
|
|
void stuffRedoReadbuff(const char *s)
|
|
{
|
|
add_buff(&readbuf2, s, -1);
|
|
}
|
|
|
|
void stuffReadbuffLen(const char *s, ptrdiff_t len)
|
|
{
|
|
add_buff(&readbuf1, s, len);
|
|
}
|
|
|
|
/// Stuff "s" into the stuff buffer, leaving special key codes unmodified and
|
|
/// escaping other K_SPECIAL bytes.
|
|
/// Change CR, LF and ESC into a space.
|
|
void stuffReadbuffSpec(const char *s)
|
|
{
|
|
while (*s != NUL) {
|
|
if ((uint8_t)(*s) == K_SPECIAL && s[1] != NUL && s[2] != NUL) {
|
|
// Insert special key literally.
|
|
stuffReadbuffLen(s, 3);
|
|
s += 3;
|
|
} else {
|
|
int c = mb_cptr2char_adv(&s);
|
|
if (c == CAR || c == NL || c == ESC) {
|
|
c = ' ';
|
|
}
|
|
stuffcharReadbuff(c);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Append a character to the stuff buffer.
|
|
/// Translates special keys, NUL, K_SPECIAL and multibyte characters.
|
|
void stuffcharReadbuff(int c)
|
|
{
|
|
add_char_buff(&readbuf1, c);
|
|
}
|
|
|
|
// Append a number to the stuff buffer.
|
|
void stuffnumReadbuff(int n)
|
|
{
|
|
add_num_buff(&readbuf1, n);
|
|
}
|
|
|
|
/// Stuff a string into the typeahead buffer, such that edit() will insert it
|
|
/// literally ("literally" true) or interpret is as typed characters.
|
|
void stuffescaped(const char *arg, bool literally)
|
|
{
|
|
while (*arg != NUL) {
|
|
// Stuff a sequence of normal ASCII characters, that's fast. Also
|
|
// stuff K_SPECIAL to get the effect of a special key when "literally"
|
|
// is true.
|
|
const char *const start = arg;
|
|
while ((*arg >= ' ' && *arg < DEL) || ((uint8_t)(*arg) == K_SPECIAL
|
|
&& !literally)) {
|
|
arg++;
|
|
}
|
|
if (arg > start) {
|
|
stuffReadbuffLen(start, arg - start);
|
|
}
|
|
|
|
// stuff a single special character
|
|
if (*arg != NUL) {
|
|
const int c = mb_cptr2char_adv(&arg);
|
|
if (literally && ((c < ' ' && c != TAB) || c == DEL)) {
|
|
stuffcharReadbuff(Ctrl_V);
|
|
}
|
|
stuffcharReadbuff(c);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Read a character from the redo buffer. Translates K_SPECIAL and
|
|
/// multibyte characters.
|
|
/// The redo buffer is left as it is.
|
|
/// If init is true, prepare for redo, return FAIL if nothing to redo, OK
|
|
/// otherwise.
|
|
/// If old_redo is true, use old_redobuff instead of redobuff.
|
|
static int read_redo(bool init, bool old_redo)
|
|
{
|
|
static buffblock_T *bp;
|
|
static uint8_t *p;
|
|
int c;
|
|
int n;
|
|
uint8_t buf[MB_MAXBYTES + 1];
|
|
|
|
if (init) {
|
|
bp = old_redo ? old_redobuff.bh_first.b_next : redobuff.bh_first.b_next;
|
|
if (bp == NULL) {
|
|
return FAIL;
|
|
}
|
|
p = (uint8_t *)bp->b_str;
|
|
return OK;
|
|
}
|
|
if ((c = *p) == NUL) {
|
|
return c;
|
|
}
|
|
// Reverse the conversion done by add_char_buff()
|
|
// For a multi-byte character get all the bytes and return the
|
|
// converted character.
|
|
if (c != K_SPECIAL || p[1] == KS_SPECIAL) {
|
|
n = MB_BYTE2LEN_CHECK(c);
|
|
} else {
|
|
n = 1;
|
|
}
|
|
for (int i = 0;; i++) {
|
|
if (c == K_SPECIAL) { // special key or escaped K_SPECIAL
|
|
c = TO_SPECIAL(p[1], p[2]);
|
|
p += 2;
|
|
}
|
|
if (*++p == NUL && bp->b_next != NULL) {
|
|
bp = bp->b_next;
|
|
p = (uint8_t *)bp->b_str;
|
|
}
|
|
buf[i] = (uint8_t)c;
|
|
if (i == n - 1) { // last byte of a character
|
|
if (n != 1) {
|
|
c = utf_ptr2char((char *)buf);
|
|
}
|
|
break;
|
|
}
|
|
c = *p;
|
|
if (c == NUL) { // cannot happen?
|
|
break;
|
|
}
|
|
}
|
|
|
|
return c;
|
|
}
|
|
|
|
/// Copy the rest of the redo buffer into the stuff buffer (in a slow way).
|
|
/// If old_redo is true, use old_redobuff instead of redobuff.
|
|
/// The escaped K_SPECIAL is copied without translation.
|
|
static void copy_redo(bool old_redo)
|
|
{
|
|
int c;
|
|
|
|
while ((c = read_redo(false, old_redo)) != NUL) {
|
|
add_char_buff(&readbuf2, c);
|
|
}
|
|
}
|
|
|
|
/// Stuff the redo buffer into readbuf2.
|
|
/// Insert the redo count into the command.
|
|
/// If "old_redo" is true, the last but one command is repeated
|
|
/// instead of the last command (inserting text). This is used for
|
|
/// CTRL-O <.> in insert mode
|
|
///
|
|
/// @return FAIL for failure, OK otherwise
|
|
int start_redo(int count, bool old_redo)
|
|
{
|
|
// init the pointers; return if nothing to redo
|
|
if (read_redo(true, old_redo) == FAIL) {
|
|
return FAIL;
|
|
}
|
|
|
|
int c = read_redo(false, old_redo);
|
|
|
|
// copy the buffer name, if present
|
|
if (c == '"') {
|
|
add_buff(&readbuf2, "\"", 1);
|
|
c = read_redo(false, old_redo);
|
|
|
|
// if a numbered buffer is used, increment the number
|
|
if (c >= '1' && c < '9') {
|
|
c++;
|
|
}
|
|
add_char_buff(&readbuf2, c);
|
|
|
|
// the expression register should be re-evaluated
|
|
if (c == '=') {
|
|
add_char_buff(&readbuf2, CAR);
|
|
cmd_silent = true;
|
|
}
|
|
|
|
c = read_redo(false, old_redo);
|
|
}
|
|
|
|
if (c == 'v') { // redo Visual
|
|
VIsual = curwin->w_cursor;
|
|
VIsual_active = true;
|
|
VIsual_select = false;
|
|
VIsual_reselect = true;
|
|
redo_VIsual_busy = true;
|
|
c = read_redo(false, old_redo);
|
|
}
|
|
|
|
// try to enter the count (in place of a previous count)
|
|
if (count) {
|
|
while (ascii_isdigit(c)) { // skip "old" count
|
|
c = read_redo(false, old_redo);
|
|
}
|
|
add_num_buff(&readbuf2, count);
|
|
}
|
|
|
|
// copy from the redo buffer into the stuff buffer
|
|
add_char_buff(&readbuf2, c);
|
|
copy_redo(old_redo);
|
|
return OK;
|
|
}
|
|
|
|
/// Repeat the last insert (R, o, O, a, A, i or I command) by stuffing
|
|
/// the redo buffer into readbuf2.
|
|
///
|
|
/// @return FAIL for failure, OK otherwise
|
|
int start_redo_ins(void)
|
|
{
|
|
int c;
|
|
|
|
if (read_redo(true, false) == FAIL) {
|
|
return FAIL;
|
|
}
|
|
start_stuff();
|
|
|
|
// skip the count and the command character
|
|
while ((c = read_redo(false, false)) != NUL) {
|
|
if (vim_strchr("AaIiRrOo", c) != NULL) {
|
|
if (c == 'O' || c == 'o') {
|
|
add_buff(&readbuf2, NL_STR, -1);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// copy the typed text from the redo buffer into the stuff buffer
|
|
copy_redo(false);
|
|
block_redo = true;
|
|
return OK;
|
|
}
|
|
|
|
void stop_redo_ins(void)
|
|
{
|
|
block_redo = false;
|
|
}
|
|
|
|
/// Initialize typebuf.tb_buf to point to typebuf_init.
|
|
/// alloc() cannot be used here: In out-of-memory situations it would
|
|
/// be impossible to type anything.
|
|
static void init_typebuf(void)
|
|
{
|
|
if (typebuf.tb_buf != NULL) {
|
|
return;
|
|
}
|
|
|
|
typebuf.tb_buf = typebuf_init;
|
|
typebuf.tb_noremap = noremapbuf_init;
|
|
typebuf.tb_buflen = TYPELEN_INIT;
|
|
typebuf.tb_len = 0;
|
|
typebuf.tb_off = MAXMAPLEN + 4;
|
|
typebuf.tb_change_cnt = 1;
|
|
}
|
|
|
|
/// @return true when keys cannot be remapped.
|
|
bool noremap_keys(void)
|
|
{
|
|
return KeyNoremap & (RM_NONE|RM_SCRIPT);
|
|
}
|
|
|
|
/// Insert a string in position "offset" in the typeahead buffer.
|
|
///
|
|
/// If "noremap" is REMAP_YES, new string can be mapped again.
|
|
/// If "noremap" is REMAP_NONE, new string cannot be mapped again.
|
|
/// If "noremap" is REMAP_SKIP, first char of new string cannot be mapped again,
|
|
/// but abbreviations are allowed.
|
|
/// If "noremap" is REMAP_SCRIPT, new string cannot be mapped again, except for
|
|
/// script-local mappings.
|
|
/// If "noremap" is > 0, that many characters of the new string cannot be mapped.
|
|
///
|
|
/// If "nottyped" is true, the string does not return KeyTyped (don't use when
|
|
/// "offset" is non-zero!).
|
|
///
|
|
/// If "silent" is true, cmd_silent is set when the characters are obtained.
|
|
///
|
|
/// @return FAIL for failure, OK otherwise
|
|
int ins_typebuf(char *str, int noremap, int offset, bool nottyped, bool silent)
|
|
{
|
|
int val;
|
|
int nrm;
|
|
|
|
init_typebuf();
|
|
if (++typebuf.tb_change_cnt == 0) {
|
|
typebuf.tb_change_cnt = 1;
|
|
}
|
|
state_no_longer_safe("ins_typebuf()");
|
|
|
|
int addlen = (int)strlen(str);
|
|
|
|
if (offset == 0 && addlen <= typebuf.tb_off) {
|
|
// Easy case: there is room in front of typebuf.tb_buf[typebuf.tb_off]
|
|
typebuf.tb_off -= addlen;
|
|
memmove(typebuf.tb_buf + typebuf.tb_off, str, (size_t)addlen);
|
|
} else if (typebuf.tb_len == 0
|
|
&& typebuf.tb_buflen >= addlen + 3 * (MAXMAPLEN + 4)) {
|
|
// Buffer is empty and string fits in the existing buffer.
|
|
// Leave some space before and after, if possible.
|
|
typebuf.tb_off = (typebuf.tb_buflen - addlen - 3 * (MAXMAPLEN + 4)) / 2;
|
|
memmove(typebuf.tb_buf + typebuf.tb_off, str, (size_t)addlen);
|
|
} else {
|
|
// Need to allocate a new buffer.
|
|
// In typebuf.tb_buf there must always be room for 3 * (MAXMAPLEN + 4)
|
|
// characters. We add some extra room to avoid having to allocate too
|
|
// often.
|
|
int newoff = MAXMAPLEN + 4;
|
|
int extra = addlen + newoff + 4 * (MAXMAPLEN + 4);
|
|
if (typebuf.tb_len > INT_MAX - extra) {
|
|
// string is getting too long for 32 bit int
|
|
emsg(_(e_toocompl)); // also calls flush_buffers
|
|
setcursor();
|
|
return FAIL;
|
|
}
|
|
int newlen = typebuf.tb_len + extra;
|
|
uint8_t *s1 = xmalloc((size_t)newlen);
|
|
uint8_t *s2 = xmalloc((size_t)newlen);
|
|
typebuf.tb_buflen = newlen;
|
|
|
|
// copy the old chars, before the insertion point
|
|
memmove(s1 + newoff, typebuf.tb_buf + typebuf.tb_off, (size_t)offset);
|
|
// copy the new chars
|
|
memmove(s1 + newoff + offset, str, (size_t)addlen);
|
|
// copy the old chars, after the insertion point, including the NUL at
|
|
// the end
|
|
int bytes = typebuf.tb_len - offset + 1;
|
|
assert(bytes > 0);
|
|
memmove(s1 + newoff + offset + addlen,
|
|
typebuf.tb_buf + typebuf.tb_off + offset, (size_t)bytes);
|
|
if (typebuf.tb_buf != typebuf_init) {
|
|
xfree(typebuf.tb_buf);
|
|
}
|
|
typebuf.tb_buf = s1;
|
|
|
|
memmove(s2 + newoff, typebuf.tb_noremap + typebuf.tb_off,
|
|
(size_t)offset);
|
|
memmove(s2 + newoff + offset + addlen,
|
|
typebuf.tb_noremap + typebuf.tb_off + offset,
|
|
(size_t)(typebuf.tb_len - offset));
|
|
if (typebuf.tb_noremap != noremapbuf_init) {
|
|
xfree(typebuf.tb_noremap);
|
|
}
|
|
typebuf.tb_noremap = s2;
|
|
|
|
typebuf.tb_off = newoff;
|
|
}
|
|
typebuf.tb_len += addlen;
|
|
|
|
// If noremap == REMAP_SCRIPT: do remap script-local mappings.
|
|
if (noremap == REMAP_SCRIPT) {
|
|
val = RM_SCRIPT;
|
|
} else if (noremap == REMAP_SKIP) {
|
|
val = RM_ABBR;
|
|
} else {
|
|
val = RM_NONE;
|
|
}
|
|
|
|
// Adjust typebuf.tb_noremap[] for the new characters:
|
|
// If noremap == REMAP_NONE or REMAP_SCRIPT: new characters are
|
|
// (sometimes) not remappable
|
|
// If noremap == REMAP_YES: all the new characters are mappable
|
|
// If noremap > 0: "noremap" characters are not remappable, the rest
|
|
// mappable
|
|
if (noremap == REMAP_SKIP) {
|
|
nrm = 1;
|
|
} else if (noremap < 0) {
|
|
nrm = addlen;
|
|
} else {
|
|
nrm = noremap;
|
|
}
|
|
for (int i = 0; i < addlen; i++) {
|
|
typebuf.tb_noremap[typebuf.tb_off + i + offset] =
|
|
(uint8_t)((--nrm >= 0) ? val : RM_YES);
|
|
}
|
|
|
|
// tb_maplen and tb_silent only remember the length of mapped and/or
|
|
// silent mappings at the start of the buffer, assuming that a mapped
|
|
// sequence doesn't result in typed characters.
|
|
if (nottyped || typebuf.tb_maplen > offset) {
|
|
typebuf.tb_maplen += addlen;
|
|
}
|
|
if (silent || typebuf.tb_silent > offset) {
|
|
typebuf.tb_silent += addlen;
|
|
cmd_silent = true;
|
|
}
|
|
if (typebuf.tb_no_abbr_cnt && offset == 0) { // and not used for abbrev.s
|
|
typebuf.tb_no_abbr_cnt += addlen;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
/// Put character "c" back into the typeahead buffer.
|
|
/// Can be used for a character obtained by vgetc() that needs to be put back.
|
|
/// Uses cmd_silent, KeyTyped and KeyNoremap to restore the flags belonging to
|
|
/// the char.
|
|
///
|
|
/// @param no_on_key don't store these bytes for vim.on_key()
|
|
///
|
|
/// @return the length of what was inserted
|
|
int ins_char_typebuf(int c, int modifiers, bool no_on_key)
|
|
{
|
|
char buf[MB_MAXBYTES * 3 + 4];
|
|
unsigned len = special_to_buf(c, modifiers, true, buf);
|
|
assert(len < sizeof(buf));
|
|
buf[len] = NUL;
|
|
ins_typebuf(buf, KeyNoremap, 0, !KeyTyped, cmd_silent);
|
|
if (KeyTyped && no_on_key) {
|
|
no_on_key_len += len;
|
|
}
|
|
return (int)len;
|
|
}
|
|
|
|
/// Return true if the typeahead buffer was changed (while waiting for a
|
|
/// character to arrive). Happens when a message was received from a client or
|
|
/// from feedkeys().
|
|
/// But check in a more generic way to avoid trouble: When "typebuf.tb_buf"
|
|
/// changed it was reallocated and the old pointer can no longer be used.
|
|
/// Or "typebuf.tb_off" may have been changed and we would overwrite characters
|
|
/// that was just added.
|
|
///
|
|
/// @param tb_change_cnt old value of typebuf.tb_change_cnt
|
|
bool typebuf_changed(int tb_change_cnt)
|
|
FUNC_ATTR_PURE
|
|
{
|
|
return tb_change_cnt != 0 && (typebuf.tb_change_cnt != tb_change_cnt
|
|
|| typebuf_was_filled);
|
|
}
|
|
|
|
/// Return true if there are no characters in the typeahead buffer that have
|
|
/// not been typed (result from a mapping or come from ":normal").
|
|
int typebuf_typed(void)
|
|
FUNC_ATTR_PURE
|
|
{
|
|
return typebuf.tb_maplen == 0;
|
|
}
|
|
|
|
/// Get the number of characters that are mapped (or not typed).
|
|
int typebuf_maplen(void)
|
|
FUNC_ATTR_PURE
|
|
{
|
|
return typebuf.tb_maplen;
|
|
}
|
|
|
|
/// Remove "len" characters from typebuf.tb_buf[typebuf.tb_off + offset]
|
|
void del_typebuf(int len, int offset)
|
|
{
|
|
if (len == 0) {
|
|
return; // nothing to do
|
|
}
|
|
|
|
typebuf.tb_len -= len;
|
|
|
|
// Easy case: Just increase typebuf.tb_off.
|
|
if (offset == 0 && typebuf.tb_buflen - (typebuf.tb_off + len)
|
|
>= 3 * MAXMAPLEN + 3) {
|
|
typebuf.tb_off += len;
|
|
} else {
|
|
// Have to move the characters in typebuf.tb_buf[] and typebuf.tb_noremap[]
|
|
int i = typebuf.tb_off + offset;
|
|
// Leave some extra room at the end to avoid reallocation.
|
|
if (typebuf.tb_off > MAXMAPLEN) {
|
|
memmove(typebuf.tb_buf + MAXMAPLEN,
|
|
typebuf.tb_buf + typebuf.tb_off, (size_t)offset);
|
|
memmove(typebuf.tb_noremap + MAXMAPLEN,
|
|
typebuf.tb_noremap + typebuf.tb_off, (size_t)offset);
|
|
typebuf.tb_off = MAXMAPLEN;
|
|
}
|
|
// adjust typebuf.tb_buf (include the NUL at the end)
|
|
int bytes = typebuf.tb_len - offset + 1;
|
|
assert(bytes > 0);
|
|
memmove(typebuf.tb_buf + typebuf.tb_off + offset,
|
|
typebuf.tb_buf + i + len, (size_t)bytes);
|
|
// adjust typebuf.tb_noremap[]
|
|
memmove(typebuf.tb_noremap + typebuf.tb_off + offset,
|
|
typebuf.tb_noremap + i + len,
|
|
(size_t)(typebuf.tb_len - offset));
|
|
}
|
|
|
|
if (typebuf.tb_maplen > offset) { // adjust tb_maplen
|
|
if (typebuf.tb_maplen < offset + len) {
|
|
typebuf.tb_maplen = offset;
|
|
} else {
|
|
typebuf.tb_maplen -= len;
|
|
}
|
|
}
|
|
if (typebuf.tb_silent > offset) { // adjust tb_silent
|
|
if (typebuf.tb_silent < offset + len) {
|
|
typebuf.tb_silent = offset;
|
|
} else {
|
|
typebuf.tb_silent -= len;
|
|
}
|
|
}
|
|
if (typebuf.tb_no_abbr_cnt > offset) { // adjust tb_no_abbr_cnt
|
|
if (typebuf.tb_no_abbr_cnt < offset + len) {
|
|
typebuf.tb_no_abbr_cnt = offset;
|
|
} else {
|
|
typebuf.tb_no_abbr_cnt -= len;
|
|
}
|
|
}
|
|
|
|
// Reset the flag that text received from a client or from feedkeys()
|
|
// was inserted in the typeahead buffer.
|
|
typebuf_was_filled = false;
|
|
if (++typebuf.tb_change_cnt == 0) {
|
|
typebuf.tb_change_cnt = 1;
|
|
}
|
|
}
|
|
|
|
/// Add a single byte to a recording or 'showcmd'.
|
|
/// Return true if a full key has been received, false otherwise.
|
|
static bool gotchars_add_byte(gotchars_state_T *state, uint8_t byte)
|
|
FUNC_ATTR_NONNULL_ALL
|
|
{
|
|
int c = state->buf[state->buflen++] = byte;
|
|
bool retval = false;
|
|
const bool in_special = state->pending_special > 0;
|
|
const bool in_mbyte = state->pending_mbyte > 0;
|
|
|
|
if (in_special) {
|
|
state->pending_special--;
|
|
} else if (c == K_SPECIAL) {
|
|
// When receiving a special key sequence, store it until we have all
|
|
// the bytes and we can decide what to do with it.
|
|
state->pending_special = 2;
|
|
}
|
|
|
|
if (state->pending_special > 0) {
|
|
goto ret_false;
|
|
}
|
|
|
|
if (in_mbyte) {
|
|
state->pending_mbyte--;
|
|
} else {
|
|
if (in_special) {
|
|
if (state->prev_c == KS_MODIFIER) {
|
|
// When receiving a modifier, wait for the modified key.
|
|
goto ret_false;
|
|
}
|
|
c = TO_SPECIAL(state->prev_c, c);
|
|
}
|
|
// When receiving a multibyte character, store it until we have all
|
|
// the bytes, so that it won't be split between two buffer blocks,
|
|
// and delete_buff_tail() will work properly.
|
|
state->pending_mbyte = MB_BYTE2LEN_CHECK(c) - 1;
|
|
}
|
|
|
|
if (state->pending_mbyte > 0) {
|
|
goto ret_false;
|
|
}
|
|
|
|
retval = true;
|
|
ret_false:
|
|
state->prev_c = c;
|
|
return retval;
|
|
}
|
|
|
|
/// Write typed characters to script file.
|
|
/// If recording is on put the character in the record buffer.
|
|
static void gotchars(const uint8_t *chars, size_t len)
|
|
FUNC_ATTR_NONNULL_ALL
|
|
{
|
|
const uint8_t *s = chars;
|
|
size_t todo = len;
|
|
static gotchars_state_T state;
|
|
|
|
while (todo-- > 0) {
|
|
if (!gotchars_add_byte(&state, *s++)) {
|
|
continue;
|
|
}
|
|
|
|
// Handle one byte at a time; no translation to be done.
|
|
for (size_t i = 0; i < state.buflen; i++) {
|
|
updatescript(state.buf[i]);
|
|
}
|
|
|
|
state.buf[state.buflen] = NUL;
|
|
|
|
if (reg_recording != 0) {
|
|
add_buff(&recordbuff, (char *)state.buf, (ptrdiff_t)state.buflen);
|
|
// remember how many chars were last recorded
|
|
last_recorded_len += state.buflen;
|
|
}
|
|
|
|
if (state.buflen > no_on_key_len) {
|
|
vim_unescape_ks((char *)state.buf + no_on_key_len);
|
|
kvi_concat(on_key_buf, (char *)state.buf + no_on_key_len);
|
|
no_on_key_len = 0;
|
|
} else {
|
|
no_on_key_len -= state.buflen;
|
|
}
|
|
|
|
state.buflen = 0;
|
|
}
|
|
|
|
may_sync_undo();
|
|
|
|
// output "debug mode" message next time in debug mode
|
|
debug_did_msg = false;
|
|
|
|
// Since characters have been typed, consider the following to be in
|
|
// another mapping. Search string will be kept in history.
|
|
maptick++;
|
|
}
|
|
|
|
/// Record an <Ignore> key.
|
|
void gotchars_ignore(void)
|
|
{
|
|
uint8_t nop_buf[3] = { K_SPECIAL, KS_EXTRA, KE_IGNORE };
|
|
no_on_key_len += 3;
|
|
gotchars(nop_buf, 3);
|
|
}
|
|
|
|
/// Undo the last gotchars() for "len" bytes. To be used when putting a typed
|
|
/// character back into the typeahead buffer, thus gotchars() will be called
|
|
/// again.
|
|
/// Only affects recorded characters.
|
|
void ungetchars(int len)
|
|
{
|
|
if (reg_recording == 0) {
|
|
return;
|
|
}
|
|
|
|
delete_buff_tail(&recordbuff, len);
|
|
last_recorded_len -= (size_t)len;
|
|
}
|
|
|
|
/// Sync undo. Called when typed characters are obtained from the typeahead
|
|
/// buffer, or when a menu is used.
|
|
/// Do not sync:
|
|
/// - In Insert mode, unless cursor key has been used.
|
|
/// - While reading a script file.
|
|
/// - When no_u_sync is non-zero.
|
|
void may_sync_undo(void)
|
|
{
|
|
if ((!(State & (MODE_INSERT | MODE_CMDLINE)) || arrow_used)
|
|
&& curscript < 0) {
|
|
u_sync(false);
|
|
}
|
|
}
|
|
|
|
/// Make "typebuf" empty and allocate new buffers.
|
|
void alloc_typebuf(void)
|
|
{
|
|
typebuf.tb_buf = xmalloc(TYPELEN_INIT);
|
|
typebuf.tb_noremap = xmalloc(TYPELEN_INIT);
|
|
typebuf.tb_buflen = TYPELEN_INIT;
|
|
typebuf.tb_off = MAXMAPLEN + 4; // can insert without realloc
|
|
typebuf.tb_len = 0;
|
|
typebuf.tb_maplen = 0;
|
|
typebuf.tb_silent = 0;
|
|
typebuf.tb_no_abbr_cnt = 0;
|
|
if (++typebuf.tb_change_cnt == 0) {
|
|
typebuf.tb_change_cnt = 1;
|
|
}
|
|
}
|
|
|
|
/// Free the buffers of "typebuf".
|
|
void free_typebuf(void)
|
|
{
|
|
if (typebuf.tb_buf == typebuf_init) {
|
|
internal_error("Free typebuf 1");
|
|
} else {
|
|
XFREE_CLEAR(typebuf.tb_buf);
|
|
}
|
|
if (typebuf.tb_noremap == noremapbuf_init) {
|
|
internal_error("Free typebuf 2");
|
|
} else {
|
|
XFREE_CLEAR(typebuf.tb_noremap);
|
|
}
|
|
}
|
|
|
|
/// When doing ":so! file", the current typeahead needs to be saved, and
|
|
/// restored when "file" has been read completely.
|
|
static typebuf_T saved_typebuf[NSCRIPT];
|
|
|
|
static void save_typebuf(void)
|
|
{
|
|
assert(curscript >= 0);
|
|
init_typebuf();
|
|
saved_typebuf[curscript] = typebuf;
|
|
alloc_typebuf();
|
|
}
|
|
|
|
static int old_char = -1; ///< character put back by vungetc()
|
|
static int old_mod_mask; ///< mod_mask for ungotten character
|
|
static int old_mouse_grid; ///< mouse_grid related to old_char
|
|
static int old_mouse_row; ///< mouse_row related to old_char
|
|
static int old_mouse_col; ///< mouse_col related to old_char
|
|
static int old_KeyStuffed; ///< whether old_char was stuffed
|
|
|
|
static bool can_get_old_char(void)
|
|
{
|
|
// If the old character was not stuffed and characters have been added to
|
|
// the stuff buffer, need to first get the stuffed characters instead.
|
|
return old_char != -1 && (old_KeyStuffed || stuff_empty());
|
|
}
|
|
|
|
/// Save all three kinds of typeahead, so that the user must type at a prompt.
|
|
void save_typeahead(tasave_T *tp)
|
|
{
|
|
tp->save_typebuf = typebuf;
|
|
alloc_typebuf();
|
|
tp->typebuf_valid = true;
|
|
tp->old_char = old_char;
|
|
tp->old_mod_mask = old_mod_mask;
|
|
old_char = -1;
|
|
|
|
tp->save_readbuf1 = readbuf1;
|
|
readbuf1.bh_first.b_next = NULL;
|
|
tp->save_readbuf2 = readbuf2;
|
|
readbuf2.bh_first.b_next = NULL;
|
|
}
|
|
|
|
/// Restore the typeahead to what it was before calling save_typeahead().
|
|
/// The allocated memory is freed, can only be called once!
|
|
void restore_typeahead(tasave_T *tp)
|
|
{
|
|
if (tp->typebuf_valid) {
|
|
free_typebuf();
|
|
typebuf = tp->save_typebuf;
|
|
}
|
|
|
|
old_char = tp->old_char;
|
|
old_mod_mask = tp->old_mod_mask;
|
|
|
|
free_buff(&readbuf1);
|
|
readbuf1 = tp->save_readbuf1;
|
|
free_buff(&readbuf2);
|
|
readbuf2 = tp->save_readbuf2;
|
|
}
|
|
|
|
/// Open a new script file for the ":source!" command.
|
|
///
|
|
/// @param directly when true execute directly
|
|
void openscript(char *name, bool directly)
|
|
{
|
|
if (curscript + 1 == NSCRIPT) {
|
|
emsg(_(e_nesting));
|
|
return;
|
|
}
|
|
|
|
// Disallow sourcing a file in the sandbox, the commands would be executed
|
|
// later, possibly outside of the sandbox.
|
|
if (check_secure()) {
|
|
return;
|
|
}
|
|
|
|
if (ignore_script) {
|
|
// Not reading from script, also don't open one. Warning message?
|
|
return;
|
|
}
|
|
|
|
curscript++;
|
|
// use NameBuff for expanded name
|
|
expand_env(name, NameBuff, MAXPATHL);
|
|
int error = file_open(&scriptin[curscript], NameBuff, kFileReadOnly, 0);
|
|
if (error) {
|
|
semsg(_(e_notopen_2), name, os_strerror(error));
|
|
curscript--;
|
|
return;
|
|
}
|
|
save_typebuf();
|
|
|
|
// Execute the commands from the file right now when using ":source!"
|
|
// after ":global" or ":argdo" or in a loop. Also when another command
|
|
// follows. This means the display won't be updated. Don't do this
|
|
// always, "make test" would fail.
|
|
if (directly) {
|
|
oparg_T oa;
|
|
int save_State = State;
|
|
int save_restart_edit = restart_edit;
|
|
int save_finish_op = finish_op;
|
|
int save_msg_scroll = msg_scroll;
|
|
|
|
State = MODE_NORMAL;
|
|
msg_scroll = false; // no msg scrolling in Normal mode
|
|
restart_edit = 0; // don't go to Insert mode
|
|
clear_oparg(&oa);
|
|
finish_op = false;
|
|
|
|
int oldcurscript = curscript;
|
|
do {
|
|
update_topline_cursor(); // update cursor position and topline
|
|
normal_cmd(&oa, false); // execute one command
|
|
vpeekc(); // check for end of file
|
|
} while (curscript >= oldcurscript);
|
|
|
|
State = save_State;
|
|
msg_scroll = save_msg_scroll;
|
|
restart_edit = save_restart_edit;
|
|
finish_op = save_finish_op;
|
|
}
|
|
}
|
|
|
|
/// Close the currently active input script.
|
|
static void closescript(void)
|
|
{
|
|
assert(curscript >= 0);
|
|
free_typebuf();
|
|
typebuf = saved_typebuf[curscript];
|
|
|
|
file_close(&scriptin[curscript], false);
|
|
curscript--;
|
|
}
|
|
|
|
#if defined(EXITFREE)
|
|
void close_all_scripts(void)
|
|
{
|
|
while (curscript >= 0) {
|
|
closescript();
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
bool open_scriptin(char *scriptin_name)
|
|
FUNC_ATTR_NONNULL_ALL
|
|
{
|
|
assert(curscript == -1);
|
|
curscript++;
|
|
|
|
int error;
|
|
if (strequal(scriptin_name, "-")) {
|
|
error = file_open_stdin(&scriptin[0]);
|
|
} else {
|
|
error = file_open(&scriptin[0], scriptin_name,
|
|
kFileReadOnly|kFileNonBlocking, 0);
|
|
}
|
|
if (error) {
|
|
fprintf(stderr, _("Cannot open for reading: \"%s\": %s\n"),
|
|
scriptin_name, os_strerror(error));
|
|
curscript--;
|
|
return false;
|
|
}
|
|
save_typebuf();
|
|
|
|
return true;
|
|
}
|
|
|
|
/// Return true when reading keys from a script file.
|
|
int using_script(void)
|
|
FUNC_ATTR_PURE
|
|
{
|
|
return curscript >= 0;
|
|
}
|
|
|
|
/// This function is called just before doing a blocking wait. Thus after
|
|
/// waiting 'updatetime' for a character to arrive.
|
|
void before_blocking(void)
|
|
{
|
|
updatescript(0);
|
|
if (may_garbage_collect) {
|
|
garbage_collect(false);
|
|
}
|
|
}
|
|
|
|
/// updatescript() is called when a character can be written to the script
|
|
/// file or when we have waited some time for a character (c == 0).
|
|
///
|
|
/// All the changed memfiles are synced if c == 0 or when the number of typed
|
|
/// characters reaches 'updatecount' and 'updatecount' is non-zero.
|
|
static void updatescript(int c)
|
|
{
|
|
static int count = 0;
|
|
|
|
if (c && scriptout) {
|
|
putc(c, scriptout);
|
|
}
|
|
bool idle = (c == 0);
|
|
if (idle || (p_uc > 0 && ++count >= p_uc)) {
|
|
ml_sync_all(idle, true,
|
|
(!!p_fs || idle)); // Always fsync at idle (CursorHold).
|
|
count = 0;
|
|
}
|
|
}
|
|
|
|
/// Merge "modifiers" into "c_arg".
|
|
int merge_modifiers(int c_arg, int *modifiers)
|
|
{
|
|
int c = c_arg;
|
|
|
|
if (*modifiers & MOD_MASK_CTRL) {
|
|
if ((c >= '`' && c <= 0x7f) || (c >= '@' && c <= '_')) {
|
|
c &= 0x1f;
|
|
if (c == NUL) {
|
|
c = K_ZERO;
|
|
}
|
|
} else if (c == '6') {
|
|
// CTRL-6 is equivalent to CTRL-^
|
|
c = 0x1e;
|
|
}
|
|
if (c != c_arg) {
|
|
*modifiers &= ~MOD_MASK_CTRL;
|
|
}
|
|
}
|
|
return c;
|
|
}
|
|
|
|
/// Add a single byte to 'showcmd' for a partially matched mapping.
|
|
/// Call add_to_showcmd() if a full key has been received.
|
|
static void add_byte_to_showcmd(uint8_t byte)
|
|
{
|
|
static gotchars_state_T state;
|
|
|
|
if (!p_sc || msg_silent != 0) {
|
|
return;
|
|
}
|
|
|
|
if (!gotchars_add_byte(&state, byte)) {
|
|
return;
|
|
}
|
|
|
|
state.buf[state.buflen] = NUL;
|
|
state.buflen = 0;
|
|
|
|
int modifiers = 0;
|
|
int c = NUL;
|
|
|
|
const uint8_t *ptr = state.buf;
|
|
if (ptr[0] == K_SPECIAL && ptr[1] == KS_MODIFIER && ptr[2] != NUL) {
|
|
modifiers = ptr[2];
|
|
ptr += 3;
|
|
}
|
|
|
|
if (*ptr != NUL) {
|
|
const char *mb_ptr = mb_unescape((const char **)&ptr);
|
|
c = mb_ptr != NULL ? utf_ptr2char(mb_ptr) : *ptr++;
|
|
if (c <= 0x7f) {
|
|
// Merge modifiers into the key to make the result more readable.
|
|
int modifiers_after = modifiers;
|
|
int mod_c = merge_modifiers(c, &modifiers_after);
|
|
if (modifiers_after == 0) {
|
|
modifiers = 0;
|
|
c = mod_c;
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO(zeertzjq): is there a more readable and yet compact representation of
|
|
// modifiers and special keys?
|
|
if (modifiers != 0) {
|
|
add_to_showcmd(K_SPECIAL);
|
|
add_to_showcmd(KS_MODIFIER);
|
|
add_to_showcmd(modifiers);
|
|
}
|
|
if (c != NUL) {
|
|
add_to_showcmd(c);
|
|
}
|
|
while (*ptr != NUL) {
|
|
add_to_showcmd(*ptr++);
|
|
}
|
|
}
|
|
|
|
/// Get the next input character.
|
|
/// Can return a special key or a multi-byte character.
|
|
/// Can return NUL when called recursively, use safe_vgetc() if that's not
|
|
/// wanted.
|
|
/// This translates escaped K_SPECIAL bytes to a K_SPECIAL byte.
|
|
/// Collects the bytes of a multibyte character into the whole character.
|
|
/// Returns the modifiers in the global "mod_mask".
|
|
int vgetc(void)
|
|
{
|
|
int c;
|
|
uint8_t buf[MB_MAXBYTES + 1];
|
|
|
|
// Do garbage collection when garbagecollect() was called previously and
|
|
// we are now at the toplevel.
|
|
if (may_garbage_collect && want_garbage_collect) {
|
|
garbage_collect(false);
|
|
}
|
|
|
|
// If a character was put back with vungetc, it was already processed.
|
|
// Return it directly.
|
|
if (can_get_old_char()) {
|
|
c = old_char;
|
|
old_char = -1;
|
|
mod_mask = old_mod_mask;
|
|
mouse_grid = old_mouse_grid;
|
|
mouse_row = old_mouse_row;
|
|
mouse_col = old_mouse_col;
|
|
} else {
|
|
// number of characters recorded from the last vgetc() call
|
|
static size_t last_vgetc_recorded_len = 0;
|
|
|
|
mod_mask = 0;
|
|
vgetc_mod_mask = 0;
|
|
vgetc_char = 0;
|
|
|
|
// last_recorded_len can be larger than last_vgetc_recorded_len
|
|
// if peeking records more
|
|
last_recorded_len -= last_vgetc_recorded_len;
|
|
|
|
while (true) { // this is done twice if there are modifiers
|
|
bool did_inc = false;
|
|
if (mod_mask) { // no mapping after modifier has been read
|
|
no_mapping++;
|
|
allow_keys++;
|
|
did_inc = true; // mod_mask may change value
|
|
}
|
|
c = vgetorpeek(true);
|
|
if (did_inc) {
|
|
no_mapping--;
|
|
allow_keys--;
|
|
}
|
|
|
|
// Get two extra bytes for special keys
|
|
if (c == K_SPECIAL) {
|
|
int save_allow_keys = allow_keys;
|
|
no_mapping++;
|
|
allow_keys = 0; // make sure BS is not found
|
|
int c2 = vgetorpeek(true); // no mapping for these chars
|
|
c = vgetorpeek(true);
|
|
no_mapping--;
|
|
allow_keys = save_allow_keys;
|
|
if (c2 == KS_MODIFIER) {
|
|
mod_mask = c;
|
|
continue;
|
|
}
|
|
c = TO_SPECIAL(c2, c);
|
|
}
|
|
|
|
// a keypad or special function key was not mapped, use it like
|
|
// its ASCII equivalent
|
|
switch (c) {
|
|
case K_KPLUS:
|
|
c = '+'; break;
|
|
case K_KMINUS:
|
|
c = '-'; break;
|
|
case K_KDIVIDE:
|
|
c = '/'; break;
|
|
case K_KMULTIPLY:
|
|
c = '*'; break;
|
|
case K_KENTER:
|
|
c = CAR; break;
|
|
case K_KPOINT:
|
|
c = '.'; break;
|
|
case K_KCOMMA:
|
|
c = ','; break;
|
|
case K_KEQUAL:
|
|
c = '='; break;
|
|
case K_K0:
|
|
c = '0'; break;
|
|
case K_K1:
|
|
c = '1'; break;
|
|
case K_K2:
|
|
c = '2'; break;
|
|
case K_K3:
|
|
c = '3'; break;
|
|
case K_K4:
|
|
c = '4'; break;
|
|
case K_K5:
|
|
c = '5'; break;
|
|
case K_K6:
|
|
c = '6'; break;
|
|
case K_K7:
|
|
c = '7'; break;
|
|
case K_K8:
|
|
c = '8'; break;
|
|
case K_K9:
|
|
c = '9'; break;
|
|
|
|
case K_XHOME:
|
|
case K_ZHOME:
|
|
if (mod_mask == MOD_MASK_SHIFT) {
|
|
c = K_S_HOME;
|
|
mod_mask = 0;
|
|
} else if (mod_mask == MOD_MASK_CTRL) {
|
|
c = K_C_HOME;
|
|
mod_mask = 0;
|
|
} else {
|
|
c = K_HOME;
|
|
}
|
|
break;
|
|
case K_XEND:
|
|
case K_ZEND:
|
|
if (mod_mask == MOD_MASK_SHIFT) {
|
|
c = K_S_END;
|
|
mod_mask = 0;
|
|
} else if (mod_mask == MOD_MASK_CTRL) {
|
|
c = K_C_END;
|
|
mod_mask = 0;
|
|
} else {
|
|
c = K_END;
|
|
}
|
|
break;
|
|
|
|
case K_KUP:
|
|
case K_XUP:
|
|
c = K_UP; break;
|
|
case K_KDOWN:
|
|
case K_XDOWN:
|
|
c = K_DOWN; break;
|
|
case K_KLEFT:
|
|
case K_XLEFT:
|
|
c = K_LEFT; break;
|
|
case K_KRIGHT:
|
|
case K_XRIGHT:
|
|
c = K_RIGHT; break;
|
|
}
|
|
|
|
// For a multi-byte character get all the bytes and return the
|
|
// converted character.
|
|
// Note: This will loop until enough bytes are received!
|
|
int n;
|
|
if ((n = MB_BYTE2LEN_CHECK(c)) > 1) {
|
|
no_mapping++;
|
|
buf[0] = (uint8_t)c;
|
|
for (int i = 1; i < n; i++) {
|
|
buf[i] = (uint8_t)vgetorpeek(true);
|
|
if (buf[i] == K_SPECIAL) {
|
|
// Must be a K_SPECIAL - KS_SPECIAL - KE_FILLER sequence,
|
|
// which represents a K_SPECIAL (0x80).
|
|
vgetorpeek(true); // skip KS_SPECIAL
|
|
vgetorpeek(true); // skip KE_FILLER
|
|
}
|
|
}
|
|
no_mapping--;
|
|
c = utf_ptr2char((char *)buf);
|
|
}
|
|
|
|
if (vgetc_char == 0) {
|
|
vgetc_mod_mask = mod_mask;
|
|
vgetc_char = c;
|
|
}
|
|
|
|
// If mappings are enabled (i.e., not i_CTRL-V) and the user directly typed something with
|
|
// MOD_MASK_ALT (<M-/<A- modifier) that was not mapped, interpret <M-x> as <Esc>x rather
|
|
// than as an unbound <M-x> keypress. #8213
|
|
// In Terminal mode, however, this is not desirable. #16202 #16220
|
|
// Also do not do this for mouse keys, as terminals encode mouse events as CSI sequences, and
|
|
// MOD_MASK_ALT has a meaning even for unmapped mouse keys.
|
|
if (!no_mapping && KeyTyped && mod_mask == MOD_MASK_ALT && !(State & MODE_TERMINAL)
|
|
&& !is_mouse_key(c)) {
|
|
mod_mask = 0;
|
|
int len = ins_char_typebuf(c, 0, false);
|
|
ins_char_typebuf(ESC, 0, false);
|
|
int old_len = len + 3; // K_SPECIAL KS_MODIFIER MOD_MASK_ALT takes 3 more bytes
|
|
ungetchars(old_len);
|
|
if (on_key_buf.size >= (size_t)old_len) {
|
|
on_key_buf.size -= (size_t)old_len;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
last_vgetc_recorded_len = last_recorded_len;
|
|
}
|
|
|
|
// In the main loop "may_garbage_collect" can be set to do garbage
|
|
// collection in the first next vgetc(). It's disabled after that to
|
|
// avoid internally used Lists and Dicts to be freed.
|
|
may_garbage_collect = false;
|
|
|
|
// Execute Lua on_key callbacks.
|
|
nlua_execute_on_key(c, on_key_buf.items, on_key_buf.size);
|
|
kvi_destroy(on_key_buf);
|
|
kvi_init(on_key_buf);
|
|
|
|
// Need to process the character before we know it's safe to do something
|
|
// else.
|
|
if (c != K_IGNORE) {
|
|
state_no_longer_safe("key typed");
|
|
}
|
|
|
|
return c;
|
|
}
|
|
|
|
/// Like vgetc(), but never return a NUL when called recursively, get a key
|
|
/// directly from the user (ignoring typeahead).
|
|
int safe_vgetc(void)
|
|
{
|
|
int c = vgetc();
|
|
if (c == NUL) {
|
|
c = get_keystroke(NULL);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
/// Like safe_vgetc(), but loop to handle K_IGNORE.
|
|
/// Also ignore scrollbar events.
|
|
int plain_vgetc(void)
|
|
{
|
|
int c;
|
|
|
|
do {
|
|
c = safe_vgetc();
|
|
} while (c == K_IGNORE
|
|
|| c == K_VER_SCROLLBAR || c == K_HOR_SCROLLBAR
|
|
|| c == K_MOUSEMOVE);
|
|
return c;
|
|
}
|
|
|
|
/// Check if a character is available, such that vgetc() will not block.
|
|
/// If the next character is a special character or multi-byte, the returned
|
|
/// character is not valid!.
|
|
/// Returns NUL if no character is available.
|
|
int vpeekc(void)
|
|
{
|
|
if (can_get_old_char()) {
|
|
return old_char;
|
|
}
|
|
return vgetorpeek(false);
|
|
}
|
|
|
|
/// Check if any character is available, also half an escape sequence.
|
|
/// Trick: when no typeahead found, but there is something in the typeahead
|
|
/// buffer, it must be an ESC that is recognized as the start of a key code.
|
|
int vpeekc_any(void)
|
|
{
|
|
int c = vpeekc();
|
|
if (c == NUL && typebuf.tb_len > 0) {
|
|
c = ESC;
|
|
}
|
|
return c;
|
|
}
|
|
|
|
/// Call vpeekc() without causing anything to be mapped.
|
|
/// @return true if a character is available, false otherwise.
|
|
bool char_avail(void)
|
|
{
|
|
no_mapping++;
|
|
int retval = vpeekc();
|
|
no_mapping--;
|
|
return retval != NUL;
|
|
}
|
|
|
|
/// "getchar()" and "getcharstr()" functions
|
|
static void getchar_common(typval_T *argvars, typval_T *rettv)
|
|
FUNC_ATTR_NONNULL_ALL
|
|
{
|
|
varnumber_T n;
|
|
bool error = false;
|
|
|
|
no_mapping++;
|
|
allow_keys++;
|
|
while (true) {
|
|
if (msg_col > 0) {
|
|
// Position the cursor. Needed after a message that ends in a space.
|
|
ui_cursor_goto(msg_row, msg_col);
|
|
}
|
|
|
|
if (argvars[0].v_type == VAR_UNKNOWN) {
|
|
// getchar(): blocking wait.
|
|
// TODO(bfredl): deduplicate shared logic with state_enter ?
|
|
if (!char_avail()) {
|
|
// Flush screen updates before blocking.
|
|
ui_flush();
|
|
os_inchar(NULL, 0, -1, typebuf.tb_change_cnt, main_loop.events);
|
|
if (!multiqueue_empty(main_loop.events)) {
|
|
state_handle_k_event();
|
|
continue;
|
|
}
|
|
}
|
|
n = safe_vgetc();
|
|
} else if (tv_get_number_chk(&argvars[0], &error) == 1) {
|
|
// getchar(1): only check if char avail
|
|
n = vpeekc_any();
|
|
} else if (error || vpeekc_any() == NUL) {
|
|
// illegal argument or getchar(0) and no char avail: return zero
|
|
n = 0;
|
|
} else {
|
|
// getchar(0) and char avail() != NUL: get a character.
|
|
// Note that vpeekc_any() returns K_SPECIAL for K_IGNORE.
|
|
n = safe_vgetc();
|
|
}
|
|
|
|
if (n == K_IGNORE
|
|
|| n == K_MOUSEMOVE
|
|
|| n == K_VER_SCROLLBAR
|
|
|| n == K_HOR_SCROLLBAR) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
no_mapping--;
|
|
allow_keys--;
|
|
|
|
set_vim_var_nr(VV_MOUSE_WIN, 0);
|
|
set_vim_var_nr(VV_MOUSE_WINID, 0);
|
|
set_vim_var_nr(VV_MOUSE_LNUM, 0);
|
|
set_vim_var_nr(VV_MOUSE_COL, 0);
|
|
|
|
rettv->vval.v_number = n;
|
|
if (n != 0 && (IS_SPECIAL(n) || mod_mask != 0)) {
|
|
char temp[10]; // modifier: 3, mbyte-char: 6, NUL: 1
|
|
int i = 0;
|
|
|
|
// Turn a special key into three bytes, plus modifier.
|
|
if (mod_mask != 0) {
|
|
temp[i++] = (char)K_SPECIAL;
|
|
temp[i++] = (char)KS_MODIFIER;
|
|
temp[i++] = (char)mod_mask;
|
|
}
|
|
if (IS_SPECIAL(n)) {
|
|
temp[i++] = (char)K_SPECIAL;
|
|
temp[i++] = (char)K_SECOND(n);
|
|
temp[i++] = (char)K_THIRD(n);
|
|
} else {
|
|
i += utf_char2bytes((int)n, temp + i);
|
|
}
|
|
assert(i < 10);
|
|
temp[i++] = NUL;
|
|
rettv->v_type = VAR_STRING;
|
|
rettv->vval.v_string = xstrdup(temp);
|
|
|
|
if (is_mouse_key((int)n)) {
|
|
int row = mouse_row;
|
|
int col = mouse_col;
|
|
int grid = mouse_grid;
|
|
linenr_T lnum;
|
|
win_T *wp;
|
|
|
|
if (row >= 0 && col >= 0) {
|
|
int winnr = 1;
|
|
// Find the window at the mouse coordinates and compute the
|
|
// text position.
|
|
win_T *const win = mouse_find_win(&grid, &row, &col);
|
|
if (win == NULL) {
|
|
return;
|
|
}
|
|
mouse_comp_pos(win, &row, &col, &lnum);
|
|
for (wp = firstwin; wp != win; wp = wp->w_next) {
|
|
winnr++;
|
|
}
|
|
set_vim_var_nr(VV_MOUSE_WIN, winnr);
|
|
set_vim_var_nr(VV_MOUSE_WINID, wp->handle);
|
|
set_vim_var_nr(VV_MOUSE_LNUM, lnum);
|
|
set_vim_var_nr(VV_MOUSE_COL, col + 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// "getchar()" function
|
|
void f_getchar(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
|
|
{
|
|
getchar_common(argvars, rettv);
|
|
}
|
|
|
|
/// "getcharstr()" function
|
|
void f_getcharstr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
|
|
{
|
|
getchar_common(argvars, rettv);
|
|
|
|
if (rettv->v_type != VAR_NUMBER) {
|
|
return;
|
|
}
|
|
|
|
char temp[7]; // mbyte-char: 6, NUL: 1
|
|
const varnumber_T n = rettv->vval.v_number;
|
|
int i = 0;
|
|
|
|
if (n != 0) {
|
|
i += utf_char2bytes((int)n, temp);
|
|
}
|
|
assert(i < 7);
|
|
temp[i++] = NUL;
|
|
rettv->v_type = VAR_STRING;
|
|
rettv->vval.v_string = xstrdup(temp);
|
|
}
|
|
|
|
/// "getcharmod()" function
|
|
void f_getcharmod(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
|
|
{
|
|
rettv->vval.v_number = mod_mask;
|
|
}
|
|
|
|
typedef enum {
|
|
map_result_fail, // failed, break loop
|
|
map_result_get, // get a character from typeahead
|
|
map_result_retry, // try to map again
|
|
map_result_nomatch, // no matching mapping, get char
|
|
} map_result_T;
|
|
|
|
/// Put "string[new_slen]" in typebuf.
|
|
/// Remove "slen" bytes.
|
|
/// @return FAIL for error, OK otherwise.
|
|
static int put_string_in_typebuf(int offset, int slen, uint8_t *string, int new_slen)
|
|
{
|
|
int extra = new_slen - slen;
|
|
string[new_slen] = NUL;
|
|
if (extra < 0) {
|
|
// remove matched chars, taking care of noremap
|
|
del_typebuf(-extra, offset);
|
|
} else if (extra > 0) {
|
|
// insert the extra space we need
|
|
if (ins_typebuf((char *)string + slen, REMAP_YES, offset, false, false) == FAIL) {
|
|
return FAIL;
|
|
}
|
|
}
|
|
// Careful: del_typebuf() and ins_typebuf() may have reallocated
|
|
// typebuf.tb_buf[]!
|
|
memmove(typebuf.tb_buf + typebuf.tb_off + offset, string, (size_t)new_slen);
|
|
return OK;
|
|
}
|
|
|
|
/// Check if the bytes at the start of the typeahead buffer are a character used
|
|
/// in Insert mode completion. This includes the form with a CTRL modifier.
|
|
static bool at_ins_compl_key(void)
|
|
{
|
|
uint8_t *p = typebuf.tb_buf + typebuf.tb_off;
|
|
int c = *p;
|
|
|
|
if (typebuf.tb_len > 3 && c == K_SPECIAL && p[1] == KS_MODIFIER && (p[2] & MOD_MASK_CTRL)) {
|
|
c = p[3] & 0x1f;
|
|
}
|
|
return (ctrl_x_mode_not_default() && vim_is_ctrl_x_key(c))
|
|
|| (compl_status_local() && (c == Ctrl_N || c == Ctrl_P));
|
|
}
|
|
|
|
/// Check if typebuf.tb_buf[] contains a modifier plus key that can be changed
|
|
/// into just a key, apply that.
|
|
/// Check from typebuf.tb_buf[typebuf.tb_off] to typebuf.tb_buf[typebuf.tb_off + "max_offset"].
|
|
/// @return the length of the replaced bytes, 0 if nothing changed, -1 for error.
|
|
static int check_simplify_modifier(int max_offset)
|
|
{
|
|
for (int offset = 0; offset < max_offset; offset++) {
|
|
if (offset + 3 >= typebuf.tb_len) {
|
|
break;
|
|
}
|
|
uint8_t *tp = typebuf.tb_buf + typebuf.tb_off + offset;
|
|
if (tp[0] == K_SPECIAL && tp[1] == KS_MODIFIER) {
|
|
// A modifier was not used for a mapping, apply it to ASCII
|
|
// keys. Shift would already have been applied.
|
|
int modifier = tp[2];
|
|
int c = tp[3];
|
|
int new_c = merge_modifiers(c, &modifier);
|
|
|
|
if (new_c != c) {
|
|
if (offset == 0) {
|
|
// At the start: remember the character and mod_mask before
|
|
// merging, in some cases, e.g. at the hit-return prompt,
|
|
// they are put back in the typeahead buffer.
|
|
vgetc_char = c;
|
|
vgetc_mod_mask = tp[2];
|
|
}
|
|
uint8_t new_string[MB_MAXBYTES];
|
|
int len;
|
|
if (IS_SPECIAL(new_c)) {
|
|
new_string[0] = K_SPECIAL;
|
|
new_string[1] = (uint8_t)K_SECOND(new_c);
|
|
new_string[2] = (uint8_t)K_THIRD(new_c);
|
|
len = 3;
|
|
} else {
|
|
len = utf_char2bytes(new_c, (char *)new_string);
|
|
}
|
|
if (modifier == 0) {
|
|
if (put_string_in_typebuf(offset, 4, new_string, len) == FAIL) {
|
|
return -1;
|
|
}
|
|
} else {
|
|
tp[2] = (uint8_t)modifier;
|
|
if (put_string_in_typebuf(offset + 3, 1, new_string, len) == FAIL) {
|
|
return -1;
|
|
}
|
|
}
|
|
return len;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/// Handle mappings in the typeahead buffer.
|
|
/// - When something was mapped, return map_result_retry for recursive mappings.
|
|
/// - When nothing mapped and typeahead has a character: return map_result_get.
|
|
/// - When there is no match yet, return map_result_nomatch, need to get more
|
|
/// typeahead.
|
|
/// - On failure (out of memory) return map_result_fail.
|
|
static int handle_mapping(int *keylenp, const bool *timedout, int *mapdepth)
|
|
{
|
|
mapblock_T *mp = NULL;
|
|
mapblock_T *mp2;
|
|
mapblock_T *mp_match;
|
|
int mp_match_len = 0;
|
|
int max_mlen = 0;
|
|
int keylen = *keylenp;
|
|
int local_State = get_real_state();
|
|
bool is_plug_map = false;
|
|
|
|
// If typeahead starts with <Plug> then remap, even for a "noremap" mapping.
|
|
if (typebuf.tb_len >= 3
|
|
&& typebuf.tb_buf[typebuf.tb_off] == K_SPECIAL
|
|
&& typebuf.tb_buf[typebuf.tb_off + 1] == KS_EXTRA
|
|
&& typebuf.tb_buf[typebuf.tb_off + 2] == KE_PLUG) {
|
|
is_plug_map = true;
|
|
}
|
|
|
|
// Check for a mappable key sequence.
|
|
// Walk through one maphash[] list until we find an entry that matches.
|
|
//
|
|
// Don't look for mappings if:
|
|
// - no_mapping set: mapping disabled (e.g. for CTRL-V)
|
|
// - maphash_valid not set: no mappings present.
|
|
// - typebuf.tb_buf[typebuf.tb_off] should not be remapped
|
|
// - in insert or cmdline mode and 'paste' option set
|
|
// - waiting for "hit return to continue" and CR or SPACE typed
|
|
// - waiting for a char with --more--
|
|
// - in Ctrl-X mode, and we get a valid char for that mode
|
|
int tb_c1 = typebuf.tb_buf[typebuf.tb_off];
|
|
if (no_mapping == 0
|
|
&& (no_zero_mapping == 0 || tb_c1 != '0')
|
|
&& (typebuf.tb_maplen == 0 || is_plug_map
|
|
|| (!(typebuf.tb_noremap[typebuf.tb_off] & (RM_NONE|RM_ABBR))))
|
|
&& !(p_paste && (State & (MODE_INSERT | MODE_CMDLINE)))
|
|
&& !(State == MODE_HITRETURN && (tb_c1 == CAR || tb_c1 == ' '))
|
|
&& State != MODE_ASKMORE
|
|
&& State != MODE_CONFIRM
|
|
&& !at_ins_compl_key()) {
|
|
int mlen;
|
|
int nolmaplen;
|
|
if (tb_c1 == K_SPECIAL) {
|
|
nolmaplen = 2;
|
|
} else {
|
|
LANGMAP_ADJUST(tb_c1, ((State & (MODE_CMDLINE | MODE_INSERT)) == 0
|
|
&& get_real_state() != MODE_SELECT));
|
|
nolmaplen = 0;
|
|
}
|
|
// First try buffer-local mappings.
|
|
mp = get_buf_maphash_list(local_State, tb_c1);
|
|
mp2 = get_maphash_list(local_State, tb_c1);
|
|
if (mp == NULL) {
|
|
// There are no buffer-local mappings.
|
|
mp = mp2;
|
|
mp2 = NULL;
|
|
}
|
|
// Loop until a partly matching mapping is found or all (local)
|
|
// mappings have been checked.
|
|
// The longest full match is remembered in "mp_match".
|
|
// A full match is only accepted if there is no partly match, so "aa"
|
|
// and "aaa" can both be mapped.
|
|
mp_match = NULL;
|
|
mp_match_len = 0;
|
|
for (; mp != NULL; mp->m_next == NULL ? (mp = mp2, mp2 = NULL) : (mp = mp->m_next)) {
|
|
// Only consider an entry if the first character matches and it is
|
|
// for the current state.
|
|
// Skip ":lmap" mappings if keys were mapped.
|
|
if ((uint8_t)mp->m_keys[0] == tb_c1 && (mp->m_mode & local_State)
|
|
&& ((mp->m_mode & MODE_LANGMAP) == 0 || typebuf.tb_maplen == 0)) {
|
|
int nomap = nolmaplen;
|
|
int modifiers = 0;
|
|
// find the match length of this mapping
|
|
for (mlen = 1; mlen < typebuf.tb_len; mlen++) {
|
|
int c2 = typebuf.tb_buf[typebuf.tb_off + mlen];
|
|
if (nomap > 0) {
|
|
if (nomap == 2 && c2 == KS_MODIFIER) {
|
|
modifiers = 1;
|
|
} else if (nomap == 1 && modifiers == 1) {
|
|
modifiers = c2;
|
|
}
|
|
nomap--;
|
|
} else {
|
|
if (c2 == K_SPECIAL) {
|
|
nomap = 2;
|
|
} else if (merge_modifiers(c2, &modifiers) == c2) {
|
|
// Only apply 'langmap' if merging modifiers into
|
|
// the key will not result in another character,
|
|
// so that 'langmap' behaves consistently in
|
|
// different terminals and GUIs.
|
|
LANGMAP_ADJUST(c2, true);
|
|
}
|
|
modifiers = 0;
|
|
}
|
|
if ((uint8_t)mp->m_keys[mlen] != c2) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Don't allow mapping the first byte(s) of a multi-byte char.
|
|
// Happens when mapping <M-a> and then changing 'encoding'.
|
|
// Beware that 0x80 is escaped.
|
|
const char *p1 = mp->m_keys;
|
|
const char *p2 = mb_unescape(&p1);
|
|
|
|
if (p2 != NULL && MB_BYTE2LEN(tb_c1) > utfc_ptr2len(p2)) {
|
|
mlen = 0;
|
|
}
|
|
|
|
// Check an entry whether it matches.
|
|
// - Full match: mlen == keylen
|
|
// - Partly match: mlen == typebuf.tb_len
|
|
keylen = mp->m_keylen;
|
|
if (mlen == keylen || (mlen == typebuf.tb_len && typebuf.tb_len < keylen)) {
|
|
int n;
|
|
|
|
// If only script-local mappings are allowed, check if the
|
|
// mapping starts with K_SNR.
|
|
uint8_t *s = typebuf.tb_noremap + typebuf.tb_off;
|
|
if (*s == RM_SCRIPT
|
|
&& ((uint8_t)mp->m_keys[0] != K_SPECIAL
|
|
|| (uint8_t)mp->m_keys[1] != KS_EXTRA
|
|
|| mp->m_keys[2] != KE_SNR)) {
|
|
continue;
|
|
}
|
|
|
|
// If one of the typed keys cannot be remapped, skip the entry.
|
|
for (n = mlen; --n >= 0;) {
|
|
if (*s++ & (RM_NONE|RM_ABBR)) {
|
|
break;
|
|
}
|
|
}
|
|
if (!is_plug_map && n >= 0) {
|
|
continue;
|
|
}
|
|
|
|
if (keylen > typebuf.tb_len) {
|
|
if (!*timedout && !(mp_match != NULL && mp_match->m_nowait)) {
|
|
// break at a partly match
|
|
keylen = KEYLEN_PART_MAP;
|
|
break;
|
|
}
|
|
} else if (keylen > mp_match_len
|
|
|| (keylen == mp_match_len
|
|
&& mp_match != NULL
|
|
&& (mp_match->m_mode & MODE_LANGMAP) == 0
|
|
&& (mp->m_mode & MODE_LANGMAP) != 0)) {
|
|
// found a longer match
|
|
mp_match = mp;
|
|
mp_match_len = keylen;
|
|
}
|
|
} else {
|
|
// No match; may have to check for termcode at next character.
|
|
if (max_mlen < mlen) {
|
|
max_mlen = mlen;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If no partly match found, use the longest full match.
|
|
if (keylen != KEYLEN_PART_MAP && mp_match != NULL) {
|
|
mp = mp_match;
|
|
keylen = mp_match_len;
|
|
}
|
|
}
|
|
|
|
if ((mp == NULL || max_mlen > mp_match_len) && keylen != KEYLEN_PART_MAP) {
|
|
// When no matching mapping found or found a non-matching mapping that
|
|
// matches at least what the matching mapping matched:
|
|
// Try to include the modifier into the key when mapping is allowed.
|
|
if (no_mapping == 0 || allow_keys != 0) {
|
|
if (tb_c1 == K_SPECIAL
|
|
&& (typebuf.tb_len < 2
|
|
|| (typebuf.tb_buf[typebuf.tb_off + 1] == KS_MODIFIER && typebuf.tb_len < 4))) {
|
|
// Incomplete modifier sequence: cannot decide whether to simplify yet.
|
|
keylen = KEYLEN_PART_KEY;
|
|
} else {
|
|
// Try to include the modifier into the key.
|
|
keylen = check_simplify_modifier(max_mlen + 1);
|
|
if (keylen < 0) {
|
|
// ins_typebuf() failed
|
|
return map_result_fail;
|
|
}
|
|
}
|
|
} else {
|
|
keylen = 0;
|
|
}
|
|
if (keylen == 0) { // no simplification has been done
|
|
// If there was no mapping at all use the character from the
|
|
// typeahead buffer right here.
|
|
if (mp == NULL) {
|
|
*keylenp = keylen;
|
|
return map_result_get; // get character from typeahead
|
|
}
|
|
}
|
|
|
|
if (keylen > 0) { // keys have been simplified
|
|
*keylenp = keylen;
|
|
return map_result_retry; // try mapping again
|
|
}
|
|
|
|
if (keylen < 0) {
|
|
// Incomplete key sequence: get some more characters.
|
|
assert(keylen == KEYLEN_PART_KEY);
|
|
} else {
|
|
assert(mp != NULL);
|
|
// When a matching mapping was found use that one.
|
|
keylen = mp_match_len;
|
|
}
|
|
}
|
|
|
|
// complete match
|
|
if (keylen >= 0 && keylen <= typebuf.tb_len) {
|
|
int i;
|
|
char *map_str = NULL;
|
|
|
|
// Write chars to script file(s).
|
|
// Note: :lmap mappings are written *after* being applied. #5658
|
|
if (keylen > typebuf.tb_maplen && (mp->m_mode & MODE_LANGMAP) == 0) {
|
|
gotchars(typebuf.tb_buf + typebuf.tb_off + typebuf.tb_maplen,
|
|
(size_t)(keylen - typebuf.tb_maplen));
|
|
}
|
|
|
|
cmd_silent = (typebuf.tb_silent > 0);
|
|
del_typebuf(keylen, 0); // remove the mapped keys
|
|
|
|
// Put the replacement string in front of mapstr.
|
|
// The depth check catches ":map x y" and ":map y x".
|
|
if (++*mapdepth >= p_mmd) {
|
|
emsg(_(e_recursive_mapping));
|
|
if (State & MODE_CMDLINE) {
|
|
redrawcmdline();
|
|
} else {
|
|
setcursor();
|
|
}
|
|
flush_buffers(FLUSH_MINIMAL);
|
|
*mapdepth = 0; // for next one
|
|
*keylenp = keylen;
|
|
return map_result_fail;
|
|
}
|
|
|
|
// In Select mode and a Visual mode mapping is used: Switch to Visual
|
|
// mode temporarily. Append K_SELECT to switch back to Select mode.
|
|
if (VIsual_active && VIsual_select && (mp->m_mode & MODE_VISUAL)) {
|
|
VIsual_select = false;
|
|
ins_typebuf(K_SELECT_STRING, REMAP_NONE, 0, true, false);
|
|
}
|
|
|
|
// Copy the values from *mp that are used, because evaluating the
|
|
// expression may invoke a function that redefines the mapping, thereby
|
|
// making *mp invalid.
|
|
const bool save_m_expr = mp->m_expr;
|
|
const int save_m_noremap = mp->m_noremap;
|
|
const bool save_m_silent = mp->m_silent;
|
|
char *save_m_keys = NULL; // only saved when needed
|
|
char *save_m_str = NULL; // only saved when needed
|
|
const LuaRef save_m_luaref = mp->m_luaref;
|
|
|
|
// Handle ":map <expr>": evaluate the {rhs} as an
|
|
// expression. Also save and restore the command line
|
|
// for "normal :".
|
|
if (mp->m_expr) {
|
|
const int save_vgetc_busy = vgetc_busy;
|
|
const bool save_may_garbage_collect = may_garbage_collect;
|
|
const int prev_did_emsg = did_emsg;
|
|
|
|
vgetc_busy = 0;
|
|
may_garbage_collect = false;
|
|
|
|
save_m_keys = xstrdup(mp->m_keys);
|
|
if (save_m_luaref == LUA_NOREF) {
|
|
save_m_str = xstrdup(mp->m_str);
|
|
}
|
|
map_str = eval_map_expr(mp, NUL);
|
|
|
|
if ((map_str == NULL || *map_str == NUL)) {
|
|
// If an error was displayed and the expression returns an empty
|
|
// string, generate a <Nop> to allow for a redraw.
|
|
if (prev_did_emsg != did_emsg) {
|
|
char buf[4];
|
|
xfree(map_str);
|
|
buf[0] = (char)K_SPECIAL;
|
|
buf[1] = (char)KS_EXTRA;
|
|
buf[2] = KE_IGNORE;
|
|
buf[3] = NUL;
|
|
map_str = xstrdup(buf);
|
|
if (State & MODE_CMDLINE) {
|
|
// redraw the command below the error
|
|
msg_didout = true;
|
|
if (msg_row < cmdline_row) {
|
|
msg_row = cmdline_row;
|
|
}
|
|
redrawcmd();
|
|
}
|
|
} else if (State & (MODE_NORMAL | MODE_INSERT)) {
|
|
// otherwise, just put back the cursor
|
|
setcursor();
|
|
}
|
|
}
|
|
|
|
vgetc_busy = save_vgetc_busy;
|
|
may_garbage_collect = save_may_garbage_collect;
|
|
} else {
|
|
map_str = mp->m_str;
|
|
}
|
|
|
|
// Insert the 'to' part in the typebuf.tb_buf.
|
|
// If 'from' field is the same as the start of the 'to' field, don't
|
|
// remap the first character (but do allow abbreviations).
|
|
// If m_noremap is set, don't remap the whole 'to' part.
|
|
if (map_str == NULL) {
|
|
i = FAIL;
|
|
} else {
|
|
int noremap;
|
|
|
|
// If this is a LANGMAP mapping, then we didn't record the keys
|
|
// at the start of the function and have to record them now.
|
|
if (keylen > typebuf.tb_maplen && (mp->m_mode & MODE_LANGMAP) != 0) {
|
|
gotchars((uint8_t *)map_str, strlen(map_str));
|
|
}
|
|
|
|
if (save_m_noremap != REMAP_YES) {
|
|
noremap = save_m_noremap;
|
|
} else if (strncmp(map_str, save_m_keys != NULL ? save_m_keys : mp->m_keys,
|
|
(size_t)keylen) != 0) {
|
|
noremap = REMAP_YES;
|
|
} else {
|
|
noremap = REMAP_SKIP;
|
|
}
|
|
i = ins_typebuf(map_str, noremap, 0, true, cmd_silent || save_m_silent);
|
|
if (save_m_expr) {
|
|
xfree(map_str);
|
|
}
|
|
}
|
|
xfree(save_m_keys);
|
|
xfree(save_m_str);
|
|
*keylenp = keylen;
|
|
if (i == FAIL) {
|
|
return map_result_fail;
|
|
}
|
|
return map_result_retry;
|
|
}
|
|
|
|
*keylenp = keylen;
|
|
return map_result_nomatch;
|
|
}
|
|
|
|
/// unget one character (can only be done once!)
|
|
/// If the character was stuffed, vgetc() will get it next time it is called.
|
|
/// Otherwise vgetc() will only get it when the stuff buffer is empty.
|
|
void vungetc(int c)
|
|
{
|
|
old_char = c;
|
|
old_mod_mask = mod_mask;
|
|
old_mouse_grid = mouse_grid;
|
|
old_mouse_row = mouse_row;
|
|
old_mouse_col = mouse_col;
|
|
old_KeyStuffed = KeyStuffed;
|
|
}
|
|
|
|
/// When peeking and not getting a character, reg_executing cannot be cleared
|
|
/// yet, so set a flag to clear it later.
|
|
void check_end_reg_executing(bool advance)
|
|
{
|
|
if (reg_executing != 0 && (typebuf.tb_maplen == 0 || pending_end_reg_executing)) {
|
|
if (advance) {
|
|
reg_executing = 0;
|
|
pending_end_reg_executing = false;
|
|
} else {
|
|
pending_end_reg_executing = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Gets a byte:
|
|
/// 1. from the stuffbuffer
|
|
/// This is used for abbreviated commands like "D" -> "d$".
|
|
/// Also used to redo a command for ".".
|
|
/// 2. from the typeahead buffer
|
|
/// Stores text obtained previously but not used yet.
|
|
/// Also stores the result of mappings.
|
|
/// Also used for the ":normal" command.
|
|
/// 3. from the user
|
|
/// This may do a blocking wait if "advance" is true.
|
|
///
|
|
/// if "advance" is true (vgetc()):
|
|
/// Really get the character.
|
|
/// KeyTyped is set to true in the case the user typed the key.
|
|
/// KeyStuffed is true if the character comes from the stuff buffer.
|
|
/// if "advance" is false (vpeekc()):
|
|
/// Just look whether there is a character available.
|
|
/// Return NUL if not.
|
|
///
|
|
/// When `no_mapping` (global) is zero, checks for mappings in the current mode.
|
|
/// Only returns one byte (of a multi-byte character).
|
|
/// K_SPECIAL may be escaped, need to get two more bytes then.
|
|
static int vgetorpeek(bool advance)
|
|
{
|
|
int c;
|
|
bool timedout = false; // waited for more than 'timeoutlen'
|
|
// for mapping to complete or
|
|
// 'ttimeoutlen' for complete key code
|
|
int mapdepth = 0; // check for recursive mapping
|
|
bool mode_deleted = false; // set when mode has been deleted
|
|
|
|
// This function doesn't work very well when called recursively. This may
|
|
// happen though, because of:
|
|
// 1. The call to add_to_showcmd(). char_avail() is then used to check if
|
|
// there is a character available, which calls this function. In that
|
|
// case we must return NUL, to indicate no character is available.
|
|
// 2. A GUI callback function writes to the screen, causing a
|
|
// wait_return().
|
|
// Using ":normal" can also do this, but it saves the typeahead buffer,
|
|
// thus it should be OK. But don't get a key from the user then.
|
|
if (vgetc_busy > 0 && ex_normal_busy == 0) {
|
|
return NUL;
|
|
}
|
|
|
|
vgetc_busy++;
|
|
|
|
if (advance) {
|
|
KeyStuffed = false;
|
|
typebuf_was_empty = false;
|
|
}
|
|
|
|
init_typebuf();
|
|
start_stuff();
|
|
check_end_reg_executing(advance);
|
|
do {
|
|
// get a character: 1. from the stuffbuffer
|
|
if (typeahead_char != 0) {
|
|
c = typeahead_char;
|
|
if (advance) {
|
|
typeahead_char = 0;
|
|
}
|
|
} else {
|
|
c = read_readbuffers(advance);
|
|
}
|
|
if (c != NUL && !got_int) {
|
|
if (advance) {
|
|
// KeyTyped = false; When the command that stuffed something
|
|
// was typed, behave like the stuffed command was typed.
|
|
// needed for CTRL-W CTRL-] to open a fold, for example.
|
|
KeyStuffed = true;
|
|
}
|
|
if (typebuf.tb_no_abbr_cnt == 0) {
|
|
typebuf.tb_no_abbr_cnt = 1; // no abbreviations now
|
|
}
|
|
} else {
|
|
// Loop until we either find a matching mapped key, or we
|
|
// are sure that it is not a mapped key.
|
|
// If a mapped key sequence is found we go back to the start to
|
|
// try re-mapping.
|
|
while (true) {
|
|
check_end_reg_executing(advance);
|
|
// os_breakcheck() is slow, don't use it too often when
|
|
// inside a mapping. But call it each time for typed
|
|
// characters.
|
|
if (typebuf.tb_maplen) {
|
|
line_breakcheck();
|
|
} else {
|
|
// os_breakcheck() can call input_enqueue()
|
|
if ((mapped_ctrl_c | curbuf->b_mapped_ctrl_c) & get_real_state()) {
|
|
ctrl_c_interrupts = false;
|
|
}
|
|
os_breakcheck(); // check for CTRL-C
|
|
ctrl_c_interrupts = true;
|
|
}
|
|
int keylen = 0;
|
|
if (got_int) {
|
|
// flush all input
|
|
c = inchar(typebuf.tb_buf, typebuf.tb_buflen - 1, 0);
|
|
|
|
// If inchar() returns true (script file was active) or we
|
|
// are inside a mapping, get out of Insert mode.
|
|
// Otherwise we behave like having gotten a CTRL-C.
|
|
// As a result typing CTRL-C in insert mode will
|
|
// really insert a CTRL-C.
|
|
if ((c || typebuf.tb_maplen)
|
|
&& (State & (MODE_INSERT | MODE_CMDLINE))) {
|
|
c = ESC;
|
|
} else {
|
|
c = Ctrl_C;
|
|
}
|
|
flush_buffers(FLUSH_INPUT); // flush all typeahead
|
|
|
|
if (advance) {
|
|
// Also record this character, it might be needed to
|
|
// get out of Insert mode.
|
|
*typebuf.tb_buf = (uint8_t)c;
|
|
gotchars(typebuf.tb_buf, 1);
|
|
}
|
|
cmd_silent = false;
|
|
|
|
break;
|
|
} else if (typebuf.tb_len > 0) {
|
|
// Check for a mapping in "typebuf".
|
|
map_result_T result = (map_result_T)handle_mapping(&keylen, &timedout, &mapdepth);
|
|
|
|
if (result == map_result_retry) {
|
|
// try mapping again
|
|
continue;
|
|
}
|
|
|
|
if (result == map_result_fail) {
|
|
// failed, use the outer loop
|
|
c = -1;
|
|
break;
|
|
}
|
|
|
|
if (result == map_result_get) {
|
|
// get a character: 2. from the typeahead buffer
|
|
c = typebuf.tb_buf[typebuf.tb_off] & 255;
|
|
if (advance) { // remove chars from tb_buf
|
|
cmd_silent = (typebuf.tb_silent > 0);
|
|
if (typebuf.tb_maplen > 0) {
|
|
KeyTyped = false;
|
|
} else {
|
|
KeyTyped = true;
|
|
// write char to script file(s)
|
|
gotchars(typebuf.tb_buf + typebuf.tb_off, 1);
|
|
}
|
|
KeyNoremap = (unsigned char)typebuf.tb_noremap[typebuf.tb_off];
|
|
del_typebuf(1, 0);
|
|
}
|
|
break; // got character, break the for loop
|
|
}
|
|
|
|
// not enough characters, get more
|
|
}
|
|
|
|
// get a character: 3. from the user - handle <Esc> in Insert mode
|
|
|
|
// special case: if we get an <ESC> in insert mode and there
|
|
// are no more characters at once, we pretend to go out of
|
|
// insert mode. This prevents the one second delay after
|
|
// typing an <ESC>. If we get something after all, we may
|
|
// have to redisplay the mode. That the cursor is in the wrong
|
|
// place does not matter.
|
|
c = 0;
|
|
int new_wcol = curwin->w_wcol;
|
|
int new_wrow = curwin->w_wrow;
|
|
if (advance
|
|
&& typebuf.tb_len == 1
|
|
&& typebuf.tb_buf[typebuf.tb_off] == ESC
|
|
&& !no_mapping
|
|
&& ex_normal_busy == 0
|
|
&& typebuf.tb_maplen == 0
|
|
&& (State & MODE_INSERT)
|
|
&& (p_timeout || (keylen == KEYLEN_PART_KEY && p_ttimeout))
|
|
&& (c = inchar(typebuf.tb_buf + typebuf.tb_off + typebuf.tb_len, 3, 25)) == 0) {
|
|
if (mode_displayed) {
|
|
unshowmode(true);
|
|
mode_deleted = true;
|
|
}
|
|
validate_cursor(curwin);
|
|
int old_wcol = curwin->w_wcol;
|
|
int old_wrow = curwin->w_wrow;
|
|
|
|
// move cursor left, if possible
|
|
if (curwin->w_cursor.col != 0) {
|
|
colnr_T col = 0;
|
|
char *ptr;
|
|
if (curwin->w_wcol > 0) {
|
|
// After auto-indenting and no text is following,
|
|
// we are expecting to truncate the trailing
|
|
// white-space, so find the last non-white
|
|
// character -- webb
|
|
if (did_ai && *skipwhite(get_cursor_line_ptr() + curwin->w_cursor.col) == NUL) {
|
|
curwin->w_wcol = 0;
|
|
ptr = get_cursor_line_ptr();
|
|
char *endptr = ptr + curwin->w_cursor.col;
|
|
|
|
CharsizeArg csarg;
|
|
CSType cstype = init_charsize_arg(&csarg, curwin, curwin->w_cursor.lnum, ptr);
|
|
StrCharInfo ci = utf_ptr2StrCharInfo(ptr);
|
|
int vcol = 0;
|
|
while (ci.ptr < endptr) {
|
|
if (!ascii_iswhite(ci.chr.value)) {
|
|
curwin->w_wcol = vcol;
|
|
}
|
|
vcol += win_charsize(cstype, vcol, ci.ptr, ci.chr.value, &csarg).width;
|
|
ci = utfc_next(ci);
|
|
}
|
|
|
|
curwin->w_wrow = curwin->w_cline_row
|
|
+ curwin->w_wcol / curwin->w_width_inner;
|
|
curwin->w_wcol %= curwin->w_width_inner;
|
|
curwin->w_wcol += win_col_off(curwin);
|
|
col = 0; // no correction needed
|
|
} else {
|
|
curwin->w_wcol--;
|
|
col = curwin->w_cursor.col - 1;
|
|
}
|
|
} else if (curwin->w_p_wrap && curwin->w_wrow) {
|
|
curwin->w_wrow--;
|
|
curwin->w_wcol = curwin->w_width_inner - 1;
|
|
col = curwin->w_cursor.col - 1;
|
|
}
|
|
if (col > 0 && curwin->w_wcol > 0) {
|
|
// Correct when the cursor is on the right halve
|
|
// of a double-wide character.
|
|
ptr = get_cursor_line_ptr();
|
|
col -= utf_head_off(ptr, ptr + col);
|
|
if (utf_ptr2cells(ptr + col) > 1) {
|
|
curwin->w_wcol--;
|
|
}
|
|
}
|
|
}
|
|
setcursor();
|
|
ui_flush();
|
|
new_wcol = curwin->w_wcol;
|
|
new_wrow = curwin->w_wrow;
|
|
curwin->w_wcol = old_wcol;
|
|
curwin->w_wrow = old_wrow;
|
|
}
|
|
if (c < 0) {
|
|
continue; // end of input script reached
|
|
}
|
|
|
|
// Allow mapping for just typed characters. When we get here c
|
|
// is the number of extra bytes and typebuf.tb_len is 1.
|
|
for (int n = 1; n <= c; n++) {
|
|
typebuf.tb_noremap[typebuf.tb_off + n] = RM_YES;
|
|
}
|
|
typebuf.tb_len += c;
|
|
|
|
// buffer full, don't map
|
|
if (typebuf.tb_len >= typebuf.tb_maplen + MAXMAPLEN) {
|
|
timedout = true;
|
|
continue;
|
|
}
|
|
|
|
if (ex_normal_busy > 0) {
|
|
static int tc = 0;
|
|
|
|
// No typeahead left and inside ":normal". Must return
|
|
// something to avoid getting stuck. When an incomplete
|
|
// mapping is present, behave like it timed out.
|
|
if (typebuf.tb_len > 0) {
|
|
timedout = true;
|
|
continue;
|
|
}
|
|
// In Ex-mode \n is compatible with original Vim behaviour.
|
|
// For the command line only CTRL-C always breaks it.
|
|
// For the cmdline window: Alternate between ESC and
|
|
// CTRL-C: ESC for most situations and CTRL-C to close the
|
|
// cmdline window.
|
|
if ((State & MODE_CMDLINE) || (cmdwin_type > 0 && tc == ESC)) {
|
|
c = Ctrl_C;
|
|
} else {
|
|
c = ESC;
|
|
}
|
|
tc = c;
|
|
|
|
// set a flag to indicate this wasn't a normal char
|
|
if (advance) {
|
|
typebuf_was_empty = true;
|
|
}
|
|
|
|
// return 0 in normal_check()
|
|
if (pending_exmode_active) {
|
|
exmode_active = true;
|
|
}
|
|
|
|
// no chars to block abbreviations for
|
|
typebuf.tb_no_abbr_cnt = 0;
|
|
|
|
break;
|
|
}
|
|
|
|
// get a character: 3. from the user - update display
|
|
|
|
// In insert mode a screen update is skipped when characters
|
|
// are still available. But when those available characters
|
|
// are part of a mapping, and we are going to do a blocking
|
|
// wait here. Need to update the screen to display the
|
|
// changed text so far. Also for when 'lazyredraw' is set and
|
|
// redrawing was postponed because there was something in the
|
|
// input buffer (e.g., termresponse).
|
|
if (((State & MODE_INSERT) != 0 || p_lz) && (State & MODE_CMDLINE) == 0
|
|
&& advance && must_redraw != 0 && !need_wait_return) {
|
|
update_screen();
|
|
setcursor(); // put cursor back where it belongs
|
|
}
|
|
|
|
// If we have a partial match (and are going to wait for more
|
|
// input from the user), show the partially matched characters
|
|
// to the user with showcmd.
|
|
int showcmd_idx = 0;
|
|
bool showing_partial = false;
|
|
if (typebuf.tb_len > 0 && advance && !exmode_active) {
|
|
if (((State & (MODE_NORMAL | MODE_INSERT)) || State == MODE_LANGMAP)
|
|
&& State != MODE_HITRETURN) {
|
|
// this looks nice when typing a dead character map
|
|
if (State & MODE_INSERT
|
|
&& ptr2cells((char *)typebuf.tb_buf + typebuf.tb_off + typebuf.tb_len - 1) == 1) {
|
|
edit_putchar(typebuf.tb_buf[typebuf.tb_off + typebuf.tb_len - 1], false);
|
|
setcursor(); // put cursor back where it belongs
|
|
showing_partial = true;
|
|
}
|
|
// need to use the col and row from above here
|
|
int old_wcol = curwin->w_wcol;
|
|
int old_wrow = curwin->w_wrow;
|
|
curwin->w_wcol = new_wcol;
|
|
curwin->w_wrow = new_wrow;
|
|
push_showcmd();
|
|
if (typebuf.tb_len > SHOWCMD_COLS) {
|
|
showcmd_idx = typebuf.tb_len - SHOWCMD_COLS;
|
|
}
|
|
while (showcmd_idx < typebuf.tb_len) {
|
|
add_byte_to_showcmd(typebuf.tb_buf[typebuf.tb_off + showcmd_idx++]);
|
|
}
|
|
curwin->w_wcol = old_wcol;
|
|
curwin->w_wrow = old_wrow;
|
|
}
|
|
|
|
// This looks nice when typing a dead character map.
|
|
// There is no actual command line for get_number().
|
|
if ((State & MODE_CMDLINE)
|
|
&& get_cmdline_info()->cmdbuff != NULL
|
|
&& cmdline_star == 0) {
|
|
char *p = (char *)typebuf.tb_buf + typebuf.tb_off + typebuf.tb_len - 1;
|
|
if (ptr2cells(p) == 1 && (uint8_t)(*p) < 128) {
|
|
putcmdline(*p, false);
|
|
showing_partial = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// get a character: 3. from the user - get it
|
|
if (typebuf.tb_len == 0) {
|
|
// timedout may have been set if a mapping with empty RHS
|
|
// fully matched while longer mappings timed out.
|
|
timedout = false;
|
|
}
|
|
|
|
int wait_time = 0;
|
|
|
|
if (advance) {
|
|
if (typebuf.tb_len == 0 || !(p_timeout || (p_ttimeout && keylen == KEYLEN_PART_KEY))) {
|
|
// blocking wait
|
|
wait_time = -1;
|
|
} else if (keylen == KEYLEN_PART_KEY && p_ttm >= 0) {
|
|
wait_time = (int)p_ttm;
|
|
} else {
|
|
wait_time = (int)p_tm;
|
|
}
|
|
}
|
|
|
|
int wait_tb_len = typebuf.tb_len;
|
|
c = inchar(typebuf.tb_buf + typebuf.tb_off + typebuf.tb_len,
|
|
typebuf.tb_buflen - typebuf.tb_off - typebuf.tb_len - 1,
|
|
wait_time);
|
|
|
|
if (showcmd_idx != 0) {
|
|
pop_showcmd();
|
|
}
|
|
if (showing_partial == 1) {
|
|
if (State & MODE_INSERT) {
|
|
edit_unputchar();
|
|
}
|
|
if ((State & MODE_CMDLINE)
|
|
&& get_cmdline_info()->cmdbuff != NULL) {
|
|
unputcmdline();
|
|
} else {
|
|
setcursor(); // put cursor back where it belongs
|
|
}
|
|
}
|
|
|
|
if (c < 0) {
|
|
continue; // end of input script reached
|
|
}
|
|
if (c == NUL) { // no character available
|
|
if (!advance) {
|
|
break;
|
|
}
|
|
if (wait_tb_len > 0) { // timed out
|
|
timedout = true;
|
|
continue;
|
|
}
|
|
} else { // allow mapping for just typed characters
|
|
while (typebuf.tb_buf[typebuf.tb_off + typebuf.tb_len] != NUL) {
|
|
typebuf.tb_noremap[typebuf.tb_off + typebuf.tb_len++] = RM_YES;
|
|
}
|
|
}
|
|
} // while (true)
|
|
} // if (!character from stuffbuf)
|
|
|
|
// if advance is false don't loop on NULs
|
|
} while (c < 0 || (advance && c == NUL));
|
|
|
|
// The "INSERT" message is taken care of here:
|
|
// if we return an ESC to exit insert mode, the message is deleted
|
|
// if we don't return an ESC but deleted the message before, redisplay it
|
|
if (advance && p_smd && msg_silent == 0 && (State & MODE_INSERT)) {
|
|
if (c == ESC && !mode_deleted && !no_mapping && mode_displayed) {
|
|
if (typebuf.tb_len && !KeyTyped) {
|
|
redraw_cmdline = true; // delete mode later
|
|
} else {
|
|
unshowmode(false);
|
|
}
|
|
} else if (c != ESC && mode_deleted) {
|
|
if (typebuf.tb_len && !KeyTyped) {
|
|
redraw_cmdline = true; // show mode later
|
|
} else {
|
|
showmode();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (timedout && c == ESC) {
|
|
// When recording there will be no timeout. Add an <Ignore> after the
|
|
// ESC to avoid that it forms a key code with following characters.
|
|
gotchars_ignore();
|
|
}
|
|
|
|
vgetc_busy--;
|
|
|
|
return c;
|
|
}
|
|
|
|
/// inchar() - get one character from
|
|
/// 1. a scriptfile
|
|
/// 2. the keyboard
|
|
///
|
|
/// As many characters as we can get (up to 'maxlen') are put in "buf" and
|
|
/// NUL terminated (buffer length must be 'maxlen' + 1).
|
|
/// Minimum for "maxlen" is 3!!!!
|
|
///
|
|
/// "tb_change_cnt" is the value of typebuf.tb_change_cnt if "buf" points into
|
|
/// it. When typebuf.tb_change_cnt changes (e.g., when a message is received
|
|
/// from a remote client) "buf" can no longer be used. "tb_change_cnt" is 0
|
|
/// otherwise.
|
|
///
|
|
/// If we got an interrupt all input is read until none is available.
|
|
///
|
|
/// If wait_time == 0 there is no waiting for the char.
|
|
/// If wait_time == n we wait for n msec for a character to arrive.
|
|
/// If wait_time == -1 we wait forever for a character to arrive.
|
|
///
|
|
/// Return the number of obtained characters.
|
|
/// Return -1 when end of input script reached.
|
|
///
|
|
/// @param wait_time milliseconds
|
|
int inchar(uint8_t *buf, int maxlen, long wait_time)
|
|
{
|
|
int len = 0; // Init for GCC.
|
|
int retesc = false; // Return ESC with gotint.
|
|
const int tb_change_cnt = typebuf.tb_change_cnt;
|
|
|
|
if (wait_time == -1 || wait_time > 100) {
|
|
// flush output before waiting
|
|
ui_flush();
|
|
}
|
|
|
|
// Don't reset these when at the hit-return prompt, otherwise an endless
|
|
// recursive loop may result (write error in swapfile, hit-return, timeout
|
|
// on char wait, flush swapfile, write error....).
|
|
if (State != MODE_HITRETURN) {
|
|
did_outofmem_msg = false; // display out of memory message (again)
|
|
did_swapwrite_msg = false; // display swap file write error again
|
|
}
|
|
|
|
// Get a character from a script file if there is one.
|
|
// If interrupted: Stop reading script files, close them all.
|
|
ptrdiff_t read_size = -1;
|
|
while (curscript >= 0 && read_size <= 0 && !ignore_script) {
|
|
char script_char;
|
|
if (got_int
|
|
|| (read_size = file_read(&scriptin[curscript], &script_char, 1)) != 1) {
|
|
// Reached EOF or some error occurred.
|
|
// Careful: closescript() frees typebuf.tb_buf[] and buf[] may
|
|
// point inside typebuf.tb_buf[]. Don't use buf[] after this!
|
|
closescript();
|
|
// When reading script file is interrupted, return an ESC to get
|
|
// back to normal mode.
|
|
// Otherwise return -1, because typebuf.tb_buf[] has changed.
|
|
if (got_int) {
|
|
retesc = true;
|
|
} else {
|
|
return -1;
|
|
}
|
|
} else {
|
|
buf[0] = (uint8_t)script_char;
|
|
len = 1;
|
|
}
|
|
}
|
|
|
|
if (read_size <= 0) { // Did not get a character from script.
|
|
// If we got an interrupt, skip all previously typed characters and
|
|
// return true if quit reading script file.
|
|
// Stop reading typeahead when a single CTRL-C was read,
|
|
// fill_input_buf() returns this when not able to read from stdin.
|
|
// Don't use buf[] here, closescript() may have freed typebuf.tb_buf[]
|
|
// and buf may be pointing inside typebuf.tb_buf[].
|
|
if (got_int) {
|
|
#define DUM_LEN (MAXMAPLEN * 3 + 3)
|
|
uint8_t dum[DUM_LEN + 1];
|
|
|
|
while (true) {
|
|
len = os_inchar(dum, DUM_LEN, 0, 0, NULL);
|
|
if (len == 0 || (len == 1 && dum[0] == Ctrl_C)) {
|
|
break;
|
|
}
|
|
}
|
|
return retesc;
|
|
}
|
|
|
|
// Always flush the output characters when getting input characters
|
|
// from the user and not just peeking.
|
|
if (wait_time == -1 || wait_time > 10) {
|
|
ui_flush();
|
|
}
|
|
|
|
// Fill up to a third of the buffer, because each character may be
|
|
// tripled below.
|
|
len = os_inchar(buf, maxlen / 3, (int)wait_time, tb_change_cnt, NULL);
|
|
}
|
|
|
|
// If the typebuf was changed further down, it is like nothing was added by
|
|
// this call.
|
|
if (typebuf_changed(tb_change_cnt)) {
|
|
return 0;
|
|
}
|
|
|
|
// Note the change in the typeahead buffer, this matters for when
|
|
// vgetorpeek() is called recursively, e.g. using getchar(1) in a timer
|
|
// function.
|
|
if (len > 0 && ++typebuf.tb_change_cnt == 0) {
|
|
typebuf.tb_change_cnt = 1;
|
|
}
|
|
|
|
return fix_input_buffer(buf, len);
|
|
}
|
|
|
|
/// Fix typed characters for use by vgetc().
|
|
/// "buf[]" must have room to triple the number of bytes!
|
|
/// Returns the new length.
|
|
int fix_input_buffer(uint8_t *buf, int len)
|
|
FUNC_ATTR_NONNULL_ALL
|
|
{
|
|
if (!using_script()) {
|
|
// Should not escape K_SPECIAL reading input from the user because vim
|
|
// key codes keys are processed in input.c/input_enqueue.
|
|
buf[len] = NUL;
|
|
return len;
|
|
}
|
|
|
|
// Reading from script, need to process special bytes
|
|
uint8_t *p = buf;
|
|
|
|
// Two characters are special: NUL and K_SPECIAL.
|
|
// Replace NUL by K_SPECIAL KS_ZERO KE_FILLER
|
|
// Replace K_SPECIAL by K_SPECIAL KS_SPECIAL KE_FILLER
|
|
for (int i = len; --i >= 0; p++) {
|
|
if (p[0] == NUL
|
|
|| (p[0] == K_SPECIAL
|
|
&& (i < 2 || p[1] != KS_EXTRA))) {
|
|
memmove(p + 3, p + 1, (size_t)i);
|
|
p[2] = (uint8_t)K_THIRD(p[0]);
|
|
p[1] = (uint8_t)K_SECOND(p[0]);
|
|
p[0] = K_SPECIAL;
|
|
p += 2;
|
|
len += 2;
|
|
}
|
|
}
|
|
*p = NUL; // add trailing NUL
|
|
return len;
|
|
}
|
|
|
|
/// Function passed to do_cmdline() to get the command after a <Cmd> key from
|
|
/// typeahead.
|
|
char *getcmdkeycmd(int promptc, void *cookie, int indent, bool do_concat)
|
|
{
|
|
garray_T line_ga;
|
|
int c1 = -1;
|
|
int cmod = 0;
|
|
bool aborted = false;
|
|
|
|
ga_init(&line_ga, 1, 32);
|
|
|
|
// no mapping for these characters
|
|
no_mapping++;
|
|
|
|
got_int = false;
|
|
while (c1 != NUL && !aborted) {
|
|
ga_grow(&line_ga, 32);
|
|
|
|
if (vgetorpeek(false) == NUL) {
|
|
// incomplete <Cmd> is an error, because there is not much the user
|
|
// could do in this state.
|
|
emsg(_(e_cmd_mapping_must_end_with_cr));
|
|
aborted = true;
|
|
break;
|
|
}
|
|
|
|
// Get one character at a time.
|
|
c1 = vgetorpeek(true);
|
|
|
|
// Get two extra bytes for special keys
|
|
if (c1 == K_SPECIAL) {
|
|
c1 = vgetorpeek(true);
|
|
int c2 = vgetorpeek(true);
|
|
if (c1 == KS_MODIFIER) {
|
|
cmod = c2;
|
|
continue;
|
|
}
|
|
c1 = TO_SPECIAL(c1, c2);
|
|
}
|
|
|
|
if (got_int) {
|
|
aborted = true;
|
|
} else if (c1 == '\r' || c1 == '\n') {
|
|
c1 = NUL; // end the line
|
|
} else if (c1 == ESC) {
|
|
aborted = true;
|
|
} else if (c1 == K_COMMAND) {
|
|
// give a nicer error message for this special case
|
|
emsg(_(e_cmd_mapping_must_end_with_cr_before_second_cmd));
|
|
aborted = true;
|
|
} else if (c1 == K_SNR) {
|
|
ga_concat(&line_ga, "<SNR>");
|
|
} else {
|
|
if (cmod != 0) {
|
|
ga_append(&line_ga, K_SPECIAL);
|
|
ga_append(&line_ga, KS_MODIFIER);
|
|
ga_append(&line_ga, (uint8_t)cmod);
|
|
}
|
|
if (IS_SPECIAL(c1)) {
|
|
ga_append(&line_ga, K_SPECIAL);
|
|
ga_append(&line_ga, (uint8_t)K_SECOND(c1));
|
|
ga_append(&line_ga, (uint8_t)K_THIRD(c1));
|
|
} else {
|
|
ga_append(&line_ga, (uint8_t)c1);
|
|
}
|
|
}
|
|
|
|
cmod = 0;
|
|
}
|
|
|
|
no_mapping--;
|
|
|
|
if (aborted) {
|
|
ga_clear(&line_ga);
|
|
}
|
|
|
|
return line_ga.ga_data;
|
|
}
|
|
|
|
/// Handle a Lua mapping: get its LuaRef from typeahead and execute it.
|
|
///
|
|
/// @param may_repeat save the LuaRef for redoing with "." later
|
|
///
|
|
/// @return false if getting the LuaRef was aborted, true otherwise
|
|
bool map_execute_lua(bool may_repeat)
|
|
{
|
|
garray_T line_ga;
|
|
int c1 = -1;
|
|
bool aborted = false;
|
|
|
|
ga_init(&line_ga, 1, 32);
|
|
|
|
no_mapping++;
|
|
|
|
got_int = false;
|
|
while (c1 != NUL && !aborted) {
|
|
ga_grow(&line_ga, 32);
|
|
// Get one character at a time.
|
|
c1 = vgetorpeek(true);
|
|
if (got_int) {
|
|
aborted = true;
|
|
} else if (c1 == '\r' || c1 == '\n') {
|
|
c1 = NUL; // end the line
|
|
} else {
|
|
ga_append(&line_ga, (uint8_t)c1);
|
|
}
|
|
}
|
|
|
|
no_mapping--;
|
|
|
|
if (aborted) {
|
|
ga_clear(&line_ga);
|
|
return false;
|
|
}
|
|
|
|
LuaRef ref = (LuaRef)atoi(line_ga.ga_data);
|
|
if (may_repeat) {
|
|
repeat_luaref = ref;
|
|
}
|
|
|
|
Error err = ERROR_INIT;
|
|
Array args = ARRAY_DICT_INIT;
|
|
nlua_call_ref(ref, NULL, args, kRetNilBool, NULL, &err);
|
|
if (err.type != kErrorTypeNone) {
|
|
semsg_multiline("E5108: %s", err.msg);
|
|
api_clear_error(&err);
|
|
}
|
|
|
|
ga_clear(&line_ga);
|
|
return true;
|
|
}
|