---

yaml
---
r: 81712
b: refs/heads/master
c: 807725b
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 7f826cb25ac3c1295a90bc8eb16e1cdf518fc6e1
+refs/heads/master: 807725b995a14c0aac5926c77636d3998b82dc9d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
 refs/heads/try: 70152ff55722878cde684ee6462c14c65f2c4729

trunk/src/libstd/util.rs

@@ -23,25 +23,6 @@ pub fn id<T>(x: T) -> T { x }
 #[inline]
 pub fn ignore<T>(_x: T) { }
 
-/// Sets `*ptr` to `new_value`, invokes `op()`, and then restores the
-/// original value of `*ptr`.
-///
-/// NB: This function accepts `@mut T` and not `&mut T` to avoid
-/// an obvious borrowck hazard. Typically passing in `&mut T` will
-/// cause borrow check errors because it freezes whatever location
-/// that `&mut T` is stored in (either statically or dynamically).
-#[inline]
-pub fn with<T,R>(
-    ptr: @mut T,
-    value: T,
-    op: &fn() -> R) -> R
-{
-    let prev = replace(ptr, value);
-    let result = op();
-    *ptr = prev;
-    return result;
-}
-
 /**
  * Swap the values at two mutable locations of the same type, without
  * deinitialising or copying either one.

trunk/src/libsyntax/parse/lexer.rs

@@ -149,46 +149,6 @@ impl reader for TtReader {
     fn dup(@mut self) -> @mut reader { dup_tt_reader(self) as @mut reader }
 }
 
-// report a lexical error spanning [`from_pos`, `to_pos`)
-fn fatal_span(rdr: @mut StringReader,
-              from_pos: BytePos,
-              to_pos: BytePos,
-              m: ~str)
-           -> ! {
-    rdr.peek_span = codemap::mk_sp(from_pos, to_pos);
-    rdr.fatal(m);
-}
-
-// report a lexical error spanning [`from_pos`, `to_pos`), appending an
-// escaped character to the error message
-fn fatal_span_char(rdr: @mut StringReader,
-                   from_pos: BytePos,
-                   to_pos: BytePos,
-                   m: ~str,
-                   c: char)
-                -> ! {
-    let mut m = m;
-    m.push_str(": ");
-    char::escape_default(c, |c| m.push_char(c));
-    fatal_span(rdr, from_pos, to_pos, m);
-}
-
-// report a lexical error spanning [`from_pos`, `to_pos`), appending the
-// offending string to the error message
-fn fatal_span_verbose(rdr: @mut StringReader,
-                      from_pos: BytePos,
-                      to_pos: BytePos,
-                      m: ~str)
-                   -> ! {
-    let mut m = m;
-    m.push_str(": ");
-    let s = rdr.src.slice(
-                  byte_offset(rdr, from_pos).to_uint(),
-                  byte_offset(rdr, to_pos).to_uint());
-    m.push_str(s);
-    fatal_span(rdr, from_pos, to_pos, m);
-}
-
 // EFFECT: advance peek_tok and peek_span to refer to the next token.
 // EFFECT: update the interner, maybe.
 fn string_advance_token(r: @mut StringReader) {
@@ -367,8 +327,7 @@ fn consume_block_comment(rdr: @mut StringReader)
             bump(rdr);
         }
         if is_eof(rdr) {
-            fatal_span(rdr, start_bpos, rdr.last_pos,
-                       ~"unterminated block doc-comment");
+            rdr.fatal(~"unterminated block doc-comment");
         } else {
             bump(rdr);
             bump(rdr);
@@ -385,12 +344,8 @@ fn consume_block_comment(rdr: @mut StringReader)
             }
         }
     } else {
-        let start_bpos = rdr.last_pos - BytePos(2u);
         loop {
-            if is_eof(rdr) {
-                fatal_span(rdr, start_bpos, rdr.last_pos,
-                           ~"unterminated block comment");
-            }
+            if is_eof(rdr) { rdr.fatal(~"unterminated block comment"); }
             if rdr.curr == '*' && nextch(rdr) == '/' {
                 bump(rdr);
                 bump(rdr);
@@ -406,7 +361,7 @@ fn consume_block_comment(rdr: @mut StringReader)
    if res.is_some() { res } else { consume_whitespace_and_comments(rdr) }
 }
 
-fn scan_exponent(rdr: @mut StringReader, start_bpos: BytePos) -> Option<~str> {
+fn scan_exponent(rdr: @mut StringReader) -> Option<~str> {
     let mut c = rdr.curr;
     let mut rslt = ~"";
     if c == 'e' || c == 'E' {
@@ -420,10 +375,7 @@ fn scan_exponent(rdr: @mut StringReader, start_bpos: BytePos) -> Option<~str> {
         let exponent = scan_digits(rdr, 10u);
         if exponent.len() > 0u {
             return Some(rslt + exponent);
-        } else {
-            fatal_span(rdr, start_bpos, rdr.last_pos,
-                       ~"scan_exponent: bad fp literal");
-        }
+        } else { rdr.fatal(~"scan_exponent: bad fp literal"); }
     } else { return None::<~str>; }
 }
 
@@ -447,7 +399,6 @@ fn scan_number(c: char, rdr: @mut StringReader) -> token::Token {
     let mut base = 10u;
     let mut c = c;
     let mut n = nextch(rdr);
-    let start_bpos = rdr.last_pos;
     if c == '0' && n == 'x' {
         bump(rdr);
         bump(rdr);
@@ -491,13 +442,11 @@ fn scan_number(c: char, rdr: @mut StringReader) -> token::Token {
                       else { either::Right(ast::ty_u64) };
         }
         if num_str.len() == 0u {
-            fatal_span(rdr, start_bpos, rdr.last_pos,
-                       ~"no valid digits found for number");
+            rdr.fatal(~"no valid digits found for number");
         }
         let parsed = match from_str_radix::<u64>(num_str, base as uint) {
             Some(p) => p,
-            None => fatal_span(rdr, start_bpos, rdr.last_pos,
-                               ~"int literal is too large")
+            None => rdr.fatal(~"int literal is too large")
         };
 
         match tp {
@@ -515,14 +464,12 @@ fn scan_number(c: char, rdr: @mut StringReader) -> token::Token {
     }
     if is_float {
         match base {
-          16u => fatal_span(rdr, start_bpos, rdr.last_pos,
-                            ~"hexadecimal float literal is not supported"),
-          2u => fatal_span(rdr, start_bpos, rdr.last_pos,
-                           ~"binary float literal is not supported"),
+          16u => rdr.fatal(~"hexadecimal float literal is not supported"),
+          2u => rdr.fatal(~"binary float literal is not supported"),
           _ => ()
         }
     }
-    match scan_exponent(rdr, start_bpos) {
+    match scan_exponent(rdr) {
       Some(ref s) => {
         is_float = true;
         num_str.push_str(*s);
@@ -560,13 +507,11 @@ fn scan_number(c: char, rdr: @mut StringReader) -> token::Token {
         return token::LIT_FLOAT_UNSUFFIXED(str_to_ident(num_str));
     } else {
         if num_str.len() == 0u {
-            fatal_span(rdr, start_bpos, rdr.last_pos,
-                       ~"no valid digits found for number");
+            rdr.fatal(~"no valid digits found for number");
         }
         let parsed = match from_str_radix::<u64>(num_str, base as uint) {
             Some(p) => p,
-            None => fatal_span(rdr, start_bpos, rdr.last_pos,
-                               ~"int literal is too large")
+            None => rdr.fatal(~"int literal is too large")
         };
 
         debug!("lexing %s as an unsuffixed integer literal",
@@ -578,23 +523,19 @@ fn scan_number(c: char, rdr: @mut StringReader) -> token::Token {
 fn scan_numeric_escape(rdr: @mut StringReader, n_hex_digits: uint) -> char {
     let mut accum_int = 0;
     let mut i = n_hex_digits;
-    let start_bpos = rdr.last_pos;
     while i != 0u {
         let n = rdr.curr;
+        bump(rdr);
         if !is_hex_digit(n) {
-            fatal_span_char(rdr, rdr.last_pos, rdr.pos,
-                            ~"illegal character in numeric character escape",
-                            n);
+            rdr.fatal(fmt!("illegal numeric character escape: %d", n as int));
         }
-        bump(rdr);
         accum_int *= 16;
         accum_int += hex_digit_val(n);
         i -= 1u;
     }
     match char::from_u32(accum_int as u32) {
         Some(x) => x,
-        None => fatal_span(rdr, start_bpos, rdr.last_pos,
-                           ~"illegal numeric character escape")
+        None => rdr.fatal(fmt!("illegal numeric character escape"))
     }
 }
 
@@ -750,7 +691,6 @@ fn next_token_inner(rdr: @mut StringReader) -> token::Token {
         if c2 == '\\' {
             // '\X' for some X must be a character constant:
             let escaped = rdr.curr;
-            let escaped_pos = rdr.last_pos;
             bump(rdr);
             match escaped {
               'n' => { c2 = '\n'; }
@@ -764,39 +704,32 @@ fn next_token_inner(rdr: @mut StringReader) -> token::Token {
               'u' => { c2 = scan_numeric_escape(rdr, 4u); }
               'U' => { c2 = scan_numeric_escape(rdr, 8u); }
               c2 => {
-                fatal_span_char(rdr, escaped_pos, rdr.last_pos,
-                                ~"unknown character escape", c2);
+                rdr.fatal(fmt!("unknown character escape: %d", c2 as int));
               }
             }
         }
         if rdr.curr != '\'' {
-            fatal_span_verbose(rdr,
-                               // Byte offsetting here is okay because the
-                               // character before position `start` is an
-                               // ascii single quote.
-                               start - BytePos(1u),
-                               rdr.last_pos,
-                               ~"unterminated character constant");
+            rdr.fatal(~"unterminated character constant");
         }
         bump(rdr); // advance curr past token
         return token::LIT_CHAR(c2 as u32);
       }
       '"' => {
         let mut accum_str = ~"";
-        let start_bpos = rdr.last_pos;
+        let n = rdr.last_pos;
         bump(rdr);
         while rdr.curr != '"' {
             if is_eof(rdr) {
-                fatal_span(rdr, start_bpos, rdr.last_pos,
-                           ~"unterminated double quote string");
+                do with_str_from(rdr, n) |s| {
+                    rdr.fatal(fmt!("unterminated double quote string: %s", s));
+                }
             }
 
             let ch = rdr.curr;
             bump(rdr);
             match ch {
               '\\' => {
                 let escaped = rdr.curr;
-                let escaped_pos = rdr.last_pos;
                 bump(rdr);
                 match escaped {
                   'n' => accum_str.push_char('\n'),
@@ -817,8 +750,7 @@ fn next_token_inner(rdr: @mut StringReader) -> token::Token {
                     accum_str.push_char(scan_numeric_escape(rdr, 8u));
                   }
                   c2 => {
-                    fatal_span_char(rdr, escaped_pos, rdr.last_pos,
-                                    ~"unknown string escape", c2);
+                    rdr.fatal(fmt!("unknown string escape: %d", c2 as int));
                   }
                 }
               }
@@ -854,8 +786,11 @@ fn next_token_inner(rdr: @mut StringReader) -> token::Token {
       '^' => { return binop(rdr, token::CARET); }
       '%' => { return binop(rdr, token::PERCENT); }
       c => {
-          fatal_span_char(rdr, rdr.last_pos, rdr.pos,
-                          ~"unknown start of token", c);
+          // So the error span points to the unrecognized character
+          rdr.peek_span = codemap::mk_sp(rdr.last_pos, rdr.pos);
+          let mut cs = ~"";
+          char::escape_default(c, |c| cs.push_char(c));
+          rdr.fatal(fmt!("unknown start of token: %s", cs));
       }
     }
 }