use std::path::Path;
use serde::{Deserialize, Serialize};
use crate::catcode::{Cat, CatTable};
use crate::expand::{Engine, Macro, Meaning};
use crate::token::{CsId, Token};
pub const FORMAT_MAGIC: u32 = 0x5458_464D;
pub const FORMAT_VERSION: u32 = 3;
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
enum TokenRepr {
Char(char, u8),
Cs(String),
}
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
enum MeaningRepr {
Macro {
params: Vec<TokenRepr>,
body: Vec<TokenRepr>,
#[serde(default)]
long: bool,
#[serde(default)]
outer: bool,
#[serde(default)]
protected: bool,
},
Primitive(String),
Char(char, u8),
CharDef(i64),
CountDef(i64),
ToksDef(i64),
MathCharDef(i64),
Font(u16),
AttributeDef(i64),
}
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
pub struct Format {
magic: u32,
version: u32,
texrs_version: String,
intpars: Vec<(String, i64)>,
catcodes: Vec<(u32, u8)>,
counts: Vec<(i64, i64)>,
#[serde(default)]
pooled: Vec<(i64, u8, i64)>,
meanings: Vec<(String, MeaningRepr)>,
scratch_mark: i64,
}
impl Format {
pub fn capture(engine: &Engine, scratch_mark: i64) -> Self {
let initex = CatTable::new();
let mut catcodes = Vec::new();
for code in 0u32..=0x10FFFF {
let Some(ch) = char::from_u32(code) else {
continue;
};
if code > 0xFF {
break;
}
let cat = engine.cats.get(ch);
if cat != initex.get(ch) {
catcodes.push((code, cat_to_u8(cat)));
}
}
let counts = engine.known.counts();
let mut meanings: Vec<(String, MeaningRepr)> = engine
.meanings
.iter()
.map(|(id, meaning)| (id.name().to_string(), meaning_repr(meaning)))
.collect();
meanings.sort_by(|a, b| a.0.cmp(&b.0));
Format {
magic: FORMAT_MAGIC,
version: FORMAT_VERSION,
texrs_version: env!("CARGO_PKG_VERSION").to_string(),
intpars: engine
.intpars
.differences(&crate::intpar::IntPars::new())
.into_iter()
.filter(|(n, _)| !matches!(n.as_str(), "time" | "day" | "month" | "year"))
.collect(),
catcodes,
counts,
pooled: engine
.pooled_registers()
.into_iter()
.map(|(slot, file, reg)| (slot, file as u8, reg))
.collect(),
meanings,
scratch_mark,
}
}
pub fn apply(&self, engine: &mut Engine) -> i64 {
engine.intpars = crate::intpar::IntPars::new();
for (name, v) in &self.intpars {
if let Some(i) = crate::intpar::index(name) {
engine.intpars.set(i, *v);
}
}
engine.cats = CatTable::new();
for (code, cat) in &self.catcodes {
if let Some(ch) = char::from_u32(*code) {
engine.cats.set(ch, u8_to_cat(*cat));
}
}
let end_line_char = engine.intpars.get(crate::intpar::END_LINE_CHAR);
engine.cats.set_end_line_char(end_line_char);
engine.known.clear();
engine.restore_pooled(
self.pooled
.iter()
.filter_map(|(slot, file, reg)| Some((*slot, file_of(*file)?, *reg))),
);
for (register, value) in &self.counts {
engine.known.set(*register, Some(*value));
}
engine.meanings.clear();
for (name, meaning) in &self.meanings {
engine
.meanings
.insert(CsId::intern(name), meaning_of(meaning));
}
self.scratch_mark
}
fn usable(&self) -> bool {
self.magic == FORMAT_MAGIC
&& self.version == FORMAT_VERSION
&& self.texrs_version == env!("CARGO_PKG_VERSION")
}
pub fn save(&self, path: &Path) -> Result<(), String> {
let bytes = bincode::serialize(self).map_err(|e| format!("format: {e}"))?;
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent)
.map_err(|e| format!("cannot make {}: {e}", parent.display()))?;
}
let tmp = path.with_extension(format!("tmp.{}", std::process::id()));
std::fs::write(&tmp, &bytes).map_err(|e| format!("cannot write {}: {e}", tmp.display()))?;
std::fs::rename(&tmp, path)
.map_err(|e| format!("cannot rename into {}: {e}", path.display()))
}
pub fn load(path: &Path) -> Option<Format> {
let bytes = std::fs::read(path).ok()?;
let format: Format = bincode::deserialize(&bytes).ok()?;
format.usable().then_some(format)
}
}
fn cat_to_u8(cat: Cat) -> u8 {
cat as u8
}
fn file_of(n: u8) -> Option<crate::compiler::RegFile> {
use crate::compiler::RegFile;
[
RegFile::Count,
RegFile::Dimen,
RegFile::Skip,
RegFile::MuSkip,
]
.into_iter()
.find(|f| *f as u8 == n)
}
fn u8_to_cat(n: u8) -> Cat {
match n {
0 => Cat::Escape,
1 => Cat::BeginGroup,
2 => Cat::EndGroup,
3 => Cat::MathShift,
4 => Cat::AlignTab,
5 => Cat::EndLine,
6 => Cat::Param,
7 => Cat::Superscript,
8 => Cat::Subscript,
9 => Cat::Ignored,
10 => Cat::Space,
11 => Cat::Letter,
13 => Cat::Active,
14 => Cat::Comment,
15 => Cat::Invalid,
_ => Cat::Other,
}
}
fn token_repr(token: &Token) -> TokenRepr {
match token {
Token::Char(c, cat) => TokenRepr::Char(*c, cat_to_u8(*cat)),
Token::Cs(id) => TokenRepr::Cs(id.name().to_string()),
}
}
fn token_of(repr: &TokenRepr) -> Token {
match repr {
TokenRepr::Char(c, cat) => Token::Char(*c, u8_to_cat(*cat)),
TokenRepr::Cs(name) => Token::Cs(CsId::intern(name)),
}
}
fn meaning_repr(meaning: &Meaning) -> MeaningRepr {
match meaning {
Meaning::Macro(m) => MeaningRepr::Macro {
params: m.params.iter().map(token_repr).collect(),
body: m.body.iter().map(token_repr).collect(),
long: m.long,
outer: m.outer,
protected: m.protected,
},
Meaning::Primitive(id) => MeaningRepr::Primitive(id.name().to_string()),
Meaning::Char(c, cat) => MeaningRepr::Char(*c, cat_to_u8(*cat)),
Meaning::CharDef(v) => MeaningRepr::CharDef(*v),
Meaning::CountDef(r) => MeaningRepr::CountDef(*r),
Meaning::ToksDef(r) => MeaningRepr::ToksDef(*r),
Meaning::MathCharDef(v) => MeaningRepr::MathCharDef(*v),
Meaning::Font(f) => MeaningRepr::Font(*f),
Meaning::AttributeDef(n) => MeaningRepr::AttributeDef(*n),
}
}
fn meaning_of(repr: &MeaningRepr) -> Meaning {
match repr {
MeaningRepr::Macro {
params,
body,
long,
outer,
protected,
} => Meaning::Macro(std::rc::Rc::new(Macro {
params: params.iter().map(token_of).collect(),
body: body.iter().map(token_of).collect(),
long: *long,
outer: *outer,
protected: *protected,
})),
MeaningRepr::Primitive(name) => Meaning::Primitive(CsId::intern(name)),
MeaningRepr::Char(c, cat) => Meaning::Char(*c, u8_to_cat(*cat)),
MeaningRepr::CharDef(v) => Meaning::CharDef(*v),
MeaningRepr::Font(f) => Meaning::Font(*f),
MeaningRepr::CountDef(r) => Meaning::CountDef(*r),
MeaningRepr::ToksDef(r) => Meaning::ToksDef(*r),
MeaningRepr::MathCharDef(v) => Meaning::MathCharDef(*v),
MeaningRepr::AttributeDef(n) => Meaning::AttributeDef(*n),
}
}
#[cfg(test)]
mod tests {
use super::*;
fn preamble(src: &str) -> (Engine, i64, usize) {
let mut lowerer = crate::lower::Lowerer::new();
let cmds = lowerer.lower(src).expect("lowers");
let mark = lowerer.scratch_mark();
(lowerer.eng, mark, cmds.len())
}
const MACROS: &str = "\\catcode`\\{=1 \\catcode`\\}=2 \\catcode`\\#=6\n\
\\def\\greet#1{HELLO-#1}\n\\let\\hello\\greet\n";
#[test]
fn a_preamble_that_only_defines_lowers_to_nothing_a_format_could_lose() {
let (_, _, commands) = preamble(MACROS);
assert_eq!(commands, 0, "definitions produce no run-time commands");
let (engine, _, commands) = preamble("\\count7=42\n");
assert!(commands > 0, "an assignment lowers to run-time commands");
assert_eq!(engine.known.get(7), Some(42), "and the frontend follows it");
}
#[test]
fn what_a_preamble_left_is_what_a_format_puts_back() {
let (engine, scratch, _) = preamble(MACROS);
let format = Format::capture(&engine, scratch);
let mut fresh = Engine::new();
assert_ne!(fresh.cats.get('{'), engine.cats.get('{'), "before applying");
let mark = format.apply(&mut fresh);
assert_eq!(mark, scratch);
assert_eq!(fresh.esc(), engine.esc());
assert_eq!(fresh.cats.get('{'), Cat::BeginGroup);
assert_eq!(fresh.cats.get('}'), Cat::EndGroup);
assert_eq!(fresh.cats.get('#'), Cat::Param);
assert_eq!(fresh.cats.get('a'), Cat::Letter);
assert_eq!(fresh.meanings.len(), engine.meanings.len());
assert!(fresh.meanings.contains_key(&CsId::intern("greet")));
}
#[test]
fn a_macro_survives_the_round_trip_with_its_parameters() {
let (engine, scratch, _) = preamble(MACROS);
let format = Format::capture(&engine, scratch);
let mut fresh = Engine::new();
format.apply(&mut fresh);
let before = engine.meanings.get(&CsId::intern("greet")).unwrap();
let after = fresh.meanings.get(&CsId::intern("greet")).unwrap();
assert!(before == after, "the meaning is the same meaning");
match after {
Meaning::Macro(m) => {
assert!(!m.params.is_empty(), "the parameter text survived");
assert!(!m.body.is_empty(), "so did the body");
}
_ => panic!("\\greet came back as something other than a macro"),
}
}
#[test]
fn a_format_is_the_same_bytes_for_the_same_state() {
let (a, mark_a, _) = preamble(MACROS);
let (b, mark_b, _) = preamble(MACROS);
let first = bincode::serialize(&Format::capture(&a, mark_a)).unwrap();
let second = bincode::serialize(&Format::capture(&b, mark_b)).unwrap();
assert_eq!(first, second, "the dump does not depend on hash order");
}
#[test]
fn a_format_this_build_cannot_use_is_a_rebuild_rather_than_an_error() {
let dir = std::env::temp_dir().join(format!("texrs_fmt_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("preamble.fmt");
let (engine, scratch, _) = preamble(MACROS);
let format = Format::capture(&engine, scratch);
format.save(&path).expect("saves");
assert!(Format::load(&path).is_some(), "what it wrote, it reads");
let mut foreign = format.clone();
foreign.texrs_version = "0.0.0-other".into();
foreign.save(&path).unwrap();
assert!(Format::load(&path).is_none());
let mut old = format.clone();
old.version = FORMAT_VERSION + 1;
old.save(&path).unwrap();
assert!(Format::load(&path).is_none());
std::fs::write(&path, b"not a format at all").unwrap();
assert!(Format::load(&path).is_none());
assert!(Format::load(&dir.join("nothing.fmt")).is_none());
let strays: Vec<String> = std::fs::read_dir(&dir)
.unwrap()
.filter_map(|e| e.ok())
.map(|e| e.file_name().to_string_lossy().into_owned())
.filter(|n| n.contains("tmp"))
.collect();
assert!(strays.is_empty(), "{strays:?}");
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn every_category_number_survives_the_wire() {
for cat in [
Cat::Escape,
Cat::BeginGroup,
Cat::EndGroup,
Cat::MathShift,
Cat::AlignTab,
Cat::EndLine,
Cat::Param,
Cat::Superscript,
Cat::Subscript,
Cat::Ignored,
Cat::Space,
Cat::Letter,
Cat::Other,
Cat::Active,
Cat::Comment,
Cat::Invalid,
] {
assert_eq!(u8_to_cat(cat_to_u8(cat)), cat, "{cat:?}");
}
assert_eq!(u8_to_cat(200), Cat::Other);
}
}