json-as 1.5.0 → 1.6.1

package/assembly/deserialize/swar/string.ts

@@ -4,6 +4,8 @@ import { __heap_base } from "memory";
 import { BACK_SLASH, QUOTE } from "../../custom/chars";
 import { DESERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
 import { hex4_to_u16_swar } from "../../util/swar";
+import { markProductionParseError } from "../error";
+import { isValidStringEscape } from "../string-validation";
 
 // Overflow Pattern for Unicode Escapes (READ)
 // \u0001     0 \u00|01__   + 4
@@ -71,7 +73,7 @@ function deserializeEscapedString_SWAR(
   }
 
   let srcStart = escapeStart;
-  const srcEnd8 = srcEnd >= 8 ? srcEnd - 8 : 0;
+  const srcEnd8 = srcEnd - 8;
 
   while (srcStart <= srcEnd8) {
     const block = load<u64>(srcStart);
@@ -107,6 +109,11 @@ function deserializeEscapedString_SWAR(
       const srcIdx = srcStart + laneIdx;
       if ((load<u32>(srcIdx) & 0xffff) !== 0x5c) continue; // false positive
       bs.offset += laneIdx;
+      if (!isValidStringEscape(srcIdx, srcEnd)) {
+        bs.offset = bs.buffer + outStart;
+        markProductionParseError();
+        return changetype<string>(0);
+      }
       const code = load<u16>(srcIdx, 2);
       if (code !== 0x75) {
         store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
@@ -134,6 +141,11 @@ function deserializeEscapedString_SWAR(
       srcStart += 2;
       continue;
     }
+    if (!isValidStringEscape(srcStart, srcEnd)) {
+      bs.offset = bs.buffer + outStart;
+      markProductionParseError();
+      return changetype<string>(0);
+    }
     const code = load<u16>(srcStart, 2);
     if (code !== 0x75) {
       store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
@@ -256,16 +268,25 @@ function deserializeEscapedStringField_SWAR(
 ): usize {
   const prefixLen = <u32>(escapeStart - payloadStart);
   bs.offset = bs.buffer;
-  bs.ensureSize(<u32>(srcEnd - payloadStart) + 8); // +8 slack for u64 overcopy
+  // `srcEnd` may be the end of a containing map/document when a generated
+  // parser is cursor-driven. Reserving that entire remainder for one escaped
+  // field retained multi-megabyte scratch buffers. Grow with the decoded
+  // string instead; escapes only shrink relative to the source.
+  bs.ensureSize(prefixLen + 1024);
   if (prefixLen != 0) {
     memory.copy(bs.buffer, payloadStart, prefixLen);
     bs.offset += prefixLen;
   }
 
   let srcStart = escapeStart;
-  const srcEnd8 = srcEnd >= 8 ? srcEnd - 8 : 0;
+  const srcEnd8 = srcEnd - 8;
+  let scratchEnd = bs.buffer + bs.bufferSize - 8;
 
   while (srcStart <= srcEnd8) {
+    if (bs.offset > scratchEnd) {
+      bs.ensureSize(1024);
+      scratchEnd = bs.buffer + bs.bufferSize - 8;
+    }
     const block = load<u64>(srcStart);
     let mask = backslash_or_quote_mask(block);
     if (mask == 0) {
@@ -285,6 +306,10 @@ function deserializeEscapedStringField_SWAR(
           srcStart += 8;
         }
         const runLen = <u32>(srcStart - runStart);
+        if (bs.offset + runLen > scratchEnd) {
+          bs.ensureSize(runLen + 1024);
+          scratchEnd = bs.buffer + bs.bufferSize - 8;
+        }
         memory.copy(bs.offset, runStart, runLen);
         bs.offset += runLen;
       }
@@ -310,6 +335,11 @@ function deserializeEscapedStringField_SWAR(
         bs.offset = bs.buffer;
         return srcIdx + 2;
       }
+      if (!isValidStringEscape(srcIdx, srcEnd)) {
+        bs.offset = bs.buffer;
+        markProductionParseError();
+        return 0;
+      }
       const code = load<u16>(srcIdx, 2);
       if (code !== 0x75) {
         store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
@@ -330,6 +360,7 @@ function deserializeEscapedStringField_SWAR(
   }
 
   // scalar tail (< 8 bytes remaining)
+  bs.ensureSize(<u32>(srcEnd - srcStart) + 2);
   while (srcStart < srcEnd) {
     const char = load<u16>(srcStart);
     if (char == QUOTE) {
@@ -343,6 +374,11 @@ function deserializeEscapedStringField_SWAR(
       srcStart += 2;
       continue;
     }
+    if (!isValidStringEscape(srcStart, srcEnd)) {
+      bs.offset = bs.buffer;
+      markProductionParseError();
+      return 0;
+    }
     const code = load<u16>(srcStart, 2);
     if (code !== 0x75) {
       store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
@@ -356,122 +392,37 @@ function deserializeEscapedStringField_SWAR(
   }
 
   bs.offset = bs.buffer;
-  abort("Unterminated string literal");
-  return srcStart;
+  markProductionParseError();
+  return 0;
 }
 
-function deserializeEscapedStringContinuation_SWAR_MergedTuned(
-  lastPtr: usize,
+export function deserializeStringField_SWAR<T extends string | null>(
   srcStart: usize,
   srcEnd: usize,
-  dstFieldPtr: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
 ): usize {
-  const srcEnd8 = srcEnd - 8;
-
-  while (srcStart <= srcEnd8) {
-    const blockStart = srcStart;
-    let mask = backslash_or_quote_mask(load<u64>(srcStart));
-    if (mask === 0) {
-      srcStart += 8;
-      continue;
-    }
-
-    do {
-      const laneIdx = usize(ctz(mask) >> 3);
-      mask &= mask - 1;
-      const srcIdx = srcStart + laneIdx;
-      const char = load<u16>(srcIdx);
-      if (char == QUOTE) {
-        const runLen = <u32>(srcIdx - lastPtr);
-        if (runLen != 0) {
-          memory.copy(bs.offset, lastPtr, runLen);
-          bs.offset += runLen;
-        }
-        writeStringToField(
-          dstFieldPtr,
-          bs.buffer,
-          <u32>(bs.offset - bs.buffer),
-        );
-        bs.offset = bs.buffer;
-        return srcIdx + 2;
-      }
-      if (char != BACK_SLASH) continue;
-
-      const runLen = <u32>(srcIdx - lastPtr);
-      if (runLen != 0) {
-        memory.copy(bs.offset, lastPtr, runLen);
-        bs.offset += runLen;
-      }
-
-      const chunk = load<u32>(srcIdx);
-      const code = <u16>(chunk >> 16);
-      if (code !== 0x75) {
-        store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
-        bs.offset += 2;
-        lastPtr = srcIdx + 4;
-      } else {
-        store<u16>(bs.offset, hex4_to_u16_swar(load<u64>(srcIdx, 4)));
-        bs.offset += 2;
-        lastPtr = srcIdx + 12;
-      }
-      srcStart = lastPtr;
-      break;
-    } while (mask !== 0);
-
-    if (srcStart == blockStart) srcStart += 8;
-  }
-
-  while (srcStart < srcEnd) {
-    const tailChar = load<u16>(srcStart);
-    if (tailChar == QUOTE) {
-      const runLen = <u32>(srcStart - lastPtr);
-      if (runLen != 0) {
-        memory.copy(bs.offset, lastPtr, runLen);
-        bs.offset += runLen;
-      }
-      writeStringToField(dstFieldPtr, bs.buffer, <u32>(bs.offset - bs.buffer));
-      bs.offset = bs.buffer;
-      return srcStart + 2;
-    }
-    if (tailChar != BACK_SLASH) {
-      srcStart += 2;
-      continue;
-    }
-
-    const runLen = <u32>(srcStart - lastPtr);
-    if (runLen != 0) {
-      memory.copy(bs.offset, lastPtr, runLen);
-      bs.offset += runLen;
-    }
-    const tailCode = load<u16>(srcStart, 2);
-    if (tailCode !== 0x75) {
-      store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + tailCode));
-      bs.offset += 2;
-      srcStart += 4;
-    } else {
-      store<u16>(bs.offset, hex4_to_u16_swar(load<u64>(srcStart, 4)));
-      bs.offset += 2;
-      srcStart += 12;
-    }
-    lastPtr = srcStart;
+  if (srcStart + 2 > srcEnd || load<u16>(srcStart) != QUOTE) {
+    markProductionParseError();
+    return 0;
   }
-
-  bs.offset = bs.buffer;
-  return srcStart;
+  return deserializeStringFieldTrusted_SWAR(
+    srcStart + 2,
+    srcEnd,
+    dstObj,
+    dstOffset,
+  );
 }
 
-export function deserializeStringField_SWAR<T extends string | null>(
-  srcStart: usize,
+export function deserializeStringFieldTrusted_SWAR(
+  payloadStart: usize,
   srcEnd: usize,
   dstObj: usize,
   dstOffset: usize = 0,
 ): usize {
   const dstFieldPtr = dstObj + dstOffset;
-  if (srcStart + 2 > srcEnd || load<u16>(srcStart) != QUOTE)
-    abort("Expected leading quote");
-
-  const payloadStart = srcStart + 2;
-  srcStart = payloadStart;
+  let srcStart = payloadStart;
+  let pendingMask: u64 = 0;
 
   // Wide pre-scan: skip 16 bytes per iter while both halves are clean. The
   // common case (plain ASCII payloads, no escape) hits this loop exclusively
@@ -482,9 +433,15 @@ export function deserializeStringField_SWAR<T extends string | null>(
       // Test the first word before loading the second: short values and keys
       // close (or escape) within the first 8 bytes, so this skips the second
       // load on the common case while still skipping 16 bytes when both clean.
-      if (backslash_or_quote_mask(load<u64>(srcStart)) != 0) break;
-      if (backslash_or_quote_mask(load<u64>(srcStart, 8)) != 0) {
+      const firstMask = backslash_or_quote_mask(load<u64>(srcStart));
+      if (firstMask != 0) {
+        pendingMask = firstMask;
+        break;
+      }
+      const secondMask = backslash_or_quote_mask(load<u64>(srcStart, 8));
+      if (secondMask != 0) {
         srcStart += 8;
+        pendingMask = secondMask;
         break;
       }
       srcStart += 16;
@@ -493,7 +450,9 @@ export function deserializeStringField_SWAR<T extends string | null>(
 
   const srcEnd8 = srcEnd - 8;
   while (srcStart <= srcEnd8) {
-    let mask = backslash_or_quote_mask(load<u64>(srcStart));
+    let mask = pendingMask;
+    if (mask == 0) mask = backslash_or_quote_mask(load<u64>(srcStart));
+    pendingMask = 0;
     if (mask === 0) {
       srcStart += 8;
       continue;
@@ -545,8 +504,8 @@ export function deserializeStringField_SWAR<T extends string | null>(
     srcStart += 2;
   }
 
-  abort("Unterminated string literal");
-  return srcStart;
+  markProductionParseError();
+  return 0;
 }
 
 /**

package/assembly/index.d.ts

@@ -267,6 +267,12 @@ declare function deserializer(
  */
 declare const JSON_MODE: JSONMode;
 
+/**
+ * Whether strict RFC 8259 validation is enabled. Injected by the transform from
+ * the `JSON_STRICT` build-time environment variable (default `false`).
+ */
+declare const JSON_STRICT: bool;
+
 /**
  * Whether the string cache is enabled (default off). Injected from the
  * `JSON_CACHE` build-time environment variable. When on, repeated strings are