Struct Printer 

pub struct Printer {

    pub selector: Selector,
    pub term_offset: usize,
    pub term_just_wrapped: bool,
    pub file_offset: usize,
    pub max_print_line: usize,
    pub log_slack: usize,
    pub term_quiet: bool,
    pub quiet_line: Vec<u8>,
    pub capture: Option<Vec<u8>>,
    pub error_line: usize,
    pub half_error_line: usize,
    pub tally: usize,
    pub trick_buf: Vec<Vec<u8>>,
    pub trick_count: usize,
    pub first_count: usize,
    pub cur_string: Vec<u8>,
    pub new_line_char: i32,
    /* private fields */
}

The printer state.

Fields

selector: Selector

Current destination.

term_offset: usize

Characters on the current terminal line.

term_just_wrapped: bool

Whether the last terminal output was an automatic line break at max_print_line.

file_offset: usize

Characters on the current log line.

max_print_line: usize

Maximum line length for terminal and log.

log_slack: usize

Extra characters allowed on a log line. LuaTeX lets text printed from Lua (texio) and its own warnings run one character past max_print_line in the log, but not on the terminal.

term_quiet: bool

Default output mode: nothing is written to the terminal, but line positions are tracked as if it were, so the log is unchanged.

quiet_line: Vec<u8>

While the terminal is quiet: the text of its current line (a prompt such as Enter file name: ), shown when the terminal is read.

capture: Option<Vec<u8>>

While Some, the text printed to the terminal or log is also collected here (used to turn error messages into diagnostics).

error_line: usize

Width of error context lines.

half_error_line: usize

Width of the first half of an error context line.

tally: usize

Characters printed so far in the current pseudo-print or other counted operation (TeX’s tally).

trick_buf: Vec<Vec<u8>>

Buffer for pseudo printing: one entry per counted position, a byte or the bytes of an invalid input byte shown with its successors.

trick_count: usize

Limit of pseudo-printed characters to keep.

first_count: usize

The tally at the start of the second line of pseudo printing.

cur_string: Vec<u8>

The string under construction (NewString).

new_line_char: i32

The current \newlinechar (−1 for none).

Implementations

impl Printer

pub fn new(term: Box<dyn Write>) -> Self

A printer writing to term.

pub fn set_log(&mut self, log: Box<dyn Write>)

Installs the log file.

pub fn log_opened(&self) -> bool

Whether a log file is open.

pub fn close_log(&mut self)

Flushes and closes the log file.

pub fn log_raw(&mut self, bytes: &[u8])

Writes raw bytes to the log without bookkeeping (for banners).

pub fn term_raw(&mut self, bytes: &[u8])

Writes raw bytes to the terminal without bookkeeping (nothing while the terminal is quiet).

pub fn update_terminal(&mut self)

Flushes the terminal (TeX’s update_terminal).

pub fn open_write(&mut self, n: u32, w: Box<dyn Write>)

Opens \write stream n on w.

pub fn open_write_streams(&self) -> Vec<u32>

The \write streams that are open.

pub fn close_write(&mut self, n: u32)

Closes \write stream n.

pub fn write_open(&self, n: u32) -> bool

Whether \write stream n is open.

pub fn print_ln(&mut self)

Ends the current line (TeX’s print_ln).

pub fn print_char(&mut self, c: u32)

Prints character c, handling the new-line character and the printable representation for terminal and log.

pub fn print_raw_byte(&mut self, b: u8)

Prints byte b as it is (a byte of invalid UTF-8 input).

pub fn pseudo_unit(&mut self, bytes: &[u8])

Pseudo-prints bytes (possibly none) as they are, counted as one position: how LuaTeX shows an invalid byte of an input line.

pub fn print_str(&mut self, s: &str)

Prints an ASCII string (e.g. a fixed message).

pub fn print_callback_bytes(&mut self, s: &[u8])

Prints a string returned by a Lua callback (glyph_info): the log gets the bytes as they are, the terminal shows control characters in ^^ notation.

pub fn print_plain(&mut self, s: &str)

Prints digits and other characters TeX prints one by one with print_char (no log slack).

pub fn print_bytes(&mut self, s: &[u8])

Prints a byte string in extended UTF-8 (e.g. a control-sequence name or file name).

pub fn print_lua_bytes(&mut self, s: &[u8])

Prints a byte string as text coming from Lua, with LuaTeX’s log line length for it (see log_slack).

pub fn luatex_warning(&mut self, category: &str, msg: &str)

A LuaTeX warning, warning (category): message, on a line of its own.

pub fn print_nl(&mut self, s: &str)

Starts a new line unless at the beginning of one (TeX’s print_nl).

pub fn begin_line(&mut self)

The test-and-newline part of print_nl: ends the current terminal or log line if it is not empty.

pub fn print_int(&mut self, n: i64)

Prints a decimal integer (TeX’s print_int).

pub fn print_scaled(&mut self, s: i32)

Prints a scaled value (TeX’s print_scaled).

pub fn print_hex(&mut self, n: i64)

Prints " followed by the uppercase hexadecimal value (TeX’s print_hex).

pub fn print_roman_int(&mut self, n: i64)

Prints a positive integer in lowercase roman numerals (TeX’s print_roman_int).

pub fn take_string(&mut self) -> Vec<u8>

Takes the string built by NewString printing.

pub fn flush(&mut self)

Flushes all outputs.

Trait Implementations

impl Debug for Printer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.