json-as 1.3.9 → 1.5.0

package/assembly/deserialize/naive/object.ts

@@ -1,7 +1,5 @@
 import { JSON } from "../..";
-import { bs } from "../../../lib/as-bs";
 import {
-  BACK_SLASH,
   COMMA,
   CHAR_F,
   BRACE_LEFT,
@@ -13,29 +11,54 @@ import {
   CHAR_T,
   COLON,
 } from "../../custom/chars";
-import { isSpace, isUnescapedQuote, scanStringEnd } from "../../util";
-import { ptrToStr } from "../../util/ptrToStr";
-import { deserializeArray } from "./array";
-import { deserializeBoolean } from "./bool";
-import { deserializeFloat_NAIVE } from "./float";
-import { deserializeString_NAIVE } from "./string";
+import { isSpace, scanStringEnd } from "../../util";
+import { deserializeFloat } from "../index/float";
+import { deserializeString } from "../index/string";
+
+// "true"  as a u64 of UTF-16 code units (LE).
+const TRUE_WORD: u64 = 28429475166421108;
+// "alse"  - the tail of "false", read at +2 so the leading 'f' is skipped.
+const ALSE_WORD: u64 = 28429466576093281;
+// "null"  as a u64 of UTF-16 code units (LE).
+const NULL_WORD: u64 = 30399761348886638;
+
+// End offset (just past the value) of the most recent parseValue() call. The
+// recursive-descent parser reports each value's end through this single cursor
+// so containers can resume after a child without a separate bounds scan. It is
+// only read immediately after parseValue() returns, before any other
+// parseValue() runs, so recursion never clobbers a still-needed value.
+let parseValueEnd: usize = 0;
+
+// Source string for the parse currently in flight. When non-empty, nested
+// objects/arrays are deferred: instead of being recursively materialized, each
+// is stored as a lazy JSON.Value holding its raw slice + this anchor (see
+// JSON.Value.fromSlice / JSON.Types.Lazy). Set at the top of JSON.parse (and in
+// JSON.Value.materialize), both of which save/restore it for re-entrancy, so any
+// lazy value built during a parse points into that parse's own source buffer.
+let parseSrc: string = "";
+export function setParseSrc(s: string): void {
+  parseSrc = s;
+}
+export function getParseSrc(): string {
+  return parseSrc;
+}
 
 export function deserializeObject(
   srcStart: usize,
   srcEnd: usize,
   dst: usize,
 ): JSON.Obj {
-  const out = changetype<JSON.Obj>(dst || changetype<usize>(new JSON.Obj()));
-
-  let keyStart: usize = 0;
-  let keyEnd: usize = 0;
-  let isKey = false;
-  let depth = 0;
-  let lastIndex: usize = 0;
+  const reuse = dst != 0;
+  const out = changetype<JSON.Obj>(
+    reuse ? dst : changetype<usize>(new JSON.Obj()),
+  );
+  // Reuse path (`JSON.parse<JSON.Obj>(data, out)`): empty the handle first,
+  // keeping its buffer capacity, so we overwrite rather than append stale data.
+  if (reuse) out.clear();
 
-  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2; // would like to optimize this later
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
 
-  if (srcStart - srcEnd == 0)
+  if (srcEnd == srcStart)
     throw new Error("Input string had zero length or was all whitespace");
   if (load<u16>(srcStart) != BRACE_LEFT)
     throw new Error(
@@ -48,166 +71,260 @@ export function deserializeObject(
         (srcEnd - srcStart).toString(),
     );
 
-  srcStart += 2;
+  parseObjectBody(out, srcStart + 2, srcEnd);
+  return out;
+}
+
+export function deserializeJsonArray(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): JSON.Arr {
+  const reuse = dst != 0;
+  const out = changetype<JSON.Arr>(
+    reuse ? dst : changetype<usize>(new JSON.Arr()),
+  );
+  if (reuse) out.clear();
+
+  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");
+
+  parseArrayBodySlots(out, srcStart + 2, srcEnd);
+  return out;
+}
+
+/**
+ * Parses array elements starting at `srcStart` (just past the opening `[`) into
+ * a JSON.Arr's NaN-boxed value slots, returning the offset just after the
+ * matching `]`. Mirrors {@link parseObjectBody} without keys.
+ */
+export function parseArrayBodySlots(
+  out: JSON.Arr,
+  srcStart: usize,
+  srcEnd: usize,
+): usize {
+  out._src = parseSrc;
   while (srcStart < srcEnd) {
-    let code = load<u16>(srcStart); // while (isSpace(code)) code = load<u16>(srcStart += 2);
-    if (keyStart == 0) {
-      if (code == QUOTE && isUnescapedQuote(srcStart)) {
-        if (isKey) {
-          keyStart = lastIndex;
-          keyEnd = srcStart;
-          // console.log("Key: " + ptrToStr(lastIndex, srcStart));
-          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart + 2)));
-          while (isSpace((code = load<u16>((srcStart += 2))))) {}
-          if (code !== COLON)
-            throw new Error(
-              "Expected ':' after key at position " +
-                (srcEnd - srcStart).toString(),
-            );
-          isKey = false;
-        } else {
-          // console.log("Got key start");
-          isKey = true; // i don't like this
-          lastIndex = srcStart + 2;
-        }
-      }
-      // isKey = !isKey;
+    const code = load<u16>(srcStart);
+    if (isSpace(code) || code == COMMA) {
       srcStart += 2;
+      continue;
+    }
+    if (code == BRACKET_RIGHT) return srcStart + 2;
+    if (parseSrc.length != 0) {
+      out.pushRawSlot(parseSlotBits(srcStart, srcEnd));
     } else {
-      if (code == QUOTE) {
-        lastIndex = srcStart;
-        srcStart = scanStringEnd(srcStart, srcEnd);
-        if (srcStart >= srcEnd)
-          throw new Error("Unterminated string in JSON object");
-        out.set(
-          ptrToStr(keyStart, keyEnd),
-          deserializeString_NAIVE(lastIndex, srcStart + 2),
-        );
-        srcStart += 2;
-        keyStart = 0;
-        continue;
-      } else if (code - 48 <= 9 || code == 45) {
-        lastIndex = srcStart;
-        srcStart += 2;
-        while (srcStart < srcEnd) {
-          const code = load<u16>(srcStart);
-          if (code == COMMA || code == BRACE_RIGHT || isSpace(code)) {
-            // console.log("Value (number): " + ptrToStr(lastIndex, srcStart));
-            out.set(
-              ptrToStr(keyStart, keyEnd),
-              deserializeFloat_NAIVE<f64>(lastIndex, srcStart),
-            );
-            // while (isSpace(load<u16>((srcStart += 2)))) {
-            //   /* empty */
-            // }
-            srcStart += 2;
-            // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
-            keyStart = 0;
-            break;
-          }
-          srcStart += 2;
-        }
-      } else if (code == BRACE_LEFT) {
-        lastIndex = srcStart;
-        depth++;
-        srcStart += 2;
-        while (srcStart < srcEnd) {
-          const code = load<u16>(srcStart);
-          if (code == QUOTE) {
-            srcStart = scanStringEnd(srcStart, srcEnd);
-            if (srcStart >= srcEnd)
-              throw new Error("Unterminated string in JSON object");
-          } else if (code == BRACE_RIGHT) {
-            if (--depth == 0) {
-              // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
-              out.set(
-                ptrToStr(keyStart, keyEnd),
-                deserializeObject(lastIndex, (srcStart += 2), 0),
-              );
-              // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
-              keyStart = 0;
-              // while (isSpace(load<u16>(srcStart))) {
-              //   /* empty */
-              // }
-              break;
-            }
-          } else if (code == BRACE_LEFT) depth++;
-          srcStart += 2;
-        }
-      } else if (code == BRACKET_LEFT) {
-        lastIndex = srcStart;
-        depth++;
-        srcStart += 2;
-        while (srcStart < srcEnd) {
-          const code = load<u16>(srcStart);
-          if (code == QUOTE) {
-            srcStart = scanStringEnd(srcStart, srcEnd);
-            if (srcStart >= srcEnd)
-              throw new Error("Unterminated string in JSON object");
-          } else if (code == BRACKET_RIGHT) {
-            if (--depth == 0) {
-              // console.log("Value (array): " + ptrToStr(lastIndex, srcStart + 2));
-              out.set(
-                ptrToStr(keyStart, keyEnd),
-                deserializeArray<JSON.Value[]>(lastIndex, (srcStart += 2), 0),
-              );
-              // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
-              keyStart = 0;
-              // while (isSpace(load<u16>((srcStart += 2)))) {
-              //   /* empty */
-              // }
-              break;
-            }
-          } else if (code == BRACKET_LEFT) depth++;
-          srcStart += 2;
-        }
-      } else if (code == CHAR_T) {
-        if (load<u64>(srcStart) == 28429475166421108) {
-          // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 8));
-          out.set(ptrToStr(keyStart, keyEnd), true);
-          srcStart += 8;
-          // while (isSpace(load<u16>((srcStart += 2)))) {
-          //   /* empty */
-          // }
-          srcStart += 2;
-          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)) + "  " + (srcStart < srcEnd).toString());
-          keyStart = 0;
-        }
-      } else if (code == CHAR_F) {
-        if (load<u64>(srcStart, 2) == 28429466576093281) {
-          // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 10));
-          out.set(ptrToStr(keyStart, keyEnd), false);
-          srcStart += 10;
-          // while (isSpace(load<u16>((srcStart += 2)))) {
-          //   /* empty */
-          // }
-          srcStart += 2;
-          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
-          keyStart = 0;
-        }
-      } else if (code == CHAR_N) {
-        if (load<u64>(srcStart) == 30399761348886638) {
-          // console.log("Value (null): " + ptrToStr(srcStart, srcStart + 8));
-          out.set(ptrToStr(keyStart, keyEnd), JSON.Value.from<usize>(0));
-          srcStart += 8;
-          // while (isSpace(load<u16>((srcStart += 2)))) {
-          /* empty */
-          // }
-          srcStart += 2;
-          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
-          keyStart = 0;
-        }
-      } else if (isSpace(code)) {
-        srcStart += 2;
-      } else {
-        throw new Error(
-          "Unexpected character in JSON object '" +
-            String.fromCharCode(code) +
-            "' at position " +
-            (srcEnd - srcStart).toString(),
-        );
-      }
+      out.pushRawSlot(
+        JSON.Value.bitsFrom<JSON.Value>(parseValue(srcStart, srcEnd)),
+      );
     }
+    srcStart = parseValueEnd;
   }
-  return out;
+  return srcEnd;
+}
+
+/**
+ * Parses a single object-member value into a NaN-boxed value slot, setting
+ * {@link parseValueEnd} to the offset just past it. Strings and composites are
+ * deferred (a `valBox(Lazy, startPtr)` slice the object parses on first access);
+ * numbers, booleans and null are parsed eagerly inline. Requires {@link parseSrc}
+ * to be set (the caller guards), since a lazy slot points into it.
+ */
+function parseSlotBits(srcStart: usize, srcEnd: usize): u64 {
+  const code = load<u16>(srcStart);
+  if (code == QUOTE || code == BRACE_LEFT || code == BRACKET_LEFT) {
+    const end = JSON.Util.scanValueEnd<JSON.Value>(srcStart, srcEnd);
+    parseValueEnd = end;
+    return JSON.Value.lazyBits(changetype<usize>(parseSrc), srcStart, end);
+  } else if (code - 48 <= 9 || code == 45) {
+    let p = srcStart + 2;
+    while (p < srcEnd) {
+      const c = load<u16>(p);
+      if (c == COMMA || c == BRACKET_RIGHT || c == BRACE_RIGHT || isSpace(c))
+        break;
+      p += 2;
+    }
+    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");
+    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");
+    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");
+    parseValueEnd = srcStart + 8;
+    return JSON.Value.nullBits();
+  }
+  throw new Error(
+    "Unexpected character in JSON '" + String.fromCharCode(code) + "'",
+  );
+}
+
+/**
+ * Parses a single JSON value whose first character is at `srcStart` (`srcEnd`
+ * is an upper bound). Returns the value and sets {@link parseValueEnd} to the
+ * offset just after it. Nested objects and arrays recurse here, so every byte
+ * is scanned exactly once.
+ */
+/** Offset just past the value returned by the most recent {@link parseValue}. */
+export function lastValueEnd(): usize {
+  return parseValueEnd;
+}
+
+export function parseValue(srcStart: usize, srcEnd: usize): JSON.Value {
+  const code = load<u16>(srcStart);
+  if (code == QUOTE) {
+    const end = scanStringEnd(srcStart, srcEnd);
+    if (end >= srcEnd) throw new Error("Unterminated string in JSON");
+    parseValueEnd = end + 2;
+    return JSON.Value.from(deserializeString(srcStart, end + 2));
+  } else if (code == BRACE_LEFT) {
+    const obj = new JSON.Obj();
+    parseValueEnd = parseObjectBody(obj, srcStart + 2, srcEnd);
+    return JSON.Value.from(obj);
+  } else if (code == BRACKET_LEFT) {
+    const arr = new JSON.Arr();
+    parseValueEnd = parseArrayBodySlots(arr, srcStart + 2, srcEnd);
+    return JSON.Value.from(arr);
+  } else if (code - 48 <= 9 || code == 45) {
+    let p = srcStart + 2;
+    while (p < srcEnd) {
+      const c = load<u16>(p);
+      if (c == COMMA || c == BRACKET_RIGHT || c == BRACE_RIGHT || isSpace(c))
+        break;
+      p += 2;
+    }
+    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");
+    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");
+    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");
+    parseValueEnd = srcStart + 8;
+    return JSON.Value.from<usize>(0);
+  }
+  throw new Error(
+    "Unexpected character in JSON '" + String.fromCharCode(code) + "'",
+  );
+}
+
+/**
+ * Parses array elements starting at `srcStart` (just past the opening `[`)
+ * until the matching `]`, returning the offset just after that `]`. Nested
+ * values are parsed in the same pass.
+ */
+export function parseArrayBody(
+  out: JSON.Value[],
+  srcStart: usize,
+  srcEnd: usize,
+): usize {
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (isSpace(code) || code == COMMA) {
+      srcStart += 2;
+      continue;
+    }
+    if (code == BRACKET_RIGHT) return srcStart + 2;
+    if (
+      (code == BRACE_LEFT || code == BRACKET_LEFT || code == QUOTE) &&
+      parseSrc.length != 0
+    ) {
+      // 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);
+      out.push(JSON.Value.fromSlice(srcStart, end, parseSrc));
+      srcStart = end;
+    } else {
+      out.push(parseValue(srcStart, srcEnd));
+      srcStart = parseValueEnd;
+    }
+  }
+  return srcEnd;
+}
+
+/**
+ * Parses object members starting at `srcStart` (just past the opening `{`)
+ * until the matching `}`, returning the offset just after that `}`. `srcEnd`
+ * is an upper bound (end of the enclosing buffer), not the object's exact end.
+ */
+export function parseObjectBody(
+  out: JSON.Obj,
+  srcStart: usize,
+  srcEnd: usize,
+): usize {
+  // 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,
+  // where no lazy slots are produced.
+  out._src = parseSrc;
+  while (srcStart < srcEnd) {
+    let code = load<u16>(srcStart);
+
+    // Skip insignificant whitespace and member separators before each key.
+    if (isSpace(code) || code == COMMA) {
+      srcStart += 2;
+      continue;
+    }
+    if (code == BRACE_RIGHT) return srcStart + 2;
+
+    // --- key ---
+    if (code != QUOTE)
+      throw new Error(
+        "Unexpected character in JSON object '" +
+          String.fromCharCode(code) +
+          "' at position " +
+          (srcEnd - srcStart).toString(),
+      );
+    const keyStart = srcStart + 2;
+    srcStart = scanStringEnd(srcStart, srcEnd);
+    if (srcStart >= srcEnd)
+      throw new Error("Unterminated string in JSON object");
+    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(),
+      );
+    srcStart += 2;
+
+    // --- value ---
+    while (srcStart < srcEnd && isSpace((code = load<u16>(srcStart))))
+      srcStart += 2;
+    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));
+    } else {
+      // Off the parse path (no source anchor): box eagerly.
+      out.appendRaw(keyStart, keyEnd, parseValue(srcStart, srcEnd));
+    }
+    srcStart = parseValueEnd;
+  }
+  return srcEnd;
 }

package/assembly/deserialize/naive/raw.ts

@@ -1,10 +1,6 @@
 import { JSON } from "../..";
 import { ptrToStr } from "../../util/ptrToStr";
 
-// @ts-ignore: inline
-@inline export function deserializeRaw(
-  srcStart: usize,
-  srcEnd: usize,
-): JSON.Raw {
+export function deserializeRaw(srcStart: usize, srcEnd: usize): JSON.Raw {
   return JSON.Raw.from(ptrToStr(srcStart, srcEnd));
 }

package/assembly/deserialize/naive/set.ts

@@ -11,8 +11,7 @@ import {
 } from "../../custom/chars";
 import { isSpace, atoi, scanStringEnd } from "../../util";
 
-// @ts-expect-error: Decorator valid here
-@inline function scanSetElementEnd(srcStart: usize, srcEnd: usize): usize {
+function scanSetElementEnd(srcStart: usize, srcEnd: usize): usize {
   const first = load<u16>(srcStart);
 
   if (first == QUOTE) {
@@ -157,8 +156,7 @@ export function deserializeSet<T extends Set<any>>(
   return out;
 }
 
-// @ts-expect-error: Decorator valid here
-@inline function deserializeSetBody<T extends Set<any>>(
+function deserializeSetBody<T extends Set<any>>(
   srcStart: usize,
   srcEnd: usize,
   out: T,
@@ -167,8 +165,7 @@ export function deserializeSet<T extends Set<any>>(
   return deserializeSetDirect<T>(srcStart, srcEnd, changetype<nonnull<T>>(out));
 }
 
-// @ts-expect-error: Decorator valid here
-@inline export function deserializeSetField<T extends Set<any>>(
+export function deserializeSetField<T extends Set<any>>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

package/assembly/deserialize/naive/staticarray.ts

@@ -17,8 +17,7 @@ import { deserializeStaticArrayInteger } from "./staticarray/integer";
 import { deserializeStaticArrayString } from "./staticarray/string";
 import { scanValueEnd } from "../../util/scanValueEnd";
 
-
-@inline function materializeStaticArray<T extends StaticArray<any>>(
+function materializeStaticArray<T extends StaticArray<any>>(
   src: valueof<T>[],
   dst: usize,
 ): T {
@@ -113,8 +112,7 @@ export function deserializeStaticArray<T extends StaticArray<any>>(
   throw new Error("Could not parse static array of type " + nameof<T>() + "!");
 }
 
-
-@inline export function deserializeStaticArrayField<T extends StaticArray<any>>(
+export function deserializeStaticArrayField<T extends StaticArray<any>>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,