@akiojin/gwt 9.7.0 → 9.8.1

package/vendor/vt100/src/lib.rs

@@ -0,0 +1,64 @@
+//! This crate parses a terminal byte stream and provides an in-memory
+//! representation of the rendered contents.
+//!
+//! # Overview
+//!
+//! This is essentially the terminal parser component of a graphical terminal
+//! emulator pulled out into a separate crate. Although you can use this crate
+//! to build a graphical terminal emulator, it also contains functionality
+//! necessary for implementing terminal applications that want to run other
+//! terminal applications - programs like `screen` or `tmux` for example.
+//!
+//! # Synopsis
+//!
+//! ```
+//! let mut parser = vt100::Parser::new(24, 80, 0);
+//!
+//! let screen = parser.screen().clone();
+//! parser.process(b"this text is \x1b[31mRED\x1b[m");
+//! assert_eq!(
+//!     parser.screen().cell(0, 13).unwrap().fgcolor(),
+//!     vt100::Color::Idx(1),
+//! );
+//!
+//! let screen = parser.screen().clone();
+//! parser.process(b"\x1b[3D\x1b[32mGREEN");
+//! assert_eq!(
+//!     parser.screen().contents_formatted(),
+//!     &b"\x1b[?25h\x1b[m\x1b[H\x1b[Jthis text is \x1b[32mGREEN"[..],
+//! );
+//! assert_eq!(
+//!     parser.screen().contents_diff(&screen),
+//!     &b"\x1b[1;14H\x1b[32mGREEN"[..],
+//! );
+//! ```
+
+#![warn(missing_docs)]
+#![warn(clippy::cargo)]
+#![warn(clippy::pedantic)]
+#![warn(clippy::nursery)]
+#![warn(clippy::as_conversions)]
+#![warn(clippy::get_unwrap)]
+#![allow(clippy::cognitive_complexity)]
+#![allow(clippy::missing_const_for_fn)]
+#![allow(clippy::similar_names)]
+#![allow(clippy::struct_excessive_bools)]
+#![allow(clippy::too_many_arguments)]
+#![allow(clippy::too_many_lines)]
+#![allow(clippy::type_complexity)]
+
+mod attrs;
+mod callbacks;
+mod cell;
+mod grid;
+mod parser;
+mod perform;
+mod row;
+mod screen;
+mod term;
+
+pub use attrs::Color;
+pub use callbacks::Callbacks;
+pub use cell::Cell;
+pub use parser::Parser;
+pub use screen::{MouseProtocolEncoding, MouseProtocolMode, Screen};

package/vendor/vt100/src/parser.rs

@@ -0,0 +1,96 @@
+/// A parser for terminal output which produces an in-memory representation of
+/// the terminal contents.
+pub struct Parser<CB: crate::callbacks::Callbacks = ()> {
+    parser: vte::Parser,
+    screen: crate::perform::WrappedScreen<CB>,
+}
+
+impl Parser {
+    /// Creates a new terminal parser of the given size and with the given
+    /// amount of scrollback.
+    #[must_use]
+    pub fn new(rows: u16, cols: u16, scrollback_len: usize) -> Self {
+        Self {
+            parser: vte::Parser::new(),
+            screen: crate::perform::WrappedScreen::new(
+                rows,
+                cols,
+                scrollback_len,
+            ),
+        }
+    }
+}
+
+impl<CB: crate::callbacks::Callbacks> Parser<CB> {
+    /// Creates a new terminal parser of the given size and with the given
+    /// amount of scrollback. Terminal events will be reported via method
+    /// calls on the provided [`Callbacks`](crate::callbacks::Callbacks)
+    /// implementation.
+    pub fn new_with_callbacks(
+        rows: u16,
+        cols: u16,
+        scrollback_len: usize,
+        callbacks: CB,
+    ) -> Self {
+        Self {
+            parser: vte::Parser::new(),
+            screen: crate::perform::WrappedScreen::new_with_callbacks(
+                rows,
+                cols,
+                scrollback_len,
+                callbacks,
+            ),
+        }
+    }
+
+    /// Processes the contents of the given byte string, and updates the
+    /// in-memory terminal state.
+    pub fn process(&mut self, bytes: &[u8]) {
+        self.parser.advance(&mut self.screen, bytes);
+    }
+
+    /// Returns a reference to a [`Screen`](crate::Screen) object containing
+    /// the terminal state.
+    #[must_use]
+    pub fn screen(&self) -> &crate::Screen {
+        &self.screen.screen
+    }
+
+    /// Returns a mutable reference to a [`Screen`](crate::Screen) object
+    /// containing the terminal state.
+    #[must_use]
+    pub fn screen_mut(&mut self) -> &mut crate::Screen {
+        &mut self.screen.screen
+    }
+
+    /// Returns a reference to the [`Callbacks`](crate::callbacks::Callbacks)
+    /// state object passed into the constructor.
+    pub fn callbacks(&self) -> &CB {
+        &self.screen.callbacks
+    }
+
+    /// Returns a mutable reference to the
+    /// [`Callbacks`](crate::callbacks::Callbacks) state object passed into
+    /// the constructor.
+    pub fn callbacks_mut(&mut self) -> &mut CB {
+        &mut self.screen.callbacks
+    }
+}
+
+impl Default for Parser {
+    /// Returns a parser with dimensions 80x24 and no scrollback.
+    fn default() -> Self {
+        Self::new(24, 80, 0)
+    }
+}
+
+impl std::io::Write for Parser {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        self.process(buf);
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        Ok(())
+    }
+}

package/vendor/vt100/src/perform.rs

@@ -0,0 +1,277 @@
+const BASE64: &[u8] =
+    b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+const CLIPBOARD_SELECTOR: &[u8] = b"cpqs01234567";
+
+pub struct WrappedScreen<CB: crate::callbacks::Callbacks = ()> {
+    pub screen: crate::screen::Screen,
+    pub callbacks: CB,
+}
+
+impl WrappedScreen<()> {
+    pub fn new(rows: u16, cols: u16, scrollback_len: usize) -> Self {
+        Self::new_with_callbacks(rows, cols, scrollback_len, ())
+    }
+}
+
+impl<CB: crate::callbacks::Callbacks> WrappedScreen<CB> {
+    pub fn new_with_callbacks(
+        rows: u16,
+        cols: u16,
+        scrollback_len: usize,
+        callbacks: CB,
+    ) -> Self {
+        Self {
+            screen: crate::screen::Screen::new(
+                crate::grid::Size { rows, cols },
+                scrollback_len,
+            ),
+            callbacks,
+        }
+    }
+}
+
+impl<CB: crate::callbacks::Callbacks> vte::Perform for WrappedScreen<CB> {
+    fn print(&mut self, c: char) {
+        if c == '\u{fffd}' || ('\u{80}'..'\u{a0}').contains(&c) {
+            self.callbacks.unhandled_char(&mut self.screen, c);
+        } else {
+            self.screen.text(c);
+        }
+    }
+
+    fn execute(&mut self, b: u8) {
+        match b {
+            7 => self.callbacks.audible_bell(&mut self.screen),
+            8 => self.screen.bs(),
+            9 => self.screen.tab(),
+            10 => self.screen.lf(),
+            11 => self.screen.vt(),
+            12 => self.screen.ff(),
+            13 => self.screen.cr(),
+            // we don't implement shift in/out alternate character sets, but
+            // it shouldn't count as an "error"
+            14 | 15 => {}
+            _ => self.callbacks.unhandled_control(&mut self.screen, b),
+        }
+    }
+
+    fn esc_dispatch(&mut self, intermediates: &[u8], _ignore: bool, b: u8) {
+        if let Some(i) = intermediates.first() {
+            self.callbacks.unhandled_escape(
+                &mut self.screen,
+                Some(*i),
+                intermediates.get(1).copied(),
+                b,
+            );
+        } else {
+            match b {
+                b'7' => self.screen.decsc(),
+                b'8' => self.screen.decrc(),
+                b'=' => self.screen.deckpam(),
+                b'>' => self.screen.deckpnm(),
+                b'M' => self.screen.ri(),
+                b'c' => self.screen.ris(),
+                b'g' => self.callbacks.visual_bell(&mut self.screen),
+                _ => {
+                    self.callbacks.unhandled_escape(
+                        &mut self.screen,
+                        None,
+                        None,
+                        b,
+                    );
+                }
+            }
+        }
+    }
+
+    fn csi_dispatch(
+        &mut self,
+        params: &vte::Params,
+        intermediates: &[u8],
+        _ignore: bool,
+        c: char,
+    ) {
+        let unhandled = |screen: &mut crate::screen::Screen| {
+            self.callbacks.unhandled_csi(
+                screen,
+                intermediates.first().copied(),
+                intermediates.get(1).copied(),
+                &params.iter().collect::<Vec<_>>(),
+                c,
+            );
+        };
+        match intermediates.first() {
+            None => match c {
+                '@' => self.screen.ich(canonicalize_params_1(params, 1)),
+                'A' => self.screen.cuu(canonicalize_params_1(params, 1)),
+                'B' => self.screen.cud(canonicalize_params_1(params, 1)),
+                'C' => self.screen.cuf(canonicalize_params_1(params, 1)),
+                'D' => self.screen.cub(canonicalize_params_1(params, 1)),
+                'E' => self.screen.cnl(canonicalize_params_1(params, 1)),
+                'F' => self.screen.cpl(canonicalize_params_1(params, 1)),
+                'G' => self.screen.cha(canonicalize_params_1(params, 1)),
+                'H' => self.screen.cup(canonicalize_params_2(params, 1, 1)),
+                'J' => self
+                    .screen
+                    .ed(canonicalize_params_1(params, 0), unhandled),
+                'K' => self
+                    .screen
+                    .el(canonicalize_params_1(params, 0), unhandled),
+                'L' => self.screen.il(canonicalize_params_1(params, 1)),
+                'M' => self.screen.dl(canonicalize_params_1(params, 1)),
+                'P' => self.screen.dch(canonicalize_params_1(params, 1)),
+                'S' => self.screen.su(canonicalize_params_1(params, 1)),
+                'T' => self.screen.sd(canonicalize_params_1(params, 1)),
+                'X' => self.screen.ech(canonicalize_params_1(params, 1)),
+                'd' => self.screen.vpa(canonicalize_params_1(params, 1)),
+                'm' => self.screen.sgr(params, unhandled),
+                'r' => self.screen.decstbm(canonicalize_params_decstbm(
+                    params,
+                    self.screen.grid().size(),
+                )),
+                't' => {
+                    let mut params_iter = params.iter();
+                    let op =
+                        params_iter.next().and_then(|x| x.first().copied());
+                    if op == Some(8) {
+                        let (screen_rows, screen_cols) = self.screen.size();
+                        let rows =
+                            params_iter.next().map_or(screen_rows, |x| {
+                                *x.first().unwrap_or(&screen_rows)
+                            });
+                        let cols =
+                            params_iter.next().map_or(screen_cols, |x| {
+                                *x.first().unwrap_or(&screen_cols)
+                            });
+                        self.callbacks.resize(&mut self.screen, (rows, cols));
+                    } else {
+                        self.callbacks.unhandled_csi(
+                            &mut self.screen,
+                            None,
+                            None,
+                            &params.iter().collect::<Vec<_>>(),
+                            c,
+                        );
+                    }
+                }
+                _ => {
+                    self.callbacks.unhandled_csi(
+                        &mut self.screen,
+                        None,
+                        None,
+                        &params.iter().collect::<Vec<_>>(),
+                        c,
+                    );
+                }
+            },
+            Some(b'?') => match c {
+                'J' => self
+                    .screen
+                    .decsed(canonicalize_params_1(params, 0), unhandled),
+                'K' => self
+                    .screen
+                    .decsel(canonicalize_params_1(params, 0), unhandled),
+                'h' => self.screen.decset(params, unhandled),
+                'l' => self.screen.decrst(params, unhandled),
+                _ => {
+                    self.callbacks.unhandled_csi(
+                        &mut self.screen,
+                        Some(b'?'),
+                        intermediates.get(1).copied(),
+                        &params.iter().collect::<Vec<_>>(),
+                        c,
+                    );
+                }
+            },
+            Some(i) => {
+                self.callbacks.unhandled_csi(
+                    &mut self.screen,
+                    Some(*i),
+                    intermediates.get(1).copied(),
+                    &params.iter().collect::<Vec<_>>(),
+                    c,
+                );
+            }
+        }
+    }
+
+    fn osc_dispatch(&mut self, params: &[&[u8]], _bel_terminated: bool) {
+        match params {
+            [b"0", s] => {
+                self.callbacks.set_window_icon_name(&mut self.screen, s);
+                self.callbacks.set_window_title(&mut self.screen, s);
+            }
+            [b"1", s] => {
+                self.callbacks.set_window_icon_name(&mut self.screen, s);
+            }
+            [b"2", s] => {
+                self.callbacks.set_window_title(&mut self.screen, s);
+            }
+            [b"52", ty, data] => {
+                match (
+                    ty.iter().all(|c| CLIPBOARD_SELECTOR.contains(c)),
+                    *data,
+                ) {
+                    (true, b"?") => {
+                        self.callbacks
+                            .paste_from_clipboard(&mut self.screen, ty);
+                    }
+                    (true, data)
+                        if data.iter().all(|c| BASE64.contains(c)) =>
+                    {
+                        self.callbacks.copy_to_clipboard(
+                            &mut self.screen,
+                            ty,
+                            data,
+                        );
+                    }
+                    _ => {
+                        self.callbacks
+                            .unhandled_osc(&mut self.screen, params);
+                    }
+                }
+            }
+            _ => {
+                self.callbacks.unhandled_osc(&mut self.screen, params);
+            }
+        }
+    }
+}
+
+fn canonicalize_params_1(params: &vte::Params, default: u16) -> u16 {
+    let first = params.iter().next().map_or(0, |x| *x.first().unwrap_or(&0));
+    if first == 0 {
+        default
+    } else {
+        first
+    }
+}
+
+fn canonicalize_params_2(
+    params: &vte::Params,
+    default1: u16,
+    default2: u16,
+) -> (u16, u16) {
+    let mut iter = params.iter();
+    let first = iter.next().map_or(0, |x| *x.first().unwrap_or(&0));
+    let first = if first == 0 { default1 } else { first };
+
+    let second = iter.next().map_or(0, |x| *x.first().unwrap_or(&0));
+    let second = if second == 0 { default2 } else { second };
+
+    (first, second)
+}
+
+fn canonicalize_params_decstbm(
+    params: &vte::Params,
+    size: crate::grid::Size,
+) -> (u16, u16) {
+    let mut iter = params.iter();
+    let top = iter.next().map_or(0, |x| *x.first().unwrap_or(&0));
+    let top = if top == 0 { 1 } else { top };
+
+    let bottom = iter.next().map_or(0, |x| *x.first().unwrap_or(&0));
+    let bottom = if bottom == 0 { size.rows } else { bottom };
+
+    (top, bottom)
+}