vtgl

terminal.c (41162B)

---

 /* See LICENSE for copyright details */
 
 /* TODO: build own wide char tables */
 i32 wcwidth(u32 cp);
 
 global const u8 utf8overhangmask[32] = {
 	255, 255, 255, 255,  255, 255, 255, 255,
 	255, 255, 255, 255,  255, 255, 255, 255,
 	0, 0, 0, 0,  0, 0, 0, 0,
 	0, 0, 0, 0,  0, 0, 0, 0
 };
 
 #define SPLIT_LONG 4096L
 
 function iv2
 initialize_framebuffer(Framebuffer *fb, iv2 term_size)
 {
 	iz cell_memory_size = sizeof(Cell) * term_size.h * term_size.w;
 	iz rows_memory_size = sizeof(Row)  * term_size.h;
 
 	/* NOTE: make sure cell memory size is a multiple of pointer size */
 	cell_memory_size += (sizeof(void *) - cell_memory_size % sizeof(void *));
 
 	if (cell_memory_size + rows_memory_size >= fb->backing_store.size)
 		term_size.h = (fb->backing_store.size - cell_memory_size) / sizeof(Row);
 
 	fb->cells = fb->backing_store.memory;
 	fb->rows  = fb->backing_store.memory + cell_memory_size;
 
 	for (i32 i = 0; i < term_size.h; i++)
 		fb->rows[i] = fb->cells + i * term_size.w;
 
 	return term_size;
 }
 
 function Range
 get_word_around_cell(Term *t, iv2 cell)
 {
 	Range result = {.start = cell, .end = cell};
 	Cell *row    = t->views[t->view_idx].fb.rows[cell.y];
 
 	b32 isspace = ISSPACE(row[cell.x].cp) && !(row[cell.x].bg & ATTR_WDUMMY);
 	while (result.start.x > 0) {
 		Cell *nc = row + result.start.x - 1;
 		if (!(nc->bg & ATTR_WDUMMY) && isspace != ISSPACE(nc->cp))
 			break;
 		result.start.x--;
 	}
 	while (result.end.x < t->size.w - 1) {
 		Cell *nc = row + result.end.x + 1;
 		if (!(nc->bg & ATTR_WDUMMY) && isspace != ISSPACE(nc->cp))
 			break;
 		result.end.x++;
 	}
 
 	return result;
 }
 
 function Range
 get_char_around_cell(Term *t, iv2 cell)
 {
 	Range result = {.start = cell, .end = cell};
 
 	/* NOTE: if the cell is WDUMMY move back until we find the starting
 	 * WIDE cell. then set the range end to the last WDUMMY cell */
 	Cell *row = t->views[t->view_idx].fb.rows[cell.y];
 	if (row[cell.x].bg & ATTR_WDUMMY) {
 		ASSERT(cell.x - 1 >= 0);
 		cell.x--;
 		ASSERT(row[cell.x].bg & ATTR_WIDE);
 		result.start = cell;
 	} else if (row[cell.x].bg & ATTR_WIDE) {
 		ASSERT(cell.x + 1 < t->size.w);
 		cell.x++;
 		ASSERT(row[cell.x].bg & ATTR_WDUMMY);
 		result.end = cell;
 	}
 
 	return result;
 }
 
 function s8
 consume(s8 raw, iz count)
 {
 	raw.data += count;
 	raw.len  -= count;
 	return raw;
 }
 
 function u8
 peek(s8 raw, iz i)
 {
 	ASSERT(i < raw.len);
 	return raw.data[i];
 }
 
 function u32
 get_utf8(s8 *raw)
 {
 	u32 state = 0, cp;
 	iz  off = 0;
 	while (off < raw->len) {
 		if (!utf8_decode(&state, &cp, raw->data[off++])) {
 			*raw = consume(*raw, off);
 			return cp;
 		}
 	}
 	return (u32)-1;
 }
 
 function u32
 get_ascii(s8 *raw)
 {
 	ASSERT(raw->len > 0);
 	u32 result = raw->data[0];
 	*raw = consume(*raw, 1);
 	return result;
 }
 
 function iz
 line_length(Line *l)
 {
 	ASSERT(l->start <= l->end);
 	return l->end - l->start;
 }
 
 function s8
 line_to_s8(Line *l)
 {
 	ASSERT(l->start <= l->end);
 
 	s8 result = {.len = l->end - l->start, .data = l->start};
 	return result;
 }
 
 function void
 init_line(Line *l, u8 *position, CellStyle cursor_state)
 {
 	l->start        = position;
 	l->end          = position;
 	l->has_unicode  = 0;
 	l->cursor_state = cursor_state;
 }
 
 function iz
 feed_line(LineBuffer *lb, u8 *position, CellStyle cursor_state)
 {
 	iz result = 0;
 	if (lb->data[lb->count].start != position) {
 		lb->data[lb->count++].end = position;
 		lb->count   = lb->count >= lb->capacity ? 0 : lb->count;
 		lb->filled += lb->filled <= lb->count;
 		init_line(lb->data + lb->count, position, cursor_state);
 		result = 1;
 	}
 	return result;
 }
 
 function void
 selection_scroll(Term *t, i32 origin, i32 n)
 {
 	Selection *s = &t->selection;
 	if (!is_valid_range(s->range))
 		return;
 
 	b32 start_in_bounds = BETWEEN(s->range.start.y, origin, t->bot);
 	b32 end_in_bounds   = BETWEEN(s->range.end.y,   origin, t->bot);
 	if (start_in_bounds != end_in_bounds) {
 		selection_clear(s);
 	} else if (start_in_bounds) {
 		s->range.start.y += n;
 		s->range.end.y   += n;
 		if (s->range.start.y > t->bot || s->range.start.y < t->top ||
 		    s->range.end.y   > t->bot || s->range.end.y   < t->top)
 			selection_clear(s);
 	}
 }
 
 function b32
 is_selected(Selection *s, i32 x, i32 y)
 {
 	if (!is_valid_range(s->range))
 		return 0;
 
 	b32 result = BETWEEN(y, s->range.start.y, s->range.end.y) &&
 	             (y != s->range.start.y || x >= s->range.start.x) &&
 	             (y != s->range.end.y   || x <= s->range.end.x);
 	return result;
 }
 
 function b32
 selection_intersects_region(Selection *s, iv2 tl, iv2 br)
 {
 	/* TODO: maybe this can be further simplified (eg. with a k-map) */
 	Range r = s->range;
 	b32 valid   = is_valid_range(r);
 	b32 whole   = r.start.y <  tl.y && r.end.y   >  br.y;
 	b32 start_x = r.start.x >= tl.x && r.start.x <= br.x;
 	b32 start_y = r.start.y >= tl.y && r.start.y <= br.y;
 	b32 end_x   = r.end.x   >= tl.x && r.end.x   <= br.x;
 	b32 end_y   = r.end.y   >= tl.y && r.end.y   <= br.y;
 	b32 result  = valid && (whole || (start_y && start_x) || (end_y && end_x));
 	return result;
 }
 
 function void
 fb_clear_region(Term *t, i32 r1, i32 r2, i32 c1, i32 c2)
 {
 	BEGIN_TIMED_BLOCK();
 	u32 tmp;
 	if (r1 > r2) {
 		tmp = r1;
 		r1  = r2;
 		r2  = tmp;
 	}
 	if (c1 > c2) {
 		tmp = c1;
 		c1  = c2;
 		c2  = tmp;
 	}
 	CLAMP(c1, 0, t->size.w - 1);
 	CLAMP(c2, 0, t->size.w - 1);
 	CLAMP(r1, 0, t->size.h - 1);
 	CLAMP(r2, 0, t->size.h - 1);
 
 	iv2 top_left     = {.x = c1, .y = r1};
 	iv2 bottom_right = {.x = c2, .y = r2};
 	if (selection_intersects_region(&t->selection, top_left, bottom_right))
 		selection_clear(&t->selection);
 
 	Row *rows = t->views[t->view_idx].fb.rows;
 	CellStyle cursor_style = t->cursor.style;
 	u32 fg = SHADER_PACK_FG(cursor_style.fg.rgba, cursor_style.attr);
 	u32 bg = SHADER_PACK_BG(cursor_style.bg.rgba, cursor_style.attr);
 	for (i32 r = top_left.y; r <= bottom_right.y; r++) {
 		for (i32 c = top_left.x; c <= bottom_right.x; c++) {
 			rows[r][c].fg = fg;
 			rows[r][c].bg = bg;
 			rows[r][c].cp = ' ';
 		}
 	}
 
 	END_TIMED_BLOCK();
 }
 
 function void
 fb_scroll_down(Term *t, i32 top, i32 n)
 {
 	BEGIN_TIMED_BLOCK();
 	if (!BETWEEN(top, t->top, t->bot))
 		goto end;
 
 	TermView *tv = t->views + t->view_idx;
 	CLAMP(n, 0, t->bot - top);
 
 	fb_clear_region(t, t->bot - n + 1, t->bot, 0, t->size.w);
 	for (i32 i = t->bot; i >= top + n; i--) {
 		Row tmp = tv->fb.rows[i];
 		tv->fb.rows[i]     = tv->fb.rows[i - n];
 		tv->fb.rows[i - n] = tmp;
 	}
 	selection_scroll(t, top, n);
 end:
 	END_TIMED_BLOCK();
 }
 
 function void
 fb_scroll_up(Term *t, i32 top, i32 n)
 {
 	BEGIN_TIMED_BLOCK();
 	if (!BETWEEN(top, t->top, t->bot))
 		goto end;
 
 	TermView *tv = t->views + t->view_idx;
 	CLAMP(n, 0, t->bot - top);
 
 #if 0
 	size cell_count = (t->bot - n + 1) * t->size.w;
 	ASSERT(cell_count < tv->fb.cells_count);
 	mem_move(tv->fb.cells + t->size.w * n, tv->fb.cells, cell_count * sizeof(Cell));
 	fb_clear_region(t, t->bot - n + 1, t->bot, 0, t->size.w);
 #else
 	fb_clear_region(t, top, top + n - 1, 0, t->size.w);
 	for (i32 i = top; i <= t->bot - n; i++) {
 		Row tmp = tv->fb.rows[i];
 		tv->fb.rows[i]     = tv->fb.rows[i + n];
 		tv->fb.rows[i + n] = tmp;
 	}
 #endif
 	selection_scroll(t, top, -n);
 end:
 	END_TIMED_BLOCK();
 }
 
 function void
 swap_screen(Term *t)
 {
 	t->mode.term ^= TM_ALTSCREEN;
 	t->view_idx   = !!(t->mode.term & TM_ALTSCREEN);
 }
 
 function void
 cursor_reset(Term *t)
 {
 	//(Colour){.rgba = 0x1e9e33ff};
 	t->cursor.style.fg   = g_colours.data[g_colours.fgidx];
 	t->cursor.style.bg   = g_colours.data[g_colours.bgidx];
 	t->cursor.style.attr = ATTR_NULL;
 }
 
 function void
 cursor_move_to(Term *t, i32 row, i32 col)
 {
 	i32 minr = 0, maxr = t->size.h - 1;
 	if (t->cursor.state & CURSOR_ORIGIN) {
 		minr = t->top;
 		maxr = t->bot;
 	}
 	t->cursor.pos.y  = CLAMP(row, minr, maxr);
 	t->cursor.pos.x  = CLAMP(col, 0, t->size.w - 1);
 	t->cursor.state &= ~CURSOR_WRAP_NEXT;
 }
 
 function void
 cursor_move_abs_to(Term *t, i32 row, i32 col)
 {
 	if (t->cursor.state & CURSOR_ORIGIN)
 		row += t->top;
 	cursor_move_to(t, row, col);
 }
 
 function void
 cursor_alt(Term *t, b32 save)
 {
 	i32 mode = t->view_idx;
 	if (save) {
 		t->saved_cursors[mode] = t->cursor;
 	} else {
 		t->cursor = t->saved_cursors[mode];
 		cursor_move_to(t, t->cursor.pos.y, t->cursor.pos.x);
 	}
 }
 
 /* NOTE: advance the cursor by <n> cells; handles reverse movement */
 function void
 cursor_step_column(Term *t, i32 n)
 {
 	i32 col = t->cursor.pos.x + n;
 	i32 row = t->cursor.pos.y;
 	if (col >= t->size.w) {
 		row++;
 		col = 0;
 		if (row >= t->size.h)
 			fb_scroll_up(t, t->top, 1);
 	}
 	cursor_move_to(t, row, col);
 }
 
 /* NOTE: steps the cursor without causing a scroll */
 function void
 cursor_step_raw(Term *t, i32 step, i32 rows, i32 cols)
 {
 	rows *= step;
 	cols *= step;
 	rows = MIN(rows, I32_MAX - t->cursor.pos.y);
 	cols = MIN(cols, I32_MAX - t->cursor.pos.x);
 	cursor_move_to(t, t->cursor.pos.y + rows, t->cursor.pos.x + cols);
 }
 
 function void
 cursor_up(Term *t, i32 requested_count)
 {
 	i32 cursor_y = t->cursor.pos.y;
 	i32 max      = cursor_y >= t->top ? (cursor_y - t->top) : cursor_y;
 	i32 count    = MIN(max, MAX(requested_count, 1));
 	cursor_move_to(t, t->cursor.pos.y - count, t->cursor.pos.x);
 }
 
 function void
 cursor_down(Term *t, i32 requested_count)
 {
 	i32 cursor_y = t->cursor.pos.y;
 	i32 max      = cursor_y <= t->bot ? (t->bot - cursor_y) : (t->size.h - cursor_y - 1);
 	i32 count    = MIN(max, MAX(requested_count, 1));
 	cursor_move_to(t, t->cursor.pos.y + count, t->cursor.pos.x);
 }
 
 function i32
 next_tab_position(Term *t, b32 backwards)
 {
 	static_assert(ARRAY_COUNT(t->tabs) == 8 * sizeof(*t->tabs),
 	              "Term.tabs must be same length as the bitwidth of it's type");
 	u32 col  = t->cursor.pos.x;
 	u32 idx  = col / ARRAY_COUNT(t->tabs);
 	u32 bit  = col % ARRAY_COUNT(t->tabs);
 	u32 mask = safe_left_shift(1, bit - backwards) - 1;
 
 	i32 result = 32 * idx;
 	if (backwards) {
 		u32 zeroes = clz_u32(t->tabs[idx--] & mask);
 		while (idx < ARRAY_COUNT(t->tabs) && zeroes == 32)
 			zeroes = clz_u32(t->tabs[idx--]);
 		result  = 32 * (idx + 1) + 32 - zeroes;
 		result *= col != 0;
 	} else {
 		u32 zeroes = ctz_u32(t->tabs[idx++] & ~mask);
 		while (idx < ARRAY_COUNT(t->tabs) && zeroes == 32)
 			zeroes = ctz_u32(t->tabs[idx++]);
 		result = 32 * (idx - 1) + zeroes + 1;
 	}
 	/* TODO(rnp): is clamping this correct? */
 	//ASSERT(result < t->size.w);
 	result = MIN(result, t->size.w - 1);
 
 	return result;
 }
 
 function void
 term_tab_col(Term *t, i32 col, b32 set)
 {
 	ASSERT(col < t->size.w);
 	u32 idx  = (col > 0) ? ((col - 1) / ARRAY_COUNT(t->tabs)) : 0;
 	u32 bit  = (col > 0) ? ((col - 1) % ARRAY_COUNT(t->tabs)) : 0;
 	u32 mask = 1u;
 	if (bit) mask = safe_left_shift(1, bit);
 	if (set) t->tabs[idx] |=  mask;
 	else     t->tabs[idx] &= ~mask;
 }
 
 function void
 reset_tabs(Term *t, u32 column_step)
 {
 	for (i32 i = 0; i < ARRAY_COUNT(t->tabs); i++)
 		t->tabs[i] = 0;
 	for (i32 i = column_step; i < t->size.w; i += column_step)
 		term_tab_col(t, i, 1);
 }
 
 function void
 term_reset(Term *t)
 {
 	i32 mode = t->mode.term & TM_ALTSCREEN;
 	t->cursor.state = CURSOR_NORMAL;
 	for (u32 i = 0; i < ARRAY_COUNT(t->saved_cursors); i++) {
 		cursor_reset(t);
 		t->cursor.charset_index = 0;
 		for (u32 i = 0; i < ARRAY_COUNT(t->cursor.charsets); i++)
 			t->cursor.charsets[i] = CS_USA;
 		cursor_move_to(t, 0, 0);
 		cursor_alt(t, 1);
 		swap_screen(t);
 		fb_clear_region(t, 0, t->size.h, 0, t->size.w);
 	}
 	reset_tabs(t, g_tabstop);
 
 	t->top  = 0;
 	t->bot  = t->size.h - 1;
 	/* TODO: why is term_reset() being called when we are in the altscreen */
 	t->mode.term = mode|TM_AUTO_WRAP|TM_UTF8;
 }
 
 function void
 stream_push_csi(Stream *s, CSI *csi)
 {
 	stream_push_s8(s, s8("ESC ["));
 	for (iz i = 0; i < csi->raw.len; i++) {
 		u8 c = csi->raw.data[i];
 		if (ISPRINT(c)) {
 			stream_push_byte(s, csi->raw.data[i]);
 		} else if (c == '\n') {
 			stream_push_s8(s, s8("\\n"));
 		} else if (c == '\r') {
 			stream_push_s8(s, s8("\\r"));
 		} else {
 			stream_push_s8(s, s8("\\x"));
 			stream_push_hex_u64(s, c);
 		}
 	}
 	stream_push_s8(s, s8("\n\t{ .priv = "));
 	stream_push_u64(s, csi->priv);
 	stream_push_s8(s, s8(" .mode = "));
 	if (ISPRINT(csi->mode)) {
 		stream_push_byte(s, csi->mode);
 	} else {
 		stream_push_s8(s, s8("\\x"));
 		stream_push_hex_u64(s, csi->mode);
 	}
 
 	stream_push_s8(s, s8(", .argc = "));
 	stream_push_u64(s, csi->argc);
 	stream_push_s8(s, s8(", .argv = {"));
 	for (i32 i = 0; i < csi->argc; i++) {
 		stream_push_byte(s, ' ');
 		stream_push_i64(s, csi->argv[i]);
 	}
 	stream_push_s8(s, s8(" } }\n"));
 }
 
 /* ED/DECSED: Erase in Display */
 function void
 erase_in_display(Term *t, CSI *csi)
 {
 	iv2 cpos = t->cursor.pos;
 	switch (csi->argv[0]) {
 	case 0: /* Erase Below (default) */
 		fb_clear_region(t, cpos.y, cpos.y, cpos.x, t->size.w);
 		if (cpos.y < t->size.h - 1)
 			fb_clear_region(t, cpos.y + 1, t->size.h, 0, t->size.w);
 		break;
 	case 1: /* Erase Above */
 		if (cpos.y > 0)
 			fb_clear_region(t, 0, cpos.y - 1, 0, t->size.w);
 		fb_clear_region(t, cpos.y, cpos.y, 0, cpos.x);
 		break;
 	case 2: /* Erase All */
 		fb_clear_region(t, 0, t->size.h, 0, t->size.w);
 		break;
 	case 3: /* Erase Saved Lines (xterm) */
 		/* NOTE: ignored; we don't save lines in the way xterm does */
 		break;
 	default: /* TODO(rnp): warn about invalid argument */ ;
 	}
 }
 
 /* EL/DECSEL: Erase in Line */
 function void
 erase_in_line(Term *t, CSI *csi)
 {
 	iv2 cpos = t->cursor.pos;
 	switch (csi->argv[0]) {
 	case 0: /* Erase to Right */
 		fb_clear_region(t, cpos.y, cpos.y, cpos.x, t->size.w);
 		break;
 	case 1: /* Erase to Left */
 		fb_clear_region(t, cpos.y, cpos.y, 0, cpos.x);
 		break;
 	case 2: /* Erase All */
 		fb_clear_region(t, cpos.y, cpos.y, 0, t->size.w);
 		break;
 	default: /* TODO(rnp): warn about invalid argument */ ;
 	}
 }
 
 /* IL: Insert <count> blank lines */
 function void
 insert_blank_lines(Term *t, i32 count)
 {
 	fb_scroll_down(t, t->cursor.pos.y, count);
 }
 
 /* DL: Erase <count> lines */
 function void
 erase_lines(Term *t, i32 count)
 {
 	fb_scroll_up(t, t->cursor.pos.y, count);
 }
 
 /* DCH: Delete <count> Characters */
 function void
 delete_characters(Term *t, i32 requested_count)
 {
 	iv2 cpos = t->cursor.pos;
 	/* TODO(rnp): if the cursor is outside the left/right margins do nothing */
 
 	TermView *tv  = t->views + t->view_idx;
 	i32 count     = MAX(0, MIN(requested_count, t->size.w - cpos.x));
 	i32 total     = t->size.w - count;
 
 	Cell *dst = tv->fb.rows[cpos.y] + cpos.x;
 	if (dst->bg & ATTR_WDUMMY) dst--;
 	Cell *src = dst + count;
 
 	i32 dst_off = 0, src_off = 0;
 	for (i32 i = 0; i < total; i++) {
 		b32 dst_wide = (dst[i].bg & ATTR_WIDE) != 0;
 		b32 src_wide = (src[i].bg & ATTR_WIDE) != 0;
 
 		if (dst_wide && !src_wide)
 			dst[i + 1].bg &= ~ATTR_WDUMMY;
 
 		dst[i + dst_off] = src[i + src_off];
 
 		if (src_wide && !dst_wide) {
 			dst[i + 1] = src[i + 1];
 			i++;
 		}
 	}
 
 	fb_clear_region(t, cpos.y, cpos.y, t->size.w - count, t->size.w);
 }
 
 /* ECH: Erase <count> Characters */
 function void
 erase_characters(Term *t, i32 count)
 {
 	iv2 cpos  = t->cursor.pos;
 	fb_clear_region(t, cpos.y, cpos.y, cpos.x, cpos.x + count - 1);
 }
 
 /* TBC: Tabulation Clear */
 function void
 clear_term_tab(Term *t, i32 arg)
 {
 	/* TODO: case 1, 2? */
 	switch(arg) {
 	case 0:
 		term_tab_col(t, t->cursor.pos.x, 0);
 		break;
 	case 3:
 		for (u32 i = 0; i < ARRAY_COUNT(t->tabs); i++)
 			t->tabs[i] = 0;
 		break;
 	default:
 		stream_push_s8(&t->error_stream, s8("clear_term_tab: unhandled arg: "));
 		stream_push_i64(&t->error_stream, arg);
 		stream_push_byte(&t->error_stream, '\n');
 		os_write_err_msg(stream_to_s8(&t->error_stream));
 		stream_reset(&t->error_stream, 0);
 	}
 }
 
 /* SM/DECSET: Set Mode & RM/DECRST Reset Mode */
 function void
 set_mode(Term *t, CSI *csi, b32 set, ModeState src, ModeState *dest)
 {
 	BEGIN_TIMED_BLOCK();
 	i32 alt = t->view_idx;
 
 	/* TODO: this whole thing should be a lookup table */
 	#define PRIV(a) ((1 << 30) | (a))
 	for (i32 i = 0; i < csi->argc; i++) {
 		i32 arg = (csi->argv[i]) | ((csi->priv & 1) << 30);
 		switch (arg) {
 		case 4:          /* IRM: Insert/Replace Mode */
 			dest->term &= ~TM_REPLACE;
 			if (set) dest->term |= (src.term & TM_REPLACE);
 			break;
 		case 20:         /* LNM: Linefeed Assumes Carriage Return */
 			dest->term &= ~TM_CRLF;
 			if (set) dest->term |= (src.term & TM_CRLF);
 			break;
 		case PRIV(1):    /* DECCKM: use application cursor keys */
 			dest->win &= ~WM_APPCURSOR;
 			if (set) dest->win |= (src.win & WM_APPCURSOR);
 			break;
 		case PRIV(5):    /* DECSCNM: reverse/normal video mode */
 			dest->win &= ~WM_REVERSE;
 			if (set) dest->win |= (src.win & WM_REVERSE);
 			break;
 		case PRIV(6):    /* DECOM: Cursor Origin Mode */
 			if (set) t->cursor.state |=  CURSOR_ORIGIN;
 			else     t->cursor.state &= ~CURSOR_ORIGIN;
 			cursor_move_abs_to(t, 0, 0);
 			break;
 		case PRIV(7):    /* DECAWM: Auto-Wrap Mode */
 			dest->term &= ~TM_AUTO_WRAP;
 			if (set) dest->term |= (src.term & TM_AUTO_WRAP);
 			break;
 		case PRIV(1000): /* xterm: report mouse button presses */
 			dest->win &= ~WM_MOUSE_MASK;
 			if (set) dest->win |= (src.win & WM_MOUSE_BTN);
 			break;
 		case PRIV(1002): /* xterm: cell motion tracking */
 			dest->win &= ~WM_MOUSE_MASK;
 			if (set) dest->win |= (src.win & WM_MOUSE_TRK);
 			break;
 		case PRIV(1006): /* xterm: SGR mouse mode */
 			dest->win &= ~WM_MOUSE_SGR;
 			if (set) dest->win |= (src.win & WM_MOUSE_SGR);
 			break;
 		case PRIV(3):    /* DECCOLM: 132/80 Column Mode */
 		case PRIV(4):    /* DECSCLM: Fast/Slow Scroll */
 		case PRIV(8):    /* DECARM: Auto-Repeat Keys */
 		case PRIV(12):   /* AT&T 610: Start blinking cursor */
 		case PRIV(40):   /* xterm: (dis)allow 132/80 Column Mode */
 		case PRIV(45):   /* XTREVWRAP: xterm reverse wrap around */
 		case PRIV(1001): /* xterm: (broken) mouse highlight tracking; requires
 		                  * the requesting program to be competely functional or will
 		                  * hang the terminal by design */
 		case PRIV(1015): /* urxvt: (broken) mouse mode */
 			/* IGNORED */
 			break;
 		case PRIV(25):   /* DECTCEM: Show/Hide Cursor */
 			dest->win &= ~WM_HIDECURSOR;
 			if (!set) dest->win |= (src.win & WM_HIDECURSOR);
 			break;
 		case PRIV(1034): /* xterm: enable 8-bit input mode */
 			dest->win &= ~WM_8BIT;
 			if (set) dest->win |= (src.win & WM_8BIT);
 			break;
 		case PRIV(1049): /* xterm: swap cursor then swap screen */
 			cursor_alt(t, set);
 			/* FALLTHROUGH */
 		case PRIV(47):   /* xterm: swap screen buffer */
 		case PRIV(1047): /* xterm: swap screen buffer */
 			if (alt)                  fb_clear_region(t, 0, t->size.h, 0, t->size.w);
 			if (set ^ alt)            swap_screen(t);
 			if (csi->argv[i] != 1049) break;
 			/* FALLTHROUGH */
 		case PRIV(1048): /* xterm: swap cursor */
 			cursor_alt(t, set);
 			break;
 		case PRIV(2004): /* xterm: bracketed paste mode */
 			dest->win &= ~WM_BRACKPASTE;
 			if (set) dest->win |= (src.win & WM_BRACKPASTE);
 			break;
 		case PRIV(2026): /* synchronized render (eg. wezterm) */
 			/* IGNORED: we aren't writing some slow garbage so we won't let some
 			 * broken program try and stall us because they think we can't operate
 			 * fast enough */
 			break;
 		default:
 			stream_push_s8(&t->error_stream, s8("set_mode: unhandled mode: "));
 			stream_push_csi(&t->error_stream, csi);
 			os_write_err_msg(stream_to_s8(&t->error_stream));
 			stream_reset(&t->error_stream, 0);
 		}
 	}
 	#undef PRIV
 	END_TIMED_BLOCK();
 }
 
 /* NOTE: adapted from the perl script 256colres.pl in xterm src */
 function Colour
 indexed_colour(i32 index)
 {
 	Colour result;
 	if (index < 232) {
 		/* NOTE: 16-231 are colours off a 6x6x6 RGB cube */
 		index -= 16;
 		result.r = 40 * ((index / 36));
 		result.g = 40 * ((index % 36) / 6);
 		result.b = 40 * ((index %  6));
 		result.a = 0xFF;
 		if (result.r) result.r += 55;
 		if (result.g) result.g += 55;
 		if (result.b) result.b += 55;
 	} else {
 		/* NOTE: 232-255 are greyscale ramp */
 		u32 k = (10 * (index - 232) + 8) & 0xFF;
 		result.r = result.g = result.b = k;
 		result.a = 0xFF;
 	}
 	return result;
 }
 
 function struct conversion_result
 direct_colour(i32 *argv, i32 argc, i32 *idx, Stream *err)
 {
 	struct conversion_result result = {.status = CR_FAILURE};
 	switch (argv[*idx + 1]) {
 	case 2: /* NOTE: defined RGB colour */
 		if (*idx + 4 >= argc) {
 			stream_push_s8(err, s8("direct_colour: wrong parameter count: "));
 			stream_push_u64(err, argc);
 			stream_push_byte(err, '\n');
 			break;
 		}
 		u32 r = (u32)argv[*idx + 2];
 		u32 g = (u32)argv[*idx + 3];
 		u32 b = (u32)argv[*idx + 4];
 		*idx += 4;
 		if (r > 0xFF || g > 0xFF || b > 0xFF) {
 			stream_push_s8(err, s8("direct_colour: bad rgb colour: ("));
 			stream_push_u64(err, r);
 			stream_push_s8(err, s8(", "));
 			stream_push_u64(err, g);
 			stream_push_s8(err, s8(", "));
 			stream_push_u64(err, b);
 			stream_push_s8(err, s8(")\n"));
 			break;
 		}
 		result.colour = (Colour){.r = r, .g = g, .b = b, .a = 0xFF};
 		result.status = CR_SUCCESS;
 		break;
 	case 5: /* NOTE: indexed colour */
 		if (*idx + 2 >= argc) {
 			stream_push_s8(err, s8("direct_colour: wrong parameter count: "));
 			stream_push_u64(err, argc);
 			stream_push_byte(err, '\n');
 			break;
 		}
 		*idx += 2;
 		if (!BETWEEN(argv[*idx], 0, 255)) {
 			stream_push_s8(err, s8("direct_colour: index parameter out of range: "));
 			stream_push_i64(err, argv[*idx]);
 			stream_push_byte(err, '\n');
 			break;
 		}
 		if (BETWEEN(argv[*idx], 0, 16))
 			result.colour = g_colours.data[argv[*idx]];
 		else
 			result.colour = indexed_colour(argv[*idx]);
 		result.status = CR_SUCCESS;
 		break;
 	default:
 		stream_push_s8(err, s8("direct_colour: unknown argument: "));
 		stream_push_i64(err, argv[*idx + 1]);
 		stream_push_byte(err, '\n');
 	}
 
 	return result;
 }
 
 /* SGR: Select Graphic Rendition */
 function void
 set_colours(Term *t, CSI *csi)
 {
 	BEGIN_TIMED_BLOCK();
 	CellStyle *cs = &t->cursor.style;
 	struct conversion_result dcr;
 	for (i32 i = 0; i < csi->argc; i++) {
 		switch (csi->argv[i]) {
 		case  0: cursor_reset(t);                     break;
 		case  1: cs->attr |= ATTR_BOLD;               break;
 		case  2: cs->attr |= ATTR_FAINT;              break;
 		case  3: cs->attr |= ATTR_ITALIC;             break;
 		case  4: cs->attr |= ATTR_UNDERLINED;         break;
 		case  5: cs->attr |= ATTR_BLINK;              break;
 		case  7: cs->attr |= ATTR_INVERSE;            break;
 		case  8: cs->attr |= ATTR_INVISIBLE;          break;
 		case  9: cs->attr |= ATTR_STRUCK;             break;
 		case 22: cs->attr &= ~(ATTR_BOLD|ATTR_FAINT); break;
 		case 23: cs->attr &= ~ATTR_ITALIC;            break;
 		case 24: cs->attr &= ~ATTR_UNDERLINED;        break;
 		case 25: cs->attr &= ~ATTR_BLINK;             break;
 		case 27: cs->attr &= ~ATTR_INVERSE;           break;
 		case 28: cs->attr &= ~ATTR_INVISIBLE;         break;
 		case 29: cs->attr &= ~ATTR_STRUCK;            break;
 		case 38:
 			dcr = direct_colour(csi->argv, csi->argc, &i, &t->error_stream);
 			if (dcr.status == CR_SUCCESS) {
 				cs->fg = dcr.colour;
 			} else {
 				stream_push_s8(&t->error_stream, s8("set_colours: "));
 				stream_push_csi(&t->error_stream, csi);
 				os_write_err_msg(stream_to_s8(&t->error_stream));
 				stream_reset(&t->error_stream, 0);
 			}
 			break;
 
 		case 39: cs->fg = g_colours.data[g_colours.fgidx]; break;
 
 		case 48:
 			dcr = direct_colour(csi->argv, csi->argc, &i, &t->error_stream);
 			if (dcr.status == CR_SUCCESS) {
 				cs->bg = dcr.colour;
 			} else {
 				stream_push_s8(&t->error_stream, s8("set_colours: "));
 				stream_push_csi(&t->error_stream, csi);
 				os_write_err_msg(stream_to_s8(&t->error_stream));
 				stream_reset(&t->error_stream, 0);
 			}
 			break;
 
 		case 49: cs->bg = g_colours.data[g_colours.bgidx]; break;
 
 		default:
 			if (BETWEEN(csi->argv[i], 30, 37)) {
 				cs->fg = g_colours.data[csi->argv[i] - 30];
 			} else if (BETWEEN(csi->argv[i], 40, 47)) {
 				cs->bg = g_colours.data[csi->argv[i] - 40];
 			} else if (BETWEEN(csi->argv[i], 90, 97)) {
 				cs->fg = g_colours.data[csi->argv[i] - 82];
 			} else if (BETWEEN(csi->argv[i], 100, 107)) {
 				cs->bg = g_colours.data[csi->argv[i] - 92];
 			} else {
 				stream_push_s8(&t->error_stream, s8("unhandled colour arg: "));
 				stream_push_i64(&t->error_stream, csi->argv[i]);
 				stream_push_byte(&t->error_stream, '\n');
 				stream_push_csi(&t->error_stream, csi);
 				os_write_err_msg(stream_to_s8(&t->error_stream));
 				stream_reset(&t->error_stream, 0);
 			}
 		}
 	}
 	END_TIMED_BLOCK();
 }
 
 function void
 set_top_bottom_margins(Term *t, i32 requested_top, i32 requested_bottom)
 {
 	i32 top    = MIN(MAX(1, requested_top), t->size.h);
 	i32 bottom = MIN(t->size.h, (requested_bottom ? requested_bottom : t->size.h));
 	if (top < bottom) {
 		t->top = top - 1;
 		t->bot = bottom - 1;
 		cursor_move_abs_to(t, 0, 0);
 	}
 }
 
 function void
 window_manipulation(Term *t, CSI *csi)
 {
 	switch (csi->argv[0]) {
 	case 22: {
 		u8 *title = t->os->get_window_title();
 		stream_reset(&t->saved_title, 0);
 		stream_push_s8(&t->saved_title, c_str_to_s8((char *)title));
 		/* TODO(rnp): ensure termination */
 		stream_push_byte(&t->saved_title, 0);
 	} break;
 	case 23: t->os->set_window_title(stream_to_s8(&t->saved_title)); break;
 	default:
 		stream_push_s8(&t->error_stream, s8("unhandled xtwinops: "));
 		stream_push_i64(&t->error_stream, csi->argv[0]);
 		stream_push_byte(&t->error_stream, '\n');
 		stream_push_csi(&t->error_stream, csi);
 		os_write_err_msg(stream_to_s8(&t->error_stream));
 		stream_reset(&t->error_stream, 0);
 	}
 }
 
 function void
 push_newline(Term *t, b32 move_to_first_col)
 {
 	i32 row = t->cursor.pos.y;
 	if (row == t->bot && t->scroll_offset == 0)
 		fb_scroll_up(t, t->top, 1);
 	else
 		row++;
 	cursor_move_to(t, row, move_to_first_col? 0 : t->cursor.pos.x);
 }
 
 function void
 push_tab(Term *t, i32 n)
 {
 	u32 end = ABS(n);
 	for (u32 i = 0; i < end; i++)
 		cursor_move_to(t, t->cursor.pos.y, next_tab_position(t, n < 0));
 }
 
 function b32
 parse_csi(s8 *r, CSI *csi)
 {
 	BEGIN_TIMED_BLOCK();
 	b32 result = 1;
 
 	if (peek(*r, 0) == '?') {
 		csi->priv = 1;
 		get_ascii(r);
 	}
 
 	struct conversion_result arg = {0};
 	while (r->len) {
 		s8_parse_i32_accum(&arg, *r);
 		*r = arg.unparsed;
 		if (r->len) {
 			u32 cp = get_ascii(r);
 
 			if (ISCONTROL(cp))
 				continue;
 
 			csi->argv[csi->argc++] = arg.i;
 			zero_struct(&arg);
 
 			if (cp != ';' || csi->argc == ESC_ARG_SIZ) {
 				if (cp == ';') csi->mode = get_ascii(r);
 				else           csi->mode = cp;
 				goto end;
 			}
 		}
 	}
 	/* NOTE: if we fell out of the loop then we ran out of characters */
 	result = 0;
 end:
 	END_TIMED_BLOCK();
 
 	return result;
 }
 
 function void
 handle_csi(Term *t, CSI *csi)
 {
 	BEGIN_TIMED_BLOCK();
 	s8  raw = csi->raw;
 	b32 ret = parse_csi(&raw, csi);
 	if (!ret) goto unknown;
 
 	#define ORONE(x) ((x)? (x) : 1)
 
 	iv2 p = t->cursor.pos;
 
 	switch (csi->mode) {
 	case 'A': cursor_up(t,   csi->argv[0]);                              break;
 	case 'B': cursor_down(t, csi->argv[0]);                              break;
 	case 'C': cursor_step_raw(t, ORONE(csi->argv[0]),  0,  1);           break;
 	case 'D': cursor_step_raw(t, ORONE(csi->argv[0]),  0, -1);           break;
 	case 'E': cursor_move_to(t, p.y + ORONE(csi->argv[0]), 0);           break;
 	case 'F': cursor_move_to(t, p.y - ORONE(csi->argv[0]), 0);           break;
 	case 'G': cursor_move_to(t, p.y, csi->argv[0] - 1);                  break;
 	case 'H': cursor_move_abs_to(t, csi->argv[0] - 1, csi->argv[1] - 1); break;
 	case 'J': erase_in_display(t, csi);                                  break;
 	case 'K': erase_in_line(t, csi);                                     break;
 	case 'L': insert_blank_lines(t, ORONE(csi->argv[0]));                break;
 	case 'M': erase_lines(t, ORONE(csi->argv[0]));                       break;
 	case 'P': delete_characters(t, ORONE(csi->argv[0]));                 break;
 	case 'X': erase_characters(t, ORONE(csi->argv[0]));                  break;
 	case 'S': fb_scroll_up(t, t->top, ORONE(csi->argv[0]));              break;
 	case 'T': fb_scroll_down(t, t->top, ORONE(csi->argv[0]));            break;
 	case 'W': if (csi->priv) reset_tabs(t, 8); else goto unknown;        break;
 	case 'Z': push_tab(t, -(ORONE(csi->argv[0])));                       break;
 	case 'a': cursor_step_raw(t, ORONE(csi->argv[0]),  0,  1);           break;
 	case 'd': cursor_move_abs_to(t, csi->argv[0] - 1, p.x);              break;
 	case 'e': cursor_step_raw(t, ORONE(csi->argv[0]),  1,  0);           break;
 	case 'f': cursor_move_abs_to(t, csi->argv[0] - 1, csi->argv[1] - 1); break;
 	case 'g': clear_term_tab(t, csi->argv[0]);                           break;
 	case 'h': set_mode(t, csi, 1, MODE_STATE_ALL_MASK, &t->mode);        break;
 	case 'l': set_mode(t, csi, 0, MODE_STATE_ALL_MASK, &t->mode);        break;
 	case 'm': set_colours(t, csi);                                       break;
 	case 'n': {
 		switch (csi->argv[0]) {
 		case 5: /* NOTE: DSR V-1: Operating Status */
 			t->os->write(t->child, s8("\x1B[0n"));
 			break;
 		case 6: /* NOTE: DSR V-2: Cursor Position */ {
 			iv2 cpos = t->cursor.pos;
 			if (t->cursor.state & CURSOR_ORIGIN) {
 				/* TODO(rnp): left/right margin */
 				//cpos.x = MAX(0, cpos.x - t->margin.left);
 				cpos.y = MAX(0, cpos.y - t->top);
 			}
 			Stream buf = arena_stream(t->arena_for_frame);
 			stream_push_s8(&buf, s8("\x1B["));
 			stream_push_i64(&buf, cpos.y + 1);
 			stream_push_byte(&buf, ';');
 			stream_push_i64(&buf, cpos.x + 1);
 			stream_push_byte(&buf, 'R');
 			t->os->write(t->child, stream_to_s8(&buf));
 		} break;
 		default: goto unknown;
 		}
 	} break;
 	case 'r':
 		if (csi->priv) {
 			/* NOTE: XTRESTORE: restore the value of a private mode */
 			set_mode(t, csi, 1, t->saved_mode, &t->mode);
 		} else {
 			set_top_bottom_margins(t, csi->argv[0], csi->argv[1]);
 		}
 		break;
 	case 's':
 		if (csi->priv) {
 			/* NOTE: XTSAVE: save the value of a private mode */
 			set_mode(t, csi, 1, t->mode, &t->saved_mode);
 		} else if (csi->argc == 1) {
 			/* NOTE: SCOSC/ANSI.SYS: save the cursor */
 			cursor_alt(t, 1);
 		} else {
 			goto unknown;
 		}
 		break;
 	case 't': window_manipulation(t, csi); break;
 	case '!':
 		if (csi->raw.data[csi->raw.len - 1] == 'p') {
 			/* NOTE: DECSTR: soft terminal reset IGNORED */
 			break;
 		}
 		goto unknown;
 	case '"':
 		if (csi->raw.data[csi->raw.len - 1] == 'p') {
 			/* TODO: we should look at the second parameter and
 			 * use it modify C1 control character mode */
 			/* NOTE: DECSCL: set conformance level IGNORED */
 			break;
 		}
 		goto unknown;
 	default:
 	unknown:
 		stream_push_s8(&t->error_stream, s8("unknown csi: "));
 		stream_push_csi(&t->error_stream, csi);
 		os_write_err_msg(stream_to_s8(&t->error_stream));
 		stream_reset(&t->error_stream, 0);
 	}
 	END_TIMED_BLOCK();
 }
 
 function b32
 parse_osc(s8 *raw, OSC *osc)
 {
 	BEGIN_TIMED_BLOCK();
 
 	b32 result = 0;
 	/* TODO(rnp): make this whole function re-entrant */
 	zero_struct(osc);
 	osc->raw.data = raw->data;
 
 	struct conversion_result cmd = s8_parse_i32_until(*raw, ';');
 	if (cmd.status != CR_FAILURE) {
 		osc->cmd     = cmd.i;
 		osc->arg     = cmd.unparsed;
 		osc->raw.len = osc->arg.data - raw->data;
 		*raw         = consume(*raw, osc->raw.len);
 	}
 
 	if (osc->arg.len && peek(osc->arg, 0) == ';') {
 		osc->arg.data++;
 		osc->arg.len = 0;
 		osc->raw.len++;
 		get_ascii(raw);
 		while (raw->len) {
 			u32 cp = get_ascii(raw);
 			osc->raw.len++;
 			if (cp == '\a') {
 				result = 1;
 				break;
 			}
 			if (cp == 0x1B && (raw->len && peek(*raw, 0) == '\\')) {
 				get_ascii(raw);
 				osc->raw.len++;
 				result = 1;
 				break;
 			}
 			osc->arg.len++;
 		}
 	}
 
 	END_TIMED_BLOCK();
 
 	return result;
 }
 
 function void
 reset_csi(CSI *csi, s8 *raw)
 {
 	*csi          = (CSI){0};
 	csi->raw.data = raw->data;
 }
 
 function void
 dump_osc(OSC *osc, Stream *err)
 {
 	stream_push_s8(err, s8("ESC]"));
 	for (iz i = 0; i < osc->raw.len; i++) {
 		u8 cp = osc->raw.data[i];
 		if (ISPRINT(cp)) {
 			stream_push_byte(err, cp);
 		} else if (cp == '\n') {
 			stream_push_s8(err, s8("\\n"));
 		} else if (cp == '\r') {
 			stream_push_s8(err, s8("\\r"));
 		} else if (cp == '\a') {
 			stream_push_s8(err, s8("\\a"));
 		} else {
 			stream_push_s8(err, s8("\\x"));
 			stream_push_hex_u64(err, cp);
 		}
 	}
 	stream_push_s8(err, s8("\n\t.cmd = "));
 	stream_push_u64(err, osc->cmd);
 	stream_push_s8(err, s8(", .arg = {.len = "));
 	stream_push_i64(err, osc->arg.len);
 	stream_push_s8(err, s8("}\n"));
 	os_write_err_msg(stream_to_s8(err));
 	stream_reset(err, 0);
 }
 
 function void
 handle_osc(Term *t, s8 *raw, Arena a)
 {
 	BEGIN_TIMED_BLOCK();
 	OSC osc;
 	if (!parse_osc(raw, &osc))
 		goto unknown;
 
 	Stream buffer = arena_stream(a);
 	switch (osc.cmd) {
 	case  0:
 	case  2: {
 		stream_push_s8(&buffer, osc.arg);
 		stream_push_byte(&buffer, 0);
 		t->os->set_window_title(stream_to_s8(&buffer));
 	} break;
 	case  1: break; /* IGNORED: set icon name */
 	default:
 	unknown:
 		stream_push_s8(&t->error_stream, s8("unhandled osc cmd: "));
 		dump_osc(&osc, &t->error_stream);
 		break;
 	}
 	END_TIMED_BLOCK();
 }
 
 function i32
 handle_escape(Term *t, s8 *raw, Arena a)
 {
 	BEGIN_TIMED_BLOCK();
 	i32 result = 0;
 	u32 cp = get_ascii(raw);
 	switch (cp) {
 	case '[': reset_csi(&t->csi, raw); t->escape |= EM_CSI; break;
 	case ']': handle_osc(t, raw, a); break;
 	case '%': /* utf-8 mode */
 		/* TODO: should this really be done here? */
 		if (!raw->len) {
 			result = 1;
 		} else {
 			switch (get_ascii(raw)) {
 			case 'G': t->mode.term |=  TM_UTF8; break;
 			case '@': t->mode.term &= ~TM_UTF8; break;
 			}
 		}
 		break;
 	case '(':   /* GZD4 -- set primary charset G0 */
 	case ')':   /* G1D4 -- set secondary charset G1 */
 	case '*':   /* G2D4 -- set tertiary charset G2 */
 	case '+': { /* G3D4 -- set quaternary charset G3 */
 		i32 index = cp - '(';
 		/* TODO: should this really be done here? */
 		if (!raw->len) {
 			result = 1;
 		} else {
 			u32 cs = get_ascii(raw);
 			switch (cs) {
 			case '0': t->cursor.charsets[index] = CS_GRAPHIC0; break;
 			case 'B': t->cursor.charsets[index] = CS_USA;      break;
 			default:
 				stream_push_s8(&t->error_stream, s8("unhandled charset: "));
 				stream_push_byte(&t->error_stream, cs);
 				stream_push_byte(&t->error_stream, '\n');
 				os_write_err_msg(stream_to_s8(&t->error_stream));
 				stream_reset(&t->error_stream, 0);
 				break;
 			}
 		}
 	} break;
 	case '=': /* DECPAM -- application keypad */
 	case '>': /* DECPNM -- normal keypad mode */
 		/* TODO: MODE_APPKEYPAD */
 		break;
 	case 'c': /* RIS -- Reset to Initial State */
 		term_reset(t);
 		break;
 	case 'D': /* IND -- Linefeed */
 		push_newline(t, 0);
 		break;
 	case 'E': /* NEL -- Next Line */
 		push_newline(t, 1);
 		break;
 	case 'H': /* HTS -- Horizontal Tab Stop */
 		term_tab_col(t, t->cursor.pos.x, 1);
 		break;
 	case 'M': /* RI  -- Reverse Index */
 		if (t->cursor.pos.y == t->top) {
 			fb_scroll_down(t, t->top, 1);
 		} else {
 			cursor_move_to(t, t->cursor.pos.y - 1, t->cursor.pos.x);
 		}
 		break;
 	case '7': /* DECSC: Save Cursor */
 		cursor_alt(t, 1);
 		break;
 	case '8': /* DECRC: Restore Cursor */
 		cursor_alt(t, 0);
 		break;
 	default:
 		stream_push_s8(&t->error_stream, s8("unknown escape sequence: ESC "));
 		stream_push_byte(&t->error_stream, cp);
 		stream_push_s8(&t->error_stream, s8(" (0x"));
 		stream_push_hex_u64(&t->error_stream, cp);
 		stream_push_s8(&t->error_stream, s8(")\n"));
 		os_write_err_msg(stream_to_s8(&t->error_stream));
 		stream_reset(&t->error_stream, 0);
 		break;
 	}
 	END_TIMED_BLOCK();
 	return result;
 }
 
 function i32
 push_control(Term *t, s8 *line, u32 cp, Arena a)
 {
 	i32 result = 0;
 	switch (cp) {
 	case 0x1B:
 		if (!line->len) result = 1;
 		else            result = handle_escape(t, line, a);
 		break;
 	case '\r': cursor_move_to(t, t->cursor.pos.y, 0);   break;
 	case '\n': push_newline(t, t->mode.term & TM_CRLF); break;
 	case '\t': push_tab(t, 1);                          break;
 	case '\a': /* TODO: ding ding? */                   break;
 	case '\b':
 		cursor_move_to(t, t->cursor.pos.y, t->cursor.pos.x - 1);
 		break;
 	case 0x0E: /* SO (LS1: Locking Shift 1) */
 	case 0x0F: /* SI (LS0: Locking Shift 0) */
 		t->cursor.charset_index = 1 - (cp - 0x0E);
 		break;
 	default:
 		stream_push_s8(&t->error_stream, s8("unknown control code: 0x"));
 		stream_push_hex_u64(&t->error_stream, cp);
 		stream_push_byte(&t->error_stream, '\n');
 		os_write_err_msg(stream_to_s8(&t->error_stream));
 		stream_reset(&t->error_stream, 0);
 		break;
 	}
 	if (cp != 0x1B) {
 		if (t->escape & EM_CSI) t->csi.raw.len++;
 	}
 	return result;
 }
 
 function void
 push_normal_cp(Term *t, TermView *tv, u32 cp)
 {
 	BEGIN_TIMED_BLOCK();
 
 	if (t->mode.term & TM_AUTO_WRAP && t->cursor.state & CURSOR_WRAP_NEXT)
 		push_newline(t, 1);
 
 	if (t->cursor.charsets[t->cursor.charset_index] == CS_GRAPHIC0 && BETWEEN(cp, 0x60, 0x7e))
 		cp = graphic_0[cp - 0x60];
 
 	i32 width = 1;
 	if (cp > 0x7F) {
 		width = wcwidth(cp);
 		ASSERT(width != -1);
 	}
 
 	/* NOTE: make this '>=' for fun in vis */
 	if (t->cursor.pos.x + width > t->size.w) {
 		/* NOTE: make space for character if mode enabled else
 		 * clobber whatever was on the end of the line */
 		if (t->mode.term & TM_AUTO_WRAP)
 			push_newline(t, 1);
 		else
 			cursor_move_to(t, t->cursor.pos.y, t->size.w - width);
 	}
 
 	Cell *c = &tv->fb.rows[t->cursor.pos.y][t->cursor.pos.x];
 	/* TODO: pack cell into ssbo */
 	c->cp   = cp;
 	c->fg   = SHADER_PACK_FG(t->cursor.style.fg.rgba, t->cursor.style.attr);
 	c->bg   = SHADER_PACK_BG(t->cursor.style.bg.rgba, t->cursor.style.attr);
 
 	if (width > 1) {
 		ASSERT(t->cursor.pos.x + (width - 1) < t->size.w);
 		c[0].bg |= ATTR_WIDE;
 		c[1].bg |= ATTR_WDUMMY;
 	}
 
 	if (t->cursor.pos.x + width < t->size.w)
 		cursor_step_column(t, width);
 	else
 		t->cursor.state |= CURSOR_WRAP_NEXT;
 
 	/* TODO: region detection */
 	if (is_selected(&t->selection, t->cursor.pos.x, t->cursor.pos.y))
 		selection_clear(&t->selection);
 
 	END_TIMED_BLOCK();
 }
 
 function void
 push_line(Term *t, Line *line, Arena a)
 {
 	BEGIN_TIMED_BLOCK();
 
 	TermView *tv    = t->views + t->view_idx;
 	s8 l            = line_to_s8(line);
 	t->cursor.style = line->cursor_state;
 
 	while (l.len) {
 		u32 cp;
 		if (line->has_unicode) cp = get_utf8(&l);
 		else                   cp = get_ascii(&l);
 
 		ASSERT(cp != (u32)-1);
 		if (ISCONTROL(cp)) {
 			if (!(t->mode.term & TM_UTF8) || !ISCONTROLC1(cp))
 				push_control(t, &l, cp, a);
 			continue;
 		} else if (t->escape & EM_CSI) {
 			t->csi.raw.len++;
 			if (BETWEEN(cp, '@', '~')) {
 				handle_csi(t, &t->csi);
 				t->escape &= ~EM_CSI;
 			}
 			continue;
 		}
 
 		push_normal_cp(t, tv, cp);
 	}
 	END_TIMED_BLOCK();
 }
 
 function iz
 get_line_idx(LineBuffer *lb, iz off)
 {
 	ASSERT(-off <= lb->filled);
 	iz result = lb->count + off;
 	if (result < 0)
 		result += lb->filled;
 	return result;
 }
 
 function void
 blit_lines(Term *t, Arena a)
 {
 	BEGIN_TIMED_BLOCK();
 
 	ASSERT(t->state & TS_NEEDS_REFILL);
 	term_reset(t);
 
 	TermView *tv  = t->views + t->view_idx;
 	iz line_count = t->size.h - 1;
 	iz off        = t->scroll_offset;
 	CLAMP(line_count, 0, tv->lines.filled);
 	for (iz idx = -line_count; idx <= 0; idx++) {
 		iz line_idx = get_line_idx(&tv->lines, idx - off);
 		push_line(t, tv->lines.data + line_idx, a);
 	}
 
 	t->state &= ~TS_NEEDS_REFILL;
 
 	END_TIMED_BLOCK();
 }
 
 function void
 handle_input(Term *t, Arena a, s8 raw)
 {
 	BEGIN_TIMED_BLOCK();
 
 	TermView *tv = t->views + t->view_idx;
 
 	/* TODO: SIMD look ahead */
 	while (raw.len) {
 		iz start_len = raw.len;
 		u32 cp = peek(raw, 0);
 		/* TODO: this could be a performance issue; may need seperate code path for
 		 * terminal when not in UTF8 mode */
 		if (cp > 0x7F && (t->mode.term & TM_UTF8)) {
 			cp = get_utf8(&raw);
 			if (cp == (u32)-1 && start_len < 4) {
 				/* NOTE: Need More Bytes! */
 				goto end;
 			} else if (cp == (u32)-1 && start_len >= 4) {
 				/* NOTE(rnp): invalid/garbage cp; treat as ASCII control char */
 				cp = get_ascii(&raw);
 			} else if (cp != (u32)-1) {
 				tv->lines.data[tv->lines.count].has_unicode = 1;
 			}
 		} else {
 			cp = get_ascii(&raw);
 		}
 
 		ASSERT(cp != (u32)-1);
 
 		if (ISCONTROL(cp)) {
 			if (!(t->mode.term & TM_UTF8) || !ISCONTROLC1(cp)) {
 				i32 old_curs_y = t->cursor.pos.y;
 				if (push_control(t, &raw, cp, a)) {
 					raw.len = start_len;
 					goto end;
 				}
 				if (!t->escape && (cp == '\n' || t->cursor.pos.y != old_curs_y))
 					feed_line(&tv->lines, raw.data, t->cursor.style);
 			}
 			continue;
 		} else if (t->escape & EM_CSI) {
 			t->csi.raw.len++;
 			if (BETWEEN(cp, '@', '~')) {
 				i32 old_curs_y = t->cursor.pos.y;
 				u32 mode = t->mode.term & TM_ALTSCREEN;
 				handle_csi(t, &t->csi);
 				t->escape &= ~EM_CSI;
 				if ((t->mode.term & TM_ALTSCREEN) != mode) {
 					u8 *old = raw.data - t->csi.raw.len - 2;
 					ASSERT(*old == 0x1B);
 					feed_line(&tv->lines, old, t->cursor.style);
 					TermView *nv = t->views + t->view_idx;
 					iz nstart    = nv->log.write_index;
 					mem_copy(nv->log.data + nstart, raw.data, raw.len);
 					commit_to_rb(tv, -raw.len);
 					commit_to_rb(nv,  raw.len);
 					raw.data = nv->log.data + nstart;
 					init_line(nv->lines.data + nv->lines.count, raw.data,
 					          t->cursor.style);
 					tv = nv;
 				} else if (t->cursor.pos.y != old_curs_y) {
 					feed_line(&tv->lines, raw.data, t->cursor.style);
 				}
 			}
 			continue;
 		}
 
 		push_normal_cp(t, tv, cp);
 
 	}
 end:
 	tv->lines.data[tv->lines.count].end = raw.data;
 
 	/* TODO: this shouldn't be needed */
 	if (tv->lines.data[tv->lines.count].end < tv->lines.data[tv->lines.count].start)
 		tv->lines.data[tv->lines.count].start -= tv->log.capacity;
 
 	if (!t->escape && line_length(tv->lines.data + tv->lines.count) > SPLIT_LONG)
 		feed_line(&tv->lines, raw.data, t->cursor.style);
 
 	t->unprocessed_bytes = raw.len;
 	END_TIMED_BLOCK();
 }