Struct lrpar::CTParserBuilder

pub struct CTParserBuilder<'a, StorageT = u32> where
    StorageT: Eq + Hash,  { /* fields omitted */ }

A CTParserBuilder allows one to specify the criteria for building a statically generated parser.

Methods

impl<'a> CTParserBuilder<'a, u32>

pub fn new() -> Self

Create a new CTParserBuilder.

Examples

CTParserBuilder::new()
    .process_file_in_src("grm.y")
    .unwrap();

impl<'a, StorageT> CTParserBuilder<'a, StorageT> where
    StorageT: 'static + Debug + Hash + PrimInt + Serialize + TypeName + Unsigned,
    usize: AsPrimitive<StorageT>,
    u32: AsPrimitive<StorageT>, 

pub fn new_with_storaget() -> Self

Create a new CTParserBuilder.

StorageT must be an unsigned integer type (e.g. u8, u16) which is big enough to index (separately) all the tokens, rules, and productions in the grammar and less than or equal in size to usize (e.g. on a 64-bit machine u128 would be too big). In other words, if you have a grammar with 256 tokens, 256 rules, and 256 productions, you can safely specify u8 here; but if any of those counts becomes 256 you will need to specify u16. If you are parsing large files, the additional storage requirements of larger integer types can be noticeable, and in such cases it can be worth specifying a smaller type. StorageT defaults to u32 if unspecified.

Examples

CTParserBuilder::<u8>::new_with_storaget()
    .process_file_in_src("grm.y")
    .unwrap();

pub fn mod_name(self, mod_name: &'a str) -> Self

Set the generated module name to mod_name. If no module name is specified, process_file will attempt to create a sensible default based on the input filename.

pub fn recoverer(self, rk: RecoveryKind) -> Self

Set the recoverer for this parser to rk.

pub fn yacckind(self, yk: YaccKind) -> Self

Set the YaccKind for this parser to ak.

pub fn error_on_conflicts(self, b: bool) -> Self

If set to true, process_file_in_src will return an error if the given grammar contains any Shift/Reduce or Reduce/Reduce conflicts. Defaults to true.

pub fn conflicts(
    &self
) -> Option<(&YaccGrammar<StorageT>, &StateGraph<StorageT>, &StateTable<StorageT>, &Conflicts<StorageT>)>

If there are any conflicts in the grammar, return a tuple which allows users to inspect and pretty print them; otherwise returns None. Note: The conflicts feature is currently unstable and may change in the future.

pub fn process_file_in_src(
    &mut self,
    srcp: &str
) -> Result<HashMap<String, StorageT>, Box<dyn Error>>

Given the filename a/b.y as input, statically compile the grammar src/a/b.y into a Rust module which can then be imported using lrpar_mod!("a/b.y"). This is a convenience function around process_file which makes it easier to compile grammar files stored in a project's src/ directory: please see process_file for additional constraints and information about the generated files.

pub fn process_file<P, Q>(
    &mut self,
    inp: P,
    outp: Q
) -> Result<HashMap<String, StorageT>, Box<dyn Error>> where
    P: AsRef<Path>,
    Q: AsRef<Path>, 

Statically compile the Yacc file inp into Rust, placing the output into the file outp. Note that three additional files will be created with the same name as outp but with the extensions grm, sgraph, and stable, overwriting any existing files with those names.

outp defines a module as follows:

  mod modname {
    fn parse(lexemes: &::std::vec::Vec<::lrpar::Lexeme<StorageT>>) { ... }
        -> (::std::option::Option<ActionT>,
            ::std::vec::Vec<::lrpar::LexParseError<StorageT>>)> { ...}

    fn token_epp<'a>(tidx: ::cfgrammar::TIdx<StorageT>) -> ::std::option::Option<&'a str> {
      ...
    }

    ...
  }

where:

• modname is either:
  • the module name specified mod_name
  • or, if no module name was explicitly specified, then for the file /a/b/c.y the module name is c_y (i.e. the file's leaf name, minus its extension, with a prefix of _y).
• ActionT is either:
  • the %actiontype value given to the grammar
  • or, if the yacckind was set YaccKind::Original(YaccOriginalActionKind::UserAction), it is Node<StorageT>

Panics

If StorageT is not big enough to index the grammar's tokens, rules, or productions.