json-as 1.2.5 → 1.3.0

package/assembly/deserialize/swar/array/map.ts

@@ -0,0 +1,7 @@
+import { ensureArrayField } from "./shared";
+
+
+@inline export function deserializeMapArrayField<T extends Map<any, any>[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  ensureArrayField<T>(fieldPtr);
+  throw new Error("Failed to parse JSON!");
+}

package/assembly/deserialize/swar/array/object.ts

@@ -0,0 +1,44 @@
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
+import { ensureArrayElementSlot, ensureArrayField } from "./shared";
+
+
+@inline export function deserializeObjectArrayField<T extends unknown[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  const out = ensureArrayField<T>(fieldPtr);
+  let index = 0;
+
+  do {
+    if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
+    srcStart += 2;
+    if (srcStart >= srcEnd) break;
+    if (load<u16>(srcStart) == BRACKET_RIGHT) {
+      out.length = 0;
+      return srcStart + 2;
+    }
+
+    while (srcStart < srcEnd) {
+      const slot = ensureArrayElementSlot<T>(out, index);
+      let value = load<valueof<T>>(slot);
+      if (changetype<usize>(value) == 0) {
+        value = changetype<valueof<T>>(instantiate<nonnull<valueof<T>>>());
+        store<valueof<T>>(slot, value);
+      }
+
+      srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE<valueof<T>>(srcStart, srcEnd, value);
+      if (!srcStart || srcStart >= srcEnd) break;
+
+      const code = load<u16>(srcStart);
+      if (code == COMMA) {
+        srcStart += 2;
+        index++;
+        continue;
+      }
+      if (code == BRACKET_RIGHT) {
+        out.length = index + 1;
+        return srcStart + 2;
+      }
+      break;
+    }
+  } while (false);
+
+  throw new Error("Failed to parse JSON!");
+}

package/assembly/deserialize/swar/array/raw.ts

@@ -0,0 +1,8 @@
+import { JSON } from "../../..";
+import { ensureArrayField } from "./shared";
+
+
+@inline export function deserializeRawArrayField(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  ensureArrayField<JSON.Raw[]>(fieldPtr);
+  throw new Error("Failed to parse JSON!");
+}

package/assembly/deserialize/swar/array/shared.ts

@@ -0,0 +1,96 @@
+import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA, QUOTE } from "../../../custom/chars";
+
+
+@inline export function ensureArrayField<T extends Array<any>>(fieldPtr: usize): T {
+  let out = load<T>(fieldPtr);
+  if (!changetype<usize>(out)) {
+    out = changetype<T>(instantiate<T>());
+    store<T>(fieldPtr, out);
+  } else {
+    out.length = 0;
+  }
+  return out;
+}
+
+
+@inline function backslashOrQuoteMask(block: u64): u64 {
+  const b = block ^ 0x005c_005c_005c_005c;
+  const q = block ^ 0x0022_0022_0022_0022;
+  return (((q - 0x0001_0001_0001_0001) & ~q) | ((b - 0x0001_0001_0001_0001) & ~b)) & 0x0080_0080_0080_0080;
+}
+
+
+@inline export function ensureArrayElementSlot<T extends Array<any>>(out: T, index: i32): usize {
+  const nextLength = index + 1;
+  if (out.length < nextLength) out.length = nextLength;
+  return out.dataStart + <usize>index * sizeof<valueof<T>>();
+}
+
+
+@inline export function scanQuotedValueEnd_SWAR(srcStart: usize, srcEnd: usize): usize {
+  srcStart += 2;
+  const srcEnd8 = srcEnd >= 8 ? srcEnd - 8 : 0;
+
+  while (srcStart <= srcEnd8) {
+    let mask = inline.always(backslashOrQuoteMask(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) return srcIdx + 2;
+      if (char == BACK_SLASH) break;
+    } while (mask !== 0);
+
+    break;
+  }
+
+  while (srcStart < srcEnd) {
+    const char = load<u16>(srcStart);
+    if (char == QUOTE && load<u16>(srcStart - 2) != BACK_SLASH) return srcStart + 2;
+    srcStart += 2;
+  }
+
+  return 0;
+}
+
+
+@inline export function scanValueEnd(srcStart: usize, srcEnd: usize): usize {
+  if (srcStart >= srcEnd) return 0;
+  const first = load<u16>(srcStart);
+
+  if (first == QUOTE) return scanQuotedValueEnd_SWAR(srcStart, srcEnd);
+
+  if (first == BRACE_LEFT || first == BRACKET_LEFT) {
+    let depth: i32 = 1;
+    let ptr = srcStart + 2;
+    while (ptr < srcEnd) {
+      const code = load<u16>(ptr);
+      if (code == QUOTE) {
+        ptr = scanQuotedValueEnd_SWAR(ptr, srcEnd);
+        if (!ptr) return 0;
+        continue;
+      }
+      if (code == BRACE_LEFT || code == BRACKET_LEFT) {
+        depth++;
+      } else if (code == BRACE_RIGHT || code == BRACKET_RIGHT) {
+        if (--depth == 0) return ptr + 2;
+      }
+      ptr += 2;
+    }
+    return 0;
+  }
+
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == COMMA || code == BRACKET_RIGHT) return srcStart;
+    srcStart += 2;
+  }
+
+  return 0;
+}

package/assembly/deserialize/swar/array/string.ts

@@ -0,0 +1,39 @@
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
+import { ensureArrayElementSlot, ensureArrayField } from "./shared";
+import { deserializeStringField_SWAR } from "../string";
+
+
+@inline export function deserializeStringArrayField<T extends string[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  const out = ensureArrayField<T>(fieldPtr);
+  let index = 0;
+
+  do {
+    if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
+    srcStart += 2;
+    if (srcStart >= srcEnd) break;
+    if (load<u16>(srcStart) == BRACKET_RIGHT) {
+      out.length = 0;
+      return srcStart + 2;
+    }
+
+    while (srcStart < srcEnd) {
+      const slot = ensureArrayElementSlot<T>(out, index);
+      srcStart = deserializeStringField_SWAR<valueof<T>>(srcStart, srcEnd, slot);
+      if (!srcStart || srcStart >= srcEnd) break;
+
+      const code = load<u16>(srcStart);
+      if (code == COMMA) {
+        srcStart += 2;
+        index++;
+        continue;
+      }
+      if (code == BRACKET_RIGHT) {
+        out.length = index + 1;
+        return srcStart + 2;
+      }
+      break;
+    }
+  } while (false);
+
+  throw new Error("Failed to parse JSON!");
+}

package/assembly/deserialize/swar/array/struct.ts

@@ -0,0 +1,44 @@
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
+import { ensureArrayElementSlot, ensureArrayField } from "./shared";
+
+
+@inline export function deserializeStructArrayField<T extends unknown[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  const out = ensureArrayField<T>(fieldPtr);
+  let index = 0;
+
+  do {
+    if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
+    srcStart += 2;
+    if (srcStart >= srcEnd) break;
+    if (load<u16>(srcStart) == BRACKET_RIGHT) {
+      out.length = 0;
+      return srcStart + 2;
+    }
+
+    while (srcStart < srcEnd) {
+      const slot = ensureArrayElementSlot<T>(out, index);
+      let value = load<valueof<T>>(slot);
+      if (changetype<usize>(value) == 0) {
+        value = changetype<valueof<T>>(instantiate<nonnull<valueof<T>>>());
+        store<valueof<T>>(slot, value);
+      }
+
+      srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE<valueof<T>>(srcStart, srcEnd, value);
+      if (!srcStart || srcStart >= srcEnd) break;
+
+      const code = load<u16>(srcStart);
+      if (code == COMMA) {
+        srcStart += 2;
+        index++;
+        continue;
+      }
+      if (code == BRACKET_RIGHT) {
+        out.length = index + 1;
+        return srcStart + 2;
+      }
+      break;
+    }
+  } while (false);
+
+  throw new Error("Failed to parse JSON!");
+}

package/assembly/deserialize/swar/array.ts

@@ -0,0 +1,49 @@
+import { JSON } from "../..";
+import { deserializeArbitraryArrayField } from "./array/arbitrary";
+import { deserializeArrayArrayField } from "./array/array";
+import { deserializeBooleanArrayField } from "./array/bool";
+import { deserializeBoxArrayField } from "./array/box";
+import { deserializeFloatArrayField } from "./array/float";
+import { deserializeIntegerArrayField } from "./array/integer";
+import { deserializeMapArrayField } from "./array/map";
+import { deserializeObjectArrayField } from "./array/object";
+import { deserializeRawArrayField } from "./array/raw";
+import { deserializeStringArrayField } from "./array/string";
+import { deserializeStructArrayField } from "./array/struct";
+
+
+@inline export function deserializeArrayField<T extends unknown[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  if (isString<valueof<T>>()) {
+    return deserializeStringArrayField<T>(srcStart, srcEnd, fieldPtr);
+  } else if (isBoolean<valueof<T>>()) {
+    return deserializeBooleanArrayField<T>(srcStart, srcEnd, fieldPtr);
+  } else if (isInteger<valueof<T>>()) {
+    return deserializeIntegerArrayField<T>(srcStart, srcEnd, fieldPtr);
+  } else if (isFloat<valueof<T>>()) {
+    return deserializeFloatArrayField<T>(srcStart, srcEnd, fieldPtr);
+  } else if (isArray<valueof<T>>()) {
+    return deserializeArrayArrayField<T>(srcStart, srcEnd, fieldPtr);
+  } else if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
+    const type = changetype<nonnull<valueof<T>>>(0);
+    if (type instanceof JSON.Value) {
+      return deserializeArbitraryArrayField(srcStart, srcEnd, fieldPtr);
+    } else if (type instanceof JSON.Box) {
+      return deserializeBoxArrayField<T>(srcStart, srcEnd, fieldPtr);
+    } else if (type instanceof JSON.Obj) {
+      return deserializeObjectArrayField<T>(srcStart, srcEnd, fieldPtr);
+    } else if (type instanceof JSON.Raw) {
+      return deserializeRawArrayField(srcStart, srcEnd, fieldPtr);
+    } else if (type instanceof Map) {
+      return deserializeMapArrayField<T>(srcStart, srcEnd, fieldPtr);
+      // @ts-ignore: defined by transform
+    } else if (isDefined(type.__DESERIALIZE_CUSTOM)) {
+      return deserializeStructArrayField<T>(srcStart, srcEnd, fieldPtr);
+      // @ts-ignore: defined by transform
+    } else if (isDefined(type.__DESERIALIZE)) {
+      return deserializeStructArrayField<T>(srcStart, srcEnd, fieldPtr);
+    }
+    throw new Error("Could not parse array field of type " + nameof<T>() + "!");
+  } else {
+    throw new Error("Could not parse array field of type " + nameof<T>() + "!");
+  }
+}