@effekt-lang/effekt 0.5.0 → 0.7.0

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

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

@@ -8,29 +8,6 @@ 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, ptr)
-declare %Pos @c_buffer_concatenate(%Pos, %Pos)
-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(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)
@@ -41,3 +18,26 @@ 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)
+
+declare %Pos @c_bytearray_new(%Int)
+declare %Int @c_bytearray_size(%Pos)
+declare %Byte @c_bytearray_get(%Pos, %Int)
+declare %Pos @c_bytearray_set(%Pos, %Int, %Byte)
+
+declare ptr @c_bytearray_data(%Pos)
+declare %Pos @c_bytearray_construct(i64, ptr)
+
+declare %Pos @c_bytearray_from_nullterminated_string(ptr)
+declare ptr @c_bytearray_into_nullterminated_string(%Pos)
+
+declare %Pos @c_bytearray_show_Int(i64)
+declare %Pos @c_bytearray_show_Char(i32)
+declare %Pos @c_bytearray_show_Byte(i8)
+declare %Pos @c_bytearray_show_Double(double)
+
+declare %Pos @c_bytearray_concatenate(%Pos, %Pos)
+declare %Pos @c_bytearray_equal(%Pos, %Pos)
+
+declare %Pos @c_bytearray_substring(%Pos, i64, i64)
+declare %Int @c_bytearray_character_at(%Pos, i64)
+

package/libraries/llvm/io.c

@@ -20,8 +20,8 @@ void c_io_println_Double(const Double x) {
 }
 
 void c_io_println_String(String text) {
-    for (uint64_t j = 0; j < c_buffer_length(text); ++j)
-        putchar(c_buffer_bytes(text)[j]);
+    for (int64_t j = 0; j < c_bytearray_size(text); ++j)
+        putchar(c_bytearray_data(text)[j]);
     erasePositive(text);
     putchar('\n');
 }
@@ -34,7 +34,7 @@ void c_io_println_String(String text) {
 // Share memory between Effekt-buffers and libuv buffers
 // -----------------------------------------------------
 // A libuv buffer is a {ptr, i64} where i64 is the capacity
-// while our buffer (from buffer.c, which is ref-counted) is a %Pos with a
+// while our buffer (from bytearray.c, which is ref-counted) is a %Pos with a
 // pointer and a length. The data ptr is shared between the two such that
 // libuv (and underlying mechanisms) can directly write into our buffer without
 // copying. Since our buffer is ref-counted, this has the advantage that we
@@ -96,10 +96,10 @@ int modeFlags(struct Pos mode) {
     }
 }
 
-void c_fs_open(struct Pos path, struct Pos mode, Stack stack) {
+void c_fs_open(String path, struct Pos mode, Stack stack) {
 
     // Convert the Effekt String to a 0-terminated string
-    char* path_str = c_buffer_as_null_terminated_string(path);
+    char* path_str = c_bytearray_into_nullterminated_string(path);
     erasePositive((struct Pos) path);
 
     // Convert the Effekt String representing the opening mode to libuv flags
@@ -123,17 +123,16 @@ void c_fs_open(struct Pos path, struct Pos mode, Stack stack) {
     return;
 }
 
-void c_fs_read(Int fd, struct Pos buffer, Int offset, Stack stack) {
+void c_fs_read(Int file, struct Pos buffer, Int offset, Int size, Int position, Stack stack) {
 
-    char* bytes = (char*)c_buffer_bytes(buffer); // libuv expects signed integers
-    uv_buf_t buf = uv_buf_init(bytes, c_buffer_length(buffer));
+    uv_buf_t buf = uv_buf_init((char*)(c_bytearray_data(buffer) + offset), size);
     // erasePositive(buffer);
     // TODO we should erase the buffer but abort if this was the last reference
 
     uv_fs_t* request = malloc(sizeof(uv_fs_t));
     request->data = stack;
 
-    int result = uv_fs_read(uv_default_loop(), request, fd, &buf, 1, offset, c_resume_int_fs);
+    int result = uv_fs_read(uv_default_loop(), request, file, &buf, 1, position, c_resume_int_fs);
 
     if (result < 0) {
         uv_fs_req_cleanup(request);
@@ -142,17 +141,16 @@ void c_fs_read(Int fd, struct Pos buffer, Int offset, Stack stack) {
     }
 }
 
-void c_fs_write(Int fd, struct Pos buffer, Int offset, Stack stack) {
+void c_fs_write(Int file, struct Pos buffer, Int offset, Int size, Int position, Stack stack) {
 
-    char* bytes = (char*)c_buffer_bytes(buffer); // libuv expects signed integers
-    uv_buf_t buf = uv_buf_init(bytes, c_buffer_length(buffer));
+    uv_buf_t buf = uv_buf_init((char*)(c_bytearray_data(buffer) + offset), size);
     // erasePositive(buffer);
     // TODO we should erase the buffer but abort if this was the last reference
 
     uv_fs_t* request = malloc(sizeof(uv_fs_t));
     request->data = stack;
 
-    int result = uv_fs_write(uv_default_loop(), request, fd, &buf, 1, offset, c_resume_int_fs);
+    int result = uv_fs_write(uv_default_loop(), request, file, &buf, 1, position, c_resume_int_fs);
 
     if (result < 0) {
         uv_fs_req_cleanup(request);
@@ -161,12 +159,12 @@ void c_fs_write(Int fd, struct Pos buffer, Int offset, Stack stack) {
     }
 }
 
-void c_fs_close(Int fd, Stack stack) {
+void c_fs_close(Int file, Stack stack) {
 
     uv_fs_t* request = malloc(sizeof(uv_fs_t));
     request->data = stack;
 
-    int result = uv_fs_close(uv_default_loop(), request, fd, c_resume_int_fs);
+    int result = uv_fs_close(uv_default_loop(), request, file, c_resume_int_fs);
 
     if (result < 0) {
         uv_fs_req_cleanup(request);

package/libraries/llvm/main.c

@@ -11,7 +11,7 @@
 
 #include "sanity.c"
 #include "types.c"
-#include "buffer.c"
+#include "bytearray.c"
 #include "io.c"
 #include "hole.c"
 #include "ref.c"
@@ -25,9 +25,9 @@ char** program_argv;
 
 struct Pos c_get_arg(uint64_t idx) {
     if(idx < (uint64_t)program_argc) {
-        return c_buffer_construct_from_null_terminated_string(program_argv[idx]);
+        return c_bytearray_from_nullterminated_string(program_argv[idx]);
     } else {
-        return c_buffer_construct_zeroed(1);
+        return c_bytearray_new(0);
     }
 }
 uint64_t c_get_argc() {