[Strings] Unescape in JSON parsing, so StringLifting can read escaped strings (#7410)

Author: kripken

src/support/json.h

@@ -39,6 +39,7 @@
 
 #include "support/istring.h"
 #include "support/safe_integer.h"
+#include "support/string.h"
 
 namespace json {
 
@@ -260,11 +261,17 @@ struct Value {
     skip();
     if (*curr == '"') {
       // String
-      curr++;
-      char* close = strchr(curr, '"');
+      // Start |close| at the opening ", and in the loop below we will always
+      // begin looking at the first character after.
+      char* close = curr;
+      // Skip escaped "
+      do {
+        close = strchr(close + 1, '"');
+      } while (*(close - 1) == '\\');
       assert(close);
       *close = 0; // end this string, and reuse it straight from the input
-      setString(curr);
+      char* raw = curr + 1;
+      unescapeAndSetString(raw);
       curr = close + 1;
     } else if (*curr == '[') {
       // Array
@@ -403,6 +410,23 @@ struct Value {
     assert(isObject());
     return obj->count(x) > 0;
   }
+
+private:
+  // If the string has no escaped characters, setString() the char* directly. If
+  // it does require escaping, do that and intern a new string with those
+  // contents.
+  void unescapeAndSetString(char* str) {
+    if (!strchr(str, '\\')) {
+      // No escaping slash.
+      setString(str);
+      return;
+    }
+
+    auto unescaped = wasm::String::unescapeJSONToWTF8(str);
+
+    setString(
+      IString(std::string_view(unescaped.data(), unescaped.size()), false));
+  }
 };
 
 using Ref = Value::Ref;

src/support/string.cpp

@@ -432,4 +432,65 @@ bool isUTF8(std::string_view str) {
   return true;
 }
 
+std::vector<char> unescapeJSONToWTF8(const char* str) {
+  std::vector<char> unescaped;
+  size_t i = 0;
+  while (str[i]) {
+    if (str[i] != '\\') {
+      // Normal character.
+      unescaped.push_back(str[i]);
+      i++;
+      continue;
+    }
+
+    // Escaped character.
+    char c = str[i + 1];
+    if (c != 'u') {
+      switch (c) {
+        case 'b':
+          c = '\b';
+          break;
+        case 'f':
+          c = '\f';
+          break;
+        case 'n':
+          c = '\n';
+          break;
+        case 'r':
+          c = '\r';
+          break;
+        case 't':
+          c = '\t';
+          break;
+        case 0:
+          Fatal() << "Invalid escaped JSON ends in slash";
+      }
+      unescaped.push_back(c);
+      i += 2;
+      continue;
+    }
+
+    // \uXXXX, 4-digit hex number. First, read the hex.
+    unsigned int x;
+    std::stringstream unhex;
+    if (!str[i + 2] || !str[i + 3] || !str[i + 4] || !str[i + 5]) {
+      Fatal() << "Invalid escaped JSON \\uXXXX";
+    }
+    unhex << std::hex << std::string_view(str + i + 2, 4);
+    unhex >> x;
+
+    // Write out the results.
+    unescaped.push_back(x & 0xff);
+    x >>= 8;
+    if (x) {
+      unescaped.push_back(x);
+    }
+    // TODO UTF stuff
+
+    i += 6;
+  }
+
+  return unescaped;
+}
+
 } // namespace wasm::String

src/support/string.h

@@ -102,6 +102,9 @@ bool convertUTF16ToUTF8(std::ostream& os, std::string_view str);
 // Whether the string is valid UTF-8.
 bool isUTF8(std::string_view str);
 
+// Given a string of properly-escaped JSON, unescape it.
+std::vector<char> unescapeJSONToWTF8(const char* str);
+
 } // namespace wasm::String
 
 #endif // wasm_support_string_h

test/lit/passes/string-lifting-section.wast

@@ -7,9 +7,9 @@
 (module
   ;; CHECK:      (type $0 (array (mut i16)))
 
-  ;; CHECK:      (type $1 (func (param externref externref) (result i32)))
+  ;; CHECK:      (type $1 (func))
 
-  ;; CHECK:      (type $2 (func))
+  ;; CHECK:      (type $2 (func (param externref externref) (result i32)))
 
   ;; CHECK:      (type $3 (func (param (ref null $0) i32 i32) (result (ref extern))))
 
@@ -29,6 +29,8 @@
 
   ;; CHECK:      (import "string.const" "1" (global $"string.const_\"foo\"" (ref extern)))
 
+  ;; CHECK:      (import "string.const" "2" (global $"string.const_\"needs\\tescaping\\00.\\\'#%\\\"\"" (ref extern)))
+
   ;; CHECK:      (import "wasm:js-string" "fromCharCodeArray" (func $fromCharCodeArray (type $3) (param (ref null $0) i32 i32) (result (ref extern))))
 
   ;; CHECK:      (import "wasm:js-string" "fromCodePoint" (func $fromCodePoint (type $4) (param i32) (result (ref extern))))
@@ -37,17 +39,17 @@
 
   ;; CHECK:      (import "wasm:js-string" "intoCharCodeArray" (func $intoCharCodeArray (type $6) (param externref (ref null $0) i32) (result i32)))
 
-  ;; CHECK:      (import "wasm:js-string" "equals" (func $equals (type $1) (param externref externref) (result i32)))
+  ;; CHECK:      (import "wasm:js-string" "equals" (func $equals (type $2) (param externref externref) (result i32)))
 
-  ;; CHECK:      (import "wasm:js-string" "compare" (func $compare (type $1) (param externref externref) (result i32)))
+  ;; CHECK:      (import "wasm:js-string" "compare" (func $compare (type $2) (param externref externref) (result i32)))
 
   ;; CHECK:      (import "wasm:js-string" "length" (func $length (type $7) (param externref) (result i32)))
 
   ;; CHECK:      (import "wasm:js-string" "charCodeAt" (func $charCodeAt (type $8) (param externref i32) (result i32)))
 
   ;; CHECK:      (import "wasm:js-string" "substring" (func $substring (type $9) (param externref i32 i32) (result (ref extern))))
 
-  ;; CHECK:      (func $consts (type $2)
+  ;; CHECK:      (func $consts (type $1)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (string.const "foo")
   ;; CHECK-NEXT:  )
@@ -71,7 +73,19 @@
     (drop
       (string.const "foo")
     )
-    ;; TODO: test utf-8 etc.
+  )
+
+  ;; CHECK:      (func $tricky-consts (type $1)
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (string.const "needs\tescaping\00.\'#%\"")
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $tricky-consts
+    ;; This tricky string should remain exactly the same after lowering and
+    ;; lifting.
+    (drop
+      (string.const "needs\tescaping\00.'#%\"")
+    )
   )
 )