beans 8.0.0

A parser generator library based on the Earley parser
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use std::collections::{HashMap, HashSet};
use std::rc::Rc;

use crate::{
    lexer::{Grammar as LexerGrammar, TerminalId},
    span::Span,
};
use newty::newty;
use serde::{Deserialize, Serialize};

use super::{earley::EarleyGrammar, parser::NonTerminalId, Value, AST};

newty! {
    #[derive(Serialize, Deserialize)]
    pub vec NonTerminalName(Rc<str>)[NonTerminalId]
}

newty! {
    #[derive(Serialize, Deserialize)]
    pub vec NonTerminalDescription(Option<Rc<str>>)[NonTerminalId]
}

newty! {
    pub set Axioms [NonTerminalId]
}

newty! {
    #[derive(Serialize, Deserialize)]
    pub vec Rules(Rule)[RuleId]
}

newty! {
    pub set Nullables[NonTerminalId]
}

newty! {
    #[derive(PartialOrd, Ord)]
    pub id RuleId
}

pub type Proxy = HashMap<Rc<str>, ValueTemplate>;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ElementType {
    Terminal(TerminalId),
    NonTerminal(NonTerminalId),
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum Attribute {
    Named(Rc<str>),
    Indexed(usize),
    None,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Element {
    pub attribute: Attribute,
    pub key: Option<Rc<str>>,
    pub element_type: ElementType,
}

impl Element {
    pub fn new(attribute: Attribute, key: Option<Rc<str>>, element_type: ElementType) -> Self {
        Self {
            attribute,
            key,
            element_type,
        }
    }

    pub fn name(&self, lexer_grammar: &LexerGrammar, grammar: &EarleyGrammar) -> Rc<str> {
        match self.element_type {
            ElementType::Terminal(id) => lexer_grammar.name(id).into(),
            ElementType::NonTerminal(id) => grammar.name_of(id),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum ValueTemplate {
    String(Rc<str>),
    Variable(Rc<str>),
    InlineRule {
        non_terminal: NonTerminalId,
        attributes: Proxy,
    },
}

impl ValueTemplate {
    pub fn evaluate(
        &self,
        all_attributes: &HashMap<Rc<str>, AST>,
        removed: &mut HashSet<Rc<str>>,
        span: &Span,
    ) -> AST {
        match self {
            ValueTemplate::String(string) => AST::Literal {
                value: Value::Str(string.clone()),
                span: None,
            },
            ValueTemplate::Variable(name) => {
                removed.insert(name.clone());
                all_attributes[name].clone()
            }
            ValueTemplate::InlineRule {
                non_terminal,
                attributes,
            } => AST::Node {
                nonterminal: *non_terminal,
                attributes: attributes
                    .iter()
                    .map(|(key, value_template)| {
                        (
                            key.clone(),
                            value_template.evaluate(all_attributes, removed, span),
                        )
                    })
                    .collect(),
                span: span.clone(),
            },
        }
    }
}

#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct Rule {
    pub id: NonTerminalId,
    pub elements: Vec<Element>,
    pub proxy: Proxy,
    pub left_associative: bool,
}

impl Rule {
    pub fn new(
        id: NonTerminalId,
        elements: Vec<Element>,
        proxy: Proxy,
        left_associative: bool,
    ) -> Self {
        Self {
            id,
            elements,
            proxy,
            left_associative,
        }
    }
}