#73 support escapeUnicode false

taowen · taowen · commit 5d61fd19f14d · 2017-06-17T23:17:51.000+08:00
diff --git a/src/main/java/com/jsoniter/output/JsonStream.java b/src/main/java/com/jsoniter/output/JsonStream.java
@@ -110,6 +110,9 @@ public void flush() throws IOException {
 
     @Override
     public void close() throws IOException {
+        if (out == null) {
+            return;
+        }
         if (count > 0) {
             flushBuffer();
         }
@@ -119,6 +122,9 @@ public void close() throws IOException {
     }
 
     final void flushBuffer() throws IOException {
+        if (out == null) {
+            return;
+        }
         out.write(buf, 0, count);
         count = 0;
     }
@@ -457,26 +463,19 @@ public static String serialize(TypeLiteral typeLiteral, Object obj) {
     }
 
     public static String serialize(boolean escapeUnicode, Type type, Object obj) {
-        if (escapeUnicode) {
-            AsciiOutputStream asciiOutputStream = JsonStreamPool.borrowAsciiOutputStream();
-            try {
-                asciiOutputStream.reset();
-                serialize(type, obj, asciiOutputStream);
-                return asciiOutputStream.toString();
-            } finally {
-                JsonStreamPool.returnAsciiOutputStream(asciiOutputStream);
-            }
-        } else {
-            ByteArrayOutputStream baos = JsonStreamPool.borrowByteArrayOutputStream();
-            try {
-                baos.reset();
-                serialize(type, obj, baos);
-                return baos.toString("UTF8");
-            } catch (UnsupportedEncodingException e) {
-                throw new JsonException(e);
-            } finally {
-                JsonStreamPool.returnByteArrayOutputStream(baos);
+        JsonStream stream = JsonStreamPool.borrowJsonStream();
+        try {
+            stream.reset(null);
+            stream.writeVal(type, obj);
+            if (escapeUnicode) {
+                return new String(stream.buf, 0, stream.count);
+            } else {
+                return new String(stream.buf, 0, stream.count, "UTF8");
             }
+        } catch (IOException e) {
+            throw new JsonException(e);
+        } finally {
+            JsonStreamPool.returnJsonStream(stream);
         }
     }
 
@@ -496,4 +495,5 @@ public static void setIndentionStep(int indentionStep) {
     public static void registerNativeEncoder(Class clazz, Encoder.ReflectionEncoder encoder) {
         CodegenImplNative.NATIVE_ENCODERS.put(clazz, encoder);
     }
+
 }
diff --git a/src/main/java/com/jsoniter/output/StreamImplString.java b/src/main/java/com/jsoniter/output/StreamImplString.java
@@ -31,6 +31,8 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  */
 package com.jsoniter.output;
 
+import com.jsoniter.spi.JsonException;
+
 import java.io.IOException;
 
 class StreamImplString {
@@ -39,6 +41,10 @@ class StreamImplString {
             '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
             'a', 'b', 'c', 'd', 'e', 'f'};
     private static final boolean[] CAN_DIRECT_WRITE = new boolean[128];
+    private final static int SURR1_FIRST = 0xD800;
+    private final static int SURR1_LAST = 0xDBFF;
+    private final static int SURR2_FIRST = 0xDC00;
+    private final static int SURR2_LAST = 0xDFFF;
 
     static {
         for (int i = 0; i < CAN_DIRECT_WRITE.length; i++) {
@@ -122,41 +128,102 @@ public static final void writeStringWithoutQuote(final JsonStream stream, final
     }
 
     private static void writeStringSlowPath(JsonStream stream, String val, int i, int valLen) throws IOException {
+        boolean escapeUnicode = stream.currentConfig().escapeUnicode();
+        if (escapeUnicode) {
+            for (; i < valLen; i++) {
+                int c = val.charAt(i);
+                if (c > 125) {
+                    byte b4 = (byte) (c & 0xf);
+                    byte b3 = (byte) (c >> 4 & 0xf);
+                    byte b2 = (byte) (c >> 8 & 0xf);
+                    byte b1 = (byte) (c >> 12 & 0xf);
+                    stream.write((byte) '\\', (byte) 'u', ITOA[b1], ITOA[b2], ITOA[b3], ITOA[b4]);
+                } else {
+                    writeAsciiChar(stream, c);
+                }
+            }
+        } else {
+            writeStringSlowPathWithoutEscapeUnicode(stream, val, i, valLen);
+        }
+    }
+
+    private static void writeStringSlowPathWithoutEscapeUnicode(JsonStream stream, String val, int i, int valLen) throws IOException {
+        int _surrogate;
         for (; i < valLen; i++) {
             int c = val.charAt(i);
             if (c > 125) {
-                byte b4 = (byte) (c & 0xf);
-                byte b3 = (byte) (c >> 4 & 0xf);
-                byte b2 = (byte) (c >> 8 & 0xf);
-                byte b1 = (byte) (c >> 12 & 0xf);
-                stream.write((byte) '\\', (byte) 'u', ITOA[b1], ITOA[b2], ITOA[b3], ITOA[b4]);
-            } else {
-                switch (c) {
-                    case '"':
-                        stream.write((byte) '\\', (byte) '"');
-                        break;
-                    case '\\':
-                        stream.write((byte) '\\', (byte) '\\');
-                        break;
-                    case '\b':
-                        stream.write((byte) '\\', (byte) 'b');
-                        break;
-                    case '\f':
-                        stream.write((byte) '\\', (byte) 'f');
-                        break;
-                    case '\n':
-                        stream.write((byte) '\\', (byte) 'n');
-                        break;
-                    case '\r':
-                        stream.write((byte) '\\', (byte) 'r');
+                if (c < 0x800) { // 2-byte
+                    stream.write(
+                            (byte) (0xc0 | (c >> 6)),
+                            (byte) (0x80 | (c & 0x3f))
+                    );
+                } else { // 3 or 4 bytes
+                    // Surrogates?
+                    if (c < SURR1_FIRST || c > SURR2_LAST) {
+                        stream.write(
+                                (byte) (0xe0 | (c >> 12)),
+                                (byte) (0x80 | ((c >> 6) & 0x3f)),
+                                (byte) (0x80 | (c & 0x3f))
+                        );
+                        continue;
+                    }
+                    // Yup, a surrogate:
+                    if (c > SURR1_LAST) { // must be from first range
+                        throw new JsonException("illegalSurrogate");
+                    }
+                    _surrogate = c;
+                    // and if so, followed by another from next range
+                    if (i >= valLen) { // unless we hit the end?
                         break;
-                    case '\t':
-                        stream.write((byte) '\\', (byte) 't');
-                        break;
-                    default:
-                        stream.write(c);
+                    }
+                    int firstPart = _surrogate;
+                    _surrogate = 0;
+                    // Ok, then, is the second part valid?
+                    if (c < SURR2_FIRST || c > SURR2_LAST) {
+                        throw new JsonException("Broken surrogate pair: first char 0x" + Integer.toHexString(firstPart) + ", second 0x" + Integer.toHexString(c) + "; illegal combination");
+                    }
+                    c = 0x10000 + ((firstPart - SURR1_FIRST) << 10) + (c - SURR2_FIRST);
+                    if (c > 0x10FFFF) { // illegal in JSON as well as in XML
+                        throw new JsonException("illegalSurrogate");
+                    }
+                    stream.write(
+                            (byte) (0xf0 | (c >> 18)),
+                            (byte) (0x80 | ((c >> 12) & 0x3f)),
+                            (byte) (0x80 | ((c >> 6) & 0x3f)),
+                            (byte) (0x80 | (c & 0x3f))
+                    );
                 }
+            } else {
+                writeAsciiChar(stream, c);
             }
         }
     }
+
+    private static void writeAsciiChar(JsonStream stream, int c) throws IOException {
+        switch (c) {
+            case '"':
+                stream.write((byte) '\\', (byte) '"');
+                break;
+            case '\\':
+                stream.write((byte) '\\', (byte) '\\');
+                break;
+            case '\b':
+                stream.write((byte) '\\', (byte) 'b');
+                break;
+            case '\f':
+                stream.write((byte) '\\', (byte) 'f');
+                break;
+            case '\n':
+                stream.write((byte) '\\', (byte) 'n');
+                break;
+            case '\r':
+                stream.write((byte) '\\', (byte) 'r');
+                break;
+            case '\t':
+                stream.write((byte) '\\', (byte) 't');
+                break;
+            default:
+                stream.write(c);
+        }
+    }
 }
diff --git a/src/test/java/com/jsoniter/TestGson.java b/src/test/java/com/jsoniter/TestGson.java
@@ -37,11 +37,15 @@ public void test_Expose() {
         // test if the iterator reuse will keep right config cache
         JsonIterator.deserialize(new GsonCompatibilityMode.Builder().build(),
                 "{\"field-1\":\"hello\"}", TestObject2.class);
-        Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create();
+        Gson gson = new GsonBuilder()
+                .excludeFieldsWithoutExposeAnnotation()
+                .create();
         TestObject2 obj = gson.fromJson("{\"field1\":\"hello\"}", TestObject2.class);
         assertNull(obj.field1);
-        obj = JsonIterator.deserialize(new GsonCompatibilityMode.Builder()
-                        .excludeFieldsWithoutExposeAnnotation().build(),
+        GsonCompatibilityMode config = new GsonCompatibilityMode.Builder()
+                .excludeFieldsWithoutExposeAnnotation()
+                .build();
+        obj = JsonIterator.deserialize(config,
                 "{\"field1\":\"hello\"}", TestObject2.class);
         assertNull(obj.field1);
     }
diff --git a/src/test/java/com/jsoniter/output/TestString.java b/src/test/java/com/jsoniter/output/TestString.java
@@ -0,0 +1,11 @@
+package com.jsoniter.output;
+
+import com.jsoniter.spi.Config;
+import junit.framework.TestCase;
+
+public class TestString extends TestCase {
+    public void test_unicode() {
+        String output = JsonStream.serialize(new Config.Builder().escapeUnicode(false).build(), "中文");
+        assertEquals("\"中文\"", output);
+    }
+}
diff --git a/src/test/java/com/jsoniter/suite/AllTestCases.java b/src/test/java/com/jsoniter/suite/AllTestCases.java
@@ -5,6 +5,7 @@
 import com.jsoniter.TestGson;
 import com.jsoniter.TestNested;
 import com.jsoniter.TestObject;
+import com.jsoniter.TestString;
 import com.jsoniter.any.TestList;
 import com.jsoniter.output.*;
 import org.junit.runner.RunWith;
@@ -27,7 +28,9 @@
         TestObject.class,
         com.jsoniter.output.TestObject.class,
         TestReadAny.class, TestSkip.class, TestSlice.class,
-        TestString.class, TestWhatIsNext.class,
+        TestString.class,
+        com.jsoniter.output.TestString.class,
+        TestWhatIsNext.class,
         TestAny.class,
         com.jsoniter.output.TestArray.class,
         com.jsoniter.any.TestArray.class,
