mirrors/foot
1
0
Fork 0
mirror of https://codeberg.org/dnkl/foot.git synced 2026-02-05 04:06:08 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'search-crashes'

Browse source 
Closes #1036
This commit is contained in:
Daniel Eklöf 2022-04-26 17:40:58 +02:00
commit 57543c4290
No known key found for this signature in database
GPG key ID: 5BBD4992C116573F
8 changed files with 177 additions and 161 deletions
Download patch file Download diff file Expand all files Collapse all files

4
CHANGELOG.md
View file

@ -50,6 +50,10 @@
box, that does not result in a grid update (for example, when the
search criteria did not result in any matches) ([#1040][1040]).
* foot freezing in scrollback search mode, using 100% CPU ([#1036][1036]).
* Crash when extending a selection to the next word boundary in
scrollback search mode ([#1036][1036]).
* Scrollback search mode not always highlighting all matches
correctly.
[1040]: https://codeberg.org/dnkl/foot/issues/1040
[1036]: https://codeberg.org/dnkl/foot/issues/1036

28
grid.c
View file

@ -15,6 +15,34 @@
#define TIME_REFLOW 0
/*
* “sb” (scrollback relative) coordinates
*
* The scrollback relative row number 0 is the *first*, and *oldest*
* row in the scrollback history (and thus the *first* row to be
* scrolled out). Thus, a higher number means further *down* in the
* scrollback, with the *highest* number being at the bottom of the
* screen, where new input appears.
*/
int
grid_row_abs_to_sb(const struct grid *grid, int screen_rows, int abs_row)
{
const int scrollback_start = grid->offset + screen_rows;
int rebased_row = abs_row - scrollback_start + grid->num_rows;
rebased_row &= grid->num_rows - 1;
return rebased_row;
}
int grid_row_sb_to_abs(const struct grid *grid, int screen_rows, int sb_rel_row)
{
const int scrollback_start = grid->offset + screen_rows;
int abs_row = sb_rel_row + scrollback_start;
abs_row &= grid->num_rows - 1;
return abs_row;
}
static void
ensure_row_has_extra_data(struct row *row)
{

5
grid.h
View file

@ -21,6 +21,10 @@ void grid_resize_and_reflow(
size_t tracking_points_count,
struct coord *const _tracking_points[static tracking_points_count]);
/* Convert row numbers between scrollback-relative and absolute coordinates */
int grid_row_abs_to_sb(const struct grid *grid, int screen_rows, int abs_row);
int grid_row_sb_to_abs(const struct grid *grid, int screen_rows, int sb_rel_row);
static inline int
grid_row_absolute(const struct grid *grid, int row_no)
{
@ -33,6 +37,7 @@ grid_row_absolute_in_view(const struct grid *grid, int row_no)
return (grid->view + row_no) & (grid->num_rows - 1);
}
static inline struct row *
_grid_row_maybe_alloc(struct grid *grid, int row_no, bool alloc_if_null)
{

194
search.c
View file

@ -82,11 +82,7 @@ search_ensure_size(struct terminal *term, size_t wanted_size)
static bool
has_wrapped_around(const struct terminal *term, int abs_row_no)
{
const struct grid *grid = term->grid;
int scrollback_start = grid->offset + term->rows;
int rebased_row = abs_row_no - scrollback_start + grid->num_rows;
rebased_row &= grid->num_rows - 1;
int rebased_row = grid_row_abs_to_sb(term->grid, term->rows, abs_row_no);
return rebased_row == 0;
}
@ -182,6 +178,9 @@ search_update_selection(struct terminal *term, const struct range *match)
int end_row = match->end.row;
int end_col = match->end.col;
xassert(start_row >= 0);
xassert(start_row < grid->num_rows);
bool move_viewport = true;
int view_end = (grid->view + term->rows - 1) & (grid->num_rows - 1);
@ -196,24 +195,14 @@ search_update_selection(struct terminal *term, const struct range *match)
}
if (move_viewport) {
int old_view = grid->view;
int new_view = start_row - term->rows / 2;
int rebased_new_view = grid_row_abs_to_sb(grid, term->rows, start_row);
while (new_view < 0)
new_view += grid->num_rows;
rebased_new_view -= term->rows / 2;
rebased_new_view =
min(max(rebased_new_view, 0), grid->num_rows - term->rows);
new_view = ensure_view_is_allocated(term, new_view);
/* Don't scroll past scrollback history */
int end = (grid->offset + term->rows - 1) & (grid->num_rows - 1);
if (end >= grid->offset) {
/* Not wrapped */
if (new_view >= grid->offset && new_view <= end)
new_view = grid->offset;
} else {
if (new_view >= grid->offset || new_view <= end)
new_view = grid->offset;
}
const int old_view = grid->view;
int new_view = grid_row_sb_to_abs(grid, term->rows, rebased_new_view);
#if defined(_DEBUG)
/* Verify all to-be-visible rows have been allocated */
@ -227,23 +216,8 @@ search_update_selection(struct terminal *term, const struct range *match)
term_damage_view(term);
}
#if 0
/* Selection endpoint is inclusive */
if (--end_col < 0) {
end_col = term->cols - 1;
end_row--;
}
#endif
/*
* Begin a new selection if the start coords changed
*
* Note: check column against selection.coords, since our “old”
* start column isn’t reliable - we modify it when searching
* “next” or “prev”.
*/
if (start_row != term->search.match.row ||
start_col != term->selection.coords.start.col)
start_col != term->search.match.col)
{
int selection_row = start_row - grid->view + grid->num_rows;
selection_row &= grid->num_rows - 1;
@ -516,7 +490,7 @@ search_matches_new_iter(struct terminal *term)
{
return (struct search_match_iterator){
.term = term,
.start = {-2, -2},
.start = {0, 0},
};
}
@ -529,86 +503,63 @@ search_matches_next(struct search_match_iterator *iter)
if (term->search.match_len == 0)
goto no_match;
struct range match;
bool found;
const bool return_primary_match =
iter->start.row == -2 && term->selection.coords.end.row >= 0;
if (return_primary_match) {
/* First, return the primary match */
match = term->selection.coords;
found = true;
}
else if (iter->start.row >= term->rows) {
if (iter->start.row >= term->rows)
goto no_match;
xassert(iter->start.row >= 0);
xassert(iter->start.row < term->rows);
xassert(iter->start.col >= 0);
xassert(iter->start.col < term->cols);
struct coord abs_start = iter->start;
abs_start.row = grid_row_absolute_in_view(grid, abs_start.row);
struct coord abs_end = {
term->cols - 1,
grid_row_absolute_in_view(grid, term->rows - 1)};
struct range match;
bool found = find_next(term, SEARCH_FORWARD, abs_start, abs_end, &match);
if (!found)
goto no_match;
LOG_DBG("match at (absolute coordinates) %dx%d-%dx%d",
match.start.row, match.start.col,
match.end.row, match.end.col);
/* Convert absolute row numbers back to view relative */
match.start.row = match.start.row - grid->view + grid->num_rows;
match.start.row &= grid->num_rows - 1;
match.end.row = match.end.row - grid->view + grid->num_rows;
match.end.row &= grid->num_rows - 1;
LOG_DBG("match at (view-local coordinates) %dx%d-%dx%d, view=%d",
match.start.row, match.start.col,
match.end.row, match.end.col, grid->view);
xassert(match.start.row >= 0);
xassert(match.start.row < term->rows);
xassert(match.end.row >= 0);
xassert(match.end.row < term->rows);
xassert(match.end.row > match.start.row ||
(match.end.row == match.start.row &&
match.end.col >= match.start.col));
/* Continue at next column, next time */
iter->start.row = match.start.row;
iter->start.col = match.start.col + 1;
if (iter->start.col >= term->cols) {
iter->start.col = 0;
iter->start.row++; /* Overflow is caught in next iteration */
}
else {
xassert(iter->start.row >= 0);
xassert(iter->start.row < term->rows);
xassert(iter->start.col >= 0);
xassert(iter->start.col < term->cols);
struct coord abs_start = iter->start;
abs_start.row = grid_row_absolute_in_view(grid, abs_start.row);
struct coord abs_end = {
term->cols - 1,
grid_row_absolute_in_view(grid, term->rows - 1)};
found = find_next(term, SEARCH_FORWARD, abs_start, abs_end, &match);
}
if (found) {
LOG_DBG("match at %dx%d-%dx%d",
match.start.row, match.start.col,
match.end.row, match.end.col);
/* Convert absolute row numbers back to view relative */
match.start.row = match.start.row - grid->view + grid->num_rows;
match.start.row &= grid->num_rows - 1;
match.end.row = match.end.row - grid->view + grid->num_rows;
match.end.row &= grid->num_rows - 1;
xassert(match.start.row >= 0);
xassert(match.start.row < term->rows);
xassert(match.end.row >= 0);
xassert(match.end.row < term->rows);
xassert(match.end.row > match.start.row ||
(match.end.row == match.start.row &&
match.end.col >= match.start.col));
if (return_primary_match) {
iter->start.row = 0;
iter->start.col = 0;
} else {
/* Continue at next column, next time */
iter->start.row = match.start.row;
iter->start.col = match.start.col + 1;
if (iter->start.col >= term->cols) {
iter->start.col = 0;
iter->start.row++; /* Overflow is caught in next iteration */
}
xassert(iter->start.row >= 0);
xassert(iter->start.row <= term->rows);
xassert(iter->start.col >= 0);
xassert(iter->start.col < term->cols);
if (match.start.row == term->search.match.row &&
match.start.col == term->search.match.col)
{
/* Primary match is handled explicitly */
LOG_DBG("primary match: skipping");
return search_matches_next(iter);
}
}
return match;
}
xassert(iter->start.row >= 0);
xassert(iter->start.row <= term->rows);
xassert(iter->start.col >= 0);
xassert(iter->start.col < term->cols);
return match;
no_match:
iter->start.row = -1;
@ -663,15 +614,18 @@ search_match_to_end_of_word(struct terminal *term, bool spaces_only)
if (term->search.match_len == 0)
return;
xassert(term->selection.coords.end.row != -1);
xassert(term->selection.coords.end.row >= 0);
struct grid *grid = term->grid;
const bool move_cursor = term->search.cursor == term->search.len;
const struct coord old_end = term->selection.coords.end;
struct coord old_end = selection_get_end(term);
struct coord new_end = old_end;
struct row *row = NULL;
xassert(new_end.row >= 0);
xassert(new_end.row < grid->num_rows);
/* Advances a coordinate by one column, to the right. Returns
* false if we’ve reached the scrollback wrap-around */
#define advance_pos(coord) __extension__ \
@ -691,12 +645,16 @@ search_match_to_end_of_word(struct terminal *term, bool spaces_only)
if (!advance_pos(new_end))
return;
xassert(new_end.row >= 0);
xassert(new_end.row < grid->num_rows);
xassert(grid->rows[new_end.row] != NULL);
/* Find next word boundary */
new_end.row -= grid->view;
new_end.row -= grid->view + grid->num_rows;
new_end.row &= grid->num_rows - 1;
selection_find_word_boundary_right(term, &new_end, spaces_only);
new_end.row += grid->view;
new_end.row &= grid->num_rows - 1;
struct coord pos = old_end;
row = grid->rows[pos.row];

24
selection.c
View file

@ -38,6 +38,29 @@ static const char *const mime_type_map[] = {
[DATA_OFFER_MIME_TEXT_UTF8_STRING] = "UTF8_STRING",
};
static inline struct coord
bounded(const struct grid *grid, struct coord coord)
{
coord.row &= grid->num_rows - 1;
return coord;
}
struct coord
selection_get_start(const struct terminal *term)
{
if (term->selection.coords.start.row < 0)
return term->selection.coords.start;
return bounded(term->grid, term->selection.coords.start);
}
struct coord
selection_get_end(const struct terminal *term)
{
if (term->selection.coords.end.row < 0)
return term->selection.coords.end;
return bounded(term->grid, term->selection.coords.end);
}
bool
selection_on_rows(const struct terminal *term, int row_start, int row_end)
{
@ -2461,3 +2484,4 @@ const struct zwp_primary_selection_device_v1_listener primary_selection_device_l
.data_offer = &primary_data_offer,
.selection = &primary_selection,
};

3
selection.h
View file

@ -79,3 +79,6 @@ void selection_find_word_boundary_left(
struct terminal *term, struct coord *pos, bool spaces_only);
void selection_find_word_boundary_right(
struct terminal *term, struct coord *pos, bool spaces_only);
struct coord selection_get_start(const struct terminal *term);
struct coord selection_get_end(const struct terminal *term);

55
sixel.c
View file

@ -7,8 +7,9 @@
#define LOG_ENABLE_DBG 0
#include "log.h"
#include "debug.h"
#include "render.h"
#include "grid.h"
#include "hsl.h"
#include "render.h"
#include "util.h"
#include "xmalloc.h"
#include "xsnprintf.h"
@ -138,25 +139,6 @@ sixel_erase(struct terminal *term, struct sixel *sixel)
sixel_destroy(sixel);
}
/*
* Calculates the scrollback relative row number, given an absolute row number.
*
* The scrollback relative row number 0 is the *first*, and *oldest*
* row in the scrollback history (and thus the *first* row to be
* scrolled out). Thus, a higher number means further *down* in the
* scrollback, with the *highest* number being at the bottom of the
* screen, where new input appears.
*/
static int
rebase_row(const struct terminal *term, int abs_row)
{
int scrollback_start = term->grid->offset + term->rows;
int rebased_row = abs_row - scrollback_start + term->grid->num_rows;
rebased_row &= term->grid->num_rows - 1;
return rebased_row;
}
/*
* Verify the sixels are sorted correctly.
*
@ -175,7 +157,8 @@ verify_list_order(const struct terminal *term)
size_t idx = 0;
tll_foreach(term->grid->sixel_images, it) {
int row = rebase_row(term, it->item.pos.row + it->item.rows - 1);
int row = grid_row_abs_to_sb(
term->grid, term->rows, it->item.pos.row + it->item.rows - 1);
int col = it->item.pos.col;
int col_count = it->item.cols;
@ -232,7 +215,8 @@ verify_scrollback_consistency(const struct terminal *term)
int last_row = -1;
for (int i = 0; i < six->rows; i++) {
int row_no = rebase_row(term, six->pos.row + i);
int row_no = grid_row_abs_to_sb(
term->grid, term->rows, six->pos.row + i);
if (last_row != -1)
xassert(last_row < row_no);
@ -295,10 +279,14 @@ verify_sixels(const struct terminal *term)
static void
sixel_insert(struct terminal *term, struct sixel sixel)
{
int end_row = rebase_row(term, sixel.pos.row + sixel.rows - 1);
int end_row = grid_row_abs_to_sb(
term->grid, term->rows, sixel.pos.row + sixel.rows - 1);
tll_foreach(term->grid->sixel_images, it) {
if (rebase_row(term, it->item.pos.row + it->item.rows - 1) < end_row) {
int rebased = grid_row_abs_to_sb(
term->grid, term->rows, it->item.pos.row + it->item.rows - 1);
if (rebased < end_row) {
tll_insert_before(term->grid->sixel_images, it, sixel);
goto out;
}
@ -325,7 +313,7 @@ sixel_scroll_up(struct terminal *term, int rows)
tll_rforeach(term->grid->sixel_images, it) {
struct sixel *six = &it->item;
int six_start = rebase_row(term, six->pos.row);
int six_start = grid_row_abs_to_sb(term->grid, term->rows, six->pos.row);
if (six_start < rows) {
sixel_erase(term, six);
@ -358,7 +346,8 @@ sixel_scroll_down(struct terminal *term, int rows)
tll_foreach(term->grid->sixel_images, it) {
struct sixel *six = &it->item;
int six_end = rebase_row(term, six->pos.row + six->rows - 1);
int six_end = grid_row_abs_to_sb(
term->grid, term->rows, six->pos.row + six->rows - 1);
if (six_end >= term->grid->num_rows - rows) {
sixel_erase(term, six);
tll_remove(term->grid->sixel_images, it);
@ -668,7 +657,8 @@ _sixel_overwrite_by_rectangle(
/* We should never generate scrollback wrapping sixels */
xassert(end < term->grid->num_rows);
const int scrollback_rel_start = rebase_row(term, start);
const int scrollback_rel_start = grid_row_abs_to_sb(
term->grid, term->rows, start);
bool UNUSED would_have_breaked = false;
@ -677,7 +667,8 @@ _sixel_overwrite_by_rectangle(
const int six_start = six->pos.row;
const int six_end = (six_start + six->rows - 1);
const int six_scrollback_rel_end = rebase_row(term, six_end);
const int six_scrollback_rel_end =
grid_row_abs_to_sb(term->grid, term->rows, six_end);
/* We should never generate scrollback wrapping sixels */
xassert(six_end < term->grid->num_rows);
@ -776,7 +767,7 @@ sixel_overwrite_by_row(struct terminal *term, int _row, int col, int width)
width = term->grid->num_cols - col;
const int row = (term->grid->offset + _row) & (term->grid->num_rows - 1);
const int scrollback_rel_row = rebase_row(term, row);
const int scrollback_rel_row = grid_row_abs_to_sb(term->grid, term->rows, row);
tll_foreach(term->grid->sixel_images, it) {
struct sixel *six = &it->item;
@ -786,7 +777,8 @@ sixel_overwrite_by_row(struct terminal *term, int _row, int col, int width)
/* We should never generate scrollback wrapping sixels */
xassert(six_end >= six_start);
const int six_scrollback_rel_end = rebase_row(term, six_end);
const int six_scrollback_rel_end =
grid_row_abs_to_sb(term->grid, term->rows, six_end);
if (six_scrollback_rel_end < scrollback_rel_row) {
/* All remaining sixels are *before* "our" row */
@ -888,7 +880,8 @@ sixel_reflow(struct terminal *term)
int last_row = -1;
for (int j = 0; j < six->rows; j++) {
int row_no = rebase_row(term, six->pos.row + j);
int row_no = grid_row_abs_to_sb(
term->grid, term->rows, six->pos.row + j);
if (last_row != -1 && last_row >= row_no) {
sixel_destroy(six);
sixel_destroyed = true;

25
terminal.c
View file

@ -2154,18 +2154,18 @@ term_erase(struct terminal *term, int start_row, int start_col,
void
term_erase_scrollback(struct terminal *term)
{
const int num_rows = term->grid->num_rows;
const struct grid *grid = term->grid;
const int num_rows = grid->num_rows;
const int mask = num_rows - 1;
const int start = (term->grid->offset + term->rows) & mask;
const int end = (term->grid->offset - 1) & mask;
const int start = (grid->offset + term->rows) & mask;
const int end = (grid->offset - 1) & mask;
const int scrollback_start = term->grid->offset + term->rows;
const int rel_start = (start - scrollback_start + num_rows) & mask;
const int rel_end = (end - scrollback_start + num_rows) & mask;
const int rel_start = grid_row_abs_to_sb(grid, term->rows, start);
const int rel_end = grid_row_abs_to_sb(grid, term->rows, end);
const int sel_start = term->selection.coords.start.row;
const int sel_end = term->selection.coords.end.row;
const int sel_start = selection_get_start(term).row;
const int sel_end = selection_get_end(term).row;
if (sel_end >= 0) {
/*
@ -2183,8 +2183,8 @@ term_erase_scrollback(struct terminal *term)
* closer to the screen bottom.
*/
const int rel_sel_start = (sel_start - scrollback_start + num_rows) & mask;
const int rel_sel_end = (sel_end - scrollback_start + num_rows) & mask;
const int rel_sel_start = grid_row_abs_to_sb(grid, term->rows, sel_start);
const int rel_sel_end = grid_row_abs_to_sb(grid, term->rows, sel_end);
if ((rel_sel_start <= rel_start && rel_sel_end >= rel_start) ||
(rel_sel_start <= rel_end && rel_sel_end >= rel_end) ||
@ -2196,8 +2196,9 @@ term_erase_scrollback(struct terminal *term)
tll_foreach(term->grid->sixel_images, it) {
struct sixel *six = &it->item;
const int six_start = (six->pos.row - scrollback_start + num_rows) & mask;
const int six_end = (six->pos.row + six->rows - 1 - scrollback_start + num_rows) & mask;
const int six_start = grid_row_abs_to_sb(grid, term->rows, six->pos.row);
const int six_end = grid_row_abs_to_sb(
grid, term->rows, six->pos.row + six->rows - 1);
if ((six_start <= rel_start && six_end >= rel_start) ||
(six_start <= rel_end && six_end >= rel_end) ||