mirrors/foot
1
0
Fork 0
mirror of https://codeberg.org/dnkl/foot.git synced 2026-02-05 04:06:08 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
foot/vt.c

1134 lines
41 KiB
C
Raw Normal View History

wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
#include "vt.h"
#include <stdlib.h>
#include <string.h>
vt: add vt_to_slave()
2019-07-15 15:42:00 +02:00
#include <unistd.h>
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
wip: grapheme shaping
2020-08-20 19:25:35 +02:00
#if defined(FOOT_GRAPHEME_CLUSTERING)
#include <utf8proc.h>
#endif
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
#define LOG_MODULE "vt"
logging: disable debug logging by default
2019-07-03 20:21:03 +02:00
#define LOG_ENABLE_DBG 0
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
#include "log.h"
fcft: adapt to API changes in fcft-3.x Fcft no longer uses wchar_t, but plain uint32_t to represent codepoints. Since we do a fair amount of string operations in foot, it still makes sense to use something that actually _is_ a string (or character), rather than an array of uint32_t. For this reason, we switch out all wchar_t usage in foot to char32_t. We also verify, at compile-time, that char32_t used UTF-32 (which is what fcft expects). Unfortunately, there are no string functions for char32_t. To avoid having to re-implement all wcs*() functions, we add a small wrapper layer of c32*() functions. These wrapper functions take char32_t arguments, but then simply call the corresponding wcs*() function. For this to work, wcs*() must _also_ be UTF-32 compatible. We can check for the presence of the __STDC_ISO_10646__ macro. If set, wchar_t is at least 4 bytes and its internal representation is UTF-32. FreeBSD does *not* define this macro, because its internal wchar_t representation depends on the current locale. It _does_ use UTF-32 _if_ the current locale is UTF-8. Since foot enforces UTF-8, we simply need to check if __FreeBSD__ is defined. Other fcft API changes: * fcft_glyph_rasterize() -> fcft_codepoint_rasterize() * font.space_advance has been removed * ‘tags’ have been removed from fcft_grapheme_rasterize() * ‘fcft_log_init()’ removed * ‘fcft_init()’ and ‘fcft_fini()’ must be explicitly called
2021-08-21 14:50:42 +02:00
#include "char32.h"
wip: grapheme shaping
2020-08-20 19:25:35 +02:00
#include "config.h"
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
#include "csi.h"
dcs: initial handling of DCS in general Add data structure to term->vt. This structure tracks the free-form data that is passed-through, and the handler to call at the end. Intermediates and parameters are collected by the normal VT parser. Then, when we enter the passthrough state, we call dcs_hook(). This function checks the intermediate(s) and parameters, and selects the appropriate unhook handler (and optionally does some execution already). In passthrough mode, we simply append strings to an internal buffer. This might have to be changed in the future, if we need to support a DCS that needs to execute as we go. In unhook (i.e. when the DCS is terminated), we execute the unhook handler. As a proof-of-concept, handlers for BSU/ESU (Begin/End Synchronized Update) has been added (but are left unimplemented).
2020-01-12 11:55:22 +01:00
#include "dcs.h"
Print stack trace on assert() failure or when calling fatal_error() Note: this uses the __sanitizer_print_stack_trace() function from the AddressSanitizer runtime, so it only works when AddressSanitizer is in use.
2021-01-15 20:39:45 +00:00
#include "debug.h"
dcs: sort of implement DCS passthrough We now store the passthrough characters in a buffer, and call dcs_passthrough() on unhook. However, dcs_passthrough() doesn't do anything.
2019-07-19 09:55:07 +02:00
#include "osc.h"
vt: DECALN: erase sixels, reset margins, home the cursor https://vt100.net/docs/vt510-rm/DECALN.html: Notes on DECALN DECALN sets the margins to the extremes of the page, and moves the cursor to the home position.
2021-12-26 16:42:53 +01:00
#include "sixel.h"
util.h: new header file defining commonly used macros
2020-05-01 11:46:24 +02:00
#include "util.h"
Convert most dynamic allocations to use functions from xmalloc.h
2020-08-08 20:34:30 +01:00
#include "xmalloc.h"
vt: implement 'insert mode'
2019-08-30 22:08:37 +02:00
csi/ocs/vt: log unhandled/unrecognized sequences as debug messages Having them as error messages was nice when we where still missing lots of sequences. Now we don't anymore, and these just spam stdout as well as syslog when e.g. cat:ing binary data.
2019-11-29 23:59:24 +01:00
#define UNHANDLED() LOG_DBG("unhandled: %s", esc_as_string(term, final))
vt: remove almost all abort() calls Replace with generic error log messages that simply says the ESC/CSI/OSC sequence is unhandled. This can mean either invalid or unimplemented, depending on the context.
2019-07-30 21:42:46 +02:00
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
/* https://vt100.net/emu/dec_ansi_parser */
enum state {
STATE_GROUND,
vt: add all (?) missing states, actions and transitions
2019-06-23 13:28:55 +02:00
STATE_ESCAPE,
STATE_ESCAPE_INTERMEDIATE,
STATE_CSI_ENTRY,
STATE_CSI_PARAM,
STATE_CSI_INTERMEDIATE,
STATE_CSI_IGNORE,
STATE_OSC_STRING,
STATE_DCS_ENTRY,
STATE_DCS_PARAM,
STATE_DCS_INTERMEDIATE,
STATE_DCS_IGNORE,
STATE_DCS_PASSTHROUGH,
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
vt: add all (?) missing states, actions and transitions
2019-06-23 13:28:55 +02:00
STATE_SOS_PM_APC_STRING,
vt: initial version of UTF-8 decoding built-in into the VT parser
2020-06-07 16:16:50 +02:00
STATE_UTF8_21,
STATE_UTF8_31,
STATE_UTF8_32,
STATE_UTF8_41,
STATE_UTF8_42,
STATE_UTF8_43,
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
};
vt: always disable state_names[] array It isn't used anywhere, even with LOG_ENABLE_DBG
2019-11-05 13:55:43 +01:00
#if defined(_DEBUG) && defined(LOG_ENABLE_DBG) && LOG_ENABLE_DBG && 0
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
static const char *const state_names[] = {
[STATE_GROUND] = "ground",
vt: add all (?) missing states, actions and transitions
2019-06-23 13:28:55 +02:00
[STATE_ESCAPE] = "escape",
[STATE_ESCAPE_INTERMEDIATE] = "escape intermediate",
[STATE_CSI_ENTRY] = "CSI entry",
[STATE_CSI_PARAM] = "CSI param",
[STATE_CSI_INTERMEDIATE] = "CSI intermediate",
[STATE_CSI_IGNORE] = "CSI ignore",
[STATE_OSC_STRING] = "OSC string",
[STATE_DCS_ENTRY] = "DCS entry",
[STATE_DCS_PARAM] = "DCS param",
[STATE_DCS_INTERMEDIATE] = "DCS intermediate",
[STATE_DCS_IGNORE] = "DCS ignore",
[STATE_DCS_PASSTHROUGH] = "DCS passthrough",
[STATE_SOS_PM_APC_STRING] = "sos/pm/apc string",
vt: initial version of UTF-8 decoding built-in into the VT parser
2020-06-07 16:16:50 +02:00
[STATE_UTF8_21] = "UTF8 2-byte 1/2",
[STATE_UTF8_31] = "UTF8 3-byte 1/3",
[STATE_UTF8_32] = "UTF8 3-byte 2/3",
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
};
vt: don't special case UTF-8 collect state
2019-12-20 22:10:27 +01:00
#endif
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
vt: only define esc_as_string() when debug logging has been enabled
2019-11-30 00:02:19 +01:00
#if defined(LOG_ENABLE_DBG) && LOG_ENABLE_DBG
vt: improve logging of invalid and unimplemented sequences
2019-07-04 19:35:01 +02:00
static const char *
esc_as_string(struct terminal *term, uint8_t final)
vt: dummy implementation of ESC dispatch
2019-06-23 13:36:20 +02:00
{
vt: improve logging of invalid and unimplemented sequences
2019-07-04 19:35:01 +02:00
static char msg[1024];
vt: escape '\E' properly when logging an ESC sequence
2019-07-10 16:04:25 +02:00
int c = snprintf(msg, sizeof(msg), "\\E");
vt: dummy implementation of ESC dispatch
2019-06-23 13:36:20 +02:00
vt: don’t ignore extra private/intermediate characters Take ‘\E(#0’ for example - this is *not* the same as ‘\E(0’. Up until now, foot has however treated them as the same escape, because the handler for ‘\E(0’ didn’t verify there weren’t any _other_ private characters present. Fix this by turning the ‘private’ array into a single 4-byte integer. This allows us to match *all* privates with a single comparison. Private characters are added to the LSB first, and MSB last. This means we can check for single privates in pretty much the same way as before: switch (term->vt.private) { case ‘?’: ... break; } Checking for two (or more) is much uglier, but foot only supports a *single* escape with two privates, and no escapes with three or more: switch (term->vt.private) { case 0x243f: /* ‘?$’ */ ... break; } The ‘clear’ action remains simple (and fast), with a single write operation. Collecting privates is potentially _slightly_ more complex than before; we now need mask and compare, instead of simply comparing, when checking how many privates we already have. We _could_ add a counter, which would make collecting privates easier, but this would add an additional write to the ‘clean’ action which is really bad since it’s in the hot path.
2020-12-16 14:30:49 +01:00
for (size_t i = 0; i < sizeof(term->vt.private); i++) {
char value = (term->vt.private >> (i * 8)) & 0xff;
if (value == 0)
vt: handle up to two private characters
2019-07-19 09:56:59 +02:00
break;
vt: don’t ignore extra private/intermediate characters Take ‘\E(#0’ for example - this is *not* the same as ‘\E(0’. Up until now, foot has however treated them as the same escape, because the handler for ‘\E(0’ didn’t verify there weren’t any _other_ private characters present. Fix this by turning the ‘private’ array into a single 4-byte integer. This allows us to match *all* privates with a single comparison. Private characters are added to the LSB first, and MSB last. This means we can check for single privates in pretty much the same way as before: switch (term->vt.private) { case ‘?’: ... break; } Checking for two (or more) is much uglier, but foot only supports a *single* escape with two privates, and no escapes with three or more: switch (term->vt.private) { case 0x243f: /* ‘?$’ */ ... break; } The ‘clear’ action remains simple (and fast), with a single write operation. Collecting privates is potentially _slightly_ more complex than before; we now need mask and compare, instead of simply comparing, when checking how many privates we already have. We _could_ add a counter, which would make collecting privates easier, but this would add an additional write to the ‘clean’ action which is really bad since it’s in the hot path.
2020-12-16 14:30:49 +01:00
c += snprintf(&msg[c], sizeof(msg) - c, "%c", value);
vt: handle up to two private characters
2019-07-19 09:56:59 +02:00
}
vt: dummy implementation of ESC dispatch
2019-06-23 13:36:20 +02:00
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(term->vt.params.idx == 0);
vt: \EB and \E0 have an optional "private", not param (which are CSI only)
2019-07-15 13:39:19 +02:00
scan-build: fix a couple of minor warnings from a scan-build run
2019-11-05 10:39:36 +01:00
snprintf(&msg[c], sizeof(msg) - c, "%c", final);
vt: improve logging of invalid and unimplemented sequences
2019-07-04 19:35:01 +02:00
return msg;
}
vt: only define esc_as_string() when debug logging has been enabled
2019-11-30 00:02:19 +01:00
#endif
vt: improve logging of invalid and unimplemented sequences
2019-07-04 19:35:01 +02:00
performance improvements * action() returns void - this gets rid of checks in vt_from_slave() * split up ACTION_PRINT into ACTION_PRINT (ASCII) and ACTION_UTF8_PRINT ACTION_PRINT is on the hot path, and we want it streamlined. * Remove run-time checkout for unimplemented state transitions, as we shouldn't have any of those left. * Don't re-load current VT state on each iteration in vt_from_slave()
2019-07-07 16:32:18 +02:00
static void
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
action_ignore(struct terminal *term)
{
}
static void
action_clear(struct terminal *term)
{
term->vt.params.idx = 0;
vt: don’t ignore extra private/intermediate characters Take ‘\E(#0’ for example - this is *not* the same as ‘\E(0’. Up until now, foot has however treated them as the same escape, because the handler for ‘\E(0’ didn’t verify there weren’t any _other_ private characters present. Fix this by turning the ‘private’ array into a single 4-byte integer. This allows us to match *all* privates with a single comparison. Private characters are added to the LSB first, and MSB last. This means we can check for single privates in pretty much the same way as before: switch (term->vt.private) { case ‘?’: ... break; } Checking for two (or more) is much uglier, but foot only supports a *single* escape with two privates, and no escapes with three or more: switch (term->vt.private) { case 0x243f: /* ‘?$’ */ ... break; } The ‘clear’ action remains simple (and fast), with a single write operation. Collecting privates is potentially _slightly_ more complex than before; we now need mask and compare, instead of simply comparing, when checking how many privates we already have. We _could_ add a counter, which would make collecting privates easier, but this would add an additional write to the ‘clean’ action which is really bad since it’s in the hot path.
2020-12-16 14:30:49 +01:00
term->vt.private = 0;
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
}
static void
action_execute(struct terminal *term, uint8_t c)
{
LOG_DBG("execute: 0x%02x", c);
switch (c) {
/*
* 7-bit C0 control characters
*/
case '\0':
break;
vt: sort C0's in the switch statement, and use escaped character possible
2020-07-14 09:11:17 +02:00
case '\a':
/* BEL - bell */
bell: optionally render margins in red when receiving BEL Add anew config option, ‘bell=none|set-urgency’. When set to ‘set-urgency’, the margins will be painted in red (if the window did not have keyboard focus). This is intended as a cheap replacement for the ‘urgency’ hint, that doesn’t (yet) exist on Wayland. Closes #157
2020-10-08 19:55:32 +02:00
term_bell(term);
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
break;
case '\b':
/* backspace */
vt: document correct BS behavior, and why we do differently
2021-01-15 18:40:07 +01:00
#if 0
/*
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* This is the "correct" BS behavior. However, it doesn't play
vt: document correct BS behavior, and why we do differently
2021-01-15 18:40:07 +01:00
* nicely with bw/auto_left_margin, hence the alternative
* implementation below.
*
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* Note that it breaks vttest "1. Test of cursor movements ->
* Test of autowrap"
vt: document correct BS behavior, and why we do differently
2021-01-15 18:40:07 +01:00
*/
term_cursor_left(term, 1);
#else
vt: BS: *only* reset lcf if cursor is beyond right margin: don’t move cursor This is needed to make reverse auto-wrap work correctly. Without it, we’ll end up moving the cursor left one cell extra.
2020-10-02 21:40:30 +02:00
if (term->grid->cursor.lcf)
term->grid->cursor.lcf = false;
term/vt: only do reverse-wrapping (‘bw’) on cub1 Foot currently does reverse-wrapping (‘auto_left_margin’, or ’bw’) on everything that calls ‘term_cursor_left()’. This is wrong; it should only be done for cub1. From man terminfo: auto_left_margin | bw | bw | cub1 wraps from column 0 to last column This patch moves the reverse-wrapping logic from term_cursor_left() to the handling of BS (backspace). Closes #441
2021-04-08 12:58:47 +02:00
else {
/* Reverse wrap */
if (unlikely(term->grid->cursor.point.col == 0) &&
likely(term->reverse_wrap && term->auto_margin))
{
if (term->grid->cursor.point.row <= term->scroll_region.start) {
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
/* Don't wrap past, or inside, the scrolling region(?) */
term/vt: only do reverse-wrapping (‘bw’) on cub1 Foot currently does reverse-wrapping (‘auto_left_margin’, or ’bw’) on everything that calls ‘term_cursor_left()’. This is wrong; it should only be done for cub1. From man terminfo: auto_left_margin | bw | bw | cub1 wraps from column 0 to last column This patch moves the reverse-wrapping logic from term_cursor_left() to the handling of BS (backspace). Closes #441
2021-04-08 12:58:47 +02:00
} else
term_cursor_to(
term,
term->grid->cursor.point.row - 1,
term->cols - 1);
} else
term_cursor_left(term, 1);
}
vt: document correct BS behavior, and why we do differently
2021-01-15 18:40:07 +01:00
#endif
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
break;
vt: sort C0's in the switch statement, and use escaped character possible
2020-07-14 09:11:17 +02:00
case '\t': {
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
/* HT - horizontal tab */
vt: emit a tab character if all cells between cursor and tab stop are empty TAB (\t) move the cursor to the next tab stop. That’s it, according to the specification. However, many terminal emulators try to keep tabs in the grid, to be able to e.g. copy them. That is, copying a text chunk containing tabs should result in tabs being pasted, not spaces. In order to do that, we need to print a tab character to the grid. To improve text reflow of tabs, we also print spaces to the subsequent cells, up until (but not including) the next tab stop. However, we can only do this if all the cells between the cursor and the next tab stop are empty, since (obviously), we cannot overwrite pre-existing characters. Finally, while some fonts render tabs as spaces (i.e. an empty glyph), some use a glyph representing “unprintable” characters, or similar. Thus, we need to exclude cells with tab characters when rendering.
2021-06-05 22:48:20 +02:00
int start_col = term->grid->cursor.point.col;
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
int new_col = term->cols - 1;
vt: emit a tab character if all cells between cursor and tab stop are empty TAB (\t) move the cursor to the next tab stop. That’s it, according to the specification. However, many terminal emulators try to keep tabs in the grid, to be able to e.g. copy them. That is, copying a text chunk containing tabs should result in tabs being pasted, not spaces. In order to do that, we need to print a tab character to the grid. To improve text reflow of tabs, we also print spaces to the subsequent cells, up until (but not including) the next tab stop. However, we can only do this if all the cells between the cursor and the next tab stop are empty, since (obviously), we cannot overwrite pre-existing characters. Finally, while some fonts render tabs as spaces (i.e. an empty glyph), some use a glyph representing “unprintable” characters, or similar. Thus, we need to exclude cells with tab characters when rendering.
2021-06-05 22:48:20 +02:00
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
tll_foreach(term->tab_stops, it) {
vt: emit a tab character if all cells between cursor and tab stop are empty TAB (\t) move the cursor to the next tab stop. That’s it, according to the specification. However, many terminal emulators try to keep tabs in the grid, to be able to e.g. copy them. That is, copying a text chunk containing tabs should result in tabs being pasted, not spaces. In order to do that, we need to print a tab character to the grid. To improve text reflow of tabs, we also print spaces to the subsequent cells, up until (but not including) the next tab stop. However, we can only do this if all the cells between the cursor and the next tab stop are empty, since (obviously), we cannot overwrite pre-existing characters. Finally, while some fonts render tabs as spaces (i.e. an empty glyph), some use a glyph representing “unprintable” characters, or similar. Thus, we need to exclude cells with tab characters when rendering.
2021-06-05 22:48:20 +02:00
if (it->item > start_col) {
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
new_col = it->item;
break;
}
}
vt: emit a tab character if all cells between cursor and tab stop are empty TAB (\t) move the cursor to the next tab stop. That’s it, according to the specification. However, many terminal emulators try to keep tabs in the grid, to be able to e.g. copy them. That is, copying a text chunk containing tabs should result in tabs being pasted, not spaces. In order to do that, we need to print a tab character to the grid. To improve text reflow of tabs, we also print spaces to the subsequent cells, up until (but not including) the next tab stop. However, we can only do this if all the cells between the cursor and the next tab stop are empty, since (obviously), we cannot overwrite pre-existing characters. Finally, while some fonts render tabs as spaces (i.e. an empty glyph), some use a glyph representing “unprintable” characters, or similar. Thus, we need to exclude cells with tab characters when rendering.
2021-06-05 22:48:20 +02:00
xassert(new_col >= start_col);
xassert(new_col < term->cols);
struct row *row = term->grid->cur_row;
vt: TAB: don’t print a ‘\t’ to the grid if the *current* cell isn’t empty If the cursor is already at the right edge, our logic that checked for non-empty cells failed; it didn’t check the current cell. Fix by initializing ‘emit_tab_char’ to true/false, depending on the contents of the current cell.
2021-06-07 21:16:38 +02:00
bool emit_tab_char = (row->cells[start_col].wc == 0 ||
fcft: adapt to API changes in fcft-3.x Fcft no longer uses wchar_t, but plain uint32_t to represent codepoints. Since we do a fair amount of string operations in foot, it still makes sense to use something that actually _is_ a string (or character), rather than an array of uint32_t. For this reason, we switch out all wchar_t usage in foot to char32_t. We also verify, at compile-time, that char32_t used UTF-32 (which is what fcft expects). Unfortunately, there are no string functions for char32_t. To avoid having to re-implement all wcs*() functions, we add a small wrapper layer of c32*() functions. These wrapper functions take char32_t arguments, but then simply call the corresponding wcs*() function. For this to work, wcs*() must _also_ be UTF-32 compatible. We can check for the presence of the __STDC_ISO_10646__ macro. If set, wchar_t is at least 4 bytes and its internal representation is UTF-32. FreeBSD does *not* define this macro, because its internal wchar_t representation depends on the current locale. It _does_ use UTF-32 _if_ the current locale is UTF-8. Since foot enforces UTF-8, we simply need to check if __FreeBSD__ is defined. Other fcft API changes: * fcft_glyph_rasterize() -> fcft_codepoint_rasterize() * font.space_advance has been removed * ‘tags’ have been removed from fcft_grapheme_rasterize() * ‘fcft_log_init()’ removed * ‘fcft_init()’ and ‘fcft_fini()’ must be explicitly called
2021-08-21 14:50:42 +02:00
row->cells[start_col].wc == U' ');
vt: TAB: don’t print a ‘\t’ to the grid if the *current* cell isn’t empty If the cursor is already at the right edge, our logic that checked for non-empty cells failed; it didn’t check the current cell. Fix by initializing ‘emit_tab_char’ to true/false, depending on the contents of the current cell.
2021-06-07 21:16:38 +02:00
vt: emit a tab character if all cells between cursor and tab stop are empty TAB (\t) move the cursor to the next tab stop. That’s it, according to the specification. However, many terminal emulators try to keep tabs in the grid, to be able to e.g. copy them. That is, copying a text chunk containing tabs should result in tabs being pasted, not spaces. In order to do that, we need to print a tab character to the grid. To improve text reflow of tabs, we also print spaces to the subsequent cells, up until (but not including) the next tab stop. However, we can only do this if all the cells between the cursor and the next tab stop are empty, since (obviously), we cannot overwrite pre-existing characters. Finally, while some fonts render tabs as spaces (i.e. an empty glyph), some use a glyph representing “unprintable” characters, or similar. Thus, we need to exclude cells with tab characters when rendering.
2021-06-05 22:48:20 +02:00
/* Check if all cells from here until the next tab stop are empty */
vt: TAB: don’t print a ‘\t’ to the grid if the *current* cell isn’t empty If the cursor is already at the right edge, our logic that checked for non-empty cells failed; it didn’t check the current cell. Fix by initializing ‘emit_tab_char’ to true/false, depending on the contents of the current cell.
2021-06-07 21:16:38 +02:00
for (const struct cell *cell = &row->cells[start_col + 1];
vt: emit a tab character if all cells between cursor and tab stop are empty TAB (\t) move the cursor to the next tab stop. That’s it, according to the specification. However, many terminal emulators try to keep tabs in the grid, to be able to e.g. copy them. That is, copying a text chunk containing tabs should result in tabs being pasted, not spaces. In order to do that, we need to print a tab character to the grid. To improve text reflow of tabs, we also print spaces to the subsequent cells, up until (but not including) the next tab stop. However, we can only do this if all the cells between the cursor and the next tab stop are empty, since (obviously), we cannot overwrite pre-existing characters. Finally, while some fonts render tabs as spaces (i.e. an empty glyph), some use a glyph representing “unprintable” characters, or similar. Thus, we need to exclude cells with tab characters when rendering.
2021-06-05 22:48:20 +02:00
cell < &row->cells[new_col];
cell++)
{
fcft: adapt to API changes in fcft-3.x Fcft no longer uses wchar_t, but plain uint32_t to represent codepoints. Since we do a fair amount of string operations in foot, it still makes sense to use something that actually _is_ a string (or character), rather than an array of uint32_t. For this reason, we switch out all wchar_t usage in foot to char32_t. We also verify, at compile-time, that char32_t used UTF-32 (which is what fcft expects). Unfortunately, there are no string functions for char32_t. To avoid having to re-implement all wcs*() functions, we add a small wrapper layer of c32*() functions. These wrapper functions take char32_t arguments, but then simply call the corresponding wcs*() function. For this to work, wcs*() must _also_ be UTF-32 compatible. We can check for the presence of the __STDC_ISO_10646__ macro. If set, wchar_t is at least 4 bytes and its internal representation is UTF-32. FreeBSD does *not* define this macro, because its internal wchar_t representation depends on the current locale. It _does_ use UTF-32 _if_ the current locale is UTF-8. Since foot enforces UTF-8, we simply need to check if __FreeBSD__ is defined. Other fcft API changes: * fcft_glyph_rasterize() -> fcft_codepoint_rasterize() * font.space_advance has been removed * ‘tags’ have been removed from fcft_grapheme_rasterize() * ‘fcft_log_init()’ removed * ‘fcft_init()’ and ‘fcft_fini()’ must be explicitly called
2021-08-21 14:50:42 +02:00
if (!(cell->wc == 0 || cell->wc == U' ')) {
vt: emit a tab character if all cells between cursor and tab stop are empty TAB (\t) move the cursor to the next tab stop. That’s it, according to the specification. However, many terminal emulators try to keep tabs in the grid, to be able to e.g. copy them. That is, copying a text chunk containing tabs should result in tabs being pasted, not spaces. In order to do that, we need to print a tab character to the grid. To improve text reflow of tabs, we also print spaces to the subsequent cells, up until (but not including) the next tab stop. However, we can only do this if all the cells between the cursor and the next tab stop are empty, since (obviously), we cannot overwrite pre-existing characters. Finally, while some fonts render tabs as spaces (i.e. an empty glyph), some use a glyph representing “unprintable” characters, or similar. Thus, we need to exclude cells with tab characters when rendering.
2021-06-05 22:48:20 +02:00
emit_tab_char = false;
break;
}
}
/*
* Emit a tab in current cell, and write spaces to the
* subsequent cells, all the way until the next tab stop.
*/
if (emit_tab_char) {
row->dirty = true;
fcft: adapt to API changes in fcft-3.x Fcft no longer uses wchar_t, but plain uint32_t to represent codepoints. Since we do a fair amount of string operations in foot, it still makes sense to use something that actually _is_ a string (or character), rather than an array of uint32_t. For this reason, we switch out all wchar_t usage in foot to char32_t. We also verify, at compile-time, that char32_t used UTF-32 (which is what fcft expects). Unfortunately, there are no string functions for char32_t. To avoid having to re-implement all wcs*() functions, we add a small wrapper layer of c32*() functions. These wrapper functions take char32_t arguments, but then simply call the corresponding wcs*() function. For this to work, wcs*() must _also_ be UTF-32 compatible. We can check for the presence of the __STDC_ISO_10646__ macro. If set, wchar_t is at least 4 bytes and its internal representation is UTF-32. FreeBSD does *not* define this macro, because its internal wchar_t representation depends on the current locale. It _does_ use UTF-32 _if_ the current locale is UTF-8. Since foot enforces UTF-8, we simply need to check if __FreeBSD__ is defined. Other fcft API changes: * fcft_glyph_rasterize() -> fcft_codepoint_rasterize() * font.space_advance has been removed * ‘tags’ have been removed from fcft_grapheme_rasterize() * ‘fcft_log_init()’ removed * ‘fcft_init()’ and ‘fcft_fini()’ must be explicitly called
2021-08-21 14:50:42 +02:00
row->cells[start_col].wc = U'\t';
vt: emit a tab character if all cells between cursor and tab stop are empty TAB (\t) move the cursor to the next tab stop. That’s it, according to the specification. However, many terminal emulators try to keep tabs in the grid, to be able to e.g. copy them. That is, copying a text chunk containing tabs should result in tabs being pasted, not spaces. In order to do that, we need to print a tab character to the grid. To improve text reflow of tabs, we also print spaces to the subsequent cells, up until (but not including) the next tab stop. However, we can only do this if all the cells between the cursor and the next tab stop are empty, since (obviously), we cannot overwrite pre-existing characters. Finally, while some fonts render tabs as spaces (i.e. an empty glyph), some use a glyph representing “unprintable” characters, or similar. Thus, we need to exclude cells with tab characters when rendering.
2021-06-05 22:48:20 +02:00
row->cells[start_col].attrs.clean = 0;
for (struct cell *cell = &row->cells[start_col + 1];
cell < &row->cells[new_col];
cell++)
{
fcft: adapt to API changes in fcft-3.x Fcft no longer uses wchar_t, but plain uint32_t to represent codepoints. Since we do a fair amount of string operations in foot, it still makes sense to use something that actually _is_ a string (or character), rather than an array of uint32_t. For this reason, we switch out all wchar_t usage in foot to char32_t. We also verify, at compile-time, that char32_t used UTF-32 (which is what fcft expects). Unfortunately, there are no string functions for char32_t. To avoid having to re-implement all wcs*() functions, we add a small wrapper layer of c32*() functions. These wrapper functions take char32_t arguments, but then simply call the corresponding wcs*() function. For this to work, wcs*() must _also_ be UTF-32 compatible. We can check for the presence of the __STDC_ISO_10646__ macro. If set, wchar_t is at least 4 bytes and its internal representation is UTF-32. FreeBSD does *not* define this macro, because its internal wchar_t representation depends on the current locale. It _does_ use UTF-32 _if_ the current locale is UTF-8. Since foot enforces UTF-8, we simply need to check if __FreeBSD__ is defined. Other fcft API changes: * fcft_glyph_rasterize() -> fcft_codepoint_rasterize() * font.space_advance has been removed * ‘tags’ have been removed from fcft_grapheme_rasterize() * ‘fcft_log_init()’ removed * ‘fcft_init()’ and ‘fcft_fini()’ must be explicitly called
2021-08-21 14:50:42 +02:00
cell->wc = U' ';
vt: emit a tab character if all cells between cursor and tab stop are empty TAB (\t) move the cursor to the next tab stop. That’s it, according to the specification. However, many terminal emulators try to keep tabs in the grid, to be able to e.g. copy them. That is, copying a text chunk containing tabs should result in tabs being pasted, not spaces. In order to do that, we need to print a tab character to the grid. To improve text reflow of tabs, we also print spaces to the subsequent cells, up until (but not including) the next tab stop. However, we can only do this if all the cells between the cursor and the next tab stop are empty, since (obviously), we cannot overwrite pre-existing characters. Finally, while some fonts render tabs as spaces (i.e. an empty glyph), some use a glyph representing “unprintable” characters, or similar. Thus, we need to exclude cells with tab characters when rendering.
2021-06-05 22:48:20 +02:00
cell->attrs.clean = 0;
}
}
vt: change HT (horizontal tab) to *not* clear LCF According to the specification, HT **should** clear LCF. However, nearly all emulators do not. In particular, XTerm doesn't. So we follow suite.
2020-07-14 10:47:17 +02:00
/* According to the specification, HT _should_ cancel LCF. But
* XTerm, and nearly all other emulators, don't. So we follow
Fix spelling mistake in vt.c
2020-08-16 14:37:27 +01:00
* suit */
vt: change HT (horizontal tab) to *not* clear LCF According to the specification, HT **should** clear LCF. However, nearly all emulators do not. In particular, XTerm doesn't. So we follow suite.
2020-07-14 10:47:17 +02:00
bool lcf = term->grid->cursor.lcf;
vt: emit a tab character if all cells between cursor and tab stop are empty TAB (\t) move the cursor to the next tab stop. That’s it, according to the specification. However, many terminal emulators try to keep tabs in the grid, to be able to e.g. copy them. That is, copying a text chunk containing tabs should result in tabs being pasted, not spaces. In order to do that, we need to print a tab character to the grid. To improve text reflow of tabs, we also print spaces to the subsequent cells, up until (but not including) the next tab stop. However, we can only do this if all the cells between the cursor and the next tab stop are empty, since (obviously), we cannot overwrite pre-existing characters. Finally, while some fonts render tabs as spaces (i.e. an empty glyph), some use a glyph representing “unprintable” characters, or similar. Thus, we need to exclude cells with tab characters when rendering.
2021-06-05 22:48:20 +02:00
term_cursor_right(term, new_col - start_col);
vt: change HT (horizontal tab) to *not* clear LCF According to the specification, HT **should** clear LCF. However, nearly all emulators do not. In particular, XTerm doesn't. So we follow suite.
2020-07-14 10:47:17 +02:00
term->grid->cursor.lcf = lcf;
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
break;
}
vt: sort C0's in the switch statement, and use escaped character possible
2020-07-14 09:11:17 +02:00
case '\n':
case '\v':
vt: implement C0::FF - processed in the same way as C0::LF
2020-07-14 09:18:52 +02:00
case '\f':
vt: process C0::VT the same way we process C0::LF Previously, C0::VT was implemented as a simple 'cursor down'. I.e. it would behave as LF **until** it reached the bottom of the screen, where instead of scrolling, it became a no-op. See https://vt100.net/docs/vt102-ug/chapter5.html
2020-07-14 09:15:15 +02:00
/* LF - \n - line feed */
/* VT - \v - vertical tab */
vt: implement C0::FF - processed in the same way as C0::LF
2020-07-14 09:18:52 +02:00
/* FF - \f - form feed */
vt: process C0::VT the same way we process C0::LF Previously, C0::VT was implemented as a simple 'cursor down'. I.e. it would behave as LF **until** it reached the bottom of the screen, where instead of scrolling, it became a no-op. See https://vt100.net/docs/vt102-ug/chapter5.html
2020-07-14 09:15:15 +02:00
term_linefeed(term);
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
break;
vt: sort C0's in the switch statement, and use escaped character possible
2020-07-14 09:11:17 +02:00
case '\r':
/* CR - carriage ret */
term: rename term_formfeed() -> term_carriage_return()
2020-07-14 09:29:10 +02:00
term_carriage_return(term);
vt: sort C0's in the switch statement, and use escaped character possible
2020-07-14 09:11:17 +02:00
break;
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
case '\x0e':
/* SO - shift out */
terminal: add 'charset_designator' enum to make code more self-documenting This commit also renames the term_set_single_shift_ascii_printer() function to term_single_shift(), since the former is overly verbose and not really even accurate.
2021-06-09 09:51:48 +01:00
term->charsets.selected = G1;
term: performance: use a bitfield to track which ascii printer to use The things affecting which ASCII printer we use have grown... Instead of checking everything inside term_update_ascii_printer(), use a bitfield. Anything affecting the printer used, must now set a bit in this bitfield. This makes term_update_ascii_printer() much faster, since all it needs to do is check if the bitfield is zero or not.
2024-06-24 01:26:57 +02:00
term->bits_affecting_ascii_printer.charset =
term->charsets.set[term->charsets.selected] != CHARSET_ASCII;
term: runtime switch between a ‘fast’ and a ‘generic’ ASCII print function term_print() is called whenever the client application “prints” something to the grid. It is called for both ASCII and UTF-8 characters, and needs to handle sixels, insert mode and ASCII vs. graphical charsets. Since it’s on the hot path, this becomes unnecessarily slow. This patch adds a “fast” version of term_print(), tailored for the common case: ASCII characters in non-insert mode, without any sixels and non-graphical charsets. A new function, term_update_ascii_printer(), has been added, and must be called whenever: * The currently selected charset *index* changes * The currently selected charset changes (from ASCII to graphical, or vice verse) * Sixels are added to the grid * Sixels are removed from the grid * Insert mode is enabled/disabled
2021-03-14 19:19:10 +01:00
term_update_ascii_printer(term);
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
break;
case '\x0f':
/* SI - shift in */
terminal: add 'charset_designator' enum to make code more self-documenting This commit also renames the term_set_single_shift_ascii_printer() function to term_single_shift(), since the former is overly verbose and not really even accurate.
2021-06-09 09:51:48 +01:00
term->charsets.selected = G0;
term: performance: use a bitfield to track which ascii printer to use The things affecting which ASCII printer we use have grown... Instead of checking everything inside term_update_ascii_printer(), use a bitfield. Anything affecting the printer used, must now set a bit in this bitfield. This makes term_update_ascii_printer() much faster, since all it needs to do is check if the bitfield is zero or not.
2024-06-24 01:26:57 +02:00
term->bits_affecting_ascii_printer.charset =
term->charsets.set[term->charsets.selected] != CHARSET_ASCII;
term: runtime switch between a ‘fast’ and a ‘generic’ ASCII print function term_print() is called whenever the client application “prints” something to the grid. It is called for both ASCII and UTF-8 characters, and needs to handle sixels, insert mode and ASCII vs. graphical charsets. Since it’s on the hot path, this becomes unnecessarily slow. This patch adds a “fast” version of term_print(), tailored for the common case: ASCII characters in non-insert mode, without any sixels and non-graphical charsets. A new function, term_update_ascii_printer(), has been added, and must be called whenever: * The currently selected charset *index* changes * The currently selected charset changes (from ASCII to graphical, or vice verse) * Sixels are added to the grid * Sixels are removed from the grid * Insert mode is enabled/disabled
2021-03-14 19:19:10 +01:00
term_update_ascii_printer(term);
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
break;
/*
* 8-bit C1 control characters
*
* We ignore these, but keep them here for reference, along
* with their corresponding 7-bit variants.
*
* As far as I can tell, XTerm also ignores these _when in
* UTF-8 mode_. Which would be the normal mode of operation
* these days. And since we _only_ support UTF-8...
*/
term: rename term_formfeed() -> term_carriage_return()
2020-07-14 09:29:10 +02:00
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
#if 0
case '\x84': /* IND -> ESC D */
case '\x85': /* NEL -> ESC E */
case '\x88': /* Tab Set -> ESC H */
case '\x8d': /* RI -> ESC M */
case '\x8e': /* SS2 -> ESC N */
case '\x8f': /* SS3 -> ESC O */
case '\x90': /* DCS -> ESC P */
case '\x96': /* SPA -> ESC V */
case '\x97': /* EPA -> ESC W */
case '\x98': /* SOS -> ESC X */
case '\x9a': /* DECID -> ESC Z (obsolete form of CSI c) */
case '\x9b': /* CSI -> ESC [ */
case '\x9c': /* ST -> ESC \ */
case '\x9d': /* OSC -> ESC ] */
case '\x9e': /* PM -> ESC ^ */
case '\x9f': /* APC -> ESC _ */
break;
#endif
default:
break;
}
}
static void
action_print(struct terminal *term, uint8_t c)
{
wip: grapheme shaping
2020-08-20 19:25:35 +02:00
term_reset_grapheme_state(term);
term: runtime switch between a ‘fast’ and a ‘generic’ ASCII print function term_print() is called whenever the client application “prints” something to the grid. It is called for both ASCII and UTF-8 characters, and needs to handle sixels, insert mode and ASCII vs. graphical charsets. Since it’s on the hot path, this becomes unnecessarily slow. This patch adds a “fast” version of term_print(), tailored for the common case: ASCII characters in non-insert mode, without any sixels and non-graphical charsets. A new function, term_update_ascii_printer(), has been added, and must be called whenever: * The currently selected charset *index* changes * The currently selected charset changes (from ASCII to graphical, or vice verse) * Sixels are added to the grid * Sixels are removed from the grid * Insert mode is enabled/disabled
2021-03-14 19:19:10 +01:00
term->ascii_printer(term, c);
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
}
static void
vt: split up action_param() to three separate functions We’re already switching on the next VT input byte in the state machine; no need to if...else if in action_param() too. That is, split up action_param() into three: * action_param_new() * action_param_new_subparam() * action_param() This makes the code cleaner, and hopefully slightly faster. Next, to improve performance further, only check for (sub)parameter overflow in action_param_new() and action_param_subparam(). Add pointers to the VT struct that points to the currently active parameter and sub-parameter. When the number of parameters (or sub-parameters) overflow, warn, and then point the parameter pointer to a "dummy" value in the VT struct. This way, we don’t have to check anything in action_param().
2023-06-16 16:26:13 +02:00
action_param_lazy_init(struct terminal *term)
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
{
if (term->vt.params.idx == 0) {
struct vt_param *param = &term->vt.params.v[0];
vt: split up action_param() to three separate functions We’re already switching on the next VT input byte in the state machine; no need to if...else if in action_param() too. That is, split up action_param() into three: * action_param_new() * action_param_new_subparam() * action_param() This makes the code cleaner, and hopefully slightly faster. Next, to improve performance further, only check for (sub)parameter overflow in action_param_new() and action_param_subparam(). Add pointers to the VT struct that points to the currently active parameter and sub-parameter. When the number of parameters (or sub-parameters) overflow, warn, and then point the parameter pointer to a "dummy" value in the VT struct. This way, we don’t have to check anything in action_param().
2023-06-16 16:26:13 +02:00
term->vt.params.cur = param;
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
param->value = 0;
param->sub.idx = 0;
vt: split up action_param() to three separate functions We’re already switching on the next VT input byte in the state machine; no need to if...else if in action_param() too. That is, split up action_param() into three: * action_param_new() * action_param_new_subparam() * action_param() This makes the code cleaner, and hopefully slightly faster. Next, to improve performance further, only check for (sub)parameter overflow in action_param_new() and action_param_subparam(). Add pointers to the VT struct that points to the currently active parameter and sub-parameter. When the number of parameters (or sub-parameters) overflow, warn, and then point the parameter pointer to a "dummy" value in the VT struct. This way, we don’t have to check anything in action_param().
2023-06-16 16:26:13 +02:00
param->sub.cur = NULL;
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
term->vt.params.idx = 1;
}
vt: split up action_param() to three separate functions We’re already switching on the next VT input byte in the state machine; no need to if...else if in action_param() too. That is, split up action_param() into three: * action_param_new() * action_param_new_subparam() * action_param() This makes the code cleaner, and hopefully slightly faster. Next, to improve performance further, only check for (sub)parameter overflow in action_param_new() and action_param_subparam(). Add pointers to the VT struct that points to the currently active parameter and sub-parameter. When the number of parameters (or sub-parameters) overflow, warn, and then point the parameter pointer to a "dummy" value in the VT struct. This way, we don’t have to check anything in action_param().
2023-06-16 16:26:13 +02:00
}
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
vt: split up action_param() to three separate functions We’re already switching on the next VT input byte in the state machine; no need to if...else if in action_param() too. That is, split up action_param() into three: * action_param_new() * action_param_new_subparam() * action_param() This makes the code cleaner, and hopefully slightly faster. Next, to improve performance further, only check for (sub)parameter overflow in action_param_new() and action_param_subparam(). Add pointers to the VT struct that points to the currently active parameter and sub-parameter. When the number of parameters (or sub-parameters) overflow, warn, and then point the parameter pointer to a "dummy" value in the VT struct. This way, we don’t have to check anything in action_param().
2023-06-16 16:26:13 +02:00
static void
action_param_new(struct terminal *term, uint8_t c)
{
xassert(c == ';');
action_param_lazy_init(term);
vt: ensure we never step outside our parameter and sub-parameter arrays We only support 16 parameters, and for each parameter, 16 sub-parameters. If we ever hit that limit (or rather, if the client writes 17 (sub) parameters), log this and stop incrementing the parameter index variable. For performance reason, we implement the following behavior: * We never increment the parameter index past the supported number. This ensures all code *accessing* the parameter list can do so without verifying the validity of the index. * The *first* time we see too many parameters, and the first time we see too many sub parameters, log this. Then *never* log again. Even if we see too many parameters in a completely different escape. This is so that we don't have to keep a "have warned" boolean in the terminal struct, but can use a simple function local static variable.
2020-02-01 19:44:56 +01:00
const size_t max_params
= sizeof(term->vt.params.v) / sizeof(term->vt.params.v[0]);
vt: split up action_param() to three separate functions We’re already switching on the next VT input byte in the state machine; no need to if...else if in action_param() too. That is, split up action_param() into three: * action_param_new() * action_param_new_subparam() * action_param() This makes the code cleaner, and hopefully slightly faster. Next, to improve performance further, only check for (sub)parameter overflow in action_param_new() and action_param_subparam(). Add pointers to the VT struct that points to the currently active parameter and sub-parameter. When the number of parameters (or sub-parameters) overflow, warn, and then point the parameter pointer to a "dummy" value in the VT struct. This way, we don’t have to check anything in action_param().
2023-06-16 16:26:13 +02:00
struct vt_param *param;
vt: ensure we never step outside our parameter and sub-parameter arrays We only support 16 parameters, and for each parameter, 16 sub-parameters. If we ever hit that limit (or rather, if the client writes 17 (sub) parameters), log this and stop incrementing the parameter index variable. For performance reason, we implement the following behavior: * We never increment the parameter index past the supported number. This ensures all code *accessing* the parameter list can do so without verifying the validity of the index. * The *first* time we see too many parameters, and the first time we see too many sub parameters, log this. Then *never* log again. Even if we see too many parameters in a completely different escape. This is so that we don't have to keep a "have warned" boolean in the terminal struct, but can use a simple function local static variable.
2020-02-01 19:44:56 +01:00
vt: split up action_param() to three separate functions We’re already switching on the next VT input byte in the state machine; no need to if...else if in action_param() too. That is, split up action_param() into three: * action_param_new() * action_param_new_subparam() * action_param() This makes the code cleaner, and hopefully slightly faster. Next, to improve performance further, only check for (sub)parameter overflow in action_param_new() and action_param_subparam(). Add pointers to the VT struct that points to the currently active parameter and sub-parameter. When the number of parameters (or sub-parameters) overflow, warn, and then point the parameter pointer to a "dummy" value in the VT struct. This way, we don’t have to check anything in action_param().
2023-06-16 16:26:13 +02:00
if (unlikely(term->vt.params.idx >= max_params)) {
vt: ensure we never step outside our parameter and sub-parameter arrays We only support 16 parameters, and for each parameter, 16 sub-parameters. If we ever hit that limit (or rather, if the client writes 17 (sub) parameters), log this and stop incrementing the parameter index variable. For performance reason, we implement the following behavior: * We never increment the parameter index past the supported number. This ensures all code *accessing* the parameter list can do so without verifying the validity of the index. * The *first* time we see too many parameters, and the first time we see too many sub parameters, log this. Then *never* log again. Even if we see too many parameters in a completely different escape. This is so that we don't have to keep a "have warned" boolean in the terminal struct, but can use a simple function local static variable.
2020-02-01 19:44:56 +01:00
static bool have_warned = false;
if (!have_warned) {
have_warned = true;
LOG_WARN(
"unsupported: escape with more than %zu parameters "
"(will not warn again)",
sizeof(term->vt.params.v) / sizeof(term->vt.params.v[0]));
}
vt: split up action_param() to three separate functions We’re already switching on the next VT input byte in the state machine; no need to if...else if in action_param() too. That is, split up action_param() into three: * action_param_new() * action_param_new_subparam() * action_param() This makes the code cleaner, and hopefully slightly faster. Next, to improve performance further, only check for (sub)parameter overflow in action_param_new() and action_param_subparam(). Add pointers to the VT struct that points to the currently active parameter and sub-parameter. When the number of parameters (or sub-parameters) overflow, warn, and then point the parameter pointer to a "dummy" value in the VT struct. This way, we don’t have to check anything in action_param().
2023-06-16 16:26:13 +02:00
param = &term->vt.params.dummy;
} else
param = &term->vt.params.v[term->vt.params.idx++];
vt: ensure we never step outside our parameter and sub-parameter arrays We only support 16 parameters, and for each parameter, 16 sub-parameters. If we ever hit that limit (or rather, if the client writes 17 (sub) parameters), log this and stop incrementing the parameter index variable. For performance reason, we implement the following behavior: * We never increment the parameter index past the supported number. This ensures all code *accessing* the parameter list can do so without verifying the validity of the index. * The *first* time we see too many parameters, and the first time we see too many sub parameters, log this. Then *never* log again. Even if we see too many parameters in a completely different escape. This is so that we don't have to keep a "have warned" boolean in the terminal struct, but can use a simple function local static variable.
2020-02-01 19:44:56 +01:00
vt: split up action_param() to three separate functions We’re already switching on the next VT input byte in the state machine; no need to if...else if in action_param() too. That is, split up action_param() into three: * action_param_new() * action_param_new_subparam() * action_param() This makes the code cleaner, and hopefully slightly faster. Next, to improve performance further, only check for (sub)parameter overflow in action_param_new() and action_param_subparam(). Add pointers to the VT struct that points to the currently active parameter and sub-parameter. When the number of parameters (or sub-parameters) overflow, warn, and then point the parameter pointer to a "dummy" value in the VT struct. This way, we don’t have to check anything in action_param().
2023-06-16 16:26:13 +02:00
term->vt.params.cur = param;
param->value = 0;
param->sub.idx = 0;
param->sub.cur = NULL;
}
static void
action_param_new_subparam(struct terminal *term, uint8_t c)
{
xassert(c == ':');
action_param_lazy_init(term);
const size_t max_sub_params
= sizeof(term->vt.params.v[0].sub.value) / sizeof(term->vt.params.v[0].sub.value[0]);
struct vt_param *param = term->vt.params.cur;
unsigned *sub_param_value;
if (unlikely(param->sub.idx >= max_sub_params)) {
vt: ensure we never step outside our parameter and sub-parameter arrays We only support 16 parameters, and for each parameter, 16 sub-parameters. If we ever hit that limit (or rather, if the client writes 17 (sub) parameters), log this and stop incrementing the parameter index variable. For performance reason, we implement the following behavior: * We never increment the parameter index past the supported number. This ensures all code *accessing* the parameter list can do so without verifying the validity of the index. * The *first* time we see too many parameters, and the first time we see too many sub parameters, log this. Then *never* log again. Even if we see too many parameters in a completely different escape. This is so that we don't have to keep a "have warned" boolean in the terminal struct, but can use a simple function local static variable.
2020-02-01 19:44:56 +01:00
static bool have_warned = false;
if (!have_warned) {
have_warned = true;
LOG_WARN(
"unsupported: escape with more than %zu sub-parameters "
"(will not warn again)",
sizeof(term->vt.params.v[0].sub.value) / sizeof(term->vt.params.v[0].sub.value[0]));
}
vt: split up action_param() to three separate functions We’re already switching on the next VT input byte in the state machine; no need to if...else if in action_param() too. That is, split up action_param() into three: * action_param_new() * action_param_new_subparam() * action_param() This makes the code cleaner, and hopefully slightly faster. Next, to improve performance further, only check for (sub)parameter overflow in action_param_new() and action_param_subparam(). Add pointers to the VT struct that points to the currently active parameter and sub-parameter. When the number of parameters (or sub-parameters) overflow, warn, and then point the parameter pointer to a "dummy" value in the VT struct. This way, we don’t have to check anything in action_param().
2023-06-16 16:26:13 +02:00
sub_param_value = &param->sub.dummy;
} else
sub_param_value = &param->sub.value[param->sub.idx++];
param->sub.cur = sub_param_value;
*sub_param_value = 0;
}
static void
action_param(struct terminal *term, uint8_t c)
{
action_param_lazy_init(term);
xassert(term->vt.params.cur != NULL);
struct vt_param *param = term->vt.params.cur;
unsigned *value;
if (unlikely(param->sub.cur != NULL))
value = param->sub.cur;
else
value = &param->value;
unsigned v = *value;
v *= 10;
v += c - '0';
*value = v;
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
}
static void
action_collect(struct terminal *term, uint8_t c)
{
vt: collect (intermediate): log _which_ character we collected
2020-02-01 19:29:14 +01:00
LOG_DBG("collect: %c", c);
vt: don’t ignore extra private/intermediate characters Take ‘\E(#0’ for example - this is *not* the same as ‘\E(0’. Up until now, foot has however treated them as the same escape, because the handler for ‘\E(0’ didn’t verify there weren’t any _other_ private characters present. Fix this by turning the ‘private’ array into a single 4-byte integer. This allows us to match *all* privates with a single comparison. Private characters are added to the LSB first, and MSB last. This means we can check for single privates in pretty much the same way as before: switch (term->vt.private) { case ‘?’: ... break; } Checking for two (or more) is much uglier, but foot only supports a *single* escape with two privates, and no escapes with three or more: switch (term->vt.private) { case 0x243f: /* ‘?$’ */ ... break; } The ‘clear’ action remains simple (and fast), with a single write operation. Collecting privates is potentially _slightly_ more complex than before; we now need mask and compare, instead of simply comparing, when checking how many privates we already have. We _could_ add a counter, which would make collecting privates easier, but this would add an additional write to the ‘clean’ action which is really bad since it’s in the hot path.
2020-12-16 14:30:49 +01:00
/*
vt: codespell: ony -> only
2020-12-16 15:06:34 +01:00
* Having more than one private is *very* rare. Foot only supports
vt: don’t ignore extra private/intermediate characters Take ‘\E(#0’ for example - this is *not* the same as ‘\E(0’. Up until now, foot has however treated them as the same escape, because the handler for ‘\E(0’ didn’t verify there weren’t any _other_ private characters present. Fix this by turning the ‘private’ array into a single 4-byte integer. This allows us to match *all* privates with a single comparison. Private characters are added to the LSB first, and MSB last. This means we can check for single privates in pretty much the same way as before: switch (term->vt.private) { case ‘?’: ... break; } Checking for two (or more) is much uglier, but foot only supports a *single* escape with two privates, and no escapes with three or more: switch (term->vt.private) { case 0x243f: /* ‘?$’ */ ... break; } The ‘clear’ action remains simple (and fast), with a single write operation. Collecting privates is potentially _slightly_ more complex than before; we now need mask and compare, instead of simply comparing, when checking how many privates we already have. We _could_ add a counter, which would make collecting privates easier, but this would add an additional write to the ‘clean’ action which is really bad since it’s in the hot path.
2020-12-16 14:30:49 +01:00
* a *single* escape with two privates, and none with three or
* more.
*
* As such, we optimize *reading* the private(s), and *resetting*
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* them (in action_clear()). Writing is ok if it's a bit slow.
vt: don’t ignore extra private/intermediate characters Take ‘\E(#0’ for example - this is *not* the same as ‘\E(0’. Up until now, foot has however treated them as the same escape, because the handler for ‘\E(0’ didn’t verify there weren’t any _other_ private characters present. Fix this by turning the ‘private’ array into a single 4-byte integer. This allows us to match *all* privates with a single comparison. Private characters are added to the LSB first, and MSB last. This means we can check for single privates in pretty much the same way as before: switch (term->vt.private) { case ‘?’: ... break; } Checking for two (or more) is much uglier, but foot only supports a *single* escape with two privates, and no escapes with three or more: switch (term->vt.private) { case 0x243f: /* ‘?$’ */ ... break; } The ‘clear’ action remains simple (and fast), with a single write operation. Collecting privates is potentially _slightly_ more complex than before; we now need mask and compare, instead of simply comparing, when checking how many privates we already have. We _could_ add a counter, which would make collecting privates easier, but this would add an additional write to the ‘clean’ action which is really bad since it’s in the hot path.
2020-12-16 14:30:49 +01:00
*/
if ((term->vt.private & 0xff) == 0)
term->vt.private = c;
else if (((term->vt.private >> 8) & 0xff) == 0)
term->vt.private |= c << 8;
else if (((term->vt.private >> 16) & 0xff) == 0)
term->vt.private |= c << 16;
else if (((term->vt.private >> 24) & 0xff) == 0)
term->vt.private |= c << 24;
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
else
vt: don’t ignore extra private/intermediate characters Take ‘\E(#0’ for example - this is *not* the same as ‘\E(0’. Up until now, foot has however treated them as the same escape, because the handler for ‘\E(0’ didn’t verify there weren’t any _other_ private characters present. Fix this by turning the ‘private’ array into a single 4-byte integer. This allows us to match *all* privates with a single comparison. Private characters are added to the LSB first, and MSB last. This means we can check for single privates in pretty much the same way as before: switch (term->vt.private) { case ‘?’: ... break; } Checking for two (or more) is much uglier, but foot only supports a *single* escape with two privates, and no escapes with three or more: switch (term->vt.private) { case 0x243f: /* ‘?$’ */ ... break; } The ‘clear’ action remains simple (and fast), with a single write operation. Collecting privates is potentially _slightly_ more complex than before; we now need mask and compare, instead of simply comparing, when checking how many privates we already have. We _could_ add a counter, which would make collecting privates easier, but this would add an additional write to the ‘clean’ action which is really bad since it’s in the hot path.
2020-12-16 14:30:49 +01:00
LOG_WARN("only four private/intermediate characters supported");
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
}
vt: add some unit tests for action_collect()
2021-07-02 08:36:39 +01:00
UNITTEST
{
struct terminal term = {.vt = {.private = 0}};
uint32_t expected = ' ';
action_collect(&term, ' ');
xassert(term.vt.private == expected);
expected |= '/' << 8;
action_collect(&term, '/');
xassert(term.vt.private == expected);
expected |= '<' << 16;
action_collect(&term, '<');
xassert(term.vt.private == expected);
expected |= '?' << 24;
action_collect(&term, '?');
xassert(term.vt.private == expected);
action_collect(&term, '?');
xassert(term.vt.private == expected);
}
vt: improve handling of HTS Do not insert existing positions into the tab stop list. This prevents a performance issue when iterating through an extremely long tab stop list. Also corrects the behaviour of CBT.
2023-07-20 07:00:14 +08:00
static void
tab_set(struct terminal *term)
{
int col = term->grid->cursor.point.col;
if (tll_length(term->tab_stops) == 0 || tll_back(term->tab_stops) < col) {
tll_push_back(term->tab_stops, col);
return;
}
tll_foreach(term->tab_stops, it) {
if (it->item < col) {
continue;
}
if (it->item > col) {
tll_insert_before(term->tab_stops, it, col);
}
break;
}
}
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
static void
action_esc_dispatch(struct terminal *term, uint8_t final)
vt: improve logging of invalid and unimplemented sequences
2019-07-04 19:35:01 +02:00
{
LOG_DBG("ESC: %s", esc_as_string(term, final));
vt: dummy implementation of ESC dispatch
2019-06-23 13:36:20 +02:00
vt: don’t ignore extra private/intermediate characters Take ‘\E(#0’ for example - this is *not* the same as ‘\E(0’. Up until now, foot has however treated them as the same escape, because the handler for ‘\E(0’ didn’t verify there weren’t any _other_ private characters present. Fix this by turning the ‘private’ array into a single 4-byte integer. This allows us to match *all* privates with a single comparison. Private characters are added to the LSB first, and MSB last. This means we can check for single privates in pretty much the same way as before: switch (term->vt.private) { case ‘?’: ... break; } Checking for two (or more) is much uglier, but foot only supports a *single* escape with two privates, and no escapes with three or more: switch (term->vt.private) { case 0x243f: /* ‘?$’ */ ... break; } The ‘clear’ action remains simple (and fast), with a single write operation. Collecting privates is potentially _slightly_ more complex than before; we now need mask and compare, instead of simply comparing, when checking how many privates we already have. We _could_ add a counter, which would make collecting privates easier, but this would add an additional write to the ‘clean’ action which is really bad since it’s in the hot path.
2020-12-16 14:30:49 +01:00
switch (term->vt.private) {
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
case 0:
switch (final) {
case '7':
term/vt/csi: break out cursor save/restore to dedicated functions
2021-01-15 17:08:30 +01:00
term_save_cursor(term);
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
break;
vt/csi: recognize the reset sequence sent by 'reset' However, we don't (yet) actually reset the terminal
2019-07-17 10:39:38 +02:00
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
case '8':
grid: move 'cursor' state from terminal to grid This way, the 'normal' and 'alt' grids have their own cursor state, and we don't need to switch between them.
2020-04-16 18:51:14 +02:00
term_restore_cursor(term, &term->grid->saved_cursor);
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
break;
vt: dummy implementation of of "ESC (B" (character charset)
2019-06-29 20:49:00 +02:00
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
case 'c':
term_reset(term, true);
break;
vt: dummy implementation of of "ESC (B" (character charset)
2019-06-29 20:49:00 +02:00
vt: add support for LS2 and LS3 locking shifts
2021-06-08 21:06:18 +01:00
case 'n':
/* LS2 - Locking Shift 2 */
terminal: add 'charset_designator' enum to make code more self-documenting This commit also renames the term_set_single_shift_ascii_printer() function to term_single_shift(), since the former is overly verbose and not really even accurate.
2021-06-09 09:51:48 +01:00
term->charsets.selected = G2;
term: performance: use a bitfield to track which ascii printer to use The things affecting which ASCII printer we use have grown... Instead of checking everything inside term_update_ascii_printer(), use a bitfield. Anything affecting the printer used, must now set a bit in this bitfield. This makes term_update_ascii_printer() much faster, since all it needs to do is check if the bitfield is zero or not.
2024-06-24 01:26:57 +02:00
term->bits_affecting_ascii_printer.charset =
term->charsets.set[term->charsets.selected] != CHARSET_ASCII;
vt: add support for LS2 and LS3 locking shifts
2021-06-08 21:06:18 +01:00
term_update_ascii_printer(term);
break;
case 'o':
/* LS3 - Locking Shift 3 */
terminal: add 'charset_designator' enum to make code more self-documenting This commit also renames the term_set_single_shift_ascii_printer() function to term_single_shift(), since the former is overly verbose and not really even accurate.
2021-06-09 09:51:48 +01:00
term->charsets.selected = G3;
term: performance: use a bitfield to track which ascii printer to use The things affecting which ASCII printer we use have grown... Instead of checking everything inside term_update_ascii_printer(), use a bitfield. Anything affecting the printer used, must now set a bit in this bitfield. This makes term_update_ascii_printer() much faster, since all it needs to do is check if the bitfield is zero or not.
2024-06-24 01:26:57 +02:00
term->bits_affecting_ascii_printer.charset =
term->charsets.set[term->charsets.selected] != CHARSET_ASCII;
vt: add support for LS2 and LS3 locking shifts
2021-06-08 21:06:18 +01:00
term_update_ascii_printer(term);
break;
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
case 'D':
term_linefeed(term);
break;
vt: implement \ED and \EE '\ED' is just like '\n'; move the cursor down to the next row, or if it's at the bottom, scroll up one row. '\EE' is just like '\n\r'
2019-07-10 16:05:19 +02:00
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
case 'E':
term: rename term_formfeed() -> term_carriage_return()
2020-07-14 09:29:10 +02:00
term_carriage_return(term);
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
term_linefeed(term);
break;
vt: implement SS2/SS3 and ST
2019-07-18 19:25:53 +02:00
vt: implement ESC H - set tab stop at current column
2019-11-16 10:57:11 +01:00
case 'H':
vt: improve handling of HTS Do not insert existing positions into the tab stop list. This prevents a performance issue when iterating through an extremely long tab stop list. Also corrects the behaviour of CBT.
2023-07-20 07:00:14 +08:00
tab_set(term);
vt: implement ESC H - set tab stop at current column
2019-11-16 10:57:11 +01:00
break;
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
case 'M':
term_reverse_index(term);
break;
vt: \EM now calls term_reverse_index() instead of always scrolling one line
2019-07-10 16:05:01 +02:00
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
case 'N':
/* SS2 - Single Shift 2 */
terminal: add 'charset_designator' enum to make code more self-documenting This commit also renames the term_set_single_shift_ascii_printer() function to term_single_shift(), since the former is overly verbose and not really even accurate.
2021-06-09 09:51:48 +01:00
term_single_shift(term, G2);
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
break;
vt: implement SS2/SS3 and ST
2019-07-18 19:25:53 +02:00
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
case 'O':
/* SS3 - Single Shift 3 */
terminal: add 'charset_designator' enum to make code more self-documenting This commit also renames the term_set_single_shift_ascii_printer() function to term_single_shift(), since the former is overly verbose and not really even accurate.
2021-06-09 09:51:48 +01:00
term_single_shift(term, G3);
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
break;
vt: implement SS2/SS3 and ST
2019-07-18 19:25:53 +02:00
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
case '\\':
/* ST - String Terminator */
break;
vt: implement \ED and \EE '\ED' is just like '\n'; move the cursor down to the next row, or if it's at the bottom, scroll up one row. '\EE' is just like '\n\r'
2019-07-10 16:05:19 +02:00
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
case '=':
term->keypad_keys_mode = KEYPAD_APPLICATION;
break;
vt: recognize ESC(0 - switch character set
2019-07-03 16:21:26 +02:00
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
case '>':
term->keypad_keys_mode = KEYPAD_NUMERICAL;
break;
vt: recognize ESC(0 - switch character set
2019-07-03 16:21:26 +02:00
default:
vt: remove almost all abort() calls Replace with generic error log messages that simply says the ESC/CSI/OSC sequence is unhandled. This can mean either invalid or unimplemented, depending on the context.
2019-07-30 21:42:46 +02:00
UNHANDLED();
performance improvements * action() returns void - this gets rid of checks in vt_from_slave() * split up ACTION_PRINT into ACTION_PRINT (ASCII) and ACTION_UTF8_PRINT ACTION_PRINT is on the hot path, and we want it streamlined. * Remove run-time checkout for unimplemented state transitions, as we shouldn't have any of those left. * Don't re-load current VT state on each iteration in vt_from_slave()
2019-07-07 16:32:18 +02:00
break;
vt: recognize ESC(0 - switch character set
2019-07-03 16:21:26 +02:00
}
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
break; /* private[0] == 0 */
vt: fix buggy chains of ternary expressions in action_esc_dispatch() Only the first character in the chain was being compared with `priv` and the rest were just being evaluated as simple expressions. This was causing the G2 and G3 operations to erroneously use the G1 index. Since the characters are a contiguous range, we can just subtract the start of the range to get the appropriate index. The outer switch statement already ensures the values are in range.
2021-06-08 16:52:00 +01:00
// Designate character set
case '(': // G0
case ')': // G1
case '*': // G2
case '+': // G3
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
switch (final) {
case '0': {
vt: fix buggy chains of ternary expressions in action_esc_dispatch() Only the first character in the chain was being compared with `priv` and the rest were just being evaluated as simple expressions. This was causing the G2 and G3 operations to erroneously use the G1 index. Since the characters are a contiguous range, we can just subtract the start of the range to get the appropriate index. The outer switch statement already ensures the values are in range.
2021-06-08 16:52:00 +01:00
size_t idx = term->vt.private - '(';
terminal: add 'charset_designator' enum to make code more self-documenting This commit also renames the term_set_single_shift_ascii_printer() function to term_single_shift(), since the former is overly verbose and not really even accurate.
2021-06-09 09:51:48 +01:00
xassert(idx <= G3);
term: move charset variables into an anonymous struct
2019-11-17 09:59:12 +01:00
term->charsets.set[idx] = CHARSET_GRAPHIC;
term: performance: use a bitfield to track which ascii printer to use The things affecting which ASCII printer we use have grown... Instead of checking everything inside term_update_ascii_printer(), use a bitfield. Anything affecting the printer used, must now set a bit in this bitfield. This makes term_update_ascii_printer() much faster, since all it needs to do is check if the bitfield is zero or not.
2024-06-24 01:26:57 +02:00
term->bits_affecting_ascii_printer.charset =
term->charsets.set[term->charsets.selected] != CHARSET_ASCII;
term: runtime switch between a ‘fast’ and a ‘generic’ ASCII print function term_print() is called whenever the client application “prints” something to the grid. It is called for both ASCII and UTF-8 characters, and needs to handle sixels, insert mode and ASCII vs. graphical charsets. Since it’s on the hot path, this becomes unnecessarily slow. This patch adds a “fast” version of term_print(), tailored for the common case: ASCII characters in non-insert mode, without any sixels and non-graphical charsets. A new function, term_update_ascii_printer(), has been added, and must be called whenever: * The currently selected charset *index* changes * The currently selected charset changes (from ASCII to graphical, or vice verse) * Sixels are added to the grid * Sixels are removed from the grid * Insert mode is enabled/disabled
2021-03-14 19:19:10 +01:00
term_update_ascii_printer(term);
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
break;
}
vt: dummy implementation of of "ESC (B" (character charset)
2019-06-29 20:49:00 +02:00
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
case 'B': {
vt: fix buggy chains of ternary expressions in action_esc_dispatch() Only the first character in the chain was being compared with `priv` and the rest were just being evaluated as simple expressions. This was causing the G2 and G3 operations to erroneously use the G1 index. Since the characters are a contiguous range, we can just subtract the start of the range to get the appropriate index. The outer switch statement already ensures the values are in range.
2021-06-08 16:52:00 +01:00
size_t idx = term->vt.private - '(';
terminal: add 'charset_designator' enum to make code more self-documenting This commit also renames the term_set_single_shift_ascii_printer() function to term_single_shift(), since the former is overly verbose and not really even accurate.
2021-06-09 09:51:48 +01:00
xassert(idx <= G3);
term: move charset variables into an anonymous struct
2019-11-17 09:59:12 +01:00
term->charsets.set[idx] = CHARSET_ASCII;
term: performance: use a bitfield to track which ascii printer to use The things affecting which ASCII printer we use have grown... Instead of checking everything inside term_update_ascii_printer(), use a bitfield. Anything affecting the printer used, must now set a bit in this bitfield. This makes term_update_ascii_printer() much faster, since all it needs to do is check if the bitfield is zero or not.
2024-06-24 01:26:57 +02:00
term->bits_affecting_ascii_printer.charset =
term->charsets.set[term->charsets.selected] != CHARSET_ASCII;
term: runtime switch between a ‘fast’ and a ‘generic’ ASCII print function term_print() is called whenever the client application “prints” something to the grid. It is called for both ASCII and UTF-8 characters, and needs to handle sixels, insert mode and ASCII vs. graphical charsets. Since it’s on the hot path, this becomes unnecessarily slow. This patch adds a “fast” version of term_print(), tailored for the common case: ASCII characters in non-insert mode, without any sixels and non-graphical charsets. A new function, term_update_ascii_printer(), has been added, and must be called whenever: * The currently selected charset *index* changes * The currently selected charset changes (from ASCII to graphical, or vice verse) * Sixels are added to the grid * Sixels are removed from the grid * Insert mode is enabled/disabled
2021-03-14 19:19:10 +01:00
term_update_ascii_printer(term);
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
break;
}
}
vt: dummy implementation of ESC dispatch
2019-06-23 13:36:20 +02:00
break;
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
case '#':
switch (final) {
vt: update DECALN to use term_fill()
2021-12-26 16:07:51 +01:00
case '8': /* DECALN */
vt: DECALN: erase sixels, reset margins, home the cursor https://vt100.net/docs/vt510-rm/DECALN.html: Notes on DECALN DECALN sets the margins to the extremes of the page, and moves the cursor to the home position.
2021-12-26 16:42:53 +01:00
sixel_overwrite_by_rectangle(term, 0, 0, term->rows, term->cols);
term->scroll_region.start = 0;
term->scroll_region.end = term->rows;
vt: update DECALN to use term_fill()
2021-12-26 16:07:51 +01:00
for (int r = 0; r < term->rows; r++)
term_fill(term, r, 0, 'E', term->cols, false);
vt: DECALN: erase sixels, reset margins, home the cursor https://vt100.net/docs/vt510-rm/DECALN.html: Notes on DECALN DECALN sets the margins to the extremes of the page, and moves the cursor to the home position.
2021-12-26 16:42:53 +01:00
term_cursor_home(term);
vt: esc dispatch: implement DECALN In esc dispatch: * Switch on private first, then final * Recognize ESC #8 (DECALN), and implement it
2019-11-05 11:32:56 +01:00
break;
}
break; /* private[0] == '#' */
performance improvements * action() returns void - this gets rid of checks in vt_from_slave() * split up ACTION_PRINT into ACTION_PRINT (ASCII) and ACTION_UTF8_PRINT ACTION_PRINT is on the hot path, and we want it streamlined. * Remove run-time checkout for unimplemented state transitions, as we shouldn't have any of those left. * Don't re-load current VT state on each iteration in vt_from_slave()
2019-07-07 16:32:18 +02:00
}
}
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
static void
action_csi_dispatch(struct terminal *term, uint8_t c)
Revert "vt: replace pre_print() with term_autowrap()" This reverts commit fd8a3992745b9ec51b6e6c1dfc39faf01369b680.
2019-11-17 17:22:16 +01:00
{
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
csi_dispatch(term, c);
}
static void
action_osc_start(struct terminal *term, uint8_t c)
{
term->vt.osc.idx = 0;
}
static void
action_osc_end(struct terminal *term, uint8_t c)
{
vt: free OSC buffer after dispatch, if larger than 4K
2022-03-20 16:31:44 +01:00
struct vt *vt = &term->vt;
if (!osc_ensure_size(term, vt->osc.idx + 1))
vt: don't try to move cursor outside the terminal When we insert an auto-newline, we must make sure we don't try to move outside the terminal window. This can for example happen when a scrolling region have been configured, and the cursor is **outside** the scrolling region (i.e. it's in the bottom margin).
2019-11-30 00:32:34 +01:00
return;
vt: free OSC buffer after dispatch, if larger than 4K
2022-03-20 16:31:44 +01:00
vt->osc.data[vt->osc.idx] = '\0';
vt->osc.bel = c == '\a';
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
osc_dispatch(term);
vt: free OSC buffer after dispatch, if larger than 4K
2022-03-20 16:31:44 +01:00
if (unlikely(vt->osc.idx >= 4096)) {
free(vt->osc.data);
vt->osc.data = NULL;
vt->osc.size = 0;
}
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
}
static void
action_osc_put(struct terminal *term, uint8_t c)
{
if (!osc_ensure_size(term, term->vt.osc.idx + 1))
vt: don't try to move cursor outside the terminal When we insert an auto-newline, we must make sure we don't try to move outside the terminal window. This can for example happen when a scrolling region have been configured, and the cursor is **outside** the scrolling region (i.e. it's in the bottom margin).
2019-11-30 00:32:34 +01:00
return;
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
term->vt.osc.data[term->vt.osc.idx++] = c;
}
vt: don't try to move cursor outside the terminal When we insert an auto-newline, we must make sure we don't try to move outside the terminal window. This can for example happen when a scrolling region have been configured, and the cursor is **outside** the scrolling region (i.e. it's in the bottom margin).
2019-11-30 00:32:34 +01:00
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
static void
action_hook(struct terminal *term, uint8_t c)
{
dcs: initial handling of DCS in general Add data structure to term->vt. This structure tracks the free-form data that is passed-through, and the handler to call at the end. Intermediates and parameters are collected by the normal VT parser. Then, when we enter the passthrough state, we call dcs_hook(). This function checks the intermediate(s) and parameters, and selects the appropriate unhook handler (and optionally does some execution already). In passthrough mode, we simply append strings to an internal buffer. This might have to be changed in the future, if we need to support a DCS that needs to execute as we go. In unhook (i.e. when the DCS is terminated), we execute the unhook handler. As a proof-of-concept, handlers for BSU/ESU (Begin/End Synchronized Update) has been added (but are left unimplemented).
2020-01-12 11:55:22 +01:00
dcs_hook(term, c);
Revert "vt: replace pre_print() with term_autowrap()" This reverts commit fd8a3992745b9ec51b6e6c1dfc39faf01369b680.
2019-11-17 17:22:16 +01:00
}
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
static void
action_unhook(struct terminal *term, uint8_t c)
performance improvements * action() returns void - this gets rid of checks in vt_from_slave() * split up ACTION_PRINT into ACTION_PRINT (ASCII) and ACTION_UTF8_PRINT ACTION_PRINT is on the hot path, and we want it streamlined. * Remove run-time checkout for unimplemented state transitions, as we shouldn't have any of those left. * Don't re-load current VT state on each iteration in vt_from_slave()
2019-07-07 16:32:18 +02:00
{
dcs: initial handling of DCS in general Add data structure to term->vt. This structure tracks the free-form data that is passed-through, and the handler to call at the end. Intermediates and parameters are collected by the normal VT parser. Then, when we enter the passthrough state, we call dcs_hook(). This function checks the intermediate(s) and parameters, and selects the appropriate unhook handler (and optionally does some execution already). In passthrough mode, we simply append strings to an internal buffer. This might have to be changed in the future, if we need to support a DCS that needs to execute as we go. In unhook (i.e. when the DCS is terminated), we execute the unhook handler. As a proof-of-concept, handlers for BSU/ESU (Begin/End Synchronized Update) has been added (but are left unimplemented).
2020-01-12 11:55:22 +01:00
dcs_unhook(term);
performance improvements * action() returns void - this gets rid of checks in vt_from_slave() * split up ACTION_PRINT into ACTION_PRINT (ASCII) and ACTION_UTF8_PRINT ACTION_PRINT is on the hot path, and we want it streamlined. * Remove run-time checkout for unimplemented state transitions, as we shouldn't have any of those left. * Don't re-load current VT state on each iteration in vt_from_slave()
2019-07-07 16:32:18 +02:00
}
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
static void
action_put(struct terminal *term, uint8_t c)
performance improvements * action() returns void - this gets rid of checks in vt_from_slave() * split up ACTION_PRINT into ACTION_PRINT (ASCII) and ACTION_UTF8_PRINT ACTION_PRINT is on the hot path, and we want it streamlined. * Remove run-time checkout for unimplemented state transitions, as we shouldn't have any of those left. * Don't re-load current VT state on each iteration in vt_from_slave()
2019-07-07 16:32:18 +02:00
{
dcs: initial handling of DCS in general Add data structure to term->vt. This structure tracks the free-form data that is passed-through, and the handler to call at the end. Intermediates and parameters are collected by the normal VT parser. Then, when we enter the passthrough state, we call dcs_hook(). This function checks the intermediate(s) and parameters, and selects the appropriate unhook handler (and optionally does some execution already). In passthrough mode, we simply append strings to an internal buffer. This might have to be changed in the future, if we need to support a DCS that needs to execute as we go. In unhook (i.e. when the DCS is terminated), we execute the unhook handler. As a proof-of-concept, handlers for BSU/ESU (Begin/End Synchronized Update) has been added (but are left unimplemented).
2020-01-12 11:55:22 +01:00
dcs_put(term, c);
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
}
vt: fix memory corruption: wcwidth() may return -1 When it did, we called print_insert() with that, which in turn resulted in a too large size value passed to memmove.
2019-11-30 00:15:05 +01:00
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
static void
fcft: adapt to API changes in fcft-3.x Fcft no longer uses wchar_t, but plain uint32_t to represent codepoints. Since we do a fair amount of string operations in foot, it still makes sense to use something that actually _is_ a string (or character), rather than an array of uint32_t. For this reason, we switch out all wchar_t usage in foot to char32_t. We also verify, at compile-time, that char32_t used UTF-32 (which is what fcft expects). Unfortunately, there are no string functions for char32_t. To avoid having to re-implement all wcs*() functions, we add a small wrapper layer of c32*() functions. These wrapper functions take char32_t arguments, but then simply call the corresponding wcs*() function. For this to work, wcs*() must _also_ be UTF-32 compatible. We can check for the presence of the __STDC_ISO_10646__ macro. If set, wchar_t is at least 4 bytes and its internal representation is UTF-32. FreeBSD does *not* define this macro, because its internal wchar_t representation depends on the current locale. It _does_ use UTF-32 _if_ the current locale is UTF-8. Since foot enforces UTF-8, we simply need to check if __FreeBSD__ is defined. Other fcft API changes: * fcft_glyph_rasterize() -> fcft_codepoint_rasterize() * font.space_advance has been removed * ‘tags’ have been removed from fcft_grapheme_rasterize() * ‘fcft_log_init()’ removed * ‘fcft_init()’ and ‘fcft_fini()’ must be explicitly called
2021-08-21 14:50:42 +02:00
action_utf8_print(struct terminal *term, char32_t wc)
vt: remove enum action; add separate functions for each action instead
2019-12-20 23:27:15 +01:00
{
term+vt: refactor: move "utf8" char processing to term_process_and_print_non_ascii() This function "prints" any non-ascii character (i.e. any character that ends up in the action_utf8_print() function in vt.c) to the grid. This includes grapheme cluster processing etc. action_utf8_print() now simply calls this function. This allows us to re-use the same functionality from other places (like the text-sizing protocol).
2025-01-26 07:33:53 +01:00
term_process_and_print_non_ascii(term, wc);
vt: dummy implementation of ESC dispatch
2019-06-23 13:36:20 +02:00
}
vt: initial version of UTF-8 decoding built-in into the VT parser
2020-06-07 16:16:50 +02:00
static void
action_utf8_21(struct terminal *term, uint8_t c)
{
// wc = ((utf8[0] & 0x1f) << 6) | (utf8[1] & 0x3f)
term->vt.utf8 = (c & 0x1f) << 6;
}
static void
action_utf8_22(struct terminal *term, uint8_t c)
{
// wc = ((utf8[0] & 0x1f) << 6) | (utf8[1] & 0x3f)
term->vt.utf8 |= c & 0x3f;
action_utf8_print(term, term->vt.utf8);
}
static void
action_utf8_31(struct terminal *term, uint8_t c)
{
// wc = ((utf8[0] & 0xf) << 12) | ((utf8[1] & 0x3f) << 6) | (utf8[2] & 0x3f)
term->vt.utf8 = (c & 0x0f) << 12;
}
static void
action_utf8_32(struct terminal *term, uint8_t c)
{
// wc = ((utf8[0] & 0xf) << 12) | ((utf8[1] & 0x3f) << 6) | (utf8[2] & 0x3f)
term->vt.utf8 |= (c & 0x3f) << 6;
}
static void
action_utf8_33(struct terminal *term, uint8_t c)
{
// wc = ((utf8[0] & 0xf) << 12) | ((utf8[1] & 0x3f) << 6) | (utf8[2] & 0x3f)
term->vt.utf8 |= c & 0x3f;
vt: detect and ignore invalid UTF-8 sequences This patch detects invalid codepoints in the UTF-8 EDxxxx range, and the F4xxxxxx range. Note that we still allow the E0xxxx and F0xxxxxx ranges. These contains overlong encodings. We allow them, because they still decode into correct UTF-32. Closes #1423
2023-07-22 11:21:41 +02:00
const char32_t utf32 = term->vt.utf8;
if (unlikely(utf32 >= 0xd800 && utf32 <= 0xdfff)) {
/* Invalid sequence - invalid UTF-16 surrogate halves */
return;
}
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
/* Note: the E0 range contains overlong encodings. We don't try to
detect, as they'll still decode to valid UTF-32. */
vt: detect and ignore invalid UTF-8 sequences This patch detects invalid codepoints in the UTF-8 EDxxxx range, and the F4xxxxxx range. Note that we still allow the E0xxxx and F0xxxxxx ranges. These contains overlong encodings. We allow them, because they still decode into correct UTF-32. Closes #1423
2023-07-22 11:21:41 +02:00
vt: initial version of UTF-8 decoding built-in into the VT parser
2020-06-07 16:16:50 +02:00
action_utf8_print(term, term->vt.utf8);
}
static void
action_utf8_41(struct terminal *term, uint8_t c)
{
// wc = ((utf8[0] & 7) << 18) | ((utf8[1] & 0x3f) << 12) | ((utf8[2] & 0x3f) << 6) | (utf8[3] & 0x3f);
term->vt.utf8 = (c & 0x07) << 18;
}
static void
action_utf8_42(struct terminal *term, uint8_t c)
{
// wc = ((utf8[0] & 7) << 18) | ((utf8[1] & 0x3f) << 12) | ((utf8[2] & 0x3f) << 6) | (utf8[3] & 0x3f);
term->vt.utf8 |= (c & 0x3f) << 12;
}
static void
action_utf8_43(struct terminal *term, uint8_t c)
{
// wc = ((utf8[0] & 7) << 18) | ((utf8[1] & 0x3f) << 12) | ((utf8[2] & 0x3f) << 6) | (utf8[3] & 0x3f);
term->vt.utf8 |= (c & 0x3f) << 6;
}
static void
action_utf8_44(struct terminal *term, uint8_t c)
{
// wc = ((utf8[0] & 7) << 18) | ((utf8[1] & 0x3f) << 12) | ((utf8[2] & 0x3f) << 6) | (utf8[3] & 0x3f);
term->vt.utf8 |= c & 0x3f;
vt: detect and ignore invalid UTF-8 sequences This patch detects invalid codepoints in the UTF-8 EDxxxx range, and the F4xxxxxx range. Note that we still allow the E0xxxx and F0xxxxxx ranges. These contains overlong encodings. We allow them, because they still decode into correct UTF-32. Closes #1423
2023-07-22 11:21:41 +02:00
const char32_t utf32 = term->vt.utf8;
if (unlikely(utf32 > 0x10FFFF)) {
/* Invalid UTF-8 */
return;
}
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
/* Note: the F0 range contains overlong encodings. We don't try to
detect, as they'll still decode to valid UTF-32. */
vt: detect and ignore invalid UTF-8 sequences This patch detects invalid codepoints in the UTF-8 EDxxxx range, and the F4xxxxxx range. Note that we still allow the E0xxxx and F0xxxxxx ranges. These contains overlong encodings. We allow them, because they still decode into correct UTF-32. Closes #1423
2023-07-22 11:21:41 +02:00
vt: initial version of UTF-8 decoding built-in into the VT parser
2020-06-07 16:16:50 +02:00
action_utf8_print(term, term->vt.utf8);
}
Use wrappers from macros.h instead of bare GCC attributes/pragmas
2021-01-03 08:56:47 +00:00
IGNORE_WARNING("-Wpedantic")
vt: hide pedantic warnings around the VT state machine's switch cases The switch statements use the GCC extension "case X ... Y", and here it doesn't really make any sense to convert it to "case X: case Y:", so hide the warnings instead.
2020-08-23 09:38:37 +02:00
vt: replace GROUND, ESCAPE and ESCAPE_INTERMEDIATE tables with switches
2019-12-20 19:16:52 +01:00
static enum state
vt: make anywhere() function return `term->vt.state` by default Instead of passing a `default_return` parameter, which is always just the current state anyway.
2021-05-10 10:23:06 +01:00
anywhere(struct terminal *term, uint8_t data)
vt: replace GROUND, ESCAPE and ESCAPE_INTERMEDIATE tables with switches
2019-12-20 19:16:52 +01:00
{
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
switch (data) {
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
/* exit current enter new state */
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x18: action_execute(term, data); return STATE_GROUND;
case 0x1a: action_execute(term, data); return STATE_GROUND;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x1b: action_clear(term); return STATE_ESCAPE;
vt: remove partial support for 8-bit C1 control chars These are part of the "anywhere" state in Paul Flo Williams' VT parser state diagram[1]. That means that they should be accepted *anywhere* in a byte sequence, including in the middle of other sequences or even in the middle of a multi-byte UTF-8 sequence. Adhering to this requirement makes them incompatible with the use of UTF-8 as a universal encoding. Not adhering to the aforementioned requirement by making a special case for UTF-8 sequences may seem tempting, but it's much more at odds with the relevant standards[2] than it appears on the surface. UTF-8 is not an "8-bit code", at least not according to the parlance of ECMA-43, nor does it map the C1 control range in a compatible way. [1]: https://vt100.net/emu/dec_ansi_parser [2]: ECMA-35, ECMA-43, ECMA-48
2021-05-25 19:14:06 +01:00
/* 8-bit C1 control characters (not supported) */
case 0x80 ... 0x9f: return STATE_GROUND;
vt: clean up handling of "anywhere" actions
2021-05-10 09:54:07 +01:00
}
vt: make anywhere() function return `term->vt.state` by default Instead of passing a `default_return` parameter, which is always just the current state anyway.
2021-05-10 10:23:06 +01:00
return term->vt.state;
vt: clean up handling of "anywhere" actions
2021-05-10 09:54:07 +01:00
}
static enum state
state_ground_switch(struct terminal *term, uint8_t data)
{
switch (data) {
/* exit current enter new state */
case 0x00 ... 0x17:
case 0x19:
case 0x1c ... 0x1f: action_execute(term, data); return STATE_GROUND;
/* modified from 0x20..0x7f to 0x20..0x7e, since 0x7f is DEL, which is a zero-width character */
case 0x20 ... 0x7e: action_print(term, data); return STATE_GROUND;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
vt: clean up handling of "anywhere" actions
2021-05-10 09:54:07 +01:00
case 0xc2 ... 0xdf: action_utf8_21(term, data); return STATE_UTF8_21;
case 0xe0 ... 0xef: action_utf8_31(term, data); return STATE_UTF8_31;
case 0xf0 ... 0xf4: action_utf8_41(term, data); return STATE_UTF8_41;
vt: replace GROUND, ESCAPE and ESCAPE_INTERMEDIATE tables with switches
2019-12-20 19:16:52 +01:00
}
vt: clean up handling of "anywhere" actions
2021-05-10 09:54:07 +01:00
vt: make anywhere() function return `term->vt.state` by default Instead of passing a `default_return` parameter, which is always just the current state anyway.
2021-05-10 10:23:06 +01:00
return anywhere(term, data);
vt: replace GROUND, ESCAPE and ESCAPE_INTERMEDIATE tables with switches
2019-12-20 19:16:52 +01:00
}
static enum state
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
state_escape_switch(struct terminal *term, uint8_t data)
vt: replace GROUND, ESCAPE and ESCAPE_INTERMEDIATE tables with switches
2019-12-20 19:16:52 +01:00
{
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
switch (data) {
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
/* exit current enter new state */
vt: replace GROUND, ESCAPE and ESCAPE_INTERMEDIATE tables with switches
2019-12-20 19:16:52 +01:00
case 0x00 ... 0x17:
case 0x19:
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x1c ... 0x1f: action_execute(term, data); return STATE_ESCAPE;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x20 ... 0x2f: action_collect(term, data); return STATE_ESCAPE_INTERMEDIATE;
case 0x30 ... 0x4f: action_esc_dispatch(term, data); return STATE_GROUND;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x50: action_clear(term); return STATE_DCS_ENTRY;
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x51 ... 0x57: action_esc_dispatch(term, data); return STATE_GROUND;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x58: return STATE_SOS_PM_APC_STRING;
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x59: action_esc_dispatch(term, data); return STATE_GROUND;
case 0x5a: action_esc_dispatch(term, data); return STATE_GROUND;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x5b: action_clear(term); return STATE_CSI_ENTRY;
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x5c: action_esc_dispatch(term, data); return STATE_GROUND;
case 0x5d: action_osc_start(term, data); return STATE_OSC_STRING;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x5e ... 0x5f: return STATE_SOS_PM_APC_STRING;
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x60 ... 0x7e: action_esc_dispatch(term, data); return STATE_GROUND;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x7f: action_ignore(term); return STATE_ESCAPE;
vt: replace GROUND, ESCAPE and ESCAPE_INTERMEDIATE tables with switches
2019-12-20 19:16:52 +01:00
}
vt: clean up handling of "anywhere" actions
2021-05-10 09:54:07 +01:00
vt: make anywhere() function return `term->vt.state` by default Instead of passing a `default_return` parameter, which is always just the current state anyway.
2021-05-10 10:23:06 +01:00
return anywhere(term, data);
vt: replace GROUND, ESCAPE and ESCAPE_INTERMEDIATE tables with switches
2019-12-20 19:16:52 +01:00
}
static enum state
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
state_escape_intermediate_switch(struct terminal *term, uint8_t data)
vt: replace GROUND, ESCAPE and ESCAPE_INTERMEDIATE tables with switches
2019-12-20 19:16:52 +01:00
{
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
switch (data) {
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
/* exit current enter new state */
vt: replace GROUND, ESCAPE and ESCAPE_INTERMEDIATE tables with switches
2019-12-20 19:16:52 +01:00
case 0x00 ... 0x17:
case 0x19:
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x1c ... 0x1f: action_execute(term, data); return STATE_ESCAPE_INTERMEDIATE;
vt: replace GROUND, ESCAPE and ESCAPE_INTERMEDIATE tables with switches
2019-12-20 19:16:52 +01:00
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x20 ... 0x2f: action_collect(term, data); return STATE_ESCAPE_INTERMEDIATE;
case 0x30 ... 0x7e: action_esc_dispatch(term, data); return STATE_GROUND;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x7f: action_ignore(term); return STATE_ESCAPE_INTERMEDIATE;
vt: replace GROUND, ESCAPE and ESCAPE_INTERMEDIATE tables with switches
2019-12-20 19:16:52 +01:00
}
vt: clean up handling of "anywhere" actions
2021-05-10 09:54:07 +01:00
vt: make anywhere() function return `term->vt.state` by default Instead of passing a `default_return` parameter, which is always just the current state anyway.
2021-05-10 10:23:06 +01:00
return anywhere(term, data);
vt: replace GROUND, ESCAPE and ESCAPE_INTERMEDIATE tables with switches
2019-12-20 19:16:52 +01:00
}
vt: convert CSI entry from table lookup to switch
2019-12-20 20:57:38 +01:00
static enum state
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
state_csi_entry_switch(struct terminal *term, uint8_t data)
vt: convert CSI entry from table lookup to switch
2019-12-20 20:57:38 +01:00
{
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
switch (data) {
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
/* exit current enter new state */
vt: convert CSI entry from table lookup to switch
2019-12-20 20:57:38 +01:00
case 0x00 ... 0x17:
case 0x19:
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x1c ... 0x1f: action_execute(term, data); return STATE_CSI_ENTRY;
vt: convert CSI entry from table lookup to switch
2019-12-20 20:57:38 +01:00
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x20 ... 0x2f: action_collect(term, data); return STATE_CSI_INTERMEDIATE;
case 0x30 ... 0x39: action_param(term, data); return STATE_CSI_PARAM;
vt: split up action_param() to three separate functions We’re already switching on the next VT input byte in the state machine; no need to if...else if in action_param() too. That is, split up action_param() into three: * action_param_new() * action_param_new_subparam() * action_param() This makes the code cleaner, and hopefully slightly faster. Next, to improve performance further, only check for (sub)parameter overflow in action_param_new() and action_param_subparam(). Add pointers to the VT struct that points to the currently active parameter and sub-parameter. When the number of parameters (or sub-parameters) overflow, warn, and then point the parameter pointer to a "dummy" value in the VT struct. This way, we don’t have to check anything in action_param().
2023-06-16 16:26:13 +02:00
case 0x3a: action_param_new_subparam(term, data); return STATE_CSI_PARAM;
case 0x3b: action_param_new(term, data); return STATE_CSI_PARAM;
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x3c ... 0x3f: action_collect(term, data); return STATE_CSI_PARAM;
case 0x40 ... 0x7e: action_csi_dispatch(term, data); return STATE_GROUND;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x7f: action_ignore(term); return STATE_CSI_ENTRY;
vt: convert CSI entry from table lookup to switch
2019-12-20 20:57:38 +01:00
}
vt: clean up handling of "anywhere" actions
2021-05-10 09:54:07 +01:00
vt: make anywhere() function return `term->vt.state` by default Instead of passing a `default_return` parameter, which is always just the current state anyway.
2021-05-10 10:23:06 +01:00
return anywhere(term, data);
vt: convert CSI entry from table lookup to switch
2019-12-20 20:57:38 +01:00
}
vt: convert CSI param from table lookup to switch
2019-12-20 21:04:47 +01:00
static enum state
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
state_csi_param_switch(struct terminal *term, uint8_t data)
vt: convert CSI param from table lookup to switch
2019-12-20 21:04:47 +01:00
{
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
switch (data) {
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
/* exit current enter new state */
vt: convert CSI param from table lookup to switch
2019-12-20 21:04:47 +01:00
case 0x00 ... 0x17:
case 0x19:
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x1c ... 0x1f: action_execute(term, data); return STATE_CSI_PARAM;
vt: convert CSI param from table lookup to switch
2019-12-20 21:04:47 +01:00
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x20 ... 0x2f: action_collect(term, data); return STATE_CSI_INTERMEDIATE;
vt: convert CSI param from table lookup to switch
2019-12-20 21:04:47 +01:00
vt: split up action_param() to three separate functions We’re already switching on the next VT input byte in the state machine; no need to if...else if in action_param() too. That is, split up action_param() into three: * action_param_new() * action_param_new_subparam() * action_param() This makes the code cleaner, and hopefully slightly faster. Next, to improve performance further, only check for (sub)parameter overflow in action_param_new() and action_param_subparam(). Add pointers to the VT struct that points to the currently active parameter and sub-parameter. When the number of parameters (or sub-parameters) overflow, warn, and then point the parameter pointer to a "dummy" value in the VT struct. This way, we don’t have to check anything in action_param().
2023-06-16 16:26:13 +02:00
case 0x30 ... 0x39: action_param(term, data); return STATE_CSI_PARAM;
case 0x3a: action_param_new_subparam(term, data); return STATE_CSI_PARAM;
case 0x3b: action_param_new(term, data); return STATE_CSI_PARAM;
vt: convert CSI param from table lookup to switch
2019-12-20 21:04:47 +01:00
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x3c ... 0x3f: return STATE_CSI_IGNORE;
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x40 ... 0x7e: action_csi_dispatch(term, data); return STATE_GROUND;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x7f: action_ignore(term); return STATE_CSI_PARAM;
vt: convert CSI param from table lookup to switch
2019-12-20 21:04:47 +01:00
}
vt: clean up handling of "anywhere" actions
2021-05-10 09:54:07 +01:00
vt: make anywhere() function return `term->vt.state` by default Instead of passing a `default_return` parameter, which is always just the current state anyway.
2021-05-10 10:23:06 +01:00
return anywhere(term, data);
vt: convert CSI param from table lookup to switch
2019-12-20 21:04:47 +01:00
}
vt: convert CSI intermediate from table lookup to switch
2019-12-20 21:09:00 +01:00
static enum state
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
state_csi_intermediate_switch(struct terminal *term, uint8_t data)
vt: convert CSI intermediate from table lookup to switch
2019-12-20 21:09:00 +01:00
{
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
switch (data) {
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
/* exit current enter new state */
vt: convert CSI intermediate from table lookup to switch
2019-12-20 21:09:00 +01:00
case 0x00 ... 0x17:
case 0x19:
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x1c ... 0x1f: action_execute(term, data); return STATE_CSI_INTERMEDIATE;
vt: convert CSI intermediate from table lookup to switch
2019-12-20 21:09:00 +01:00
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x20 ... 0x2f: action_collect(term, data); return STATE_CSI_INTERMEDIATE;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x30 ... 0x3f: return STATE_CSI_IGNORE;
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x40 ... 0x7e: action_csi_dispatch(term, data); return STATE_GROUND;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x7f: action_ignore(term); return STATE_CSI_INTERMEDIATE;
vt: convert CSI intermediate from table lookup to switch
2019-12-20 21:09:00 +01:00
}
vt: clean up handling of "anywhere" actions
2021-05-10 09:54:07 +01:00
vt: make anywhere() function return `term->vt.state` by default Instead of passing a `default_return` parameter, which is always just the current state anyway.
2021-05-10 10:23:06 +01:00
return anywhere(term, data);
vt: convert CSI intermediate from table lookup to switch
2019-12-20 21:09:00 +01:00
}
vt: convert CSI ignore from table lookup to switch
2019-12-20 21:13:06 +01:00
static enum state
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
state_csi_ignore_switch(struct terminal *term, uint8_t data)
vt: convert CSI ignore from table lookup to switch
2019-12-20 21:13:06 +01:00
{
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
switch (data) {
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
/* exit current enter new state */
vt: convert CSI ignore from table lookup to switch
2019-12-20 21:13:06 +01:00
case 0x00 ... 0x17:
case 0x19:
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x1c ... 0x1f: action_execute(term, data); return STATE_CSI_IGNORE;
vt: convert CSI ignore from table lookup to switch
2019-12-20 21:13:06 +01:00
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x20 ... 0x3f: action_ignore(term); return STATE_CSI_IGNORE;
case 0x40 ... 0x7e: return STATE_GROUND;
case 0x7f: action_ignore(term); return STATE_CSI_IGNORE;
vt: convert CSI ignore from table lookup to switch
2019-12-20 21:13:06 +01:00
}
vt: clean up handling of "anywhere" actions
2021-05-10 09:54:07 +01:00
vt: make anywhere() function return `term->vt.state` by default Instead of passing a `default_return` parameter, which is always just the current state anyway.
2021-05-10 10:23:06 +01:00
return anywhere(term, data);
vt: convert CSI ignore from table lookup to switch
2019-12-20 21:13:06 +01:00
}
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
static enum state
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
state_osc_string_switch(struct terminal *term, uint8_t data)
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
{
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
switch (data) {
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
/* exit current enter new state */
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
/* Note: original was 20-7f, but I changed to 20-ff to include utf-8. Don't forget to add EXECUTE to 8-bit C1 if we implement that. */
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
default: action_osc_put(term, data); return STATE_OSC_STRING;
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x07: action_osc_end(term, data); return STATE_GROUND;
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
case 0x00 ... 0x06:
case 0x08 ... 0x17:
case 0x19:
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x1c ... 0x1f: action_ignore(term); return STATE_OSC_STRING;
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
case 0x18:
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x1a: action_osc_end(term, data); action_execute(term, data); return STATE_GROUND;
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x1b: action_osc_end(term, data); action_clear(term); return STATE_ESCAPE;
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
}
}
static enum state
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
state_dcs_entry_switch(struct terminal *term, uint8_t data)
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
{
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
switch (data) {
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
/* exit current enter new state */
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
case 0x00 ... 0x17:
case 0x19:
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x1c ... 0x1f: action_ignore(term); return STATE_DCS_ENTRY;
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x20 ... 0x2f: action_collect(term, data); return STATE_DCS_INTERMEDIATE;
case 0x30 ... 0x39: action_param(term, data); return STATE_DCS_PARAM;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x3a: return STATE_DCS_IGNORE;
vt: split up action_param() to three separate functions We’re already switching on the next VT input byte in the state machine; no need to if...else if in action_param() too. That is, split up action_param() into three: * action_param_new() * action_param_new_subparam() * action_param() This makes the code cleaner, and hopefully slightly faster. Next, to improve performance further, only check for (sub)parameter overflow in action_param_new() and action_param_subparam(). Add pointers to the VT struct that points to the currently active parameter and sub-parameter. When the number of parameters (or sub-parameters) overflow, warn, and then point the parameter pointer to a "dummy" value in the VT struct. This way, we don’t have to check anything in action_param().
2023-06-16 16:26:13 +02:00
case 0x3b: action_param_new(term, data); return STATE_DCS_PARAM;
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x3c ... 0x3f: action_collect(term, data); return STATE_DCS_PARAM;
case 0x40 ... 0x7e: action_hook(term, data); return STATE_DCS_PASSTHROUGH;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x7f: action_ignore(term); return STATE_DCS_ENTRY;
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
}
vt: clean up handling of "anywhere" actions
2021-05-10 09:54:07 +01:00
vt: make anywhere() function return `term->vt.state` by default Instead of passing a `default_return` parameter, which is always just the current state anyway.
2021-05-10 10:23:06 +01:00
return anywhere(term, data);
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
}
static enum state
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
state_dcs_param_switch(struct terminal *term, uint8_t data)
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
{
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
switch (data) {
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
/* exit current enter new state */
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
case 0x00 ... 0x17:
case 0x19:
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x1c ... 0x1f: action_ignore(term); return STATE_DCS_PARAM;
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x20 ... 0x2f: action_collect(term, data); return STATE_DCS_INTERMEDIATE;
case 0x30 ... 0x39: action_param(term, data); return STATE_DCS_PARAM;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x3a: return STATE_DCS_IGNORE;
vt: split up action_param() to three separate functions We’re already switching on the next VT input byte in the state machine; no need to if...else if in action_param() too. That is, split up action_param() into three: * action_param_new() * action_param_new_subparam() * action_param() This makes the code cleaner, and hopefully slightly faster. Next, to improve performance further, only check for (sub)parameter overflow in action_param_new() and action_param_subparam(). Add pointers to the VT struct that points to the currently active parameter and sub-parameter. When the number of parameters (or sub-parameters) overflow, warn, and then point the parameter pointer to a "dummy" value in the VT struct. This way, we don’t have to check anything in action_param().
2023-06-16 16:26:13 +02:00
case 0x3b: action_param_new(term, data); return STATE_DCS_PARAM;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x3c ... 0x3f: return STATE_DCS_IGNORE;
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x40 ... 0x7e: action_hook(term, data); return STATE_DCS_PASSTHROUGH;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x7f: action_ignore(term); return STATE_DCS_PARAM;
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
}
vt: clean up handling of "anywhere" actions
2021-05-10 09:54:07 +01:00
vt: make anywhere() function return `term->vt.state` by default Instead of passing a `default_return` parameter, which is always just the current state anyway.
2021-05-10 10:23:06 +01:00
return anywhere(term, data);
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
}
static enum state
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
state_dcs_intermediate_switch(struct terminal *term, uint8_t data)
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
{
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
switch (data) {
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
/* exit current enter new state */
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
case 0x00 ... 0x17:
case 0x19:
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x1c ... 0x1f: action_ignore(term); return STATE_DCS_INTERMEDIATE;
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x20 ... 0x2f: action_collect(term, data); return STATE_DCS_INTERMEDIATE;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x30 ... 0x3f: return STATE_DCS_IGNORE;
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x40 ... 0x7e: action_hook(term, data); return STATE_DCS_PASSTHROUGH;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x7f: action_ignore(term); return STATE_DCS_INTERMEDIATE;
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
}
vt: clean up handling of "anywhere" actions
2021-05-10 09:54:07 +01:00
vt: make anywhere() function return `term->vt.state` by default Instead of passing a `default_return` parameter, which is always just the current state anyway.
2021-05-10 10:23:06 +01:00
return anywhere(term, data);
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
}
static enum state
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
state_dcs_ignore_switch(struct terminal *term, uint8_t data)
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
{
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
switch (data) {
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
/* exit current enter new state */
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
case 0x00 ... 0x17:
case 0x19:
case 0x1c ... 0x1f:
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x20 ... 0x7f: action_ignore(term); return STATE_DCS_IGNORE;
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
}
vt: clean up handling of "anywhere" actions
2021-05-10 09:54:07 +01:00
vt: make anywhere() function return `term->vt.state` by default Instead of passing a `default_return` parameter, which is always just the current state anyway.
2021-05-10 10:23:06 +01:00
return anywhere(term, data);
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
}
static enum state
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
state_dcs_passthrough_switch(struct terminal *term, uint8_t data)
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
{
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
switch (data) {
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
/* exit current enter new state */
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
case 0x00 ... 0x17:
case 0x19:
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x1c ... 0x7e: action_put(term, data); return STATE_DCS_PASSTHROUGH;
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x7f: action_ignore(term); return STATE_DCS_PASSTHROUGH;
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
/* Anywhere */
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
case 0x18: action_unhook(term, data); action_execute(term, data); return STATE_GROUND;
case 0x1a: action_unhook(term, data); action_execute(term, data); return STATE_GROUND;
case 0x1b: action_unhook(term, data); action_clear(term); return STATE_ESCAPE;
vt: remove partial support for 8-bit C1 control chars These are part of the "anywhere" state in Paul Flo Williams' VT parser state diagram[1]. That means that they should be accepted *anywhere* in a byte sequence, including in the middle of other sequences or even in the middle of a multi-byte UTF-8 sequence. Adhering to this requirement makes them incompatible with the use of UTF-8 as a universal encoding. Not adhering to the aforementioned requirement by making a special case for UTF-8 sequences may seem tempting, but it's much more at odds with the relevant standards[2] than it appears on the surface. UTF-8 is not an "8-bit code", at least not according to the parlance of ECMA-43, nor does it map the C1 control range in a compatible way. [1]: https://vt100.net/emu/dec_ansi_parser [2]: ECMA-35, ECMA-43, ECMA-48
2021-05-25 19:14:06 +01:00
/* 8-bit C1 control characters (not supported) */
case 0x80 ... 0x9f: action_unhook(term, data); return STATE_GROUND;
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
default: return STATE_DCS_PASSTHROUGH;
vt: convert DCS from table lookup to switch
2019-12-20 21:48:04 +01:00
}
}
vt: convert SOS/PM/APC string from table lookup to switch
2019-12-20 21:50:54 +01:00
static enum state
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
state_sos_pm_apc_string_switch(struct terminal *term, uint8_t data)
vt: convert SOS/PM/APC string from table lookup to switch
2019-12-20 21:50:54 +01:00
{
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
switch (data) {
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
/* exit current enter new state */
vt: convert SOS/PM/APC string from table lookup to switch
2019-12-20 21:50:54 +01:00
case 0x00 ... 0x17:
case 0x19:
vt: visually compact the switch tables
2019-12-20 23:38:16 +01:00
case 0x1c ... 0x7f: action_ignore(term); return STATE_SOS_PM_APC_STRING;
vt: convert SOS/PM/APC string from table lookup to switch
2019-12-20 21:50:54 +01:00
}
vt: clean up handling of "anywhere" actions
2021-05-10 09:54:07 +01:00
vt: make anywhere() function return `term->vt.state` by default Instead of passing a `default_return` parameter, which is always just the current state anyway.
2021-05-10 10:23:06 +01:00
return anywhere(term, data);
vt: convert SOS/PM/APC string from table lookup to switch
2019-12-20 21:50:54 +01:00
}
vt: don't special case UTF-8 collect state
2019-12-20 22:10:27 +01:00
static enum state
vt: initial version of UTF-8 decoding built-in into the VT parser
2020-06-07 16:16:50 +02:00
state_utf8_21_switch(struct terminal *term, uint8_t data)
{
switch (data) {
/* exit current enter new state */
case 0x80 ... 0xbf: action_utf8_22(term, data); return STATE_GROUND;
vt: utf8: insert a REPLACEMENT CHARACTER when an invalid UTF-8 sequence is detected
2025-03-18 18:28:09 +01:00
default: action_utf8_print(term, 0xfffd); return state_ground_switch(term, data);
vt: initial version of UTF-8 decoding built-in into the VT parser
2020-06-07 16:16:50 +02:00
}
}
static enum state
state_utf8_31_switch(struct terminal *term, uint8_t data)
vt: don't special case UTF-8 collect state
2019-12-20 22:10:27 +01:00
{
vt: initial version of UTF-8 decoding built-in into the VT parser
2020-06-07 16:16:50 +02:00
switch (data) {
/* exit current enter new state */
case 0x80 ... 0xbf: action_utf8_32(term, data); return STATE_UTF8_32;
vt: utf8: insert a REPLACEMENT CHARACTER when an invalid UTF-8 sequence is detected
2025-03-18 18:28:09 +01:00
default: action_utf8_print(term, 0xfffd); return state_ground_switch(term, data);
vt: initial version of UTF-8 decoding built-in into the VT parser
2020-06-07 16:16:50 +02:00
}
vt: don't special case UTF-8 collect state
2019-12-20 22:10:27 +01:00
}
static enum state
vt: initial version of UTF-8 decoding built-in into the VT parser
2020-06-07 16:16:50 +02:00
state_utf8_32_switch(struct terminal *term, uint8_t data)
vt: don't special case UTF-8 collect state
2019-12-20 22:10:27 +01:00
{
vt: initial version of UTF-8 decoding built-in into the VT parser
2020-06-07 16:16:50 +02:00
switch (data) {
/* exit current enter new state */
case 0x80 ... 0xbf: action_utf8_33(term, data); return STATE_GROUND;
vt: utf8: insert a REPLACEMENT CHARACTER when an invalid UTF-8 sequence is detected
2025-03-18 18:28:09 +01:00
default: action_utf8_print(term, 0xfffd); return state_ground_switch(term, data);
vt: initial version of UTF-8 decoding built-in into the VT parser
2020-06-07 16:16:50 +02:00
}
vt: don't special case UTF-8 collect state
2019-12-20 22:10:27 +01:00
}
static enum state
vt: initial version of UTF-8 decoding built-in into the VT parser
2020-06-07 16:16:50 +02:00
state_utf8_41_switch(struct terminal *term, uint8_t data)
vt: don't special case UTF-8 collect state
2019-12-20 22:10:27 +01:00
{
vt: initial version of UTF-8 decoding built-in into the VT parser
2020-06-07 16:16:50 +02:00
switch (data) {
/* exit current enter new state */
case 0x80 ... 0xbf: action_utf8_42(term, data); return STATE_UTF8_42;
vt: utf8: insert a REPLACEMENT CHARACTER when an invalid UTF-8 sequence is detected
2025-03-18 18:28:09 +01:00
default: action_utf8_print(term, 0xfffd); return state_ground_switch(term, data);
vt: initial version of UTF-8 decoding built-in into the VT parser
2020-06-07 16:16:50 +02:00
}
}
static enum state
state_utf8_42_switch(struct terminal *term, uint8_t data)
{
switch (data) {
/* exit current enter new state */
case 0x80 ... 0xbf: action_utf8_43(term, data); return STATE_UTF8_43;
vt: utf8: insert a REPLACEMENT CHARACTER when an invalid UTF-8 sequence is detected
2025-03-18 18:28:09 +01:00
default: action_utf8_print(term, 0xfffd); return state_ground_switch(term, data);
vt: initial version of UTF-8 decoding built-in into the VT parser
2020-06-07 16:16:50 +02:00
}
}
static enum state
state_utf8_43_switch(struct terminal *term, uint8_t data)
{
switch (data) {
/* exit current enter new state */
case 0x80 ... 0xbf: action_utf8_44(term, data); return STATE_GROUND;
vt: utf8: insert a REPLACEMENT CHARACTER when an invalid UTF-8 sequence is detected
2025-03-18 18:28:09 +01:00
default: action_utf8_print(term, 0xfffd); return state_ground_switch(term, data);
vt: initial version of UTF-8 decoding built-in into the VT parser
2020-06-07 16:16:50 +02:00
}
vt: don't special case UTF-8 collect state
2019-12-20 22:10:27 +01:00
}
Use wrappers from macros.h instead of bare GCC attributes/pragmas
2021-01-03 08:56:47 +00:00
UNIGNORE_WARNINGS
vt: hide pedantic warnings around the VT state machine's switch cases The switch statements use the GCC extension "case X ... Y", and here it doesn't really make any sense to convert it to "case X: case Y:", so hide the warnings instead.
2020-08-23 09:38:37 +02:00
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
void
vt_from_slave(struct terminal *term, const uint8_t *data, size_t len)
{
vt: use a pointer that we increment, instead of indexing
2019-12-20 23:00:07 +01:00
enum state current_state = term->vt.state;
const uint8_t *p = data;
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
for (size_t i = 0; i < len; i++, p++) {
switch (current_state) {
case STATE_GROUND: current_state = state_ground_switch(term, *p); break;
case STATE_ESCAPE: current_state = state_escape_switch(term, *p); break;
case STATE_ESCAPE_INTERMEDIATE: current_state = state_escape_intermediate_switch(term, *p); break;
case STATE_CSI_ENTRY: current_state = state_csi_entry_switch(term, *p); break;
case STATE_CSI_PARAM: current_state = state_csi_param_switch(term, *p); break;
case STATE_CSI_INTERMEDIATE: current_state = state_csi_intermediate_switch(term, *p); break;
case STATE_CSI_IGNORE: current_state = state_csi_ignore_switch(term, *p); break;
case STATE_OSC_STRING: current_state = state_osc_string_switch(term, *p); break;
case STATE_DCS_ENTRY: current_state = state_dcs_entry_switch(term, *p); break;
case STATE_DCS_PARAM: current_state = state_dcs_param_switch(term, *p); break;
case STATE_DCS_INTERMEDIATE: current_state = state_dcs_intermediate_switch(term, *p); break;
case STATE_DCS_IGNORE: current_state = state_dcs_ignore_switch(term, *p); break;
case STATE_DCS_PASSTHROUGH: current_state = state_dcs_passthrough_switch(term, *p); break;
case STATE_SOS_PM_APC_STRING: current_state = state_sos_pm_apc_string_switch(term, *p); break;
vt: initial version of UTF-8 decoding built-in into the VT parser
2020-06-07 16:16:50 +02:00
case STATE_UTF8_21: current_state = state_utf8_21_switch(term, *p); break;
case STATE_UTF8_31: current_state = state_utf8_31_switch(term, *p); break;
case STATE_UTF8_32: current_state = state_utf8_32_switch(term, *p); break;
case STATE_UTF8_41: current_state = state_utf8_41_switch(term, *p); break;
case STATE_UTF8_42: current_state = state_utf8_42_switch(term, *p); break;
case STATE_UTF8_43: current_state = state_utf8_43_switch(term, *p); break;
Revert "vt: refactor" This reverts commit a575204bc77c711047740d2328d26043e8c976cb.
2019-12-20 23:59:23 +01:00
}
vt: no need to assign to term->vt.state for *every* input byte
2019-12-20 22:12:35 +01:00
Update `term->vt.state` for each iteration of vt_from_slave() loop Otherwise it may be stale when read by the anywhere() function.
2021-05-15 19:20:36 +01:00
term->vt.state = current_state;
}
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
}
Reference in a new issue Copy permalink