@effekt-lang/effekt 0.2.2 → 0.4.0

package/libraries/js/effekt_builtins.js

@@ -1,7 +1,7 @@
-function show$impl(obj) {
+$effekt.show = function(obj) {
   if (!!obj && !!obj.__reflect) {
     const meta = obj.__reflect()
-    return meta.__name + "(" + meta.__data.map(show$impl).join(", ") + ")"
+    return meta.__name + "(" + meta.__data.map($effekt.show).join(", ") + ")"
   }
   else if (!!obj && obj.__unit) {
     return "()";
@@ -10,7 +10,7 @@ function show$impl(obj) {
   }
 }
 
-function equals$impl(obj1, obj2) {
+$effekt.equals = function(obj1, obj2) {
   if (!!obj1.__equals) {
     return obj1.__equals(obj2)
   } else {
@@ -18,9 +18,40 @@ function equals$impl(obj1, obj2) {
   }
 }
 
-function println$impl(obj) {
-  //return $effekt.delayed(() => { console.log(show(obj)); return $effekt.unit; });
-  console.log(show$impl(obj)); return $effekt.unit;
+function compare$prim(n1, n2) {
+  if (n1 == n2) { return 0; }
+  else if (n1 > n2) { return 1; }
+  else { return -1; }
+}
+
+$effekt.compare = function(obj1, obj2) {
+  if ($effekt.equals(obj1, obj2)) { return 0; }
+
+  if (!!obj1 && !!obj2) {
+    if (!!obj1.__reflect && !!obj2.__reflect) {
+      const tagOrdering = compare$prim(obj1.__tag, obj2.__tag)
+      if (tagOrdering != 0) { return tagOrdering; }
+
+      const meta1 = obj1.__reflect().__data
+      const meta2 = obj2.__reflect().__data
+
+      const lengthOrdering = compare$prim(meta1.length, meta2.length)
+      if (lengthOrdering != 0) { return lengthOrdering; }
+
+      for (let i = 0; i < meta1.length; i++) {
+        const contentOrdering = $effekt.compare(meta1[i], meta2[i])
+        if (contentOrdering != 0) { return contentOrdering; }
+      }
+
+      return 0;
+    }
+  }
+
+  return compare$prim(obj1, obj2);
+}
+
+$effekt.println = function println$impl(str) {
+  console.log(str); return $effekt.unit;
 }
 
 $effekt.unit = { __unit: true }

package/libraries/js/mutable/map.effekt

@@ -1,21 +1,20 @@
 module mutable/map
 
-import mutable/array
-import immutable/option
+import array
 
 // A mutable map, backed by a JavaScript Map.
 extern type Map[K, V]
 
 extern pure def emptyMap[K, V](): Map[K, V] =
-  "new Map()"
+  js "new Map()"
 
 def get[K, V](m: Map[K, V], key: K): Option[V] =
-  m.unsafeGet(key).undefinedToOption
+  undefinedToOption(m.unsafeGet(key))
 
 extern pure def unsafeGet[K, V](m: Map[K, V], key: K): V =
-  "${m}.get(${key})"
+  js "${m}.get(${key})"
 
-extern """
+extern js """
 function map$update(m, key, value) {
   m.set(key, value);
   return $effekt.unit
@@ -23,10 +22,10 @@ function map$update(m, key, value) {
 """
 
 extern io def update[K, V](m: Map[K, V], key: K, value: V): Unit =
-  "map$update(${m}, ${key}, ${value})"
+  js "map$update(${m}, ${key}, ${value})"
 
 extern pure def values[K, V](map: Map[K, V]): Array[V] =
-  "Array.from(${map}.values())"
+  js "Array.from(${map}.values())"
 
 extern pure def keys[K, V](map: Map[K, V]): Array[K] =
-  "Array.from(${map}.keys())"
+  js "Array.from(${map}.keys())"

package/libraries/js/text/regex.effekt

@@ -1,27 +1,26 @@
 module text/regex
 
-import text/string
-import immutable/option
+import string
 
 extern type Regex
 
 record Match(matched: String, index: Int)
 
 extern pure def regex(str: String): Regex =
-  "new RegExp(${str})"
+  js "new RegExp(${str})"
 
 def exec(reg: Regex, str: String): Option[Match] =
-  reg.unsafeExec(str).undefinedToOption match {
+   undefinedToOption(reg.unsafeExec(str)) match {
     case None() => None()
     case Some(v) => Some(Match(v.matched, v.index))
   }
 
 // internal representation { matched: String, index: Int }
 extern type RegexMatch
-extern pure def matched(r: RegexMatch): String = "${r}.matched"
-extern pure def index(r: RegexMatch): Int = "${r}.index"
+extern pure def matched(r: RegexMatch): String = js "${r}.matched"
+extern pure def index(r: RegexMatch): Int = js "${r}.index"
 
-extern """
+extern js """
 function regex$exec(reg, str) {
   var res = reg.exec(str);
   if (res === null) { return undefined }
@@ -31,4 +30,4 @@ function regex$exec(reg, str) {
 
 // internals
 extern io def unsafeExec(reg: Regex, str: String): RegexMatch =
-  "regex$exec(${reg}, ${str})"
+  js "regex$exec(${reg}, ${str})"

package/libraries/js/unsafe/cont.effekt

@@ -4,8 +4,8 @@ module unsafe/cont
 extern type Cont[A, B]
 
 // we mark this as {io} since pure functions should not take block parameters.
-extern io def cont[A, B] { r: A => B / {} }: Cont[A, B] = "${box r}"
+extern io def cont[A, B] { r: A => B / {} }: Cont[A, B] = js "${box r}"
 
 // This is unsafe if the continuation left the scope of the
 // capabilities it closed over
-extern control def apply[A, B](k: Cont[A, B], a: A): B / {} = "${k}(${a})"
+extern async def apply[A, B](k: Cont[A, B], a: A): B / {} = js "${k}(${a})"

package/libraries/js/web/dom.effekt

@@ -4,42 +4,42 @@ extern type Node
 
 // can be null
 extern pure def getElementById(id: String): Node =
-  "document.getElementById(${id})"
+  js "document.getElementById(${id})"
 
 extern pure def createElement(tag: String): Node =
-  "document.createElement(${tag})"
+  js "document.createElement(${tag})"
 
 extern pure def createTextNode(text: String): Node =
-  "document.createTextNode(${text})"
+  js "document.createTextNode(${text})"
 
 extern pure def setAttribute(node: Node, key: String, value: String): Node =
-  "${node}.setAttribute(${key}, ${value})"
+  js "${node}.setAttribute(${key}, ${value})"
 
 // the string return type is wrong here...
 extern pure def getAttribute(node: Node, key: String): String =
-  "${node}.getAttribute(${key})"
+  js "${node}.getAttribute(${key})"
 
 extern pure def appendChild(node: Node, child: Node): Node =
-  "${node}.appendChild(${child})"
+  js "${node}.appendChild(${child})"
 
 extern pure def innerHTML(node: Node, contents: String): Node =
-  "(function() { ${node}.innerHTML = ${contents}; return ${node} })()"
+  js "(function() { ${node}.innerHTML = ${contents}; return ${node} })()"
 
 extern type IdleDeadline
 
 extern pure def requestIdleCallback(callback: (IdleDeadline) => Unit at {io}): Unit =
-  "window.requestIdleCallback(deadline => ${callback}(deadline).run())"
+  js "window.requestIdleCallback(deadline => ${callback}(deadline).run())"
 
-extern pure def didDimeout(deadline: IdleDeadline): Boolean =
-  "${deadline}.didTimeout"
+extern pure def didDimeout(deadline: IdleDeadline): Bool =
+  js "${deadline}.didTimeout"
 
 extern pure def timeRemaining(deadline: IdleDeadline): Double =
-  "${deadline}.timeRemaining()"
+  js "${deadline}.timeRemaining()"
 
 extern pure def onClick(node: Node, handler: () => Unit at {io}): Node =
-  "(function() { ${node}.onclick = () => ${handler}().run(); return ${node} })()"
+  js "(function() { ${node}.onclick = () => ${handler}().run(); return ${node} })()"
 
 extern def sleep(n: Int): Unit =
-  "$effekt.callcc(k => window.setTimeout(() => k(null), ${n}))"
+  js "$effekt.callcc(k => window.setTimeout(() => k(null), ${n}))"
 
 def clear(node: Node) = node.innerHTML("")

package/libraries/llvm/array.c

@@ -0,0 +1,53 @@
+#ifndef EFFEKT_ARRAY_C
+#define EFFEKT_ARRAY_C
+
+/** We represent arrays like positive types.
+ *  The tag is 0 and the obj points to memory with the following layout:
+ *
+ *   +--[ Header ]--+------+------------+
+ *   | Rc  | Eraser | Size | Fields ... |
+ *   +--------------+------+------------+
+ */
+
+void c_array_erase_fields(void *envPtr) {
+  uint64_t *sizePtr = envPtr;
+  struct Pos *dataPtr = envPtr + sizeof(uint64_t);
+  uint64_t size = *sizePtr;
+  for (uint64_t i = 0; i < size; i++) {
+    erasePositive(dataPtr[i]);
+  }
+}
+
+struct Pos c_array_new(const Int size) {
+  void *objPtr = calloc(sizeof(struct Header) + sizeof(uint64_t) + size * sizeof(struct Pos), 1);
+  struct Header *headerPtr = objPtr;
+  uint64_t *sizePtr = objPtr + sizeof(struct Header);
+  *headerPtr = (struct Header) { .rc = 0, .eraser = c_array_erase_fields, };
+  *sizePtr = size;
+  return (struct Pos) {
+    .tag = 0,
+    .obj = objPtr,
+  };
+}
+
+Int c_array_size(const struct Pos arr) {
+  uint64_t *sizePtr = arr.obj + sizeof(struct Header);
+  return *sizePtr;
+}
+
+struct Pos c_array_get(const struct Pos arr, const Int index) {
+  struct Pos *dataPtr = arr.obj + sizeof(struct Header) + sizeof(uint64_t);
+  struct Pos element = dataPtr[index];
+  sharePositive(element);
+  return element;
+}
+
+struct Pos c_array_set(const struct Pos arr, const Int index, const struct Pos value) {
+  struct Pos *dataPtr = arr.obj + sizeof(struct Header) + sizeof(uint64_t);
+  struct Pos element = dataPtr[index];
+  erasePositive(element);
+  dataPtr[index] = value;
+  return Unit;
+}
+
+#endif

package/libraries/llvm/buffer.c

@@ -1,10 +1,22 @@
 #ifndef EFFEKT_BUFFER_C
 #define EFFEKT_BUFFER_C
 
-// NOTE: Buffers are NOT 0-terminated!
-
 #include "stdlib.h"
 #include <stdint.h>
+#include <string.h> // For memcopy
+
+/** We represent buffers like positive types.
+ *
+ *  - The field `tag` contains offset (32bit) and length (32bit), which is equal to
+ *    the tag (64bit) in Pos;
+ *  - The field `obj` points to memory with the following layout:
+ *
+ *       +--[ Header ]--+--------------+
+ *       | Rc  | Eraser | Contents ... |
+ *       +--------------+--------------+
+ *
+ * The eraser is always a null pointer since it does not need to do anything.
+ */
 
 // TODO It may be performance-advantageous to implement this C file's semantics
 // in LLVM, since the linker cannot realistically be asked to satisfactorily
@@ -13,113 +25,123 @@
 // with clang-generated LLVM from this file's entire translation unit.
 
 
-// Eight bytes for the reference counter.
-// E.g. capacity could later also be stored in the header.
-#define BUFFER_HEADER_WIDTH (8)
+struct Pos c_buffer(const uint32_t offset, const uint32_t length, void* obj) {
+    return (struct Pos) {
+        .tag = ((uint64_t)offset << 32) | (uint32_t)length,
+        .obj = obj,
+    };
+}
 
-uint64_t c_buffer_length(const struct Pos buffer) {
-    return buffer.tag;
+void c_buffer_erase_noop(void *envPtr) { (void)envPtr; }
+
+uint64_t c_buffer_offset(const struct Pos buffer) {
+    return (uint32_t)(buffer.tag >> 32); // Extract offset from the upper 32 bits
 }
 
-// NOTE: This assumes a homogenously used byte order.
-uint64_t *c_buffer_refcount(const struct Pos buffer) {
-    return (uint64_t *) (buffer.obj + 0);
+// Function to get the length from Pos
+// WARNING: This does not erase the Pos argument!
+uint64_t c_buffer_length(const struct Pos buffer) {
+    return (uint32_t)(buffer.tag & 0xFFFFFFFF); // Extract length from the lower 32 bits
 }
 
 uint8_t *c_buffer_bytes(const struct Pos buffer) {
-    return (uint8_t *) (buffer.obj + BUFFER_HEADER_WIDTH);
+    return (uint8_t *) (buffer.obj + sizeof(struct Header) + c_buffer_offset(buffer));
 }
 
-
 struct Pos c_buffer_construct(const uint64_t n, const uint8_t *data) {
-    uint8_t *obj = malloc(BUFFER_HEADER_WIDTH + n * sizeof *obj);
-    ASSERT_NON_NULL(obj)
+    uint8_t *obj = (uint8_t *)malloc(sizeof(struct Header) + n * sizeof *obj);
+    ASSERT_NON_NULL(obj);
 
-    // reference count (a reference count of zero means one sole owner)
-    for (uint64_t j = 0; j < BUFFER_HEADER_WIDTH; ++j)
-        obj[j] = 0;
+    struct Header *header = (void*) obj;
+    *header = (struct Header) { .rc = 0, .eraser = c_buffer_erase_noop, };
 
-    // data
-    for (uint64_t j = 0; j < n; ++j)
-        obj[BUFFER_HEADER_WIDTH + j] = data[j];
+    // Copy data
+    memcpy(obj + sizeof(struct Header), data, n);
 
-    return (struct Pos) {
-        .tag = n,
-        .obj = obj,
-    };
+    return c_buffer(0, n, obj);
 }
 
-void c_buffer_destruct(const struct Pos buffer) {
-    free(buffer.obj);
+struct Pos c_buffer_construct_zeroed(const uint64_t n) {
+    uint8_t *zeroes = calloc(sizeof(struct Header) + n, sizeof *zeroes);
+    ASSERT_NON_NULL(zeroes)
+
+    struct Header *header = (void*) zeroes;
+    *header = (struct Header) { .rc = 0, .eraser = c_buffer_erase_noop, };
+
+    return c_buffer(0, n, zeroes);
 }
 
+struct Pos c_buffer_construct_uninitialized(const uint64_t n) {
+    uint8_t *data = malloc(sizeof(struct Header) + n * sizeof *data);
+    ASSERT_NON_NULL(data)
 
-void c_buffer_refcount_increment(const struct Pos buffer) {
-    if (DEBUG_REFCOUNT) {
-        fprintf(stderr, "c_buffer_refcount_increment((struct Pos) "
-            "{ .tag = %" PRIu64 ", .obj = %p }): from %" PRIu64 "\n",
-            buffer.tag, buffer.obj, *(c_buffer_refcount(buffer)));
-        fflush(stderr);
-    }
+    struct Header *header = (void*) data;
+    *header = (struct Header) { .rc = 0, .eraser = c_buffer_erase_noop, };
 
-    (*c_buffer_refcount(buffer))++;
+    return c_buffer(0, n, data);
 }
 
-void c_buffer_refcount_decrement(const struct Pos buffer) {
-    if (DEBUG_REFCOUNT) {
-        fprintf(stderr, "c_buffer_refcount_decrement((struct Pos) "
-            "{ .tag = %" PRIu64 ", .obj = %p }): from %" PRIu64 "\n",
-            buffer.tag, buffer.obj, *(c_buffer_refcount(buffer)));
-        fflush(stderr);
-    }
+struct Pos c_buffer_slice(struct Pos buffer, const uint64_t offset, const uint64_t length) {
 
-    if (!(*c_buffer_refcount(buffer))--)
-        c_buffer_destruct(buffer);
-}
+    if ((c_buffer_offset(buffer) + offset + length) > c_buffer_length(buffer))
+        return buffer;
 
+    return c_buffer(c_buffer_offset(buffer) + offset, length, buffer.obj);
+}
 
-struct Pos c_buffer_construct_zeroed(const uint64_t n) {
-    uint8_t *zeroes = calloc(n, sizeof *zeroes);
-    ASSERT_NON_NULL(zeroes)
-    const struct Pos buffer = c_buffer_construct(n, zeroes);
-    free(zeroes);
-    return buffer;
+struct Pos c_buffer_clone(const struct Pos buffer) {
+    return c_buffer_construct(c_buffer_length(buffer), c_buffer_bytes(buffer));
 }
 
-void c_buffer_truncate(struct Pos buffer, const uint64_t n) {
-    if (n > c_buffer_length(buffer))
+void c_buffer_copy(const struct Pos from, struct Pos to, uint64_t startFrom, uint64_t startTo, uint64_t length) {
+    // Check bounds
+    if ((startFrom + length > c_buffer_length(from)) || (startTo + length > c_buffer_length(to))) {
         return;
-    buffer.tag = n;
-}
+    }
 
-struct Pos c_buffer_copy(const struct Pos buffer) {
-    return c_buffer_construct(c_buffer_length(buffer), c_buffer_bytes(buffer));
+    // Get pointers to the source and destination slices
+    uint8_t *from_bytes = c_buffer_bytes(from) + startFrom;
+    uint8_t *to_bytes = c_buffer_bytes(to) + startTo;
+
+    // Copy bytes from `from` to `to`
+    memcpy(to_bytes, from_bytes, length);
 }
 
 
-// incurs a malloc: the returned pointer needs to be managed
-char *c_buffer_as_null_terminated_string(const struct Pos buffer) {
-    // Zero runes are represented as non-minimal utf8 in the null-terminated
-    // string. As such, a count reveals the necessary number of bytes.
+/**
+ * Converts a buffer to a null-terminated string, handling zero bytes by encoding them as non-minimal UTF-8 sequences.
+ *
+ * Note: the returned pointer needs to be managed manually!
+ *
+ * @param buffer The buffer to convert.
+ * @return A null-terminated string representing the contents of the buffer.
+ */
+char* c_buffer_as_null_terminated_string(const struct Pos buffer) {
+    uint64_t length = c_buffer_length(buffer);
     uint64_t zero_runes = 0;
-    for (uint64_t j = 0; j < c_buffer_length(buffer); ++j)
-        zero_runes += !c_buffer_bytes(buffer)[j];
+    uint8_t* bytes = c_buffer_bytes(buffer);
+
+    // Count zero runes
+    for (uint64_t j = 0; j < length; ++j) {
+        zero_runes += !bytes[j];
+    }
 
-    const uint64_t n = c_buffer_length(buffer) + zero_runes;
-    char *buf = (char *) malloc((n+1) * sizeof *buf);
+    // Allocate buffer for the null-terminated string
+    uint64_t n = length + zero_runes;
+    char *buf = (char *) malloc((n + 1) * sizeof(*buf));
     ASSERT_NON_NULL(buf)
 
     uint64_t i = 0;
-    for (uint64_t j = 0; j < c_buffer_length(buffer); ++j) {
-        buf[i++] = c_buffer_bytes(buffer)[j];
-        if (!buf[i]) {
-            buf[i]   = 0xc0; // 0b110.00000
-            buf[i++] = 0x80; // 0b10.000000
+    for (uint64_t j = 0; j < length; ++j) {
+        buf[i++] = bytes[j];
+        if (buf[i-1] == 0) {
+            buf[i-1] = 0xc0; // 0b11000000
+            buf[i++] = 0x80; // 0b10000000
         }
     }
 
-    // null-terminated
-    buf[n] = '\00';
+    // Null-terminate the string
+    buf[n] = '\0';
 
     return buf;
 }
@@ -140,18 +162,29 @@ struct Pos c_buffer_concatenate(const struct Pos left, const struct Pos right) {
             = j < c_buffer_length(left)
             ? c_buffer_bytes(left)[j]
             : c_buffer_bytes(right)[j - c_buffer_length(left)];
+
+    erasePositive(left);
+    erasePositive(right);
     return concatenated;
 }
 
 struct Pos c_buffer_eq(const struct Pos left, const struct Pos right) {
     uint64_t left_len = c_buffer_length(left);
     uint64_t right_len = c_buffer_length(right);
-    if(left_len != right_len) return BooleanFalse;
-    for(uint64_t j = 0; j < left_len; ++j) {
-        if(c_buffer_bytes(left)[j] != c_buffer_bytes(right)[j]) {
+    if (left_len != right_len) {
+        erasePositive(left);
+        erasePositive(right);
+        return BooleanFalse;
+    }
+    for (uint64_t j = 0; j < left_len; ++j) {
+        if (c_buffer_bytes(left)[j] != c_buffer_bytes(right)[j]) {
+            erasePositive(left);
+            erasePositive(right);
             return BooleanFalse;
         }
     }
+    erasePositive(left);
+    erasePositive(right);
     return BooleanTrue;
 }
 
@@ -160,6 +193,7 @@ struct Pos c_buffer_substring(const struct Pos str, uint64_t start, uint64_t end
     for (uint64_t j = 0; j < c_buffer_length(substr); ++j) {
         c_buffer_bytes(substr)[j] = c_buffer_bytes(str)[start+j];
     }
+    erasePositive(str);
     return substr;
 }
 
@@ -168,14 +202,85 @@ struct Pos c_buffer_show_Int(const Int n) {
     sprintf(str, "%" PRId64, n);
     return c_buffer_construct_from_null_terminated_string(str);
 }
+
+struct Pos c_buffer_show_Byte(const uint8_t n) {
+    char str[4];  // Byte values range from 0 to 255, 3 characters + null terminator
+    sprintf(str, "%" PRIu8, n);
+    return c_buffer_construct_from_null_terminated_string(str);
+}
+
+struct Pos c_buffer_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_buffer_construct_from_null_terminated_string(str);
+}
+
 struct Pos c_buffer_show_Double(const Double x) {
     char str[64]; // TODO is this large enough? Possibly use snprintf first
     sprintf(str, "%g", x);
     return c_buffer_construct_from_null_terminated_string(str);
 }
 
-uint64_t c_buffer_index(const struct Pos str, const uint64_t index) {
-    return c_buffer_bytes(str)[index];
+uint64_t c_buffer_index(const struct Pos buffer, const uint64_t index) {
+    return c_buffer_bytes(buffer)[index];
+}
+
+void c_buffer_set(struct Pos buffer, const uint64_t index, uint8_t value) {
+    c_buffer_bytes(buffer)[index] = value;
+}
+
+uint32_t c_buffer_character_at(const struct Pos buffer, const uint64_t index) {
+    const uint8_t *bytes = c_buffer_bytes(buffer);
+    uint8_t first_byte = bytes[index];
+    uint32_t character = 0;
+
+    uint32_t length = c_buffer_length(buffer);
+
+    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(buffer);
+    return character;
 }
 
 #endif

package/libraries/llvm/forward-declare-c.ll

@@ -8,17 +8,36 @@ declare void @c_io_println_Int(%Int)
 declare void @c_io_println_Double(%Double)
 declare void @c_io_println_String(%Pos)
 
-declare %Pos @c_buffer_construct(i64, i8*)
-declare void @c_buffer_refcount_increment(%Pos)
-declare void @c_buffer_refcount_decrement(%Pos)
+declare %Pos @c_buffer_construct(i64, ptr)
 declare %Pos @c_buffer_concatenate(%Pos, %Pos)
-
-declare void @hole()
+declare ptr @c_buffer_as_null_terminated_string(%Pos)
+declare %Pos @c_buffer_construct_from_null_terminated_string(ptr)
+declare ptr @c_buffer_construct_uninitialized(i64)
+declare ptr @c_buffer_bytes(ptr)
+declare void @c_buffer_copy(%Pos, %Pos, i64, i64, i64)
+declare %Pos @c_buffer_clone(%Pos)
 
 declare %Pos @c_buffer_eq(%Pos, %Pos)
 declare %Pos @c_buffer_substring(%Pos, i64, i64)
 declare i64 @c_buffer_length(%Pos)
 declare i64 @c_buffer_toInt(%Pos)
-declare %Pos @c_buffer_show_Int(%Pos)
-declare %Pos @c_buffer_show_Double(%Pos)
-declare %Int @c_buffer_index(%Pos)
+declare %Pos @c_buffer_show_Int(i64)
+declare %Pos @c_buffer_show_Char(i32)
+declare %Pos @c_buffer_show_Byte(i8)
+declare %Pos @c_buffer_show_Double(double)
+declare %Int @c_buffer_index(%Pos, i64)
+declare void @c_buffer_set(%Pos, i64, i8)
+declare %Int @c_buffer_character_at(%Pos, i64)
+
+declare %Pos @c_buffer_slice(%Pos, i64, i64)
+
+declare void @hole()
+
+declare %Pos @c_ref_fresh(%Pos)
+declare %Pos @c_ref_get(%Pos)
+declare %Pos @c_ref_set(%Pos, %Pos)
+
+declare %Pos @c_array_new(%Int)
+declare %Int @c_array_size(%Pos)
+declare %Pos @c_array_get(%Pos, %Int)
+declare %Pos @c_array_set(%Pos, %Int, %Pos)