aboutsummaryrefslogtreecommitdiff
path: root/src/nvim/vterm
diff options
context:
space:
mode:
Diffstat (limited to 'src/nvim/vterm')
-rw-r--r--src/nvim/vterm/LICENSE23
-rw-r--r--src/nvim/vterm/README.md1
-rw-r--r--src/nvim/vterm/encoding.c271
-rw-r--r--src/nvim/vterm/encoding.h10
-rw-r--r--src/nvim/vterm/keyboard.c318
-rw-r--r--src/nvim/vterm/keyboard.h10
-rw-r--r--src/nvim/vterm/mouse.c124
-rw-r--r--src/nvim/vterm/mouse.h10
-rw-r--r--src/nvim/vterm/parser.c411
-rw-r--r--src/nvim/vterm/parser.h9
-rw-r--r--src/nvim/vterm/pen.c644
-rw-r--r--src/nvim/vterm/pen.h9
-rw-r--r--src/nvim/vterm/screen.c1115
-rw-r--r--src/nvim/vterm/screen.h9
-rw-r--r--src/nvim/vterm/state.c2467
-rw-r--r--src/nvim/vterm/state.h7
-rw-r--r--src/nvim/vterm/vterm.c335
-rw-r--r--src/nvim/vterm/vterm.h161
-rw-r--r--src/nvim/vterm/vterm_defs.h322
-rw-r--r--src/nvim/vterm/vterm_internal_defs.h292
-rw-r--r--src/nvim/vterm/vterm_keycodes_defs.h58
21 files changed, 6606 insertions, 0 deletions
diff --git a/src/nvim/vterm/LICENSE b/src/nvim/vterm/LICENSE
new file mode 100644
index 0000000000..0d051634b2
--- /dev/null
+++ b/src/nvim/vterm/LICENSE
@@ -0,0 +1,23 @@
+
+
+The MIT License
+
+Copyright (c) 2008 Paul Evans <leonerd@leonerd.org.uk>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/src/nvim/vterm/README.md b/src/nvim/vterm/README.md
new file mode 100644
index 0000000000..4cc43bfb94
--- /dev/null
+++ b/src/nvim/vterm/README.md
@@ -0,0 +1 @@
+Adopted from [libvterm](https://www.leonerd.org.uk/code/libvterm/)
diff --git a/src/nvim/vterm/encoding.c b/src/nvim/vterm/encoding.c
new file mode 100644
index 0000000000..f9061e8e50
--- /dev/null
+++ b/src/nvim/vterm/encoding.c
@@ -0,0 +1,271 @@
+#include "nvim/vterm/encoding.h"
+#include "nvim/vterm/vterm_internal_defs.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "vterm/encoding.c.generated.h"
+#endif
+
+#define UNICODE_INVALID 0xFFFD
+
+#if defined(DEBUG) && DEBUG > 1
+# define DEBUG_PRINT_UTF8
+#endif
+
+struct UTF8DecoderData {
+ // number of bytes remaining in this codepoint
+ int bytes_remaining;
+
+ // number of bytes total in this codepoint once it's finished
+ // (for detecting overlongs)
+ int bytes_total;
+
+ int this_cp;
+};
+
+static void init_utf8(VTermEncoding *enc, void *data_)
+{
+ struct UTF8DecoderData *data = data_;
+
+ data->bytes_remaining = 0;
+ data->bytes_total = 0;
+}
+
+static void decode_utf8(VTermEncoding *enc, void *data_, uint32_t cp[], int *cpi, int cplen,
+ const char bytes[], size_t *pos, size_t bytelen)
+{
+ struct UTF8DecoderData *data = data_;
+
+#ifdef DEBUG_PRINT_UTF8
+ printf("BEGIN UTF-8\n");
+#endif
+
+ for (; *pos < bytelen && *cpi < cplen; (*pos)++) {
+ uint8_t c = (uint8_t)bytes[*pos];
+
+#ifdef DEBUG_PRINT_UTF8
+ printf(" pos=%zd c=%02x rem=%d\n", *pos, c, data->bytes_remaining);
+#endif
+
+ if (c < 0x20) { // C0
+ return;
+ } else if (c >= 0x20 && c < 0x7f) {
+ if (data->bytes_remaining) {
+ cp[(*cpi)++] = UNICODE_INVALID;
+ }
+
+ cp[(*cpi)++] = c;
+#ifdef DEBUG_PRINT_UTF8
+ printf(" UTF-8 char: U+%04x\n", c);
+#endif
+ data->bytes_remaining = 0;
+ } else if (c == 0x7f) { // DEL
+ return;
+ } else if (c >= 0x80 && c < 0xc0) {
+ if (!data->bytes_remaining) {
+ cp[(*cpi)++] = UNICODE_INVALID;
+ continue;
+ }
+
+ data->this_cp <<= 6;
+ data->this_cp |= c & 0x3f;
+ data->bytes_remaining--;
+
+ if (!data->bytes_remaining) {
+#ifdef DEBUG_PRINT_UTF8
+ printf(" UTF-8 raw char U+%04x bytelen=%d ", data->this_cp, data->bytes_total);
+#endif
+ // Check for overlong sequences
+ switch (data->bytes_total) {
+ case 2:
+ if (data->this_cp < 0x0080) {
+ data->this_cp = UNICODE_INVALID;
+ }
+ break;
+ case 3:
+ if (data->this_cp < 0x0800) {
+ data->this_cp = UNICODE_INVALID;
+ }
+ break;
+ case 4:
+ if (data->this_cp < 0x10000) {
+ data->this_cp = UNICODE_INVALID;
+ }
+ break;
+ case 5:
+ if (data->this_cp < 0x200000) {
+ data->this_cp = UNICODE_INVALID;
+ }
+ break;
+ case 6:
+ if (data->this_cp < 0x4000000) {
+ data->this_cp = UNICODE_INVALID;
+ }
+ break;
+ }
+ // Now look for plain invalid ones
+ if ((data->this_cp >= 0xD800 && data->this_cp <= 0xDFFF)
+ || data->this_cp == 0xFFFE
+ || data->this_cp == 0xFFFF) {
+ data->this_cp = UNICODE_INVALID;
+ }
+#ifdef DEBUG_PRINT_UTF8
+ printf(" char: U+%04x\n", data->this_cp);
+#endif
+ cp[(*cpi)++] = (uint32_t)data->this_cp;
+ }
+ } else if (c >= 0xc0 && c < 0xe0) {
+ if (data->bytes_remaining) {
+ cp[(*cpi)++] = UNICODE_INVALID;
+ }
+
+ data->this_cp = c & 0x1f;
+ data->bytes_total = 2;
+ data->bytes_remaining = 1;
+ } else if (c >= 0xe0 && c < 0xf0) {
+ if (data->bytes_remaining) {
+ cp[(*cpi)++] = UNICODE_INVALID;
+ }
+
+ data->this_cp = c & 0x0f;
+ data->bytes_total = 3;
+ data->bytes_remaining = 2;
+ } else if (c >= 0xf0 && c < 0xf8) {
+ if (data->bytes_remaining) {
+ cp[(*cpi)++] = UNICODE_INVALID;
+ }
+
+ data->this_cp = c & 0x07;
+ data->bytes_total = 4;
+ data->bytes_remaining = 3;
+ } else if (c >= 0xf8 && c < 0xfc) {
+ if (data->bytes_remaining) {
+ cp[(*cpi)++] = UNICODE_INVALID;
+ }
+
+ data->this_cp = c & 0x03;
+ data->bytes_total = 5;
+ data->bytes_remaining = 4;
+ } else if (c >= 0xfc && c < 0xfe) {
+ if (data->bytes_remaining) {
+ cp[(*cpi)++] = UNICODE_INVALID;
+ }
+
+ data->this_cp = c & 0x01;
+ data->bytes_total = 6;
+ data->bytes_remaining = 5;
+ } else {
+ cp[(*cpi)++] = UNICODE_INVALID;
+ }
+ }
+}
+
+static VTermEncoding encoding_utf8 = {
+ .init = &init_utf8,
+ .decode = &decode_utf8,
+};
+
+static void decode_usascii(VTermEncoding *enc, void *data, uint32_t cp[], int *cpi, int cplen,
+ const char bytes[], size_t *pos, size_t bytelen)
+{
+ int is_gr = bytes[*pos] & 0x80;
+
+ for (; *pos < bytelen && *cpi < cplen; (*pos)++) {
+ uint8_t c = (uint8_t)(bytes[*pos] ^ is_gr);
+
+ if (c < 0x20 || c == 0x7f || c >= 0x80) {
+ return;
+ }
+
+ cp[(*cpi)++] = c;
+ }
+}
+
+static VTermEncoding encoding_usascii = {
+ .decode = &decode_usascii,
+};
+
+struct StaticTableEncoding {
+ const VTermEncoding enc;
+ const uint32_t chars[128];
+};
+
+static void decode_table(VTermEncoding *enc, void *data, uint32_t cp[], int *cpi, int cplen,
+ const char bytes[], size_t *pos, size_t bytelen)
+{
+ struct StaticTableEncoding *table = (struct StaticTableEncoding *)enc;
+ int is_gr = bytes[*pos] & 0x80;
+
+ for (; *pos < bytelen && *cpi < cplen; (*pos)++) {
+ uint8_t c = (uint8_t)(bytes[*pos] ^ is_gr);
+
+ if (c < 0x20 || c == 0x7f || c >= 0x80) {
+ return;
+ }
+
+ if (table->chars[c]) {
+ cp[(*cpi)++] = table->chars[c];
+ } else {
+ cp[(*cpi)++] = c;
+ }
+ }
+}
+
+// https://en.wikipedia.org/wiki/DEC_Special_Graphics
+static const struct StaticTableEncoding encoding_DECdrawing = {
+ { .decode = &decode_table },
+ {
+ [0x60] = 0x25C6, // BLACK DIAMOND
+ [0x61] = 0x2592, // MEDIUM SHADE (checkerboard)
+ [0x62] = 0x2409, // SYMBOL FOR HORIZONTAL TAB
+ [0x63] = 0x240C, // SYMBOL FOR FORM FEED
+ [0x64] = 0x240D, // SYMBOL FOR CARRIAGE RETURN
+ [0x65] = 0x240A, // SYMBOL FOR LINE FEED
+ [0x66] = 0x00B0, // DEGREE SIGN
+ [0x67] = 0x00B1, // PLUS-MINUS SIGN (plus or minus)
+ [0x68] = 0x2424, // SYMBOL FOR NEW LINE
+ [0x69] = 0x240B, // SYMBOL FOR VERTICAL TAB
+ [0x6a] = 0x2518, // BOX DRAWINGS LIGHT UP AND LEFT (bottom-right corner)
+ [0x6b] = 0x2510, // BOX DRAWINGS LIGHT DOWN AND LEFT (top-right corner)
+ [0x6c] = 0x250C, // BOX DRAWINGS LIGHT DOWN AND RIGHT (top-left corner)
+ [0x6d] = 0x2514, // BOX DRAWINGS LIGHT UP AND RIGHT (bottom-left corner)
+ [0x6e] = 0x253C, // BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL (crossing lines)
+ [0x6f] = 0x23BA, // HORIZONTAL SCAN LINE-1
+ [0x70] = 0x23BB, // HORIZONTAL SCAN LINE-3
+ [0x71] = 0x2500, // BOX DRAWINGS LIGHT HORIZONTAL
+ [0x72] = 0x23BC, // HORIZONTAL SCAN LINE-7
+ [0x73] = 0x23BD, // HORIZONTAL SCAN LINE-9
+ [0x74] = 0x251C, // BOX DRAWINGS LIGHT VERTICAL AND RIGHT
+ [0x75] = 0x2524, // BOX DRAWINGS LIGHT VERTICAL AND LEFT
+ [0x76] = 0x2534, // BOX DRAWINGS LIGHT UP AND HORIZONTAL
+ [0x77] = 0x252C, // BOX DRAWINGS LIGHT DOWN AND HORIZONTAL
+ [0x78] = 0x2502, // BOX DRAWINGS LIGHT VERTICAL
+ [0x79] = 0x2A7D, // LESS-THAN OR SLANTED EQUAL-TO
+ [0x7a] = 0x2A7E, // GREATER-THAN OR SLANTED EQUAL-TO
+ [0x7b] = 0x03C0, // GREEK SMALL LETTER PI
+ [0x7c] = 0x2260, // NOT EQUAL TO
+ [0x7d] = 0x00A3, // POUND SIGN
+ [0x7e] = 0x00B7, // MIDDLE DOT
+ }
+};
+
+static struct {
+ VTermEncodingType type;
+ char designation;
+ VTermEncoding *enc;
+}
+encodings[] = {
+ { ENC_UTF8, 'u', &encoding_utf8 },
+ { ENC_SINGLE_94, '0', (VTermEncoding *)&encoding_DECdrawing },
+ { ENC_SINGLE_94, 'B', &encoding_usascii },
+ { 0 },
+};
+
+VTermEncoding *vterm_lookup_encoding(VTermEncodingType type, char designation)
+{
+ for (int i = 0; encodings[i].designation; i++) {
+ if (encodings[i].type == type && encodings[i].designation == designation) {
+ return encodings[i].enc;
+ }
+ }
+ return NULL;
+}
diff --git a/src/nvim/vterm/encoding.h b/src/nvim/vterm/encoding.h
new file mode 100644
index 0000000000..204b6d90c9
--- /dev/null
+++ b/src/nvim/vterm/encoding.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <stddef.h>
+
+#include "nvim/vterm/vterm_defs.h"
+#include "nvim/vterm/vterm_internal_defs.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "vterm/encoding.h.generated.h"
+#endif
diff --git a/src/nvim/vterm/keyboard.c b/src/nvim/vterm/keyboard.c
new file mode 100644
index 0000000000..dd088ac40e
--- /dev/null
+++ b/src/nvim/vterm/keyboard.c
@@ -0,0 +1,318 @@
+#include <stdio.h>
+
+#include "nvim/ascii_defs.h"
+#include "nvim/tui/termkey/termkey.h"
+#include "nvim/vterm/keyboard.h"
+#include "nvim/vterm/vterm.h"
+#include "nvim/vterm/vterm_internal_defs.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "vterm/keyboard.c.generated.h"
+#endif
+
+static VTermKeyEncodingFlags vterm_state_get_key_encoding_flags(const VTermState *state)
+{
+ int screen = state->mode.alt_screen ? BUFIDX_ALTSCREEN : BUFIDX_PRIMARY;
+ const struct VTermKeyEncodingStack *stack = &state->key_encoding_stacks[screen];
+ assert(stack->size > 0);
+ return stack->items[stack->size - 1];
+}
+
+void vterm_keyboard_unichar(VTerm *vt, uint32_t c, VTermModifier mod)
+{
+ bool passthru = false;
+ if (c == ' ') {
+ // Space is passed through only when there are no modifiers (including shift)
+ passthru = mod == VTERM_MOD_NONE;
+ } else {
+ // Otherwise pass through when there are no modifiers (ignoring shift)
+ passthru = (mod & (unsigned)~VTERM_MOD_SHIFT) == 0;
+ }
+
+ if (passthru) {
+ char str[6];
+ int seqlen = fill_utf8((int)c, str);
+ vterm_push_output_bytes(vt, str, (size_t)seqlen);
+ return;
+ }
+
+ VTermKeyEncodingFlags flags = vterm_state_get_key_encoding_flags(vt->state);
+ if (flags.disambiguate) {
+ // Always use unshifted codepoint
+ if (c >= 'A' && c <= 'Z') {
+ c += 'a' - 'A';
+ mod |= VTERM_MOD_SHIFT;
+ }
+
+ vterm_push_output_sprintf_ctrl(vt, C1_CSI, "%d;%du", c, mod + 1);
+ return;
+ }
+
+ if (mod & VTERM_MOD_CTRL) {
+ // Handle special cases. These are taken from kitty, but seem mostly
+ // consistent across terminals.
+ switch (c) {
+ case '2':
+ case ' ':
+ // Ctrl+2 is NUL to match Ctrl+@ (which is Shift+2 on US keyboards)
+ // Ctrl+Space is also NUL for some reason
+ c = 0x00;
+ break;
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ // Ctrl+3 through Ctrl+7 are sequential starting from 0x1b. Importantly,
+ // this means that Ctrl+6 emits 0x1e (the same as Ctrl+^ on US keyboards)
+ c = 0x1b + c - '3';
+ break;
+ case '8':
+ // Ctrl+8 is DEL
+ c = 0x7f;
+ break;
+ case '/':
+ // Ctrl+/ is equivalent to Ctrl+_ for historic reasons
+ c = 0x1f;
+ break;
+ default:
+ if (c >= '@' && c <= 0x7f) {
+ c &= 0x1f;
+ }
+ break;
+ }
+ }
+
+ vterm_push_output_sprintf(vt, "%s%c", mod & VTERM_MOD_ALT ? ESC_S : "", c);
+}
+
+typedef struct {
+ enum {
+ KEYCODE_NONE,
+ KEYCODE_LITERAL,
+ KEYCODE_TAB,
+ KEYCODE_ENTER,
+ KEYCODE_SS3,
+ KEYCODE_CSI,
+ KEYCODE_CSI_CURSOR,
+ KEYCODE_CSINUM,
+ KEYCODE_KEYPAD,
+ } type;
+ int literal;
+ int csinum;
+} keycodes_s;
+
+static keycodes_s keycodes[] = {
+ { KEYCODE_NONE, NUL, 0 }, // NONE
+
+ { KEYCODE_ENTER, '\r', 0 }, // ENTER
+ { KEYCODE_TAB, '\t', 0 }, // TAB
+ { KEYCODE_LITERAL, '\x7f', 0 }, // BACKSPACE == ASCII DEL
+ { KEYCODE_LITERAL, '\x1b', 0 }, // ESCAPE
+
+ { KEYCODE_CSI_CURSOR, 'A', 0 }, // UP
+ { KEYCODE_CSI_CURSOR, 'B', 0 }, // DOWN
+ { KEYCODE_CSI_CURSOR, 'D', 0 }, // LEFT
+ { KEYCODE_CSI_CURSOR, 'C', 0 }, // RIGHT
+
+ { KEYCODE_CSINUM, '~', 2 }, // INS
+ { KEYCODE_CSINUM, '~', 3 }, // DEL
+ { KEYCODE_CSI_CURSOR, 'H', 0 }, // HOME
+ { KEYCODE_CSI_CURSOR, 'F', 0 }, // END
+ { KEYCODE_CSINUM, '~', 5 }, // PAGEUP
+ { KEYCODE_CSINUM, '~', 6 }, // PAGEDOWN
+};
+
+static keycodes_s keycodes_fn[] = {
+ { KEYCODE_NONE, NUL, 0 }, // F0 - shouldn't happen
+ { KEYCODE_SS3, 'P', 0 }, // F1
+ { KEYCODE_SS3, 'Q', 0 }, // F2
+ { KEYCODE_SS3, 'R', 0 }, // F3
+ { KEYCODE_SS3, 'S', 0 }, // F4
+ { KEYCODE_CSINUM, '~', 15 }, // F5
+ { KEYCODE_CSINUM, '~', 17 }, // F6
+ { KEYCODE_CSINUM, '~', 18 }, // F7
+ { KEYCODE_CSINUM, '~', 19 }, // F8
+ { KEYCODE_CSINUM, '~', 20 }, // F9
+ { KEYCODE_CSINUM, '~', 21 }, // F10
+ { KEYCODE_CSINUM, '~', 23 }, // F11
+ { KEYCODE_CSINUM, '~', 24 }, // F12
+};
+
+static keycodes_s keycodes_kp[] = {
+ { KEYCODE_KEYPAD, '0', 'p' }, // KP_0
+ { KEYCODE_KEYPAD, '1', 'q' }, // KP_1
+ { KEYCODE_KEYPAD, '2', 'r' }, // KP_2
+ { KEYCODE_KEYPAD, '3', 's' }, // KP_3
+ { KEYCODE_KEYPAD, '4', 't' }, // KP_4
+ { KEYCODE_KEYPAD, '5', 'u' }, // KP_5
+ { KEYCODE_KEYPAD, '6', 'v' }, // KP_6
+ { KEYCODE_KEYPAD, '7', 'w' }, // KP_7
+ { KEYCODE_KEYPAD, '8', 'x' }, // KP_8
+ { KEYCODE_KEYPAD, '9', 'y' }, // KP_9
+ { KEYCODE_KEYPAD, '*', 'j' }, // KP_MULT
+ { KEYCODE_KEYPAD, '+', 'k' }, // KP_PLUS
+ { KEYCODE_KEYPAD, ',', 'l' }, // KP_COMMA
+ { KEYCODE_KEYPAD, '-', 'm' }, // KP_MINUS
+ { KEYCODE_KEYPAD, '.', 'n' }, // KP_PERIOD
+ { KEYCODE_KEYPAD, '/', 'o' }, // KP_DIVIDE
+ { KEYCODE_KEYPAD, '\n', 'M' }, // KP_ENTER
+ { KEYCODE_KEYPAD, '=', 'X' }, // KP_EQUAL
+};
+
+static keycodes_s keycodes_kp_csiu[] = {
+ { KEYCODE_KEYPAD, 57399, 'p' }, // KP_0
+ { KEYCODE_KEYPAD, 57400, 'q' }, // KP_1
+ { KEYCODE_KEYPAD, 57401, 'r' }, // KP_2
+ { KEYCODE_KEYPAD, 57402, 's' }, // KP_3
+ { KEYCODE_KEYPAD, 57403, 't' }, // KP_4
+ { KEYCODE_KEYPAD, 57404, 'u' }, // KP_5
+ { KEYCODE_KEYPAD, 57405, 'v' }, // KP_6
+ { KEYCODE_KEYPAD, 57406, 'w' }, // KP_7
+ { KEYCODE_KEYPAD, 57407, 'x' }, // KP_8
+ { KEYCODE_KEYPAD, 57408, 'y' }, // KP_9
+ { KEYCODE_KEYPAD, 57411, 'j' }, // KP_MULT
+ { KEYCODE_KEYPAD, 57413, 'k' }, // KP_PLUS
+ { KEYCODE_KEYPAD, 57416, 'l' }, // KP_COMMA
+ { KEYCODE_KEYPAD, 57412, 'm' }, // KP_MINUS
+ { KEYCODE_KEYPAD, 57409, 'n' }, // KP_PERIOD
+ { KEYCODE_KEYPAD, 57410, 'o' }, // KP_DIVIDE
+ { KEYCODE_KEYPAD, 57414, 'M' }, // KP_ENTER
+ { KEYCODE_KEYPAD, 57415, 'X' }, // KP_EQUAL
+};
+
+void vterm_keyboard_key(VTerm *vt, VTermKey key, VTermModifier mod)
+{
+ if (key == VTERM_KEY_NONE) {
+ return;
+ }
+
+ VTermKeyEncodingFlags flags = vterm_state_get_key_encoding_flags(vt->state);
+
+ keycodes_s k;
+ if (key < VTERM_KEY_FUNCTION_0) {
+ if (key >= sizeof(keycodes)/sizeof(keycodes[0])) {
+ return;
+ }
+ k = keycodes[key];
+ } else if (key >= VTERM_KEY_FUNCTION_0 && key <= VTERM_KEY_FUNCTION_MAX) {
+ if ((key - VTERM_KEY_FUNCTION_0) >= sizeof(keycodes_fn)/sizeof(keycodes_fn[0])) {
+ return;
+ }
+ k = keycodes_fn[key - VTERM_KEY_FUNCTION_0];
+ } else if (key >= VTERM_KEY_KP_0) {
+ if ((key - VTERM_KEY_KP_0) >= sizeof(keycodes_kp)/sizeof(keycodes_kp[0])) {
+ return;
+ }
+
+ if (flags.disambiguate) {
+ k = keycodes_kp_csiu[key - VTERM_KEY_KP_0];
+ } else {
+ k = keycodes_kp[key - VTERM_KEY_KP_0];
+ }
+ }
+
+ switch (k.type) {
+ case KEYCODE_NONE:
+ break;
+
+ case KEYCODE_TAB:
+ // Shift-Tab is CSI Z but plain Tab is 0x09
+ if (flags.disambiguate) {
+ goto case_LITERAL;
+ } else if (mod == VTERM_MOD_SHIFT) {
+ vterm_push_output_sprintf_ctrl(vt, C1_CSI, "Z");
+ } else if (mod & VTERM_MOD_SHIFT) {
+ vterm_push_output_sprintf_ctrl(vt, C1_CSI, "1;%dZ", mod + 1);
+ } else {
+ goto case_LITERAL;
+ }
+ break;
+
+ case KEYCODE_ENTER:
+ // Enter is CRLF in newline mode, but just LF in linefeed
+ if (vt->state->mode.newline) {
+ vterm_push_output_sprintf(vt, "\r\n");
+ } else {
+ goto case_LITERAL;
+ }
+ break;
+
+ case KEYCODE_LITERAL:
+ case_LITERAL:
+ if (flags.disambiguate) {
+ switch (key) {
+ case VTERM_KEY_TAB:
+ case VTERM_KEY_ENTER:
+ case VTERM_KEY_BACKSPACE:
+ // If there are no mods then leave these as-is
+ flags.disambiguate = mod != VTERM_MOD_NONE;
+ break;
+ default:
+ break;
+ }
+ }
+
+ if (flags.disambiguate) {
+ vterm_push_output_sprintf_ctrl(vt, C1_CSI, "%d;%du", k.literal, mod + 1);
+ } else {
+ vterm_push_output_sprintf(vt, mod & VTERM_MOD_ALT ? ESC_S "%c" : "%c", k.literal);
+ }
+ break;
+
+ case KEYCODE_SS3:
+ case_SS3:
+ if (mod == 0) {
+ vterm_push_output_sprintf_ctrl(vt, C1_SS3, "%c", k.literal);
+ } else {
+ goto case_CSI;
+ }
+ break;
+
+ case KEYCODE_CSI:
+ case_CSI:
+ if (mod == 0) {
+ vterm_push_output_sprintf_ctrl(vt, C1_CSI, "%c", k.literal);
+ } else {
+ vterm_push_output_sprintf_ctrl(vt, C1_CSI, "1;%d%c", mod + 1, k.literal);
+ }
+ break;
+
+ case KEYCODE_CSINUM:
+ if (mod == 0) {
+ vterm_push_output_sprintf_ctrl(vt, C1_CSI, "%d%c", k.csinum, k.literal);
+ } else {
+ vterm_push_output_sprintf_ctrl(vt, C1_CSI, "%d;%d%c", k.csinum, mod + 1, k.literal);
+ }
+ break;
+
+ case KEYCODE_CSI_CURSOR:
+ if (vt->state->mode.cursor) {
+ goto case_SS3;
+ } else {
+ goto case_CSI;
+ }
+
+ case KEYCODE_KEYPAD:
+ if (vt->state->mode.keypad) {
+ k.literal = k.csinum;
+ goto case_SS3;
+ } else {
+ goto case_LITERAL;
+ }
+ }
+}
+
+void vterm_keyboard_start_paste(VTerm *vt)
+{
+ if (vt->state->mode.bracketpaste) {
+ vterm_push_output_sprintf_ctrl(vt, C1_CSI, "200~");
+ }
+}
+
+void vterm_keyboard_end_paste(VTerm *vt)
+{
+ if (vt->state->mode.bracketpaste) {
+ vterm_push_output_sprintf_ctrl(vt, C1_CSI, "201~");
+ }
+}
diff --git a/src/nvim/vterm/keyboard.h b/src/nvim/vterm/keyboard.h
new file mode 100644
index 0000000000..af5f4a3ed1
--- /dev/null
+++ b/src/nvim/vterm/keyboard.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <stddef.h>
+
+#include "nvim/vterm/vterm_defs.h"
+#include "nvim/vterm/vterm_keycodes_defs.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "vterm/keyboard.h.generated.h"
+#endif
diff --git a/src/nvim/vterm/mouse.c b/src/nvim/vterm/mouse.c
new file mode 100644
index 0000000000..2f3b1d9e2f
--- /dev/null
+++ b/src/nvim/vterm/mouse.c
@@ -0,0 +1,124 @@
+#include "nvim/math.h"
+#include "nvim/tui/termkey/termkey.h"
+#include "nvim/vterm/mouse.h"
+#include "nvim/vterm/vterm.h"
+#include "nvim/vterm/vterm_internal_defs.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "vterm/mouse.c.generated.h"
+#endif
+
+static void output_mouse(VTermState *state, int code, int pressed, int modifiers, int col, int row)
+{
+ modifiers <<= 2;
+
+ switch (state->mouse_protocol) {
+ case MOUSE_X10:
+ if (col + 0x21 > 0xff) {
+ col = 0xff - 0x21;
+ }
+ if (row + 0x21 > 0xff) {
+ row = 0xff - 0x21;
+ }
+
+ if (!pressed) {
+ code = 3;
+ }
+
+ if (code & 0x80) {
+ break;
+ }
+ vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "M%c%c%c",
+ (code | modifiers) + 0x20, col + 0x21, row + 0x21);
+ break;
+
+ case MOUSE_UTF8: {
+ char utf8[18];
+ size_t len = 0;
+
+ if (!pressed) {
+ code = 3;
+ }
+
+ len += (size_t)fill_utf8((code | modifiers) + 0x20, utf8 + len);
+ len += (size_t)fill_utf8(col + 0x21, utf8 + len);
+ len += (size_t)fill_utf8(row + 0x21, utf8 + len);
+ utf8[len] = 0;
+
+ vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "M%s", utf8);
+ }
+ break;
+
+ case MOUSE_SGR:
+ vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "<%d;%d;%d%c",
+ code | modifiers, col + 1, row + 1, pressed ? 'M' : 'm');
+ break;
+
+ case MOUSE_RXVT:
+ if (!pressed) {
+ code = 3;
+ }
+
+ vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "%d;%d;%dM",
+ code | modifiers, col + 1, row + 1);
+ break;
+ }
+}
+
+void vterm_mouse_move(VTerm *vt, int row, int col, VTermModifier mod)
+{
+ VTermState *state = vt->state;
+
+ if (col == state->mouse_col && row == state->mouse_row) {
+ return;
+ }
+
+ state->mouse_col = col;
+ state->mouse_row = row;
+
+ if ((state->mouse_flags & MOUSE_WANT_DRAG && state->mouse_buttons)
+ || (state->mouse_flags & MOUSE_WANT_MOVE)) {
+ if (state->mouse_buttons) {
+ int button = xctz((uint64_t)state->mouse_buttons) + 1;
+ if (button < 4) {
+ output_mouse(state, button - 1 + 0x20, 1, (int)mod, col, row);
+ } else if (button >= 8 && button < 12) {
+ output_mouse(state, button - 8 + 0x80 + 0x20, 1, (int)mod, col, row);
+ }
+ } else {
+ output_mouse(state, 3 + 0x20, 1, (int)mod, col, row);
+ }
+ }
+}
+
+void vterm_mouse_button(VTerm *vt, int button, bool pressed, VTermModifier mod)
+{
+ VTermState *state = vt->state;
+
+ int old_buttons = state->mouse_buttons;
+
+ if ((button > 0 && button <= 3) || (button >= 8 && button <= 11)) {
+ if (pressed) {
+ state->mouse_buttons |= (1 << (button - 1));
+ } else {
+ state->mouse_buttons &= ~(1 << (button - 1));
+ }
+ }
+
+ // Most of the time we don't get button releases from 4/5/6/7
+ if (state->mouse_buttons == old_buttons && (button < 4 || button > 7)) {
+ return;
+ }
+
+ if (!state->mouse_flags) {
+ return;
+ }
+
+ if (button < 4) {
+ output_mouse(state, button - 1, pressed, (int)mod, state->mouse_col, state->mouse_row);
+ } else if (button < 8) {
+ output_mouse(state, button - 4 + 0x40, pressed, (int)mod, state->mouse_col, state->mouse_row);
+ } else if (button < 12) {
+ output_mouse(state, button - 8 + 0x80, pressed, (int)mod, state->mouse_col, state->mouse_row);
+ }
+}
diff --git a/src/nvim/vterm/mouse.h b/src/nvim/vterm/mouse.h
new file mode 100644
index 0000000000..477f4028a2
--- /dev/null
+++ b/src/nvim/vterm/mouse.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <stddef.h>
+
+#include "nvim/vterm/vterm_defs.h"
+#include "nvim/vterm/vterm_keycodes_defs.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "vterm/mouse.h.generated.h"
+#endif
diff --git a/src/nvim/vterm/parser.c b/src/nvim/vterm/parser.c
new file mode 100644
index 0000000000..79d348f2c1
--- /dev/null
+++ b/src/nvim/vterm/parser.c
@@ -0,0 +1,411 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "nvim/vterm/parser.h"
+#include "nvim/vterm/vterm.h"
+#include "nvim/vterm/vterm_internal_defs.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "vterm/parser.c.generated.h"
+#endif
+
+#undef DEBUG_PARSER
+
+static bool is_intermed(uint8_t c)
+{
+ return c >= 0x20 && c <= 0x2f;
+}
+
+static void do_control(VTerm *vt, uint8_t control)
+{
+ if (vt->parser.callbacks && vt->parser.callbacks->control) {
+ if ((*vt->parser.callbacks->control)(control, vt->parser.cbdata)) {
+ return;
+ }
+ }
+
+ DEBUG_LOG("libvterm: Unhandled control 0x%02x\n", control);
+}
+
+static void do_csi(VTerm *vt, char command)
+{
+#ifdef DEBUG_PARSER
+ printf("Parsed CSI args as:\n", arglen, args);
+ printf(" leader: %s\n", vt->parser.v.csi.leader);
+ for (int argi = 0; argi < vt->parser.v.csi.argi; argi++) {
+ printf(" %lu", CSI_ARG(vt->parser.v.csi.args[argi]));
+ if (!CSI_ARG_HAS_MORE(vt->parser.v.csi.args[argi])) {
+ printf("\n");
+ }
+ printf(" intermed: %s\n", vt->parser.intermed);
+ }
+#endif
+
+ if (vt->parser.callbacks && vt->parser.callbacks->csi) {
+ if ((*vt->parser.callbacks->csi)(vt->parser.v.csi.leaderlen ? vt->parser.v.csi.leader : NULL,
+ vt->parser.v.csi.args,
+ vt->parser.v.csi.argi,
+ vt->parser.intermedlen ? vt->parser.intermed : NULL,
+ command,
+ vt->parser.cbdata)) {
+ return;
+ }
+ }
+
+ DEBUG_LOG("libvterm: Unhandled CSI %c\n", command);
+}
+
+static void do_escape(VTerm *vt, char command)
+{
+ char seq[INTERMED_MAX + 1];
+
+ size_t len = (size_t)vt->parser.intermedlen;
+ strncpy(seq, vt->parser.intermed, len); // NOLINT(runtime/printf)
+ seq[len++] = command;
+ seq[len] = 0;
+
+ if (vt->parser.callbacks && vt->parser.callbacks->escape) {
+ if ((*vt->parser.callbacks->escape)(seq, len, vt->parser.cbdata)) {
+ return;
+ }
+ }
+
+ DEBUG_LOG("libvterm: Unhandled escape ESC 0x%02x\n", command);
+}
+
+static void string_fragment(VTerm *vt, const char *str, size_t len, bool final)
+{
+ VTermStringFragment frag = {
+ .str = str,
+ .len = len,
+ .initial = vt->parser.string_initial,
+ .final = final,
+ };
+
+ switch (vt->parser.state) {
+ case OSC:
+ if (vt->parser.callbacks && vt->parser.callbacks->osc) {
+ (*vt->parser.callbacks->osc)(vt->parser.v.osc.command, frag, vt->parser.cbdata);
+ }
+ break;
+
+ case DCS_VTERM:
+ if (vt->parser.callbacks && vt->parser.callbacks->dcs) {
+ (*vt->parser.callbacks->dcs)(vt->parser.v.dcs.command, (size_t)vt->parser.v.dcs.commandlen,
+ frag,
+ vt->parser.cbdata);
+ }
+ break;
+
+ case APC:
+ if (vt->parser.callbacks && vt->parser.callbacks->apc) {
+ (*vt->parser.callbacks->apc)(frag, vt->parser.cbdata);
+ }
+ break;
+
+ case PM:
+ if (vt->parser.callbacks && vt->parser.callbacks->pm) {
+ (*vt->parser.callbacks->pm)(frag, vt->parser.cbdata);
+ }
+ break;
+
+ case SOS:
+ if (vt->parser.callbacks && vt->parser.callbacks->sos) {
+ (*vt->parser.callbacks->sos)(frag, vt->parser.cbdata);
+ }
+ break;
+
+ case NORMAL:
+ case CSI_LEADER:
+ case CSI_ARGS:
+ case CSI_INTERMED:
+ case OSC_COMMAND:
+ case DCS_COMMAND:
+ break;
+ }
+
+ vt->parser.string_initial = false;
+}
+
+size_t vterm_input_write(VTerm *vt, const char *bytes, size_t len)
+{
+ size_t pos = 0;
+ const char *string_start;
+
+ switch (vt->parser.state) {
+ case NORMAL:
+ case CSI_LEADER:
+ case CSI_ARGS:
+ case CSI_INTERMED:
+ case OSC_COMMAND:
+ case DCS_COMMAND:
+ string_start = NULL;
+ break;
+ case OSC:
+ case DCS_VTERM:
+ case APC:
+ case PM:
+ case SOS:
+ string_start = bytes;
+ break;
+ }
+
+#define ENTER_STATE(st) do { vt->parser.state = st; string_start = NULL; } while (0)
+#define ENTER_NORMAL_STATE() ENTER_STATE(NORMAL)
+
+#define IS_STRING_STATE() (vt->parser.state >= OSC_COMMAND)
+
+ for (; pos < len; pos++) {
+ uint8_t c = (uint8_t)bytes[pos];
+ bool c1_allowed = !vt->mode.utf8;
+
+ if (c == 0x00 || c == 0x7f) { // NUL, DEL
+ if (IS_STRING_STATE()) {
+ string_fragment(vt, string_start, (size_t)(bytes + pos - string_start), false);
+ string_start = bytes + pos + 1;
+ }
+ if (vt->parser.emit_nul) {
+ do_control(vt, c);
+ }
+ continue;
+ }
+ if (c == 0x18 || c == 0x1a) { // CAN, SUB
+ vt->parser.in_esc = false;
+ ENTER_NORMAL_STATE();
+ if (vt->parser.emit_nul) {
+ do_control(vt, c);
+ }
+ continue;
+ } else if (c == 0x1b) { // ESC
+ vt->parser.intermedlen = 0;
+ if (!IS_STRING_STATE()) {
+ vt->parser.state = NORMAL;
+ }
+ vt->parser.in_esc = true;
+ continue;
+ } else if (c == 0x07 // BEL, can stand for ST in OSC or DCS state
+ && IS_STRING_STATE()) {} else if (c < 0x20) { // other C0
+ if (vt->parser.state == SOS) {
+ continue; // All other C0s permitted in SOS
+ }
+ if (IS_STRING_STATE()) {
+ string_fragment(vt, string_start, (size_t)(bytes + pos - string_start), false);
+ }
+ do_control(vt, c);
+ if (IS_STRING_STATE()) {
+ string_start = bytes + pos + 1;
+ }
+ continue;
+ }
+
+ size_t string_len = (size_t)(bytes + pos - string_start);
+
+ if (vt->parser.in_esc) {
+ // Hoist an ESC letter into a C1 if we're not in a string mode
+ // Always accept ESC \ == ST even in string mode
+ if (!vt->parser.intermedlen
+ && c >= 0x40 && c < 0x60
+ && ((!IS_STRING_STATE() || c == 0x5c))) {
+ c += 0x40;
+ c1_allowed = true;
+ if (string_len) {
+ assert(string_len > 0);
+ string_len -= 1;
+ }
+ vt->parser.in_esc = false;
+ } else {
+ string_start = NULL;
+ vt->parser.state = NORMAL;
+ }
+ }
+
+ switch (vt->parser.state) {
+ case CSI_LEADER:
+ // Extract leader bytes 0x3c to 0x3f
+ if (c >= 0x3c && c <= 0x3f) {
+ if (vt->parser.v.csi.leaderlen < CSI_LEADER_MAX - 1) {
+ vt->parser.v.csi.leader[vt->parser.v.csi.leaderlen++] = (char)c;
+ }
+ break;
+ }
+
+ vt->parser.v.csi.leader[vt->parser.v.csi.leaderlen] = 0;
+
+ vt->parser.v.csi.argi = 0;
+ vt->parser.v.csi.args[0] = CSI_ARG_MISSING;
+ vt->parser.state = CSI_ARGS;
+
+ FALLTHROUGH;
+ case CSI_ARGS:
+ // Numerical value of argument
+ if (c >= '0' && c <= '9') {
+ if (vt->parser.v.csi.args[vt->parser.v.csi.argi] == CSI_ARG_MISSING) {
+ vt->parser.v.csi.args[vt->parser.v.csi.argi] = 0;
+ }
+ vt->parser.v.csi.args[vt->parser.v.csi.argi] *= 10;
+ vt->parser.v.csi.args[vt->parser.v.csi.argi] += c - '0';
+ break;
+ }
+ if (c == ':') {
+ vt->parser.v.csi.args[vt->parser.v.csi.argi] |= CSI_ARG_FLAG_MORE;
+ c = ';';
+ }
+ if (c == ';') {
+ vt->parser.v.csi.argi++;
+ vt->parser.v.csi.args[vt->parser.v.csi.argi] = CSI_ARG_MISSING;
+ break;
+ }
+
+ vt->parser.v.csi.argi++;
+ vt->parser.intermedlen = 0;
+ vt->parser.state = CSI_INTERMED;
+ FALLTHROUGH;
+ case CSI_INTERMED:
+ if (is_intermed(c)) {
+ if (vt->parser.intermedlen < INTERMED_MAX - 1) {
+ vt->parser.intermed[vt->parser.intermedlen++] = (char)c;
+ }
+ break;
+ } else if (c == 0x1b) {
+ // ESC in CSI cancels
+ } else if (c >= 0x40 && c <= 0x7e) {
+ vt->parser.intermed[vt->parser.intermedlen] = 0;
+ do_csi(vt, (char)c);
+ }
+ // else was invalid CSI
+
+ ENTER_NORMAL_STATE();
+ break;
+
+ case OSC_COMMAND:
+ // Numerical value of command
+ if (c >= '0' && c <= '9') {
+ if (vt->parser.v.osc.command == -1) {
+ vt->parser.v.osc.command = 0;
+ } else {
+ vt->parser.v.osc.command *= 10;
+ }
+ vt->parser.v.osc.command += c - '0';
+ break;
+ }
+ if (c == ';') {
+ vt->parser.state = OSC;
+ string_start = bytes + pos + 1;
+ break;
+ }
+
+ string_start = bytes + pos;
+ string_len = 0;
+ vt->parser.state = OSC;
+ goto string_state;
+
+ case DCS_COMMAND:
+ if (vt->parser.v.dcs.commandlen < CSI_LEADER_MAX) {
+ vt->parser.v.dcs.command[vt->parser.v.dcs.commandlen++] = (char)c;
+ }
+
+ if (c >= 0x40 && c <= 0x7e) {
+ string_start = bytes + pos + 1;
+ vt->parser.state = DCS_VTERM;
+ }
+ break;
+
+string_state:
+ case OSC:
+ case DCS_VTERM:
+ case APC:
+ case PM:
+ case SOS:
+ if (c == 0x07 || (c1_allowed && c == 0x9c)) {
+ string_fragment(vt, string_start, string_len, true);
+ ENTER_NORMAL_STATE();
+ }
+ break;
+
+ case NORMAL:
+ if (vt->parser.in_esc) {
+ if (is_intermed(c)) {
+ if (vt->parser.intermedlen < INTERMED_MAX - 1) {
+ vt->parser.intermed[vt->parser.intermedlen++] = (char)c;
+ }
+ } else if (c >= 0x30 && c < 0x7f) {
+ do_escape(vt, (char)c);
+ vt->parser.in_esc = 0;
+ ENTER_NORMAL_STATE();
+ } else {
+ DEBUG_LOG("TODO: Unhandled byte %02x in Escape\n", c);
+ }
+ break;
+ }
+ if (c1_allowed && c >= 0x80 && c < 0xa0) {
+ switch (c) {
+ case 0x90: // DCS
+ vt->parser.string_initial = true;
+ vt->parser.v.dcs.commandlen = 0;
+ ENTER_STATE(DCS_COMMAND);
+ break;
+ case 0x98: // SOS
+ vt->parser.string_initial = true;
+ ENTER_STATE(SOS);
+ string_start = bytes + pos + 1;
+ break;
+ case 0x9b: // CSI
+ vt->parser.v.csi.leaderlen = 0;
+ ENTER_STATE(CSI_LEADER);
+ break;
+ case 0x9d: // OSC
+ vt->parser.v.osc.command = -1;
+ vt->parser.string_initial = true;
+ ENTER_STATE(OSC_COMMAND);
+ break;
+ case 0x9e: // PM
+ vt->parser.string_initial = true;
+ ENTER_STATE(PM);
+ string_start = bytes + pos + 1;
+ break;
+ case 0x9f: // APC
+ vt->parser.string_initial = true;
+ ENTER_STATE(APC);
+ string_start = bytes + pos + 1;
+ break;
+ default:
+ do_control(vt, c);
+ break;
+ }
+ } else {
+ size_t eaten = 0;
+ if (vt->parser.callbacks && vt->parser.callbacks->text) {
+ eaten = (size_t)(*vt->parser.callbacks->text)(bytes + pos, len - pos, vt->parser.cbdata);
+ }
+
+ if (!eaten) {
+ DEBUG_LOG("libvterm: Text callback did not consume any input\n");
+ // force it to make progress
+ eaten = 1;
+ }
+
+ pos += (eaten - 1); // we'll ++ it again in a moment
+ }
+ break;
+ }
+ }
+
+ if (string_start) {
+ size_t string_len = (size_t)(bytes + pos - string_start);
+ if (string_len > 0) {
+ if (vt->parser.in_esc) {
+ string_len -= 1;
+ }
+ string_fragment(vt, string_start, string_len, false);
+ }
+ }
+
+ return len;
+}
+
+void vterm_parser_set_callbacks(VTerm *vt, const VTermParserCallbacks *callbacks, void *user)
+{
+ vt->parser.callbacks = callbacks;
+ vt->parser.cbdata = user;
+}
diff --git a/src/nvim/vterm/parser.h b/src/nvim/vterm/parser.h
new file mode 100644
index 0000000000..168be830c0
--- /dev/null
+++ b/src/nvim/vterm/parser.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <stddef.h>
+
+#include "nvim/vterm/vterm_defs.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "vterm/parser.h.generated.h"
+#endif
diff --git a/src/nvim/vterm/pen.c b/src/nvim/vterm/pen.c
new file mode 100644
index 0000000000..e7f50078ae
--- /dev/null
+++ b/src/nvim/vterm/pen.c
@@ -0,0 +1,644 @@
+#include <stdio.h>
+
+#include "nvim/vterm/pen.h"
+#include "nvim/vterm/vterm.h"
+#include "nvim/vterm/vterm_internal_defs.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "vterm/pen.c.generated.h"
+#endif
+
+// Structure used to store RGB triples without the additional metadata stored in VTermColor.
+typedef struct {
+ uint8_t red, green, blue;
+} VTermRGB;
+
+static const VTermRGB ansi_colors[] = {
+ // R G B
+ { 0, 0, 0 }, // black
+ { 224, 0, 0 }, // red
+ { 0, 224, 0 }, // green
+ { 224, 224, 0 }, // yellow
+ { 0, 0, 224 }, // blue
+ { 224, 0, 224 }, // magenta
+ { 0, 224, 224 }, // cyan
+ { 224, 224, 224 }, // white == light grey
+
+ // high intensity
+ { 128, 128, 128 }, // black
+ { 255, 64, 64 }, // red
+ { 64, 255, 64 }, // green
+ { 255, 255, 64 }, // yellow
+ { 64, 64, 255 }, // blue
+ { 255, 64, 255 }, // magenta
+ { 64, 255, 255 }, // cyan
+ { 255, 255, 255 }, // white for real
+};
+
+static uint8_t ramp6[] = {
+ 0x00, 0x33, 0x66, 0x99, 0xCC, 0xFF,
+};
+
+static uint8_t ramp24[] = {
+ 0x00, 0x0B, 0x16, 0x21, 0x2C, 0x37, 0x42, 0x4D, 0x58, 0x63, 0x6E, 0x79,
+ 0x85, 0x90, 0x9B, 0xA6, 0xB1, 0xBC, 0xC7, 0xD2, 0xDD, 0xE8, 0xF3, 0xFF,
+};
+
+static void lookup_default_colour_ansi(long idx, VTermColor *col)
+{
+ if (idx >= 0 && idx < 16) {
+ vterm_color_rgb(col,
+ ansi_colors[idx].red, ansi_colors[idx].green, ansi_colors[idx].blue);
+ }
+}
+
+static bool lookup_colour_ansi(const VTermState *state, long index, VTermColor *col)
+{
+ if (index >= 0 && index < 16) {
+ *col = state->colors[index];
+ return true;
+ }
+
+ return false;
+}
+
+static bool lookup_colour_palette(const VTermState *state, long index, VTermColor *col)
+{
+ if (index >= 0 && index < 16) {
+ // Normal 8 colours or high intensity - parse as palette 0
+ return lookup_colour_ansi(state, index, col);
+ } else if (index >= 16 && index < 232) {
+ // 216-colour cube
+ index -= 16;
+
+ vterm_color_rgb(col, ramp6[index/6/6 % 6],
+ ramp6[index/6 % 6],
+ ramp6[index % 6]);
+
+ return true;
+ } else if (index >= 232 && index < 256) {
+ // 24 greyscales
+ index -= 232;
+
+ vterm_color_rgb(col, ramp24[index], ramp24[index], ramp24[index]);
+
+ return true;
+ }
+
+ return false;
+}
+
+static int lookup_colour(const VTermState *state, int palette, const long args[], int argcount,
+ VTermColor *col)
+{
+ switch (palette) {
+ case 2: // RGB mode - 3 args contain colour values directly
+ if (argcount < 3) {
+ return argcount;
+ }
+
+ vterm_color_rgb(col, (uint8_t)CSI_ARG(args[0]), (uint8_t)CSI_ARG(args[1]),
+ (uint8_t)CSI_ARG(args[2]));
+
+ return 3;
+
+ case 5: // XTerm 256-colour mode
+ if (!argcount || CSI_ARG_IS_MISSING(args[0])) {
+ return argcount ? 1 : 0;
+ }
+
+ vterm_color_indexed(col, (uint8_t)args[0]);
+
+ return argcount ? 1 : 0;
+
+ default:
+ DEBUG_LOG("Unrecognised colour palette %d\n", palette);
+ return 0;
+ }
+}
+
+// Some conveniences
+
+static void setpenattr(VTermState *state, VTermAttr attr, VTermValueType type, VTermValue *val)
+{
+#ifdef DEBUG
+ if (type != vterm_get_attr_type(attr)) {
+ DEBUG_LOG("Cannot set attr %d as it has type %d, not type %d\n",
+ attr, vterm_get_attr_type(attr), type);
+ return;
+ }
+#endif
+ if (state->callbacks && state->callbacks->setpenattr) {
+ (*state->callbacks->setpenattr)(attr, val, state->cbdata);
+ }
+}
+
+static void setpenattr_bool(VTermState *state, VTermAttr attr, int boolean)
+{
+ VTermValue val = { .boolean = boolean };
+ setpenattr(state, attr, VTERM_VALUETYPE_BOOL, &val);
+}
+
+static void setpenattr_int(VTermState *state, VTermAttr attr, int number)
+{
+ VTermValue val = { .number = number };
+ setpenattr(state, attr, VTERM_VALUETYPE_INT, &val);
+}
+
+static void setpenattr_col(VTermState *state, VTermAttr attr, VTermColor color)
+{
+ VTermValue val = { .color = color };
+ setpenattr(state, attr, VTERM_VALUETYPE_COLOR, &val);
+}
+
+static void set_pen_col_ansi(VTermState *state, VTermAttr attr, long col)
+{
+ VTermColor *colp = (attr == VTERM_ATTR_BACKGROUND) ? &state->pen.bg : &state->pen.fg;
+
+ vterm_color_indexed(colp, (uint8_t)col);
+
+ setpenattr_col(state, attr, *colp);
+}
+
+void vterm_state_newpen(VTermState *state)
+{
+ // 90% grey so that pure white is brighter
+ vterm_color_rgb(&state->default_fg, 240, 240, 240);
+ vterm_color_rgb(&state->default_bg, 0, 0, 0);
+ vterm_state_set_default_colors(state, &state->default_fg, &state->default_bg);
+
+ for (int col = 0; col < 16; col++) {
+ lookup_default_colour_ansi(col, &state->colors[col]);
+ }
+}
+
+void vterm_state_resetpen(VTermState *state)
+{
+ state->pen.bold = 0; setpenattr_bool(state, VTERM_ATTR_BOLD, 0);
+ state->pen.underline = 0; setpenattr_int(state, VTERM_ATTR_UNDERLINE, 0);
+ state->pen.italic = 0; setpenattr_bool(state, VTERM_ATTR_ITALIC, 0);
+ state->pen.blink = 0; setpenattr_bool(state, VTERM_ATTR_BLINK, 0);
+ state->pen.reverse = 0; setpenattr_bool(state, VTERM_ATTR_REVERSE, 0);
+ state->pen.conceal = 0; setpenattr_bool(state, VTERM_ATTR_CONCEAL, 0);
+ state->pen.strike = 0; setpenattr_bool(state, VTERM_ATTR_STRIKE, 0);
+ state->pen.font = 0; setpenattr_int(state, VTERM_ATTR_FONT, 0);
+ state->pen.small = 0; setpenattr_bool(state, VTERM_ATTR_SMALL, 0);
+ state->pen.baseline = 0; setpenattr_int(state, VTERM_ATTR_BASELINE, 0);
+
+ state->pen.fg = state->default_fg;
+ setpenattr_col(state, VTERM_ATTR_FOREGROUND, state->default_fg);
+ state->pen.bg = state->default_bg;
+ setpenattr_col(state, VTERM_ATTR_BACKGROUND, state->default_bg);
+
+ state->pen.uri = 0; setpenattr_int(state, VTERM_ATTR_URI, 0);
+}
+
+void vterm_state_savepen(VTermState *state, int save)
+{
+ if (save) {
+ state->saved.pen = state->pen;
+ } else {
+ state->pen = state->saved.pen;
+
+ setpenattr_bool(state, VTERM_ATTR_BOLD, state->pen.bold);
+ setpenattr_int(state, VTERM_ATTR_UNDERLINE, state->pen.underline);
+ setpenattr_bool(state, VTERM_ATTR_ITALIC, state->pen.italic);
+ setpenattr_bool(state, VTERM_ATTR_BLINK, state->pen.blink);
+ setpenattr_bool(state, VTERM_ATTR_REVERSE, state->pen.reverse);
+ setpenattr_bool(state, VTERM_ATTR_CONCEAL, state->pen.conceal);
+ setpenattr_bool(state, VTERM_ATTR_STRIKE, state->pen.strike);
+ setpenattr_int(state, VTERM_ATTR_FONT, state->pen.font);
+ setpenattr_bool(state, VTERM_ATTR_SMALL, state->pen.small);
+ setpenattr_int(state, VTERM_ATTR_BASELINE, state->pen.baseline);
+
+ setpenattr_col(state, VTERM_ATTR_FOREGROUND, state->pen.fg);
+ setpenattr_col(state, VTERM_ATTR_BACKGROUND, state->pen.bg);
+
+ setpenattr_int(state, VTERM_ATTR_URI, state->pen.uri);
+ }
+}
+
+void vterm_state_set_default_colors(VTermState *state, const VTermColor *default_fg,
+ const VTermColor *default_bg)
+{
+ if (default_fg) {
+ state->default_fg = *default_fg;
+ state->default_fg.type = (state->default_fg.type & ~VTERM_COLOR_DEFAULT_MASK)
+ | VTERM_COLOR_DEFAULT_FG;
+ }
+
+ if (default_bg) {
+ state->default_bg = *default_bg;
+ state->default_bg.type = (state->default_bg.type & ~VTERM_COLOR_DEFAULT_MASK)
+ | VTERM_COLOR_DEFAULT_BG;
+ }
+}
+
+void vterm_state_set_palette_color(VTermState *state, int index, const VTermColor *col)
+{
+ if (index >= 0 && index < 16) {
+ state->colors[index] = *col;
+ }
+}
+
+/// Makes sure that the given color `col` is indeed an RGB colour. After this
+/// function returns, VTERM_COLOR_IS_RGB(col) will return true, while all other
+/// flags stored in `col->type` will have been reset.
+///
+/// @param state is the VTermState instance from which the colour palette should
+/// be extracted.
+/// @param col is a pointer at the VTermColor instance that should be converted
+/// to an RGB colour.
+void vterm_state_convert_color_to_rgb(const VTermState *state, VTermColor *col)
+{
+ if (VTERM_COLOR_IS_INDEXED(col)) { // Convert indexed colors to RGB
+ lookup_colour_palette(state, col->indexed.idx, col);
+ }
+ col->type &= VTERM_COLOR_TYPE_MASK; // Reset any metadata but the type
+}
+
+void vterm_state_setpen(VTermState *state, const long args[], int argcount)
+{
+ // SGR - ECMA-48 8.3.117
+
+ int argi = 0;
+ int value;
+
+ while (argi < argcount) {
+ // This logic is easier to do 'done' backwards; set it true, and make it
+ // false again in the 'default' case
+ int done = 1;
+
+ long arg;
+ switch (arg = CSI_ARG(args[argi])) {
+ case CSI_ARG_MISSING:
+ case 0: // Reset
+ vterm_state_resetpen(state);
+ break;
+
+ case 1: { // Bold on
+ const VTermColor *fg = &state->pen.fg;
+ state->pen.bold = 1;
+ setpenattr_bool(state, VTERM_ATTR_BOLD, 1);
+ if (!VTERM_COLOR_IS_DEFAULT_FG(fg) && VTERM_COLOR_IS_INDEXED(fg) && fg->indexed.idx < 8
+ && state->bold_is_highbright) {
+ set_pen_col_ansi(state, VTERM_ATTR_FOREGROUND, fg->indexed.idx + (state->pen.bold ? 8 : 0));
+ }
+ break;
+ }
+
+ case 3: // Italic on
+ state->pen.italic = 1;
+ setpenattr_bool(state, VTERM_ATTR_ITALIC, 1);
+ break;
+
+ case 4: // Underline
+ state->pen.underline = VTERM_UNDERLINE_SINGLE;
+ if (CSI_ARG_HAS_MORE(args[argi])) {
+ argi++;
+ switch (CSI_ARG(args[argi])) {
+ case 0:
+ state->pen.underline = 0;
+ break;
+ case 1:
+ state->pen.underline = VTERM_UNDERLINE_SINGLE;
+ break;
+ case 2:
+ state->pen.underline = VTERM_UNDERLINE_DOUBLE;
+ break;
+ case 3:
+ state->pen.underline = VTERM_UNDERLINE_CURLY;
+ break;
+ }
+ }
+ setpenattr_int(state, VTERM_ATTR_UNDERLINE, state->pen.underline);
+ break;
+
+ case 5: // Blink
+ state->pen.blink = 1;
+ setpenattr_bool(state, VTERM_ATTR_BLINK, 1);
+ break;
+
+ case 7: // Reverse on
+ state->pen.reverse = 1;
+ setpenattr_bool(state, VTERM_ATTR_REVERSE, 1);
+ break;
+
+ case 8: // Conceal on
+ state->pen.conceal = 1;
+ setpenattr_bool(state, VTERM_ATTR_CONCEAL, 1);
+ break;
+
+ case 9: // Strikethrough on
+ state->pen.strike = 1;
+ setpenattr_bool(state, VTERM_ATTR_STRIKE, 1);
+ break;
+
+ case 10:
+ case 11:
+ case 12:
+ case 13:
+ case 14:
+ case 15:
+ case 16:
+ case 17:
+ case 18:
+ case 19: // Select font
+ state->pen.font = CSI_ARG(args[argi]) - 10;
+ setpenattr_int(state, VTERM_ATTR_FONT, state->pen.font);
+ break;
+
+ case 21: // Underline double
+ state->pen.underline = VTERM_UNDERLINE_DOUBLE;
+ setpenattr_int(state, VTERM_ATTR_UNDERLINE, state->pen.underline);
+ break;
+
+ case 22: // Bold off
+ state->pen.bold = 0;
+ setpenattr_bool(state, VTERM_ATTR_BOLD, 0);
+ break;
+
+ case 23: // Italic and Gothic (currently unsupported) off
+ state->pen.italic = 0;
+ setpenattr_bool(state, VTERM_ATTR_ITALIC, 0);
+ break;
+
+ case 24: // Underline off
+ state->pen.underline = 0;
+ setpenattr_int(state, VTERM_ATTR_UNDERLINE, 0);
+ break;
+
+ case 25: // Blink off
+ state->pen.blink = 0;
+ setpenattr_bool(state, VTERM_ATTR_BLINK, 0);
+ break;
+
+ case 27: // Reverse off
+ state->pen.reverse = 0;
+ setpenattr_bool(state, VTERM_ATTR_REVERSE, 0);
+ break;
+
+ case 28: // Conceal off (Reveal)
+ state->pen.conceal = 0;
+ setpenattr_bool(state, VTERM_ATTR_CONCEAL, 0);
+ break;
+
+ case 29: // Strikethrough off
+ state->pen.strike = 0;
+ setpenattr_bool(state, VTERM_ATTR_STRIKE, 0);
+ break;
+
+ case 30:
+ case 31:
+ case 32:
+ case 33:
+ case 34:
+ case 35:
+ case 36:
+ case 37: // Foreground colour palette
+ value = CSI_ARG(args[argi]) - 30;
+ if (state->pen.bold && state->bold_is_highbright) {
+ value += 8;
+ }
+ set_pen_col_ansi(state, VTERM_ATTR_FOREGROUND, value);
+ break;
+
+ case 38: // Foreground colour alternative palette
+ if (argcount - argi < 1) {
+ return;
+ }
+ argi += 1 + lookup_colour(state, CSI_ARG(args[argi + 1]), args + argi + 2,
+ argcount - argi - 2, &state->pen.fg);
+ setpenattr_col(state, VTERM_ATTR_FOREGROUND, state->pen.fg);
+ break;
+
+ case 39: // Foreground colour default
+ state->pen.fg = state->default_fg;
+ setpenattr_col(state, VTERM_ATTR_FOREGROUND, state->pen.fg);
+ break;
+
+ case 40:
+ case 41:
+ case 42:
+ case 43:
+ case 44:
+ case 45:
+ case 46:
+ case 47: // Background colour palette
+ value = CSI_ARG(args[argi]) - 40;
+ set_pen_col_ansi(state, VTERM_ATTR_BACKGROUND, value);
+ break;
+
+ case 48: // Background colour alternative palette
+ if (argcount - argi < 1) {
+ return;
+ }
+ argi += 1 + lookup_colour(state, CSI_ARG(args[argi + 1]), args + argi + 2,
+ argcount - argi - 2, &state->pen.bg);
+ setpenattr_col(state, VTERM_ATTR_BACKGROUND, state->pen.bg);
+ break;
+
+ case 49: // Default background
+ state->pen.bg = state->default_bg;
+ setpenattr_col(state, VTERM_ATTR_BACKGROUND, state->pen.bg);
+ break;
+
+ case 73: // Superscript
+ case 74: // Subscript
+ case 75: // Superscript/subscript off
+ state->pen.small = (arg != 75);
+ state->pen.baseline =
+ (arg == 73) ? VTERM_BASELINE_RAISE
+ : (arg == 74) ? VTERM_BASELINE_LOWER
+ : VTERM_BASELINE_NORMAL;
+ setpenattr_bool(state, VTERM_ATTR_SMALL, state->pen.small);
+ setpenattr_int(state, VTERM_ATTR_BASELINE, state->pen.baseline);
+ break;
+
+ case 90:
+ case 91:
+ case 92:
+ case 93:
+ case 94:
+ case 95:
+ case 96:
+ case 97: // Foreground colour high-intensity palette
+ value = CSI_ARG(args[argi]) - 90 + 8;
+ set_pen_col_ansi(state, VTERM_ATTR_FOREGROUND, value);
+ break;
+
+ case 100:
+ case 101:
+ case 102:
+ case 103:
+ case 104:
+ case 105:
+ case 106:
+ case 107: // Background colour high-intensity palette
+ value = CSI_ARG(args[argi]) - 100 + 8;
+ set_pen_col_ansi(state, VTERM_ATTR_BACKGROUND, value);
+ break;
+
+ default:
+ done = 0;
+ break;
+ }
+
+ if (!done) {
+ DEBUG_LOG("libvterm: Unhandled CSI SGR %ld\n", arg);
+ }
+
+ while (CSI_ARG_HAS_MORE(args[argi++])) {}
+ }
+}
+
+static int vterm_state_getpen_color(const VTermColor *col, int argi, long args[], int fg)
+{
+ // Do nothing if the given color is the default color
+ if ((fg && VTERM_COLOR_IS_DEFAULT_FG(col))
+ || (!fg && VTERM_COLOR_IS_DEFAULT_BG(col))) {
+ return argi;
+ }
+
+ // Decide whether to send an indexed color or an RGB color
+ if (VTERM_COLOR_IS_INDEXED(col)) {
+ const uint8_t idx = col->indexed.idx;
+ if (idx < 8) {
+ args[argi++] = (idx + (fg ? 30 : 40));
+ } else if (idx < 16) {
+ args[argi++] = (idx - 8 + (fg ? 90 : 100));
+ } else {
+ args[argi++] = CSI_ARG_FLAG_MORE | (fg ? 38 : 48);
+ args[argi++] = CSI_ARG_FLAG_MORE | 5;
+ args[argi++] = idx;
+ }
+ } else if (VTERM_COLOR_IS_RGB(col)) {
+ args[argi++] = CSI_ARG_FLAG_MORE | (fg ? 38 : 48);
+ args[argi++] = CSI_ARG_FLAG_MORE | 2;
+ args[argi++] = CSI_ARG_FLAG_MORE | col->rgb.red;
+ args[argi++] = CSI_ARG_FLAG_MORE | col->rgb.green;
+ args[argi++] = col->rgb.blue;
+ }
+ return argi;
+}
+
+int vterm_state_getpen(VTermState *state, long args[], int argcount)
+{
+ int argi = 0;
+
+ if (state->pen.bold) {
+ args[argi++] = 1;
+ }
+
+ if (state->pen.italic) {
+ args[argi++] = 3;
+ }
+
+ if (state->pen.underline == VTERM_UNDERLINE_SINGLE) {
+ args[argi++] = 4;
+ }
+ if (state->pen.underline == VTERM_UNDERLINE_CURLY) {
+ args[argi++] = 4 | CSI_ARG_FLAG_MORE, args[argi++] = 3;
+ }
+
+ if (state->pen.blink) {
+ args[argi++] = 5;
+ }
+
+ if (state->pen.reverse) {
+ args[argi++] = 7;
+ }
+
+ if (state->pen.conceal) {
+ args[argi++] = 8;
+ }
+
+ if (state->pen.strike) {
+ args[argi++] = 9;
+ }
+
+ if (state->pen.font) {
+ args[argi++] = 10 + state->pen.font;
+ }
+
+ if (state->pen.underline == VTERM_UNDERLINE_DOUBLE) {
+ args[argi++] = 21;
+ }
+
+ argi = vterm_state_getpen_color(&state->pen.fg, argi, args, true);
+
+ argi = vterm_state_getpen_color(&state->pen.bg, argi, args, false);
+
+ if (state->pen.small) {
+ if (state->pen.baseline == VTERM_BASELINE_RAISE) {
+ args[argi++] = 73;
+ } else if (state->pen.baseline == VTERM_BASELINE_LOWER) {
+ args[argi++] = 74;
+ }
+ }
+
+ return argi;
+}
+
+int vterm_state_set_penattr(VTermState *state, VTermAttr attr, VTermValueType type, VTermValue *val)
+{
+ if (!val) {
+ return 0;
+ }
+
+ if (type != vterm_get_attr_type(attr)) {
+ DEBUG_LOG("Cannot set attr %d as it has type %d, not type %d\n",
+ attr, vterm_get_attr_type(attr), type);
+ return 0;
+ }
+
+ switch (attr) {
+ case VTERM_ATTR_BOLD:
+ state->pen.bold = (unsigned)val->boolean;
+ break;
+ case VTERM_ATTR_UNDERLINE:
+ state->pen.underline = (unsigned)val->number;
+ break;
+ case VTERM_ATTR_ITALIC:
+ state->pen.italic = (unsigned)val->boolean;
+ break;
+ case VTERM_ATTR_BLINK:
+ state->pen.blink = (unsigned)val->boolean;
+ break;
+ case VTERM_ATTR_REVERSE:
+ state->pen.reverse = (unsigned)val->boolean;
+ break;
+ case VTERM_ATTR_CONCEAL:
+ state->pen.conceal = (unsigned)val->boolean;
+ break;
+ case VTERM_ATTR_STRIKE:
+ state->pen.strike = (unsigned)val->boolean;
+ break;
+ case VTERM_ATTR_FONT:
+ state->pen.font = (unsigned)val->number;
+ break;
+ case VTERM_ATTR_FOREGROUND:
+ state->pen.fg = val->color;
+ break;
+ case VTERM_ATTR_BACKGROUND:
+ state->pen.bg = val->color;
+ break;
+ case VTERM_ATTR_SMALL:
+ state->pen.small = (unsigned)val->boolean;
+ break;
+ case VTERM_ATTR_BASELINE:
+ state->pen.baseline = (unsigned)val->number;
+ break;
+ case VTERM_ATTR_URI:
+ state->pen.uri = val->number;
+ break;
+ default:
+ return 0;
+ }
+
+ if (state->callbacks && state->callbacks->setpenattr) {
+ (*state->callbacks->setpenattr)(attr, val, state->cbdata);
+ }
+
+ return 1;
+}
diff --git a/src/nvim/vterm/pen.h b/src/nvim/vterm/pen.h
new file mode 100644
index 0000000000..c5f5217420
--- /dev/null
+++ b/src/nvim/vterm/pen.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <stddef.h>
+
+#include "nvim/vterm/vterm_defs.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "vterm/pen.h.generated.h"
+#endif
diff --git a/src/nvim/vterm/screen.c b/src/nvim/vterm/screen.c
new file mode 100644
index 0000000000..45bd5e2a27
--- /dev/null
+++ b/src/nvim/vterm/screen.c
@@ -0,0 +1,1115 @@
+#include <stdio.h>
+#include <string.h>
+
+#include "nvim/grid.h"
+#include "nvim/mbyte.h"
+#include "nvim/tui/termkey/termkey.h"
+#include "nvim/vterm/pen.h"
+#include "nvim/vterm/screen.h"
+#include "nvim/vterm/state.h"
+#include "nvim/vterm/vterm.h"
+#include "nvim/vterm/vterm_defs.h"
+#include "nvim/vterm/vterm_internal_defs.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "vterm/screen.c.generated.h"
+#endif
+
+#define UNICODE_SPACE 0x20
+#define UNICODE_LINEFEED 0x0a
+
+#undef DEBUG_REFLOW
+
+static inline void clearcell(const VTermScreen *screen, ScreenCell *cell)
+{
+ cell->schar = 0;
+ cell->pen = screen->pen;
+}
+
+ScreenCell *getcell(const VTermScreen *screen, int row, int col)
+{
+ if (row < 0 || row >= screen->rows) {
+ return NULL;
+ }
+ if (col < 0 || col >= screen->cols) {
+ return NULL;
+ }
+ return screen->buffer + (screen->cols * row) + col;
+}
+
+static ScreenCell *alloc_buffer(VTermScreen *screen, int rows, int cols)
+{
+ ScreenCell *new_buffer = vterm_allocator_malloc(screen->vt,
+ sizeof(ScreenCell) * (size_t)rows * (size_t)cols);
+
+ for (int row = 0; row < rows; row++) {
+ for (int col = 0; col < cols; col++) {
+ clearcell(screen, &new_buffer[row * cols + col]);
+ }
+ }
+
+ return new_buffer;
+}
+
+static void damagerect(VTermScreen *screen, VTermRect rect)
+{
+ VTermRect emit;
+
+ switch (screen->damage_merge) {
+ case VTERM_DAMAGE_CELL:
+ // Always emit damage event
+ emit = rect;
+ break;
+
+ case VTERM_DAMAGE_ROW:
+ // Emit damage longer than one row. Try to merge with existing damage in the same row
+ if (rect.end_row > rect.start_row + 1) {
+ // Bigger than 1 line - flush existing, emit this
+ vterm_screen_flush_damage(screen);
+ emit = rect;
+ } else if (screen->damaged.start_row == -1) {
+ // None stored yet
+ screen->damaged = rect;
+ return;
+ } else if (rect.start_row == screen->damaged.start_row) {
+ // Merge with the stored line
+ if (screen->damaged.start_col > rect.start_col) {
+ screen->damaged.start_col = rect.start_col;
+ }
+ if (screen->damaged.end_col < rect.end_col) {
+ screen->damaged.end_col = rect.end_col;
+ }
+ return;
+ } else {
+ // Emit the currently stored line, store a new one
+ emit = screen->damaged;
+ screen->damaged = rect;
+ }
+ break;
+
+ case VTERM_DAMAGE_SCREEN:
+ case VTERM_DAMAGE_SCROLL:
+ // Never emit damage event
+ if (screen->damaged.start_row == -1) {
+ screen->damaged = rect;
+ } else {
+ rect_expand(&screen->damaged, &rect);
+ }
+ return;
+
+ default:
+ DEBUG_LOG("TODO: Maybe merge damage for level %d\n", screen->damage_merge);
+ return;
+ }
+
+ if (screen->callbacks && screen->callbacks->damage) {
+ (*screen->callbacks->damage)(emit, screen->cbdata);
+ }
+}
+
+static void damagescreen(VTermScreen *screen)
+{
+ VTermRect rect = {
+ .start_row = 0,
+ .end_row = screen->rows,
+ .start_col = 0,
+ .end_col = screen->cols,
+ };
+
+ damagerect(screen, rect);
+}
+
+static int putglyph(VTermGlyphInfo *info, VTermPos pos, void *user)
+{
+ VTermScreen *screen = user;
+ ScreenCell *cell = getcell(screen, pos.row, pos.col);
+
+ if (!cell) {
+ return 0;
+ }
+
+ cell->schar = info->schar;
+ if (info->schar != 0) {
+ cell->pen = screen->pen;
+ }
+
+ for (int col = 1; col < info->width; col++) {
+ getcell(screen, pos.row, pos.col + col)->schar = (uint32_t)-1;
+ }
+
+ VTermRect rect = {
+ .start_row = pos.row,
+ .end_row = pos.row + 1,
+ .start_col = pos.col,
+ .end_col = pos.col + info->width,
+ };
+
+ cell->pen.protected_cell = info->protected_cell;
+ cell->pen.dwl = info->dwl;
+ cell->pen.dhl = info->dhl;
+
+ damagerect(screen, rect);
+
+ return 1;
+}
+
+static void sb_pushline_from_row(VTermScreen *screen, int row)
+{
+ VTermPos pos = { .row = row };
+ for (pos.col = 0; pos.col < screen->cols; pos.col++) {
+ vterm_screen_get_cell(screen, pos, screen->sb_buffer + pos.col);
+ }
+
+ (screen->callbacks->sb_pushline)(screen->cols, screen->sb_buffer, screen->cbdata);
+}
+
+static int moverect_internal(VTermRect dest, VTermRect src, void *user)
+{
+ VTermScreen *screen = user;
+
+ if (screen->callbacks && screen->callbacks->sb_pushline
+ && dest.start_row == 0 && dest.start_col == 0 // starts top-left corner
+ && dest.end_col == screen->cols // full width
+ && screen->buffer == screen->buffers[BUFIDX_PRIMARY]) { // not altscreen
+ for (int row = 0; row < src.start_row; row++) {
+ sb_pushline_from_row(screen, row);
+ }
+ }
+
+ int cols = src.end_col - src.start_col;
+ int downward = src.start_row - dest.start_row;
+
+ int init_row, test_row, inc_row;
+ if (downward < 0) {
+ init_row = dest.end_row - 1;
+ test_row = dest.start_row - 1;
+ inc_row = -1;
+ } else {
+ init_row = dest.start_row;
+ test_row = dest.end_row;
+ inc_row = +1;
+ }
+
+ for (int row = init_row; row != test_row; row += inc_row) {
+ memmove(getcell(screen, row, dest.start_col),
+ getcell(screen, row + downward, src.start_col),
+ (size_t)cols * sizeof(ScreenCell));
+ }
+
+ return 1;
+}
+
+static int moverect_user(VTermRect dest, VTermRect src, void *user)
+{
+ VTermScreen *screen = user;
+
+ if (screen->callbacks && screen->callbacks->moverect) {
+ if (screen->damage_merge != VTERM_DAMAGE_SCROLL) {
+ // Avoid an infinite loop
+ vterm_screen_flush_damage(screen);
+ }
+
+ if ((*screen->callbacks->moverect)(dest, src, screen->cbdata)) {
+ return 1;
+ }
+ }
+
+ damagerect(screen, dest);
+
+ return 1;
+}
+
+static int erase_internal(VTermRect rect, int selective, void *user)
+{
+ VTermScreen *screen = user;
+
+ for (int row = rect.start_row; row < screen->state->rows && row < rect.end_row; row++) {
+ const VTermLineInfo *info = vterm_state_get_lineinfo(screen->state, row);
+
+ for (int col = rect.start_col; col < rect.end_col; col++) {
+ ScreenCell *cell = getcell(screen, row, col);
+
+ if (selective && cell->pen.protected_cell) {
+ continue;
+ }
+
+ cell->schar = 0;
+ cell->pen = (ScreenPen){
+ // Only copy .fg and .bg; leave things like rv in reset state
+ .fg = screen->pen.fg,
+ .bg = screen->pen.bg,
+ };
+ cell->pen.dwl = info->doublewidth;
+ cell->pen.dhl = info->doubleheight;
+ }
+ }
+
+ return 1;
+}
+
+static int erase_user(VTermRect rect, int selective, void *user)
+{
+ VTermScreen *screen = user;
+
+ damagerect(screen, rect);
+
+ return 1;
+}
+
+static int erase(VTermRect rect, int selective, void *user)
+{
+ erase_internal(rect, selective, user);
+ return erase_user(rect, 0, user);
+}
+
+static int scrollrect(VTermRect rect, int downward, int rightward, void *user)
+{
+ VTermScreen *screen = user;
+
+ if (screen->damage_merge != VTERM_DAMAGE_SCROLL) {
+ vterm_scroll_rect(rect, downward, rightward,
+ moverect_internal, erase_internal, screen);
+
+ vterm_screen_flush_damage(screen);
+
+ vterm_scroll_rect(rect, downward, rightward,
+ moverect_user, erase_user, screen);
+
+ return 1;
+ }
+
+ if (screen->damaged.start_row != -1
+ && !rect_intersects(&rect, &screen->damaged)) {
+ vterm_screen_flush_damage(screen);
+ }
+
+ if (screen->pending_scrollrect.start_row == -1) {
+ screen->pending_scrollrect = rect;
+ screen->pending_scroll_downward = downward;
+ screen->pending_scroll_rightward = rightward;
+ } else if (rect_equal(&screen->pending_scrollrect, &rect)
+ && ((screen->pending_scroll_downward == 0 && downward == 0)
+ || (screen->pending_scroll_rightward == 0 && rightward == 0))) {
+ screen->pending_scroll_downward += downward;
+ screen->pending_scroll_rightward += rightward;
+ } else {
+ vterm_screen_flush_damage(screen);
+
+ screen->pending_scrollrect = rect;
+ screen->pending_scroll_downward = downward;
+ screen->pending_scroll_rightward = rightward;
+ }
+
+ vterm_scroll_rect(rect, downward, rightward,
+ moverect_internal, erase_internal, screen);
+
+ if (screen->damaged.start_row == -1) {
+ return 1;
+ }
+
+ if (rect_contains(&rect, &screen->damaged)) {
+ // Scroll region entirely contains the damage; just move it
+ vterm_rect_move(&screen->damaged, -downward, -rightward);
+ rect_clip(&screen->damaged, &rect);
+ }
+ // There are a number of possible cases here, but lets restrict this to only the common case where
+ // we might actually gain some performance by optimising it. Namely, a vertical scroll that neatly
+ // cuts the damage region in half.
+ else if (rect.start_col <= screen->damaged.start_col
+ && rect.end_col >= screen->damaged.end_col
+ && rightward == 0) {
+ if (screen->damaged.start_row >= rect.start_row
+ && screen->damaged.start_row < rect.end_row) {
+ screen->damaged.start_row -= downward;
+ if (screen->damaged.start_row < rect.start_row) {
+ screen->damaged.start_row = rect.start_row;
+ }
+ if (screen->damaged.start_row > rect.end_row) {
+ screen->damaged.start_row = rect.end_row;
+ }
+ }
+ if (screen->damaged.end_row >= rect.start_row
+ && screen->damaged.end_row < rect.end_row) {
+ screen->damaged.end_row -= downward;
+ if (screen->damaged.end_row < rect.start_row) {
+ screen->damaged.end_row = rect.start_row;
+ }
+ if (screen->damaged.end_row > rect.end_row) {
+ screen->damaged.end_row = rect.end_row;
+ }
+ }
+ } else {
+ DEBUG_LOG("TODO: Just flush and redo damaged=" STRFrect " rect=" STRFrect "\n",
+ ARGSrect(screen->damaged), ARGSrect(rect));
+ }
+
+ return 1;
+}
+
+static int movecursor(VTermPos pos, VTermPos oldpos, int visible, void *user)
+{
+ VTermScreen *screen = user;
+
+ if (screen->callbacks && screen->callbacks->movecursor) {
+ return (*screen->callbacks->movecursor)(pos, oldpos, visible, screen->cbdata);
+ }
+
+ return 0;
+}
+
+static int setpenattr(VTermAttr attr, VTermValue *val, void *user)
+{
+ VTermScreen *screen = user;
+
+ switch (attr) {
+ case VTERM_ATTR_BOLD:
+ screen->pen.bold = (unsigned)val->boolean;
+ return 1;
+ case VTERM_ATTR_UNDERLINE:
+ screen->pen.underline = (unsigned)val->number;
+ return 1;
+ case VTERM_ATTR_ITALIC:
+ screen->pen.italic = (unsigned)val->boolean;
+ return 1;
+ case VTERM_ATTR_BLINK:
+ screen->pen.blink = (unsigned)val->boolean;
+ return 1;
+ case VTERM_ATTR_REVERSE:
+ screen->pen.reverse = (unsigned)val->boolean;
+ return 1;
+ case VTERM_ATTR_CONCEAL:
+ screen->pen.conceal = (unsigned)val->boolean;
+ return 1;
+ case VTERM_ATTR_STRIKE:
+ screen->pen.strike = (unsigned)val->boolean;
+ return 1;
+ case VTERM_ATTR_FONT:
+ screen->pen.font = (unsigned)val->number;
+ return 1;
+ case VTERM_ATTR_FOREGROUND:
+ screen->pen.fg = val->color;
+ return 1;
+ case VTERM_ATTR_BACKGROUND:
+ screen->pen.bg = val->color;
+ return 1;
+ case VTERM_ATTR_SMALL:
+ screen->pen.small = (unsigned)val->boolean;
+ return 1;
+ case VTERM_ATTR_BASELINE:
+ screen->pen.baseline = (unsigned)val->number;
+ return 1;
+ case VTERM_ATTR_URI:
+ screen->pen.uri = val->number;
+ return 1;
+
+ case VTERM_N_ATTRS:
+ return 0;
+ }
+
+ return 0;
+}
+
+static int settermprop(VTermProp prop, VTermValue *val, void *user)
+{
+ VTermScreen *screen = user;
+
+ switch (prop) {
+ case VTERM_PROP_ALTSCREEN:
+ if (val->boolean && !screen->buffers[BUFIDX_ALTSCREEN]) {
+ return 0;
+ }
+
+ screen->buffer =
+ val->boolean ? screen->buffers[BUFIDX_ALTSCREEN] : screen->buffers[BUFIDX_PRIMARY];
+ // only send a damage event on disable; because during enable there's an erase that sends a
+ // damage anyway
+ if (!val->boolean) {
+ damagescreen(screen);
+ }
+ break;
+ case VTERM_PROP_REVERSE:
+ screen->global_reverse = (unsigned)val->boolean;
+ damagescreen(screen);
+ break;
+ default:
+ ; // ignore
+ }
+
+ if (screen->callbacks && screen->callbacks->settermprop) {
+ return (*screen->callbacks->settermprop)(prop, val, screen->cbdata);
+ }
+
+ return 1;
+}
+
+static int bell(void *user)
+{
+ VTermScreen *screen = user;
+
+ if (screen->callbacks && screen->callbacks->bell) {
+ return (*screen->callbacks->bell)(screen->cbdata);
+ }
+
+ return 0;
+}
+
+/// How many cells are non-blank Returns the position of the first blank cell in the trailing blank
+/// end
+static int line_popcount(ScreenCell *buffer, int row, int rows, int cols)
+{
+ int col = cols - 1;
+ while (col >= 0 && buffer[row * cols + col].schar == 0) {
+ col--;
+ }
+ return col + 1;
+}
+
+static void resize_buffer(VTermScreen *screen, int bufidx, int new_rows, int new_cols, bool active,
+ VTermStateFields *statefields)
+{
+ int old_rows = screen->rows;
+ int old_cols = screen->cols;
+
+ ScreenCell *old_buffer = screen->buffers[bufidx];
+ VTermLineInfo *old_lineinfo = statefields->lineinfos[bufidx];
+
+ ScreenCell *new_buffer = vterm_allocator_malloc(screen->vt,
+ sizeof(ScreenCell) * (size_t)new_rows *
+ (size_t)new_cols);
+ VTermLineInfo *new_lineinfo = vterm_allocator_malloc(screen->vt,
+ sizeof(new_lineinfo[0]) * (size_t)new_rows);
+
+ int old_row = old_rows - 1;
+ int new_row = new_rows - 1;
+
+ VTermPos old_cursor = statefields->pos;
+ VTermPos new_cursor = { -1, -1 };
+
+#ifdef DEBUG_REFLOW
+ fprintf(stderr, "Resizing from %dx%d to %dx%d; cursor was at (%d,%d)\n",
+ old_cols, old_rows, new_cols, new_rows, old_cursor.col, old_cursor.row);
+#endif
+
+ // Keep track of the final row that is knonw to be blank, so we know what spare space we have for
+ // scrolling into
+ int final_blank_row = new_rows;
+
+ while (old_row >= 0) {
+ int old_row_end = old_row;
+ // TODO(vterm): Stop if dwl or dhl
+ while (screen->reflow && old_lineinfo && old_row > 0 && old_lineinfo[old_row].continuation) {
+ old_row--;
+ }
+ int old_row_start = old_row;
+
+ int width = 0;
+ for (int row = old_row_start; row <= old_row_end; row++) {
+ if (screen->reflow && row < (old_rows - 1) && old_lineinfo[row + 1].continuation) {
+ width += old_cols;
+ } else {
+ width += line_popcount(old_buffer, row, old_rows, old_cols);
+ }
+ }
+
+ if (final_blank_row == (new_row + 1) && width == 0) {
+ final_blank_row = new_row;
+ }
+
+ int new_height = screen->reflow
+ ? width ? (width + new_cols - 1) / new_cols : 1
+ : 1;
+
+ int new_row_end = new_row;
+ int new_row_start = new_row - new_height + 1;
+
+ old_row = old_row_start;
+ int old_col = 0;
+
+ int spare_rows = new_rows - final_blank_row;
+
+ if (new_row_start < 0 // we'd fall off the top
+ && spare_rows >= 0 // we actually have spare rows
+ && (!active || new_cursor.row == -1 || (new_cursor.row - new_row_start) < new_rows)) {
+ // Attempt to scroll content down into the blank rows at the bottom to make it fit
+ int downwards = -new_row_start;
+ if (downwards > spare_rows) {
+ downwards = spare_rows;
+ }
+ int rowcount = new_rows - downwards;
+
+#ifdef DEBUG_REFLOW
+ fprintf(stderr, " scroll %d rows +%d downwards\n", rowcount, downwards);
+#endif
+
+ memmove(&new_buffer[downwards * new_cols], &new_buffer[0],
+ (size_t)rowcount * (size_t)new_cols * sizeof(ScreenCell));
+ memmove(&new_lineinfo[downwards], &new_lineinfo[0],
+ (size_t)rowcount * sizeof(new_lineinfo[0]));
+
+ new_row += downwards;
+ new_row_start += downwards;
+ new_row_end += downwards;
+
+ if (new_cursor.row >= 0) {
+ new_cursor.row += downwards;
+ }
+
+ final_blank_row += downwards;
+ }
+
+#ifdef DEBUG_REFLOW
+ fprintf(stderr, " rows [%d..%d] <- [%d..%d] width=%d\n",
+ new_row_start, new_row_end, old_row_start, old_row_end, width);
+#endif
+
+ if (new_row_start < 0) {
+ if (old_row_start <= old_cursor.row && old_cursor.row <= old_row_end) {
+ new_cursor.row = 0;
+ new_cursor.col = old_cursor.col;
+ if (new_cursor.col >= new_cols) {
+ new_cursor.col = new_cols - 1;
+ }
+ }
+ break;
+ }
+
+ for (new_row = new_row_start, old_row = old_row_start; new_row <= new_row_end; new_row++) {
+ int count = width >= new_cols ? new_cols : width;
+ width -= count;
+
+ int new_col = 0;
+
+ while (count) {
+ // TODO(vterm): This could surely be done a lot faster by memcpy()'ing the entire range
+ new_buffer[new_row * new_cols + new_col] = old_buffer[old_row * old_cols + old_col];
+
+ if (old_cursor.row == old_row && old_cursor.col == old_col) {
+ new_cursor.row = new_row, new_cursor.col = new_col;
+ }
+
+ old_col++;
+ if (old_col == old_cols) {
+ old_row++;
+
+ if (!screen->reflow) {
+ new_col++;
+ break;
+ }
+ old_col = 0;
+ }
+
+ new_col++;
+ count--;
+ }
+
+ if (old_cursor.row == old_row && old_cursor.col >= old_col) {
+ new_cursor.row = new_row, new_cursor.col = (old_cursor.col - old_col + new_col);
+ if (new_cursor.col >= new_cols) {
+ new_cursor.col = new_cols - 1;
+ }
+ }
+
+ while (new_col < new_cols) {
+ clearcell(screen, &new_buffer[new_row * new_cols + new_col]);
+ new_col++;
+ }
+
+ new_lineinfo[new_row].continuation = (new_row > new_row_start);
+ }
+
+ old_row = old_row_start - 1;
+ new_row = new_row_start - 1;
+ }
+
+ if (old_cursor.row <= old_row) {
+ // cursor would have moved entirely off the top of the screen; lets just bring it within range
+ new_cursor.row = 0, new_cursor.col = old_cursor.col;
+ if (new_cursor.col >= new_cols) {
+ new_cursor.col = new_cols - 1;
+ }
+ }
+
+ // We really expect the cursor position to be set by now
+ if (active && (new_cursor.row == -1 || new_cursor.col == -1)) {
+ fprintf(stderr, "screen_resize failed to update cursor position\n");
+ abort();
+ }
+
+ if (old_row >= 0 && bufidx == BUFIDX_PRIMARY) {
+ // Push spare lines to scrollback buffer
+ if (screen->callbacks && screen->callbacks->sb_pushline) {
+ for (int row = 0; row <= old_row; row++) {
+ sb_pushline_from_row(screen, row);
+ }
+ }
+ if (active) {
+ statefields->pos.row -= (old_row + 1);
+ }
+ }
+ if (new_row >= 0 && bufidx == BUFIDX_PRIMARY
+ && screen->callbacks && screen->callbacks->sb_popline) {
+ // Try to backfill rows by popping scrollback buffer
+ while (new_row >= 0) {
+ if (!(screen->callbacks->sb_popline(old_cols, screen->sb_buffer, screen->cbdata))) {
+ break;
+ }
+
+ VTermPos pos = { .row = new_row };
+ for (pos.col = 0; pos.col < old_cols && pos.col < new_cols;
+ pos.col += screen->sb_buffer[pos.col].width) {
+ VTermScreenCell *src = &screen->sb_buffer[pos.col];
+ ScreenCell *dst = &new_buffer[pos.row * new_cols + pos.col];
+
+ dst->schar = src->schar;
+
+ dst->pen.bold = src->attrs.bold;
+ dst->pen.underline = src->attrs.underline;
+ dst->pen.italic = src->attrs.italic;
+ dst->pen.blink = src->attrs.blink;
+ dst->pen.reverse = src->attrs.reverse ^ screen->global_reverse;
+ dst->pen.conceal = src->attrs.conceal;
+ dst->pen.strike = src->attrs.strike;
+ dst->pen.font = src->attrs.font;
+ dst->pen.small = src->attrs.small;
+ dst->pen.baseline = src->attrs.baseline;
+
+ dst->pen.fg = src->fg;
+ dst->pen.bg = src->bg;
+
+ dst->pen.uri = src->uri;
+
+ if (src->width == 2 && pos.col < (new_cols - 1)) {
+ (dst + 1)->schar = (uint32_t)-1;
+ }
+ }
+ for (; pos.col < new_cols; pos.col++) {
+ clearcell(screen, &new_buffer[pos.row * new_cols + pos.col]);
+ }
+ new_row--;
+
+ if (active) {
+ statefields->pos.row++;
+ }
+ }
+ }
+ if (new_row >= 0) {
+ // Scroll new rows back up to the top and fill in blanks at the bottom
+ int moverows = new_rows - new_row - 1;
+ memmove(&new_buffer[0], &new_buffer[(new_row + 1) * new_cols],
+ (size_t)moverows * (size_t)new_cols * sizeof(ScreenCell));
+ memmove(&new_lineinfo[0], &new_lineinfo[new_row + 1],
+ (size_t)moverows * sizeof(new_lineinfo[0]));
+
+ new_cursor.row -= (new_row + 1);
+
+ for (new_row = moverows; new_row < new_rows; new_row++) {
+ for (int col = 0; col < new_cols; col++) {
+ clearcell(screen, &new_buffer[new_row * new_cols + col]);
+ }
+ new_lineinfo[new_row] = (VTermLineInfo){ 0 };
+ }
+ }
+
+ vterm_allocator_free(screen->vt, old_buffer);
+ screen->buffers[bufidx] = new_buffer;
+
+ vterm_allocator_free(screen->vt, old_lineinfo);
+ statefields->lineinfos[bufidx] = new_lineinfo;
+
+ if (active) {
+ statefields->pos = new_cursor;
+ }
+}
+
+static int resize(int new_rows, int new_cols, VTermStateFields *fields, void *user)
+{
+ VTermScreen *screen = user;
+
+ int altscreen_active = (screen->buffers[BUFIDX_ALTSCREEN]
+ && screen->buffer == screen->buffers[BUFIDX_ALTSCREEN]);
+
+ int old_rows = screen->rows;
+ int old_cols = screen->cols;
+
+ if (new_cols > old_cols) {
+ // Ensure that ->sb_buffer is large enough for a new or and old row
+ if (screen->sb_buffer) {
+ vterm_allocator_free(screen->vt, screen->sb_buffer);
+ }
+
+ screen->sb_buffer = vterm_allocator_malloc(screen->vt,
+ sizeof(VTermScreenCell) * (size_t)new_cols);
+ }
+
+ resize_buffer(screen, 0, new_rows, new_cols, !altscreen_active, fields);
+ if (screen->buffers[BUFIDX_ALTSCREEN]) {
+ resize_buffer(screen, 1, new_rows, new_cols, altscreen_active, fields);
+ } else if (new_rows != old_rows) {
+ // We don't need a full resize of the altscreen because it isn't enabled but we should at least
+ // keep the lineinfo the right size
+ vterm_allocator_free(screen->vt, fields->lineinfos[BUFIDX_ALTSCREEN]);
+
+ VTermLineInfo *new_lineinfo = vterm_allocator_malloc(screen->vt,
+ sizeof(new_lineinfo[0]) *
+ (size_t)new_rows);
+ for (int row = 0; row < new_rows; row++) {
+ new_lineinfo[row] = (VTermLineInfo){ 0 };
+ }
+
+ fields->lineinfos[BUFIDX_ALTSCREEN] = new_lineinfo;
+ }
+
+ screen->buffer =
+ altscreen_active ? screen->buffers[BUFIDX_ALTSCREEN] : screen->buffers[BUFIDX_PRIMARY];
+
+ screen->rows = new_rows;
+ screen->cols = new_cols;
+
+ if (new_cols <= old_cols) {
+ if (screen->sb_buffer) {
+ vterm_allocator_free(screen->vt, screen->sb_buffer);
+ }
+
+ screen->sb_buffer = vterm_allocator_malloc(screen->vt,
+ sizeof(VTermScreenCell) * (size_t)new_cols);
+ }
+
+ // TODO(vterm): Maaaaybe we can optimise this if there's no reflow happening
+ damagescreen(screen);
+
+ if (screen->callbacks && screen->callbacks->resize) {
+ return (*screen->callbacks->resize)(new_rows, new_cols, screen->cbdata);
+ }
+
+ return 1;
+}
+
+static int theme(bool *dark, void *user)
+{
+ VTermScreen *screen = user;
+
+ if (screen->callbacks && screen->callbacks->theme) {
+ return (*screen->callbacks->theme)(dark, screen->cbdata);
+ }
+
+ return 1;
+}
+
+static int setlineinfo(int row, const VTermLineInfo *newinfo, const VTermLineInfo *oldinfo,
+ void *user)
+{
+ VTermScreen *screen = user;
+
+ if (newinfo->doublewidth != oldinfo->doublewidth
+ || newinfo->doubleheight != oldinfo->doubleheight) {
+ for (int col = 0; col < screen->cols; col++) {
+ ScreenCell *cell = getcell(screen, row, col);
+ cell->pen.dwl = newinfo->doublewidth;
+ cell->pen.dhl = newinfo->doubleheight;
+ }
+
+ VTermRect rect = {
+ .start_row = row,
+ .end_row = row + 1,
+ .start_col = 0,
+ .end_col = newinfo->doublewidth ? screen->cols / 2 : screen->cols,
+ };
+ damagerect(screen, rect);
+
+ if (newinfo->doublewidth) {
+ rect.start_col = screen->cols / 2;
+ rect.end_col = screen->cols;
+
+ erase_internal(rect, 0, user);
+ }
+ }
+
+ return 1;
+}
+
+static int sb_clear(void *user)
+{
+ VTermScreen *screen = user;
+
+ if (screen->callbacks && screen->callbacks->sb_clear) {
+ if ((*screen->callbacks->sb_clear)(screen->cbdata)) {
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+static VTermStateCallbacks state_cbs = {
+ .putglyph = &putglyph,
+ .movecursor = &movecursor,
+ .scrollrect = &scrollrect,
+ .erase = &erase,
+ .setpenattr = &setpenattr,
+ .settermprop = &settermprop,
+ .bell = &bell,
+ .resize = &resize,
+ .theme = &theme,
+ .setlineinfo = &setlineinfo,
+ .sb_clear = &sb_clear,
+};
+
+static VTermScreen *screen_new(VTerm *vt)
+{
+ VTermState *state = vterm_obtain_state(vt);
+ if (!state) {
+ return NULL;
+ }
+
+ VTermScreen *screen = vterm_allocator_malloc(vt, sizeof(VTermScreen));
+ int rows, cols;
+
+ vterm_get_size(vt, &rows, &cols);
+
+ screen->vt = vt;
+ screen->state = state;
+
+ screen->damage_merge = VTERM_DAMAGE_CELL;
+ screen->damaged.start_row = -1;
+ screen->pending_scrollrect.start_row = -1;
+
+ screen->rows = rows;
+ screen->cols = cols;
+
+ screen->global_reverse = false;
+ screen->reflow = false;
+
+ screen->callbacks = NULL;
+ screen->cbdata = NULL;
+
+ screen->buffers[BUFIDX_PRIMARY] = alloc_buffer(screen, rows, cols);
+
+ screen->buffer = screen->buffers[BUFIDX_PRIMARY];
+
+ screen->sb_buffer = vterm_allocator_malloc(screen->vt, sizeof(VTermScreenCell) * (size_t)cols);
+
+ vterm_state_set_callbacks(screen->state, &state_cbs, screen);
+
+ return screen;
+}
+
+void vterm_screen_free(VTermScreen *screen)
+{
+ vterm_allocator_free(screen->vt, screen->buffers[BUFIDX_PRIMARY]);
+ if (screen->buffers[BUFIDX_ALTSCREEN]) {
+ vterm_allocator_free(screen->vt, screen->buffers[BUFIDX_ALTSCREEN]);
+ }
+
+ vterm_allocator_free(screen->vt, screen->sb_buffer);
+
+ vterm_allocator_free(screen->vt, screen);
+}
+
+void vterm_screen_reset(VTermScreen *screen, int hard)
+{
+ screen->damaged.start_row = -1;
+ screen->pending_scrollrect.start_row = -1;
+ vterm_state_reset(screen->state, hard);
+ vterm_screen_flush_damage(screen);
+}
+
+// Copy internal to external representation of a screen cell
+int vterm_screen_get_cell(const VTermScreen *screen, VTermPos pos, VTermScreenCell *cell)
+{
+ ScreenCell *intcell = getcell(screen, pos.row, pos.col);
+ if (!intcell) {
+ return 0;
+ }
+
+ cell->schar = (intcell->schar == (uint32_t)-1) ? 0 : intcell->schar;
+
+ cell->attrs.bold = intcell->pen.bold;
+ cell->attrs.underline = intcell->pen.underline;
+ cell->attrs.italic = intcell->pen.italic;
+ cell->attrs.blink = intcell->pen.blink;
+ cell->attrs.reverse = intcell->pen.reverse ^ screen->global_reverse;
+ cell->attrs.conceal = intcell->pen.conceal;
+ cell->attrs.strike = intcell->pen.strike;
+ cell->attrs.font = intcell->pen.font;
+ cell->attrs.small = intcell->pen.small;
+ cell->attrs.baseline = intcell->pen.baseline;
+
+ cell->attrs.dwl = intcell->pen.dwl;
+ cell->attrs.dhl = intcell->pen.dhl;
+
+ cell->fg = intcell->pen.fg;
+ cell->bg = intcell->pen.bg;
+
+ cell->uri = intcell->pen.uri;
+
+ if (pos.col < (screen->cols - 1)
+ && getcell(screen, pos.row, pos.col + 1)->schar == (uint32_t)-1) {
+ cell->width = 2;
+ } else {
+ cell->width = 1;
+ }
+
+ return 1;
+}
+
+VTermScreen *vterm_obtain_screen(VTerm *vt)
+{
+ if (vt->screen) {
+ return vt->screen;
+ }
+
+ VTermScreen *screen = screen_new(vt);
+ vt->screen = screen;
+
+ return screen;
+}
+
+void vterm_screen_enable_reflow(VTermScreen *screen, bool reflow)
+{
+ screen->reflow = reflow;
+}
+
+#undef vterm_screen_set_reflow
+void vterm_screen_set_reflow(VTermScreen *screen, bool reflow)
+{
+ vterm_screen_enable_reflow(screen, reflow);
+}
+
+void vterm_screen_enable_altscreen(VTermScreen *screen, int altscreen)
+{
+ if (!screen->buffers[BUFIDX_ALTSCREEN] && altscreen) {
+ int rows, cols;
+ vterm_get_size(screen->vt, &rows, &cols);
+
+ screen->buffers[BUFIDX_ALTSCREEN] = alloc_buffer(screen, rows, cols);
+ }
+}
+
+void vterm_screen_set_callbacks(VTermScreen *screen, const VTermScreenCallbacks *callbacks,
+ void *user)
+{
+ screen->callbacks = callbacks;
+ screen->cbdata = user;
+}
+
+void vterm_screen_set_unrecognised_fallbacks(VTermScreen *screen,
+ const VTermStateFallbacks *fallbacks, void *user)
+{
+ vterm_state_set_unrecognised_fallbacks(screen->state, fallbacks, user);
+}
+
+void vterm_screen_flush_damage(VTermScreen *screen)
+{
+ if (screen->pending_scrollrect.start_row != -1) {
+ vterm_scroll_rect(screen->pending_scrollrect, screen->pending_scroll_downward,
+ screen->pending_scroll_rightward,
+ moverect_user, erase_user, screen);
+
+ screen->pending_scrollrect.start_row = -1;
+ }
+
+ if (screen->damaged.start_row != -1) {
+ if (screen->callbacks && screen->callbacks->damage) {
+ (*screen->callbacks->damage)(screen->damaged, screen->cbdata);
+ }
+
+ screen->damaged.start_row = -1;
+ }
+}
+
+void vterm_screen_set_damage_merge(VTermScreen *screen, VTermDamageSize size)
+{
+ vterm_screen_flush_damage(screen);
+ screen->damage_merge = size;
+}
+
+/// Same as vterm_state_convert_color_to_rgb(), but takes a `screen` instead of a `state` instance.
+void vterm_screen_convert_color_to_rgb(const VTermScreen *screen, VTermColor *col)
+{
+ vterm_state_convert_color_to_rgb(screen->state, col);
+}
+
+// Some utility functions on VTermRect structures
+
+#define STRFrect "(%d,%d-%d,%d)"
+#define ARGSrect(r) (r).start_row, (r).start_col, (r).end_row, (r).end_col
+
+// Expand dst to contain src as well
+void rect_expand(VTermRect *dst, VTermRect *src)
+{
+ if (dst->start_row > src->start_row) {
+ dst->start_row = src->start_row;
+ }
+ if (dst->start_col > src->start_col) {
+ dst->start_col = src->start_col;
+ }
+ if (dst->end_row < src->end_row) {
+ dst->end_row = src->end_row;
+ }
+ if (dst->end_col < src->end_col) {
+ dst->end_col = src->end_col;
+ }
+}
+
+// Clip the dst to ensure it does not step outside of bounds
+void rect_clip(VTermRect *dst, VTermRect *bounds)
+{
+ if (dst->start_row < bounds->start_row) {
+ dst->start_row = bounds->start_row;
+ }
+ if (dst->start_col < bounds->start_col) {
+ dst->start_col = bounds->start_col;
+ }
+ if (dst->end_row > bounds->end_row) {
+ dst->end_row = bounds->end_row;
+ }
+ if (dst->end_col > bounds->end_col) {
+ dst->end_col = bounds->end_col;
+ }
+ // Ensure it doesn't end up negatively-sized
+ if (dst->end_row < dst->start_row) {
+ dst->end_row = dst->start_row;
+ }
+ if (dst->end_col < dst->start_col) {
+ dst->end_col = dst->start_col;
+ }
+}
+
+// True if the two rectangles are equal
+int rect_equal(VTermRect *a, VTermRect *b)
+{
+ return (a->start_row == b->start_row)
+ && (a->start_col == b->start_col)
+ && (a->end_row == b->end_row)
+ && (a->end_col == b->end_col);
+}
+
+// True if small is contained entirely within big
+int rect_contains(VTermRect *big, VTermRect *small)
+{
+ if (small->start_row < big->start_row) {
+ return 0;
+ }
+ if (small->start_col < big->start_col) {
+ return 0;
+ }
+ if (small->end_row > big->end_row) {
+ return 0;
+ }
+ if (small->end_col > big->end_col) {
+ return 0;
+ }
+ return 1;
+}
+
+// True if the rectangles overlap at all
+int rect_intersects(VTermRect *a, VTermRect *b)
+{
+ if (a->start_row > b->end_row || b->start_row > a->end_row) {
+ return 0;
+ }
+ if (a->start_col > b->end_col || b->start_col > a->end_col) {
+ return 0;
+ }
+ return 1;
+}
diff --git a/src/nvim/vterm/screen.h b/src/nvim/vterm/screen.h
new file mode 100644
index 0000000000..fa7520d75a
--- /dev/null
+++ b/src/nvim/vterm/screen.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <stddef.h>
+
+#include "nvim/vterm/vterm_defs.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "vterm/screen.h.generated.h"
+#endif
diff --git a/src/nvim/vterm/state.c b/src/nvim/vterm/state.c
new file mode 100644
index 0000000000..0e43107347
--- /dev/null
+++ b/src/nvim/vterm/state.c
@@ -0,0 +1,2467 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "nvim/grid.h"
+#include "nvim/mbyte.h"
+#include "nvim/vterm/encoding.h"
+#include "nvim/vterm/parser.h"
+#include "nvim/vterm/pen.h"
+#include "nvim/vterm/state.h"
+#include "nvim/vterm/vterm.h"
+#include "nvim/vterm/vterm_internal_defs.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "vterm/state.c.generated.h"
+#endif
+
+#define strneq(a, b, n) (strncmp(a, b, n) == 0)
+
+// Some convenient wrappers to make callback functions easier
+
+static void putglyph(VTermState *state, const schar_T schar, int width, VTermPos pos)
+{
+ VTermGlyphInfo info = {
+ .schar = schar,
+ .width = width,
+ .protected_cell = state->protected_cell,
+ .dwl = state->lineinfo[pos.row].doublewidth,
+ .dhl = state->lineinfo[pos.row].doubleheight,
+ };
+
+ if (state->callbacks && state->callbacks->putglyph) {
+ if ((*state->callbacks->putglyph)(&info, pos, state->cbdata)) {
+ return;
+ }
+ }
+
+ DEBUG_LOG("libvterm: Unhandled putglyph U+%04x at (%d,%d)\n", chars[0], pos.col, pos.row);
+}
+
+static void updatecursor(VTermState *state, VTermPos *oldpos, int cancel_phantom)
+{
+ if (state->pos.col == oldpos->col && state->pos.row == oldpos->row) {
+ return;
+ }
+
+ if (cancel_phantom) {
+ state->at_phantom = 0;
+ }
+
+ if (state->callbacks && state->callbacks->movecursor) {
+ if ((*state->callbacks->movecursor)(state->pos, *oldpos, state->mode.cursor_visible,
+ state->cbdata)) {
+ return;
+ }
+ }
+}
+
+static void erase(VTermState *state, VTermRect rect, int selective)
+{
+ if (rect.end_col == state->cols) {
+ // If we're erasing the final cells of any lines, cancel the continuation marker on the
+ // subsequent line
+ for (int row = rect.start_row + 1; row < rect.end_row + 1 && row < state->rows; row++) {
+ state->lineinfo[row].continuation = 0;
+ }
+ }
+
+ if (state->callbacks && state->callbacks->erase) {
+ if ((*state->callbacks->erase)(rect, selective, state->cbdata)) {
+ return;
+ }
+ }
+}
+
+static VTermState *vterm_state_new(VTerm *vt)
+{
+ VTermState *state = vterm_allocator_malloc(vt, sizeof(VTermState));
+
+ state->vt = vt;
+
+ state->rows = vt->rows;
+ state->cols = vt->cols;
+
+ state->mouse_col = 0;
+ state->mouse_row = 0;
+ state->mouse_buttons = 0;
+
+ state->mouse_protocol = MOUSE_X10;
+
+ state->callbacks = NULL;
+ state->cbdata = NULL;
+
+ state->selection.callbacks = NULL;
+ state->selection.user = NULL;
+ state->selection.buffer = NULL;
+
+ vterm_state_newpen(state);
+
+ state->bold_is_highbright = 0;
+
+ state->combine_pos.row = -1;
+
+ state->tabstops = vterm_allocator_malloc(state->vt, ((size_t)state->cols + 7) / 8);
+
+ state->lineinfos[BUFIDX_PRIMARY] = vterm_allocator_malloc(state->vt,
+ (size_t)state->rows *
+ sizeof(VTermLineInfo));
+ // TODO(vterm): Make an 'enable' function
+ state->lineinfos[BUFIDX_ALTSCREEN] = vterm_allocator_malloc(state->vt,
+ (size_t)state->rows *
+ sizeof(VTermLineInfo));
+ state->lineinfo = state->lineinfos[BUFIDX_PRIMARY];
+
+ state->encoding_utf8.enc = vterm_lookup_encoding(ENC_UTF8, 'u');
+ if (*state->encoding_utf8.enc->init) {
+ (*state->encoding_utf8.enc->init)(state->encoding_utf8.enc, state->encoding_utf8.data);
+ }
+
+ for (size_t i = 0; i < ARRAY_SIZE(state->key_encoding_stacks); i++) {
+ struct VTermKeyEncodingStack *stack = &state->key_encoding_stacks[i];
+ for (size_t j = 0; j < ARRAY_SIZE(stack->items); j++) {
+ memset(&stack->items[j], 0, sizeof(stack->items[j]));
+ }
+
+ stack->size = 1;
+ }
+
+ return state;
+}
+
+void vterm_state_free(VTermState *state)
+{
+ vterm_allocator_free(state->vt, state->tabstops);
+ vterm_allocator_free(state->vt, state->lineinfos[BUFIDX_PRIMARY]);
+ if (state->lineinfos[BUFIDX_ALTSCREEN]) {
+ vterm_allocator_free(state->vt, state->lineinfos[BUFIDX_ALTSCREEN]);
+ }
+ vterm_allocator_free(state->vt, state);
+}
+
+static void scroll(VTermState *state, VTermRect rect, int downward, int rightward)
+{
+ if (!downward && !rightward) {
+ return;
+ }
+
+ int rows = rect.end_row - rect.start_row;
+ if (downward > rows) {
+ downward = rows;
+ } else if (downward < -rows) {
+ downward = -rows;
+ }
+
+ int cols = rect.end_col - rect.start_col;
+ if (rightward > cols) {
+ rightward = cols;
+ } else if (rightward < -cols) {
+ rightward = -cols;
+ }
+
+ // Update lineinfo if full line
+ if (rect.start_col == 0 && rect.end_col == state->cols && rightward == 0) {
+ int height = rect.end_row - rect.start_row - abs(downward);
+
+ if (downward > 0) {
+ memmove(state->lineinfo + rect.start_row,
+ state->lineinfo + rect.start_row + downward,
+ (size_t)height * sizeof(state->lineinfo[0]));
+ for (int row = rect.end_row - downward; row < rect.end_row; row++) {
+ state->lineinfo[row] = (VTermLineInfo){ 0 };
+ }
+ } else {
+ memmove(state->lineinfo + rect.start_row - downward,
+ state->lineinfo + rect.start_row,
+ (size_t)height * sizeof(state->lineinfo[0]));
+ for (int row = rect.start_row; row < rect.start_row - downward; row++) {
+ state->lineinfo[row] = (VTermLineInfo){ 0 };
+ }
+ }
+ }
+
+ if (state->callbacks && state->callbacks->scrollrect) {
+ if ((*state->callbacks->scrollrect)(rect, downward, rightward, state->cbdata)) {
+ return;
+ }
+ }
+
+ if (state->callbacks) {
+ vterm_scroll_rect(rect, downward, rightward,
+ state->callbacks->moverect, state->callbacks->erase, state->cbdata);
+ }
+}
+
+static void linefeed(VTermState *state)
+{
+ if (state->pos.row == SCROLLREGION_BOTTOM(state) - 1) {
+ VTermRect rect = {
+ .start_row = state->scrollregion_top,
+ .end_row = SCROLLREGION_BOTTOM(state),
+ .start_col = SCROLLREGION_LEFT(state),
+ .end_col = SCROLLREGION_RIGHT(state),
+ };
+
+ scroll(state, rect, 1, 0);
+ } else if (state->pos.row < state->rows - 1) {
+ state->pos.row++;
+ }
+}
+
+static void set_col_tabstop(VTermState *state, int col)
+{
+ uint8_t mask = (uint8_t)(1 << (col & 7));
+ state->tabstops[col >> 3] |= mask;
+}
+
+static void clear_col_tabstop(VTermState *state, int col)
+{
+ uint8_t mask = (uint8_t)(1 << (col & 7));
+ state->tabstops[col >> 3] &= ~mask;
+}
+
+static int is_col_tabstop(VTermState *state, int col)
+{
+ uint8_t mask = (uint8_t)(1 << (col & 7));
+ return state->tabstops[col >> 3] & mask;
+}
+
+static int is_cursor_in_scrollregion(const VTermState *state)
+{
+ if (state->pos.row < state->scrollregion_top
+ || state->pos.row >= SCROLLREGION_BOTTOM(state)) {
+ return 0;
+ }
+ if (state->pos.col < SCROLLREGION_LEFT(state)
+ || state->pos.col >= SCROLLREGION_RIGHT(state)) {
+ return 0;
+ }
+
+ return 1;
+}
+
+static void tab(VTermState *state, int count, int direction)
+{
+ while (count > 0) {
+ if (direction > 0) {
+ if (state->pos.col >= THISROWWIDTH(state) - 1) {
+ return;
+ }
+
+ state->pos.col++;
+ } else if (direction < 0) {
+ if (state->pos.col < 1) {
+ return;
+ }
+
+ state->pos.col--;
+ }
+
+ if (is_col_tabstop(state, state->pos.col)) {
+ count--;
+ }
+ }
+}
+
+#define NO_FORCE 0
+#define FORCE 1
+
+#define DWL_OFF 0
+#define DWL_ON 1
+
+#define DHL_OFF 0
+#define DHL_TOP 1
+#define DHL_BOTTOM 2
+
+static void set_lineinfo(VTermState *state, int row, int force, int dwl, int dhl)
+{
+ VTermLineInfo info = state->lineinfo[row];
+
+ if (dwl == DWL_OFF) {
+ info.doublewidth = DWL_OFF;
+ } else if (dwl == DWL_ON) {
+ info.doublewidth = DWL_ON;
+ }
+ // else -1 to ignore
+
+ if (dhl == DHL_OFF) {
+ info.doubleheight = DHL_OFF;
+ } else if (dhl == DHL_TOP) {
+ info.doubleheight = DHL_TOP;
+ } else if (dhl == DHL_BOTTOM) {
+ info.doubleheight = DHL_BOTTOM;
+ }
+
+ if ((state->callbacks
+ && state->callbacks->setlineinfo
+ && (*state->callbacks->setlineinfo)(row, &info, state->lineinfo + row, state->cbdata))
+ || force) {
+ state->lineinfo[row] = info;
+ }
+}
+
+static int on_text(const char bytes[], size_t len, void *user)
+{
+ VTermState *state = user;
+
+ VTermPos oldpos = state->pos;
+
+ uint32_t *codepoints = (uint32_t *)(state->vt->tmpbuffer);
+ size_t maxpoints = (state->vt->tmpbuffer_len) / sizeof(uint32_t);
+
+ int npoints = 0;
+ size_t eaten = 0;
+
+ VTermEncodingInstance *encoding =
+ state->gsingle_set ? &state->encoding[state->gsingle_set]
+ : !(bytes[eaten] & 0x80) ? &state->encoding[state->gl_set]
+ : state->vt->mode.utf8 ? &state->encoding_utf8
+ : &state->encoding[state->
+ gr_set];
+
+ (*encoding->enc->decode)(encoding->enc, encoding->data,
+ codepoints, &npoints, state->gsingle_set ? 1 : (int)maxpoints,
+ bytes, &eaten, len);
+
+ // There's a chance an encoding (e.g. UTF-8) hasn't found enough bytes yet for even a single codepoint
+ if (!npoints) {
+ return (int)eaten;
+ }
+
+ if (state->gsingle_set && npoints) {
+ state->gsingle_set = 0;
+ }
+
+ int i = 0;
+ GraphemeState grapheme_state = GRAPHEME_STATE_INIT;
+ size_t grapheme_len = 0;
+ bool recombine = false;
+
+ // See if the cursor has moved since
+ if (state->pos.row == state->combine_pos.row
+ && state->pos.col == state->combine_pos.col + state->combine_width) {
+ // This is a combining char. that needs to be merged with the previous glyph output
+ if (utf_iscomposing((int)state->grapheme_last, (int)codepoints[i], &state->grapheme_state)) {
+ // Find where we need to append these combining chars
+ grapheme_len = state->grapheme_len;
+ grapheme_state = state->grapheme_state;
+ state->pos.col = state->combine_pos.col;
+ recombine = true;
+ } else {
+ DEBUG_LOG("libvterm: TODO: Skip over split char+combining\n");
+ }
+ }
+
+ while (i < npoints) {
+ // Try to find combining characters following this
+ do {
+ if (grapheme_len < sizeof(state->grapheme_buf) - 4) {
+ grapheme_len += (size_t)utf_char2bytes((int)codepoints[i],
+ state->grapheme_buf + grapheme_len);
+ }
+ i++;
+ } while (i < npoints && utf_iscomposing((int)codepoints[i - 1], (int)codepoints[i],
+ &grapheme_state));
+
+ int width = utf_ptr2cells_len(state->grapheme_buf, (int)grapheme_len);
+
+ if (state->at_phantom || state->pos.col + width > THISROWWIDTH(state)) {
+ linefeed(state);
+ state->pos.col = 0;
+ state->at_phantom = 0;
+ state->lineinfo[state->pos.row].continuation = 1;
+ }
+
+ if (state->mode.insert && !recombine) {
+ // TODO(vterm): This will be a little inefficient for large bodies of text, as it'll have to
+ // 'ICH' effectively before every glyph. We should scan ahead and ICH as many times as
+ // required
+ VTermRect rect = {
+ .start_row = state->pos.row,
+ .end_row = state->pos.row + 1,
+ .start_col = state->pos.col,
+ .end_col = THISROWWIDTH(state),
+ };
+ scroll(state, rect, 0, -1);
+ }
+
+ schar_T sc = schar_from_buf(state->grapheme_buf, grapheme_len);
+ putglyph(state, sc, width, state->pos);
+
+ if (i == npoints) {
+ // End of the buffer. Save the chars in case we have to combine with more on the next call
+ state->grapheme_len = grapheme_len;
+ state->grapheme_last = codepoints[i - 1];
+ state->grapheme_state = grapheme_state;
+ state->combine_width = width;
+ state->combine_pos = state->pos;
+ } else {
+ grapheme_len = 0;
+ recombine = false;
+ }
+
+ if (state->pos.col + width >= THISROWWIDTH(state)) {
+ if (state->mode.autowrap) {
+ state->at_phantom = 1;
+ }
+ } else {
+ state->pos.col += width;
+ }
+ }
+
+ updatecursor(state, &oldpos, 0);
+
+#ifdef DEBUG
+ if (state->pos.row < 0 || state->pos.row >= state->rows
+ || state->pos.col < 0 || state->pos.col >= state->cols) {
+ fprintf(stderr, "Position out of bounds after text: (%d,%d)\n",
+ state->pos.row, state->pos.col);
+ abort();
+ }
+#endif
+
+ return (int)eaten;
+}
+
+static int on_control(uint8_t control, void *user)
+{
+ VTermState *state = user;
+
+ VTermPos oldpos = state->pos;
+
+ switch (control) {
+ case 0x07: // BEL - ECMA-48 8.3.3
+ if (state->callbacks && state->callbacks->bell) {
+ (*state->callbacks->bell)(state->cbdata);
+ }
+ break;
+
+ case 0x08: // BS - ECMA-48 8.3.5
+ if (state->pos.col > 0) {
+ state->pos.col--;
+ }
+ break;
+
+ case 0x09: // HT - ECMA-48 8.3.60
+ tab(state, 1, +1);
+ break;
+
+ case 0x0a: // LF - ECMA-48 8.3.74
+ case 0x0b: // VT
+ case 0x0c: // FF
+ linefeed(state);
+ if (state->mode.newline) {
+ state->pos.col = 0;
+ }
+ break;
+
+ case 0x0d: // CR - ECMA-48 8.3.15
+ state->pos.col = 0;
+ break;
+
+ case 0x0e: // LS1 - ECMA-48 8.3.76
+ state->gl_set = 1;
+ break;
+
+ case 0x0f: // LS0 - ECMA-48 8.3.75
+ state->gl_set = 0;
+ break;
+
+ case 0x84: // IND - DEPRECATED but implemented for completeness
+ linefeed(state);
+ break;
+
+ case 0x85: // NEL - ECMA-48 8.3.86
+ linefeed(state);
+ state->pos.col = 0;
+ break;
+
+ case 0x88: // HTS - ECMA-48 8.3.62
+ set_col_tabstop(state, state->pos.col);
+ break;
+
+ case 0x8d: // RI - ECMA-48 8.3.104
+ if (state->pos.row == state->scrollregion_top) {
+ VTermRect rect = {
+ .start_row = state->scrollregion_top,
+ .end_row = SCROLLREGION_BOTTOM(state),
+ .start_col = SCROLLREGION_LEFT(state),
+ .end_col = SCROLLREGION_RIGHT(state),
+ };
+
+ scroll(state, rect, -1, 0);
+ } else if (state->pos.row > 0) {
+ state->pos.row--;
+ }
+ break;
+
+ case 0x8e: // SS2 - ECMA-48 8.3.141
+ state->gsingle_set = 2;
+ break;
+
+ case 0x8f: // SS3 - ECMA-48 8.3.142
+ state->gsingle_set = 3;
+ break;
+
+ default:
+ if (state->fallbacks && state->fallbacks->control) {
+ if ((*state->fallbacks->control)(control, state->fbdata)) {
+ return 1;
+ }
+ }
+
+ return 0;
+ }
+
+ updatecursor(state, &oldpos, 1);
+
+#ifdef DEBUG
+ if (state->pos.row < 0 || state->pos.row >= state->rows
+ || state->pos.col < 0 || state->pos.col >= state->cols) {
+ fprintf(stderr, "Position out of bounds after Ctrl %02x: (%d,%d)\n",
+ control, state->pos.row, state->pos.col);
+ abort();
+ }
+#endif
+
+ return 1;
+}
+
+static int settermprop_bool(VTermState *state, VTermProp prop, int v)
+{
+ VTermValue val = { .boolean = v };
+ return vterm_state_set_termprop(state, prop, &val);
+}
+
+static int settermprop_int(VTermState *state, VTermProp prop, int v)
+{
+ VTermValue val = { .number = v };
+ return vterm_state_set_termprop(state, prop, &val);
+}
+
+static int settermprop_string(VTermState *state, VTermProp prop, VTermStringFragment frag)
+{
+ VTermValue val = { .string = frag };
+ return vterm_state_set_termprop(state, prop, &val);
+}
+
+static void savecursor(VTermState *state, int save)
+{
+ if (save) {
+ state->saved.pos = state->pos;
+ state->saved.mode.cursor_visible = state->mode.cursor_visible;
+ state->saved.mode.cursor_blink = state->mode.cursor_blink;
+ state->saved.mode.cursor_shape = state->mode.cursor_shape;
+
+ vterm_state_savepen(state, 1);
+ } else {
+ VTermPos oldpos = state->pos;
+
+ state->pos = state->saved.pos;
+
+ settermprop_bool(state, VTERM_PROP_CURSORVISIBLE, state->saved.mode.cursor_visible);
+ settermprop_bool(state, VTERM_PROP_CURSORBLINK, state->saved.mode.cursor_blink);
+ settermprop_int(state, VTERM_PROP_CURSORSHAPE, state->saved.mode.cursor_shape);
+
+ vterm_state_savepen(state, 0);
+
+ updatecursor(state, &oldpos, 1);
+ }
+}
+
+static int on_escape(const char *bytes, size_t len, void *user)
+{
+ VTermState *state = user;
+
+ // Easier to decode this from the first byte, even though the final byte terminates it
+ switch (bytes[0]) {
+ case ' ':
+ if (len != 2) {
+ return 0;
+ }
+
+ switch (bytes[1]) {
+ case 'F': // S7C1T
+ state->vt->mode.ctrl8bit = 0;
+ break;
+
+ case 'G': // S8C1T
+ state->vt->mode.ctrl8bit = 1;
+ break;
+
+ default:
+ return 0;
+ }
+ return 2;
+
+ case '#':
+ if (len != 2) {
+ return 0;
+ }
+
+ switch (bytes[1]) {
+ case '3': // DECDHL top
+ if (state->mode.leftrightmargin) {
+ break;
+ }
+ set_lineinfo(state, state->pos.row, NO_FORCE, DWL_ON, DHL_TOP);
+ break;
+
+ case '4': // DECDHL bottom
+ if (state->mode.leftrightmargin) {
+ break;
+ }
+ set_lineinfo(state, state->pos.row, NO_FORCE, DWL_ON, DHL_BOTTOM);
+ break;
+
+ case '5': // DECSWL
+ if (state->mode.leftrightmargin) {
+ break;
+ }
+ set_lineinfo(state, state->pos.row, NO_FORCE, DWL_OFF, DHL_OFF);
+ break;
+
+ case '6': // DECDWL
+ if (state->mode.leftrightmargin) {
+ break;
+ }
+ set_lineinfo(state, state->pos.row, NO_FORCE, DWL_ON, DHL_OFF);
+ break;
+
+ case '8': // DECALN
+ {
+ VTermPos pos;
+ schar_T E = schar_from_ascii('E'); // E
+ for (pos.row = 0; pos.row < state->rows; pos.row++) {
+ for (pos.col = 0; pos.col < ROWWIDTH(state, pos.row); pos.col++) {
+ putglyph(state, E, 1, pos);
+ }
+ }
+ break;
+ }
+
+ default:
+ return 0;
+ }
+ return 2;
+
+ case '(':
+ case ')':
+ case '*':
+ case '+': // SCS
+ if (len != 2) {
+ return 0;
+ }
+
+ {
+ int setnum = bytes[0] - 0x28;
+ VTermEncoding *newenc = vterm_lookup_encoding(ENC_SINGLE_94, bytes[1]);
+
+ if (newenc) {
+ state->encoding[setnum].enc = newenc;
+
+ if (newenc->init) {
+ (*newenc->init)(newenc, state->encoding[setnum].data);
+ }
+ }
+ }
+
+ return 2;
+
+ case '7': // DECSC
+ savecursor(state, 1);
+ return 1;
+
+ case '8': // DECRC
+ savecursor(state, 0);
+ return 1;
+
+ case '<': // Ignored by VT100. Used in VT52 mode to switch up to VT100
+ return 1;
+
+ case '=': // DECKPAM
+ state->mode.keypad = 1;
+ return 1;
+
+ case '>': // DECKPNM
+ state->mode.keypad = 0;
+ return 1;
+
+ case 'c': // RIS - ECMA-48 8.3.105
+ {
+ VTermPos oldpos = state->pos;
+ vterm_state_reset(state, 1);
+ if (state->callbacks && state->callbacks->movecursor) {
+ (*state->callbacks->movecursor)(state->pos, oldpos, state->mode.cursor_visible,
+ state->cbdata);
+ }
+ return 1;
+ }
+
+ case 'n': // LS2 - ECMA-48 8.3.78
+ state->gl_set = 2;
+ return 1;
+
+ case 'o': // LS3 - ECMA-48 8.3.80
+ state->gl_set = 3;
+ return 1;
+
+ case '~': // LS1R - ECMA-48 8.3.77
+ state->gr_set = 1;
+ return 1;
+
+ case '}': // LS2R - ECMA-48 8.3.79
+ state->gr_set = 2;
+ return 1;
+
+ case '|': // LS3R - ECMA-48 8.3.81
+ state->gr_set = 3;
+ return 1;
+
+ default:
+ return 0;
+ }
+}
+
+static void set_mode(VTermState *state, int num, int val)
+{
+ switch (num) {
+ case 4: // IRM - ECMA-48 7.2.10
+ state->mode.insert = (unsigned)val;
+ break;
+
+ case 20: // LNM - ANSI X3.4-1977
+ state->mode.newline = (unsigned)val;
+ break;
+
+ default:
+ DEBUG_LOG("libvterm: Unknown mode %d\n", num);
+ return;
+ }
+}
+
+static void set_dec_mode(VTermState *state, int num, int val)
+{
+ switch (num) {
+ case 1:
+ state->mode.cursor = (unsigned)val;
+ break;
+
+ case 5: // DECSCNM - screen mode
+ settermprop_bool(state, VTERM_PROP_REVERSE, val);
+ break;
+
+ case 6: // DECOM - origin mode
+ {
+ VTermPos oldpos = state->pos;
+ state->mode.origin = (unsigned)val;
+ state->pos.row = state->mode.origin ? state->scrollregion_top : 0;
+ state->pos.col = state->mode.origin ? SCROLLREGION_LEFT(state) : 0;
+ updatecursor(state, &oldpos, 1);
+ }
+ break;
+
+ case 7:
+ state->mode.autowrap = (unsigned)val;
+ break;
+
+ case 12:
+ settermprop_bool(state, VTERM_PROP_CURSORBLINK, val);
+ break;
+
+ case 25:
+ settermprop_bool(state, VTERM_PROP_CURSORVISIBLE, val);
+ break;
+
+ case 69: // DECVSSM - vertical split screen mode
+ // DECLRMM - left/right margin mode
+ state->mode.leftrightmargin = (unsigned)val;
+ if (val) {
+ // Setting DECVSSM must clear doublewidth/doubleheight state of every line
+ for (int row = 0; row < state->rows; row++) {
+ set_lineinfo(state, row, FORCE, DWL_OFF, DHL_OFF);
+ }
+ }
+
+ break;
+
+ case 1000:
+ case 1002:
+ case 1003:
+ settermprop_int(state, VTERM_PROP_MOUSE,
+ !val ? VTERM_PROP_MOUSE_NONE
+ : (num == 1000) ? VTERM_PROP_MOUSE_CLICK
+ : (num == 1002) ? VTERM_PROP_MOUSE_DRAG
+ : VTERM_PROP_MOUSE_MOVE);
+ break;
+
+ case 1004:
+ settermprop_bool(state, VTERM_PROP_FOCUSREPORT, val);
+ state->mode.report_focus = (unsigned)val;
+ break;
+
+ case 1005:
+ state->mouse_protocol = val ? MOUSE_UTF8 : MOUSE_X10;
+ break;
+
+ case 1006:
+ state->mouse_protocol = val ? MOUSE_SGR : MOUSE_X10;
+ break;
+
+ case 1015:
+ state->mouse_protocol = val ? MOUSE_RXVT : MOUSE_X10;
+ break;
+
+ case 1047:
+ settermprop_bool(state, VTERM_PROP_ALTSCREEN, val);
+ break;
+
+ case 1048:
+ savecursor(state, val);
+ break;
+
+ case 1049:
+ settermprop_bool(state, VTERM_PROP_ALTSCREEN, val);
+ savecursor(state, val);
+ break;
+
+ case 2004:
+ state->mode.bracketpaste = (unsigned)val;
+ break;
+
+ case 2031:
+ settermprop_bool(state, VTERM_PROP_THEMEUPDATES, val);
+ break;
+
+ default:
+ DEBUG_LOG("libvterm: Unknown DEC mode %d\n", num);
+ return;
+ }
+}
+
+static void request_dec_mode(VTermState *state, int num)
+{
+ int reply;
+
+ switch (num) {
+ case 1:
+ reply = state->mode.cursor;
+ break;
+
+ case 5:
+ reply = state->mode.screen;
+ break;
+
+ case 6:
+ reply = state->mode.origin;
+ break;
+
+ case 7:
+ reply = state->mode.autowrap;
+ break;
+
+ case 12:
+ reply = state->mode.cursor_blink;
+ break;
+
+ case 25:
+ reply = state->mode.cursor_visible;
+ break;
+
+ case 69:
+ reply = state->mode.leftrightmargin;
+ break;
+
+ case 1000:
+ reply = state->mouse_flags == MOUSE_WANT_CLICK;
+ break;
+
+ case 1002:
+ reply = state->mouse_flags == (MOUSE_WANT_CLICK|MOUSE_WANT_DRAG);
+ break;
+
+ case 1003:
+ reply = state->mouse_flags == (MOUSE_WANT_CLICK|MOUSE_WANT_MOVE);
+ break;
+
+ case 1004:
+ reply = state->mode.report_focus;
+ break;
+
+ case 1005:
+ reply = state->mouse_protocol == MOUSE_UTF8;
+ break;
+
+ case 1006:
+ reply = state->mouse_protocol == MOUSE_SGR;
+ break;
+
+ case 1015:
+ reply = state->mouse_protocol == MOUSE_RXVT;
+ break;
+
+ case 1047:
+ reply = state->mode.alt_screen;
+ break;
+
+ case 2004:
+ reply = state->mode.bracketpaste;
+ break;
+
+ case 2031:
+ reply = state->mode.theme_updates;
+ break;
+
+ default:
+ vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "?%d;%d$y", num, 0);
+ return;
+ }
+
+ vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "?%d;%d$y", num, reply ? 1 : 2);
+}
+
+static void request_version_string(VTermState *state)
+{
+ vterm_push_output_sprintf_str(state->vt, C1_DCS, true, ">|libvterm(%d.%d)",
+ VTERM_VERSION_MAJOR, VTERM_VERSION_MINOR);
+}
+
+static void request_key_encoding_flags(VTermState *state)
+{
+ int screen = state->mode.alt_screen ? BUFIDX_ALTSCREEN : BUFIDX_PRIMARY;
+ struct VTermKeyEncodingStack *stack = &state->key_encoding_stacks[screen];
+
+ int reply = 0;
+
+ assert(stack->size > 0);
+ VTermKeyEncodingFlags flags = stack->items[stack->size - 1];
+
+ if (flags.disambiguate) {
+ reply |= KEY_ENCODING_DISAMBIGUATE;
+ }
+
+ if (flags.report_events) {
+ reply |= KEY_ENCODING_REPORT_EVENTS;
+ }
+
+ if (flags.report_alternate) {
+ reply |= KEY_ENCODING_REPORT_ALTERNATE;
+ }
+
+ if (flags.report_all_keys) {
+ reply |= KEY_ENCODING_REPORT_ALL_KEYS;
+ }
+
+ if (flags.report_associated) {
+ reply |= KEY_ENCODING_REPORT_ASSOCIATED;
+ }
+
+ vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "?%du", reply);
+}
+
+static void set_key_encoding_flags(VTermState *state, int arg, int mode)
+{
+ // When mode is 3, bits set in arg reset the corresponding mode
+ bool set = mode != 3;
+
+ // When mode is 1, unset bits are reset
+ bool reset_unset = mode == 1;
+
+ struct VTermKeyEncodingFlags flags = { 0 };
+ if (arg & KEY_ENCODING_DISAMBIGUATE) {
+ flags.disambiguate = set;
+ } else if (reset_unset) {
+ flags.disambiguate = false;
+ }
+
+ if (arg & KEY_ENCODING_REPORT_EVENTS) {
+ flags.report_events = set;
+ } else if (reset_unset) {
+ flags.report_events = false;
+ }
+
+ if (arg & KEY_ENCODING_REPORT_ALTERNATE) {
+ flags.report_alternate = set;
+ } else if (reset_unset) {
+ flags.report_alternate = false;
+ }
+ if (arg & KEY_ENCODING_REPORT_ALL_KEYS) {
+ flags.report_all_keys = set;
+ } else if (reset_unset) {
+ flags.report_all_keys = false;
+ }
+
+ if (arg & KEY_ENCODING_REPORT_ASSOCIATED) {
+ flags.report_associated = set;
+ } else if (reset_unset) {
+ flags.report_associated = false;
+ }
+
+ int screen = state->mode.alt_screen ? BUFIDX_ALTSCREEN : BUFIDX_PRIMARY;
+ struct VTermKeyEncodingStack *stack = &state->key_encoding_stacks[screen];
+ assert(stack->size > 0);
+ stack->items[stack->size - 1] = flags;
+}
+
+static void push_key_encoding_flags(VTermState *state, int arg)
+{
+ int screen = state->mode.alt_screen ? BUFIDX_ALTSCREEN : BUFIDX_PRIMARY;
+ struct VTermKeyEncodingStack *stack = &state->key_encoding_stacks[screen];
+ assert(stack->size <= ARRAY_SIZE(stack->items));
+
+ if (stack->size == ARRAY_SIZE(stack->items)) {
+ // Evict oldest entry when stack is full
+ for (size_t i = 0; i < ARRAY_SIZE(stack->items) - 1; i++) {
+ stack->items[i] = stack->items[i + 1];
+ }
+ } else {
+ stack->size++;
+ }
+
+ set_key_encoding_flags(state, arg, 1);
+}
+
+static void pop_key_encoding_flags(VTermState *state, int arg)
+{
+ int screen = state->mode.alt_screen ? BUFIDX_ALTSCREEN : BUFIDX_PRIMARY;
+ struct VTermKeyEncodingStack *stack = &state->key_encoding_stacks[screen];
+ if (arg >= stack->size) {
+ stack->size = 1;
+
+ // If a pop request is received that empties the stack, all flags are reset.
+ memset(&stack->items[0], 0, sizeof(stack->items[0]));
+ } else if (arg > 0) {
+ stack->size -= arg;
+ }
+}
+
+static int on_csi(const char *leader, const long args[], int argcount, const char *intermed,
+ char command, void *user)
+{
+ VTermState *state = user;
+ int leader_byte = 0;
+ int intermed_byte = 0;
+ int cancel_phantom = 1;
+
+ if (leader && leader[0]) {
+ if (leader[1]) { // longer than 1 char
+ return 0;
+ }
+
+ switch (leader[0]) {
+ case '?':
+ case '>':
+ case '<':
+ case '=':
+ leader_byte = (int)leader[0];
+ break;
+ default:
+ return 0;
+ }
+ }
+
+ if (intermed && intermed[0]) {
+ if (intermed[1]) { // longer than 1 char
+ return 0;
+ }
+
+ switch (intermed[0]) {
+ case ' ':
+ case '!':
+ case '"':
+ case '$':
+ case '\'':
+ intermed_byte = (int)intermed[0];
+ break;
+ default:
+ return 0;
+ }
+ }
+
+ VTermPos oldpos = state->pos;
+
+ // Some temporaries for later code
+ int count, val;
+ int row, col;
+ VTermRect rect;
+ int selective;
+
+#define LBOUND(v, min) if ((v) < (min))(v) = (min)
+#define UBOUND(v, max) if ((v) > (max))(v) = (max)
+
+#define LEADER(l, b) ((l << 8) | b)
+#define INTERMED(i, b) ((i << 16) | b)
+
+ switch (intermed_byte << 16 | leader_byte << 8 | command) {
+ case 0x40: // ICH - ECMA-48 8.3.64
+ count = CSI_ARG_COUNT(args[0]);
+
+ if (!is_cursor_in_scrollregion(state)) {
+ break;
+ }
+
+ rect.start_row = state->pos.row;
+ rect.end_row = state->pos.row + 1;
+ rect.start_col = state->pos.col;
+ if (state->mode.leftrightmargin) {
+ rect.end_col = SCROLLREGION_RIGHT(state);
+ } else {
+ rect.end_col = THISROWWIDTH(state);
+ }
+
+ scroll(state, rect, 0, -count);
+
+ break;
+
+ case 0x41: // CUU - ECMA-48 8.3.22
+ count = CSI_ARG_COUNT(args[0]);
+ state->pos.row -= count;
+ state->at_phantom = 0;
+ break;
+
+ case 0x42: // CUD - ECMA-48 8.3.19
+ count = CSI_ARG_COUNT(args[0]);
+ state->pos.row += count;
+ state->at_phantom = 0;
+ break;
+
+ case 0x43: // CUF - ECMA-48 8.3.20
+ count = CSI_ARG_COUNT(args[0]);
+ state->pos.col += count;
+ state->at_phantom = 0;
+ break;
+
+ case 0x44: // CUB - ECMA-48 8.3.18
+ count = CSI_ARG_COUNT(args[0]);
+ state->pos.col -= count;
+ state->at_phantom = 0;
+ break;
+
+ case 0x45: // CNL - ECMA-48 8.3.12
+ count = CSI_ARG_COUNT(args[0]);
+ state->pos.col = 0;
+ state->pos.row += count;
+ state->at_phantom = 0;
+ break;
+
+ case 0x46: // CPL - ECMA-48 8.3.13
+ count = CSI_ARG_COUNT(args[0]);
+ state->pos.col = 0;
+ state->pos.row -= count;
+ state->at_phantom = 0;
+ break;
+
+ case 0x47: // CHA - ECMA-48 8.3.9
+ val = CSI_ARG_OR(args[0], 1);
+ state->pos.col = val - 1;
+ state->at_phantom = 0;
+ break;
+
+ case 0x48: // CUP - ECMA-48 8.3.21
+ row = CSI_ARG_OR(args[0], 1);
+ col = argcount < 2 || CSI_ARG_IS_MISSING(args[1]) ? 1 : CSI_ARG(args[1]);
+ // zero-based
+ state->pos.row = row - 1;
+ state->pos.col = col - 1;
+ if (state->mode.origin) {
+ state->pos.row += state->scrollregion_top;
+ state->pos.col += SCROLLREGION_LEFT(state);
+ }
+ state->at_phantom = 0;
+ break;
+
+ case 0x49: // CHT - ECMA-48 8.3.10
+ count = CSI_ARG_COUNT(args[0]);
+ tab(state, count, +1);
+ break;
+
+ case 0x4a: // ED - ECMA-48 8.3.39
+ case LEADER('?', 0x4a): // DECSED - Selective Erase in Display
+ selective = (leader_byte == '?');
+ switch (CSI_ARG(args[0])) {
+ case CSI_ARG_MISSING:
+ case 0:
+ rect.start_row = state->pos.row; rect.end_row = state->pos.row + 1;
+ rect.start_col = state->pos.col; rect.end_col = state->cols;
+ if (rect.end_col > rect.start_col) {
+ erase(state, rect, selective);
+ }
+
+ rect.start_row = state->pos.row + 1; rect.end_row = state->rows;
+ rect.start_col = 0;
+ for (int row_ = rect.start_row; row_ < rect.end_row; row_++) {
+ set_lineinfo(state, row_, FORCE, DWL_OFF, DHL_OFF);
+ }
+ if (rect.end_row > rect.start_row) {
+ erase(state, rect, selective);
+ }
+ break;
+
+ case 1:
+ rect.start_row = 0; rect.end_row = state->pos.row;
+ rect.start_col = 0; rect.end_col = state->cols;
+ for (int row_ = rect.start_row; row_ < rect.end_row; row_++) {
+ set_lineinfo(state, row_, FORCE, DWL_OFF, DHL_OFF);
+ }
+ if (rect.end_col > rect.start_col) {
+ erase(state, rect, selective);
+ }
+
+ rect.start_row = state->pos.row; rect.end_row = state->pos.row + 1;
+ rect.end_col = state->pos.col + 1;
+ if (rect.end_row > rect.start_row) {
+ erase(state, rect, selective);
+ }
+ break;
+
+ case 2:
+ rect.start_row = 0; rect.end_row = state->rows;
+ rect.start_col = 0; rect.end_col = state->cols;
+ for (int row_ = rect.start_row; row_ < rect.end_row; row_++) {
+ set_lineinfo(state, row_, FORCE, DWL_OFF, DHL_OFF);
+ }
+ erase(state, rect, selective);
+ break;
+
+ case 3:
+ if (state->callbacks && state->callbacks->sb_clear) {
+ if ((*state->callbacks->sb_clear)(state->cbdata)) {
+ return 1;
+ }
+ }
+ break;
+ }
+ break;
+
+ case 0x4b: // EL - ECMA-48 8.3.41
+ case LEADER('?', 0x4b): // DECSEL - Selective Erase in Line
+ selective = (leader_byte == '?');
+ rect.start_row = state->pos.row;
+ rect.end_row = state->pos.row + 1;
+
+ switch (CSI_ARG(args[0])) {
+ case CSI_ARG_MISSING:
+ case 0:
+ rect.start_col = state->pos.col; rect.end_col = THISROWWIDTH(state); break;
+ case 1:
+ rect.start_col = 0; rect.end_col = state->pos.col + 1; break;
+ case 2:
+ rect.start_col = 0; rect.end_col = THISROWWIDTH(state); break;
+ default:
+ return 0;
+ }
+
+ if (rect.end_col > rect.start_col) {
+ erase(state, rect, selective);
+ }
+
+ break;
+
+ case 0x4c: // IL - ECMA-48 8.3.67
+ count = CSI_ARG_COUNT(args[0]);
+
+ if (!is_cursor_in_scrollregion(state)) {
+ break;
+ }
+
+ rect.start_row = state->pos.row;
+ rect.end_row = SCROLLREGION_BOTTOM(state);
+ rect.start_col = SCROLLREGION_LEFT(state);
+ rect.end_col = SCROLLREGION_RIGHT(state);
+
+ scroll(state, rect, -count, 0);
+
+ break;
+
+ case 0x4d: // DL - ECMA-48 8.3.32
+ count = CSI_ARG_COUNT(args[0]);
+
+ if (!is_cursor_in_scrollregion(state)) {
+ break;
+ }
+
+ rect.start_row = state->pos.row;
+ rect.end_row = SCROLLREGION_BOTTOM(state);
+ rect.start_col = SCROLLREGION_LEFT(state);
+ rect.end_col = SCROLLREGION_RIGHT(state);
+
+ scroll(state, rect, count, 0);
+
+ break;
+
+ case 0x50: // DCH - ECMA-48 8.3.26
+ count = CSI_ARG_COUNT(args[0]);
+
+ if (!is_cursor_in_scrollregion(state)) {
+ break;
+ }
+
+ rect.start_row = state->pos.row;
+ rect.end_row = state->pos.row + 1;
+ rect.start_col = state->pos.col;
+ if (state->mode.leftrightmargin) {
+ rect.end_col = SCROLLREGION_RIGHT(state);
+ } else {
+ rect.end_col = THISROWWIDTH(state);
+ }
+
+ scroll(state, rect, 0, count);
+
+ break;
+
+ case 0x53: // SU - ECMA-48 8.3.147
+ count = CSI_ARG_COUNT(args[0]);
+
+ rect.start_row = state->scrollregion_top;
+ rect.end_row = SCROLLREGION_BOTTOM(state);
+ rect.start_col = SCROLLREGION_LEFT(state);
+ rect.end_col = SCROLLREGION_RIGHT(state);
+
+ scroll(state, rect, count, 0);
+
+ break;
+
+ case 0x54: // SD - ECMA-48 8.3.113
+ count = CSI_ARG_COUNT(args[0]);
+
+ rect.start_row = state->scrollregion_top;
+ rect.end_row = SCROLLREGION_BOTTOM(state);
+ rect.start_col = SCROLLREGION_LEFT(state);
+ rect.end_col = SCROLLREGION_RIGHT(state);
+
+ scroll(state, rect, -count, 0);
+
+ break;
+
+ case 0x58: // ECH - ECMA-48 8.3.38
+ count = CSI_ARG_COUNT(args[0]);
+
+ rect.start_row = state->pos.row;
+ rect.end_row = state->pos.row + 1;
+ rect.start_col = state->pos.col;
+ rect.end_col = state->pos.col + count;
+ UBOUND(rect.end_col, THISROWWIDTH(state));
+
+ erase(state, rect, 0);
+ break;
+
+ case 0x5a: // CBT - ECMA-48 8.3.7
+ count = CSI_ARG_COUNT(args[0]);
+ tab(state, count, -1);
+ break;
+
+ case 0x60: // HPA - ECMA-48 8.3.57
+ col = CSI_ARG_OR(args[0], 1);
+ state->pos.col = col - 1;
+ state->at_phantom = 0;
+ break;
+
+ case 0x61: // HPR - ECMA-48 8.3.59
+ count = CSI_ARG_COUNT(args[0]);
+ state->pos.col += count;
+ state->at_phantom = 0;
+ break;
+
+ case 0x62: { // REP - ECMA-48 8.3.103
+ const int row_width = THISROWWIDTH(state);
+ count = CSI_ARG_COUNT(args[0]);
+ col = state->pos.col + count;
+ UBOUND(col, row_width);
+ schar_T sc = schar_from_buf(state->grapheme_buf, state->grapheme_len);
+ while (state->pos.col < col) {
+ putglyph(state, sc, state->combine_width, state->pos);
+ state->pos.col += state->combine_width;
+ }
+ if (state->pos.col + state->combine_width >= row_width) {
+ if (state->mode.autowrap) {
+ state->at_phantom = 1;
+ cancel_phantom = 0;
+ }
+ }
+ break;
+ }
+
+ case 0x63: // DA - ECMA-48 8.3.24
+ val = CSI_ARG_OR(args[0], 0);
+ if (val == 0) {
+ // DEC VT100 response
+ vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "?1;2c");
+ }
+ break;
+
+ case LEADER('>', 0x63): // DEC secondary Device Attributes
+ vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, ">%d;%d;%dc", 0, 100, 0);
+ break;
+
+ case 0x64: // VPA - ECMA-48 8.3.158
+ row = CSI_ARG_OR(args[0], 1);
+ state->pos.row = row - 1;
+ if (state->mode.origin) {
+ state->pos.row += state->scrollregion_top;
+ }
+ state->at_phantom = 0;
+ break;
+
+ case 0x65: // VPR - ECMA-48 8.3.160
+ count = CSI_ARG_COUNT(args[0]);
+ state->pos.row += count;
+ state->at_phantom = 0;
+ break;
+
+ case 0x66: // HVP - ECMA-48 8.3.63
+ row = CSI_ARG_OR(args[0], 1);
+ col = argcount < 2 || CSI_ARG_IS_MISSING(args[1]) ? 1 : CSI_ARG(args[1]);
+ // zero-based
+ state->pos.row = row - 1;
+ state->pos.col = col - 1;
+ if (state->mode.origin) {
+ state->pos.row += state->scrollregion_top;
+ state->pos.col += SCROLLREGION_LEFT(state);
+ }
+ state->at_phantom = 0;
+ break;
+
+ case 0x67: // TBC - ECMA-48 8.3.154
+ val = CSI_ARG_OR(args[0], 0);
+
+ switch (val) {
+ case 0:
+ clear_col_tabstop(state, state->pos.col);
+ break;
+ case 3:
+ case 5:
+ for (col = 0; col < state->cols; col++) {
+ clear_col_tabstop(state, col);
+ }
+ break;
+ case 1:
+ case 2:
+ case 4:
+ break;
+ // TODO(vterm): 1, 2 and 4 aren't meaningful yet without line tab stops
+ default:
+ return 0;
+ }
+ break;
+
+ case 0x68: // SM - ECMA-48 8.3.125
+ if (!CSI_ARG_IS_MISSING(args[0])) {
+ set_mode(state, CSI_ARG(args[0]), 1);
+ }
+ break;
+
+ case LEADER('?', 0x68): // DEC private mode set
+ for (int i = 0; i < argcount; i++) {
+ if (!CSI_ARG_IS_MISSING(args[i])) {
+ set_dec_mode(state, CSI_ARG(args[i]), 1);
+ }
+ }
+ break;
+
+ case 0x6a: // HPB - ECMA-48 8.3.58
+ count = CSI_ARG_COUNT(args[0]);
+ state->pos.col -= count;
+ state->at_phantom = 0;
+ break;
+
+ case 0x6b: // VPB - ECMA-48 8.3.159
+ count = CSI_ARG_COUNT(args[0]);
+ state->pos.row -= count;
+ state->at_phantom = 0;
+ break;
+
+ case 0x6c: // RM - ECMA-48 8.3.106
+ if (!CSI_ARG_IS_MISSING(args[0])) {
+ set_mode(state, CSI_ARG(args[0]), 0);
+ }
+ break;
+
+ case LEADER('?', 0x6c): // DEC private mode reset
+ for (int i = 0; i < argcount; i++) {
+ if (!CSI_ARG_IS_MISSING(args[i])) {
+ set_dec_mode(state, CSI_ARG(args[i]), 0);
+ }
+ }
+ break;
+
+ case 0x6d: // SGR - ECMA-48 8.3.117
+ vterm_state_setpen(state, args, argcount);
+ break;
+
+ case LEADER('?', 0x6d): // DECSGR
+ // No actual DEC terminal recognised these, but some printers did. These are alternative ways to
+ // request subscript/superscript/off
+ for (int argi = 0; argi < argcount; argi++) {
+ long arg;
+ switch (arg = CSI_ARG(args[argi])) {
+ case 4: // Superscript on
+ arg = 73;
+ vterm_state_setpen(state, &arg, 1);
+ break;
+ case 5: // Subscript on
+ arg = 74;
+ vterm_state_setpen(state, &arg, 1);
+ break;
+ case 24: // Super+subscript off
+ arg = 75;
+ vterm_state_setpen(state, &arg, 1);
+ break;
+ }
+ }
+ break;
+
+ case 0x6e: // DSR - ECMA-48 8.3.35
+ case LEADER('?', 0x6e): // DECDSR
+ val = CSI_ARG_OR(args[0], 0);
+
+ {
+ char *qmark = (leader_byte == '?') ? "?" : "";
+ bool dark = false;
+
+ switch (val) {
+ case 0:
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ // ignore - these are replies
+ break;
+ case 5:
+ vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "%s0n", qmark);
+ break;
+ case 6: // CPR - cursor position report
+ vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "%s%d;%dR", qmark, state->pos.row + 1,
+ state->pos.col + 1);
+ break;
+ case 996:
+ if (state->callbacks && state->callbacks->theme) {
+ if (state->callbacks->theme(&dark, state->cbdata)) {
+ vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "?997;%cn", dark ? '1' : '2');
+ }
+ }
+ break;
+ }
+ }
+ break;
+
+ case INTERMED('!', 0x70): // DECSTR - DEC soft terminal reset
+ vterm_state_reset(state, 0);
+ break;
+
+ case LEADER('?', INTERMED('$', 0x70)):
+ request_dec_mode(state, CSI_ARG(args[0]));
+ break;
+
+ case LEADER('>', 0x71): // XTVERSION - xterm query version string
+ request_version_string(state);
+ break;
+
+ case INTERMED(' ', 0x71): // DECSCUSR - DEC set cursor shape
+ val = CSI_ARG_OR(args[0], 1);
+
+ switch (val) {
+ case 0:
+ case 1:
+ settermprop_bool(state, VTERM_PROP_CURSORBLINK, 1);
+ settermprop_int(state, VTERM_PROP_CURSORSHAPE, VTERM_PROP_CURSORSHAPE_BLOCK);
+ break;
+ case 2:
+ settermprop_bool(state, VTERM_PROP_CURSORBLINK, 0);
+ settermprop_int(state, VTERM_PROP_CURSORSHAPE, VTERM_PROP_CURSORSHAPE_BLOCK);
+ break;
+ case 3:
+ settermprop_bool(state, VTERM_PROP_CURSORBLINK, 1);
+ settermprop_int(state, VTERM_PROP_CURSORSHAPE, VTERM_PROP_CURSORSHAPE_UNDERLINE);
+ break;
+ case 4:
+ settermprop_bool(state, VTERM_PROP_CURSORBLINK, 0);
+ settermprop_int(state, VTERM_PROP_CURSORSHAPE, VTERM_PROP_CURSORSHAPE_UNDERLINE);
+ break;
+ case 5:
+ settermprop_bool(state, VTERM_PROP_CURSORBLINK, 1);
+ settermprop_int(state, VTERM_PROP_CURSORSHAPE, VTERM_PROP_CURSORSHAPE_BAR_LEFT);
+ break;
+ case 6:
+ settermprop_bool(state, VTERM_PROP_CURSORBLINK, 0);
+ settermprop_int(state, VTERM_PROP_CURSORSHAPE, VTERM_PROP_CURSORSHAPE_BAR_LEFT);
+ break;
+ }
+
+ break;
+
+ case INTERMED('"', 0x71): // DECSCA - DEC select character protection attribute
+ val = CSI_ARG_OR(args[0], 0);
+
+ switch (val) {
+ case 0:
+ case 2:
+ state->protected_cell = 0;
+ break;
+ case 1:
+ state->protected_cell = 1;
+ break;
+ }
+
+ break;
+
+ case 0x72: // DECSTBM - DEC custom
+ state->scrollregion_top = CSI_ARG_OR(args[0], 1) - 1;
+ state->scrollregion_bottom = argcount < 2
+ || CSI_ARG_IS_MISSING(args[1]) ? -1 : CSI_ARG(args[1]);
+ LBOUND(state->scrollregion_top, 0);
+ UBOUND(state->scrollregion_top, state->rows);
+ LBOUND(state->scrollregion_bottom, -1);
+ if (state->scrollregion_top == 0 && state->scrollregion_bottom == state->rows) {
+ state->scrollregion_bottom = -1;
+ } else {
+ UBOUND(state->scrollregion_bottom, state->rows);
+ }
+
+ if (SCROLLREGION_BOTTOM(state) <= state->scrollregion_top) {
+ // Invalid
+ state->scrollregion_top = 0;
+ state->scrollregion_bottom = -1;
+ }
+
+ // Setting the scrolling region restores the cursor to the home position
+ state->pos.row = 0;
+ state->pos.col = 0;
+ if (state->mode.origin) {
+ state->pos.row += state->scrollregion_top;
+ state->pos.col += SCROLLREGION_LEFT(state);
+ }
+
+ break;
+
+ case 0x73: // DECSLRM - DEC custom
+ // Always allow setting these margins, just they won't take effect without DECVSSM
+ state->scrollregion_left = CSI_ARG_OR(args[0], 1) - 1;
+ state->scrollregion_right = argcount < 2 || CSI_ARG_IS_MISSING(args[1]) ? -1 : CSI_ARG(args[1]);
+ LBOUND(state->scrollregion_left, 0);
+ UBOUND(state->scrollregion_left, state->cols);
+ LBOUND(state->scrollregion_right, -1);
+ if (state->scrollregion_left == 0 && state->scrollregion_right == state->cols) {
+ state->scrollregion_right = -1;
+ } else {
+ UBOUND(state->scrollregion_right, state->cols);
+ }
+
+ if (state->scrollregion_right > -1
+ && state->scrollregion_right <= state->scrollregion_left) {
+ // Invalid
+ state->scrollregion_left = 0;
+ state->scrollregion_right = -1;
+ }
+
+ // Setting the scrolling region restores the cursor to the home position
+ state->pos.row = 0;
+ state->pos.col = 0;
+ if (state->mode.origin) {
+ state->pos.row += state->scrollregion_top;
+ state->pos.col += SCROLLREGION_LEFT(state);
+ }
+
+ break;
+
+ case LEADER('?', 0x75): // Kitty query
+ request_key_encoding_flags(state);
+ break;
+
+ case LEADER('>', 0x75): // Kitty push flags
+ push_key_encoding_flags(state, CSI_ARG_OR(args[0], 0));
+ break;
+
+ case LEADER('<', 0x75): // Kitty pop flags
+ pop_key_encoding_flags(state, CSI_ARG_OR(args[0], 1));
+ break;
+
+ case LEADER('=', 0x75): // Kitty set flags
+ val = argcount < 2 || CSI_ARG_IS_MISSING(args[1]) ? 1 : CSI_ARG(args[1]);
+ set_key_encoding_flags(state, CSI_ARG_OR(args[0], 0), val);
+ break;
+
+ case INTERMED('\'', 0x7D): // DECIC
+ count = CSI_ARG_COUNT(args[0]);
+
+ if (!is_cursor_in_scrollregion(state)) {
+ break;
+ }
+
+ rect.start_row = state->scrollregion_top;
+ rect.end_row = SCROLLREGION_BOTTOM(state);
+ rect.start_col = state->pos.col;
+ rect.end_col = SCROLLREGION_RIGHT(state);
+
+ scroll(state, rect, 0, -count);
+
+ break;
+
+ case INTERMED('\'', 0x7E): // DECDC
+ count = CSI_ARG_COUNT(args[0]);
+
+ if (!is_cursor_in_scrollregion(state)) {
+ break;
+ }
+
+ rect.start_row = state->scrollregion_top;
+ rect.end_row = SCROLLREGION_BOTTOM(state);
+ rect.start_col = state->pos.col;
+ rect.end_col = SCROLLREGION_RIGHT(state);
+
+ scroll(state, rect, 0, count);
+
+ break;
+
+ default:
+ if (state->fallbacks && state->fallbacks->csi) {
+ if ((*state->fallbacks->csi)(leader, args, argcount, intermed, command, state->fbdata)) {
+ return 1;
+ }
+ }
+
+ return 0;
+ }
+
+ if (state->mode.origin) {
+ LBOUND(state->pos.row, state->scrollregion_top);
+ UBOUND(state->pos.row, SCROLLREGION_BOTTOM(state) - 1);
+ LBOUND(state->pos.col, SCROLLREGION_LEFT(state));
+ UBOUND(state->pos.col, SCROLLREGION_RIGHT(state) - 1);
+ } else {
+ LBOUND(state->pos.row, 0);
+ UBOUND(state->pos.row, state->rows - 1);
+ LBOUND(state->pos.col, 0);
+ UBOUND(state->pos.col, THISROWWIDTH(state) - 1);
+ }
+
+ updatecursor(state, &oldpos, cancel_phantom);
+
+#ifdef DEBUG
+ if (state->pos.row < 0 || state->pos.row >= state->rows
+ || state->pos.col < 0 || state->pos.col >= state->cols) {
+ fprintf(stderr, "Position out of bounds after CSI %c: (%d,%d)\n",
+ command, state->pos.row, state->pos.col);
+ abort();
+ }
+
+ if (SCROLLREGION_BOTTOM(state) <= state->scrollregion_top) {
+ fprintf(stderr, "Scroll region height out of bounds after CSI %c: %d <= %d\n",
+ command, SCROLLREGION_BOTTOM(state), state->scrollregion_top);
+ abort();
+ }
+
+ if (SCROLLREGION_RIGHT(state) <= SCROLLREGION_LEFT(state)) {
+ fprintf(stderr, "Scroll region width out of bounds after CSI %c: %d <= %d\n",
+ command, SCROLLREGION_RIGHT(state), SCROLLREGION_LEFT(state));
+ abort();
+ }
+#endif
+
+ return 1;
+}
+
+static uint8_t unbase64one(char c)
+{
+ if (c >= 'A' && c <= 'Z') {
+ return (uint8_t)c - 'A';
+ } else if (c >= 'a' && c <= 'z') {
+ return (uint8_t)c - 'a' + 26;
+ } else if (c >= '0' && c <= '9') {
+ return (uint8_t)c - '0' + 52;
+ } else if (c == '+') {
+ return 62;
+ } else if (c == '/') {
+ return 63;
+ }
+
+ return 0xFF;
+}
+
+static void osc_selection(VTermState *state, VTermStringFragment frag)
+{
+ if (frag.initial) {
+ state->tmp.selection.mask = 0;
+ state->tmp.selection.state = SELECTION_INITIAL;
+ }
+
+ while (!state->tmp.selection.state && frag.len) {
+ // Parse selection parameter
+ switch (frag.str[0]) {
+ case 'c':
+ state->tmp.selection.mask |= VTERM_SELECTION_CLIPBOARD;
+ break;
+ case 'p':
+ state->tmp.selection.mask |= VTERM_SELECTION_PRIMARY;
+ break;
+ case 'q':
+ state->tmp.selection.mask |= VTERM_SELECTION_SECONDARY;
+ break;
+ case 's':
+ state->tmp.selection.mask |= VTERM_SELECTION_SELECT;
+ break;
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ state->tmp.selection.mask |= (VTERM_SELECTION_CUT0 << (frag.str[0] - '0'));
+ break;
+
+ case ';':
+ state->tmp.selection.state = SELECTION_SELECTED;
+ if (!state->tmp.selection.mask) {
+ state->tmp.selection.mask = VTERM_SELECTION_SELECT|VTERM_SELECTION_CUT0;
+ }
+ break;
+ }
+
+ frag.str++;
+ frag.len--;
+ }
+
+ if (!frag.len) {
+ // Clear selection if we're already finished but didn't do anything
+ if (frag.final && state->selection.callbacks->set) {
+ (*state->selection.callbacks->set)(state->tmp.selection.mask, (VTermStringFragment){
+ .str = NULL,
+ .len = 0,
+ .initial = state->tmp.selection.state != SELECTION_SET,
+ .final = true,
+ }, state->selection.user);
+ }
+ return;
+ }
+
+ if (state->tmp.selection.state == SELECTION_SELECTED) {
+ if (frag.str[0] == '?') {
+ state->tmp.selection.state = SELECTION_QUERY;
+ } else {
+ state->tmp.selection.state = SELECTION_SET_INITIAL;
+ state->tmp.selection.recvpartial = 0;
+ }
+ }
+
+ if (state->tmp.selection.state == SELECTION_QUERY) {
+ if (state->selection.callbacks->query) {
+ (*state->selection.callbacks->query)(state->tmp.selection.mask, state->selection.user);
+ }
+ return;
+ }
+
+ if (state->tmp.selection.state == SELECTION_INVALID) {
+ return;
+ }
+
+ if (state->selection.callbacks->set) {
+ size_t bufcur = 0;
+ char *buffer = state->selection.buffer;
+
+ uint32_t x = 0; // Current decoding value
+ int n = 0; // Number of sextets consumed
+
+ if (state->tmp.selection.recvpartial) {
+ n = state->tmp.selection.recvpartial >> 24;
+ x = state->tmp.selection.recvpartial & 0x03FFFF; // could be up to 18 bits of state in here
+
+ state->tmp.selection.recvpartial = 0;
+ }
+
+ while ((state->selection.buflen - bufcur) >= 3 && frag.len) {
+ if (frag.str[0] == '=') {
+ if (n == 2) {
+ buffer[0] = (char)(x >> 4 & 0xFF);
+ buffer += 1, bufcur += 1;
+ }
+ if (n == 3) {
+ buffer[0] = (char)(x >> 10 & 0xFF);
+ buffer[1] = (char)(x >> 2 & 0xFF);
+ buffer += 2, bufcur += 2;
+ }
+
+ while (frag.len && frag.str[0] == '=') {
+ frag.str++, frag.len--;
+ }
+
+ n = 0;
+ } else {
+ uint8_t b = unbase64one(frag.str[0]);
+ if (b == 0xFF) {
+ DEBUG_LOG("base64decode bad input %02X\n", (uint8_t)frag.str[0]);
+
+ state->tmp.selection.state = SELECTION_INVALID;
+ if (state->selection.callbacks->set) {
+ (*state->selection.callbacks->set)(state->tmp.selection.mask, (VTermStringFragment){
+ .str = NULL,
+ .len = 0,
+ .initial = true,
+ .final = true,
+ }, state->selection.user);
+ }
+ break;
+ }
+
+ x = (x << 6) | b;
+ n++;
+ frag.str++, frag.len--;
+
+ if (n == 4) {
+ buffer[0] = (char)(x >> 16 & 0xFF);
+ buffer[1] = (char)(x >> 8 & 0xFF);
+ buffer[2] = (char)(x >> 0 & 0xFF);
+
+ buffer += 3, bufcur += 3;
+ x = 0;
+ n = 0;
+ }
+ }
+
+ if (!frag.len || (state->selection.buflen - bufcur) < 3) {
+ if (bufcur) {
+ (*state->selection.callbacks->set)(state->tmp.selection.mask, (VTermStringFragment){
+ .str = state->selection.buffer,
+ .len = bufcur,
+ .initial = state->tmp.selection.state == SELECTION_SET_INITIAL,
+ .final = frag.final && !frag.len,
+ }, state->selection.user);
+ state->tmp.selection.state = SELECTION_SET;
+ }
+
+ buffer = state->selection.buffer;
+ bufcur = 0;
+ }
+ }
+
+ if (n) {
+ state->tmp.selection.recvpartial = (uint32_t)(n << 24) | x;
+ }
+ }
+}
+
+static int on_osc(int command, VTermStringFragment frag, void *user)
+{
+ VTermState *state = user;
+
+ switch (command) {
+ case 0:
+ settermprop_string(state, VTERM_PROP_ICONNAME, frag);
+ settermprop_string(state, VTERM_PROP_TITLE, frag);
+ return 1;
+
+ case 1:
+ settermprop_string(state, VTERM_PROP_ICONNAME, frag);
+ return 1;
+
+ case 2:
+ settermprop_string(state, VTERM_PROP_TITLE, frag);
+ return 1;
+
+ case 52:
+ if (state->selection.callbacks) {
+ osc_selection(state, frag);
+ }
+
+ return 1;
+
+ default:
+ if (state->fallbacks && state->fallbacks->osc) {
+ if ((*state->fallbacks->osc)(command, frag, state->fbdata)) {
+ return 1;
+ }
+ }
+ }
+
+ return 0;
+}
+
+static void request_status_string(VTermState *state, VTermStringFragment frag)
+{
+ VTerm *vt = state->vt;
+
+ char *tmp = state->tmp.decrqss;
+
+ if (frag.initial) {
+ tmp[0] = tmp[1] = tmp[2] = tmp[3] = 0;
+ }
+
+ size_t i = 0;
+ while (i < sizeof(state->tmp.decrqss) - 1 && tmp[i]) {
+ i++;
+ }
+ while (i < sizeof(state->tmp.decrqss) - 1 && frag.len--) {
+ tmp[i++] = (frag.str++)[0];
+ }
+ tmp[i] = 0;
+
+ if (!frag.final) {
+ return;
+ }
+
+ switch (tmp[0] | tmp[1] << 8 | tmp[2] << 16) {
+ case 'm': {
+ // Query SGR
+ long args[20];
+ int argc = vterm_state_getpen(state, args, sizeof(args)/sizeof(args[0]));
+ size_t cur = 0;
+
+ cur += (size_t)snprintf(vt->tmpbuffer + cur, vt->tmpbuffer_len - cur,
+ vt->mode.ctrl8bit ? "\x90" "1$r" : ESC_S "P" "1$r"); // DCS 1$r ...
+ if (cur >= vt->tmpbuffer_len) {
+ return;
+ }
+
+ for (int argi = 0; argi < argc; argi++) {
+ cur += (size_t)snprintf(vt->tmpbuffer + cur, vt->tmpbuffer_len - cur,
+ argi == argc - 1 ? "%ld"
+ : CSI_ARG_HAS_MORE(args[argi]) ? "%ld:"
+ : "%ld;",
+ CSI_ARG(args[argi]));
+ if (cur >= vt->tmpbuffer_len) {
+ return;
+ }
+ }
+
+ cur += (size_t)snprintf(vt->tmpbuffer + cur, vt->tmpbuffer_len - cur,
+ vt->mode.ctrl8bit ? "m" "\x9C" : "m" ESC_S "\\"); // ... m ST
+ if (cur >= vt->tmpbuffer_len) {
+ return;
+ }
+
+ vterm_push_output_bytes(vt, vt->tmpbuffer, cur);
+ return;
+ }
+
+ case 'r':
+ // Query DECSTBM
+ vterm_push_output_sprintf_str(vt, C1_DCS, true,
+ "1$r%d;%dr", state->scrollregion_top + 1,
+ SCROLLREGION_BOTTOM(state));
+ return;
+
+ case 's':
+ // Query DECSLRM
+ vterm_push_output_sprintf_str(vt, C1_DCS, true,
+ "1$r%d;%ds", SCROLLREGION_LEFT(state) + 1,
+ SCROLLREGION_RIGHT(state));
+ return;
+
+ case ' '|('q' << 8): {
+ // Query DECSCUSR
+ int reply = 0;
+ switch (state->mode.cursor_shape) {
+ case VTERM_PROP_CURSORSHAPE_BLOCK:
+ reply = 2; break;
+ case VTERM_PROP_CURSORSHAPE_UNDERLINE:
+ reply = 4; break;
+ case VTERM_PROP_CURSORSHAPE_BAR_LEFT:
+ reply = 6; break;
+ }
+ if (state->mode.cursor_blink) {
+ reply--;
+ }
+ vterm_push_output_sprintf_str(vt, C1_DCS, true,
+ "1$r%d q", reply);
+ return;
+ }
+
+ case '\"'|('q' << 8):
+ // Query DECSCA
+ vterm_push_output_sprintf_str(vt, C1_DCS, true,
+ "1$r%d\"q", state->protected_cell ? 1 : 2);
+ return;
+ }
+
+ vterm_push_output_sprintf_str(state->vt, C1_DCS, true, "0$r");
+}
+
+static int on_dcs(const char *command, size_t commandlen, VTermStringFragment frag, void *user)
+{
+ VTermState *state = user;
+
+ if (commandlen == 2 && strneq(command, "$q", 2)) {
+ request_status_string(state, frag);
+ return 1;
+ } else if (state->fallbacks && state->fallbacks->dcs) {
+ if ((*state->fallbacks->dcs)(command, commandlen, frag, state->fbdata)) {
+ return 1;
+ }
+ }
+
+ DEBUG_LOG("libvterm: Unhandled DCS %.*s\n", (int)commandlen, command);
+ return 0;
+}
+
+static int on_apc(VTermStringFragment frag, void *user)
+{
+ VTermState *state = user;
+
+ if (state->fallbacks && state->fallbacks->apc) {
+ if ((*state->fallbacks->apc)(frag, state->fbdata)) {
+ return 1;
+ }
+ }
+
+ // No DEBUG_LOG because all APCs are unhandled
+ return 0;
+}
+
+static int on_pm(VTermStringFragment frag, void *user)
+{
+ VTermState *state = user;
+
+ if (state->fallbacks && state->fallbacks->pm) {
+ if ((*state->fallbacks->pm)(frag, state->fbdata)) {
+ return 1;
+ }
+ }
+
+ // No DEBUG_LOG because all PMs are unhandled
+ return 0;
+}
+
+static int on_sos(VTermStringFragment frag, void *user)
+{
+ VTermState *state = user;
+
+ if (state->fallbacks && state->fallbacks->sos) {
+ if ((*state->fallbacks->sos)(frag, state->fbdata)) {
+ return 1;
+ }
+ }
+
+ // No DEBUG_LOG because all SOSs are unhandled
+ return 0;
+}
+
+static int on_resize(int rows, int cols, void *user)
+{
+ VTermState *state = user;
+ VTermPos oldpos = state->pos;
+
+ if (cols != state->cols) {
+ uint8_t *newtabstops = vterm_allocator_malloc(state->vt, ((size_t)cols + 7) / 8);
+
+ // TODO(vterm): This can all be done much more efficiently bytewise
+ int col;
+ for (col = 0; col < state->cols && col < cols; col++) {
+ uint8_t mask = (uint8_t)(1 << (col & 7));
+ if (state->tabstops[col >> 3] & mask) {
+ newtabstops[col >> 3] |= mask;
+ } else {
+ newtabstops[col >> 3] &= ~mask;
+ }
+ }
+
+ for (; col < cols; col++) {
+ uint8_t mask = (uint8_t)(1 << (col & 7));
+ if (col % 8 == 0) {
+ newtabstops[col >> 3] |= mask;
+ } else {
+ newtabstops[col >> 3] &= ~mask;
+ }
+ }
+
+ vterm_allocator_free(state->vt, state->tabstops);
+ state->tabstops = newtabstops;
+ }
+
+ state->rows = rows;
+ state->cols = cols;
+
+ if (state->scrollregion_bottom > -1) {
+ UBOUND(state->scrollregion_bottom, state->rows);
+ }
+ if (state->scrollregion_right > -1) {
+ UBOUND(state->scrollregion_right, state->cols);
+ }
+
+ VTermStateFields fields = {
+ .pos = state->pos,
+ .lineinfos = {[0] = state->lineinfos[0], [1] = state->lineinfos[1] },
+ };
+
+ if (state->callbacks && state->callbacks->resize) {
+ (*state->callbacks->resize)(rows, cols, &fields, state->cbdata);
+ state->pos = fields.pos;
+
+ state->lineinfos[0] = fields.lineinfos[0];
+ state->lineinfos[1] = fields.lineinfos[1];
+ } else {
+ if (rows != state->rows) {
+ for (int bufidx = BUFIDX_PRIMARY; bufidx <= BUFIDX_ALTSCREEN; bufidx++) {
+ VTermLineInfo *oldlineinfo = state->lineinfos[bufidx];
+ if (!oldlineinfo) {
+ continue;
+ }
+
+ VTermLineInfo *newlineinfo = vterm_allocator_malloc(state->vt,
+ (size_t)rows * sizeof(VTermLineInfo));
+
+ int row;
+ for (row = 0; row < state->rows && row < rows; row++) {
+ newlineinfo[row] = oldlineinfo[row];
+ }
+
+ for (; row < rows; row++) {
+ newlineinfo[row] = (VTermLineInfo){
+ .doublewidth = 0,
+ };
+ }
+
+ vterm_allocator_free(state->vt, state->lineinfos[bufidx]);
+ state->lineinfos[bufidx] = newlineinfo;
+ }
+ }
+ }
+
+ state->lineinfo = state->lineinfos[state->mode.alt_screen ? BUFIDX_ALTSCREEN : BUFIDX_PRIMARY];
+
+ if (state->at_phantom && state->pos.col < cols - 1) {
+ state->at_phantom = 0;
+ state->pos.col++;
+ }
+
+ if (state->pos.row < 0) {
+ state->pos.row = 0;
+ }
+ if (state->pos.row >= rows) {
+ state->pos.row = rows - 1;
+ }
+ if (state->pos.col < 0) {
+ state->pos.col = 0;
+ }
+ if (state->pos.col >= cols) {
+ state->pos.col = cols - 1;
+ }
+
+ updatecursor(state, &oldpos, 1);
+
+ return 1;
+}
+
+static const VTermParserCallbacks parser_callbacks = {
+ .text = on_text,
+ .control = on_control,
+ .escape = on_escape,
+ .csi = on_csi,
+ .osc = on_osc,
+ .dcs = on_dcs,
+ .apc = on_apc,
+ .pm = on_pm,
+ .sos = on_sos,
+ .resize = on_resize,
+};
+
+VTermState *vterm_obtain_state(VTerm *vt)
+{
+ if (vt->state) {
+ return vt->state;
+ }
+
+ VTermState *state = vterm_state_new(vt);
+ vt->state = state;
+
+ vterm_parser_set_callbacks(vt, &parser_callbacks, state);
+
+ return state;
+}
+
+void vterm_state_reset(VTermState *state, int hard)
+{
+ state->scrollregion_top = 0;
+ state->scrollregion_bottom = -1;
+ state->scrollregion_left = 0;
+ state->scrollregion_right = -1;
+
+ state->mode.keypad = 0;
+ state->mode.cursor = 0;
+ state->mode.autowrap = 1;
+ state->mode.insert = 0;
+ state->mode.newline = 0;
+ state->mode.alt_screen = 0;
+ state->mode.origin = 0;
+ state->mode.leftrightmargin = 0;
+ state->mode.bracketpaste = 0;
+ state->mode.report_focus = 0;
+
+ state->mouse_flags = 0;
+
+ state->vt->mode.ctrl8bit = 0;
+
+ for (int col = 0; col < state->cols; col++) {
+ if (col % 8 == 0) {
+ set_col_tabstop(state, col);
+ } else {
+ clear_col_tabstop(state, col);
+ }
+ }
+
+ for (int row = 0; row < state->rows; row++) {
+ set_lineinfo(state, row, FORCE, DWL_OFF, DHL_OFF);
+ }
+
+ if (state->callbacks && state->callbacks->initpen) {
+ (*state->callbacks->initpen)(state->cbdata);
+ }
+
+ vterm_state_resetpen(state);
+
+ VTermEncoding *default_enc = state->vt->mode.utf8
+ ? vterm_lookup_encoding(ENC_UTF8, 'u')
+ : vterm_lookup_encoding(ENC_SINGLE_94, 'B');
+
+ for (int i = 0; i < 4; i++) {
+ state->encoding[i].enc = default_enc;
+ if (default_enc->init) {
+ (*default_enc->init)(default_enc, state->encoding[i].data);
+ }
+ }
+
+ state->gl_set = 0;
+ state->gr_set = 1;
+ state->gsingle_set = 0;
+
+ state->protected_cell = 0;
+
+ // Initialise the props
+ settermprop_bool(state, VTERM_PROP_CURSORVISIBLE, 1);
+ settermprop_bool(state, VTERM_PROP_CURSORBLINK, 1);
+ settermprop_int(state, VTERM_PROP_CURSORSHAPE, VTERM_PROP_CURSORSHAPE_BLOCK);
+
+ if (hard) {
+ state->pos.row = 0;
+ state->pos.col = 0;
+ state->at_phantom = 0;
+
+ VTermRect rect = { 0, state->rows, 0, state->cols };
+ erase(state, rect, 0);
+ }
+}
+
+void vterm_state_set_callbacks(VTermState *state, const VTermStateCallbacks *callbacks, void *user)
+{
+ if (callbacks) {
+ state->callbacks = callbacks;
+ state->cbdata = user;
+
+ if (state->callbacks && state->callbacks->initpen) {
+ (*state->callbacks->initpen)(state->cbdata);
+ }
+ } else {
+ state->callbacks = NULL;
+ state->cbdata = NULL;
+ }
+}
+
+void vterm_state_set_unrecognised_fallbacks(VTermState *state, const VTermStateFallbacks *fallbacks,
+ void *user)
+{
+ if (fallbacks) {
+ state->fallbacks = fallbacks;
+ state->fbdata = user;
+ } else {
+ state->fallbacks = NULL;
+ state->fbdata = NULL;
+ }
+}
+
+int vterm_state_set_termprop(VTermState *state, VTermProp prop, VTermValue *val)
+{
+ // Only store the new value of the property if usercode said it was happy. This is especially
+ // important for altscreen switching
+ if (state->callbacks && state->callbacks->settermprop) {
+ if (!(*state->callbacks->settermprop)(prop, val, state->cbdata)) {
+ return 0;
+ }
+ }
+
+ switch (prop) {
+ case VTERM_PROP_TITLE:
+ case VTERM_PROP_ICONNAME:
+ // we don't store these, just transparently pass through
+ return 1;
+ case VTERM_PROP_CURSORVISIBLE:
+ state->mode.cursor_visible = (unsigned)val->boolean;
+ return 1;
+ case VTERM_PROP_CURSORBLINK:
+ state->mode.cursor_blink = (unsigned)val->boolean;
+ return 1;
+ case VTERM_PROP_CURSORSHAPE:
+ state->mode.cursor_shape = (unsigned)val->number;
+ return 1;
+ case VTERM_PROP_REVERSE:
+ state->mode.screen = (unsigned)val->boolean;
+ return 1;
+ case VTERM_PROP_ALTSCREEN:
+ state->mode.alt_screen = (unsigned)val->boolean;
+ state->lineinfo = state->lineinfos[state->mode.alt_screen ? BUFIDX_ALTSCREEN : BUFIDX_PRIMARY];
+ if (state->mode.alt_screen) {
+ VTermRect rect = {
+ .start_row = 0,
+ .start_col = 0,
+ .end_row = state->rows,
+ .end_col = state->cols,
+ };
+ erase(state, rect, 0);
+ }
+ return 1;
+ case VTERM_PROP_MOUSE:
+ state->mouse_flags = 0;
+ if (val->number) {
+ state->mouse_flags |= MOUSE_WANT_CLICK;
+ }
+ if (val->number == VTERM_PROP_MOUSE_DRAG) {
+ state->mouse_flags |= MOUSE_WANT_DRAG;
+ }
+ if (val->number == VTERM_PROP_MOUSE_MOVE) {
+ state->mouse_flags |= MOUSE_WANT_MOVE;
+ }
+ return 1;
+ case VTERM_PROP_FOCUSREPORT:
+ state->mode.report_focus = (unsigned)val->boolean;
+ return 1;
+ case VTERM_PROP_THEMEUPDATES:
+ state->mode.theme_updates = (unsigned)val->boolean;
+ return 1;
+
+ case VTERM_N_PROPS:
+ return 0;
+ }
+
+ return 0;
+}
+
+void vterm_state_focus_in(VTermState *state)
+{
+ if (state->mode.report_focus) {
+ vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "I");
+ }
+}
+
+void vterm_state_focus_out(VTermState *state)
+{
+ if (state->mode.report_focus) {
+ vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "O");
+ }
+}
+
+const VTermLineInfo *vterm_state_get_lineinfo(const VTermState *state, int row)
+{
+ return state->lineinfo + row;
+}
+
+void vterm_state_set_selection_callbacks(VTermState *state,
+ const VTermSelectionCallbacks *callbacks, void *user,
+ char *buffer, size_t buflen)
+{
+ if (buflen && !buffer) {
+ buffer = vterm_allocator_malloc(state->vt, buflen);
+ }
+
+ state->selection.callbacks = callbacks;
+ state->selection.user = user;
+ state->selection.buffer = buffer;
+ state->selection.buflen = buflen;
+}
diff --git a/src/nvim/vterm/state.h b/src/nvim/vterm/state.h
new file mode 100644
index 0000000000..2f59cf7eec
--- /dev/null
+++ b/src/nvim/vterm/state.h
@@ -0,0 +1,7 @@
+#pragma once
+
+#include "nvim/vterm/vterm_defs.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "vterm/state.h.generated.h"
+#endif
diff --git a/src/nvim/vterm/vterm.c b/src/nvim/vterm/vterm.c
new file mode 100644
index 0000000000..76d5dc3808
--- /dev/null
+++ b/src/nvim/vterm/vterm.c
@@ -0,0 +1,335 @@
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "auto/config.h"
+#include "nvim/memory.h"
+#include "nvim/vterm/screen.h"
+#include "nvim/vterm/state.h"
+#include "nvim/vterm/vterm.h"
+#include "nvim/vterm/vterm_internal_defs.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "vterm/vterm.c.generated.h"
+#endif
+
+// *****************
+// * API functions *
+// *****************
+
+static void *default_malloc(size_t size, void *allocdata)
+{
+ void *ptr = xmalloc(size);
+ if (ptr) {
+ memset(ptr, 0, size);
+ }
+ return ptr;
+}
+
+static void default_free(void *ptr, void *allocdata)
+{
+ xfree(ptr);
+}
+
+static VTermAllocatorFunctions default_allocator = {
+ .malloc = &default_malloc,
+ .free = &default_free,
+};
+
+/// Convenient shortcut for default cases
+VTerm *vterm_new(int rows, int cols)
+{
+ return vterm_build(&(const struct VTermBuilder){
+ .rows = rows,
+ .cols = cols,
+ });
+}
+
+// A handy macro for defaulting values out of builder fields
+#define DEFAULT(v, def) ((v) ? (v) : (def))
+
+VTerm *vterm_build(const struct VTermBuilder *builder)
+{
+ const VTermAllocatorFunctions *allocator = DEFAULT(builder->allocator, &default_allocator);
+
+ // Need to bootstrap using the allocator function directly
+ VTerm *vt = (*allocator->malloc)(sizeof(VTerm), builder->allocdata);
+
+ vt->allocator = allocator;
+ vt->allocdata = builder->allocdata;
+
+ vt->rows = builder->rows;
+ vt->cols = builder->cols;
+
+ vt->parser.state = NORMAL;
+
+ vt->parser.callbacks = NULL;
+ vt->parser.cbdata = NULL;
+
+ vt->parser.emit_nul = false;
+
+ vt->outfunc = NULL;
+ vt->outdata = NULL;
+
+ vt->outbuffer_len = DEFAULT(builder->outbuffer_len, 4096);
+ vt->outbuffer_cur = 0;
+ vt->outbuffer = vterm_allocator_malloc(vt, vt->outbuffer_len);
+
+ vt->tmpbuffer_len = DEFAULT(builder->tmpbuffer_len, 4096);
+ vt->tmpbuffer = vterm_allocator_malloc(vt, vt->tmpbuffer_len);
+
+ return vt;
+}
+
+void vterm_free(VTerm *vt)
+{
+ if (vt->screen) {
+ vterm_screen_free(vt->screen);
+ }
+
+ if (vt->state) {
+ vterm_state_free(vt->state);
+ }
+
+ vterm_allocator_free(vt, vt->outbuffer);
+ vterm_allocator_free(vt, vt->tmpbuffer);
+
+ vterm_allocator_free(vt, vt);
+}
+
+void *vterm_allocator_malloc(VTerm *vt, size_t size)
+{
+ return (*vt->allocator->malloc)(size, vt->allocdata);
+}
+
+void vterm_allocator_free(VTerm *vt, void *ptr)
+{
+ (*vt->allocator->free)(ptr, vt->allocdata);
+}
+
+void vterm_get_size(const VTerm *vt, int *rowsp, int *colsp)
+{
+ if (rowsp) {
+ *rowsp = vt->rows;
+ }
+ if (colsp) {
+ *colsp = vt->cols;
+ }
+}
+
+void vterm_set_size(VTerm *vt, int rows, int cols)
+{
+ if (rows < 1 || cols < 1) {
+ return;
+ }
+
+ vt->rows = rows;
+ vt->cols = cols;
+
+ if (vt->parser.callbacks && vt->parser.callbacks->resize) {
+ (*vt->parser.callbacks->resize)(rows, cols, vt->parser.cbdata);
+ }
+}
+
+void vterm_set_utf8(VTerm *vt, int is_utf8)
+{
+ vt->mode.utf8 = (unsigned)is_utf8;
+}
+
+void vterm_output_set_callback(VTerm *vt, VTermOutputCallback *func, void *user)
+{
+ vt->outfunc = func;
+ vt->outdata = user;
+}
+
+void vterm_push_output_bytes(VTerm *vt, const char *bytes, size_t len)
+{
+ if (vt->outfunc) {
+ (vt->outfunc)(bytes, len, vt->outdata);
+ return;
+ }
+
+ if (len > vt->outbuffer_len - vt->outbuffer_cur) {
+ return;
+ }
+
+ memcpy(vt->outbuffer + vt->outbuffer_cur, bytes, len);
+ vt->outbuffer_cur += len;
+}
+
+void vterm_push_output_sprintf(VTerm *vt, const char *format, ...)
+ FUNC_ATTR_PRINTF(2, 3)
+{
+ va_list args;
+ va_start(args, format);
+ size_t len = (size_t)vsnprintf(vt->tmpbuffer, vt->tmpbuffer_len, format, args);
+ vterm_push_output_bytes(vt, vt->tmpbuffer, len);
+ va_end(args);
+}
+
+void vterm_push_output_sprintf_ctrl(VTerm *vt, uint8_t ctrl, const char *fmt, ...)
+ FUNC_ATTR_PRINTF(3, 4)
+{
+ size_t cur;
+
+ if (ctrl >= 0x80 && !vt->mode.ctrl8bit) {
+ cur = (size_t)snprintf(vt->tmpbuffer, vt->tmpbuffer_len, ESC_S "%c", ctrl - 0x40);
+ } else {
+ cur = (size_t)snprintf(vt->tmpbuffer, vt->tmpbuffer_len, "%c", ctrl);
+ }
+
+ if (cur >= vt->tmpbuffer_len) {
+ return;
+ }
+
+ va_list args;
+ va_start(args, fmt);
+ cur += (size_t)vsnprintf(vt->tmpbuffer + cur, vt->tmpbuffer_len - cur, fmt, args);
+ va_end(args);
+
+ if (cur >= vt->tmpbuffer_len) {
+ return;
+ }
+
+ vterm_push_output_bytes(vt, vt->tmpbuffer, cur);
+}
+
+void vterm_push_output_sprintf_str(VTerm *vt, uint8_t ctrl, bool term, const char *fmt, ...)
+ FUNC_ATTR_PRINTF(4, 5)
+{
+ size_t cur = 0;
+
+ if (ctrl) {
+ if (ctrl >= 0x80 && !vt->mode.ctrl8bit) {
+ cur = (size_t)snprintf(vt->tmpbuffer, vt->tmpbuffer_len, ESC_S "%c", ctrl - 0x40);
+ } else {
+ cur = (size_t)snprintf(vt->tmpbuffer, vt->tmpbuffer_len, "%c", ctrl);
+ }
+
+ if (cur >= vt->tmpbuffer_len) {
+ return;
+ }
+ }
+
+ va_list args;
+ va_start(args, fmt);
+ cur += (size_t)vsnprintf(vt->tmpbuffer + cur, vt->tmpbuffer_len - cur, fmt, args);
+ va_end(args);
+
+ if (cur >= vt->tmpbuffer_len) {
+ return;
+ }
+
+ if (term) {
+ cur += (size_t)snprintf(vt->tmpbuffer + cur, vt->tmpbuffer_len - cur,
+ vt->mode.ctrl8bit ? "\x9C" : ESC_S "\\"); // ST
+
+ if (cur >= vt->tmpbuffer_len) {
+ return;
+ }
+ }
+
+ vterm_push_output_bytes(vt, vt->tmpbuffer, cur);
+}
+
+VTermValueType vterm_get_attr_type(VTermAttr attr)
+{
+ switch (attr) {
+ case VTERM_ATTR_BOLD:
+ return VTERM_VALUETYPE_BOOL;
+ case VTERM_ATTR_UNDERLINE:
+ return VTERM_VALUETYPE_INT;
+ case VTERM_ATTR_ITALIC:
+ return VTERM_VALUETYPE_BOOL;
+ case VTERM_ATTR_BLINK:
+ return VTERM_VALUETYPE_BOOL;
+ case VTERM_ATTR_REVERSE:
+ return VTERM_VALUETYPE_BOOL;
+ case VTERM_ATTR_CONCEAL:
+ return VTERM_VALUETYPE_BOOL;
+ case VTERM_ATTR_STRIKE:
+ return VTERM_VALUETYPE_BOOL;
+ case VTERM_ATTR_FONT:
+ return VTERM_VALUETYPE_INT;
+ case VTERM_ATTR_FOREGROUND:
+ return VTERM_VALUETYPE_COLOR;
+ case VTERM_ATTR_BACKGROUND:
+ return VTERM_VALUETYPE_COLOR;
+ case VTERM_ATTR_SMALL:
+ return VTERM_VALUETYPE_BOOL;
+ case VTERM_ATTR_BASELINE:
+ return VTERM_VALUETYPE_INT;
+ case VTERM_ATTR_URI:
+ return VTERM_VALUETYPE_INT;
+
+ case VTERM_N_ATTRS:
+ return 0;
+ }
+ return 0; // UNREACHABLE
+}
+
+void vterm_scroll_rect(VTermRect rect, int downward, int rightward,
+ int (*moverect)(VTermRect src, VTermRect dest, void *user),
+ int (*eraserect)(VTermRect rect, int selective, void *user), void *user)
+{
+ VTermRect src;
+ VTermRect dest;
+
+ if (abs(downward) >= rect.end_row - rect.start_row
+ || abs(rightward) >= rect.end_col - rect.start_col) {
+ // Scroll more than area; just erase the lot
+ (*eraserect)(rect, 0, user);
+ return;
+ }
+
+ if (rightward >= 0) {
+ // rect: [XXX................]
+ // src: [----------------]
+ // dest: [----------------]
+ dest.start_col = rect.start_col;
+ dest.end_col = rect.end_col - rightward;
+ src.start_col = rect.start_col + rightward;
+ src.end_col = rect.end_col;
+ } else {
+ // rect: [................XXX]
+ // src: [----------------]
+ // dest: [----------------]
+ int leftward = -rightward;
+ dest.start_col = rect.start_col + leftward;
+ dest.end_col = rect.end_col;
+ src.start_col = rect.start_col;
+ src.end_col = rect.end_col - leftward;
+ }
+
+ if (downward >= 0) {
+ dest.start_row = rect.start_row;
+ dest.end_row = rect.end_row - downward;
+ src.start_row = rect.start_row + downward;
+ src.end_row = rect.end_row;
+ } else {
+ int upward = -downward;
+ dest.start_row = rect.start_row + upward;
+ dest.end_row = rect.end_row;
+ src.start_row = rect.start_row;
+ src.end_row = rect.end_row - upward;
+ }
+
+ if (moverect) {
+ (*moverect)(dest, src, user);
+ }
+
+ if (downward > 0) {
+ rect.start_row = rect.end_row - downward;
+ } else if (downward < 0) {
+ rect.end_row = rect.start_row - downward;
+ }
+
+ if (rightward > 0) {
+ rect.start_col = rect.end_col - rightward;
+ } else if (rightward < 0) {
+ rect.end_col = rect.start_col - rightward;
+ }
+
+ (*eraserect)(rect, 0, user);
+}
diff --git a/src/nvim/vterm/vterm.h b/src/nvim/vterm/vterm.h
new file mode 100644
index 0000000000..e66f40425a
--- /dev/null
+++ b/src/nvim/vterm/vterm.h
@@ -0,0 +1,161 @@
+#pragma once
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "nvim/macros_defs.h"
+#include "nvim/types_defs.h"
+#include "nvim/vterm/vterm_defs.h"
+#include "nvim/vterm/vterm_keycodes_defs.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "vterm/vterm.h.generated.h"
+#endif
+
+#define VTERM_VERSION_MAJOR 0
+#define VTERM_VERSION_MINOR 3
+
+// move a rect
+static inline void vterm_rect_move(VTermRect *rect, int row_delta, int col_delta)
+{
+ rect->start_row += row_delta; rect->end_row += row_delta;
+ rect->start_col += col_delta; rect->end_col += col_delta;
+}
+
+// Bit-field describing the content of the tagged union `VTermColor`.
+typedef enum {
+ // If the lower bit of `type` is not set, the colour is 24-bit RGB.
+ VTERM_COLOR_RGB = 0x00,
+
+ // The colour is an index into a palette of 256 colours.
+ VTERM_COLOR_INDEXED = 0x01,
+
+ // Mask that can be used to extract the RGB/Indexed bit.
+ VTERM_COLOR_TYPE_MASK = 0x01,
+
+ // If set, indicates that this colour should be the default foreground color, i.e. there was no
+ // SGR request for another colour. When rendering this colour it is possible to ignore "idx" and
+ // just use a colour that is not in the palette.
+ VTERM_COLOR_DEFAULT_FG = 0x02,
+
+ // If set, indicates that this colour should be the default background color, i.e. there was no
+ // SGR request for another colour. A common option when rendering this colour is to not render a
+ // background at all, for example by rendering the window transparently at this spot.
+ VTERM_COLOR_DEFAULT_BG = 0x04,
+
+ // Mask that can be used to extract the default foreground/background bit.
+ VTERM_COLOR_DEFAULT_MASK = 0x06,
+} VTermColorType;
+
+// Returns true if the VTERM_COLOR_RGB `type` flag is set, indicating that the given VTermColor
+// instance is an indexed colour.
+#define VTERM_COLOR_IS_INDEXED(col) \
+ (((col)->type & VTERM_COLOR_TYPE_MASK) == VTERM_COLOR_INDEXED)
+
+// Returns true if the VTERM_COLOR_INDEXED `type` flag is set, indicating that the given VTermColor
+// instance is an rgb colour.
+#define VTERM_COLOR_IS_RGB(col) \
+ (((col)->type & VTERM_COLOR_TYPE_MASK) == VTERM_COLOR_RGB)
+
+// Returns true if the VTERM_COLOR_DEFAULT_FG `type` flag is set, indicating that the given
+// VTermColor instance corresponds to the default foreground color.
+#define VTERM_COLOR_IS_DEFAULT_FG(col) \
+ (!!((col)->type & VTERM_COLOR_DEFAULT_FG))
+
+// Returns true if the VTERM_COLOR_DEFAULT_BG `type` flag is set, indicating that the given
+// VTermColor instance corresponds to the default background color.
+#define VTERM_COLOR_IS_DEFAULT_BG(col) \
+ (!!((col)->type & VTERM_COLOR_DEFAULT_BG))
+
+// Constructs a new VTermColor instance representing the given RGB values.
+static inline void vterm_color_rgb(VTermColor *col, uint8_t red, uint8_t green, uint8_t blue)
+{
+ col->type = VTERM_COLOR_RGB;
+ col->rgb.red = red;
+ col->rgb.green = green;
+ col->rgb.blue = blue;
+}
+
+// Construct a new VTermColor instance representing an indexed color with the given index.
+static inline void vterm_color_indexed(VTermColor *col, uint8_t idx)
+{
+ col->type = VTERM_COLOR_INDEXED;
+ col->indexed.idx = idx;
+}
+
+// ------------
+// Parser layer
+// ------------
+
+/// Flag to indicate non-final subparameters in a single CSI parameter.
+/// Consider
+/// CSI 1;2:3:4;5a
+/// 1 4 and 5 are final.
+/// 2 and 3 are non-final and will have this bit set
+///
+/// Don't confuse this with the final byte of the CSI escape; 'a' in this case.
+#define CSI_ARG_FLAG_MORE (1U << 31)
+#define CSI_ARG_MASK (~(1U << 31))
+
+#define CSI_ARG_HAS_MORE(a) ((a)& CSI_ARG_FLAG_MORE)
+#define CSI_ARG(a) ((a)& CSI_ARG_MASK)
+
+// Can't use -1 to indicate a missing argument; use this instead
+#define CSI_ARG_MISSING ((1UL<<31) - 1)
+
+#define CSI_ARG_IS_MISSING(a) (CSI_ARG(a) == CSI_ARG_MISSING)
+#define CSI_ARG_OR(a, def) (CSI_ARG(a) == CSI_ARG_MISSING ? (def) : CSI_ARG(a))
+#define CSI_ARG_COUNT(a) (CSI_ARG(a) == CSI_ARG_MISSING || CSI_ARG(a) == 0 ? 1 : CSI_ARG(a))
+
+enum {
+ VTERM_UNDERLINE_OFF,
+ VTERM_UNDERLINE_SINGLE,
+ VTERM_UNDERLINE_DOUBLE,
+ VTERM_UNDERLINE_CURLY,
+};
+
+enum {
+ VTERM_BASELINE_NORMAL,
+ VTERM_BASELINE_RAISE,
+ VTERM_BASELINE_LOWER,
+};
+
+// Back-compat alias for the brief time it was in 0.3-RC1
+#define vterm_screen_set_reflow vterm_screen_enable_reflow
+
+void vterm_scroll_rect(VTermRect rect, int downward, int rightward,
+ int (*moverect)(VTermRect src, VTermRect dest, void *user),
+ int (*eraserect)(VTermRect rect, int selective, void *user), void *user);
+
+struct VTermScreen {
+ VTerm *vt;
+ VTermState *state;
+
+ const VTermScreenCallbacks *callbacks;
+ void *cbdata;
+
+ VTermDamageSize damage_merge;
+ // start_row == -1 => no damage
+ VTermRect damaged;
+ VTermRect pending_scrollrect;
+ int pending_scroll_downward, pending_scroll_rightward;
+
+ int rows;
+ int cols;
+
+ unsigned global_reverse : 1;
+ unsigned reflow : 1;
+
+ // Primary and Altscreen. buffers[1] is lazily allocated as needed
+ ScreenCell *buffers[2];
+
+ // buffer will == buffers[0] or buffers[1], depending on altscreen
+ ScreenCell *buffer;
+
+ // buffer for a single screen row used in scrollback storage callbacks
+ VTermScreenCell *sb_buffer;
+
+ ScreenPen pen;
+};
diff --git a/src/nvim/vterm/vterm_defs.h b/src/nvim/vterm/vterm_defs.h
new file mode 100644
index 0000000000..9aa933bef0
--- /dev/null
+++ b/src/nvim/vterm/vterm_defs.h
@@ -0,0 +1,322 @@
+#pragma once
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "nvim/types_defs.h"
+
+typedef struct VTerm VTerm;
+typedef struct VTermState VTermState;
+typedef struct VTermScreen VTermScreen;
+
+typedef struct {
+ int row;
+ int col;
+} VTermPos;
+
+// some small utility functions; we can just keep these static here
+
+typedef struct {
+ int start_row;
+ int end_row;
+ int start_col;
+ int end_col;
+} VTermRect;
+
+// Tagged union storing either an RGB color or an index into a colour palette. In order to convert
+// indexed colours to RGB, you may use the vterm_state_convert_color_to_rgb() or
+// vterm_screen_convert_color_to_rgb() functions which lookup the RGB colour from the palette
+// maintained by a VTermState or VTermScreen instance.
+typedef union {
+ // Tag indicating which union member is actually valid. This variable coincides with the `type`
+ // member of the `rgb` and the `indexed` struct in memory. Please use the `VTERM_COLOR_IS_*` test
+ // macros to check whether a particular type flag is set.
+ uint8_t type;
+
+ // Valid if `VTERM_COLOR_IS_RGB(type)` is true. Holds the RGB colour values.
+ struct {
+ // Same as the top-level `type` member stored in VTermColor.
+ uint8_t type;
+
+ // The actual 8-bit red, green, blue colour values.
+ uint8_t red, green, blue;
+ } rgb;
+
+ // If `VTERM_COLOR_IS_INDEXED(type)` is true, this member holds the index into the colour palette.
+ struct {
+ // Same as the top-level `type` member stored in VTermColor.
+ uint8_t type;
+
+ // Index into the colour map.
+ uint8_t idx;
+ } indexed;
+} VTermColor;
+
+typedef struct {
+ unsigned bold : 1;
+ unsigned underline : 2;
+ unsigned italic : 1;
+ unsigned blink : 1;
+ unsigned reverse : 1;
+ unsigned conceal : 1;
+ unsigned strike : 1;
+ unsigned font : 4; // 0 to 9
+ unsigned dwl : 1; // On a DECDWL or DECDHL line
+ unsigned dhl : 2; // On a DECDHL line (1=top 2=bottom)
+ unsigned small : 1;
+ unsigned baseline : 2;
+} VTermScreenCellAttrs;
+
+typedef struct {
+ schar_T schar;
+ char width;
+ VTermScreenCellAttrs attrs;
+ VTermColor fg, bg;
+ int uri;
+} VTermScreenCell;
+
+typedef enum {
+ // VTERM_PROP_NONE = 0
+ VTERM_PROP_CURSORVISIBLE = 1, // bool
+ VTERM_PROP_CURSORBLINK, // bool
+ VTERM_PROP_ALTSCREEN, // bool
+ VTERM_PROP_TITLE, // string
+ VTERM_PROP_ICONNAME, // string
+ VTERM_PROP_REVERSE, // bool
+ VTERM_PROP_CURSORSHAPE, // number
+ VTERM_PROP_MOUSE, // number
+ VTERM_PROP_FOCUSREPORT, // bool
+ VTERM_PROP_THEMEUPDATES, // bool
+
+ VTERM_N_PROPS,
+} VTermProp;
+
+typedef struct {
+ const char *str;
+ size_t len : 30;
+ bool initial : 1;
+ bool final : 1;
+} VTermStringFragment;
+
+typedef union {
+ int boolean;
+ int number;
+ VTermStringFragment string;
+ VTermColor color;
+} VTermValue;
+
+typedef struct {
+ int (*damage)(VTermRect rect, void *user);
+ int (*moverect)(VTermRect dest, VTermRect src, void *user);
+ int (*movecursor)(VTermPos pos, VTermPos oldpos, int visible, void *user);
+ int (*settermprop)(VTermProp prop, VTermValue *val, void *user);
+ int (*bell)(void *user);
+ int (*resize)(int rows, int cols, void *user);
+ int (*theme)(bool *dark, void *user);
+ int (*sb_pushline)(int cols, const VTermScreenCell *cells, void *user);
+ int (*sb_popline)(int cols, VTermScreenCell *cells, void *user);
+ int (*sb_clear)(void *user);
+} VTermScreenCallbacks;
+
+typedef struct {
+ int (*control)(uint8_t control, void *user);
+ int (*csi)(const char *leader, const long args[], int argcount, const char *intermed,
+ char command, void *user);
+ int (*osc)(int command, VTermStringFragment frag, void *user);
+ int (*dcs)(const char *command, size_t commandlen, VTermStringFragment frag, void *user);
+ int (*apc)(VTermStringFragment frag, void *user);
+ int (*pm)(VTermStringFragment frag, void *user);
+ int (*sos)(VTermStringFragment frag, void *user);
+} VTermStateFallbacks;
+
+typedef enum {
+ VTERM_DAMAGE_CELL, // every cell
+ VTERM_DAMAGE_ROW, // entire rows
+ VTERM_DAMAGE_SCREEN, // entire screen
+ VTERM_DAMAGE_SCROLL, // entire screen + scrollrect
+
+ VTERM_N_DAMAGES,
+} VTermDamageSize;
+
+typedef enum {
+ VTERM_ATTR_BOLD_MASK = 1 << 0,
+ VTERM_ATTR_UNDERLINE_MASK = 1 << 1,
+ VTERM_ATTR_ITALIC_MASK = 1 << 2,
+ VTERM_ATTR_BLINK_MASK = 1 << 3,
+ VTERM_ATTR_REVERSE_MASK = 1 << 4,
+ VTERM_ATTR_STRIKE_MASK = 1 << 5,
+ VTERM_ATTR_FONT_MASK = 1 << 6,
+ VTERM_ATTR_FOREGROUND_MASK = 1 << 7,
+ VTERM_ATTR_BACKGROUND_MASK = 1 << 8,
+ VTERM_ATTR_CONCEAL_MASK = 1 << 9,
+ VTERM_ATTR_SMALL_MASK = 1 << 10,
+ VTERM_ATTR_BASELINE_MASK = 1 << 11,
+ VTERM_ATTR_URI_MASK = 1 << 12,
+
+ VTERM_ALL_ATTRS_MASK = (1 << 13) - 1,
+} VTermAttrMask;
+
+typedef enum {
+ // VTERM_VALUETYPE_NONE = 0
+ VTERM_VALUETYPE_BOOL = 1,
+ VTERM_VALUETYPE_INT,
+ VTERM_VALUETYPE_STRING,
+ VTERM_VALUETYPE_COLOR,
+
+ VTERM_N_VALUETYPES,
+} VTermValueType;
+
+typedef enum {
+ // VTERM_ATTR_NONE = 0
+ VTERM_ATTR_BOLD = 1, // bool: 1, 22
+ VTERM_ATTR_UNDERLINE, // number: 4, 21, 24
+ VTERM_ATTR_ITALIC, // bool: 3, 23
+ VTERM_ATTR_BLINK, // bool: 5, 25
+ VTERM_ATTR_REVERSE, // bool: 7, 27
+ VTERM_ATTR_CONCEAL, // bool: 8, 28
+ VTERM_ATTR_STRIKE, // bool: 9, 29
+ VTERM_ATTR_FONT, // number: 10-19
+ VTERM_ATTR_FOREGROUND, // color: 30-39 90-97
+ VTERM_ATTR_BACKGROUND, // color: 40-49 100-107
+ VTERM_ATTR_SMALL, // bool: 73, 74, 75
+ VTERM_ATTR_BASELINE, // number: 73, 74, 75
+ VTERM_ATTR_URI, // number
+
+ VTERM_N_ATTRS,
+} VTermAttr;
+
+enum {
+ VTERM_PROP_CURSORSHAPE_BLOCK = 1,
+ VTERM_PROP_CURSORSHAPE_UNDERLINE,
+ VTERM_PROP_CURSORSHAPE_BAR_LEFT,
+
+ VTERM_N_PROP_CURSORSHAPES,
+};
+
+enum {
+ VTERM_PROP_MOUSE_NONE = 0,
+ VTERM_PROP_MOUSE_CLICK,
+ VTERM_PROP_MOUSE_DRAG,
+ VTERM_PROP_MOUSE_MOVE,
+
+ VTERM_N_PROP_MOUSES,
+};
+
+typedef enum {
+ VTERM_SELECTION_CLIPBOARD = (1<<0),
+ VTERM_SELECTION_PRIMARY = (1<<1),
+ VTERM_SELECTION_SECONDARY = (1<<2),
+ VTERM_SELECTION_SELECT = (1<<3),
+ VTERM_SELECTION_CUT0 = (1<<4), // also CUT1 .. CUT7 by bitshifting
+} VTermSelectionMask;
+
+typedef struct {
+ schar_T schar;
+ int width;
+ unsigned protected_cell:1; // DECSCA-protected against DECSEL/DECSED
+ unsigned dwl:1; // DECDWL or DECDHL double-width line
+ unsigned dhl:2; // DECDHL double-height line (1=top 2=bottom)
+} VTermGlyphInfo;
+
+typedef struct {
+ unsigned doublewidth:1; // DECDWL or DECDHL line
+ unsigned doubleheight:2; // DECDHL line (1=top 2=bottom)
+ unsigned continuation:1; // Line is a flow continuation of the previous
+} VTermLineInfo;
+
+// Copies of VTermState fields that the 'resize' callback might have reason to edit. 'resize'
+// callback gets total control of these fields and may free-and-reallocate them if required. They
+// will be copied back from the struct after the callback has returned.
+typedef struct {
+ VTermPos pos; // current cursor position
+ VTermLineInfo *lineinfos[2]; // [1] may be NULL
+} VTermStateFields;
+
+typedef struct {
+ // libvterm relies on this memory to be zeroed out before it is returned by the allocator.
+ void *(*malloc)(size_t size, void *allocdata);
+ void (*free)(void *ptr, void *allocdata);
+} VTermAllocatorFunctions;
+
+// Setting output callback will override the buffer logic
+typedef void VTermOutputCallback(const char *s, size_t len, void *user);
+
+struct VTermBuilder {
+ int ver; // currently unused but reserved for some sort of ABI version flag
+
+ int rows, cols;
+
+ const VTermAllocatorFunctions *allocator;
+ void *allocdata;
+
+ // Override default sizes for various structures
+ size_t outbuffer_len; // default: 4096
+ size_t tmpbuffer_len; // default: 4096
+};
+
+typedef struct {
+ int (*putglyph)(VTermGlyphInfo *info, VTermPos pos, void *user);
+ int (*movecursor)(VTermPos pos, VTermPos oldpos, int visible, void *user);
+ int (*scrollrect)(VTermRect rect, int downward, int rightward, void *user);
+ int (*moverect)(VTermRect dest, VTermRect src, void *user);
+ int (*erase)(VTermRect rect, int selective, void *user);
+ int (*initpen)(void *user);
+ int (*setpenattr)(VTermAttr attr, VTermValue *val, void *user);
+ int (*settermprop)(VTermProp prop, VTermValue *val, void *user);
+ int (*bell)(void *user);
+ int (*resize)(int rows, int cols, VTermStateFields *fields, void *user);
+ int (*theme)(bool *dark, void *user);
+ int (*setlineinfo)(int row, const VTermLineInfo *newinfo, const VTermLineInfo *oldinfo,
+ void *user);
+ int (*sb_clear)(void *user);
+} VTermStateCallbacks;
+
+typedef struct {
+ int (*set)(VTermSelectionMask mask, VTermStringFragment frag, void *user);
+ int (*query)(VTermSelectionMask mask, void *user);
+} VTermSelectionCallbacks;
+
+typedef struct {
+ int (*text)(const char *bytes, size_t len, void *user);
+ int (*control)(uint8_t control, void *user);
+ int (*escape)(const char *bytes, size_t len, void *user);
+ int (*csi)(const char *leader, const long args[], int argcount, const char *intermed,
+ char command, void *user);
+ int (*osc)(int command, VTermStringFragment frag, void *user);
+ int (*dcs)(const char *command, size_t commandlen, VTermStringFragment frag, void *user);
+ int (*apc)(VTermStringFragment frag, void *user);
+ int (*pm)(VTermStringFragment frag, void *user);
+ int (*sos)(VTermStringFragment frag, void *user);
+ int (*resize)(int rows, int cols, void *user);
+} VTermParserCallbacks;
+
+// State of the pen at some moment in time, also used in a cell
+typedef struct {
+ // After the bitfield
+ VTermColor fg, bg;
+
+ // Opaque ID that maps to a URI in a set
+ int uri;
+
+ unsigned bold : 1;
+ unsigned underline : 2;
+ unsigned italic : 1;
+ unsigned blink : 1;
+ unsigned reverse : 1;
+ unsigned conceal : 1;
+ unsigned strike : 1;
+ unsigned font : 4; // 0 to 9
+ unsigned small : 1;
+ unsigned baseline : 2;
+
+ // Extra state storage that isn't strictly pen-related
+ unsigned protected_cell : 1;
+ unsigned dwl : 1; // on a DECDWL or DECDHL line
+ unsigned dhl : 2; // on a DECDHL line (1=top 2=bottom)
+} ScreenPen;
+
+// Internal representation of a screen cell
+typedef struct {
+ schar_T schar;
+ ScreenPen pen;
+} ScreenCell;
diff --git a/src/nvim/vterm/vterm_internal_defs.h b/src/nvim/vterm/vterm_internal_defs.h
new file mode 100644
index 0000000000..19e809490f
--- /dev/null
+++ b/src/nvim/vterm/vterm_internal_defs.h
@@ -0,0 +1,292 @@
+#pragma once
+
+#include <stdarg.h>
+
+#include "nvim/mbyte_defs.h"
+#include "nvim/vterm/vterm_defs.h"
+
+#ifdef DEBUG
+# define DEBUG_LOG(...) fprintf(stderr, __VA_ARGS__)
+#else
+# define DEBUG_LOG(...)
+#endif
+
+#define ESC_S "\x1b"
+
+#define INTERMED_MAX 16
+
+#define CSI_ARGS_MAX 16
+#define CSI_LEADER_MAX 16
+
+#define BUFIDX_PRIMARY 0
+#define BUFIDX_ALTSCREEN 1
+
+#define KEY_ENCODING_DISAMBIGUATE 0x1
+#define KEY_ENCODING_REPORT_EVENTS 0x2
+#define KEY_ENCODING_REPORT_ALTERNATE 0x4
+#define KEY_ENCODING_REPORT_ALL_KEYS 0x8
+#define KEY_ENCODING_REPORT_ASSOCIATED 0x10
+
+typedef struct VTermEncoding VTermEncoding;
+typedef struct VTermKeyEncodingFlags VTermKeyEncodingFlags;
+
+typedef struct {
+ VTermEncoding *enc;
+
+ // This size should be increased if required by other stateful encodings
+ char data[4 * sizeof(uint32_t)];
+} VTermEncodingInstance;
+
+struct VTermPen {
+ VTermColor fg;
+ VTermColor bg;
+ int uri;
+ unsigned bold:1;
+ unsigned underline:2;
+ unsigned italic:1;
+ unsigned blink:1;
+ unsigned reverse:1;
+ unsigned conceal:1;
+ unsigned strike:1;
+ unsigned font:4; // To store 0-9
+ unsigned small:1;
+ unsigned baseline:2;
+};
+
+// https://sw.kovidgoyal.net/kitty/keyboard-protocol/#progressive-enhancement
+struct VTermKeyEncodingFlags {
+ bool disambiguate:1;
+ bool report_events:1;
+ bool report_alternate:1;
+ bool report_all_keys:1;
+ bool report_associated:1;
+};
+
+struct VTermKeyEncodingStack {
+ VTermKeyEncodingFlags items[16];
+ uint8_t size; ///< Number of items in the stack. This is at least 1 and at
+ ///< most the length of the "items" array.
+};
+
+struct VTermState {
+ VTerm *vt;
+
+ const VTermStateCallbacks *callbacks;
+ void *cbdata;
+
+ const VTermStateFallbacks *fallbacks;
+ void *fbdata;
+
+ int rows;
+ int cols;
+
+ // Current cursor position
+ VTermPos pos;
+
+ int at_phantom; // True if we're on the "81st" phantom column to defer a wraparound
+
+ int scrollregion_top;
+ int scrollregion_bottom; // -1 means unbounded
+#define SCROLLREGION_BOTTOM(state) ((state)->scrollregion_bottom > \
+ -1 ? (state)->scrollregion_bottom : (state)->rows)
+ int scrollregion_left;
+#define SCROLLREGION_LEFT(state) ((state)->mode.leftrightmargin ? (state)->scrollregion_left : 0)
+ int scrollregion_right; // -1 means unbounded
+#define SCROLLREGION_RIGHT(state) ((state)->mode.leftrightmargin \
+ && (state)->scrollregion_right > \
+ -1 ? (state)->scrollregion_right : (state)->cols)
+
+ // Bitvector of tab stops
+ uint8_t *tabstops;
+
+ // Primary and Altscreen; lineinfos[1] is lazily allocated as needed
+ VTermLineInfo *lineinfos[2];
+
+ // lineinfo will == lineinfos[0] or lineinfos[1], depending on altscreen
+ VTermLineInfo *lineinfo;
+#define ROWWIDTH(state, \
+ row) ((state)->lineinfo[(row)].doublewidth ? ((state)->cols / 2) : (state)->cols)
+#define THISROWWIDTH(state) ROWWIDTH(state, (state)->pos.row)
+
+ // Mouse state
+ int mouse_col, mouse_row;
+ int mouse_buttons;
+ int mouse_flags;
+#define MOUSE_WANT_CLICK 0x01
+#define MOUSE_WANT_DRAG 0x02
+#define MOUSE_WANT_MOVE 0x04
+
+ enum { MOUSE_X10, MOUSE_UTF8, MOUSE_SGR, MOUSE_RXVT, } mouse_protocol;
+
+// Last glyph output, for Unicode recombining purposes
+ char grapheme_buf[MAX_SCHAR_SIZE];
+ size_t grapheme_len;
+ uint32_t grapheme_last; // last added UTF-32 char
+ GraphemeState grapheme_state;
+ int combine_width; // The width of the glyph above
+ VTermPos combine_pos; // Position before movement
+
+ struct {
+ unsigned keypad:1;
+ unsigned cursor:1;
+ unsigned autowrap:1;
+ unsigned insert:1;
+ unsigned newline:1;
+ unsigned cursor_visible:1;
+ unsigned cursor_blink:1;
+ unsigned cursor_shape:2;
+ unsigned alt_screen:1;
+ unsigned origin:1;
+ unsigned screen:1;
+ unsigned leftrightmargin:1;
+ unsigned bracketpaste:1;
+ unsigned report_focus:1;
+ unsigned theme_updates:1;
+ } mode;
+
+ VTermEncodingInstance encoding[4], encoding_utf8;
+ int gl_set, gr_set, gsingle_set;
+
+ struct VTermPen pen;
+
+ VTermColor default_fg;
+ VTermColor default_bg;
+ VTermColor colors[16]; // Store the 8 ANSI and the 8 ANSI high-brights only
+
+ int bold_is_highbright;
+
+ unsigned protected_cell : 1;
+
+// Saved state under DEC mode 1048/1049
+ struct {
+ VTermPos pos;
+ struct VTermPen pen;
+
+ struct {
+ unsigned cursor_visible:1;
+ unsigned cursor_blink:1;
+ unsigned cursor_shape:2;
+ } mode;
+ } saved;
+
+// Temporary state for DECRQSS parsing
+ union {
+ char decrqss[4];
+ struct {
+ uint16_t mask;
+ enum {
+ SELECTION_INITIAL,
+ SELECTION_SELECTED,
+ SELECTION_QUERY,
+ SELECTION_SET_INITIAL,
+ SELECTION_SET,
+ SELECTION_INVALID,
+ } state : 8;
+ uint32_t recvpartial;
+ uint32_t sendpartial;
+ } selection;
+ } tmp;
+
+ struct {
+ const VTermSelectionCallbacks *callbacks;
+ void *user;
+ char *buffer;
+ size_t buflen;
+ } selection;
+
+ // Maintain two stacks, one for primary screen and one for altscreen
+ struct VTermKeyEncodingStack key_encoding_stacks[2];
+};
+
+struct VTerm {
+ const VTermAllocatorFunctions *allocator;
+ void *allocdata;
+
+ int rows;
+ int cols;
+
+ struct {
+ unsigned utf8:1;
+ unsigned ctrl8bit:1;
+ } mode;
+
+ struct {
+ enum VTermParserState {
+ NORMAL,
+ CSI_LEADER,
+ CSI_ARGS,
+ CSI_INTERMED,
+ DCS_COMMAND,
+ // below here are the "string states"
+ OSC_COMMAND,
+ OSC,
+ DCS_VTERM,
+ APC,
+ PM,
+ SOS,
+ } state;
+
+ bool in_esc : 1;
+
+ int intermedlen;
+ char intermed[INTERMED_MAX];
+
+ union {
+ struct {
+ int leaderlen;
+ char leader[CSI_LEADER_MAX];
+
+ int argi;
+ long args[CSI_ARGS_MAX];
+ } csi;
+ struct {
+ int command;
+ } osc;
+ struct {
+ int commandlen;
+ char command[CSI_LEADER_MAX];
+ } dcs;
+ } v;
+
+ const VTermParserCallbacks *callbacks;
+ void *cbdata;
+
+ bool string_initial;
+
+ bool emit_nul;
+ } parser;
+
+ // len == malloc()ed size; cur == number of valid bytes
+
+ VTermOutputCallback *outfunc;
+ void *outdata;
+
+ char *outbuffer;
+ size_t outbuffer_len;
+ size_t outbuffer_cur;
+
+ char *tmpbuffer;
+ size_t tmpbuffer_len;
+
+ VTermState *state;
+ VTermScreen *screen;
+};
+
+struct VTermEncoding {
+ void (*init)(VTermEncoding *enc, void *data);
+ void (*decode)(VTermEncoding *enc, void *data, uint32_t cp[], int *cpi, int cplen,
+ const char bytes[], size_t *pos, size_t len);
+};
+
+typedef enum {
+ ENC_UTF8,
+ ENC_SINGLE_94,
+} VTermEncodingType;
+
+enum {
+ C1_SS3 = 0x8f,
+ C1_DCS = 0x90,
+ C1_CSI = 0x9b,
+ C1_ST = 0x9c,
+ C1_OSC = 0x9d,
+};
diff --git a/src/nvim/vterm/vterm_keycodes_defs.h b/src/nvim/vterm/vterm_keycodes_defs.h
new file mode 100644
index 0000000000..70db05af54
--- /dev/null
+++ b/src/nvim/vterm/vterm_keycodes_defs.h
@@ -0,0 +1,58 @@
+#pragma once
+
+typedef enum {
+ VTERM_MOD_NONE = 0x00,
+ VTERM_MOD_SHIFT = 0x01,
+ VTERM_MOD_ALT = 0x02,
+ VTERM_MOD_CTRL = 0x04,
+
+ VTERM_ALL_MODS_MASK = 0x07,
+} VTermModifier;
+
+typedef enum {
+ VTERM_KEY_NONE,
+
+ VTERM_KEY_ENTER,
+ VTERM_KEY_TAB,
+ VTERM_KEY_BACKSPACE,
+ VTERM_KEY_ESCAPE,
+
+ VTERM_KEY_UP,
+ VTERM_KEY_DOWN,
+ VTERM_KEY_LEFT,
+ VTERM_KEY_RIGHT,
+
+ VTERM_KEY_INS,
+ VTERM_KEY_DEL,
+ VTERM_KEY_HOME,
+ VTERM_KEY_END,
+ VTERM_KEY_PAGEUP,
+ VTERM_KEY_PAGEDOWN,
+
+ VTERM_KEY_FUNCTION_0 = 256,
+ VTERM_KEY_FUNCTION_MAX = VTERM_KEY_FUNCTION_0 + 255,
+
+ VTERM_KEY_KP_0,
+ VTERM_KEY_KP_1,
+ VTERM_KEY_KP_2,
+ VTERM_KEY_KP_3,
+ VTERM_KEY_KP_4,
+ VTERM_KEY_KP_5,
+ VTERM_KEY_KP_6,
+ VTERM_KEY_KP_7,
+ VTERM_KEY_KP_8,
+ VTERM_KEY_KP_9,
+ VTERM_KEY_KP_MULT,
+ VTERM_KEY_KP_PLUS,
+ VTERM_KEY_KP_COMMA,
+ VTERM_KEY_KP_MINUS,
+ VTERM_KEY_KP_PERIOD,
+ VTERM_KEY_KP_DIVIDE,
+ VTERM_KEY_KP_ENTER,
+ VTERM_KEY_KP_EQUAL,
+
+ VTERM_KEY_MAX, // Must be last
+ VTERM_N_KEYS = VTERM_KEY_MAX,
+} VTermKey;
+
+#define VTERM_KEY_FUNCTION(n) (VTERM_KEY_FUNCTION_0 + (n))
generated by cgit (git 2.34.1) at 2025-04-28 18:32:24 +0000