use crate::{Error, Result};
const HIGH: [(&str, &str); 32] = [
("∡", "\\<)"),
("x\u{0304}", "\\x-"),
("∇", "\\.V"),
("√", "\\v/"),
("∫", "\\.S"),
("Σ", "\\GS"),
("▶", "\\|>"),
("π", "\\pi"),
("∂", "\\.d"),
("≤", "\\<="),
("≥", "\\>="),
("≠", "\\=/"),
("α", "\\Ga"),
("→", "\\->"),
("←", "\\<-"),
("↓", "\\|v"),
("↑", "\\|^"),
("γ", "\\Gg"),
("δ", "\\Gd"),
("ε", "\\Ge"),
("η", "\\Gn"),
("θ", "\\Gh"),
("λ", "\\Gl"),
("ρ", "\\Gr"),
("σ", "\\Gs"),
("τ", "\\Gt"),
("ω", "\\Gw"),
("Δ", "\\GD"),
("Π", "\\PI"),
("Ω", "\\GW"),
("■", "\\[]"),
("∞", "\\oo"),
];
const LATIN_TRIGRAPHS: [(u8, &str); 8] = [
(171, "\\<<"),
(176, "\\^o"),
(181, "\\Gm"),
(187, "\\>>"),
(215, "\\.x"),
(216, "\\O/"),
(223, "\\Gb"),
(247, "\\:-"),
];
pub fn decode(bytes: &[u8]) -> String {
let mut s = String::with_capacity(bytes.len());
for &b in bytes {
match b {
0x80..=0x9F => s.push_str(HIGH[usize::from(b - 0x80)].0),
_ => s.push(char::from(b)),
}
}
s
}
pub fn encode(text: &str) -> Result<Vec<u8>> {
let mut out = Vec::with_capacity(text.len());
let mut chars = text.chars().peekable();
while let Some(c) = chars.next() {
if c == 'x' && chars.peek() == Some(&'\u{0304}') {
chars.next();
out.push(0x81);
continue;
}
out.push(encode_char(c)?);
}
Ok(out)
}
fn encode_char(c: char) -> Result<u8> {
let code = u32::from(c);
if code < 0x80 || (0xA0..=0xFF).contains(&code) {
return u8::try_from(code).map_err(|_| Error::Charset(c));
}
let mut buf = [0u8; 4];
let s: &str = c.encode_utf8(&mut buf);
HIGH.iter()
.position(|(text, _)| *text == s)
.and_then(|i| u8::try_from(0x80 + i).ok())
.ok_or(Error::Charset(c))
}
pub fn encode_command(text: &str) -> Result<Vec<u8>> {
let mut out = Vec::with_capacity(text.len());
let mut rest = text;
while let Some(pos) = rest.find('\\') {
out.extend(encode(&rest[..pos])?);
let tail = &rest[pos..];
match trigraph_at(tail) {
Some((byte, len)) => {
out.push(byte);
rest = &tail[len..];
}
None => {
out.push(b'\\');
rest = &tail[1..];
}
}
}
out.extend(encode(rest)?);
Ok(out)
}
pub fn trigraph_at(s: &str) -> Option<(u8, usize)> {
if let Some(head) = s.get(..3) {
if let Some(i) = HIGH.iter().position(|(_, t)| *t == head) {
return u8::try_from(0x80 + i).ok().map(|b| (b, 3));
}
if let Some((b, _)) = LATIN_TRIGRAPHS.iter().find(|(_, t)| *t == head) {
return Some((*b, 3));
}
}
let digits = s.get(1..4)?;
if digits.bytes().all(|d| d.is_ascii_digit()) {
let n: u16 = digits.parse().ok()?;
if (128..=255).contains(&n) {
return u8::try_from(n).ok().map(|b| (b, 4));
}
}
None
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NamedChar {
pub code: u8,
pub text: String,
pub trigraph: &'static str,
}
pub fn named_chars() -> Vec<NamedChar> {
let high = (0x80u8..)
.zip(HIGH.iter())
.map(|(code, (text, trigraph))| NamedChar {
code,
text: (*text).to_string(),
trigraph,
});
let latin = LATIN_TRIGRAPHS.iter().map(|&(code, trigraph)| NamedChar {
code,
text: char::from(code).to_string(),
trigraph,
});
high.chain(latin).collect()
}
pub fn to_trigraphs(bytes: &[u8]) -> String {
let mut s = String::with_capacity(bytes.len());
for &b in bytes {
match b {
0x80..=0x9F => s.push_str(HIGH[usize::from(b - 0x80)].1),
0xA0..=0xFF => match LATIN_TRIGRAPHS.iter().find(|(l, _)| *l == b) {
Some((_, t)) => s.push_str(t),
None => s.push_str(&format!("\\{b}")),
},
_ => s.push(char::from(b)),
}
}
s
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
const SX_T3: &str = concat!(
"\\<)\\x-\\.V\\v/\\.S\\GS\\|>\\pi\\.d\\<=\\>=\\=/\\Ga\\->\\<-\\|v\\|^\\Gg\\Gd",
"\\Ge\\Gn\\Gh\\Gl\\Gr\\Gs\\Gt\\Gw\\GD\\PI\\GW\\[]\\oo\\160\\161\\162\\163",
"\\164\\165\\166\\167\\168\\169\\170\\<<\\172\\173\\174\\175\\^o\\177\\178",
"\\179\\180\\Gm\\182\\183\\184\\185\\186\\>>\\188\\189\\190\\191\\192\\193",
"\\194\\195\\196\\197\\198\\199\\200\\201\\202\\203\\204\\205\\206\\207",
"\\208\\209\\210\\211\\212\\213\\214\\.x\\O/\\217\\218\\219\\220\\221\\222",
"\\Gb\\224\\225\\226\\227\\228\\229\\230\\231\\232\\233\\234\\235\\236",
"\\237\\238\\239\\240\\241\\242\\243\\244\\245\\246\\:-\\248\\249\\250",
"\\251\\252\\253\\254\\255",
);
#[test]
fn trigraphs_match_the_calculator() {
let high: Vec<u8> = (128..=255).collect();
assert_eq!(to_trigraphs(&high), SX_T3);
assert_eq!(encode_command(SX_T3).unwrap(), high);
}
#[test]
fn every_byte_round_trips_through_utf8() {
let all: Vec<u8> = (0..=255).collect();
assert_eq!(encode(&decode(&all)).unwrap(), all);
}
#[test]
fn decode_known_characters() {
assert_eq!(decode(b"\x8dSTR"), "→STR");
assert_eq!(decode(b"'\x9f'"), "'∞'");
assert_eq!(decode(b"\xab 1 \xbb"), "« 1 »");
assert_eq!(decode(b"\x81"), "x̄");
}
#[test]
fn encode_rejects_unknown() {
assert!(matches!(encode("€"), Err(Error::Charset('€'))));
assert_eq!(encode("x").unwrap(), b"x");
assert_eq!(encode("x\u{0304}y").unwrap(), b"\x81y");
}
#[test]
fn named_chars_cover_both_tables_and_round_trip() {
let named = named_chars();
assert_eq!(named.len(), HIGH.len() + LATIN_TRIGRAPHS.len());
assert!(named.windows(2).all(|w| w[0].code < w[1].code));
for c in &named {
assert_eq!(
encode_command(c.trigraph).unwrap(),
[c.code],
"{}",
c.trigraph
);
assert_eq!(encode(&c.text).unwrap(), [c.code], "{}", c.text);
assert_eq!(decode(&[c.code]), c.text);
assert_eq!(to_trigraphs(&[c.code]), c.trigraph);
}
assert_eq!(named[3].trigraph, "\\v/");
assert_eq!(named[3].text, "√");
}
#[test]
fn command_trigraphs() {
assert_eq!(
encode_command("{ 1 2 } \\->STR").unwrap(),
b"{ 1 2 } \x8dSTR"
);
assert_eq!(encode_command("→STR").unwrap(), b"\x8dSTR");
assert_eq!(encode_command("\\<< 1 \\>>").unwrap(), b"\xab 1 \xbb");
assert_eq!(encode_command("\"a\\b\" \\1").unwrap(), b"\"a\\b\" \\1");
assert_eq!(encode_command("\\127 \\256").unwrap(), b"\\127 \\256");
assert_eq!(encode_command("\\").unwrap(), b"\\");
}
}