kitty/kitty/vt-parser.c
Kovid Goyal 1fee9e89f6
ssh kitten: Allow per-host color schemes for dark and light mode
New color_scheme_dark, color_scheme_light and color_scheme_no_preference
options. When any of them is set, the ssh kitten sends the color schemes
for all three system color schemes to kitty, which applies the one
matching the current system color scheme and switches between them when
the system color scheme changes. color_scheme is used for modes without
a specific color scheme.

The colors are applied in a new session color layer, above the colors of
the window and below colors set by programs. They are associated with the
color stack entry pushed by the ssh kitten and are removed when it is
popped, so nested sessions work and the colors are restored on exit.

Configs that only use color_scheme continue to use escape codes exactly
as before, as does the kitten when running inside tmux.

Fixes #10724
2026-10-23 09:37:50 +05:30

1847 lines
70 KiB
C

/*
* vt-parser.c
* Copyright (C) 2023 Kovid Goyal <kovid at kovidgoyal.net>
*
* Distributed under terms of the GPL3 license.
*/
// TODO: Test clipboard kitten with 52 and 5522
// TODO: Test screen_request_capabilities
#include "vt-parser.h"
#include "screen.h"
#include "control-codes.h"
#include "state.h"
#include "simd-string.h"
#include <stdalign.h>
#define BUF_SZ (1024u * 1024u)
// The extra bytes are so loads of large integers such as for AVX 512 dont read past the end of the buffer
#define BUF_EXTRA (512u / 8u)
#define MAX_ESCAPE_CODE_LENGTH (BUF_SZ / 4u)
#define MAX_CSI_PARAMS 256u
// Pending input smaller than this, typically the echo of typed characters, is
// parsed without waiting for input_delay
#define SMALL_PENDING_INPUT_THRESHOLD 1024u
// See classify_pending_input()
#define INPUT_PARSE_FORCE_MARGIN (16u * 1024u)
// Macros {{{
#define SET_STATE(x) self->vte_state = VTE_##x;
#define DIGIT \
'0' : case '1': \
case '2': \
case '3': \
case '4': \
case '5': \
case '6': \
case '7': \
case '8': \
case '9'
static void
_report_unknown_escape_code(PyObject *dump_callback, id_type window_id, const char *name, const uint8_t *payload) {
char buf[1024];
if (strlen((const char *)payload) < 64) snprintf(buf, sizeof(buf), "Unknown %s escape code: %.64s", name, payload);
else snprintf(buf, sizeof(buf), "Unknown %s escape code: %.64s...", name, payload);
if (dump_callback) {
Py_XDECREF(PyObject_CallFunction(dump_callback, "Kss", window_id, "error", buf));
PyErr_Clear();
} else
log_error(
ERROR_PREFIX " "
"%s",
buf);
}
#define REPORT_UKNOWN_ESCAPE_CODE(name, data) _report_unknown_escape_code(self->dump_callback, self->window_id, name, data);
#ifdef DUMP_COMMANDS
static void
_report_error(PyObject *dump_callback, id_type window_id, const char *fmt, ...) {
va_list argptr;
va_start(argptr, fmt);
RAII_PyObject(temp, PyUnicode_FromFormatV(fmt, argptr));
va_end(argptr);
if (temp != NULL) {
RAII_PyObject(wid, PyLong_FromUnsignedLongLong(window_id));
RAII_PyObject(err, PyUnicode_FromString("error"));
if (wid && err) Py_XDECREF(PyObject_CallFunctionObjArgs(dump_callback, wid, err, temp, NULL));
}
PyErr_Clear();
}
static void
_report_params(PyObject *dump_callback, id_type window_id, const char *name, int *params, unsigned int count, bool is_group, Region *r) {
static char buf[MAX_CSI_PARAMS * 3] = {0};
unsigned int i, p = 0;
if (r) p += snprintf(buf + p, sizeof(buf) - 2, "%u;%u;%u;%u;", r->top, r->left, r->bottom, r->right);
const char *fmt = is_group ? "%i:" : "%i;";
for (i = 0; i < count && p < arraysz(buf) - 20; i++) {
int n = snprintf(buf + p, arraysz(buf) - p, fmt, params[i]);
if (n < 0) break;
p += n;
}
buf[count ? p - 1 : p] = 0;
Py_XDECREF(PyObject_CallFunction(dump_callback, "Kss", window_id, name, buf));
PyErr_Clear();
}
static void
_report_params_with_first(PyObject *dump_callback, id_type window_id, const char *name, int first_param, int *params, unsigned count) {
static char buf[MAX_CSI_PARAMS * 3] = {0};
unsigned int i, p = 0;
p += snprintf(buf + p, sizeof(buf) - 2, "%d;", first_param);
for (i = 0; i < count && p < arraysz(buf) - 20; i++) {
int n = snprintf(buf + p, arraysz(buf) - p, "%i:", params[i]);
if (n < 0) break;
p += n;
}
buf[count ? p - 1 : p] = 0;
Py_XDECREF(PyObject_CallFunction(dump_callback, "Kss", window_id, name, buf));
PyErr_Clear();
}
#define DUMP_UNUSED
#define REPORT_ERROR(...) _report_error(self->dump_callback, self->window_id, __VA_ARGS__);
#define REPORT_COMMAND1(name) \
Py_XDECREF(PyObject_CallFunction(self->dump_callback, "Ks", self->window_id, #name)); \
PyErr_Clear();
#define REPORT_COMMAND2(name, x) \
Py_XDECREF(PyObject_CallFunction(self->dump_callback, "Ksi", self->window_id, #name, (int)x)); \
PyErr_Clear();
#define REPORT_COMMAND3(name, x, y) \
Py_XDECREF(PyObject_CallFunction(self->dump_callback, "Ksii", self->window_id, #name, (int)x, (int)y)); \
PyErr_Clear();
#define GET_MACRO(_1, _2, _3, NAME, ...) NAME
#define REPORT_COMMAND(...) GET_MACRO(__VA_ARGS__, REPORT_COMMAND3, REPORT_COMMAND2, REPORT_COMMAND1, SENTINEL)(__VA_ARGS__)
#define REPORT_VA_COMMAND(...) \
Py_XDECREF(PyObject_CallFunction(self->dump_callback, __VA_ARGS__)); \
PyErr_Clear();
#define REPORT_DRAW(chars, num) \
{ \
for (unsigned i = 0; i < (num); i++) { \
uint32_t rd_ch = (chars)[i]; \
switch (rd_ch) { \
case BEL: REPORT_COMMAND(screen_bell); break; \
case BS: REPORT_COMMAND(screen_backspace); break; \
case HT: REPORT_COMMAND(screen_tab); break; \
case SI: REPORT_COMMAND(screen_change_charset, 0); break; \
case SO: REPORT_COMMAND(screen_change_charset, 1); break; \
case LF: \
case VT: \
case FF: REPORT_COMMAND(screen_linefeed); break; \
case CR: REPORT_COMMAND(screen_carriage_return); break; \
default: \
if (rd_ch >= ' ') { \
RAII_PyObject(t, PyObject_CallFunction(self->dump_callback, "KsC", self->window_id, "draw", rd_ch)); \
if (t == NULL) PyErr_Clear(); \
} \
} \
} \
}
#define REPORT_PARAMS(name, params, num, is_group, region) _report_params(self->dump_callback, self->window_id, name, params, num, is_group, region)
#define REPORT_PARAMS_WITH_FIRST(name, first, params, num) _report_params_with_first(self->dump_callback, self->window_id, name, first, params, num)
#define REPORT_OSC(name, string) \
Py_XDECREF(PyObject_CallFunction(self->dump_callback, "KsO", self->window_id, #name, string)); \
PyErr_Clear();
#define REPORT_OSC2(name, code, string) \
Py_XDECREF(PyObject_CallFunction(self->dump_callback, "KsiO", self->window_id, #name, code, string)); \
PyErr_Clear();
#define REPORT_HYPERLINK(id, url) \
Py_XDECREF(PyObject_CallFunction(self->dump_callback, "Kszz", self->window_id, "set_active_hyperlink", id, url)); \
PyErr_Clear();
#else
#define REPORT_ERROR(...) log_error(ERROR_PREFIX " " __VA_ARGS__);
#define REPORT_COMMAND(...)
#define REPORT_VA_COMMAND(...)
#define REPORT_DRAW(...)
#define REPORT_PARAMS(...)
#define REPORT_PARAMS_WITH_FIRST(...)
#define REPORT_OSC(name, string)
#define REPORT_OSC2(name, code, string)
#define REPORT_HYPERLINK(id, url)
#endif
// }}}
// Utils {{{
// }}}
// Data structures {{{
typedef enum VTEState {
VTE_NORMAL,
VTE_ESC = ESC,
VTE_CSI = ESC_CSI,
VTE_OSC = ESC_OSC,
VTE_DCS = ESC_DCS,
VTE_APC = ESC_APC,
VTE_PM = ESC_PM,
VTE_SOS = ESC_SOS
} VTEState;
static inline const char *
vte_state_name(VTEState s) {
switch (s) {
case VTE_NORMAL: return "VTE_NORMAL";
case VTE_ESC: return "VTE_ESC";
case VTE_CSI: return "VTE_CSI";
case VTE_OSC: return "VTE_OSC";
case VTE_DCS: return "VTE_DCS";
case VTE_APC: return "VTE_APC";
case VTE_PM: return "VTE_PM";
case VTE_SOS: return "VTE_SOS";
}
static char buf[16];
snprintf(buf, sizeof(buf), "VTE_0x%x", s);
return buf;
}
typedef enum { CSI_START, CSI_BODY, CSI_POST_SECONDARY } CSIState;
typedef struct ParsedCSI {
char primary, secondary, trailer;
CSIState state;
unsigned num_params, num_digits;
bool is_valid;
uint64_t accumulator;
int mult;
int params[MAX_CSI_PARAMS];
uint8_t is_sub_param[MAX_CSI_PARAMS];
} ParsedCSI;
typedef struct PS {
alignas(BUF_EXTRA) uint8_t buf[BUF_SZ + BUF_EXTRA];
UTF8Decoder utf8_decoder;
id_type window_id;
VTEState vte_state;
ParsedCSI csi;
// these are temporary variables set only for duration of a parse call
PyObject *dump_callback;
Screen *screen;
monotonic_t now, new_input_at;
// Buffer size when new_input_at was set. Bytes before this are a scanned tail.
size_t fresh_input_at;
// input_chunk identifies the bytes stamped by new_input_at. accepted_chunk is a chunk
// the I/O thread woke the main loop for as small input, parsed even if it has grown since.
uint64_t input_chunk, accepted_chunk;
pthread_mutex_t lock;
// The buffer
struct {
size_t consumed, pos, sz;
} read;
struct {
size_t offset, sz, pending;
} write;
} PS;
static void
reset_csi(ParsedCSI *csi) {
csi->num_params = 0;
csi->primary = 0;
csi->secondary = 0;
csi->trailer = 0;
csi->state = CSI_START;
csi->num_digits = 0;
csi->is_valid = false;
csi->accumulator = 0;
csi->mult = 1;
memset(csi->is_sub_param, 0, sizeof(csi->is_sub_param));
}
// }}}
// Normal mode {{{
static void
dispatch_single_byte_control(PS *self, uint32_t ch) {
REPORT_DRAW(&ch, 1);
screen_draw_text(self->screen, &ch, 1);
}
static void
consume_normal(PS *self) {
do {
const bool sentinel_found = utf8_decode_to_esc(&self->utf8_decoder, self->buf + self->read.pos, self->read.sz - self->read.pos);
self->read.pos += self->utf8_decoder.num_consumed;
if (self->utf8_decoder.output.pos) {
REPORT_DRAW(self->utf8_decoder.output.storage, self->utf8_decoder.output.pos);
screen_draw_text(self->screen, self->utf8_decoder.output.storage, self->utf8_decoder.output.pos);
}
if (sentinel_found) {
SET_STATE(ESC);
break;
}
} while (self->read.pos < self->read.sz);
}
// }}}
// Esc mode {{{
#define IS_ESCAPED_CHAR \
case '%': \
case '(': \
case ')': \
case '*': \
case '+': \
case '-': \
case '.': \
case '/': \
case ' ': \
case '#'
static void
screen_nel(Screen *screen) {
screen_carriage_return(screen);
screen_linefeed(screen);
}
static bool
consume_esc(PS *self) {
#define CALL_ED(name) \
REPORT_COMMAND(name); \
name(self->screen); \
SET_STATE(NORMAL);
#define CALL_ED1(name, ch) \
REPORT_COMMAND(name, ch); \
name(self->screen, ch); \
SET_STATE(NORMAL);
#define CALL_ED2(name, a, b) \
REPORT_COMMAND(name, a, b); \
name(self->screen, a, b); \
SET_STATE(NORMAL);
const uint8_t ch = self->buf[self->read.pos++];
const bool is_first_char = self->read.pos - self->read.consumed == 1;
if (is_first_char) {
switch (ch) {
case ESC_DCS: SET_STATE(DCS); break;
case ESC_OSC: SET_STATE(OSC); break;
case ESC_CSI:
SET_STATE(CSI);
reset_csi(&self->csi);
break;
case ESC_APC: SET_STATE(APC); break;
case ESC_SOS: SET_STATE(SOS); break;
case ESC_PM:
SET_STATE(PM);
break;
IS_ESCAPED_CHAR:
return false;
case ESC_RIS: CALL_ED(screen_reset); break;
case ESC_IND: CALL_ED(screen_index); break;
case ESC_NEL: CALL_ED(screen_nel); break;
case ESC_RI: CALL_ED(screen_reverse_index); break;
case ESC_HTS: CALL_ED(screen_set_tab_stop); break;
case ESC_DECSC: CALL_ED(screen_save_cursor); break;
case ESC_DECRC: CALL_ED(screen_restore_cursor); break;
case ESC_DECKPNM: CALL_ED(screen_normal_keypad_mode); break;
case ESC_DECKPAM: CALL_ED(screen_alternate_keypad_mode); break;
default:
REPORT_ERROR("%s0x%x", "Unknown char after ESC: ", ch);
SET_STATE(NORMAL);
break;
}
return true;
} else {
const uint8_t prev_ch = self->buf[self->read.pos - 2];
SET_STATE(NORMAL);
switch (prev_ch) {
case '%':
switch (ch) {
case '@': REPORT_ERROR("Ignoring attempt to switch to non-utf8 encoding"); break;
case 'G': REPORT_ERROR("Ignoring attempt to switch to utf8 encoding as we are always utf-8"); break;
default: REPORT_ERROR("Unhandled Esc %% code: 0x%x", ch); break;
}
break;
case '#':
if (ch == '8') {
CALL_ED(screen_align);
} else {
REPORT_ERROR("Unhandled Esc # code: 0x%x", ch);
}
break;
case '(':
case ')':
switch (ch) {
case 'A':
case 'B':
case '0':
case 'U':
case 'V': CALL_ED2(screen_designate_charset, prev_ch - '(', ch); break;
default: REPORT_ERROR("Unknown charset: 0x%x", ch); break;
}
break;
case ' ':
switch (ch) {
case 'F':
case 'G': REPORT_ERROR("Ignoring attempt to turn on/off C1 controls as we only support C0 controls"); break;
default: REPORT_ERROR("Unhandled ESC SP escape code: 0x%x", ch); break;
}
break;
default: REPORT_ERROR("Unhandled charset related escape code: 0x%x 0x%x", prev_ch, ch); break;
}
return true;
}
#undef CALL_ED
#undef CALL_ED1
} // }}}
// ST terminator {{{
static bool
find_st_terminator(PS *self, size_t *end_pos) {
const size_t sz = self->read.sz - self->read.pos;
const uint8_t *q = find_either_of_two_bytes(self->buf + self->read.pos, sz, BEL, ESC_ST);
if (q == NULL) {
self->read.pos += sz;
return false;
}
switch (*q) {
case ESC_ST:
if (q > self->buf && *(q - 1) == ESC) {
*end_pos = q - 1 - self->buf;
self->read.pos = *end_pos + 2;
return true;
}
self->read.pos = (q - self->buf) + 1;
break;
case BEL:
*end_pos = q - self->buf;
self->read.pos = *end_pos + 1;
return true;
}
return false;
}
// }}}
// OSC {{{
#include "parse-multicell-command.h"
#include "parse-dnd-command.h"
static bool
is_osc_52(PS *self) {
return memcmp(self->buf + self->read.consumed, "52;", 3) == 0;
}
static void
continue_osc_52(PS *self) {
self->read.pos -= 4;
self->read.consumed = self->read.pos;
self->buf[self->read.pos++] = '5';
self->buf[self->read.pos++] = '2';
self->buf[self->read.pos++] = ';';
self->buf[self->read.pos++] = ';';
}
static bool
accumulate_st_terminated_esc_code(PS *self, void(dispatch)(PS *, uint8_t *, size_t, bool)) {
size_t pos;
if (find_st_terminator(self, &pos)) {
// technically we should check MAX_ESCAPE_CODE_LENGTH here but lets be generous in what we accept since we
// have a full escape code
uint8_t *buf = self->buf + self->read.consumed;
size_t sz = pos - self->read.consumed;
buf[sz] = 0; // ensure null termination, this is anyway an ST termination char
dispatch(self, buf, sz, false);
return true;
}
if (UNLIKELY((pos = self->read.pos - self->read.consumed) > MAX_ESCAPE_CODE_LENGTH)) {
if (self->vte_state == VTE_OSC && is_osc_52(self)) {
// null terminate
self->read.pos--;
uint8_t before = self->buf[self->read.pos];
self->buf[self->read.pos] = 0;
// send partial OSC 52
dispatch(self, self->buf + self->read.consumed, self->read.pos - self->read.consumed, true);
// continue OSC 52
self->buf[self->read.pos] = before;
continue_osc_52(self);
return accumulate_st_terminated_esc_code(self, dispatch);
}
REPORT_ERROR("%s escape code too long (%zu bytes), ignoring it", vte_state_name(self->vte_state), pos);
return true;
}
return false;
}
static bool
parse_osc_8(char *buf, char **id, char **url) {
// the spec says only ASCII printable chars are allowed in OSC 8
char *boundary = strstr(buf, ";");
if (boundary == NULL) return false;
*boundary = 0;
if (*(boundary + 1)) *url = boundary + 1;
char *save = NULL, *token = strtok_r(buf, ":", &save);
while (token != NULL) {
size_t len = strlen(token);
if (len > 3 && token[0] == 'i' && token[1] == 'd' && token[2] == '=' && token[3]) {
*id = token + 3;
break;
}
token = strtok_r(NULL, ":", &save);
}
return true;
}
static void
dispatch_hyperlink(PS *self, char *buf) {
char *id = NULL, *url = NULL;
if (parse_osc_8(buf, &id, &url)) {
REPORT_HYPERLINK(id, url);
set_active_hyperlink(self->screen, id, url);
} else {
REPORT_ERROR("Ignoring malformed OSC 8 code");
}
}
static void
dispatch_osc(PS *self, uint8_t *buf, size_t limit, bool is_extended_osc) {
#define DISPATCH_OSC_WITH_CODE(name) \
REPORT_OSC2(name, code, mv); \
name(self->screen, code, mv);
#define DISPATCH_OSC(name) \
REPORT_OSC(name, mv); \
name(self->screen, mv);
#define START_DISPATCH \
{ \
RAII_PyObject(mv, PyMemoryView_FromMemory((char *)buf + i, limit - i, PyBUF_READ)); \
if (mv) {
#define END_DISPATCH_WITHOUT_BREAK \
} \
; \
PyErr_Clear(); \
}
#define END_DISPATCH \
} \
; \
PyErr_Clear(); \
break; \
}
int code = 0;
unsigned int i;
for (i = 0; i < MIN(limit, 5u); i++) {
uint8_t num = buf[i] - '0';
if (num > 9) break;
code = code * 10 + num;
}
if (i < limit && buf[i] == ';') i++;
switch (code) {
case 0:
START_DISPATCH
DISPATCH_OSC(set_title);
DISPATCH_OSC(set_icon);
END_DISPATCH
case 1:
START_DISPATCH
DISPATCH_OSC(set_icon);
END_DISPATCH
case 2:
START_DISPATCH
DISPATCH_OSC(set_title);
END_DISPATCH
case 5:
case 105: REPORT_ERROR("Ignoring OSC 5/105, used by XTerm to change special colors used for rendering bold/italic/underline"); break;
case 6:
case 106: { // report only once as this is used by benchmark kitten causing log spam
static bool reported = false;
if (!reported) {
reported = true;
REPORT_ERROR("Ignoring OSC 6/106, used by XTerm to enable/disable special colors used for rendering bold/italic/underline");
}
} break;
case 4:
case 104:
START_DISPATCH
DISPATCH_OSC_WITH_CODE(set_color_table_color);
END_DISPATCH
case 7:
#ifdef DUMP_COMMANDS
START_DISPATCH
REPORT_OSC2(process_cwd_notification, code, mv);
END_DISPATCH_WITHOUT_BREAK
#endif
process_cwd_notification(self->screen, code, (char *)buf + i, limit - i);
break;
case 8: dispatch_hyperlink(self, (char *)buf + i); break;
case 9:
case 99:
case 777:
case 1337:
START_DISPATCH
DISPATCH_OSC_WITH_CODE(desktop_notify)
END_DISPATCH
case 13:
case 14:
case 15:
case 16:
case 18:
REPORT_ERROR("Ignoring OSC 13,14,15,16 and 18 used for pointer and Textronic colors by XTerm");
break;
break;
case 10:
case 11:
case 12:
case 17:
case 19:
case 22:
case 110:
case 111:
case 112:
case 117:
case 119:
START_DISPATCH
DISPATCH_OSC_WITH_CODE(set_dynamic_color);
END_DISPATCH
case 21:
START_DISPATCH
DISPATCH_OSC_WITH_CODE(color_control);
END_DISPATCH
case 52:
case 5522:
START_DISPATCH
if (is_extended_osc && code == 52) code = -52;
DISPATCH_OSC_WITH_CODE(clipboard_control);
END_DISPATCH
case 46: REPORT_ERROR("Ignoring OSC 46 used for file logging in XTerm"); break;
case 50: REPORT_ERROR("Ignoring OSC 50 used for font changing in XTerm"); break;
case 51: REPORT_ERROR("Ignoring OSC 51 used by emacs shell"); break;
case 60:
case 61: REPORT_ERROR("Ignoring OSC 60/61 used for query control in XTerm"); break;
case TEXT_SIZE_CODE: parse_multicell_code(self, buf + i, limit - i); break;
case DND_CODE: parse_dnd_code(self, buf + i, limit - i); break;
case 133:
#ifdef DUMP_COMMANDS
START_DISPATCH
REPORT_OSC2(shell_prompt_marking, code, mv);
END_DISPATCH_WITHOUT_BREAK
#endif
if (limit > i) {
buf[limit] = 0; // safe to do as we have 8 extra bytes after PARSER_BUF_SZ
shell_prompt_marking(self->screen, (char *)buf + i);
}
break;
case FILE_TRANSFER_CODE:
START_DISPATCH
DISPATCH_OSC(file_transmission);
END_DISPATCH
case 30001:
REPORT_COMMAND(screen_push_dynamic_colors);
screen_push_colors(self->screen, 0);
break;
case 30101:
REPORT_COMMAND(screen_pop_dynamic_colors);
screen_pop_colors(self->screen, 0);
break;
case 440: REPORT_ERROR("Ignoring OSC 440 used for audio by mintty"); break;
case 633: REPORT_ERROR("Ignoring OSC 633, use by Windows Terminal for VSCode actions"); break;
case 666: REPORT_ERROR("Ignoring OSC 666, typically used by VTE terminals for shell integration"); break;
case 697: REPORT_ERROR("Ignoring OSC 697, typically used by Fig for shell integration"); break;
case 701: REPORT_ERROR("Ignoring OSC 701, used by mintty for locale"); break;
case 3008:
START_DISPATCH
DISPATCH_OSC(osc_context);
END_DISPATCH
case 7501:
START_DISPATCH
DISPATCH_OSC(program_status_report);
END_DISPATCH
case 7704: REPORT_ERROR("Ignoring OSC 7704, used by mintty for ANSI colors"); break;
case 7750: REPORT_ERROR("Ignoring OSC 7750, used by mintty for Emoji style"); break;
case 7770: REPORT_ERROR("Ignoring OSC 7770, used by mintty for font size"); break;
case 7721: REPORT_ERROR("Ignoring OSC 7721, used by mintty for copy window title"); break;
case 7771: REPORT_ERROR("Ignoring OSC 7771, used by mintty for glyph coverage"); break;
case 7777: REPORT_ERROR("Ignoring OSC 7777, used by mintty for window size"); break;
case 77119: REPORT_ERROR("Ignoring OSC 7777, used by mintty for wide chars"); break;
case 9001: REPORT_ERROR("Ignoring OSC 9001, used by windows terminal"); break;
default: REPORT_UKNOWN_ESCAPE_CODE("OSC", buf); break;
}
#undef DISPATCH_OSC
#undef DISPATCH_OSC_WITH_CODE
#undef START_DISPATCH
#undef END_DISPATCH
}
// }}}
// DCS {{{
static bool
startswith(const uint8_t *string, ssize_t sz, const char *prefix, ssize_t l) {
if (sz < l) return false;
for (ssize_t i = 0; i < l; i++) {
if (string[i] != (unsigned char)prefix[i]) return false;
}
return true;
}
static bool
parse_kitty_dcs(PS *self, uint8_t *buf, size_t bufsz) {
#define starts_with(x) startswith(buf, bufsz, x, literal_strlen(x))
#define inc(x) \
buf += literal_strlen(x); \
bufsz -= literal_strlen(x)
#define dispatch(prefix, func, delta) \
{ \
if (starts_with(prefix)) { \
inc(prefix); \
buf -= delta; \
bufsz += delta; \
PyObject *cmd = PyMemoryView_FromMemory((char *)buf, bufsz, PyBUF_READ); \
if (cmd) { \
REPORT_OSC(func, cmd); \
screen_handle_kitty_dcs(self->screen, #func, cmd); \
Py_DECREF(cmd); \
} else PyErr_Clear(); \
return true; \
} \
}
if (!starts_with("kitty-")) return false;
inc("kitty-");
dispatch("cmd{", handle_remote_cmd, 1);
dispatch("overlay-ready|", handle_overlay_ready, 0) dispatch("kitten-result|", handle_kitten_result, 0) dispatch("print|", handle_remote_print, 0)
dispatch("echo|", handle_remote_echo, 0) dispatch("ssh|", handle_remote_ssh, 0) dispatch("ask|", handle_remote_askpass, 0)
dispatch("clone|", handle_remote_clone, 0) dispatch("edit|", handle_remote_edit, 0) dispatch("color-scheme|", handle_remote_color_scheme, 0)
dispatch("restore-cursor-appearance|", handle_restore_cursor_appearance, 0)
return false;
#undef dispatch
#undef starts_with
#undef inc
}
static void
dispatch_dcs(PS *self, uint8_t *buf, size_t bufsz, bool is_extended UNUSED) {
if (bufsz < 2) return;
switch (buf[0]) {
case '+':
case '$':
if (buf[1] == 'q') {
PyObject *mv = PyMemoryView_FromMemory((char *)buf + 2, bufsz - 2, PyBUF_READ);
if (mv) {
REPORT_OSC2(screen_request_capabilities, (char)buf[0], mv);
Py_DECREF(mv);
} else PyErr_Clear();
screen_request_capabilities(self->screen, (char)buf[0], (char *)buf + 2);
} else {
REPORT_UKNOWN_ESCAPE_CODE("DCS", buf);
}
break;
case '=':
if (bufsz > 2 && (buf[1] == '1' || buf[1] == '2') && buf[2] == 's') {
if (buf[1] == '1') {
REPORT_COMMAND(screen_start_pending_mode)
if (!screen_pause_rendering(self->screen, true, 0)) {
REPORT_ERROR("Pending mode start requested while already in pending mode. This is most likely an application error.");
}
} else {
REPORT_COMMAND(screen_stop_pending_mode);
if (!screen_pause_rendering(self->screen, false, 0)) {
REPORT_ERROR(
"Pending mode stop command issued while not in pending mode, this can"
" be either a bug in the terminal application or caused by a timeout with no data"
" received for too long or by too much data in pending mode");
}
}
} else {
REPORT_UKNOWN_ESCAPE_CODE("DCS", buf);
}
break;
case '@':
if (!parse_kitty_dcs(self, buf + 1, bufsz - 1)) REPORT_UKNOWN_ESCAPE_CODE("DCS", buf);
break;
default: REPORT_UKNOWN_ESCAPE_CODE("DCS", buf); break;
}
}
// }}}
// CSI {{{
#define CSI_SECONDARY \
' ' : case '!': \
case '"': \
case '#': \
case '$': \
case '%': \
case '&': \
case '\'': \
case '(': \
case ')': \
case '*': \
case '+': \
case ',': \
case '-': \
case '.': \
case '/'
#define CSI_TRAILER \
'@' : START_ALLOW_CASE_RANGE case 'a' ... 'z': \
case 'A' ... 'Z': END_ALLOW_CASE_RANGE \
case '`': \
case '{': \
case '|': \
case '}': \
case '~'
#define CSI_NORMAL_MODE_EMBEDDINGS \
BEL: \
case BS: \
case HT: \
case LF: \
case VT: \
case FF: \
case CR: \
case SO: \
case SI
static const char *
csi_letter(unsigned code) {
static char buf[8];
if (33 <= code && code <= 126) snprintf(buf, sizeof(buf), "%c", code);
else snprintf(buf, sizeof(buf), "0x%x", code);
return buf;
}
static bool
commit_csi_param(PS *self UNUSED, ParsedCSI *csi) {
if (!csi->num_digits) return true;
if (csi->num_params >= MAX_CSI_PARAMS) {
REPORT_ERROR("CSI escape code has too many parameters, ignoring it");
return false;
}
csi->params[csi->num_params++] = csi->mult * (int64_t)csi->accumulator;
csi->num_digits = 0;
csi->mult = 1;
csi->accumulator = 0;
return true;
}
#define MAX_CSI_DIGITS 16u
static void
csi_add_digit(ParsedCSI *csi, uint8_t ch) {
if (UNLIKELY(csi->num_digits >= MAX_CSI_DIGITS)) return;
csi->num_digits++;
csi->accumulator = csi->accumulator * 10 + (ch - '0');
}
static void
consume_csi_digit_run(ParsedCSI *csi, const uint8_t *buf, size_t *pos, const size_t sz) {
// consume a run of parameter digits without re-entering the per-byte state machine
size_t p = *pos;
while (p < sz && (uint8_t)(buf[p] - '0') <= 9) csi_add_digit(csi, buf[p++]);
*pos = p;
}
static bool
csi_parse_loop(PS *self, ParsedCSI *csi, const uint8_t *buf, size_t *pos, const size_t sz, const size_t start) {
while (*pos < sz) {
const uint8_t ch = buf[*pos];
*pos += 1;
switch (csi->state) {
case CSI_START:
switch (ch) {
case CSI_NORMAL_MODE_EMBEDDINGS: dispatch_single_byte_control(self, ch); break;
case ';':
csi->params[csi->num_params++] = 0;
csi->state = CSI_BODY;
break;
case DIGIT:
csi_add_digit(csi, ch);
consume_csi_digit_run(csi, buf, pos, sz);
csi->state = CSI_BODY;
break;
case '?':
case '>':
case '<':
case '=':
csi->state = CSI_BODY;
csi->primary = ch;
break;
case CSI_SECONDARY:
if (ch == '-') {
csi->mult = -1;
csi->num_digits++;
csi->state = CSI_BODY;
} else {
csi->secondary = ch;
csi->state = CSI_POST_SECONDARY;
}
break;
case CSI_TRAILER:
csi->is_valid = true;
csi->trailer = ch;
return true;
default: REPORT_ERROR("Invalid character in CSI: %s (0x%x), ignoring the sequence", csi_letter(ch), ch); return true;
}
break;
case CSI_POST_SECONDARY:
switch (ch) {
case CSI_NORMAL_MODE_EMBEDDINGS: dispatch_single_byte_control(self, ch); break;
case CSI_TRAILER:
csi->is_valid = true;
csi->trailer = ch;
break;
default: REPORT_ERROR("Invalid character in CSI: %s (0x%x), ignoring the sequence", csi_letter(ch), ch); break;
}
return true;
case CSI_BODY:
switch (ch) {
case CSI_NORMAL_MODE_EMBEDDINGS: dispatch_single_byte_control(self, ch); break;
case CSI_SECONDARY:
if (ch == '-' && csi->num_digits == 0) {
csi->mult = -1;
csi->num_digits = 1;
} else {
if (!commit_csi_param(self, csi)) return true;
csi->secondary = ch;
csi->state = CSI_POST_SECONDARY;
}
break;
case CSI_TRAILER:
if (csi->num_digits == 1 && csi->secondary == 0 && csi->mult == -1) {
csi->num_digits = 0;
csi->secondary = '-';
}
if (!commit_csi_param(self, csi)) return true;
csi->is_valid = true;
csi->trailer = ch;
return true;
case ':':
if (!commit_csi_param(self, csi)) return true;
if (csi->num_params < MAX_CSI_PARAMS) csi->is_sub_param[csi->num_params] = true;
break;
case ';':
if (!csi->num_digits) csi->num_digits++; // Empty means zero
if (!commit_csi_param(self, csi)) return true;
if (csi->num_params < MAX_CSI_PARAMS) csi->is_sub_param[csi->num_params] = false;
break;
case DIGIT:
csi_add_digit(csi, ch);
consume_csi_digit_run(csi, buf, pos, sz);
break;
default: REPORT_ERROR("Invalid character in CSI: %s (0x%x), ignoring the sequence", csi_letter(ch), ch); return true;
}
break;
}
}
if (UNLIKELY(*pos - start > MAX_ESCAPE_CODE_LENGTH)) {
REPORT_ERROR("CSI escape too long ignoring and truncating");
return true;
}
return false;
#undef COMMIT_PARAM
}
static bool
consume_csi(PS *self) {
return csi_parse_loop(self, &self->csi, self->buf, &self->read.pos, self->read.sz, self->read.consumed);
}
static void
_parse_multi_cursors(PS *self, ParsedCSI *csi) {
switch (csi->num_params) {
case 0:
REPORT_COMMAND("screen_multi_cursor");
screen_multi_cursor(self->screen, 0, NULL, 0);
break;
case 1:
REPORT_PARAMS_WITH_FIRST("screen_multi_cursor", csi->params[0], csi->params, 0);
screen_multi_cursor(self->screen, csi->params[0], csi->params, 0);
break;
default: {
unsigned pos = 1, first_param = pos;
for (; pos < csi->num_params; pos++) {
if (pos > first_param) {
if (!csi->is_sub_param[pos]) {
REPORT_PARAMS_WITH_FIRST("screen_multi_cursor", csi->params[0], csi->params + first_param, pos - first_param);
screen_multi_cursor(self->screen, csi->params[0], csi->params + first_param, pos - first_param);
first_param = pos;
}
}
}
if (pos > first_param) {
REPORT_PARAMS_WITH_FIRST("screen_multi_cursor", csi->params[0], csi->params + first_param, pos - first_param);
screen_multi_cursor(self->screen, csi->params[0], csi->params + first_param, pos - first_param);
}
}
}
}
static unsigned int
parse_region(const ParsedCSI *csi, Region *r) {
switch (csi->num_params) {
case 0: return 0;
case 1: r->top = csi->params[0]; return 1;
case 2:
r->top = csi->params[0];
r->left = csi->params[1];
return 2;
case 3:
r->top = csi->params[0];
r->left = csi->params[1];
r->bottom = csi->params[2];
return 3;
default:
r->top = csi->params[0];
r->left = csi->params[1];
r->bottom = csi->params[2];
r->right = csi->params[3];
return 4;
}
}
static bool
_parse_sgr(PS *self, ParsedCSI *csi) {
#define SEND_SGR \
if (num_params) { \
REPORT_PARAMS(report_name, csi->params + first_param, num_params, state != NORMAL, region); \
select_graphic_rendition(screen, csi->params + first_param, num_params, state != NORMAL, region); \
state = NORMAL; \
first_param += num_params; \
num_params = 0; \
}
Screen *screen = self->screen;
size_t pos = 0, first_param, num_params = 0;
Region r = {0}, *region = NULL;
const char *report_name = "select_graphic_rendition";
if (csi->trailer == 'r') { // DECCARA
region = &r;
if (csi->num_params == 0) {
for (; csi->num_params < 5; csi->num_params++) csi->params[csi->num_params] = 0;
}
pos = parse_region(csi, region);
report_name = "deccara";
(void)report_name;
} else if (csi->num_params == 0) {
csi->params[0] = 0;
csi->num_params++;
}
enum State { NORMAL, SUB_PARAMS, COLOR, COLOR1, COLOR3 };
enum State state = NORMAL;
for (first_param = pos; pos < csi->num_params; pos++) {
switch (state) {
case NORMAL:
if (csi->is_sub_param[pos]) {
if (num_params == 0 || pos == 0) {
REPORT_ERROR("SGR escape code has an unexpected sub-parameter ignoring the full code");
return false;
}
num_params--;
SEND_SGR;
state = SUB_PARAMS;
first_param = pos - 1;
num_params = 1;
}
switch (csi->params[pos]) {
case 38:
case 48:
case DECORATION_FG_CODE:
SEND_SGR;
state = COLOR;
first_param = pos;
num_params = 1;
break;
default: num_params++; break;
}
break;
case SUB_PARAMS:
switch (csi->is_sub_param[pos]) {
case true: num_params++; break;
case false:
SEND_SGR;
pos--;
break;
}
break;
case COLOR:
switch (csi->params[pos]) {
case 2:
state = csi->is_sub_param[pos] ? SUB_PARAMS : COLOR3;
num_params++;
break;
case 5:
state = csi->is_sub_param[pos] ? SUB_PARAMS : COLOR1;
num_params++;
break;
default: REPORT_ERROR("SGR escape code has unknown color type: %d ignoring the full code", csi->params[pos]); return false;
}
break;
case COLOR1:
num_params++;
SEND_SGR;
break;
case COLOR3:
num_params++;
if (num_params >= 5) { SEND_SGR; }
break;
}
}
SEND_SGR;
return true;
#undef SEND_SGR
}
#ifndef DUMP_COMMANDS
bool
parse_sgr(Screen *screen, const uint8_t *buf, unsigned int num, const char *report_name UNUSED, bool is_deccara) {
ParsedCSI csi = {.mult = 1};
size_t pos = 0;
RAII_ALLOC(uint8_t, _buf, malloc(num + 3));
if (!_buf) return false;
memcpy(_buf, buf, num);
if (is_deccara) {
_buf[num++] = '$';
_buf[num++] = 'r';
} else {
_buf[num++] = 'm';
}
_buf[num] = 0;
PS *state = (PS *)screen->vt_parser->state;
state->screen = screen;
if (!csi_parse_loop(state, &csi, _buf, &pos, num, 0)) return false;
return _parse_sgr(state, &csi);
}
#endif
static void
screen_cursor_up2(Screen *s, unsigned int count) {
screen_cursor_up(s, count, false, -1);
}
static void
screen_cursor_back1(Screen *s, unsigned int count) {
screen_cursor_move(s, count, -1, false);
}
static void
screen_tabn(Screen *s, unsigned int count) {
for (index_type i = 0; i < MAX(1u, count); i++) {
index_type x = s->cursor->x;
screen_tab(s);
if (s->cursor->x == x) break;
}
}
static const char *
repr_csi_params(int *params, unsigned int num_params) {
if (!num_params) return "";
static char buf[256];
unsigned int pos = 0, i = 0;
while (pos < 200 && i++ < num_params && sizeof(buf) > pos + 1) {
const char *fmt = i < num_params ? "%i, " : "%i";
int ret = snprintf(buf + pos, sizeof(buf) - pos - 1, fmt, params[i - 1]);
if (ret < 0) return "An error occurred formatting the params array";
pos += ret;
}
buf[pos] = 0;
return buf;
}
static void
handle_mode(PS *self) {
bool is_shifted = self->csi.primary == '?';
int shift = is_shifted ? 5 : 0;
for (unsigned i = 0; i < self->csi.num_params; i++) {
int p = self->csi.params[i];
if (p >= 0) {
unsigned int sp = p << shift;
switch (self->csi.trailer) {
case SM:
screen_set_mode(self->screen, sp);
REPORT_COMMAND(screen_set_mode, p, is_shifted);
break;
case RM:
screen_reset_mode(self->screen, sp);
REPORT_COMMAND(screen_reset_mode, p, is_shifted);
break;
case 's':
screen_save_mode(self->screen, sp);
REPORT_COMMAND(screen_save_mode, p, is_shifted);
break;
case 'r':
screen_restore_mode(self->screen, sp);
REPORT_COMMAND(screen_restore_mode, p, is_shifted);
break;
}
}
}
}
static void
dispatch_csi(PS *self) {
#define num_params self->csi.num_params
#define code self->csi.trailer
#define params self->csi.params
#define start_modifier self->csi.primary
#define end_modifier self->csi.secondary
#define AT_MOST_ONE_PARAMETER \
{ \
if (num_params > 1) { \
REPORT_ERROR("CSI code %s has %u > 1 parameters", csi_letter(code), num_params); \
break; \
} \
}
#define NON_NEGATIVE_PARAM(x) \
{ \
if (x < 0) { \
REPORT_ERROR("CSI code %s is not allowed to have negative parameter (%d)", csi_letter(code), x); \
break; \
} \
}
#define CALL_CSI_HANDLER1(name, defval) \
AT_MOST_ONE_PARAMETER; \
p1 = num_params > 0 ? params[0] : defval; \
NON_NEGATIVE_PARAM(p1); \
REPORT_COMMAND(name, p1); \
name(self->screen, p1); \
break;
#define CALL_CSI_HANDLER1P(name, defval, qch) \
AT_MOST_ONE_PARAMETER; \
p1 = num_params > 0 ? params[0] : defval; \
NON_NEGATIVE_PARAM(p1); \
private = start_modifier == qch; \
REPORT_COMMAND(name, p1, private); \
name(self->screen, p1, private); \
break;
#define CALL_CSI_HANDLER1S(name, defval) \
AT_MOST_ONE_PARAMETER; \
p1 = num_params > 0 ? params[0] : defval; \
NON_NEGATIVE_PARAM(p1); \
REPORT_COMMAND(name, p1, start_modifier); \
name(self->screen, p1, start_modifier); \
break;
#define CALL_CSI_HANDLER1M(name, defval) \
AT_MOST_ONE_PARAMETER; \
p1 = num_params > 0 ? params[0] : defval; \
NON_NEGATIVE_PARAM(p1); \
REPORT_COMMAND(name, p1, end_modifier); \
name(self->screen, p1, end_modifier); \
break;
#define CALL_CSI_HANDLER2(name, defval1, defval2) \
if (num_params > 2) { \
REPORT_ERROR("CSI code %s has %u > 2 parameters", csi_letter(code), num_params); \
break; \
} \
p1 = num_params > 0 ? params[0] : defval1; \
p2 = num_params > 1 ? params[1] : defval2; \
NON_NEGATIVE_PARAM(p1); \
NON_NEGATIVE_PARAM(p2); \
REPORT_COMMAND(name, p1, p2); \
name(self->screen, p1, p2); \
break;
#define NO_MODIFIERS(modifier, special, special_msg) \
{ \
if (self->csi.primary || self->csi.secondary) { \
if (special && modifier == special) { \
REPORT_ERROR(special_msg); \
} else { \
REPORT_ERROR( \
"CSI code %s has unsupported start modifier: %s or end modifier: %s", \
csi_letter(self->csi.trailer), \
csi_letter(self->csi.primary), \
csi_letter(self->csi.secondary)); \
} \
break; \
} \
}
int p1, p2;
bool private;
switch (self->csi.trailer) {
case ICH: NO_MODIFIERS(self->csi.secondary, ' ', "Shift left escape code not implemented"); CALL_CSI_HANDLER1(screen_insert_characters, 1);
case REP: CALL_CSI_HANDLER1(screen_repeat_character, 1);
case CUU: NO_MODIFIERS(end_modifier, ' ', "Shift right escape code not implemented"); CALL_CSI_HANDLER1(screen_cursor_up2, 1);
case CUD:
case VPR: CALL_CSI_HANDLER1(screen_cursor_down, 1);
case CUF:
case HPR: CALL_CSI_HANDLER1(screen_cursor_forward, 1);
case CUB: CALL_CSI_HANDLER1(screen_cursor_back1, 1);
case CNL: CALL_CSI_HANDLER1(screen_cursor_down1, 1);
case CPL: CALL_CSI_HANDLER1(screen_cursor_up1, 1);
case CHA:
case HPA: CALL_CSI_HANDLER1(screen_cursor_to_column, 1);
case VPA: CALL_CSI_HANDLER1(screen_cursor_to_line, 1);
case CBT: CALL_CSI_HANDLER1(screen_backtab, 1);
case CHT: CALL_CSI_HANDLER1(screen_tabn, 1);
case CUP:
case HVP: CALL_CSI_HANDLER2(screen_cursor_position, 1, 1);
case ED: CALL_CSI_HANDLER1P(screen_erase_in_display, 0, '?');
case EL: CALL_CSI_HANDLER1P(screen_erase_in_line, 0, '?');
case IL: CALL_CSI_HANDLER1(screen_insert_lines, 1);
case DL: CALL_CSI_HANDLER1(screen_delete_lines, 1);
case DCH:
if (end_modifier == '#' && !start_modifier) {
CALL_CSI_HANDLER1(screen_push_colors, 0);
} else {
CALL_CSI_HANDLER1(screen_delete_characters, 1);
}
case 'Q':
if (end_modifier == '#' && !start_modifier) { CALL_CSI_HANDLER1(screen_pop_colors, 0); }
REPORT_ERROR("Unknown CSI Q sequence with start and end modifiers: '%c' '%c' and %u parameters", start_modifier, end_modifier, num_params);
break;
case 'R':
if (end_modifier == '#' && !start_modifier) {
REPORT_COMMAND(screen_report_color_stack);
screen_report_color_stack(self->screen);
break;
}
REPORT_ERROR("Unknown CSI R sequence with start and end modifiers: '%c' '%c' and %u parameters", start_modifier, end_modifier, num_params);
break;
case 'W':
if (start_modifier == '?' && !end_modifier && num_params == 1 && params[0] == 5) {
REPORT_COMMAND(screen_reset_tab_stops);
screen_reset_tab_stops(self->screen);
break;
}
REPORT_ERROR("Unknown CSI W sequence with start and end modifiers: '%c' '%c' and %u parameters", start_modifier, end_modifier, num_params);
break;
case ECH: CALL_CSI_HANDLER1(screen_erase_characters, 1);
case DA: CALL_CSI_HANDLER1S(report_device_attributes, 0);
case TBC: CALL_CSI_HANDLER1(screen_clear_tab_stop, 0);
case SM: handle_mode(self); break;
case RM: handle_mode(self); break;
case DSR: CALL_CSI_HANDLER1P(report_device_status, 0, '?');
case 's':
if (!start_modifier && !end_modifier && !num_params) {
REPORT_COMMAND(screen_save_cursor);
screen_save_cursor(self->screen);
break;
} else if (start_modifier == '?' && !end_modifier) {
if (!num_params) {
REPORT_COMMAND(screen_save_modes);
screen_save_modes(self->screen);
} else handle_mode(self);
break;
}
REPORT_ERROR("Unknown CSI s sequence with start and end modifiers: '%c' '%c' and %u parameters", start_modifier, end_modifier, num_params);
break;
case 't':
if (!num_params) {
REPORT_ERROR("Unknown CSI t sequence with start and end modifiers: '%c' '%c' and no parameters", start_modifier, end_modifier);
break;
}
if (start_modifier || end_modifier) {
REPORT_ERROR(
"Unknown CSI t sequence with start and end modifiers: '%c' '%c', %u parameters and first parameter: %d",
start_modifier,
end_modifier,
num_params,
params[0]);
break;
}
switch (params[0]) {
case 4:
case 8: REPORT_ERROR("Escape codes to resize text area are not supported"); break;
case 14:
case 16:
case 18: CALL_CSI_HANDLER2(screen_report_size, 0, 0); break;
case 22:
case 23:
if (num_params == 3 && !params[2]) num_params = 2; // ignore extra 0, generated by weechat or ncurses
CALL_CSI_HANDLER2(screen_manipulate_title_stack, 22, 0);
break;
default: REPORT_ERROR("Unknown CSI t window manipulation sequence with %u parameters and first parameter: %d", num_params, params[0]); break;
}
break;
case 'u':
if (!start_modifier && !end_modifier && !num_params) {
REPORT_COMMAND(screen_restore_cursor);
screen_restore_cursor(self->screen);
break;
}
if (!end_modifier && start_modifier == '?') {
REPORT_COMMAND(screen_report_key_encoding_flags);
screen_report_key_encoding_flags(self->screen);
break;
}
if (!end_modifier && start_modifier == '=') {
CALL_CSI_HANDLER2(screen_set_key_encoding_flags, 0, 1);
break;
}
if (!end_modifier && start_modifier == '>') {
CALL_CSI_HANDLER1(screen_push_key_encoding_flags, 0);
break;
}
if (!end_modifier && start_modifier == '<') {
CALL_CSI_HANDLER1(screen_pop_key_encoding_flags, 1);
break;
}
REPORT_ERROR("Unknown CSI u sequence with start and end modifiers: '%c' '%c' and %u parameters", start_modifier, end_modifier, num_params);
break;
case 'r':
if (!start_modifier && !end_modifier) {
// DECSTBM
CALL_CSI_HANDLER2(screen_set_margins, 0, 0);
} else if (start_modifier == '?' && !end_modifier) {
if (!num_params) {
REPORT_COMMAND(screen_restore_modes);
screen_restore_modes(self->screen);
} else handle_mode(self);
break;
} else if (!start_modifier && end_modifier == '$') {
_parse_sgr(self, &self->csi);
break;
}
REPORT_ERROR("Unknown CSI r sequence with start and end modifiers: '%c' '%c' and %u parameters", start_modifier, end_modifier, num_params);
break;
case 'x':
if (!start_modifier && end_modifier == '*') { CALL_CSI_HANDLER1(screen_decsace, 0); }
REPORT_ERROR("Unknown CSI x sequence with start and end modifiers: '%c' '%c'", start_modifier, end_modifier);
break;
case DECSCUSR:
if (end_modifier == ' ') {
if (!start_modifier) { CALL_CSI_HANDLER1M(screen_set_cursor, 1); }
if (start_modifier == '>') {
_parse_multi_cursors(self, &self->csi);
break;
}
} else if (end_modifier == 0 && start_modifier == '>') {
CALL_CSI_HANDLER1(screen_xtversion, 0);
}
REPORT_ERROR("Unknown CSI q sequence with start and end modifiers: '%c' '%c'", start_modifier, end_modifier);
break;
case SU: NO_MODIFIERS(end_modifier, ' ', "Select presentation directions escape code not implemented"); CALL_CSI_HANDLER1(screen_scroll, 1);
case SD:
if (!start_modifier && end_modifier == '+') {
CALL_CSI_HANDLER1(screen_reverse_scroll_and_fill_from_scrollback, 1);
} else {
NO_MODIFIERS(start_modifier, 0, "");
CALL_CSI_HANDLER1(screen_reverse_scroll, 1);
}
break;
case DECSTR:
switch (end_modifier) {
case '$': // DECRQM
CALL_CSI_HANDLER1P(report_mode_status, 0, '?');
break;
case '!': // Soft reset
if (num_params) {
REPORT_ERROR("DECSTR escape code with parameters is invalid");
} else {
REPORT_COMMAND(screen_soft_reset);
screen_soft_reset(self->screen);
}
break;
default: REPORT_ERROR("Unknown CSI p sequence with start and end modifiers: '%c' '%c'", start_modifier, end_modifier); break;
}
break;
case 'm':
if (!start_modifier && !end_modifier) {
_parse_sgr(self, &self->csi);
break;
}
if (start_modifier == '>' && !end_modifier) {
CALL_CSI_HANDLER2(screen_modify_other_keys, 0, INT_MAX);
break;
}
/* fallthrough */
default:
REPORT_ERROR(
"Unknown CSI code: '%c' with start_modifier: '%c' and end_modifier: '%c' and parameters: '%s'",
code,
start_modifier,
end_modifier,
repr_csi_params(params, num_params));
}
#undef num_params
#undef code
#undef params
#undef start_modifier
#undef end_modifier
}
// }}}
// APC mode {{{
#include "parse-graphics-command.h"
static void
dispatch_apc(PS *self, uint8_t *buf, size_t bufsz, bool is_extended UNUSED) {
if (bufsz < 2) return;
switch (buf[0]) {
case 'G': parse_graphics_code(self, buf, bufsz); break;
default: REPORT_ERROR("Unrecognized APC code: 0x%x", buf[0]); break;
}
}
// }}}
// PM mode {{{
static void
dispatch_pm(PS *self UNUSED, uint8_t *buf, size_t bufsz, bool is_extended UNUSED) {
if (bufsz < 2) return;
switch (buf[0]) {
default: REPORT_ERROR("Unrecognized PM code: 0x%x", buf[0]); break;
}
}
// }}}
// SOS mode {{{
static void
dispatch_sos(PS *self UNUSED, uint8_t *buf, size_t bufsz, bool is_extended UNUSED) {
if (bufsz < 2) return;
switch (buf[0]) {
default: REPORT_ERROR("Unrecognized SOS code: 0x%x", buf[0]); break;
}
}
// }}}
// Parse loop {{{
static void
consume_input(PS *self, PyObject *dump_callback UNUSED, id_type window_id UNUSED) {
#define consume(x) \
if (accumulate_st_terminated_esc_code(self, dispatch_##x)) { \
self->read.consumed = self->read.pos; \
SET_STATE(NORMAL); \
} \
break;
#ifdef DUMP_COMMANDS
PyObject *dumped_bytes = PyBytes_FromStringAndSize((const char *)self->buf + self->read.pos, self->read.sz - self->read.pos);
size_t pre_consume_pos = self->read.pos;
#endif
switch (self->vte_state) {
case VTE_NORMAL:
consume_normal(self);
self->read.consumed = self->read.pos;
break;
case VTE_ESC:
if (consume_esc(self)) { self->read.consumed = self->read.pos; }
break;
case VTE_CSI:
if (consume_csi(self)) {
self->read.consumed = self->read.pos;
if (self->csi.is_valid) dispatch_csi(self);
SET_STATE(NORMAL);
}
break;
case VTE_OSC: consume(osc);
case VTE_APC: consume(apc);
case VTE_PM: consume(pm);
case VTE_DCS: consume(dcs);
case VTE_SOS: consume(sos);
}
#ifdef DUMP_COMMANDS
if (dumped_bytes && dump_callback && self->read.pos > pre_consume_pos) {
if (_PyBytes_Resize(&dumped_bytes, self->read.pos - pre_consume_pos) == 0) {
PyObject *ret = PyObject_CallFunction(dump_callback, "KsO", window_id, "bytes", dumped_bytes);
Py_DECREF(dumped_bytes);
if (ret) {
Py_DECREF(ret);
} else {
PyErr_Clear();
}
}
}
#endif
#undef consume
}
// }}}
// API {{{
#define with_lock pthread_mutex_lock(&self->lock);
#define end_with_lock pthread_mutex_unlock(&self->lock);
typedef enum { PENDING_INPUT_NONE, PENDING_INPUT_SMALL, PENDING_INPUT_READY, PENDING_INPUT_HELD } PendingInput;
static PendingInput
classify_pending_input(const PS *self, monotonic_t now) {
// Must be called with the lock held. Both the parser and the I/O thread use this,
// so the I/O thread wakes the main loop exactly when the parser will accept the input.
size_t pending = self->read.sz + self->write.pending;
// A cleared timestamp or bytes before fresh_input_at are a scanned tail the parser left in the buffer
if (!self->new_input_at || pending <= self->fresh_input_at) return PENDING_INPUT_NONE;
// A chunk this close to the end of the buffer is parsed immediately so a fast
// producer cannot fill the buffer and block while input_delay is waiting.
if (pending + INPUT_PARSE_FORCE_MARGIN > BUF_SZ) return PENDING_INPUT_READY;
if (pending - self->fresh_input_at < SMALL_PENDING_INPUT_THRESHOLD || self->input_chunk == self->accepted_chunk) return PENDING_INPUT_SMALL;
return now - self->new_input_at >= OPT(input_delay) ? PENDING_INPUT_READY : PENDING_INPUT_HELD;
}
static void
run_worker(void *p, ParseData *pd, bool flush) {
Screen *screen = (Screen *)p;
PS *self = (PS *)screen->vt_parser->state;
screen->parsing_at = pd->now;
with_lock {
self->read.sz += self->write.pending;
self->write.pending = 0;
pd->has_pending_input = self->read.pos < self->read.sz;
if (pd->has_pending_input) {
if (flush || classify_pending_input(self, pd->now) != PENDING_INPUT_HELD) {
pd->input_read = true;
self->dump_callback = pd->dump_callback;
self->now = pd->now;
self->screen = screen;
self->read.consumed = 0;
do {
end_with_lock;
// consume all already read input without lock cycling, the
// writer thread only modifies write.pending and buffer space
// beyond read.sz + write.pending
do { consume_input(self, pd->dump_callback, screen->window_id); } while (self->read.pos < self->read.sz);
with_lock;
self->read.sz += self->write.pending;
self->write.pending = 0;
} while (self->read.pos < self->read.sz);
self->new_input_at = 0;
self->fresh_input_at = 0;
if (self->read.consumed) {
pd->write_space_created = self->read.sz >= BUF_SZ;
self->read.pos -= MIN(self->read.pos, self->read.consumed);
self->read.sz -= MIN(self->read.sz, self->read.consumed);
if (self->read.sz) memmove(self->buf, self->buf + self->read.consumed, self->read.sz);
}
}
}
}
end_with_lock;
}
#ifndef DUMP_COMMANDS
static uint8_t *
create_write_buffer(Parser *p, size_t *sz) {
PS *self = (PS *)p->state;
uint8_t *ans = NULL;
with_lock {
if (!self->write.sz) {
self->write.offset = self->read.sz + self->write.pending;
*sz = BUF_SZ - self->write.offset;
self->write.sz = *sz;
ans = self->buf + self->write.offset;
}
}
end_with_lock;
return ans;
}
uint8_t *
vt_parser_create_write_buffer(Parser *p, size_t *sz) {
uint8_t *ans = create_write_buffer(p, sz);
if (!ans) fatal("vt_parser_create_write_buffer() called with an already existing write buffer");
return ans;
}
uint8_t *
vt_parser_create_write_buffer_if_none(Parser *p, size_t *sz) {
return create_write_buffer(p, sz);
}
void
vt_parser_commit_write(Parser *p, size_t sz) {
PS *self = (PS *)p->state;
with_lock {
size_t off = self->read.sz + self->write.pending;
// 0 means no unparsed input is waiting. monotonic() can return 0 at startup.
// A zero-length commit must not start the clock before any byte arrives.
if (sz && self->new_input_at == 0) {
monotonic_t stamp = monotonic();
self->new_input_at = stamp ? stamp : 1;
self->fresh_input_at = off;
self->input_chunk++;
}
if (self->write.offset > off) memmove(self->buf + off, self->buf + self->write.offset, sz);
self->write.pending += sz;
self->write.sz = 0;
}
end_with_lock;
}
bool
vt_parser_has_space_for_input(const Parser *p) {
PS *self = (PS *)p->state;
bool ans;
with_lock { ans = self->read.sz + self->write.pending < BUF_SZ; }
end_with_lock;
return ans;
}
ParserInputWake
vt_parser_input_wake(const Parser *p, monotonic_t now) {
PS *self = (PS *)p->state;
ParserInputWake ans = {0};
with_lock {
switch (classify_pending_input(self, now)) {
case PENDING_INPUT_NONE: break;
case PENDING_INPUT_SMALL: ans.small_pending = true; break;
case PENDING_INPUT_READY: ans.large_ready = true; break;
case PENDING_INPUT_HELD: ans.large_held_until = self->new_input_at + OPT(input_delay); break;
}
if (ans.small_pending || ans.large_ready || ans.large_held_until) ans.chunk = self->input_chunk;
}
end_with_lock;
return ans;
}
void
vt_parser_accept_input(Parser *p, uint64_t chunk) {
PS *self = (PS *)p->state;
with_lock {
// The chunk may have been parsed already, in which case a later chunk must not be accepted early
if (self->new_input_at && self->input_chunk == chunk) self->accepted_chunk = chunk;
}
end_with_lock;
}
#endif
// }}}
// Boilerplate {{{
#ifdef DUMP_COMMANDS
void
parse_worker_dump(void *p, ParseData *pd, bool flush) {
run_worker(p, pd, flush);
}
#else
void
parse_worker(void *p, ParseData *pd, bool flush) {
run_worker(p, pd, flush);
}
#endif
#ifndef DUMP_COMMANDS
static PyObject *
new_vtparser_object(PyTypeObject *type UNUSED, PyObject *args, PyObject UNUSED *kwds) {
id_type window_id = 0;
if (!PyArg_ParseTuple(args, "|K", &window_id)) return NULL;
return (PyObject *)alloc_vt_parser(window_id);
}
void
free_vt_parser(Parser *self) {
if (self->state) {
PS *s = (PS *)self->state;
utf8_decoder_free(&s->utf8_decoder);
pthread_mutex_destroy(&s->lock);
free(self->state);
self->state = NULL;
}
Py_TYPE(self)->tp_free((PyObject *)self);
}
static void
reset(PS *self) {
SET_STATE(NORMAL);
reset_csi(&self->csi);
utf8_decoder_reset(&self->utf8_decoder);
}
void
reset_vt_parser(Parser *self) {
reset((PS *)self->state);
}
extern PyTypeObject Screen_Type;
static PyObject *
current_state(Parser *self, PyObject *closure UNUSED) {
PS *state = (PS *)self->state;
return PyUnicode_FromString(vte_state_name(state->vte_state));
}
static PyGetSetDef getsetters[] = {
{"vte_state", (getter)current_state, NULL, "The VTE parser state", NULL}, {NULL} /* Sentinel */
};
static PyMethodDef methods[] = {
{NULL},
};
PyTypeObject Parser_Type = {
PyVarObject_HEAD_INIT(NULL, 0).tp_name = "fast_data_types.Parser",
.tp_basicsize = sizeof(Parser),
.tp_dealloc = (destructor)free_vt_parser,
.tp_flags = Py_TPFLAGS_DEFAULT,
.tp_doc = "VT Escape code parser",
.tp_methods = methods,
.tp_getset = getsetters,
.tp_new = new_vtparser_object,
};
Parser *
alloc_vt_parser(id_type window_id) {
Parser *self = (Parser *)Parser_Type.tp_alloc(&Parser_Type, 1);
if (self != NULL) {
int ret;
if ((ret = posix_memalign((void **)&self->state, BUF_EXTRA, sizeof(PS))) != 0) {
Py_CLEAR(self);
PyErr_Format(PyExc_RuntimeError, "Failed to call posix_memalign: %s", strerror(ret));
return NULL;
}
memset(self->state, 0, sizeof(PS));
PS *state = (PS *)self->state;
if ((intptr_t)state->buf % BUF_EXTRA != 0) {
Py_CLEAR(self);
PyErr_SetString(PyExc_TypeError, "PS->buf is not aligned");
return NULL;
}
if ((ret = pthread_mutex_init(&state->lock, NULL)) != 0) {
Py_CLEAR(self);
PyErr_Format(PyExc_RuntimeError, "Failed to create Parser lock mutex: %s", strerror(ret));
return NULL;
}
state->window_id = window_id;
utf8_decoder_reset(&state->utf8_decoder);
reset_csi(&state->csi);
}
return self;
}
#undef EXTRA_INIT
#define EXTRA_INIT \
if (0 != PyModule_AddIntConstant(module, "VT_PARSER_BUFFER_SIZE", BUF_SZ)) return 0; \
if (0 != PyModule_AddIntConstant(module, "VT_PARSER_MAX_ESCAPE_CODE_SIZE", MAX_ESCAPE_CODE_LENGTH)) return 0; \
if (!init_simd(module)) return 0;
INIT_TYPE(Parser)
#endif
// }}}