@grain/stdlib 0.4.6 → 0.5.0

package/runtime/stringUtils.gr

@@ -14,9 +14,10 @@ import WasmI32, {
 import WasmI64 from "runtime/unsafe/wasmi64"
 import Memory from "runtime/unsafe/memory"
 import Tags from "runtime/unsafe/tags"
+import BI from "runtime/bigint"
 import { reducedInteger } from "runtime/numbers"
 
-@disableGC
+@unsafe
 export let rec parseInt = (string: String, radix: Number) => {
   let _CHAR_0 = 0x30n
   let _CHAR_B = 0x42n
@@ -45,15 +46,13 @@ export let rec parseInt = (string: String, radix: Number) => {
   let strEnd = offset + strLen
 
   let radix = WasmI32.fromGrain(radix)
-  let result = if (
+  if (
     WasmI32.eqz(radix & Tags._GRAIN_NUMBER_TAG_MASK) ||
     radix < WasmI32.fromGrain(2) ||
     radix > WasmI32.fromGrain(36)
   ) {
-    Memory.incRef(WasmI32.fromGrain(Err))
     Err("Radix must be an integer between 2 and 36")
   } else if (WasmI32.eqz(strLen)) {
-    Memory.incRef(WasmI32.fromGrain(Err))
     Err("Invalid input")
   } else {
     let mut char = WasmI32.load8U(offset, 0n)
@@ -90,10 +89,13 @@ export let rec parseInt = (string: String, radix: Number) => {
       }
     }
 
+    // We try to avoid allocating a BigInt if it's not needed
     let mut value = 0N
+    let mut radixBigInt = 0n
+    let mut valueBigInt = 0n
+    let mut isBigInt = 0n
 
-    // we use 0 to represent no error, 1 to represent an invalid
-    // input, and 2 to represent an overflow
+    // we use 0 to represent no error and 1 to represent an invalid input
     let mut error = 1n
 
     for (let mut i = offset; i < strEnd; i += 1n) {
@@ -130,47 +132,65 @@ export let rec parseInt = (string: String, radix: Number) => {
 
       let digit = WasmI64.extendI32U(digit)
 
-      value = WasmI64.mul(value, radix)
-
-      // Check for overflow
-      // 64-bit int min + 1
-      if (WasmI64.ltS(value, WasmI64.add(limit, digit))) {
-        error = 2n
-        // overflow
-        break
+      if (WasmI32.eqz(isBigInt)) {
+        let prevValue = value
+        value = WasmI64.mul(value, radix)
+        // Check for overflow
+        // 64-bit int min + 1
+        if (WasmI64.ltS(value, WasmI64.add(limit, digit))) {
+          // we overflowed. allocate BigInt and use instead
+          isBigInt = 1n
+          valueBigInt = BI.makeWrappedUint64(WasmI64.mul(prevValue, -1N))
+          radixBigInt = BI.makeWrappedUint64(radix)
+          let newvalue = BI.mul(valueBigInt, radixBigInt)
+          Memory.decRef(valueBigInt)
+          valueBigInt = newvalue
+          let newvalue = BI.addInt(valueBigInt, digit)
+          Memory.decRef(valueBigInt)
+          valueBigInt = newvalue
+        } else {
+          // To quote the OpenJDK,
+          // "Accumulating negatively avoids surprises near MAX_VALUE"
+          // The minimum value of a 64-bit integer (-9223372036854775808) can't be
+          // represented as a positive number because it would be larger than the
+          // maximum 64-bit integer (9223372036854775807), so we'd be unable to
+          // parse negatives as positives and multiply by the sign at the end.
+          // Instead, we represent all positive numbers as negative numbers since
+          // we have one unit more headroom.
+          value = WasmI64.sub(value, digit)
+        }
+      } else {
+        let newvalue = BI.mul(valueBigInt, radixBigInt)
+        Memory.decRef(valueBigInt)
+        valueBigInt = newvalue
+        let newvalue = BI.addInt(valueBigInt, digit)
+        Memory.decRef(valueBigInt)
+        valueBigInt = newvalue
       }
-
-      // To quote the OpenJDK,
-      // "Accumulating negatively avoids surprises near MAX_VALUE"
-      // The minimum value of a 64-bit integer (-9223372036854775808) can't be
-      // represented as a positive number because it would be larger than the
-      // maximum 64-bit integer (9223372036854775807), so we'd be unable to
-      // parse negatives as positives and multiply by the sign at the end.
-      // Instead, we represent all positive numbers as negative numbers since
-      // we have one unit more headroom.
-      value = WasmI64.sub(value, digit)
     }
 
     match (error) {
       1n => {
-        Memory.incRef(WasmI32.fromGrain(Err))
         Err("Invalid digit in input")
       },
-      2n => {
-        Memory.incRef(WasmI32.fromGrain(Err))
-        Err("Input out of range of representable integers")
-      },
       _ => {
-        let value = if (negative) value else WasmI64.mul(value, -1N)
-        let number = WasmI32.toGrain(reducedInteger(value)): Number
-        Memory.incRef(WasmI32.fromGrain(Ok))
-        Ok(number)
+        if (WasmI32.eqz(isBigInt)) {
+          let value = if (negative) value else WasmI64.mul(value, -1N)
+          let number = WasmI32.toGrain(
+            Memory.incRef(reducedInteger(value))
+          ): Number
+          Ok(number)
+        } else {
+          // BigInt number is accumulated in positive form
+          if (negative) {
+            let newvalue = BI.negate(valueBigInt)
+            Memory.decRef(valueBigInt)
+            Ok(WasmI32.toGrain(newvalue))
+          } else {
+            Ok(WasmI32.toGrain(valueBigInt))
+          }
+        }
       },
     }
   }
-
-  Memory.decRef(WasmI32.fromGrain(parseInt))
-  Memory.decRef(radix)
-
-  result
 }

package/runtime/stringUtils.md

@@ -0,0 +1,6 @@
+### StringUtils.**parseInt**
+
+```grain
+parseInt : (String, Number) -> Result<Number, String>
+```
+

package/runtime/unsafe/constants.gr

@@ -0,0 +1,17 @@
+/* grainc-flags --compilation-mode=runtime */
+
+// Signed/Unsigned Min/Max Constants
+export let _SMIN_I32 = 0xFFFFFFFFn
+export let _SMAX_I32 = 0x7FFFFFFFn
+export let _UMIN_I32 = 0x0n
+export let _UMAX_I32 = 0xFFFFFFFFn
+
+export let _SMIN_I64 = 0xFFFFFFFFFFFFFFFFN
+export let _SMAX_I64 = 0x7FFFFFFFFFFFFFFFN
+export let _UMIN_I64 = 0x0N
+export let _UMAX_I64 = 0xFFFFFFFFFFFFFFFFN
+
+export let _SMIN32_I64 = -0x7FFFFFFFN
+export let _SMAX32_I64 = 0x7FFFFFFFN
+export let _UMIN32_I64 = 0x0N
+export let _UMAX32_I64 = 0xFFFFFFFFN

package/runtime/unsafe/constants.md

@@ -0,0 +1,72 @@
+### Constants.**_SMIN_I32**
+
+```grain
+_SMIN_I32 : WasmI32
+```
+
+### Constants.**_SMAX_I32**
+
+```grain
+_SMAX_I32 : WasmI32
+```
+
+### Constants.**_UMIN_I32**
+
+```grain
+_UMIN_I32 : WasmI32
+```
+
+### Constants.**_UMAX_I32**
+
+```grain
+_UMAX_I32 : WasmI32
+```
+
+### Constants.**_SMIN_I64**
+
+```grain
+_SMIN_I64 : WasmI64
+```
+
+### Constants.**_SMAX_I64**
+
+```grain
+_SMAX_I64 : WasmI64
+```
+
+### Constants.**_UMIN_I64**
+
+```grain
+_UMIN_I64 : WasmI64
+```
+
+### Constants.**_UMAX_I64**
+
+```grain
+_UMAX_I64 : WasmI64
+```
+
+### Constants.**_SMIN32_I64**
+
+```grain
+_SMIN32_I64 : WasmI64
+```
+
+### Constants.**_SMAX32_I64**
+
+```grain
+_SMAX32_I64 : WasmI64
+```
+
+### Constants.**_UMIN32_I64**
+
+```grain
+_UMIN32_I64 : WasmI64
+```
+
+### Constants.**_UMAX32_I64**
+
+```grain
+_UMAX32_I64 : WasmI64
+```
+

package/runtime/unsafe/conv.md

@@ -0,0 +1,71 @@
+### Conv.**toInt32**
+
+```grain
+toInt32 : WasmI32 -> Int32
+```
+
+### Conv.**fromInt32**
+
+```grain
+fromInt32 : Int32 -> WasmI32
+```
+
+### Conv.**toInt64**
+
+```grain
+toInt64 : WasmI64 -> Int64
+```
+
+### Conv.**fromInt64**
+
+```grain
+fromInt64 : Int64 -> WasmI64
+```
+
+### Conv.**toFloat32**
+
+```grain
+toFloat32 : WasmF32 -> Float32
+```
+
+### Conv.**fromFloat32**
+
+```grain
+fromFloat32 : Float32 -> WasmF32
+```
+
+### Conv.**toFloat64**
+
+```grain
+toFloat64 : WasmF64 -> Float64
+```
+
+### Conv.**fromFloat64**
+
+```grain
+fromFloat64 : Float64 -> WasmF64
+```
+
+### Conv.**wasmI32ToNumber**
+
+```grain
+wasmI32ToNumber : WasmI32 -> Number
+```
+
+Converts a WasmI32 value to Number.
+
+This function is meant to be called from a `@disableGC` context without
+need to call incRef on the function.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`n`|`WasmI32`|The WasmI32 to convert|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`Number`|The value converted to either a simple or a 32 bit heap allocated number.|
+

package/runtime/unsafe/errors.md

@@ -0,0 +1,204 @@
+### Errors.**_GRAIN_ERR_NOT_NUMBER_COMP**
+
+```grain
+_GRAIN_ERR_NOT_NUMBER_COMP : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_NUMBER_ARITH**
+
+```grain
+_GRAIN_ERR_NOT_NUMBER_ARITH : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_BOOLEAN_LOGIC**
+
+```grain
+_GRAIN_ERR_NOT_BOOLEAN_LOGIC : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_BOOLEAN_IF**
+
+```grain
+_GRAIN_ERR_NOT_BOOLEAN_IF : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_OVERFLOW**
+
+```grain
+_GRAIN_ERR_OVERFLOW : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_GET_NOT_TUP**
+
+```grain
+_GRAIN_ERR_GET_NOT_TUP : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_GET_ITEM_IDX_NOT_NUMBER**
+
+```grain
+_GRAIN_ERR_GET_ITEM_IDX_NOT_NUMBER : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_GET_ITEM_IDX_TOO_SMALL**
+
+```grain
+_GRAIN_ERR_GET_ITEM_IDX_TOO_SMALL : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_GET_ITEM_IDX_TOO_LARGE**
+
+```grain
+_GRAIN_ERR_GET_ITEM_IDX_TOO_LARGE : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_CALLED_NON_FUNCTION**
+
+```grain
+_GRAIN_ERR_CALLED_NON_FUNCTION : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_ARITY_MISMATCH**
+
+```grain
+_GRAIN_ERR_ARITY_MISMATCH : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_OUT_OF_MEMORY**
+
+```grain
+_GRAIN_ERR_OUT_OF_MEMORY : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_SET_NOT_TUP**
+
+```grain
+_GRAIN_ERR_SET_NOT_TUP : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_SET_ITEM_IDX_NOT_NUMBER**
+
+```grain
+_GRAIN_ERR_SET_ITEM_IDX_NOT_NUMBER : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_SET_ITEM_IDX_TOO_SMALL**
+
+```grain
+_GRAIN_ERR_SET_ITEM_IDX_TOO_SMALL : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_SET_ITEM_IDX_TOO_LARGE**
+
+```grain
+_GRAIN_ERR_SET_ITEM_IDX_TOO_LARGE : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_DIVISION_BY_ZERO**
+
+```grain
+_GRAIN_ERR_DIVISION_BY_ZERO : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_MODULO_BY_ZERO**
+
+```grain
+_GRAIN_ERR_MODULO_BY_ZERO : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_ARRAY_INDEX_OUT_OF_BOUNDS**
+
+```grain
+_GRAIN_ERR_ARRAY_INDEX_OUT_OF_BOUNDS : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_INVALID_ARGUMENT**
+
+```grain
+_GRAIN_ERR_INVALID_ARGUMENT : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_ASSERTION_ERROR**
+
+```grain
+_GRAIN_ERR_ASSERTION_ERROR : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_FAILURE**
+
+```grain
+_GRAIN_ERR_FAILURE : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_SYSTEM**
+
+```grain
+_GRAIN_ERR_SYSTEM : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_INTLIKE**
+
+```grain
+_GRAIN_ERR_NOT_INTLIKE : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_RATIONAL**
+
+```grain
+_GRAIN_ERR_NOT_RATIONAL : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_MALFORMED_UTF8**
+
+```grain
+_GRAIN_ERR_MALFORMED_UTF8 : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_ADT_VAL_GENERIC**
+
+```grain
+_GRAIN_ERR_NOT_ADT_VAL_GENERIC : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_STRING_GENERIC**
+
+```grain
+_GRAIN_ERR_NOT_STRING_GENERIC : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_BOOLEAN_GENERIC**
+
+```grain
+_GRAIN_ERR_NOT_BOOLEAN_GENERIC : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_TUPLE_GENERIC**
+
+```grain
+_GRAIN_ERR_NOT_TUPLE_GENERIC : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_LAMBDA_GENERIC**
+
+```grain
+_GRAIN_ERR_NOT_LAMBDA_GENERIC : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_BAD_INPUT**
+
+```grain
+_GRAIN_ERR_BAD_INPUT : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_NONNEG**
+
+```grain
+_GRAIN_ERR_NOT_NONNEG : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_NUMBER_GENERIC**
+
+```grain
+_GRAIN_ERR_NOT_NUMBER_GENERIC : WasmI32
+```
+

package/runtime/unsafe/memory.md

@@ -0,0 +1,54 @@
+### Memory.**malloc**
+
+```grain
+malloc : WasmI32 -> WasmI32
+```
+
+### Memory.**free**
+
+```grain
+free : WasmI32 -> Void
+```
+
+### Memory.**incRef**
+
+```grain
+incRef : WasmI32 -> WasmI32
+```
+
+### Memory.**decRef**
+
+```grain
+decRef : WasmI32 -> WasmI32
+```
+
+### Memory.**utoa32Buffered**
+
+```grain
+utoa32Buffered : Box<(WasmI32, WasmI32, WasmI32) -> Void>
+```
+
+### Memory.**decimalCount32**
+
+```grain
+decimalCount32 : Box<WasmI32 -> WasmI32>
+```
+
+### Memory.**copy**
+
+```grain
+copy : (WasmI32, WasmI32, WasmI32) -> Void
+```
+
+### Memory.**fill**
+
+```grain
+fill : (WasmI32, WasmI32, WasmI32) -> Void
+```
+
+### Memory.**compare**
+
+```grain
+compare : (WasmI32, WasmI32, WasmI32) -> WasmI32
+```
+

package/runtime/unsafe/printWasm.md

@@ -0,0 +1,24 @@
+### PrintWasm.**printI32**
+
+```grain
+printI32 : WasmI32 -> Void
+```
+
+### PrintWasm.**printI64**
+
+```grain
+printI64 : WasmI64 -> Void
+```
+
+### PrintWasm.**printF32**
+
+```grain
+printF32 : WasmF32 -> Void
+```
+
+### PrintWasm.**printF64**
+
+```grain
+printF64 : WasmF64 -> Void
+```
+

package/runtime/unsafe/tags.gr

@@ -1,6 +1,7 @@
 /* grainc-flags --compilation-mode=runtime */
 
 export let _GRAIN_NUMBER_TAG_TYPE = 0b0001n
+export let _GRAIN_CHAR_TAG_TYPE = 0b0010n
 export let _GRAIN_CONST_TAG_TYPE = 0b0110n
 export let _GRAIN_GENERIC_HEAP_TAG_TYPE = 0b0000n
 
@@ -8,14 +9,13 @@ export let _GRAIN_NUMBER_TAG_MASK = 0b0001n
 export let _GRAIN_GENERIC_TAG_MASK = 0b0111n
 
 export let _GRAIN_STRING_HEAP_TAG = 1n
-export let _GRAIN_CHAR_HEAP_TAG = 2n
-export let _GRAIN_ADT_HEAP_TAG = 3n
-export let _GRAIN_RECORD_HEAP_TAG = 4n
-export let _GRAIN_ARRAY_HEAP_TAG = 5n
-export let _GRAIN_BOXED_NUM_HEAP_TAG = 6n
-export let _GRAIN_LAMBDA_HEAP_TAG = 7n
-export let _GRAIN_TUPLE_HEAP_TAG = 8n
-export let _GRAIN_BYTES_HEAP_TAG = 9n
+export let _GRAIN_ADT_HEAP_TAG = 2n
+export let _GRAIN_RECORD_HEAP_TAG = 3n
+export let _GRAIN_ARRAY_HEAP_TAG = 4n
+export let _GRAIN_BOXED_NUM_HEAP_TAG = 5n
+export let _GRAIN_LAMBDA_HEAP_TAG = 6n
+export let _GRAIN_TUPLE_HEAP_TAG = 7n
+export let _GRAIN_BYTES_HEAP_TAG = 8n
 
 // Boxed number types
 export let _GRAIN_FLOAT32_BOXED_NUM_TAG = 1n
@@ -23,3 +23,4 @@ export let _GRAIN_FLOAT64_BOXED_NUM_TAG = 2n
 export let _GRAIN_INT32_BOXED_NUM_TAG = 3n
 export let _GRAIN_INT64_BOXED_NUM_TAG = 4n
 export let _GRAIN_RATIONAL_BOXED_NUM_TAG = 5n
+export let _GRAIN_BIGINT_BOXED_NUM_TAG = 6n