rust-bakery / nom-peg

PEG parser generator built on top of nom

PEG Grammars for Nom

nom-peg is a PEG (Parsing Expression Grammar) parser generator built on top of nom, using a syntax that is heavily inspired by LALRPOP.

Grammars defined with nom-peg can freely be mixed with other nom parsers.

Example

let arithmetic = grammar! {
    // a grammar can have as many non-terminals as you want, and can return any type
    parse: i64 = <term> "="

    // alternatives are separated by `|`,
    // and the `=> { ... }` syntax is used to manipulate the output of the parser before returning it
    term: i64 = <l: factor> "+" <r: term> => { l + r }
              | <l: factor> "-" <r: term> => { l - r }
              | factor

    // the `<...>` syntax is used to capture the output of a sub-parser,
    // and optionally assign it to a local variable with `<name: ...>`
    factor: i64 = <l: value> "*" <r: factor> => { l * r }
                | <l: value> "/" <r: factor> => { l / r }
                | value

    value: i64 = ("0"|"1"|"2"|"3"|"4"|"5"|"6"|"7"|"8"|"9")+ => { result.join("").parse::<i64>().unwrap() }
               | "(" <term> ")"
};

// when the grammar is defined you can use any of the non-terminals as parser functions
assert_eq!(arithmetic.parse("123="), Ok(("", 123 as i64)));
assert_eq!(arithmetic.parse("1+1="), Ok(("", 2 as i64)));
assert_eq!(arithmetic.parse("12+(3*7)="), Ok(("", 33 as i64)));

nom-peg's Issues

Try to lift the dependency on unstable rust

I already attempted to try to use proc-macro-hack instead, but it failed to work, likely because of they weird (and honestly, probably bad) construction it builds to allow the user to use the . operator to access the different sub-parsers / non-terminals:

// user code
let parser = grammar! {
    something = ...
    something_else = ...
}

would essentially expand to this:

let parser = {
        struct PEGParser {}
        impl PEGParser {
            fn something<'input>(&self, input: &'input str) -> ... 
                ...
            }
             fn something_else<'input>(&self, input: &'input str) -> ... 
                ...
            }
        }
    PEGParser {}
    }
}

and then it can be used like this:

let result = parser.something("some string");

An alternative way to (hopefully) circumvent the use of the currently unstable #![feature(proc_macro_hygiene)] could be to do something like this instead:

// user code
mod parser {
    grammar! {
        something = ...
        something_else = ...
    }
}

and then expand to this, without the weird struct/impl construction:

mod parser {
    fn something<'input>(&self, input: &'input str) -> ... 
        ...
    }
    fn something_else<'input>(&self, input: &'input str) -> ... 
        ...
    }
}

and the use would be slightly different, but not much:

let result = parser::something("some string");

This should "just work" on stable rust AFAIK, and in the worst case it should definitely work using proc-macro-hack.

(Note: wrapping the grammar! invocation in a mod is simply to avoid namespace pollution, it could technically be left out if the user wants that.)

Left Recursion and Precedence

This would be an amazing feature to have :)

Some prior work:

• https://github.com/PhilippeSigaud/Pegged/wiki/Left-Recursion
• https://arxiv.org/pdf/1207.0443.pdf
• https://arxiv.org/pdf/1509.02439v1.pdf

Suggestions: New features for version 0.2.0?

Hey,
Just putting this issue here to list suggestions / ideas for the next version.

1. port everything to use nom 5.0 (alpha)
2. ...