// Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 or the MIT license // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. use ast; use ast::{token_tree, tt_delim, tt_tok, tt_seq, tt_nonterminal,Ident}; use codemap::{Span, dummy_sp}; use diagnostic::span_handler; use ext::tt::macro_parser::{named_match, matched_seq, matched_nonterminal}; use parse::token::{EOF, INTERPOLATED, IDENT, Token, nt_ident}; use parse::token::{ident_to_str}; use parse::lexer::TokenAndSpan; use std::hashmap::HashMap; use std::option; ///an unzipping of `token_tree`s struct TtFrame { forest: @~[ast::token_tree], idx: uint, dotdotdoted: bool, sep: Option, up: Option<@mut TtFrame>, } pub struct TtReader { sp_diag: @mut span_handler, // the unzipped tree: stack: @mut TtFrame, /* for MBE-style macro transcription */ interpolations: HashMap, repeat_idx: ~[uint], repeat_len: ~[uint], /* cached: */ cur_tok: Token, 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. */ pub fn new_tt_reader(sp_diag: @mut span_handler, interp: Option>, src: ~[ast::token_tree]) -> @mut TtReader { let r = @mut TtReader { sp_diag: sp_diag, stack: @mut TtFrame { forest: @src, idx: 0u, dotdotdoted: false, sep: None, up: option::None }, interpolations: match interp { /* just a convienience */ None => HashMap::new(), Some(x) => x }, repeat_idx: ~[], repeat_len: ~[], /* dummy values, never read: */ cur_tok: EOF, cur_span: dummy_sp() }; tt_next_token(r); /* get cur_tok and cur_span set up */ return r; } fn dup_tt_frame(f: @mut TtFrame) -> @mut TtFrame { @mut TtFrame { forest: @(*f.forest).clone(), idx: f.idx, dotdotdoted: f.dotdotdoted, sep: f.sep.clone(), up: match f.up { Some(up_frame) => Some(dup_tt_frame(up_frame)), None => None } } } pub fn dup_tt_reader(r: @mut TtReader) -> @mut TtReader { @mut TtReader { sp_diag: r.sp_diag, stack: dup_tt_frame(r.stack), repeat_idx: r.repeat_idx.clone(), repeat_len: r.repeat_len.clone(), cur_tok: r.cur_tok.clone(), cur_span: r.cur_span, interpolations: r.interpolations.clone(), } } fn lookup_cur_matched_by_matched(r: &mut TtReader, start: @named_match) -> @named_match { fn red(ad: @named_match, idx: &uint) -> @named_match { match *ad { matched_nonterminal(_) => { // end of the line; duplicate henceforth ad } matched_seq(ref ads, _) => ads[*idx] } } r.repeat_idx.iter().fold(start, red) } fn lookup_cur_matched(r: &mut TtReader, name: Ident) -> @named_match { match r.interpolations.find_copy(&name) { Some(s) => lookup_cur_matched_by_matched(r, s), None => { r.sp_diag.span_fatal(r.cur_span, format!("unknown macro variable `{}`", ident_to_str(&name))); } } } #[deriving(Clone)] enum lis { lis_unconstrained, lis_constraint(uint, Ident), lis_contradiction(~str), } fn lockstep_iter_size(t: &token_tree, r: &mut TtReader) -> lis { fn lis_merge(lhs: lis, rhs: lis) -> lis { match lhs { lis_unconstrained => rhs.clone(), lis_contradiction(_) => lhs.clone(), lis_constraint(l_len, ref l_id) => match rhs { lis_unconstrained => lhs.clone(), lis_contradiction(_) => rhs.clone(), lis_constraint(r_len, _) if l_len == r_len => lhs.clone(), lis_constraint(r_len, ref r_id) => { let l_n = ident_to_str(l_id); let r_n = ident_to_str(r_id); lis_contradiction(format!("Inconsistent lockstep iteration: \ '{}' has {} items, but '{}' has {}", l_n, l_len, r_n, r_len)) } } } } match *t { tt_delim(ref tts) | tt_seq(_, ref tts, _, _) => { tts.iter().fold(lis_unconstrained, |lis, tt| { let lis2 = lockstep_iter_size(tt, r); lis_merge(lis, lis2) }) } tt_tok(..) => lis_unconstrained, tt_nonterminal(_, name) => match *lookup_cur_matched(r, name) { matched_nonterminal(_) => lis_unconstrained, matched_seq(ref ads, _) => lis_constraint(ads.len(), name) } } } // return the next token from the TtReader. // EFFECT: advances the reader's token field pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan { // XXX(pcwalton): Bad copy? let ret_val = TokenAndSpan { tok: r.cur_tok.clone(), sp: r.cur_span, }; loop { { let stack = &mut *r.stack; if stack.idx < stack.forest.len() { break; } } /* done with this set; pop or repeat? */ if ! r.stack.dotdotdoted || { *r.repeat_idx.last() == *r.repeat_len.last() - 1 } { match r.stack.up { None => { r.cur_tok = EOF; return ret_val; } Some(tt_f) => { if r.stack.dotdotdoted { r.repeat_idx.pop(); r.repeat_len.pop(); } r.stack = tt_f; r.stack.idx += 1u; } } } else { /* repeat */ r.stack.idx = 0u; r.repeat_idx[r.repeat_idx.len() - 1u] += 1u; match r.stack.sep.clone() { 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 */ // XXX(pcwalton): Bad copy. match r.stack.forest[r.stack.idx].clone() { tt_delim(tts) => { r.stack = @mut TtFrame { forest: tts, idx: 0u, dotdotdoted: false, sep: None, up: option::Some(r.stack) }; // 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.stack.idx += 1u; return ret_val; } tt_seq(sp, tts, sep, zerok) => { // XXX(pcwalton): Bad copy. let t = tt_seq(sp, tts, sep.clone(), zerok); match lockstep_iter_size(&t, 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(ref 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.stack.idx += 1u; return tt_next_token(r); } else { r.repeat_len.push(len); r.repeat_idx.push(0u); r.stack = @mut TtFrame { forest: tts, idx: 0u, dotdotdoted: true, sep: sep, up: Some(r.stack) }; } } } } // 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.stack.idx += 1u; return ret_val; } matched_nonterminal(ref other_whole_nt) => { // XXX(pcwalton): Bad copy. r.cur_span = sp; r.cur_tok = INTERPOLATED((*other_whole_nt).clone()); r.stack.idx += 1u; return ret_val; } matched_seq(..) => { r.sp_diag.span_fatal( r.cur_span, /* blame the macro writer */ format!("variable '{}' is still repeating at this depth", ident_to_str(&ident))); } } } } } }