---

yaml
---
r: 22692
b: refs/heads/master
c: c341eb9
h: refs/heads/master
v: v3

Author: Elliott Slaughter

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 9103e439091fbd4e5ec7e561f007172342065340
+refs/heads/master: c341eb90522294dda6dbce646d1c0a7170a48bfc
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be

trunk/src/libcore/core.rs

@@ -10,22 +10,22 @@ import str::{extensions, str_slice, unique_str};
 import vec::extensions;
 import vec::{const_vector, copyable_vector, immutable_vector};
 import vec::{immutable_copyable_vector, iter_trait_extensions, vec_concat};
-import iter::{base_iter, extended_iter, copyable_iter, times, timesi};
+import iter::{base_iter, extended_iter, copyable_iter, times};
 import option::extensions;
 import option_iter::extensions;
 import ptr::{extensions, ptr};
 import rand::extensions;
 import result::extensions;
-import int::{num, times, timesi};
-import i8::{num, times, timesi};
-import i16::{num, times, timesi};
-import i32::{num, times, timesi};
-import i64::{num, times, timesi};
-import uint::{num, times, timesi};
-import u8::{num, times, timesi};
-import u16::{num, times, timesi};
-import u32::{num, times, timesi};
-import u64::{num, times, timesi};
+import int::{num, times};
+import i8::{num, times};
+import i16::{num, times};
+import i32::{num, times};
+import i64::{num, times};
+import uint::{num, times};
+import u8::{num, times};
+import u16::{num, times};
+import u32::{num, times};
+import u64::{num, times};
 import float::num;
 import f32::num;
 import f64::num;
@@ -34,7 +34,7 @@ import num::num;
 export path, option, some, none, unreachable;
 export extensions;
 // The following exports are the extension impls for numeric types
-export num, times, timesi;
+export num, times;
 // The following exports are the common traits
 export str_slice, unique_str;
 export const_vector, copyable_vector, immutable_vector;

trunk/src/libcore/int-template.rs

@@ -11,7 +11,7 @@ export range;
 export compl;
 export abs;
 export parse_buf, from_str, to_str, to_str_bytes, str;
-export num, ord, eq, times, timesi;
+export num, ord, eq, times;
 
 const min_value: T = -1 as T << (inst::bits - 1 as T);
 const max_value: T = min_value - 1 as T;
@@ -155,23 +155,6 @@ impl times of iter::times for T {
     }
 }
 
-impl timesi of iter::timesi for T {
-    #[inline(always)]
-    /// Like `times`, but provides an index
-    fn timesi(it: fn(uint) -> bool) {
-        let slf = self as uint;
-        if slf < 0u {
-            fail #fmt("The .timesi method expects a nonnegative number, \
-                       but found %?", self);
-        }
-        let mut i = 0u;
-        while i < slf {
-            if !it(i) { break }
-            i += 1u;
-        }
-    }
-}
-
 // FIXME: Has alignment issues on windows and 32-bit linux (#2609)
 #[test]
 #[ignore]

trunk/src/libcore/iter.rs

@@ -16,9 +16,6 @@ trait extended_iter<A> {
 iface times {
     fn times(it: fn() -> bool);
 }
-iface timesi{
-    fn timesi(it: fn(uint) -> bool);
-}
 
 trait copyable_iter<A:copy> {
     fn filter_to_vec(pred: fn(A) -> bool) -> ~[A];

trunk/src/libcore/rt.rs

@@ -37,6 +37,9 @@ fn rt_exchange_malloc(td: *c_char, size: uintptr_t) -> *c_char {
     ret rustrt::rust_upcall_exchange_malloc(td, size);
 }
 
+// NB: Calls to free CANNOT be allowed to fail, as throwing an exception from
+// inside a landing pad may corrupt the state of the exception handler. If a
+// problem occurs, call exit instead.
 #[rt(exchange_free)]
 fn rt_exchange_free(ptr: *c_char) {
     rustrt::rust_upcall_exchange_free(ptr);
@@ -47,6 +50,9 @@ fn rt_malloc(td: *c_char, size: uintptr_t) -> *c_char {
     ret rustrt::rust_upcall_malloc(td, size);
 }
 
+// NB: Calls to free CANNOT be allowed to fail, as throwing an exception from
+// inside a landing pad may corrupt the state of the exception handler. If a
+// problem occurs, call exit instead.
 #[rt(free)]
 fn rt_free(ptr: *c_char) {
     rustrt::rust_upcall_free(ptr);

trunk/src/libcore/uint-template.rs

@@ -11,7 +11,7 @@ export range;
 export compl;
 export to_str, to_str_bytes;
 export from_str, from_str_radix, str, parse_buf;
-export num, ord, eq, times, timesi;
+export num, ord, eq, times;
 
 const min_value: T = 0 as T;
 const max_value: T = 0 as T - 1 as T;
@@ -120,19 +120,6 @@ impl times of iter::times for T {
     }
 }
 
-impl timesi of iter::timesi for T {
-    #[inline(always)]
-    /// Like `times`, but with an index, `eachi`-style.
-    fn timesi(it: fn(uint) -> bool) {
-        let slf = self as uint;
-        let mut i = 0u;
-        while i < slf {
-            if !it(i) { break }
-            i += 1u;
-        }
-    }
-}
-
 /// Parse a string to an int
 fn from_str(s: ~str) -> option<T> { parse_buf(str::bytes(s), 10u) }
 

trunk/src/libsyntax/ast.rs

@@ -378,9 +378,8 @@ type matcher = spanned<matcher_>;
 enum matcher_ {
     /* match one token */
     mtc_tok(token::token),
-    /* match repetitions of a sequence: body, separator, zero ok?,
-    lo, hi position-in-match-array used: */
-    mtc_rep(~[matcher], option<token::token>, bool, uint, uint),
+    /* match repetitions of a sequence: body, separator, zero ok? : */
+    mtc_rep(~[matcher], option<token::token>, bool),
     /* parse a Rust NT: name to bind, name of NT, position in match array : */
     mtc_bb(ident, ident, uint)
 }

trunk/src/libsyntax/ext/tt/earley_parser.rs

@@ -41,7 +41,6 @@ type matcher_pos = ~{
     mut idx: uint,
     mut up: matcher_pos_up, // mutable for swapping only
     matches: ~[dvec<@arb_depth>],
-    match_lo: uint, match_hi: uint,
     sp_lo: uint,
 };
 
@@ -56,25 +55,17 @@ fn count_names(ms: &[matcher]) -> uint {
     vec::foldl(0u, ms, |ct, m| {
         ct + alt m.node {
           mtc_tok(_) { 0u }
-          mtc_rep(more_ms, _, _, _, _) { count_names(more_ms) }
+          mtc_rep(more_ms, _, _) { count_names(more_ms) }
           mtc_bb(_,_,_) { 1u }
         }})
 }
 
 #[warn(no_non_implicitly_copyable_typarams)]
-fn initial_matcher_pos(ms: ~[matcher], sep: option<token>, lo: uint)
+fn new_matcher_pos(ms: ~[matcher], sep: option<token>, lo: uint)
     -> matcher_pos {
-    let mut match_idx_hi = 0u;
-    for ms.each() |elt| {
-        alt elt.node {
-          mtc_tok(_) {}
-          mtc_rep(_,_,_,_,hi) { match_idx_hi = hi; } //it is monotonic...
-          mtc_bb(_,_,pos) { match_idx_hi = pos+1u; } //...so latest is highest
-        }
-    }
     ~{elts: ms, sep: sep, mut idx: 0u, mut up: matcher_pos_up(none),
       matches: copy vec::from_fn(count_names(ms), |_i| dvec::dvec()),
-      match_lo: 0u, match_hi: match_idx_hi, sp_lo: lo}
+      sp_lo: lo}
 }
 
 /* logically, an arb_depth should contain only one kind of nonterminal */
@@ -88,7 +79,7 @@ fn nameize(p_s: parse_sess, ms: ~[matcher], res: ~[@arb_depth])
              ret_val: hashmap<ident, @arb_depth>) {
         alt m {
           {node: mtc_tok(_), span: _} { }
-          {node: mtc_rep(more_ms, _, _, _, _), span: _} {
+          {node: mtc_rep(more_ms, _, _), span: _} {
             for more_ms.each() |next_m| { n_rec(p_s, next_m, res, ret_val) };
           }
           {node: mtc_bb(bind_name, _, idx), span: sp} {
@@ -113,7 +104,7 @@ enum parse_result {
 fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
     -> parse_result {
     let mut cur_eis = ~[];
-    vec::push(cur_eis, initial_matcher_pos(ms, none, rdr.peek().sp.lo));
+    vec::push(cur_eis, new_matcher_pos(ms, none, rdr.peek().sp.lo));
 
     loop {
         let mut bb_eis = ~[]; // black-box parsed by parser.rs
@@ -150,10 +141,10 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
                         // I bet this is a perf problem: we're preemptively
                         // doing a lot of array work that will get thrown away
                         // most of the time.
-
-                        // Only touch the binders we have actually bound
-                        for uint::range(ei.match_lo, ei.match_hi) |idx| {
-                            let sub = ei.matches[idx].get();
+                        for ei.matches.eachi() |idx, elt| {
+                            let sub = elt.get();
+                            // Some subtrees don't contain the name at all
+                            if sub.len() == 0u { again; }
                             new_pos.matches[idx]
                                 .push(@seq(sub, mk_sp(ei.sp_lo,sp.hi)));
                         }
@@ -185,15 +176,10 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
             } else {
                 alt copy ei.elts[idx].node {
                   /* need to descend into sequence */
-                  mtc_rep(matchers, sep, zero_ok, match_idx_lo, match_idx_hi){
+                  mtc_rep(matchers, sep, zero_ok) {
                     if zero_ok {
                         let new_ei = copy ei;
                         new_ei.idx += 1u;
-                        //we specifically matched zero repeats.
-                        for uint::range(match_idx_lo, match_idx_hi) |idx| {
-                            new_ei.matches[idx].push(@seq(~[], sp));
-                        }
-
                         vec::push(cur_eis, new_ei);
                     }
 
@@ -203,9 +189,7 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
                     vec::push(cur_eis, ~{
                         elts: matchers, sep: sep, mut idx: 0u,
                         mut up: matcher_pos_up(some(ei_t)),
-                        matches: matches,
-                        match_lo: match_idx_lo, match_hi: match_idx_hi,
-                        sp_lo: sp.lo
+                        matches: matches, sp_lo: sp.lo
                     });
                   }
                   mtc_bb(_,_,_) { vec::push(bb_eis, ei) }
@@ -232,11 +216,9 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
             if (bb_eis.len() > 0u && next_eis.len() > 0u)
                 || bb_eis.len() > 1u {
                 let nts = str::connect(vec::map(bb_eis, |ei| {
-                    alt ei.elts[ei.idx].node {
-                      mtc_bb(bind,name,_) {
-                        #fmt["%s ('%s')", *name, *bind]
-                      }
-                      _ { fail; } } }), ~" or ");
+                    alt ei.elts[ei.idx].node
+                        { mtc_bb(_,name,_) { *name } _ { fail; } }
+                }), ~" or ");
                 ret failure(sp, #fmt[
                     "Local ambiguity: multiple parsing options: \
                      built-in NTs %s or %u other options.",

trunk/src/libsyntax/ext/tt/macro_rules.rs

@@ -21,7 +21,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, name: ident,
             ms(mtc_bb(@~"lhs",@~"mtcs", 0u)),
             ms(mtc_tok(FAT_ARROW)),
             ms(mtc_bb(@~"rhs",@~"tt", 1u)),
-        ], some(SEMI), false, 0u, 2u))];
+        ], some(SEMI), false))];
 
     let arg_reader = new_tt_reader(cx.parse_sess().span_diagnostic,
                                    cx.parse_sess().interner, none, arg);

trunk/src/libsyntax/ext/tt/transcribe.rs

@@ -133,7 +133,7 @@ fn lockstep_iter_size(&&t: token_tree, &&r: tt_reader) -> lis {
 
 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() {
+    while r.cur.idx >= vec::len(r.cur.readme) {
         /* done with this set; pop or repeat? */
         if ! r.cur.dotdotdoted
             || r.repeat_idx.last() == r.repeat_len.last() - 1 {
@@ -191,21 +191,20 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} {
                 r.sp_diag.span_fatal(sp, msg);
               }
               lis_constraint(len, _) {
+                vec::push(r.repeat_len, len);
+                vec::push(r.repeat_idx, 0u);
+                r.cur = @{readme: tts, mut idx: 0u, dotdotdoted: true,
+                          sep: sep, up: tt_frame_up(option::some(r.cur)) };
+
                 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;
+                    /* we need to pop before we proceed, so recur */
                     ret tt_next_token(r);
-                } else {
-                    vec::push(r.repeat_len, len);
-                    vec::push(r.repeat_idx, 0u);
-                    r.cur = @{readme: tts, mut idx: 0u, dotdotdoted: true,
-                              sep: sep, up: tt_frame_up(option::some(r.cur))};
                 }
               }
             }

trunk/src/libsyntax/parse/parser.rs

@@ -1194,14 +1194,13 @@ class parser {
         let m = if self.token == token::DOLLAR {
             self.bump();
             if self.token == token::LPAREN {
-                let name_idx_lo = *name_idx;
                 let ms = self.parse_matcher_subseq(name_idx, token::LPAREN,
                                                    token::RPAREN);
                 if ms.len() == 0u {
                     self.fatal(~"repetition body must be nonempty");
                 }
                 let (sep, zerok) = self.parse_sep_and_zerok();
-                mtc_rep(ms, sep, zerok, name_idx_lo, *name_idx)
+                mtc_rep(ms, sep, zerok)
             } else {
                 let bound_to = self.parse_ident();
                 self.expect(token::COLON);