earlgrey 0.4.1

A library for parsing context-free grammars using Earley algorithm
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

fn build_grammar() -> earlgrey::Grammar {
    use std::str::FromStr;
    earlgrey::GrammarBuilder::default()
        .nonterm("expr")
        .nonterm("term")
        .nonterm("factor")
        .nonterm("power")
        .nonterm("ufact")
        .nonterm("group")
        .nonterm("func")
        .nonterm("args")
        .terminal("[n]", |n| f64::from_str(n).is_ok())
        .terminal("+", |n| n == "+")
        .terminal("-", |n| n == "-")
        .terminal("*", |n| n == "*")
        .terminal("/", |n| n == "/")
        .terminal("%", |n| n == "%")
        .terminal("^", |n| n == "^")
        .terminal("!", |n| n == "!")
        .terminal("(", |n| n == "(")
        .terminal(")", |n| n == ")")
        .rule("expr", &["term"])
        .rule("expr", &["expr", "+", "term"])
        .rule("expr", &["expr", "-", "term"])
        .rule("term", &["factor"])
        .rule("term", &["term", "*", "factor"])
        .rule("term", &["term", "/", "factor"])
        .rule("term", &["term", "%", "factor"])
        .rule("factor", &["power"])
        .rule("factor", &["-", "factor"])
        .rule("power", &["ufact"])
        .rule("power", &["ufact", "^", "factor"])
        .rule("ufact", &["group"])
        .rule("ufact", &["ufact", "!"])
        .rule("group", &["[n]"])
        .rule("group", &["(", "expr", ")"])
        .into_grammar("expr")
        .expect("Bad Gramar")
}

struct Tokenizer<I: Iterator<Item = char>>(lexers::Scanner<I>);

impl<I: Iterator<Item = char>> Iterator for Tokenizer<I> {
    type Item = String;
    fn next(&mut self) -> Option<Self::Item> {
        self.0.scan_whitespace();
        self.0
            .scan_math_op()
            .or_else(|| self.0.scan_number())
            .or_else(|| self.0.scan_identifier())
    }
}

fn tokenizer<I: Iterator<Item = char>>(input: I) -> Tokenizer<I> {
    Tokenizer(lexers::Scanner::new(input))
}

fn gamma(x: f64) -> f64 {
    #[link(name = "m")]
    extern "C" {
        fn tgamma(x: f64) -> f64;
    }
    unsafe { tgamma(x) }
}

fn semanter<'a>() -> earlgrey::EarleyForest<'a, f64> {
    use std::str::FromStr;
    let mut ev = earlgrey::EarleyForest::new(|symbol, token| match symbol {
        "[n]" => f64::from_str(token).unwrap(),
        _ => 0.0,
    });
    ev.action("expr -> term", |n| n[0]);
    ev.action("expr -> expr + term", |n| n[0] + n[2]);
    ev.action("expr -> expr - term", |n| n[0] - n[2]);
    ev.action("term -> factor", |n| n[0]);
    ev.action("term -> term * factor", |n| n[0] * n[2]);
    ev.action("term -> term / factor", |n| n[0] / n[2]);
    ev.action("term -> term % factor", |n| n[0] % n[2]);
    ev.action("factor -> power", |n| n[0]);
    ev.action("factor -> - factor", |n| -n[1]);
    ev.action("power -> ufact", |n| n[0]);
    ev.action("power -> ufact ^ factor", |n| n[0].powf(n[2]));
    ev.action("ufact -> group", |n| n[0]);
    ev.action("ufact -> ufact !", |n| gamma(n[0] + 1.0));
    ev.action("group -> [n]", |n| n[0]);
    ev.action("group -> ( expr )", |n| n[1]);
    ev
}

fn main() -> Result<(), String> {
    let grammar = build_grammar();
    let parser = earlgrey::EarleyParser::new(grammar.clone());
    let evaler = semanter();

    if std::env::args().len() > 1 {
        let input = std::env::args().skip(1).collect::<Vec<String>>().join(" ");
        match parser.parse(tokenizer(input.chars())) {
            Err(e) => println!("Parse err: {:?}", e),
            Ok(state) => println!("{:?}", evaler.eval(&state)),
        }
        return Ok(());
    }

    println!("{:?}", grammar);
    use rustyline::error::ReadlineError;

    let mut rl = rustyline::DefaultEditor::new().map_err(|e| e.to_string())?;
    loop {
        match rl.readline("~> ") {
            Err(ReadlineError::Interrupted) | Err(ReadlineError::Eof) => return Ok(()),
            Err(e) => return Err(format!("Readline err: {:?}", e)),
            Ok(line) => match parser.parse(&mut tokenizer(line.chars())) {
                Err(e) => println!("Parse err: {:?}", e),
                Ok(state) => {
                    let _ = rl.add_history_entry(&line);
                    println!("{:?}", evaler.eval(&state));
                }
            },
        }
    }
}