@grain/stdlib 0.6.6 → 0.7.1

package/buffer.gr

@@ -16,13 +16,17 @@ from "runtime/unsafe/wasmi32" include WasmI32
 from "runtime/unsafe/conv" include Conv
 from "runtime/exception" include Exception
 from "runtime/dataStructures" include DataStructures
-use DataStructures.{ untagChar }
+use DataStructures.{ untagChar, tagSimpleNumber }
 from "int32" include Int32
 from "bytes" include Bytes
 from "string" include String
 from "char" include Char
 from "runtime/numbers" include Numbers
 use Numbers.{ coerceNumberToWasmI32 }
+from "runtime/utf8" include Utf8
+use Utf8.{ usvEncodeLength, utf8ByteCount, exception MalformedUnicode }
+from "runtime/unsafe/offsets" include Offsets
+use Offsets.{ _BYTES_LEN_OFFSET, _BYTES_DATA_OFFSET }
 
 abstract record Buffer {
   mut len: Number,
@@ -30,12 +34,6 @@ abstract record Buffer {
   mut data: Bytes,
 }
 
-@unsafe
-let _SIZE_OFFSET = 4n
-
-@unsafe
-let _VALUE_OFFSET = 8n
-
 let _8BIT_LEN = 1
 
 let _16BIT_LEN = 2
@@ -46,7 +44,7 @@ let _64BIT_LEN = 8
 
 /* 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)
 
 /* Doubles the size of buffer's underlying byte sequence, if the given size is larger than the size of a buffer's underlying byte sequence */
 let autogrow = (len, buf) => {
@@ -75,7 +73,11 @@ let autogrow = (len, buf) => {
 @unsafe
 let appendBytes = (srcOff, dstOff, len, src, dst) => {
   use WasmI32.{ (+) }
-  Memory.copy(dst + _VALUE_OFFSET + dstOff, src + _VALUE_OFFSET + srcOff, len)
+  Memory.copy(
+    dst + _BYTES_DATA_OFFSET + dstOff,
+    src + _BYTES_DATA_OFFSET + srcOff,
+    len
+  )
 }
 
 /*
@@ -237,7 +239,7 @@ provide let truncate = (length, buffer) => {
   let src = WasmI32.fromGrain(buffer.data)
   let size = getSize(src)
   let off = coerceNumberToWasmI32(length)
-  let ret = Memory.fill(src + _VALUE_OFFSET + off, 0n, size - off)
+  let ret = Memory.fill(src + _BYTES_DATA_OFFSET + off, 0n, size - off)
   buffer.len = length
 }
 
@@ -374,6 +376,41 @@ provide let addString = (string, buffer) => {
   buffer.len += bytelen
 }
 
+/**
+ * Gets the UTF-8 encoded character at the given byte index.
+ *
+ * @param index: The byte index to access
+ * @param buffer: The buffer to access
+ * @returns A character starting at the given index
+ *
+ * @throws IndexOutOfBounds: When `index` is negative
+ * @throws IndexOutOfBounds: When `index + 1` is greater than the buffer size
+ * @throws MalformedUnicode: When the bytes at the index are not a valid UTF-8 sequence
+ *
+ * @example
+ * let buf = Buffer.make(32)
+ * Buffer.addString("Hello World 🌾", buf)
+ * assert Buffer.getChar(12, buf) == '🌾'
+ *
+ * @since v0.7.1
+ */
+@unsafe
+provide let getChar = (index, buffer) => {
+  use WasmI32.{ (+), (&), (+), (==), (>) }
+  checkIsIndexInBounds(index, 1, buffer)
+  // Note: We do a raw check as we need the byte length before reading the full char
+  let bytes = buffer.data
+  let ptr = WasmI32.fromGrain(bytes)
+  let offset = coerceNumberToWasmI32(index)
+  let byte = WasmI32.load8U(ptr + offset, _BYTES_DATA_OFFSET)
+  let charSize = utf8ByteCount(byte)
+  if (offset + charSize > coerceNumberToWasmI32(buffer.len)) {
+    throw MalformedUnicode
+  }
+  ignore(bytes)
+  Bytes.getChar(index, bytes)
+}
+
 /**
  * Appends the bytes of a character to a buffer.
  *
@@ -389,48 +426,12 @@ provide let addString = (string, buffer) => {
  */
 @unsafe
 provide let addChar = (char, buffer) => {
-  use WasmI32.{ (-), (*), (&), (|), (>>>), ltU as (<), gtU as (>), leU as (<=) }
   let usv = untagChar(char)
-
-  let bytelen = if (usv < 0x80n) {
-    autogrow(1, buffer)
-    use WasmI32.{ (+) }
-    let off = coerceNumberToWasmI32(buffer.len)
-    let dst = WasmI32.fromGrain(buffer.data) + _VALUE_OFFSET
-    WasmI32.store8(dst, usv, off)
-    1
-  } else {
-    let mut count = 0n
-    let mut bytelen = 0
-    let mut offset = 0n
-    if (usv <= 0x07FFn) {
-      count = 1n
-      bytelen = 2
-      offset = 0xC0n
-    } else if (usv <= 0xFFFFn) {
-      count = 2n
-      bytelen = 3
-      offset = 0xE0n
-    } else {
-      count = 3n
-      bytelen = 4
-      offset = 0xF0n
-    }
-    use WasmI32.{ (+) }
-    autogrow(bytelen, buffer)
-    let off = coerceNumberToWasmI32(buffer.len)
-    let dst = WasmI32.fromGrain(buffer.data) + _VALUE_OFFSET
-    WasmI32.store8(dst, (usv >>> (6n * count)) + offset, off)
-    let mut n = 0n
-    while (count > 0n) {
-      n += 1n
-      let temp = usv >>> (6n * (count - 1n))
-      WasmI32.store8(dst + n, 0x80n | temp & 0x3Fn, off)
-      count -= 1n
-    }
-    bytelen
-  }
-  buffer.len += bytelen
+  let byteCount = tagSimpleNumber(usvEncodeLength(usv))
+  autogrow(byteCount, buffer)
+  let index = buffer.len
+  buffer.len += byteCount
+  Bytes.setChar(index, char, buffer.data)
 }
 
 /**
@@ -514,7 +515,8 @@ provide let addBytesSlice = (
     use WasmI32.{ (-), (<), (>), (>=) }
 
     // bounds check start
-    let bytelen = WasmI32.load(WasmI32.fromGrain(bytes), 4n)
+    let src = WasmI32.fromGrain(bytes)
+    let bytelen = getSize(src)
     let srcOff = coerceNumberToWasmI32(start)
     if (srcOff < 0n || srcOff >= bytelen) {
       throw IndexOutOfBounds
@@ -529,9 +531,9 @@ provide let addBytesSlice = (
     autogrow(length, buffer)
 
     let dstOff = coerceNumberToWasmI32(buffer.len)
-    let src = WasmI32.fromGrain(bytes)
     let dst = WasmI32.fromGrain(buffer.data)
     appendBytes(srcOff, dstOff, len, src, dst)
+    ignore(src)
 
     buffer.len += length
   }
@@ -624,8 +626,11 @@ provide let getInt8 = (index, buffer) => {
  * Buffer.setInt8(0, 3s, buf)
  * assert Buffer.getInt8(0, buf) == 3s
  *
+ * @deprecated Use `Bytes` instead of `Buffer` for set operations.
+ *
  * @since v0.4.0
  * @history v0.6.0: `value` argument type changed to `Int8`
+ * @history v0.7.1: Deprecated in favor of `Bytes.setInt8`
  */
 provide let setInt8 = (index, value, buffer) => {
   checkIsIndexInBounds(index, _8BIT_LEN, buffer)
@@ -691,7 +696,10 @@ provide let getUint8 = (index, buffer) => {
  * Buffer.setUint8(4us, buf)
  * assert Buffer.getUint8(0, buf) == 4us
  *
+ * @deprecated Use `Bytes` instead of `Buffer` for set operations.
+ *
  * @since v0.6.0
+ * @history v0.7.1: Deprecated in favor of `Bytes.setUint8`
  */
 provide let setUint8 = (index, value, buffer) => {
   checkIsIndexInBounds(index, _8BIT_LEN, buffer)
@@ -756,8 +764,11 @@ provide let getInt16 = (index, buffer) => {
  * Buffer.setInt16(5, 1S, buf)
  * assert Buffer.getInt16(5, buf) == 1S
  *
+ * @deprecated Use `Bytes` instead of `Buffer` for set operations.
+ *
  * @since v0.4.0
  * @history v0.6.0: `value` argument type changed to `Int16`
+ * @history v0.7.1: Deprecated in favor of `Bytes.setInt16`
  */
 provide let setInt16 = (index, value, buffer) => {
   checkIsIndexInBounds(index, _16BIT_LEN, buffer)
@@ -823,7 +834,10 @@ provide let getUint16 = (index, buffer) => {
  * Buffer.setUint16(0, 1uS, buf)
  * assert Buffer.getUint16(0, buf) == 1uS
  *
+ * @deprecated Use `Bytes` instead of `Buffer` for set operations.
+ *
  * @since v0.6.0
+ * @history v0.7.1: Deprecated in favor of `Bytes.setUint16`
  */
 provide let setUint16 = (index, value, buffer) => {
   checkIsIndexInBounds(index, _16BIT_LEN, buffer)
@@ -887,7 +901,10 @@ provide let getInt32 = (index, buffer) => {
  * Buffer.setInt32(3, 1l, buf)
  * assert Buffer.getInt32(3, buf) == 1l
  *
+ * @deprecated Use `Bytes` instead of `Buffer` for set operations.
+ *
  * @since v0.4.0
+ * @history v0.7.1: Deprecated in favor of `Bytes.setInt32`
  */
 provide let setInt32 = (index, value, buffer) => {
   checkIsIndexInBounds(index, _32BIT_LEN, buffer)
@@ -951,7 +968,10 @@ provide let getUint32 = (index, buffer) => {
  * Buffer.setUint32(0, 1ul, buf)
  * assert Buffer.getUint32(0, buf) == 1ul
  *
+ * @deprecated Use `Bytes` instead of `Buffer` for set operations.
+ *
  * @since v0.6.0
+ * @history v0.7.1: Deprecated in favor of `Bytes.setUint32`
  */
 provide let setUint32 = (index, value, buffer) => {
   checkIsIndexInBounds(index, _32BIT_LEN, buffer)
@@ -1015,7 +1035,10 @@ provide let getFloat32 = (index, buffer) => {
  * Buffer.setFloat32(0, 1.0f, buf)
  * assert Buffer.getFloat32(0, buf) == 1.0f
  *
+ * @deprecated Use `Bytes` instead of `Buffer` for set operations.
+ *
  * @since v0.4.0
+ * @history v0.7.1: Deprecated in favor of `Bytes.setFloat32`
  */
 provide let setFloat32 = (index, value, buffer) => {
   checkIsIndexInBounds(index, _32BIT_LEN, buffer)
@@ -1082,7 +1105,10 @@ provide let getInt64 = (index, buffer) => {
  * Buffer.setInt64(0, 1L, buf)
  * assert Buffer.getInt64(0, buf) == 1L
  *
+ * @deprecated Use `Bytes` instead of `Buffer` for set operations.
+ *
  * @since v0.4.0
+ * @history v0.7.1: Deprecated in favor of `Bytes.setInt64
  */
 provide let setInt64 = (index, value, buffer) => {
   checkIsIndexInBounds(index, _64BIT_LEN, buffer)
@@ -1149,7 +1175,10 @@ provide let getUint64 = (index, buffer) => {
  * Buffer.setUint64(0, 1uL, buf)
  * assert Buffer.getUint64(0, buf) == 1uL
  *
+ * @deprecated Use `Bytes` instead of `Buffer` for set operations.
+ *
  * @since v0.6.0
+ * @history v0.7.1: Deprecated in favor of `Bytes.setUint64`
  */
 provide let setUint64 = (index, value, buffer) => {
   checkIsIndexInBounds(index, _64BIT_LEN, buffer)
@@ -1216,7 +1245,10 @@ provide let getFloat64 = (index, buffer) => {
  * Buffer.setFloat64(0, 1.0F, buf)
  * assert Buffer.getFloat64(0, buf) == 1.0F
  *
+ * @deprecated Use `Bytes` instead of `Buffer` for set operations.
+ *
  * @since v0.4.0
+ * @history v0.7.1: Deprecated in favor of `Bytes.setFloat64`
  */
 provide let setFloat64 = (index, value, buffer) => {
   checkIsIndexInBounds(index, _64BIT_LEN, buffer)