Rewrite with working async

lib/rt/str.h

@@ -1,40 +1,44 @@
-// Strings: UTF-16 code units, as JS counts them, and the string natives
+// Strings: UTF-16 code units, as JS counts them
 #pragma once
 
 #include "core.h"
 
-string_t jsrt_string_lit(const char *utf8);
-string_t jsrt_string_from_utf8(const char *utf8, size_t size);
-int32_t jsrt_string_length(string_t s);
-bool jsrt_string_eq(string_t a, string_t b);
-int32_t jsrt_string_cmp(string_t a, string_t b);
-
-// `s[i]`: the code unit at `i`, as a string, or JSRT_UNDEFINED past the end
-string_t jsrt_string_at(string_t s, int32_t i);
-
-#ifdef JSRT_IMPLEMENTATION
-#include <stdlib.h>
-#include <string.h>
-
+// A string. The emitted C makes its literals as static strings of this
 struct jsrt_string {
     int32_t length;
     uint16_t units[];
 };
 
-static string_t jsrt_string_new(int32_t length) {
-    string_t s = jsrt_alloc(sizeof *s + (size_t)length * sizeof(uint16_t));
+string_t __rt_string_lit(const char *utf8);
+string_t __rt_string_from_utf8(const char *utf8, size_t size);
+int32_t __rt_string_length(string_t s);
+bool __rt_string_eq(string_t a, string_t b);
+int32_t __rt_string_cmp(string_t a, string_t b);
+
+// `a + b`
+string_t __rt_string_concat(string_t a, string_t b);
+
+// `s[i]`: the code unit at `i`, as a string. `i` must be in the string
+string_t __rt_string_at(string_t s, int32_t i);
+
+#ifdef JSRT_IMPLEMENTATION
+#include <stdlib.h>
+#include <string.h>
+
+static string_t __rt_string_new(int32_t length) {
+    string_t s = __rt_alloc(sizeof *s + (size_t)length * sizeof(uint16_t));
     s->length = length;
     return s;
 }
 
-string_t jsrt_string_lit(const char *utf8) {
-    return jsrt_string_from_utf8(utf8, strlen(utf8));
+string_t __rt_string_lit(const char *utf8) {
+    return __rt_string_from_utf8(utf8, strlen(utf8));
 }
 
 // The `size` bytes at `utf8`, which need not end in a 0
-string_t jsrt_string_from_utf8(const char *utf8, size_t size) {
+string_t __rt_string_from_utf8(const char *utf8, size_t size) {
     const unsigned char *p = (const unsigned char *)utf8, *end = p + size;
-    string_t s = jsrt_string_new((int32_t)size * 2);
+    string_t s = __rt_string_new((int32_t)size * 2);
     int32_t n = 0;
 
     while (p < end) {
@@ -59,15 +63,15 @@ string_t jsrt_string_from_utf8(const char *utf8, size_t size) {
     return s;
 }
 
-int32_t jsrt_string_length(string_t s) {
+int32_t __rt_string_length(string_t s) {
     return s->length;
 }
 
-bool jsrt_string_eq(string_t a, string_t b) {
+bool __rt_string_eq(string_t a, string_t b) {
     return a->length == b->length && !memcmp(a->units, b->units, (size_t)a->length * sizeof(uint16_t));
 }
 
-int32_t jsrt_string_cmp(string_t a, string_t b) {
+int32_t __rt_string_cmp(string_t a, string_t b) {
     int32_t n = a->length < b->length ? a->length : b->length;
 
     for (int32_t i = 0; i < n; i++) {
@@ -79,19 +83,36 @@ int32_t jsrt_string_cmp(string_t a, string_t b) {
     return a->length < b->length ? -1 : a->length > b->length;
 }
 
-string_t jsrt_string_at(string_t s, int32_t i) {
-    if (i < 0 || i >= s->length) {
-        return JSRT_UNDEFINED;
+string_t __rt_string_concat(string_t a, string_t b) {
+    string_t s = __rt_string_new(a->length + b->length);
+    memcpy(s->units, a->units, (size_t)a->length * sizeof(uint16_t));
+    memcpy(s->units + a->length, b->units, (size_t)b->length * sizeof(uint16_t));
+    return s;
+}
+
+// The strings of one ASCII unit, made once each, the first time they are needed
+static string_t __rt_ascii_strings[128];
+
+string_t __rt_string_at(string_t s, int32_t i) {
+    uint16_t unit = s->units[i];
+
+    if (unit < 128 && __rt_ascii_strings[unit]) {
+        return __rt_ascii_strings[unit];
+    }
+
+    string_t c = __rt_string_new(1);
+    c->units[0] = unit;
+
+    if (unit < 128) {
+        __rt_ascii_strings[unit] = c;
     }
 
-    string_t c = jsrt_string_new(1);
-    c->units[0] = s->units[i];
     return c;
 }
 
 // `s` as UTF-8, in a new buffer for the caller to free
-static char *jsrt_string_utf8(string_t s) {
-    char *utf8 = jsrt_alloc((size_t)s->length * 3 + 1);
+static char *__rt_string_utf8(string_t s) {
+    char *utf8 = __rt_alloc((size_t)s->length * 3 + 1);
     char *out = utf8;
 
     for (int32_t i = 0; i < s->length; i++) {
@@ -124,30 +145,23 @@ static char *jsrt_string_utf8(string_t s) {
     return utf8;
 }
 
-// ── natives ──
+// ── for the stdlib ──
 
-string_t __native_string_concat(string_t a, string_t b) {
-    string_t s = jsrt_string_new(a->length + b->length);
-    memcpy(s->units, a->units, (size_t)a->length * sizeof(uint16_t));
-    memcpy(s->units + a->length, b->units, (size_t)b->length * sizeof(uint16_t));
-    return s;
-}
-
-string_t __native_string_slice(string_t s, int32_t start, int32_t end) {
+string_t __rt_string_slice(string_t s, int32_t start, int32_t end) {
     start = start < 0 ? 0 : start > s->length ? s->length : start;
     end = end < start ? start : end > s->length ? s->length : end;
 
-    string_t r = jsrt_string_new(end - start);
+    string_t r = __rt_string_new(end - start);
     memcpy(r->units, s->units + start, (size_t)(end - start) * sizeof(uint16_t));
     return r;
 }
 
-int32_t __native_string_char_code_at(string_t s, int32_t i) {
+int32_t __rt_string_char_code_at(string_t s, int32_t i) {
     return s->units[i];
 }
 
-string_t __native_string_from_char_code(int32_t code) {
-    string_t s = jsrt_string_new(1);
+string_t __rt_string_from_char_code(int32_t code) {
+    string_t s = __rt_string_new(1);
     s->units[0] = (uint16_t)code;
     return s;
 }