Struct DefaultMouth

pub struct DefaultMouth<ET>
where
    ET: EngineTypes,
{
    inputs: Vec<TokenSource<<ET as EngineTypes>::Token, <ET as EngineTypes>::File>>,
    args: Option<[Vec<<ET as EngineTypes>::Token>; 9]>,
    start_ref: Vec<SourceReference<<<ET as EngineTypes>::File as File>::SourceRefID>>,
    vecs: Vec<Vec<<ET as EngineTypes>::Token>>,
}

The default implementation of Mouth. Well optimized to be fast, but at the cost of not keeping track of “the depth of current macro expansions” - I found that to be an acceptable loss, since afaict, the only thing that is done with that information is to print a corresponding number of .s if \tracingcommands is set. By omitting that and just concatenating all expansions into a single Vec from which to pop(), we gain a massive speedup.

Errors

Fields

inputs: Vec<TokenSource<<ET as EngineTypes>::Token, <ET as EngineTypes>::File>>

args: Option<[Vec<<ET as EngineTypes>::Token>; 9]>

start_ref: Vec<SourceReference<<<ET as EngineTypes>::File as File>::SourceRefID>>

vecs: Vec<Vec<<ET as EngineTypes>::Token>>

Implementations

impl<ET> DefaultMouth<ET>

where ET: EngineTypes,

pub fn into<ET2>(self) -> DefaultMouth<ET2>

where ET2: EngineTypes<Token = <ET as EngineTypes>::Token, File = <ET as EngineTypes>::File>,

Trivial conversion between different compatible EngineTypes.

pub fn into_tokens<ET2, F>(self, token: F) -> DefaultMouth<ET2>

where ET2: EngineTypes<Char = <ET as EngineTypes>::Char, File = <ET as EngineTypes>::File>, F: FnMut(<ET as EngineTypes>::Token) -> <ET2 as EngineTypes>::Token,

Less trivial conversion between different EngineTypes with compatible Tokens.

Trait Implementations

impl<ET> Mouth<ET> for DefaultMouth<ET>

where ET: EngineTypes,

fn new( _aux: &mut EngineAux<ET>, _state: &mut <ET as EngineTypes>::State, ) -> DefaultMouth<ET>

Create a new Mouth. May use EngineAux and State, although in practice, the default implementation doesn’t.

fn finish(&mut self)

clears the mouth at the end of a run, if desired.

fn file_trace( &self, ) -> impl Iterator<Item = SourceReference<<<ET as EngineTypes>::File as File>::SourceRefID>>

fn current_sourceref( &self, ) -> SourceReference<<<ET as EngineTypes>::File as File>::SourceRefID>

Get the current SourceReference of the Mouth (file/line/column).

fn start_ref( &self, ) -> SourceReference<<<ET as EngineTypes>::File as File>::SourceRefID>

The mouth (can) track(s) two SourceReferences: the current one (see current_sourceref) and the position of the last Token encountered in the top-loop of an engine run that was not the result of an expansion. The latter is returned by this function. The intuition being that this one indicates the start of the macro responsible for what is currently happening, even if the Mouth is already further along because more Tokens have been eaten as arguments to a macro etc.

fn update_start_ref(&mut self)

Tells the mouth to update the start reference to the current SourceReference (see start_ref).

fn get_args(&mut self) -> [Vec<<ET as EngineTypes>::Token>; 9]

We (can) reuse an array of Token vectors for macro arguments and reuse it to avoid frequent memory allocations. This method provides such an array. If it is not pushed to the mouth using push_macro_exp, later, it should be given back to the mouth using return_args later.

fn return_args(&mut self, exp: [Vec<<ET as EngineTypes>::Token>; 9])

Return the array of Token vectors to the mouth. Should only be called with an array that was previously obtained using get_args.

fn endinput( &mut self, aux: &mut EngineAux<ET>, state: &<ET as EngineTypes>::State, ) -> Result<(), InvalidCharacter<<ET as EngineTypes>::Char>>

\endinput - removes the last file from the Mouth without inserting \everyeof or an EOF Token.

fn line_number(&self) -> usize

The current line number in the top-most file in the Mouth.

fn push_macro_exp(&mut self, exp: MacroExpansion<<ET as EngineTypes>::Token>)

Push a MacroExpansion (with arguments already read) to the Mouth. The Mouth will return the Tokens lazily, resolving the parameter tokens in the expansion in the process.

fn push_exp(&mut self, exp: &TokenList<<ET as EngineTypes>::Token>)

Push a TokenList to the Mouth - e.g. from a token register or \everypar.

fn push_vec(&mut self, exp: Vec<<ET as EngineTypes>::Token>)

Push a Vec of Tokens to the Mouth. This is occasionally useful for things like \write.

fn push_slice_rev(&mut self, exp: &[<ET as EngineTypes>::Token])

Push a slice of Tokens to the Mouth, assumed to be in reverse order (i.e. the first token to return is the last one in the slice).

fn push_string(&mut self, s: StringLineSource<<ET as EngineTypes>::Char>)

Push a string to the Mouth. The Mouth will tokenize the string and return the Tokens lazily.

fn requeue(&mut self, t: <ET as EngineTypes>::Token)

Push a Token back to the Mouth. This is useful for e.g. \futurelet, \expandafter, or when reading keywords, numbers, dimensions, etc. that often read “too far ahead” and need to back up. This method should not be called directly, but rather through EngineReferences::requeue or Gullet::requeue.

fn push_file(&mut self, f: <ET as EngineTypes>::File)

Push a file to the Mouth. The Mouth will tokenize the file contents and return the Tokens lazily.

fn get_next( &mut self, aux: &mut EngineAux<ET>, state: &<ET as EngineTypes>::State, ) -> Result<Option<<ET as EngineTypes>::Token>, InvalidCharacter<<ET as EngineTypes>::Char>>

Get the next Token from the Mouth. This method should not be called directly, but rather through EngineReferences::get_next or Gullet::get_next_opt.

fn iterate<R, E, F>( &mut self, aux: &mut EngineAux<ET>, state: &<ET as EngineTypes>::State, cont: F, eof: E, ) -> Result<R, TeXError<ET>>

where F: FnMut(&mut EngineAux<ET>, <ET as EngineTypes>::Token) -> Result<Option<R>, TeXError<ET>>, E: Fn(&EngineAux<ET>, &<ET as EngineTypes>::State, &mut DefaultMouth<ET>) -> Result<(), TeXError<ET>>,

Iterate over the Tokens in the Mouth until cont returns false. Can be faster than repeatedly calling get_next_opt, but blocking both state changes and expanding macros. Useful for e.g. reading macro arguments or the expansion list in \def. This method should not be called directly, but rather through EngineReferences::iterate or Gullet::iterate.

fn preview( &self, int: &<<ET as EngineTypes>::CSName as CSName<<ET as EngineTypes>::Char>>::Handler, cc: &<<ET as EngineTypes>::Char as Character>::CharMap<CategoryCode>, esc: Option<<ET as EngineTypes>::Char>, ) -> String

For debugging purposes, this method returns a string representation of the upcoming stuff in the Mouth.

fn read_until_endgroup<E, F>( &mut self, aux: &mut EngineAux<ET>, state: &<ET as EngineTypes>::State, cont: F, eof: E, ) -> Result<<ET as EngineTypes>::Token, TeXError<ET>>

where F: FnMut(&mut EngineAux<ET>, <ET as EngineTypes>::Token) -> Result<(), TeXError<ET>>, E: Fn(&EngineAux<ET>, &<ET as EngineTypes>::State, &mut Self) -> Result<(), TeXError<ET>>,

Convenience method reading Tokens in the Mouth until the next EndGroup Token is encountered and returns that. Useful whenever a group is to be taken; e.g. when reading macro arguments. This method should not be called directly, but rather through EngineReferences::read_until_endgroup or Gullet::read_until_endgroup.