librustty 0.0.0

Experimental pure-Rust terminal emulation library; initial releases focus on VT stream parsing
Documentation
#![allow(missing_docs)]

use std::io::{self, Read};

use rustty::{CsiDispatch, EscDispatch, Handler, OscDispatch, Parser, StringDispatch};

#[derive(Default)]
struct Trace;

impl Handler for Trace {
    fn print(&mut self, ch: char) {
        println!("print {ch:?}");
    }

    fn execute(&mut self, byte: u8) {
        println!("execute {}", escaped_byte(byte));
    }

    fn esc_dispatch(&mut self, event: EscDispatch<'_>) {
        println!(
            "esc final={} intermediates={} truncated={}",
            escaped_byte(event.final_byte),
            escaped_bytes(event.intermediates),
            event.truncated
        );
    }

    fn csi_dispatch(&mut self, event: CsiDispatch<'_>) {
        println!(
            "csi final={} private={} params={} intermediates={} truncated={}",
            escaped_byte(event.final_byte),
            escaped_bytes(event.private_markers),
            escaped_bytes(event.params.as_bytes()),
            escaped_bytes(event.intermediates),
            event.truncated
        );
    }

    fn osc_dispatch(&mut self, event: OscDispatch<'_>) {
        println!(
            "osc termination={:?} data={} truncated={}",
            event.termination,
            escaped_bytes(event.data),
            event.truncated
        );
    }

    fn string_dispatch(&mut self, event: StringDispatch<'_>) {
        println!(
            "string kind={:?} termination={:?} data={} truncated={}",
            event.kind,
            event.termination,
            escaped_bytes(event.data),
            event.truncated
        );
    }
}

fn escaped_byte(byte: u8) -> String {
    match byte {
        0x20..=0x7E => char::from(byte).to_string(),
        _ => format!("\\x{byte:02X}"),
    }
}

fn escaped_bytes(bytes: &[u8]) -> String {
    bytes.iter().map(|&byte| escaped_byte(byte)).collect()
}

fn main() -> io::Result<()> {
    let mut input = Vec::new();
    io::stdin().read_to_end(&mut input)?;

    let mut parser = Parser::new();
    let mut trace = Trace;
    for chunk in input.chunks(3) {
        parser.advance(&mut trace, chunk);
    }
    parser.finish(&mut trace);
    Ok(())
}