From 20923bb2e8235c0e3d72f7c6195523ad0b0a2afa Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Sun, 23 Jun 2024 13:29:12 +0200 Subject: grid: refactor: first step towards a more generic range handling --- grid.c | 163 ++++++++++++++++++++++++++++++++++++++--------------------------- 1 file changed, 95 insertions(+), 68 deletions(-) (limited to 'grid.c') diff --git a/grid.c b/grid.c index 85e6183f..cbc00177 100644 --- a/grid.c +++ b/grid.c @@ -85,22 +85,27 @@ ensure_row_has_extra_data(struct row *row) } static void -verify_no_overlapping_uris(const struct row_data *extra) +verify_no_overlapping_ranges_of_type(const struct row_ranges *ranges, + enum row_range_type type) { #if defined(_DEBUG) - for (size_t i = 0; i < extra->uri_ranges.count; i++) { - const struct row_uri_range *r1 = &extra->uri_ranges.v[i]; + for (size_t i = 0; i < ranges->count; i++) { + const struct row_range *r1 = &ranges->v[i]; - for (size_t j = i + 1; j < extra->uri_ranges.count; j++) { - const struct row_uri_range *r2 = &extra->uri_ranges.v[j]; + for (size_t j = i + 1; j < ranges->count; j++) { + const struct row_range *r2 = &ranges->v[j]; xassert(r1 != r2); if ((r1->start <= r2->start && r1->end >= r2->start) || (r1->start <= r2->end && r1->end >= r2->end)) { - BUG("OSC-8 URI overlap: %s: %d-%d: %s: %d-%d", - r1->uri, r1->start, r1->end, - r2->uri, r2->start, r2->end); + switch (type) { + case ROW_RANGE_URI: + BUG("OSC-8 URI overlap: %s: %d-%d: %s: %d-%d", + r1->uri.uri, r1->start, r1->end, + r2->uri.uri, r2->start, r2->end); + break; + } } } } @@ -108,20 +113,31 @@ verify_no_overlapping_uris(const struct row_data *extra) } static void -verify_uris_are_sorted(const struct row_data *extra) +verify_no_overlapping_ranges(const struct row_data *extra) +{ + verify_no_overlapping_ranges_of_type(&extra->uri_ranges, ROW_RANGE_URI); +} + +static void +verify_ranges_of_type_are_sorted(const struct row_ranges *ranges, + enum row_range_type type) { #if defined(_DEBUG) - const struct row_uri_range *last = NULL; + const struct row_range *last = NULL; - for (size_t i = 0; i < extra->uri_ranges.count; i++) { - const struct row_uri_range *r = &extra->uri_ranges.v[i]; + for (size_t i = 0; i < ranges->count; i++) { + const struct row_range *r = &ranges->v[i]; if (last != NULL) { if (last->start >= r->start || last->end >= r->end) { - BUG("OSC-8 URI not sorted correctly: " - "%s: %d-%d came before %s: %d-%d", - last->uri, last->start, last->end, - r->uri, r->start, r->end); + switch (type) { + case ROW_RANGE_URI: + BUG("OSC-8 URI not sorted correctly: " + "%s: %d-%d came before %s: %d-%d", + last->uri.uri, last->start, last->end, + r->uri.uri, r->start, r->end); + break; + } } } @@ -130,6 +146,12 @@ verify_uris_are_sorted(const struct row_data *extra) #endif } +static void +verify_ranges_are_sorted(const struct row_data *extra) +{ + verify_ranges_of_type_are_sorted(&extra->uri_ranges, ROW_RANGE_URI); +} + static void uri_range_ensure_size(struct row_data *extra, uint32_t count_to_add) { @@ -161,11 +183,13 @@ uri_range_insert(struct row_data *extra, size_t idx, int start, int end, move_count * sizeof(extra->uri_ranges.v[0])); extra->uri_ranges.count++; - extra->uri_ranges.v[idx] = (struct row_uri_range){ + extra->uri_ranges.v[idx] = (struct row_range){ .start = start, .end = end, - .id = id, - .uri = xstrdup(uri), + .uri = { + .id = id, + .uri = xstrdup(uri), + }, }; } @@ -174,11 +198,13 @@ uri_range_append_no_strdup(struct row_data *extra, int start, int end, uint64_t id, char *uri) { uri_range_ensure_size(extra, 1); - extra->uri_ranges.v[extra->uri_ranges.count++] = (struct row_uri_range){ + extra->uri_ranges.v[extra->uri_ranges.count++] = (struct row_range){ .start = start, .end = end, - .id = id, - .uri = uri, + .uri = { + .id = id, + .uri = uri, + }, }; } @@ -246,10 +272,10 @@ grid_snapshot(const struct grid *grid) uri_range_ensure_size(clone_extra, extra->uri_ranges.count); for (size_t i = 0; i < extra->uri_ranges.count; i++) { - const struct row_uri_range *range = &extra->uri_ranges.v[i]; + const struct row_range *range = &extra->uri_ranges.v[i]; uri_range_append( clone_extra, - range->start, range->end, range->id, range->uri); + range->start, range->end, range->uri.id, range->uri.uri); } } else clone_row->extra = NULL; @@ -467,7 +493,7 @@ grid_resize_without_reflow( uri_range_ensure_size(new_extra, old_extra->uri_ranges.count); for (size_t i = 0; i < old_extra->uri_ranges.count; i++) { - const struct row_uri_range *range = &old_extra->uri_ranges.v[i]; + const struct row_range *range = &old_extra->uri_ranges.v[i]; if (range->start >= new_cols) { /* The whole range is truncated */ @@ -476,7 +502,7 @@ grid_resize_without_reflow( const int start = range->start; const int end = min(range->end, new_cols - 1); - uri_range_append(new_extra, start, end, range->id, range->uri); + uri_range_append(new_extra, start, end, range->uri.id, range->uri.uri); } } @@ -498,8 +524,8 @@ grid_resize_without_reflow( if (row->extra == NULL) continue; - verify_no_overlapping_uris(row->extra); - verify_uris_are_sorted(row->extra); + verify_no_overlapping_ranges(row->extra); + verify_ranges_are_sorted(row->extra); } #endif @@ -549,26 +575,26 @@ grid_resize_without_reflow( } static void -reflow_uri_range_start(struct row_uri_range *range, struct row *new_row, +reflow_uri_range_start(struct row_range *range, struct row *new_row, int new_col_idx) { ensure_row_has_extra_data(new_row); uri_range_append_no_strdup - (new_row->extra, new_col_idx, -1, range->id, range->uri); - range->uri = NULL; + (new_row->extra, new_col_idx, -1, range->uri.id, range->uri.uri); + range->uri.uri = NULL; } static void -reflow_uri_range_end(struct row_uri_range *range, struct row *new_row, +reflow_uri_range_end(struct row_range *range, struct row *new_row, int new_col_idx) { struct row_data *extra = new_row->extra; xassert(extra->uri_ranges.count > 0); - struct row_uri_range *new_range = + struct row_range *new_range = &extra->uri_ranges.v[extra->uri_ranges.count - 1]; - xassert(new_range->id == range->id); + xassert(new_range->uri.id == range->uri.id); xassert(new_range->end < 0); new_range->end = new_col_idx; } @@ -619,7 +645,7 @@ _line_wrap(struct grid *old_grid, struct row **new_grid, struct row *row, * next/current row. */ if (extra->uri_ranges.count > 0) { - struct row_uri_range *range = + struct row_range *range = &extra->uri_ranges.v[extra->uri_ranges.count - 1]; if (range->end < 0) { @@ -629,7 +655,7 @@ _line_wrap(struct grid *old_grid, struct row **new_grid, struct row *row, /* Open a new range on the new/current row */ ensure_row_has_extra_data(new_row); - uri_range_append(new_row->extra, 0, -1, range->id, range->uri); + uri_range_append(new_row->extra, 0, -1, range->uri.id, range->uri.uri); } } @@ -817,7 +843,7 @@ grid_resize_and_reflow( tp = NULL; /* Does this row have any URIs? */ - struct row_uri_range *range, *range_terminator; + struct row_range *range, *range_terminator; struct row_data *extra = old_row->extra; if (extra != NULL && extra->uri_ranges.count > 0) { @@ -826,7 +852,7 @@ grid_resize_and_reflow( /* Make sure the *last* URI range's end point is included * in the copy */ - const struct row_uri_range *last_on_row = + const struct row_range *last_on_row = &extra->uri_ranges.v[extra->uri_ranges.count - 1]; col_count = max(col_count, last_on_row->end + 1); } else @@ -1043,8 +1069,8 @@ grid_resize_and_reflow( for (size_t i = 0; i < row->extra->uri_ranges.count; i++) xassert(row->extra->uri_ranges.v[i].end >= 0); - verify_no_overlapping_uris(row->extra); - verify_uris_are_sorted(row->extra); + verify_no_overlapping_ranges(row->extra); + verify_ranges_are_sorted(row->extra); } /* Verify all old rows have been free:d */ @@ -1136,9 +1162,9 @@ grid_row_uri_range_put(struct row *row, int col, const char *uri, uint64_t id) struct row_data *extra = row->extra; for (ssize_t i = (ssize_t)extra->uri_ranges.count - 1; i >= 0; i--) { - struct row_uri_range *r = &extra->uri_ranges.v[i]; + struct row_range *r = &extra->uri_ranges.v[i]; - const bool matching_id = r->id == id; + const bool matching_id = r->uri.id == id; if (matching_id && r->end + 1 == col) { /* Extend existing URI's tail */ @@ -1177,7 +1203,7 @@ grid_row_uri_range_put(struct row *row, int col, const char *uri, uint64_t id) xassert(r->start < col); xassert(r->end > col); - uri_range_insert(extra, i + 1, col + 1, r->end, r->id, r->uri); + uri_range_insert(extra, i + 1, col + 1, r->end, r->uri.id, r->uri.uri); /* The insertion may xrealloc() the vector, making our * 'old' pointer invalid */ @@ -1196,21 +1222,23 @@ grid_row_uri_range_put(struct row *row, int col, const char *uri, uint64_t id) if (replace) { grid_row_uri_range_destroy(&extra->uri_ranges.v[insert_idx]); - extra->uri_ranges.v[insert_idx] = (struct row_uri_range){ + extra->uri_ranges.v[insert_idx] = (struct row_range){ .start = col, .end = col, - .id = id, - .uri = xstrdup(uri), + .uri = { + .id = id, + .uri = xstrdup(uri), + }, }; } else uri_range_insert(extra, insert_idx, col, col, id, uri); if (run_merge_pass) { for (size_t i = 1; i < extra->uri_ranges.count; i++) { - struct row_uri_range *r1 = &extra->uri_ranges.v[i - 1]; - struct row_uri_range *r2 = &extra->uri_ranges.v[i]; + struct row_range *r1 = &extra->uri_ranges.v[i - 1]; + struct row_range *r2 = &extra->uri_ranges.v[i]; - if (r1->id == r2->id && r1->end + 1 == r2->start) { + if (r1->uri.id == r2->uri.id && r1->end + 1 == r2->start) { r1->end = r2->end; uri_range_delete(extra, i); i--; @@ -1219,8 +1247,8 @@ grid_row_uri_range_put(struct row *row, int col, const char *uri, uint64_t id) } out: - verify_no_overlapping_uris(extra); - verify_uris_are_sorted(extra); + verify_no_overlapping_ranges(extra); + verify_ranges_are_sorted(extra); } UNITTEST @@ -1233,7 +1261,7 @@ UNITTEST xassert(idx < row_data.uri_ranges.count); \ xassert(row_data.uri_ranges.v[idx].start == _start); \ xassert(row_data.uri_ranges.v[idx].end == _end); \ - xassert(row_data.uri_ranges.v[idx].id == _id); \ + xassert(row_data.uri_ranges.v[idx].uri.id == _id); \ } while (0) grid_row_uri_range_put(&row, 0, "http://foo.bar", 123); @@ -1298,7 +1326,7 @@ grid_row_uri_range_erase(struct row *row, int start, int end) /* Split up, or remove, URI ranges affected by the erase */ for (ssize_t i = (ssize_t)extra->uri_ranges.count - 1; i >= 0; i--) { - struct row_uri_range *old = &extra->uri_ranges.v[i]; + struct row_range *old = &extra->uri_ranges.v[i]; if (old->end < start) return; @@ -1314,7 +1342,7 @@ grid_row_uri_range_erase(struct row *row, int start, int end) else if (start > old->start && end < old->end) { /* Erase range erases a part in the middle of the URI */ uri_range_insert( - extra, i + 1, end + 1, old->end, old->id, old->uri); + extra, i + 1, end + 1, old->end, old->uri.id, old->uri.uri); /* The insertion may xrealloc() the vector, making our * 'old' pointer invalid */ @@ -1352,14 +1380,14 @@ UNITTEST xassert(row_data.uri_ranges.count == 2); xassert(row_data.uri_ranges.v[1].start == 11); xassert(row_data.uri_ranges.v[1].end == 20); - verify_no_overlapping_uris(&row_data); - verify_uris_are_sorted(&row_data); + verify_no_overlapping_ranges(&row_data); + verify_ranges_are_sorted(&row_data); /* Erase both URis */ grid_row_uri_range_erase(&row, 1, 20); xassert(row_data.uri_ranges.count == 0); - verify_no_overlapping_uris(&row_data); - verify_uris_are_sorted(&row_data); + verify_no_overlapping_ranges(&row_data); + verify_ranges_are_sorted(&row_data); /* Two URIs, then erase second half of the first, first half of the second */ @@ -1371,11 +1399,11 @@ UNITTEST xassert(row_data.uri_ranges.v[0].end == 4); xassert(row_data.uri_ranges.v[1].start == 16); xassert(row_data.uri_ranges.v[1].end == 20); - verify_no_overlapping_uris(&row_data); - verify_uris_are_sorted(&row_data); + verify_no_overlapping_ranges(&row_data); + verify_ranges_are_sorted(&row_data); - grid_row_uri_range_destroy(&row_data.uri_ranges.v[0]); - grid_row_uri_range_destroy(&row_data.uri_ranges.v[1]); + grid_row_range_destroy(&row_data.uri_ranges.v[0], ROW_RANGE_URI); + grid_row_range_destroy(&row_data.uri_ranges.v[1], ROW_RANGE_URI); row_data.uri_ranges.count = 0; /* One URI, erase middle part of it */ @@ -1386,11 +1414,11 @@ UNITTEST xassert(row_data.uri_ranges.v[0].end == 4); xassert(row_data.uri_ranges.v[1].start == 7); xassert(row_data.uri_ranges.v[1].end == 10); - verify_no_overlapping_uris(&row_data); - verify_uris_are_sorted(&row_data); + verify_no_overlapping_ranges(&row_data); + verify_ranges_are_sorted(&row_data); - grid_row_uri_range_destroy(&row_data.uri_ranges.v[0]); - grid_row_uri_range_destroy(&row_data.uri_ranges.v[1]); + grid_row_range_destroy(&row_data.uri_ranges.v[0], ROW_RANGE_URI); + grid_row_range_destroy(&row_data.uri_ranges.v[1], ROW_RANGE_URI); row_data.uri_ranges.count = 0; /* @@ -1416,7 +1444,6 @@ UNITTEST grid_row_uri_range_erase(&row, 5, 7); xassert(row_data.uri_ranges.count == 2); - for (size_t i = 0; i < row_data.uri_ranges.count; i++) - grid_row_uri_range_destroy(&row_data.uri_ranges.v[i]); + grid_row_ranges_destroy(&row_data.uri_ranges, ROW_RANGE_URI); free(row_data.uri_ranges.v); } -- cgit v1.3 From 32effc6657c1802cdf34098748337b0d7bc39dba Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Sun, 23 Jun 2024 17:39:15 +0200 Subject: csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied. --- csi.c | 58 ++++++++++++- grid.c | 279 +++++++++++++++++++++++++++++++++++++++++++++++++------------ grid.h | 15 +++- render.c | 39 ++++++++- terminal.c | 22 ++++- terminal.h | 26 +++++- 6 files changed, 372 insertions(+), 67 deletions(-) (limited to 'grid.c') diff --git a/csi.c b/csi.c index be470e70..b3583df5 100644 --- a/csi.c +++ b/csi.c @@ -32,7 +32,14 @@ static void sgr_reset(struct terminal *term) { + /* TODO: can we drop this check? */ + const enum curly_style curly_style = term->vt.curly.style; + memset(&term->vt.attrs, 0, sizeof(term->vt.attrs)); + memset(&term->vt.curly, 0, sizeof(term->vt.curly)); + + if (unlikely(curly_style > CURLY_SINGLE)) + term_update_ascii_printer(term); } static const char * @@ -88,7 +95,34 @@ csi_sgr(struct terminal *term) case 1: term->vt.attrs.bold = true; break; case 2: term->vt.attrs.dim = true; break; case 3: term->vt.attrs.italic = true; break; - case 4: term->vt.attrs.underline = true; break; + case 4: { + term->vt.attrs.underline = true; + term->vt.curly.style = CURLY_SINGLE; + + if (unlikely(term->vt.params.v[i].sub.idx == 1)) { + enum curly_style style = term->vt.params.v[i].sub.value[0]; + + switch (style) { + default: + case CURLY_NONE: + term->vt.attrs.underline = false; + term->vt.curly.style = CURLY_NONE; + break; + + case CURLY_SINGLE: + case CURLY_DOUBLE: + case CURLY_CURLY: + case CURLY_DOTTED: + case CURLY_DASHED: + term->vt.curly.style = style; break; + break; + } + + term_update_ascii_printer(term); + } + LOG_WARN("CURLY: %d", term->vt.curly.style); + break; + } case 5: term->vt.attrs.blink = true; break; case 6: LOG_WARN("ignored: rapid blink"); break; case 7: term->vt.attrs.reverse = true; break; @@ -98,7 +132,12 @@ csi_sgr(struct terminal *term) case 21: break; /* double-underline, not implemented */ case 22: term->vt.attrs.bold = term->vt.attrs.dim = false; break; case 23: term->vt.attrs.italic = false; break; - case 24: term->vt.attrs.underline = false; break; + case 24: { + term->vt.attrs.underline = false; + term->vt.curly.style = CURLY_NONE; + term_update_ascii_printer(term); + break; + } case 25: term->vt.attrs.blink = false; break; case 26: break; /* rapid blink, ignored */ case 27: term->vt.attrs.reverse = false; break; @@ -119,7 +158,8 @@ csi_sgr(struct terminal *term) break; case 38: - case 48: { + case 48: + case 58: { uint32_t color; enum color_source src; @@ -194,7 +234,11 @@ csi_sgr(struct terminal *term) break; } - if (param == 38) { + if (unlikely(param == 58)) { + term->vt.curly.color_src = src; + term->vt.curly.color = color; + term_update_ascii_printer(term); + } else if (param == 38) { term->vt.attrs.fg_src = src; term->vt.attrs.fg = color; } else { @@ -226,6 +270,12 @@ csi_sgr(struct terminal *term) term->vt.attrs.bg_src = COLOR_DEFAULT; break; + case 59: + term->vt.curly.color_src = COLOR_DEFAULT; + term->vt.curly.color = 0; + term_update_ascii_printer(term); + break; + /* Bright foreground colors */ case 90: case 91: diff --git a/grid.c b/grid.c index cbc00177..2eade784 100644 --- a/grid.c +++ b/grid.c @@ -105,6 +105,11 @@ verify_no_overlapping_ranges_of_type(const struct row_ranges *ranges, r1->uri.uri, r1->start, r1->end, r2->uri.uri, r2->start, r2->end); break; + + case ROW_RANGE_CURLY: + BUG("curly underline overlap: %d-%d, %d-%d", + r1->start, r1->end, r2->start, r2->end); + break; } } } @@ -116,6 +121,7 @@ static void verify_no_overlapping_ranges(const struct row_data *extra) { verify_no_overlapping_ranges_of_type(&extra->uri_ranges, ROW_RANGE_URI); + verify_no_overlapping_ranges_of_type(&extra->curly_ranges, ROW_RANGE_CURLY); } static void @@ -137,6 +143,12 @@ verify_ranges_of_type_are_sorted(const struct row_ranges *ranges, last->uri.uri, last->start, last->end, r->uri.uri, r->start, r->end); break; + + case ROW_RANGE_CURLY: + BUG("curly ranges not sorted correctly: " + "%d-%d came before %d-%d", + last->start, last->end, r->start, r->end); + break; } } } @@ -150,54 +162,65 @@ static void verify_ranges_are_sorted(const struct row_data *extra) { verify_ranges_of_type_are_sorted(&extra->uri_ranges, ROW_RANGE_URI); + verify_ranges_of_type_are_sorted(&extra->curly_ranges, ROW_RANGE_CURLY); } static void -uri_range_ensure_size(struct row_data *extra, uint32_t count_to_add) +range_ensure_size(struct row_ranges *ranges, int count_to_add) { - if (extra->uri_ranges.count + count_to_add > extra->uri_ranges.size) { - extra->uri_ranges.size = extra->uri_ranges.count + count_to_add; - extra->uri_ranges.v = xrealloc( - extra->uri_ranges.v, - extra->uri_ranges.size * sizeof(extra->uri_ranges.v[0])); + if (ranges->count + count_to_add > ranges->size) { + ranges->size = ranges->count + count_to_add; + ranges->v = xrealloc(ranges->v, ranges->size * sizeof(ranges->v[0])); } - xassert(extra->uri_ranges.count + count_to_add <= extra->uri_ranges.size); + xassert(ranges->count + count_to_add <= ranges->size); } -/* - * Be careful! This function may xrealloc() the URI range vector, thus - * invalidating pointers into it. - */ static void -uri_range_insert(struct row_data *extra, size_t idx, int start, int end, - uint64_t id, const char *uri) +range_insert(struct row_ranges *ranges, size_t idx, int start, int end) { - uri_range_ensure_size(extra, 1); + range_ensure_size(ranges, 1); - xassert(idx <= extra->uri_ranges.count); + xassert(idx <= ranges->count); - const size_t move_count = extra->uri_ranges.count - idx; - memmove(&extra->uri_ranges.v[idx + 1], - &extra->uri_ranges.v[idx], - move_count * sizeof(extra->uri_ranges.v[0])); + const size_t move_count = ranges->count - idx; + memmove(&ranges->v[idx + 1], + &ranges->v[idx], + move_count * sizeof(ranges->v[0])); - extra->uri_ranges.count++; - extra->uri_ranges.v[idx] = (struct row_range){ + ranges->count++; + ranges->v[idx] = (struct row_range){ .start = start, .end = end, - .uri = { - .id = id, - .uri = xstrdup(uri), - }, }; } +/* + * Be careful! This function may xrealloc() the URI range vector, thus + * invalidating pointers into it. + */ +static void +uri_range_insert(struct row_ranges *ranges, size_t idx, int start, int end, + uint64_t id, const char *uri) +{ + range_insert(ranges, idx, start, end); + ranges->v[idx].uri.id = id; + ranges->v[idx].uri.uri = xstrdup(uri); +} + +static void +curly_range_insert(struct row_ranges *ranges, size_t idx, int start, int end, + struct curly_range_data data) +{ + range_insert(ranges, idx, start, end); + ranges->v[idx].curly = data; +} + static void uri_range_append_no_strdup(struct row_data *extra, int start, int end, uint64_t id, char *uri) { - uri_range_ensure_size(extra, 1); + range_ensure_size(&extra->uri_ranges, 1); extra->uri_ranges.v[extra->uri_ranges.count++] = (struct row_range){ .start = start, .end = end, @@ -216,16 +239,16 @@ uri_range_append(struct row_data *extra, int start, int end, uint64_t id, } static void -uri_range_delete(struct row_data *extra, size_t idx) +range_delete(struct row_ranges *ranges, enum row_range_type type, size_t idx) { - xassert(idx < extra->uri_ranges.count); - grid_row_uri_range_destroy(&extra->uri_ranges.v[idx]); - - const size_t move_count = extra->uri_ranges.count - idx - 1; - memmove(&extra->uri_ranges.v[idx], - &extra->uri_ranges.v[idx + 1], - move_count * sizeof(extra->uri_ranges.v[0])); - extra->uri_ranges.count--; + xassert(idx < ranges->count); + grid_row_range_destroy(&ranges->v[idx], type); + + const size_t move_count = ranges->count - idx - 1; + memmove(&ranges->v[idx], + &ranges->v[idx + 1], + move_count * sizeof(ranges->v[0])); + ranges->count--; } struct grid * @@ -269,14 +292,20 @@ grid_snapshot(const struct grid *grid) struct row_data *clone_extra = xcalloc(1, sizeof(*clone_extra)); clone_row->extra = clone_extra; - uri_range_ensure_size(clone_extra, extra->uri_ranges.count); + range_ensure_size(&clone_extra->uri_ranges, extra->uri_ranges.count); + range_ensure_size(&clone_extra->curly_ranges, extra->curly_ranges.count); - for (size_t i = 0; i < extra->uri_ranges.count; i++) { + for (int i = 0; i < extra->uri_ranges.count; i++) { const struct row_range *range = &extra->uri_ranges.v[i]; uri_range_append( clone_extra, range->start, range->end, range->uri.id, range->uri.uri); } + + for (int i = 0; i < extra->curly_ranges.count; i++) { + //const struct row_range *range = &extra->curly_ranges.v[i]; + BUG("TODO"); + } } else clone_row->extra = NULL; } @@ -490,9 +519,10 @@ grid_resize_without_reflow( ensure_row_has_extra_data(new_row); struct row_data *new_extra = new_row->extra; - uri_range_ensure_size(new_extra, old_extra->uri_ranges.count); + range_ensure_size(&new_extra->uri_ranges, old_extra->uri_ranges.count); + range_ensure_size(&new_extra->curly_ranges, old_extra->curly_ranges.count); - for (size_t i = 0; i < old_extra->uri_ranges.count; i++) { + for (int i = 0; i < old_extra->uri_ranges.count; i++) { const struct row_range *range = &old_extra->uri_ranges.v[i]; if (range->start >= new_cols) { @@ -504,7 +534,21 @@ grid_resize_without_reflow( const int end = min(range->end, new_cols - 1); uri_range_append(new_extra, start, end, range->uri.id, range->uri.uri); } - } + + for (int i = 0; i < old_extra->uri_ranges.count; i++) { + const struct row_range *range = &old_extra->uri_ranges.v[i]; + + if (range->start >= new_cols) { + /* The whole range is truncated */ + continue; + } + + //const int start = range->start; + //const int end = min(range->end, new_cols - 1); + //uri_range_append(new_extra, start, end, range->uri.id, range->uri.uri); + BUG("TODO"); + } +} /* Clear "new" lines */ for (int r = min(old_screen_rows, new_screen_rows); r < new_screen_rows; r++) { @@ -1161,7 +1205,7 @@ grid_row_uri_range_put(struct row *row, int col, const char *uri, uint64_t id) bool run_merge_pass = false; struct row_data *extra = row->extra; - for (ssize_t i = (ssize_t)extra->uri_ranges.count - 1; i >= 0; i--) { + for (int i = extra->uri_ranges.count - 1; i >= 0; i--) { struct row_range *r = &extra->uri_ranges.v[i]; const bool matching_id = r->uri.id == id; @@ -1203,7 +1247,8 @@ grid_row_uri_range_put(struct row *row, int col, const char *uri, uint64_t id) xassert(r->start < col); xassert(r->end > col); - uri_range_insert(extra, i + 1, col + 1, r->end, r->uri.id, r->uri.uri); + uri_range_insert( + &extra->uri_ranges, i + 1, col + 1, r->end, r->uri.id, r->uri.uri); /* The insertion may xrealloc() the vector, making our * 'old' pointer invalid */ @@ -1231,7 +1276,7 @@ grid_row_uri_range_put(struct row *row, int col, const char *uri, uint64_t id) }, }; } else - uri_range_insert(extra, insert_idx, col, col, id, uri); + uri_range_insert(&extra->uri_ranges, insert_idx, col, col, id, uri); if (run_merge_pass) { for (size_t i = 1; i < extra->uri_ranges.count; i++) { @@ -1240,7 +1285,111 @@ grid_row_uri_range_put(struct row *row, int col, const char *uri, uint64_t id) if (r1->uri.id == r2->uri.id && r1->end + 1 == r2->start) { r1->end = r2->end; - uri_range_delete(extra, i); + range_delete(&extra->uri_ranges, ROW_RANGE_URI, i); + i--; + } + } + } + +out: + verify_no_overlapping_ranges(extra); + verify_ranges_are_sorted(extra); +} + +void +grid_row_curly_range_put(struct row *row, int col, struct curly_range_data data) +{ + ensure_row_has_extra_data(row); + + size_t insert_idx = 0; + bool replace = false; + bool run_merge_pass = false; + + struct row_data *extra = row->extra; + for (int i = extra->curly_ranges.count - 1; i >= 0; i--) { + struct row_range *r = &extra->curly_ranges.v[i]; + + const bool matching = r->curly.style == data.style && + r->curly.color_src == data.color_src && + r->curly.color == data.color; + + if (matching && r->end + 1 == col) { + /* Extend existing curly tail */ + r->end++; + goto out; + } + + else if (r->end < col) { + insert_idx = i + 1; + break; + } + + else if (r->start > col) + continue; + + else { + xassert(r->start <= col); + xassert(r->end >= col); + + if (matching) + goto out; + + if (r->start == r->end) { + replace = true; + run_merge_pass = true; + insert_idx = i; + } else if (r->start == col) { + run_merge_pass = true; + r->start++; + insert_idx = i; + } else if (r->end == col) { + run_merge_pass = true; + r->end--; + insert_idx = i + 1; + } else { + xassert(r->start < col); + xassert(r->end > col); + + curly_range_insert( + &extra->curly_ranges, i + 1, col + 1, r->end, data); + + /* The insertion may xrealloc() the vector, making our + * 'old' pointer invalid */ + r = &extra->curly_ranges.v[i]; + r->end = col - 1; + xassert(r->start <= r->end); + + insert_idx = i + 1; + } + + break; + } + } + + xassert(insert_idx <= extra->curly_ranges.count); + + if (replace) { + grid_row_curly_range_destroy(&extra->curly_ranges.v[insert_idx]); + extra->curly_ranges.v[insert_idx] = (struct row_range){ + .start = col, + .end = col, + .curly = data, + }; + } else + curly_range_insert(&extra->curly_ranges, insert_idx, col, col, data); + + if (run_merge_pass) { + for (size_t i = 1; i < extra->curly_ranges.count; i++) { + struct row_range *r1 = &extra->curly_ranges.v[i - 1]; + struct row_range *r2 = &extra->curly_ranges.v[i]; + + if (r1->curly.style == r2->curly.style && + r1->curly.color_src == r2->curly.color_src && + r1->curly.color == r2->curly.color && + r1->end + 1 == r2->start) + { + r1->end = r2->end; + range_delete(&extra->curly_ranges, ROW_RANGE_CURLY, i); i--; } } @@ -1316,17 +1465,15 @@ UNITTEST #undef verify_range } -void -grid_row_uri_range_erase(struct row *row, int start, int end) +static void +grid_row_range_erase(struct row_ranges *ranges, enum row_range_type type, + int start, int end) { - xassert(row->extra != NULL); xassert(start <= end); - struct row_data *extra = row->extra; - /* Split up, or remove, URI ranges affected by the erase */ - for (ssize_t i = (ssize_t)extra->uri_ranges.count - 1; i >= 0; i--) { - struct row_range *old = &extra->uri_ranges.v[i]; + for (int i = ranges->count - 1; i >= 0; i--) { + struct row_range *old = &ranges->v[i]; if (old->end < start) return; @@ -1336,17 +1483,25 @@ grid_row_uri_range_erase(struct row *row, int start, int end) if (start <= old->start && end >= old->end) { /* Erase range covers URI completely - remove it */ - uri_range_delete(extra, i); + range_delete(ranges, type, i); } else if (start > old->start && end < old->end) { /* Erase range erases a part in the middle of the URI */ - uri_range_insert( - extra, i + 1, end + 1, old->end, old->uri.id, old->uri.uri); + switch (type) { + case ROW_RANGE_URI: + uri_range_insert( + ranges, i + 1, end + 1, old->end, old->uri.id, old->uri.uri); + break; + + case ROW_RANGE_CURLY: + curly_range_insert(ranges, i + 1, end + 1, old->end, old->curly); + break; + } /* The insertion may xrealloc() the vector, making our * 'old' pointer invalid */ - old = &extra->uri_ranges.v[i]; + old = &ranges->v[i]; old->end = start - 1; return; /* There can be no more URIs affected by the erase range */ } @@ -1366,6 +1521,20 @@ grid_row_uri_range_erase(struct row *row, int start, int end) } } +void +grid_row_uri_range_erase(struct row *row, int start, int end) +{ + xassert(row->extra != NULL); + grid_row_range_erase(&row->extra->uri_ranges, ROW_RANGE_URI, start, end); +} + +void +grid_row_curly_range_erase(struct row *row, int start, int end) +{ + xassert(row->extra != NULL); + grid_row_range_erase(&row->extra->curly_ranges, ROW_RANGE_CURLY, start, end); +} + UNITTEST { struct row_data row_data = {.uri_ranges = {0}}; diff --git a/grid.h b/grid.h index 7c1f14be..c5c2b60c 100644 --- a/grid.h +++ b/grid.h @@ -88,17 +88,27 @@ void grid_row_uri_range_put( struct row *row, int col, const char *uri, uint64_t id); void grid_row_uri_range_erase(struct row *row, int start, int end); +void grid_row_curly_range_put( + struct row *row, int col, struct curly_range_data data); +void grid_row_curly_range_erase(struct row *row, int start, int end); + static inline void grid_row_uri_range_destroy(struct row_range *range) { free(range->uri.uri); } +static inline void +grid_row_curly_range_destroy(struct row_range *range) +{ +} + static inline void grid_row_range_destroy(struct row_range *range, enum row_range_type type) { switch (type) { case ROW_RANGE_URI: grid_row_uri_range_destroy(range); break; + case ROW_RANGE_CURLY: grid_row_curly_range_destroy(range); break; } } @@ -118,9 +128,10 @@ grid_row_reset_extra(struct row *row) if (likely(extra == NULL)) return; - for (size_t i = 0; i < extra->uri_ranges.count; i++) - grid_row_uri_range_destroy(&extra->uri_ranges.v[i]); + grid_row_ranges_destroy(&extra->uri_ranges, ROW_RANGE_URI); + grid_row_ranges_destroy(&extra->curly_ranges, ROW_RANGE_CURLY); free(extra->uri_ranges.v); + free(extra->curly_ranges.v); free(extra); row->extra = NULL; diff --git a/render.c b/render.c index fd7e743a..78cc5325 100644 --- a/render.c +++ b/render.c @@ -847,8 +847,43 @@ render_cell(struct terminal *term, pixman_image_t *pix, pixman_region32_t *damag pixman_image_unref(clr_pix); /* Underline */ - if (cell->attrs.underline) - draw_underline(term, pix, font, &fg, x, y, cell_cols); + if (cell->attrs.underline) { + pixman_color_t underline_color = fg; + + /* Check if cell has a styled underline. This lookup is fairly + expensive... */ + if (row->extra != NULL) { + for (int i = 0; i < row->extra->curly_ranges.count; i++) { + const struct row_range *range = &row->extra->curly_ranges.v[i]; + + if (range->start <= col && col <= range->end) { + switch (range->curly.color_src) { + case COLOR_BASE256: + underline_color = color_hex_to_pixman( + term->colors.table[range->curly.color]); + break; + + case COLOR_RGB: + underline_color = + color_hex_to_pixman(range->curly.color); + break; + + case COLOR_DEFAULT: + break; + + case COLOR_BASE16: + BUG("underline color can't be base-16"); + break; + } + + break; + } + } + } + + draw_underline(term, pix, font, &underline_color, x, y, cell_cols); + + } if (cell->attrs.strikethrough) draw_strikeout(term, pix, font, &fg, x, y, cell_cols); diff --git a/terminal.c b/terminal.c index 55c387c1..48c0b298 100644 --- a/terminal.c +++ b/terminal.c @@ -1940,8 +1940,10 @@ erase_cell_range(struct terminal *term, struct row *row, int start, int end) } else memset(&row->cells[start], 0, (end - start + 1) * sizeof(row->cells[0])); - if (unlikely(row->extra != NULL)) + if (unlikely(row->extra != NULL)) { grid_row_uri_range_erase(row, start, end); + grid_row_curly_range_erase(row, start, end); + } } static inline void @@ -3621,6 +3623,7 @@ term_fill(struct terminal *term, int r, int c, uint8_t data, size_t count, cell->wc = data; cell->attrs = attrs; + /* TODO: why do we print the URI here, and then erase it below? */ if (unlikely(term->vt.osc8.uri != NULL)) { grid_row_uri_range_put(row, c, term->vt.osc8.uri, term->vt.osc8.id); @@ -3635,8 +3638,10 @@ term_fill(struct terminal *term, int r, int c, uint8_t data, size_t count, } } - if (unlikely(row->extra != NULL)) + if (unlikely(row->extra != NULL)) { grid_row_uri_range_erase(row, c, c + count - 1); + grid_row_curly_range_erase(row, c, c + count - 1); + } } void @@ -3706,6 +3711,13 @@ term_print(struct terminal *term, char32_t wc, int width) } else if (row->extra != NULL) grid_row_uri_range_erase(row, col, col + width - 1); + if (unlikely(term->vt.curly.style > CURLY_SINGLE || + term->vt.curly.color_src != COLOR_DEFAULT)) + { + grid_row_curly_range_put(row, col, term->vt.curly); + } else if (row->extra != NULL) + grid_row_curly_range_erase(row, col, col + width - 1); + /* Advance cursor the 'additional' columns while dirty:ing the cells */ for (int i = 1; i < width && (col + 1) < term->cols; i++) { col++; @@ -3763,8 +3775,10 @@ ascii_printer_fast(struct terminal *term, char32_t wc) grid->cursor.point.col = col; - if (unlikely(row->extra != NULL)) + if (unlikely(row->extra != NULL)) { grid_row_uri_range_erase(row, uri_start, uri_start); + grid_row_curly_range_erase(row, uri_start, uri_start); + } } static void @@ -3781,6 +3795,8 @@ term_update_ascii_printer(struct terminal *term) void (*new_printer)(struct terminal *term, char32_t wc) = unlikely(tll_length(term->grid->sixel_images) > 0 || term->vt.osc8.uri != NULL || + term->vt.curly.style > CURLY_SINGLE || + term->vt.curly.color_src != COLOR_DEFAULT || term->charsets.set[term->charsets.selected] == CHARSET_GRAPHIC || term->insert_mode) ? &ascii_printer_generic diff --git a/terminal.h b/terminal.h index fc654702..7f6814d3 100644 --- a/terminal.h +++ b/terminal.h @@ -104,12 +104,33 @@ struct uri_range_data { char *uri; }; +enum curly_style { + CURLY_NONE, + CURLY_SINGLE, /* Legacy underline */ + CURLY_DOUBLE, + CURLY_CURLY, + CURLY_DOTTED, + CURLY_DASHED, +}; + +struct curly_range_data { + enum curly_style style; + enum color_source color_src; + uint32_t color; +}; + +union row_range_data { + struct uri_range_data uri; + struct curly_range_data curly; +}; + struct row_range { int start; int end; union { struct uri_range_data uri; + struct curly_range_data curly; }; }; @@ -119,10 +140,11 @@ struct row_ranges { int count; }; -enum row_range_type {ROW_RANGE_URI}; +enum row_range_type {ROW_RANGE_URI, ROW_RANGE_CURLY}; struct row_data { struct row_ranges uri_ranges; + struct row_ranges curly_ranges; }; struct row { @@ -271,6 +293,8 @@ struct vt { char *uri; } osc8; + struct curly_range_data curly; + struct { uint8_t *data; size_t size; -- cgit v1.3 From b20302c2a7bcb70844f04c122c640b88be45ff60 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Mon, 24 Jun 2024 00:57:03 +0200 Subject: grid: reflow: handle styled underlines --- grid.c | 166 ++++++++++++++++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 128 insertions(+), 38 deletions(-) (limited to 'grid.c') diff --git a/grid.c b/grid.c index 2eade784..3cd818a7 100644 --- a/grid.c +++ b/grid.c @@ -238,6 +238,18 @@ uri_range_append(struct row_data *extra, int start, int end, uint64_t id, uri_range_append_no_strdup(extra, start, end, id, xstrdup(uri)); } +static void +curly_range_append(struct row_data *extra, int start, int end, + struct curly_range_data data) +{ + range_ensure_size(&extra->curly_ranges, 1); + extra->curly_ranges.v[extra->curly_ranges.count++] = (struct row_range){ + .start = start, + .end = end, + .curly = data, + }; +} + static void range_delete(struct row_ranges *ranges, enum row_range_type type, size_t idx) { @@ -303,8 +315,8 @@ grid_snapshot(const struct grid *grid) } for (int i = 0; i < extra->curly_ranges.count; i++) { - //const struct row_range *range = &extra->curly_ranges.v[i]; - BUG("TODO"); + const struct row_range *range = &extra->curly_ranges.v[i]; + curly_range_append(clone_extra, range->start, range->end, range->curly); } } else clone_row->extra = NULL; @@ -535,18 +547,17 @@ grid_resize_without_reflow( uri_range_append(new_extra, start, end, range->uri.id, range->uri.uri); } - for (int i = 0; i < old_extra->uri_ranges.count; i++) { - const struct row_range *range = &old_extra->uri_ranges.v[i]; + for (int i = 0; i < old_extra->curly_ranges.count; i++) { + const struct row_range *range = &old_extra->curly_ranges.v[i]; if (range->start >= new_cols) { /* The whole range is truncated */ continue; } - //const int start = range->start; - //const int end = min(range->end, new_cols - 1); - //uri_range_append(new_extra, start, end, range->uri.id, range->uri.uri); - BUG("TODO"); + const int start = range->start; + const int end = min(range->end, new_cols - 1); + curly_range_append(new_extra, start, end, range->curly); } } @@ -623,8 +634,8 @@ reflow_uri_range_start(struct row_range *range, struct row *new_row, int new_col_idx) { ensure_row_has_extra_data(new_row); - uri_range_append_no_strdup - (new_row->extra, new_col_idx, -1, range->uri.id, range->uri.uri); + uri_range_append_no_strdup( + new_row->extra, new_col_idx, -1, range->uri.id, range->uri.uri); range->uri.uri = NULL; } @@ -643,6 +654,33 @@ reflow_uri_range_end(struct row_range *range, struct row *new_row, new_range->end = new_col_idx; } +static void +reflow_curly_range_start(struct row_range *range, struct row *new_row, + int new_col_idx) +{ + ensure_row_has_extra_data(new_row); + curly_range_append(new_row->extra, new_col_idx, -1, range->curly); +} + + +static void +reflow_curly_range_end(struct row_range *range, struct row *new_row, + int new_col_idx) +{ + struct row_data *extra = new_row->extra; + xassert(extra->curly_ranges.count > 0); + + struct row_range *new_range = + &extra->curly_ranges.v[extra->curly_ranges.count - 1]; + + xassert(new_range->curly.style == range->curly.style); + xassert(new_range->curly.color_src == range->curly.color_src); + xassert(new_range->curly.color == range->curly.color); + + xassert(new_range->end < 0); + new_range->end = new_col_idx; +} + static struct row * _line_wrap(struct grid *old_grid, struct row **new_grid, struct row *row, int *row_idx, int *col_idx, int row_count, int col_count) @@ -703,6 +741,21 @@ _line_wrap(struct grid *old_grid, struct row **new_grid, struct row *row, } } + if (extra->curly_ranges.count > 0) { + struct row_range *range = + &extra->curly_ranges.v[extra->curly_ranges.count - 1]; + + if (range->end < 0) { + + /* Terminate URI range on the previous row */ + range->end = col_count - 1; + + /* Open a new range on the new/current row */ + ensure_row_has_extra_data(new_row); + curly_range_append(new_row->extra, 0, -1, range->curly); + } + } + return new_row; } @@ -887,12 +940,13 @@ grid_resize_and_reflow( tp = NULL; /* Does this row have any URIs? */ - struct row_range *range, *range_terminator; + struct row_range *uri_range, *uri_range_terminator; + struct row_range *curly_range, *curly_range_terminator; struct row_data *extra = old_row->extra; if (extra != NULL && extra->uri_ranges.count > 0) { - range = &extra->uri_ranges.v[0]; - range_terminator = &extra->uri_ranges.v[extra->uri_ranges.count]; + uri_range = &extra->uri_ranges.v[0]; + uri_range_terminator = &extra->uri_ranges.v[extra->uri_ranges.count]; /* Make sure the *last* URI range's end point is included * in the copy */ @@ -900,18 +954,32 @@ grid_resize_and_reflow( &extra->uri_ranges.v[extra->uri_ranges.count - 1]; col_count = max(col_count, last_on_row->end + 1); } else - range = range_terminator = NULL; + uri_range = uri_range_terminator = NULL; + + if (extra != NULL && extra->curly_ranges.count > 0) { + curly_range = &extra->curly_ranges.v[0]; + curly_range_terminator = &extra->curly_ranges.v[extra->curly_ranges.count]; + + const struct row_range *last_on_row = + &extra->curly_ranges.v[extra->curly_ranges.count - 1]; + col_count = max(col_count, last_on_row->end + 1); + } else + curly_range = curly_range_terminator = NULL; for (int start = 0, left = col_count; left > 0;) { int end; bool tp_break = false; bool uri_break = false; + bool curly_break = false; bool ftcs_break = false; /* Figure out where to end this chunk */ { - const int uri_col = range != range_terminator - ? ((range->start >= start ? range->start : range->end) + 1) + const int uri_col = uri_range != uri_range_terminator + ? ((uri_range->start >= start ? uri_range->start : uri_range->end) + 1) + : INT_MAX; + const int curly_col = curly_range != curly_range_terminator + ? ((curly_range->start >= start ? curly_range->start : curly_range->end) + 1) : INT_MAX; const int tp_col = tp != NULL ? tp->col + 1 : INT_MAX; const int ftcs_col = old_row->shell_integration.cmd_start >= start @@ -920,9 +988,10 @@ grid_resize_and_reflow( ? old_row->shell_integration.cmd_end + 1 : INT_MAX; - end = min(col_count, min(min(tp_col, uri_col), ftcs_col)); + end = min(col_count, min(min(tp_col, min(uri_col, curly_col)), ftcs_col)); uri_break = end == uri_col; + curly_break = end == curly_col; tp_break = end == tp_col; ftcs_break = end == ftcs_col; } @@ -1033,15 +1102,28 @@ grid_resize_and_reflow( } if (uri_break) { - xassert(range != NULL); + xassert(uri_range != NULL); + + if (uri_range->start == end - 1) + reflow_uri_range_start(uri_range, new_row, new_col_idx - 1); + + if (uri_range->end == end - 1) { + reflow_uri_range_end(uri_range, new_row, new_col_idx - 1); + grid_row_uri_range_destroy(uri_range); + uri_range++; + } + } + + if (curly_break) { + xassert(curly_range != NULL); - if (range->start == end - 1) - reflow_uri_range_start(range, new_row, new_col_idx - 1); + if (curly_range->start == end - 1) + reflow_curly_range_start(curly_range, new_row, new_col_idx - 1); - if (range->end == end - 1) { - reflow_uri_range_end(range, new_row, new_col_idx - 1); - grid_row_uri_range_destroy(range); - range++; + if (curly_range->end == end - 1) { + reflow_curly_range_end(curly_range, new_row, new_col_idx - 1); + grid_row_curly_range_destroy(curly_range); + curly_range++; } } @@ -1067,20 +1149,26 @@ grid_resize_and_reflow( if (r + 1 < old_rows) line_wrap(); - else if (new_row->extra != NULL && - new_row->extra->uri_ranges.count > 0) - { - /* - * line_wrap() "closes" still-open URIs. Since this is - * the *last* row, and since we're line-breaking due - * to a hard line-break (rather than running out of - * cells in the "new_row"), there shouldn't be an open - * URI (it would have been closed when we reached the - * end of the URI while reflowing the last "old" - * row). - */ - uint32_t last_idx = new_row->extra->uri_ranges.count - 1; - xassert(new_row->extra->uri_ranges.v[last_idx].end >= 0); + else if (new_row->extra != NULL) { + if (new_row->extra->uri_ranges.count > 0) { + /* + * line_wrap() "closes" still-open URIs. Since + * this is the *last* row, and since we're + * line-breaking due to a hard line-break (rather + * than running out of cells in the "new_row"), + * there shouldn't be an open URI (it would have + * been closed when we reached the end of the URI + * while reflowing the last "old" row). + */ + int last_idx = new_row->extra->uri_ranges.count - 1; + xassert(new_row->extra->uri_ranges.v[last_idx].end >= 0); + } + + if (new_row->extra->curly_ranges.count > 0) { + int last_idx = new_row->extra->curly_ranges.count - 1; + xassert(new_row->extra->curly_ranges.v[last_idx].end >= 0); + + } } } @@ -1112,6 +1200,8 @@ grid_resize_and_reflow( for (size_t i = 0; i < row->extra->uri_ranges.count; i++) xassert(row->extra->uri_ranges.v[i].end >= 0); + for (size_t i = 0; i < row->extra->curly_ranges.count; i++) + xassert(row->extra->curly_ranges.v[i].end >= 0); verify_no_overlapping_ranges(row->extra); verify_ranges_are_sorted(row->extra); -- cgit v1.3 From 6a0110446c1c96379b5b34dfdff5236a9bee311a Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Tue, 25 Jun 2024 09:55:55 +0200 Subject: grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions. --- grid.c | 248 ++++++++++++++++++++++++++++++----------------------------------- 1 file changed, 116 insertions(+), 132 deletions(-) (limited to 'grid.c') diff --git a/grid.c b/grid.c index 3cd818a7..30ef3b65 100644 --- a/grid.c +++ b/grid.c @@ -176,8 +176,17 @@ range_ensure_size(struct row_ranges *ranges, int count_to_add) xassert(ranges->count + count_to_add <= ranges->size); } +union range_data_for_insertion { + struct { + uint64_t id; + const char *uri; + } uri; + struct curly_range_data curly; +}; + static void -range_insert(struct row_ranges *ranges, size_t idx, int start, int end) +range_insert(struct row_ranges *ranges, size_t idx, int start, int end, + enum row_range_type type, const union range_data_for_insertion *data) { range_ensure_size(ranges, 1); @@ -193,6 +202,17 @@ range_insert(struct row_ranges *ranges, size_t idx, int start, int end) .start = start, .end = end, }; + + switch (type) { + case ROW_RANGE_URI: + ranges->v[idx].uri.id = data->uri.id; + ranges->v[idx].uri.uri = xstrdup(data->uri.uri); + break; + + case ROW_RANGE_CURLY: + ranges->v[idx].curly = data->curly; + break; + } } /* @@ -203,17 +223,16 @@ static void uri_range_insert(struct row_ranges *ranges, size_t idx, int start, int end, uint64_t id, const char *uri) { - range_insert(ranges, idx, start, end); - ranges->v[idx].uri.id = id; - ranges->v[idx].uri.uri = xstrdup(uri); + range_insert(ranges, idx, start, end, ROW_RANGE_URI, + &(union range_data_for_insertion){.uri = {.id = id, .uri = uri}}); } static void curly_range_insert(struct row_ranges *ranges, size_t idx, int start, int end, struct curly_range_data data) { - range_insert(ranges, idx, start, end); - ranges->v[idx].curly = data; + range_insert(ranges, idx, start, end, ROW_RANGE_CURLY, + &(union range_data_for_insertion){.curly = data}); } static void @@ -1285,25 +1304,62 @@ grid_resize_and_reflow( #endif } -void -grid_row_uri_range_put(struct row *row, int col, const char *uri, uint64_t id) +static bool +ranges_match(const struct row_range *r1, const struct row_range *r2, + enum row_range_type type) { - ensure_row_has_extra_data(row); + switch (type) { + case ROW_RANGE_URI: + /* TODO: also match URI? */ + return r1->uri.id == r2->uri.id; + + case ROW_RANGE_CURLY: + return r1->curly.style == r2->curly.style && + r1->curly.color_src == r2->curly.color_src && + r1->curly.color == r2->curly.color; + } + + BUG("invalid range type"); + return false; +} + +static bool +range_match_data(const struct row_range *r, + const union range_data_for_insertion *data, + enum row_range_type type) +{ + switch (type) { + case ROW_RANGE_URI: + return r->uri.id == data->uri.id; + + case ROW_RANGE_CURLY: + return r->curly.style == data->curly.style && + r->curly.color_src == data->curly.color_src && + r->curly.color == data->curly.color; + } + BUG("invalid range type"); + return false; +} + +static void +grid_row_range_put(struct row_ranges *ranges, int col, + const union range_data_for_insertion *data, + enum row_range_type type) +{ size_t insert_idx = 0; bool replace = false; bool run_merge_pass = false; - struct row_data *extra = row->extra; - for (int i = extra->uri_ranges.count - 1; i >= 0; i--) { - struct row_range *r = &extra->uri_ranges.v[i]; + for (int i = ranges->count - 1; i >= 0; i--) { + struct row_range *r = &ranges->v[i]; - const bool matching_id = r->uri.id == id; + const bool matching = range_match_data(r, data, type); - if (matching_id && r->end + 1 == col) { - /* Extend existing URI's tail */ + if (matching && r->end + 1 == col) { + /* Extend existing range tail */ r->end++; - goto out; + return; } else if (r->end < col) { @@ -1318,8 +1374,8 @@ grid_row_uri_range_put(struct row *row, int col, const char *uri, uint64_t id) xassert(r->start <= col); xassert(r->end >= col); - if (matching_id) - goto out; + if (matching) + return; if (r->start == r->end) { replace = true; @@ -1337,12 +1393,13 @@ grid_row_uri_range_put(struct row *row, int col, const char *uri, uint64_t id) xassert(r->start < col); xassert(r->end > col); - uri_range_insert( - &extra->uri_ranges, i + 1, col + 1, r->end, r->uri.id, r->uri.uri); + range_insert( + ranges, i + 1, col + 1, r->end, type, + &(union range_data_for_insertion){.uri = {.id = r->uri.id, .uri = r->uri.uri}}); /* The insertion may xrealloc() the vector, making our * 'old' pointer invalid */ - r = &extra->uri_ranges.v[i]; + r = &ranges->v[i]; r->end = col - 1; xassert(r->start <= r->end); @@ -1353,141 +1410,68 @@ grid_row_uri_range_put(struct row *row, int col, const char *uri, uint64_t id) } } - xassert(insert_idx <= extra->uri_ranges.count); + xassert(insert_idx <= ranges->count); if (replace) { - grid_row_uri_range_destroy(&extra->uri_ranges.v[insert_idx]); - extra->uri_ranges.v[insert_idx] = (struct row_range){ + grid_row_range_destroy(&ranges->v[insert_idx], type); + ranges->v[insert_idx] = (struct row_range){ .start = col, .end = col, - .uri = { - .id = id, - .uri = xstrdup(uri), - }, }; + + switch (type) { + case ROW_RANGE_URI: + ranges->v[insert_idx].uri.id = data->uri.id; + ranges->v[insert_idx].uri.uri = xstrdup(data->uri.uri); + break; + + case ROW_RANGE_CURLY: + ranges->v[insert_idx].curly = data->curly; + break; + } } else - uri_range_insert(&extra->uri_ranges, insert_idx, col, col, id, uri); + range_insert(ranges, insert_idx, col, col, type, data); if (run_merge_pass) { - for (size_t i = 1; i < extra->uri_ranges.count; i++) { - struct row_range *r1 = &extra->uri_ranges.v[i - 1]; - struct row_range *r2 = &extra->uri_ranges.v[i]; + for (size_t i = 1; i < ranges->count; i++) { + struct row_range *r1 = &ranges->v[i - 1]; + struct row_range *r2 = &ranges->v[i]; - if (r1->uri.id == r2->uri.id && r1->end + 1 == r2->start) { + if (ranges_match(r1, r2, type) && r1->end + 1 == r2->start) { r1->end = r2->end; - range_delete(&extra->uri_ranges, ROW_RANGE_URI, i); + range_delete(ranges, ROW_RANGE_URI, i); i--; } } } - -out: - verify_no_overlapping_ranges(extra); - verify_ranges_are_sorted(extra); } void -grid_row_curly_range_put(struct row *row, int col, struct curly_range_data data) +grid_row_uri_range_put(struct row *row, int col, const char *uri, uint64_t id) { ensure_row_has_extra_data(row); - size_t insert_idx = 0; - bool replace = false; - bool run_merge_pass = false; - - struct row_data *extra = row->extra; - for (int i = extra->curly_ranges.count - 1; i >= 0; i--) { - struct row_range *r = &extra->curly_ranges.v[i]; - - const bool matching = r->curly.style == data.style && - r->curly.color_src == data.color_src && - r->curly.color == data.color; - - if (matching && r->end + 1 == col) { - /* Extend existing curly tail */ - r->end++; - goto out; - } - - else if (r->end < col) { - insert_idx = i + 1; - break; - } - - else if (r->start > col) - continue; - - else { - xassert(r->start <= col); - xassert(r->end >= col); - - if (matching) - goto out; - - if (r->start == r->end) { - replace = true; - run_merge_pass = true; - insert_idx = i; - } else if (r->start == col) { - run_merge_pass = true; - r->start++; - insert_idx = i; - } else if (r->end == col) { - run_merge_pass = true; - r->end--; - insert_idx = i + 1; - } else { - xassert(r->start < col); - xassert(r->end > col); - - curly_range_insert( - &extra->curly_ranges, i + 1, col + 1, r->end, data); + grid_row_range_put( + &row->extra->uri_ranges, col, + &(union range_data_for_insertion){.uri = {.id = id, .uri = uri}}, + ROW_RANGE_URI); - /* The insertion may xrealloc() the vector, making our - * 'old' pointer invalid */ - r = &extra->curly_ranges.v[i]; - r->end = col - 1; - xassert(r->start <= r->end); - - insert_idx = i + 1; - } - - break; - } - } - - xassert(insert_idx <= extra->curly_ranges.count); + verify_no_overlapping_ranges(row->extra); + verify_ranges_are_sorted(row->extra); +} - if (replace) { - grid_row_curly_range_destroy(&extra->curly_ranges.v[insert_idx]); - extra->curly_ranges.v[insert_idx] = (struct row_range){ - .start = col, - .end = col, - .curly = data, - }; - } else - curly_range_insert(&extra->curly_ranges, insert_idx, col, col, data); +void +grid_row_curly_range_put(struct row *row, int col, struct curly_range_data data) +{ + ensure_row_has_extra_data(row); - if (run_merge_pass) { - for (size_t i = 1; i < extra->curly_ranges.count; i++) { - struct row_range *r1 = &extra->curly_ranges.v[i - 1]; - struct row_range *r2 = &extra->curly_ranges.v[i]; - - if (r1->curly.style == r2->curly.style && - r1->curly.color_src == r2->curly.color_src && - r1->curly.color == r2->curly.color && - r1->end + 1 == r2->start) - { - r1->end = r2->end; - range_delete(&extra->curly_ranges, ROW_RANGE_CURLY, i); - i--; - } - } - } + grid_row_range_put( + &row->extra->curly_ranges, col, + &(union range_data_for_insertion){.curly = data}, + ROW_RANGE_CURLY); -out: - verify_no_overlapping_ranges(extra); - verify_ranges_are_sorted(extra); + verify_no_overlapping_ranges(row->extra); + verify_ranges_are_sorted(row->extra); } UNITTEST -- cgit v1.3 From 45f4eb48fb6b4b651df6b466936dd425d9647400 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Tue, 25 Jun 2024 10:26:07 +0200 Subject: grid: refactor: remove union range_data_for_insertion This union is identical to row_range_data, except the URI char pointer is const. Let's ignore that, and re-use row_range_data, casting the URI pointer when necessary. Also remove uri_range_insert() and curly_range_insert(), and use the generic version of range_insert() everywhere. --- grid.c | 74 +++++++++++++++++++++----------------------------------------- terminal.h | 10 +++++++-- 2 files changed, 33 insertions(+), 51 deletions(-) (limited to 'grid.c') diff --git a/grid.c b/grid.c index 30ef3b65..9aee69fb 100644 --- a/grid.c +++ b/grid.c @@ -176,17 +176,13 @@ range_ensure_size(struct row_ranges *ranges, int count_to_add) xassert(ranges->count + count_to_add <= ranges->size); } -union range_data_for_insertion { - struct { - uint64_t id; - const char *uri; - } uri; - struct curly_range_data curly; -}; - +/* + * Be careful! This function may xrealloc() the URI range vector, thus + * invalidating pointers into it. + */ static void range_insert(struct row_ranges *ranges, size_t idx, int start, int end, - enum row_range_type type, const union range_data_for_insertion *data) + enum row_range_type type, const union row_range_data *data) { range_ensure_size(ranges, 1); @@ -215,26 +211,6 @@ range_insert(struct row_ranges *ranges, size_t idx, int start, int end, } } -/* - * Be careful! This function may xrealloc() the URI range vector, thus - * invalidating pointers into it. - */ -static void -uri_range_insert(struct row_ranges *ranges, size_t idx, int start, int end, - uint64_t id, const char *uri) -{ - range_insert(ranges, idx, start, end, ROW_RANGE_URI, - &(union range_data_for_insertion){.uri = {.id = id, .uri = uri}}); -} - -static void -curly_range_insert(struct row_ranges *ranges, size_t idx, int start, int end, - struct curly_range_data data) -{ - range_insert(ranges, idx, start, end, ROW_RANGE_CURLY, - &(union range_data_for_insertion){.curly = data}); -} - static void uri_range_append_no_strdup(struct row_data *extra, int start, int end, uint64_t id, char *uri) @@ -1324,8 +1300,7 @@ ranges_match(const struct row_range *r1, const struct row_range *r2, } static bool -range_match_data(const struct row_range *r, - const union range_data_for_insertion *data, +range_match_data(const struct row_range *r, const union row_range_data *data, enum row_range_type type) { switch (type) { @@ -1344,8 +1319,7 @@ range_match_data(const struct row_range *r, static void grid_row_range_put(struct row_ranges *ranges, int col, - const union range_data_for_insertion *data, - enum row_range_type type) + const union row_range_data *data, enum row_range_type type) { size_t insert_idx = 0; bool replace = false; @@ -1393,9 +1367,13 @@ grid_row_range_put(struct row_ranges *ranges, int col, xassert(r->start < col); xassert(r->end > col); - range_insert( - ranges, i + 1, col + 1, r->end, type, - &(union range_data_for_insertion){.uri = {.id = r->uri.id, .uri = r->uri.uri}}); + union row_range_data insert_data; + switch (type) { + case ROW_RANGE_URI: insert_data.uri = r->uri; break; + case ROW_RANGE_CURLY: insert_data.curly = r->curly; break; + } + + range_insert(ranges, i + 1, col + 1, r->end, type, &insert_data); /* The insertion may xrealloc() the vector, making our * 'old' pointer invalid */ @@ -1453,7 +1431,7 @@ grid_row_uri_range_put(struct row *row, int col, const char *uri, uint64_t id) grid_row_range_put( &row->extra->uri_ranges, col, - &(union range_data_for_insertion){.uri = {.id = id, .uri = uri}}, + &(union row_range_data){.uri = {.id = id, .uri = (char *)uri}}, ROW_RANGE_URI); verify_no_overlapping_ranges(row->extra); @@ -1467,7 +1445,7 @@ grid_row_curly_range_put(struct row *row, int col, struct curly_range_data data) grid_row_range_put( &row->extra->curly_ranges, col, - &(union range_data_for_insertion){.curly = data}, + &(union row_range_data){.curly = data}, ROW_RANGE_CURLY); verify_no_overlapping_ranges(row->extra); @@ -1561,17 +1539,15 @@ grid_row_range_erase(struct row_ranges *ranges, enum row_range_type type, } else if (start > old->start && end < old->end) { - /* Erase range erases a part in the middle of the URI */ - switch (type) { - case ROW_RANGE_URI: - uri_range_insert( - ranges, i + 1, end + 1, old->end, old->uri.id, old->uri.uri); - break; - - case ROW_RANGE_CURLY: - curly_range_insert(ranges, i + 1, end + 1, old->end, old->curly); - break; - } + /* + * Erase range erases a part in the middle of the URI + * + * Must copy, since range_insert() may xrealloc() (thus + * causing 'old' to be invalid) before it dereferences + * old->data + */ + union row_range_data data = old->data; + range_insert(ranges, i + 1, end + 1, old->end, type, &data); /* The insertion may xrealloc() the vector, making our * 'old' pointer invalid */ diff --git a/terminal.h b/terminal.h index 9fdd3dc0..21eb7cee 100644 --- a/terminal.h +++ b/terminal.h @@ -129,8 +129,14 @@ struct row_range { int end; union { - struct uri_range_data uri; - struct curly_range_data curly; + /* This is just an expanded union row_range_data, but + * anonymous, so that we don't have to write range->u.uri.id, + * but can instead do range->uri.id */ + union { + struct uri_range_data uri; + struct curly_range_data curly; + }; + union row_range_data data; }; }; -- cgit v1.3 From cb4a74e10ba97ad37df3d065ae95a8f8efa34420 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Tue, 25 Jun 2024 20:01:47 +0200 Subject: grid: row_range_put(): use correct type in call to range_delete() --- grid.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'grid.c') diff --git a/grid.c b/grid.c index 9aee69fb..93e9eaf8 100644 --- a/grid.c +++ b/grid.c @@ -1417,7 +1417,7 @@ grid_row_range_put(struct row_ranges *ranges, int col, if (ranges_match(r1, r2, type) && r1->end + 1 == r2->start) { r1->end = r2->end; - range_delete(ranges, ROW_RANGE_URI, i); + range_delete(ranges, type, i); i--; } } -- cgit v1.3 From 0d3f2f27e33bdee58dc1a0e0ff6a3cb39f53056f Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Wed, 26 Jun 2024 19:01:54 +0200 Subject: grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup(). --- grid.c | 119 ++++++++++++++++++++++++++++++++++++++--------------------------- 1 file changed, 70 insertions(+), 49 deletions(-) (limited to 'grid.c') diff --git a/grid.c b/grid.c index 93e9eaf8..c9a0d8dc 100644 --- a/grid.c +++ b/grid.c @@ -194,55 +194,62 @@ range_insert(struct row_ranges *ranges, size_t idx, int start, int end, move_count * sizeof(ranges->v[0])); ranges->count++; - ranges->v[idx] = (struct row_range){ - .start = start, - .end = end, - }; + + struct row_range *r = &ranges->v[idx]; + r->start = start; + r->end = end; switch (type) { case ROW_RANGE_URI: - ranges->v[idx].uri.id = data->uri.id; - ranges->v[idx].uri.uri = xstrdup(data->uri.uri); + r->uri.id = data->uri.id; + r->uri.uri = xstrdup(data->uri.uri); break; case ROW_RANGE_CURLY: - ranges->v[idx].curly = data->curly; + r->curly = data->curly; break; } } static void -uri_range_append_no_strdup(struct row_data *extra, int start, int end, - uint64_t id, char *uri) +range_append_by_ref(struct row_ranges *ranges, int start, int end, + enum row_range_type type, const union row_range_data *data) { - range_ensure_size(&extra->uri_ranges, 1); - extra->uri_ranges.v[extra->uri_ranges.count++] = (struct row_range){ - .start = start, - .end = end, - .uri = { - .id = id, - .uri = uri, - }, - }; -} + range_ensure_size(ranges, 1); -static void -uri_range_append(struct row_data *extra, int start, int end, uint64_t id, - const char *uri) -{ - uri_range_append_no_strdup(extra, start, end, id, xstrdup(uri)); + struct row_range *r = &ranges->v[ranges->count++]; + + r->start = start; + r->end = end; + + switch (type) { + case ROW_RANGE_URI: + r->uri.id = data->uri.id;; + r->uri.uri = data->uri.uri; + break; + + case ROW_RANGE_CURLY: + r->curly = data->curly; + break; + } } static void -curly_range_append(struct row_data *extra, int start, int end, - struct curly_range_data data) +range_append(struct row_ranges *ranges, int start, int end, + enum row_range_type type, const union row_range_data *data) { - range_ensure_size(&extra->curly_ranges, 1); - extra->curly_ranges.v[extra->curly_ranges.count++] = (struct row_range){ - .start = start, - .end = end, - .curly = data, - }; + switch (type) { + case ROW_RANGE_URI: + range_append_by_ref( + ranges, start, end, type, + &(union row_range_data){.uri = {.id = data->uri.id, + .uri = xstrdup(data->uri.uri)}}); + break; + + case ROW_RANGE_CURLY: + range_append_by_ref(ranges, start, end, type, data); + break; + } } static void @@ -304,14 +311,16 @@ grid_snapshot(const struct grid *grid) for (int i = 0; i < extra->uri_ranges.count; i++) { const struct row_range *range = &extra->uri_ranges.v[i]; - uri_range_append( - clone_extra, - range->start, range->end, range->uri.id, range->uri.uri); + range_append( + &clone_extra->uri_ranges, + range->start, range->end, ROW_RANGE_URI, &range->data); } for (int i = 0; i < extra->curly_ranges.count; i++) { const struct row_range *range = &extra->curly_ranges.v[i]; - curly_range_append(clone_extra, range->start, range->end, range->curly); + range_append_by_ref( + &clone_extra->curly_ranges, range->start, range->end, + ROW_RANGE_CURLY, &range->data); } } else clone_row->extra = NULL; @@ -539,7 +548,7 @@ grid_resize_without_reflow( const int start = range->start; const int end = min(range->end, new_cols - 1); - uri_range_append(new_extra, start, end, range->uri.id, range->uri.uri); + range_append(&new_extra->uri_ranges, start, end, ROW_RANGE_URI, &range->data); } for (int i = 0; i < old_extra->curly_ranges.count; i++) { @@ -552,7 +561,7 @@ grid_resize_without_reflow( const int start = range->start; const int end = min(range->end, new_cols - 1); - curly_range_append(new_extra, start, end, range->curly); + range_append_by_ref(&new_extra->curly_ranges, start, end, ROW_RANGE_CURLY, &range->data); } } @@ -629,8 +638,11 @@ reflow_uri_range_start(struct row_range *range, struct row *new_row, int new_col_idx) { ensure_row_has_extra_data(new_row); - uri_range_append_no_strdup( - new_row->extra, new_col_idx, -1, range->uri.id, range->uri.uri); + range_append_by_ref( + &new_row->extra->uri_ranges, new_col_idx, -1, + ROW_RANGE_URI, &range->data); + + /* The reflowed range now owns the URI string */ range->uri.uri = NULL; } @@ -654,7 +666,8 @@ reflow_curly_range_start(struct row_range *range, struct row *new_row, int new_col_idx) { ensure_row_has_extra_data(new_row); - curly_range_append(new_row->extra, new_col_idx, -1, range->curly); + range_append_by_ref(&new_row->extra->curly_ranges, new_col_idx, -1, + ROW_RANGE_CURLY, &range->data); } @@ -732,7 +745,8 @@ _line_wrap(struct grid *old_grid, struct row **new_grid, struct row *row, /* Open a new range on the new/current row */ ensure_row_has_extra_data(new_row); - uri_range_append(new_row->extra, 0, -1, range->uri.id, range->uri.uri); + range_append(&new_row->extra->uri_ranges, 0, -1, + ROW_RANGE_URI, &range->data); } } @@ -747,7 +761,8 @@ _line_wrap(struct grid *old_grid, struct row **new_grid, struct row *row, /* Open a new range on the new/current row */ ensure_row_has_extra_data(new_row); - curly_range_append(new_row->extra, 0, -1, range->curly); + range_append(&new_row->extra->curly_ranges, 0, -1, + ROW_RANGE_CURLY, &range->data); } } @@ -1589,13 +1604,19 @@ UNITTEST { struct row_data row_data = {.uri_ranges = {0}}; struct row row = {.extra = &row_data}; + const union row_range_data data = { + .uri = { + .id = 0, + .uri = (char *)"dummy", + }, + }; /* Try erasing a row without any URIs */ grid_row_uri_range_erase(&row, 0, 200); xassert(row_data.uri_ranges.count == 0); - uri_range_append(&row_data, 1, 10, 0, "dummy"); - uri_range_append(&row_data, 11, 20, 0, "dummy"); + range_append(&row_data.uri_ranges, 1, 10, ROW_RANGE_URI, &data); + range_append(&row_data.uri_ranges, 11, 20, ROW_RANGE_URI, &data); xassert(row_data.uri_ranges.count == 2); xassert(row_data.uri_ranges.v[1].start == 11); xassert(row_data.uri_ranges.v[1].end == 20); @@ -1610,8 +1631,8 @@ UNITTEST /* Two URIs, then erase second half of the first, first half of the second */ - uri_range_append(&row_data, 1, 10, 0, "dummy"); - uri_range_append(&row_data, 11, 20, 0, "dummy"); + range_append(&row_data.uri_ranges, 1, 10, ROW_RANGE_URI, &data); + range_append(&row_data.uri_ranges, 11, 20, ROW_RANGE_URI, &data); grid_row_uri_range_erase(&row, 5, 15); xassert(row_data.uri_ranges.count == 2); xassert(row_data.uri_ranges.v[0].start == 1); @@ -1626,7 +1647,7 @@ UNITTEST row_data.uri_ranges.count = 0; /* One URI, erase middle part of it */ - uri_range_append(&row_data, 1, 10, 0, "dummy"); + range_append(&row_data.uri_ranges, 1, 10, ROW_RANGE_URI, &data); grid_row_uri_range_erase(&row, 5, 6); xassert(row_data.uri_ranges.count == 2); xassert(row_data.uri_ranges.v[0].start == 1); @@ -1657,7 +1678,7 @@ UNITTEST free(row_data.uri_ranges.v); row_data.uri_ranges.v = NULL; row_data.uri_ranges.size = 0; - uri_range_append(&row_data, 1, 10, 0, "dummy"); + range_append(&row_data.uri_ranges, 1, 10, ROW_RANGE_URI, &data); xassert(row_data.uri_ranges.size == 1); grid_row_uri_range_erase(&row, 5, 7); -- cgit v1.3 From 73f6982cbeb17501b097ea6ed6ca3342d46b6c7d Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Thu, 27 Jun 2024 19:06:40 +0200 Subject: grid: merge reflow_{uri,curly}_range_start(), and reflow_{uri,curly}_range_end() --- grid.c | 88 +++++++++++++++++++++++++++++++++++------------------------------- 1 file changed, 47 insertions(+), 41 deletions(-) (limited to 'grid.c') diff --git a/grid.c b/grid.c index c9a0d8dc..1db71b5c 100644 --- a/grid.c +++ b/grid.c @@ -634,58 +634,60 @@ grid_resize_without_reflow( } static void -reflow_uri_range_start(struct row_range *range, struct row *new_row, - int new_col_idx) +reflow_range_start(struct row_range *range, enum row_range_type type, + struct row *new_row, int new_col_idx) { ensure_row_has_extra_data(new_row); - range_append_by_ref( - &new_row->extra->uri_ranges, new_col_idx, -1, - ROW_RANGE_URI, &range->data); - /* The reflowed range now owns the URI string */ - range->uri.uri = NULL; -} - -static void -reflow_uri_range_end(struct row_range *range, struct row *new_row, - int new_col_idx) -{ - struct row_data *extra = new_row->extra; - xassert(extra->uri_ranges.count > 0); + struct row_ranges *new_ranges = NULL; + switch (type) { + case ROW_RANGE_URI: new_ranges = &new_row->extra->uri_ranges; break; + case ROW_RANGE_CURLY: new_ranges = &new_row->extra->curly_ranges; break; + } - struct row_range *new_range = - &extra->uri_ranges.v[extra->uri_ranges.count - 1]; + if (new_ranges == NULL) + BUG("unhandled range type"); - xassert(new_range->uri.id == range->uri.id); - xassert(new_range->end < 0); - new_range->end = new_col_idx; -} + range_append_by_ref(new_ranges, new_col_idx, -1, type, &range->data); -static void -reflow_curly_range_start(struct row_range *range, struct row *new_row, - int new_col_idx) -{ - ensure_row_has_extra_data(new_row); - range_append_by_ref(&new_row->extra->curly_ranges, new_col_idx, -1, - ROW_RANGE_CURLY, &range->data); + switch (type) { + case ROW_RANGE_URI: range->uri.uri = NULL; break; /* Owned by new_ranges */ + case ROW_RANGE_CURLY: break; + } } - static void -reflow_curly_range_end(struct row_range *range, struct row *new_row, - int new_col_idx) +reflow_range_end(struct row_range *range, enum row_range_type type, + struct row *new_row, int new_col_idx) { struct row_data *extra = new_row->extra; - xassert(extra->curly_ranges.count > 0); + struct row_ranges *ranges = NULL; - struct row_range *new_range = - &extra->curly_ranges.v[extra->curly_ranges.count - 1]; + switch (type) { + case ROW_RANGE_URI: ranges = &extra->uri_ranges; break; + case ROW_RANGE_CURLY: ranges = &extra->curly_ranges; break; + } - xassert(new_range->curly.style == range->curly.style); - xassert(new_range->curly.color_src == range->curly.color_src); - xassert(new_range->curly.color == range->curly.color); + if (ranges == NULL) + BUG("unhandled range type"); + xassert(ranges->count > 0); + + struct row_range *new_range = &ranges->v[ranges->count - 1]; xassert(new_range->end < 0); + + switch (type) { + case ROW_RANGE_URI: + xassert(new_range->uri.id == range->uri.id); + break; + + case ROW_RANGE_CURLY: + xassert(new_range->curly.style == range->curly.style); + xassert(new_range->curly.color_src == range->curly.color_src); + xassert(new_range->curly.color == range->curly.color); + break; + } + new_range->end = new_col_idx; } @@ -1115,10 +1117,12 @@ grid_resize_and_reflow( xassert(uri_range != NULL); if (uri_range->start == end - 1) - reflow_uri_range_start(uri_range, new_row, new_col_idx - 1); + reflow_range_start( + uri_range, ROW_RANGE_URI, new_row, new_col_idx - 1); if (uri_range->end == end - 1) { - reflow_uri_range_end(uri_range, new_row, new_col_idx - 1); + reflow_range_end( + uri_range, ROW_RANGE_URI, new_row, new_col_idx - 1); grid_row_uri_range_destroy(uri_range); uri_range++; } @@ -1128,10 +1132,12 @@ grid_resize_and_reflow( xassert(curly_range != NULL); if (curly_range->start == end - 1) - reflow_curly_range_start(curly_range, new_row, new_col_idx - 1); + reflow_range_start( + curly_range, ROW_RANGE_CURLY, new_row, new_col_idx - 1); if (curly_range->end == end - 1) { - reflow_curly_range_end(curly_range, new_row, new_col_idx - 1); + reflow_range_end( + curly_range, ROW_RANGE_CURLY, new_row, new_col_idx - 1); grid_row_curly_range_destroy(curly_range); curly_range++; } -- cgit v1.3