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
|
{
package parser
func exprs(first, rest interface{}) []ast.Expr {
es := []ast.Expr{first.(ast.Expr)}
if rest == nil {
return es
}
for _, i := range rest.([]interface{}) {
es = append(es, i.([]interface{})[3].(ast.Expr))
}
return es
}
}
// Chain
Chain <- as:Assignment* r:Return _ EOF {
ch := &ast.Chain{}
for _, a := range as.([]interface{}) {
ch.Statements = append(ch.Statements, a.(ast.Statement))
}
ch.Statements = append(ch.Statements, r.(ast.Statement))
return ch, nil
}
// Statements
Assignment <- _ n:Identifier _ '=' _ e:Expr _ EOL {
return ast.Statement{
Name: n.(ast.Identifier),
Expr: e.(ast.Expr),
}, nil
}
Return <- _ ("return" __)? e:Expr _ EOL? {
return ast.Statement{
Name: "",
Expr: e.(ast.Expr),
}, nil
}
// Expressions
Expr <- e:AddExpr {
return e, nil
}
AddExpr <- _ x:ShiftExpr rest:(_ AddOperator _ ShiftExpr)* _ {
es := exprs(x, rest)
r := es[0]
for _, e := range es[1:] {
r = ast.Add{
X: r,
Y: e,
}
}
return r, nil
}
ShiftExpr <- _ x:BaseExpr _ ShiftOperator _ s:UintLiteral _ {
return ast.Shift{
X: x.(ast.Expr),
S: s.(uint),
}, nil
} / _ DoubleOperator _ x:BaseExpr {
return ast.Double{
X: x.(ast.Expr),
}, nil
} / BaseExpr
BaseExpr <- ParenExpr / Operand
ParenExpr <- '(' _ e:Expr _ ')' {
return e, nil
}
// Operators
AddOperator <- '+' / "add"
ShiftOperator <- "<<" / "shl"
DoubleOperator <- '2' _ '*' / "dbl"
// Operands
Operand <- op:( One / Index / Identifier ) {
return op, nil
}
One <- '1' {
return ast.Operand(0), nil
}
Index <- '[' _ idx:UintLiteral _ ']' {
return ast.Operand(idx.(uint)), nil
}
// Identifiers
Identifier <- [a-zA-Z_] [a-zA-Z0-9_]* {
return ast.Identifier(c.text), nil
}
// Primitives
UintLiteral <- u64:Uint64Literal {
return uint(u64.(uint64)), nil
}
Uint64Literal <- (HexUintLiteral / OctalUintLiteral / DecimalUintLiteral) {
return strconv.ParseUint(string(c.text), 0, 64)
}
DecimalUintLiteral <- [0-9]+
HexUintLiteral <- "0x" [0-9a-fA-F]+
OctalUintLiteral <- '0' [0-7]+
// Character classes
__ <- Whitespace+
_ <- Whitespace*
Whitespace <- [ \t\r]
EOL <- '\n'
EOF <- !.
|
