json-as 1.3.7 → 1.3.8

package/assembly/deserialize/naive/string.ts

@@ -0,0 +1,199 @@
+import { bs } from "../../../lib/as-bs";
+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";
+
+// @ts-ignore: inline
+@inline function hexDigit(c: u16): u32 {
+  if (c <= 0x39) return c - 0x30; // '0'-'9'
+  if (c <= 0x46) return c - 0x37; // 'A'-'F'
+  return c - 0x57; // 'a'-'f'
+}
+
+// @ts-ignore: inline
+@inline function hex4ToU16(srcStart: usize): u16 {
+  return <u16>(
+    ((hexDigit(load<u16>(srcStart)) << 12) |
+      (hexDigit(load<u16>(srcStart, 2)) << 8) |
+      (hexDigit(load<u16>(srcStart, 4)) << 4) |
+      hexDigit(load<u16>(srcStart, 6)))
+  );
+}
+
+// @ts-ignore: inline
+@inline 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.
+// @ts-ignore: inline
+@inline 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");
+}
+
+// @ts-ignore: inline
+@inline export function deserializeString_NAIVE(
+  srcStart: usize,
+  srcEnd: usize,
+): string {
+  // RFC 8259: a string is quote-framed. All callers pass quote-inclusive
+  // bounds, so the first and last chars must be `"` (rejects `"` alone and
+  // trailing garbage like `""x`).
+  if (
+    srcEnd - srcStart < 4 ||
+    load<u16>(srcStart) != QUOTE ||
+    load<u16>(srcEnd - 2) != QUOTE
+  )
+    throw new Error("Invalid JSON string: missing surrounding quotes");
+  // Strip quotes
+  srcStart += 2;
+  srcEnd -= 2;
+  const outStart = bs.offset - bs.buffer;
+  bs.ensureSize(u32(srcEnd - srcStart));
+
+  while (srcStart < srcEnd) {
+    const block = load<u16>(srcStart);
+    store<u16>(bs.offset, block);
+    srcStart += 2;
+
+    // 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");
+      bs.offset += 2;
+      continue;
+    }
+
+    validateEscape(srcStart, srcEnd);
+    const code = load<u16>(srcStart);
+    if (code !== 0x75) {
+      // Short escapes (\n \t \" \\)
+      const block = load<u16>(srcStart);
+      const escape = load<u16>(DESERIALIZE_ESCAPE_TABLE + block);
+      store<u16>(bs.offset, escape);
+      srcStart += 2;
+    } else {
+      // Unicode escape (\uXXXX)
+      const escaped = hex4ToU16(srcStart + 2);
+      store<u16>(bs.offset, escaped);
+      srcStart += 10;
+    }
+
+    bs.offset += 2;
+  }
+  return bs.sliceOut<string>(outStart);
+}
+
+// Writes into the destination field, reusing or resizing the backing string.
+// Mirrors `writeStringToField` in ../swar/string.ts.
+// @ts-ignore: inline
+@inline function writeStringToField(
+  dstFieldPtr: usize,
+  srcStart: usize,
+  byteLength: u32,
+): void {
+  if (byteLength == 0) {
+    store<usize>(dstFieldPtr, changetype<usize>(""));
+    return;
+  }
+
+  const current = load<usize>(dstFieldPtr);
+  let stringPtr: usize;
+  if (current >= __heap_base) {
+    if (changetype<OBJECT>(current - TOTAL_OVERHEAD).rtSize == byteLength) {
+      stringPtr = current;
+    } else {
+      stringPtr = __renew(current, byteLength);
+      store<usize>(dstFieldPtr, stringPtr);
+    }
+  } else {
+    stringPtr = __new(byteLength, idof<string>());
+    store<usize>(dstFieldPtr, stringPtr);
+  }
+  memory.copy(stringPtr, srcStart, byteLength);
+}
+
+// @ts-ignore: inline
+@inline export function deserializeStringField_NAIVE<T extends string | null>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  const dstFieldPtr = dstObj + dstOffset;
+  if (srcStart + 2 > srcEnd || load<u16>(srcStart) != QUOTE)
+    abort("Expected leading quote");
+
+  const payloadStart = srcStart + 2;
+  srcStart = payloadStart;
+
+  bs.offset = bs.buffer;
+  bs.ensureSize(<u32>(srcEnd - payloadStart));
+
+  while (srcStart < srcEnd) {
+    const block = load<u16>(srcStart);
+
+    if (block == QUOTE) {
+      writeStringToField(dstFieldPtr, bs.buffer, <u32>(bs.offset - bs.buffer));
+      bs.offset = bs.buffer;
+      return srcStart + 2;
+    }
+
+    if (block != BACK_SLASH) {
+      store<u16>(bs.offset, block);
+      bs.offset += 2;
+      srcStart += 2;
+      continue;
+    }
+
+    const code = load<u16>(srcStart, 2);
+    if (code !== 0x75) {
+      // Short escapes (\n \t \" \\)
+      store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
+      srcStart += 4;
+    } else {
+      // Unicode escape (\uXXXX)
+      store<u16>(bs.offset, hex4ToU16(srcStart + 4));
+      srcStart += 12;
+    }
+    bs.offset += 2;
+  }
+
+  abort("Expected closing quote");
+  return 0;
+}

package/assembly/deserialize/{simple → naive}/typedarray.ts

@@ -1,5 +1,5 @@
 import { COMMA, BRACKET_RIGHT } from "../../custom/chars";
-import { deserializeFloat } from "./float";
+import { deserializeFloat_NAIVE } from "./float";
 import { atoi, isSpace } from "../../util";
 
 
@@ -25,7 +25,7 @@ import { atoi, isSpace } from "../../util";
   return count;
 }
 
-export function deserializeTypedArray<T extends ArrayLike<number>>(
+export function deserializeTypedArray_NAIVE<T extends ArrayLike<number>>(
   srcStart: usize,
   srcEnd: usize,
   dst: usize = 0,
@@ -49,7 +49,7 @@ export function deserializeTypedArray<T extends ArrayLike<number>>(
         if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) {
           if (isFloat<valueof<T>>()) {
             unchecked(
-              (out[index++] = deserializeFloat<valueof<T>>(
+              (out[index++] = deserializeFloat_NAIVE<valueof<T>>(
                 lastIndex,
                 srcStart,
               )),
@@ -69,7 +69,7 @@ export function deserializeTypedArray<T extends ArrayLike<number>>(
   return out;
 }
 
-export function deserializeArrayBuffer(
+export function deserializeArrayBuffer_NAIVE(
   srcStart: usize,
   srcEnd: usize,
   dst: usize = 0,

package/assembly/deserialize/{simple → naive}/unsigned.ts

@@ -1,7 +1,7 @@
 import { atoi } from "../../util/atoi";
 
 // @ts-ignore: inline
-@inline export function deserializeUnsigned<T>(
+@inline export function deserializeUnsigned_NAIVE<T extends number>(
   srcStart: usize,
   srcEnd: usize,
 ): T {
@@ -9,7 +9,7 @@ import { atoi } from "../../util/atoi";
 }
 
 // @ts-ignore: inline
-@inline export function deserializeUnsignedField<T extends number>(
+@inline export function deserializeUnsignedField_NAIVE<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

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

@@ -5,19 +5,19 @@ import { isSpace } from "../../../util";
 const ASCII_LANE_MASK_4: u64 = 0x00ff00ff00ff00ff;
 const ASCII_ZERO_4: u64 = 0x0030003000300030;
 
-
+// @ts-expect-error: decorators valid here
 @lazy const SPLAT_30 = i16x8.splat(0x30);
 
-
+// @ts-expect-error: decorators valid here
 @lazy const SPLAT_09 = i16x8.splat(9);
 
-
+// @ts-expect-error: decorators valid here
 @lazy const ZERO_I16X8 = i16x8.splat(0);
 
-
+// @ts-expect-error: decorators valid here
 @lazy const ZERO_I32X4 = i32x4.splat(0);
 
-
+// @ts-expect-error: decorators valid here
 @lazy const PACK_WEIGHTS_10_1 = i8x16(
   10,
   1,
@@ -37,10 +37,10 @@ const ASCII_ZERO_4: u64 = 0x0030003000300030;
   0,
 );
 
-
+// @ts-expect-error: decorators valid here
 @lazy const PAIR_WEIGHTS_100_1 = i16x8(100, 1, 100, 1, 0, 0, 0, 0);
 
-
+// @ts-expect-error: decorators valid here
 @inline function storeSignedInteger<T extends number[]>(
   slot: usize,
   value: i64,
@@ -58,7 +58,7 @@ const ASCII_ZERO_4: u64 = 0x0030003000300030;
   }
 }
 
-
+// @ts-expect-error: decorators valid here
 @inline function storeUnsignedInteger<T extends number[]>(
   slot: usize,
   value: u64,
@@ -76,7 +76,7 @@ const ASCII_ZERO_4: u64 = 0x0030003000300030;
   }
 }
 
-
+// @ts-expect-error: decorators valid here
 @inline function tryParseEightDigitsSIMD(srcStart: usize, value: u64): u64 {
   const block = load<v128>(srcStart);
   const digits = i16x8.sub(block, SPLAT_30);
@@ -96,8 +96,7 @@ const ASCII_ZERO_4: u64 = 0x0030003000300030;
 // As in the SWAR variant: the parse helpers take a `slot` (`writePtr`) and
 // store directly. The dispatcher owns `out.length = maxElements` and the
 // per-element `writePtr` advance so `Array.push` is removed for every
-// integer width, not just the narrow-lane fast path.
-
+// @ts-expect-error: decorators valid here
 @inline function parseSignedIntegerSIMD<T extends number[]>(
   srcStart: usize,
   srcEnd: usize,
@@ -136,7 +135,7 @@ const ASCII_ZERO_4: u64 = 0x0030003000300030;
   return srcStart;
 }
 
-
+// @ts-expect-error: decorators valid here
 @inline function parseUnsignedIntegerSIMD<T extends number[]>(
   srcStart: usize,
   srcEnd: usize,
@@ -166,7 +165,7 @@ const ASCII_ZERO_4: u64 = 0x0030003000300030;
   return srcStart;
 }
 
-
+// @ts-expect-error: decorators valid here
 @lazy const COMMA_SPLAT_8 = i16x8.splat(<i16>COMMA);
 
 // Pair-multiply weights for the common two-element packings in 8-char blocks.
@@ -181,24 +180,25 @@ const ASCII_ZERO_4: u64 = 0x0030003000300030;
 //   2+2 (`DD,DD,??`)   bitmask 0x24, advance 12
 //   3+1 (`DDD,D,??`)   bitmask 0x28, advance 12
 //   1+3 (`D,DDD,??`)   bitmask 0x22, advance 12
+// @ts-expect-error: decorators valid here
 @lazy const PAIR_WEIGHTS_3_3_8 = i16x8(100, 10, 1, 0, 100, 10, 1, 0);
 
-
+// @ts-expect-error: decorators valid here
 @lazy const PAIR_WEIGHTS_3_2_8 = i16x8(100, 10, 1, 0, 10, 1, 0, 0);
 
-
+// @ts-expect-error: decorators valid here
 @lazy const PAIR_WEIGHTS_2_3_8 = i16x8(10, 1, 0, 100, 10, 1, 0, 0);
 
-
+// @ts-expect-error: decorators valid here
 @lazy const PAIR_WEIGHTS_2_2_8 = i16x8(10, 1, 0, 10, 1, 0, 0, 0);
 
-
+// @ts-expect-error: decorators valid here
 @lazy const PAIR_WEIGHTS_3_1_8 = i16x8(100, 10, 1, 0, 1, 0, 0, 0);
 
-
+// @ts-expect-error: decorators valid here
 @lazy const PAIR_WEIGHTS_1_3_8 = i16x8(1, 0, 100, 10, 1, 0, 0, 0);
 
-
+// @ts-expect-error: decorators valid here
 @lazy const SPLAT_30_8 = i16x8.splat(0x30);
 
 /**

package/assembly/deserialize/simd/float.ts

@@ -0,0 +1,303 @@
+// SIMD float deserializers. Same Lemire-style fast path / `scientific()` /
+// `f*.parse` cascade as `swar/float.ts`, but the fractional digit loop uses
+// `parse8Digits_SIMD` (16 bytes / 8 digits) before falling through to
+// `parse4Digits_PairMul` (8 bytes / 4 digits) and finally the scalar tail.
+//
+// Output is bit-identical to `f64.parse` / `f32.parse` for every input — the
+// SIMD strides only change how the u64 mantissa is accumulated, not what it
+// becomes.
+//
+// Requires `--enable simd` at compile time. Dead-code-eliminated when
+// JSON_MODE != SIMD.
+
+import { ptrToStr } from "../../util/ptrToStr";
+import { parse4Digits_PairMul } from "../../util/swar-int";
+import { parse16Digits_SIMD } from "../../util/simd-int";
+import { scientific } from "../../util/scientific";
+import { loadPow10, MAX_EXACT_MANTISSA, MAX_EXACT_POW10 } from "../swar/float";
+
+const ASCII_PLUS: u16 = 43;
+const ASCII_MINUS: u16 = 45;
+const ASCII_DOT: u16 = 46;
+const ASCII_ZERO: u16 = 48;
+const ASCII_E_UP: u16 = 69;
+const ASCII_E_LO: u16 = 101;
+
+// @ts-ignore: inline
+@inline function fallback<T>(srcStart: usize, srcEnd: usize): T {
+  const s = ptrToStr(srcStart, srcEnd);
+  // @ts-ignore
+  const type: T = 0;
+  // @ts-ignore
+  if (type instanceof f64) return <T>f64.parse(s);
+  // @ts-ignore
+  return <T>(<f32>f32.parse(s));
+}
+
+// @ts-ignore: inline
+@inline function fallbackField<T extends number>(
+  origStart: usize,
+  end: usize,
+  fieldPtr: usize,
+): void {
+  const s = ptrToStr(origStart, end);
+  if (sizeof<T>() == sizeof<f32>()) {
+    store<f32>(fieldPtr, f32.parse(s));
+  } else {
+    store<f64>(fieldPtr, f64.parse(s));
+  }
+}
+
+// @ts-ignore: inline
+@inline export function deserializeFloat_SIMD<T>(
+  srcStart: usize,
+  srcEnd: usize,
+): T {
+  const origStart = srcStart;
+  let p = srcStart;
+  let negative = false;
+  if (p < srcEnd && load<u16>(p) == ASCII_MINUS) {
+    negative = true;
+    p += 2;
+  }
+
+  let mantissa: u64 = 0;
+  let intDigits: i32 = 0;
+  while (p < srcEnd) {
+    const d = <u32>load<u16>(p) - ASCII_ZERO;
+    if (d > 9) break;
+    mantissa = mantissa * 10 + <u64>d;
+    intDigits++;
+    p += 2;
+  }
+
+  // Fractional part: parse8 SIMD stride → parse4 SWAR stride → scalar tail.
+  // `intDigits + fracDigits <= 11` gate keeps `mantissa * 10^8 + parsed8`
+  // under u64 max even when the integer part is large.
+  let fracDigits: i32 = 0;
+  if (p < srcEnd && load<u16>(p) == ASCII_DOT) {
+    p += 2;
+    // parse16 SIMD only fires on long fractions (>=16 digits ahead, with
+    // <=3 integer digits to keep mantissa * 1e16 under u64 max). Rare in
+    // typical JSON but a big win when it does fire (8 digits per stride in
+    // SWAR's parse8 was benched even/worse than parse4, so we skip parse8
+    // entirely and let parse4 handle the 4-15 char tail).
+    while (p + 30 < srcEnd && intDigits + fracDigits <= 3) {
+      const parsed = parse16Digits_SIMD(p);
+      if (parsed == U64.MAX_VALUE) break;
+      mantissa = mantissa * 10_000_000_000_000_000 + parsed;
+      fracDigits += 16;
+      p += 32;
+    }
+    while (p + 6 < srcEnd) {
+      const parsed = parse4Digits_PairMul(load<u64>(p));
+      if (parsed == U32.MAX_VALUE) break;
+      mantissa = mantissa * 10_000 + <u64>parsed;
+      fracDigits += 4;
+      p += 8;
+    }
+    while (p < srcEnd) {
+      const d = <u32>load<u16>(p) - ASCII_ZERO;
+      if (d > 9) break;
+      mantissa = mantissa * 10 + <u64>d;
+      fracDigits++;
+      p += 2;
+    }
+  }
+
+  const mantDigits = intDigits + fracDigits;
+  if (mantDigits == 0) return fallback<T>(origStart, srcEnd);
+
+  let exponent: i32 = -fracDigits;
+
+  if (p < srcEnd) {
+    const c = load<u16>(p);
+    if (c == ASCII_E_LO || c == ASCII_E_UP) {
+      const expStart = p;
+      p += 2;
+      if (p >= srcEnd) return fallback<T>(origStart, expStart);
+      let expNeg = false;
+      const sc = load<u16>(p);
+      if (sc == ASCII_MINUS) {
+        expNeg = true;
+        p += 2;
+      } else if (sc == ASCII_PLUS) {
+        p += 2;
+      }
+      if (p >= srcEnd) return fallback<T>(origStart, expStart);
+      let exp: i32 = 0;
+      let expDigits: i32 = 0;
+      while (p < srcEnd) {
+        const d = <u32>load<u16>(p) - ASCII_ZERO;
+        if (d > 9) break;
+        exp = exp * 10 + <i32>d;
+        expDigits++;
+        if (expDigits > 4) return fallback<T>(origStart, srcEnd);
+        p += 2;
+      }
+      if (expDigits == 0) return fallback<T>(origStart, expStart);
+      exponent += expNeg ? -exp : exp;
+    }
+  }
+
+  let result: f64;
+  if (
+    mantDigits <= 19 &&
+    mantissa <= MAX_EXACT_MANTISSA &&
+    exponent <= MAX_EXACT_POW10 &&
+    exponent >= -MAX_EXACT_POW10
+  ) {
+    result = <f64>mantissa;
+    if (exponent > 0) {
+      result *= loadPow10(<u32>exponent);
+    } else if (exponent < 0) {
+      result /= loadPow10(<u32>-exponent);
+    }
+  } else if (mantDigits <= 19) {
+    result = scientific(mantissa, exponent);
+  } else {
+    return fallback<T>(origStart, srcEnd);
+  }
+  if (negative) result = -result;
+
+  // @ts-ignore
+  const type: T = 0;
+  // @ts-ignore
+  if (type instanceof f64) return <T>result;
+  // @ts-ignore
+  return <T>(<f32>result);
+}
+
+// @ts-ignore: inline
+@inline export function deserializeFloatField_SIMD<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  const fieldPtr = dstObj + dstOffset;
+  const origStart = srcStart;
+  let p = srcStart;
+  let negative = false;
+  if (p < srcEnd && load<u16>(p) == ASCII_MINUS) {
+    negative = true;
+    p += 2;
+  }
+
+  let mantissa: u64 = 0;
+  let intDigits: i32 = 0;
+  while (p < srcEnd) {
+    const d = <u32>load<u16>(p) - ASCII_ZERO;
+    if (d > 9) break;
+    mantissa = mantissa * 10 + <u64>d;
+    intDigits++;
+    p += 2;
+  }
+
+  let fracDigits: i32 = 0;
+  if (p < srcEnd && load<u16>(p) == ASCII_DOT) {
+    p += 2;
+    // parse16 SIMD only fires on long fractions (>=16 digits ahead, with
+    // <=3 integer digits to keep mantissa * 1e16 under u64 max). Rare in
+    // typical JSON but a big win when it does fire (8 digits per stride in
+    // SWAR's parse8 was benched even/worse than parse4, so we skip parse8
+    // entirely and let parse4 handle the 4-15 char tail).
+    while (p + 30 < srcEnd && intDigits + fracDigits <= 3) {
+      const parsed = parse16Digits_SIMD(p);
+      if (parsed == U64.MAX_VALUE) break;
+      mantissa = mantissa * 10_000_000_000_000_000 + parsed;
+      fracDigits += 16;
+      p += 32;
+    }
+    while (p + 6 < srcEnd) {
+      const parsed = parse4Digits_PairMul(load<u64>(p));
+      if (parsed == U32.MAX_VALUE) break;
+      mantissa = mantissa * 10_000 + <u64>parsed;
+      fracDigits += 4;
+      p += 8;
+    }
+    while (p < srcEnd) {
+      const d = <u32>load<u16>(p) - ASCII_ZERO;
+      if (d > 9) break;
+      mantissa = mantissa * 10 + <u64>d;
+      fracDigits++;
+      p += 2;
+    }
+  }
+
+  const mantDigits = intDigits + fracDigits;
+  if (mantDigits == 0) unreachable();
+
+  let exponent: i32 = -fracDigits;
+
+  if (p < srcEnd) {
+    const c = load<u16>(p);
+    if (c == ASCII_E_LO || c == ASCII_E_UP) {
+      const expStart = p;
+      p += 2;
+      if (p >= srcEnd) {
+        fallbackField<T>(origStart, expStart, fieldPtr);
+        return expStart;
+      }
+      let expNeg = false;
+      const sc = load<u16>(p);
+      if (sc == ASCII_MINUS) {
+        expNeg = true;
+        p += 2;
+      } else if (sc == ASCII_PLUS) {
+        p += 2;
+      }
+      if (p >= srcEnd) {
+        fallbackField<T>(origStart, expStart, fieldPtr);
+        return expStart;
+      }
+      let exp: i32 = 0;
+      let expDigits: i32 = 0;
+      while (p < srcEnd) {
+        const d = <u32>load<u16>(p) - ASCII_ZERO;
+        if (d > 9) break;
+        exp = exp * 10 + <i32>d;
+        expDigits++;
+        if (expDigits > 4) {
+          fallbackField<T>(origStart, p, fieldPtr);
+          return p;
+        }
+        p += 2;
+      }
+      if (expDigits == 0) {
+        fallbackField<T>(origStart, expStart, fieldPtr);
+        return expStart;
+      }
+      exponent += expNeg ? -exp : exp;
+    }
+  }
+
+  let result: f64;
+  if (
+    mantDigits <= 19 &&
+    mantissa <= MAX_EXACT_MANTISSA &&
+    exponent <= MAX_EXACT_POW10 &&
+    exponent >= -MAX_EXACT_POW10
+  ) {
+    result = <f64>mantissa;
+    if (exponent > 0) {
+      result *= loadPow10(<u32>exponent);
+    } else if (exponent < 0) {
+      result /= loadPow10(<u32>-exponent);
+    }
+  } else if (mantDigits <= 19) {
+    result = scientific(mantissa, exponent);
+  } else {
+    fallbackField<T>(origStart, p, fieldPtr);
+    return p;
+  }
+  if (negative) result = -result;
+
+  if (sizeof<T>() == sizeof<f32>()) {
+    store<f32>(fieldPtr, <f32>result);
+  } else {
+    store<f64>(fieldPtr, result);
+  }
+
+  return p;
+}