Merge branch 'wt/namespace' into api-hardening

10 files changed, 84 insertions, 84 deletions

diff --git a/src/core.c b/src/core.c
index b352be1..dd6232a 100644
--- a/src/core.c
+++ b/src/core.c
@@ -16,13 +16,13 @@ static uint16_t cluster_presentation(const uint32_t *cps, int len)
 {
     if (len <= 1)
         return 0;
-    bool pictographic = unicode_extended_pictographic(cps[0]);
+    bool pictographic = term_unicode_extended_pictographic(cps[0]);
     if (len == 2) {
         uint32_t c1 = cps[1];
         if (c1 == 0xFE0F) return CELL_EMOJI;
         if (c1 == 0xFE0E) return CELL_TEXT;
-        if (c1 == 0x20E3 || grapheme_regional_indicator(c1) ||
-            (pictographic && (c1 == 0x200D || grapheme_emoji_modifier(c1) ||
+        if (c1 == 0x20E3 || term_grapheme_regional_indicator(c1) ||
+            (pictographic && (c1 == 0x200D || term_grapheme_emoji_modifier(c1) ||
                              (c1 >= 0xE0020 && c1 <= 0xE007F))))
             return CELL_EMOJI;
         return 0;
@@ -33,8 +33,8 @@ static uint16_t cluster_presentation(const uint32_t *cps, int len)
             return CELL_EMOJI;
         if (cps[i] == 0xFE0E)
             return CELL_TEXT;
-        if (cps[i] == 0x20E3 || grapheme_regional_indicator(cps[i]) ||
-            (pictographic && (cps[i] == 0x200D || grapheme_emoji_modifier(cps[i]) ||
+        if (cps[i] == 0x20E3 || term_grapheme_regional_indicator(cps[i]) ||
+            (pictographic && (cps[i] == 0x200D || term_grapheme_emoji_modifier(cps[i]) ||
                              (cps[i] >= 0xE0020 && cps[i] <= 0xE007F))))
             emoji = true;
     }
@@ -44,9 +44,9 @@ static uint16_t cluster_presentation(const uint32_t *cps, int len)
 void term_sc_print_glyph(struct term *t, uint32_t cp, int width, uint16_t flags)
 {
     uint32_t base = cp;
-    if (TERM_EXPECT(grapheme_is_handle(cp), 0)) {
-        uint32_t cps[GRAPHEME_MAX_LEN];
-        int len = term_gstore_expand(t->gstore, cp, cps, GRAPHEME_MAX_LEN);
+    if (TERM_EXPECT(term_grapheme_is_handle(cp), 0)) {
+        uint32_t cps[TERM_GRAPHEME_MAX_LEN];
+        int len = term_gstore_expand(t->gstore, cp, cps, TERM_GRAPHEME_MAX_LEN);
         base = cps[0];
         flags = (flags & ~(CELL_EMOJI | CELL_TEXT)) | cluster_presentation(cps, len);
     }
@@ -179,13 +179,13 @@ bool term_sc_extend_cluster(struct term *t, uint32_t cp, int klass)
         return false;
 
     struct cell *prev = last_written_cell(t);
-    uint32_t cps[GRAPHEME_MAX_LEN];
-    int len = prev && prev->c > ' ' ? term_gstore_expand(t->gstore, prev->c, cps, GRAPHEME_MAX_LEN) : 0;
+    uint32_t cps[TERM_GRAPHEME_MAX_LEN];
+    int len = prev && prev->c > ' ' ? term_gstore_expand(t->gstore, prev->c, cps, TERM_GRAPHEME_MAX_LEN) : 0;
     if (!len)
         return joins_cluster(cp, klass);
     if (!cluster_joins(cps, len, cp, klass))
         return false;
-    if (len >= GRAPHEME_MAX_LEN)
+    if (len >= TERM_GRAPHEME_MAX_LEN)
         return true;
     cps[len++] = cp;
 
@@ -517,7 +517,7 @@ static inline bool next_byte_wraps(const char *buf, size_t len, size_t pos, uint
 {
     if (pos >= len) return false;
     uint32_t cp;
-    if (!utf8_decode_one(buf + pos, len - pos, &cp)) return false;
+    if (!term_utf8_decode_one(buf + pos, len - pos, &cp)) return false;
     int w = term_text_class(cp);
     return w > 0 && !can_extend_cluster(last, cp, w);
 }
diff --git a/src/gstore.c b/src/gstore.c
index d2bc57f..813ea7d 100644
--- a/src/gstore.c
+++ b/src/gstore.c
@@ -72,11 +72,11 @@ int term_gstore_expand(const struct gstore *g, uint32_t handle, uint32_t *cps, i
 {
     if (cap <= 0)
         return 0;
-    if (!g || !grapheme_is_handle(handle)) {
+    if (!g || !term_grapheme_is_handle(handle)) {
         cps[0] = handle;
         return 1;
     }
-    uint32_t idx = handle - GRAPHEME_HANDLE_BASE;
+    uint32_t idx = handle - TERM_GRAPHEME_HANDLE_BASE;
     if (idx >= g->entries_count || !g->entries[idx].allocated) {
         cps[0] = 0xFFFD;
         return 1;
@@ -124,8 +124,8 @@ static bool grow_slots(struct gstore *g)
         struct gentry *e = &g->entries[i];
         if (!e->allocated)
             continue;
-        uint32_t cps_buf[GRAPHEME_MAX_LEN];
-        int n = term_gstore_expand(g, GRAPHEME_HANDLE_BASE + i, cps_buf, GRAPHEME_MAX_LEN);
+        uint32_t cps_buf[TERM_GRAPHEME_MAX_LEN];
+        int n = term_gstore_expand(g, TERM_GRAPHEME_HANDLE_BASE + i, cps_buf, TERM_GRAPHEME_MAX_LEN);
         uint64_t h = hash_cps(cps_buf, n);
         uint32_t h32 = (uint32_t)h ? (uint32_t)h : 1;
         gstore_insert_slot(g, h32, i);
@@ -147,7 +147,7 @@ static uint32_t gstore_find(const struct gstore *g, const uint32_t *cps, int n,
             uint32_t e_idx = slot->entry_idx - 1;
             const struct gentry *e = &g->entries[e_idx];
             if (e->allocated && gentry_matches(g, e, cps, n))
-                return GRAPHEME_HANDLE_BASE + e_idx;
+                return TERM_GRAPHEME_HANDLE_BASE + e_idx;
         }
         idx = (idx + 1) & mask;
     }
@@ -193,9 +193,9 @@ void term_gstore_unpin(struct gstore *g)
 
 void term_gstore_mark(struct gstore *g, uint32_t handle)
 {
-    if (!g || !grapheme_is_handle(handle))
+    if (!g || !term_grapheme_is_handle(handle))
         return;
-    uint32_t idx = handle - GRAPHEME_HANDLE_BASE;
+    uint32_t idx = handle - TERM_GRAPHEME_HANDLE_BASE;
     if (idx < g->entries_count && g->entries[idx].allocated)
         g->entries[idx].mark = true;
 }
@@ -204,7 +204,7 @@ static void sweep_mark_row(struct gstore *g, const struct cell *cells, int len)
 {
     for (int x = 0; x < len; x++) {
         uint32_t c = cells[x].c;
-        if (grapheme_is_handle(c))
+        if (term_grapheme_is_handle(c))
             term_gstore_mark(g, c);
     }
 }
@@ -215,7 +215,7 @@ void term_gstore_sweep(struct gstore *g, struct term *t)
         return;
 
     if (t) {
-        if (grapheme_is_handle(t->last_char))
+        if (term_grapheme_is_handle(t->last_char))
             term_gstore_mark(g, t->last_char);
 
         struct screen *s = &t->scr;
@@ -266,8 +266,8 @@ void term_gstore_sweep(struct gstore *g, struct term *t)
                 live++;
                 e->mark = false;
                 if (g->slots) {
-                    uint32_t cps_buf[GRAPHEME_MAX_LEN];
-                    int n = term_gstore_expand(g, GRAPHEME_HANDLE_BASE + i, cps_buf, GRAPHEME_MAX_LEN);
+                    uint32_t cps_buf[TERM_GRAPHEME_MAX_LEN];
+                    int n = term_gstore_expand(g, TERM_GRAPHEME_HANDLE_BASE + i, cps_buf, TERM_GRAPHEME_MAX_LEN);
                     uint64_t h = hash_cps(cps_buf, n);
                     uint32_t h32 = (uint32_t)h ? (uint32_t)h : 1;
                     gstore_insert_slot(g, h32, i);
@@ -300,8 +300,8 @@ uint32_t term_gstore_intern(struct gstore *g, const uint32_t *cps, int n)
         return 0;
     if (n == 1)
         return cps[0];
-    if (n > GRAPHEME_MAX_LEN)
-        n = GRAPHEME_MAX_LEN;
+    if (n > TERM_GRAPHEME_MAX_LEN)
+        n = TERM_GRAPHEME_MAX_LEN;
 
     uint64_t h = hash_cps(cps, n);
     uint32_t h32 = (uint32_t)h ? (uint32_t)h : 1;
@@ -375,5 +375,5 @@ uint32_t term_gstore_intern(struct gstore *g, const uint32_t *cps, int n)
 
     gstore_insert_slot(g, h32, entry_idx);
     g->live_count++;
-    return GRAPHEME_HANDLE_BASE + entry_idx;
+    return TERM_GRAPHEME_HANDLE_BASE + entry_idx;
 }
diff --git a/src/hist.c b/src/hist.c
index 344cdc8..fff0bfe 100644
--- a/src/hist.c
+++ b/src/hist.c
@@ -42,7 +42,7 @@
 #define ROWS_UNKNOWN 255
 /* Bytes one cell can need, except a cluster. */
 #define CELL_BYTES 5
-#define CLUSTER_BYTES (2 + GRAPHEME_MAX_LEN * 4)
+#define CLUSTER_BYTES (2 + TERM_GRAPHEME_MAX_LEN * 4)
 
 /* ---- Parts and pages ---- */
 
@@ -1039,8 +1039,8 @@ static int uniform_utf8_prefix(const struct cell *cells, int len, uint8_t *dst,
 static TERM_NOINLINE size_t encode_cluster(uint8_t *dst, const struct gstore *g,
                                                        uint32_t handle, uint16_t f)
 {
-    uint32_t cps[GRAPHEME_MAX_LEN];
-    int n = term_gstore_expand(g, handle, cps, GRAPHEME_MAX_LEN);
+    uint32_t cps[TERM_GRAPHEME_MAX_LEN];
+    int n = term_gstore_expand(g, handle, cps, TERM_GRAPHEME_MAX_LEN);
     size_t b = 0;
     dst[b++] = PREFIX_CLUSTER;
     dst[b++] = (uint8_t)((n & 0x1f) | ((f & CELL_WIDE) ? 0x80 : 0) |
@@ -1053,7 +1053,7 @@ static TERM_NOINLINE size_t encode_cluster(uint8_t *dst, const struct gstore *g,
 static size_t encode_shaped(uint8_t *dst, uint32_t cp, uint16_t f, const struct gstore *g,
                             uint8_t *flags)
 {
-    if (grapheme_is_handle(cp)) {
+    if (term_grapheme_is_handle(cp)) {
         *flags |= HLINE_HAS_CLUSTER | ((f & CELL_WIDE) ? HLINE_HAS_WIDE : 0);
         return encode_cluster(dst, g, cp, f);
     }
@@ -1155,7 +1155,7 @@ static int encode_cells(struct hist_runs *r, const struct cell *cells, int n, ui
             continue;
         uint32_t cp = c->c;
         bool simple = !(f & (CELL_WIDE | CELL_EMOJI | CELL_TEXT)) && cp - 0x20u < 0x60u;
-        if (!simple && grapheme_is_handle(cp) &&
+        if (!simple && term_grapheme_is_handle(cp) &&
             bytes + CLUSTER_BYTES + (size_t)(n - i) * CELL_BYTES > cap)
             break;
         uint32_t sl = (uint32_t)(f & STYLE_FLAGS) | ((uint32_t)c->pad << 16);
@@ -2516,12 +2516,12 @@ static const uint8_t *text_cell(const uint8_t *s, const uint8_t *end, struct gst
     }
     uint8_t k = s[1];
     s += 2;
-    uint32_t cps[GRAPHEME_MAX_LEN];
+    uint32_t cps[TERM_GRAPHEME_MAX_LEN];
     int n = 0;
     for (int i = 0; i < (k & 0x1f) && s < end; i++) {
         uint32_t c;
         s += get_utf8(s, end, &c);
-        if (n < GRAPHEME_MAX_LEN)
+        if (n < TERM_GRAPHEME_MAX_LEN)
             cps[n++] = c;
     }
     *cp = n == 0 ? ' ' : (g && n > 1) ? term_gstore_intern(g, cps, n) : cps[0];
diff --git a/src/input.c b/src/input.c
index 9fee179..2f0cd5c 100644
--- a/src/input.c
+++ b/src/input.c
@@ -53,7 +53,7 @@ static inline void sb_u32(struct seqbuf *sb, uint32_t val)
 static inline void sb_utf8(struct seqbuf *sb, uint32_t cp)
 {
     char tmp[8];
-    size_t n = (size_t)utf8_encode(cp, tmp);
+    size_t n = (size_t)term_utf8_encode(cp, tmp);
     sb_bytes(sb, tmp, n);
 }
 
@@ -695,7 +695,7 @@ struct term_input_result term_input_encode_paste(const struct term_modes *m,
             continue;
         }
         uint32_t cp;
-        int n = utf8_decode_one(text + i, len - i, &cp);
+        int n = term_utf8_decode_one(text + i, len - i, &cp);
         if (!n) { i++; continue; }
         if (cp >= 0xa0 && !is_direction_format(cp)) {
             sb_bytes(&sb, text + i, (size_t)n);
diff --git a/src/selection.c b/src/selection.c
index 3ac2ee3..40fb1f1 100644
--- a/src/selection.c
+++ b/src/selection.c
@@ -742,17 +742,17 @@ static char *range_text_inner(const struct term *t,
                 uint32_t cp = cells[c].c;
                 if (cells[c].flags & (CELL_TRAIL | CELL_WRAP_PAD))
                     continue;
-                /* One cell expands to GRAPHEME_MAX_LEN code points of up
+                /* One cell expands to TERM_GRAPHEME_MAX_LEN code points of up
                  * to 4 bytes each. Leave room for all of them. */
-                if (!text_reserve(&text, &cap, n + (size_t)GRAPHEME_MAX_LEN * 4 + 1))
+                if (!text_reserve(&text, &cap, n + (size_t)TERM_GRAPHEME_MAX_LEN * 4 + 1))
                     break;
                 if (cp > 0 && cp < 128) {
                     text[n++] = (char)cp;
                 } else {
-                    uint32_t cps[GRAPHEME_MAX_LEN];
-                    int len = term_gstore_expand(t->gstore, cp ? cp : ' ', cps, GRAPHEME_MAX_LEN);
+                    uint32_t cps[TERM_GRAPHEME_MAX_LEN];
+                    int len = term_gstore_expand(t->gstore, cp ? cp : ' ', cps, TERM_GRAPHEME_MAX_LEN);
                     for (int k = 0; k < len; k++)
-                        n += (size_t)utf8_encode(cps[k], text + n);
+                        n += (size_t)term_utf8_encode(cps[k], text + n);
                 }
             }
             if (text && !is_last && !wrapped && text_reserve(&text, &cap, n + 2))
diff --git a/src/snapshot.c b/src/snapshot.c
index c578f18..0bbf545 100644
--- a/src/snapshot.c
+++ b/src/snapshot.c
@@ -90,8 +90,8 @@ static void invalidate(struct term_snapshot *s)
 static uint32_t arena_add(struct term_snapshot *s, const struct gstore *g, uint32_t handle,
                           bool *ok)
 {
-    uint32_t cps[GRAPHEME_MAX_LEN];
-    int n = term_gstore_expand(g, handle, cps, GRAPHEME_MAX_LEN);
+    uint32_t cps[TERM_GRAPHEME_MAX_LEN];
+    int n = term_gstore_expand(g, handle, cps, TERM_GRAPHEME_MAX_LEN);
     if (n <= 0)
         return ' ';
     if (s->arena_len + (uint32_t)n + 1 > s->arena_cap) {
@@ -124,7 +124,7 @@ static uint32_t convert_row(struct term_snapshot *s, const struct gstore *g,
         uint32_t text = c->c;
         if (TERM_EXPECT(text < 0x20, 0))
             text = text ? ' ' : 0;
-        else if (TERM_EXPECT(grapheme_is_handle(text), 0)) {
+        else if (TERM_EXPECT(term_grapheme_is_handle(text), 0)) {
             text = arena_add(s, g, text, ok);
             if (!*ok)
                 return 0;
diff --git a/src/term.c b/src/term.c
index bf8f3cf..5839da3 100644
--- a/src/term.c
+++ b/src/term.c
@@ -5,7 +5,7 @@ _Thread_local char term_thread_anchor;
 
 const char *term_unicode_version(void)
 {
-    return UNICODE_DATA_VERSION;
+    return TERM_UNICODE_DATA_VERSION;
 }
 
 unsigned term_version(void)
diff --git a/src/text.c b/src/text.c
index a646195..17f3f4f 100644
--- a/src/text.c
+++ b/src/text.c
@@ -50,15 +50,15 @@ static inline void emit_decoded(struct term *t, uint32_t cp, uint16_t flags)
  * sequence prints U+FFFD (Unicode 3.9, maximal subparts). */
 void term_text_utf8_interrupt(struct term *t)
 {
-    if (TERM_EXPECT(t->utf8_state == UTF8_ACCEPT, 1))
+    if (TERM_EXPECT(t->utf8_state == TERM_UTF8_ACCEPT, 1))
         return;
-    t->utf8_state = UTF8_ACCEPT;
+    t->utf8_state = TERM_UTF8_ACCEPT;
     emit_decoded(t, 0xFFFD, term_current_flags(t));
 }
 
 void term_text_ground(struct term *t, unsigned char ch)
 {
-    if (ch >= 0x20 && ch < 0x7f && t->utf8_state == UTF8_ACCEPT) {
+    if (ch >= 0x20 && ch < 0x7f && t->utf8_state == TERM_UTF8_ACCEPT) {
         emit_codepoint(t, ch, 1, term_current_flags(t));
         return;
     }
@@ -92,14 +92,14 @@ void term_text_ground(struct term *t, unsigned char ch)
         t->graphics = t->charsets[0] == '0';
     } else if (ch >= 0x20 && ch != 0x7f) {
         uint32_t before = t->utf8_state;
-        uint32_t st = utf8_decode(&t->utf8_state, &t->utf8_codep, ch);
-        if (st == UTF8_ACCEPT) {
+        uint32_t st = term_utf8_decode(&t->utf8_state, &t->utf8_codep, ch);
+        if (st == TERM_UTF8_ACCEPT) {
             emit_decoded(t, t->utf8_codep, term_current_flags(t));
-        } else if (st == UTF8_REJECT) {
-            t->utf8_state = UTF8_ACCEPT;
+        } else if (st == TERM_UTF8_REJECT) {
+            t->utf8_state = TERM_UTF8_ACCEPT;
             emit_decoded(t, 0xFFFD, term_current_flags(t));
             /* The byte that ended an unfinished sequence starts anew. */
-            if (before != UTF8_ACCEPT)
+            if (before != TERM_UTF8_ACCEPT)
                 term_text_ground(t, ch);
         }
     }
@@ -109,7 +109,7 @@ static inline bool can_stream_bottom(const struct term *t)
 {
     return t->state == ST_GROUND && !t->graphics && !t->insert_mode && t->autowrap &&
            !t->lr_margin_mode &&
-           t->utf8_state == UTF8_ACCEPT && !t->inverse &&
+           t->utf8_state == TERM_UTF8_ACCEPT && !t->inverse &&
            t->scroll_top == 0 && t->scroll_bottom == t->rows - 1 &&
            t->cursor_y == t->rows - 1 &&
            !t->alternate && t->sb_capacity > 0 &&
@@ -123,14 +123,14 @@ static inline bool try_text_run(struct term *t, const char *buf, size_t len,
     if (t->pending_wrap || i + 4 > len ||
         ((unsigned char)buf[i] >= 0x80 &&
          ((unsigned char)buf[i] < 0xc2 || (unsigned char)buf[i] > 0xf4)) ||
-        t->last_char == 0x200D || grapheme_is_handle(t->last_char))
+        t->last_char == 0x200D || term_grapheme_is_handle(t->last_char))
         return false;
     if (t->cursor_x != 0 &&
         t->cursor_x != term_row(t, t->cursor_y)->len)
         return false;
     if ((unsigned char)buf[i] >= 0x80) {
         uint32_t cp;
-        int bytes = utf8_decode_one(buf + i, len - i, &cp);
+        int bytes = term_utf8_decode_one(buf + i, len - i, &cp);
         if (!bytes || term_text_class(cp) <= 0)
             return false;
     }
@@ -181,7 +181,7 @@ static inline bool try_text_run(struct term *t, const char *buf, size_t len,
             newline = true;
         }
         if (!newline || i + 4 > len || t->pending_wrap ||
-            t->last_char == 0x200D || grapheme_is_handle(t->last_char) ||
+            t->last_char == 0x200D || term_grapheme_is_handle(t->last_char) ||
             (t->cursor_x != 0 &&
              t->cursor_x != term_row(t, t->cursor_y)->len))
             break;
@@ -213,7 +213,7 @@ static void term_feed_inner(struct term *t, const char *buf, size_t len, unsigne
         unsigned char ch = (unsigned char)buf[i];
         if (TERM_EXPECT(ch >= 0x20 && ch < 0x7f && !t->insert_mode && !t->lr_margin_mode &&
                              t->state == ST_GROUND && !t->graphics &&
-                             t->utf8_state == UTF8_ACCEPT, 1)) {
+                             t->utf8_state == TERM_UTF8_ACCEPT, 1)) {
             int avail = t->pending_wrap ? t->cols : t->cols - t->cursor_x;
             int rem = (int)(len - i);
             if (rem > avail) rem = avail;
@@ -240,7 +240,7 @@ static void term_feed_inner(struct term *t, const char *buf, size_t len, unsigne
                     (unsigned char)buf[i + 1] <= 0xf4 &&
                     (i + 2 == len || ((unsigned char)buf[i + 2] & 0xc0) == 0x80)) {
                     uint32_t next_cp;
-                    if (utf8_decode_one(buf + i + 1, len - i - 1, &next_cp) &&
+                    if (term_utf8_decode_one(buf + i + 1, len - i - 1, &next_cp) &&
                         term_text_class(next_cp) > 0 &&
                         try_text_run(t, buf, len, &i))
                         continue;
@@ -250,7 +250,7 @@ static void term_feed_inner(struct term *t, const char *buf, size_t len, unsigne
             }
             if (i + (size_t)run < len && (unsigned char)buf[i + run] >= 0x80) {
                 uint32_t next_cp;
-                if (utf8_decode_one(buf + i + run, len - i - (size_t)run, &next_cp) &&
+                if (term_utf8_decode_one(buf + i + run, len - i - (size_t)run, &next_cp) &&
                     term_text_class(next_cp) > 0 &&
                     try_text_run(t, buf, len, &i))
                     continue;
@@ -275,21 +275,21 @@ static void term_feed_inner(struct term *t, const char *buf, size_t len, unsigne
 
         if (TERM_EXPECT(ch >= 0x80, 1)) {
             if (TERM_EXPECT(t->state == ST_GROUND &&
-                            t->utf8_state == UTF8_ACCEPT && !t->graphics, 1)) {
+                            t->utf8_state == TERM_UTF8_ACCEPT && !t->graphics, 1)) {
                 if (ch >= 0xc2 && ch <= 0xf4 &&
                     (i + 1 == len || ((unsigned char)buf[i + 1] & 0xc0) == 0x80)) {
                     if (!t->insert_mode && !t->lr_margin_mode &&
                         try_text_run(t, buf, len, &i))
                         continue;
                 } else {
-                    if (TERM_EXPECT(t->last_char != 0x200D && !grapheme_is_handle(t->last_char), 1))
+                    if (TERM_EXPECT(t->last_char != 0x200D && !term_grapheme_is_handle(t->last_char), 1))
                         sc_print_cell(t, 0xFFFD, 1, cur_flags);
                     else
                         emit_decoded(t, 0xFFFD, cur_flags);
                     continue;
                 }
                 uint32_t cp;
-                int cp_len = utf8_decode_ground(&t->utf8_state, &t->utf8_codep, buf + i, len - i, &cp);
+                int cp_len = term_utf8_decode_ground(&t->utf8_state, &t->utf8_codep, buf + i, len - i, &cp);
                 if (cp)
                     emit_decoded(t, cp, cur_flags);
                 i += (size_t)(cp_len - 1);
@@ -329,7 +329,7 @@ static void term_feed_inner(struct term *t, const char *buf, size_t len, unsigne
                     }
                     continue;
                 case 0x1b:
-                    if (t->utf8_state == UTF8_ACCEPT && i + 1 < len &&
+                    if (t->utf8_state == TERM_UTF8_ACCEPT && i + 1 < len &&
                         buf[i + 1] == '[' && !t->insert_mode &&
                         !t->lr_margin_mode && !t->graphics) {
                         int fast = term_try_fast_csi(t, buf + i + 2, len - i - 2);
diff --git a/src/text_run.c b/src/text_run.c
index 028b160..c48b73e 100644
--- a/src/text_run.c
+++ b/src/text_run.c
@@ -19,7 +19,7 @@ static int width_run_count;
 void term_text_tables_init(void)
 {
     for (uint32_t cp = 0; cp < 65536; cp++) {
-        int w = unicode_width(cp);
+        int w = term_unicode_width(cp);
         unicode_fast_class[cp] = (w == 1 || w == 2) && !cluster_contextual(cp)
             ? (uint8_t)w : 0;
         unicode_width_bmp[cp] = (int8_t)w;
@@ -92,7 +92,7 @@ static TERM_MAYBE_UNUSED bool width_cache_extend(struct width_cache *wc, const u
 int term_text_class(uint32_t cp)
 {
     assert(term_tables_ready());
-    return TERM_EXPECT(cp < 65536, 1) ? (int)unicode_width_bmp[cp] : unicode_width(cp);
+    return TERM_EXPECT(cp < 65536, 1) ? (int)unicode_width_bmp[cp] : term_unicode_width(cp);
 }
 
 #if defined(TERM_KERNEL_AVX512)
@@ -189,10 +189,10 @@ static inline bool classify_3byte_block(__m512i in, struct width_ranges *ranges,
             _mm512_loadu_si512(utf8_3byte_bits)) & UTF8_3BYTE_SPAN, 0))
         return false;
     *cps = utf8_3byte_decode(_mm512_permutexvar_epi8(_mm512_loadu_si512(utf8_3byte_shuffle), in));
-    if (_mm512_cmplt_epu32_mask(*cps, _mm512_set1_epi32((int)UTF8_3BYTE_MIN)) ||
+    if (_mm512_cmplt_epu32_mask(*cps, _mm512_set1_epi32((int)TERM_UTF8_3BYTE_MIN)) ||
         _mm512_cmple_epu32_mask(
-            _mm512_sub_epi32(*cps, _mm512_set1_epi32((int)UTF8_SURROGATE_LO)),
-            _mm512_set1_epi32((int)(UTF8_SURROGATE_HI - UTF8_SURROGATE_LO))))
+            _mm512_sub_epi32(*cps, _mm512_set1_epi32((int)TERM_UTF8_SURROGATE_LO)),
+            _mm512_set1_epi32((int)(TERM_UTF8_SURROGATE_HI - TERM_UTF8_SURROGATE_LO))))
         return false;
     __mmask16 covered = width_ranges_cover(ranges, *cps);
     if (TERM_EXPECT(covered != 0xFFFF || wc->klass == 0, 0)) {
@@ -289,7 +289,7 @@ text_3byte_blocks(uint8_t * restrict dst, const char * restrict buf, int len, in
 struct text_run_bytes term_text_run_bytes(uint8_t *restrict dst, const char *restrict buf, int len,
                                           int max_cols, uint32_t last, struct width_cache *restrict wc)
 {
-    if (TERM_EXPECT(last == 0x200D || grapheme_is_handle(last), 0))
+    if (TERM_EXPECT(last == 0x200D || term_grapheme_is_handle(last), 0))
         return (struct text_run_bytes){ .last = last, .narrow = true };
     /* Unlike term_text_run(), this fills up to the edge and up to the end of
      * buf: the cells path writes those characters one by one with the same
@@ -335,7 +335,7 @@ struct text_run_bytes term_text_run_bytes(uint8_t *restrict dst, const char *res
         }
 #endif
         uint32_t cp;
-        int bytes = utf8_decode_one(buf + i, (size_t)(len - i), &cp);
+        int bytes = term_utf8_decode_one(buf + i, (size_t)(len - i), &cp);
         if (!bytes)
             break;
         int w = bytes < 4 ? unicode_fast_class[cp] : term_text_class(cp);
@@ -493,9 +493,9 @@ static inline int decode_3byte_quads(uint64_t **dst_io, const char *buf, int len
                          _mm_and_si128(_mm_srli_epi32(packed, 2), _mm_set1_epi32(0x0FC0))),
             _mm_and_si128(_mm_srli_epi32(packed, 4), _mm_set1_epi32(0xF000)));
         __m128i bad = _mm_or_si128(
-            _mm_cmplt_epi32(cps, _mm_set1_epi32((int)UTF8_3BYTE_MIN)),
+            _mm_cmplt_epi32(cps, _mm_set1_epi32((int)TERM_UTF8_3BYTE_MIN)),
             _mm_cmpeq_epi32(_mm_and_si128(cps, _mm_set1_epi32(0xF800)),
-                            _mm_set1_epi32((int)UTF8_SURROGATE_LO)));
+                            _mm_set1_epi32((int)TERM_UTF8_SURROGATE_LO)));
         if (_mm_movemask_epi8(bad))
             break;
         alignas(16) uint32_t cp[4];
@@ -530,7 +530,7 @@ text_run_body(struct cell *restrict row, const char *restrict buf, int len, int
 {
     int i = 0;
     int cx = 0;
-    if (TERM_EXPECT(last == 0x200D || grapheme_is_handle(last), 0))
+    if (TERM_EXPECT(last == 0x200D || term_grapheme_is_handle(last), 0))
         return (struct text_run_result){0, 0, last};
 
     const struct cell_bases bases = cell_bases_make(fg, bg, flags);
@@ -593,14 +593,14 @@ text_run_body(struct cell *restrict row, const char *restrict buf, int len, int
         }
 #endif
         uint32_t cp;
-        int bytes = utf8_decode_one(buf + i, (size_t)(len - i), &cp);
+        int bytes = term_utf8_decode_one(buf + i, (size_t)(len - i), &cp);
         if (!bytes) break;
         int w = bytes < 4 ? unicode_fast_class[cp] : term_text_class(cp);
         if (w <= 0 || (bytes == 4 && can_extend_cluster(last, cp, w))) break;
 #if defined(TERM_KERNEL_AVX512)
         if (isa == TERM_ISA_AVX512 && bytes == 3 && w == 2 && i + 6 <= len && cx + 4 <= max_cols) {
             uint32_t next_cp;
-            if (utf8_decode_one(buf + i + 3, (size_t)(len - i - 3), &next_cp) == 3 &&
+            if (term_utf8_decode_one(buf + i + 3, (size_t)(len - i - 3), &next_cp) == 3 &&
                 unicode_fast_class[next_cp] == 2) {
                 store_wide_pair(dst, fg, bg, flags, cp, next_cp);
                 dst += 8;
diff --git a/src/text_run.h b/src/text_run.h
index fac638f..3ff432b 100644
--- a/src/text_run.h
+++ b/src/text_run.h
@@ -53,25 +53,25 @@ static inline bool joins_cluster(uint32_t cp, int klass)
 {
     if (cp < 0x0300)
         return false;
-    if (klass == 0 || grapheme_emoji_modifier(cp))
+    if (klass == 0 || term_grapheme_emoji_modifier(cp))
         return true;
 
-    return klass == 1 && unicode_spacing_mark(cp);
+    return klass == 1 && term_unicode_spacing_mark(cp);
 }
 
 static inline bool can_extend_cluster(uint32_t last_char, uint32_t cp, int klass)
 {
     if (klass == 0) return true;
-    if (last_char == 0x200D || grapheme_is_handle(last_char)) return true;
-    if (cp - 0x1F1E6u <= 0x19u && grapheme_regional_indicator(cp))
+    if (last_char == 0x200D || term_grapheme_is_handle(last_char)) return true;
+    if (cp - 0x1F1E6u <= 0x19u && term_grapheme_regional_indicator(cp))
         return true;
     return joins_cluster(cp, klass);
 }
 
 static inline bool cluster_contextual(uint32_t cp)
 {
-    return unicode_spacing_mark(cp) || grapheme_emoji_modifier(cp) ||
-           (cp - 0x1F1E6u <= 0x19u && grapheme_regional_indicator(cp));
+    return term_unicode_spacing_mark(cp) || term_grapheme_emoji_modifier(cp) ||
+           (cp - 0x1F1E6u <= 0x19u && term_grapheme_regional_indicator(cp));
 }
 
 static inline bool cluster_joins(const uint32_t *cps, int len,
@@ -80,10 +80,10 @@ static inline bool cluster_joins(const uint32_t *cps, int len,
     if (joins_cluster(cp, klass))
         return true;
     if (cps[len - 1] == 0x200D)
-        return unicode_extended_pictographic(cp);
+        return term_unicode_extended_pictographic(cp);
     return len == 1 && cp - 0x1F1E6u <= 0x19u &&
-           grapheme_regional_indicator(cp) &&
-           grapheme_regional_indicator(cps[0]);
+           term_grapheme_regional_indicator(cp) &&
+           term_grapheme_regional_indicator(cps[0]);
 }
 
 #endif