Struct LuaTexHost 

pub struct LuaTexHost { /* private fields */ }

The Lua interpreter with LuaTeX’s libraries.

Implementations

impl LuaTexHost

pub fn new() -> Result<Rc<Self>>

Creates the interpreter and installs the libraries.

pub fn lua(&self) -> &Lua

The underlying Lua state.

pub fn attach(engine: &mut Engine) -> Result<Rc<Self>>

Installs a host into an engine.

pub fn check_io_names(&self) -> Result<()>

Makes io.open and io.lines honour openin_any and openout_any, as LuaTeX does when it typesets (not in texlua scripts, observed).

pub fn make_safer(&self) -> Result<()>

-safer, as observed with LuaTeX: the functions that run programs or change or open files return nil without doing anything, and debug.traceback is removed.

pub fn set_script_args(&self, script: &str, args: &[String]) -> Result<()>

Sets the global arg table of a standalone script (--luaonly): the script at index 0, its arguments from 1.

Trait Implementations

impl Drop for LuaTexHost

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl LuaHost for LuaTexHost

fn run( &self, engine: &mut Engine, name: &str, code: &[u8], ) -> Result<(), String>

Runs a chunk of Lua code for \directlua (or \latelua, etc.). name is the chunk name. Text printed with tex.print must be pushed back into the engine’s input by the host.

fn call_function( &self, engine: &mut Engine, n: i32, ) -> Option<Result<(), String>>

Calls the registered Lua function n (\luafunction n) with its number, like run runs a chunk; None if there is no such function.

fn intarray_set(&self, gset: i32, writes: &[(i64, i64, &[i64])]) -> bool

Sets entries of expl3’s intarrays (l3intarray under LuaTeX keeps them in Lua tables), as \__intarray_gset:w does: for each (array, first, values), entry first + k of the array numbered array (\__intarray:w <array>) gets values[k]. gset is the \luafunction number of \__intarray_gset:w, through which the arrays are found. false, with nothing changed, when the arrays are not reachable natively.

fn call_simple(&self, engine: &mut Engine, name: &str) -> Result<(), String>

Calls callback name without arguments, ignoring its results (pre_dump, stop_run, …). Does nothing if none is registered.

fn call_with_string( &self, engine: &mut Engine, name: &str, arg: &str, ) -> Result<(), String>

Calls callback name with one string argument, ignoring its results (buildpage_filter, contribute_filter).

fn has_callback(&self, name: &str) -> bool

Whether a Lua function is registered for callback name.

fn define_font( &self, engine: &mut Engine, name: &[u8], size: i32, ) -> Option<u32>

Calls the define_font callback. Returns the id of the font it defined, or None if the font could not be loaded.

fn list_filter( &self, engine: &mut Engine, callback_name: &str, head: NodeRef, group: &str, ) -> ListFilter

Calls a node-list filter callback (pre_linebreak_filter, hpack_filter, post_linebreak_filter, …) on the list starting at head. Returns the new head; ListFilter::Flush means the list must be discarded.

fn pack_quality( &self, engine: &mut Engine, cb: &str, incident: &str, detail: i32, b: NodeRef, first: i32, last: i32, ) -> NodeRef

Calls the hpack_quality or vpack_quality callback cb for box b with incident (overfull, underfull, loose, tight) and its detail; returns the node the callback gave (null if none).

fn node_pass(&self, engine: &mut Engine, cb: &str, head: NodeRef) -> bool

Runs the hyphenate, ligaturing or kerning callback cb on the list after head (a temporary node), with its last node: true if a function or false is registered, which replaces the built-in pass.

fn linebreak_filter( &self, engine: &mut Engine, head: NodeRef, display: bool, ) -> Option<NodeRef>

Calls the linebreak_filter callback on paragraph head (display: a display follows): Some(list) if it returned a node list, which replaces line breaking; None otherwise.

fn mlist_to_hlist( &self, engine: &mut Engine, head: NodeRef, style: i32, penalties: bool, ) -> Option<NodeRef>

Calls the mlist_to_hlist callback on math list head in style style (0–7); None if the callback failed or none is set.

fn pipe_read(&self, engine: &mut Engine, cmd: &[u8]) -> Option<Vec<u8>>

Runs shell command cmd under the shell escape rules (as Lua’s io.popen does) and returns its output; None if it may not run.

fn input_level_string(&self, engine: &mut Engine, n: i64) -> Option<Vec<u8>>

Calls the input_level_string callback with input-stack depth n; None if it returned no string.

fn glyph_info(&self, engine: &mut Engine, p: NodeRef) -> Option<Vec<u8>>

Calls the glyph_info callback for glyph node p: Some(text) is what to print, None means the callback returned no string.

fn call_reference( &self, engine: &mut Engine, reference: i32, args: ReferenceArgs, ) -> Result<(), String>

Runs the Lua value kept under reference number reference (see nodes::LuaRefs) at shipout: a function is called with args, a string is run as Lua code. For the lua commands of virtual characters and \latelua functions.

fn dump(&self, _engine: &mut Engine) -> Vec<u8>

Data to store in the format file (e.g. lua.bytecode).

fn undump(&self, _engine: &mut Engine, data: &[u8]) -> Result<(), String>

Restores data stored by dump.