Add ByteArray support on Chez (#791)

Author: jiribenes

effekt/jvm/src/test/scala/effekt/StdlibTests.scala

@@ -22,7 +22,6 @@ class StdlibJavaScriptTests extends StdlibTests {
 abstract class StdlibChezTests extends StdlibTests {
   override def ignored: List[File] = List(
     // Not implemented yet
-    examplesDir / "stdlib" / "bytearray",
     examplesDir / "stdlib" / "io",
     examplesDir / "stdlib" / "stream" / "characters.effekt",
     examplesDir / "stdlib" / "stream" / "fuse_newlines.effekt"

examples/stdlib/bytearray/bytearray_compare.check

@@ -1,4 +1,24 @@
 Equal()
+Greater()
+Less()
+Equal()
+
+Equal()
+Greater()
+Greater()
+
 Equal()
 Greater()
-Less()
+Less()
+Equal()
+Equal()
+
+Greater()
+Less()
+Greater()
+Less()
+
+Less()
+Greater()
+Less()
+Greater()

examples/stdlib/bytearray/bytearray_compare.effekt

@@ -3,12 +3,51 @@ module examples/pos/bytearray_compare
 import bytearray
 
 def main() = {
-  val b1 = fromString("Hey")
-  val b2 = fromString("Hey")
-  val b3 = fromString("He")
-  val b4 = fromString("Heys")
-  println(compareByteArray(b1, b1))
-  println(compareByteArray(b1, b2))
-  println(compareByteArray(b1, b3))
-  println(compareByteArray(b1, b4))
+  val empty: ByteArray = "".fromString
+  val zeros: ByteArray = bytearray::allocate(8)
+  each(0, zeros.size) { i =>
+    zeros.unsafeSet(i, 0.toByte)
+  }
+  val abcs: ByteArray = bytearray::allocate(8)
+  each(0, abcs.size) { i =>
+    abcs.unsafeSet(i, (97 + i).toByte)
+  }
+
+  println(empty.compareByteArray(empty))
+  println(zeros.compareByteArray(empty))
+  println(empty.compareByteArray(zeros))
+  println(zeros.compareByteArray(zeros))
+
+  println("")
+
+  println(abcs.compareByteArray(abcs))
+  println(abcs.compareByteArray(zeros))
+  println(abcs.compareByteArray(empty))
+
+  println("")
+
+  val hey1: ByteArray = "Hey".fromString
+  val hey2: ByteArray = "Hey".fromString
+  val he: ByteArray = "He".fromString
+  val heys: ByteArray = "Heys".fromString
+
+  println(hey1.compareByteArray(hey1))
+  println(hey1.compareByteArray(empty))
+  println(empty.compareByteArray(hey1))
+  println(hey1.compareByteArray(hey2))
+  println(hey2.compareByteArray(hey1))
+
+  println("")
+
+  println(hey1.compareByteArray(he))
+  println(he.compareByteArray(hey1))
+  println(he.compareByteArray(empty))
+  println(empty.compareByteArray(he))
+
+  println("")
+
+  println(hey1.compareByteArray(heys))
+  println(heys.compareByteArray(hey1))
+  println(he.compareByteArray(heys))
+  println(heys.compareByteArray(he))
 }

libraries/common/bytearray.effekt

@@ -6,7 +6,7 @@ module bytearray
 extern type ByteArray
   // = llvm "%Pos"
   // = js "Uint8Array"
-
+  // = chez "bytevector"
 
 /// Allocates a new bytearray with the given `size`, its values are undefined.
 extern global def allocate(size: Int): ByteArray =
@@ -15,27 +15,31 @@ extern global def allocate(size: Int): ByteArray =
     %arr = call %Pos @c_bytearray_new(%Int ${size})
     ret %Pos %arr
   """
+  chez "(make-bytevector ${size})"
 
 extern pure def size(arr: ByteArray): Int =
   js "${arr}.length"
   llvm """
     %size = call %Int @c_bytearray_size(%Pos ${arr})
     ret %Int %size
   """
+  chez "(bytevector-length ${arr})"
 
 extern global def unsafeGet(arr: ByteArray, index: Int): Byte =
   js "(${arr})[${index}]"
   llvm """
     %byte = call %Byte @c_bytearray_get(%Pos ${arr}, %Int ${index})
     ret %Byte %byte
   """
+  chez "(bytevector-u8-ref ${arr} ${index})"
 
 extern global def unsafeSet(arr: ByteArray, index: Int, value: Byte): Unit =
   js "bytearray$set(${arr}, ${index}, ${value})"
   llvm """
     %z = call %Pos @c_bytearray_set(%Pos ${arr}, %Int ${index}, %Byte ${value})
     ret %Pos %z
   """
+  chez "(bytevector-u8-set! ${arr} ${index} ${value})"
 
 def resize(source: ByteArray, size: Int): ByteArray = {
   val target = allocate(size)
@@ -75,13 +79,15 @@ extern pure def fromString(str: String): ByteArray =
   llvm """
     ret %Pos ${str}
   """
+  chez "(string->utf8 ${str})"
 
 extern pure def toString(arr: ByteArray): String =
   js "(new TextDecoder('utf-8').decode(${arr}))"
   // assuming the buffer is already in UTF-8
   llvm """
     ret %Pos ${arr}
   """
+  chez "(utf8->string ${arr})"
 
 extern js """
   function bytearray$set(bytes, index, value) {
@@ -106,12 +112,29 @@ extern js """
   }
 """
 
+extern chez """
+  (define (bytearray$compare b1 b2)
+    (let ([len1 (bytevector-length b1)]
+          [len2 (bytevector-length b2)]
+          [minlen (min (bytevector-length b1) (bytevector-length b2))])
+      (let loop ([i 0])
+        (cond
+          [(= i minlen)
+          (cond [(< len1 len2) -1]
+                [(> len1 len2) 1]
+                [else 0])]
+          [(< (bytevector-u8-ref b1 i) (bytevector-u8-ref b2 i)) -1]
+          [(> (bytevector-u8-ref b1 i) (bytevector-u8-ref b2 i)) 1]
+          [else (loop (+ i 1))]))))
+"""
+
 extern pure def compareByteArrayImpl(b1: ByteArray, b2: ByteArray): Int =
   js "bytearray$compare(${b1}, ${b2})"
   llvm """
     %x = call %Int @c_bytearray_compare(%Pos ${b1}, %Pos ${b2})
     ret %Int %x
   """
+  chez "(bytearray$compare ${b1} ${b2})"
 
 def compareByteArray(b1: ByteArray, b2: ByteArray): Ordering =
   compareByteArrayImpl(b1, b2) match {

libraries/common/effekt.effekt

@@ -90,6 +90,7 @@ extern pure def show(value: Char): String =
 
 extern pure def show(value: Byte): String =
   js "'' + ${value}"
+  chez "(string ${value})"
   llvm """
     %z = call %Pos @c_bytearray_show_Byte(i8 ${value})
     ret %Pos %z
@@ -647,11 +648,13 @@ extern pure def bitwiseXor(x: Int, y: Int): Int =
 extern pure def toByte(n: Int): Byte =
   js "${n}"
   llvm "%z = trunc %Int ${n} to %Byte ret %Byte %z"
+  chez "${n}"
 
 extern pure def toInt(n: Byte): Int =
   js "${n}"
   llvm "%z = zext %Byte ${n} to %Int ret %Int %z"
   vm "effekt::toInt(Byte)"
+  chez "${n}"
 
 
 // Undefined and Null