Struct Grammar

pub struct Grammar {
    pub imports: Vec<ImportStm>,
    pub productions: ProdVec<Production>,
    pub terminals: TermVec<Terminal>,
    pub nonterminals: NonTermVec<NonTerminal>,
    pub nonterm_by_name: BTreeMap<String, SymbolIndex>,
    pub term_by_name: BTreeMap<String, SymbolIndex>,
    pub empty_index: SymbolIndex,
    pub stop_index: SymbolIndex,
    pub augmented_index: SymbolIndex,
    pub augmented_layout_index: Option<SymbolIndex>,
    pub start_index: SymbolIndex,
}

Fields

imports: Vec<ImportStm>

productions: ProdVec<Production>

terminals: TermVec<Terminal>

nonterminals: NonTermVec<NonTerminal>

nonterm_by_name: BTreeMap<String, SymbolIndex>

term_by_name: BTreeMap<String, SymbolIndex>

empty_index: SymbolIndex

Index of EMPTY symbol

stop_index: SymbolIndex

Index of STOP symbol

augmented_index: SymbolIndex

Index of grammar augmented symbol

augmented_layout_index: Option<SymbolIndex>

Index of augmented symbol for Layout rule if given

start_index: SymbolIndex

An index of the start symbol. First non-terminal or terminal of the grammar.

Implementations

impl Grammar

pub fn symbol_index(&self, name: &str) -> SymbolIndex

pub fn symbol_name(&self, index: SymbolIndex) -> String

pub fn symbol_has_content(&self, symbol: SymbolIndex) -> bool

If this symbol is either a non-terminal of a terminal with a content. I.e. not a constant match terminal (keyword, punctuation…)

pub fn symbol_indexes(&self, names: &[&str]) -> SymbolVec<SymbolIndex>

pub fn symbol_names<T>(&self, indexes: T) -> Vec<String>

where T: IntoIterator<Item = SymbolIndex>,

pub fn term_to_symbol_index(&self, index: TermIndex) -> SymbolIndex

pub fn symbol_to_term_index(&self, index: SymbolIndex) -> TermIndex

Convert symbol index to terminal index.

pub fn symbol_to_term(&self, index: SymbolIndex) -> &Terminal

Convert symbol index to terminal

pub fn term_by_name(&self, name: &str) -> &Terminal

Get Terminal by name.

pub fn term_by_index(&self, index: TermIndex) -> &Terminal

Get Terminal by index.

pub fn nonterm_to_symbol_index(&self, index: NonTermIndex) -> SymbolIndex

pub fn symbol_to_nonterm_index(&self, index: SymbolIndex) -> NonTermIndex

Convert symbol index to non-terminal index. Panics if symbol index is a terminal index.

pub fn symbol_to_nonterm(&self, index: SymbolIndex) -> &NonTerminal

Convert symbol index to non-terminal. Panics if symbol index is a terminal index.

pub fn nonterm_by_name(&self, name: &str) -> &NonTerminal

Get NonTerminal by name.

pub fn nonterm_by_index(&self, index: NonTermIndex) -> &NonTerminal

Get NonTerminal by index.

pub fn is_nonterm(&self, index: SymbolIndex) -> bool

pub fn is_term(&self, index: SymbolIndex) -> bool

pub fn is_empty(&self, index: SymbolIndex) -> bool

pub fn production_len(&self, prod: ProdIndex) -> usize

pub fn production_rhs_symbols(&self, prod: ProdIndex) -> Vec<SymbolIndex>

pub fn productions(&self) -> Vec<&Production>

Returns all productions except special AUG and AUGL.

pub fn nonterminals(&self) -> Vec<&NonTerminal>

Returns all nonterminals except special EMPTY, AUG and AUGL.

pub fn is_enum(&self, nonterminal: &NonTerminal) -> bool

pub fn has_layout(&self) -> bool

Trait Implementations

impl Debug for Grammar

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

Formats the value using the given formatter.

impl Display for Grammar

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

Formats the value using the given formatter.

impl FromStr for Grammar

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.