@effekt-lang/effekt 0.6.0 → 0.7.0

package/libraries/common/bytearray.effekt

@@ -0,0 +1,71 @@
+module bytearray
+
+/**
+ * A memory managed, mutable, fixed-length array of bytes.
+ */
+extern type ByteArray
+  // = llvm "%Pos"
+  // = js "Uint8Array"
+
+
+/// Allocates a new bytearray with the given `size`, its values are undefined.
+extern global def allocate(size: Int): ByteArray =
+  js "(new Uint8Array(${size}))"
+  llvm """
+    %arr = call %Pos @c_bytearray_new(%Int ${size})
+    ret %Pos %arr
+  """
+
+extern pure def size(arr: ByteArray): Int =
+  js "${arr}.length"
+  llvm """
+    %size = call %Int @c_bytearray_size(%Pos ${arr})
+    ret %Int %size
+  """
+
+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
+  """
+
+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
+  """
+
+def resize(source: ByteArray, size: Int): ByteArray = {
+  val target = allocate(size)
+  val n = min(source.size, target.size)
+  def go(i: Int): ByteArray =
+    if (i < n) {
+      target.unsafeSet(i, source.unsafeGet(i))
+      go(i + 1)
+    } else {
+      target
+    }
+  go(0)
+}
+
+extern pure def fromUTF8(str: String): ByteArray =
+  js "(new TextEncoder().encode(${str}))"
+  llvm """
+    ret %Pos ${str}
+  """
+
+extern pure def toUTF8(arr: ByteArray): String =
+  js "(new TextDecoder('utf-8').decode(${arr}))"
+  // assuming the buffer is already in UTF-8
+  llvm """
+    ret %Pos ${arr}
+  """
+
+extern js """
+  function bytearray$set(bytes, index, value) {
+    bytes[index] = value;
+    return $effekt.unit;
+  }
+"""

package/libraries/common/effekt.effekt

@@ -56,7 +56,7 @@ extern pure def show(value: Int): String =
   js "'' + ${value}"
   chez "(show-number ${value})"
   llvm """
-    %z = call %Pos @c_buffer_show_Int(%Int ${value})
+    %z = call %Pos @c_bytearray_show_Int(%Int ${value})
     ret %Pos %z
   """
 
@@ -66,7 +66,7 @@ extern pure def show(value: Double): String =
   js "'' + ${value}"
   chez "(show-number ${value})"
   llvm """
-    %z = call %Pos @c_buffer_show_Double(%Double ${value})
+    %z = call %Pos @c_bytearray_show_Double(%Double ${value})
     ret %Pos %z
   """
 
@@ -80,13 +80,13 @@ extern pure def show(value: Char): String =
   js "String.fromCodePoint(${value})"
   chez "(string (integer->char ${value}))"
   llvm """
-    %z = call %Pos @c_buffer_show_Char(%Int ${value})
+    %z = call %Pos @c_bytearray_show_Char(%Int ${value})
     ret %Pos %z
   """
 
 extern pure def show(value: Byte): String =
   llvm """
-    %z = call %Pos @c_buffer_show_Byte(i8 ${value})
+    %z = call %Pos @c_bytearray_show_Byte(i8 ${value})
     ret %Pos %z
   """
 
@@ -105,7 +105,7 @@ extern pure def infixConcat(s1: String, s2: String): String =
   js "((${s1}) + (${s2}))"
   chez "(string-append ${s1} ${s2})"
   llvm """
-    %spz = call %Pos @c_buffer_concatenate(%Pos ${s1}, %Pos ${s2})
+    %spz = call %Pos @c_bytearray_concatenate(%Pos ${s1}, %Pos ${s2})
     ret %Pos %spz
   """
 
@@ -113,7 +113,7 @@ extern pure def length(str: String): Int =
   js "${str}.length"
   chez "(string-length ${str})"
   llvm """
-    %x = call %Int @c_buffer_length(%Pos ${str})
+    %x = call %Int @c_bytearray_size(%Pos ${str})
     call void @erasePositive(%Pos ${str})
     ret %Int %x
   """
@@ -122,7 +122,7 @@ extern pure def unsafeSubstring(str: String, from: Int, to: Int): String =
   js "${str}.substring(${from}, ${to})"
   chez "(substring ${str} ${from} ${to})" // potentially raises: "Exception in substring: ..."
   llvm """
-    %x = call %Pos @c_buffer_substring(%Pos ${str}, i64 ${from}, i64 ${to})
+    %x = call %Pos @c_bytearray_substring(%Pos ${str}, i64 ${from}, i64 ${to})
     ret %Pos %x
   """
 
@@ -239,7 +239,7 @@ extern pure def infixEq(x: String, y: String): Bool =
   js "${x} === ${y}"
   chez "(equal? ${x} ${y})"
   llvm """
-    %res = call %Pos @c_buffer_eq(%Pos ${x}, %Pos ${y})
+    %res = call %Pos @c_bytearray_equal(%Pos ${x}, %Pos ${y})
     ret %Pos %res
   """
 

package/libraries/common/io/filesystem.effekt

@@ -1,6 +1,6 @@
 module io/filesystem
 
-import bytes
+import bytearray
 
 import io
 import io/error
@@ -34,29 +34,21 @@ type File = Int
 
 /// Reads a file at given path as utf8 encoded string.
 def readFile(path: String): String / Exception[IOError] = {
-  val fd = open(path, ReadOnly());
-  with on[IOError].finalize { close(fd) }
+  val file = open(path, ReadOnly());
+  with on[IOError].finalize { close(file) }
 
-  val readSize = 1048576 // 1MB
-  var size = readSize
-  var buffer = bytes(size)
-  var offset = 0;
+  val chunkSize = 1048576 // 1MB
+  var buffer = bytearray::allocate(chunkSize)
+  var offset = 0
 
   def go(): String = {
-    read(fd, buffer.slice(offset, min(readSize, size - offset)), -1) match {
+    read(file, buffer, offset, chunkSize, -1) match {
       case 0 =>
-        buffer.slice(0, offset).toUTF8
-      case n and n < 0 => panic("Error!")
+        buffer.resize(offset).toUTF8
       case n =>
         offset = offset + n
-
-        // we are at maximum capacity
-        if (n == readSize && (offset + readSize) > size) {
-          val newSize   = size * 2
-          val newBuffer = bytes(newSize)
-          copy(buffer, newBuffer, 0, 0, size)
-          buffer = newBuffer
-          size = newSize
+        if (offset + chunkSize > buffer.size) {
+          buffer = buffer.resize(2 * buffer.size)
         }
         go()
     }
@@ -67,26 +59,18 @@ def readFile(path: String): String / Exception[IOError] = {
 
 /// Writes the (utf8 encoded) string `contents` into the specified file.
 def writeFile(path: String, contents: String): Unit / Exception[IOError] = {
-  val fd = open(path, WriteOnly());
-  with on[IOError].finalize { close(fd) }
+  val file = open(path, WriteOnly());
+  with on[IOError].finalize { close(file) }
 
-  val writeSize = 1048576 // 1MB
-
-  // this induces a memcpy that is not strictly necessary, since we use the buffer read-only
+  val chunkSize = 1048576 // 1MB
   val buffer = contents.fromUTF8
-  val size = buffer.size
-
   var offset = 0;
-  def remaining() = size - offset
 
-  def go(): Unit =
-    write(fd, buffer.slice(offset, min(writeSize, remaining())), -1) match {
-      case 0 => ()
-      case n and n < 0 => panic("Error!")
-      case n =>
-        offset = offset + n;
-        if (remaining() > 0) go()
-    }
+  def go(): Unit = {
+    val n = write(file, buffer, offset, min(buffer.size - offset, chunkSize), -1)
+    offset = offset + n
+    if (offset < buffer.size) { go() }
+  }
 
   go()
 }
@@ -114,14 +98,14 @@ def filesystem[R] { program: => R / Files }: R / Exception[IOError] = // TODO mo
 def open(path: String, mode: Mode): File / Exception[IOError] =
   internal::checkResult(internal::open(path, mode))
 
-def read(fd: File, buffer: Bytes, offset: Int): Int / Exception[IOError] =
-  internal::checkResult(internal::read(fd, buffer, offset))
+def read(file: File, buffer: ByteArray, offset: Int, size: Int, position: Int): Int / Exception[IOError] =
+  internal::checkResult(internal::read(file, buffer, offset, size, position))
 
-def write(fd: File, buffer: Bytes, offset: Int): Int / Exception[IOError] =
-  internal::checkResult(internal::write(fd, buffer, offset))
+def write(file: File, buffer: ByteArray, offset: Int, size: Int, position: Int): Int / Exception[IOError] =
+  internal::checkResult(internal::write(file, buffer, offset, size, position))
 
-def close(fd: File): Unit / Exception[IOError] = {
-  internal::checkResult(internal::close(fd)); ()
+def close(file: File): Unit / Exception[IOError] = {
+  internal::checkResult(internal::close(file)); ()
 }
 
 namespace internal {
@@ -174,27 +158,27 @@ namespace internal {
     const fs = require("fs");
 
     function open(path, mode, callback) {
-      fs.open(path, modeName(mode), (err, fd) => {
-        if (err) { callback(err.errno) } else { callback(fd) }
+      fs.open(path, modeName(mode), (err, file) => {
+        if (err) { callback(err.errno) } else { callback(file) }
       })
     }
 
-    function read(fd, buffer, offset, callback) {
-      let position = offset === -1 ? null : offset;
-      fs.read(fd, toBuffer(buffer), 0, buffer.length, position, (err, bytesRead) => {
+    function read(file, buffer, offset, size, position, callback) {
+      let positionOrNull = position === -1 ? null : position;
+      fs.read(file, toBuffer(buffer), offset, size, positionOrNull, (err, bytesRead) => {
         if (err) { callback(err.errno) } else { callback(bytesRead) }
       })
     }
 
-    function write(fd, buffer, offset, callback) {
-      let position = offset === -1 ? null : offset;
-      fs.write(fd, toBuffer(buffer), 0, buffer.length, position, (err, bytesWritten) => {
+    function write(file, buffer, offset, size, position, callback) {
+      let positionOrNull = position === -1 ? null : position;
+      fs.write(file, toBuffer(buffer), offset, size, positionOrNull, (err, bytesWritten) => {
         if (err) { callback(err.errno) } else { callback(bytesWritten) }
       })
     }
 
-    function close(fd, callback) {
-      fs.close(fd, (err) => {
+    function close(file, callback) {
+      fs.close(file, (err) => {
         if (err) { callback(err.errno) } else { callback(0) }
       })
     }
@@ -202,36 +186,36 @@ namespace internal {
 
   extern llvm """
     declare void @c_fs_open(%Pos, %Pos, %Stack)
-    declare void @c_fs_read(%Int, %Pos, %Int, %Stack)
-    declare void @c_fs_write(%Int, %Pos, %Int, %Stack)
+    declare void @c_fs_read(%Int, %Pos, %Int, %Int, %Int, %Stack)
+    declare void @c_fs_write(%Int, %Pos, %Int, %Int, %Int, %Stack)
     declare void @c_fs_close(%Int, %Stack)
   """
 
   extern async def open(path: String, mode: Mode): Int =
-    jsNode "$effekt.capture(k => open(${path}, ${mode}, k))"
+    jsNode "$effekt.capture(callback => open(${path}, ${mode}, callback))"
     llvm """
       call void @c_fs_open(%Pos ${path}, %Pos ${mode}, %Stack %stack)
       ret void
     """
 
-  extern async def read(fd: Int, buffer: Bytes, offset: Int): Int =
-    jsNode "$effekt.capture(k => read(${fd}, ${buffer}, ${offset}, k))"
+  extern async def read(file: Int, buffer: ByteArray, offset: Int, size: Int, position: Int): Int =
+    jsNode "$effekt.capture(callback => read(${file}, ${buffer}, ${offset}, ${size}, ${position}, callback))"
     llvm """
-      call void @c_fs_read(%Int ${fd}, %Pos ${buffer}, %Int ${offset}, %Stack %stack)
+      call void @c_fs_read(%Int ${file}, %Pos ${buffer}, %Int ${offset}, %Int ${size}, %Int ${position}, %Stack %stack)
       ret void
     """
 
-  extern async def write(fd: Int, buffer: Bytes, offset: Int): Int =
-    jsNode "$effekt.capture(k => write(${fd}, ${buffer}, ${offset}, k))"
+  extern async def write(file: Int, buffer: ByteArray, offset: Int, size: Int, position: Int): Int =
+    jsNode "$effekt.capture(callback => write(${file}, ${buffer}, ${offset}, ${size}, ${position}, callback))"
     llvm """
-      call void @c_fs_write(%Int ${fd}, %Pos ${buffer}, %Int ${offset}, %Stack %stack)
+      call void @c_fs_write(%Int ${file}, %Pos ${buffer}, %Int ${offset}, %Int ${size}, %Int ${position}, %Stack %stack)
       ret void
     """
 
-  extern async def close(fd: Int): Int =
-    jsNode "$effekt.capture(k => close(${fd}, k))"
+  extern async def close(file: Int): Int =
+    jsNode "$effekt.capture(callback => close(${file}, callback))"
     llvm """
-      call void @c_fs_close(%Int ${fd}, %Stack %stack)
+      call void @c_fs_close(%Int ${file}, %Stack %stack)
       ret void
     """
 

package/libraries/common/io/network.effekt

@@ -1,6 +1,6 @@
 module io/network
 
-import bytes
+import bytearray
 import io
 
 namespace js {
@@ -20,19 +20,19 @@ namespace js {
   extern io def listen(server: JSServer, port: Int, host: String, listener: JSSocket => Unit at {io, async, global}): Unit =
     jsNode "listen(${server}, ${port}, ${host}, (socket) => $effekt.runToplevel((ks, k) => (${listener})(socket, ks, k)))"
 
-  extern async def send(socket: JSSocket, data: Bytes): Unit =
-    jsNode "$effekt.capture(k => ${socket}.write(${data}, k))"
+  extern async def send(socket: JSSocket, data: ByteArray): Unit =
+    jsNode "$effekt.capture(callback => ${socket}.write(${data}, callback))"
 
-  extern async def receive(socket: JSSocket): Bytes =
-    jsNode "$effekt.capture(k => ${socket}.once('data', k))"
+  extern async def receive(socket: JSSocket): ByteArray =
+    jsNode "$effekt.capture(callback => ${socket}.once('data', callback))"
 
   extern async def end(socket: JSSocket): Unit =
     jsNode "$effekt.capture(k => ${socket}.end(k))"
 }
 
 interface Socket {
-  def send(message: Bytes): Unit
-  def receive(): Bytes
+  def send(message: ByteArray): Unit
+  def receive(): ByteArray
   def end(): Unit
 }
 

package/libraries/common/ref.effekt

@@ -12,7 +12,7 @@ extern js """
 /// Global, mutable references
 extern type Ref[T]
 
-/// Allocates a new reference of size `size`, keeping its value _undefined_.
+/// Allocates a new reference, keeping its value _undefined_.
 /// Prefer using `ref` constructor instead to ensure that the value is defined.
 extern global def allocate[T](): Ref[T] =
   js "{ value: undefined }"

package/libraries/common/string.effekt

@@ -14,7 +14,6 @@ import result
 /**
  * Strings
  * - JS: Strings are represented as UTF-16 code units where some characters take 2 slots (surrogate pairs)
- * - ML: Strings are sequences of 8-bit characters (https://smlfamily.github.io/Basis/string.html)
  * - Chez: Strings are sequences of unicode characters (?)
  * - LLVM: UTF-8 (characters can take from 1-4 bytes).
  */
@@ -237,14 +236,14 @@ def printing[T] { prog: => T / Stream }: T = <>
 // ----------
 //
 //   JS: Int (Unicode codepoints)
-//   CS: ?
+//   Chez: ?
 //   LLVM: i64 representing utf-8 (varying length 1-4 bytes)
 
 extern pure def toString(ch: Char): String =
   js "String.fromCodePoint(${ch})"
   chez "(string (integer->char ${ch}))"
   llvm """
-    %z = call %Pos @c_buffer_show_Char(%Int ${ch})
+    %z = call %Pos @c_bytearray_show_Char(%Int ${ch})
     ret %Pos %z
   """
 
@@ -324,16 +323,6 @@ def utf16UnitCount(codepoint: Char): Int = codepoint match {
   case c => panic("Not a valid code point")
 }
 
-// TODO this is copied from the LLVM-backend stdlib. Do we need this?
-// def showQuoted(s: String): String =
-//  "\x22" ++ s.map { c =>
-//    if(c == "\x22") {
-//     "\\\x22"
-//    } else if (c == "\\") {
-//     "\\\\"
-//    } else c
-//  } ++ "\x22"
-
 extern pure def charWidth(c: Char): Int =
   // JavaScript strings are UTF-16 where every unicode character after 0xffff takes two units
   js "(${c} > 0xffff) ? 2 : 1"
@@ -348,6 +337,6 @@ extern pure def unsafeCharAt(str: String, n: Int): Char =
   js "${str}.codePointAt(${n})"
   chez "(char->integer (string-ref ${str} ${n}))"
   llvm """
-    %x = call %Int @c_buffer_character_at(%Pos ${str}, i64 ${n})
+    %x = call %Int @c_bytearray_character_at(%Pos ${str}, %Int ${n})
     ret %Int %x
   """

package/libraries/llvm/bytearray.c

@@ -0,0 +1,209 @@
+#ifndef EFFEKT_BYTEARRAY_C
+#define EFFEKT_BYTEARRAY_C
+
+#include <string.h> // For memcopy
+
+/** We represent bytearrays like positive types.
+ *
+ *  - The field `tag` contains the size
+ *  - The field `obj` points to memory with the following layout:
+ *
+ *       +--[ Header ]--+--------------+
+ *       | Rc  | Eraser | Contents ... |
+ *       +--------------+--------------+
+ *
+ * The eraser does nothing.
+ */
+
+
+void c_bytearray_erase_noop(void *envPtr) { (void)envPtr; }
+
+struct Pos c_bytearray_new(const Int size) {
+  void *objPtr = malloc(sizeof(struct Header) + size);
+  struct Header *headerPtr = objPtr;
+  *headerPtr = (struct Header) { .rc = 0, .eraser = c_bytearray_erase_noop, };
+  return (struct Pos) {
+    .tag = size,
+    .obj = objPtr,
+  };
+}
+
+Int c_bytearray_size(const struct Pos arr) {
+  return arr.tag;
+}
+
+uint8_t* c_bytearray_data(const struct Pos arr) {
+  return arr.obj + sizeof(struct Header);
+}
+
+Byte c_bytearray_get(const struct Pos arr, const Int index) {
+  Byte *dataPtr = arr.obj + sizeof(struct Header);
+  Byte element = dataPtr[index];
+  return element;
+}
+
+struct Pos c_bytearray_set(const struct Pos arr, const Int index, const Byte value) {
+  Byte *dataPtr = arr.obj + sizeof(struct Header);
+  dataPtr[index] = value;
+  return Unit;
+}
+
+struct Pos c_bytearray_construct(const uint64_t n, const uint8_t *data) {
+    struct Pos arr = c_bytearray_new(n);
+
+    memcpy(c_bytearray_data(arr), data, n);
+
+    return arr;
+}
+
+// Complex Operations
+
+struct Pos c_bytearray_from_nullterminated_string(const char *data) {
+    uint64_t n = 0;
+    while (data[++n]);
+
+    return c_bytearray_construct(n, (uint8_t*)data);
+}
+
+char* c_bytearray_into_nullterminated_string(const struct Pos arr) {
+    uint64_t size = c_bytearray_size(arr);
+
+    char* result = (char*)malloc(size + 1);
+
+    memcpy(result, c_bytearray_data(arr), size);
+
+    result[size] = '\0';
+
+    // TODO we should erase the input
+    return result;
+}
+
+// TODO do this in Effekt
+struct Pos c_bytearray_show_Int(const Int n) {
+    char str[24];
+    sprintf(str, "%" PRId64, n);
+    return c_bytearray_from_nullterminated_string(str);
+}
+
+// TODO do this in Effekt
+struct Pos c_bytearray_show_Char(const uint64_t n) {
+    char str[5] = {0};  // Max 4 bytes for UTF-8 + 1 for null terminator
+    unsigned char *buf = (unsigned char *)str;
+
+    if (n < 0x80) {  // 1-byte sequence
+        buf[0] = (unsigned char)n;
+    } else if (n < 0x800) {  // 2-byte sequence
+        buf[0] = (unsigned char)(0xC0 | (n >> 6));
+        buf[1] = (unsigned char)(0x80 | (n & 0x3F));
+    } else if (n < 0x10000) {  // 3-byte sequence
+        buf[0] = (unsigned char)(0xE0 | (n >> 12));
+        buf[1] = (unsigned char)(0x80 | ((n >> 6) & 0x3F));
+        buf[2] = (unsigned char)(0x80 | (n & 0x3F));
+    } else if (n < 0x110000) {  // 4-byte sequence
+        buf[0] = (unsigned char)(0xF0 | (n >> 18));
+        buf[1] = (unsigned char)(0x80 | ((n >> 12) & 0x3F));
+        buf[2] = (unsigned char)(0x80 | ((n >> 6) & 0x3F));
+        buf[3] = (unsigned char)(0x80 | (n & 0x3F));
+    }
+
+    return c_bytearray_from_nullterminated_string(str);
+}
+
+// TODO do this in Effekt
+struct Pos c_bytearray_show_Byte(const Byte n) {
+    char str[4];  // Byte values range from 0 to 255, 3 characters + null terminator
+    sprintf(str, "%" PRIu8, n);
+    return c_bytearray_from_nullterminated_string(str);
+}
+
+// TODO do this in Effekt
+struct Pos c_bytearray_show_Double(const Double x) {
+    char str[64]; // TODO is this large enough? Possibly use snprintf first
+    sprintf(str, "%g", x);
+    return c_bytearray_from_nullterminated_string(str);
+}
+
+// TODO do this in Effekt
+struct Pos c_bytearray_concatenate(const struct Pos left, const struct Pos right) {
+    const struct Pos concatenated = c_bytearray_new(c_bytearray_size(left) + c_bytearray_size(right));
+    for (int64_t j = 0; j < c_bytearray_size(concatenated); ++j)
+        c_bytearray_data(concatenated)[j]
+            = j < c_bytearray_size(left)
+            ? c_bytearray_data(left)[j]
+            : c_bytearray_data(right)[j - c_bytearray_size(left)];
+
+    erasePositive(left);
+    erasePositive(right);
+    return concatenated;
+}
+
+// TODO do this in Effekt
+struct Pos c_bytearray_equal(const struct Pos left, const struct Pos right) {
+    uint64_t left_size = c_bytearray_size(left);
+    uint64_t right_size = c_bytearray_size(right);
+    if (left_size != right_size) {
+        erasePositive(left);
+        erasePositive(right);
+        return BooleanFalse;
+    }
+    for (uint64_t j = 0; j < left_size; ++j) {
+        if (c_bytearray_data(left)[j] != c_bytearray_data(right)[j]) {
+            erasePositive(left);
+            erasePositive(right);
+            return BooleanFalse;
+        }
+    }
+    erasePositive(left);
+    erasePositive(right);
+    return BooleanTrue;
+}
+
+// TODO deprecate
+struct Pos c_bytearray_substring(const struct Pos str, uint64_t start, uint64_t end) {
+    const struct Pos substr = c_bytearray_new(end - start);
+    for (int64_t j = 0; j < c_bytearray_size(substr); ++j) {
+        c_bytearray_data(substr)[j] = c_bytearray_data(str)[start+j];
+    }
+    erasePositive(str);
+    return substr;
+}
+
+// TODO deprecate
+uint32_t c_bytearray_character_at(const struct Pos str, const uint64_t index) {
+    const uint8_t *bytes = c_bytearray_data(str);
+    uint8_t first_byte = bytes[index];
+    uint32_t character = 0;
+
+    uint32_t length = c_bytearray_size(str);
+
+    if (first_byte < 0x80) {
+        // Single-byte character (0xxxxxxx)
+        character = first_byte;
+    } else if ((first_byte & 0xE0) == 0xC0) {
+        // Two-byte character (110xxxxx 10xxxxxx)
+        if (index + 1 < length) {
+            character = ((first_byte & 0x1F) << 6) |
+                        (bytes[index + 1] & 0x3F);
+        }
+    } else if ((first_byte & 0xF0) == 0xE0) {
+        // Three-byte character (1110xxxx 10xxxxxx 10xxxxxx)
+        if (index + 2 < length) {
+            character = ((first_byte & 0x0F) << 12) |
+                        ((bytes[index + 1] & 0x3F) << 6) |
+                        (bytes[index + 2] & 0x3F);
+        }
+    } else if ((first_byte & 0xF8) == 0xF0) {
+        // Four-byte character (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx)
+        if (index + 3 < length) {
+            character = ((first_byte & 0x07) << 18) |
+                        ((bytes[index + 1] & 0x3F) << 12) |
+                        ((bytes[index + 2] & 0x3F) << 6) |
+                        (bytes[index + 3] & 0x3F);
+        }
+    }
+
+    erasePositive(str);
+    return character;
+}
+
+#endif