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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use quote::{quote, ToTokens};
use std::fs::File;
use std::io::{Read, Write};
use std::path::Path;
use syn;
use syn::fold::Fold;
use syn::parse::{Parse, ParseStream, Result};
use syn::{parse_quote, Token};
use proc_macro2::{Span, TokenStream};
struct MatchByteParser {}
pub fn expand(from: &Path, to: &Path) {
let mut source = String::new();
File::open(from)
.unwrap()
.read_to_string(&mut source)
.unwrap();
let ast = syn::parse_file(&source).expect("Parsing rules.rs module");
let mut m = MatchByteParser {};
let ast = m.fold_file(ast);
let code = ast
.into_token_stream()
.to_string()
.replace("{ ", "{\n")
.replace(" }", "\n}");
File::create(to)
.unwrap()
.write_all(code.as_bytes())
.unwrap();
}
struct MatchByte {
expr: syn::Expr,
arms: Vec<syn::Arm>,
}
impl Parse for MatchByte {
fn parse(input: ParseStream) -> Result<Self> {
Ok(MatchByte {
expr: {
let expr = input.parse()?;
input.parse::<Token![,]>()?;
expr
},
arms: {
let mut arms = Vec::new();
while !input.is_empty() {
arms.push(input.call(syn::Arm::parse)?);
}
arms
},
})
}
}
fn get_byte_from_expr_lit(expr: &Box<syn::Expr>) -> u8 {
match **expr {
syn::Expr::Lit(syn::ExprLit { ref lit, .. }) => {
if let syn::Lit::Byte(ref byte) = *lit {
byte.value()
} else {
panic!("Found a pattern that wasn't a byte")
}
}
_ => unreachable!(),
}
}
/// Parse a pattern and fill the table accordingly
fn parse_pat_to_table<'a>(
pat: &'a syn::Pat,
case_id: u8,
wildcard: &mut Option<&'a syn::Ident>,
table: &mut [u8; 256],
) {
match pat {
&syn::Pat::Lit(syn::PatLit { ref expr, .. }) => {
let value = get_byte_from_expr_lit(expr);
if table[value as usize] == 0 {
table[value as usize] = case_id;
}
}
&syn::Pat::Range(syn::PatRange { ref lo, ref hi, .. }) => {
let lo = get_byte_from_expr_lit(lo);
let hi = get_byte_from_expr_lit(hi);
for value in lo..hi {
if table[value as usize] == 0 {
table[value as usize] = case_id;
}
}
if table[hi as usize] == 0 {
table[hi as usize] = case_id;
}
}
&syn::Pat::Wild(_) => {
for byte in table.iter_mut() {
if *byte == 0 {
*byte = case_id;
}
}
}
&syn::Pat::Ident(syn::PatIdent { ref ident, .. }) => {
assert_eq!(*wildcard, None);
*wildcard = Some(ident);
for byte in table.iter_mut() {
if *byte == 0 {
*byte = case_id;
}
}
}
&syn::Pat::Or(syn::PatOr { ref cases, .. }) => {
for case in cases {
parse_pat_to_table(case, case_id, wildcard, table);
}
}
_ => {
panic!("Unexpected pattern: {:?}. Buggy code ?", pat);
}
}
}
/// Expand a TokenStream corresponding to the `match_byte` macro.
///
/// ## Example
///
/// ```rust
/// match_byte! { tokenizer.next_byte_unchecked(),
/// b'a'..b'z' => { ... }
/// b'0'..b'9' => { ... }
/// b'\n' | b'\\' => { ... }
/// foo => { ... }
/// }
/// ```
///
fn expand_match_byte(body: &TokenStream) -> syn::Expr {
let match_byte: MatchByte = syn::parse2(body.clone()).unwrap();
let expr = match_byte.expr;
let mut cases = Vec::new();
let mut table = [0u8; 256];
let mut match_body = Vec::new();
let mut wildcard = None;
for (i, ref arm) in match_byte.arms.iter().enumerate() {
let case_id = i + 1;
let index = case_id as isize;
let name = syn::Ident::new(&format!("Case{}", case_id), Span::call_site());
parse_pat_to_table(&arm.pat, case_id as u8, &mut wildcard, &mut table);
cases.push(quote!(#name = #index));
let body = &arm.body;
match_body.push(quote!(Case::#name => { #body }))
}
let en = quote!(enum Case {
#(#cases),*
});
let mut table_content = Vec::new();
for entry in table.iter() {
let name: syn::Path = syn::parse_str(&format!("Case::Case{}", entry)).unwrap();
table_content.push(name);
}
let table = quote!(static __CASES: [Case; 256] = [#(#table_content),*];);
let expr = if let Some(binding) = wildcard {
quote!({ #en #table let #binding = #expr; match __CASES[#binding as usize] { #(#match_body),* }})
} else {
quote!({ #en #table match __CASES[#expr as usize] { #(#match_body),* }})
};
syn::parse2(expr.into()).unwrap()
}
impl Fold for MatchByteParser {
fn fold_stmt(&mut self, stmt: syn::Stmt) -> syn::Stmt {
match stmt {
syn::Stmt::Item(syn::Item::Macro(syn::ItemMacro { ref mac, .. })) => {
if mac.path == parse_quote!(match_byte) {
return syn::fold::fold_stmt(
self,
syn::Stmt::Expr(expand_match_byte(&mac.tokens)),
);
}
}
_ => {}
}
syn::fold::fold_stmt(self, stmt)
}
fn fold_expr(&mut self, expr: syn::Expr) -> syn::Expr {
match expr {
syn::Expr::Macro(syn::ExprMacro { ref mac, .. }) => {
if mac.path == parse_quote!(match_byte) {
return syn::fold::fold_expr(self, expand_match_byte(&mac.tokens));
}
}
_ => {}
}
syn::fold::fold_expr(self, expr)
}
}
|
