Struct syntect::parsing::ParseState

pub struct ParseState { /* private fields */ }

Keeps the current parser state (the internal syntax interpreter stack) between lines of parsing.

If you are parsing an entire file you create one of these at the start and use it all the way to the end.

Caching

One reason this is exposed is that since it implements Clone you can actually cache these (probably along with a HighlightState) and only re-start parsing from the point of a change. See the docs for HighlightState for more in-depth discussion of caching.

This state doesn’t keep track of the current scope stack and parsing only returns changes to this stack so if you want to construct scope stacks you’ll need to keep track of that as well. Note that HighlightState contains exactly this as a public field that you can use.

Note: Caching is for advanced users who have tons of time to maximize performance or want to do so eventually. It is not recommended that you try caching the first time you implement highlighting.

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<Vec<(usize, ScopeStackOp)>, 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.

Trait Implementations

impl Clone for ParseState

fn clone(&self) -> ParseState

Returns a copy 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<ParseState> for ParseState

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for ParseState

impl StructuralEq for ParseState

impl StructuralPartialEq for ParseState