Struct FormatBuilder

Source

pub struct FormatBuilder { /* private fields */ }

Expand description

Bakes a packaged format: INITEX runs an optional kernel file, then the preamble, then dumps.

Implementations§

Source §

impl FormatBuilder

Source

pub fn new(preamble: impl Into<String>) -> Self

A format whose INITEX run reads preamble, which should not \dump itself.

Examples found in repository ?

examples/bake_format.rs (line 25)

11fn main() -> ExitCode {
12    let mut args = std::env::args_os().skip(1);
13    let (Some(output), None) = (args.next().map(PathBuf::from), args.next()) else {
14        eprintln!("usage: bake_format <output.pkg>");
15        return ExitCode::FAILURE;
16    };
17    let texmf = match TexmfResources::discover() {
18        Ok(texmf) => texmf,
19        Err(error) => {
20            eprintln!("bake_format: {error}");
21            return ExitCode::FAILURE;
22        }
23    };
24    let fonts = ResourceFontLoader::new(&texmf);
25    let format = match FormatBuilder::new(PREAMBLE)
26        .kernel("latex.ltx")
27        .build(&texmf, &fonts)
28    {
29        Ok(format) => format,
30        Err(error) => {
31            eprintln!("bake_format: {error}");
32            return ExitCode::FAILURE;
33        }
34    };
35    if let Err(error) = std::fs::write(&output, &format) {
36        eprintln!("bake_format: cannot write {}: {error}", output.display());
37        return ExitCode::FAILURE;
38    }
39    eprintln!(
40        "bake_format: wrote {} bytes to {}",
41        format.len(),
42        output.display()
43    );
44    ExitCode::SUCCESS
45}

Source

pub fn kernel(self, file: impl Into<String>) -> Self

Runs file, such as latex.ltx, through INITEX to its own \dump before the preamble.

Examples found in repository ?

examples/bake_format.rs (line 26)

11fn main() -> ExitCode {
12    let mut args = std::env::args_os().skip(1);
13    let (Some(output), None) = (args.next().map(PathBuf::from), args.next()) else {
14        eprintln!("usage: bake_format <output.pkg>");
15        return ExitCode::FAILURE;
16    };
17    let texmf = match TexmfResources::discover() {
18        Ok(texmf) => texmf,
19        Err(error) => {
20            eprintln!("bake_format: {error}");
21            return ExitCode::FAILURE;
22        }
23    };
24    let fonts = ResourceFontLoader::new(&texmf);
25    let format = match FormatBuilder::new(PREAMBLE)
26        .kernel("latex.ltx")
27        .build(&texmf, &fonts)
28    {
29        Ok(format) => format,
30        Err(error) => {
31            eprintln!("bake_format: {error}");
32            return ExitCode::FAILURE;
33        }
34    };
35    if let Err(error) = std::fs::write(&output, &format) {
36        eprintln!("bake_format: cannot write {}: {error}", output.display());
37        return ExitCode::FAILURE;
38    }
39    eprintln!(
40        "bake_format: wrote {} bytes to {}",
41        format.len(),
42        output.display()
43    );
44    ExitCode::SUCCESS
45}

Source

pub fn build( self, resources: &impl ResourceProvider, fonts: &impl FontLoader, ) -> Result<Vec<u8>, BuildError>

Runs the kernel and preamble, defines \hostbox if still undefined, and returns the packaged format.

Examples found in repository ?

examples/bake_format.rs (line 27)

11fn main() -> ExitCode {
12    let mut args = std::env::args_os().skip(1);
13    let (Some(output), None) = (args.next().map(PathBuf::from), args.next()) else {
14        eprintln!("usage: bake_format <output.pkg>");
15        return ExitCode::FAILURE;
16    };
17    let texmf = match TexmfResources::discover() {
18        Ok(texmf) => texmf,
19        Err(error) => {
20            eprintln!("bake_format: {error}");
21            return ExitCode::FAILURE;
22        }
23    };
24    let fonts = ResourceFontLoader::new(&texmf);
25    let format = match FormatBuilder::new(PREAMBLE)
26        .kernel("latex.ltx")
27        .build(&texmf, &fonts)
28    {
29        Ok(format) => format,
30        Err(error) => {
31            eprintln!("bake_format: {error}");
32            return ExitCode::FAILURE;
33        }
34    };
35    if let Err(error) = std::fs::write(&output, &format) {
36        eprintln!("bake_format: cannot write {}: {error}", output.display());
37        return ExitCode::FAILURE;
38    }
39    eprintln!(
40        "bake_format: wrote {} bytes to {}",
41        format.len(),
42        output.display()
43    );
44    ExitCode::SUCCESS
45}