json-as 1.2.5 → 1.3.0

package/assembly/deserialize/float.ts

@@ -0,0 +1,181 @@
+import { ptrToStr } from "../util/ptrToStr";
+
+// @ts-ignore: inline
+@inline function pow10Fast(exponent: u32): f64 {
+  let result = 1.0;
+  if (exponent & 1) result *= 1e1;
+  if (exponent & 2) result *= 1e2;
+  if (exponent & 4) result *= 1e4;
+  if (exponent & 8) result *= 1e8;
+  if (exponent & 16) result *= 1e16;
+  if (exponent & 32) result *= 1e32;
+  if (exponent & 64) result *= 1e64;
+  if (exponent & 128) result *= 1e128;
+  if (exponent & 256) result *= 1e256;
+  return result;
+}
+
+// @ts-ignore: inline
+@inline export function deserializeFloat<T>(srcStart: usize, srcEnd: usize): T {
+  let negative = false;
+  if (load<u16>(srcStart) == 45) {
+    negative = true;
+    srcStart += 2;
+    if (srcStart >= srcEnd) unreachable();
+  }
+
+  let value: f64 = 0.0;
+  let seenDigit = false;
+
+  while (srcStart < srcEnd) {
+    const digit = <u32>load<u16>(srcStart) - 48;
+    if (digit > 9) break;
+    value = value * 10.0 + <f64>digit;
+    seenDigit = true;
+    srcStart += 2;
+  }
+
+  if (srcStart < srcEnd && load<u16>(srcStart) == 46) {
+    srcStart += 2;
+    let fraction: u64 = 0;
+    let digits: u32 = 0;
+    while (srcStart < srcEnd) {
+      const digit = <u32>load<u16>(srcStart) - 48;
+      if (digit > 9) break;
+      fraction = fraction * 10 + digit;
+      digits += 1;
+      seenDigit = true;
+      srcStart += 2;
+    }
+    if (digits != 0) value += <f64>fraction / pow10Fast(digits);
+  }
+
+  if (!seenDigit) {
+    // @ts-ignore
+    const type: T = 0;
+    // @ts-ignore
+    if (type instanceof f64) return f64.parse(ptrToStr(srcStart, srcEnd));
+    // @ts-ignore
+    return f32.parse(ptrToStr(srcStart, srcEnd));
+  }
+
+  if (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == 101 || code == 69) {
+      srcStart += 2;
+      if (srcStart >= srcEnd) unreachable();
+
+      let exponentNegative = false;
+      let exponentCode = load<u16>(srcStart);
+      if (exponentCode == 45 || exponentCode == 43) {
+        exponentNegative = exponentCode == 45;
+        srcStart += 2;
+        if (srcStart >= srcEnd) unreachable();
+        exponentCode = load<u16>(srcStart);
+      }
+
+      let exponent = <u32>exponentCode - 48;
+      if (exponent > 9) unreachable();
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        const digit = <u32>load<u16>(srcStart) - 48;
+        if (digit > 9) break;
+        exponent = exponent * 10 + digit;
+        srcStart += 2;
+      }
+
+      const power = pow10Fast(exponent);
+      value = exponentNegative ? value / power : value * power;
+    }
+  }
+
+  if (negative) value = -value;
+
+  // @ts-ignore
+  const type: T = 0;
+  // @ts-ignore
+  if (type instanceof f64) return <T>value;
+  // @ts-ignore
+  return <T>(<f32>value);
+}
+
+// @ts-ignore: inline
+@inline export function deserializeFloatField<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 value: f64 = 0.0;
+  let seenDigit = false;
+
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    const digit = <u32>code - 48;
+    if (digit > 9) break;
+    value = value * 10.0 + <f64>digit;
+    seenDigit = true;
+    srcStart += 2;
+  }
+
+  if (srcStart < srcEnd && load<u16>(srcStart) == 46) {
+    srcStart += 2;
+    let fraction: u64 = 0;
+    let digits: u32 = 0;
+    while (srcStart < srcEnd) {
+      const code = load<u16>(srcStart);
+      const digit = <u32>code - 48;
+      if (digit > 9) break;
+      fraction = fraction * 10 + digit;
+      digits += 1;
+      seenDigit = true;
+      srcStart += 2;
+    }
+    if (digits != 0) value += <f64>fraction / pow10Fast(digits);
+  }
+
+  if (!seenDigit) unreachable();
+
+  if (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == 101 || code == 69) {
+      srcStart += 2;
+      if (srcStart >= srcEnd) unreachable();
+
+      let exponentNegative = false;
+      let exponentCode = load<u16>(srcStart);
+      if (exponentCode == 45 || exponentCode == 43) {
+        exponentNegative = exponentCode == 45;
+        srcStart += 2;
+        if (srcStart >= srcEnd) unreachable();
+        exponentCode = load<u16>(srcStart);
+      }
+
+      let exponent = <u32>exponentCode - 48;
+      if (exponent > 9) unreachable();
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        const code = load<u16>(srcStart);
+        const digit = <u32>code - 48;
+        if (digit > 9) break;
+        exponent = exponent * 10 + digit;
+        srcStart += 2;
+      }
+
+      const power = pow10Fast(exponent);
+      value = exponentNegative ? value / power : value * power;
+    }
+  }
+
+  if (negative) value = -value;
+
+  if (sizeof<T>() == sizeof<f32>()) {
+    store<f32>(fieldPtr, <f32>value);
+  } else {
+    store<f64>(fieldPtr, value);
+  }
+
+  return srcStart;
+}

package/assembly/deserialize/helpers/uint.ts

@@ -0,0 +1,12 @@
+export function deserializeUintScan<T extends number>(src: usize, dst: usize): usize {
+  let digit = <T>load<u16>(src) - 48;
+  if (digit > 9) abort("Found invalid digit");
+  let val = digit;
+  src += 2;
+  while ((digit = <u32>load<u16>(src) - 48) < 10) {
+    val = val * 10 + digit;
+    src += 2;
+  }
+  store<T>(dst, val);
+  return src;
+}

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 @@
+export { deserializeArrayBuffer, deserializeTypedArray } from "../simple/typedarray";

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;
+}