syntax: copy unstable char::escape_{default,unicode} code into libsyntax

This avoids using unsafe behavior.

Author: erickt

src/libsyntax/parse/lexer/mod.rs

@@ -15,7 +15,7 @@ use diagnostic::SpanHandler;
 use ext::tt::transcribe::tt_next_token;
 use parse::token::str_to_ident;
 use parse::token;
-use str::char_at;
+use str::{char_at, escape_default};
 
 use std::borrow::Cow;
 use std::char;
@@ -205,7 +205,7 @@ impl<'a> StringReader<'a> {
     fn fatal_span_char(&self, from_pos: BytePos, to_pos: BytePos, m: &str, c: char) -> ! {
         let mut m = m.to_string();
         m.push_str(": ");
-        for c in c.escape_default() { m.push(c) }
+        for c in escape_default(c) { m.push(c) }
         self.fatal_span_(from_pos, to_pos, &m[..]);
     }
 
@@ -214,7 +214,7 @@ impl<'a> StringReader<'a> {
     fn err_span_char(&self, from_pos: BytePos, to_pos: BytePos, m: &str, c: char) {
         let mut m = m.to_string();
         m.push_str(": ");
-        for c in c.escape_default() { m.push(c) }
+        for c in escape_default(c) { m.push(c) }
         self.err_span_(from_pos, to_pos, &m[..]);
     }
 

src/libsyntax/str.rs

@@ -8,6 +8,116 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use std::mem::transmute;
+
 pub fn char_at(s: &str, byte: usize) -> char {
     s[byte..].chars().next().unwrap()
 }
+
+// FIXME: This was copied from core/char.rs because it is currenty unstable.
+pub fn escape_unicode(ch: char) -> EscapeUnicode {
+    EscapeUnicode { c: ch, state: EscapeUnicodeState::Backslash }
+}
+
+// FIXME: This was copied from core/char.rs because it is currenty unstable.
+pub fn escape_default(ch: char) -> EscapeDefault {
+    let init_state = match ch {
+        '\t' => EscapeDefaultState::Backslash('t'),
+        '\r' => EscapeDefaultState::Backslash('r'),
+        '\n' => EscapeDefaultState::Backslash('n'),
+        '\\' => EscapeDefaultState::Backslash('\\'),
+        '\'' => EscapeDefaultState::Backslash('\''),
+        '"'  => EscapeDefaultState::Backslash('"'),
+        '\x20' ... '\x7e' => EscapeDefaultState::Char(ch),
+        _ => EscapeDefaultState::Unicode(escape_unicode(ch))
+    };
+    EscapeDefault { state: init_state }
+}
+
+// FIXME: This was copied from core/char.rs because it is currenty unstable.
+pub struct EscapeUnicode {
+    c: char,
+    state: EscapeUnicodeState
+}
+
+enum EscapeUnicodeState {
+    Backslash,
+    Type,
+    LeftBrace,
+    Value(usize),
+    RightBrace,
+    Done,
+}
+
+impl Iterator for EscapeUnicode {
+    type Item = char;
+
+    fn next(&mut self) -> Option<char> {
+        match self.state {
+            EscapeUnicodeState::Backslash => {
+                self.state = EscapeUnicodeState::Type;
+                Some('\\')
+            }
+            EscapeUnicodeState::Type => {
+                self.state = EscapeUnicodeState::LeftBrace;
+                Some('u')
+            }
+            EscapeUnicodeState::LeftBrace => {
+                let mut n = 0;
+                while (self.c as u32) >> (4 * (n + 1)) != 0 {
+                    n += 1;
+                }
+                self.state = EscapeUnicodeState::Value(n);
+                Some('{')
+            }
+            EscapeUnicodeState::Value(offset) => {
+                let v = match ((self.c as i32) >> (offset * 4)) & 0xf {
+                    i @ 0 ... 9 => '0' as i32 + i,
+                    i => 'a' as i32 + (i - 10)
+                };
+                if offset == 0 {
+                    self.state = EscapeUnicodeState::RightBrace;
+                } else {
+                    self.state = EscapeUnicodeState::Value(offset - 1);
+                }
+                Some(unsafe { transmute(v) })
+            }
+            EscapeUnicodeState::RightBrace => {
+                self.state = EscapeUnicodeState::Done;
+                Some('}')
+            }
+            EscapeUnicodeState::Done => None,
+        }
+    }
+}
+
+// FIXME: This was copied from core/char.rs because it is currenty unstable.
+pub struct EscapeDefault {
+    state: EscapeDefaultState
+}
+
+enum EscapeDefaultState {
+    Backslash(char),
+    Char(char),
+    Done,
+    Unicode(EscapeUnicode),
+}
+
+impl Iterator for EscapeDefault {
+    type Item = char;
+
+    fn next(&mut self) -> Option<char> {
+        match self.state {
+            EscapeDefaultState::Backslash(c) => {
+                self.state = EscapeDefaultState::Char(c);
+                Some('\\')
+            }
+            EscapeDefaultState::Char(c) => {
+                self.state = EscapeDefaultState::Done;
+                Some(c)
+            }
+            EscapeDefaultState::Done => None,
+            EscapeDefaultState::Unicode(ref mut iter) => iter.next()
+        }
+    }
+}