| /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ |
| |
| /*** |
| This file is part of systemd. |
| |
| Copyright (C) 2014 David Herrmann <dh.herrmann@gmail.com> |
| |
| systemd is free software; you can redistribute it and/or modify it |
| under the terms of the GNU Lesser General Public License as published by |
| the Free Software Foundation; either version 2.1 of the License, or |
| (at your option) any later version. |
| |
| systemd is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public License |
| along with systemd; If not, see <http://www.gnu.org/licenses/>. |
| ***/ |
| |
| /* |
| * Terminal Parser |
| * This file contains a bunch of UTF-8 helpers and the main ctlseq-parser. The |
| * parser is a simple state-machine that correctly parses all CSI, DCS, OSC, ST |
| * control sequences and generic escape sequences. |
| * The parser itself does not perform any actions but lets the caller react to |
| * detected sequences. |
| */ |
| |
| #include <stdbool.h> |
| #include <stdint.h> |
| #include <stdlib.h> |
| #include "macro.h" |
| #include "term-internal.h" |
| #include "util.h" |
| |
| static const uint8_t default_palette[18][3] = { |
| { 0, 0, 0 }, /* black */ |
| { 205, 0, 0 }, /* red */ |
| { 0, 205, 0 }, /* green */ |
| { 205, 205, 0 }, /* yellow */ |
| { 0, 0, 238 }, /* blue */ |
| { 205, 0, 205 }, /* magenta */ |
| { 0, 205, 205 }, /* cyan */ |
| { 229, 229, 229 }, /* light grey */ |
| { 127, 127, 127 }, /* dark grey */ |
| { 255, 0, 0 }, /* light red */ |
| { 0, 255, 0 }, /* light green */ |
| { 255, 255, 0 }, /* light yellow */ |
| { 92, 92, 255 }, /* light blue */ |
| { 255, 0, 255 }, /* light magenta */ |
| { 0, 255, 255 }, /* light cyan */ |
| { 255, 255, 255 }, /* white */ |
| |
| { 229, 229, 229 }, /* light grey */ |
| { 0, 0, 0 }, /* black */ |
| }; |
| |
| static uint32_t term_color_to_argb32(const term_color *color, const term_attr *attr, const uint8_t *palette) { |
| static const uint8_t bval[] = { |
| 0x00, 0x5f, 0x87, |
| 0xaf, 0xd7, 0xff, |
| }; |
| uint8_t r, g, b, t; |
| |
| assert(color); |
| |
| if (!palette) |
| palette = (void*)default_palette; |
| |
| switch (color->ccode) { |
| case TERM_CCODE_RGB: |
| r = color->red; |
| g = color->green; |
| b = color->blue; |
| |
| break; |
| case TERM_CCODE_256: |
| t = color->c256; |
| if (t < 16) { |
| r = palette[t * 3 + 0]; |
| g = palette[t * 3 + 1]; |
| b = palette[t * 3 + 2]; |
| } else if (t < 232) { |
| t -= 16; |
| b = bval[t % 6]; |
| t /= 6; |
| g = bval[t % 6]; |
| t /= 6; |
| r = bval[t % 6]; |
| } else { |
| t = (t - 232) * 10 + 8; |
| r = t; |
| g = t; |
| b = t; |
| } |
| |
| break; |
| case TERM_CCODE_BLACK ... TERM_CCODE_LIGHT_WHITE: |
| t = color->ccode - TERM_CCODE_BLACK; |
| |
| /* bold causes light colors (only for foreground colors) */ |
| if (t < 8 && attr->bold && color == &attr->fg) |
| t += 8; |
| |
| r = palette[t * 3 + 0]; |
| g = palette[t * 3 + 1]; |
| b = palette[t * 3 + 2]; |
| break; |
| case TERM_CCODE_DEFAULT: |
| /* fallthrough */ |
| default: |
| t = 16 + !(color == &attr->fg); |
| r = palette[t * 3 + 0]; |
| g = palette[t * 3 + 1]; |
| b = palette[t * 3 + 2]; |
| break; |
| } |
| |
| return (0xff << 24) | (r << 16) | (g << 8) | b; |
| } |
| |
| /** |
| * term_attr_to_argb32() - Encode terminal colors as native ARGB32 value |
| * @color: Terminal attributes to work on |
| * @fg: Storage for foreground color (or NULL) |
| * @bg: Storage for background color (or NULL) |
| * @palette: The color palette to use (or NULL for default) |
| * |
| * This encodes the colors attr->fg and attr->bg as native-endian ARGB32 values |
| * and returns them. Any color conversions are automatically applied. |
| */ |
| void term_attr_to_argb32(const term_attr *attr, uint32_t *fg, uint32_t *bg, const uint8_t *palette) { |
| uint32_t f, b, t; |
| |
| assert(attr); |
| |
| f = term_color_to_argb32(&attr->fg, attr, palette); |
| b = term_color_to_argb32(&attr->bg, attr, palette); |
| |
| if (attr->inverse) { |
| t = f; |
| f = b; |
| b = t; |
| } |
| |
| if (fg) |
| *fg = f; |
| if (bg) |
| *bg = b; |
| } |
| |
| /** |
| * term_utf8_decode() - Try decoding the next UCS-4 character |
| * @p: decoder object to operate on or NULL |
| * @out_len: output storage for pointer to decoded UCS-4 string or NULL |
| * @c: next char to push into decoder |
| * |
| * This decodes a UTF-8 stream. It must be called for each input-byte of the |
| * UTF-8 stream and returns a UCS-4 stream. A pointer to the parsed UCS-4 |
| * string is stored in @out_buf if non-NULL. The length of this string (number |
| * of parsed UCS4 characters) is returned as result. The string is not |
| * zero-terminated! Furthermore, the string is only valid until the next |
| * invocation of this function. It is also bound to the parser state @p and |
| * must not be freed nor written to by the caller. |
| * |
| * This function is highly optimized to work with terminal-emulators. Instead |
| * of being strict about UTF-8 validity, this tries to perform a fallback to |
| * ISO-8859-1 in case a wrong series was detected. Therefore, this function |
| * might return multiple UCS-4 characters by parsing just a single UTF-8 byte. |
| * |
| * The parser state @p should be allocated and managed by the caller. There're |
| * no helpers to do that for you. To initialize it, simply reset it to all |
| * zero. You can reset or free the object at any point in time. |
| * |
| * Returns: Number of parsed UCS4 characters |
| */ |
| size_t term_utf8_decode(term_utf8 *p, uint32_t **out_buf, char c) { |
| static uint32_t ucs4_null = 0; |
| uint32_t t, *res = NULL; |
| uint8_t byte; |
| size_t len = 0; |
| |
| if (!p) |
| goto out; |
| |
| byte = c; |
| |
| if (!p->valid || p->i_bytes >= p->n_bytes) { |
| /* |
| * If the previous sequence was invalid or fully parsed, start |
| * parsing a fresh new sequence. |
| */ |
| |
| if ((byte & 0xE0) == 0xC0) { |
| /* start of two byte sequence */ |
| t = byte & 0x1F; |
| p->n_bytes = 2; |
| p->i_bytes = 1; |
| p->valid = 1; |
| } else if ((byte & 0xF0) == 0xE0) { |
| /* start of three byte sequence */ |
| t = byte & 0x0F; |
| p->n_bytes = 3; |
| p->i_bytes = 1; |
| p->valid = 1; |
| } else if ((byte & 0xF8) == 0xF0) { |
| /* start of four byte sequence */ |
| t = byte & 0x07; |
| p->n_bytes = 4; |
| p->i_bytes = 1; |
| p->valid = 1; |
| } else { |
| /* Either of: |
| * - single ASCII 7-bit char |
| * - out-of-sync continuation byte |
| * - overlong encoding |
| * All of them are treated as single byte ISO-8859-1 */ |
| t = byte; |
| p->n_bytes = 1; |
| p->i_bytes = 1; |
| p->valid = 0; |
| } |
| |
| p->chars[0] = byte; |
| p->ucs4 = t << (6 * (p->n_bytes - p->i_bytes)); |
| } else { |
| /* |
| * ..otherwise, try to continue the previous sequence.. |
| */ |
| |
| if ((byte & 0xC0) == 0x80) { |
| /* |
| * Valid continuation byte. Append to sequence and |
| * update the ucs4 cache accordingly. |
| */ |
| |
| t = byte & 0x3F; |
| p->chars[p->i_bytes++] = byte; |
| p->ucs4 |= t << (6 * (p->n_bytes - p->i_bytes)); |
| } else { |
| /* |
| * Invalid continuation? Treat cached sequence as |
| * ISO-8859-1, but parse the new char as valid new |
| * starting character. If it's a new single-byte UTF-8 |
| * sequence, we immediately return it in the same run, |
| * otherwise, we might suffer from starvation. |
| */ |
| |
| if ((byte & 0xE0) == 0xC0 || |
| (byte & 0xF0) == 0xE0 || |
| (byte & 0xF8) == 0xF0) { |
| /* |
| * New multi-byte sequence. Move to-be-returned |
| * data at the end and start new sequence. Only |
| * return the old sequence. |
| */ |
| |
| memmove(p->chars + 1, |
| p->chars, |
| sizeof(*p->chars) * p->i_bytes); |
| res = p->chars + 1; |
| len = p->i_bytes; |
| |
| if ((byte & 0xE0) == 0xC0) { |
| /* start of two byte sequence */ |
| t = byte & 0x1F; |
| p->n_bytes = 2; |
| p->i_bytes = 1; |
| p->valid = 1; |
| } else if ((byte & 0xF0) == 0xE0) { |
| /* start of three byte sequence */ |
| t = byte & 0x0F; |
| p->n_bytes = 3; |
| p->i_bytes = 1; |
| p->valid = 1; |
| } else if ((byte & 0xF8) == 0xF0) { |
| /* start of four byte sequence */ |
| t = byte & 0x07; |
| p->n_bytes = 4; |
| p->i_bytes = 1; |
| p->valid = 1; |
| } else |
| assert_not_reached("Should not happen"); |
| |
| p->chars[0] = byte; |
| p->ucs4 = t << (6 * (p->n_bytes - p->i_bytes)); |
| |
| goto out; |
| } else { |
| /* |
| * New single byte sequence, append to output |
| * and return combined sequence. |
| */ |
| |
| p->chars[p->i_bytes++] = byte; |
| p->valid = 0; |
| } |
| } |
| } |
| |
| /* |
| * Check whether a full sequence (valid or invalid) has been parsed and |
| * then return it. Otherwise, return nothing. |
| */ |
| if (p->valid) { |
| /* still parsing? then bail out */ |
| if (p->i_bytes < p->n_bytes) |
| goto out; |
| |
| res = &p->ucs4; |
| len = 1; |
| } else { |
| res = p->chars; |
| len = p->i_bytes; |
| } |
| |
| p->valid = 0; |
| p->i_bytes = 0; |
| p->n_bytes = 0; |
| |
| out: |
| if (out_buf) |
| *out_buf = res ? : &ucs4_null; |
| return len; |
| } |
| |
| /* |
| * Command Parser |
| * The ctl-seq parser "term_parser" only detects whole sequences, it does not |
| * detect the specific command. Once a sequence is parsed, the command-parsers |
| * are used to figure out their meaning. Note that this depends on whether we |
| * run on the host or terminal side. |
| */ |
| |
| static unsigned int term_parse_host_control(const term_seq *seq) { |
| assert_return(seq, TERM_CMD_NONE); |
| |
| switch (seq->terminator) { |
| case 0x00: /* NUL */ |
| return TERM_CMD_NULL; |
| case 0x05: /* ENQ */ |
| return TERM_CMD_ENQ; |
| case 0x07: /* BEL */ |
| return TERM_CMD_BEL; |
| case 0x08: /* BS */ |
| return TERM_CMD_BS; |
| case 0x09: /* HT */ |
| return TERM_CMD_HT; |
| case 0x0a: /* LF */ |
| return TERM_CMD_LF; |
| case 0x0b: /* VT */ |
| return TERM_CMD_VT; |
| case 0x0c: /* FF */ |
| return TERM_CMD_FF; |
| case 0x0d: /* CR */ |
| return TERM_CMD_CR; |
| case 0x0e: /* SO */ |
| return TERM_CMD_SO; |
| case 0x0f: /* SI */ |
| return TERM_CMD_SI; |
| case 0x11: /* DC1 */ |
| return TERM_CMD_DC1; |
| case 0x13: /* DC3 */ |
| return TERM_CMD_DC3; |
| case 0x18: /* CAN */ |
| /* this is already handled by the state-machine */ |
| break; |
| case 0x1a: /* SUB */ |
| return TERM_CMD_SUB; |
| case 0x1b: /* ESC */ |
| /* this is already handled by the state-machine */ |
| break; |
| case 0x1f: /* DEL */ |
| /* this is already handled by the state-machine */ |
| break; |
| case 0x84: /* IND */ |
| return TERM_CMD_IND; |
| case 0x85: /* NEL */ |
| return TERM_CMD_NEL; |
| case 0x88: /* HTS */ |
| return TERM_CMD_HTS; |
| case 0x8d: /* RI */ |
| return TERM_CMD_RI; |
| case 0x8e: /* SS2 */ |
| return TERM_CMD_SS2; |
| case 0x8f: /* SS3 */ |
| return TERM_CMD_SS3; |
| case 0x90: /* DCS */ |
| /* this is already handled by the state-machine */ |
| break; |
| case 0x96: /* SPA */ |
| return TERM_CMD_SPA; |
| case 0x97: /* EPA */ |
| return TERM_CMD_EPA; |
| case 0x98: /* SOS */ |
| /* this is already handled by the state-machine */ |
| break; |
| case 0x9a: /* DECID */ |
| return TERM_CMD_DECID; |
| case 0x9b: /* CSI */ |
| /* this is already handled by the state-machine */ |
| break; |
| case 0x9c: /* ST */ |
| return TERM_CMD_ST; |
| case 0x9d: /* OSC */ |
| /* this is already handled by the state-machine */ |
| break; |
| case 0x9e: /* PM */ |
| /* this is already handled by the state-machine */ |
| break; |
| case 0x9f: /* APC */ |
| /* this is already handled by the state-machine */ |
| break; |
| } |
| |
| return TERM_CMD_NONE; |
| } |
| |
| static inline int charset_from_cmd(uint32_t raw, unsigned int flags, bool require_96) { |
| static const struct { |
| uint32_t raw; |
| unsigned int flags; |
| } charset_cmds[] = { |
| /* 96-compat charsets */ |
| [TERM_CHARSET_ISO_LATIN1_SUPPLEMENTAL] = { .raw = 'A', .flags = 0 }, |
| [TERM_CHARSET_ISO_LATIN2_SUPPLEMENTAL] = { .raw = 'B', .flags = 0 }, |
| [TERM_CHARSET_ISO_LATIN5_SUPPLEMENTAL] = { .raw = 'M', .flags = 0 }, |
| [TERM_CHARSET_ISO_GREEK_SUPPLEMENTAL] = { .raw = 'F', .flags = 0 }, |
| [TERM_CHARSET_ISO_HEBREW_SUPPLEMENTAL] = { .raw = 'H', .flags = 0 }, |
| [TERM_CHARSET_ISO_LATIN_CYRILLIC] = { .raw = 'L', .flags = 0 }, |
| |
| /* 94-compat charsets */ |
| [TERM_CHARSET_DEC_SPECIAL_GRAPHIC] = { .raw = '0', .flags = 0 }, |
| [TERM_CHARSET_DEC_SUPPLEMENTAL] = { .raw = '5', .flags = TERM_SEQ_FLAG_PERCENT }, |
| [TERM_CHARSET_DEC_TECHNICAL] = { .raw = '>', .flags = 0 }, |
| [TERM_CHARSET_CYRILLIC_DEC] = { .raw = '4', .flags = TERM_SEQ_FLAG_AND }, |
| [TERM_CHARSET_DUTCH_NRCS] = { .raw = '4', .flags = 0 }, |
| [TERM_CHARSET_FINNISH_NRCS] = { .raw = '5', .flags = 0 }, |
| [TERM_CHARSET_FRENCH_NRCS] = { .raw = 'R', .flags = 0 }, |
| [TERM_CHARSET_FRENCH_CANADIAN_NRCS] = { .raw = '9', .flags = 0 }, |
| [TERM_CHARSET_GERMAN_NRCS] = { .raw = 'K', .flags = 0 }, |
| [TERM_CHARSET_GREEK_DEC] = { .raw = '?', .flags = TERM_SEQ_FLAG_DQUOTE }, |
| [TERM_CHARSET_GREEK_NRCS] = { .raw = '>', .flags = TERM_SEQ_FLAG_DQUOTE }, |
| [TERM_CHARSET_HEBREW_DEC] = { .raw = '4', .flags = TERM_SEQ_FLAG_DQUOTE }, |
| [TERM_CHARSET_HEBREW_NRCS] = { .raw = '=', .flags = TERM_SEQ_FLAG_PERCENT }, |
| [TERM_CHARSET_ITALIAN_NRCS] = { .raw = 'Y', .flags = 0 }, |
| [TERM_CHARSET_NORWEGIAN_DANISH_NRCS] = { .raw = '`', .flags = 0 }, |
| [TERM_CHARSET_PORTUGUESE_NRCS] = { .raw = '6', .flags = TERM_SEQ_FLAG_PERCENT }, |
| [TERM_CHARSET_RUSSIAN_NRCS] = { .raw = '5', .flags = TERM_SEQ_FLAG_AND }, |
| [TERM_CHARSET_SCS_NRCS] = { .raw = '3', .flags = TERM_SEQ_FLAG_PERCENT }, |
| [TERM_CHARSET_SPANISH_NRCS] = { .raw = 'Z', .flags = 0 }, |
| [TERM_CHARSET_SWEDISH_NRCS] = { .raw = '7', .flags = 0 }, |
| [TERM_CHARSET_SWISS_NRCS] = { .raw = '=', .flags = 0 }, |
| [TERM_CHARSET_TURKISH_DEC] = { .raw = '0', .flags = TERM_SEQ_FLAG_PERCENT }, |
| [TERM_CHARSET_TURKISH_NRCS] = { .raw = '2', .flags = TERM_SEQ_FLAG_PERCENT }, |
| |
| /* special charsets */ |
| [TERM_CHARSET_USERPREF_SUPPLEMENTAL] = { .raw = '<', .flags = 0 }, |
| |
| /* secondary choices */ |
| [TERM_CHARSET_CNT + TERM_CHARSET_FINNISH_NRCS] = { .raw = 'C', .flags = 0 }, |
| [TERM_CHARSET_CNT + TERM_CHARSET_FRENCH_NRCS] = { .raw = 'f', .flags = 0 }, |
| [TERM_CHARSET_CNT + TERM_CHARSET_FRENCH_CANADIAN_NRCS] = { .raw = 'Q', .flags = 0 }, |
| [TERM_CHARSET_CNT + TERM_CHARSET_NORWEGIAN_DANISH_NRCS] = { .raw = 'E', .flags = 0 }, |
| [TERM_CHARSET_CNT + TERM_CHARSET_SWEDISH_NRCS] = { .raw = 'H', .flags = 0 }, /* unused; conflicts with ISO_HEBREW */ |
| |
| /* tertiary choices */ |
| [TERM_CHARSET_CNT + TERM_CHARSET_CNT + TERM_CHARSET_NORWEGIAN_DANISH_NRCS] = { .raw = '6', .flags = 0 }, |
| }; |
| size_t i, cs; |
| |
| /* |
| * Secondary choice on SWEDISH_NRCS and primary choice on |
| * ISO_HEBREW_SUPPLEMENTAL have a conflict: raw=="H", flags==0. |
| * We always choose the ISO 96-compat set, which is what VT510 does. |
| */ |
| |
| for (i = 0; i < ELEMENTSOF(charset_cmds); ++i) { |
| if (charset_cmds[i].raw == raw && charset_cmds[i].flags == flags) { |
| cs = i; |
| while (cs >= TERM_CHARSET_CNT) |
| cs -= TERM_CHARSET_CNT; |
| |
| if (!require_96 || cs < TERM_CHARSET_96_CNT || cs >= TERM_CHARSET_94_CNT) |
| return cs; |
| } |
| } |
| |
| return -ENOENT; |
| } |
| |
| /* true if exactly one bit in @value is set */ |
| static inline bool exactly_one_bit_set(unsigned int value) { |
| return __builtin_popcount(value) == 1; |
| } |
| |
| static unsigned int term_parse_host_escape(const term_seq *seq, unsigned int *cs_out) { |
| unsigned int t, flags; |
| int cs; |
| |
| assert_return(seq, TERM_CMD_NONE); |
| |
| flags = seq->intermediates; |
| t = TERM_SEQ_FLAG_POPEN | TERM_SEQ_FLAG_PCLOSE | TERM_SEQ_FLAG_MULT | |
| TERM_SEQ_FLAG_PLUS | TERM_SEQ_FLAG_MINUS | TERM_SEQ_FLAG_DOT | |
| TERM_SEQ_FLAG_SLASH; |
| |
| if (exactly_one_bit_set(flags & t)) { |
| switch (flags & t) { |
| case TERM_SEQ_FLAG_POPEN: |
| case TERM_SEQ_FLAG_PCLOSE: |
| case TERM_SEQ_FLAG_MULT: |
| case TERM_SEQ_FLAG_PLUS: |
| cs = charset_from_cmd(seq->terminator, flags & ~t, false); |
| break; |
| case TERM_SEQ_FLAG_MINUS: |
| case TERM_SEQ_FLAG_DOT: |
| case TERM_SEQ_FLAG_SLASH: |
| cs = charset_from_cmd(seq->terminator, flags & ~t, true); |
| break; |
| default: |
| cs = -ENOENT; |
| break; |
| } |
| |
| if (cs >= 0) { |
| if (cs_out) |
| *cs_out = cs; |
| return TERM_CMD_SCS; |
| } |
| |
| /* looked like a charset-cmd but wasn't; continue */ |
| } |
| |
| switch (seq->terminator) { |
| case '3': |
| if (flags == TERM_SEQ_FLAG_HASH) /* DECDHL top-half */ |
| return TERM_CMD_DECDHL_TH; |
| break; |
| case '4': |
| if (flags == TERM_SEQ_FLAG_HASH) /* DECDHL bottom-half */ |
| return TERM_CMD_DECDHL_BH; |
| break; |
| case '5': |
| if (flags == TERM_SEQ_FLAG_HASH) /* DECSWL */ |
| return TERM_CMD_DECSWL; |
| break; |
| case '6': |
| if (flags == 0) /* DECBI */ |
| return TERM_CMD_DECBI; |
| else if (flags == TERM_SEQ_FLAG_HASH) /* DECDWL */ |
| return TERM_CMD_DECDWL; |
| break; |
| case '7': |
| if (flags == 0) /* DECSC */ |
| return TERM_CMD_DECSC; |
| break; |
| case '8': |
| if (flags == 0) /* DECRC */ |
| return TERM_CMD_DECRC; |
| else if (flags == TERM_SEQ_FLAG_HASH) /* DECALN */ |
| return TERM_CMD_DECALN; |
| break; |
| case '9': |
| if (flags == 0) /* DECFI */ |
| return TERM_CMD_DECFI; |
| break; |
| case '<': |
| if (flags == 0) /* DECANM */ |
| return TERM_CMD_DECANM; |
| break; |
| case '=': |
| if (flags == 0) /* DECKPAM */ |
| return TERM_CMD_DECKPAM; |
| break; |
| case '>': |
| if (flags == 0) /* DECKPNM */ |
| return TERM_CMD_DECKPNM; |
| break; |
| case '@': |
| if (flags == TERM_SEQ_FLAG_PERCENT) { |
| /* Select default character set */ |
| return TERM_CMD_XTERM_SDCS; |
| } |
| break; |
| case 'D': |
| if (flags == 0) /* IND */ |
| return TERM_CMD_IND; |
| break; |
| case 'E': |
| if (flags == 0) /* NEL */ |
| return TERM_CMD_NEL; |
| break; |
| case 'F': |
| if (flags == 0) /* Cursor to lower-left corner of screen */ |
| return TERM_CMD_XTERM_CLLHP; |
| else if (flags == TERM_SEQ_FLAG_SPACE) /* S7C1T */ |
| return TERM_CMD_S7C1T; |
| break; |
| case 'G': |
| if (flags == TERM_SEQ_FLAG_SPACE) { /* S8C1T */ |
| return TERM_CMD_S8C1T; |
| } else if (flags == TERM_SEQ_FLAG_PERCENT) { |
| /* Select UTF-8 character set */ |
| return TERM_CMD_XTERM_SUCS; |
| } |
| break; |
| case 'H': |
| if (flags == 0) /* HTS */ |
| return TERM_CMD_HTS; |
| break; |
| case 'L': |
| if (flags == TERM_SEQ_FLAG_SPACE) { |
| /* Set ANSI conformance level 1 */ |
| return TERM_CMD_XTERM_SACL1; |
| } |
| break; |
| case 'M': |
| if (flags == 0) { /* RI */ |
| return TERM_CMD_RI; |
| } else if (flags == TERM_SEQ_FLAG_SPACE) { |
| /* Set ANSI conformance level 2 */ |
| return TERM_CMD_XTERM_SACL2; |
| } |
| break; |
| case 'N': |
| if (flags == 0) { /* SS2 */ |
| return TERM_CMD_SS2; |
| } else if (flags == TERM_SEQ_FLAG_SPACE) { |
| /* Set ANSI conformance level 3 */ |
| return TERM_CMD_XTERM_SACL3; |
| } |
| break; |
| case 'O': |
| if (flags == 0) /* SS3 */ |
| return TERM_CMD_SS3; |
| break; |
| case 'P': |
| if (flags == 0) /* DCS: this is already handled by the state-machine */ |
| return 0; |
| break; |
| case 'V': |
| if (flags == 0) /* SPA */ |
| return TERM_CMD_SPA; |
| break; |
| case 'W': |
| if (flags == 0) /* EPA */ |
| return TERM_CMD_EPA; |
| break; |
| case 'X': |
| if (flags == 0) { /* SOS */ |
| /* this is already handled by the state-machine */ |
| break; |
| } |
| break; |
| case 'Z': |
| if (flags == 0) /* DECID */ |
| return TERM_CMD_DECID; |
| break; |
| case '[': |
| if (flags == 0) { /* CSI */ |
| /* this is already handled by the state-machine */ |
| break; |
| } |
| break; |
| case '\\': |
| if (flags == 0) /* ST */ |
| return TERM_CMD_ST; |
| break; |
| case ']': |
| if (flags == 0) { /* OSC */ |
| /* this is already handled by the state-machine */ |
| break; |
| } |
| break; |
| case '^': |
| if (flags == 0) { /* PM */ |
| /* this is already handled by the state-machine */ |
| break; |
| } |
| break; |
| case '_': |
| if (flags == 0) { /* APC */ |
| /* this is already handled by the state-machine */ |
| break; |
| } |
| break; |
| case 'c': |
| if (flags == 0) /* RIS */ |
| return TERM_CMD_RIS; |
| break; |
| case 'l': |
| if (flags == 0) /* Memory lock */ |
| return TERM_CMD_XTERM_MLHP; |
| break; |
| case 'm': |
| if (flags == 0) /* Memory unlock */ |
| return TERM_CMD_XTERM_MUHP; |
| break; |
| case 'n': |
| if (flags == 0) /* LS2 */ |
| return TERM_CMD_LS2; |
| break; |
| case 'o': |
| if (flags == 0) /* LS3 */ |
| return TERM_CMD_LS3; |
| break; |
| case '|': |
| if (flags == 0) /* LS3R */ |
| return TERM_CMD_LS3R; |
| break; |
| case '}': |
| if (flags == 0) /* LS2R */ |
| return TERM_CMD_LS2R; |
| break; |
| case '~': |
| if (flags == 0) /* LS1R */ |
| return TERM_CMD_LS1R; |
| break; |
| } |
| |
| return TERM_CMD_NONE; |
| } |
| |
| static unsigned int term_parse_host_csi(const term_seq *seq) { |
| unsigned int flags; |
| |
| assert_return(seq, TERM_CMD_NONE); |
| |
| flags = seq->intermediates; |
| |
| switch (seq->terminator) { |
| case 'A': |
| if (flags == 0) /* CUU */ |
| return TERM_CMD_CUU; |
| break; |
| case 'a': |
| if (flags == 0) /* HPR */ |
| return TERM_CMD_HPR; |
| break; |
| case 'B': |
| if (flags == 0) /* CUD */ |
| return TERM_CMD_CUD; |
| break; |
| case 'b': |
| if (flags == 0) /* REP */ |
| return TERM_CMD_REP; |
| break; |
| case 'C': |
| if (flags == 0) /* CUF */ |
| return TERM_CMD_CUF; |
| break; |
| case 'c': |
| if (flags == 0) /* DA1 */ |
| return TERM_CMD_DA1; |
| else if (flags == TERM_SEQ_FLAG_GT) /* DA2 */ |
| return TERM_CMD_DA2; |
| else if (flags == TERM_SEQ_FLAG_EQUAL) /* DA3 */ |
| return TERM_CMD_DA3; |
| break; |
| case 'D': |
| if (flags == 0) /* CUB */ |
| return TERM_CMD_CUB; |
| break; |
| case 'd': |
| if (flags == 0) /* VPA */ |
| return TERM_CMD_VPA; |
| break; |
| case 'E': |
| if (flags == 0) /* CNL */ |
| return TERM_CMD_CNL; |
| break; |
| case 'e': |
| if (flags == 0) /* VPR */ |
| return TERM_CMD_VPR; |
| break; |
| case 'F': |
| if (flags == 0) /* CPL */ |
| return TERM_CMD_CPL; |
| break; |
| case 'f': |
| if (flags == 0) /* HVP */ |
| return TERM_CMD_HVP; |
| break; |
| case 'G': |
| if (flags == 0) /* CHA */ |
| return TERM_CMD_CHA; |
| break; |
| case 'g': |
| if (flags == 0) /* TBC */ |
| return TERM_CMD_TBC; |
| else if (flags == TERM_SEQ_FLAG_MULT) /* DECLFKC */ |
| return TERM_CMD_DECLFKC; |
| break; |
| case 'H': |
| if (flags == 0) /* CUP */ |
| return TERM_CMD_CUP; |
| break; |
| case 'h': |
| if (flags == 0) /* SM ANSI */ |
| return TERM_CMD_SM_ANSI; |
| else if (flags == TERM_SEQ_FLAG_WHAT) /* SM DEC */ |
| return TERM_CMD_SM_DEC; |
| break; |
| case 'I': |
| if (flags == 0) /* CHT */ |
| return TERM_CMD_CHT; |
| break; |
| case 'i': |
| if (flags == 0) /* MC ANSI */ |
| return TERM_CMD_MC_ANSI; |
| else if (flags == TERM_SEQ_FLAG_WHAT) /* MC DEC */ |
| return TERM_CMD_MC_DEC; |
| break; |
| case 'J': |
| if (flags == 0) /* ED */ |
| return TERM_CMD_ED; |
| else if (flags == TERM_SEQ_FLAG_WHAT) /* DECSED */ |
| return TERM_CMD_DECSED; |
| break; |
| case 'K': |
| if (flags == 0) /* EL */ |
| return TERM_CMD_EL; |
| else if (flags == TERM_SEQ_FLAG_WHAT) /* DECSEL */ |
| return TERM_CMD_DECSEL; |
| break; |
| case 'L': |
| if (flags == 0) /* IL */ |
| return TERM_CMD_IL; |
| break; |
| case 'l': |
| if (flags == 0) /* RM ANSI */ |
| return TERM_CMD_RM_ANSI; |
| else if (flags == TERM_SEQ_FLAG_WHAT) /* RM DEC */ |
| return TERM_CMD_RM_DEC; |
| break; |
| case 'M': |
| if (flags == 0) /* DL */ |
| return TERM_CMD_DL; |
| break; |
| case 'm': |
| if (flags == 0) /* SGR */ |
| return TERM_CMD_SGR; |
| else if (flags == TERM_SEQ_FLAG_GT) /* XTERM SMR */ |
| return TERM_CMD_XTERM_SRV; |
| break; |
| case 'n': |
| if (flags == 0) /* DSR ANSI */ |
| return TERM_CMD_DSR_ANSI; |
| else if (flags == TERM_SEQ_FLAG_GT) /* XTERM RMR */ |
| return TERM_CMD_XTERM_RRV; |
| else if (flags == TERM_SEQ_FLAG_WHAT) /* DSR DEC */ |
| return TERM_CMD_DSR_DEC; |
| break; |
| case 'P': |
| if (flags == 0) /* DCH */ |
| return TERM_CMD_DCH; |
| else if (flags == TERM_SEQ_FLAG_SPACE) /* PPA */ |
| return TERM_CMD_PPA; |
| break; |
| case 'p': |
| if (flags == 0) /* DECSSL */ |
| return TERM_CMD_DECSSL; |
| else if (flags == TERM_SEQ_FLAG_SPACE) /* DECSSCLS */ |
| return TERM_CMD_DECSSCLS; |
| else if (flags == TERM_SEQ_FLAG_BANG) /* DECSTR */ |
| return TERM_CMD_DECSTR; |
| else if (flags == TERM_SEQ_FLAG_DQUOTE) /* DECSCL */ |
| return TERM_CMD_DECSCL; |
| else if (flags == TERM_SEQ_FLAG_CASH) /* DECRQM-ANSI */ |
| return TERM_CMD_DECRQM_ANSI; |
| else if (flags == (TERM_SEQ_FLAG_CASH | TERM_SEQ_FLAG_WHAT)) /* DECRQM-DEC */ |
| return TERM_CMD_DECRQM_DEC; |
| else if (flags == TERM_SEQ_FLAG_PCLOSE) /* DECSDPT */ |
| return TERM_CMD_DECSDPT; |
| else if (flags == TERM_SEQ_FLAG_MULT) /* DECSPPCS */ |
| return TERM_CMD_DECSPPCS; |
| else if (flags == TERM_SEQ_FLAG_PLUS) /* DECSR */ |
| return TERM_CMD_DECSR; |
| else if (flags == TERM_SEQ_FLAG_COMMA) /* DECLTOD */ |
| return TERM_CMD_DECLTOD; |
| else if (flags == TERM_SEQ_FLAG_GT) /* XTERM SPM */ |
| return TERM_CMD_XTERM_SPM; |
| break; |
| case 'Q': |
| if (flags == TERM_SEQ_FLAG_SPACE) /* PPR */ |
| return TERM_CMD_PPR; |
| break; |
| case 'q': |
| if (flags == 0) /* DECLL */ |
| return TERM_CMD_DECLL; |
| else if (flags == TERM_SEQ_FLAG_SPACE) /* DECSCUSR */ |
| return TERM_CMD_DECSCUSR; |
| else if (flags == TERM_SEQ_FLAG_DQUOTE) /* DECSCA */ |
| return TERM_CMD_DECSCA; |
| else if (flags == TERM_SEQ_FLAG_CASH) /* DECSDDT */ |
| return TERM_CMD_DECSDDT; |
| else if (flags == TERM_SEQ_FLAG_MULT) /* DECSRC */ |
| return TERM_CMD_DECSR; |
| else if (flags == TERM_SEQ_FLAG_PLUS) /* DECELF */ |
| return TERM_CMD_DECELF; |
| else if (flags == TERM_SEQ_FLAG_COMMA) /* DECTID */ |
| return TERM_CMD_DECTID; |
| break; |
| case 'R': |
| if (flags == TERM_SEQ_FLAG_SPACE) /* PPB */ |
| return TERM_CMD_PPB; |
| break; |
| case 'r': |
| if (flags == 0) { |
| /* DECSTBM */ |
| return TERM_CMD_DECSTBM; |
| } else if (flags == TERM_SEQ_FLAG_SPACE) { |
| /* DECSKCV */ |
| return TERM_CMD_DECSKCV; |
| } else if (flags == TERM_SEQ_FLAG_CASH) { |
| /* DECCARA */ |
| return TERM_CMD_DECCARA; |
| } else if (flags == TERM_SEQ_FLAG_MULT) { |
| /* DECSCS */ |
| return TERM_CMD_DECSCS; |
| } else if (flags == TERM_SEQ_FLAG_PLUS) { |
| /* DECSMKR */ |
| return TERM_CMD_DECSMKR; |
| } else if (flags == TERM_SEQ_FLAG_WHAT) { |
| /* |
| * There's a conflict between DECPCTERM and XTERM-RPM. |
| * XTERM-RPM takes a single argument, DECPCTERM takes 2. |
| * Split both up and forward the call to the closer |
| * match. |
| */ |
| if (seq->n_args <= 1) /* XTERM RPM */ |
| return TERM_CMD_XTERM_RPM; |
| else if (seq->n_args >= 2) /* DECPCTERM */ |
| return TERM_CMD_DECPCTERM; |
| } |
| break; |
| case 'S': |
| if (flags == 0) /* SU */ |
| return TERM_CMD_SU; |
| else if (flags == TERM_SEQ_FLAG_WHAT) /* XTERM SGFX */ |
| return TERM_CMD_XTERM_SGFX; |
| break; |
| case 's': |
| if (flags == 0) { |
| /* |
| * There's a conflict between DECSLRM and SC-ANSI which |
| * cannot be resolved without knowing the state of |
| * DECLRMM. We leave that decision up to the caller. |
| */ |
| return TERM_CMD_DECSLRM_OR_SC; |
| } else if (flags == TERM_SEQ_FLAG_CASH) { |
| /* DECSPRTT */ |
| return TERM_CMD_DECSPRTT; |
| } else if (flags == TERM_SEQ_FLAG_MULT) { |
| /* DECSFC */ |
| return TERM_CMD_DECSFC; |
| } else if (flags == TERM_SEQ_FLAG_WHAT) { |
| /* XTERM SPM */ |
| return TERM_CMD_XTERM_SPM; |
| } |
| break; |
| case 'T': |
| if (flags == 0) { |
| /* |
| * Awesome: There's a conflict between SD and XTERM IHMT |
| * that we have to resolve by checking the parameter |
| * count.. XTERM_IHMT needs exactly 5 arguments, SD |
| * takes 0 or 1. We're conservative here and give both |
| * a wider range to allow unused arguments (compat...). |
| */ |
| if (seq->n_args >= 5) { |
| /* XTERM IHMT */ |
| return TERM_CMD_XTERM_IHMT; |
| } else if (seq->n_args < 5) { |
| /* SD */ |
| return TERM_CMD_SD; |
| } |
| } else if (flags == TERM_SEQ_FLAG_GT) { |
| /* XTERM RTM */ |
| return TERM_CMD_XTERM_RTM; |
| } |
| break; |
| case 't': |
| if (flags == 0) { |
| if (seq->n_args > 0 && seq->args[0] < 24) { |
| /* XTERM WM */ |
| return TERM_CMD_XTERM_WM; |
| } else { |
| /* DECSLPP */ |
| return TERM_CMD_DECSLPP; |
| } |
| } else if (flags == TERM_SEQ_FLAG_SPACE) { |
| /* DECSWBV */ |
| return TERM_CMD_DECSWBV; |
| } else if (flags == TERM_SEQ_FLAG_DQUOTE) { |
| /* DECSRFR */ |
| return TERM_CMD_DECSRFR; |
| } else if (flags == TERM_SEQ_FLAG_CASH) { |
| /* DECRARA */ |
| return TERM_CMD_DECRARA; |
| } else if (flags == TERM_SEQ_FLAG_GT) { |
| /* XTERM STM */ |
| return TERM_CMD_XTERM_STM; |
| } |
| break; |
| case 'U': |
| if (flags == 0) /* NP */ |
| return TERM_CMD_NP; |
| break; |
| case 'u': |
| if (flags == 0) { |
| /* RC */ |
| return TERM_CMD_RC; |
| } else if (flags == TERM_SEQ_FLAG_SPACE) { |
| /* DECSMBV */ |
| return TERM_CMD_DECSMBV; |
| } else if (flags == TERM_SEQ_FLAG_DQUOTE) { |
| /* DECSTRL */ |
| return TERM_CMD_DECSTRL; |
| } else if (flags == TERM_SEQ_FLAG_WHAT) { |
| /* DECRQUPSS */ |
| return TERM_CMD_DECRQUPSS; |
| } else if (seq->args[0] == 1 && flags == TERM_SEQ_FLAG_CASH) { |
| /* DECRQTSR */ |
| return TERM_CMD_DECRQTSR; |
| } else if (flags == TERM_SEQ_FLAG_MULT) { |
| /* DECSCP */ |
| return TERM_CMD_DECSCP; |
| } else if (flags == TERM_SEQ_FLAG_COMMA) { |
| /* DECRQKT */ |
| return TERM_CMD_DECRQKT; |
| } |
| break; |
| case 'V': |
| if (flags == 0) /* PP */ |
| return TERM_CMD_PP; |
| break; |
| case 'v': |
| if (flags == TERM_SEQ_FLAG_SPACE) /* DECSLCK */ |
| return TERM_CMD_DECSLCK; |
| else if (flags == TERM_SEQ_FLAG_DQUOTE) /* DECRQDE */ |
| return TERM_CMD_DECRQDE; |
| else if (flags == TERM_SEQ_FLAG_CASH) /* DECCRA */ |
| return TERM_CMD_DECCRA; |
| else if (flags == TERM_SEQ_FLAG_COMMA) /* DECRPKT */ |
| return TERM_CMD_DECRPKT; |
| break; |
| case 'W': |
| if (seq->args[0] == 5 && flags == TERM_SEQ_FLAG_WHAT) { |
| /* DECST8C */ |
| return TERM_CMD_DECST8C; |
| } |
| break; |
| case 'w': |
| if (flags == TERM_SEQ_FLAG_CASH) /* DECRQPSR */ |
| return TERM_CMD_DECRQPSR; |
| else if (flags == TERM_SEQ_FLAG_SQUOTE) /* DECEFR */ |
| return TERM_CMD_DECEFR; |
| else if (flags == TERM_SEQ_FLAG_PLUS) /* DECSPP */ |
| return TERM_CMD_DECSPP; |
| break; |
| case 'X': |
| if (flags == 0) /* ECH */ |
| return TERM_CMD_ECH; |
| break; |
| case 'x': |
| if (flags == 0) /* DECREQTPARM */ |
| return TERM_CMD_DECREQTPARM; |
| else if (flags == TERM_SEQ_FLAG_CASH) /* DECFRA */ |
| return TERM_CMD_DECFRA; |
| else if (flags == TERM_SEQ_FLAG_MULT) /* DECSACE */ |
| return TERM_CMD_DECSACE; |
| else if (flags == TERM_SEQ_FLAG_PLUS) /* DECRQPKFM */ |
| return TERM_CMD_DECRQPKFM; |
| break; |
| case 'y': |
| if (flags == 0) /* DECTST */ |
| return TERM_CMD_DECTST; |
| else if (flags == TERM_SEQ_FLAG_MULT) /* DECRQCRA */ |
| return TERM_CMD_DECRQCRA; |
| else if (flags == TERM_SEQ_FLAG_PLUS) /* DECPKFMR */ |
| return TERM_CMD_DECPKFMR; |
| break; |
| case 'Z': |
| if (flags == 0) /* CBT */ |
| return TERM_CMD_CBT; |
| break; |
| case 'z': |
| if (flags == TERM_SEQ_FLAG_CASH) /* DECERA */ |
| return TERM_CMD_DECERA; |
| else if (flags == TERM_SEQ_FLAG_SQUOTE) /* DECELR */ |
| return TERM_CMD_DECELR; |
| else if (flags == TERM_SEQ_FLAG_MULT) /* DECINVM */ |
| return TERM_CMD_DECINVM; |
| else if (flags == TERM_SEQ_FLAG_PLUS) /* DECPKA */ |
| return TERM_CMD_DECPKA; |
| break; |
| case '@': |
| if (flags == 0) /* ICH */ |
| return TERM_CMD_ICH; |
| break; |
| case '`': |
| if (flags == 0) /* HPA */ |
| return TERM_CMD_HPA; |
| break; |
| case '{': |
| if (flags == TERM_SEQ_FLAG_CASH) /* DECSERA */ |
| return TERM_CMD_DECSERA; |
| else if (flags == TERM_SEQ_FLAG_SQUOTE) /* DECSLE */ |
| return TERM_CMD_DECSLE; |
| break; |
| case '|': |
| if (flags == TERM_SEQ_FLAG_CASH) /* DECSCPP */ |
| return TERM_CMD_DECSCPP; |
| else if (flags == TERM_SEQ_FLAG_SQUOTE) /* DECRQLP */ |
| return TERM_CMD_DECRQLP; |
| else if (flags == TERM_SEQ_FLAG_MULT) /* DECSNLS */ |
| return TERM_CMD_DECSNLS; |
| break; |
| case '}': |
| if (flags == TERM_SEQ_FLAG_SPACE) /* DECKBD */ |
| return TERM_CMD_DECKBD; |
| else if (flags == TERM_SEQ_FLAG_CASH) /* DECSASD */ |
| return TERM_CMD_DECSASD; |
| else if (flags == TERM_SEQ_FLAG_SQUOTE) /* DECIC */ |
| return TERM_CMD_DECIC; |
| break; |
| case '~': |
| if (flags == TERM_SEQ_FLAG_SPACE) /* DECTME */ |
| return TERM_CMD_DECTME; |
| else if (flags == TERM_SEQ_FLAG_CASH) /* DECSSDT */ |
| return TERM_CMD_DECSSDT; |
| else if (flags == TERM_SEQ_FLAG_SQUOTE) /* DECDC */ |
| return TERM_CMD_DECDC; |
| break; |
| } |
| |
| return TERM_CMD_NONE; |
| } |
| |
| /* |
| * State Machine |
| * This parser controls the parser-state and returns any detected sequence to |
| * the caller. The parser is based on this state-diagram from Paul Williams: |
| * http://vt100.net/emu/ |
| * It was written from scratch and extended where needed. |
| * This parser is fully compatible up to the vt500 series. We expect UCS-4 as |
| * input. It's the callers responsibility to do any UTF-8 parsing. |
| */ |
| |
| enum parser_state { |
| STATE_NONE, /* placeholder */ |
| STATE_GROUND, /* initial state and ground */ |
| STATE_ESC, /* ESC sequence was started */ |
| STATE_ESC_INT, /* intermediate escape characters */ |
| STATE_CSI_ENTRY, /* starting CSI sequence */ |
| STATE_CSI_PARAM, /* CSI parameters */ |
| STATE_CSI_INT, /* intermediate CSI characters */ |
| STATE_CSI_IGNORE, /* CSI error; ignore this CSI sequence */ |
| STATE_DCS_ENTRY, /* starting DCS sequence */ |
| STATE_DCS_PARAM, /* DCS parameters */ |
| STATE_DCS_INT, /* intermediate DCS characters */ |
| STATE_DCS_PASS, /* DCS data passthrough */ |
| STATE_DCS_IGNORE, /* DCS error; ignore this DCS sequence */ |
| STATE_OSC_STRING, /* parsing OSC sequence */ |
| STATE_ST_IGNORE, /* unimplemented seq; ignore until ST */ |
| STATE_NUM |
| }; |
| |
| enum parser_action { |
| ACTION_NONE, /* placeholder */ |
| ACTION_CLEAR, /* clear parameters */ |
| ACTION_IGNORE, /* ignore the character entirely */ |
| ACTION_PRINT, /* print the character on the console */ |
| ACTION_EXECUTE, /* execute single control character (C0/C1) */ |
| ACTION_COLLECT, /* collect intermediate character */ |
| ACTION_PARAM, /* collect parameter character */ |
| ACTION_ESC_DISPATCH, /* dispatch escape sequence */ |
| ACTION_CSI_DISPATCH, /* dispatch csi sequence */ |
| ACTION_DCS_START, /* start of DCS data */ |
| ACTION_DCS_COLLECT, /* collect DCS data */ |
| ACTION_DCS_CONSUME, /* consume DCS terminator */ |
| ACTION_DCS_DISPATCH, /* dispatch dcs sequence */ |
| ACTION_OSC_START, /* start of OSC data */ |
| ACTION_OSC_COLLECT, /* collect OSC data */ |
| ACTION_OSC_CONSUME, /* consume OSC terminator */ |
| ACTION_OSC_DISPATCH, /* dispatch osc sequence */ |
| ACTION_NUM |
| }; |
| |
| int term_parser_new(term_parser **out, bool host) { |
| _term_parser_free_ term_parser *parser = NULL; |
| |
| assert_return(out, -EINVAL); |
| |
| parser = new0(term_parser, 1); |
| if (!parser) |
| return -ENOMEM; |
| |
| parser->is_host = host; |
| parser->st_alloc = 64; |
| parser->seq.st = new0(char, parser->st_alloc + 1); |
| if (!parser->seq.st) |
| return -ENOMEM; |
| |
| *out = parser; |
| parser = NULL; |
| return 0; |
| } |
| |
| term_parser *term_parser_free(term_parser *parser) { |
| if (!parser) |
| return NULL; |
| |
| free(parser->seq.st); |
| free(parser); |
| return NULL; |
| } |
| |
| static inline void parser_clear(term_parser *parser) { |
| unsigned int i; |
| |
| parser->seq.command = TERM_CMD_NONE; |
| parser->seq.terminator = 0; |
| parser->seq.intermediates = 0; |
| parser->seq.charset = TERM_CHARSET_NONE; |
| parser->seq.n_args = 0; |
| for (i = 0; i < TERM_PARSER_ARG_MAX; ++i) |
| parser->seq.args[i] = -1; |
| |
| parser->seq.n_st = 0; |
| parser->seq.st[0] = 0; |
| } |
| |
| static int parser_ignore(term_parser *parser, uint32_t raw) { |
| parser_clear(parser); |
| parser->seq.type = TERM_SEQ_IGNORE; |
| parser->seq.command = TERM_CMD_NONE; |
| parser->seq.terminator = raw; |
| parser->seq.charset = TERM_CHARSET_NONE; |
| |
| return parser->seq.type; |
| } |
| |
| static int parser_print(term_parser *parser, uint32_t raw) { |
| parser_clear(parser); |
| parser->seq.type = TERM_SEQ_GRAPHIC; |
| parser->seq.command = TERM_CMD_GRAPHIC; |
| parser->seq.terminator = raw; |
| parser->seq.charset = TERM_CHARSET_NONE; |
| |
| return parser->seq.type; |
| } |
| |
| static int parser_execute(term_parser *parser, uint32_t raw) { |
| parser_clear(parser); |
| parser->seq.type = TERM_SEQ_CONTROL; |
| parser->seq.command = TERM_CMD_GRAPHIC; |
| parser->seq.terminator = raw; |
| parser->seq.charset = TERM_CHARSET_NONE; |
| if (!parser->is_host) |
| parser->seq.command = term_parse_host_control(&parser->seq); |
| |
| return parser->seq.type; |
| } |
| |
| static void parser_collect(term_parser *parser, uint32_t raw) { |
| /* |
| * Usually, characters from 0x30 to 0x3f are only allowed as leading |
| * markers (or as part of the parameters), characters from 0x20 to 0x2f |
| * are only allowed as trailing markers. However, our state-machine |
| * already verifies those restrictions so we can handle them the same |
| * way here. Note that we safely allow markers to be specified multiple |
| * times. |
| */ |
| |
| if (raw >= 0x20 && raw <= 0x3f) |
| parser->seq.intermediates |= 1 << (raw - 0x20); |
| } |
| |
| static void parser_param(term_parser *parser, uint32_t raw) { |
| int new; |
| |
| if (raw == ';') { |
| if (parser->seq.n_args < TERM_PARSER_ARG_MAX) |
| ++parser->seq.n_args; |
| |
| return; |
| } |
| |
| if (parser->seq.n_args >= TERM_PARSER_ARG_MAX) |
| return; |
| |
| if (raw >= '0' && raw <= '9') { |
| new = parser->seq.args[parser->seq.n_args]; |
| if (new < 0) |
| new = 0; |
| new = new * 10 + raw - '0'; |
| |
| /* VT510 tells us to clamp all values to [0, 9999], however, it |
| * also allows commands with values up to 2^15-1. We simply use |
| * 2^16 as maximum here to be compatible to all commands, but |
| * avoid overflows in any calculations. */ |
| if (new > 0xffff) |
| new = 0xffff; |
| |
| parser->seq.args[parser->seq.n_args] = new; |
| } |
| } |
| |
| static int parser_esc(term_parser *parser, uint32_t raw) { |
| parser->seq.type = TERM_SEQ_ESCAPE; |
| parser->seq.command = TERM_CMD_NONE; |
| parser->seq.terminator = raw; |
| parser->seq.charset = TERM_CHARSET_NONE; |
| if (!parser->is_host) |
| parser->seq.command = term_parse_host_escape(&parser->seq, &parser->seq.charset); |
| |
| return parser->seq.type; |
| } |
| |
| static int parser_csi(term_parser *parser, uint32_t raw) { |
| /* parser->seq is cleared during CSI-ENTER state, thus there's no need |
| * to clear invalid fields here. */ |
| |
| if (parser->seq.n_args < TERM_PARSER_ARG_MAX) { |
| if (parser->seq.n_args > 0 || |
| parser->seq.args[parser->seq.n_args] >= 0) |
| ++parser->seq.n_args; |
| } |
| |
| parser->seq.type = TERM_SEQ_CSI; |
| parser->seq.command = TERM_CMD_NONE; |
| parser->seq.terminator = raw; |
| parser->seq.charset = TERM_CHARSET_NONE; |
| if (!parser->is_host) |
| parser->seq.command = term_parse_host_csi(&parser->seq); |
| |
| return parser->seq.type; |
| } |
| |
| /* perform state transition and dispatch related actions */ |
| static int parser_transition(term_parser *parser, uint32_t raw, unsigned int state, unsigned int action) { |
| if (state != STATE_NONE) |
| parser->state = state; |
| |
| switch (action) { |
| case ACTION_NONE: |
| return TERM_SEQ_NONE; |
| case ACTION_CLEAR: |
| parser_clear(parser); |
| return TERM_SEQ_NONE; |
| case ACTION_IGNORE: |
| return parser_ignore(parser, raw); |
| case ACTION_PRINT: |
| return parser_print(parser, raw); |
| case ACTION_EXECUTE: |
| return parser_execute(parser, raw); |
| case ACTION_COLLECT: |
| parser_collect(parser, raw); |
| return TERM_SEQ_NONE; |
| case ACTION_PARAM: |
| parser_param(parser, raw); |
| return TERM_SEQ_NONE; |
| case ACTION_ESC_DISPATCH: |
| return parser_esc(parser, raw); |
| case ACTION_CSI_DISPATCH: |
| return parser_csi(parser, raw); |
| case ACTION_DCS_START: |
| /* not implemented */ |
| return TERM_SEQ_NONE; |
| case ACTION_DCS_COLLECT: |
| /* not implemented */ |
| return TERM_SEQ_NONE; |
| case ACTION_DCS_CONSUME: |
| /* not implemented */ |
| return TERM_SEQ_NONE; |
| case ACTION_DCS_DISPATCH: |
| /* not implemented */ |
| return TERM_SEQ_NONE; |
| case ACTION_OSC_START: |
| /* not implemented */ |
| return TERM_SEQ_NONE; |
| case ACTION_OSC_COLLECT: |
| /* not implemented */ |
| return TERM_SEQ_NONE; |
| case ACTION_OSC_CONSUME: |
| /* not implemented */ |
| return TERM_SEQ_NONE; |
| case ACTION_OSC_DISPATCH: |
| /* not implemented */ |
| return TERM_SEQ_NONE; |
| default: |
| assert_not_reached("invalid vte-parser action"); |
| return TERM_SEQ_NONE; |
| } |
| } |
| |
| static int parser_feed_to_state(term_parser *parser, uint32_t raw) { |
| switch (parser->state) { |
| case STATE_NONE: |
| /* |
| * During initialization, parser->state is cleared. Treat this |
| * as STATE_GROUND. We will then never get to STATE_NONE again. |
| */ |
| case STATE_GROUND: |
| switch (raw) { |
| case 0x00 ... 0x1f: /* C0 */ |
| case 0x80 ... 0x9b: /* C1 \ { ST } */ |
| case 0x9d ... 0x9f: |
| return parser_transition(parser, raw, STATE_NONE, ACTION_EXECUTE); |
| case 0x9c: /* ST */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_IGNORE); |
| } |
| |
| return parser_transition(parser, raw, STATE_NONE, ACTION_PRINT); |
| case STATE_ESC: |
| switch (raw) { |
| case 0x00 ... 0x1f: /* C0 */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_EXECUTE); |
| case 0x20 ... 0x2f: /* [' ' - '\'] */ |
| return parser_transition(parser, raw, STATE_ESC_INT, ACTION_COLLECT); |
| case 0x30 ... 0x4f: /* ['0' - '~'] \ { 'P', 'X', '[', ']', '^', '_' } */ |
| case 0x51 ... 0x57: |
| case 0x59 ... 0x5a: |
| case 0x5c: |
| case 0x60 ... 0x7e: |
| return parser_transition(parser, raw, STATE_GROUND, ACTION_ESC_DISPATCH); |
| case 0x50: /* 'P' */ |
| return parser_transition(parser, raw, STATE_DCS_ENTRY, ACTION_CLEAR); |
| case 0x5b: /* '[' */ |
| return parser_transition(parser, raw, STATE_CSI_ENTRY, ACTION_CLEAR); |
| case 0x5d: /* ']' */ |
| return parser_transition(parser, raw, STATE_OSC_STRING, ACTION_CLEAR); |
| case 0x58: /* 'X' */ |
| case 0x5e: /* '^' */ |
| case 0x5f: /* '_' */ |
| return parser_transition(parser, raw, STATE_ST_IGNORE, ACTION_NONE); |
| case 0x7f: /* DEL */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_IGNORE); |
| case 0x9c: /* ST */ |
| return parser_transition(parser, raw, STATE_GROUND, ACTION_IGNORE); |
| } |
| |
| return parser_transition(parser, raw, STATE_ESC_INT, ACTION_COLLECT); |
| case STATE_ESC_INT: |
| switch (raw) { |
| case 0x00 ... 0x1f: /* C0 */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_EXECUTE); |
| case 0x20 ... 0x2f: /* [' ' - '\'] */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_COLLECT); |
| case 0x30 ... 0x7e: /* ['0' - '~'] */ |
| return parser_transition(parser, raw, STATE_GROUND, ACTION_ESC_DISPATCH); |
| case 0x7f: /* DEL */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_IGNORE); |
| case 0x9c: /* ST */ |
| return parser_transition(parser, raw, STATE_GROUND, ACTION_IGNORE); |
| } |
| |
| return parser_transition(parser, raw, STATE_NONE, ACTION_COLLECT); |
| case STATE_CSI_ENTRY: |
| switch (raw) { |
| case 0x00 ... 0x1f: /* C0 */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_EXECUTE); |
| case 0x20 ... 0x2f: /* [' ' - '\'] */ |
| return parser_transition(parser, raw, STATE_CSI_INT, ACTION_COLLECT); |
| case 0x3a: /* ':' */ |
| return parser_transition(parser, raw, STATE_CSI_IGNORE, ACTION_NONE); |
| case 0x30 ... 0x39: /* ['0' - '9'] */ |
| case 0x3b: /* ';' */ |
| return parser_transition(parser, raw, STATE_CSI_PARAM, ACTION_PARAM); |
| case 0x3c ... 0x3f: /* ['<' - '?'] */ |
| return parser_transition(parser, raw, STATE_CSI_PARAM, ACTION_COLLECT); |
| case 0x40 ... 0x7e: /* ['@' - '~'] */ |
| return parser_transition(parser, raw, STATE_GROUND, ACTION_CSI_DISPATCH); |
| case 0x7f: /* DEL */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_IGNORE); |
| case 0x9c: /* ST */ |
| return parser_transition(parser, raw, STATE_GROUND, ACTION_IGNORE); |
| } |
| |
| return parser_transition(parser, raw, STATE_CSI_IGNORE, ACTION_NONE); |
| case STATE_CSI_PARAM: |
| switch (raw) { |
| case 0x00 ... 0x1f: /* C0 */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_EXECUTE); |
| case 0x20 ... 0x2f: /* [' ' - '\'] */ |
| return parser_transition(parser, raw, STATE_CSI_INT, ACTION_COLLECT); |
| case 0x30 ... 0x39: /* ['0' - '9'] */ |
| case 0x3b: /* ';' */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_PARAM); |
| case 0x3a: /* ':' */ |
| case 0x3c ... 0x3f: /* ['<' - '?'] */ |
| return parser_transition(parser, raw, STATE_CSI_IGNORE, ACTION_NONE); |
| case 0x40 ... 0x7e: /* ['@' - '~'] */ |
| return parser_transition(parser, raw, STATE_GROUND, ACTION_CSI_DISPATCH); |
| case 0x7f: /* DEL */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_IGNORE); |
| case 0x9c: /* ST */ |
| return parser_transition(parser, raw, STATE_GROUND, ACTION_IGNORE); |
| } |
| |
| return parser_transition(parser, raw, STATE_CSI_IGNORE, ACTION_NONE); |
| case STATE_CSI_INT: |
| switch (raw) { |
| case 0x00 ... 0x1f: /* C0 */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_EXECUTE); |
| case 0x20 ... 0x2f: /* [' ' - '\'] */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_COLLECT); |
| case 0x30 ... 0x3f: /* ['0' - '?'] */ |
| return parser_transition(parser, raw, STATE_CSI_IGNORE, ACTION_NONE); |
| case 0x40 ... 0x7e: /* ['@' - '~'] */ |
| return parser_transition(parser, raw, STATE_GROUND, ACTION_CSI_DISPATCH); |
| case 0x7f: /* DEL */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_IGNORE); |
| case 0x9c: /* ST */ |
| return parser_transition(parser, raw, STATE_GROUND, ACTION_IGNORE); |
| } |
| |
| return parser_transition(parser, raw, STATE_CSI_IGNORE, ACTION_NONE); |
| case STATE_CSI_IGNORE: |
| switch (raw) { |
| case 0x00 ... 0x1f: /* C0 */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_EXECUTE); |
| case 0x20 ... 0x3f: /* [' ' - '?'] */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_NONE); |
| case 0x40 ... 0x7e: /* ['@' - '~'] */ |
| return parser_transition(parser, raw, STATE_GROUND, ACTION_NONE); |
| case 0x7f: /* DEL */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_IGNORE); |
| case 0x9c: /* ST */ |
| return parser_transition(parser, raw, STATE_GROUND, ACTION_IGNORE); |
| } |
| |
| return parser_transition(parser, raw, STATE_NONE, ACTION_NONE); |
| case STATE_DCS_ENTRY: |
| switch (raw) { |
| case 0x00 ... 0x1f: /* C0 */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_IGNORE); |
| case 0x20 ... 0x2f: /* [' ' - '\'] */ |
| return parser_transition(parser, raw, STATE_DCS_INT, ACTION_COLLECT); |
| case 0x3a: /* ':' */ |
| return parser_transition(parser, raw, STATE_DCS_IGNORE, ACTION_NONE); |
| case 0x30 ... 0x39: /* ['0' - '9'] */ |
| case 0x3b: /* ';' */ |
| return parser_transition(parser, raw, STATE_DCS_PARAM, ACTION_PARAM); |
| case 0x3c ... 0x3f: /* ['<' - '?'] */ |
| return parser_transition(parser, raw, STATE_DCS_PARAM, ACTION_COLLECT); |
| case 0x40 ... 0x7e: /* ['@' - '~'] */ |
| return parser_transition(parser, raw, STATE_DCS_PASS, ACTION_DCS_CONSUME); |
| case 0x7f: /* DEL */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_IGNORE); |
| case 0x9c: /* ST */ |
| return parser_transition(parser, raw, STATE_GROUND, ACTION_IGNORE); |
| } |
| |
| return parser_transition(parser, raw, STATE_DCS_PASS, ACTION_DCS_CONSUME); |
| case STATE_DCS_PARAM: |
| switch (raw) { |
| case 0x00 ... 0x1f: /* C0 */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_IGNORE); |
| case 0x20 ... 0x2f: /* [' ' - '\'] */ |
| return parser_transition(parser, raw, STATE_DCS_INT, ACTION_COLLECT); |
| case 0x30 ... 0x39: /* ['0' - '9'] */ |
| case 0x3b: /* ';' */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_PARAM); |
| case 0x3a: /* ':' */ |
| case 0x3c ... 0x3f: /* ['<' - '?'] */ |
| return parser_transition(parser, raw, STATE_DCS_IGNORE, ACTION_NONE); |
| case 0x40 ... 0x7e: /* ['@' - '~'] */ |
| return parser_transition(parser, raw, STATE_DCS_PASS, ACTION_DCS_CONSUME); |
| case 0x7f: /* DEL */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_IGNORE); |
| case 0x9c: /* ST */ |
| return parser_transition(parser, raw, STATE_GROUND, ACTION_IGNORE); |
| } |
| |
| return parser_transition(parser, raw, STATE_DCS_PASS, ACTION_DCS_CONSUME); |
| case STATE_DCS_INT: |
| switch (raw) { |
| case 0x00 ... 0x1f: /* C0 */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_IGNORE); |
| case 0x20 ... 0x2f: /* [' ' - '\'] */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_COLLECT); |
| case 0x30 ... 0x3f: /* ['0' - '?'] */ |
| return parser_transition(parser, raw, STATE_DCS_IGNORE, ACTION_NONE); |
| case 0x40 ... 0x7e: /* ['@' - '~'] */ |
| return parser_transition(parser, raw, STATE_DCS_PASS, ACTION_DCS_CONSUME); |
| case 0x7f: /* DEL */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_IGNORE); |
| case 0x9c: /* ST */ |
| return parser_transition(parser, raw, STATE_GROUND, ACTION_IGNORE); |
| } |
| |
| return parser_transition(parser, raw, STATE_DCS_PASS, ACTION_DCS_CONSUME); |
| case STATE_DCS_PASS: |
| switch (raw) { |
| case 0x00 ... 0x7e: /* ASCII \ { DEL } */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_DCS_COLLECT); |
| case 0x7f: /* DEL */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_IGNORE); |
| case 0x9c: /* ST */ |
| return parser_transition(parser, raw, STATE_GROUND, ACTION_DCS_DISPATCH); |
| } |
| |
| return parser_transition(parser, raw, STATE_NONE, ACTION_DCS_COLLECT); |
| case STATE_DCS_IGNORE: |
| switch (raw) { |
| case 0x00 ... 0x7f: /* ASCII */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_IGNORE); |
| case 0x9c: /* ST */ |
| return parser_transition(parser, raw, STATE_GROUND, ACTION_NONE); |
| } |
| |
| return parser_transition(parser, raw, STATE_NONE, ACTION_NONE); |
| case STATE_OSC_STRING: |
| switch (raw) { |
| case 0x00 ... 0x06: /* C0 \ { BEL } */ |
| case 0x08 ... 0x1f: |
| return parser_transition(parser, raw, STATE_NONE, ACTION_IGNORE); |
| case 0x20 ... 0x7f: /* [' ' - DEL] */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_OSC_COLLECT); |
| case 0x07: /* BEL */ |
| case 0x9c: /* ST */ |
| return parser_transition(parser, raw, STATE_GROUND, ACTION_OSC_DISPATCH); |
| } |
| |
| return parser_transition(parser, raw, STATE_NONE, ACTION_OSC_COLLECT); |
| case STATE_ST_IGNORE: |
| switch (raw) { |
| case 0x00 ... 0x7f: /* ASCII */ |
| return parser_transition(parser, raw, STATE_NONE, ACTION_IGNORE); |
| case 0x9c: /* ST */ |
| return parser_transition(parser, raw, STATE_GROUND, ACTION_IGNORE); |
| } |
| |
| return parser_transition(parser, raw, STATE_NONE, ACTION_NONE); |
| } |
| |
| assert_not_reached("bad vte-parser state"); |
| return -EINVAL; |
| } |
| |
| int term_parser_feed(term_parser *parser, const term_seq **seq_out, uint32_t raw) { |
| int r; |
| |
| assert_return(parser, -EINVAL); |
| assert_return(seq_out, -EINVAL); |
| |
| /* |
| * Notes: |
| * * DEC treats GR codes as GL. We don't do that as we require UTF-8 |
| * as charset and, thus, it doesn't make sense to treat GR special. |
| * * During control sequences, unexpected C1 codes cancel the sequence |
| * and immediately start a new one. C0 codes, however, may or may not |
| * be ignored/executed depending on the sequence. |
| */ |
| |
| switch (raw) { |
| case 0x18: /* CAN */ |
| r = parser_transition(parser, raw, STATE_GROUND, ACTION_IGNORE); |
| break; |
| case 0x1a: /* SUB */ |
| r = parser_transition(parser, raw, STATE_GROUND, ACTION_EXECUTE); |
| break; |
| case 0x80 ... 0x8f: /* C1 \ {DCS, SOS, CSI, ST, OSC, PM, APC} */ |
| case 0x91 ... 0x97: |
| case 0x99 ... 0x9a: |
| r = parser_transition(parser, raw, STATE_GROUND, ACTION_EXECUTE); |
| break; |
| case 0x1b: /* ESC */ |
| r = parser_transition(parser, raw, STATE_ESC, ACTION_CLEAR); |
| break; |
| case 0x98: /* SOS */ |
| case 0x9e: /* PM */ |
| case 0x9f: /* APC */ |
| r = parser_transition(parser, raw, STATE_ST_IGNORE, ACTION_NONE); |
| break; |
| case 0x90: /* DCS */ |
| r = parser_transition(parser, raw, STATE_DCS_ENTRY, ACTION_CLEAR); |
| break; |
| case 0x9d: /* OSC */ |
| r = parser_transition(parser, raw, STATE_OSC_STRING, ACTION_CLEAR); |
| break; |
| case 0x9b: /* CSI */ |
| r = parser_transition(parser, raw, STATE_CSI_ENTRY, ACTION_CLEAR); |
| break; |
| default: |
| r = parser_feed_to_state(parser, raw); |
| break; |
| } |
| |
| if (r <= 0) |
| *seq_out = NULL; |
| else |
| *seq_out = &parser->seq; |
| |
| return r; |
| } |