@grain/stdlib 0.6.6 → 0.7.0

package/bytes.gr

@@ -18,10 +18,12 @@ from "runtime/unsafe/wasmf64" include WasmF64
 from "runtime/unsafe/conv" include Conv
 from "runtime/dataStructures" include DataStructures
 use DataStructures.{
+  tagChar,
   tagInt8,
   tagUint8,
   tagInt16,
   tagUint16,
+  untagChar,
   untagInt8,
   untagUint8,
   untagInt16,
@@ -33,11 +35,17 @@ from "runtime/exception" include Exception
 from "int32" include Int32
 from "runtime/numbers" include Numbers
 use Numbers.{ coerceNumberToWasmI32 }
+from "runtime/utf8" include Utf8
+use Utf8.{
+  utf8ByteCount,
+  getCodePoint,
+  usvEncodeLength,
+  writeUtf8CodePoint,
+  exception MalformedUnicode,
+}
+from "runtime/unsafe/offsets" include Offsets
+use Offsets.{ _BYTES_LEN_OFFSET, _BYTES_DATA_OFFSET }
 
-@unsafe
-let _SIZE_OFFSET = 4n
-@unsafe
-let _VALUE_OFFSET = 8n
 @unsafe
 let _INT8_BYTE_SIZE = 1n
 @unsafe
@@ -65,7 +73,7 @@ let checkIndexIsInBounds = (i, byteSize, max) => {
 
 /** Gets the size of a Bytes via its ptr */
 @unsafe
-let getSize = ptr => WasmI32.load(ptr, _SIZE_OFFSET)
+let getSize = ptr => WasmI32.load(ptr, _BYTES_LEN_OFFSET)
 
 /**
  * Creates a new byte sequence of the input size.
@@ -112,7 +120,7 @@ provide let fromString = (string: String) => {
   let src = WasmI32.fromGrain(string)
   let size = getSize(src)
   let dst = allocateBytes(size)
-  Memory.copy(dst + _VALUE_OFFSET, src + _VALUE_OFFSET, size)
+  Memory.copy(dst + _BYTES_DATA_OFFSET, src + _BYTES_DATA_OFFSET, size)
   ignore(string)
   WasmI32.toGrain(dst): Bytes
 }
@@ -134,7 +142,7 @@ provide let toString = (bytes: Bytes) => {
   let src = WasmI32.fromGrain(bytes)
   let size = getSize(src)
   let dst = allocateString(size)
-  Memory.copy(dst + _VALUE_OFFSET, src + _VALUE_OFFSET, size)
+  Memory.copy(dst + _BYTES_DATA_OFFSET, src + _BYTES_DATA_OFFSET, size)
   ignore(bytes)
   WasmI32.toGrain(dst): String
 }
@@ -174,7 +182,7 @@ provide let copy = (bytes: Bytes) => {
   let src = WasmI32.fromGrain(bytes)
   let size = getSize(src)
   let dst = allocateBytes(size)
-  Memory.copy(dst + _VALUE_OFFSET, src + _VALUE_OFFSET, size)
+  Memory.copy(dst + _BYTES_DATA_OFFSET, src + _BYTES_DATA_OFFSET, size)
   ignore(bytes)
   WasmI32.toGrain(dst): Bytes
 }
@@ -212,7 +220,11 @@ provide let slice = (start: Number, length: Number, bytes: Bytes) => {
   }
   let dst = allocateBytes(length)
   let offset = start
-  Memory.copy(dst + _VALUE_OFFSET, src + _VALUE_OFFSET + start, length)
+  Memory.copy(
+    dst + _BYTES_DATA_OFFSET,
+    src + _BYTES_DATA_OFFSET + start,
+    length
+  )
   ignore(bytes)
   WasmI32.toGrain(dst): Bytes
 }
@@ -264,8 +276,8 @@ provide let resize = (left: Number, right: Number, bytes: Bytes) => {
   }
   if (len > 0n) {
     Memory.copy(
-      dst + _VALUE_OFFSET + dstOffset,
-      src + _VALUE_OFFSET + srcOffset,
+      dst + _BYTES_DATA_OFFSET + dstOffset,
+      src + _BYTES_DATA_OFFSET + srcOffset,
       len
     )
   }
@@ -320,8 +332,8 @@ provide let move = (
   }
   let end = srcIndex + length
   Memory.copy(
-    dstPtr + _VALUE_OFFSET + dstIndex,
-    srcPtr + _VALUE_OFFSET + srcIndex,
+    dstPtr + _BYTES_DATA_OFFSET + dstIndex,
+    srcPtr + _BYTES_DATA_OFFSET + srcIndex,
     length
   )
   ignore(src)
@@ -370,7 +382,7 @@ provide let fill = (value: Uint8, bytes: Bytes) => {
   let src = WasmI32.fromGrain(bytes)
   let size = getSize(src)
   let v = untagUint8(value)
-  Memory.fill(src + _VALUE_OFFSET, v, size)
+  Memory.fill(src + _BYTES_DATA_OFFSET, v, size)
   ignore(bytes)
 }
 
@@ -392,7 +404,71 @@ provide let clear = (bytes: Bytes) => {
   use WasmI32.{ (+) }
   let src = WasmI32.fromGrain(bytes)
   let size = getSize(src)
-  Memory.fill(src + _VALUE_OFFSET, 0n, size)
+  Memory.fill(src + _BYTES_DATA_OFFSET, 0n, size)
+  ignore(bytes)
+}
+
+/**
+ * Gets the UTF-8 encoded character at the given byte index.
+ *
+ * @param index: The byte index to access
+ * @param bytes: The byte sequence to access
+ * @returns The character that starts at the given index
+ *
+ * @throws IndexOutOfBounds: When `index` is negative
+ * @throws MalformedUnicode: When the requested character is not a valid UTF-8 sequence
+ *
+ * @example
+ * let bytes = Bytes.fromString("Hello")
+ * assert Bytes.getChar(0, bytes) == 'H'
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let getChar = (index: Number, bytes: Bytes) => {
+  // result
+  use WasmI32.{ (+), (&), (+), (==), (>) }
+  let ptr = WasmI32.fromGrain(bytes)
+  let size = getSize(ptr)
+  let offset = coerceNumberToWasmI32(index)
+  checkIndexIsInBounds(offset, 1n, size)
+  let byte = WasmI32.load8U(ptr + offset, _BYTES_DATA_OFFSET)
+  let charSize = utf8ByteCount(byte)
+  if (offset + charSize > size) {
+    throw MalformedUnicode
+  }
+  let codePoint = getCodePoint(ptr + offset + _BYTES_DATA_OFFSET)
+  ignore(bytes)
+  tagChar(codePoint)
+}
+
+/**
+ * UTF-8 encodes a character starting at the given byte index.
+ *
+ * @param index: The byte index to update
+ * @param value: The value to set
+ * @param bytes: The byte sequence to mutate
+ *
+ * @throws IndexOutOfBounds: When `index` is negative
+ * @throws IndexOutOfBounds: When `index + charSize` is greater than the bytes size, `charSize` is the number of bytes in the character ranging from 1 to 4
+ *
+ * @example
+ * let bytes = Bytes.make(1)
+ * Bytes.setChar(0, 'a', bytes)
+ * assert Bytes.getChar(0, bytes) == 'a'
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let setChar = (index: Number, value: Char, bytes: Bytes) => {
+  use WasmI32.{ (+) }
+  let ptr = WasmI32.fromGrain(bytes)
+  let size = getSize(ptr)
+  let offset = coerceNumberToWasmI32(index)
+  let usv = untagChar(value)
+  let charSize = usvEncodeLength(usv)
+  checkIndexIsInBounds(offset, charSize, size)
+  writeUtf8CodePoint(ptr + offset + _BYTES_DATA_OFFSET, usv)
   ignore(bytes)
 }
 
@@ -421,7 +497,7 @@ provide let getInt8 = (index: Number, bytes: Bytes) => {
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT8_BYTE_SIZE, size)
-  let n = WasmI32.load8S(ptr + offset, _VALUE_OFFSET)
+  let n = WasmI32.load8S(ptr + offset, _BYTES_DATA_OFFSET)
   ignore(bytes)
   tagInt8(n)
 }
@@ -452,8 +528,8 @@ provide let setInt8 = (index: Number, value: Int8, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT8_BYTE_SIZE, size)
   let v = untagInt8(value)
+  WasmI32.store8(ptr + offset, v, _BYTES_DATA_OFFSET)
   ignore(bytes)
-  WasmI32.store8(ptr + offset, v, _VALUE_OFFSET)
 }
 
 /**
@@ -481,7 +557,7 @@ provide let getUint8 = (index: Number, bytes: Bytes) => {
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT8_BYTE_SIZE, size)
-  let n = WasmI32.load8U(ptr + offset, _VALUE_OFFSET)
+  let n = WasmI32.load8U(ptr + offset, _BYTES_DATA_OFFSET)
   ignore(bytes)
   tagUint8(n)
 }
@@ -511,7 +587,7 @@ provide let setUint8 = (index: Number, value: Uint8, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT8_BYTE_SIZE, size)
   let v = untagUint8(value)
-  WasmI32.store8(ptr + offset, v, _VALUE_OFFSET)
+  WasmI32.store8(ptr + offset, v, _BYTES_DATA_OFFSET)
   ignore(bytes)
 }
 
@@ -540,7 +616,7 @@ provide let getInt16 = (index: Number, bytes: Bytes) => {
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT16_BYTE_SIZE, size)
-  let n = WasmI32.load16S(ptr + offset, _VALUE_OFFSET)
+  let n = WasmI32.load16S(ptr + offset, _BYTES_DATA_OFFSET)
   ignore(bytes)
   tagInt16(n)
 }
@@ -571,7 +647,7 @@ provide let setInt16 = (index: Number, value: Int16, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT16_BYTE_SIZE, size)
   let v = untagInt16(value)
-  WasmI32.store16(ptr + offset, v, _VALUE_OFFSET)
+  WasmI32.store16(ptr + offset, v, _BYTES_DATA_OFFSET)
   ignore(bytes)
 }
 
@@ -600,7 +676,7 @@ provide let getUint16 = (index: Number, bytes: Bytes) => {
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT16_BYTE_SIZE, size)
-  let n = WasmI32.load16U(ptr + offset, _VALUE_OFFSET)
+  let n = WasmI32.load16U(ptr + offset, _BYTES_DATA_OFFSET)
   ignore(bytes)
   tagUint16(n)
 }
@@ -630,7 +706,7 @@ provide let setUint16 = (index: Number, value: Uint16, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT16_BYTE_SIZE, size)
   let v = untagUint16(value)
-  WasmI32.store16(ptr + offset, v, _VALUE_OFFSET)
+  WasmI32.store16(ptr + offset, v, _BYTES_DATA_OFFSET)
   ignore(bytes)
 }
 
@@ -658,7 +734,7 @@ provide let getInt32 = (index: Number, bytes: Bytes) => {
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
-  let n = WasmI32.load(ptr + offset, _VALUE_OFFSET)
+  let n = WasmI32.load(ptr + offset, _BYTES_DATA_OFFSET)
   ignore(bytes)
   Conv.toInt32(n)
 }
@@ -688,7 +764,7 @@ provide let setInt32 = (index: Number, value: Int32, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
   let v = Conv.fromInt32(value)
-  WasmI32.store(ptr + offset, v, _VALUE_OFFSET)
+  WasmI32.store(ptr + offset, v, _BYTES_DATA_OFFSET)
   ignore(bytes)
 }
 
@@ -716,7 +792,7 @@ provide let getUint32 = (index: Number, bytes: Bytes) => {
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
-  let n = WasmI32.load(ptr + offset, _VALUE_OFFSET)
+  let n = WasmI32.load(ptr + offset, _BYTES_DATA_OFFSET)
   ignore(bytes)
   Conv.toUint32(n)
 }
@@ -746,7 +822,7 @@ provide let setUint32 = (index: Number, value: Uint32, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
   let v = Conv.fromUint32(value)
-  WasmI32.store(ptr + offset, v, _VALUE_OFFSET)
+  WasmI32.store(ptr + offset, v, _BYTES_DATA_OFFSET)
   ignore(bytes)
 }
 
@@ -774,7 +850,7 @@ provide let getFloat32 = (index: Number, bytes: Bytes) => {
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
-  let n = WasmF32.load(ptr + offset, _VALUE_OFFSET)
+  let n = WasmF32.load(ptr + offset, _BYTES_DATA_OFFSET)
   ignore(bytes)
   Conv.toFloat32(n)
 }
@@ -804,7 +880,7 @@ provide let setFloat32 = (index: Number, value: Float32, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
   let v = Conv.fromFloat32(value)
-  WasmF32.store(ptr + offset, v, _VALUE_OFFSET)
+  WasmF32.store(ptr + offset, v, _BYTES_DATA_OFFSET)
   ignore(bytes)
 }
 
@@ -832,7 +908,7 @@ provide let getInt64 = (index: Number, bytes: Bytes) => {
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT64_BYTE_SIZE, size)
-  let n = WasmI64.load(ptr + offset, _VALUE_OFFSET)
+  let n = WasmI64.load(ptr + offset, _BYTES_DATA_OFFSET)
   ignore(bytes)
   Conv.toInt64(n)
 }
@@ -862,7 +938,7 @@ provide let setInt64 = (index: Number, value: Int64, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT64_BYTE_SIZE, size)
   let v = Conv.fromInt64(value)
-  WasmI64.store(ptr + offset, v, _VALUE_OFFSET)
+  WasmI64.store(ptr + offset, v, _BYTES_DATA_OFFSET)
   ignore(bytes)
 }
 
@@ -890,7 +966,7 @@ provide let getUint64 = (index: Number, bytes: Bytes) => {
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT64_BYTE_SIZE, size)
-  let n = WasmI64.load(ptr + offset, _VALUE_OFFSET)
+  let n = WasmI64.load(ptr + offset, _BYTES_DATA_OFFSET)
   ignore(bytes)
   Conv.toUint64(n)
 }
@@ -920,7 +996,7 @@ provide let setUint64 = (index: Number, value: Uint64, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT64_BYTE_SIZE, size)
   let v = Conv.fromUint64(value)
-  WasmI64.store(ptr + offset, v, _VALUE_OFFSET)
+  WasmI64.store(ptr + offset, v, _BYTES_DATA_OFFSET)
   ignore(bytes)
 }
 
@@ -948,7 +1024,7 @@ provide let getFloat64 = (index: Number, bytes: Bytes) => {
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _FLOAT64_BYTE_SIZE, size)
-  let n = WasmF64.load(ptr + offset, _VALUE_OFFSET)
+  let n = WasmF64.load(ptr + offset, _BYTES_DATA_OFFSET)
   ignore(bytes)
   Conv.toFloat64(n)
 }
@@ -978,6 +1054,6 @@ provide let setFloat64 = (index: Number, value: Float64, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _FLOAT64_BYTE_SIZE, size)
   let v = Conv.fromFloat64(value)
-  WasmF64.store(ptr + offset, v, _VALUE_OFFSET)
+  WasmF64.store(ptr + offset, v, _BYTES_DATA_OFFSET)
   ignore(bytes)
 }