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
|
comment = '#' (~'\n' anything)*
hspace = ' ' | '\t' | comment
vspace = '\r\n' | '\r' | '\n'
ws = (hspace | vspace | comment)*
number = ws ('-' barenumber:x -> t.Exactly(-x)
|barenumber:x -> t.Exactly(x))
barenumber = '0' (('x'|'X') <hexdigit+>:hs -> int(hs, 16)
|<octaldigit+>:ds -> int(ds, 8))
|<digit+>:ds -> int(ds)
octaldigit = :x ?(x in '01234567' ) -> x
hexdigit = :x ?(x in '0123456789ABCDEFabcdef') -> x
escapedChar = '\\' ('n' -> "\n"
|'r' -> "\r"
|'t' -> "\t"
|'b' -> "\b"
|'f' -> "\f"
|'"' -> '"'
|'\'' -> "'"
|'\\' -> "\\")
character = ws '\'' (escapedChar | anything):c ws '\'' -> t.Exactly(c)
string = ws '"' (escapedChar | ~('"') anything)*:c '"' -> t.Exactly(''.join(c))
name = <letter (letterOrDigit | '_')*>
application = (ws '<' ws name:name
(' ' !(self.applicationArgs(finalChar='>')):args '>'
-> t.Apply(name, self.rulename, args)
|ws '>'
-> t.Apply(name, self.rulename, [])))
expr1 = (application
|ruleValue
|semanticPredicate
|semanticAction
|number:n !(self.isTree()) -> n
|character
|string
|ws '(' expr:e ws ')' -> e
|(ws '[' expr:e ws ']' !(self.isTree())
-> t.List(e)))
expr2 = (ws '~' ('~' expr2:e
-> t.Lookahead(e)
|expr2:e -> t.Not(e))
|expr1)
expr3 = expr2:e
('*' -> t.Many(e)
|'+' -> t.Many1(e)
|'?' -> t.Optional(e)
| -> e):r
(':' name:n -> t.Bind(n, r)
| -> r)
| (ws ':' name:n -> t.Bind(n, t.Apply("anything", self.rulename, [])))
expr4 = expr3*:es -> t.And(es)
expr = expr4:e (ws '|' expr4)*:es
-> t.Or([e] + es)
ruleValue = ws '=>' -> self.ruleValueExpr(False)
semanticPredicate = ws '?(' -> self.semanticPredicateExpr()
semanticAction = ws '!(' -> self.semanticActionExpr()
ruleEnd = (hspace* vspace+) | end
rulePart :requiredName = ws name:n ?(n == requiredName)
!(setattr(self, "rulename", n))
expr4:args
(ws '::=' expr:e ruleEnd
-> t.And([args, e])
| ruleEnd -> args)
rule = (ws ~~(name:n) rulePart(n):r
(rulePart(n)+:rs -> t.Rule(n, t.Or([r] + rs))
| -> t.Rule(n, r)))
grammar = rule*:rs ws -> t.Grammar(self.name, self.tree_target, rs)
|
