json-as 1.2.6 → 1.3.1

package/assembly/deserialize/index/arbitrary.ts

@@ -0,0 +1,25 @@
+import { JSON } from "../..";
+import { deserializeArray } from "./array";
+import { deserializeBoolean } from "./bool";
+import { deserializeFloat } from "./float";
+import { deserializeObject } from "./object";
+import { deserializeString } from "./string";
+import { BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE } from "../../custom/chars";
+
+export function deserializeArbitrary(srcStart: usize, srcEnd: usize, dst: usize): JSON.Value {
+  const firstChar = load<u16>(srcStart);
+  if (firstChar == QUOTE) {
+    return JSON.Value.from(deserializeString(srcStart, srcEnd));
+  } else if (firstChar == BRACE_LEFT) {
+    return JSON.Value.from(deserializeObject(srcStart, srcEnd, 0));
+  } else if (firstChar - 48 <= 9 || firstChar == 45) {
+    return JSON.Value.from(deserializeFloat<f64>(srcStart, srcEnd));
+  } else if (firstChar == BRACKET_LEFT) {
+    return JSON.Value.from(deserializeArray<JSON.Value[]>(srcStart, srcEnd, 0));
+  } else if (firstChar == 116 || firstChar == 102) {
+    return JSON.Value.from(deserializeBoolean(srcStart, srcEnd));
+  } else if (firstChar == CHAR_N) {
+    return JSON.Value.from<usize>(0);
+  }
+  return unreachable();
+}

package/assembly/deserialize/index/array.ts

@@ -0,0 +1,61 @@
+import { JSON, JSONMode } from "../..";
+import { deserializeArbitraryArray } from "../simple/array/arbitrary";
+import { deserializeArrayArray } from "../simple/array/array";
+import { deserializeBooleanArray } from "../simple/array/bool";
+import { deserializeBoxArray } from "../simple/array/box";
+import { deserializeFloatArray } from "../simple/array/float";
+import { deserializeIntegerArray as deserializeIntegerArray_NAIVE } from "../simple/array/integer";
+import { deserializeMapArray } from "../simple/array/map";
+import { deserializeObjectArray } from "../simple/array/object";
+import { deserializeRawArray } from "../simple/array/raw";
+import { deserializeStringArray } from "../simple/array/string";
+import { deserializeStructArray } from "../simple/array/struct";
+import { deserializeIntegerArray_SIMD } from "../simd/array/integer";
+import { deserializeIntegerArray_SWAR } from "../swar/array/integer";
+
+export { deserializeArrayField, deserializeArrayField as deserializeArrayField_SWAR } from "../swar/array";
+
+export function deserializeArray<T extends unknown[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  if (isString<valueof<T>>()) {
+    return <T>deserializeStringArray(srcStart, srcEnd, dst);
+  } else if (isBoolean<valueof<T>>()) {
+    return deserializeBooleanArray<T>(srcStart, srcEnd, dst);
+  } else if (isInteger<valueof<T>>()) {
+    if (JSON_MODE == JSONMode.SIMD) {
+      // @ts-ignore: integer array branch
+      return deserializeIntegerArray_SIMD<T>(srcStart, srcEnd, dst);
+    } else if (JSON_MODE == JSONMode.SWAR) {
+      // @ts-ignore: integer array branch
+      return deserializeIntegerArray_SWAR<T>(srcStart, srcEnd, dst);
+    } else {
+      // @ts-ignore: integer array branch
+      return deserializeIntegerArray_NAIVE<T>(srcStart, srcEnd, dst);
+    }
+  } else if (isFloat<valueof<T>>()) {
+    return deserializeFloatArray<T>(srcStart, srcEnd, dst);
+  } else if (isArray<valueof<T>>()) {
+    return deserializeArrayArray<T>(srcStart, srcEnd, dst);
+  } else if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
+    const type = changetype<nonnull<valueof<T>>>(0);
+    if (type instanceof JSON.Value) {
+      return deserializeArbitraryArray(srcStart, srcEnd, dst) as T;
+    } else if (type instanceof JSON.Box) {
+      return deserializeBoxArray<T>(srcStart, srcEnd, dst);
+    } else if (type instanceof JSON.Obj) {
+      return deserializeObjectArray<T>(srcStart, srcEnd, dst);
+    } else if (type instanceof JSON.Raw) {
+      return deserializeRawArray(srcStart, srcEnd, dst) as T;
+    } else if (type instanceof Map) {
+      return deserializeMapArray<T>(srcStart, srcEnd, dst);
+      // @ts-ignore: defined by transform
+    } else if (isDefined(type.__DESERIALIZE_CUSTOM)) {
+      return deserializeStructArray<T>(srcStart, srcEnd, dst);
+      // @ts-ignore: defined by transform
+    } else if (isDefined(type.__DESERIALIZE)) {
+      return deserializeStructArray<T>(srcStart, srcEnd, dst);
+    }
+    throw new Error("Could not parse array of type " + nameof<T>() + "!");
+  } else {
+    throw new Error("Could not parse array of type " + nameof<T>() + "!");
+  }
+}

package/assembly/deserialize/index/bool.ts

@@ -0,0 +1 @@
+export { deserializeBoolean } from "../simple/bool";

package/assembly/deserialize/index/date.ts

@@ -0,0 +1 @@
+export { deserializeDate } from "../simple/date";

package/assembly/deserialize/index/float.ts

@@ -0,0 +1 @@
+export { deserializeFloat } from "../float";

package/assembly/deserialize/index/integer.ts

@@ -0,0 +1 @@
+export { deserializeInteger } from "../integer";

package/assembly/deserialize/index/map.ts

@@ -0,0 +1 @@
+export { deserializeMap } from "../simple/map";

package/assembly/deserialize/index/object.ts

@@ -0,0 +1 @@
+export { deserializeObject } from "../simple/object";

package/assembly/deserialize/index/raw.ts

@@ -0,0 +1 @@
+export { deserializeRaw } from "../simple/raw";

package/assembly/deserialize/index/set.ts

@@ -0,0 +1 @@
+export { deserializeSet } from "../simple/set";

package/assembly/deserialize/index/staticarray.ts

@@ -0,0 +1 @@
+export { deserializeStaticArray } from "../simple/staticarray";

package/assembly/deserialize/index/string.ts

@@ -0,0 +1,15 @@
+import { JSONMode } from "../..";
+import { deserializeString as deserializeString_NAIVE } from "../simple/string";
+import { deserializeString_SIMD } from "../simd/string";
+import { deserializeString_SWAR } from "../swar/string";
+
+
+@inline export function deserializeString(srcStart: usize, srcEnd: usize): string {
+  if (JSON_MODE == JSONMode.SIMD) {
+    return deserializeString_SIMD(srcStart, srcEnd);
+  } else if (JSON_MODE == JSONMode.NAIVE) {
+    return deserializeString_NAIVE(srcStart, srcEnd);
+  } else {
+    return deserializeString_SWAR(srcStart, srcEnd);
+  }
+}

package/assembly/deserialize/index/struct.ts

@@ -0,0 +1 @@
+export { deserializeStruct } from "../simple/struct";

package/assembly/deserialize/index/typedarray.ts

@@ -0,0 +1,15 @@
+import { bytes } from "../../util";
+export { deserializeArrayBuffer, deserializeTypedArray } from "../simple/typedarray";
+import { deserializeArrayBuffer, deserializeTypedArray } from "../simple/typedarray";
+
+
+@inline export function parseArrayBuffer(data: string): ArrayBuffer {
+  const dataSize = bytes(data);
+  const dataPtr = changetype<usize>(data);
+  return deserializeArrayBuffer(dataPtr, dataPtr + dataSize, 0);
+}
+
+
+@inline export function __deserializeArrayBuffer(srcStart: usize, srcEnd: usize, dst: usize = 0): ArrayBuffer {
+  return deserializeArrayBuffer(srcStart, srcEnd, dst);
+}

package/assembly/deserialize/index/unsigned.ts

@@ -0,0 +1 @@
+export { deserializeUnsigned } from "../unsigned";

package/assembly/deserialize/index.ts

@@ -0,0 +1,14 @@
+export * from "./index/arbitrary";
+export * from "./index/array";
+export * from "./index/bool";
+export * from "./index/date";
+export * from "./index/float";
+export * from "./index/integer";
+export * from "./index/map";
+export * from "./index/object";
+export * from "./index/raw";
+export * from "./index/set";
+export * from "./index/staticarray";
+export * from "./index/string";
+export * from "./index/struct";
+export * from "./index/unsigned";

package/assembly/deserialize/integer.ts

@@ -0,0 +1,42 @@
+import { atoi } from "../util/atoi";
+
+// @ts-ignore: inline
+@inline export function deserializeInteger<T>(srcStart: usize, srcEnd: usize): T {
+  return atoi<T>(srcStart, srcEnd);
+}
+
+// @ts-ignore: inline
+@inline export function deserializeIntegerField<T extends number>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  let negative = false;
+  if (load<u16>(srcStart) == 45) {
+    negative = true;
+    srcStart += 2;
+    if (srcStart >= srcEnd) unreachable();
+  }
+
+  let digit = <u32>load<u16>(srcStart) - 48;
+  if (digit > 9) unreachable();
+
+  let value: u64 = digit;
+  srcStart += 2;
+  while (srcStart < srcEnd) {
+    digit = <u32>load<u16>(srcStart) - 48;
+    if (digit > 9) break;
+    value = value * 10 + digit;
+    srcStart += 2;
+  }
+
+  if (sizeof<T>() == sizeof<i8>()) {
+    store<i8>(fieldPtr, negative ? -(<i8>value) : <i8>value);
+  } else if (sizeof<T>() == sizeof<i16>()) {
+    store<i16>(fieldPtr, negative ? -(<i16>value) : <i16>value);
+  } else if (sizeof<T>() == sizeof<i32>()) {
+    store<i32>(fieldPtr, negative ? -(<i32>value) : <i32>value);
+  } else if (sizeof<T>() == sizeof<isize>()) {
+    store<isize>(fieldPtr, negative ? -(<isize>value) : <isize>value);
+  } else {
+    store<i64>(fieldPtr, negative ? -(<i64>value) : <i64>value);
+  }
+
+  return srcStart;
+}

package/assembly/deserialize/simd/array/integer.ts

@@ -0,0 +1,307 @@
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
+import { deserializeIntegerArray_SLOW } from "../../swar/array/integer";
+
+const ASCII_LANE_MASK_4: u64 = 0x00ff00ff00ff00ff;
+const ASCII_ZERO_4: u64 = 0x0030003000300030;
+
+
+@lazy const SPLAT_30 = i16x8.splat(0x30);
+
+
+@lazy const SPLAT_09 = i16x8.splat(9);
+
+
+@lazy const ZERO_I16X8 = i16x8.splat(0);
+
+
+@lazy const ZERO_I32X4 = i32x4.splat(0);
+
+
+@lazy const PACK_WEIGHTS_10_1 = i8x16(10, 1, 10, 1, 10, 1, 10, 1, 0, 0, 0, 0, 0, 0, 0, 0);
+
+
+@lazy const PAIR_WEIGHTS_100_1 = i16x8(100, 1, 100, 1, 0, 0, 0, 0);
+
+
+@inline function pushSignedInteger<T extends number[]>(out: T, value: i64): void {
+  if (sizeof<valueof<T>>() == sizeof<i8>()) {
+    out.push(<valueof<T>>(<i8>value));
+  } else if (sizeof<valueof<T>>() == sizeof<i16>()) {
+    out.push(<valueof<T>>(<i16>value));
+  } else if (sizeof<valueof<T>>() == sizeof<i32>()) {
+    out.push(<valueof<T>>(<i32>value));
+  } else if (sizeof<valueof<T>>() == sizeof<isize>()) {
+    out.push(<valueof<T>>(<isize>value));
+  } else {
+    out.push(<valueof<T>>value);
+  }
+}
+
+
+@inline function pushUnsignedInteger<T extends number[]>(out: T, value: u64): void {
+  if (sizeof<valueof<T>>() == sizeof<u8>()) {
+    out.push(<valueof<T>>(<u8>value));
+  } else if (sizeof<valueof<T>>() == sizeof<u16>()) {
+    out.push(<valueof<T>>(<u16>value));
+  } else if (sizeof<valueof<T>>() == sizeof<u32>()) {
+    out.push(<valueof<T>>(<u32>value));
+  } else if (sizeof<valueof<T>>() == sizeof<usize>()) {
+    out.push(<valueof<T>>(<usize>value));
+  } else {
+    out.push(<valueof<T>>value);
+  }
+}
+
+
+@inline function storeSignedInteger<T extends number[]>(slot: usize, value: i64): void {
+  if (sizeof<valueof<T>>() == sizeof<i8>()) {
+    store<i8>(slot, <i8>value);
+  } else if (sizeof<valueof<T>>() == sizeof<i16>()) {
+    store<i16>(slot, <i16>value);
+  } else if (sizeof<valueof<T>>() == sizeof<i32>()) {
+    store<i32>(slot, <i32>value);
+  } else if (sizeof<valueof<T>>() == sizeof<isize>()) {
+    store<isize>(slot, <isize>value);
+  } else {
+    store<i64>(slot, value);
+  }
+}
+
+
+@inline function storeUnsignedInteger<T extends number[]>(slot: usize, value: u64): void {
+  if (sizeof<valueof<T>>() == sizeof<u8>()) {
+    store<u8>(slot, <u8>value);
+  } else if (sizeof<valueof<T>>() == sizeof<u16>()) {
+    store<u16>(slot, <u16>value);
+  } else if (sizeof<valueof<T>>() == sizeof<u32>()) {
+    store<u32>(slot, <u32>value);
+  } else if (sizeof<valueof<T>>() == sizeof<usize>()) {
+    store<usize>(slot, <usize>value);
+  } else {
+    store<u64>(slot, value);
+  }
+}
+
+
+@inline function tryParseEightDigitsSIMD(srcStart: usize, value: u64): u64 {
+  const block = load<v128>(srcStart);
+  const digits = i16x8.sub(block, SPLAT_30);
+  if (v128.any_true(i16x8.gt_u(digits, SPLAT_09))) return 0;
+
+  const packed = i8x16.narrow_i16x8_u(digits, ZERO_I16X8);
+  const products = i16x8.extmul_low_i8x16_u(packed, PACK_WEIGHTS_10_1);
+  const pairs = i32x4.extadd_pairwise_i16x8_u(products);
+  const pairs16 = i16x8.narrow_i32x4_u(pairs, ZERO_I32X4);
+  const groups = i32x4.dot_i16x8_s(pairs16, PAIR_WEIGHTS_100_1);
+
+  const lo = i32x4.extract_lane(groups, 0);
+  const hi = i32x4.extract_lane(groups, 1);
+  return value * 100000000 + (<u64>lo * 10000 + <u64>hi);
+}
+
+
+@inline function parseSignedIntegerSIMD<T extends number[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+  let negative = false;
+  let code = load<u16>(srcStart);
+  if (code == 45) {
+    negative = true;
+    srcStart += 2;
+    if (srcStart >= srcEnd) return 0;
+    code = load<u16>(srcStart);
+  }
+
+  let digit = <u32>code - 48;
+  if (digit > 9) return 0;
+
+  let value: u64 = digit;
+  srcStart += 2;
+
+  while (srcStart + 14 < srcEnd) {
+    const next = tryParseEightDigitsSIMD(srcStart, value);
+    if (!next) break;
+    value = next;
+    srcStart += 16;
+  }
+
+  while (srcStart < srcEnd) {
+    digit = <u32>load<u16>(srcStart) - 48;
+    if (digit > 9) break;
+    value = value * 10 + digit;
+    srcStart += 2;
+  }
+
+  pushSignedInteger<T>(out, negative ? -(<i64>value) : <i64>value);
+  return srcStart;
+}
+
+
+@inline function parseUnsignedIntegerSIMD<T extends number[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+  let digit = <u32>load<u16>(srcStart) - 48;
+  if (digit > 9) return 0;
+
+  let value: u64 = digit;
+  srcStart += 2;
+
+  while (srcStart + 14 < srcEnd) {
+    const next = tryParseEightDigitsSIMD(srcStart, value);
+    if (!next) break;
+    value = next;
+    srcStart += 16;
+  }
+
+  while (srcStart < srcEnd) {
+    digit = <u32>load<u16>(srcStart) - 48;
+    if (digit > 9) break;
+    value = value * 10 + digit;
+    srcStart += 2;
+  }
+
+  pushUnsignedInteger<T>(out, value);
+  return srcStart;
+}
+
+// @ts-ignore: Decorator valid here
+export function deserializeIntegerArray_SIMD<T extends number[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+  const originalSrcStart = srcStart;
+  const reusableLength = out.length;
+
+  if (reusableLength != 0) {
+    const dataStart = out.dataStart;
+    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 out;
+      }
+
+      if (isSigned<valueof<T>>()) {
+        while (srcStart < srcEnd) {
+          let negative = false;
+          let code = load<u16>(srcStart);
+          if (code == 45) {
+            negative = true;
+            srcStart += 2;
+            if (srcStart >= srcEnd) break;
+            code = load<u16>(srcStart);
+          }
+
+          let digit = <u32>code - 48;
+          if (digit > 9) break;
+
+          let value: u64 = digit;
+          srcStart += 2;
+          while (srcStart + 14 < srcEnd) {
+            const next = tryParseEightDigitsSIMD(srcStart, value);
+            if (!next) break;
+            value = next;
+            srcStart += 16;
+          }
+          while (srcStart < srcEnd) {
+            digit = <u32>load<u16>(srcStart) - 48;
+            if (digit > 9) break;
+            value = value * 10 + digit;
+            srcStart += 2;
+          }
+
+          if (index >= reusableLength) break;
+          storeSignedInteger<T>(dataStart + <usize>index * sizeof<valueof<T>>(), negative ? -(<i64>value) : <i64>value);
+          index++;
+          if (srcStart >= srcEnd) break;
+
+          code = load<u16>(srcStart);
+          if (code == COMMA) {
+            srcStart += 2;
+            continue;
+          }
+          if (code == BRACKET_RIGHT) {
+            out.length = index;
+            return out;
+          }
+          break;
+        }
+      } else {
+        while (srcStart < srcEnd) {
+          let digit = <u32>load<u16>(srcStart) - 48;
+          if (digit > 9) break;
+
+          let value: u64 = digit;
+          srcStart += 2;
+          while (srcStart + 14 < srcEnd) {
+            const next = tryParseEightDigitsSIMD(srcStart, value);
+            if (!next) break;
+            value = next;
+            srcStart += 16;
+          }
+          while (srcStart < srcEnd) {
+            digit = <u32>load<u16>(srcStart) - 48;
+            if (digit > 9) break;
+            value = value * 10 + digit;
+            srcStart += 2;
+          }
+
+          if (index >= reusableLength) break;
+          storeUnsignedInteger<T>(dataStart + <usize>index * sizeof<valueof<T>>(), value);
+          index++;
+          if (srcStart >= srcEnd) break;
+
+          const code = load<u16>(srcStart);
+          if (code == COMMA) {
+            srcStart += 2;
+            continue;
+          }
+          if (code == BRACKET_RIGHT) {
+            out.length = index;
+            return out;
+          }
+          break;
+        }
+      }
+    } while (false);
+
+    srcStart = originalSrcStart;
+  }
+
+  out.length = 0;
+
+  do {
+    if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
+    srcStart += 2;
+    if (srcStart >= srcEnd) break;
+    if (load<u16>(srcStart) == BRACKET_RIGHT) return out;
+
+    if (isSigned<valueof<T>>()) {
+      while (srcStart < srcEnd) {
+        srcStart = parseSignedIntegerSIMD<T>(srcStart, srcEnd, out);
+        if (!srcStart || srcStart >= srcEnd) break;
+
+        const code = load<u16>(srcStart);
+        if (code == COMMA) {
+          srcStart += 2;
+          continue;
+        }
+        if (code == BRACKET_RIGHT) return out;
+        break;
+      }
+    } else {
+      while (srcStart < srcEnd) {
+        srcStart = parseUnsignedIntegerSIMD<T>(srcStart, srcEnd, out);
+        if (!srcStart || srcStart >= srcEnd) break;
+
+        const code = load<u16>(srcStart);
+        if (code == COMMA) {
+          srcStart += 2;
+          continue;
+        }
+        if (code == BRACKET_RIGHT) return out;
+        break;
+      }
+    }
+  } while (false);
+
+  return deserializeIntegerArray_SLOW<T>(originalSrcStart, srcEnd, changetype<usize>(out));
+}