forked from NotAShelf/beer
NotAShelf
5cba919c78Signed-off-by: NotAShelf <raf@notashelf.dev> Change-Id: I9cace0b7c6995c0fca21ff2cf465ae1f6a6a6964
1018 lines
34 KiB
Rust
1018 lines
34 KiB
Rust
//! VT emulation: feed bytes through `vte` and drive the [`Grid`].
|
|
|
|
mod perform;
|
|
|
|
use std::io::Write as _;
|
|
|
|
use vte::Params;
|
|
|
|
use crate::grid::{
|
|
Color, CursorShape, Flags, Grid, MouseEncoding, MouseProtocol, PromptKind, Underline,
|
|
};
|
|
use crate::theme::{Rgb, Theme};
|
|
|
|
/// G0/G1 character set designation.
|
|
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
|
|
enum Charset {
|
|
Ascii,
|
|
DecSpecial,
|
|
}
|
|
|
|
/// Which device-attributes query is being answered.
|
|
#[derive(Clone, Copy, Debug)]
|
|
enum DaLevel {
|
|
Primary,
|
|
Secondary,
|
|
Tertiary,
|
|
}
|
|
|
|
/// A clipboard request from the application (OSC 52), for the front-end to act
|
|
/// on since it owns the Wayland selections.
|
|
#[derive(Clone, Debug)]
|
|
pub enum ClipboardOp {
|
|
/// Set the clipboard (or primary) to `text`.
|
|
Set { primary: bool, text: String },
|
|
/// Report the current clipboard (or primary) contents back to the app.
|
|
Query { primary: bool },
|
|
}
|
|
|
|
/// A desktop notification an application requested (OSC 9 / 777 / 99), for the
|
|
/// front-end to deliver via the configured notifier.
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub struct Notification {
|
|
pub title: Option<String>,
|
|
pub body: String,
|
|
}
|
|
|
|
/// Which dynamic colour an OSC 10/11/17/19 escape targets.
|
|
#[derive(Clone, Copy, Debug)]
|
|
enum Dynamic {
|
|
Fg,
|
|
Bg,
|
|
SelBg,
|
|
SelFg,
|
|
}
|
|
|
|
/// DECRQM mode-state code: 1 = set, 2 = reset.
|
|
fn set_reset(on: bool) -> u8 {
|
|
if on { 1 } else { 2 }
|
|
}
|
|
|
|
/// Parse an OSC colour spec into an [`Rgb`].
|
|
fn parse_spec(spec: &[u8]) -> Option<Rgb> {
|
|
std::str::from_utf8(spec)
|
|
.ok()
|
|
.and_then(crate::theme::parse_color)
|
|
}
|
|
|
|
/// Parse a decimal palette index (0-255).
|
|
fn parse_index(b: &[u8]) -> Option<u8> {
|
|
std::str::from_utf8(b).ok()?.parse().ok()
|
|
}
|
|
|
|
fn rgb_tuple(rgb: Rgb) -> (u8, u8, u8) {
|
|
(rgb.0, rgb.1, rgb.2)
|
|
}
|
|
|
|
/// Select `protocol` when a mouse mode is set, else turn reporting off.
|
|
fn proto(on: bool, protocol: MouseProtocol) -> MouseProtocol {
|
|
if on { protocol } else { MouseProtocol::Off }
|
|
}
|
|
|
|
/// Select `encoding` when its mode is set, else fall back to the default form.
|
|
fn enc(on: bool, encoding: MouseEncoding) -> MouseEncoding {
|
|
if on { encoding } else { MouseEncoding::X10 }
|
|
}
|
|
|
|
/// Map an SGR 4 param (`4` or `4:x`) to an underline style.
|
|
fn underline_from(param: &[u16]) -> Underline {
|
|
match param.get(1).copied().unwrap_or(1) {
|
|
0 => Underline::None,
|
|
2 => Underline::Double,
|
|
3 => Underline::Curly,
|
|
4 => Underline::Dotted,
|
|
5 => Underline::Dashed,
|
|
_ => Underline::Single,
|
|
}
|
|
}
|
|
|
|
/// The terminal model: a grid plus the escape-sequence state around it.
|
|
#[derive(Debug)]
|
|
pub struct Term {
|
|
grid: Grid,
|
|
title: Option<String>,
|
|
title_stack: Vec<Option<String>>,
|
|
response: Vec<u8>,
|
|
g0: Charset,
|
|
g1: Charset,
|
|
shift_out: bool,
|
|
/// Accumulated payload of an in-progress `DCS + q` (XTGETTCAP) query.
|
|
xtgettcap: Option<Vec<u8>>,
|
|
/// Pending OSC 52 clipboard requests, drained by the front-end.
|
|
clipboard_ops: Vec<ClipboardOp>,
|
|
/// The active colour scheme (seeded from config, mutated by OSC escapes).
|
|
theme: Theme,
|
|
/// Set when the child rings the bell (`BEL`); cleared by the front-end.
|
|
bell: bool,
|
|
/// Working directory reported by the shell via OSC 7, for new windows.
|
|
cwd: Option<String>,
|
|
/// Desktop notifications requested via OSC 9/777/99, drained by the front-end.
|
|
notifications: Vec<Notification>,
|
|
}
|
|
|
|
impl Term {
|
|
pub fn new(cols: usize, rows: usize) -> Self {
|
|
Self {
|
|
grid: Grid::new(cols, rows),
|
|
title: None,
|
|
title_stack: Vec::new(),
|
|
response: Vec::new(),
|
|
g0: Charset::Ascii,
|
|
g1: Charset::Ascii,
|
|
shift_out: false,
|
|
xtgettcap: None,
|
|
clipboard_ops: Vec::new(),
|
|
theme: Theme::default(),
|
|
bell: false,
|
|
cwd: None,
|
|
notifications: Vec::new(),
|
|
}
|
|
}
|
|
|
|
/// The working directory last reported by the shell (OSC 7), if any.
|
|
pub fn cwd(&self) -> Option<&str> {
|
|
self.cwd.as_deref()
|
|
}
|
|
|
|
/// Drain the desktop notifications requested since the last call.
|
|
pub fn take_notifications(&mut self) -> Vec<Notification> {
|
|
std::mem::take(&mut self.notifications)
|
|
}
|
|
|
|
/// Take and clear the pending bell flag.
|
|
pub fn take_bell(&mut self) -> bool {
|
|
std::mem::take(&mut self.bell)
|
|
}
|
|
|
|
/// Drain the OSC 52 clipboard requests accumulated since the last call.
|
|
pub fn take_clipboard_ops(&mut self) -> Vec<ClipboardOp> {
|
|
std::mem::take(&mut self.clipboard_ops)
|
|
}
|
|
|
|
pub fn theme(&self) -> &Theme {
|
|
&self.theme
|
|
}
|
|
|
|
/// Replace the colour scheme (config load / reload).
|
|
pub fn set_theme(&mut self, theme: Theme) {
|
|
self.theme = theme;
|
|
}
|
|
|
|
/// Answer an XTGETTCAP query: for each hex-encoded capability name, reply
|
|
/// with `DCS 1 + r name=value ST` if known, else `DCS 0 + r name ST`.
|
|
fn answer_xtgettcap(&mut self, payload: &[u8]) {
|
|
for name_hex in payload.split(|&b| b == b';') {
|
|
let value = decode_hex(name_hex).and_then(|name| cap_value(&name));
|
|
match value {
|
|
Some(value) => {
|
|
self.response.extend_from_slice(b"\x1bP1+r");
|
|
self.response.extend_from_slice(name_hex);
|
|
self.response.push(b'=');
|
|
for byte in value.bytes() {
|
|
let _ = write!(self.response, "{byte:02x}");
|
|
}
|
|
self.response.extend_from_slice(b"\x1b\\");
|
|
}
|
|
None => {
|
|
self.response.extend_from_slice(b"\x1bP0+r");
|
|
self.response.extend_from_slice(name_hex);
|
|
self.response.extend_from_slice(b"\x1b\\");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn grid(&self) -> &Grid {
|
|
&self.grid
|
|
}
|
|
|
|
pub fn grid_mut(&mut self) -> &mut Grid {
|
|
&mut self.grid
|
|
}
|
|
|
|
pub fn resize(&mut self, cols: usize, rows: usize) {
|
|
self.grid.resize(cols, rows);
|
|
}
|
|
|
|
pub fn scroll_view(&mut self, delta: isize) {
|
|
self.grid.scroll_view(delta);
|
|
}
|
|
|
|
pub fn scroll_to_bottom(&mut self) {
|
|
self.grid.scroll_to_bottom();
|
|
}
|
|
|
|
/// Lines per page, for page-scroll bindings.
|
|
pub fn page(&self) -> usize {
|
|
self.grid.page()
|
|
}
|
|
|
|
pub fn title(&self) -> Option<&str> {
|
|
self.title.as_deref()
|
|
}
|
|
|
|
/// Bytes the terminal needs to send back to the application (DA, CPR, ...).
|
|
pub fn take_response(&mut self) -> Vec<u8> {
|
|
std::mem::take(&mut self.response)
|
|
}
|
|
|
|
fn active_charset(&self) -> Charset {
|
|
if self.shift_out { self.g1 } else { self.g0 }
|
|
}
|
|
|
|
fn set_mode(&mut self, params: &Params, private: bool, on: bool) {
|
|
for p in params.iter() {
|
|
let Some(&code) = p.first() else { continue };
|
|
match (private, code) {
|
|
(true, 6) => self.grid.set_origin(on),
|
|
(true, 7) => self.grid.set_autowrap(on),
|
|
(true, 1049) => {
|
|
if on {
|
|
self.grid.save_cursor();
|
|
self.grid.enter_alt_screen();
|
|
self.grid.erase_display(2);
|
|
} else {
|
|
self.grid.leave_alt_screen();
|
|
self.grid.restore_cursor();
|
|
}
|
|
}
|
|
(true, 47 | 1047) => {
|
|
if on {
|
|
self.grid.enter_alt_screen();
|
|
} else {
|
|
self.grid.leave_alt_screen();
|
|
}
|
|
}
|
|
(false, 4) => self.grid.set_insert(on),
|
|
(true, 1) => self.grid.set_app_cursor(on),
|
|
(true, 25) => self.grid.set_cursor_visible(on),
|
|
(true, 9) => self.grid.set_mouse_protocol(proto(on, MouseProtocol::X10)),
|
|
(true, 1000) => self
|
|
.grid
|
|
.set_mouse_protocol(proto(on, MouseProtocol::Normal)),
|
|
(true, 1002) => self
|
|
.grid
|
|
.set_mouse_protocol(proto(on, MouseProtocol::Button)),
|
|
(true, 1003) => self.grid.set_mouse_protocol(proto(on, MouseProtocol::Any)),
|
|
(true, 1004) => self.grid.set_focus_events(on),
|
|
(true, 1005) => self.grid.set_mouse_encoding(enc(on, MouseEncoding::Utf8)),
|
|
(true, 1006) => self.grid.set_mouse_encoding(enc(on, MouseEncoding::Sgr)),
|
|
(true, 2004) => self.grid.set_bracketed_paste(on),
|
|
(true, 2026) => self.grid.set_sync(on),
|
|
_ => tracing::trace!("unhandled mode {code} private={private} on={on}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn sgr(&mut self, params: &Params) {
|
|
let items: Vec<&[u16]> = params.iter().collect();
|
|
if items.is_empty() {
|
|
self.grid.reset_pen();
|
|
return;
|
|
}
|
|
let mut i = 0;
|
|
while i < items.len() {
|
|
let p = items[i];
|
|
let code = p.first().copied().unwrap_or(0);
|
|
let pen = self.grid.pen_mut();
|
|
let mut step = 1;
|
|
match code {
|
|
0 => *pen = Default::default(),
|
|
1 => pen.flags.insert(Flags::BOLD),
|
|
2 => pen.flags.insert(Flags::DIM),
|
|
3 => pen.flags.insert(Flags::ITALIC),
|
|
4 => pen.underline = underline_from(p),
|
|
5 | 6 => pen.flags.insert(Flags::BLINK),
|
|
7 => pen.flags.insert(Flags::REVERSE),
|
|
8 => pen.flags.insert(Flags::HIDDEN),
|
|
9 => pen.flags.insert(Flags::STRIKE),
|
|
21 => pen.underline = Underline::Double,
|
|
22 => pen.flags.remove(Flags::BOLD.union(Flags::DIM)),
|
|
23 => pen.flags.remove(Flags::ITALIC),
|
|
24 => pen.underline = Underline::None,
|
|
25 => pen.flags.remove(Flags::BLINK),
|
|
27 => pen.flags.remove(Flags::REVERSE),
|
|
28 => pen.flags.remove(Flags::HIDDEN),
|
|
29 => pen.flags.remove(Flags::STRIKE),
|
|
30..=37 => pen.fg = Color::Indexed((code - 30) as u8),
|
|
39 => pen.fg = Color::Default,
|
|
40..=47 => pen.bg = Color::Indexed((code - 40) as u8),
|
|
49 => pen.bg = Color::Default,
|
|
53 => pen.flags.insert(Flags::OVERLINE),
|
|
55 => pen.flags.remove(Flags::OVERLINE),
|
|
90..=97 => pen.fg = Color::Indexed((code - 90 + 8) as u8),
|
|
100..=107 => pen.bg = Color::Indexed((code - 100 + 8) as u8),
|
|
38 | 48 | 58 => {
|
|
let (color, consumed) = ext_color(&items, i);
|
|
if let Some(color) = color {
|
|
match code {
|
|
38 => pen.fg = color,
|
|
48 => pen.bg = color,
|
|
_ => pen.underline_color = color,
|
|
}
|
|
}
|
|
step = consumed;
|
|
}
|
|
59 => pen.underline_color = Color::Default,
|
|
_ => {}
|
|
}
|
|
i += step;
|
|
}
|
|
}
|
|
|
|
/// Device attributes. DA1 claims a VT220 with ANSI colour; DA2 a generic
|
|
/// firmware level; DA3 a (zero) unit ID.
|
|
fn device_attrs(&mut self, level: DaLevel) {
|
|
match level {
|
|
DaLevel::Primary => self.response.extend_from_slice(b"\x1b[?62;22c"),
|
|
DaLevel::Secondary => self.response.extend_from_slice(b"\x1b[>0;276;0c"),
|
|
DaLevel::Tertiary => self.response.extend_from_slice(b"\x1bP!|00000000\x1b\\"),
|
|
}
|
|
}
|
|
|
|
/// XTVERSION (`CSI > q`): report the terminal name and version.
|
|
fn report_version(&mut self) {
|
|
let _ = write!(
|
|
self.response,
|
|
"\x1bP>|beer({})\x1b\\",
|
|
env!("CARGO_PKG_VERSION")
|
|
);
|
|
}
|
|
|
|
/// Emit an OSC colour reply (`OSC code ; rgb:rrrr/gggg/bbbb` + terminator).
|
|
fn reply_color(&mut self, code: &str, rgb: Rgb, bell: bool) {
|
|
let Rgb(r, g, b) = rgb;
|
|
let _ = write!(
|
|
self.response,
|
|
"\x1b]{code};rgb:{:04x}/{:04x}/{:04x}",
|
|
u16::from(r) * 0x101,
|
|
u16::from(g) * 0x101,
|
|
u16::from(b) * 0x101,
|
|
);
|
|
self.response
|
|
.extend_from_slice(if bell { b"\x07" } else { b"\x1b\\" });
|
|
}
|
|
|
|
/// OSC 4: set or query palette entries, given as `index;spec` pairs.
|
|
fn osc_palette(&mut self, params: &[&[u8]], bell: bool) {
|
|
let mut rest = params[1..].iter();
|
|
while let (Some(idx_raw), Some(spec)) = (rest.next(), rest.next()) {
|
|
let Some(idx) = parse_index(idx_raw) else {
|
|
continue;
|
|
};
|
|
if *spec == b"?" {
|
|
let rgb = self.theme.palette[idx as usize];
|
|
self.reply_color(&format!("4;{idx}"), rgb, bell);
|
|
} else if let Some(rgb) = parse_spec(spec) {
|
|
self.theme.set_palette(idx, rgb);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// OSC 10/11/17/19: set or query a dynamic colour.
|
|
fn osc_dynamic_color(&mut self, kind: Dynamic, spec: Option<&&[u8]>, bell: bool) {
|
|
let Some(spec) = spec else { return };
|
|
if **spec == b"?"[..] {
|
|
let rgb = match kind {
|
|
Dynamic::Fg => self.theme.fg,
|
|
Dynamic::Bg => self.theme.bg,
|
|
Dynamic::SelBg => self.theme.selection_bg,
|
|
Dynamic::SelFg => self.theme.selection_fg.unwrap_or(self.theme.fg),
|
|
};
|
|
let code = match kind {
|
|
Dynamic::Fg => "10",
|
|
Dynamic::Bg => "11",
|
|
Dynamic::SelBg => "17",
|
|
Dynamic::SelFg => "19",
|
|
};
|
|
self.reply_color(code, rgb, bell);
|
|
} else if let Some(rgb) = parse_spec(spec) {
|
|
match kind {
|
|
Dynamic::Fg => self.theme.fg = rgb,
|
|
Dynamic::Bg => self.theme.bg = rgb,
|
|
Dynamic::SelBg => self.theme.selection_bg = rgb,
|
|
Dynamic::SelFg => self.theme.selection_fg = Some(rgb),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn device_status(&mut self, params: &Params) {
|
|
match params.iter().next().and_then(|p| p.first().copied()) {
|
|
Some(5) => self.response.extend_from_slice(b"\x1b[0n"),
|
|
Some(6) => {
|
|
let (x, y) = self.grid.cursor();
|
|
let _ = write!(self.response, "\x1b[{};{}R", y + 1, x + 1);
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
/// DECRQM (`CSI [?] Ps $ p`): report whether a mode is set (1), reset (2),
|
|
/// or unrecognized (0). Only the modes we actually track are reported.
|
|
fn report_mode(&mut self, params: &Params, private: bool) {
|
|
let code = raw(params, 0);
|
|
let state = match (private, code) {
|
|
(true, 6) => set_reset(self.grid.origin()),
|
|
(true, 7) => set_reset(self.grid.autowrap()),
|
|
(true, 47 | 1047 | 1049) => set_reset(self.grid.alt_active()),
|
|
(true, 9) => set_reset(self.grid.mouse_protocol() == MouseProtocol::X10),
|
|
(true, 1000) => set_reset(self.grid.mouse_protocol() == MouseProtocol::Normal),
|
|
(true, 1002) => set_reset(self.grid.mouse_protocol() == MouseProtocol::Button),
|
|
(true, 1003) => set_reset(self.grid.mouse_protocol() == MouseProtocol::Any),
|
|
(true, 1004) => set_reset(self.grid.focus_events()),
|
|
(true, 1005) => set_reset(self.grid.mouse_encoding() == MouseEncoding::Utf8),
|
|
(true, 1006) => set_reset(self.grid.mouse_encoding() == MouseEncoding::Sgr),
|
|
(true, 2004) => set_reset(self.grid.bracketed_paste()),
|
|
(true, 2026) => set_reset(self.grid.sync_active()),
|
|
(false, 4) => set_reset(self.grid.insert()),
|
|
_ => 0,
|
|
};
|
|
let prefix = if private { "?" } else { "" };
|
|
let _ = write!(self.response, "\x1b[{prefix}{code};{state}$y");
|
|
}
|
|
|
|
/// Title stack (`CSI 22/23 ; Ps t`): push or pop the window title.
|
|
fn title_stack_op(&mut self, params: &Params) {
|
|
match raw(params, 0) {
|
|
22 => self.title_stack.push(self.title.clone()),
|
|
23 => {
|
|
if let Some(title) = self.title_stack.pop() {
|
|
self.title = title;
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// First param value, with 0/absent folded to `default` (xterm convention for
|
|
/// cursor movement and counts).
|
|
fn n(params: &Params, idx: usize, default: usize) -> usize {
|
|
match params.iter().nth(idx).and_then(|p| p.first().copied()) {
|
|
Some(0) | None => default,
|
|
Some(v) => v as usize,
|
|
}
|
|
}
|
|
|
|
/// Raw first param value (0 is meaningful), defaulting to 0 when absent.
|
|
fn raw(params: &Params, idx: usize) -> u16 {
|
|
params
|
|
.iter()
|
|
.nth(idx)
|
|
.and_then(|p| p.first().copied())
|
|
.unwrap_or(0)
|
|
}
|
|
|
|
/// Parse an SGR 38/48 extended colour, returning the colour and how many
|
|
/// top-level params it consumed (1 for colon form, more for semicolon form).
|
|
fn ext_color(items: &[&[u16]], i: usize) -> (Option<Color>, usize) {
|
|
let head = items[i];
|
|
if head.len() >= 2 {
|
|
return (color_from_subparams(&head[1..]), 1);
|
|
}
|
|
match items.get(i + 1).and_then(|s| s.first().copied()) {
|
|
Some(5) => {
|
|
let idx = items
|
|
.get(i + 2)
|
|
.and_then(|s| s.first().copied())
|
|
.unwrap_or(0);
|
|
(Some(Color::Indexed(idx as u8)), 3)
|
|
}
|
|
Some(2) => {
|
|
let get = |k: usize| {
|
|
items
|
|
.get(i + k)
|
|
.and_then(|s| s.first().copied())
|
|
.unwrap_or(0)
|
|
};
|
|
(
|
|
Some(Color::Rgb(get(2) as u8, get(3) as u8, get(4) as u8)),
|
|
5,
|
|
)
|
|
}
|
|
_ => (None, 1),
|
|
}
|
|
}
|
|
|
|
fn color_from_subparams(sub: &[u16]) -> Option<Color> {
|
|
match sub.first().copied() {
|
|
Some(5) => sub.get(1).map(|&i| Color::Indexed(i as u8)),
|
|
Some(2) => {
|
|
// Either `2:r:g:b` or `2:colorspace:r:g:b`.
|
|
let rgb = if sub.len() >= 5 {
|
|
&sub[2..5]
|
|
} else {
|
|
&sub[1..]
|
|
};
|
|
match rgb {
|
|
[r, g, b, ..] => Some(Color::Rgb(*r as u8, *g as u8, *b as u8)),
|
|
_ => None,
|
|
}
|
|
}
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn charset(byte: u8) -> Charset {
|
|
match byte {
|
|
b'0' => Charset::DecSpecial,
|
|
_ => Charset::Ascii,
|
|
}
|
|
}
|
|
|
|
/// Translate a byte under the DEC special graphics set (line drawing).
|
|
fn dec_special(c: char) -> char {
|
|
match c {
|
|
'`' => '◆',
|
|
'a' => '▒',
|
|
'f' => '°',
|
|
'g' => '±',
|
|
'j' => '┘',
|
|
'k' => '┐',
|
|
'l' => '┌',
|
|
'm' => '└',
|
|
'n' => '┼',
|
|
'o' => '⎺',
|
|
'p' => '⎻',
|
|
'q' => '─',
|
|
'r' => '⎼',
|
|
's' => '⎽',
|
|
't' => '├',
|
|
'u' => '┤',
|
|
'v' => '┴',
|
|
'w' => '┬',
|
|
'x' => '│',
|
|
'y' => '≤',
|
|
'z' => '≥',
|
|
'~' => '·',
|
|
_ => c,
|
|
}
|
|
}
|
|
|
|
/// Look up a terminfo capability beer reports via XTGETTCAP.
|
|
fn cap_value(name: &[u8]) -> Option<&'static str> {
|
|
match name {
|
|
b"TN" => Some("beer"),
|
|
b"Co" | b"colors" => Some("256"),
|
|
b"RGB" => Some("8/8/8"),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
const B64: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
|
|
/// Standard base64 encode (used for OSC 52 query replies).
|
|
pub fn base64_encode(data: &[u8]) -> String {
|
|
let mut out = String::with_capacity(data.len().div_ceil(3) * 4);
|
|
for chunk in data.chunks(3) {
|
|
let b = [
|
|
chunk[0],
|
|
*chunk.get(1).unwrap_or(&0),
|
|
*chunk.get(2).unwrap_or(&0),
|
|
];
|
|
let n = (u32::from(b[0]) << 16) | (u32::from(b[1]) << 8) | u32::from(b[2]);
|
|
out.push(B64[(n >> 18 & 63) as usize] as char);
|
|
out.push(B64[(n >> 12 & 63) as usize] as char);
|
|
out.push(if chunk.len() > 1 {
|
|
B64[(n >> 6 & 63) as usize] as char
|
|
} else {
|
|
'='
|
|
});
|
|
out.push(if chunk.len() > 2 {
|
|
B64[(n & 63) as usize] as char
|
|
} else {
|
|
'='
|
|
});
|
|
}
|
|
out
|
|
}
|
|
|
|
/// Standard base64 decode, ignoring padding and whitespace; `None` on a bad
|
|
/// character.
|
|
fn base64_decode(data: &[u8]) -> Option<Vec<u8>> {
|
|
let val = |c: u8| -> Option<u32> {
|
|
match c {
|
|
b'A'..=b'Z' => Some(u32::from(c - b'A')),
|
|
b'a'..=b'z' => Some(u32::from(c - b'a') + 26),
|
|
b'0'..=b'9' => Some(u32::from(c - b'0') + 52),
|
|
b'+' => Some(62),
|
|
b'/' => Some(63),
|
|
_ => None,
|
|
}
|
|
};
|
|
let filtered: Vec<u8> = data
|
|
.iter()
|
|
.copied()
|
|
.filter(|&c| c != b'=' && !c.is_ascii_whitespace())
|
|
.collect();
|
|
let mut out = Vec::with_capacity(filtered.len() / 4 * 3);
|
|
for chunk in filtered.chunks(4) {
|
|
if chunk.len() == 1 {
|
|
return None; // a lone sextet cannot form a byte
|
|
}
|
|
let mut n = 0u32;
|
|
for &c in chunk {
|
|
n = (n << 6) | val(c)?;
|
|
}
|
|
n <<= 6 * (4 - chunk.len() as u32);
|
|
out.push((n >> 16) as u8);
|
|
if chunk.len() >= 3 {
|
|
out.push((n >> 8) as u8);
|
|
}
|
|
if chunk.len() >= 4 {
|
|
out.push(n as u8);
|
|
}
|
|
}
|
|
Some(out)
|
|
}
|
|
|
|
/// Decode an OSC string field to UTF-8 (lossy), or `None` if absent.
|
|
fn osc_text(field: Option<&&[u8]>) -> Option<String> {
|
|
field.map(|b| String::from_utf8_lossy(b).into_owned())
|
|
}
|
|
|
|
/// Map an OSC 133 mark letter to a [`PromptKind`].
|
|
fn prompt_kind(b: u8) -> Option<PromptKind> {
|
|
match b {
|
|
b'A' => Some(PromptKind::PromptStart),
|
|
b'B' => Some(PromptKind::CmdStart),
|
|
b'C' => Some(PromptKind::OutputStart),
|
|
b'D' => Some(PromptKind::CmdEnd),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
/// Extract the local path from an OSC 7 `file://host/path` URI, percent-decoding
|
|
/// `%XX` escapes. The host part is ignored (we only spawn locally). Returns
|
|
/// `None` if it is not a usable absolute path.
|
|
fn file_uri_path(uri: &[u8]) -> Option<String> {
|
|
let rest = uri.strip_prefix(b"file://").unwrap_or(uri);
|
|
// Skip the authority (host) up to the first '/', which begins the path.
|
|
let slash = rest.iter().position(|&b| b == b'/')?;
|
|
let path_bytes = percent_decode(&rest[slash..]);
|
|
let path = String::from_utf8(path_bytes).ok()?;
|
|
path.starts_with('/').then_some(path)
|
|
}
|
|
|
|
/// Percent-decode `%XX` byte escapes in a URI path, passing other bytes through.
|
|
fn percent_decode(s: &[u8]) -> Vec<u8> {
|
|
let mut out = Vec::with_capacity(s.len());
|
|
let mut i = 0;
|
|
while i < s.len() {
|
|
if s[i] == b'%' && i + 2 < s.len() {
|
|
let hi = (s[i + 1] as char).to_digit(16);
|
|
let lo = (s[i + 2] as char).to_digit(16);
|
|
if let (Some(hi), Some(lo)) = (hi, lo) {
|
|
out.push((hi * 16 + lo) as u8);
|
|
i += 3;
|
|
continue;
|
|
}
|
|
}
|
|
out.push(s[i]);
|
|
i += 1;
|
|
}
|
|
out
|
|
}
|
|
|
|
/// Decode an even-length lowercase/uppercase hex string into bytes.
|
|
fn decode_hex(s: &[u8]) -> Option<Vec<u8>> {
|
|
if s.is_empty() || !s.len().is_multiple_of(2) {
|
|
return None;
|
|
}
|
|
let nibble = |b: u8| (b as char).to_digit(16).map(|d| d as u8);
|
|
s.chunks_exact(2)
|
|
.map(|pair| Some((nibble(pair[0])? << 4) | nibble(pair[1])?))
|
|
.collect()
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::grid::{MouseEncoding, MouseProtocol};
|
|
|
|
fn feed(term: &mut Term, bytes: &[u8]) {
|
|
let mut parser = vte::Parser::new();
|
|
parser.advance(term, bytes);
|
|
}
|
|
|
|
#[test]
|
|
fn plain_text_lands_in_the_grid() {
|
|
let mut t = Term::new(20, 4);
|
|
feed(&mut t, b"hello");
|
|
assert_eq!(t.grid().row_text(0), "hello");
|
|
}
|
|
|
|
#[test]
|
|
fn cursor_position_and_erase() {
|
|
let mut t = Term::new(20, 4);
|
|
feed(&mut t, b"abcde\x1b[Hxyz");
|
|
assert_eq!(t.grid().row_text(0), "xyzde");
|
|
}
|
|
|
|
#[test]
|
|
fn newline_sequence() {
|
|
let mut t = Term::new(20, 4);
|
|
feed(&mut t, b"one\r\ntwo");
|
|
assert_eq!(t.grid().row_text(0), "one");
|
|
assert_eq!(t.grid().row_text(1), "two");
|
|
}
|
|
|
|
#[test]
|
|
fn device_attributes_levels() {
|
|
let mut t = Term::new(20, 4);
|
|
feed(&mut t, b"\x1b[c");
|
|
assert_eq!(t.take_response(), b"\x1b[?62;22c");
|
|
feed(&mut t, b"\x1b[>c");
|
|
assert_eq!(t.take_response(), b"\x1b[>0;276;0c");
|
|
feed(&mut t, b"\x1b[=c");
|
|
assert_eq!(t.take_response(), b"\x1bP!|00000000\x1b\\");
|
|
}
|
|
|
|
#[test]
|
|
fn xtversion_reports_name() {
|
|
let mut t = Term::new(20, 4);
|
|
feed(&mut t, b"\x1b[>q");
|
|
let resp = t.take_response();
|
|
assert!(resp.starts_with(b"\x1bP>|beer("));
|
|
assert!(resp.ends_with(b")\x1b\\"));
|
|
}
|
|
|
|
#[test]
|
|
fn decrqm_reports_known_modes() {
|
|
let mut t = Term::new(20, 4);
|
|
feed(&mut t, b"\x1b[?7$p"); // autowrap, on by default
|
|
assert_eq!(t.take_response(), b"\x1b[?7;1$y");
|
|
feed(&mut t, b"\x1b[?7l\x1b[?7$p"); // turn it off, re-query
|
|
assert_eq!(t.take_response(), b"\x1b[?7;2$y");
|
|
feed(&mut t, b"\x1b[?9999$p"); // unknown mode
|
|
assert_eq!(t.take_response(), b"\x1b[?9999;0$y");
|
|
}
|
|
|
|
#[test]
|
|
fn sgr_underline_styles_and_lines() {
|
|
let mut t = Term::new(20, 1);
|
|
feed(&mut t, b"\x1b[4:3;58;5;1;53mX");
|
|
let cell = t.grid().cell(0, 0);
|
|
assert_eq!(cell.underline, Underline::Curly);
|
|
assert_eq!(cell.underline_color, Color::Indexed(1));
|
|
assert!(cell.flags.contains(Flags::OVERLINE));
|
|
// 4:0 turns the underline back off.
|
|
feed(&mut t, b"\x1b[4:0mY");
|
|
assert_eq!(t.grid().cell(1, 0).underline, Underline::None);
|
|
}
|
|
|
|
#[test]
|
|
fn decscusr_and_cursor_visibility() {
|
|
let mut t = Term::new(20, 1);
|
|
feed(&mut t, b"\x1b[4 q");
|
|
assert_eq!(t.grid().cursor_shape(), CursorShape::Underline);
|
|
feed(&mut t, b"\x1b[6 q");
|
|
assert_eq!(t.grid().cursor_shape(), CursorShape::Beam);
|
|
feed(&mut t, b"\x1b[0 q");
|
|
assert_eq!(t.grid().cursor_shape(), CursorShape::Block);
|
|
|
|
feed(&mut t, b"\x1b[?25l");
|
|
assert!(!t.grid().cursor_visible());
|
|
feed(&mut t, b"\x1b[?25h");
|
|
assert!(t.grid().cursor_visible());
|
|
}
|
|
|
|
#[test]
|
|
fn osc12_sets_and_resets_cursor_color() {
|
|
let mut t = Term::new(20, 1);
|
|
feed(&mut t, b"\x1b]12;#ff0000\x07");
|
|
assert_eq!(t.grid().cursor_color(), Some((255, 0, 0)));
|
|
feed(&mut t, b"\x1b]12;rgb:00/80/ff\x07");
|
|
assert_eq!(t.grid().cursor_color(), Some((0, 0x80, 0xff)));
|
|
feed(&mut t, b"\x1b]112\x07");
|
|
assert_eq!(t.grid().cursor_color(), None);
|
|
}
|
|
|
|
#[test]
|
|
fn decscusr_and_cursor_color() {
|
|
use crate::grid::CursorShape;
|
|
let mut t = Term::new(20, 1);
|
|
feed(&mut t, b"\x1b[5 q"); // blinking bar
|
|
assert_eq!(t.grid().cursor_shape(), CursorShape::Beam);
|
|
feed(&mut t, b"\x1b[4 q"); // steady underline
|
|
assert_eq!(t.grid().cursor_shape(), CursorShape::Underline);
|
|
feed(&mut t, b"\x1b]12;#ff3030\x07");
|
|
assert_eq!(t.grid().cursor_color(), Some((0xff, 0x30, 0x30)));
|
|
feed(&mut t, b"\x1b]112\x07");
|
|
assert_eq!(t.grid().cursor_color(), None);
|
|
feed(&mut t, b"\x1b[?25l"); // hide cursor
|
|
assert!(!t.grid().cursor_visible());
|
|
}
|
|
|
|
#[test]
|
|
fn osc_palette_and_dynamic_colors() {
|
|
use crate::theme::Rgb;
|
|
let mut t = Term::new(20, 2);
|
|
// Set palette index 1 and foreground via OSC, then query them back.
|
|
feed(&mut t, b"\x1b]4;1;#ff0000\x1b\\");
|
|
assert_eq!(t.theme().palette[1], Rgb(0xff, 0, 0));
|
|
feed(&mut t, b"\x1b]10;rgb:00/80/ff\x1b\\");
|
|
assert_eq!(t.theme().fg, Rgb(0, 0x80, 0xff));
|
|
feed(&mut t, b"\x1b]11;?\x07");
|
|
let resp = t.take_response();
|
|
assert!(resp.starts_with(b"\x1b]11;rgb:"));
|
|
// Reset returns the palette entry to its default.
|
|
feed(&mut t, b"\x1b]104;1\x1b\\");
|
|
assert_ne!(t.theme().palette[1], Rgb(0xff, 0, 0));
|
|
}
|
|
|
|
#[test]
|
|
fn xtgettcap_known_and_unknown() {
|
|
let mut t = Term::new(20, 1);
|
|
feed(&mut t, b"\x1bP+q544e\x1b\\"); // "TN"
|
|
assert_eq!(t.take_response(), b"\x1bP1+r544e=62656572\x1b\\"); // = "beer"
|
|
feed(&mut t, b"\x1bP+q6162\x1b\\"); // "ab", unknown
|
|
assert_eq!(t.take_response(), b"\x1bP0+r6162\x1b\\");
|
|
}
|
|
|
|
#[test]
|
|
fn bracketed_paste_and_sync_modes() {
|
|
let mut t = Term::new(20, 2);
|
|
feed(&mut t, b"\x1b[?2004h");
|
|
assert!(t.grid().bracketed_paste());
|
|
feed(&mut t, b"\x1b[?2004$p");
|
|
assert_eq!(t.take_response(), b"\x1b[?2004;1$y");
|
|
feed(&mut t, b"\x1b[?2026h");
|
|
assert!(t.grid().sync_active());
|
|
feed(&mut t, b"\x1b[?2026l\x1b[?2026$p");
|
|
assert!(!t.grid().sync_active());
|
|
assert_eq!(t.take_response(), b"\x1b[?2026;2$y");
|
|
}
|
|
|
|
#[test]
|
|
fn base64_round_trips() {
|
|
for s in [
|
|
"",
|
|
"f",
|
|
"fo",
|
|
"foo",
|
|
"foob",
|
|
"fooba",
|
|
"foobar",
|
|
"hi there\n",
|
|
] {
|
|
let enc = base64_encode(s.as_bytes());
|
|
assert_eq!(base64_decode(enc.as_bytes()).as_deref(), Some(s.as_bytes()));
|
|
}
|
|
assert_eq!(base64_encode(b"foobar"), "Zm9vYmFy");
|
|
assert_eq!(base64_decode(b"Zm9vYmFy").as_deref(), Some(&b"foobar"[..]));
|
|
}
|
|
|
|
#[test]
|
|
fn osc52_set_and_query() {
|
|
let mut t = Term::new(20, 2);
|
|
// Set clipboard to "hi" (base64 "aGk=").
|
|
feed(&mut t, b"\x1b]52;c;aGk=\x07");
|
|
let ops = t.take_clipboard_ops();
|
|
match ops.as_slice() {
|
|
[
|
|
ClipboardOp::Set {
|
|
primary: false,
|
|
text,
|
|
},
|
|
] => assert_eq!(text, "hi"),
|
|
other => panic!("unexpected ops: {other:?}"),
|
|
}
|
|
// Query the primary selection.
|
|
feed(&mut t, b"\x1b]52;p;?\x07");
|
|
let ops = t.take_clipboard_ops();
|
|
assert!(matches!(
|
|
ops.as_slice(),
|
|
[ClipboardOp::Query { primary: true }]
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn mouse_modes_track_protocol_and_encoding() {
|
|
let mut t = Term::new(20, 4);
|
|
feed(&mut t, b"\x1b[?1002h\x1b[?1006h");
|
|
assert_eq!(t.grid().mouse_protocol(), MouseProtocol::Button);
|
|
assert_eq!(t.grid().mouse_encoding(), MouseEncoding::Sgr);
|
|
feed(&mut t, b"\x1b[?1002$p");
|
|
assert_eq!(t.take_response(), b"\x1b[?1002;1$y");
|
|
feed(&mut t, b"\x1b[?1003h"); // any-event supersedes button-event
|
|
assert_eq!(t.grid().mouse_protocol(), MouseProtocol::Any);
|
|
feed(&mut t, b"\x1b[?1000l"); // turning a mouse mode off clears reporting
|
|
assert_eq!(t.grid().mouse_protocol(), MouseProtocol::Off);
|
|
feed(&mut t, b"\x1b[?1004h");
|
|
assert!(t.grid().focus_events());
|
|
}
|
|
|
|
#[test]
|
|
fn title_stack_push_pop() {
|
|
let mut t = Term::new(20, 4);
|
|
feed(&mut t, b"\x1b]0;first\x07");
|
|
feed(&mut t, b"\x1b[22t"); // push "first"
|
|
feed(&mut t, b"\x1b]0;second\x07");
|
|
assert_eq!(t.title(), Some("second"));
|
|
feed(&mut t, b"\x1b[23t"); // pop -> "first"
|
|
assert_eq!(t.title(), Some("first"));
|
|
}
|
|
|
|
#[test]
|
|
fn sgr_sets_pen_colours() {
|
|
let mut t = Term::new(20, 1);
|
|
feed(&mut t, b"\x1b[31;1mX");
|
|
let cell = t.grid().cell(0, 0);
|
|
assert_eq!(cell.fg, Color::Indexed(1));
|
|
assert!(cell.flags.contains(Flags::BOLD));
|
|
}
|
|
|
|
#[test]
|
|
fn truecolor_semicolon_and_colon() {
|
|
let mut t = Term::new(20, 1);
|
|
feed(&mut t, b"\x1b[38;2;10;20;30mA");
|
|
assert_eq!(t.grid().cell(0, 0).fg, Color::Rgb(10, 20, 30));
|
|
feed(&mut t, b"\x1b[38:2:40:50:60mB");
|
|
assert_eq!(t.grid().cell(1, 0).fg, Color::Rgb(40, 50, 60));
|
|
}
|
|
|
|
#[test]
|
|
fn device_status_reports_cursor() {
|
|
let mut t = Term::new(20, 4);
|
|
feed(&mut t, b"\x1b[3;5H\x1b[6n");
|
|
assert_eq!(t.take_response(), b"\x1b[3;5R");
|
|
}
|
|
|
|
#[test]
|
|
fn line_drawing_charset() {
|
|
let mut t = Term::new(20, 1);
|
|
feed(&mut t, b"\x1b(0qx\x1b(B");
|
|
assert_eq!(t.grid().row_text(0), "─│");
|
|
}
|
|
|
|
#[test]
|
|
fn osc133_marks_capture_last_command_output() {
|
|
let mut t = Term::new(12, 6);
|
|
feed(&mut t, b"\x1b]133;A\x07$ echo hi\r\n"); // prompt + typed command
|
|
feed(&mut t, b"\x1b]133;C\x07hi\r\n"); // output start, then output
|
|
feed(&mut t, b"\x1b]133;D\x07"); // command finished
|
|
assert_eq!(t.grid().last_command_output().as_deref(), Some("hi\n"));
|
|
}
|
|
|
|
#[test]
|
|
fn osc_notifications_collected() {
|
|
let mut t = Term::new(20, 2);
|
|
feed(&mut t, b"\x1b]9;hello\x07");
|
|
feed(&mut t, b"\x1b]777;notify;Title;Body\x07");
|
|
let n = t.take_notifications();
|
|
assert_eq!(
|
|
n,
|
|
vec![
|
|
Notification {
|
|
title: None,
|
|
body: "hello".into()
|
|
},
|
|
Notification {
|
|
title: Some("Title".into()),
|
|
body: "Body".into()
|
|
},
|
|
]
|
|
);
|
|
assert!(t.take_notifications().is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn osc7_tracks_cwd_and_decodes_percent() {
|
|
let mut t = Term::new(20, 1);
|
|
feed(&mut t, b"\x1b]7;file://hermes/home/user/my%20dir\x07");
|
|
assert_eq!(t.cwd(), Some("/home/user/my dir"));
|
|
// A non-file or relative URI leaves the previous value untouched? It
|
|
// simply does not match a path, so cwd stays None here.
|
|
let mut t2 = Term::new(20, 1);
|
|
feed(&mut t2, b"\x1b]7;file://host\x07");
|
|
assert_eq!(t2.cwd(), None);
|
|
}
|
|
|
|
#[test]
|
|
fn title_via_osc() {
|
|
let mut t = Term::new(20, 1);
|
|
feed(&mut t, b"\x1b]0;hello\x07");
|
|
assert_eq!(t.title(), Some("hello"));
|
|
}
|
|
|
|
#[test]
|
|
fn alt_screen_preserves_primary() {
|
|
let mut t = Term::new(20, 2);
|
|
feed(&mut t, b"main");
|
|
feed(&mut t, b"\x1b[?1049h");
|
|
assert_eq!(t.grid().row_text(0), "");
|
|
feed(&mut t, b"\x1b[?1049l");
|
|
assert_eq!(t.grid().row_text(0), "main");
|
|
}
|
|
}
|