Struct ParserLimits

#[repr(C)]
pub struct ParserLimits {
    pub max_items_in_row: usize,
    pub initial_lexer_fuel: u64,
    pub step_lexer_fuel: u64,
    pub step_max_items: usize,
    pub max_lexer_states: usize,
    pub max_grammar_size: usize,
    pub precompute_large_lexemes: bool,
}

Fields

max_items_in_row: usize

For non-ambiguous grammars, this is the maximum “branching factor” of the grammar. For ambiguous grammars, this might get hit much quicker. Default: 2000

initial_lexer_fuel: u64

How much “fuel” are we willing to spend to build initial lexer regex AST nodes. Default: 1_000_000 Speed: 50k/ms

step_lexer_fuel: u64

Maximum lexer fuel for computation of the whole token mask. Default: 200_000 Speed: 14k/ms

step_max_items: usize

Number of Earley items created for the whole token mask. Default: 50_000 Speed: 20k/ms

max_lexer_states: usize

Maximum number of lexer states. Affects memory consumption, but not the speed for the most part. Default: 250_000 Speed: ~1-2kB of memory per state

max_grammar_size: usize

Maximum size of the grammar (symbols in productions) Default: 500_000 (a few megabytes of JSON)

precompute_large_lexemes: bool

If true, we’ll run any extremely large regexes against the whole trie of the tokenizer while constructing the lexer. This reduces future mask computation time, but increases the time it takes to construct the lexer. Default: true

Trait Implementations

impl Clone for ParserLimits

fn clone(&self) -> ParserLimits

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ParserLimits

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

Formats the value using the given formatter.

impl Default for ParserLimits

fn default() -> ParserLimits

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ParserLimits

where ParserLimits: Default,

fn deserialize<__D>( __deserializer: __D, ) -> Result<ParserLimits, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ParserLimits

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.