mirror of
https://github.com/kovidgoyal/kitty.git
synced 2026-11-19 14:45:29 +00:00
OSC 9;9;path is now treated as a report of the current working directory, like OSC 7, instead of popping up a desktop notification. Other ConEmu numeric OSC 9 sub-commands (1-12) are ignored rather than shown as notifications.
1859 lines
71 KiB
C
1859 lines
71 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:
|
|
if (limit - i >= 2 && buf[i] == '9' && buf[i + 1] == ';') {
|
|
// ConEmu cwd reporting: OSC 9;9;path
|
|
i += 2;
|
|
#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;
|
|
}
|
|
/* fallthrough */
|
|
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
|
|
// }}}
|