Reimplement ser::escape_str() and escape control characters

This new implementation does escape Unicode C0, DEL and C1 control characters.
It also use its own logic and does not rely on ser::escape_bytes().

Escaping C0 control characters is mandated by ECMA-404.
Escaping DEL and C1 control characters is a useful convenience often
done by other JSON implementations.

Author: PaulGrandperrin

json/src/ser.rs

@@ -486,78 +486,55 @@ impl<'a> Formatter for PrettyFormatter<'a> {
     }
 }
 
-/// Serializes and escapes a `&[u8]` into a JSON string.
+
+/// Serializes and escapes a `&str` into a JSON string.
 #[inline]
-pub fn escape_bytes<W>(wr: &mut W, bytes: &[u8]) -> Result<()>
+pub fn escape_str<W>(wr: &mut W, value: &str) -> Result<()>
     where W: io::Write
 {
-    try!(wr.write_all(b"\""));
-
     let mut start = 0;
-    let mut last_byte = 0u8;
-
-    for (i, byte) in bytes.iter().enumerate() {
-        let last_byte_was_c2 = last_byte == b'\xC2';
-        last_byte = *byte;
-
-        let escaped = match *byte {
-            b'"' => b"\\\"",
-            b'\\' => b"\\\\",
-            b'\x08' => b"\\b",
-            b'\x0c' => b"\\f",
-            b'\n' => b"\\n",
-            b'\r' => b"\\r",
-            b'\t' => b"\\t",
-            b'\x00' ... b'\x1F' | b'\x7F' => {
-                if start < i {
-                    try!(wr.write_all(&bytes[start..i]));
-                }
-
-                try!(write!(wr,"\\u{:04X}", *byte));
-
-                start = i + 1;
-
-                continue;
-            },
-            b'\x80' ... b'\x9F' if last_byte_was_c2 => {
-                if start < (i - 1) {
-                    try!(wr.write_all(&bytes[start..(i - 1)]));
-                }
-
-                try!(write!(wr,"\\u{:04X}", *byte));
 
-                start = i + 1;
+    try!(wr.write_all(b"\""));
 
+    for (i, char) in value.char_indices() {
+        let escaped = match char {
+            '"'      => b"\\\"",
+            '\\'     => b"\\\\",
+            '\u{08}' => b"\\b",
+            '\u{0c}' => b"\\f",
+            '\n'     => b"\\n",
+            '\r'     => b"\\r",
+            '\t'     => b"\\t",
+            '\u{00}' ... '\u{1F}' | '\u{7F}' | '\u{80}' ... '\u{9F}' => {
+                // only Unicode C0 control characters ('\u{00}' ... '\u{1F}') are mandated to be escaped by ECMA-404.
+                // DEL ('\u{7F}') and C1 ('\u{80}' ... '\u{9F}') control characters are also escaped for convenience.
+
+                debug_assert_eq!(char.len_utf16(), 1); // C0, DEL and C1 control characters fit on one utf16 code unit by specification.
+                try!(write!(wr, "{}\\u{:04X}", &value[start..i], char as u32));
+
+                start = i + char.len_utf8();
                 continue;
             },
-            _ => { continue; }
+            _        => { continue; }
         };
 
         if start < i {
-            try!(wr.write_all(&bytes[start..i]));
+            try!(wr.write_all(&value[start..i].as_bytes()));
         }
-
         try!(wr.write_all(escaped));
 
+        debug_assert_eq!(char.len_utf8(), 1);
         start = i + 1;
     }
 
-    if start != bytes.len() {
-        try!(wr.write_all(&bytes[start..]));
+    if start != value.len() {
+        try!(wr.write_all(&value[start..].as_bytes()));
     }
 
     try!(wr.write_all(b"\""));
     Ok(())
 }
 
-/// Serializes and escapes a `&str` into a JSON string.
-#[inline]
-pub fn escape_str<W>(wr: &mut W, value: &str) -> Result<()>
-    where W: io::Write
-{
-    escape_bytes(wr, value.as_bytes())
-}
-
 #[inline]
 fn escape_char<W>(wr: &mut W, value: char) -> Result<()>
     where W: io::Write
@@ -566,7 +543,7 @@ fn escape_char<W>(wr: &mut W, value: char) -> Result<()>
     // rust, which doesn't support encoding a `char` into a stack buffer.
     let mut s = String::new();
     s.push(value);
-    escape_bytes(wr, s.as_bytes())
+    escape_str(wr, &s)
 }
 
 fn fmt_f32_or_null<W>(wr: &mut W, value: f32) -> Result<()>