| use diagnostic::span_handler; |
| use ast::{token_tree, tt_delim, tt_tok, tt_seq, tt_nonterminal,ident}; |
| use macro_parser::{named_match, matched_seq, matched_nonterminal}; |
| use codemap::span; |
| use parse::token::{EOF, INTERPOLATED, IDENT, token, nt_ident, |
| ident_interner}; |
| use std::map::HashMap; |
| |
| export tt_reader, new_tt_reader, dup_tt_reader, tt_next_token; |
| |
| enum tt_frame_up { /* to break a circularity */ |
| tt_frame_up(Option<tt_frame>) |
| } |
| |
| /* FIXME #2811: figure out how to have a uniquely linked stack, and change to |
| `~` */ |
| ///an unzipping of `token_tree`s |
| type tt_frame = @{ |
| readme: ~[ast::token_tree], |
| mut idx: uint, |
| dotdotdoted: bool, |
| sep: Option<token>, |
| up: tt_frame_up, |
| }; |
| |
| type tt_reader = @{ |
| sp_diag: span_handler, |
| interner: @ident_interner, |
| mut cur: tt_frame, |
| /* for MBE-style macro transcription */ |
| interpolations: std::map::HashMap<ident, @named_match>, |
| mut repeat_idx: ~[uint], |
| mut repeat_len: ~[uint], |
| /* cached: */ |
| mut cur_tok: token, |
| mut cur_span: span |
| }; |
| |
| /** This can do Macro-By-Example transcription. On the other hand, if |
| * `src` contains no `tt_seq`s and `tt_nonterminal`s, `interp` can (and |
| * should) be none. */ |
| fn new_tt_reader(sp_diag: span_handler, itr: @ident_interner, |
| interp: Option<std::map::HashMap<ident,@named_match>>, |
| src: ~[ast::token_tree]) |
| -> tt_reader { |
| let r = @{sp_diag: sp_diag, interner: itr, |
| mut cur: @{readme: src, mut idx: 0u, dotdotdoted: false, |
| sep: None, up: tt_frame_up(option::None)}, |
| interpolations: match interp { /* just a convienience */ |
| None => std::map::HashMap(), |
| Some(x) => x |
| }, |
| mut repeat_idx: ~[], |
| mut repeat_len: ~[], |
| /* dummy values, never read: */ |
| mut cur_tok: EOF, |
| mut cur_span: ast_util::mk_sp(0u,0u) |
| }; |
| tt_next_token(r); /* get cur_tok and cur_span set up */ |
| return r; |
| } |
| |
| pure fn dup_tt_frame(&&f: tt_frame) -> tt_frame { |
| @{readme: f.readme, mut idx: f.idx, dotdotdoted: f.dotdotdoted, |
| sep: f.sep, up: match f.up { |
| tt_frame_up(Some(up_frame)) => { |
| tt_frame_up(Some(dup_tt_frame(up_frame))) |
| } |
| tt_frame_up(none) => tt_frame_up(none) |
| } |
| } |
| } |
| |
| pure fn dup_tt_reader(&&r: tt_reader) -> tt_reader { |
| @{sp_diag: r.sp_diag, interner: r.interner, |
| mut cur: dup_tt_frame(r.cur), |
| interpolations: r.interpolations, |
| mut repeat_idx: copy r.repeat_idx, mut repeat_len: copy r.repeat_len, |
| mut cur_tok: r.cur_tok, mut cur_span: r.cur_span} |
| } |
| |
| |
| pure fn lookup_cur_matched_by_matched(r: tt_reader, |
| start: @named_match) -> @named_match { |
| pure fn red(+ad: @named_match, idx: &uint) -> @named_match { |
| match *ad { |
| matched_nonterminal(_) => { |
| // end of the line; duplicate henceforth |
| ad |
| } |
| matched_seq(ads, _) => ads[*idx] |
| } |
| } |
| vec::foldl(start, r.repeat_idx, red) |
| } |
| |
| fn lookup_cur_matched(r: tt_reader, name: ident) -> @named_match { |
| lookup_cur_matched_by_matched(r, r.interpolations.get(name)) |
| } |
| enum lis { |
| lis_unconstrained, lis_constraint(uint, ident), lis_contradiction(~str) |
| } |
| |
| fn lockstep_iter_size(t: token_tree, r: tt_reader) -> lis { |
| fn lis_merge(lhs: lis, rhs: lis, r: tt_reader) -> lis { |
| match lhs { |
| lis_unconstrained => rhs, |
| lis_contradiction(_) => lhs, |
| lis_constraint(l_len, l_id) => match rhs { |
| lis_unconstrained => lhs, |
| lis_contradiction(_) => rhs, |
| lis_constraint(r_len, _) if l_len == r_len => lhs, |
| lis_constraint(r_len, r_id) => { |
| let l_n = *r.interner.get(l_id); |
| let r_n = *r.interner.get(r_id); |
| lis_contradiction(fmt!("Inconsistent lockstep iteration: \ |
| '%s' has %u items, but '%s' has %u", |
| l_n, l_len, r_n, r_len)) |
| } |
| } |
| } |
| } |
| match t { |
| tt_delim(tts) | tt_seq(_, tts, _, _) => { |
| vec::foldl(lis_unconstrained, tts, |lis, tt| |
| lis_merge(lis, lockstep_iter_size(*tt, r), r)) |
| } |
| tt_tok(*) => lis_unconstrained, |
| tt_nonterminal(_, name) => match *lookup_cur_matched(r, name) { |
| matched_nonterminal(_) => lis_unconstrained, |
| matched_seq(ads, _) => lis_constraint(ads.len(), name) |
| } |
| } |
| } |
| |
| |
| fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} { |
| let ret_val = { tok: r.cur_tok, sp: r.cur_span }; |
| while r.cur.idx >= r.cur.readme.len() { |
| /* done with this set; pop or repeat? */ |
| if ! r.cur.dotdotdoted |
| || r.repeat_idx.last() == r.repeat_len.last() - 1 { |
| |
| match r.cur.up { |
| tt_frame_up(None) => { |
| r.cur_tok = EOF; |
| return ret_val; |
| } |
| tt_frame_up(Some(tt_f)) => { |
| if r.cur.dotdotdoted { |
| r.repeat_idx.pop(); |
| r.repeat_len.pop(); |
| } |
| |
| r.cur = tt_f; |
| r.cur.idx += 1u; |
| } |
| } |
| |
| } else { /* repeat */ |
| r.cur.idx = 0u; |
| r.repeat_idx[r.repeat_idx.len() - 1u] += 1u; |
| match r.cur.sep { |
| Some(tk) => { |
| r.cur_tok = tk; /* repeat same span, I guess */ |
| return ret_val; |
| } |
| None => () |
| } |
| } |
| } |
| loop { /* because it's easiest, this handles `tt_delim` not starting |
| with a `tt_tok`, even though it won't happen */ |
| match r.cur.readme[r.cur.idx] { |
| tt_delim(tts) => { |
| r.cur = @{readme: tts, mut idx: 0u, dotdotdoted: false, |
| sep: None, up: tt_frame_up(option::Some(r.cur)) }; |
| // if this could be 0-length, we'd need to potentially recur here |
| } |
| tt_tok(sp, tok) => { |
| r.cur_span = sp; r.cur_tok = tok; |
| r.cur.idx += 1u; |
| return ret_val; |
| } |
| tt_seq(sp, tts, sep, zerok) => { |
| match lockstep_iter_size(tt_seq(sp, tts, sep, zerok), r) { |
| lis_unconstrained => { |
| r.sp_diag.span_fatal( |
| sp, /* blame macro writer */ |
| ~"attempted to repeat an expression containing no syntax \ |
| variables matched as repeating at this depth"); |
| } |
| lis_contradiction(msg) => { /* FIXME #2887 blame macro invoker |
| instead*/ |
| r.sp_diag.span_fatal(sp, msg); |
| } |
| lis_constraint(len, _) => { |
| if len == 0 { |
| if !zerok { |
| r.sp_diag.span_fatal(sp, /* FIXME #2887 blame invoker |
| */ |
| ~"this must repeat at least \ |
| once"); |
| } |
| |
| r.cur.idx += 1u; |
| return tt_next_token(r); |
| } else { |
| r.repeat_len.push(len); |
| r.repeat_idx.push(0u); |
| r.cur = @{readme: tts, mut idx: 0u, dotdotdoted: true, |
| sep: sep, up: tt_frame_up(option::Some(r.cur))}; |
| } |
| } |
| } |
| } |
| // FIXME #2887: think about span stuff here |
| tt_nonterminal(sp, ident) => { |
| match *lookup_cur_matched(r, ident) { |
| /* sidestep the interpolation tricks for ident because |
| (a) idents can be in lots of places, so it'd be a pain |
| (b) we actually can, since it's a token. */ |
| matched_nonterminal(nt_ident(sn,b)) => { |
| r.cur_span = sp; r.cur_tok = IDENT(sn,b); |
| r.cur.idx += 1u; |
| return ret_val; |
| } |
| matched_nonterminal(other_whole_nt) => { |
| r.cur_span = sp; r.cur_tok = INTERPOLATED(other_whole_nt); |
| r.cur.idx += 1u; |
| return ret_val; |
| } |
| matched_seq(*) => { |
| r.sp_diag.span_fatal( |
| copy r.cur_span, /* blame the macro writer */ |
| fmt!("variable '%s' is still repeating at this depth", |
| *r.interner.get(ident))); |
| } |
| } |
| } |
| } |
| } |
| |
| } |
