diff --git a/input.c b/input.c
index fa7661f7..4035b2c8 100644
--- a/input.c
+++ b/input.c
@@ -572,15 +572,14 @@ input_state_string_escape(u_char ch, struct input_ctx *ictx)
 void
 input_state_utf8(u_char ch, struct input_ctx *ictx)
 {
-	log_debug2("-- un %zu: %hhu (%c)", ictx->off, ch, ch);
+	log_debug2("-- utf8 next: %zu: %hhu (%c)", ictx->off, ch, ch);
 
-	ictx->utf8_buf[ictx->utf8_off++] = ch;
-	if (--ictx->utf8_len != 0)
-		return;
+	if (utf8_append(&ictx->utf8data, ch))
+		return;		/* more to come */
 	input_state(ictx, input_state_first);
 
 	ictx->cell.flags |= GRID_FLAG_UTF8;
-	screen_write_cell(&ictx->ctx, &ictx->cell, ictx->utf8_buf);
+	screen_write_cell(&ictx->ctx, &ictx->cell, &ictx->utf8data);
 	ictx->cell.flags &= ~GRID_FLAG_UTF8;
 }
 
@@ -590,40 +589,17 @@ input_handle_character(u_char ch, struct input_ctx *ictx)
 	struct window_pane	*wp = ictx->wp;
 
 	if (ch > 0x7f && options_get_number(&wp->window->options, "utf8")) {
-		/*
-		 * UTF-8 sequence.
-		 *
-		 * 11000010-11011111 C2-DF start of 2-byte sequence
-		 * 11100000-11101111 E0-EF start of 3-byte sequence
-		 * 11110000-11110100 F0-F4 start of 4-byte sequence
-		 */
-		memset(ictx->utf8_buf, 0xff, sizeof ictx->utf8_buf);
-		ictx->utf8_buf[0] = ch;
-		ictx->utf8_off = 1;
-
-		if (ch >= 0xc2 && ch <= 0xdf) {
-			log_debug2("-- u2 %zu: %hhu (%c)", ictx->off, ch, ch);
+		if (utf8_open(&ictx->utf8data, ch)) {
+			log_debug2("-- utf8 size %u: %zu: %hhu (%c)", 
+			    ictx->utf8data.size, ictx->off, ch, ch);
 			input_state(ictx, input_state_utf8);
-			ictx->utf8_len = 1;
-			return;
-		}
-		if (ch >= 0xe0 && ch <= 0xef) {
-			log_debug2("-- u3 %zu: %hhu (%c)", ictx->off, ch, ch);
-			input_state(ictx, input_state_utf8);
-			ictx->utf8_len = 2;
-			return;
-		}
-		if (ch >= 0xf0 && ch <= 0xf4) {
-			log_debug2("-- u4 %zu: %hhu (%c)", ictx->off, ch, ch);
-			input_state(ictx, input_state_utf8);
-			ictx->utf8_len = 3;
 			return;
 		}
 	}
 	log_debug2("-- ch %zu: %hhu (%c)", ictx->off, ch, ch);
 
 	ictx->cell.data = ch;
-	screen_write_cell(&ictx->ctx, &ictx->cell, ictx->utf8_buf);
+	screen_write_cell(&ictx->ctx, &ictx->cell, NULL);
 }
 
 void
diff --git a/screen-write.c b/screen-write.c
index 9ed8f93b..8f10976f 100644
--- a/screen-write.c
+++ b/screen-write.c
@@ -24,7 +24,8 @@
 
 void	screen_write_initctx(struct screen_write_ctx *, struct tty_ctx *, int);
 void	screen_write_overwrite(struct screen_write_ctx *);
-int	screen_write_combine(struct screen_write_ctx *, u_char *);
+int	screen_write_combine(
+	    struct screen_write_ctx *, const struct utf8_data *);
 
 /* Initialise writing with a window. */
 void
@@ -92,10 +93,11 @@ screen_write_cstrlen(int utf8flag, const char *fmt, ...)
 size_t printflike2
 screen_write_strlen(int utf8flag, const char *fmt, ...)
 {
-	va_list	ap;
-	char   *msg;
-	u_char *ptr, utf8buf[4];
-	size_t	left, size = 0;
+	va_list			ap;
+	char   	       	       *msg;
+	struct utf8_data	utf8data;
+	u_char 	      	       *ptr;
+	size_t			left, size = 0;
 
 	va_start(ap, fmt);
 	xvasprintf(&msg, fmt, ap);
@@ -103,24 +105,17 @@ screen_write_strlen(int utf8flag, const char *fmt, ...)
 
 	ptr = msg;
 	while (*ptr != '\0') {
-		if (utf8flag && *ptr > 0x7f) {
-			memset(utf8buf, 0xff, sizeof utf8buf);
+		if (utf8flag && *ptr > 0x7f && utf8_open(&utf8data, *ptr)) {
+			ptr++;
 
 			left = strlen(ptr);
-			if (*ptr >= 0xc2 && *ptr <= 0xdf && left >= 2) {
-				memcpy(utf8buf, ptr, 2);
-				ptr += 2;
-			} else if (*ptr >= 0xe0 && *ptr <= 0xef && left >= 3) {
-				memcpy(utf8buf, ptr, 3);
-				ptr += 3;
-			} else if (*ptr >= 0xf0 && *ptr <= 0xf4 && left >= 4) {
-				memcpy(utf8buf, ptr, 4);
-				ptr += 4;
-			} else {
-				*utf8buf = *ptr;
+			if (left < utf8data.size - 1)
+				break;
+			while (utf8_append(&utf8data, *ptr))
 				ptr++;
-			}
-			size += utf8_width(utf8buf);
+			ptr++;
+
+			size += utf8data.width;
 		} else {
 			size++;
 			ptr++;
@@ -159,47 +154,38 @@ void
 screen_write_vnputs(struct screen_write_ctx *ctx, ssize_t maxlen,
     struct grid_cell *gc, int utf8flag, const char *fmt, va_list ap)
 {
-	char   *msg;
-	u_char *ptr, utf8buf[4];
-	size_t	left, size = 0;
-	int	width;
+	char   		       *msg;
+	struct utf8_data	utf8data;
+	u_char 		       *ptr;
+	size_t		 	left, size = 0;
 
 	xvasprintf(&msg, fmt, ap);
 
 	ptr = msg;
 	while (*ptr != '\0') {
-		if (utf8flag && *ptr > 0x7f) {
-			memset(utf8buf, 0xff, sizeof utf8buf);
+		if (utf8flag && *ptr > 0x7f && utf8_open(&utf8data, *ptr)) {
+			ptr++;
 
 			left = strlen(ptr);
-			if (*ptr >= 0xc2 && *ptr <= 0xdf && left >= 2) {
-				memcpy(utf8buf, ptr, 2);
-				ptr += 2;
-			} else if (*ptr >= 0xe0 && *ptr <= 0xef && left >= 3) {
-				memcpy(utf8buf, ptr, 3);
-				ptr += 3;
-			} else if (*ptr >= 0xf0 && *ptr <= 0xf4 && left >= 4) {
-				memcpy(utf8buf, ptr, 4);
-				ptr += 4;
-			} else {
-				*utf8buf = *ptr;
+			if (left < utf8data.size - 1)
+				break;
+			while (utf8_append(&utf8data, *ptr))
 				ptr++;
-			}
+			ptr++;
 
-			width = utf8_width(utf8buf);
-			if (maxlen > 0 && size + width > (size_t) maxlen) {
+			if (maxlen > 0 &&
+			    size + utf8data.width > (size_t) maxlen) {
 				while (size < (size_t) maxlen) {
 					screen_write_putc(ctx, gc, ' ');
 					size++;
 				}
 				break;
 			}
-			size += width;
-
+			size += utf8data.width;
+			
 			gc->flags |= GRID_FLAG_UTF8;
-			screen_write_cell(ctx, gc, utf8buf);
+			screen_write_cell(ctx, gc, &utf8data);
 			gc->flags &= ~GRID_FLAG_UTF8;
-
 		} else {
 			if (maxlen > 0 && size + 1 > (size_t) maxlen)
 				break;
@@ -219,11 +205,11 @@ screen_write_cnputs(struct screen_write_ctx *ctx,
     ssize_t maxlen, struct grid_cell *gc, int utf8flag, const char *fmt, ...)
 {
 	struct grid_cell	 lgc;
+	struct utf8_data	 utf8data;
 	va_list			 ap;
 	char			*msg;
-	u_char 			*ptr, *last, utf8buf[4];
+	u_char 			*ptr, *last;
 	size_t			 left, size = 0;
-	int			 width;
 
 	va_start(ap, fmt);
 	xvasprintf(&msg, fmt, ap);
@@ -247,38 +233,29 @@ screen_write_cnputs(struct screen_write_ctx *ctx,
 			continue;
 		}
 
-		if (utf8flag && *ptr > 0x7f) {
-			memset(utf8buf, 0xff, sizeof utf8buf);
+		if (utf8flag && *ptr > 0x7f && utf8_open(&utf8data, *ptr)) {
+			ptr++;
 
 			left = strlen(ptr);
-			if (*ptr >= 0xc2 && *ptr <= 0xdf && left >= 2) {
-				memcpy(utf8buf, ptr, 2);
-				ptr += 2;
-			} else if (*ptr >= 0xe0 && *ptr <= 0xef && left >= 3) {
-				memcpy(utf8buf, ptr, 3);
-				ptr += 3;
-			} else if (*ptr >= 0xf0 && *ptr <= 0xf4 && left >= 4) {
-				memcpy(utf8buf, ptr, 4);
-				ptr += 4;
-			} else {
-				*utf8buf = *ptr;
+			if (left < utf8data.size - 1)
+				break;
+			while (utf8_append(&utf8data, *ptr))
 				ptr++;
-			}
+			ptr++;
 
-			width = utf8_width(utf8buf);
-			if (maxlen > 0 && size + width > (size_t) maxlen) {
+			if (maxlen > 0 &&
+			    size + utf8data.width > (size_t) maxlen) {
 				while (size < (size_t) maxlen) {
 					screen_write_putc(ctx, gc, ' ');
 					size++;
 				}
 				break;
 			}
-			size += width;
+			size += utf8data.width;
 
 			lgc.flags |= GRID_FLAG_UTF8;
-			screen_write_cell(ctx, &lgc, utf8buf);
+			screen_write_cell(ctx, &lgc, &utf8data);
 			lgc.flags &= ~GRID_FLAG_UTF8;
-
 		} else {
 			if (maxlen > 0 && size + 1 > (size_t) maxlen)
 				break;
@@ -375,8 +352,9 @@ screen_write_copy(struct screen_write_ctx *ctx,
 	struct grid		*gd = src->grid;
 	struct grid_line	*gl;
 	const struct grid_cell	*gc;
-	u_char			*udata;
-	u_int		 	 xx, yy, cx, cy, ax, bx;
+	const struct grid_utf8	*gu;
+	struct utf8_data	 utf8data;
+	u_int		 	 xx, yy, cx, cy, ax, bx, i;
 
 	cx = s->cx;
 	cy = s->cy;
@@ -397,21 +375,30 @@ screen_write_copy(struct screen_write_ctx *ctx,
 				bx = gl->cellsize;
 			else
 				bx = px + nx;
+			
 			for (xx = ax; xx < bx; xx++) {
-				udata = NULL;
 				if (xx >= gl->cellsize)
 					gc = &grid_default_cell;
-				else {
+				else
 					gc = &gl->celldata[xx];
-					if (gc->flags & GRID_FLAG_UTF8)
-						udata = gl->utf8data[xx].data;
+				if (gc->flags & GRID_FLAG_UTF8) {
+					gu = &gl->utf8data[xx]; 
+					memcpy(utf8data.data,
+					    gu->data, sizeof utf8data.data);
+					utf8data.width = gu->width;
+					utf8data.size = 0;
+					for (i = 0; i < UTF8_SIZE; i++) {
+						if (gu->data[i] == 0xff)
+							break;
+						utf8data.size++;
+					}
 				}
-				screen_write_cell(ctx, gc, udata);
+				screen_write_cell(ctx, gc, &utf8data);
 			}
 			if (px + nx == gd->sx && px + nx > gl->cellsize)
 				screen_write_clearendofline(ctx);
 		} else
- 			screen_write_clearline(ctx);
+			screen_write_clearline(ctx);
 		cy++;
 		screen_write_cursormove(ctx, cx, cy);
 	}
@@ -972,8 +959,8 @@ screen_write_clearscreen(struct screen_write_ctx *ctx)
 
 /* Write cell data. */
 void
-screen_write_cell(
-    struct screen_write_ctx *ctx, const struct grid_cell *gc, u_char *udata)
+screen_write_cell(struct screen_write_ctx *ctx,
+    const struct grid_cell *gc, const struct utf8_data *utf8data)
 {
 	struct screen		*s = ctx->s;
 	struct grid		*gd = s->grid;
@@ -988,12 +975,9 @@ screen_write_cell(
 		return;
 
 	/* Find character width. */
-	if (gc->flags & GRID_FLAG_UTF8) {
-		width = utf8_width(udata);
-
-		gu.width = width;
-		memcpy(&gu.data, udata, sizeof gu.data);
- 	} else
+	if (gc->flags & GRID_FLAG_UTF8)
+		width = utf8data->width;
+	else
 		width = 1;
 
 	/*
@@ -1009,7 +993,7 @@ screen_write_cell(
 	 * there is space. 
 	 */
 	if (width == 0) {
-		if (screen_write_combine(ctx, udata) == 0) {
+		if (screen_write_combine(ctx, utf8data) == 0) {
 			screen_write_initctx(ctx, &ttyctx, 0);
 			tty_write(tty_cmd_utf8character, &ttyctx);
 		}
@@ -1028,11 +1012,6 @@ screen_write_cell(
 
 	/* Check this will fit on the current line and wrap if not. */
 	if (s->cx > screen_size_x(s) - width) {
-		/* 
-		 * Don't update the terminal now, just update the screen and
-		 * leave the cursor to scroll naturally, unless this is only
-		 * part of the screen width.
-		 */
 		screen_write_linefeed(ctx, 1);
 		s->cx = 0;	/* carriage return */
 	}
@@ -1056,8 +1035,15 @@ screen_write_cell(
 
 	/* Set the cell. */
 	grid_view_set_cell(gd, s->cx, s->cy, gc);
-	if (gc->flags & GRID_FLAG_UTF8)
+	if (gc->flags & GRID_FLAG_UTF8) {
+		/* Construct UTF-8 and write it. */
+		gu.width = utf8data->width;
+		memset(gu.data, 0xff, sizeof gu.data);
+		if (utf8data->size > sizeof gu.data)
+			fatalx("UTF-8 data overflow");
+		memcpy(gu.data, utf8data->data, utf8data->size);
 		grid_view_set_utf8(gd, s->cx, s->cy, &gu);
+	}
 
 	/* Move the cursor. */
 	s->cx += width;
@@ -1085,13 +1071,14 @@ screen_write_cell(
 
 /* Combine a UTF-8 zero-width character onto the previous. */
 int
-screen_write_combine(struct screen_write_ctx *ctx, u_char *udata)
+screen_write_combine(
+    struct screen_write_ctx *ctx, const struct utf8_data *utf8data)
 {
 	struct screen		*s = ctx->s;
 	struct grid		*gd = s->grid;
 	struct grid_cell	*gc;
 	struct grid_utf8	*gu, tmp_gu;
-	u_int			 i, old_size, new_size;
+	u_int			 i, old_size;
 
 	/* Can't combine if at 0. */
 	if (s->cx == 0)
@@ -1108,23 +1095,15 @@ screen_write_combine(struct screen_write_ctx *ctx, u_char *udata)
 		gc->flags |= GRID_FLAG_UTF8;
 	}
 
-	/* Get the previous cell's UTF-8 data. */
+	/* Get the previous cell's UTF-8 data and its size. */
 	gu = grid_view_get_utf8(gd, s->cx - 1, s->cy);
-
-	/* Find the new size. */
-	for (new_size = 0; new_size < UTF8_SIZE; new_size++) {
-		if (udata[new_size] == 0xff)
-			break;
-	}
-
-	/* And the old size. */
 	for (old_size = 0; old_size < UTF8_SIZE; old_size++) {
 		if (gu->data[old_size] == 0xff)
 			break;
 	}
 
 	/* If there isn't space, scrap this character. */
-	if (old_size + new_size > UTF8_SIZE) {
+	if (old_size + utf8data->size > UTF8_SIZE) {
 		for (i = 0; i < gu->width && i != UTF8_SIZE; i++)
 			gu->data[i] = '_';
 		if (i != UTF8_SIZE)
@@ -1133,9 +1112,9 @@ screen_write_combine(struct screen_write_ctx *ctx, u_char *udata)
 	}
 
 	/* Otherwise save the character. */
-	memcpy(gu->data + old_size, udata, new_size);
-	if (old_size + new_size != UTF8_SIZE)
-		gu->data[old_size + new_size] = 0xff;
+	memcpy(gu->data + old_size, utf8data->data, utf8data->size);
+	if (old_size + utf8data->size != UTF8_SIZE)
+		gu->data[old_size + utf8data->size] = 0xff;
 	return (0);
 }
 
diff --git a/tmux.h b/tmux.h
index a61040b6..850c2f5b 100644
--- a/tmux.h
+++ b/tmux.h
@@ -477,6 +477,23 @@ struct mode_key_table {
 #define MODE_KKEYPAD 0x8
 #define MODE_MOUSE 0x10
 
+/*
+ * A single UTF-8 character. 
+ *
+ * The data member in this must be UTF8_SIZE to allow screen_write_copy to
+ * reinject stored UTF-8 data back into screen_write_cell after combining (ugh
+ * XXX XXX).
+ */
+#define UTF8_SIZE 9
+struct utf8_data {
+	u_char	data[UTF8_SIZE];
+
+	size_t	have;
+	size_t	size;
+
+	u_int	width;
+};
+
 /* Grid output. */
 #if defined(DEBUG) && \
     ((defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || \
@@ -516,7 +533,6 @@ struct grid_cell {
 } __packed;
 
 /* Grid cell UTF-8 data. Used instead of data in grid_cell for UTF-8 cells. */
-#define UTF8_SIZE 9
 struct grid_utf8 {
 	u_char	width;
 	u_char	data[UTF8_SIZE];
@@ -672,9 +688,7 @@ struct input_ctx {
 #define STRING_APPLICATION 1
 #define STRING_NAME 2
 
-	u_char		 utf8_buf[4];
-	u_int		 utf8_len;
-	u_int		 utf8_off;
+	struct utf8_data utf8data;
 
 	u_char		 intermediate;
 	void 		*(*state)(u_char, struct input_ctx *);
@@ -1682,8 +1696,8 @@ void	 screen_write_kkeypadmode(struct screen_write_ctx *, int);
 void	 screen_write_clearendofscreen(struct screen_write_ctx *);
 void	 screen_write_clearstartofscreen(struct screen_write_ctx *);
 void	 screen_write_clearscreen(struct screen_write_ctx *);
-void	 screen_write_cell(
-    	     struct screen_write_ctx *, const struct grid_cell *, u_char *);
+void	 screen_write_cell(struct screen_write_ctx *,
+    	     const struct grid_cell *, const struct utf8_data *);
 
 /* screen-redraw.c */
 void	 screen_redraw_screen(struct client *, int);
@@ -1838,7 +1852,8 @@ void		 session_group_synchronize1(struct session *, struct session *);
 
 /* utf8.c */
 void	utf8_build(void);
-int	utf8_width(const u_char *);
+int	utf8_open(struct utf8_data *, u_char);
+int	utf8_append(struct utf8_data *, u_char);
 
 /* procname.c */
 char   *get_proc_name(int, char *);
diff --git a/tty.c b/tty.c
index 9ddffb95..ee725edf 100644
--- a/tty.c
+++ b/tty.c
@@ -342,7 +342,7 @@ tty_putc(struct tty *tty, u_char ch)
 void
 tty_pututf8(struct tty *tty, const struct grid_utf8 *gu)
 {
-	u_int	i, width;
+	u_int	i;
 
 	for (i = 0; i < UTF8_SIZE; i++) {
 		if (gu->data[i] == 0xff)
@@ -352,8 +352,7 @@ tty_pututf8(struct tty *tty, const struct grid_utf8 *gu)
 			write(tty->log_fd, &gu->data[i], 1);
 	}
 
-	width = utf8_width(gu->data);
-	tty->cx += width;
+	tty->cx += gu->width;
 }
 
 void
diff --git a/utf8.c b/utf8.c
index 9b499d1c..52cc709e 100644
--- a/utf8.c
+++ b/utf8.c
@@ -196,9 +196,56 @@ struct utf8_width_entry utf8_width_table[] = {
 struct utf8_width_entry	*utf8_width_root = NULL;
 
 int	utf8_overlap(struct utf8_width_entry *, struct utf8_width_entry *);
-void	utf8_print(struct utf8_width_entry *, int);
-u_int	utf8_combine(const u_char *);
+u_int	utf8_combine(const struct utf8_data *);
+u_int	utf8_width(const struct utf8_data *);
 
+/*
+ * Open UTF-8 sequence.
+ *
+ * 11000010-11011111 C2-DF start of 2-byte sequence
+ * 11100000-11101111 E0-EF start of 3-byte sequence
+ * 11110000-11110100 F0-F4 start of 4-byte sequence
+ *
+ * Returns 1 if more UTF-8 to come, 0 if not UTF-8.
+ */
+int
+utf8_open(struct utf8_data *utf8data, u_char ch)
+{
+	memset(utf8data, 0, sizeof *utf8data);
+	if (ch >= 0xc2 && ch <= 0xdf)
+		utf8data->size = 2;
+	else if (ch >= 0xe0 && ch <= 0xef)
+		utf8data->size = 3;
+	else if (ch >= 0xf0 && ch <= 0xf4)
+		utf8data->size = 4;
+	else
+		return (0);
+	utf8_append(utf8data, ch);
+	return (1);
+}
+
+/*
+ * Append character to UTF-8, closing if finished.
+ *
+ * Returns 1 if more UTF-8 data to come, 1 if finished.
+ */
+int
+utf8_append(struct utf8_data *utf8data, u_char ch)
+{
+	if (utf8data->have >= utf8data->size)
+		fatalx("UTF-8 character overflow");
+	if (utf8data->size > sizeof utf8data->data)
+		fatalx("UTF-8 character size too large");
+
+	utf8data->data[utf8data->have++] = ch;
+	if (utf8data->have != utf8data->size)
+		return (1);
+
+	utf8data->width = utf8_width(utf8data);
+	return (0);
+}
+
+/* Check if two width tree entries overlap. */
 int
 utf8_overlap(
     struct utf8_width_entry *item1, struct utf8_width_entry *item2)
@@ -214,6 +261,7 @@ utf8_overlap(
 	return (0);
 }
 
+/* Build UTF-8 width tree. */
 void
 utf8_build(void)
 {
@@ -240,52 +288,50 @@ utf8_build(void)
 	}
 }
 
-void
-utf8_print(struct utf8_width_entry *node, int n)
-{
-	log_debug("%*s%04x -> %04x", n, " ",  node->first, node->last);
-	if (node->left != NULL)
-		utf8_print(node->left, n + 1);
-	if (node->right != NULL)
-		utf8_print(node->right, n + 1);
-}
-
+/* Combine UTF-8 into 32-bit Unicode. */
 u_int
-utf8_combine(const u_char *data)
+utf8_combine(const struct utf8_data *utf8data)
 {
-	u_int	uvalue;
+	u_int	value;
 
-	if (data[1] == 0xff)
-		uvalue = data[0];
-	else if (data[2] == 0xff) {
-		uvalue = data[1] & 0x3f;
-		uvalue |= (data[0] & 0x1f) << 6;
-	} else if (data[3] == 0xff) {
-		uvalue = data[2] & 0x3f;
-		uvalue |= (data[1] & 0x3f) << 6;
-		uvalue |= (data[0] & 0x0f) << 12;
-	} else {
-		uvalue = data[3] & 0x3f;
-		uvalue |= (data[2] & 0x3f) << 6;
-		uvalue |= (data[1] & 0x3f) << 12;
-		uvalue |= (data[0] & 0x3f) << 18;
+	value = 0xff;
+	switch (utf8data->size) {
+	case 1:
+		value = utf8data->data[0];
+		break;
+	case 2:
+		value = utf8data->data[1] & 0x3f;
+		value |= (utf8data->data[0] & 0x1f) << 6;
+		break;
+	case 3:
+		value = utf8data->data[2] & 0x3f;
+		value |= (utf8data->data[1] & 0x3f) << 6;
+		value |= (utf8data->data[0] & 0x0f) << 12;
+		break;
+	case 4:
+		value = utf8data->data[3] & 0x3f;
+		value |= (utf8data->data[2] & 0x3f) << 6;
+		value |= (utf8data->data[1] & 0x3f) << 12;
+		value |= (utf8data->data[0] & 0x3f) << 18;
+		break;
 	}
-	return (uvalue);
+	return (value);
 }
 
-int
-utf8_width(const u_char *udata)
+/* Lookup width of UTF-8 data in tree. */
+u_int
+utf8_width(const struct utf8_data *utf8data)
 {
 	struct utf8_width_entry	*item;
-	u_int			 uvalue;
+	u_int			 value;
 
-	uvalue = utf8_combine(udata);
+	value = utf8_combine(utf8data);
 
 	item = utf8_width_root;
 	while (item != NULL) {
-		if (uvalue < item->first)
+		if (value < item->first)
 			item = item->left;
-		else if (uvalue > item->last)
+		else if (value > item->last)
 			item = item->right;
 		else
 			return (item->width);