Struct ParseState 

pub struct ParseState { /* private fields */ }

Implementations

impl ParseState

pub fn new(syntax: &SyntaxReference) -> ParseState

Creates a state from a syntax definition, keeping its own reference-counted point to the main context of the syntax

pub fn parse_line( &mut self, line: &str, syntax_set: &SyntaxSet, ) -> Result<ParseLineOutput, ParsingError>

Parses a single line of the file. Because of the way regex engines work you unfortunately have to pass in a single line contiguous in memory. This can be bad for really long lines. Sublime Text avoids this by just not highlighting lines that are too long (thousands of characters).

For efficiency reasons this returns only the changes to the current scope at each point in the line. You can use ScopeStack::apply on each operation in succession to get the stack for a given point. Look at the code in highlighter.rs for an example of doing this for highlighting purposes.

The returned vector is in order both by index to apply at (the usize) and also by order to apply them at a given index (e.g popping old scopes before pushing new scopes).

The SyntaxSet has to be the one that contained the syntax that was used to construct this ParseState, or an extended version of it. Otherwise the parsing would return the wrong result or even panic. The reason for this is that contexts within the SyntaxSet are referenced via indexes.

pub fn is_speculative(&self) -> bool

Returns true when the parser is inside a branch_point and the result of parse_line may be revised by a future fail action. Once the branch resolves (or if no branch was entered), this returns false and all ops emitted so far are final.

Trait Implementations

impl Clone for ParseState

fn clone(&self) -> ParseState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParseState

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

Formats the value using the given formatter.

impl PartialEq for ParseState

fn eq(&self, other: &ParseState) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ParseState

impl StructuralPartialEq for ParseState