#include "vt.h" #include #include #include #include #if FOOT_UNICODE_COMBINING #include #endif #define LOG_MODULE "vt" #define LOG_ENABLE_DBG 0 #include "log.h" #include "csi.h" #include "dcs.h" #include "grid.h" #include "osc.h" #define min(x, y) ((x) < (y) ? (x) : (y)) #define max(x, y) ((x) > (y) ? (x) : (y)) #define UNHANDLED() LOG_DBG("unhandled: %s", esc_as_string(term, final)) /* https://vt100.net/emu/dec_ansi_parser */ enum state { STATE_GROUND, 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, STATE_SOS_PM_APC_STRING, STATE_UTF8_COLLECT_1, STATE_UTF8_COLLECT_2, STATE_UTF8_COLLECT_3, }; #if defined(_DEBUG) && defined(LOG_ENABLE_DBG) && LOG_ENABLE_DBG && 0 static const char *const state_names[] = { [STATE_GROUND] = "ground", [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", [STATE_UTF8_COLLECT_1] = "UTF8 collect (1 left)", [STATE_UTF8_COLLECT_2] = "UTF8 collect (2 left)", [STATE_UTF8_COLLECT_3] = "UTF8 collect (3 left)", }; #endif #if defined(LOG_ENABLE_DBG) && LOG_ENABLE_DBG static const char * esc_as_string(struct terminal *term, uint8_t final) { static char msg[1024]; int c = snprintf(msg, sizeof(msg), "\\E"); for (size_t i = 0; i < sizeof(term->vt.private) / sizeof(term->vt.private[0]); i++) { if (term->vt.private[i] == 0) break; c += snprintf(&msg[c], sizeof(msg) - c, "%c", term->vt.private[i]); } assert(term->vt.params.idx == 0); snprintf(&msg[c], sizeof(msg) - c, "%c", final); return msg; } #endif static void action_ignore(struct terminal *term) { } static void action_clear(struct terminal *term) { term->vt.params.idx = 0; term->vt.private[0] = 0; term->vt.private[1] = 0; } 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; case '\n': /* LF - line feed */ term_linefeed(term); break; case '\r': /* FF - form feed */ term_formfeed(term); break; case '\b': /* backspace */ term_cursor_left(term, 1); break; case '\x07': /* BEL */ // LOG_INFO("BELL"); // term_flash(term, 50); break; case '\x09': { /* HT - horizontal tab */ int new_col = term->cols - 1; tll_foreach(term->tab_stops, it) { if (it->item > term->grid->cursor.point.col) { new_col = it->item; break; } } assert(new_col >= term->grid->cursor.point.col); term_cursor_right(term, new_col - term->grid->cursor.point.col); break; } case '\x0b': /* VT - vertical tab */ term_cursor_down(term, 1); break; case '\x0e': /* SO - shift out */ term->charsets.selected = 1; /* G1 */ break; case '\x0f': /* SI - shift in */ term->charsets.selected = 0; /* G0 */ 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... */ #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) { /* 0x60 - 0x7e */ static const wchar_t vt100_0[] = { L'◆', L'▒', L'␉', L'␌', L'␍', L'␊', L'°', L'±', /* ` - g */ L'␤', L'␋', L'┘', L'┐', L'┌', L'└', L'┼', L'⎺', /* h - o */ L'⎻', L'─', L'⎼', L'⎽', L'├', L'┤', L'┴', L'┬', /* p - w */ L'│', L'≤', L'≥', L'π', L'≠', L'£', L'·', /* x - ~ */ }; if (unlikely(term->charsets.set[term->charsets.selected] == CHARSET_GRAPHIC) && c >= 0x60 && c <= 0x7e) { term_print(term, vt100_0[c - 0x60], 1); } else { term_print(term, c, 1); } } static void action_param(struct terminal *term, uint8_t c) { if (term->vt.params.idx == 0) { struct vt_param *param = &term->vt.params.v[0]; param->value = 0; param->sub.idx = 0; term->vt.params.idx = 1; } assert(term->vt.params.idx > 0); const size_t max_params = sizeof(term->vt.params.v) / sizeof(term->vt.params.v[0]); const size_t max_sub_params = sizeof(term->vt.params.v[0].sub.value) / sizeof(term->vt.params.v[0].sub.value[0]); /* New parameter */ if (c == ';') { if (unlikely(term->vt.params.idx >= max_params)) goto excess_params; struct vt_param *param = &term->vt.params.v[term->vt.params.idx++]; param->value = 0; param->sub.idx = 0; } /* New sub-parameter */ else if (c == ':') { if (unlikely(term->vt.params.idx - 1 >= max_params)) goto excess_params; struct vt_param *param = &term->vt.params.v[term->vt.params.idx - 1]; if (unlikely(param->sub.idx >= max_sub_params)) goto excess_sub_params; param->sub.value[param->sub.idx++] = 0; } /* New digit for current parameter/sub-parameter */ else { if (unlikely(term->vt.params.idx - 1 >= max_params)) goto excess_params; struct vt_param *param = &term->vt.params.v[term->vt.params.idx - 1]; unsigned *value; if (param->sub.idx > 0) { if (unlikely(param->sub.idx - 1 >= max_sub_params)) goto excess_sub_params; value = ¶m->sub.value[param->sub.idx - 1]; } else value = ¶m->value; *value *= 10; *value += c - '0'; } #if defined(_DEBUG) /* The rest of the code assumes 'idx' *never* points outside the array */ assert(term->vt.params.idx <= max_params); for (size_t i = 0; i < term->vt.params.idx; i++) assert(term->vt.params.v[i].sub.idx <= max_sub_params); #endif return; excess_params: { 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])); } } return; excess_sub_params: { 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])); } } return; } static void action_collect(struct terminal *term, uint8_t c) { LOG_DBG("collect: %c", c); if (term->vt.private[0] == 0) term->vt.private[0] = c; else if (term->vt.private[1] == 0) term->vt.private[1] = c; else LOG_WARN("only two private/intermediate characters supported"); } static void action_esc_dispatch(struct terminal *term, uint8_t final) { LOG_DBG("ESC: %s", esc_as_string(term, final)); switch (term->vt.private[0]) { case 0: switch (final) { case '7': term->grid->saved_cursor = term->grid->cursor; term->vt.saved_attrs = term->vt.attrs; term->saved_charsets = term->charsets; break; case '8': term_restore_cursor(term, &term->grid->saved_cursor); term->vt.attrs = term->vt.saved_attrs; term->charsets = term->saved_charsets; break; case 'c': term_reset(term, true); break; case 'D': term_linefeed(term); break; case 'E': term_formfeed(term); term_linefeed(term); break; case 'H': tll_foreach(term->tab_stops, it) { if (it->item >= term->grid->cursor.point.col) { tll_insert_before(term->tab_stops, it, term->grid->cursor.point.col); break; } } tll_push_back(term->tab_stops, term->grid->cursor.point.col); break; case 'M': term_reverse_index(term); break; case 'N': /* SS2 - Single Shift 2 */ term->charsets.selected = 2; /* G2 */ break; case 'O': /* SS3 - Single Shift 3 */ term->charsets.selected = 3; /* G3 */ break; case '\\': /* ST - String Terminator */ break; case '=': term->keypad_keys_mode = KEYPAD_APPLICATION; break; case '>': term->keypad_keys_mode = KEYPAD_NUMERICAL; break; default: UNHANDLED(); break; } break; /* private[0] == 0 */ case '(': case ')': case '*': case '+': switch (final) { case '0': { char priv = term->vt.private[0]; ssize_t idx = priv == '(' ? 0 : ')' ? 1 : '*' ? 2 : '+' ? 3 : -1; assert(idx != -1); term->charsets.set[idx] = CHARSET_GRAPHIC; break; } case 'B': { char priv = term->vt.private[0]; ssize_t idx = priv == '(' ? 0 : ')' ? 1 : '*' ? 2 : '+' ? 3 : -1; assert(idx != -1); term->charsets.set[idx] = CHARSET_ASCII; break; } } break; case '#': switch (final) { case '8': for (int r = 0; r < term->rows; r++) { struct row *row = grid_row(term->grid, r); for (int c = 0; c < term->cols; c++) { row->cells[c].wc = L'E'; row->cells[c].attrs.clean = 0; } row->dirty = true; } break; } break; /* private[0] == '#' */ } } static void action_csi_dispatch(struct terminal *term, uint8_t c) { 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) { if (!osc_ensure_size(term, term->vt.osc.idx + 1)) return; term->vt.osc.data[term->vt.osc.idx] = '\0'; osc_dispatch(term); } static void action_osc_put(struct terminal *term, uint8_t c) { if (!osc_ensure_size(term, term->vt.osc.idx + 1)) return; term->vt.osc.data[term->vt.osc.idx++] = c; } static void action_hook(struct terminal *term, uint8_t c) { dcs_hook(term, c); } static void action_unhook(struct terminal *term, uint8_t c) { dcs_unhook(term); } static void action_put(struct terminal *term, uint8_t c) { dcs_put(term, c); } static void action_utf8_2_entry(struct terminal *term, uint8_t c) { term->vt.utf8.idx = 0; term->vt.utf8.data[term->vt.utf8.idx++] = c; } static void action_utf8_3_entry(struct terminal *term, uint8_t c) { term->vt.utf8.idx = 0; term->vt.utf8.data[term->vt.utf8.idx++] = c; } static void action_utf8_4_entry(struct terminal *term, uint8_t c) { term->vt.utf8.idx = 0; term->vt.utf8.data[term->vt.utf8.idx++] = c; } static void action_utf8_print(struct terminal *term, uint8_t c) { /* Convert to wchar */ mbstate_t ps = {}; wchar_t wc; size_t count = mbrtowc( &wc, (const char *)term->vt.utf8.data, term->vt.utf8.idx, &ps); if ((ssize_t)count < 0) wc = 0; #if FOOT_UNICODE_COMBINING /* * Try to combine with the previous character. * * We _could_ try regardless of what 'wc' is. However, for * performance reasons, we only do it when 'wc' is in a known * 'combining' range. * * TODO: * - doesn't work when base character is multi-column (we'll only * see an empty "null" character) */ if (((wc >= 0x0300 && wc <= 0x036F) || /* diacritical marks */ (wc >= 0x1AB0 && wc <= 0x1AFF) || /* diacritical marks, extended */ (wc >= 0x1DC0 && wc <= 0x1DFF) || /* diacritical marks, supplement */ (wc >= 0x20D0 && wc <= 0x20FF) || /* diacritical marks, for symbols */ (wc >= 0xFE20 && wc <= 0xFE2F)) /* half marks */ && term->grid->cursor.point.col > 0) { int base_col = term->grid->cursor.point.col; if (!term->grid->cursor.lcf) base_col--; assert(base_col >= 0 && base_col < term->cols); wchar_t base = term->grid->cur_row->cells[base_col].wc; int base_width = wcwidth(base); if (base_width > 0) { wchar_t composed[] = {base, wc}; ssize_t composed_length = utf8proc_normalize_utf32( composed, sizeof(composed) / sizeof(composed[0]), UTF8PROC_COMPOSE | UTF8PROC_STABLE); LOG_DBG("composed = 0x%04x, 0x%04x (length = %zd)", composed[0], composed[1], composed_length); if (composed_length == 1) { /* Compose succeess - overwrite last cell with * combined character */ term->grid->cursor.point.col = base_col; term->grid->cursor.lcf = false; term_print(term, composed[0], wcwidth(composed[0])); return; } } } #endif /* FOOT_UNICODE_COMBINING */ term_print(term, wc, wcwidth(wc)); } 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; case 0x20 ... 0x7f: action_print(term, data); return STATE_GROUND; case 0xc0 ... 0xdf: action_utf8_2_entry(term, data); return STATE_UTF8_COLLECT_1; case 0xe0 ... 0xef: action_utf8_3_entry(term, data); return STATE_UTF8_COLLECT_2; case 0xf0 ... 0xf7: action_utf8_4_entry(term, data); return STATE_UTF8_COLLECT_3; /* Anywhere */ case 0x18: action_execute(term, data); return STATE_GROUND; case 0x1a: action_execute(term, data); return STATE_GROUND; case 0x1b: action_clear(term); return STATE_ESCAPE; case 0x80 ... 0x8f: action_execute(term, data); return STATE_GROUND; case 0x90: action_clear(term); return STATE_DCS_ENTRY; case 0x91 ... 0x97: action_execute(term, data); return STATE_GROUND; case 0x98: return STATE_SOS_PM_APC_STRING; case 0x99: action_execute(term, data); return STATE_GROUND; case 0x9a: action_execute(term, data); return STATE_GROUND; case 0x9b: action_clear(term); return STATE_CSI_ENTRY; case 0x9c: return STATE_GROUND; case 0x9d: action_osc_start(term, data); return STATE_OSC_STRING; case 0x9e ... 0x9f: return STATE_SOS_PM_APC_STRING; default: return STATE_GROUND; } } static enum state state_escape_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_ESCAPE; case 0x20 ... 0x2f: action_collect(term, data); return STATE_ESCAPE_INTERMEDIATE; case 0x30 ... 0x4f: action_esc_dispatch(term, data); return STATE_GROUND; case 0x50: action_clear(term); return STATE_DCS_ENTRY; case 0x51 ... 0x57: action_esc_dispatch(term, data); return STATE_GROUND; case 0x58: return STATE_SOS_PM_APC_STRING; case 0x59: action_esc_dispatch(term, data); return STATE_GROUND; case 0x5a: action_esc_dispatch(term, data); return STATE_GROUND; case 0x5b: action_clear(term); return STATE_CSI_ENTRY; case 0x5c: action_esc_dispatch(term, data); return STATE_GROUND; case 0x5d: action_osc_start(term, data); return STATE_OSC_STRING; case 0x5e ... 0x5f: return STATE_SOS_PM_APC_STRING; case 0x60 ... 0x7e: action_esc_dispatch(term, data); return STATE_GROUND; case 0x7f: action_ignore(term); return STATE_ESCAPE; /* Anywhere */ case 0x18: action_execute(term, data); return STATE_GROUND; case 0x1a: action_execute(term, data); return STATE_GROUND; case 0x1b: action_clear(term); return STATE_ESCAPE; case 0x80 ... 0x8f: action_execute(term, data); return STATE_GROUND; case 0x90: action_clear(term); return STATE_DCS_ENTRY; case 0x91 ... 0x97: action_execute(term, data); return STATE_GROUND; case 0x98: return STATE_SOS_PM_APC_STRING; case 0x99: action_execute(term, data); return STATE_GROUND; case 0x9a: action_execute(term, data); return STATE_GROUND; case 0x9b: action_clear(term); return STATE_CSI_ENTRY; case 0x9c: return STATE_GROUND; case 0x9d: action_osc_start(term, data); return STATE_OSC_STRING; case 0x9e ... 0x9f: return STATE_SOS_PM_APC_STRING; default: return STATE_ESCAPE; } } static enum state state_escape_intermediate_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_ESCAPE_INTERMEDIATE; case 0x20 ... 0x2f: action_collect(term, data); return STATE_ESCAPE_INTERMEDIATE; case 0x30 ... 0x7e: action_esc_dispatch(term, data); return STATE_GROUND; case 0x7f: action_ignore(term); return STATE_ESCAPE_INTERMEDIATE; /* Anywhere */ case 0x18: action_execute(term, data); return STATE_GROUND; case 0x1a: action_execute(term, data); return STATE_GROUND; case 0x1b: action_clear(term); return STATE_ESCAPE; case 0x80 ... 0x8f: action_execute(term, data); return STATE_GROUND; case 0x90: action_clear(term); return STATE_DCS_ENTRY; case 0x91 ... 0x97: action_execute(term, data); return STATE_GROUND; case 0x98: return STATE_SOS_PM_APC_STRING; case 0x99: action_execute(term, data); return STATE_GROUND; case 0x9a: action_execute(term, data); return STATE_GROUND; case 0x9b: action_clear(term); return STATE_CSI_ENTRY; case 0x9c: return STATE_GROUND; case 0x9d: action_osc_start(term, data); return STATE_OSC_STRING; case 0x9e ... 0x9f: return STATE_SOS_PM_APC_STRING; default: return STATE_ESCAPE_INTERMEDIATE; } } static enum state state_csi_entry_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_CSI_ENTRY; case 0x20 ... 0x2f: action_collect(term, data); return STATE_CSI_INTERMEDIATE; case 0x30 ... 0x39: action_param(term, data); return STATE_CSI_PARAM; case 0x3a ... 0x3b: action_param(term, data); return STATE_CSI_PARAM; case 0x3c ... 0x3f: action_collect(term, data); return STATE_CSI_PARAM; case 0x40 ... 0x7e: action_csi_dispatch(term, data); return STATE_GROUND; case 0x7f: action_ignore(term); return STATE_CSI_ENTRY; /* Anywhere */ case 0x18: action_execute(term, data); return STATE_GROUND; case 0x1a: action_execute(term, data); return STATE_GROUND; case 0x1b: action_clear(term); return STATE_ESCAPE; case 0x80 ... 0x8f: action_execute(term, data); return STATE_GROUND; case 0x90: action_clear(term); return STATE_DCS_ENTRY; case 0x91 ... 0x97: action_execute(term, data); return STATE_GROUND; case 0x98: return STATE_SOS_PM_APC_STRING; case 0x99: action_execute(term, data); return STATE_GROUND; case 0x9a: action_execute(term, data); return STATE_GROUND; case 0x9b: action_clear(term); return STATE_CSI_ENTRY; case 0x9c: return STATE_GROUND; case 0x9d: action_osc_start(term, data); return STATE_OSC_STRING; case 0x9e ... 0x9f: return STATE_SOS_PM_APC_STRING; default: return STATE_CSI_ENTRY; } } static enum state state_csi_param_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_CSI_PARAM; case 0x20 ... 0x2f: action_collect(term, data); return STATE_CSI_INTERMEDIATE; case 0x30 ... 0x39: case 0x3a ... 0x3b: action_param(term, data); return STATE_CSI_PARAM; case 0x3c ... 0x3f: return STATE_CSI_IGNORE; case 0x40 ... 0x7e: action_csi_dispatch(term, data); return STATE_GROUND; case 0x7f: action_ignore(term); return STATE_CSI_PARAM; /* Anywhere */ case 0x18: action_execute(term, data); return STATE_GROUND; case 0x1a: action_execute(term, data); return STATE_GROUND; case 0x1b: action_clear(term); return STATE_ESCAPE; case 0x80 ... 0x8f: action_execute(term, data); return STATE_GROUND; case 0x90: action_clear(term); return STATE_DCS_ENTRY; case 0x91 ... 0x97: action_execute(term, data); return STATE_GROUND; case 0x98: return STATE_SOS_PM_APC_STRING; case 0x99: action_execute(term, data); return STATE_GROUND; case 0x9a: action_execute(term, data); return STATE_GROUND; case 0x9b: action_clear(term); return STATE_CSI_ENTRY; case 0x9c: return STATE_GROUND; case 0x9d: action_osc_start(term, data); return STATE_OSC_STRING; case 0x9e ... 0x9f: return STATE_SOS_PM_APC_STRING; default: return STATE_CSI_PARAM; } } static enum state state_csi_intermediate_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_CSI_INTERMEDIATE; case 0x20 ... 0x2f: action_collect(term, data); return STATE_CSI_INTERMEDIATE; case 0x30 ... 0x3f: return STATE_CSI_IGNORE; case 0x40 ... 0x7e: action_csi_dispatch(term, data); return STATE_GROUND; case 0x7f: action_ignore(term); return STATE_CSI_INTERMEDIATE; /* Anywhere */ case 0x18: action_execute(term, data); return STATE_GROUND; case 0x1a: action_execute(term, data); return STATE_GROUND; case 0x1b: action_clear(term); return STATE_ESCAPE; case 0x80 ... 0x8f: action_execute(term, data); return STATE_GROUND; case 0x90: action_clear(term); return STATE_DCS_ENTRY; case 0x91 ... 0x97: action_execute(term, data); return STATE_GROUND; case 0x98: return STATE_SOS_PM_APC_STRING; case 0x99: action_execute(term, data); return STATE_GROUND; case 0x9a: action_execute(term, data); return STATE_GROUND; case 0x9b: action_clear(term); return STATE_CSI_ENTRY; case 0x9c: return STATE_GROUND; case 0x9d: action_osc_start(term, data); return STATE_OSC_STRING; case 0x9e ... 0x9f: return STATE_SOS_PM_APC_STRING; default: return STATE_CSI_INTERMEDIATE; } } static enum state state_csi_ignore_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_CSI_IGNORE; 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; /* Anywhere */ case 0x18: action_execute(term, data); return STATE_GROUND; case 0x1a: action_execute(term, data); return STATE_GROUND; case 0x1b: action_clear(term); return STATE_ESCAPE; case 0x80 ... 0x8f: action_execute(term, data); return STATE_GROUND; case 0x90: action_clear(term); return STATE_DCS_ENTRY; case 0x91 ... 0x97: action_execute(term, data); return STATE_GROUND; case 0x98: return STATE_SOS_PM_APC_STRING; case 0x99: action_execute(term, data); return STATE_GROUND; case 0x9a: action_execute(term, data); return STATE_GROUND; case 0x9b: action_clear(term); return STATE_CSI_ENTRY; case 0x9c: return STATE_GROUND; case 0x9d: action_osc_start(term, data); return STATE_OSC_STRING; case 0x9e ... 0x9f: return STATE_SOS_PM_APC_STRING; default: return STATE_CSI_IGNORE; } } static enum state state_osc_string_switch(struct terminal *term, uint8_t data) { switch (data) { /* exit current enter new state */ /* 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. */ default: action_osc_put(term, data); return STATE_OSC_STRING; case 0x07: action_osc_end(term, data); return STATE_GROUND; case 0x00 ... 0x06: case 0x08 ... 0x17: case 0x19: case 0x1c ... 0x1f: action_ignore(term); return STATE_OSC_STRING; case 0x18: case 0x1a: action_osc_end(term, data); action_execute(term, data); return STATE_GROUND; case 0x1b: action_osc_end(term, data); action_clear(term); return STATE_ESCAPE; } } static enum state state_dcs_entry_switch(struct terminal *term, uint8_t data) { switch (data) { /* exit current enter new state */ case 0x00 ... 0x17: case 0x19: case 0x1c ... 0x1f: action_ignore(term); return STATE_DCS_ENTRY; case 0x20 ... 0x2f: action_collect(term, data); return STATE_DCS_INTERMEDIATE; case 0x30 ... 0x39: action_param(term, data); return STATE_DCS_PARAM; case 0x3a: return STATE_DCS_IGNORE; case 0x3b: action_param(term, data); return STATE_DCS_PARAM; case 0x3c ... 0x3f: action_collect(term, data); return STATE_DCS_PARAM; case 0x40 ... 0x7e: action_hook(term, data); return STATE_DCS_PASSTHROUGH; case 0x7f: action_ignore(term); return STATE_DCS_ENTRY; /* Anywhere */ case 0x18: action_execute(term, data); return STATE_GROUND; case 0x1a: action_execute(term, data); return STATE_GROUND; case 0x1b: action_clear(term); return STATE_ESCAPE; case 0x80 ... 0x8f: action_execute(term, data); return STATE_GROUND; case 0x90: action_clear(term); return STATE_DCS_ENTRY; case 0x91 ... 0x97: action_execute(term, data); return STATE_GROUND; case 0x98: return STATE_SOS_PM_APC_STRING; case 0x99: action_execute(term, data); return STATE_GROUND; case 0x9a: action_execute(term, data); return STATE_GROUND; case 0x9b: action_clear(term); return STATE_CSI_ENTRY; case 0x9c: return STATE_GROUND; case 0x9d: action_osc_start(term, data); return STATE_OSC_STRING; case 0x9e ... 0x9f: return STATE_SOS_PM_APC_STRING; default: return STATE_DCS_ENTRY; } } static enum state state_dcs_param_switch(struct terminal *term, uint8_t data) { switch (data) { /* exit current enter new state */ case 0x00 ... 0x17: case 0x19: case 0x1c ... 0x1f: action_ignore(term); return STATE_DCS_PARAM; case 0x20 ... 0x2f: action_collect(term, data); return STATE_DCS_INTERMEDIATE; case 0x30 ... 0x39: action_param(term, data); return STATE_DCS_PARAM; case 0x3a: return STATE_DCS_IGNORE; case 0x3b: action_param(term, data); return STATE_DCS_PARAM; case 0x3c ... 0x3f: return STATE_DCS_IGNORE; case 0x40 ... 0x7e: action_hook(term, data); return STATE_DCS_PASSTHROUGH; case 0x7f: action_ignore(term); return STATE_DCS_PARAM; /* Anywhere */ case 0x18: action_execute(term, data); return STATE_GROUND; case 0x1a: action_execute(term, data); return STATE_GROUND; case 0x1b: action_clear(term); return STATE_ESCAPE; case 0x80 ... 0x8f: action_execute(term, data); return STATE_GROUND; case 0x90: action_clear(term); return STATE_DCS_ENTRY; case 0x91 ... 0x97: action_execute(term, data); return STATE_GROUND; case 0x98: return STATE_SOS_PM_APC_STRING; case 0x99: action_execute(term, data); return STATE_GROUND; case 0x9a: action_execute(term, data); return STATE_GROUND; case 0x9b: action_clear(term); return STATE_CSI_ENTRY; case 0x9c: return STATE_GROUND; case 0x9d: action_osc_start(term, data); return STATE_OSC_STRING; case 0x9e ... 0x9f: return STATE_SOS_PM_APC_STRING; default: return STATE_DCS_PARAM; } } static enum state state_dcs_intermediate_switch(struct terminal *term, uint8_t data) { switch (data) { /* exit current enter new state */ case 0x00 ... 0x17: case 0x19: case 0x1c ... 0x1f: action_ignore(term); return STATE_DCS_INTERMEDIATE; case 0x20 ... 0x2f: action_collect(term, data); return STATE_DCS_INTERMEDIATE; case 0x30 ... 0x3f: return STATE_DCS_IGNORE; case 0x40 ... 0x7e: action_hook(term, data); return STATE_DCS_PASSTHROUGH; case 0x7f: action_ignore(term); return STATE_DCS_INTERMEDIATE; /* Anywhere */ case 0x18: action_execute(term, data); return STATE_GROUND; case 0x1a: action_execute(term, data); return STATE_GROUND; case 0x1b: action_clear(term); return STATE_ESCAPE; case 0x80 ... 0x8f: action_execute(term, data); return STATE_GROUND; case 0x90: action_clear(term); return STATE_DCS_ENTRY; case 0x91 ... 0x97: action_execute(term, data); return STATE_GROUND; case 0x98: return STATE_SOS_PM_APC_STRING; case 0x99: action_execute(term, data); return STATE_GROUND; case 0x9a: action_execute(term, data); return STATE_GROUND; case 0x9b: action_clear(term); return STATE_CSI_ENTRY; case 0x9c: return STATE_GROUND; case 0x9d: action_osc_start(term, data); return STATE_OSC_STRING; case 0x9e ... 0x9f: return STATE_SOS_PM_APC_STRING; default: return STATE_DCS_INTERMEDIATE; } } static enum state state_dcs_ignore_switch(struct terminal *term, uint8_t data) { switch (data) { /* exit current enter new state */ case 0x00 ... 0x17: case 0x19: case 0x1c ... 0x1f: case 0x20 ... 0x7f: action_ignore(term); return STATE_DCS_IGNORE; /* Anywhere */ case 0x18: action_execute(term, data); return STATE_GROUND; case 0x1a: action_execute(term, data); return STATE_GROUND; case 0x1b: action_clear(term); return STATE_ESCAPE; case 0x80 ... 0x8f: action_execute(term, data); return STATE_GROUND; case 0x90: action_clear(term); return STATE_DCS_ENTRY; case 0x91 ... 0x97: action_execute(term, data); return STATE_GROUND; case 0x98: return STATE_SOS_PM_APC_STRING; case 0x99: action_execute(term, data); return STATE_GROUND; case 0x9a: action_execute(term, data); return STATE_GROUND; case 0x9b: action_clear(term); return STATE_CSI_ENTRY; case 0x9c: return STATE_GROUND; case 0x9d: action_osc_start(term, data); return STATE_OSC_STRING; case 0x9e ... 0x9f: return STATE_SOS_PM_APC_STRING; default: return STATE_DCS_IGNORE; } } static enum state state_dcs_passthrough_switch(struct terminal *term, uint8_t data) { switch (data) { /* exit current enter new state */ case 0x00 ... 0x17: case 0x19: case 0x1c ... 0x7e: action_put(term, data); return STATE_DCS_PASSTHROUGH; case 0x7f: action_ignore(term); return STATE_DCS_PASSTHROUGH; /* Anywhere */ 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; case 0x80 ... 0x8f: action_unhook(term, data); action_execute(term, data); return STATE_GROUND; case 0x90: action_unhook(term, data); action_clear(term); return STATE_DCS_ENTRY; case 0x91 ... 0x97: action_unhook(term, data); action_execute(term, data); return STATE_GROUND; case 0x98: action_unhook(term, data); return STATE_SOS_PM_APC_STRING; case 0x99: action_unhook(term, data); action_execute(term, data); return STATE_GROUND; case 0x9a: action_unhook(term, data); action_execute(term, data); return STATE_GROUND; case 0x9b: action_unhook(term, data); action_clear(term); return STATE_CSI_ENTRY; case 0x9c: action_unhook(term, data); return STATE_GROUND; case 0x9d: action_unhook(term, data); action_osc_start(term, data); return STATE_OSC_STRING; case 0x9e ... 0x9f: action_unhook(term, data); return STATE_SOS_PM_APC_STRING; default: return STATE_DCS_PASSTHROUGH; } } static enum state state_sos_pm_apc_string_switch(struct terminal *term, uint8_t data) { switch (data) { /* exit current enter new state */ case 0x00 ... 0x17: case 0x19: case 0x1c ... 0x7f: action_ignore(term); return STATE_SOS_PM_APC_STRING; /* Anywhere */ case 0x18: action_execute(term, data); return STATE_GROUND; case 0x1a: action_execute(term, data); return STATE_GROUND; case 0x1b: action_clear(term); return STATE_ESCAPE; case 0x80 ... 0x8f: action_execute(term, data); return STATE_GROUND; case 0x90: action_clear(term); return STATE_DCS_ENTRY; case 0x91 ... 0x97: action_execute(term, data); return STATE_GROUND; case 0x98: return STATE_SOS_PM_APC_STRING; case 0x99: action_execute(term, data); return STATE_GROUND; case 0x9a: action_execute(term, data); return STATE_GROUND; case 0x9b: action_clear(term); return STATE_CSI_ENTRY; case 0x9c: return STATE_GROUND; case 0x9d: action_osc_start(term, data); return STATE_OSC_STRING; case 0x9e ... 0x9f: return STATE_SOS_PM_APC_STRING; default: return STATE_SOS_PM_APC_STRING; } } static enum state state_utf8_collect_1_switch(struct terminal *term, uint8_t data) { term->vt.utf8.data[term->vt.utf8.idx++] = data; action_utf8_print(term, data); return STATE_GROUND; } static enum state state_utf8_collect_2_switch(struct terminal *term, uint8_t data) { term->vt.utf8.data[term->vt.utf8.idx++] = data; return STATE_UTF8_COLLECT_1; } static enum state state_utf8_collect_3_switch(struct terminal *term, uint8_t data) { term->vt.utf8.data[term->vt.utf8.idx++] = data; return STATE_UTF8_COLLECT_2; } void vt_from_slave(struct terminal *term, const uint8_t *data, size_t len) { enum state current_state = term->vt.state; const uint8_t *p = data; 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; case STATE_UTF8_COLLECT_1: current_state = state_utf8_collect_1_switch(term, *p); break; case STATE_UTF8_COLLECT_2: current_state = state_utf8_collect_2_switch(term, *p); break; case STATE_UTF8_COLLECT_3: current_state = state_utf8_collect_3_switch(term, *p); break; } } term->vt.state = current_state; }