Stdlib: Binary/Byte stream utilities

effekt/shared/src/main/scala/effekt/core/vm/Builtin.scala

@@ -150,6 +150,9 @@ lazy val integers: Builtins = Map(
   builtin("effekt::bitwiseXor(Int, Int)") {
     case As.Int(x) :: As.Int(y) :: Nil => Value.Int(x ^ y)
   },
+  builtin("effekt::bitwiseNot(Int)") {
+    case As.Int(x) :: Nil => Value.Int(~x)
+  },
 
   // Comparison
   // ----------

examples/stdlib/acme.effekt

@@ -5,6 +5,7 @@ module acme
 import args
 import array
 import bench
+import binstream
 import buffer
 import bytearray
 import char

examples/stdlib/binstream.check

@@ -0,0 +1,21 @@
+Binstream
+✓ literal hex 10
+✓ literal hex ff
+✓ literal char a
+✓ literal string ba
+✓ int back-and-forth (17)
+✓ int back-and-forth (17), explicit BE
+✓ int back-and-forth (17), explicit LE
+✓ byte 00101010
+✓ to bits and back
+✓ to bits and back LE bitorder
+✓ to bits and back BE bitorder
+✓ append 0 means *2
+✓ pow agrees with double one
+✓ LE 2s-complement
+✓ BE 2s-complement
+
+ 15 pass
+ 0 fail
+ 15 tests total
+

examples/stdlib/binstream.effekt

@@ -0,0 +1,55 @@
+import binstream
+import stream
+import test
+
+def main() = {
+  suite("Binstream", false){
+    test("literal hex 10"){ assert(x"10${()}", 16) }
+    test("literal hex ff"){ assert(x"ff${()}", 255) }
+    test("literal char a"){ assert(x"${'a'}", x"61${()}") }
+    test("literal string ba"){ assert(x"${"ba"}", x"62${()}" * 256 + x"61${()}") }
+    test("int back-and-forth (17)"){ assert(x"${17}", 17)}
+    test("int back-and-forth (17), explicit BE"){ assert(x"${17.BE}", 17) }
+    test("int back-and-forth (17), explicit LE"){ assert(x"${17.LE}", 17 * 256 * 256 * 256) }
+    test("byte 00101010"){
+      with on[MissingValue].default{ assert(true, false) }
+      assert(first[Byte]{groupBytes{ bit"00101010${()}" }}.toInt, 42)
+    }
+    test("to bits and back"){ 
+      with on[MissingValue].default{ assert(true, false) }
+      [42.toByte, 12.toByte, 113.toByte, 0.toByte, 255.toByte].foreach{ v =>
+        assert(first[Byte]{ groupBytes{ bits(v) } }, v)
+      }
+    }
+    test("to bits and back LE bitorder"){ 
+      with on[MissingValue].default{ assert(true, false) }
+      [42.toByte, 12.toByte, 113.toByte, 0.toByte, 255.toByte].foreach{ v =>
+        assert(first[Byte]{ groupBytesLE{ bitsLE(v) } }, v)
+      }
+    }
+    test("to bits and back BE bitorder"){ 
+      with on[MissingValue].default{ assert(true, false) }
+      [42.toByte, 12.toByte, 113.toByte, 0.toByte, 255.toByte].foreach{ v =>
+        assert(first[Byte]{ groupBytesBE{ bitsBE(v) } }, v)
+      }
+    }
+    test("append 0 means *2"){
+      with on[MissingValue].default{ assert(true, false) }
+      [42.toByte, 12.toByte, 127.toByte].foreach{ v =>
+        assert(nth[Byte](1){ groupBytes{ repeat(7){ do emit(B0()) }; bits(v); do emit(B0()) } }, (v.toInt * 2).toByte)
+      }
+    }
+    test("pow agrees with double one"){
+      assert(pow(2,5), pow(2.0,5).toInt)
+    }
+    test("LE 2s-complement"){
+      with on[MissingValue].default{ assert(true, false) }
+      assert(first[Byte]{ groupBytesLE{ twoscomplementLE{ bitsLE(6.toByte) } } }, 250.toByte)
+    }
+    test("BE 2s-complement"){
+      with on[MissingValue].default{ assert(true, false) }
+      assert(first[Byte]{ groupBytesBE{ bit"${-6.Signed.BE.OfWidth(8)}" } }, 250.toByte)
+    }
+  }
+  ()
+}