Struct syntect::parsing::SyntaxSetBuilder

pub struct SyntaxSetBuilder { /* fields omitted */ }

A syntax set builder is used for loading syntax definitions from the file system or by adding SyntaxDefinition objects.

Once all the syntaxes have been added, call build to turn the builder into a SyntaxSet that can be used for parsing or highlighting.

Implementations

impl SyntaxSetBuilder

pub fn new() -> SyntaxSetBuilder

pub fn add(&mut self, syntax: SyntaxDefinition)

Add a syntax to the set.

pub fn syntaxes(&self) -> &[SyntaxDefinition]

The list of syntaxes added so far.

pub fn add_plain_text_syntax(&mut self)

A rarely useful method that loads in a syntax with no highlighting rules for plain text

Exists mainly for adding the plain text syntax to syntax set dumps, because for some reason the default Sublime plain text syntax is still in .tmLanguage format.

pub fn add_from_folder<P: AsRef<Path>>(
    &mut self,
    folder: P,
    lines_include_newline: bool
) -> Result<(), LoadingError>

Loads all the .sublime-syntax files in a folder into this builder.

The lines_include_newline parameter is used to work around the fact that Sublime Text normally passes line strings including newline characters (\n) to its regex engine. This results in many syntaxes having regexes matching \n, which doesn’t work if you don’t pass in newlines. It is recommended that if you can you pass in lines with newlines if you can and pass true for this parameter. If that is inconvenient pass false and the loader will do some hacky find and replaces on the match regexes that seem to work for the default syntax set, but may not work for any other syntaxes.

In the future I might include a “slow mode” that copies the lines passed in and appends a newline if there isn’t one, but in the interest of performance currently this hacky fix will have to do.

pub fn build(self) -> SyntaxSet

Build a SyntaxSet from the syntaxes that have been added to this builder.

Linking

The contexts in syntaxes can reference other contexts in the same syntax or even other syntaxes. For example, a HTML syntax can reference a CSS syntax so that CSS blocks in HTML work as expected.

Those references work in various ways and involve one or two lookups. To avoid having to do these lookups during parsing/highlighting, the references are changed to directly reference contexts via index. That’s called linking.

Linking is done in this build step. So in order to get the best performance, you should try to avoid calling this too much. Ideally, create a SyntaxSet once and then use it many times. If you can, serialize a SyntaxSet for your program and when you run the program, directly load the SyntaxSet.

Trait Implementations

impl Clone for SyntaxSetBuilder

fn clone(&self) -> SyntaxSetBuilder

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for SyntaxSetBuilder

fn default() -> SyntaxSetBuilder

Returns the “default value” for a type.