json-as 1.5.0 → 1.6.1

package/assembly/deserialize/naive/object.ts

@@ -14,6 +14,11 @@ import {
 import { isSpace, scanStringEnd } from "../../util";
 import { deserializeFloat } from "../index/float";
 import { deserializeString } from "../index/string";
+import {
+  failProductionParse,
+  markProductionParseError,
+  takeProductionParseError,
+} from "../error";
 
 // "true"  as a u64 of UTF-16 code units (LE).
 const TRUE_WORD: u64 = 28429475166421108;
@@ -42,6 +47,7 @@ export function setParseSrc(s: string): void {
 export function getParseSrc(): string {
   return parseSrc;
 }
+export { markProductionParseError, takeProductionParseError };
 
 export function deserializeObject(
   srcStart: usize,
@@ -58,21 +64,19 @@ export function deserializeObject(
 
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
 
-  if (srcEnd == srcStart)
-    throw new Error("Input string had zero length or was all whitespace");
-  if (load<u16>(srcStart) != BRACE_LEFT)
-    throw new Error(
-      "Expected '{' at start of object at position " +
-        (srcEnd - srcStart).toString(),
-    );
-  if (load<u16>(srcEnd - 2) != BRACE_RIGHT)
-    throw new Error(
-      "Expected '}' at end of object at position " +
-        (srcEnd - srcStart).toString(),
-    );
+  if (
+    srcEnd == srcStart ||
+    load<u16>(srcStart) != BRACE_LEFT ||
+    load<u16>(srcEnd - 2) != BRACE_RIGHT
+  ) {
+    failProductionParse();
+    return changetype<JSON.Obj>(0);
+  }
 
-  parseObjectBody(out, srcStart + 2, srcEnd);
-  return out;
+  out.reserveForParse((srcEnd - srcStart) >> 1);
+  return parseObjectBody(out, srcStart + 2, srcEnd) != 0
+    ? out
+    : changetype<JSON.Obj>(0);
 }
 
 export function deserializeJsonArray(
@@ -88,15 +92,18 @@ export function deserializeJsonArray(
 
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
 
-  if (srcEnd == srcStart)
-    throw new Error("Input string had zero length or was all whitespace");
-  if (load<u16>(srcStart) != BRACKET_LEFT)
-    throw new Error("Expected '[' at start of array");
-  if (load<u16>(srcEnd - 2) != BRACKET_RIGHT)
-    throw new Error("Expected ']' at end of array");
+  if (
+    srcEnd == srcStart ||
+    load<u16>(srcStart) != BRACKET_LEFT ||
+    load<u16>(srcEnd - 2) != BRACKET_RIGHT
+  ) {
+    failProductionParse();
+    return changetype<JSON.Arr>(0);
+  }
 
-  parseArrayBodySlots(out, srcStart + 2, srcEnd);
-  return out;
+  return parseArrayBodySlots(out, srcStart + 2, srcEnd) != 0
+    ? out
+    : changetype<JSON.Arr>(0);
 }
 
 /**
@@ -120,13 +127,14 @@ export function parseArrayBodySlots(
     if (parseSrc.length != 0) {
       out.pushRawSlot(parseSlotBits(srcStart, srcEnd));
     } else {
-      out.pushRawSlot(
-        JSON.Value.bitsFrom<JSON.Value>(parseValue(srcStart, srcEnd)),
-      );
+      const value = parseValue(srcStart, srcEnd);
+      if (parseValueEnd == 0) return 0;
+      out.pushRawSlot(JSON.Value.bitsFrom<JSON.Value>(value));
     }
+    if (parseValueEnd == 0) return 0;
     srcStart = parseValueEnd;
   }
-  return srcEnd;
+  return 0;
 }
 
 /**
@@ -137,9 +145,19 @@ export function parseArrayBodySlots(
  * to be set (the caller guards), since a lazy slot points into it.
  */
 function parseSlotBits(srcStart: usize, srcEnd: usize): u64 {
+  if (srcStart >= srcEnd) {
+    parseValueEnd = 0;
+    markProductionParseError();
+    return JSON.Value.nullBits();
+  }
   const code = load<u16>(srcStart);
   if (code == QUOTE || code == BRACE_LEFT || code == BRACKET_LEFT) {
     const end = JSON.Util.scanValueEnd<JSON.Value>(srcStart, srcEnd);
+    if (end == 0) {
+      parseValueEnd = 0;
+      markProductionParseError();
+      return JSON.Value.nullBits();
+    }
     parseValueEnd = end;
     return JSON.Value.lazyBits(changetype<usize>(parseSrc), srcStart, end);
   } else if (code - 48 <= 9 || code == 45) {
@@ -153,24 +171,33 @@ function parseSlotBits(srcStart: usize, srcEnd: usize): u64 {
     parseValueEnd = p;
     return JSON.Value.f64Bits(deserializeFloat<f64>(srcStart, p));
   } else if (code == CHAR_T) {
-    if (load<u64>(srcStart) != TRUE_WORD)
-      throw new Error("Expected 'true' in JSON");
+    if (srcEnd - srcStart < 8 || load<u64>(srcStart) != TRUE_WORD) {
+      parseValueEnd = 0;
+      markProductionParseError();
+      return JSON.Value.nullBits();
+    }
     parseValueEnd = srcStart + 8;
     return JSON.Value.boolBits(true);
   } else if (code == CHAR_F) {
-    if (load<u64>(srcStart, 2) != ALSE_WORD)
-      throw new Error("Expected 'false' in JSON");
+    if (srcEnd - srcStart < 10 || load<u64>(srcStart, 2) != ALSE_WORD) {
+      parseValueEnd = 0;
+      markProductionParseError();
+      return JSON.Value.nullBits();
+    }
     parseValueEnd = srcStart + 10;
     return JSON.Value.boolBits(false);
   } else if (code == CHAR_N) {
-    if (load<u64>(srcStart) != NULL_WORD)
-      throw new Error("Expected 'null' in JSON");
+    if (srcEnd - srcStart < 8 || load<u64>(srcStart) != NULL_WORD) {
+      parseValueEnd = 0;
+      markProductionParseError();
+      return JSON.Value.nullBits();
+    }
     parseValueEnd = srcStart + 8;
     return JSON.Value.nullBits();
   }
-  throw new Error(
-    "Unexpected character in JSON '" + String.fromCharCode(code) + "'",
-  );
+  parseValueEnd = 0;
+  markProductionParseError();
+  return JSON.Value.nullBits();
 }
 
 /**
@@ -185,12 +212,27 @@ export function lastValueEnd(): usize {
 }
 
 export function parseValue(srcStart: usize, srcEnd: usize): JSON.Value {
+  if (srcStart >= srcEnd) {
+    parseValueEnd = 0;
+    markProductionParseError();
+    return changetype<JSON.Value>(0);
+  }
   const code = load<u16>(srcStart);
   if (code == QUOTE) {
     const end = scanStringEnd(srcStart, srcEnd);
-    if (end >= srcEnd) throw new Error("Unterminated string in JSON");
+    if (end >= srcEnd) {
+      parseValueEnd = 0;
+      markProductionParseError();
+      return changetype<JSON.Value>(0);
+    }
     parseValueEnd = end + 2;
-    return JSON.Value.from(deserializeString(srcStart, end + 2));
+    const value = deserializeString(srcStart, end + 2);
+    if (changetype<usize>(value) == 0) {
+      parseValueEnd = 0;
+      markProductionParseError();
+      return changetype<JSON.Value>(0);
+    }
+    return JSON.Value.from(value);
   } else if (code == BRACE_LEFT) {
     const obj = new JSON.Obj();
     parseValueEnd = parseObjectBody(obj, srcStart + 2, srcEnd);
@@ -210,24 +252,33 @@ export function parseValue(srcStart: usize, srcEnd: usize): JSON.Value {
     parseValueEnd = p;
     return JSON.Value.from(deserializeFloat<f64>(srcStart, p));
   } else if (code == CHAR_T) {
-    if (load<u64>(srcStart) != TRUE_WORD)
-      throw new Error("Expected 'true' in JSON");
+    if (srcEnd - srcStart < 8 || load<u64>(srcStart) != TRUE_WORD) {
+      parseValueEnd = 0;
+      markProductionParseError();
+      return changetype<JSON.Value>(0);
+    }
     parseValueEnd = srcStart + 8;
     return JSON.Value.from(true);
   } else if (code == CHAR_F) {
-    if (load<u64>(srcStart, 2) != ALSE_WORD)
-      throw new Error("Expected 'false' in JSON");
+    if (srcEnd - srcStart < 10 || load<u64>(srcStart, 2) != ALSE_WORD) {
+      parseValueEnd = 0;
+      markProductionParseError();
+      return changetype<JSON.Value>(0);
+    }
     parseValueEnd = srcStart + 10;
     return JSON.Value.from(false);
   } else if (code == CHAR_N) {
-    if (load<u64>(srcStart) != NULL_WORD)
-      throw new Error("Expected 'null' in JSON");
+    if (srcEnd - srcStart < 8 || load<u64>(srcStart) != NULL_WORD) {
+      parseValueEnd = 0;
+      markProductionParseError();
+      return changetype<JSON.Value>(0);
+    }
     parseValueEnd = srcStart + 8;
     return JSON.Value.from<usize>(0);
   }
-  throw new Error(
-    "Unexpected character in JSON '" + String.fromCharCode(code) + "'",
-  );
+  parseValueEnd = 0;
+  markProductionParseError();
+  return changetype<JSON.Value>(0);
 }
 
 /**
@@ -254,14 +305,20 @@ export function parseArrayBody(
       // Defer strings and composites (the allocating shapes): store the raw
       // slice, parse on first access. Cheap primitives stay eager below.
       const end = JSON.Util.scanValueEnd<JSON.Value>(srcStart, srcEnd);
+      if (end == 0) {
+        markProductionParseError();
+        return 0;
+      }
       out.push(JSON.Value.fromSlice(srcStart, end, parseSrc));
       srcStart = end;
     } else {
-      out.push(parseValue(srcStart, srcEnd));
+      const value = parseValue(srcStart, srcEnd);
+      if (parseValueEnd == 0) return 0;
+      out.push(value);
       srcStart = parseValueEnd;
     }
   }
-  return srcEnd;
+  return 0;
 }
 
 /**
@@ -274,6 +331,7 @@ export function parseObjectBody(
   srcStart: usize,
   srcEnd: usize,
 ): usize {
+  const objectStart = srcStart - 2;
   // Anchor the source for this object's deferred value slots (start pointers
   // into it). Set here so every caller - deserializeObject, the JSON.Obj[]
   // array path, parseValue, the map path - gets it. Empty off the parse path,
@@ -287,44 +345,43 @@ export function parseObjectBody(
       srcStart += 2;
       continue;
     }
-    if (code == BRACE_RIGHT) return srcStart + 2;
+    if (code == BRACE_RIGHT) {
+      const objectEnd = srcStart + 2;
+      out._rawStart = objectStart;
+      out._rawEnd = objectEnd;
+      return objectEnd;
+    }
 
     // --- key ---
-    if (code != QUOTE)
-      throw new Error(
-        "Unexpected character in JSON object '" +
-          String.fromCharCode(code) +
-          "' at position " +
-          (srcEnd - srcStart).toString(),
-      );
+    if (code != QUOTE) return failProductionParse();
     const keyStart = srcStart + 2;
     srcStart = scanStringEnd(srcStart, srcEnd);
-    if (srcStart >= srcEnd)
-      throw new Error("Unterminated string in JSON object");
+    if (srcStart >= srcEnd) return failProductionParse();
     const keyEnd = srcStart;
     srcStart += 2;
 
     // --- colon ---
     while (srcStart < srcEnd && isSpace((code = load<u16>(srcStart))))
       srcStart += 2;
-    if (srcStart >= srcEnd || code != COLON)
-      throw new Error(
-        "Expected ':' after key at position " + (srcEnd - srcStart).toString(),
-      );
+    if (srcStart >= srcEnd || code != COLON) return failProductionParse();
     srcStart += 2;
 
     // --- value ---
     while (srcStart < srcEnd && isSpace((code = load<u16>(srcStart))))
       srcStart += 2;
+    if (srcStart >= srcEnd) return failProductionParse();
     if (parseSrc.length != 0) {
       // Parsing: store a NaN-boxed slot directly (strings/composites deferred,
       // scalars eager) - no per-value JSON.Value object.
-      out.appendRawSlot(keyStart, keyEnd, parseSlotBits(srcStart, srcEnd));
+      out.appendParsedSlot(keyStart, keyEnd, parseSlotBits(srcStart, srcEnd));
+      if (parseValueEnd == 0) return 0;
     } else {
       // Off the parse path (no source anchor): box eagerly.
-      out.appendRaw(keyStart, keyEnd, parseValue(srcStart, srcEnd));
+      const value = parseValue(srcStart, srcEnd);
+      if (parseValueEnd == 0) return 0;
+      out.appendRaw(keyStart, keyEnd, value);
     }
     srcStart = parseValueEnd;
   }
-  return srcEnd;
+  return 0;
 }

package/assembly/deserialize/naive/raw.ts

@@ -1,6 +1,18 @@
 import { JSON } from "../..";
 import { ptrToStr } from "../../util/ptrToStr";
 
-export function deserializeRaw(srcStart: usize, srcEnd: usize): JSON.Raw {
+export function deserializeRaw(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize = 0,
+): JSON.Raw {
+  const size = srcEnd - srcStart;
+  if (dst) {
+    const out = changetype<JSON.Raw>(dst);
+    const data = changetype<string>(__renew(changetype<usize>(out.data), size));
+    memory.copy(changetype<usize>(data), srcStart, size);
+    out.data = data;
+    return out;
+  }
   return JSON.Raw.from(ptrToStr(srcStart, srcEnd));
 }

package/assembly/deserialize/naive/set.ts

@@ -63,7 +63,6 @@ function deserializeSetDirect<T extends Set<any>>(
   if (load<u16>(srcStart) == BRACKET_RIGHT) return srcStart + 2;
 
   while (srcStart < srcEnd) {
-    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
     const code = load<u16>(srcStart);
 
     // @ts-ignore: type

package/assembly/deserialize/naive/staticarray.ts

@@ -21,7 +21,8 @@ function materializeStaticArray<T extends StaticArray<any>>(
   src: valueof<T>[],
   dst: usize,
 ): T {
-  const byteLength = <usize>src.length * sizeof<valueof<T>>();
+  const len = src.length;
+  const byteLength = <usize>len * sizeof<valueof<T>>();
   let out = dst;
 
   if (!out) {
@@ -31,7 +32,7 @@ function materializeStaticArray<T extends StaticArray<any>>(
   }
 
   const typed = changetype<T>(out);
-  for (let i = 0; i < src.length; i++) {
+  for (let i = 0; i < len; i++) {
     unchecked((typed[i] = unchecked(src[i])));
   }
   return typed;

package/assembly/deserialize/naive/string.ts

@@ -3,6 +3,8 @@ import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 import { __heap_base } from "memory";
 import { BACK_SLASH, QUOTE } from "../../custom/chars";
 import { DESERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
+import { markProductionParseError } from "../error";
+import { isValidStringEscape } from "../string-validation";
 
 function hexDigit(c: u16): u32 {
   if (c <= 0x39) return c - 0x30; // '0'-'9'
@@ -19,46 +21,10 @@ function hex4ToU16(srcStart: usize): u16 {
   );
 }
 
-function isHexDigit(c: u16): bool {
-  return (
-    (c >= 0x30 && c <= 0x39) ||
-    (c >= 0x41 && c <= 0x46) ||
-    (c >= 0x61 && c <= 0x66)
-  );
-}
-
-// Strict RFC 8259 check for the char following a backslash, at [escPtr, srcEnd).
-// Legal escapes: " \ / b f n r t and \uXXXX (4 hex digits). Throws otherwise:
-// unknown escape letter, a trailing backslash, or a short / non-hex \u.
-function validateEscape(escPtr: usize, srcEnd: usize): void {
-  if (escPtr >= srcEnd)
-    throw new Error("Invalid JSON string: incomplete escape");
-  const code = load<u16>(escPtr);
-  if (code == 0x75) {
-    // \uXXXX
-    if (escPtr + 10 > srcEnd)
-      throw new Error("Invalid JSON string: incomplete \\u escape");
-    if (
-      !isHexDigit(load<u16>(escPtr, 2)) ||
-      !isHexDigit(load<u16>(escPtr, 4)) ||
-      !isHexDigit(load<u16>(escPtr, 6)) ||
-      !isHexDigit(load<u16>(escPtr, 8))
-    )
-      throw new Error("Invalid JSON string: \\u escape needs 4 hex digits");
-    return;
-  }
-  // short escapes: " \ / b f n r t
-  if (
-    code != 0x22 &&
-    code != 0x5c &&
-    code != 0x2f &&
-    code != 0x62 &&
-    code != 0x66 &&
-    code != 0x6e &&
-    code != 0x72 &&
-    code != 0x74
-  )
-    throw new Error("Invalid JSON string: illegal escape");
+// RFC 8259 check for the char following a backslash, at [escPtr, srcEnd).
+// Legal escapes: " \ / b f n r t and \uXXXX (4 hex digits).
+function validateEscape(escPtr: usize, srcEnd: usize): bool {
+  return isValidStringEscape(escPtr - 2, srcEnd);
 }
 
 export function deserializeString_NAIVE(
@@ -72,8 +38,10 @@ export function deserializeString_NAIVE(
     srcEnd - srcStart < 4 ||
     load<u16>(srcStart) != QUOTE ||
     load<u16>(srcEnd - 2) != QUOTE
-  )
-    throw new Error("Invalid JSON string: missing surrounding quotes");
+  ) {
+    markProductionParseError();
+    return changetype<string>(0);
+  }
   // Strip quotes
   srcStart += 2;
   srcEnd -= 2;
@@ -88,13 +56,20 @@ export function deserializeString_NAIVE(
     // Early exit
     if (block !== 0x5c) {
       // RFC 8259: literal control chars (U+0000..U+001F) must be escaped.
-      if (block < 0x20)
-        throw new Error("Invalid JSON string: unescaped control character");
+      if (block < 0x20) {
+        bs.offset = bs.buffer + outStart;
+        markProductionParseError();
+        return changetype<string>(0);
+      }
       bs.offset += 2;
       continue;
     }
 
-    validateEscape(srcStart, srcEnd);
+    if (!validateEscape(srcStart, srcEnd)) {
+      bs.offset = bs.buffer + outStart;
+      markProductionParseError();
+      return changetype<string>(0);
+    }
     const code = load<u16>(srcStart);
     if (code !== 0x75) {
       // Short escapes (\n \t \" \\)
@@ -191,7 +166,7 @@ function deserializeEscapedStringField_NAIVE(
     bs.offset += 2;
   }
 
-  abort("Expected closing quote");
+  markProductionParseError();
   return 0;
 }
 
@@ -206,12 +181,26 @@ export function deserializeStringField_NAIVE<T extends string | null>(
   dstObj: usize,
   dstOffset: usize = 0,
 ): usize {
-  const dstFieldPtr = dstObj + dstOffset;
-  if (srcStart + 2 > srcEnd || load<u16>(srcStart) != QUOTE)
-    abort("Expected leading quote");
+  if (srcStart + 2 > srcEnd || load<u16>(srcStart) != QUOTE) {
+    markProductionParseError();
+    return 0;
+  }
+  return deserializeStringFieldTrusted_NAIVE(
+    srcStart + 2,
+    srcEnd,
+    dstObj,
+    dstOffset,
+  );
+}
 
-  const payloadStart = srcStart + 2;
-  srcStart = payloadStart;
+export function deserializeStringFieldTrusted_NAIVE(
+  payloadStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  const dstFieldPtr = dstObj + dstOffset;
+  let srcStart = payloadStart;
 
   // Scan for the closing quote without touching the scratch buffer. For the
   // common escape-free case the bytes are a verbatim slice of the source, so we
@@ -238,6 +227,6 @@ export function deserializeStringField_NAIVE<T extends string | null>(
     srcStart += 2;
   }
 
-  abort("Expected closing quote");
+  markProductionParseError();
   return 0;
 }