From e56136ce1192d04a52b01ccb41284f0b7896430e Mon Sep 17 00:00:00 2001
From: Craig Barnes <craigbarnes@protonmail.com>
Date: Sat, 16 Jan 2021 20:16:00 +0000
Subject: [PATCH] debug: rename assert() to xassert(), to avoid clashing with
 <assert.h>

---
 base64.c      |   6 +--
 box-drawing.c |  16 +++---
 client.c      |   2 +-
 commands.c    |  16 +++---
 config.c      |  30 ++++++------
 csi.c         |   4 +-
 dcs.c         |  10 ++--
 debug.h       |   4 +-
 extract.c     |   6 +--
 fdm.c         |  18 +++----
 grid.c        |  20 ++++----
 grid.h        |   9 ++--
 ime.c         |  18 +++----
 input.c       |  56 ++++++++++-----------
 log.c         |   4 +-
 main.c        |   4 +-
 osc.c         |  22 ++++-----
 reaper.c      |   4 +-
 render.c      | 132 +++++++++++++++++++++++++-------------------------
 search.c      |  32 ++++++------
 selection.c   |  94 +++++++++++++++++------------------
 server.c      |   8 +--
 shm.c         |  48 +++++++++---------
 sixel.c       |  70 +++++++++++++-------------
 slave.c       |   4 +-
 spawn.c       |   2 +-
 terminal.c    |  88 ++++++++++++++++-----------------
 vt.c          |  22 ++++-----
 wayland.c     |  18 +++----
 xmalloc.c     |   2 +-
 xsnprintf.c   |   6 +--
 31 files changed, 387 insertions(+), 388 deletions(-)

diff --git a/base64.c b/base64.c
index 83655dfc..fe89e9fa 100644
--- a/base64.c
+++ b/base64.c
@@ -98,7 +98,7 @@ invalid:
 char *
 base64_encode(const uint8_t *data, size_t size)
 {
-    assert(size % 3 == 0);
+    xassert(size % 3 == 0);
     if (unlikely(size % 3 != 0))
         return NULL;
 
@@ -138,8 +138,8 @@ base64_encode(const uint8_t *data, size_t size)
 void
 base64_encode_final(const uint8_t *data, size_t size, char result[4])
 {
-    assert(size > 0);
-    assert(size < 3);
+    xassert(size > 0);
+    xassert(size < 3);
 
     uint32_t v = 0;
     if (size >= 1)
diff --git a/box-drawing.c b/box-drawing.c
index f10d267b..db0281bd 100644
--- a/box-drawing.c
+++ b/box-drawing.c
@@ -170,7 +170,7 @@ draw_box_drawings_dash_horizontal(struct buf *buf, int count, int thick, int gap
     int width = buf->width;
     int height = buf->height;
 
-    assert(count >= 2 && count <= 4);
+    xassert(count >= 2 && count <= 4);
     const int gap_count = count - 1;
 
     int dash_width = (width - (gap_count * gap)) / count;
@@ -184,7 +184,7 @@ draw_box_drawings_dash_horizontal(struct buf *buf, int count, int thick, int gap
         return;
     }
 
-    assert(count * dash_width + gap_count * gap <= width);
+    xassert(count * dash_width + gap_count * gap <= width);
 
     int remaining = width - count * dash_width - gap_count * gap;
 
@@ -228,7 +228,7 @@ draw_box_drawings_dash_vertical(struct buf *buf, int count, int thick, int gap)
     int width = buf->width;
     int height = buf->height;
 
-    assert(count >= 2 && count <= 4);
+    xassert(count >= 2 && count <= 4);
     const int gap_count = count - 1;
 
     int dash_height = (height - (gap_count * gap)) / count;
@@ -242,7 +242,7 @@ draw_box_drawings_dash_vertical(struct buf *buf, int count, int thick, int gap)
         return;
     }
 
-    assert(count * dash_height + gap_count * gap <= height);
+    xassert(count * dash_height + gap_count * gap <= height);
 
     int remaining = height - count * dash_height - gap_count * gap;
 
@@ -1304,8 +1304,8 @@ draw_box_drawings_light_arc(wchar_t wc, struct buf *buf)
             break;
         }
 
-        assert(row_end > row_start);
-        assert(col_end > col_start);
+        xassert(row_end > row_start);
+        xassert(col_end > col_start);
 
         for (int r = max(row_start, 0); r < max(min(row_end, buf->height), 0); r++) {
             for (int c = max(col_start, 0); c < max(min(col_end, buf->width), 0); c++) {
@@ -1844,10 +1844,10 @@ draw_sextant(wchar_t wc, struct buf *buf)
         UPPER_RIGHT | MIDDLE_LEFT | MIDDLE_RIGHT | LOWER_LEFT | LOWER_RIGHT,
     };
 
-    assert(wc >= 0x1fb00 && wc <= 0x1fb3b);
+    xassert(wc >= 0x1fb00 && wc <= 0x1fb3b);
     const size_t idx = wc - 0x1fb00;
 
-    assert(idx < ALEN(matrix));
+    xassert(idx < ALEN(matrix));
     uint8_t encoded = matrix[idx];
 
     if (encoded & UPPER_LEFT)
diff --git a/client.c b/client.c
index c78c1f59..80eb8b40 100644
--- a/client.c
+++ b/client.c
@@ -329,7 +329,7 @@ main(int argc, char *const *argv)
     ssize_t rcvd = recv(fd, &exit_code, sizeof(exit_code), 0);
 
     if (rcvd == -1 && errno == EINTR)
-        assert(aborted);
+        xassert(aborted);
     else if (rcvd != sizeof(exit_code))
         LOG_ERRNO("failed to read server response");
     else
diff --git a/commands.c b/commands.c
index 398f04e7..ac91ab19 100644
--- a/commands.c
+++ b/commands.c
@@ -19,15 +19,15 @@ cmd_scrollback_up(struct terminal *term, int rows)
         return;
 
     rows = min(rows, term->rows);
-    assert(term->grid->offset >= 0);
+    xassert(term->grid->offset >= 0);
 
     int new_view = term->grid->view - rows;
     while (new_view < 0)
         new_view += term->grid->num_rows;
     new_view %= term->grid->num_rows;
 
-    assert(new_view >= 0);
-    assert(new_view < term->grid->num_rows);
+    xassert(new_view >= 0);
+    xassert(new_view < term->grid->num_rows);
 
     /* Avoid scrolling in uninitialized rows */
     while (term->grid->rows[new_view] == NULL)
@@ -59,7 +59,7 @@ cmd_scrollback_up(struct terminal *term, int rows)
 
 #if defined(_DEBUG)
     for (int r = 0; r < term->rows; r++)
-        assert(term->grid->rows[(new_view + r) % term->grid->num_rows] != NULL);
+        xassert(term->grid->rows[(new_view + r) % term->grid->num_rows] != NULL);
 #endif
 
     LOG_DBG("scrollback UP: %d -> %d (offset = %d, end = %d, rows = %d)",
@@ -99,11 +99,11 @@ cmd_scrollback_down(struct terminal *term, int rows)
         return;
 
     rows = min(rows, term->rows);
-    assert(term->grid->offset >= 0);
+    xassert(term->grid->offset >= 0);
 
     int new_view = (term->grid->view + rows) % term->grid->num_rows;
-    assert(new_view >= 0);
-    assert(new_view < term->grid->num_rows);
+    xassert(new_view >= 0);
+    xassert(new_view < term->grid->num_rows);
 
     /* Prevent scrolling in uninitialized rows */
     bool all_initialized = false;
@@ -133,7 +133,7 @@ cmd_scrollback_down(struct terminal *term, int rows)
 
 #if defined(_DEBUG)
     for (int r = 0; r < term->rows; r++)
-        assert(term->grid->rows[(new_view + r) % term->grid->num_rows] != NULL);
+        xassert(term->grid->rows[(new_view + r) % term->grid->num_rows] != NULL);
 #endif
 
     LOG_DBG("scrollback DOWN: %d -> %d (offset = %d, end = %d, rows = %d)",
diff --git a/config.c b/config.c
index 00040802..5956a516 100644
--- a/config.c
+++ b/config.c
@@ -184,8 +184,8 @@ typedef tll(struct path_component) path_components_t;
 static void
 path_component_add(path_components_t *components, const char *comp, int fd)
 {
-    assert(comp != NULL);
-    assert(fd >= 0);
+    xassert(comp != NULL);
+    xassert(fd >= 0);
 
     struct path_component pc = {.component = comp, .fd = fd};
     tll_push_back(*components, pc);
@@ -194,7 +194,7 @@ path_component_add(path_components_t *components, const char *comp, int fd)
 static void
 path_component_destroy(struct path_component *component)
 {
-    assert(component->fd >= 0);
+    xassert(component->fd >= 0);
     close(component->fd);
 }
 
@@ -332,7 +332,7 @@ open_config(struct config *conf)
                 continue;
             }
 
-            assert(tll_length(components) == 0);
+            xassert(tll_length(components) == 0);
             path_component_add(&components, xdg_dir, xdg_fd);
             path_component_add(&components, "foot", foot_fd);
 
@@ -347,7 +347,7 @@ out:
     return ret;
 
 done:
-    assert(tll_length(components) > 0);
+    xassert(tll_length(components) > 0);
     ret = path_components_to_config_file(&components);
     goto out;
 }
@@ -1023,7 +1023,7 @@ static bool
 parse_key_combos(struct config *conf, const char *combos, key_combo_list_t *key_combos,
                  const char *path, unsigned lineno)
 {
-    assert(tll_length(*key_combos) == 0);
+    xassert(tll_length(*key_combos) == 0);
 
     char *copy = xstrdup(combos);
 
@@ -1136,8 +1136,8 @@ has_search_binding_collisions(struct config *conf, enum bind_action_search actio
 static int
 argv_compare(char *const *argv1, char *const *argv2)
 {
-    assert(argv1 != NULL);
-    assert(argv2 != NULL);
+    xassert(argv1 != NULL);
+    xassert(argv2 != NULL);
 
     for (size_t i = 0; ; i++) {
         if (argv1[i] == NULL && argv2[i] == NULL)
@@ -1152,7 +1152,7 @@ argv_compare(char *const *argv1, char *const *argv2)
             return ret;
     }
 
-    assert(false);
+    xassert(false);
     return 1;
 }
 
@@ -1372,7 +1372,7 @@ static bool
 parse_mouse_combos(struct config *conf, const char *combos, key_combo_list_t *key_combos,
                    const char *path, unsigned lineno)
 {
-    assert(tll_length(*key_combos) == 0);
+    xassert(tll_length(*key_combos) == 0);
 
     char *copy = xstrdup(combos);
 
@@ -1874,7 +1874,7 @@ parse_config_file(FILE *f, struct config *conf, const char *path, bool errors_ar
 
         /* Strip trailing whitespace from key (leading stripped earlier) */
         {
-            assert(!isspace(*key));
+            xassert(!isspace(*key));
 
             char *end = key + strlen(key) - 1;
             while (isspace(*end))
@@ -1898,10 +1898,10 @@ parse_config_file(FILE *f, struct config *conf, const char *path, bool errors_ar
         LOG_DBG("section=%s, key='%s', value='%s', comment='%s'",
                 section_info[section].name, key, value, comment);
 
-        assert(section >= 0 && section < SECTION_COUNT);
+        xassert(section >= 0 && section < SECTION_COUNT);
 
         parser_fun_t section_parser = section_info[section].fun;
-        assert(section_parser != NULL);
+        xassert(section_parser != NULL);
 
         if (!section_parser(key, value, conf, path, lineno))
             error_or_continue();
@@ -2176,8 +2176,8 @@ config_load(struct config *conf, const char *conf_path,
         }
     }
 
-    assert(conf_file.path != NULL);
-    assert(conf_file.fd >= 0);
+    xassert(conf_file.path != NULL);
+    xassert(conf_file.fd >= 0);
     LOG_INFO("loading configuration from %s", conf_file.path);
 
     FILE *f = fdopen(conf_file.fd, "r");
diff --git a/csi.c b/csi.c
index 9279345f..076723ae 100644
--- a/csi.c
+++ b/csi.c
@@ -1083,7 +1083,7 @@ csi_dispatch(struct terminal *term, uint8_t final)
                         break;
                     }
                 }
-                assert(new_col >= term->grid->cursor.point.col);
+                xassert(new_col >= term->grid->cursor.point.col);
                 term_cursor_right(term, new_col - term->grid->cursor.point.col);
             }
             break;
@@ -1099,7 +1099,7 @@ csi_dispatch(struct terminal *term, uint8_t final)
                         break;
                     }
                 }
-                assert(term->grid->cursor.point.col >= new_col);
+                xassert(term->grid->cursor.point.col >= new_col);
                 term_cursor_left(term, term->grid->cursor.point.col - new_col);
             }
             break;
diff --git a/dcs.c b/dcs.c
index 7d0dd6cc..f9e191d9 100644
--- a/dcs.c
+++ b/dcs.c
@@ -34,10 +34,10 @@ dcs_hook(struct terminal *term, uint8_t final)
     LOG_DBG("hook: %c (intermediate(s): %.2s, param=%d)", final,
             (const char *)&term->vt.private, vt_param_get(term, 0, 0));
 
-    assert(term->vt.dcs.data == NULL);
-    assert(term->vt.dcs.size == 0);
-    assert(term->vt.dcs.put_handler == NULL);
-    assert(term->vt.dcs.unhook_handler == NULL);
+    xassert(term->vt.dcs.data == NULL);
+    xassert(term->vt.dcs.size == 0);
+    xassert(term->vt.dcs.put_handler == NULL);
+    xassert(term->vt.dcs.unhook_handler == NULL);
 
     switch (term->vt.private) {
     case 0:
@@ -70,7 +70,7 @@ ensure_size(struct terminal *term, size_t required_size)
         return true;
 
     size_t new_size = (required_size + 127) / 128 * 128;
-    assert(new_size > 0);
+    xassert(new_size > 0);
 
     uint8_t *new_data = realloc(term->vt.dcs.data, new_size);
     if (new_data == NULL) {
diff --git a/debug.h b/debug.h
index ba71c047..fcc09830 100644
--- a/debug.h
+++ b/debug.h
@@ -8,9 +8,7 @@
     #define BUG(...) bug(__FILE__, __LINE__, __func__, __VA_ARGS__)
 #endif
 
-#undef assert
-
-#define assert(x) do { \
+#define xassert(x) do { \
     IGNORE_WARNING("-Wtautological-compare") \
     if (unlikely(!(x))) { \
         BUG("assertion failed: '%s'", #x); \
diff --git a/extract.c b/extract.c
index f9470871..145ef03f 100644
--- a/extract.c
+++ b/extract.c
@@ -46,7 +46,7 @@ ensure_size(struct extraction_context *ctx, size_t additional_chars)
         ctx->size = new_size;
     }
 
-    assert(ctx->size >= ctx->idx + additional_chars);
+    xassert(ctx->size >= ctx->idx + additional_chars);
     return true;
 }
 
@@ -71,8 +71,8 @@ extract_finish(struct extraction_context *ctx, char **text, size_t *len)
             goto out;
         ctx->buf[ctx->idx++] = L'\0';
     } else {
-        assert(ctx->idx > 0);
-        assert(ctx->idx <= ctx->size);
+        xassert(ctx->idx > 0);
+        xassert(ctx->idx <= ctx->size);
         if (ctx->buf[ctx->idx - 1] == L'\n')
             ctx->buf[ctx->idx - 1] = L'\0';
         else {
diff --git a/fdm.c b/fdm.c
index d0f9f9d1..3394f10c 100644
--- a/fdm.c
+++ b/fdm.c
@@ -84,11 +84,11 @@ fdm_destroy(struct fdm *fdm)
         LOG_WARN("hook list not empty");
     }
 
-    assert(tll_length(fdm->fds) == 0);
-    assert(tll_length(fdm->deferred_delete) == 0);
-    assert(tll_length(fdm->hooks_low) == 0);
-    assert(tll_length(fdm->hooks_normal) == 0);
-    assert(tll_length(fdm->hooks_high) == 0);
+    xassert(tll_length(fdm->fds) == 0);
+    xassert(tll_length(fdm->deferred_delete) == 0);
+    xassert(tll_length(fdm->hooks_low) == 0);
+    xassert(tll_length(fdm->hooks_normal) == 0);
+    xassert(tll_length(fdm->hooks_high) == 0);
 
     tll_free(fdm->fds);
     tll_free(fdm->deferred_delete);
@@ -106,14 +106,14 @@ fdm_add(struct fdm *fdm, int fd, int events, fdm_handler_t handler, void *data)
     int flags = fcntl(fd, F_GETFL);
     if (!(flags & O_NONBLOCK)) {
         LOG_ERR("FD=%d is in blocking mode", fd);
-        assert(false);
+        xassert(false);
         return false;
     }
 
     tll_foreach(fdm->fds, it) {
         if (it->item->fd == fd) {
             LOG_ERR("FD=%d already registered", fd);
-            assert(false);
+            xassert(false);
             return false;
         }
     }
@@ -251,7 +251,7 @@ hook_priority_to_list(struct fdm *fdm, enum fdm_hook_priority priority)
     case FDM_HOOK_PRIORITY_HIGH:   return &fdm->hooks_high;
     }
 
-    assert(false);
+    xassert(false);
     return NULL;
 }
 
@@ -294,7 +294,7 @@ fdm_hook_del(struct fdm *fdm, fdm_hook_t hook, enum fdm_hook_priority priority)
 bool
 fdm_poll(struct fdm *fdm)
 {
-    assert(!fdm->is_polling && "nested calls to fdm_poll() not allowed");
+    xassert(!fdm->is_polling && "nested calls to fdm_poll() not allowed");
     if (fdm->is_polling) {
         LOG_ERR("nested calls to fdm_poll() not allowed");
         return false;
diff --git a/grid.c b/grid.c
index ce691014..6d6b6b3c 100644
--- a/grid.c
+++ b/grid.c
@@ -14,8 +14,8 @@
 void
 grid_swap_row(struct grid *grid, int row_a, int row_b)
 {
-    assert(grid->offset >= 0);
-    assert(row_a != row_b);
+    xassert(grid->offset >= 0);
+    xassert(row_a != row_b);
 
     int real_a = (grid->offset + row_a) & (grid->num_rows - 1);
     int real_b = (grid->offset + row_b) & (grid->num_rows - 1);
@@ -78,7 +78,7 @@ grid_resize_without_reflow(
         const int new_row_idx = (new_offset + r) & (new_rows - 1);
 
         const struct row *old_row = old_grid[old_row_idx];
-        assert(old_row != NULL);
+        xassert(old_row != NULL);
 
         struct row *new_row = grid_row_alloc(new_cols, false);
         new_grid[new_row_idx] = new_row;
@@ -188,7 +188,7 @@ grid_resize_and_reflow(
     struct row **new_grid = xcalloc(new_rows, sizeof(new_grid[0]));
     struct row *new_row = new_grid[new_row_idx];
 
-    assert(new_row == NULL);
+    xassert(new_row == NULL);
     new_row = grid_row_alloc(new_cols, true);
     new_grid[new_row_idx] = new_row;
 
@@ -317,7 +317,7 @@ grid_resize_and_reflow(
             int width = max(1, wcwidth(wc));
 
             /* Multi-column characters are never cut in half */
-            assert(c + width <= old_cols);
+            xassert(c + width <= old_cols);
 
             for (int i = 0; i < empty_count + 1; i++) {
                 const struct cell *old_cell = &old_row->cells[c - empty_count + i];
@@ -340,9 +340,9 @@ grid_resize_and_reflow(
                     line_wrap();
                 }
 
-                assert(new_row != NULL);
-                assert(new_col_idx >= 0);
-                assert(new_col_idx < new_cols);
+                xassert(new_row != NULL);
+                xassert(new_col_idx >= 0);
+                xassert(new_col_idx < new_cols);
 
                 new_row->cells[new_col_idx] = *old_cell;
                 new_row->cells[new_col_idx].attrs.clean = 1;
@@ -364,7 +364,7 @@ grid_resize_and_reflow(
              * subsequent cells */
             const struct cell *old_cell = &old_row->cells[c];
             for (size_t i = 0; i < width - 1; i++) {
-                assert(new_col_idx < new_cols);
+                xassert(new_col_idx < new_cols);
                 print_spacer();
                 new_col_idx++;
             }
@@ -410,7 +410,7 @@ grid_resize_and_reflow(
     }
     for (size_t r = 0; r < new_screen_rows; r++) {
         int UNUSED idx = (grid->view + r) & (new_rows - 1);
-        assert(new_grid[idx] != NULL);
+        xassert(new_grid[idx] != NULL);
     }
 
     /* Free old grid */
diff --git a/grid.h b/grid.h
index 1066e28f..98b34570 100644
--- a/grid.h
+++ b/grid.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <stddef.h>
+#include "debug.h"
 #include "terminal.h"
 
 void grid_swap_row(struct grid *grid, int row_a, int row_b);
@@ -34,7 +35,7 @@ grid_row_absolute_in_view(const struct grid *grid, int row_no)
 static inline struct row *
 _grid_row_maybe_alloc(struct grid *grid, int row_no, bool alloc_if_null)
 {
-    assert(grid->offset >= 0);
+    xassert(grid->offset >= 0);
 
     int real_row = grid_row_absolute(grid, row_no);
     struct row *row = grid->rows[real_row];
@@ -44,7 +45,7 @@ _grid_row_maybe_alloc(struct grid *grid, int row_no, bool alloc_if_null)
         grid->rows[real_row] = row;
     }
 
-    assert(row != NULL);
+    xassert(row != NULL);
     return row;
 }
 
@@ -63,11 +64,11 @@ grid_row_and_alloc(struct grid *grid, int row_no)
 static inline struct row *
 grid_row_in_view(struct grid *grid, int row_no)
 {
-    assert(grid->view >= 0);
+    xassert(grid->view >= 0);
 
     int real_row = grid_row_absolute_in_view(grid, row_no);
     struct row *row = grid->rows[real_row];
 
-    assert(row != NULL);
+    xassert(row != NULL);
     return row;
 }
diff --git a/ime.c b/ime.c
index 9e2699f2..5a736f83 100644
--- a/ime.c
+++ b/ime.c
@@ -27,8 +27,8 @@ enter(void *data, struct zwp_text_input_v3 *zwp_text_input_v3,
     /* The main grid is the *only* input-receiving surface we have */
     /* TODO: can we receive text_input::enter() _before_ keyboard_enter()? */
     struct terminal UNUSED *term = seat->kbd_focus;
-    assert(term != NULL);
-    assert(term_surface_kind(term, surface) == TERM_SURF_GRID);
+    xassert(term != NULL);
+    xassert(term_surface_kind(term, surface) == TERM_SURF_GRID);
 
     ime_enable(seat);
 }
@@ -111,7 +111,7 @@ done(void *data, struct zwp_text_input_v3 *zwp_text_input_v3,
         return;
     }
 
-    assert(seat->kbd_focus);
+    xassert(seat->kbd_focus);
     struct terminal *term = seat->kbd_focus;
 
     /* 1. Delete existing pre-edit text */
@@ -272,11 +272,11 @@ done(void *data, struct zwp_text_input_v3 *zwp_text_input_v3,
 
         LOG_DBG("pre-edit cursor: begin=%d, end=%d", cell_begin, cell_end);
 
-        assert(cell_begin >= 0);
-        assert(cell_begin < cell_count);
-        assert(cell_begin <= cell_end);
-        assert(cell_end >= 0);
-        assert(cell_end <= cell_count);
+        xassert(cell_begin >= 0);
+        xassert(cell_begin < cell_count);
+        xassert(cell_begin <= cell_end);
+        xassert(cell_end >= 0);
+        xassert(cell_end <= cell_count);
 
         term->ime.preedit.cursor.hidden = false;
         term->ime.preedit.cursor.start = cell_begin;
@@ -331,7 +331,7 @@ ime_enable(struct seat *seat)
         return;
 
     struct terminal *term = seat->kbd_focus;
-    assert(term != NULL);
+    xassert(term != NULL);
 
     if (!term->ime.enabled)
         return;
diff --git a/input.c b/input.c
index c0fc3522..5042edb5 100644
--- a/input.c
+++ b/input.c
@@ -53,7 +53,7 @@ fdm_write_pipe(struct fdm *fdm, int fd, int events, void *data)
     if (events & EPOLLHUP)
         goto pipe_closed;
 
-    assert(events & EPOLLOUT);
+    xassert(events & EPOLLOUT);
     ssize_t written = write(fd, &ctx->text[ctx->idx], ctx->left);
 
     if (written < 0) {
@@ -61,7 +61,7 @@ fdm_write_pipe(struct fdm *fdm, int fd, int events, void *data)
         goto pipe_closed;
     }
 
-    assert(written <= ctx->left);
+    xassert(written <= ctx->left);
     ctx->idx += written;
     ctx->left -= written;
 
@@ -210,7 +210,7 @@ execute_binding(struct seat *seat, struct terminal *term,
             break;
 
         default:
-            assert(false);
+            xassert(false);
             success = false;
             break;
         }
@@ -332,7 +332,7 @@ execute_binding(struct seat *seat, struct terminal *term,
         return false;
 
     case BIND_ACTION_COUNT:
-        assert(false);
+        xassert(false);
         return false;
     }
 
@@ -557,7 +557,7 @@ static void
 keyboard_enter(void *data, struct wl_keyboard *wl_keyboard, uint32_t serial,
                struct wl_surface *surface, struct wl_array *keys)
 {
-    assert(surface != NULL);
+    xassert(surface != NULL);
 
     struct seat *seat = data;
     struct wl_window *win = wl_surface_get_user_data(surface);
@@ -631,7 +631,7 @@ keyboard_leave(void *data, struct wl_keyboard *wl_keyboard, uint32_t serial,
     if (seat->kbd.xkb == NULL)
         return;
 
-    assert(
+    xassert(
         seat->kbd_focus == NULL ||
         surface == NULL ||  /* Seen on Sway 1.2 */
         ((const struct wl_window *)wl_surface_get_user_data(surface))->term == seat->kbd_focus
@@ -923,7 +923,7 @@ key_press_release(struct seat *seat, struct terminal *term, uint32_t serial,
      * Compose, and maybe emit "normal" character
      */
 
-    assert(seat->kbd.xkb_compose_state != NULL ||
+    xassert(seat->kbd.xkb_compose_state != NULL ||
            compose_status != XKB_COMPOSE_COMPOSED);
 
     int count = compose_status == XKB_COMPOSE_COMPOSED
@@ -973,9 +973,9 @@ key_press_release(struct seat *seat, struct terminal *term, uint32_t serial,
             [MOD_META | MOD_SHIFT | MOD_ALT | MOD_CTRL] = 16,
         };
 
-        assert(keymap_mods < sizeof(mod_param_map) / sizeof(mod_param_map[0]));
+        xassert(keymap_mods < sizeof(mod_param_map) / sizeof(mod_param_map[0]));
         int modify_param = mod_param_map[keymap_mods];
-        assert(modify_param != 0);
+        xassert(modify_param != 0);
 
         char reply[1024];
         size_t n = xsnprintf(reply, sizeof(reply), "\x1b[27;%d;%d~", modify_param, sym);
@@ -1101,7 +1101,7 @@ void
 input_repeat(struct seat *seat, uint32_t key)
 {
     /* Should be cleared as soon as we loose focus */
-    assert(seat->kbd_focus != NULL);
+    xassert(seat->kbd_focus != NULL);
     struct terminal *term = seat->kbd_focus;
 
     key_press_release(seat, term, seat->kbd.serial, key, XKB_KEY_DOWN);
@@ -1161,7 +1161,7 @@ xcursor_for_csd_border(struct terminal *term, int x, int y)
     else if (term->active_surface == TERM_SURF_BORDER_TOP)    return XCURSOR_TOP_SIDE;
     else if (term->active_surface == TERM_SURF_BORDER_BOTTOM) return XCURSOR_BOTTOM_SIDE;
     else {
-        assert(false);
+        xassert(false);
         return NULL;
     }
 }
@@ -1171,7 +1171,7 @@ wl_pointer_enter(void *data, struct wl_pointer *wl_pointer,
                  uint32_t serial, struct wl_surface *surface,
                  wl_fixed_t surface_x, wl_fixed_t surface_y)
 {
-    assert(surface != NULL);
+    xassert(surface != NULL);
 
     struct seat *seat = data;
     struct wl_window *win = wl_surface_get_user_data(surface);
@@ -1235,7 +1235,7 @@ wl_pointer_enter(void *data, struct wl_pointer *wl_pointer,
         break;
 
     case TERM_SURF_NONE:
-        assert(false);
+        xassert(false);
         break;
     }
 }
@@ -1281,7 +1281,7 @@ wl_pointer_leave(void *data, struct wl_pointer *wl_pointer,
         if (surface != NULL) {
             /* Sway 1.4 sends this event with a NULL surface when we destroy the window */
             const struct wl_window UNUSED *win = wl_surface_get_user_data(surface);
-            assert(old_moused == win->term);
+            xassert(old_moused == win->term);
         }
 
         enum term_surface active_surface = old_moused->active_surface;
@@ -1327,7 +1327,7 @@ wl_pointer_motion(void *data, struct wl_pointer *wl_pointer,
     LOG_DBG("pointer_motion: pointer=%p, x=%d, y=%d", (void *)wl_pointer,
             wl_fixed_to_int(surface_x), wl_fixed_to_int(surface_y));
 
-    assert(term != NULL);
+    xassert(term != NULL);
 
     int x = wl_fixed_to_int(surface_x) * term->scale;
     int y = wl_fixed_to_int(surface_y) * term->scale;
@@ -1420,8 +1420,8 @@ wl_pointer_motion(void *data, struct wl_pointer *wl_pointer,
             seat->mouse.row = selection_row;
         }
 
-        assert(seat->mouse.col == -1 || (seat->mouse.col >= 0 && seat->mouse.col < term->cols));
-        assert(seat->mouse.row == -1 || (seat->mouse.row >= 0 && seat->mouse.row < term->rows));
+        xassert(seat->mouse.col == -1 || (seat->mouse.col >= 0 && seat->mouse.col < term->cols));
+        xassert(seat->mouse.row == -1 || (seat->mouse.row >= 0 && seat->mouse.row < term->rows));
 
         term_xcursor_update_for_seat(term, seat);
 
@@ -1461,7 +1461,7 @@ wl_pointer_motion(void *data, struct wl_pointer *wl_pointer,
                     ? term->margins.top - y
                     : y - (term->height - term->margins.bottom);
 
-                assert(distance > 0);
+                xassert(distance > 0);
                 int divisor
                     = distance * term->conf->scrollback.multiplier / term->scale;
 
@@ -1483,8 +1483,8 @@ wl_pointer_motion(void *data, struct wl_pointer *wl_pointer,
             ((button == 0 && cursor_is_on_grid) ||
              (button != 0 && send_to_client)))
         {
-            assert(seat->mouse.col < term->cols);
-            assert(seat->mouse.row < term->rows);
+            xassert(seat->mouse.col < term->cols);
+            xassert(seat->mouse.row < term->rows);
 
             term_mouse_motion(
                 term, button,
@@ -1529,7 +1529,7 @@ wl_pointer_button(void *data, struct wl_pointer *wl_pointer,
 
     seat->pointer.hidden = false;
 
-    assert(term != NULL);
+    xassert(term != NULL);
 
     enum term_surface surf_kind = TERM_SURF_NONE;
     bool send_to_client = false;
@@ -1549,7 +1549,7 @@ wl_pointer_button(void *data, struct wl_pointer *wl_pointer,
 
 #if defined(_DEBUG)
         tll_foreach(seat->mouse.buttons, it)
-            assert(it->item.button != button);
+            xassert(it->item.button != button);
 #endif
 
         /*
@@ -1811,7 +1811,7 @@ wl_pointer_button(void *data, struct wl_pointer *wl_pointer,
     }
 
     case TERM_SURF_NONE:
-        assert(false);
+        xassert(false);
         break;
 
     }
@@ -1824,7 +1824,7 @@ alternate_scroll(struct seat *seat, int amount, int button)
         return;
 
     /* Should be cleared in leave event */
-    assert(seat->mouse_focus != NULL);
+    xassert(seat->mouse_focus != NULL);
     struct terminal *term = seat->mouse_focus;
 
     xkb_keycode_t key = button == BTN_BACK
@@ -1839,7 +1839,7 @@ static void
 mouse_scroll(struct seat *seat, int amount)
 {
     struct terminal *term = seat->mouse_focus;
-    assert(term != NULL);
+    xassert(term != NULL);
 
     int button = amount < 0 ? BTN_BACK : BTN_FORWARD;
     amount = abs(amount);
@@ -1857,8 +1857,8 @@ mouse_scroll(struct seat *seat, int amount)
     } else if (!term_mouse_grabbed(term, seat) &&
                seat->mouse.col >= 0 && seat->mouse.row >= 0)
     {
-        assert(seat->mouse.col < term->cols);
-        assert(seat->mouse.row < term->rows);
+        xassert(seat->mouse.col < term->cols);
+        xassert(seat->mouse.row < term->rows);
 
         for (int i = 0; i < amount; i++) {
             term_mouse_down(
@@ -1884,7 +1884,7 @@ wl_pointer_axis(void *data, struct wl_pointer *wl_pointer,
     if (seat->mouse.have_discrete)
         return;
 
-    assert(seat->mouse_focus != NULL);
+    xassert(seat->mouse_focus != NULL);
 
     /*
      * Aggregate scrolled amount until we get at least 1.0
diff --git a/log.c b/log.c
index 2dafd49b..24d26ed0 100644
--- a/log.c
+++ b/log.c
@@ -94,11 +94,11 @@ _sys_log(enum log_class log_class, const char *module,
     case LOG_CLASS_DEBUG:    level = LOG_DEBUG; break;
     }
 
-    assert(level != -1);
+    xassert(level != -1);
 
     char msg[4096];
     int n = vsnprintf(msg, sizeof(msg), fmt, va);
-    assert(n >= 0);
+    xassert(n >= 0);
 
     if (sys_errno != 0 && (size_t)n < sizeof(msg))
         snprintf(msg + n, sizeof(msg) - n, ": %s", strerror(sys_errno));
diff --git a/main.c b/main.c
index ea2d4a27..2775a50d 100644
--- a/main.c
+++ b/main.c
@@ -82,7 +82,7 @@ print_usage(const char *prog_name)
 bool
 locale_is_utf8(void)
 {
-    assert(strlen(u8"ö") == 2);
+    xassert(strlen(u8"ö") == 2);
 
     wchar_t w;
     if (mbtowc(&w, u8"ö", 2) != 2)
@@ -240,7 +240,7 @@ main(int argc, char *const *argv)
 
                 /* Strip trailing spaces */
                 char *end = font + strlen(font);
-                assert(*end == '\0');
+                xassert(*end == '\0');
                 end--;
                 while (end > font && isspace(*end))
                     *(end--) = '\0';
diff --git a/osc.c b/osc.c
index 0e658ce6..801b04e9 100644
--- a/osc.c
+++ b/osc.c
@@ -106,7 +106,7 @@ from_clipboard_cb(char *text, size_t size, void *user)
     struct clip_context *ctx = user;
     struct terminal *term = ctx->term;
 
-    assert(ctx->idx >= 0 && ctx->idx <= 2);
+    xassert(ctx->idx >= 0 && ctx->idx <= 2);
 
     const char *t = text;
     size_t left = size;
@@ -115,11 +115,11 @@ from_clipboard_cb(char *text, size_t size, void *user)
         for (size_t i = ctx->idx; i < 3 && left > 0; i++, t++, left--)
             ctx->buf[ctx->idx++] = *t;
 
-        assert(ctx->idx <= 3);
+        xassert(ctx->idx <= 3);
         if (ctx->idx == 3) {
             char *chunk = base64_encode(ctx->buf, 3);
-            assert(chunk != NULL);
-            assert(strlen(chunk) == 4);
+            xassert(chunk != NULL);
+            xassert(strlen(chunk) == 4);
 
             term_to_slave(term, chunk, 4);
             free(chunk);
@@ -131,16 +131,16 @@ from_clipboard_cb(char *text, size_t size, void *user)
     if (left == 0)
         return;
 
-    assert(ctx->idx == 0);
+    xassert(ctx->idx == 0);
 
     int remaining = left % 3;
     for (int i = remaining; i > 0; i--)
         ctx->buf[ctx->idx++] = text[size - i];
-    assert(ctx->idx == remaining);
+    xassert(ctx->idx == remaining);
 
     char *chunk = base64_encode((const uint8_t *)t, left / 3 * 3);
-    assert(chunk != NULL);
-    assert(strlen(chunk) % 4 == 0);
+    xassert(chunk != NULL);
+    xassert(strlen(chunk) % 4 == 0);
     term_to_slave(term, chunk, strlen(chunk));
     free(chunk);
 }
@@ -437,7 +437,7 @@ update_color_in_grids(struct terminal *term, uint32_t old_color,
 
         for (size_t r = 0; r < term->rows; r++) {
             struct row *row = grid_row(grid, r);
-            assert(row != NULL);
+            xassert(row != NULL);
 
             for (size_t c = 0; c < term->grid->num_cols; c++) {
                 struct cell *cell = &row->cells[c];
@@ -501,7 +501,7 @@ osc_dispatch(struct terminal *term)
         if (*string != ';')
             break;
 
-        assert(*string == ';');
+        xassert(*string == ';');
 
         for (const char *s_idx = strtok(string, ";"), *s_color = strtok(NULL, ";");
              s_idx != NULL && s_color != NULL;
@@ -725,7 +725,7 @@ osc_ensure_size(struct terminal *term, size_t required_size)
         return true;
 
     size_t new_size = (required_size + 127) / 128 * 128;
-    assert(new_size > 0);
+    xassert(new_size > 0);
 
     uint8_t *new_data = realloc(term->vt.osc.data, new_size);
     if (new_data == NULL) {
diff --git a/reaper.c b/reaper.c
index d2b27986..dec15cb2 100644
--- a/reaper.c
+++ b/reaper.c
@@ -121,7 +121,7 @@ fdm_reap(struct fdm *fdm, int fd, int events, void *data)
     if (hup && !pollin)
         return false;
 
-    assert(pollin);
+    xassert(pollin);
 
     struct signalfd_siginfo info;
     ssize_t amount = read(reaper->fd, &info, sizeof(info));
@@ -131,7 +131,7 @@ fdm_reap(struct fdm *fdm, int fd, int events, void *data)
         return false;
     }
 
-    assert((size_t)amount >= sizeof(info));
+    xassert((size_t)amount >= sizeof(info));
 
     if (info.ssi_signo != SIGCHLD) {
         LOG_WARN("got non-SIGCHLD signal: %d", info.ssi_signo);
diff --git a/render.c b/render.c
index 51341365..f8bb4968 100644
--- a/render.c
+++ b/render.c
@@ -150,10 +150,10 @@ presented(void *data,
         "commit - %llu µs -> ", (unsigned long long)diff.tv_usec);
 
     if (use_input) {
-        assert(timercmp(&presented, input, >));
+        xassert(timercmp(&presented, input, >));
         timersub(&presented, input, &diff);
     } else {
-        assert(timercmp(&presented, commit, >));
+        xassert(timercmp(&presented, commit, >));
         timersub(&presented, commit, &diff);
     }
 
@@ -396,7 +396,7 @@ render_cell(struct terminal *term, pixman_image_t *pix,
     int x = term->margins.left + col * width;
     int y = term->margins.top + row_no * height;
 
-    assert(cell->attrs.selected == 0 || cell->attrs.selected == 1);
+    xassert(cell->attrs.selected == 0 || cell->attrs.selected == 1);
     bool is_selected = cell->attrs.selected;
 
     uint32_t _fg = 0;
@@ -454,7 +454,7 @@ render_cell(struct terminal *term, pixman_image_t *pix,
                      (base >= 0x1fb00 && base <= 0x1fb3b))) {
             /* Box drawing characters */
             size_t idx = base >= 0x1fb00 ? base - 0x1fb00 + 160 : base - 0x2500;
-            assert(idx < ALEN(term->box_drawing));
+            xassert(idx < ALEN(term->box_drawing));
 
             if (likely(term->box_drawing[idx] != NULL))
                 glyph = term->box_drawing[idx];
@@ -467,7 +467,7 @@ render_cell(struct terminal *term, pixman_image_t *pix,
                 mtx_unlock(&term->render.workers.lock);
 
                 glyph = term->box_drawing[idx];
-                assert(glyph != NULL);
+                xassert(glyph != NULL);
             }
         } else
             glyph = fcft_glyph_rasterize(font, base, term->font_subpixel);
@@ -893,10 +893,10 @@ render_sixel_chunk(struct terminal *term, pixman_image_t *pix, const struct sixe
             term->height - y - term->margins.bottom));
 
     /* Verify we're not stepping outside the grid */
-    assert(x >= term->margins.left);
-    assert(y >= term->margins.top);
-    assert(width == 0 || x + width <= term->width - term->margins.right);
-    assert(height == 0 || y + height <= term->height - term->margins.bottom);
+    xassert(x >= term->margins.left);
+    xassert(y >= term->margins.top);
+    xassert(width == 0 || x + width <= term->width - term->margins.right);
+    xassert(height == 0 || y + height <= term->height - term->margins.bottom);
 
     //LOG_DBG("sixel chunk: %dx%d %dx%d", x, y, width, height);
 
@@ -980,7 +980,7 @@ render_sixel(struct terminal *term, pixman_image_t *pix,
 
         /* Is the row dirty? */
         struct row *row = term->grid->rows[abs_row_no];
-        assert(row != NULL);  /* Should be visible */
+        xassert(row != NULL);  /* Should be visible */
 
         if (!row->dirty) {
             maybe_emit_sixel_chunk_then_reset();
@@ -1014,7 +1014,7 @@ render_sixel(struct terminal *term, pixman_image_t *pix,
         }
 
         if (chunk_term_start == -1) {
-            assert(chunk_img_start == -1);
+            xassert(chunk_img_start == -1);
             chunk_term_start = term_row_no;
             chunk_img_start = _abs_row_no - sixel->pos.row;
             chunk_row_count = 1;
@@ -1125,8 +1125,8 @@ render_ime_preedit(struct terminal *term, struct buffer *buf)
         }
     }
 
-    assert(col_idx >= 0);
-    assert(col_idx < term->cols);
+    xassert(col_idx >= 0);
+    xassert(col_idx < term->cols);
 
     struct row *row = grid_row_in_view(term->grid, row_idx);
 
@@ -1143,14 +1143,14 @@ render_ime_preedit(struct terminal *term, struct buffer *buf)
      */
     struct cell *real_cells = malloc(cells_used * sizeof(real_cells[0]));
     for (int i = 0; i < cells_used; i++) {
-        assert(col_idx + i < term->cols);
+        xassert(col_idx + i < term->cols);
         real_cells[i] = row->cells[col_idx + i];
         real_cells[i].attrs.clean = 0;
     }
     row->dirty = true;
 
     /* Render pre-edit text */
-    assert(term->ime.preedit.cells[ime_ofs].wc != CELL_MULT_COL_SPACER);
+    xassert(term->ime.preedit.cells[ime_ofs].wc != CELL_MULT_COL_SPACER);
     for (int i = 0, idx = ime_ofs; idx < term->ime.preedit.count; i++, idx++) {
         const struct cell *cell = &term->ime.preedit.cells[idx];
 
@@ -1255,14 +1255,14 @@ render_worker_thread(void *_ctx)
 
         while (!frame_done) {
             mtx_lock(lock);
-            assert(tll_length(term->render.workers.queue) > 0);
+            xassert(tll_length(term->render.workers.queue) > 0);
 
             int row_no = tll_pop_front(term->render.workers.queue);
             mtx_unlock(lock);
 
             switch (row_no) {
             default: {
-                assert(buf != NULL);
+                xassert(buf != NULL);
 
                 struct row *row = grid_row_in_view(term->grid, row_no);
                 int cursor_col = cursor.row == row_no ? cursor.col : -1;
@@ -1295,7 +1295,7 @@ struct csd_data {
 static struct csd_data
 get_csd_data(const struct terminal *term, enum csd_surface surf_idx)
 {
-    assert(term->window->use_csd == CSD_YES);
+    xassert(term->window->use_csd == CSD_YES);
 
     /* Only title bar is rendered in maximized mode */
     const int border_width = !term->window->is_maximized
@@ -1330,11 +1330,11 @@ get_csd_data(const struct terminal *term, enum csd_surface surf_idx)
     case CSD_SURF_CLOSE:    return (struct csd_data){term->width - 1 * button_width, 0, button_close_width,    title_height};
 
     case CSD_SURF_COUNT:
-        assert(false);
+        xassert(false);
         return (struct csd_data){0};
     }
 
-    assert(false);
+    xassert(false);
     return (struct csd_data){0};
 }
 
@@ -1352,7 +1352,7 @@ render_csd_part(struct terminal *term,
                 struct wl_surface *surf, struct buffer *buf,
                 int width, int height, pixman_color_t *color)
 {
-    assert(term->window->use_csd == CSD_YES);
+    xassert(term->window->use_csd == CSD_YES);
 
     pixman_image_t *src = pixman_image_create_solid_fill(color);
 
@@ -1365,12 +1365,12 @@ render_csd_part(struct terminal *term,
 static void
 render_csd_title(struct terminal *term)
 {
-    assert(term->window->use_csd == CSD_YES);
+    xassert(term->window->use_csd == CSD_YES);
 
     struct csd_data info = get_csd_data(term, CSD_SURF_TITLE);
     struct wl_surface *surf = term->window->csd.surface[CSD_SURF_TITLE];
 
-    assert(info.width > 0 && info.height > 0);
+    xassert(info.width > 0 && info.height > 0);
 
     unsigned long cookie = shm_cookie_csd(term, CSD_SURF_TITLE);
     struct buffer *buf = shm_get_buffer(
@@ -1395,8 +1395,8 @@ render_csd_title(struct terminal *term)
 static void
 render_csd_border(struct terminal *term, enum csd_surface surf_idx)
 {
-    assert(term->window->use_csd == CSD_YES);
-    assert(surf_idx >= CSD_SURF_LEFT && surf_idx <= CSD_SURF_BOTTOM);
+    xassert(term->window->use_csd == CSD_YES);
+    xassert(surf_idx >= CSD_SURF_LEFT && surf_idx <= CSD_SURF_BOTTOM);
 
     struct csd_data info = get_csd_data(term, surf_idx);
     struct wl_surface *surf = term->window->csd.surface[surf_idx];
@@ -1430,8 +1430,8 @@ render_csd_button_minimize(struct terminal *term, struct buffer *buf)
         width = height * 2;
     }
 
-    assert(width <= max_width);
-    assert(height <= max_height);
+    xassert(width <= max_width);
+    xassert(height <= max_height);
 
     int x_margin = (buf->width - width) / 2.;
     int y_margin = (buf->height - height) / 2.;
@@ -1503,8 +1503,8 @@ render_csd_button_maximize_window(
         width = height * 2;
     }
 
-    assert(width <= max_width);
-    assert(height <= max_height);
+    xassert(width <= max_width);
+    xassert(height <= max_height);
 
     int x_margin = (buf->width - width) / 2.;
     int y_margin = (buf->height - height) / 2.;
@@ -1564,8 +1564,8 @@ render_csd_button_close(struct terminal *term, struct buffer *buf)
 static void
 render_csd_button(struct terminal *term, enum csd_surface surf_idx)
 {
-    assert(term->window->use_csd == CSD_YES);
-    assert(surf_idx >= CSD_SURF_MINIMIZE && surf_idx <= CSD_SURF_CLOSE);
+    xassert(term->window->use_csd == CSD_YES);
+    xassert(surf_idx >= CSD_SURF_MINIMIZE && surf_idx <= CSD_SURF_CLOSE);
 
     struct csd_data info = get_csd_data(term, surf_idx);
     struct wl_surface *surf = term->window->csd.surface[surf_idx];
@@ -1606,7 +1606,7 @@ render_csd_button(struct terminal *term, enum csd_surface surf_idx)
         break;
 
     default:
-        assert(false);
+        xassert(false);
         break;
     }
 
@@ -1633,7 +1633,7 @@ render_csd_button(struct terminal *term, enum csd_surface surf_idx)
         break;
 
     default:
-        assert(false);
+        xassert(false);
         break;
     }
 
@@ -1643,7 +1643,7 @@ render_csd_button(struct terminal *term, enum csd_surface surf_idx)
 static void
 render_csd(struct terminal *term)
 {
-    assert(term->window->use_csd == CSD_YES);
+    xassert(term->window->use_csd == CSD_YES);
 
     if (term->window->is_fullscreen)
         return;
@@ -1658,8 +1658,8 @@ render_csd(struct terminal *term)
         struct wl_surface *surf = term->window->csd.surface[i];
         struct wl_subsurface *sub = term->window->csd.sub_surface[i];
 
-        assert(surf != NULL);
-        assert(sub != NULL);
+        xassert(surf != NULL);
+        xassert(sub != NULL);
 
         if (width == 0 || height == 0) {
             wl_subsurface_set_position(sub, 0, 0);
@@ -1775,8 +1775,8 @@ render_scrollback_position(struct terminal *term)
         wl_subsurface_set_sync(win->scrollback_indicator_sub_surface);
     }
 
-    assert(win->scrollback_indicator_surface != NULL);
-    assert(win->scrollback_indicator_sub_surface != NULL);
+    xassert(win->scrollback_indicator_surface != NULL);
+    xassert(win->scrollback_indicator_sub_surface != NULL);
 
     /* Find absolute row number of the scrollback start */
     int scrollback_start = term->grid->offset + term->rows;
@@ -1793,8 +1793,8 @@ render_scrollback_position(struct terminal *term)
 
     /* How much of the scrollback is actually used? */
     int populated_rows = term->grid->num_rows - empty_rows;
-    assert(populated_rows > 0);
-    assert(populated_rows <= term->grid->num_rows);
+    xassert(populated_rows > 0);
+    xassert(populated_rows <= term->grid->num_rows);
 
     /*
      * How far down in the scrollback we are.
@@ -1842,7 +1842,7 @@ render_scrollback_position(struct terminal *term)
     int surf_top = 0;
     switch (term->conf->scrollback.indicator.position) {
     case SCROLLBACK_INDICATOR_POSITION_NONE:
-        assert(false);
+        xassert(false);
         return;
 
     case SCROLLBACK_INDICATOR_POSITION_FIXED:
@@ -1855,7 +1855,7 @@ render_scrollback_position(struct terminal *term)
             /* Make sure we don't collide with the scrollback search box */
             lines--;
         }
-        assert(lines > 0);
+        xassert(lines > 0);
 
         int pixels = lines * term->cell_height - height + 2 * margin;
         surf_top = term->cell_height - margin + (int)(percent * pixels);
@@ -1925,8 +1925,8 @@ grid_render(struct terminal *term)
     if (term->conf->tweak.render_timer_osd || term->conf->tweak.render_timer_log)
         gettimeofday(&start_time, NULL);
 
-    assert(term->width > 0);
-    assert(term->height > 0);
+    xassert(term->width > 0);
+    xassert(term->height > 0);
 
     unsigned long cookie = shm_cookie_grid(term);
     struct buffer *buf = shm_get_buffer(
@@ -1955,7 +1955,7 @@ grid_render(struct terminal *term)
                 has_warned = true;
             }
 
-            assert(term->render.last_buf->size == buf->size);
+            xassert(term->render.last_buf->size == buf->size);
             memcpy(buf->mmapped, term->render.last_buf->mmapped, buf->size);
         }
 
@@ -2054,7 +2054,7 @@ grid_render(struct terminal *term)
         for (size_t i = 0; i < term->render.workers.count; i++)
             sem_post(&term->render.workers.start);
 
-        assert(tll_length(term->render.workers.queue) == 0);
+        xassert(tll_length(term->render.workers.queue) == 0);
     }
 
     int first_dirty_row = -1;
@@ -2142,10 +2142,10 @@ grid_render(struct terminal *term)
             render_render_timer(term, render_time);
     }
 
-    assert(term->grid->offset >= 0 && term->grid->offset < term->grid->num_rows);
-    assert(term->grid->view >= 0 && term->grid->view < term->grid->num_rows);
+    xassert(term->grid->offset >= 0 && term->grid->offset < term->grid->num_rows);
+    xassert(term->grid->view >= 0 && term->grid->view < term->grid->num_rows);
 
-    assert(term->window->frame_callback == NULL);
+    xassert(term->window->frame_callback == NULL);
     term->window->frame_callback = wl_surface_frame(term->window->surface);
     wl_callback_add_listener(term->window->frame_callback, &frame_listener, term);
 
@@ -2191,7 +2191,7 @@ grid_render(struct terminal *term)
 static void
 render_search_box(struct terminal *term)
 {
-    assert(term->window->search_sub_surface != NULL);
+    xassert(term->window->search_sub_surface != NULL);
 
     /*
      * We treat the search box pretty much like a row of cells. That
@@ -2237,7 +2237,7 @@ render_search_box(struct terminal *term)
     const size_t total_cells = wcswidth(text, text_len);
     const size_t wanted_visible_cells = max(20, total_cells);
 
-    assert(term->scale >= 1);
+    xassert(term->scale >= 1);
     const int scale = term->scale;
 
     const size_t margin = 3 * scale;
@@ -2391,8 +2391,8 @@ render_search_box(struct terminal *term)
 #endif
             {
                 /* Cursor *should* be in the visible area */
-                assert(cell_idx >= glyph_offset);
-                assert(cell_idx <= glyph_offset + visible_cells);
+                xassert(cell_idx >= glyph_offset);
+                xassert(cell_idx <= glyph_offset + visible_cells);
                 draw_bar(term, buf->pix[0], font, &fg, x, y);
             }
         }
@@ -2492,7 +2492,7 @@ frame_callback(void *data, struct wl_callback *wl_callback, uint32_t callback_da
 {
     struct terminal *term = data;
 
-    assert(term->window->frame_callback == wl_callback);
+    xassert(term->window->frame_callback == wl_callback);
     wl_callback_destroy(wl_callback);
     term->window->frame_callback = NULL;
 
@@ -2567,7 +2567,7 @@ maybe_resize(struct terminal *term, int width, int height, bool force)
 
                 if (term->window->use_csd == CSD_YES) {
                     /* Take CSD title bar into account */
-                    assert(!term->window->is_fullscreen);
+                    xassert(!term->window->is_fullscreen);
                     height -= term->conf->csd.title_height;
                 }
 
@@ -2591,8 +2591,8 @@ maybe_resize(struct terminal *term, int width, int height, bool force)
                 if (height % scale)
                     height += scale - height % scale;
 
-                assert(width % scale == 0);
-                assert(height % scale == 0);
+                xassert(width % scale == 0);
+                xassert(height % scale == 0);
                 break;
             }
         }
@@ -2639,8 +2639,8 @@ maybe_resize(struct terminal *term, int width, int height, bool force)
     const int new_normal_grid_rows = 1 << (32 - __builtin_clz(new_rows + scrollback_lines - 1));
     const int new_alt_grid_rows = 1 << (32  - __builtin_clz(new_rows));
 
-    assert(new_cols >= 1);
-    assert(new_rows >= 1);
+    xassert(new_cols >= 1);
+    xassert(new_rows >= 1);
 
     /* Margins */
     const int grid_width = new_cols * term->cell_width;
@@ -2658,10 +2658,10 @@ maybe_resize(struct terminal *term, int width, int height, bool force)
     term->margins.right = total_x_pad - term->margins.left;
     term->margins.bottom = total_y_pad - term->margins.top;
 
-    assert(term->margins.left >= pad_x);
-    assert(term->margins.right >= pad_x);
-    assert(term->margins.top >= pad_y);
-    assert(term->margins.bottom >= pad_y);
+    xassert(term->margins.left >= pad_x);
+    xassert(term->margins.right >= pad_x);
+    xassert(term->margins.top >= pad_y);
+    xassert(term->margins.bottom >= pad_y);
 
     if (new_cols == old_cols && new_rows == old_rows) {
         LOG_DBG("grid layout unaffected; skipping reflow");
@@ -2786,7 +2786,7 @@ render_xcursor_update(struct seat *seat)
     if (!seat->mouse_focus)
         return;
 
-    assert(seat->pointer.xcursor != NULL);
+    xassert(seat->pointer.xcursor != NULL);
 
     if (seat->pointer.xcursor == XCURSOR_HIDDEN) {
         /* Hide cursor */
@@ -2819,7 +2819,7 @@ render_xcursor_update(struct seat *seat)
 
     wl_surface_set_buffer_scale(seat->pointer.surface, scale);
 
-    assert(seat->pointer.xcursor_callback == NULL);
+    xassert(seat->pointer.xcursor_callback == NULL);
     seat->pointer.xcursor_callback = wl_surface_frame(seat->pointer.surface);
     wl_callback_add_listener(seat->pointer.xcursor_callback, &xcursor_listener, seat);
 
@@ -2831,7 +2831,7 @@ xcursor_callback(void *data, struct wl_callback *wl_callback, uint32_t callback_
 {
     struct seat *seat = data;
 
-    assert(seat->pointer.xcursor_callback == wl_callback);
+    xassert(seat->pointer.xcursor_callback == wl_callback);
     wl_callback_destroy(wl_callback);
     seat->pointer.xcursor_callback = NULL;
 
diff --git a/search.c b/search.c
index 7d1ece7b..4d520ffc 100644
--- a/search.c
+++ b/search.c
@@ -52,7 +52,7 @@ ensure_view_is_allocated(struct terminal *term, int new_view)
 
 #if defined(_DEBUG)
     for (size_t r = 0; r < term->rows; r++)
-        assert(term->grid->rows[(new_view + r) & (term->grid->num_rows - 1)] != NULL);
+        xassert(term->grid->rows[(new_view + r) & (term->grid->num_rows - 1)] != NULL);
 #endif
 
     return new_view;
@@ -197,7 +197,7 @@ search_update_selection(struct terminal *term,
 #if defined(_DEBUG)
         /* Verify all to-be-visible rows have been allocated */
         for (int r = 0; r < term->rows; r++)
-            assert(term->grid->rows[(new_view + r) & (term->grid->num_rows - 1)] != NULL);
+            xassert(term->grid->rows[(new_view + r) & (term->grid->num_rows - 1)] != NULL);
 #endif
 
         /* Update view */
@@ -220,7 +220,7 @@ search_update_selection(struct terminal *term,
         while (selection_row < 0)
             selection_row += term->grid->num_rows;
 
-        assert(selection_row >= 0 &&
+        xassert(selection_row >= 0 &&
                selection_row < term->grid->num_rows);
         selection_start(
             term, start_col, selection_row, SELECTION_CHAR_WISE, false);
@@ -232,7 +232,7 @@ search_update_selection(struct terminal *term,
         while (selection_row < 0)
             selection_row += term->grid->num_rows;
 
-        assert(selection_row >= 0 &&
+        xassert(selection_row >= 0 &&
                selection_row < term->grid->num_rows);
         selection_update(term, end_col, selection_row);
     }
@@ -255,7 +255,7 @@ search_find_next(struct terminal *term)
     int start_col = term->search.match.col;
     size_t len = term->search.match_len;
 
-    assert((len == 0 && start_row == -1 && start_col == -1) ||
+    xassert((len == 0 && start_row == -1 && start_col == -1) ||
            (len > 0 && start_row >= 0 && start_col >= 0));
 
     if (len == 0) {
@@ -365,7 +365,7 @@ search_add_chars(struct terminal *term, const char *src, size_t count)
     if (!search_ensure_size(term, term->search.len + wchars))
         return;
 
-    assert(term->search.len + wchars < term->search.sz);
+    xassert(term->search.len + wchars < term->search.sz);
 
     memmove(&term->search.buf[term->search.cursor + wchars],
             &term->search.buf[term->search.cursor],
@@ -386,8 +386,8 @@ search_match_to_end_of_word(struct terminal *term, bool spaces_only)
     if (term->search.match_len == 0)
         return;
 
-    assert(term->search.match.row != -1);
-    assert(term->search.match.col != -1);
+    xassert(term->search.match.row != -1);
+    xassert(term->search.match.col != -1);
 
     int end_row = term->search.match.row;
     int end_col = term->search.match.col;
@@ -466,7 +466,7 @@ distance_next_word(const struct terminal *term)
             break;
     }
 
-    assert(cursor == term->search.len || iswspace(term->search.buf[cursor - 1]));
+    xassert(cursor == term->search.len || iswspace(term->search.buf[cursor - 1]));
 
     /* Now skip past whitespace, so that we end up at the beginning of
      * the next word */
@@ -475,7 +475,7 @@ distance_next_word(const struct terminal *term)
             break;
     }
 
-    assert(cursor == term->search.len || !iswspace(term->search.buf[cursor - 1]));
+    xassert(cursor == term->search.len || !iswspace(term->search.buf[cursor - 1]));
 
     if (cursor < term->search.len && !iswspace(term->search.buf[cursor]))
         cursor--;
@@ -494,7 +494,7 @@ distance_prev_word(const struct terminal *term)
             break;
     }
 
-    assert(cursor == 0 || !iswspace(term->search.buf[cursor]));
+    xassert(cursor == 0 || !iswspace(term->search.buf[cursor]));
 
     /* Now eat non-whitespace. This is the word we're skipping past */
     while (cursor > 0) {
@@ -502,7 +502,7 @@ distance_prev_word(const struct terminal *term)
             break;
     }
 
-    assert(cursor == 0 || iswspace(term->search.buf[cursor]));
+    xassert(cursor == 0 || iswspace(term->search.buf[cursor]));
     if (cursor > 0 && iswspace(term->search.buf[cursor]))
         cursor++;
 
@@ -593,7 +593,7 @@ execute_binding(struct seat *seat, struct terminal *term,
     case BIND_ACTION_SEARCH_EDIT_LEFT_WORD: {
         size_t diff = distance_prev_word(term);
         term->search.cursor -= diff;
-        assert(term->search.cursor <= term->search.len);
+        xassert(term->search.cursor <= term->search.len);
         return false;
     }
 
@@ -605,7 +605,7 @@ execute_binding(struct seat *seat, struct terminal *term,
     case BIND_ACTION_SEARCH_EDIT_RIGHT_WORD: {
         size_t diff = distance_next_word(term);
         term->search.cursor += diff;
-        assert(term->search.cursor <= term->search.len);
+        xassert(term->search.cursor <= term->search.len);
         return false;
     }
 
@@ -683,11 +683,11 @@ execute_binding(struct seat *seat, struct terminal *term,
         return false;
 
     case BIND_ACTION_SEARCH_COUNT:
-        assert(false);
+        xassert(false);
         return false;
     }
 
-    assert(false);
+    xassert(false);
     return false;
 }
 
diff --git a/selection.c b/selection.c
index 7422b095..966b6b2a 100644
--- a/selection.c
+++ b/selection.c
@@ -53,7 +53,7 @@ selection_on_rows(const struct terminal *term, int row_start, int row_end)
     if (term->selection.end.row < 0)
         return false;
 
-    assert(term->selection.start.row != -1);
+    xassert(term->selection.start.row != -1);
 
     row_start += term->grid->offset;
     row_end += term->grid->offset;
@@ -142,7 +142,7 @@ foreach_selected_normal(
     for (int r = start_row; r <= end_row; r++) {
         size_t real_r = r & (term->grid->num_rows - 1);
         struct row *row = term->grid->rows[real_r];
-        assert(row != NULL);
+        xassert(row != NULL);
 
         for (int c = start_col;
              c <= (r == end_row ? end_col : term->cols - 1);
@@ -178,7 +178,7 @@ foreach_selected_block(
     for (int r = top_left.row; r <= bottom_right.row; r++) {
         size_t real_r = r & (term->grid->num_rows - 1);
         struct row *row = term->grid->rows[real_r];
-        assert(row != NULL);
+        xassert(row != NULL);
 
         for (int c = top_left.col; c <= bottom_right.col; c++) {
             if (!cb(term, row, &row->cells[c], c, data))
@@ -205,11 +205,11 @@ foreach_selected(
         return;
 
     case SELECTION_NONE:
-        assert(false);
+        xassert(false);
         return;
     }
 
-    assert(false);
+    xassert(false);
 }
 
 static bool
@@ -246,7 +246,7 @@ find_word_boundary_left(struct terminal *term, struct coord *pos,
     wchar_t c = r->cells[pos->col].wc;
 
     while (c == CELL_MULT_COL_SPACER) {
-        assert(pos->col > 0);
+        xassert(pos->col > 0);
         if (pos->col == 0)
             return;
         pos->col--;
@@ -280,7 +280,7 @@ find_word_boundary_left(struct terminal *term, struct coord *pos,
 
         c = row->cells[next_col].wc;
         while (c == CELL_MULT_COL_SPACER) {
-            assert(next_col > 0);
+            xassert(next_col > 0);
             if (--next_col < 0)
                 return;
             c = row->cells[next_col].wc;
@@ -318,7 +318,7 @@ find_word_boundary_right(struct terminal *term, struct coord *pos,
     wchar_t c = r->cells[pos->col].wc;
 
     while (c == CELL_MULT_COL_SPACER) {
-        assert(pos->col > 0);
+        xassert(pos->col > 0);
         if (pos->col == 0)
             return;
         pos->col--;
@@ -436,7 +436,7 @@ selection_start(struct terminal *term, int col, int row,
         break;
 
     case SELECTION_NONE:
-        assert(false);
+        xassert(false);
         break;
     }
 
@@ -470,7 +470,7 @@ premark_selected(struct terminal *term, struct row *row, struct cell *cell,
                  int col, void *data)
 {
     struct mark_context *ctx = data;
-    assert(ctx != NULL);
+    xassert(ctx != NULL);
 
     if (ctx->last_row != row) {
         ctx->last_row = row;
@@ -494,7 +494,7 @@ mark_selected(struct terminal *term, struct row *row, struct cell *cell,
               int col, void *data)
 {
     struct mark_context *ctx = data;
-    assert(ctx != NULL);
+    xassert(ctx != NULL);
 
     if (ctx->last_row != row) {
         ctx->last_row = row;
@@ -523,9 +523,9 @@ mark_selected(struct terminal *term, struct row *row, struct cell *cell,
 static void
 selection_modify(struct terminal *term, struct coord start, struct coord end)
 {
-    assert(term->selection.start.row != -1);
-    assert(start.row != -1 && start.col != -1);
-    assert(end.row != -1 && end.col != -1);
+    xassert(term->selection.start.row != -1);
+    xassert(start.row != -1 && start.col != -1);
+    xassert(end.row != -1 && end.col != -1);
 
     struct mark_context ctx = {0};
 
@@ -569,7 +569,7 @@ set_pivot_point_for_block_and_char_wise(struct terminal *term,
             break;
 
         /* Multi-column chars don’t cross rows */
-        assert(pivot_start->col > 0);
+        xassert(pivot_start->col > 0);
         if (pivot_start->col == 0)
             break;
 
@@ -619,9 +619,9 @@ set_pivot_point_for_block_and_char_wise(struct terminal *term,
         }
     }
 
-    assert(term->grid->rows[pivot_start->row & (term->grid->num_rows - 1)]->
+    xassert(term->grid->rows[pivot_start->row & (term->grid->num_rows - 1)]->
            cells[pivot_start->col].wc != CELL_MULT_COL_SPACER);
-    assert(term->grid->rows[pivot_end->row & (term->grid->num_rows - 1)]->
+    xassert(term->grid->rows[pivot_end->row & (term->grid->num_rows - 1)]->
            cells[pivot_end->col].wc != CELL_MULT_COL_SPACER);
 }
 
@@ -639,7 +639,7 @@ selection_update(struct terminal *term, int col, int row)
             term->selection.end.row, term->selection.end.col,
             row, col);
 
-    assert(term->grid->view + row != -1);
+    xassert(term->grid->view + row != -1);
 
     struct coord new_start = term->selection.start;
     struct coord new_end = {col, term->grid->view + row};
@@ -686,7 +686,7 @@ selection_update(struct terminal *term, int col, int row)
                 }
 
                 if (new_direction == SELECTION_LEFT) {
-                    assert(pivot_end->row >= 0);
+                    xassert(pivot_end->row >= 0);
                     new_start = *pivot_end;
                 } else
                     new_start = *pivot_start;
@@ -738,7 +738,7 @@ selection_update(struct terminal *term, int col, int row)
         break;
 
     case SELECTION_NONE:
-        assert(false);
+        xassert(false);
         break;
     }
 
@@ -797,7 +797,7 @@ selection_extend_normal(struct terminal *term, int col, int row,
         end = tmp;
     }
 
-    assert(start->row < end->row || start->col < end->col);
+    xassert(start->row < end->row || start->col < end->col);
 
     struct coord new_start, new_end;
     enum selection_direction direction;
@@ -840,12 +840,12 @@ selection_extend_normal(struct terminal *term, int col, int row,
 
     switch (term->selection.kind) {
     case SELECTION_CHAR_WISE:
-        assert(new_kind == SELECTION_CHAR_WISE);
+        xassert(new_kind == SELECTION_CHAR_WISE);
         set_pivot_point_for_block_and_char_wise(term, new_start, direction);
         break;
 
     case SELECTION_WORD_WISE: {
-        assert(new_kind == SELECTION_CHAR_WISE ||
+        xassert(new_kind == SELECTION_CHAR_WISE ||
                new_kind == SELECTION_WORD_WISE);
 
         struct coord pivot_start = {new_start.col, new_start.row - term->grid->view};
@@ -862,7 +862,7 @@ selection_extend_normal(struct terminal *term, int col, int row,
     }
 
     case SELECTION_LINE_WISE:
-        assert(new_kind == SELECTION_CHAR_WISE ||
+        xassert(new_kind == SELECTION_CHAR_WISE ||
                new_kind == SELECTION_LINE_WISE);
 
         term->selection.pivot.start = (struct coord){0, new_start.row};
@@ -871,7 +871,7 @@ selection_extend_normal(struct terminal *term, int col, int row,
 
     case SELECTION_BLOCK:
     case SELECTION_NONE:
-        assert(false);
+        xassert(false);
         break;
     }
 
@@ -973,7 +973,7 @@ selection_extend(struct seat *seat, struct terminal *term,
 
     switch (term->selection.kind) {
     case SELECTION_NONE:
-        assert(false);
+        xassert(false);
         return;
 
     case SELECTION_CHAR_WISE:
@@ -1004,8 +1004,8 @@ selection_finalize(struct seat *seat, struct terminal *term, uint32_t serial)
     if (term->selection.start.row < 0 || term->selection.end.row < 0)
         return;
 
-    assert(term->selection.start.row != -1);
-    assert(term->selection.end.row != -1);
+    xassert(term->selection.start.row != -1);
+    xassert(term->selection.end.row != -1);
 
     if (term->selection.start.row > term->selection.end.row ||
         (term->selection.start.row == term->selection.end.row &&
@@ -1016,7 +1016,7 @@ selection_finalize(struct seat *seat, struct terminal *term, uint32_t serial)
         term->selection.end = tmp;
     }
 
-    assert(term->selection.start.row <= term->selection.end.row);
+    xassert(term->selection.start.row <= term->selection.end.row);
     selection_to_primary(seat, term, serial);
 }
 
@@ -1066,7 +1066,7 @@ selection_clipboard_unset(struct seat *seat)
         return;
 
     /* Kill previous data source */
-    assert(clipboard->serial != 0);
+    xassert(clipboard->serial != 0);
     wl_data_device_set_selection(seat->data_device, NULL, clipboard->serial);
     wl_data_source_destroy(clipboard->data_source);
 
@@ -1085,7 +1085,7 @@ selection_primary_unset(struct seat *seat)
     if (primary->data_source == NULL)
         return;
 
-    assert(primary->serial != 0);
+    xassert(primary->serial != 0);
     zwp_primary_selection_device_v1_set_selection(
         seat->primary_selection_device, NULL, primary->serial);
     zwp_primary_selection_source_v1_destroy(primary->data_source);
@@ -1141,7 +1141,7 @@ void
 selection_start_scroll_timer(struct terminal *term, int interval_ns,
                              enum selection_scroll_direction direction, int col)
 {
-    assert(direction != SELECTION_SCROLL_NOT);
+    xassert(direction != SELECTION_SCROLL_NOT);
 
     if (!term->selection.ongoing)
         return;
@@ -1191,7 +1191,7 @@ void
 selection_stop_scroll_timer(struct terminal *term)
 {
     if (term->selection.auto_scroll.fd < 0) {
-        assert(term->selection.auto_scroll.direction == SELECTION_SCROLL_NOT);
+        xassert(term->selection.auto_scroll.direction == SELECTION_SCROLL_NOT);
         return;
     }
 
@@ -1294,7 +1294,7 @@ send(void *data, struct wl_data_source *wl_data_source, const char *mime_type,
     struct seat *seat = data;
     const struct wl_clipboard *clipboard = &seat->clipboard;
 
-    assert(clipboard->text != NULL);
+    xassert(clipboard->text != NULL);
     send_clipboard_or_primary(seat, fd, clipboard->text, "clipboard");
 }
 
@@ -1303,7 +1303,7 @@ cancelled(void *data, struct wl_data_source *wl_data_source)
 {
     struct seat *seat = data;
     struct wl_clipboard *clipboard = &seat->clipboard;
-    assert(clipboard->data_source == wl_data_source);
+    xassert(clipboard->data_source == wl_data_source);
 
     wl_data_source_destroy(clipboard->data_source);
     clipboard->data_source = NULL;
@@ -1349,7 +1349,7 @@ primary_send(void *data,
     struct seat *seat = data;
     const struct wl_primary *primary = &seat->primary;
 
-    assert(primary->text != NULL);
+    xassert(primary->text != NULL);
     send_clipboard_or_primary(seat, fd, primary->text, "primary");
 }
 
@@ -1380,7 +1380,7 @@ text_to_clipboard(struct seat *seat, struct terminal *term, char *text, uint32_t
 
     if (clipboard->data_source != NULL) {
         /* Kill previous data source */
-        assert(clipboard->serial != 0);
+        xassert(clipboard->serial != 0);
         wl_data_device_set_selection(seat->data_device, NULL, clipboard->serial);
         wl_data_source_destroy(clipboard->data_source);
         free(clipboard->text);
@@ -1411,7 +1411,7 @@ text_to_clipboard(struct seat *seat, struct terminal *term, char *text, uint32_t
     wl_data_device_set_selection(seat->data_device, clipboard->data_source, serial);
 
     /* Needed when sending the selection to other client */
-    assert(serial != 0);
+    xassert(serial != 0);
     clipboard->serial = serial;
     return true;
 }
@@ -1467,7 +1467,7 @@ fdm_receive_timeout(struct fdm *fdm, int fd, int events, void *data)
     if (events & EPOLLHUP)
         return false;
 
-    assert(events & EPOLLIN);
+    xassert(events & EPOLLIN);
 
     uint64_t expire_count;
     ssize_t ret = read(fd, &expire_count, sizeof(expire_count));
@@ -1600,7 +1600,7 @@ fdm_receive(struct fdm *fdm, int fd, int events, void *data)
             if (p[i] == '\r' && p[i + 1] == '\n') {
                 ctx->decoder(ctx, p, i);
 
-                assert(i + 1 <= left);
+                xassert(i + 1 <= left);
                 p += i + 1;
                 left -= i + 1;
                 goto again;
@@ -1718,7 +1718,7 @@ static void
 receive_offer(char *data, size_t size, void *user)
 {
     struct terminal *term = user;
-    assert(term->is_sending_paste_data);
+    xassert(term->is_sending_paste_data);
     term_paste_data_to_slave(term, data, size);
 }
 static void
@@ -1768,7 +1768,7 @@ text_to_primary(struct seat *seat, struct terminal *term, char *text, uint32_t s
     if (seat->primary.data_source != NULL) {
         /* Kill previous data source */
 
-        assert(primary->serial != 0);
+        xassert(primary->serial != 0);
         zwp_primary_selection_device_v1_set_selection(
             seat->primary_selection_device, NULL, primary->serial);
         zwp_primary_selection_source_v1_destroy(primary->data_source);
@@ -2046,10 +2046,10 @@ enter(void *data, struct wl_data_device *wl_data_device, uint32_t serial,
     struct seat *seat = data;
     struct wayland *wayl = seat->wayl;
 
-    assert(offer == seat->clipboard.data_offer);
+    xassert(offer == seat->clipboard.data_offer);
 
     /* Remember _which_ terminal the current DnD offer is targeting */
-    assert(seat->clipboard.window == NULL);
+    xassert(seat->clipboard.window == NULL);
     tll_foreach(wayl->terms, it) {
         if (term_surface_kind(it->item, surface) == TERM_SURF_GRID &&
             !it->item->is_sending_paste_data)
@@ -2113,7 +2113,7 @@ drop(void *data, struct wl_data_device *wl_data_device)
 {
     struct seat *seat = data;
 
-    assert(seat->clipboard.window != NULL);
+    xassert(seat->clipboard.window != NULL);
     struct terminal *term = seat->clipboard.window->term;
 
     struct wl_clipboard *clipboard = &seat->clipboard;
@@ -2167,7 +2167,7 @@ selection(void *data, struct wl_data_device *wl_data_device,
     if (offer == NULL)
         data_offer_reset(&seat->clipboard);
     else
-        assert(offer == seat->clipboard.data_offer);
+        xassert(offer == seat->clipboard.data_offer);
 }
 
 const struct wl_data_device_listener data_device_listener = {
@@ -2227,7 +2227,7 @@ primary_selection(void *data,
     if (offer == NULL)
         primary_offer_reset(&seat->primary);
     else
-        assert(seat->primary.data_offer == offer);
+        xassert(seat->primary.data_offer == offer);
 }
 
 const struct zwp_primary_selection_device_v1_listener primary_selection_device_listener = {
diff --git a/server.c b/server.c
index e6c3aae3..c5db036d 100644
--- a/server.c
+++ b/server.c
@@ -123,7 +123,7 @@ fdm_client(struct fdm *fdm, int fd, int events, void *data)
     if (events & EPOLLHUP)
         goto shutdown;
 
-    assert(events & EPOLLIN);
+    xassert(events & EPOLLIN);
 
     if (client->term != NULL) {
         uint8_t dummy[128];
@@ -186,9 +186,9 @@ fdm_client(struct fdm *fdm, int fd, int events, void *data)
 
     /* All initialization data received - time to instantiate a terminal! */
 
-    assert(client->term == NULL);
-    assert(client->buffer.data != NULL);
-    assert(client->buffer.left == 0);
+    xassert(client->term == NULL);
+    xassert(client->buffer.data != NULL);
+    xassert(client->buffer.left == 0);
 
     /*
      * Parse the received buffer, verifying lengths etc
diff --git a/shm.c b/shm.c
index f5f94b62..2231f057 100644
--- a/shm.c
+++ b/shm.c
@@ -121,8 +121,8 @@ buffer_release(void *data, struct wl_buffer *wl_buffer)
 {
     struct buffer *buffer = data;
     LOG_DBG("release: cookie=%lx (buf=%p)", buffer->cookie, (void *)buffer);
-    assert(buffer->wl_buf == wl_buffer);
-    assert(buffer->busy);
+    xassert(buffer->wl_buf == wl_buffer);
+    xassert(buffer->busy);
     buffer->busy = false;
 }
 
@@ -143,17 +143,17 @@ page_size(void)
             size = (size_t)n;
         }
     }
-    assert(size > 0);
+    xassert(size > 0);
     return size;
 }
 
 static bool
 instantiate_offset(struct wl_shm *shm, struct buffer *buf, off_t new_offset)
 {
-    assert(buf->fd >= 0);
-    assert(buf->mmapped == NULL);
-    assert(buf->wl_buf == NULL);
-    assert(buf->pix == NULL);
+    xassert(buf->fd >= 0);
+    xassert(buf->mmapped == NULL);
+    xassert(buf->wl_buf == NULL);
+    xassert(buf->pix == NULL);
 
     void *mmapped = MAP_FAILED;
     struct wl_buffer *wl_buf = NULL;
@@ -211,7 +211,7 @@ shm_get_buffer(struct wl_shm *shm, int width, int height, unsigned long cookie,
         if (!it->item.purge)
             continue;
 
-        assert(!it->item.busy);
+        xassert(!it->item.busy);
 
         LOG_DBG("cookie=%lx: purging buffer %p (width=%d, height=%d): %zu KB",
                 cookie, (void *)&it->item, it->item.width, it->item.height,
@@ -234,7 +234,7 @@ shm_get_buffer(struct wl_shm *shm, int width, int height, unsigned long cookie,
                     cookie, (void *)&it->item);
             it->item.busy = true;
             it->item.purge = false;
-            assert(it->item.pix_instances == pix_instances);
+            xassert(it->item.pix_instances == pix_instances);
             return &it->item;
         }
     }
@@ -414,7 +414,7 @@ wrap_buffer(struct wl_shm *shm, struct buffer *buf, off_t new_offset)
     /* We don't allow overlapping offsets */
     off_t UNUSED diff =
         new_offset < buf->offset ? buf->offset - new_offset : new_offset - buf->offset;
-    assert(diff > buf->size);
+    xassert(diff > buf->size);
 
     memcpy((uint8_t *)buf->real_mmapped + new_offset, buf->mmapped, buf->size);
 
@@ -448,17 +448,17 @@ shm_scroll_forward(struct wl_shm *shm, struct buffer *buf, int rows,
                    int top_margin, int top_keep_rows,
                    int bottom_margin, int bottom_keep_rows)
 {
-    assert(can_punch_hole);
-    assert(buf->busy);
-    assert(buf->pix);
-    assert(buf->wl_buf);
-    assert(buf->fd >= 0);
+    xassert(can_punch_hole);
+    xassert(buf->busy);
+    xassert(buf->pix);
+    xassert(buf->wl_buf);
+    xassert(buf->fd >= 0);
 
     LOG_DBG("scrolling %d rows (%d bytes)", rows, rows * buf->stride);
 
     const off_t diff = rows * buf->stride;
-    assert(rows > 0);
-    assert(diff < buf->size);
+    xassert(rows > 0);
+    xassert(diff < buf->size);
 
     if (buf->offset + diff + buf->size > max_pool_size) {
         LOG_DBG("memfd offset wrap around");
@@ -467,8 +467,8 @@ shm_scroll_forward(struct wl_shm *shm, struct buffer *buf, int rows,
     }
 
     off_t new_offset = buf->offset + diff;
-    assert(new_offset > buf->offset);
-    assert(new_offset + buf->size <= max_pool_size);
+    xassert(new_offset > buf->offset);
+    xassert(new_offset + buf->size <= max_pool_size);
 
 #if TIME_SCROLL
     struct timeval time1;
@@ -552,7 +552,7 @@ shm_scroll_reverse(struct wl_shm *shm, struct buffer *buf, int rows,
                    int top_margin, int top_keep_rows,
                    int bottom_margin, int bottom_keep_rows)
 {
-    assert(rows > 0);
+    xassert(rows > 0);
 
     const off_t diff = rows * buf->stride;
     if (diff > buf->offset) {
@@ -562,8 +562,8 @@ shm_scroll_reverse(struct wl_shm *shm, struct buffer *buf, int rows,
     }
 
     off_t new_offset = buf->offset - diff;
-    assert(new_offset < buf->offset);
-    assert(new_offset <= max_pool_size);
+    xassert(new_offset < buf->offset);
+    xassert(new_offset <= max_pool_size);
 
 #if TIME_SCROLL
     struct timeval time0;
@@ -649,7 +649,7 @@ shm_scroll(struct wl_shm *shm, struct buffer *buf, int rows,
     if (!shm_can_scroll(buf))
         return false;
 
-    assert(rows != 0);
+    xassert(rows != 0);
     return rows > 0
         ? shm_scroll_forward(shm, buf, rows, top_margin, top_keep_rows, bottom_margin, bottom_keep_rows)
         : shm_scroll_reverse(shm, buf, -rows, top_margin, top_keep_rows, bottom_margin, bottom_keep_rows);
@@ -665,7 +665,7 @@ shm_purge(struct wl_shm *shm, unsigned long cookie)
         if (it->item.cookie != cookie)
             continue;
 
-        assert(!it->item.busy);
+        xassert(!it->item.busy);
 
         buffer_destroy(&it->item);
         tll_remove(buffers, it);
diff --git a/sixel.c b/sixel.c
index 261446f5..4a71f9ee 100644
--- a/sixel.c
+++ b/sixel.c
@@ -31,8 +31,8 @@ color_with_alpha(const struct terminal *term, uint32_t color)
 void
 sixel_init(struct terminal *term)
 {
-    assert(term->sixel.image.data == NULL);
-    assert(term->sixel.palette_size <= SIXEL_MAX_COLORS);
+    xassert(term->sixel.image.data == NULL);
+    xassert(term->sixel.palette_size <= SIXEL_MAX_COLORS);
 
     term->sixel.state = SIXEL_DECSIXEL;
     term->sixel.pos = (struct coord){0, 0};
@@ -142,13 +142,13 @@ verify_list_order(const struct terminal *term)
         int col = it->item.pos.col;
         int col_count = it->item.cols;
 
-        assert(row <= prev_row);
+        xassert(row <= prev_row);
 
         if (row == prev_row) {
             /* Allowed to be on the same row only if their columns
              * don't overlap */
 
-            assert(col + col_count <= prev_col ||
+            xassert(col + col_count <= prev_col ||
                    prev_col + prev_col_count <= col);
         }
 
@@ -172,11 +172,11 @@ verify_no_wraparound_crossover(const struct terminal *term)
     tll_foreach(term->grid->sixel_images, it) {
         const struct sixel *six = &it->item;
 
-        assert(six->pos.row >= 0);
-        assert(six->pos.row < term->grid->num_rows);
+        xassert(six->pos.row >= 0);
+        xassert(six->pos.row < term->grid->num_rows);
 
         int end = (six->pos.row + six->rows - 1) & (term->grid->num_rows - 1);
-        assert(end >= six->pos.row);
+        xassert(end >= six->pos.row);
     }
 #endif
 }
@@ -198,7 +198,7 @@ verify_scrollback_consistency(const struct terminal *term)
             int row_no = rebase_row(term, six->pos.row + i);
 
             if (last_row != -1)
-                assert(last_row < row_no);
+                xassert(last_row < row_no);
 
             last_row = row_no;
         }
@@ -235,7 +235,7 @@ verify_no_overlap(const struct terminal *term)
             pixman_region32_init(&intersection);
             pixman_region32_intersect(&intersection, &rect1, &rect2);
 
-            assert(!pixman_region32_not_empty(&intersection));
+            xassert(!pixman_region32_not_empty(&intersection));
 
             pixman_region32_fini(&intersection);
             pixman_region32_fini(&rect2);
@@ -315,7 +315,7 @@ sixel_scroll_down(struct terminal *term, int rows)
     if (likely(tll_length(term->grid->sixel_images) == 0))
         return;
 
-    assert(term->grid->num_rows >= rows);
+    xassert(term->grid->num_rows >= rows);
 
     tll_foreach(term->grid->sixel_images, it) {
         struct sixel *six = &it->item;
@@ -351,7 +351,7 @@ sixel_overwrite(struct terminal *term, struct sixel *six,
     pixman_region32_t intersection;
     pixman_region32_init(&intersection);
     pixman_region32_intersect(&intersection, &six_rect, &overwrite_rect);
-    assert(pixman_region32_not_empty(&intersection));
+    xassert(pixman_region32_not_empty(&intersection));
     pixman_region32_fini(&intersection);
 #endif
 
@@ -369,14 +369,14 @@ sixel_overwrite(struct terminal *term, struct sixel *six,
         LOG_DBG("box #%d: x1=%d, y1=%d, x2=%d, y2=%d", i,
                 boxes[i].x1, boxes[i].y1, boxes[i].x2, boxes[i].y2);
 
-        assert(boxes[i].x1 % term->cell_width == 0);
-        assert(boxes[i].y1 % term->cell_height == 0);
+        xassert(boxes[i].x1 % term->cell_width == 0);
+        xassert(boxes[i].y1 % term->cell_height == 0);
 
         /* New image's position, in cells */
         const int new_col = boxes[i].x1 / term->cell_width;
         const int new_row = boxes[i].y1 / term->cell_height;
 
-        assert(new_row < term->grid->num_rows);
+        xassert(new_row < term->grid->num_rows);
 
         /* New image's width and height, in pixels */
         const int new_width = boxes[i].x2 - boxes[i].x1;
@@ -414,7 +414,7 @@ sixel_overwrite(struct terminal *term, struct sixel *six,
 #if defined(_DEBUG)
         /* Assert we don't cross the scrollback wrap-around */
         const int new_end = new_six.pos.row + new_six.rows - 1;
-        assert(new_end < term->grid->num_rows);
+        xassert(new_end < term->grid->num_rows);
 #endif
 
         sixel_insert(term, new_six);
@@ -439,7 +439,7 @@ _sixel_overwrite_by_rectangle(
     const int end = row + height - 1;
 
     /* We should never generate scrollback wrapping sixels */
-    assert(end < term->grid->num_rows);
+    xassert(end < term->grid->num_rows);
 
     const int scrollback_rel_start = rebase_row(term, start);
 
@@ -453,7 +453,7 @@ _sixel_overwrite_by_rectangle(
         const int six_scrollback_rel_end = rebase_row(term, six_end);
 
         /* We should never generate scrollback wrapping sixels */
-        assert(six_end < term->grid->num_rows);
+        xassert(six_end < term->grid->num_rows);
 
         if (six_scrollback_rel_end < scrollback_rel_start) {
             /* All remaining sixels are *before* our rectangle */
@@ -485,7 +485,7 @@ _sixel_overwrite_by_rectangle(
                 (col <= col_end && col + width - 1 >= col_end) ||
                 (col >= col_start && col + width - 1 <= col_end))
             {
-                assert(!would_have_breaked);
+                xassert(!would_have_breaked);
 
                 struct sixel to_be_erased = *six;
                 tll_remove(term->grid->sixel_images, it);
@@ -493,9 +493,9 @@ _sixel_overwrite_by_rectangle(
                 sixel_overwrite(term, &to_be_erased, start, col, height, width);
                 sixel_erase(term, &to_be_erased);
             } else
-                assert(!collides);
+                xassert(!collides);
         } else
-            assert(!collides);
+            xassert(!collides);
 
 #if defined(_DEBUG)
         pixman_region32_fini(&intersection);
@@ -521,7 +521,7 @@ sixel_overwrite_by_rectangle(
 
     if (wraps) {
         int rows_to_wrap_around = term->grid->num_rows - start;
-        assert(height - rows_to_wrap_around > 0);
+        xassert(height - rows_to_wrap_around > 0);
         _sixel_overwrite_by_rectangle(term, start, col, rows_to_wrap_around, width);
         _sixel_overwrite_by_rectangle(term, 0, col, height - rows_to_wrap_around, width);
     } else
@@ -532,12 +532,12 @@ sixel_overwrite_by_rectangle(
 void
 sixel_overwrite_by_row(struct terminal *term, int _row, int col, int width)
 {
-    assert(col >= 0);
+    xassert(col >= 0);
 
-    assert(_row >= 0);
-    assert(_row < term->rows);
-    assert(col >= 0);
-    assert(col < term->grid->num_cols);
+    xassert(_row >= 0);
+    xassert(_row < term->rows);
+    xassert(col >= 0);
+    xassert(col < term->grid->num_cols);
 
     if (likely(tll_length(term->grid->sixel_images) == 0))
         return;
@@ -554,7 +554,7 @@ sixel_overwrite_by_row(struct terminal *term, int _row, int col, int width)
         const int six_end = (six_start + six->rows - 1) & (term->grid->num_rows - 1);
 
         /* We should never generate scrollback wrapping sixels */
-        assert(six_end >= six_start);
+        xassert(six_end >= six_start);
 
         const int six_scrollback_rel_end = rebase_row(term, six_end);
 
@@ -731,8 +731,8 @@ sixel_unhook(struct terminal *term)
             .pos = (struct coord){start_col, cur_row},
         };
 
-        assert(image.rows < term->grid->num_rows);
-        assert(image.pos.row + image.rows - 1 < term->grid->num_rows);
+        xassert(image.rows < term->grid->num_rows);
+        xassert(image.pos.row + image.rows - 1 < term->grid->num_rows);
 
         LOG_DBG("generating %dx%d pixman image at %d-%d",
                 image.width, image.height,
@@ -796,8 +796,8 @@ resize(struct terminal *term, int new_width, int new_height)
 
     int alloc_new_width = new_width;
     int alloc_new_height = (new_height + 6 - 1) / 6 * 6;
-    assert(alloc_new_height >= new_height);
-    assert(alloc_new_height - new_height < 6);
+    xassert(alloc_new_height >= new_height);
+    xassert(alloc_new_height - new_height < 6);
 
     uint32_t *new_data = NULL;
 
@@ -811,11 +811,11 @@ resize(struct terminal *term, int new_width, int new_height)
             return false;
         }
 
-        assert(new_height > old_height);
+        xassert(new_height > old_height);
 
     } else {
         /* Width (and thus stride) change - need to allocate a new buffer */
-        assert(new_width > old_width);
+        xassert(new_width > old_width);
         new_data = xmalloc(alloc_new_width * alloc_new_height * sizeof(uint32_t));
 
         /* Copy old rows, and initialize new columns to background color */
@@ -834,7 +834,7 @@ resize(struct terminal *term, int new_width, int new_height)
             new_data[r * new_width + c] = color_with_alpha(term, term->colors.bg);
     }
 
-    assert(new_data != NULL);
+    xassert(new_data != NULL);
     term->sixel.image.data = new_data;
     term->sixel.image.width = new_width;
     term->sixel.image.height = new_height;
@@ -877,7 +877,7 @@ sixel_add(struct terminal *term, uint32_t color, uint8_t sixel)
         }
     }
 
-    assert(sixel == 0);
+    xassert(sixel == 0);
     term->sixel.pos.col++;
 }
 
diff --git a/slave.c b/slave.c
index 01c81b28..79008e5d 100644
--- a/slave.c
+++ b/slave.c
@@ -90,7 +90,7 @@ emit_one_notification(int fd, const struct user_notification *notif)
         break;
     }
 
-    assert(prefix != NULL);
+    xassert(prefix != NULL);
 
     if (write(fd, prefix, strlen(prefix)) < 0 ||
         write(fd, notif->text, strlen(notif->text)) < 0 ||
@@ -314,7 +314,7 @@ slave_spawn(int ptmx, int argc, const char *cwd, char *const *argv,
             setenv("SHELL", shell_argv[0], 1);
 
         slave_exec(ptmx, shell_argv, fork_pipe[1], login_shell, notifications);
-        assert(false);
+        xassert(false);
         break;
 
     default: {
diff --git a/spawn.c b/spawn.c
index e0d95985..fbcf0952 100644
--- a/spawn.c
+++ b/spawn.c
@@ -41,7 +41,7 @@ spawn(struct reaper *reaper, const char *cwd, char *const argv[],
             (void)!write(pipe_fds[1], &errno, sizeof(errno));
             _exit(errno);
         }
-        assert(false);
+        xassert(false);
         _exit(errno);
     }
 
diff --git a/terminal.c b/terminal.c
index 0fe55a60..312da6dd 100644
--- a/terminal.c
+++ b/terminal.c
@@ -94,14 +94,14 @@ data_to_slave(struct terminal *term, const void *data, size_t len,
     }
 
     /* Shouldn't get here */
-    assert(false);
+    xassert(false);
     return false;
 }
 
 bool
 term_paste_data_to_slave(struct terminal *term, const void *data, size_t len)
 {
-    assert(term->is_sending_paste_data);
+    xassert(term->is_sending_paste_data);
 
     if (term->ptmx < 0) {
         /* We're probably in "hold" */
@@ -150,7 +150,7 @@ fdm_ptmx_out(struct fdm *fdm, int fd, int events, void *data)
     struct terminal *term = data;
 
     /* If there is no queued data, then we shouldn't be in asynchronous mode */
-    assert(tll_length(term->ptmx_buffers) > 0 ||
+    xassert(tll_length(term->ptmx_buffers) > 0 ||
            tll_length(term->ptmx_paste_buffers) > 0);
 
     /* Writes a single buffer, returns if not all of it could be written */
@@ -230,7 +230,7 @@ fdm_ptmx(struct fdm *fdm, int fd, int events, void *data)
     const size_t max_iterations = 10;
 
     for (size_t i = 0; i < max_iterations && pollin && count == sizeof(buf); i++) {
-        assert(pollin);
+        xassert(pollin);
         count = read(term->ptmx, buf, sizeof(buf));
 
         if (count < 0) {
@@ -291,9 +291,9 @@ fdm_ptmx(struct fdm *fdm, int fd, int events, void *data)
             last = now;
 #endif
 
-            assert(lower_ns < 1000000000);
-            assert(upper_ns < 1000000000);
-            assert(upper_ns > lower_ns);
+            xassert(lower_ns < 1000000000);
+            xassert(upper_ns < 1000000000);
+            xassert(upper_ns > lower_ns);
 
             timerfd_settime(
                 term->delayed_render_timer.lower_fd, 0,
@@ -621,7 +621,7 @@ static bool
 term_set_fonts(struct terminal *term, struct fcft_font *fonts[static 4])
 {
     for (size_t i = 0; i < 4; i++) {
-        assert(fonts[i] != NULL);
+        xassert(fonts[i] != NULL);
 
         fcft_destroy(term->fonts[i]);
         term->fonts[i] = fonts[i];
@@ -710,7 +710,7 @@ get_font_dpi(const struct terminal *term)
 
     /* Use highest DPI from outputs we're mapped on */
     double dpi = 0.0;
-    assert(term->window != NULL);
+    xassert(term->window != NULL);
     tll_foreach(term->window->on_outputs, it) {
         if (it->item->dpi > dpi)
             dpi = it->item->dpi;
@@ -738,7 +738,7 @@ get_font_scale(const struct terminal *term)
     /* Same as get_font_dpi(), but returns output scale factor instead */
     int scale = 0;
 
-    assert(term->window != NULL);
+    xassert(term->window != NULL);
     tll_foreach(term->window->on_outputs, it) {
         if (it->item->scale > scale)
             scale = it->item->scale;
@@ -1267,7 +1267,7 @@ term_window_configured(struct terminal *term)
 {
     /* Enable ptmx FDM callback */
     if (!term->is_shutting_down) {
-        assert(term->window->is_configured);
+        xassert(term->window->is_configured);
         fdm_add(term->fdm, term->ptmx, EPOLLIN, &fdm_ptmx, term);
     }
 }
@@ -1325,7 +1325,7 @@ term_shutdown(struct terminal *term)
      */
 
     term_cursor_blink_update(term);
-    assert(term->cursor_blink.fd < 0);
+    xassert(term->cursor_blink.fd < 0);
 
     fdm_del(term->fdm, term->selection.auto_scroll.fd);
     fdm_del(term->fdm, term->render.app_sync_updates.timer_fd);
@@ -1405,7 +1405,7 @@ term_destroy(struct terminal *term)
         wayl_win_destroy(term->window);
 
     mtx_lock(&term->render.workers.lock);
-    assert(tll_length(term->render.workers.queue) == 0);
+    xassert(tll_length(term->render.workers.queue) == 0);
 
     /* Count livinig threads - we may get here when only some of the
      * threads have been successfully started */
@@ -1463,7 +1463,7 @@ term_destroy(struct terminal *term)
     mtx_destroy(&term->render.workers.lock);
     sem_destroy(&term->render.workers.start);
     sem_destroy(&term->render.workers.done);
-    assert(tll_length(term->render.workers.queue) == 0);
+    xassert(tll_length(term->render.workers.queue) == 0);
     tll_free(term->render.workers.queue);
 
     tll_foreach(term->ptmx_buffers, it)
@@ -1522,7 +1522,7 @@ term_destroy(struct terminal *term)
                 break;
 
             if (r == -1) {
-                assert(errno == EINTR);
+                xassert(errno == EINTR);
 
                 if (alarm_raised) {
                     LOG_DBG("slave hasn't died yet, sending: %s (%d)",
@@ -1570,8 +1570,8 @@ term_destroy(struct terminal *term)
 static inline void
 erase_cell_range(struct terminal *term, struct row *row, int start, int end)
 {
-    assert(start < term->cols);
-    assert(end < term->cols);
+    xassert(start < term->cols);
+    xassert(end < term->cols);
 
     row->dirty = true;
 
@@ -1807,7 +1807,7 @@ term_font_subpixel_changed(struct terminal *term)
 void
 term_damage_rows(struct terminal *term, int start, int end)
 {
-    assert(start <= end);
+    xassert(start <= end);
     for (int r = start; r <= end; r++) {
         struct row *row = grid_row(term->grid, r);
         row->dirty = true;
@@ -1819,7 +1819,7 @@ term_damage_rows(struct terminal *term, int start, int end)
 void
 term_damage_rows_in_view(struct terminal *term, int start, int end)
 {
-    assert(start <= end);
+    xassert(start <= end);
     for (int r = start; r <= end; r++) {
         struct row *row = grid_row_in_view(term->grid, r);
         row->dirty = true;
@@ -1879,8 +1879,8 @@ term_damage_scroll(struct terminal *term, enum damage_type damage_type,
 void
 term_erase(struct terminal *term, const struct coord *start, const struct coord *end)
 {
-    assert(start->row <= end->row);
-    assert(start->col <= end->col || start->row < end->row);
+    xassert(start->row <= end->row);
+    xassert(start->col <= end->col || start->row < end->row);
 
     if (start->row == end->row) {
         struct row *row = grid_row(term->grid, start->row);
@@ -1889,7 +1889,7 @@ term_erase(struct terminal *term, const struct coord *start, const struct coord
         return;
     }
 
-    assert(end->row > start->row);
+    xassert(end->row > start->row);
 
     erase_cell_range(
         term, grid_row(term->grid, start->row), start->col, term->cols - 1);
@@ -1915,15 +1915,15 @@ term_row_rel_to_abs(const struct terminal *term, int row)
         return min(row + term->scroll_region.start, term->scroll_region.end - 1);
     }
 
-    assert(false);
+    xassert(false);
     return -1;
 }
 
 void
 term_cursor_to(struct terminal *term, int row, int col)
 {
-    assert(row < term->rows);
-    assert(col < term->cols);
+    xassert(row < term->rows);
+    xassert(col < term->cols);
 
     term->grid->cursor.lcf = false;
 
@@ -1942,7 +1942,7 @@ term_cursor_home(struct terminal *term)
 void
 term_cursor_left(struct terminal *term, int count)
 {
-    assert(count >= 0);
+    xassert(count >= 0);
     int new_col = term->grid->cursor.point.col - count;
 
     /* Reverse wrap */
@@ -1957,7 +1957,7 @@ term_cursor_left(struct terminal *term, int count)
 
             /* New column number */
             new_col = term->cols - ((abs(new_col) - 1) % term->cols + 1);
-            assert(new_col >= 0 && new_col < term->cols);
+            xassert(new_col >= 0 && new_col < term->cols);
 
             /* Don't back up past the scroll region */
             /* TODO: should this be allowed? */
@@ -1978,7 +1978,7 @@ term_cursor_left(struct terminal *term, int count)
         new_col = 0;
     }
 
-    assert(new_col >= 0);
+    xassert(new_col >= 0);
     term->grid->cursor.point.col = new_col;
     term->grid->cursor.lcf = false;
 }
@@ -1988,7 +1988,7 @@ term_cursor_right(struct terminal *term, int count)
 {
     int move_amount = min(term->cols - term->grid->cursor.point.col - 1, count);
     term->grid->cursor.point.col += move_amount;
-    assert(term->grid->cursor.point.col < term->cols);
+    xassert(term->grid->cursor.point.col < term->cols);
     term->grid->cursor.lcf = false;
 }
 
@@ -1996,7 +1996,7 @@ void
 term_cursor_up(struct terminal *term, int count)
 {
     int top = term->origin == ORIGIN_ABSOLUTE ? 0 : term->scroll_region.start;
-    assert(term->grid->cursor.point.row >= top);
+    xassert(term->grid->cursor.point.row >= top);
 
     int move_amount = min(term->grid->cursor.point.row - top, count);
     term_cursor_to(term, term->grid->cursor.point.row - move_amount, term->grid->cursor.point.col);
@@ -2006,7 +2006,7 @@ void
 term_cursor_down(struct terminal *term, int count)
 {
     int bottom = term->origin == ORIGIN_ABSOLUTE ? term->rows : term->scroll_region.end;
-    assert(bottom >= term->grid->cursor.point.row);
+    xassert(bottom >= term->grid->cursor.point.row);
 
     int move_amount = min(bottom - term->grid->cursor.point.row - 1, count);
     term_cursor_to(term, term->grid->cursor.point.row + move_amount, term->grid->cursor.point.col);
@@ -2094,7 +2094,7 @@ term_scroll_partial(struct terminal *term, struct scroll_region region, int rows
             rows, region.start, region.end);
 
     /* Verify scroll amount has been clamped */
-    assert(rows <= region.end - region.start);
+    xassert(rows <= region.end - region.start);
 
     /* Cancel selections that cannot be scrolled */
     if (unlikely(term->selection.end.row >= 0)) {
@@ -2139,7 +2139,7 @@ term_scroll_partial(struct terminal *term, struct scroll_region region, int rows
 
 #if defined(_DEBUG)
     for (int r = 0; r < term->rows; r++)
-        assert(grid_row(term->grid, r) != NULL);
+        xassert(grid_row(term->grid, r) != NULL);
 #endif
 }
 
@@ -2157,7 +2157,7 @@ term_scroll_reverse_partial(struct terminal *term,
             rows, region.start, region.end);
 
     /* Verify scroll amount has been clamped */
-    assert(rows <= region.end - region.start);
+    xassert(rows <= region.end - region.start);
 
     /* Cancel selections that cannot be scrolled */
     if (unlikely(term->selection.end.row >= 0)) {
@@ -2182,8 +2182,8 @@ term_scroll_reverse_partial(struct terminal *term,
         term->grid->offset += term->grid->num_rows;
     term->grid->offset &= term->grid->num_rows - 1;
 
-    assert(term->grid->offset >= 0);
-    assert(term->grid->offset < term->grid->num_rows);
+    xassert(term->grid->offset >= 0);
+    xassert(term->grid->offset < term->grid->num_rows);
 
     if (view_follows) {
         selection_view_up(term, term->grid->offset);
@@ -2207,7 +2207,7 @@ term_scroll_reverse_partial(struct terminal *term,
 
 #if defined(_DEBUG)
     for (int r = 0; r < term->rows; r++)
-        assert(grid_row(term->grid, r) != NULL);
+        xassert(grid_row(term->grid, r) != NULL);
 #endif
 }
 
@@ -2470,7 +2470,7 @@ term_mouse_down(struct terminal *term, int button, int row, int col,
 
     case MOUSE_X10:
         /* Never enabled */
-        assert(false && "unimplemented");
+        xassert(false && "unimplemented");
         break;
     }
 }
@@ -2512,7 +2512,7 @@ term_mouse_up(struct terminal *term, int button, int row, int col,
 
     case MOUSE_X10:
         /* Never enabled */
-        assert(false && "unimplemented");
+        xassert(false && "unimplemented");
         break;
     }
 }
@@ -2559,7 +2559,7 @@ term_mouse_motion(struct terminal *term, int button, int row, int col,
 
     case MOUSE_X10:
         /* Never enabled */
-        assert(false && "unimplemented");
+        xassert(false && "unimplemented");
         break;
     }
 }
@@ -2720,7 +2720,7 @@ print_insert(struct terminal *term, int width)
     if (likely(!term->insert_mode))
         return;
 
-    assert(width > 0);
+    xassert(width > 0);
 
     struct row *row = term->grid->cur_row;
     const size_t move_count = max(0, term->cols - term->grid->cursor.point.col - width);
@@ -2749,7 +2749,7 @@ print_spacer(struct terminal *term, int col)
 void
 term_print(struct terminal *term, wchar_t wc, int width)
 {
-    assert(width > 0);
+    xassert(width > 0);
 
     print_linewrap(term);
     print_insert(term, width);
@@ -2788,7 +2788,7 @@ term_print(struct terminal *term, wchar_t wc, int width)
     /* Advance cursor */
     if (term->grid->cursor.point.col < term->cols - 1) {
         term->grid->cursor.point.col++;
-        assert(!term->grid->cursor.lcf);
+        xassert(!term->grid->cursor.lcf);
     } else
         term->grid->cursor.lcf = true;
 }
@@ -2837,7 +2837,7 @@ rows_to_text(const struct terminal *term, int start, int end,
          r = (r + 1) & (term->grid->num_rows - 1))
     {
         const struct row *row = term->grid->rows[r];
-        assert(row != NULL);
+        xassert(row != NULL);
 
         for (int c = 0; c < term->cols; c++)
             if (!extract_one(term, row, &row->cells[c], c, ctx))
diff --git a/vt.c b/vt.c
index ca69b77c..d1a83da2 100644
--- a/vt.c
+++ b/vt.c
@@ -89,7 +89,7 @@ esc_as_string(struct terminal *term, uint8_t final)
         c += snprintf(&msg[c], sizeof(msg) - c, "%c", value);
     }
 
-    assert(term->vt.params.idx == 0);
+    xassert(term->vt.params.idx == 0);
 
     snprintf(&msg[c], sizeof(msg) - c, "%c", final);
     return msg;
@@ -156,7 +156,7 @@ action_execute(struct terminal *term, uint8_t c)
                 break;
             }
         }
-        assert(new_col >= term->grid->cursor.point.col);
+        xassert(new_col >= term->grid->cursor.point.col);
 
         /* According to the specification, HT _should_ cancel LCF. But
          * XTerm, and nearly all other emulators, don't. So we follow
@@ -238,7 +238,7 @@ action_print(struct terminal *term, uint8_t c)
         L'│', L'≤', L'≥', L'π', L'≠', L'£', L'·',       /* x - ~ */
     };
 
-    assert(wcwidth(c) == 1);
+    xassert(wcwidth(c) == 1);
 
     if (unlikely(term->charsets.set[term->charsets.selected] == CHARSET_GRAPHIC) &&
         c >= 0x60 && c <= 0x7e)
@@ -259,7 +259,7 @@ action_param(struct terminal *term, uint8_t c)
         term->vt.params.idx = 1;
     }
 
-    assert(term->vt.params.idx > 0);
+    xassert(term->vt.params.idx > 0);
 
     const size_t max_params
         = sizeof(term->vt.params.v) / sizeof(term->vt.params.v[0]);
@@ -309,9 +309,9 @@ action_param(struct terminal *term, uint8_t c)
 
 #if defined(_DEBUG)
     /* The rest of the code assumes 'idx' *never* points outside the array */
-    assert(term->vt.params.idx <= max_params);
+    xassert(term->vt.params.idx <= max_params);
     for (size_t i = 0; i < term->vt.params.idx; i++)
-        assert(term->vt.params.v[i].sub.idx <= max_sub_params);
+        xassert(term->vt.params.v[i].sub.idx <= max_sub_params);
 #endif
 
     return;
@@ -453,7 +453,7 @@ action_esc_dispatch(struct terminal *term, uint8_t final)
                 ')' ? 1 :
                 '*' ? 2 :
                 '+' ? 3 : -1;
-            assert(idx != -1);
+            xassert(idx != -1);
             term->charsets.set[idx] = CHARSET_GRAPHIC;
             break;
         }
@@ -465,7 +465,7 @@ action_esc_dispatch(struct terminal *term, uint8_t final)
                 ')' ? 1 :
                 '*' ? 2 :
                 '+' ? 3 : -1;
-            assert(idx != -1);
+            xassert(idx != -1);
             term->charsets.set[idx] = CHARSET_ASCII;
 
             break;
@@ -570,7 +570,7 @@ action_utf8_print(struct terminal *term, wchar_t wc)
         while (row->cells[base_col].wc == CELL_MULT_COL_SPACER && base_col > 0)
             base_col--;
 
-        assert(base_col >= 0 && base_col < term->cols);
+        xassert(base_col >= 0 && base_col < term->cols);
         wchar_t base = row->cells[base_col].wc;
 
         const struct composed *composed =
@@ -632,7 +632,7 @@ action_utf8_print(struct terminal *term, wchar_t wc)
 
             size_t wanted_count = composed != NULL ? composed->count + 1 : 1;
             if (wanted_count > ALEN(composed->combining)) {
-                assert(composed != NULL);
+                xassert(composed != NULL);
 
 #if defined(LOG_ENABLE_DBG) && LOG_ENABLE_DBG
                 LOG_WARN("combining character overflow:");
@@ -645,7 +645,7 @@ action_utf8_print(struct terminal *term, wchar_t wc)
                 wanted_count--;
             }
 
-            assert(wanted_count <= ALEN(composed->combining));
+            xassert(wanted_count <= ALEN(composed->combining));
 
             /* Look for existing combining chain */
             for (size_t i = 0; i < term->composed_count; i++) {
diff --git a/wayland.c b/wayland.c
index cf6f563b..7985a90c 100644
--- a/wayland.c
+++ b/wayland.c
@@ -37,11 +37,11 @@ static void
 csd_instantiate(struct wl_window *win)
 {
     struct wayland *wayl = win->term->wl;
-    assert(wayl != NULL);
+    xassert(wayl != NULL);
 
     for (size_t i = 0; i < ALEN(win->csd.surface); i++) {
-        assert(win->csd.surface[i] == NULL);
-        assert(win->csd.sub_surface[i] == NULL);
+        xassert(win->csd.surface[i] == NULL);
+        xassert(win->csd.sub_surface[i] == NULL);
 
         win->csd.surface[i] = wl_compositor_create_surface(wayl->compositor);
 
@@ -231,7 +231,7 @@ seat_handle_capabilities(void *data, struct wl_seat *wl_seat,
                          enum wl_seat_capability caps)
 {
     struct seat *seat = data;
-    assert(seat->wl_seat == wl_seat);
+    xassert(seat->wl_seat == wl_seat);
 
     LOG_DBG("%s: keyboard=%s, pointer=%s", seat->name,
             (caps & WL_SEAT_CAPABILITY_KEYBOARD) ? "yes" : "no",
@@ -251,7 +251,7 @@ seat_handle_capabilities(void *data, struct wl_seat *wl_seat,
 
     if (caps & WL_SEAT_CAPABILITY_POINTER) {
         if (seat->wl_pointer == NULL) {
-            assert(seat->pointer.surface == NULL);
+            xassert(seat->pointer.surface == NULL);
             seat->pointer.surface = wl_compositor_create_surface(seat->wayl->compositor);
 
             if (seat->pointer.surface == NULL) {
@@ -708,7 +708,7 @@ xdg_toplevel_decoration_configure(void *data,
 {
     struct wl_window *win = data;
 
-    assert(win->term->conf->csd.preferred != CONF_CSD_PREFER_NONE);
+    xassert(win->term->conf->csd.preferred != CONF_CSD_PREFER_NONE);
     switch (mode) {
     case ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE:
         LOG_INFO("using CSD decorations");
@@ -1440,7 +1440,7 @@ wayl_reload_xcursor_theme(struct seat *seat, int new_scale)
     }
 
     if (seat->pointer.theme != NULL) {
-        assert(seat->pointer.scale != new_scale);
+        xassert(seat->pointer.scale != new_scale);
         wl_cursor_theme_destroy(seat->pointer.theme);
         seat->pointer.theme = NULL;
         seat->pointer.cursor = NULL;
@@ -1495,7 +1495,7 @@ wayl_flush(struct wayland *wayl)
 
         /* Socket buffer is full - need to wait for it to become
            writeable again */
-        assert(errno == EAGAIN);
+        xassert(errno == EAGAIN);
 
         while (true) {
             struct pollfd fds[] = {{.fd = wayl->fd, .events = POLLOUT}};
@@ -1513,7 +1513,7 @@ wayl_flush(struct wayland *wayl)
             if (fds[0].revents & POLLHUP)
                 return;
 
-            assert(fds[0].revents & POLLOUT);
+            xassert(fds[0].revents & POLLOUT);
             break;
         }
     }
diff --git a/xmalloc.c b/xmalloc.c
index 8fb78f49..16b3565a 100644
--- a/xmalloc.c
+++ b/xmalloc.c
@@ -28,7 +28,7 @@ xmalloc(size_t size)
 void *
 xcalloc(size_t nmemb, size_t size)
 {
-    assert(size != 0);
+    xassert(size != 0);
     return check_alloc(calloc(likely(nmemb) ? nmemb : 1, size));
 }
 
diff --git a/xsnprintf.c b/xsnprintf.c
index 9e7693b6..b0e17741 100644
--- a/xsnprintf.c
+++ b/xsnprintf.c
@@ -7,7 +7,7 @@
 size_t
 xvsnprintf(char *buf, size_t n, const char *format, va_list ap)
 {
-    assert(n <= INT_MAX);
+    xassert(n <= INT_MAX);
     int len = vsnprintf(buf, n, format, ap);
 
     /*
@@ -19,8 +19,8 @@ xvsnprintf(char *buf, size_t n, const char *format, va_list ap)
      * has been completely written if and only if the returned value
      * is nonnegative and less than n."
      */
-    assert(len >= 0);
-    assert(len < (int)n);
+    xassert(len >= 0);
+    xassert(len < (int)n);
 
     return (size_t)len;
 }