common.gr

// This module was based on Rust's dec2flt
// https://github.com/rust-lang/rust/blob/1cbc45942d5c0f6eb5d94e3b10762ba541958035/library/core/src/num/dec2flt/common.rs
// Rust's MIT license is provided below:
/*
 * Permission is hereby granted, free of charge, to any
 * person obtaining a copy of this software and associated
 * documentation files (the "Software"), to deal in the
 * Software without restriction, including without
 * limitation the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software
 * is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice
 * shall be included in all copies or substantial portions
 * of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
 * ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
 * TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
 * SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
 * IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
*/
@noPervasives
module Common

from "runtime/unsafe/wasmi32" include WasmI32
from "runtime/unsafe/wasmi64" include WasmI64
from "runtime/unsafe/wasmf64" include WasmF64
from "runtime/dataStructures" include DataStructures
use DataStructures.{ newInt32, newInt64, newFloat64 }
from "runtime/numberUtils" include NumberUtils
use NumberUtils.{ get_POWERS10 }
from "runtime/atof/table" include Table
use Table.{ get_F64_POWERS10_FAST_PATH, get_POWERS5 }

primitive (&&) = "@and"
primitive (||) = "@or"
primitive (!) = "@not"

provide record BiasedFp {
  f: Int64,
  mut e: Int32,
}

@unsafe
provide let _MINIMUM_EXPONENT = -1023n
@unsafe
provide let _MIN_EXPONENT_ROUND_TO_EVEN = -4N
@unsafe
provide let _MAX_EXPONENT_ROUND_TO_EVEN = 23N
@unsafe
provide let _MIN_EXPONENT_FAST_PATH = -22n
@unsafe
provide let _MAX_EXPONENT_FAST_PATH = 22n
@unsafe
provide let _MAX_EXPONENT_DISGUISED_FAST_PATH = 37n
@unsafe
provide let _MAX_MANTISSA_FAST_PATH = {
  use WasmI64.{ (<<) }
  2N << 52N
}
@unsafe
provide let _MANTISSA_EXPLICIT_BITS_64 = 52N
@unsafe
provide let _MANTISSA_EXPLICIT_BITS_32 = 52n
@unsafe
provide let _INFINITE_POWER = 0x7FFn
@unsafe
provide let _SMALLEST_POWER_OF_TEN = -342N
@unsafe
provide let _LARGEST_POWER_OF_TEN = 308N
@unsafe
provide let _SMALLEST_POWER_OF_FIVE = -342N
@unsafe
provide let _LARGEST_POWER_OF_FIVE = 308N

@unsafe
provide let _CHAR_CODE_UNDERSCORE = 0x5fn
@unsafe
provide let _CHAR_CODE_PLUS = 0x2Bn
@unsafe
provide let _CHAR_CODE_MINUS = 0x2Dn
@unsafe
provide let _CHAR_CODE_0 = 0x30n
@unsafe
provide let _CHAR_CODE_e = 0x65n
@unsafe
provide let _CHAR_CODE_E = 0x45n
@unsafe
provide let _CHAR_CODE_DOT = 0x2En
@unsafe
provide let _CHAR_CODE_A = 0x41n
@unsafe
provide let _CHAR_CODE_Z = 0x5an
@unsafe
provide let _CHAR_CODE_a = 0x61n
@unsafe
provide let _CHAR_CODE_f = 0x66n
@unsafe
provide let _CHAR_CODE_i = 0x69n
@unsafe
provide let _CHAR_CODE_n = 0x6en
@unsafe
provide let _CHAR_CODE_t = 0x74n
@unsafe
provide let _CHAR_CODE_y = 0x79n

provide let fpZero = () => { f: 0L, e: 0l }
@unsafe
provide let fpInf = () =>
  { f: 0L, e: WasmI32.toGrain(newInt32(_INFINITE_POWER)): Int32 }
provide let fpErr = () => { f: 0L, e: -1l }
provide let fpNan = () => { f: 1L, e: -1l }

@unsafe
provide let getPowers10 = (i: WasmI32) => {
  use WasmI32.{ (*) }
  WasmI32.load(get_POWERS10(), 4n * i)
}

@unsafe
provide let getPowers10FastPath = (i: WasmI32) => {
  use WasmI32.{ (*) }
  WasmF64.load(get_F64_POWERS10_FAST_PATH(), 8n * i)
}

// https://stdrs.dev/nightly/x86_64-unknown-linux-gnu/src/core/num/dec2flt/common.rs.html#165
@unsafe
provide let is8Digits = (value: WasmI64) => {
  use WasmI64.{ (+), (-), (|), (&), (==) }

  let a = value + 0x4646_4646_4646_4646N
  let b = value - 0x3030_3030_3030_3030N
  let c = (a | b) & 0x8080_8080_8080_8080N

  c == 0N
}

// From Rust:
// Calculate a base 2 exponent from a decimal exponent.
// This uses a pre-computed integer approximation for
// log2(10), where 217706 / 2^16 is accurate for the
// entire range of non-finite decimal exponents.
@unsafe
provide let power = (q: WasmI32) => {
  use WasmI32.{ (+), (*), (>>) }

  ((q * (152_170n + 65536n)) >> 16n) + 63n
}

@unsafe
provide let fullMultiplication = (a: WasmI64, b: WasmI64) => {
  // Adapted from https://www.codeproject.com/Tips/618570/UInt-Multiplication-Squaring
  use WasmI64.{ (+), (*), (&), (>>>), (<<) }

  let aLo = a & 0xffffffffN
  let bLo = b & 0xffffffffN
  let aLoxbLo = aLo * bLo
  let w3 = aLoxbLo & 0xffffffffN
  let k = aLoxbLo >>> 32N

  let aHi = a >>> 32N
  let mid = aHi * bLo + k
  let k = mid & 0xffffffffN
  let w1 = mid >>> 32N

  let bHi = b >>> 32N
  let mid = aLo * bHi + k
  let k = mid >>> 32N

  let hi = aHi * bHi + w1 + k
  let lo = (mid << 32N) + w3

  (WasmI32.toGrain(newInt64(lo)): Int64, WasmI32.toGrain(newInt64(hi)): Int64)
}

@unsafe
provide let biasedFpToNumber = (fp, negative) => {
  use WasmI64.{ (|), (<<) }
  let f = WasmI64.load(WasmI32.fromGrain(fp.f), 8n)
  let e = WasmI64.extendI32S(WasmI32.load(WasmI32.fromGrain(fp.e), 4n))
  let word = f | e << _MANTISSA_EXPLICIT_BITS_64
  let mut float = WasmF64.reinterpretI64(word)
  if (negative) {
    float = WasmF64.neg(float)
  }
  WasmI32.toGrain(newFloat64(float)): Number
}