pub mod agl;
pub mod aot;
pub mod aot_runtime;
pub mod backend;
pub mod banner;
pub mod bib;
pub mod box_;
pub mod bst;
pub mod bstvm;
pub mod bundle;
pub mod catcode;
pub mod cff;
pub mod charcodes;
pub mod cli;
pub mod colour;
pub mod compiler;
pub mod corpus;
pub mod dap;
pub mod dimen;
pub mod docs;
pub mod document;
pub mod dvi;
pub mod dvi_parity;
pub mod embed;
pub mod etex_arith;
pub mod expand;
pub mod fontmap;
pub mod fontreq;
pub mod format;
pub mod geturl;
pub mod glue;
pub mod glyf;
pub mod image;
pub mod include;
pub mod input_hooks;
pub mod intercepts;
pub mod intpar;
pub mod io;
pub mod ir;
pub mod itar;
pub mod known;
pub mod kpse;
pub mod latex;
pub mod lexer;
pub mod linebreak;
pub mod lower;
pub mod lsp;
pub mod lua;
pub mod luatex_oracle;
pub mod luatex_primitives;
pub mod math;
pub mod node;
pub mod otf;
pub mod pack;
pub mod page;
pub mod parallel;
pub mod params;
pub mod parbreak;
pub mod parity;
pub mod pdf;
pub mod pdf_parity;
pub mod pdfdoc;
pub mod pdfpage;
pub mod pdfread;
pub mod pdfship;
pub mod pk;
pub mod postline;
pub mod primitives;
pub mod repl;
pub mod runtime;
pub mod rust_ffi;
pub mod script_cache;
pub mod sfnt;
pub mod shape;
pub mod shipout;
pub mod special;
pub mod status;
pub mod stomach;
pub mod tfm;
pub mod tiers;
pub mod tikz;
pub mod token;
pub mod type1;
pub mod typeset;
pub mod vf;
pub mod write;
pub use embed::run_program;
pub use expand::{Engine, TexError};
pub fn run_messages_list(src: &str) -> Result<Vec<String>, TexError> {
let chunk = compile(src)?;
let messages = crate::runtime::run(chunk).map_err(TexError)?;
Ok(messages.iter().map(|m| without_marks(m)).collect())
}
fn without_marks(text: &str) -> String {
let mut out = String::with_capacity(text.len());
let mut in_spec = false;
let mut face_code = false;
let mut in_ref: Option<char> = None;
let mut in_picture = false;
let mut in_image = false;
let mut in_size_spec = false;
let mut in_break_params = false;
for ch in text.chars() {
match ch {
crate::typeset::REF => match in_ref.take() {
Some(crate::typeset::REF_NUMBER | crate::typeset::REF_PAGE) => out.push_str("??"),
Some(_) => {}
None => in_ref = Some('\u{0}'),
},
_ if in_ref == Some('\u{0}') => in_ref = Some(ch),
_ if in_ref.is_some() => {}
crate::typeset::PICTURE => in_picture = !in_picture,
_ if in_picture => {}
crate::typeset::IMAGE => in_image = !in_image,
_ if in_image => {}
'\u{1}' => in_spec = true,
'\u{2}' => in_spec = false,
'\u{3}' => {}
crate::typeset::LISTING_BREAK => out.push('\n'),
crate::typeset::CENTRE | crate::typeset::CENTRE_END => {}
crate::typeset::VERTICAL_SPACE => {}
crate::typeset::JUSTIFY => {}
crate::typeset::PAGE_BREAK => out.push('\n'),
crate::typeset::FACE_PUSH => face_code = true,
crate::typeset::FACE_POP => {}
crate::typeset::SIZE_PUSH => in_size_spec = !in_size_spec,
_ if in_size_spec => {}
crate::typeset::SIZE_POP => {}
crate::typeset::BREAK_PARAMS => in_break_params = !in_break_params,
_ if in_break_params => {}
crate::typeset::TABLE_CELL => out.push(' '),
crate::typeset::TABLE_ROW => out.push('\n'),
crate::typeset::TABLE_MARK => face_code = true,
crate::typeset::LONGTABLE => face_code = true,
crate::typeset::LIST_INDENT => face_code = true,
crate::typeset::TOC => face_code = true,
_ if face_code => face_code = false,
c if in_spec => {
let _ = c;
}
c => out.push(c),
}
}
out
}
pub fn text_without_marks(text: &str) -> String {
without_marks(text)
}
pub fn run_text_marked(src: &str) -> Result<String, TexError> {
let chunk = compile_text(src)?;
let _ = crate::runtime::run(chunk).map_err(TexError)?;
Ok(crate::runtime::take_text())
}
pub fn run_text(src: &str) -> Result<String, TexError> {
let marked = run_text_marked(src)?;
Ok(without_marks(&crate::typeset::refs_numbered(&marked)))
}
pub fn run_text_at(path: &std::path::Path, src: &str) -> Result<String, TexError> {
let src_d = crate::rust_ffi::desugar(src);
let mut lowerer = crate::lower::Lowerer::new().with_text_output();
if crate::latex::looks_like_latex(&src_d) {
crate::latex::aux::update(path, &src_d);
lowerer.preload(&crate::latex::preamble_at(
path,
&src_d,
crate::latex::Mode::Text,
))?;
}
let cmds = lowerer.lower(&src_d)?;
let chunk = crate::compiler::Compiler::new().compile(&cmds)?;
let _ = crate::runtime::run(chunk).map_err(TexError)?;
let marked = crate::runtime::take_text();
Ok(without_marks(&crate::typeset::refs_numbered(&marked)))
}
pub fn compile_text(src: &str) -> Result<fusevm::Chunk, TexError> {
let src = crate::rust_ffi::desugar(src);
let mut lowerer = crate::lower::Lowerer::new().with_text_output();
if crate::latex::looks_like_latex(&src) {
lowerer.preload(&crate::latex::preamble_text(&src))?;
}
let cmds = lowerer.lower(&src)?;
crate::compiler::Compiler::new().compile(&cmds)
}
pub fn run_text_cached(path: &std::path::Path, src: &str) -> Result<String, TexError> {
let marked = run_text_marked_cached(path, src)?;
Ok(without_marks(&crate::typeset::refs_numbered(&marked)))
}
pub fn run_text_marked_cached(path: &std::path::Path, src: &str) -> Result<String, TexError> {
let chunk = compile_text_cached(path, src)?;
let _ = crate::runtime::run(chunk).map_err(TexError)?;
Ok(crate::runtime::take_text())
}
fn compile_text_cached(path: &std::path::Path, src: &str) -> Result<fusevm::Chunk, TexError> {
let src_d = crate::rust_ffi::desugar(src);
let latex = crate::latex::looks_like_latex(&src_d);
let mode = match latex {
true => {
crate::latex::aux::update(path, &src_d);
format!("text{}", crate::latex::aux::stamp(path))
}
false => "text".to_string(),
};
let mode = match crate::lua::explicit_jobname() {
Some(job) => format!("{mode}#jobname={job}"),
None => mode,
};
if let Some(chunk) = crate::script_cache::try_load_mode(path, &mode) {
return Ok(chunk);
}
let mut lowerer = crate::lower::Lowerer::new().with_text_output();
if latex {
lowerer.preload(&crate::latex::preamble_at(
path,
&src_d,
crate::latex::Mode::Text,
))?;
}
let cmds = lowerer.lower(&src_d)?;
let chunk = crate::compiler::Compiler::new().compile(&cmds)?;
crate::script_cache::store_mode(path, &mode, &chunk);
Ok(chunk)
}
pub fn run_pdf(src: &str) -> Result<Vec<u8>, TexError> {
run_pdf_at(None, src)
}
pub fn run_pdf_at(path: Option<&std::path::Path>, src: &str) -> Result<Vec<u8>, TexError> {
run_pdf_with_messages(path, src).map(|(pdf, _)| pdf.bytes)
}
pub struct Pdf {
pub bytes: Vec<u8>,
pub pages: usize,
}
pub fn run_pdf_with_messages(
path: Option<&std::path::Path>,
src: &str,
) -> Result<(Pdf, Vec<String>), TexError> {
crate::kpse::prefetch_startup();
let src_d = crate::rust_ffi::desugar(src);
let latex = crate::latex::looks_like_latex(&src_d);
let ran = match (latex, path) {
(true, Some(p)) => {
crate::latex::aux::update_then(p, &src_d, || lower_for_pdf(path, &src_d, true))
}
_ => lower_for_pdf(path, &src_d, latex),
};
let mut ran = ran?;
crate::pdfdoc::prepare(std::mem::take(&mut ran.backend));
let ahead = ran.pipeline.and_then(crate::typeset::Pipeline::finish);
let pdf = crate::typeset::to_pdf_ahead(
&ran.text,
&ran.families,
&ran.layout,
ran.page_colour,
path.and_then(|p| p.parent()),
ahead,
);
Ok((pdf, ran.messages))
}
const PIPELINE_BYTES: usize = 64 * 1024;
struct Lowered {
messages: Vec<String>,
text: String,
families: crate::typeset::Families,
layout: crate::typeset::Layout,
page_colour: Option<crate::colour::Rgb>,
pipeline: Option<crate::typeset::Pipeline>,
backend: crate::backend::Prepared,
}
pub struct PdfProgram {
pub chunk: fusevm::Chunk,
pub families: crate::typeset::Families,
pub layout: crate::typeset::Layout,
pub page_colour: Option<crate::colour::Rgb>,
pub backend: crate::backend::Prepared,
}
pub fn compile_pdf_program(
path: Option<&std::path::Path>,
src: &str,
) -> Result<PdfProgram, TexError> {
let src_d = crate::rust_ffi::desugar(src);
let latex = crate::latex::looks_like_latex(&src_d);
match (latex, path) {
(true, Some(p)) => {
crate::latex::aux::update_then(p, &src_d, || pdf_program(path, &src_d, true, None))
}
_ => pdf_program(path, &src_d, latex, None),
}
}
fn lower_for_pdf(
path: Option<&std::path::Path>,
src_d: &str,
latex: bool,
) -> Result<Lowered, TexError> {
let (feed, pipeline) = match rayon::current_num_threads() > 1 && src_d.len() >= PIPELINE_BYTES {
true => {
let (feed, pipeline) = crate::typeset::Pipeline::start(path.and_then(|p| p.parent()));
(Some(feed), Some(pipeline))
}
false => (None, None),
};
let program = pdf_program(path, src_d, latex, feed)?;
let messages = crate::runtime::run(program.chunk).map_err(TexError)?;
let text = crate::runtime::take_text();
Ok(Lowered {
messages,
text,
families: program.families,
layout: program.layout,
page_colour: program.page_colour,
pipeline,
backend: program.backend,
})
}
fn pdf_program(
path: Option<&std::path::Path>,
src_d: &str,
latex: bool,
feed: Option<crate::typeset::Feed>,
) -> Result<PdfProgram, TexError> {
let mut lowerer = crate::lower::Lowerer::new().with_text_output();
if latex {
let preamble = match path {
Some(p) => crate::latex::preamble_at(p, src_d, crate::latex::Mode::Text),
None => crate::latex::preamble_text(src_d),
};
lowerer.preload(&preamble)?;
}
if let Some(feed) = feed {
lowerer.feed_paragraphs(feed);
}
let cmds = lowerer.lower(src_d)?;
let families = lowerer.fonts.clone();
let page_colour = lowerer.page_colour;
let layout = lowerer.layout.clone();
let backend = {
let eng = &mut lowerer.eng;
let mut b = std::mem::take(&mut eng.backend);
let prepared = b.take(eng);
eng.backend = b;
prepared
};
let chunk = crate::compiler::Compiler::new().compile(&cmds)?;
Ok(PdfProgram {
chunk,
families,
layout,
page_colour,
backend,
})
}
pub fn pdf_page_count(pdf: &[u8]) -> usize {
let plain = crate::pdf::inflate_streams(pdf);
let text = String::from_utf8_lossy(&plain);
text.matches("/Type /Page").count() - text.matches("/Type /Pages").count()
}
pub fn file_line(path: &str, msgs: &str, ended: bool) -> String {
let body = match msgs.is_empty() {
true => String::new(),
false => format!(" {msgs}"),
};
let close = match ended {
true => " )",
false => ")",
};
format!("(./{path}{body}{close}")
}
pub fn pdf_output_line(out: &std::path::Path, pages: usize, pdf: &[u8]) -> String {
match pages {
0 => "No pages of output.".to_string(),
1 => format!(
"Output written on {} (1 page, {} bytes).",
out.display(),
pdf.len()
),
n => format!(
"Output written on {} ({n} pages, {} bytes).",
out.display(),
pdf.len()
),
}
}
pub fn run_dvi_fallback(
path: Option<&std::path::Path>,
src: &str,
chain: &crate::typeset::FontChain,
layout: &crate::typeset::Layout,
) -> Result<Vec<u8>, TexError> {
if !crate::latex::looks_like_latex(src) {
let (_, dvi) = run_tex_dvi(src)?;
return Ok(dvi.unwrap_or_else(|| crate::dvi::Writer::new("texrs").finish()));
}
let text = match path {
Some(p) => run_text_marked_cached(p, src)?,
None => run_text_marked(src)?,
};
Ok(crate::typeset::to_dvi_chain(&text, chain, layout))
}
pub fn run_dvi_cached(
path: &std::path::Path,
src: &str,
font_path: &std::path::Path,
layout: &crate::typeset::Layout,
) -> Result<Vec<u8>, TexError> {
let text = run_text_cached(path, src)?;
let font = crate::tfm::Tfm::open(font_path).map_err(TexError)?;
let name = font_path
.file_stem()
.and_then(|s| s.to_str())
.unwrap_or("cmr10");
Ok(crate::typeset::to_dvi(&text, &font, name, layout))
}
pub fn run_list_path(src: &str) -> Result<(String, crate::stomach::Stomach), TexError> {
let src = crate::rust_ffi::desugar(src);
let mut lowerer = crate::lower::Lowerer::new()
.tex_errors(true)
.with_list_path();
let cmds = lowerer.lower(&src)?;
let chunk = crate::compiler::Compiler::new().compile(&cmds)?;
let msgs = crate::runtime::run(chunk).map_err(TexError)?;
Ok((without_marks(&msgs.join(" ")), crate::stomach::run::take()))
}
pub fn run_tex_dvi(src: &str) -> Result<(String, Option<Vec<u8>>), TexError> {
let src = crate::rust_ffi::desugar(src);
let plain = crate::kpse::locate("plain.tex")
.and_then(|p| std::fs::read_to_string(p).ok())
.ok_or_else(|| TexError("plain.tex not found".into()))?;
let mut lowerer = crate::lower::Lowerer::new()
.tex_errors(true)
.with_list_path();
lowerer.preload_format(&plain)?;
let cmds = lowerer.lower(&src)?;
let chunk = crate::compiler::Compiler::new().compile(&cmds)?;
let msgs = crate::runtime::run(chunk).map_err(TexError)?;
let stomach = crate::stomach::run::take();
Ok((without_marks(&msgs.join(" ")), stomach.dvi()))
}
pub fn run_tex_pdf(src: &str) -> Result<(String, Option<Vec<u8>>), TexError> {
let src = crate::rust_ffi::desugar(src);
let plain = crate::kpse::locate("plain.tex")
.and_then(|p| std::fs::read_to_string(p).ok())
.ok_or_else(|| TexError("plain.tex not found".into()))?;
let mut lowerer = crate::lower::Lowerer::new()
.tex_errors(true)
.with_list_path();
lowerer.preload_format(&plain)?;
let cmds = lowerer.lower(&src)?;
let prepared = {
let eng = &mut lowerer.eng;
let mut b = std::mem::take(&mut eng.backend);
let prepared = b.take(eng);
eng.backend = b;
prepared
};
let dimen = |name: &str, default: crate::node::Scaled| {
crate::params::register_slot(name)
.and_then(|s| lowerer.eng.known.get(s))
.filter(|v| *v != 0)
.unwrap_or(default)
};
let frame = crate::pdfship::PageFrame {
width: dimen("pagewidth", 40_258_437),
height: dimen("pageheight", 52_099_153),
h_origin: dimen(
"pdfvariable horigin",
crate::backend::format_default("horigin"),
),
v_origin: dimen(
"pdfvariable vorigin",
crate::backend::format_default("vorigin"),
),
};
let chunk = crate::compiler::Compiler::new().compile(&cmds)?;
let msgs = crate::runtime::run(chunk).map_err(TexError)?;
let stomach = crate::stomach::run::take();
let messages = without_marks(&msgs.join(" "));
if stomach.output.pages.is_empty() {
return Ok((messages, None));
}
let fonts: Vec<crate::pdfship::ShipFont> = stomach
.fonts
.iter()
.map(|f| crate::pdfship::ShipFont {
tfm_name: f.name.clone(),
size: f.size,
widths: (0..=255u8)
.map(|c| f.metrics(char::from(c)).map(|m| m.width))
.collect(),
})
.collect();
let pages: Vec<(
crate::node::BoxNode,
crate::node::Scaled,
crate::node::Scaled,
)> = stomach
.output
.pages
.iter()
.map(|p| (p.page.clone(), p.h_offset, p.v_offset))
.collect();
let pdf = crate::pdfship::document(&pages, frame, &fonts, prepared);
Ok((messages, Some(pdf)))
}
pub fn run_dvi(
src: &str,
font_path: &std::path::Path,
layout: &crate::typeset::Layout,
) -> Result<Vec<u8>, TexError> {
if !crate::latex::looks_like_latex(src) {
let (_, dvi) = run_tex_dvi(src)?;
return dvi.ok_or_else(|| TexError("No pages of output.".into()));
}
let text = run_text(src)?;
let font = crate::tfm::Tfm::open(font_path).map_err(TexError)?;
let name = font_path
.file_stem()
.and_then(|s| s.to_str())
.unwrap_or("cmr10");
Ok(crate::typeset::to_dvi(&text, &font, name, layout))
}
pub fn run_messages_tex(src: &str) -> Result<String, TexError> {
let src = crate::rust_ffi::desugar(src);
let latex = crate::latex::looks_like_latex(&src);
if !latex {
return run_tex_dvi(&src).map(|(m, _)| m);
}
let mut lowerer = crate::lower::Lowerer::new().tex_errors(!latex);
if latex {
lowerer.preload(&crate::latex::preamble(&src))?;
}
let cmds = lowerer.lower(&src)?;
let chunk = crate::compiler::Compiler::new().compile(&cmds)?;
let msgs = crate::runtime::run(chunk).map_err(TexError)?;
Ok(without_marks(&msgs.join(" ")))
}
pub fn run_messages_initex(src: &str) -> Result<String, TexError> {
let src = crate::rust_ffi::desugar(src);
let mut lowerer = crate::lower::Lowerer::new().tex_errors(true);
let cmds = lowerer.lower(&src)?;
let chunk = crate::compiler::Compiler::new().compile(&cmds)?;
let msgs = crate::runtime::run(chunk).map_err(TexError)?;
Ok(without_marks(&msgs.join(" ")))
}
pub fn run_messages(src: &str) -> Result<String, TexError> {
let chunk = compile(src)?;
let msgs = crate::runtime::run(chunk).map_err(TexError)?;
Ok(without_marks(&msgs.join(" ")))
}
pub fn run_messages_cached(path: &std::path::Path, src: &str) -> Result<String, TexError> {
let chunk = compile_cached(path, src)?;
let msgs = crate::runtime::run(chunk).map_err(TexError)?;
Ok(without_marks(&msgs.join(" ")))
}
pub fn compile_cached(path: &std::path::Path, src: &str) -> Result<fusevm::Chunk, TexError> {
if let Some(job) = crate::lua::explicit_jobname() {
let mode = format!("jobname={job}");
if let Some(chunk) = crate::script_cache::try_load_mode(path, &mode) {
return Ok(chunk);
}
let chunk = compile(src)?;
crate::script_cache::store_mode(path, &mode, &chunk);
return Ok(chunk);
}
if let Some(chunk) = crate::script_cache::try_load(path) {
return Ok(chunk);
}
let chunk = compile(src)?;
crate::script_cache::store(path, &chunk);
Ok(chunk)
}
pub fn compile(src: &str) -> Result<fusevm::Chunk, TexError> {
let cmds = commands(src)?;
crate::compiler::Compiler::new().compile(&cmds)
}
pub fn commands(src: &str) -> Result<Vec<crate::ir::Cmd>, TexError> {
let src = crate::rust_ffi::desugar(src);
let mut lowerer = crate::lower::Lowerer::new();
if crate::latex::looks_like_latex(&src) {
lowerer.preload(&crate::latex::preamble(&src))?;
}
lowerer.lower(&src)
}
pub fn source_ends_run(src: &str) -> bool {
let src = crate::rust_ffi::desugar(src);
let mut lowerer = crate::lower::Lowerer::new();
let _ = lowerer.lower(&src);
lowerer.ended
}
pub fn compile_located(src: &str) -> Result<fusevm::Chunk, (TexError, u32)> {
let src = crate::rust_ffi::desugar(src);
let cmds = crate::lower::Lowerer::new().lower_located(&src)?;
crate::compiler::Compiler::new()
.compile(&cmds)
.map_err(|e| (e, 0))
}
pub fn compile_debug(src: &str) -> Result<fusevm::Chunk, TexError> {
let src = crate::rust_ffi::desugar(src);
let cmds = crate::lower::Lowerer::new().lower(&src)?;
crate::compiler::Compiler::new_debug().compile(&cmds)
}
pub fn run_messages_debug(src: &str) -> Result<String, TexError> {
let chunk = compile_debug(src)?;
let msgs = crate::runtime::run_debug(chunk, crate::dap::on_debug_line).map_err(TexError)?;
Ok(msgs.join(" "))
}