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
use std::ops::{Deref, DerefMut};
use Cfg;
use Symbol;
use ContextFree;
use ContextFreeRef;
use rule::builder::RuleBuilder;
use sequence::builder::SequenceRuleBuilder;
use sequence::Sequence;
use super::BinarizedGrammar;
use super::history::{History, BuildHistory};
#[derive(Default)]
pub struct Grammar {
inherit: Cfg<History, History>,
start: Option<Symbol>,
}
impl Grammar {
pub fn new() -> Self {
Grammar {
inherit: Cfg::new(),
start: None,
}
}
pub fn set_start(&mut self, start: Symbol) {
self.start = Some(start);
}
pub fn start(&self) -> Symbol {
self.start.unwrap()
}
pub fn rule(&mut self, lhs: Symbol) -> RuleBuilder<&mut Cfg<History, History>, BuildHistory> {
let rule_count = self.inherit.rules().count() + self.sequence_rules().len();
self.inherit.rule(lhs).default_history(BuildHistory::new(rule_count))
}
pub fn sequence(&mut self, lhs: Symbol)
-> SequenceRuleBuilder<History, &mut Vec<Sequence<History>>, BuildHistory>
{
let rule_count = self.inherit.rules().count() + self.sequence_rules().len();
self.inherit.sequence(lhs).default_history(BuildHistory::new(rule_count))
}
pub fn binarize(&self) -> BinarizedGrammar {
BinarizedGrammar {
inherit: self.inherit.binarize(),
start: self.start,
has_wrapped_start: false,
}
}
}
impl Deref for Grammar {
type Target = Cfg<History, History>;
fn deref(&self) -> &Self::Target {
&self.inherit
}
}
impl DerefMut for Grammar {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inherit
}
}