1 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
10 use self::LockstepIterSize
::*;
13 use ast
::{TokenTree, TtDelimited, TtToken, TtSequence, Ident}
;
14 use codemap
::{Span, DUMMY_SP}
;
15 use diagnostic
::SpanHandler
;
16 use ext
::tt
::macro_parser
::{NamedMatch, MatchedSeq, MatchedNonterminal}
;
17 use parse
::token
::{Eof, DocComment, Interpolated, MatchNt, SubstNt}
;
18 use parse
::token
::{Token, NtIdent, SpecialMacroVar}
;
20 use parse
::lexer
::TokenAndSpan
;
24 use std
::collections
::HashMap
;
26 ///an unzipping of `TokenTree`s
36 pub struct TtReader
<'a
> {
37 pub sp_diag
: &'a SpanHandler
,
38 /// the unzipped tree:
40 /* for MBE-style macro transcription */
41 interpolations
: HashMap
<Ident
, Rc
<NamedMatch
>>,
42 imported_from
: Option
<Ident
>,
44 // Some => return imported_from as the next token
45 crate_name_next
: Option
<Span
>,
46 repeat_idx
: Vec
<usize>,
47 repeat_len
: Vec
<usize>,
51 /// Transform doc comments. Only useful in macro invocations
52 pub desugar_doc_comments
: bool
,
55 /// This can do Macro-By-Example transcription. On the other hand, if
56 /// `src` contains no `TtSequence`s, `MatchNt`s or `SubstNt`s, `interp` can
57 /// (and should) be None.
58 pub fn new_tt_reader
<'a
>(sp_diag
: &'a SpanHandler
,
59 interp
: Option
<HashMap
<Ident
, Rc
<NamedMatch
>>>,
60 imported_from
: Option
<Ident
>,
61 src
: Vec
<ast
::TokenTree
>)
63 new_tt_reader_with_doc_flag(sp_diag
, interp
, imported_from
, src
, false)
66 /// The extra `desugar_doc_comments` flag enables reading doc comments
67 /// like any other attribute which consists of `meta` and surrounding #[ ] tokens.
69 /// This can do Macro-By-Example transcription. On the other hand, if
70 /// `src` contains no `TtSequence`s, `MatchNt`s or `SubstNt`s, `interp` can
71 /// (and should) be None.
72 pub fn new_tt_reader_with_doc_flag
<'a
>(sp_diag
: &'a SpanHandler
,
73 interp
: Option
<HashMap
<Ident
, Rc
<NamedMatch
>>>,
74 imported_from
: Option
<Ident
>,
75 src
: Vec
<ast
::TokenTree
>,
76 desugar_doc_comments
: bool
)
78 let mut r
= TtReader
{
81 forest
: TtSequence(DUMMY_SP
, Rc
::new(ast
::SequenceRepetition
{
83 // doesn't matter. This merely holds the root unzipping.
84 separator
: None
, op
: ast
::ZeroOrMore
, num_captures
: 0
90 interpolations
: match interp
{ /* just a convenience */
91 None
=> HashMap
::new(),
94 imported_from
: imported_from
,
95 crate_name_next
: None
,
96 repeat_idx
: Vec
::new(),
97 repeat_len
: Vec
::new(),
98 desugar_doc_comments
: desugar_doc_comments
,
99 /* dummy values, never read: */
103 tt_next_token(&mut r
); /* get cur_tok and cur_span set up */
107 fn lookup_cur_matched_by_matched(r
: &TtReader
, start
: Rc
<NamedMatch
>) -> Rc
<NamedMatch
> {
108 r
.repeat_idx
.iter().fold(start
, |ad
, idx
| {
110 MatchedNonterminal(_
) => {
111 // end of the line; duplicate henceforth
114 MatchedSeq(ref ads
, _
) => ads
[*idx
].clone()
119 fn lookup_cur_matched(r
: &TtReader
, name
: Ident
) -> Option
<Rc
<NamedMatch
>> {
120 let matched_opt
= r
.interpolations
.get(&name
).cloned();
121 matched_opt
.map(|s
| lookup_cur_matched_by_matched(r
, s
))
125 enum LockstepIterSize
{
127 LisConstraint(usize, Ident
),
128 LisContradiction(String
),
131 impl Add
for LockstepIterSize
{
132 type Output
= LockstepIterSize
;
134 fn add(self, other
: LockstepIterSize
) -> LockstepIterSize
{
136 LisUnconstrained
=> other
,
137 LisContradiction(_
) => self,
138 LisConstraint(l_len
, ref l_id
) => match other
{
139 LisUnconstrained
=> self.clone(),
140 LisContradiction(_
) => other
,
141 LisConstraint(r_len
, _
) if l_len
== r_len
=> self.clone(),
142 LisConstraint(r_len
, r_id
) => {
143 let l_n
= token
::get_ident(l_id
.clone());
144 let r_n
= token
::get_ident(r_id
);
145 LisContradiction(format
!("inconsistent lockstep iteration: \
146 '{:?}' has {} items, but '{:?}' has {}",
147 l_n
, l_len
, r_n
, r_len
).to_string())
154 fn lockstep_iter_size(t
: &TokenTree
, r
: &TtReader
) -> LockstepIterSize
{
156 TtDelimited(_
, ref delimed
) => {
157 delimed
.tts
.iter().fold(LisUnconstrained
, |size
, tt
| {
158 size
+ lockstep_iter_size(tt
, r
)
161 TtSequence(_
, ref seq
) => {
162 seq
.tts
.iter().fold(LisUnconstrained
, |size
, tt
| {
163 size
+ lockstep_iter_size(tt
, r
)
166 TtToken(_
, SubstNt(name
, _
)) | TtToken(_
, MatchNt(name
, _
, _
, _
)) =>
167 match lookup_cur_matched(r
, name
) {
168 Some(matched
) => match *matched
{
169 MatchedNonterminal(_
) => LisUnconstrained
,
170 MatchedSeq(ref ads
, _
) => LisConstraint(ads
.len(), name
),
172 _
=> LisUnconstrained
174 TtToken(..) => LisUnconstrained
,
178 /// Return the next token from the TtReader.
179 /// EFFECT: advances the reader's token field
180 pub fn tt_next_token(r
: &mut TtReader
) -> TokenAndSpan
{
181 // FIXME(pcwalton): Bad copy?
182 let ret_val
= TokenAndSpan
{
183 tok
: r
.cur_tok
.clone(),
184 sp
: r
.cur_span
.clone(),
187 match r
.crate_name_next
.take() {
191 r
.cur_tok
= token
::Ident(r
.imported_from
.unwrap(), token
::Plain
);
195 let should_pop
= match r
.stack
.last() {
197 assert_eq
!(ret_val
.tok
, token
::Eof
);
201 if frame
.idx
< frame
.forest
.len() {
204 !frame
.dotdotdoted
||
205 *r
.repeat_idx
.last().unwrap() == *r
.repeat_len
.last().unwrap() - 1
209 /* done with this set; pop or repeat? */
211 let prev
= r
.stack
.pop().unwrap();
212 match r
.stack
.last_mut() {
214 r
.cur_tok
= token
::Eof
;
221 if prev
.dotdotdoted
{
225 } else { /* repeat */
226 *r
.repeat_idx
.last_mut().unwrap() += 1;
227 r
.stack
.last_mut().unwrap().idx
= 0;
228 match r
.stack
.last().unwrap().sep
.clone() {
230 r
.cur_tok
= tk
; /* repeat same span, I guess */
237 loop { /* because it's easiest, this handles `TtDelimited` not starting
238 with a `TtToken`, even though it won't happen */
240 let frame
= r
.stack
.last().unwrap();
241 // FIXME(pcwalton): Bad copy.
242 frame
.forest
.get_tt(frame
.idx
)
245 TtSequence(sp
, seq
) => {
246 // FIXME(pcwalton): Bad copy.
247 match lockstep_iter_size(&TtSequence(sp
, seq
.clone()),
249 LisUnconstrained
=> {
250 panic
!(r
.sp_diag
.span_fatal(
251 sp
.clone(), /* blame macro writer */
252 "attempted to repeat an expression \
253 containing no syntax \
254 variables matched as repeating at this depth"));
256 LisContradiction(ref msg
) => {
257 // FIXME #2887 blame macro invoker instead
258 panic
!(r
.sp_diag
.span_fatal(sp
.clone(), &msg
[..]));
260 LisConstraint(len
, _
) => {
262 if seq
.op
== ast
::OneOrMore
{
263 // FIXME #2887 blame invoker
264 panic
!(r
.sp_diag
.span_fatal(sp
.clone(),
265 "this must repeat at least once"));
268 r
.stack
.last_mut().unwrap().idx
+= 1;
269 return tt_next_token(r
);
271 r
.repeat_len
.push(len
);
272 r
.repeat_idx
.push(0);
273 r
.stack
.push(TtFrame
{
276 sep
: seq
.separator
.clone(),
277 forest
: TtSequence(sp
, seq
),
282 // FIXME #2887: think about span stuff here
283 TtToken(sp
, SubstNt(ident
, namep
)) => {
284 r
.stack
.last_mut().unwrap().idx
+= 1;
285 match lookup_cur_matched(r
, ident
) {
288 r
.cur_tok
= SubstNt(ident
, namep
);
290 // this can't be 0 length, just like TtDelimited
292 Some(cur_matched
) => {
294 // sidestep the interpolation tricks for ident because
295 // (a) idents can be in lots of places, so it'd be a pain
296 // (b) we actually can, since it's a token.
297 MatchedNonterminal(NtIdent(box sn
, b
)) => {
299 r
.cur_tok
= token
::Ident(sn
, b
);
302 MatchedNonterminal(ref other_whole_nt
) => {
303 // FIXME(pcwalton): Bad copy.
305 r
.cur_tok
= token
::Interpolated((*other_whole_nt
).clone());
309 panic
!(r
.sp_diag
.span_fatal(
310 r
.cur_span
, /* blame the macro writer */
311 &format
!("variable '{:?}' is still repeating at this depth",
312 token
::get_ident(ident
))));
318 // TtDelimited or any token that can be unzipped
319 seq @
TtDelimited(..) | seq @
TtToken(_
, MatchNt(..)) => {
320 // do not advance the idx yet
321 r
.stack
.push(TtFrame
{
327 // if this could be 0-length, we'd need to potentially recur here
329 TtToken(sp
, DocComment(name
)) if r
.desugar_doc_comments
=> {
330 r
.stack
.push(TtFrame
{
331 forest
: TtToken(sp
, DocComment(name
)),
337 TtToken(sp
, token
::SpecialVarNt(SpecialMacroVar
::CrateMacroVar
)) => {
338 r
.stack
.last_mut().unwrap().idx
+= 1;
340 if r
.imported_from
.is_some() {
342 r
.cur_tok
= token
::ModSep
;
343 r
.crate_name_next
= Some(sp
);
347 // otherwise emit nothing and proceed to the next token
349 TtToken(sp
, tok
) => {
352 r
.stack
.last_mut().unwrap().idx
+= 1;