degesch: phase 1 of word wrapping implementation

2 files changed, 293 insertions, 45 deletions

diff --git a/NEWS b/NEWS
index 431d85a..2c88bf2 100644
--- a/NEWS
+++ b/NEWS
@@ -23,6 +23,8 @@
 
  * degesch: added --format for previewing things like MOTD files
 
+ * degesch: implemented word wrapping in buffers
+
  * kike: add support for IRCv3.2 server-time
 
  * ZyklonB: plugins now run in a dedicated data directory
diff --git a/degesch.c b/degesch.c
index dcad0b2..3e25caf 100644
--- a/degesch.c
+++ b/degesch.c
@@ -1937,6 +1937,7 @@ struct app_context
 	bool beep_on_highlight;             ///< Beep on highlight
 	bool logging;                       ///< Logging to file enabled
 	bool show_all_prefixes;             ///< Show all prefixes before nicks
+	bool word_wrapping;                 ///< Enable simple word wrapping
 
 	struct str_map servers;             ///< Our servers
 
@@ -2138,6 +2139,7 @@ static void on_config_logging_change (struct config_item *item);
 
 TRIVIAL_BOOLEAN_ON_CHANGE (isolate_buffers)
 TRIVIAL_BOOLEAN_ON_CHANGE (beep_on_highlight)
+TRIVIAL_BOOLEAN_ON_CHANGE (word_wrapping)
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
@@ -2313,6 +2315,11 @@ static struct config_schema g_config_behaviour[] =
 	  .type      = CONFIG_ITEM_BOOLEAN,
 	  .default_  = "off",
 	  .on_change = on_config_show_all_prefixes_change },
+	{ .name      = "word_wrapping",
+	  .comment   = "Enable simple word wrapping in buffers",
+	  .type      = CONFIG_ITEM_BOOLEAN,
+	  .default_  = "on",
+	  .on_change = on_config_word_wrapping_change },
 	{ .name      = "logging",
 	  .comment   = "Log buffer contents to file",
 	  .type      = CONFIG_ITEM_BOOLEAN,
@@ -3253,29 +3260,224 @@ formatter_add (struct formatter *self, const char *format, ...)
 	va_end (ap);
 }
 
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+struct line_char_attrs
+{
+	int named;                          ///< Named attribute or -1
+	int text;                           ///< Text attributes
+	int fg;                             ///< Foreground color (-1 for default)
+	int bg;                             ///< Background color (-1 for default)
+};
+
+struct line_char
+{
+	LIST_HEADER (struct line_char)
+
+	char bytes[MB_LEN_MAX];             ///< The character
+	size_t len;                         ///< Length of the character in bytes
+	wchar_t wide;                       ///< The character as a wchar_t
+	int width;                          ///< Width of the character in cells
+	struct line_char_attrs attrs;       ///< Attributes
+};
+
+static struct line_char *
+line_char_new (const char *mb, size_t mb_len, wchar_t wc)
+{
+	struct line_char *self = xcalloc (1, sizeof *self);
+	memcpy (self->bytes, mb, (self->len = MIN (mb_len, sizeof self->bytes)));
+	self->width = wcwidth ((self->wide = wc));
+
+	self->attrs.bg = self->attrs.fg = -1;
+	self->attrs.named = ATTR_RESET;
+	return self;
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+struct line_wrap_mark
+{
+	struct line_char *start;            ///< First character
+	int used;                           ///< Display cells used
+};
+
+static void
+line_wrap_mark_push (struct line_wrap_mark *mark, struct line_char *c)
+{
+	if (!mark->start)
+		mark->start = c;
+	mark->used += c->width;
+}
+
+struct line_wrap_state
+{
+	struct line_char *result;           ///< Head of result
+	struct line_char *result_tail;      ///< Tail of result
+
+	int line_used;                      ///< Line length before marks
+	int line_max;                       ///< Maximum line length
+	struct line_wrap_mark chunk;        ///< All buffered text
+	struct line_wrap_mark overflow;     ///< Overflowing text
+};
+
+static void
+line_wrap_flush_split (struct line_wrap_state *s, struct line_wrap_mark *before)
+{
+	struct line_char *nl = line_char_new ("\n", 1, L'\n');
+	LIST_INSERT_WITH_TAIL (s->result, s->result_tail, nl, before->start);
+	s->line_used = before->used;
+}
+
+static void
+line_wrap_flush (struct line_wrap_state *s, bool force_split)
+{
+	if (!s->overflow.start)
+		s->line_used += s->chunk.used;
+	else if (force_split || s->chunk.used > s->line_max)
+	{
+#ifdef WRAP_UNNECESSARILY
+		// Use the entire line and split the chunk in the middle
+		line_wrap_flush_split (s, &s->overflow);
+#else
+		// We don't actually _need_ to split here, and doing so will break
+		// link searching mechanisms in some terminals
+		s->line_used = s->overflow.used;
+#endif
+	}
+	else
+		// Print the chunk in its entirety on a new line
+		line_wrap_flush_split (s, &s->chunk);
+
+	memset (&s->chunk,    0, sizeof s->chunk);
+	memset (&s->overflow, 0, sizeof s->overflow);
+}
+
+static void
+line_wrap_nl (struct line_wrap_state *s)
+{
+	line_wrap_flush (s, true);
+	struct line_char *nl = line_char_new ("\n", 1, L'\n');
+	LIST_APPEND_WITH_TAIL (s->result, s->result_tail, nl);
+	s->line_used = 0;
+}
+
+static void
+line_wrap_tab (struct line_wrap_state *s, struct line_char *c)
+{
+	line_wrap_flush (s, true);
+	if (s->line_used >= s->line_max)
+		line_wrap_nl (s);
+
+	// Compute the number of characters needed to get to the next tab stop
+	int tab_width = ((s->line_used + 8) & ~7) - s->line_used;
+	// On overflow just fill the rest of the line with spaces
+	if (s->line_used + tab_width > s->line_max)
+		tab_width = s->line_max - s->line_used;
+
+	s->line_used += tab_width;
+	while (tab_width--)
+	{
+		struct line_char *space = line_char_new (" ", 1, L' ');
+		space->attrs = c->attrs;
+		LIST_APPEND_WITH_TAIL (s->result, s->result_tail, space);
+	}
+}
+
+static void
+line_wrap_push_char (struct line_wrap_state *s, struct line_char *c)
+{
+	// Note that when processing whitespace here, any non-WS chunk has already
+	// been flushed, and thus it matters little if we flush with force split
+	if (wcschr (L"\r\f\v", c->wide))
+		/* Skip problematic characters */;
+	else if (c->wide == L'\n')
+		line_wrap_nl (s);
+	else if (c->wide == L'\t')
+		line_wrap_tab (s, c);
+	else
+		goto use_as_is;
+	free (c);
+	return;
+
+use_as_is:
+	if (s->overflow.start
+	 || s->line_used + s->chunk.used + c->width > s->line_max)
+	{
+		if (s->overflow.used + c->width > s->line_max)
+		{
+#ifdef WRAP_UNNECESSARILY
+			// If the overflow overflows, restart on a new line
+			line_wrap_nl (s);
+#else
+			// See line_wrap_flush(), we would end up on a new line anyway
+			line_wrap_flush (s, true);
+			s->line_used = 0;
+#endif
+		}
+		else
+			line_wrap_mark_push (&s->overflow, c);
+	}
+	line_wrap_mark_push (&s->chunk, c);
+	LIST_APPEND_WITH_TAIL (s->result, s->result_tail, c);
+}
+
+/// Basic word wrapping that respects wcwidth(3) and expands tabs.
+/// Besides making text easier to read, it also fixes the problem with
+/// formatting spilling over the entire new line on line wrap.
+static struct line_char *
+line_wrap (struct line_char *line, int max_width)
+{
+	struct line_wrap_state s = { .line_max = max_width };
+	bool last_was_word_char = false;
+	LIST_FOR_EACH (struct line_char, c, line)
+	{
+		// Act on the right boundary of (\s*\S+) chunks
+		bool this_is_word_char = !wcschr (L" \t\r\n\f\v", c->wide);
+		if (last_was_word_char && !this_is_word_char)
+			line_wrap_flush (&s, false);
+		last_was_word_char = this_is_word_char;
+
+		LIST_UNLINK (line, c);
+		line_wrap_push_char (&s, c);
+	}
+
+	// Make sure to process the last word and return the modified list
+	line_wrap_flush (&s, false);
+	return s.result;
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+struct exploder
+{
+	struct app_context *ctx;            ///< Application context
+	struct line_char *result;           ///< Result
+	struct line_char *result_tail;      ///< Tail of result
+	struct line_char_attrs attrs;       ///< Current attributes
+};
+
 static bool
-formatter_flush_attr
-	(struct attribute_printer *state, struct formatter_item *item)
+explode_formatter_attr (struct exploder *self, struct formatter_item *item)
 {
 	switch (item->type)
 	{
 	case FORMATTER_ITEM_ATTR:
-		attribute_printer_apply (state, item->attribute);
-		state->want = 0;
-		state->want_foreground = -1;
-		state->want_background = -1;
+		self->attrs.named = item->attribute;
+		self->attrs.text = 0;
+		self->attrs.fg = -1;
+		self->attrs.bg = -1;
 		return true;
 	case FORMATTER_ITEM_SIMPLE:
-		state->want ^= item->attribute;
-		attribute_printer_update (state);
+		self->attrs.named = -1;
+		self->attrs.text ^= item->attribute;
 		return true;
 	case FORMATTER_ITEM_FG_COLOR:
-		state->want_foreground = item->color;
-		attribute_printer_update (state);
+		self->attrs.named = -1;
+		self->attrs.fg = item->color;
 		return true;
 	case FORMATTER_ITEM_BG_COLOR:
-		state->want_background = item->color;
-		attribute_printer_update (state);
+		self->attrs.named = -1;
+		self->attrs.bg = item->color;
 		return true;
 	default:
 		return false;
@@ -3283,51 +3485,103 @@ formatter_flush_attr
 }
 
 static void
-formatter_flush_text (struct app_context *ctx, const char *text, FILE *stream)
+explode_text (struct exploder *self, const char *text)
 {
-	struct str sanitized;
-	str_init (&sanitized);
+	size_t term_len = 0;
+	char *term = iconv_xstrdup (self->ctx->term_from_utf8,
+		(char *) text, -1, &term_len);
+
+	mbstate_t ps;
+	memset (&ps, 0, sizeof ps);
 
-	// Throw away any potentially harmful control characters
-	char *term = iconv_xstrdup (ctx->term_from_utf8, (char *) text, -1, NULL);
-	for (char *p = term; *p; p++)
-		if (!strchr ("\a\b\x1b", *p))
-			str_append_c (&sanitized, *p);
+	wchar_t wch;
+	size_t len, processed = 0;
+	while ((len = mbrtowc (&wch, term + processed, term_len - processed, &ps)))
+	{
+		hard_assert (len != (size_t) -2 && len != (size_t) -1);
+		processed += len;
+
+		// Throw away any potentially harmful control characters
+		// XXX: this is likely to break shift state encodings
+		if (wcschr (L"\a\b\x1b", wch))
+			continue;
+
+		struct line_char *c = line_char_new (term + processed - len, len, wch);
+		c->attrs = self->attrs;
+		LIST_APPEND_WITH_TAIL (self->result, self->result_tail, c);
+	}
 	free (term);
+}
 
-	fputs (sanitized.str, stream);
-	str_free (&sanitized);
+static struct line_char *
+formatter_to_chars (struct formatter *formatter)
+{
+	struct exploder self = { .ctx = formatter->ctx };
+	self.attrs.fg = self.attrs.bg = self.attrs.named = -1;
+
+	int attribute_ignore = 0;
+	for (size_t i = 0; i < formatter->items_len; i++)
+	{
+		struct formatter_item *iter = &formatter->items[i];
+		if      (iter->type == FORMATTER_ITEM_TEXT)
+			explode_text (&self, iter->text);
+		else if (iter->type == FORMATTER_ITEM_IGNORE_ATTR)
+			attribute_ignore += iter->attribute;
+		else if (attribute_ignore <= 0
+			&& !explode_formatter_attr (&self, iter))
+				hard_assert (!"unhandled formatter item type");
+	}
+	return self.result;
 }
 
 static void
 formatter_flush (struct formatter *self, FILE *stream, bool raw_attributes)
 {
-	if (!raw_attributes && !get_attribute_printer (stream))
+	struct line_char *line = formatter_to_chars (self);
+
+	if (!get_attribute_printer (stream) && !raw_attributes)
 	{
-		for (size_t i = 0; i < self->items_len; i++)
+		LIST_FOR_EACH (struct line_char, c, line)
 		{
-			struct formatter_item *iter = &self->items[i];
-			if (iter->type == FORMATTER_ITEM_TEXT)
-				fputs (iter->text, stream);
+			fwrite (c->bytes, c->len, 1, stream);
+			free (c);
 		}
 		return;
 	}
 
+	if (self->ctx->word_wrapping)
+		line = line_wrap (line, g_terminal.columns);
+
+	// TODO: rewrite the sloppily hacked mess around attribute_printer;
+	//   so far I just didn't want to break everything at once
 	struct attribute_printer state;
 	attribute_printer_init (&state, self->ctx, stream);
 	attribute_printer_reset (&state);
 
-	int attribute_ignore = 0;
-	for (size_t i = 0; i < self->items_len; i++)
+	struct line_char_attrs attrs =
+		{ .fg = -1, .bg = -1, .named = ATTR_RESET, .text = 0 };
+	LIST_FOR_EACH (struct line_char, c, line)
 	{
-		struct formatter_item *iter = &self->items[i];
-		if      (iter->type == FORMATTER_ITEM_TEXT)
-			formatter_flush_text (self->ctx, iter->text, stream);
-		else if (iter->type == FORMATTER_ITEM_IGNORE_ATTR)
-			attribute_ignore += iter->attribute;
-		else if (attribute_ignore <= 0
-			&& !formatter_flush_attr (&state, iter))
-				hard_assert (!"unhandled formatter item type");
+		if (attrs.fg    != c->attrs.fg
+		 || attrs.bg    != c->attrs.bg
+		 || attrs.named != c->attrs.named
+		 || attrs.text  != c->attrs.text)
+		{
+			if (c->attrs.named != -1)
+				attribute_printer_apply (&state, c->attrs.named);
+			else
+			{
+				state.want            = c->attrs.text;
+				state.want_foreground = c->attrs.fg;
+				state.want_background = c->attrs.bg;
+				attribute_printer_reset (&state);
+				attribute_printer_update (&state);
+			}
+			attrs = c->attrs;
+		}
+
+		fwrite (c->bytes, c->len, 1, stream);
+		free (c);
 	}
 	attribute_printer_reset (&state);
 }
@@ -3393,14 +3647,6 @@ buffer_line_flush (struct buffer_line *line, struct formatter *f, FILE *output,
 	for (struct formatter_item *iter = line->items; iter->type; iter++)
 		formatter_add_item (f, *iter);
 
-	// XXX: we could reset attributes _before_ the newline.  That, however,
-	//   doesn't really work, because when the line wraps at the end of the
-	//   screen and a background colour is set, the terminal paints the entire
-	//   new line with that colour.  "clr_to_eol" is not a solution in that
-	//   case either, because it may delete the last character on a non-wrapped
-	//   line, and while we can append an extra space as a workaround, that can
-	//   cause an extra wrap for which I've found no way of avoiding.
-	// TODO: think about manual line wrapping; that way we can also word wrap
 	formatter_add (f, "\n");
 	formatter_flush (f, output, raw_attributes);
 	formatter_free (f);