From b9ef703eb14ba2357b847b62a715b4e97f690209 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Thu, 20 Aug 2020 19:25:35 +0200 Subject: wip: grapheme shaping --- render.c | 130 ++++++++++++++++++++++++++++++++++++++++++--------------------- 1 file changed, 86 insertions(+), 44 deletions(-) (limited to 'render.c') diff --git a/render.c b/render.c index f96ddb9e..54269bf3 100644 --- a/render.c +++ b/render.c @@ -500,19 +500,15 @@ render_cell(struct terminal *term, pixman_image_t *pix, } struct fcft_font *font = attrs_to_font(term, &cell->attrs); - const struct fcft_glyph *glyph = NULL; const struct composed *composed = NULL; + const struct fcft_grapheme *grapheme = NULL; + const struct fcft_glyph *single = NULL; + const struct fcft_glyph **glyphs = NULL; + unsigned glyph_count = 0; wchar_t base = cell->wc; if (base != 0) { - if (base >= CELL_COMB_CHARS_LO && - base < (CELL_COMB_CHARS_LO + term->composed_count)) - { - composed = &term->composed[base - CELL_COMB_CHARS_LO]; - base = composed->base; - } - if (unlikely( /* Classic box drawings */ (base >= 0x2500 && base <= 0x259f) || @@ -528,7 +524,7 @@ render_cell(struct terminal *term, pixman_image_t *pix, (base >= 0x1fb00 && base <= 0x1fb3b) || /* Unicode 13 partial blocks */ - /* TODO: there's more here! */ + /* TODO: there's more here! */ (base >= 0x1fb70 && base <= 0x1fb8b)) && likely(!term->conf->box_drawings_uses_font_glyphs)) @@ -542,7 +538,7 @@ render_cell(struct terminal *term, pixman_image_t *pix, xassert(idx < ALEN(term->box_drawing)); if (likely(term->box_drawing[idx] != NULL)) - glyph = term->box_drawing[idx]; + single = term->box_drawing[idx]; else { mtx_lock(&term->render.workers.lock); @@ -551,15 +547,45 @@ render_cell(struct terminal *term, pixman_image_t *pix, term->box_drawing[idx] = box_drawing(term, base); mtx_unlock(&term->render.workers.lock); - glyph = term->box_drawing[idx]; - xassert(glyph != NULL); + single = term->box_drawing[idx]; + xassert(single != NULL); } - } else - glyph = fcft_glyph_rasterize(font, base, term->font_subpixel); + + glyph_count = 1; + glyphs = &single; + } + + else if (base >= CELL_COMB_CHARS_LO && + base < (CELL_COMB_CHARS_LO + term->composed_count)) + { + composed = &term->composed[base - CELL_COMB_CHARS_LO]; + base = composed->chars[0]; + + if (term->conf->can_shape_grapheme && term->conf->tweak.grapheme_shaping) { + grapheme = fcft_grapheme_rasterize( + font, composed->count, composed->chars, + 0, NULL, term->font_subpixel); + } + + if (grapheme != NULL) { + composed = NULL; + glyphs = grapheme->glyphs; + glyph_count = grapheme->count; + } + } + + + if (single == NULL && grapheme == NULL) { + xassert(base != 0); + single = fcft_glyph_rasterize(font, base, term->font_subpixel); + glyph_count = 1; + glyphs = &single; + } } + assert(glyph_count == 0 || glyphs != NULL); const int cols_left = term->cols - col; - int cell_cols = glyph != NULL ? max(1, min(glyph->cols, cols_left)) : 1; + int cell_cols = glyph_count > 0 ? max(1, min(glyphs[0]->cols, cols_left)) : 1; /* * Hack! @@ -580,15 +606,15 @@ render_cell(struct terminal *term, pixman_image_t *pix, * - *this* cells is followed by an empty cell, or a space */ if (term->conf->tweak.allow_overflowing_double_width_glyphs && - ((glyph != NULL && - glyph->cols == 1 && - glyph->width >= term->cell_width * 15 / 10 && - glyph->width < 3 * term->cell_width && - col < term->cols - 1) || - (term->conf->tweak.pua_double_width && - ((base >= 0x00e000 && base <= 0x00f8ff) || - (base >= 0x0f0000 && base <= 0x0ffffd) || - (base >= 0x100000 && base <= 0x10fffd)))) && + ((glyph_count > 0 && + glyphs[0]->cols == 1 && + glyphs[0]->width >= term->cell_width * 15 / 10 && + glyphs[0]->width < 3 * term->cell_width && + col < term->cols - 1 || + (term->conf->tweak.pua_double_width && + ((base >= 0x00e000 && base <= 0x00f8ff) || + (base >= 0x0f0000 && base <= 0x0ffffd) || + (base >= 0x100000 && base <= 0x10fffd))))) && (row->cells[col + 1].wc == 0 || row->cells[col + 1].wc == L' ')) { cell_cols = 2; @@ -632,33 +658,43 @@ render_cell(struct terminal *term, pixman_image_t *pix, pixman_image_t *clr_pix = pixman_image_create_solid_fill(&fg); - if (glyph != NULL) { - const int letter_x_ofs = term->font_x_ofs; + for (unsigned i = 0; i < glyph_count; i++) { + const int letter_x_ofs = i == 0 ? term->font_x_ofs : 0; + + const struct fcft_glyph *glyph = glyphs[i]; + if (glyph == NULL) + continue; + + int g_x = glyph->x; + int g_y = glyph->y; + + if (i > 0 && glyph->x >= 0) + g_x -= term->cell_width; if (unlikely(pixman_image_get_format(glyph->pix) == PIXMAN_a8r8g8b8)) { /* Glyph surface is a pre-rendered image (typically a color emoji...) */ if (!(cell->attrs.blink && term->blink.state == BLINK_OFF)) { pixman_image_composite32( PIXMAN_OP_OVER, glyph->pix, NULL, pix, 0, 0, 0, 0, - x + letter_x_ofs + glyph->x, y + font_baseline(term) - glyph->y, + x + letter_x_ofs + g_x, y + font_baseline(term) - g_y, glyph->width, glyph->height); } } else { pixman_image_composite32( PIXMAN_OP_OVER, clr_pix, glyph->pix, pix, 0, 0, 0, 0, - x + letter_x_ofs + glyph->x, y + font_baseline(term) - glyph->y, + x + letter_x_ofs + g_x, y + font_baseline(term) - g_y, glyph->width, glyph->height); - } + /* Combining characters */ + if (composed != NULL) { + assert(glyph_count == 1); - /* Combining characters */ - if (composed != NULL) { - for (size_t i = 0; i < composed->count; i++) { - const struct fcft_glyph *g = fcft_glyph_rasterize( - font, composed->combining[i], term->font_subpixel); + for (size_t i = 1; i < composed->count; i++) { + const struct fcft_glyph *g = fcft_glyph_rasterize( + font, composed->chars[i], term->font_subpixel); - if (g == NULL) - continue; + if (g == NULL) + continue; /* * Fonts _should_ assume the pen position is now @@ -677,16 +713,22 @@ render_cell(struct terminal *term, pixman_image_t *pix, * somewhat deal with double-width glyphs we use * an offset of *one* cell. */ - int x_ofs = g->x < 0 - ? cell_cols * term->cell_width - : (cell_cols - 1) * term->cell_width; - - pixman_image_composite32( - PIXMAN_OP_OVER, clr_pix, g->pix, pix, 0, 0, 0, 0, - x + letter_x_ofs + x_ofs + g->x, y + font_baseline(term) - g->y, - g->width, g->height); + int x_ofs = g->x < 0 + ? cell_cols * term->cell_width + : (cell_cols - 1) * term->cell_width; + + pixman_image_composite32( + PIXMAN_OP_OVER, clr_pix, g->pix, pix, 0, 0, 0, 0, + /* Some fonts use a negative offset, while others use a + * "normal" offset */ + x + x_ofs + g->x, + y + font_baseline(term) - g->y, + g->width, g->height); + } } } + + x += glyph->advance.x; } pixman_image_unref(clr_pix); -- cgit v1.3 From bd98cb6a73d225e2dc15678d8fe06d54cc802c7a Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Sun, 30 May 2021 19:37:53 +0200 Subject: render: use column count from grapheme instead of first glyph, when we have one --- render.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) (limited to 'render.c') diff --git a/render.c b/render.c index 54269bf3..894c74db 100644 --- a/render.c +++ b/render.c @@ -507,6 +507,7 @@ render_cell(struct terminal *term, pixman_image_t *pix, unsigned glyph_count = 0; wchar_t base = cell->wc; + int cell_cols; if (base != 0) { if (unlikely( @@ -553,6 +554,7 @@ render_cell(struct terminal *term, pixman_image_t *pix, glyph_count = 1; glyphs = &single; + cell_cols = single->cols; } else if (base >= CELL_COMB_CHARS_LO && @@ -571,7 +573,9 @@ render_cell(struct terminal *term, pixman_image_t *pix, composed = NULL; glyphs = grapheme->glyphs; glyph_count = grapheme->count; - } + cell_cols = grapheme->cols; + } else + base = composed->chars[0]; } @@ -580,12 +584,14 @@ render_cell(struct terminal *term, pixman_image_t *pix, single = fcft_glyph_rasterize(font, base, term->font_subpixel); glyph_count = 1; glyphs = &single; + cell_cols = single->cols; } } assert(glyph_count == 0 || glyphs != NULL); + const int cols_left = term->cols - col; - int cell_cols = glyph_count > 0 ? max(1, min(glyphs[0]->cols, cols_left)) : 1; + cell_cols = max(1, min(cell_cols, cols_left)); /* * Hack! -- cgit v1.3 From 50be9242852756aac6fd82b0531ed92eeb44c754 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Mon, 31 May 2021 17:11:58 +0200 Subject: render: handle fcft_glyph_rasterize() failure correctly --- render.c | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) (limited to 'render.c') diff --git a/render.c b/render.c index 894c74db..259d4499 100644 --- a/render.c +++ b/render.c @@ -582,9 +582,14 @@ render_cell(struct terminal *term, pixman_image_t *pix, if (single == NULL && grapheme == NULL) { xassert(base != 0); single = fcft_glyph_rasterize(font, base, term->font_subpixel); - glyph_count = 1; - glyphs = &single; - cell_cols = single->cols; + if (single == NULL) { + glyph_count = 0; + cell_cols = 1; + } else { + glyph_count = 1; + glyphs = &single; + cell_cols = single->cols; + } } } -- cgit v1.3 From b471fe31b1a65c0eb11422beb8b9e119f771925d Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Mon, 31 May 2021 17:50:49 +0200 Subject: render: ensure ‘cell_cols’ have been initialized MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- render.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'render.c') diff --git a/render.c b/render.c index 259d4499..b0ce83d0 100644 --- a/render.c +++ b/render.c @@ -507,7 +507,7 @@ render_cell(struct terminal *term, pixman_image_t *pix, unsigned glyph_count = 0; wchar_t base = cell->wc; - int cell_cols; + int cell_cols = 1; if (base != 0) { if (unlikely( -- cgit v1.3 From 96ff29bbd3968759f3ebb3c83a9c2c7a8ea96134 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Tue, 15 Jun 2021 06:00:00 +0200 Subject: render: repair parenthesis after rebase --- render.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'render.c') diff --git a/render.c b/render.c index b0ce83d0..c764975c 100644 --- a/render.c +++ b/render.c @@ -621,11 +621,11 @@ render_cell(struct terminal *term, pixman_image_t *pix, glyphs[0]->cols == 1 && glyphs[0]->width >= term->cell_width * 15 / 10 && glyphs[0]->width < 3 * term->cell_width && - col < term->cols - 1 || - (term->conf->tweak.pua_double_width && - ((base >= 0x00e000 && base <= 0x00f8ff) || - (base >= 0x0f0000 && base <= 0x0ffffd) || - (base >= 0x100000 && base <= 0x10fffd))))) && + col < term->cols - 1) || + (term->conf->tweak.pua_double_width && + ((base >= 0x00e000 && base <= 0x00f8ff) || + (base >= 0x0f0000 && base <= 0x0ffffd) || + (base >= 0x100000 && base <= 0x10fffd)))) && (row->cells[col + 1].wc == 0 || row->cells[col + 1].wc == L' ')) { cell_cols = 2; -- cgit v1.3 From 51295cd7a27641d0452db6465e852f66bfd67118 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Tue, 15 Jun 2021 07:58:41 +0200 Subject: render: we’ve already assigned ‘base’ a couple of lines higher up MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- render.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'render.c') diff --git a/render.c b/render.c index c764975c..6799f23a 100644 --- a/render.c +++ b/render.c @@ -574,8 +574,7 @@ render_cell(struct terminal *term, pixman_image_t *pix, glyphs = grapheme->glyphs; glyph_count = grapheme->count; cell_cols = grapheme->cols; - } else - base = composed->chars[0]; + } } -- cgit v1.3 From c0d9f92e1a5aae2f0963d62f9fd480a5926f2d15 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Tue, 15 Jun 2021 17:52:45 +0200 Subject: render: don’t modify the cell’s x position. Fixes broken underlines MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- render.c | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) (limited to 'render.c') diff --git a/render.c b/render.c index 6799f23a..d46cb90b 100644 --- a/render.c +++ b/render.c @@ -449,8 +449,8 @@ render_cell(struct terminal *term, pixman_image_t *pix, int width = term->cell_width; int height = term->cell_height; - int x = term->margins.left + col * width; - int y = term->margins.top + row_no * height; + const int x = term->margins.left + col * width; + const int y = term->margins.top + row_no * height; xassert(cell->attrs.selected == 0 || cell->attrs.selected == 1); bool is_selected = cell->attrs.selected; @@ -668,6 +668,7 @@ render_cell(struct terminal *term, pixman_image_t *pix, pixman_image_t *clr_pix = pixman_image_create_solid_fill(&fg); + int pen_x = x; for (unsigned i = 0; i < glyph_count; i++) { const int letter_x_ofs = i == 0 ? term->font_x_ofs : 0; @@ -686,13 +687,13 @@ render_cell(struct terminal *term, pixman_image_t *pix, if (!(cell->attrs.blink && term->blink.state == BLINK_OFF)) { pixman_image_composite32( PIXMAN_OP_OVER, glyph->pix, NULL, pix, 0, 0, 0, 0, - x + letter_x_ofs + g_x, y + font_baseline(term) - g_y, + pen_x + letter_x_ofs + g_x, y + font_baseline(term) - g_y, glyph->width, glyph->height); } } else { pixman_image_composite32( PIXMAN_OP_OVER, clr_pix, glyph->pix, pix, 0, 0, 0, 0, - x + letter_x_ofs + g_x, y + font_baseline(term) - g_y, + pen_x + letter_x_ofs + g_x, y + font_baseline(term) - g_y, glyph->width, glyph->height); /* Combining characters */ @@ -731,14 +732,14 @@ render_cell(struct terminal *term, pixman_image_t *pix, PIXMAN_OP_OVER, clr_pix, g->pix, pix, 0, 0, 0, 0, /* Some fonts use a negative offset, while others use a * "normal" offset */ - x + x_ofs + g->x, + pen_x + x_ofs + g->x, y + font_baseline(term) - g->y, g->width, g->height); } } } - x += glyph->advance.x; + pen_x += glyph->advance.x; } pixman_image_unref(clr_pix); -- cgit v1.3 From b14524215ba2119c1f37787bbd4201d6d00d13df Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Thu, 24 Jun 2021 10:08:58 +0200 Subject: render: use cell cols from compose chain, not grapheme MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit fcft’s view of how many columns a grapheme cluster is may differ from our own. Make sure the rendered glyph matches the number of columns that were allocated when the cluster was printed. --- render.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'render.c') diff --git a/render.c b/render.c index d46cb90b..5bb1023e 100644 --- a/render.c +++ b/render.c @@ -570,10 +570,11 @@ render_cell(struct terminal *term, pixman_image_t *pix, } if (grapheme != NULL) { + cell_cols = composed->width; + composed = NULL; glyphs = grapheme->glyphs; glyph_count = grapheme->count; - cell_cols = grapheme->cols; } } -- cgit v1.3 From fe8ca23cfee77a6cac433892755dd7455e354a9d Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Thu, 24 Jun 2021 13:17:07 +0200 Subject: composed: store compose chains in a binary search tree MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The previous implementation stored compose chains in a dynamically allocated array. Adding a chain was easy: resize the array and append the new chain at the end. Looking up a compose chain given a compose chain key/index was also easy: just index into the array. However, searching for a pre-existing chain given a codepoint sequence was very slow. Since the array wasn’t sorted, we typically had to scan through the entire array, just to realize that there is no pre-existing chain, and that we need to add a new one. Since this happens for *each* codepoint in a grapheme cluster, things quickly became really slow. Things were ok:ish as long as the compose chain struct was small, as that made it possible to hold all the chains in the cache. Once the number of chains reached a certain point, or when we were forced to bump maximum number of allowed codepoints in a chain, we started thrashing the cache and things got much much worse. So what can we do? We can’t sort the array, because a) that would invalidate all existing chain keys in the grid (and iterating the entire scrollback and updating compose keys is *not* an option). b) inserting a chain becomes slow as we need to first find _where_ to insert it, and then memmove() the rest of the array. This patch uses a binary search tree to store the chains instead of a simple array. The tree is sorted on a “key”, which is the XOR of all codepoints, truncated to the CELL_COMB_CHARS_HI-CELL_COMB_CHARS_LO range. The grid now stores CELL_COMB_CHARS_LO+key, instead of CELL_COMB_CHARS_LO+index. Since the key is truncated, collisions may occur. This is handled by incrementing the key by 1. Lookup is of course slower than before, O(log n) instead of O(1). Insertion is slightly slower as well: technically it’s O(log n) instead of O(1). However, we also need to take into account the re-allocating the array will occasionally force a full copy of the array when it cannot simply be growed. But finding a pre-existing chain is now *much* faster: O(log n) instead of O(n). In most cases, the first lookup will either succeed (return a true match), or fail (return NULL). However, since key collisions are possible, it may also return false matches. This means we need to verify the contents of the chain before deciding to use it instead of inserting a new chain. But remember that this comparison was being done for each and every chain in the previous implementation. With lookups being much faster, and in particular, no longer requiring us to check the chain contents for every singlec chain, we can now use a dynamically allocated ‘chars’ array in the chain. This was previously a hardcoded array of 10 chars. Using a dynamic allocated array means looking in the array is slower, since we now need two loads: one to load the pointer, and a second to load _from_ the pointer. As a result, the base size of a compose chain (i.e. an “empty” chain) has now been reduced from 48 bytes to 32. A chain with two codepoints is 40 bytes. This means we have up to 4 codepoints while still using less, or the same amount, of memory as before. Furthermore, the Unicode random test (i.e. write random “unicode” chars) is now **faster** than current master (i.e. before text-shaping support was added), **with** test-shaping enabled. With text-shaping disabled, we’re _even_ faster. --- composed.c | 76 +++++++++++++++++++++++++++++++++++++++++++++++++++ composed.h | 18 +++++++++++++ extract.c | 7 +++-- grid.c | 4 +-- grid.h | 4 +-- meson.build | 1 + render.c | 9 +++---- search.c | 5 ++-- selection.c | 28 ++++++------------- terminal.c | 3 +-- terminal.h | 7 +---- vt.c | 90 +++++++++++++++++++++++++++++++++++-------------------------- 12 files changed, 168 insertions(+), 84 deletions(-) create mode 100644 composed.c create mode 100644 composed.h (limited to 'render.c') diff --git a/composed.c b/composed.c new file mode 100644 index 00000000..f969c8f1 --- /dev/null +++ b/composed.c @@ -0,0 +1,76 @@ +#include "composed.h" + +#include +#include + +#include "debug.h" + +struct composed * +composed_lookup(struct composed *root, uint32_t key) +{ + struct composed *node = root; + + while (node != NULL) { + if (key == node->key) + return node; + + node = key < node->key ? node->left : node->right; + } + + return NULL; +} + +uint32_t +composed_insert(struct composed **root, struct composed *node) +{ + node->left = node->right = NULL; + + if (*root == NULL) { + *root = node; + return node->key; + } + + uint32_t key = node->key; + + struct composed *prev = NULL; + struct composed *n = *root; + + while (n != NULL) { + if (n->key == node->key) { + /* TODO: wrap around at (CELL_COMB_CHARS_HI - CELL_COMB_CHARS_LO) */ + key++; + } + + prev = n; + n = key < n->key ? n->left : n->right; + } + + xassert(prev != NULL); + xassert(n == NULL); + + /* May have been changed */ + node->key = key; + + if (key < prev->key) { + xassert(prev->left == NULL); + prev->left = node; + } else { + xassert(prev->right == NULL); + prev->right = node; + } + + return key; +} + +void +composed_free(struct composed *root) +{ + if (root == NULL) + return; + + composed_free(root->left); + composed_free(root->right); + + free(root->chars); + free(root); +} diff --git a/composed.h b/composed.h new file mode 100644 index 00000000..3511ad30 --- /dev/null +++ b/composed.h @@ -0,0 +1,18 @@ +#pragma once + +#include +#include + +struct composed { + wchar_t *chars; + struct composed *left; + struct composed *right; + uint32_t key; + uint8_t count; + uint8_t width; +}; + +struct composed *composed_lookup(struct composed *root, uint32_t key); +uint32_t composed_insert(struct composed **root, struct composed *node); + +void composed_free(struct composed *root); diff --git a/extract.c b/extract.c index 8aa1acf3..4acd481c 100644 --- a/extract.c +++ b/extract.c @@ -223,11 +223,10 @@ extract_one(const struct terminal *term, const struct row *row, ctx->newline_count = 0; ctx->empty_count = 0; - if (cell->wc >= CELL_COMB_CHARS_LO && - cell->wc < (CELL_COMB_CHARS_LO + term->composed_count)) + if (cell->wc >= CELL_COMB_CHARS_LO && cell->wc <= CELL_COMB_CHARS_HI) { - const struct composed *composed - = &term->composed[cell->wc - CELL_COMB_CHARS_LO]; + const struct composed *composed = composed_lookup( + term->composed, cell->wc - CELL_COMB_CHARS_LO); if (!ensure_size(ctx, composed->count)) goto err; diff --git a/grid.c b/grid.c index 4419434c..733d8ded 100644 --- a/grid.c +++ b/grid.c @@ -416,9 +416,7 @@ grid_resize_and_reflow( struct grid *grid, int new_rows, int new_cols, int old_screen_rows, int new_screen_rows, size_t tracking_points_count, - struct coord *const _tracking_points[static tracking_points_count], - size_t compose_count, const struct - composed composed[static compose_count]) + struct coord *const _tracking_points[static tracking_points_count]) { #if defined(TIME_REFLOW) && TIME_REFLOW struct timeval start; diff --git a/grid.h b/grid.h index c41a5ba5..3537ddb5 100644 --- a/grid.h +++ b/grid.h @@ -19,9 +19,7 @@ void grid_resize_and_reflow( struct grid *grid, int new_rows, int new_cols, int old_screen_rows, int new_screen_rows, size_t tracking_points_count, - struct coord *const _tracking_points[static tracking_points_count], - size_t compose_count, - const struct composed composed[static compose_count]); + struct coord *const _tracking_points[static tracking_points_count]); static inline int grid_row_absolute(const struct grid *grid, int row_no) diff --git a/meson.build b/meson.build index 107fd905..33b54c9c 100644 --- a/meson.build +++ b/meson.build @@ -147,6 +147,7 @@ misc = static_library( vtlib = static_library( 'vtlib', 'base64.c', 'base64.h', + 'composed.c', 'composed.h', 'csi.c', 'csi.h', 'dcs.c', 'dcs.h', 'osc.c', 'osc.h', diff --git a/render.c b/render.c index 5bb1023e..d3e03b63 100644 --- a/render.c +++ b/render.c @@ -557,10 +557,9 @@ render_cell(struct terminal *term, pixman_image_t *pix, cell_cols = single->cols; } - else if (base >= CELL_COMB_CHARS_LO && - base < (CELL_COMB_CHARS_LO + term->composed_count)) + else if (base >= CELL_COMB_CHARS_LO && base <= CELL_COMB_CHARS_HI) { - composed = &term->composed[base - CELL_COMB_CHARS_LO]; + composed = composed_lookup(term->composed, base - CELL_COMB_CHARS_LO); base = composed->chars[0]; if (term->conf->can_shape_grapheme && term->conf->tweak.grapheme_shaping) { @@ -3339,8 +3338,8 @@ maybe_resize(struct terminal *term, int width, int height, bool force) /* Resize grids */ grid_resize_and_reflow( &term->normal, new_normal_grid_rows, new_cols, old_rows, new_rows, - term->selection.end.row >= 0 ? ALEN(tracking_points) : 0, tracking_points, - term->composed_count, term->composed); + term->selection.end.row >= 0 ? ALEN(tracking_points) : 0, + tracking_points); grid_resize_without_reflow( &term->alt, new_alt_grid_rows, new_cols, old_rows, new_rows); diff --git a/search.c b/search.c index 859608f5..8f28a656 100644 --- a/search.c +++ b/search.c @@ -245,10 +245,9 @@ matches_cell(const struct terminal *term, const struct cell *cell, size_t search wchar_t base = cell->wc; const struct composed *composed = NULL; - if (base >= CELL_COMB_CHARS_LO && - base < (CELL_COMB_CHARS_LO + term->composed_count)) + if (base >= CELL_COMB_CHARS_LO && base <= CELL_COMB_CHARS_HI) { - composed = &term->composed[base - CELL_COMB_CHARS_LO]; + composed = composed_lookup(term->composed, base - CELL_COMB_CHARS_LO); base = composed->chars[0]; } diff --git a/selection.c b/selection.c index cafb161e..57ab8bf6 100644 --- a/selection.c +++ b/selection.c @@ -246,11 +246,8 @@ selection_find_word_boundary_left(struct terminal *term, struct coord *pos, c = r->cells[pos->col].wc; } - if (c >= CELL_COMB_CHARS_LO && - c < (CELL_COMB_CHARS_LO + term->composed_count)) - { - c = term->composed[c - CELL_COMB_CHARS_LO].chars[0]; - } + if (c >= CELL_COMB_CHARS_LO && c <= CELL_COMB_CHARS_HI) + c = composed_lookup(term->composed, c - CELL_COMB_CHARS_LO)->chars[0]; bool initial_is_space = c == 0 || iswspace(c); bool initial_is_delim = @@ -286,11 +283,8 @@ selection_find_word_boundary_left(struct terminal *term, struct coord *pos, c = row->cells[next_col].wc; } - if (c >= CELL_COMB_CHARS_LO && - c < (CELL_COMB_CHARS_LO + term->composed_count)) - { - c = term->composed[c - CELL_COMB_CHARS_LO].chars[0]; - } + if (c >= CELL_COMB_CHARS_LO && c <= CELL_COMB_CHARS_HI) + c = composed_lookup(term->composed, c - CELL_COMB_CHARS_LO)->chars[0]; bool is_space = c == 0 || iswspace(c); bool is_delim = @@ -325,11 +319,8 @@ selection_find_word_boundary_right(struct terminal *term, struct coord *pos, c = r->cells[pos->col].wc; } - if (c >= CELL_COMB_CHARS_LO && - c < (CELL_COMB_CHARS_LO + term->composed_count)) - { - c = term->composed[c - CELL_COMB_CHARS_LO].chars[0]; - } + if (c >= CELL_COMB_CHARS_LO && c <= CELL_COMB_CHARS_HI) + c = composed_lookup(term->composed, c - CELL_COMB_CHARS_LO)->chars[0]; bool initial_is_space = c == 0 || iswspace(c); bool initial_is_delim = @@ -367,11 +358,8 @@ selection_find_word_boundary_right(struct terminal *term, struct coord *pos, c = row->cells[next_col].wc; } - if (c >= CELL_COMB_CHARS_LO && - c < (CELL_COMB_CHARS_LO + term->composed_count)) - { - c = term->composed[c - CELL_COMB_CHARS_LO].chars[0]; - } + if (c >= CELL_COMB_CHARS_LO && c <= CELL_COMB_CHARS_HI) + c = composed_lookup(term->composed, c - CELL_COMB_CHARS_LO)->chars[0]; bool is_space = c == 0 || iswspace(c); bool is_delim = diff --git a/terminal.c b/terminal.c index 9e0795a1..cb836fef 100644 --- a/terminal.c +++ b/terminal.c @@ -1132,7 +1132,6 @@ term_init(const struct config *conf, struct fdm *fdm, struct reaper *reaper, .normal = {.scroll_damage = tll_init(), .sixel_images = tll_init()}, .alt = {.scroll_damage = tll_init(), .sixel_images = tll_init()}, .grid = &term->normal, - .composed_count = 0, .composed = NULL, .alt_scrolling = conf->mouse.alternate_scroll_mode, .meta = { @@ -1431,7 +1430,7 @@ term_destroy(struct terminal *term) grid_free(&term->normal); grid_free(&term->alt); - free(term->composed); + composed_free(term->composed); free(term->window_title); tll_free_and_free(term->window_title_stack, free); diff --git a/terminal.h b/terminal.h index c9f5aee8..00c4221f 100644 --- a/terminal.h +++ b/terminal.h @@ -16,6 +16,7 @@ #include //#include "config.h" +#include "composed.h" #include "debug.h" #include "fdm.h" #include "macros.h" @@ -84,12 +85,6 @@ struct damage { int lines; }; -struct composed { - wchar_t chars[10]; - uint8_t count; - int width; -}; - struct row_uri_range { int start; int end; diff --git a/vt.c b/vt.c index bbe6fc9a..158ac539 100644 --- a/vt.c +++ b/vt.c @@ -611,21 +611,22 @@ action_utf8_print(struct terminal *term, wchar_t wc) xassert(col >= 0 && col < term->cols); wchar_t base = row->cells[col].wc; wchar_t UNUSED last = base; - size_t search_start_index = 0; + uint32_t key = base ^ wc; /* Is base cell already a cluster? */ const struct composed *composed = - (base >= CELL_COMB_CHARS_LO && - base < (CELL_COMB_CHARS_LO + term->composed_count)) - ? &term->composed[base - CELL_COMB_CHARS_LO] + (base >= CELL_COMB_CHARS_LO && base <= CELL_COMB_CHARS_HI) + ? composed_lookup(term->composed, base - CELL_COMB_CHARS_LO) : NULL; if (composed != NULL) { - search_start_index = base - CELL_COMB_CHARS_LO; base = composed->chars[0]; last = composed->chars[composed->count - 1]; + key = composed->key ^ wc; } + key &= CELL_COMB_CHARS_HI - CELL_COMB_CHARS_LO; + #if defined(FOOT_GRAPHEME_CLUSTERING) if (grapheme_clustering) { /* Check if we're on a grapheme cluster break */ @@ -677,7 +678,7 @@ action_utf8_print(struct terminal *term, wchar_t wc) } size_t wanted_count = composed != NULL ? composed->count + 1 : 2; - if (wanted_count > ALEN(composed->chars)) { + if (wanted_count > 255) { xassert(composed != NULL); #if defined(LOG_ENABLE_DBG) && LOG_ENABLE_DBG @@ -691,47 +692,46 @@ action_utf8_print(struct terminal *term, wchar_t wc) wanted_count--; } - xassert(wanted_count <= ALEN(composed->chars)); + xassert(wanted_count <= 255); /* Look for existing combining chain */ - for (size_t i = search_start_index; i < term->composed_count; i++) { - const struct composed *cc = &term->composed[i]; + while (true) { + const struct composed *cc = composed_lookup(term->composed, key); + if (cc == NULL) + break; - if (cc->chars[0] != base) - continue; + /* + * We may have a key collisison, so need to check that + * it’s a true match. If not, bumb the key and try + * again. + */ - if (cc->count != wanted_count) + if (cc->chars[0] != base || + cc->count != wanted_count || + cc->chars[wanted_count - 1] != wc) + { + key++; continue; - - bool match = true; - for (size_t j = 1; j < wanted_count - 1; j++) { - if (cc->chars[j] != composed->chars[j]) { - match = false; - break; - } } - if (!match) - continue; - if (cc->chars[wanted_count - 1] != wc) + bool match = composed != NULL + ? memcmp(&cc->chars[1], &composed->chars[1], + (wanted_count - 2) * sizeof(cc->chars[0])) == 0 + : true; + + if (!match) { + key++; continue; + } - wc = CELL_COMB_CHARS_LO + i; + wc = CELL_COMB_CHARS_LO + cc->key; width = cc->width; goto out; } - /* Allocate new chain */ - - struct composed new_cc; - new_cc.count = wanted_count; - new_cc.chars[0] = base; - - for (size_t i = 1; i < wanted_count - 1; i++) - new_cc.chars[i] = composed->chars[i]; - new_cc.chars[wanted_count - 1] = wc; - - if (unlikely(term->composed_count >= CELL_COMB_CHARS_HI)) { + if (unlikely(term->composed_count >= + (CELL_COMB_CHARS_HI - CELL_COMB_CHARS_LO))) + { /* We reached our maximum number of allowed composed * character chains. Fall through here and print the * current zero-width character to the current cell */ @@ -739,18 +739,32 @@ action_utf8_print(struct terminal *term, wchar_t wc) goto out; } + /* Allocate new chain */ + struct composed *new_cc = xmalloc(sizeof(*new_cc)); + new_cc->chars = xmalloc(wanted_count * sizeof(new_cc->chars[0])); + new_cc->key = key; + new_cc->count = wanted_count; + new_cc->chars[0] = base; + new_cc->chars[wanted_count - 1] = wc; + + if (composed != NULL) { + memcpy(&new_cc->chars[1], &composed->chars[1], + (wanted_count - 2) * sizeof(new_cc->chars[0])); + } + int grapheme_width = composed != NULL ? composed->width : base_width; + if (wc == 0xfe0f && grapheme_width < 2) grapheme_width = 2; else grapheme_width += width; - new_cc.width = grapheme_width; + new_cc->width = grapheme_width; term->composed_count++; - term->composed = xrealloc(term->composed, term->composed_count * sizeof(term->composed[0])); - term->composed[term->composed_count - 1] = new_cc; + key = composed_insert(&term->composed, new_cc); + wc = CELL_COMB_CHARS_LO + key; + xassert(wc <= CELL_COMB_CHARS_HI); - wc = CELL_COMB_CHARS_LO + term->composed_count - 1; width = grapheme_width; goto out; } -- cgit v1.3