isocline-1.0.1: src/term.c
/* ----------------------------------------------------------------------------
Copyright (c) 2021, Daan Leijen
This is free software; you can redistribute it and/or modify it
under the terms of the MIT License. A copy of the license can be
found in the "LICENSE" file at the root of this distribution.
-----------------------------------------------------------------------------*/
#include <string.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h> // getenv
#include <inttypes.h>
#include "common.h"
#include "tty.h"
#include "term.h"
#include "stringbuf.h" // str_next_ofs
#if defined(_WIN32)
#include <windows.h>
#define STDOUT_FILENO 1
#else
#include <unistd.h>
#include <errno.h>
#include <sys/ioctl.h>
#if defined(__linux__)
#include <linux/kd.h>
#endif
#endif
#define IC_CSI "\x1B["
// color support; colors are auto mapped smaller palettes if needed. (see `term_color.c`)
typedef enum palette_e {
MONOCHROME, // no color
ANSI8, // only basic 8 ANSI color (ESC[<idx>m, idx: 30-37, +10 for background)
ANSI16, // basic + bright ANSI colors (ESC[<idx>m, idx: 30-37, 90-97, +10 for background)
ANSI256, // ANSI 256 color palette (ESC[38;5;<idx>m, idx: 0-15 standard color, 16-231 6x6x6 rbg colors, 232-255 gray shades)
ANSIRGB // direct rgb colors supported (ESC[38;2;<r>;<g>;<b>m)
} palette_t;
// The terminal screen
struct term_s {
int fd_out; // output handle
ssize_t width; // screen column width
ssize_t height; // screen row height
ssize_t raw_enabled; // is raw mode active? counted by start/end pairs
bool nocolor; // show colors?
bool silent; // enable beep?
bool is_utf8; // utf-8 output? determined by the tty
attr_t attr; // current text attributes
palette_t palette; // color support
buffer_mode_t bufmode; // buffer mode
stringbuf_t* buf; // buffer for buffered output
tty_t* tty; // used on posix to get the cursor position
alloc_t* mem; // allocator
#ifdef _WIN32
HANDLE hcon; // output console handler
WORD hcon_default_attr; // default text attributes
WORD hcon_orig_attr; // original text attributes
DWORD hcon_orig_mode; // original console mode
DWORD hcon_mode; // used console mode
UINT hcon_orig_cp; // original console code-page (locale)
COORD hcon_save_cursor; // saved cursor position (for escape sequence emulation)
#endif
};
static bool term_write_direct(term_t* term, const char* s, ssize_t n );
static void term_append_buf(term_t* term, const char* s, ssize_t n);
//-------------------------------------------------------------
// Colors
//-------------------------------------------------------------
#include "term_color.c"
//-------------------------------------------------------------
// Helpers
//-------------------------------------------------------------
ic_private void term_left(term_t* term, ssize_t n) {
if (n <= 0) return;
term_writef( term, IC_CSI "%zdD", n );
}
ic_private void term_right(term_t* term, ssize_t n) {
if (n <= 0) return;
term_writef( term, IC_CSI "%zdC", n );
}
ic_private void term_up(term_t* term, ssize_t n) {
if (n <= 0) return;
term_writef( term, IC_CSI "%zdA", n );
}
ic_private void term_down(term_t* term, ssize_t n) {
if (n <= 0) return;
term_writef( term, IC_CSI "%zdB", n );
}
ic_private void term_clear_line(term_t* term) {
term_write( term, "\r" IC_CSI "K");
}
ic_private void term_clear_to_end_of_line(term_t* term) {
term_write(term, IC_CSI "K");
}
ic_private void term_start_of_line(term_t* term) {
term_write( term, "\r" );
}
ic_private ssize_t term_get_width(term_t* term) {
return term->width;
}
ic_private ssize_t term_get_height(term_t* term) {
return term->height;
}
ic_private void term_attr_reset(term_t* term) {
term_write(term, IC_CSI "m" );
}
ic_private void term_underline(term_t* term, bool on) {
term_write(term, on ? IC_CSI "4m" : IC_CSI "24m" );
}
ic_private void term_reverse(term_t* term, bool on) {
term_write(term, on ? IC_CSI "7m" : IC_CSI "27m");
}
ic_private void term_bold(term_t* term, bool on) {
term_write(term, on ? IC_CSI "1m" : IC_CSI "22m" );
}
ic_private void term_italic(term_t* term, bool on) {
term_write(term, on ? IC_CSI "3m" : IC_CSI "23m" );
}
ic_private void term_writeln(term_t* term, const char* s) {
term_write(term,s);
term_write(term,"\n");
}
ic_private void term_write_char(term_t* term, char c) {
char buf[2];
buf[0] = c;
buf[1] = 0;
term_write_n(term, buf, 1 );
}
ic_private attr_t term_get_attr( const term_t* term ) {
return term->attr;
}
ic_private void term_set_attr( term_t* term, attr_t attr ) {
if (attr.x.color != term->attr.x.color && attr.x.color != IC_COLOR_NONE) {
term_color(term,attr.x.color);
if (term->palette < ANSIRGB && color_is_rgb(attr.x.color)) {
term->attr.x.color = attr.x.color; // actual color may have been approximated but we keep the actual color to avoid updating every time
}
}
if (attr.x.bgcolor != term->attr.x.bgcolor && attr.x.bgcolor != IC_COLOR_NONE) {
term_bgcolor(term,attr.x.bgcolor);
if (term->palette < ANSIRGB && color_is_rgb(attr.x.bgcolor)) {
term->attr.x.bgcolor = attr.x.bgcolor;
}
}
if (attr.x.bold != term->attr.x.bold && attr.x.bold != IC_NONE) {
term_bold(term,attr.x.bold == IC_ON);
}
if (attr.x.underline != term->attr.x.underline && attr.x.underline != IC_NONE) {
term_underline(term,attr.x.underline == IC_ON);
}
if (attr.x.reverse != term->attr.x.reverse && attr.x.reverse != IC_NONE) {
term_reverse(term,attr.x.reverse == IC_ON);
}
if (attr.x.italic != term->attr.x.italic && attr.x.italic != IC_NONE) {
term_italic(term,attr.x.italic == IC_ON);
}
assert(attr.x.color == term->attr.x.color || attr.x.color == IC_COLOR_NONE);
assert(attr.x.bgcolor == term->attr.x.bgcolor || attr.x.bgcolor == IC_COLOR_NONE);
assert(attr.x.bold == term->attr.x.bold || attr.x.bold == IC_NONE);
assert(attr.x.reverse == term->attr.x.reverse || attr.x.reverse == IC_NONE);
assert(attr.x.underline == term->attr.x.underline || attr.x.underline == IC_NONE);
assert(attr.x.italic == term->attr.x.italic || attr.x.italic == IC_NONE);
}
/*
ic_private void term_clear_lines_to_end(term_t* term) {
term_write(term, "\r" IC_CSI "J");
}
ic_private void term_show_cursor(term_t* term, bool on) {
term_write(term, on ? IC_CSI "?25h" : IC_CSI "?25l");
}
*/
//-------------------------------------------------------------
// Formatted output
//-------------------------------------------------------------
ic_private void term_writef(term_t* term, const char* fmt, ...) {
va_list ap;
va_start(ap, fmt);
term_vwritef(term,fmt,ap);
va_end(ap);
}
ic_private void term_vwritef(term_t* term, const char* fmt, va_list args ) {
sbuf_append_vprintf(term->buf, fmt, args);
}
ic_private void term_write_formatted( term_t* term, const char* s, const attr_t* attrs ) {
term_write_formatted_n( term, s, attrs, ic_strlen(s));
}
ic_private void term_write_formatted_n( term_t* term, const char* s, const attr_t* attrs, ssize_t len ) {
if (attrs == NULL) {
// write directly
term_write(term,s);
}
else {
// ensure raw mode from now on
if (term->raw_enabled <= 0) {
term_start_raw(term);
}
// and output with text attributes
const attr_t default_attr = term_get_attr(term);
attr_t attr = attr_none();
ssize_t i = 0;
ssize_t n = 0;
while( i+n < len && s[i+n] != 0 ) {
if (!attr_is_eq(attr,attrs[i+n])) {
if (n > 0) {
term_write_n( term, s+i, n );
i += n;
n = 0;
}
attr = attrs[i];
term_set_attr( term, attr_update_with(default_attr,attr) );
}
n++;
}
if (n > 0) {
term_write_n( term, s+i, n );
i += n;
n = 0;
}
assert(s[i] != 0 || i == len);
term_set_attr(term, default_attr);
}
}
//-------------------------------------------------------------
// Write to the terminal
// The buffered functions are used to reduce cursor flicker
// during refresh
//-------------------------------------------------------------
ic_private void term_beep(term_t* term) {
if (term->silent) return;
fprintf(stderr,"\x7");
fflush(stderr);
}
ic_private void term_write_repeat(term_t* term, const char* s, ssize_t count) {
for (; count > 0; count--) {
term_write(term, s);
}
}
ic_private void term_write(term_t* term, const char* s) {
if (s == NULL || s[0] == 0) return;
ssize_t n = ic_strlen(s);
term_write_n(term,s,n);
}
// Primitive terminal write; all writes go through here
ic_private void term_write_n(term_t* term, const char* s, ssize_t n) {
if (s == NULL || n <= 0) return;
// write to buffer to reduce flicker and to process escape sequences (this may flush too)
term_append_buf(term, s, n);
}
//-------------------------------------------------------------
// Buffering
//-------------------------------------------------------------
ic_private void term_flush(term_t* term) {
if (sbuf_len(term->buf) > 0) {
//term_show_cursor(term,false);
term_write_direct(term, sbuf_string(term->buf), sbuf_len(term->buf));
//term_show_cursor(term,true);
sbuf_clear(term->buf);
}
}
ic_private buffer_mode_t term_set_buffer_mode(term_t* term, buffer_mode_t mode) {
buffer_mode_t oldmode = term->bufmode;
if (oldmode != mode) {
if (mode == UNBUFFERED) {
term_flush(term);
}
term->bufmode = mode;
}
return oldmode;
}
static void term_check_flush(term_t* term, bool contains_nl) {
if (term->bufmode == UNBUFFERED ||
sbuf_len(term->buf) > 4000 ||
(term->bufmode == LINEBUFFERED && contains_nl))
{
term_flush(term);
}
}
//-------------------------------------------------------------
// Init
//-------------------------------------------------------------
static void term_init_raw(term_t* term);
ic_private term_t* term_new(alloc_t* mem, tty_t* tty, bool nocolor, bool silent, int fd_out )
{
term_t* term = mem_zalloc_tp(mem, term_t);
if (term == NULL) return NULL;
term->fd_out = (fd_out < 0 ? STDOUT_FILENO : fd_out);
term->nocolor = nocolor;
term->silent = silent;
term->mem = mem;
term->tty = tty;
term->width = 80;
term->height = 25;
term->is_utf8 = tty_is_utf8(tty);
term->palette = ANSI16; // almost universally supported
term->buf = sbuf_new(mem);
term->bufmode = LINEBUFFERED;
term->attr = attr_default();
// respect NO_COLOR
if (getenv("NO_COLOR") != NULL) {
term->nocolor = true;
}
// detect color palette
// COLORTERM takes precedence
const char* colorterm = getenv("COLORTERM");
if (ic_contains(colorterm,"24bit") || ic_contains(colorterm,"truecolor") || ic_contains(colorterm,"direct")) {
term->palette = ANSIRGB;
}
else if (ic_contains(colorterm,"8bit") || ic_contains(colorterm,"256color")) { term->palette = ANSI256; }
else if (ic_contains(colorterm,"4bit") || ic_contains(colorterm,"16color")) { term->palette = ANSI16; }
else if (ic_contains(colorterm,"3bit") || ic_contains(colorterm,"8color")) { term->palette = ANSI8; }
else if (ic_contains(colorterm,"1bit") || ic_contains(colorterm,"nocolor") || ic_contains(colorterm,"monochrome")) {
term->palette = MONOCHROME;
}
// otherwise check for some specific terminals
else if (getenv("WT_SESSION") != NULL) { term->palette = ANSIRGB; } // Windows terminal
else if (getenv("ITERM_SESSION_ID") != NULL) { term->palette = ANSIRGB; } // iTerm2 terminal
else if (getenv("VSCODE_PID") != NULL) { term->palette = ANSIRGB; } // vscode terminal
else {
// and otherwise fall back to checking TERM
const char* eterm = getenv("TERM");
if (ic_contains(eterm,"truecolor") || ic_contains(eterm,"direct") || ic_contains(colorterm,"24bit")) {
term->palette = ANSIRGB;
}
else if (ic_contains(eterm,"alacritty") || ic_contains(eterm,"kitty")) {
term->palette = ANSIRGB;
}
else if (ic_contains(eterm,"256color") || ic_contains(eterm,"gnome")) {
term->palette = ANSI256;
}
else if (ic_contains(eterm,"16color")){ term->palette = ANSI16; }
else if (ic_contains(eterm,"8color")) { term->palette = ANSI8; }
else if (ic_contains(eterm,"monochrome") || ic_contains(eterm,"nocolor") || ic_contains(eterm,"dumb")) {
term->palette = MONOCHROME;
}
}
debug_msg("term: color-bits: %d (COLORTERM=%s, TERM=%s)\n", term_get_color_bits(term), colorterm, term);
// read COLUMS/LINES from the environment for a better initial guess.
const char* env_columns = getenv("COLUMNS");
if (env_columns != NULL) { ic_atoz(env_columns, &term->width); }
const char* env_lines = getenv("LINES");
if (env_lines != NULL) { ic_atoz(env_lines, &term->height); }
// initialize raw terminal output and terminal dimensions
term_init_raw(term);
term_update_dim(term);
term_attr_reset(term); // ensure we are at default settings
return term;
}
ic_private bool term_is_interactive(const term_t* term) {
ic_unused(term);
// check dimensions (0 is used for debuggers)
// if (term->width <= 0) return false;
// check editing support
const char* eterm = getenv("TERM");
debug_msg("term: TERM=%s\n", eterm);
if (eterm != NULL &&
(strstr("dumb|DUMB|cons25|CONS25|emacs|EMACS",eterm) != NULL)) {
return false;
}
return true;
}
ic_private bool term_enable_beep(term_t* term, bool enable) {
bool prev = term->silent;
term->silent = !enable;
return prev;
}
ic_private bool term_enable_color(term_t* term, bool enable) {
bool prev = !term->nocolor;
term->nocolor = !enable;
return prev;
}
ic_private void term_free(term_t* term) {
if (term == NULL) return;
term_flush(term);
term_end_raw(term, true);
sbuf_free(term->buf); term->buf = NULL;
mem_free(term->mem, term);
}
//-------------------------------------------------------------
// For best portability and applications inserting CSI SGR (ESC[ .. m)
// codes themselves in strings, we interpret these at the
// lowest level so we can have a `term_get_attr` function which
// is needed for bracketed styles etc.
//-------------------------------------------------------------
static void term_append_esc(term_t* term, const char* const s, ssize_t len) {
if (s[1]=='[' && s[len-1] == 'm') {
// it is a CSI SGR sequence: ESC[ ... m
if (term->nocolor) return; // ignore escape sequences if nocolor is set
term->attr = attr_update_with(term->attr, attr_from_esc_sgr(s,len));
}
// and write out the escape sequence as-is
sbuf_append_n(term->buf, s, len);
}
static void term_append_utf8(term_t* term, const char* s, ssize_t len) {
ssize_t nread;
unicode_t uchr = unicode_from_qutf8((const uint8_t*)s, len, &nread);
uint8_t c;
if (unicode_is_raw(uchr, &c)) {
// write bytes as is; this also ensure that on non-utf8 terminals characters between 0x80-0xFF
// go through _as is_ due to the qutf8 encoding.
sbuf_append_char(term->buf,(char)c);
}
else if (!term->is_utf8) {
// on non-utf8 terminals still send utf-8 and hope for the best
// todo: we could try to convert to the locale first?
sbuf_append_n(term->buf, s, len);
// sbuf_appendf(term->buf, "\x1B[%" PRIu32 "u", uchr); // unicode escape code
}
else {
// write utf-8 as is
sbuf_append_n(term->buf, s, len);
}
}
static void term_append_buf( term_t* term, const char* s, ssize_t len ) {
ssize_t pos = 0;
bool newline = false;
while (pos < len) {
// handle ascii sequences in bulk
ssize_t ascii = 0;
ssize_t next;
while ((next = str_next_ofs(s, len, pos+ascii, NULL)) > 0 &&
(uint8_t)s[pos + ascii] > '\x1B' && (uint8_t)s[pos + ascii] <= 0x7F )
{
ascii += next;
}
if (ascii > 0) {
sbuf_append_n(term->buf, s+pos, ascii);
pos += ascii;
}
if (next <= 0) break;
const uint8_t c = (uint8_t)s[pos];
// handle utf8 sequences (for non-utf8 terminals)
if (c >= 0x80) {
term_append_utf8(term, s+pos, next);
}
// handle escape sequence (note: str_next_ofs considers whole CSI escape sequences at a time)
else if (next > 1 && c == '\x1B') {
term_append_esc(term, s+pos, next);
}
else if (c < ' ' && c != 0 && (c < '\x07' || c > '\x0D')) {
// ignore control characters except \a, \b, \t, \n, \r, and form-feed and vertical tab.
}
else {
if (c == '\n') { newline = true; }
sbuf_append_n(term->buf, s+pos, next);
}
pos += next;
}
// possibly flush
term_check_flush(term, newline);
}
//-------------------------------------------------------------
// Platform dependent: Write directly to the terminal
//-------------------------------------------------------------
#if !defined(_WIN32)
// write to the console without further processing
static bool term_write_direct(term_t* term, const char* s, ssize_t n) {
ssize_t count = 0;
while( count < n ) {
ssize_t nwritten = write(term->fd_out, s + count, to_size_t(n - count));
if (nwritten > 0) {
count += nwritten;
}
else if (errno != EINTR && errno != EAGAIN) {
debug_msg("term: write failed: length %i, errno %i: \"%s\"\n", n, errno, s);
return false;
}
}
return true;
}
#else
//----------------------------------------------------------------------------------
// On windows we use the new virtual terminal processing if it is available (Windows Terminal)
// but fall back to ansi escape emulation on older systems but also for example
// the PS terminal
//
// note: we use row/col as 1-based ANSI escape while windows X/Y coords are 0-based.
//-----------------------------------------------------------------------------------
#if !defined(ENABLE_VIRTUAL_TERMINAL_PROCESSING)
#define ENABLE_VIRTUAL_TERMINAL_PROCESSING (0)
#endif
#if !defined(ENABLE_LVB_GRID_WORLDWIDE)
#define ENABLE_LVB_GRID_WORLDWIDE (0)
#endif
// direct write to the console without further processing
static bool term_write_console(term_t* term, const char* s, ssize_t n ) {
DWORD written;
WriteConsoleA(term->hcon, s, (DWORD)(to_size_t(n)), &written, NULL);
return (written == (DWORD)(to_size_t(n)));
}
static bool term_get_cursor_pos( term_t* term, ssize_t* row, ssize_t* col) {
*row = 0;
*col = 0;
CONSOLE_SCREEN_BUFFER_INFO info;
if (!GetConsoleScreenBufferInfo(term->hcon, &info)) return false;
*row = (ssize_t)info.dwCursorPosition.Y + 1;
*col = (ssize_t)info.dwCursorPosition.X + 1;
return true;
}
static void term_move_cursor_to( term_t* term, ssize_t row, ssize_t col ) {
CONSOLE_SCREEN_BUFFER_INFO info;
if (!GetConsoleScreenBufferInfo( term->hcon, &info )) return;
if (col > info.dwSize.X) col = info.dwSize.X;
if (row > info.dwSize.Y) row = info.dwSize.Y;
if (col <= 0) col = 1;
if (row <= 0) row = 1;
COORD coord;
coord.X = (SHORT)col - 1;
coord.Y = (SHORT)row - 1;
SetConsoleCursorPosition( term->hcon, coord);
}
static void term_cursor_save(term_t* term) {
memset(&term->hcon_save_cursor, 0, sizeof(term->hcon_save_cursor));
CONSOLE_SCREEN_BUFFER_INFO info;
if (!GetConsoleScreenBufferInfo(term->hcon, &info)) return;
term->hcon_save_cursor = info.dwCursorPosition;
}
static void term_cursor_restore(term_t* term) {
if (term->hcon_save_cursor.X == 0) return;
SetConsoleCursorPosition(term->hcon, term->hcon_save_cursor);
}
static void term_move_cursor( term_t* term, ssize_t drow, ssize_t dcol, ssize_t n ) {
CONSOLE_SCREEN_BUFFER_INFO info;
if (!GetConsoleScreenBufferInfo( term->hcon, &info )) return;
COORD cur = info.dwCursorPosition;
ssize_t col = (ssize_t)cur.X + 1 + n*dcol;
ssize_t row = (ssize_t)cur.Y + 1 + n*drow;
term_move_cursor_to( term, row, col );
}
static void term_cursor_visible( term_t* term, bool visible ) {
CONSOLE_CURSOR_INFO info;
if (!GetConsoleCursorInfo(term->hcon,&info)) return;
info.bVisible = visible;
SetConsoleCursorInfo(term->hcon,&info);
}
static void term_erase_line( term_t* term, ssize_t mode ) {
CONSOLE_SCREEN_BUFFER_INFO info;
if (!GetConsoleScreenBufferInfo( term->hcon, &info )) return;
DWORD written;
COORD start;
ssize_t length;
if (mode == 2) {
// entire line
start.X = 0;
start.Y = info.dwCursorPosition.Y;
length = (ssize_t)info.srWindow.Right + 1;
}
else if (mode == 1) {
// to start of line
start.X = 0;
start.Y = info.dwCursorPosition.Y;
length = info.dwCursorPosition.X;
}
else {
// to end of line
length = (ssize_t)info.srWindow.Right - info.dwCursorPosition.X + 1;
start = info.dwCursorPosition;
}
FillConsoleOutputAttribute( term->hcon, term->hcon_default_attr, (DWORD)length, start, &written );
FillConsoleOutputCharacterA( term->hcon, ' ', (DWORD)length, start, &written );
}
static void term_clear_screen(term_t* term, ssize_t mode) {
CONSOLE_SCREEN_BUFFER_INFO info;
if (!GetConsoleScreenBufferInfo(term->hcon, &info)) return;
COORD start;
start.X = 0;
start.Y = 0;
ssize_t length;
ssize_t width = (ssize_t)info.dwSize.X;
if (mode == 2) {
// entire screen
length = width * info.dwSize.Y;
}
else if (mode == 1) {
// to cursor
length = (width * ((ssize_t)info.dwCursorPosition.Y - 1)) + info.dwCursorPosition.X;
}
else {
// from cursor
start = info.dwCursorPosition;
length = (width * ((ssize_t)info.dwSize.Y - info.dwCursorPosition.Y)) + (width - info.dwCursorPosition.X + 1);
}
DWORD written;
FillConsoleOutputAttribute(term->hcon, term->hcon_default_attr, (DWORD)length, start, &written);
FillConsoleOutputCharacterA(term->hcon, ' ', (DWORD)length, start, &written);
}
static WORD attr_color[8] = {
0, // black
FOREGROUND_RED, // maroon
FOREGROUND_GREEN, // green
FOREGROUND_RED | FOREGROUND_GREEN, // orange
FOREGROUND_BLUE, // navy
FOREGROUND_RED | FOREGROUND_BLUE, // purple
FOREGROUND_GREEN | FOREGROUND_BLUE, // teal
FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE, // light gray
};
static void term_set_win_attr( term_t* term, attr_t ta ) {
WORD def_attr = term->hcon_default_attr;
CONSOLE_SCREEN_BUFFER_INFO info;
if (!GetConsoleScreenBufferInfo( term->hcon, &info )) return;
WORD cur_attr = info.wAttributes;
WORD attr = cur_attr;
if (ta.x.color != IC_COLOR_NONE) {
if (ta.x.color >= IC_ANSI_BLACK && ta.x.color <= IC_ANSI_SILVER) {
attr = (attr & 0xFFF0) | attr_color[ta.x.color - IC_ANSI_BLACK];
}
else if (ta.x.color >= IC_ANSI_GRAY && ta.x.color <= IC_ANSI_WHITE) {
attr = (attr & 0xFFF0) | attr_color[ta.x.color - IC_ANSI_GRAY] | FOREGROUND_INTENSITY;
}
else if (ta.x.color == IC_ANSI_DEFAULT) {
attr = (attr & 0xFFF0) | (def_attr & 0x000F);
}
}
if (ta.x.bgcolor != IC_COLOR_NONE) {
if (ta.x.bgcolor >= IC_ANSI_BLACK && ta.x.bgcolor <= IC_ANSI_SILVER) {
attr = (attr & 0xFF0F) | (WORD)(attr_color[ta.x.bgcolor - IC_ANSI_BLACK] << 4);
}
else if (ta.x.bgcolor >= IC_ANSI_GRAY && ta.x.bgcolor <= IC_ANSI_WHITE) {
attr = (attr & 0xFF0F) | (WORD)(attr_color[ta.x.bgcolor - IC_ANSI_GRAY] << 4) | BACKGROUND_INTENSITY;
}
else if (ta.x.bgcolor == IC_ANSI_DEFAULT) {
attr = (attr & 0xFF0F) | (def_attr & 0x00F0);
}
}
if (ta.x.underline != IC_NONE) {
attr = (attr & ~COMMON_LVB_UNDERSCORE) | (ta.x.underline == IC_ON ? COMMON_LVB_UNDERSCORE : 0);
}
if (ta.x.reverse != IC_NONE) {
attr = (attr & ~COMMON_LVB_REVERSE_VIDEO) | (ta.x.reverse == IC_ON ? COMMON_LVB_REVERSE_VIDEO : 0);
}
if (attr != cur_attr) {
SetConsoleTextAttribute(term->hcon, attr);
}
}
static ssize_t esc_param( const char* s, ssize_t def ) {
if (*s == '?') s++;
ssize_t n = def;
ic_atoz(s, &n);
return n;
}
static void esc_param2( const char* s, ssize_t* p1, ssize_t* p2, ssize_t def ) {
if (*s == '?') s++;
*p1 = def;
*p2 = def;
ic_atoz2(s, p1, p2);
}
// Emulate escape sequences on older windows.
static void term_write_esc( term_t* term, const char* s, ssize_t len ) {
ssize_t row;
ssize_t col;
if (s[1] == '[') {
switch (s[len-1]) {
case 'A':
term_move_cursor(term, -1, 0, esc_param(s+2, 1));
break;
case 'B':
term_move_cursor(term, 1, 0, esc_param(s+2, 1));
break;
case 'C':
term_move_cursor(term, 0, 1, esc_param(s+2, 1));
break;
case 'D':
term_move_cursor(term, 0, -1, esc_param(s+2, 1));
break;
case 'H':
esc_param2(s+2, &row, &col, 1);
term_move_cursor_to(term, row, col);
break;
case 'K':
term_erase_line(term, esc_param(s+2, 0));
break;
case 'm':
term_set_win_attr( term, attr_from_esc_sgr(s,len) );
break;
// support some less standard escape codes (currently not used by isocline)
case 'E': // line down
term_get_cursor_pos(term, &row, &col);
row += esc_param(s+2, 1);
term_move_cursor_to(term, row, 1);
break;
case 'F': // line up
term_get_cursor_pos(term, &row, &col);
row -= esc_param(s+2, 1);
term_move_cursor_to(term, row, 1);
break;
case 'G': // absolute column
term_get_cursor_pos(term, &row, &col);
col = esc_param(s+2, 1);
term_move_cursor_to(term, row, col);
break;
case 'J':
term_clear_screen(term, esc_param(s+2, 0));
break;
case 'h':
if (strncmp(s+2, "?25h", 4) == 0) {
term_cursor_visible(term, true);
}
break;
case 'l':
if (strncmp(s+2, "?25l", 4) == 0) {
term_cursor_visible(term, false);
}
break;
case 's':
term_cursor_save(term);
break;
case 'u':
term_cursor_restore(term);
break;
// otherwise ignore
}
}
else if (s[1] == '7') {
term_cursor_save(term);
}
else if (s[1] == '8') {
term_cursor_restore(term);
}
else {
// otherwise ignore
}
}
static bool term_write_direct(term_t* term, const char* s, ssize_t len ) {
term_cursor_visible(term,false); // reduce flicker
ssize_t pos = 0;
if ((term->hcon_mode & ENABLE_VIRTUAL_TERMINAL_PROCESSING) != 0) {
// use the builtin virtual terminal processing. (enables truecolor for example)
term_write_console(term, s, len);
pos = len;
}
else {
// emulate escape sequences
while( pos < len ) {
// handle non-control in bulk (including utf-8 sequences)
// (We don't need to handle utf-8 separately as we set the codepage to always be in utf-8 mode)
ssize_t nonctrl = 0;
ssize_t next;
while( (next = str_next_ofs( s, len, pos+nonctrl, NULL )) > 0 &&
(uint8_t)s[pos + nonctrl] >= ' ' && (uint8_t)s[pos + nonctrl] <= 0x7F) {
nonctrl += next;
}
if (nonctrl > 0) {
term_write_console(term, s+pos, nonctrl);
pos += nonctrl;
}
if (next <= 0) break;
if ((uint8_t)s[pos] >= 0x80) {
// utf8 is already processed
term_write_console(term, s+pos, next);
}
else if (next > 1 && s[pos] == '\x1B') {
// handle control (note: str_next_ofs considers whole CSI escape sequences at a time)
term_write_esc(term, s+pos, next);
}
else if (next == 1 && (s[pos] == '\r' || s[pos] == '\n' || s[pos] == '\t' || s[pos] == '\b')) {
term_write_console( term, s+pos, next);
}
else {
// ignore
}
pos += next;
}
}
term_cursor_visible(term,true);
assert(pos == len);
return (pos == len);
}
#endif
//-------------------------------------------------------------
// Update terminal dimensions
//-------------------------------------------------------------
#if !defined(_WIN32)
// send escape query that may return a response on the tty
static bool term_esc_query_raw( term_t* term, const char* query, char* buf, ssize_t buflen )
{
if (buf==NULL || buflen <= 0 || query[0] == 0) return false;
bool osc = (query[1] == ']');
if (!term_write_direct(term, query, ic_strlen(query))) return false;
debug_msg("term: read tty query response to: ESC %s\n", query + 1);
return tty_read_esc_response( term->tty, query[1], osc, buf, buflen );
}
static bool term_esc_query( term_t* term, const char* query, char* buf, ssize_t buflen )
{
if (!tty_start_raw(term->tty)) return false;
bool ok = term_esc_query_raw(term,query,buf,buflen);
tty_end_raw(term->tty);
return ok;
}
// get the cursor position via an ESC[6n
static bool term_get_cursor_pos( term_t* term, ssize_t* row, ssize_t* col)
{
// send escape query
char buf[128];
if (!term_esc_query(term,"\x1B[6n",buf,128)) return false;
if (!ic_atoz2(buf,row,col)) return false;
return true;
}
static void term_set_cursor_pos( term_t* term, ssize_t row, ssize_t col ) {
term_writef( term, IC_CSI "%zd;%zdH", row, col );
}
ic_private bool term_update_dim(term_t* term) {
ssize_t cols = 0;
ssize_t rows = 0;
struct winsize ws;
if (ioctl(term->fd_out, TIOCGWINSZ, &ws) >= 0) {
// ioctl succeeded
cols = ws.ws_col; // debuggers return 0 for the column
rows = ws.ws_row;
}
else {
// determine width by querying the cursor position
debug_msg("term: ioctl term-size failed: %d,%d\n", ws.ws_row, ws.ws_col);
ssize_t col0 = 0;
ssize_t row0 = 0;
if (term_get_cursor_pos(term,&row0,&col0)) {
term_set_cursor_pos(term,999,999);
ssize_t col1 = 0;
ssize_t row1 = 0;
if (term_get_cursor_pos(term,&row1,&col1)) {
cols = col1;
rows = row1;
}
term_set_cursor_pos(term,row0,col0);
}
else {
// cannot query position
// return 0 column
}
}
// update width and return whether it changed.
bool changed = (term->width != cols || term->height != rows);
debug_msg("terminal dim: %zd,%zd: %s\n", rows, cols, changed ? "changed" : "unchanged");
if (cols > 0) {
term->width = cols;
term->height = rows;
}
return changed;
}
#else
ic_private bool term_update_dim(term_t* term) {
if (term->hcon == 0) {
term->hcon = GetConsoleWindow();
}
ssize_t rows = 0;
ssize_t cols = 0;
CONSOLE_SCREEN_BUFFER_INFO sbinfo;
if (GetConsoleScreenBufferInfo(term->hcon, &sbinfo)) {
cols = (ssize_t)sbinfo.srWindow.Right - (ssize_t)sbinfo.srWindow.Left + 1;
rows = (ssize_t)sbinfo.srWindow.Bottom - (ssize_t)sbinfo.srWindow.Top + 1;
}
bool changed = (term->width != cols || term->height != rows);
term->width = cols;
term->height = rows;
debug_msg("term: update dim: %zd, %zd\n", term->height, term->width );
return changed;
}
#endif
//-------------------------------------------------------------
// Enable/disable terminal raw mode
//-------------------------------------------------------------
#if !defined(_WIN32)
// On non-windows, the terminal is set in raw mode by the tty.
ic_private void term_start_raw(term_t* term) {
term->raw_enabled++;
}
ic_private void term_end_raw(term_t* term, bool force) {
if (term->raw_enabled <= 0) return;
if (!force) {
term->raw_enabled--;
}
else {
term->raw_enabled = 0;
}
}
static bool term_esc_query_color_raw(term_t* term, int color_idx, uint32_t* color ) {
char buf[128+1];
snprintf(buf,128,"\x1B]4;%d;?\x1B\\", color_idx);
if (!term_esc_query_raw( term, buf, buf, 128 )) return false;
if (buf[0] != '4') return false;
const char* rgb = strchr(buf,':');
if (rgb==NULL) return false;
rgb++; // skip ':'
unsigned int r,g,b;
if (sscanf(rgb,"%x/%x/%x",&r,&g,&b) != 3) return false;
if (rgb[2]!='/') { // 48-bit rgb, hexadecimal round to 24-bit
r = (r+0x7F)/0x100; // note: can "overflow", e.g. 0xFFFF -> 0x100. (and we need `ic_cap8` to convert.)
g = (g+0x7F)/0x100;
b = (b+0x7F)/0x100;
}
*color = (ic_cap8(r)<<16) | (ic_cap8(g)<<8) | ic_cap8(b);
debug_msg("color query: %02x,%02x,%02x: %06x\n", r, g, b, *color);
return true;
}
// update ansi 16 color palette for better color approximation
static void term_update_ansi16(term_t* term) {
#if defined(GIO_CMAP)
// try ioctl first (on Linux)
uint8_t cmap[48];
memset(cmap,0,48);
if (ioctl(term->fd_out,GIO_CMAP,&cmap) >= 0) {
// success
for(ssize_t i = 0; i < 48; i+=3) {
uint32_t color = ((uint32_t)(cmap[i]) << 16) | ((uint32_t)(cmap[i+1]) << 8) | cmap[i+2];
debug_msg("term (ioctl) ansi color %d: 0x%06x\n", i, color);
ansi256[i] = color;
}
return;
}
else {
debug_msg("ioctl GIO_CMAP failed: entry 1: 0x%02x%02x%02x\n", cmap[3], cmap[4], cmap[5]);
}
#endif
// otherwise use OSC 4 escape sequence query
tty_start_raw(term->tty);
for(ssize_t i = 0; i < 16; i++) {
uint32_t color;
if (!term_esc_query_color_raw(term, i, &color)) break;
debug_msg("term ansi color %d: 0x%06x\n", i, color);
ansi256[i] = color;
}
tty_end_raw(term->tty);
}
static void term_init_raw(term_t* term) {
if (term->palette < ANSIRGB) {
term_update_ansi16(term);
}
}
#else
ic_private void term_start_raw(term_t* term) {
if (term->raw_enabled++ > 0) return;
CONSOLE_SCREEN_BUFFER_INFO info;
if (GetConsoleScreenBufferInfo(term->hcon, &info)) {
term->hcon_orig_attr = info.wAttributes;
}
term->hcon_orig_cp = GetConsoleOutputCP();
SetConsoleOutputCP(CP_UTF8);
if (term->hcon_mode == 0) {
// first time initialization
DWORD mode = ENABLE_PROCESSED_OUTPUT | ENABLE_LVB_GRID_WORLDWIDE; // for \r \n and \b
// use escape sequence handling if available and the terminal supports it (so we can use rgb colors in Windows terminal)
// Unfortunately, in plain powershell, we can successfully enable terminal processing
// but it still fails to render correctly; so we require the palette be large enough (like in Windows Terminal)
if (term->palette >= ANSI256 && SetConsoleMode(term->hcon, mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING)) {
term->hcon_mode = mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING;
debug_msg("term: console mode: virtual terminal processing enabled\n");
}
// no virtual terminal processing, emulate instead
else if (SetConsoleMode(term->hcon, mode)) {
term->hcon_mode = mode;
term->palette = ANSI16;
}
GetConsoleMode(term->hcon, &mode);
debug_msg("term: console mode: orig: 0x%x, new: 0x%x, current 0x%x\n", term->hcon_orig_mode, term->hcon_mode, mode);
}
else {
SetConsoleMode(term->hcon, term->hcon_mode);
}
}
ic_private void term_end_raw(term_t* term, bool force) {
if (term->raw_enabled <= 0) return;
if (!force && term->raw_enabled > 1) {
term->raw_enabled--;
}
else {
term->raw_enabled = 0;
SetConsoleMode(term->hcon, term->hcon_orig_mode);
SetConsoleOutputCP(term->hcon_orig_cp);
SetConsoleTextAttribute(term->hcon, term->hcon_orig_attr);
}
}
static void term_init_raw(term_t* term) {
term->hcon = GetStdHandle(STD_OUTPUT_HANDLE);
GetConsoleMode(term->hcon, &term->hcon_orig_mode);
CONSOLE_SCREEN_BUFFER_INFOEX info;
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
if (GetConsoleScreenBufferInfoEx(term->hcon, &info)) {
// store default attributes
term->hcon_default_attr = info.wAttributes;
// update our color table with the actual colors used.
for (unsigned i = 0; i < 16; i++) {
COLORREF cr = info.ColorTable[i];
uint32_t color = (ic_cap8(GetRValue(cr))<<16) | (ic_cap8(GetGValue(cr))<<8) | ic_cap8(GetBValue(cr)); // COLORREF = BGR
// index is also in reverse in the bits 0 and 2
unsigned j = (i&0x08) | ((i&0x04)>>2) | (i&0x02) | (i&0x01)<<2;
debug_msg("term: ansi color %d is 0x%06x\n", j, color);
ansi256[j] = color;
}
}
else {
DWORD err = GetLastError();
debug_msg("term: cannot get console screen buffer: %d %x", err, err);
}
term_start_raw(term); // initialize the hcon_mode
term_end_raw(term,false);
}
#endif