/* Copyright (C) 2019, 2021 June McEnroe * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program 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 Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . */ %option noinput nounput noyywrap %{ #include #include #include #include #include #include #include #include #include #include #define Q(...) #__VA_ARGS__ #define BIT(x) x##Bit, x = 1 << x##Bit, x##Bit_ = x##Bit #define ENUM_CODE \ X(BS) \ X(CHA) \ X(CNL) \ X(CPL) \ X(CR) \ X(CUB) \ X(CUD) \ X(CUF) \ X(CUP) \ X(CUU) \ X(DCH) \ X(DECRC) \ X(DECRST) \ X(DECSC) \ X(DECSET) \ X(DECSTBM) \ X(DL) \ X(ECH) \ X(ED) \ X(EL) \ X(HT) \ X(ICH) \ X(IL) \ X(MC) \ X(NL) \ X(RI) \ X(RM) \ X(SD) \ X(SGR) \ X(SM) \ X(SU) \ X(VPA) enum Code { Data = 1, #define X(code) code, ENUM_CODE #undef X }; static enum { USASCII, DECSpecial, } g0; static const wchar_t AltCharset[128] = { ['`'] = L'\u25C6', ['a'] = L'\u2592', ['f'] = L'\u00B0', ['g'] = L'\u00B1', ['i'] = L'\u240B', ['j'] = L'\u2518', ['k'] = L'\u2510', ['l'] = L'\u250C', ['m'] = L'\u2514', ['n'] = L'\u253C', ['o'] = L'\u23BA', ['p'] = L'\u23BB', ['q'] = L'\u2500', ['r'] = L'\u23BC', ['s'] = L'\u23BD', ['t'] = L'\u251C', ['u'] = L'\u2524', ['v'] = L'\u2534', ['w'] = L'\u252C', ['x'] = L'\u2502', ['y'] = L'\u2264', ['z'] = L'\u2265', ['{'] = L'\u03C0', ['|'] = L'\u2260', ['}'] = L'\u00A3', ['~'] = L'\u00B7', }; static int pn; static int ps[16]; static wchar_t ch; %} ESC \x1B %x CSI CSI_LT CSI_EQ CSI_GT CSI_QM %x OSC %% pn = 0; {ESC}"[" BEGIN(CSI); {ESC}"[<" BEGIN(CSI_LT); {ESC}"[=" BEGIN(CSI_EQ); {ESC}"[>" BEGIN(CSI_GT); {ESC}"[?" BEGIN(CSI_QM); {ESC}"]" BEGIN(OSC); { [0-9]+;? if (pn < 16) ps[pn++] = atoi(yytext); ; if (pn < 16) ps[pn++] = 0; } { \x07 BEGIN(0); {ESC}\\ BEGIN(0); .|\n ; } \b return BS; \t return HT; \n return NL; \r return CR; {ESC}7 return DECSC; {ESC}8 return DECRC; {ESC}= // DECKPAM {ESC}> // DECKPNM {ESC}M return RI; {ESC}"(0" g0 = DECSpecial; {ESC}"(B" g0 = USASCII; @ BEGIN(0); return ICH; A BEGIN(0); return CUU; B BEGIN(0); return CUD; C BEGIN(0); return CUF; D BEGIN(0); return CUB; E BEGIN(0); return CNL; F BEGIN(0); return CPL; G BEGIN(0); return CHA; H BEGIN(0); return CUP; J BEGIN(0); return ED; K BEGIN(0); return EL; L BEGIN(0); return IL; M BEGIN(0); return DL; P BEGIN(0); return DCH; S BEGIN(0); return SU; T BEGIN(0); return SD; X BEGIN(0); return ECH; d BEGIN(0); return VPA; h BEGIN(0); return SM; i BEGIN(0); return MC; l BEGIN(0); return RM; m BEGIN(0); return SGR; r BEGIN(0); return DECSTBM; t BEGIN(0); // XTWINOPS h BEGIN(0); return DECSET; l BEGIN(0); return DECRST; [ -/]*. BEGIN(0); warnx("unhandled CSI %s", yytext); [ -/]*. BEGIN(0); warnx("unhandled CSI < %s", yytext); [ -/]*. BEGIN(0); warnx("unhandled CSI = %s", yytext); [ -/]*. BEGIN(0); warnx("unhandled CSI > %s", yytext); [ -/]*. BEGIN(0); warnx("unhandled CSI ? %s", yytext); [\x00-\x7F] { ch = yytext[0]; if (g0 == DECSpecial && AltCharset[ch]) { ch = AltCharset[ch]; } return Data; } [\xC0-\xDF][\x80-\xBF] { ch = (wchar_t)(yytext[0] & 0x1F) << 6 | (wchar_t)(yytext[1] & 0x3F); return Data; } [\xE0-\xEF]([\x80-\xBF]{2}) { ch = (wchar_t)(yytext[0] & 0x0F) << 12 | (wchar_t)(yytext[1] & 0x3F) << 6 | (wchar_t)(yytext[2] & 0x3F); return Data; } [\xF0-\xF7]([\x80-\xBF]{3}) { ch = (wchar_t)(yytext[0] & 0x07) << 18 | (wchar_t)(yytext[1] & 0x3F) << 12 | (wchar_t)(yytext[2] & 0x3F) << 6 | (wchar_t)(yytext[3] & 0x3F); return Data; } . ch = yytext[0]; return Data; %% static int rows = 24; static int cols = 80; static struct Cell { enum { BIT(Bold), BIT(Italic), BIT(Underline), BIT(Reverse), } attr; int bg, fg; wchar_t ch; } *cells; static int y, x; static struct { int y, x; } sc; static struct { int top, bot; } scr; static enum Mode { BIT(Insert), BIT(Wrap), BIT(Cursor), } mode = Wrap | Cursor; static struct Cell sgr = { .bg = -1, .fg = -1, .ch = L' ', }; static struct Cell *cell(int y, int x) { assert(y <= rows); assert(x <= cols); assert(y * cols + x <= rows * cols); return &cells[y * cols + x]; } static int p(int i, int d) { return (i < pn ? ps[i] : d); } static int bound(int a, int x, int b) { if (x < a) return a; if (x > b) return b; return x; } static void move(struct Cell *dst, struct Cell *src, size_t len) { memmove(dst, src, sizeof(*dst) * len); } static void erase(struct Cell *at, struct Cell *to) { for (; at < to; ++at) { *at = sgr; } } static void scrup(int top, int n) { n = bound(0, n, scr.bot - top); move(cell(top, 0), cell(top+n, 0), cols * (scr.bot-top-n)); erase(cell(scr.bot-n, 0), cell(scr.bot, 0)); } static void scrdn(int top, int n) { n = bound(0, n, scr.bot - top); move(cell(top+n, 0), cell(top, 0), cols * (scr.bot-top-n)); erase(cell(top, 0), cell(top+n, 0)); } static enum Mode pmode(void) { enum Mode mode = 0; for (int i = 0; i < pn; ++i) { switch (ps[i]) { break; case 4: mode |= Insert; break; default: warnx("unhandled SM/RM %d", ps[i]); } } return mode; } static enum Mode pdmode(void) { enum Mode mode = 0; for (int i = 0; i < pn; ++i) { switch (ps[i]) { break; case 1: // DECCKM break; case 7: mode |= Wrap; break; case 12: // "Start Blinking Cursor" break; case 25: mode |= Cursor; break; default: { if (ps[i] < 1000) warnx("unhandled DECSET/DECRST %d", ps[i]); } } } return mode; } static void update(enum Code cc) { switch (cc) { break; case BS: x--; break; case HT: x = x - x % 8 + 8; break; case CR: x = 0; break; case CUU: y -= p(0, 1); break; case CUD: y += p(0, 1); break; case CUF: x += p(0, 1); break; case CUB: x -= p(0, 1); break; case CNL: x = 0; y += p(0, 1); break; case CPL: x = 0; y -= p(0, 1); break; case CHA: x = p(0, 1) - 1; break; case VPA: y = p(0, 1) - 1; break; case CUP: y = p(0, 1) - 1; x = p(1, 1) - 1; break; case DECSC: sc.y = y; sc.x = x; break; case DECRC: y = sc.y; x = sc.x; break; case ED: erase( (p(0, 0) == 0 ? cell(y, x) : cell(0, 0)), (p(0, 0) == 1 ? cell(y, x) : cell(rows-1, cols)) ); break; case EL: erase( (p(0, 0) == 0 ? cell(y, x) : cell(y, 0)), (p(0, 0) == 1 ? cell(y, x) : cell(y, cols)) ); break; case ECH: erase( cell(y, x), cell(y, bound(0, x + p(0, 1), cols)) ); break; case DCH: { int n = bound(0, p(0, 1), cols-x); move(cell(y, x), cell(y, x+n), cols-x-n); erase(cell(y, cols-n), cell(y, cols)); } break; case ICH: { int n = bound(0, p(0, 1), cols-x); move(cell(y, x+n), cell(y, x), cols-x-n); erase(cell(y, x), cell(y, x+n)); } break; case DECSTBM: { scr.bot = bound(0, p(1, rows), rows); scr.top = bound(0, p(0, 1) - 1, scr.bot); } break; case SU: scrup(scr.top, p(0, 1)); break; case SD: scrdn(scr.top, p(0, 1)); break; case DL: scrup(bound(0, y, scr.bot), p(0, 1)); break; case IL: scrdn(bound(0, y, scr.bot), p(0, 1)); break; case NL: { if (y+1 == scr.bot) { scrup(scr.top, 1); } else { y++; } } break; case RI: { if (y == scr.top) { scrdn(scr.top, 1); } else { y--; } } break; case SM: mode |= pmode(); break; case RM: mode &= ~pmode(); break; case DECSET: mode |= pdmode(); break; case DECRST: mode &= ~pdmode(); break; case SGR: { if (!pn) ps[pn++] = 0; for (int i = 0; i < pn; ++i) { switch (ps[i]) { break; case 0: sgr.attr = 0; sgr.bg = -1; sgr.fg = -1; break; case 1: sgr.attr |= Bold; break; case 3: sgr.attr |= Italic; break; case 4: sgr.attr |= Underline; break; case 7: sgr.attr |= Reverse; break; case 22: sgr.attr &= ~Bold; break; case 23: sgr.attr &= ~Italic; break; case 24: sgr.attr &= ~Underline; break; case 27: sgr.attr &= ~Reverse; break; case 30 ... 37: sgr.fg = ps[i] - 30; break; case 38: { if (++i < pn && ps[i] == 5) { if (++i < pn) sgr.fg = ps[i]; } } break; case 39: sgr.fg = -1; break; case 40 ... 47: sgr.bg = ps[i] - 40; break; case 48: { if (++i < pn && ps[i] == 5) { if (++i < pn) sgr.bg = ps[i]; } } break; case 49: sgr.bg = -1; break; case 90 ... 97: sgr.fg = 8 + ps[i] - 90; break; case 100 ... 107: sgr.bg = 8 + ps[i] - 100; break; default: warnx("unhandled SGR %d", ps[i]); } } } break; case Data: { int w = wcwidth(ch); if (w < 0) { warnx("unhandled \\u%04X", ch); return; } if (mode & Insert) { int n = bound(0, w, cols-x); move(cell(y, x+n), cell(y, x), cols-x-n); } if (mode & Wrap && x+w > cols) { update(CR); update(NL); } *cell(y, x) = sgr; cell(y, x)->ch = ch; for (int i = 1; i < w && x+i < cols; ++i) { *cell(y, x+i) = sgr; cell(y, x+i)->ch = L'\0'; } x = bound(0, x+w, (mode & Wrap ? cols : cols-1)); return; } break; case MC:; } x = bound(0, x, cols-1); y = bound(0, y, rows-1); } static bool bright; static bool colors; static int defaultBg = 0; static int defaultFg = 7; static const unsigned Palette[256] = { 0x000000, 0xCD0000, 0x00CD00, 0xCDCD00, 0x0000EE, 0xCD00CD, 0x00CDCD, 0xE5E5E5, 0x7F7F7F, 0xFF0000, 0x00FF00, 0xFFFF00, 0x5C5CFF, 0xFF00FF, 0x00FFFF, 0xFFFFFF, 0x000000, 0x00005F, 0x000087, 0x0000AF, 0x0000D7, 0x0000FF, 0x005F00, 0x005F5F, 0x005F87, 0x005FAF, 0x005FD7, 0x005FFF, 0x008700, 0x00875F, 0x008787, 0x0087AF, 0x0087D7, 0x0087FF, 0x00AF00, 0x00AF5F, 0x00AF87, 0x00AFAF, 0x00AFD7, 0x00AFFF, 0x00D700, 0x00D75F, 0x00D787, 0x00D7AF, 0x00D7D7, 0x00D7FF, 0x00FF00, 0x00FF5F, 0x00FF87, 0x00FFAF, 0x00FFD7, 0x00FFFF, 0x5F0000, 0x5F005F, 0x5F0087, 0x5F00AF, 0x5F00D7, 0x5F00FF, 0x5F5F00, 0x5F5F5F, 0x5F5F87, 0x5F5FAF, 0x5F5FD7, 0x5F5FFF, 0x5F8700, 0x5F875F, 0x5F8787, 0x5F87AF, 0x5F87D7, 0x5F87FF, 0x5FAF00, 0x5FAF5F, 0x5FAF87, 0x5FAFAF, 0x5FAFD7, 0x5FAFFF, 0x5FD700, 0x5FD75F, 0x5FD787, 0x5FD7AF, 0x5FD7D7, 0x5FD7FF, 0x5FFF00, 0x5FFF5F, 0x5FFF87, 0x5FFFAF, 0x5FFFD7, 0x5FFFFF, 0x870000, 0x87005F, 0x870087, 0x8700AF, 0x8700D7, 0x8700FF, 0x875F00, 0x875F5F, 0x875F87, 0x875FAF, 0x875FD7, 0x875FFF, 0x878700, 0x87875F, 0x878787, 0x8787AF, 0x8787D7, 0x8787FF, 0x87AF00, 0x87AF5F, 0x87AF87, 0x87AFAF, 0x87AFD7, 0x87AFFF, 0x87D700, 0x87D75F, 0x87D787, 0x87D7AF, 0x87D7D7, 0x87D7FF, 0x87FF00, 0x87FF5F, 0x87FF87, 0x87FFAF, 0x87FFD7, 0x87FFFF, 0xAF0000, 0xAF005F, 0xAF0087, 0xAF00AF, 0xAF00D7, 0xAF00FF, 0xAF5F00, 0xAF5F5F, 0xAF5F87, 0xAF5FAF, 0xAF5FD7, 0xAF5FFF, 0xAF8700, 0xAF875F, 0xAF8787, 0xAF87AF, 0xAF87D7, 0xAF87FF, 0xAFAF00, 0xAFAF5F, 0xAFAF87, 0xAFAFAF, 0xAFAFD7, 0xAFAFFF, 0xAFD700, 0xAFD75F, 0xAFD787, 0xAFD7AF, 0xAFD7D7, 0xAFD7FF, 0xAFFF00, 0xAFFF5F, 0xAFFF87, 0xAFFFAF, 0xAFFFD7, 0xAFFFFF, 0xD70000, 0xD7005F, 0xD70087, 0xD700AF, 0xD700D7, 0xD700FF, 0xD75F00, 0xD75F5F, 0xD75F87, 0xD75FAF, 0xD75FD7, 0xD75FFF, 0xD78700, 0xD7875F, 0xD78787, 0xD787AF, 0xD787D7, 0xD787FF, 0xD7AF00, 0xD7AF5F, 0xD7AF87, 0xD7AFAF, 0xD7AFD7, 0xD7AFFF, 0xD7D700, 0xD7D75F, 0xD7D787, 0xD7D7AF, 0xD7D7D7, 0xD7D7FF, 0xD7FF00, 0xD7FF5F, 0xD7FF87, 0xD7FFAF, 0xD7FFD7, 0xD7FFFF, 0xFF0000, 0xFF005F, 0xFF0087, 0xFF00AF, 0xFF00D7, 0xFF00FF, 0xFF5F00, 0xFF5F5F, 0xFF5F87, 0xFF5FAF, 0xFF5FD7, 0xFF5FFF, 0xFF8700, 0xFF875F, 0xFF8787, 0xFF87AF, 0xFF87D7, 0xFF87FF, 0xFFAF00, 0xFFAF5F, 0xFFAF87, 0xFFAFAF, 0xFFAFD7, 0xFFAFFF, 0xFFD700, 0xFFD75F, 0xFFD787, 0xFFD7AF, 0xFFD7D7, 0xFFD7FF, 0xFFFF00, 0xFFFF5F, 0xFFFF87, 0xFFFFAF, 0xFFFFD7, 0xFFFFFF, 0x080808, 0x121212, 0x1C1C1C, 0x262626, 0x303030, 0x3A3A3A, 0x444444, 0x4E4E4E, 0x585858, 0x626262, 0x6C6C6C, 0x767676, 0x808080, 0x8A8A8A, 0x949494, 0x9E9E9E, 0xA8A8A8, 0xB2B2B2, 0xBCBCBC, 0xC6C6C6, 0xD0D0D0, 0xDADADA, 0xE4E4E4, 0xEEEEEE, }; static void span(const struct Cell *prev, const struct Cell *cell) { if ( !prev || cell->attr != prev->attr || cell->bg != prev->bg || cell->fg != prev->fg ) { if (prev) printf(""); int attr = cell->attr; int bg = (attr & Reverse ? cell->fg : cell->bg); int fg = (attr & Reverse ? cell->bg : cell->fg); if (bg < 0) bg = (attr & Reverse ? defaultFg : defaultBg); if (fg < 0) fg = (attr & Reverse ? defaultBg : defaultFg); if (bright && cell->attr & Bold) { if (fg < 8) fg += 8; attr &= ~Bold; } printf(Q(", (attr || colors ? "\"" : "")); } switch (cell->ch) { break; case L'&': printf("&"); break; case L'<': printf("<"); break; case L'>': printf(">"); break; case L'"': printf("""); break; default: printf("%lc", (wint_t)cell->ch); } } static void html(void) { if (mode & Cursor) cell(y, x)->attr ^= Reverse; printf( Q(
),
		cols, defaultBg, defaultFg
	);
	for (int y = 0; y < rows; ++y) {
		for (int x = 0; x < cols; ++x) {
			if (!cell(y, x)->ch) continue;
			span((x ? cell(y, x-1) : NULL), cell(y, x));
		}
		printf("\n");
	}
	printf("
\n"); if (mode & Cursor) cell(y, x)->attr ^= Reverse; } static const char *Debug[] = { #define X(code) [code] = #code, ENUM_CODE #undef X }; int main(int argc, char *argv[]) { setlocale(LC_CTYPE, ""); bool debug = false; bool size = false; bool hide = false; for (int opt; 0 < (opt = getopt(argc, argv, "Bb:df:h:insw:"));) { switch (opt) { break; case 'B': bright = true; break; case 'b': defaultBg = atoi(optarg); break; case 'd': debug = true; break; case 'f': defaultFg = atoi(optarg); break; case 'h': rows = atoi(optarg); break; case 'i': colors = true; break; case 'n': hide = true; break; case 's': size = true; break; case 'w': cols = atoi(optarg); break; default: return 1; } } if (optind < argc) { yyin = fopen(argv[optind], "r"); if (!yyin) err(1, "%s", argv[optind]); } if (size) { struct winsize win; int error = ioctl(STDERR_FILENO, TIOCGWINSZ, &win); if (error) err(1, "ioctl"); cols = win.ws_col; rows = win.ws_row; } scr.bot = rows; cells = calloc(cols * rows, sizeof(*cells)); if (!cells) err(1, "calloc"); erase(cell(0, 0), cell(rows-1, cols)); bool mc = false; for (int cc; (cc = yylex());) { if (cc == MC) { mc = true; html(); } else { update(cc); } if (debug && cc != Data) { printf("%s", Debug[cc]); for (int i = 0; i < pn; ++i) { printf("%s%d", (i ? ", " : " "), ps[i]); } printf("\n"); html(); } } if (hide) mode &= ~Cursor; if (!mc) html(); }