Struct Types 

pub struct Types;

Trait Implementations

impl Clone for Types

fn clone(&self) -> Types

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Types

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

Formats the value using the given formatter.

impl EngineTypes for Types

type Char = u8

type CSName = (NonZero<u32>, PhantomData<u8>)

type Token = CompactToken

type Extension = RusTeXExtension

type File = VirtualFile<u8>

type FileSystem = RusTeXFileSystem

type Int = i32

type Dim = Dim32

type MuDim = Mu

type Num = DefaultNumSet

type State = RusTeXState

type Outputs = RusTeXOutput

type Mouth = DefaultMouth<Types>

type Gullet = DefaultGullet<Types>

type Stomach = RusTeXStomach

type CustomNode = RusTeXNode

type Font = Arc<TfmFontI<i32, Dim32, (NonZero<u32>, PhantomData<u8>)>>

type FontSystem = Fontsystem

type ErrorHandler = ErrorThrower<Types>

impl State<Types> for RusTeXState

fn new( nullfont: TfmFont<i32, Dim32, InternedCSName<u8>>, aux: &mut EngineAux<Types>, ) -> Self

Instantiate a new State

fn register_primitive( &mut self, aux: &mut EngineAux<Types>, name: &'static str, cmd: PrimitiveCommand<Types>, )

register a new PrimitiveCommand. Should only be called during engine initialization.

fn primitives(&self) -> &PrimitiveCommands<Types>

return the set of all registered PrimitiveCommands.

fn aftergroup(&mut self, token: CompactToken)

Append a Token to be inserted when the current group ends (i.e. \aftergroup)

fn push( &mut self, aux: &mut EngineAux<Types>, group_type: GroupType, line_number: usize, )

push a new group level to the scoping stack; line_number is used for \tracinggroups

fn pop( &mut self, aux: &mut EngineAux<Types>, mouth: &mut <Types as EngineTypes>::Mouth, )

pop a group level from the scoping stack. Needs the mouth to insert the \aftergroup Tokens (if set)

fn get_group_type(&self) -> Option<GroupType>

The current [GroupType] (i.e. \currentgrouptype`).

fn get_group_level(&self) -> usize

The current group level/depth (0 being the top level; i.e. \currentgrouplevel)

fn get_current_font(&self) -> &TfmFont<i32, Dim32, InternedCSName<u8>>

Get the current Font

fn get_textfont(&self, i: u8) -> &<Types as EngineTypes>::Font

Get the current \textfont for the given family number, where fam is 0..15

fn set_textfont( &mut self, aux: &mut EngineAux<Types>, idx: u8, fnt: <Types as EngineTypes>::Font, globally: bool, )

Set the current \textfont for the given family number, where fam is 0..15

fn get_scriptfont(&self, i: u8) -> &<Types as EngineTypes>::Font

Get the current \scriptfont for the given family number, where fam is 0..15

fn set_scriptfont( &mut self, aux: &mut EngineAux<Types>, idx: u8, fnt: <Types as EngineTypes>::Font, globally: bool, )

Set the current \scriptfont for the given family number, where fam is 0..15

fn get_scriptscriptfont(&self, i: u8) -> &<Types as EngineTypes>::Font

Get the current \scriptscriptfont for the given family number, where fam is 0..15

fn set_scriptscriptfont( &mut self, aux: &mut EngineAux<Types>, idx: u8, fnt: <Types as EngineTypes>::Font, globally: bool, )

Set the current \scriptscriptfont for the given family number, where fam is 0..15

fn set_current_font( &mut self, aux: &mut EngineAux<Types>, fnt: TfmFont<i32, Dim32, InternedCSName<u8>>, globally: bool, )

Set the current Font

fn get_catcode_scheme(&self) -> &CategoryCodeScheme<u8>

Get the current CategoryCodeScheme

fn set_catcode( &mut self, aux: &EngineAux<Types>, c: u8, cc: CategoryCode, globally: bool, )

Set the current CategoryCode for a character

fn get_sfcode(&self, c: u8) -> u16

Get the current space factor code \sfcode for a character

fn set_sfcode( &mut self, aux: &EngineAux<Types>, c: u8, sfcode: u16, globally: bool, )

Set the current space factor code \sfcode for a character

fn get_lccode(&self, c: u8) -> u8

Get the current lower case code \lccode for a character

fn set_lccode( &mut self, aux: &EngineAux<Types>, c: u8, lccode: u8, globally: bool, )

Set the current lower case code \lccode for a character

fn get_uccode(&self, c: u8) -> u8

Get the current upper case code \uccode for a character

fn set_uccode( &mut self, aux: &EngineAux<Types>, c: u8, uccode: u8, globally: bool, )

Set the current upper case code \uccode for a character

fn get_delcode(&self, c: u8) -> i32

Get the current delimiter code \delcode for a character

fn set_delcode( &mut self, aux: &EngineAux<Types>, c: u8, delcode: i32, globally: bool, )

Set the current delimiter code \delcode for a character

fn get_mathcode(&self, c: u8) -> u32

Get the current math code \mathcode for a character

fn set_mathcode( &mut self, aux: &EngineAux<Types>, c: u8, mathcode: u32, globally: bool, )

Set the current math code \mathcode for a character

fn get_endline_char(&self) -> Option<u8>

Get the current endline character

fn set_endline_char( &mut self, aux: &EngineAux<Types>, c: Option<u8>, globally: bool, )

Set the current endline character

fn get_escape_char(&self) -> Option<u8>

Get the current escape character

fn set_escape_char( &mut self, aux: &EngineAux<Types>, c: Option<u8>, globally: bool, )

Set the current escape character

fn get_newline_char(&self) -> Option<u8>

Get the current newline character

fn set_newline_char( &mut self, aux: &EngineAux<Types>, c: Option<u8>, globally: bool, )

Set the current newline character

fn get_parshape(&self) -> &Vec<(Dim32, Dim32)>

Get the current \parshape

fn take_parshape(&mut self) -> Vec<(Dim32, Dim32)>

Get the current \parshape and set it to its default value

fn set_parshape( &mut self, aux: &EngineAux<Types>, parshape: Vec<(Dim32, Dim32)>, globally: bool, )

Set the current \parshape

fn get_int_register(&self, idx: usize) -> i32

Get an integer register value

fn set_int_register( &mut self, aux: &EngineAux<Types>, idx: usize, v: i32, globally: bool, )

Set an integer register value

fn get_primitive_int(&self, name: PrimitiveIdentifier) -> i32

Get a primitive integer value

fn set_primitive_int( &mut self, aux: &EngineAux<Types>, name: PrimitiveIdentifier, v: i32, globally: bool, )

Set a primitive integer value

fn get_dim_register(&self, idx: usize) -> Dim32

Get a dimen register value

fn set_dim_register( &mut self, aux: &EngineAux<Types>, idx: usize, v: Dim32, globally: bool, )

Set a dimen register value

fn get_skip_register(&self, idx: usize) -> Skip<Dim32>

Get a skip register value

fn set_skip_register( &mut self, aux: &EngineAux<Types>, idx: usize, v: Skip<Dim32>, globally: bool, )

Set a skip register value

fn get_muskip_register(&self, idx: usize) -> MuSkip<Mu>

Get a muskip register value

fn set_muskip_register( &mut self, aux: &EngineAux<Types>, idx: usize, v: MuSkip<Mu>, globally: bool, )

Set a muskip register value

fn get_toks_register(&self, idx: usize) -> &TokenList<CompactToken>

Get a token register value

fn set_toks_register( &mut self, aux: &EngineAux<Types>, idx: usize, v: TokenList<CompactToken>, globally: bool, )

Set a token register value

fn get_box_register(&self, idx: usize) -> Option<&TeXBox<Types>>

Get a box register value

fn get_box_register_mut(&mut self, idx: usize) -> Option<&mut TeXBox<Types>>

Get a box register value mutably (to e.g. change \ht, \wd, \dp, etc.)

fn take_box_register(&mut self, idx: usize) -> Option<TeXBox<Types>>

Take a box register value; replacing it with None (i.e. void box)

fn set_box_register( &mut self, aux: &EngineAux<Types>, idx: usize, v: Option<TeXBox<Types>>, globally: bool, )

Set a box register value

fn get_primitive_dim(&self, name: PrimitiveIdentifier) -> Dim32

Get a primitive dimension value

fn set_primitive_dim( &mut self, aux: &EngineAux<Types>, name: PrimitiveIdentifier, v: Dim32, globally: bool, )

Set a primitive dimension value

fn get_primitive_skip(&self, name: PrimitiveIdentifier) -> Skip<Dim32>

Get a primitive skip value

fn set_primitive_skip( &mut self, aux: &EngineAux<Types>, name: PrimitiveIdentifier, v: Skip<Dim32>, globally: bool, )

Set a primitive skip value

fn get_primitive_muskip(&self, name: PrimitiveIdentifier) -> MuSkip<Mu>

Get a primitive muskip value

fn set_primitive_muskip( &mut self, aux: &EngineAux<Types>, name: PrimitiveIdentifier, v: MuSkip<Mu>, globally: bool, )

Set a primitive muskip value

fn get_primitive_tokens( &self, name: PrimitiveIdentifier, ) -> &TokenList<CompactToken>

Get a primitive token list

fn set_primitive_tokens( &mut self, aux: &EngineAux<Types>, name: PrimitiveIdentifier, v: TokenList<CompactToken>, globally: bool, )

Set a primitive token list

fn get_command(&self, name: &InternedCSName<u8>) -> Option<&TeXCommand<Types>>

Get the current definition for the control sequence name

fn set_command( &mut self, aux: &EngineAux<Types>, name: InternedCSName<u8>, cmd: Option<TeXCommand<Types>>, globally: bool, )

Set the current definition for the control sequence name

fn get_ac_command(&self, c: u8) -> Option<&TeXCommand<Types>>

Get the current definition for the active character

fn set_ac_command( &mut self, aux: &EngineAux<Types>, c: u8, cmd: Option<TeXCommand<Types>>, globally: bool, )

Set the current definition for the active character

fn register_index(i: <ET as EngineTypes>::Int) -> Option<usize>

convert the provided integer value into a legal index for a register (or None if out of range)

fn get_mathfonts( &self, fam: u8, ) -> (<ET as EngineTypes>::Font, <ET as EngineTypes>::Font, <ET as EngineTypes>::Font)

Get the current set of mathfonts (text, script, scriptscript) for the given family number, where fam is 0..15

impl StateChangeTracker<Types> for RusTeXState

fn stack(&mut self) -> &mut StateStack<Types>

Get the current StateStack

fn change_field<F>(&mut self, globally: bool, f: F)

where F: FnOnce(&mut Self, bool) -> StateChange<ET>,

Change a field of the state, and add the change to the StateStack. Also takes care of inspecting and considering the current \globaldefs value and passes on the actual computed globally value to the continuation function, which should return the StateChange containg the old value.

impl Stomach<Types> for RusTeXStomach

fn new(_aux: &mut EngineAux<Types>, _state: &mut RusTeXState) -> Self

Constructs a new Stomach.

fn afterassignment(&mut self) -> &mut Option<CompactToken>

Mutable reference to the current \afterassignment Token.

fn data_mut(&mut self) -> &mut StomachData<Types>

The current list(s)

fn split_vertical( engine: &'_ mut EngineReferences<'_, Types>, nodes: Vec<VNode<Types>>, target: Dim32, ) -> SplitResult<Types>

Split a vertical list for the provided target height

fn assign_font( engine: &'_ mut EngineReferences<'_, Types>, _token: CompactToken, f: TfmFont<i32, Dim32, InternedCSName<u8>>, global: bool, ) -> Res<()>

Execute the provided Font assignment and insert \afterassignment if necessary

fn close_box(engine: &mut EngineReferences<'_, Types>, bt: BoxType) -> Res<()>

Closes a node list belonging to a TeXBox and adds it to the corresponding node list

fn split_paragraph( engine: &'_ mut EngineReferences<'_, Types>, specs: Vec<ParLineSpec<Types>>, children: Vec<HNode<Types>>, sourceref: SourceReference<<<Types as EngineTypes>::File as File>::SourceRefID>, ) -> Res<()>

Split a paragraph into lines and add them (as horizontal boxes) to the current vertical list

fn maybe_do_output( engine: &mut EngineReferences<'_, Types>, penalty: Option<i32>, ) -> Res<()>

Checks whether the output routine should occur; either because the page is full enough, or because the provided penalty is Some (and assumed to be <= -10000) and the page is not empty.

fn open_align( engine: &'_ mut EngineReferences<'_, Types>, _inner: BoxType, between: BoxType, )

Opens an \halign or \valign

fn close_align(engine: &mut EngineReferences<'_, Types>) -> Res<()>

Closes an \halign or \valign

fn every_top(engine: &mut EngineReferences<'_, ET>)

To be executed at every iteration of the top-level loop - i.e. in between all unexpandable commands

fn flush(engine: &mut EngineReferences<'_, ET>) -> Result<(), TeXError<ET>>

To be executed at the end of a document - flushes the current page

fn do_unexpandable( engine: &mut EngineReferences<'_, ET>, name: PrimitiveIdentifier, scope: CommandScope, token: <ET as EngineTypes>::Token, apply: fn(&mut EngineReferences<'_, ET>, <ET as EngineTypes>::Token) -> Result<(), TeXError<ET>>, ) -> Result<(), TeXError<ET>>

Execute the provided Unexpandable command

fn do_assignment( engine: &mut EngineReferences<'_, ET>, name: PrimitiveIdentifier, token: <ET as EngineTypes>::Token, assign: fn(&mut EngineReferences<'_, ET>, <ET as EngineTypes>::Token, bool) -> Result<(), TeXError<ET>>, global: bool, ) -> Result<(), TeXError<ET>>

Execute the provided Assignment command and insert \afterassignment if necessary

fn assign_int_register( engine: &mut EngineReferences<'_, ET>, register: usize, global: bool, in_token: <ET as EngineTypes>::Token, ) -> Result<(), TeXError<ET>>

Assign a value to a count register and insert \afterassignment if necessary

fn assign_dim_register( engine: &mut EngineReferences<'_, ET>, register: usize, global: bool, in_token: <ET as EngineTypes>::Token, ) -> Result<(), TeXError<ET>>

Assign a value to a dimen register and insert \afterassignment if necessary

fn assign_skip_register( engine: &mut EngineReferences<'_, ET>, register: usize, global: bool, in_token: <ET as EngineTypes>::Token, ) -> Result<(), TeXError<ET>>

Assign a value to a skip register and insert \afterassignment if necessary

fn assign_muskip_register( engine: &mut EngineReferences<'_, ET>, register: usize, global: bool, in_token: <ET as EngineTypes>::Token, ) -> Result<(), TeXError<ET>>

Assign a value to a muskip register and insert \afterassignment if necessary

fn assign_toks_register( engine: &mut EngineReferences<'_, ET>, token: <ET as EngineTypes>::Token, register: usize, global: bool, ) -> Result<(), TeXError<ET>>

Assign a value to a token register and insert \afterassignment if necessary

fn assign_primitive_toks( engine: &mut EngineReferences<'_, ET>, token: <ET as EngineTypes>::Token, name: PrimitiveIdentifier, global: bool, ) -> Result<(), TeXError<ET>>

Assign a value to a primitive token list and insert \afterassignment if necessary

fn assign_primitive_int( engine: &mut EngineReferences<'_, ET>, name: PrimitiveIdentifier, global: bool, in_token: <ET as EngineTypes>::Token, ) -> Result<(), TeXError<ET>>

Assign a value to a primitive integer value and insert \afterassignment if necessary

fn assign_primitive_dim( engine: &mut EngineReferences<'_, ET>, name: PrimitiveIdentifier, global: bool, in_token: <ET as EngineTypes>::Token, ) -> Result<(), TeXError<ET>>

Assign a value to a primitive dimension value and insert \afterassignment if necessary

fn assign_primitive_skip( engine: &mut EngineReferences<'_, ET>, name: PrimitiveIdentifier, global: bool, in_token: <ET as EngineTypes>::Token, ) -> Result<(), TeXError<ET>>

Assign a value to a primitive skip value and insert \afterassignment if necessary

fn assign_primitive_muskip( engine: &mut EngineReferences<'_, ET>, name: PrimitiveIdentifier, global: bool, in_token: <ET as EngineTypes>::Token, ) -> Result<(), TeXError<ET>>

Assign a value to a primitive muskip value and insert \afterassignment if necessary

fn do_whatsit( engine: &mut EngineReferences<'_, ET>, name: PrimitiveIdentifier, token: <ET as EngineTypes>::Token, read: fn(&mut EngineReferences<'_, ET>, <ET as EngineTypes>::Token) -> Result<Option<Box<dyn FnOnce(&mut EngineReferences<'_, ET>) -> Result<(), TeXError<ET>> + Send + Sync>>, TeXError<ET>>, ) -> Result<(), TeXError<ET>>

Executes a Whatsit command

fn do_box( engine: &mut EngineReferences<'_, ET>, _name: PrimitiveIdentifier, token: <ET as EngineTypes>::Token, bx: fn(&mut EngineReferences<'_, ET>, <ET as EngineTypes>::Token) -> Result<Either<Option<TeXBox<ET>>, BoxInfo<ET>>, TeXError<ET>>, ) -> Result<(), TeXError<ET>>

Executes a Box command

fn do_char( engine: &mut EngineReferences<'_, ET>, token: <ET as EngineTypes>::Token, char: <ET as EngineTypes>::Char, code: CommandCode, ) -> Result<(), TeXError<ET>>

Processes a character depending on the current TeXMode and its CommandCode

fn do_defed_char( engine: &mut EngineReferences<'_, ET>, token: <ET as EngineTypes>::Token, char: <ET as EngineTypes>::Char, ) -> Result<(), TeXError<ET>>

Processes a character depending on the current TeXMode and its CommandCode

fn do_char_in_math( engine: &mut EngineReferences<'_, ET>, char: <ET as EngineTypes>::Char, ) -> Result<(), TeXError<ET>>

fn do_mathchar( engine: &mut EngineReferences<'_, ET>, code: u32, token: Option<<ET as EngineTypes>::Token>, )

Processes a mathchar value (assumes we are in math mode)

fn maybe_switch_mode( engine: &mut EngineReferences<'_, ET>, scope: CommandScope, token: <ET as EngineTypes>::Token, name: PrimitiveIdentifier, ) -> Result<bool, TeXError<ET>>

Switches the current TeXMode (if necessary) by opening/closing a paragraph, or throws an error if neither action is possible or would not result in a compatible mode. If a paragraph is opened or closed, the provided token is requeued to be reprocessed afterwards in horizontal/vertical mode, and false is returned (as to not process the triggering command further). Otherwise, all is well and true is returned.

fn add_node_m( engine: &mut EngineReferences<'_, ET>, node: MathNode<ET, UnresolvedMathFontStyle<ET>>, )

Adds a node to the current math list (i.e. assumes we’re in math mode)

fn add_node_h(engine: &mut EngineReferences<'_, ET>, node: HNode<ET>)

Adds a node to the current horizontal list (i.e. assumes we’re in (restricted) horizontal mode)

fn add_node_v( engine: &mut EngineReferences<'_, ET>, node: VNode<ET>, ) -> Result<(), TeXError<ET>>

Adds a node to the current vertical list (i.e. assumes we’re in (internal) vertical mode)

fn do_output( engine: &mut EngineReferences<'_, ET>, caused_penalty: Option<i32>, ) -> Result<(), TeXError<ET>>

Actually calls the output routine

fn open_paragraph( engine: &mut EngineReferences<'_, ET>, token: <ET as EngineTypes>::Token, )

Open a new paragraph; assumed to be called in (internal) vertical mode

fn close_paragraph( engine: &mut EngineReferences<'_, ET>, ) -> Result<(), TeXError<ET>>

Close a paragraph; assumed to be called in horizontal mode

impl Copy for Types