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/parse/mod.rs

@@ -16,7 +16,7 @@ use diagnostic::{SpanHandler, mk_span_handler, default_handler, Auto, FatalError
 use parse::attr::ParserAttr;
 use parse::parser::Parser;
 use ptr::P;
-use str::char_at;
+use str::{char_at, escape_default_string};
 
 use std::cell::{Cell, RefCell};
 use std::fs::File;
@@ -430,7 +430,7 @@ pub fn char_lit(lit: &str) -> (char, isize) {
 /// Parse a string representing a string literal into its final form. Does
 /// unescaping.
 pub fn str_lit(lit: &str) -> String {
-    debug!("parse_str_lit: given {}", lit.escape_default());
+    debug!("parse_str_lit: given {}", escape_default_string(lit));
     let mut res = String::with_capacity(lit.len());
 
     // FIXME #8372: This could be a for-loop if it didn't borrow the iterator
@@ -505,7 +505,7 @@ pub fn str_lit(lit: &str) -> String {
 /// Parse a string representing a raw string literal into its final form. The
 /// only operation this does is convert embedded CRLF into a single LF.
 pub fn raw_str_lit(lit: &str) -> String {
-    debug!("raw_str_lit: given {}", lit.escape_default());
+    debug!("raw_str_lit: given {}", escape_default_string(lit));
     let mut res = String::with_capacity(lit.len());
 
     // FIXME #8372: This could be a for-loop if it didn't borrow the iterator

src/libsyntax/print/pprust.rs

@@ -27,6 +27,7 @@ use print::pp::{Breaks, eof};
 use print::pp::Breaks::{Consistent, Inconsistent};
 use ptr::P;
 use std_inject;
+use str::{escape_default, escape_default_string};
 
 use std::ascii;
 use std::io::{self, Write, Read};
@@ -2801,7 +2802,7 @@ impl<'a> State<'a> {
             }
             ast::LitChar(ch) => {
                 let mut res = String::from("'");
-                res.extend(ch.escape_default());
+                res.extend(escape_default(ch));
                 res.push('\'');
                 word(&mut self.s, &res[..])
             }
@@ -2934,7 +2935,7 @@ impl<'a> State<'a> {
                         style: ast::StrStyle) -> io::Result<()> {
         let st = match style {
             ast::CookedStr => {
-                (format!("\"{}\"", st.escape_default()))
+                (format!("\"{}\"", escape_default_string(st)))
             }
             ast::RawStr(n) => {
                 (format!("r{delim}\"{string}\"{delim}",

src/libsyntax/str.rs

@@ -8,6 +8,120 @@
 // 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 }
+}
+
+pub fn escape_default_string(s: &str) -> String {
+    s.chars().flat_map(escape_default).collect()
+}
+
+// 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()
+        }
+    }
+}