1 /*
2  * Copyright (c) 2018, 2019, 2020 Stefan Sperling <stsp@openbsd.org>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 #include <sys/queue.h>
18 #include <sys/stat.h>
19 #include <sys/ioctl.h>
20 
21 #include <ctype.h>
22 #include <errno.h>
23 #define _XOPEN_SOURCE_EXTENDED /* for ncurses wide-character functions */
24 #include <curses.h>
25 #include <panel.h>
26 #include <locale.h>
27 #include <sha1.h>
28 #include <signal.h>
29 #include <stdlib.h>
30 #include <stdarg.h>
31 #include <stdio.h>
32 #include <getopt.h>
33 #include <string.h>
34 #include <err.h>
35 #include <unistd.h>
36 #include <limits.h>
37 #include <wchar.h>
38 #include <time.h>
39 #include <pthread.h>
40 #include <libgen.h>
41 #include <regex.h>
42 #include <sched.h>
43 
44 #include "got_version.h"
45 #include "got_error.h"
46 #include "got_object.h"
47 #include "got_reference.h"
48 #include "got_repository.h"
49 #include "got_diff.h"
50 #include "got_opentemp.h"
51 #include "got_utf8.h"
52 #include "got_cancel.h"
53 #include "got_commit_graph.h"
54 #include "got_blame.h"
55 #include "got_privsep.h"
56 #include "got_path.h"
57 #include "got_worktree.h"
58 
59 #ifndef MIN
60 #define	MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
61 #endif
62 
63 #ifndef MAX
64 #define	MAX(_a,_b) ((_a) > (_b) ? (_a) : (_b))
65 #endif
66 
67 #define CTRL(x)		((x) & 0x1f)
68 
69 #ifndef nitems
70 #define nitems(_a)	(sizeof((_a)) / sizeof((_a)[0]))
71 #endif
72 
73 struct tog_cmd {
74 	const char *name;
75 	const struct got_error *(*cmd_main)(int, char *[]);
76 	void (*cmd_usage)(void);
77 };
78 
79 __dead static void	usage(int, int);
80 __dead static void	usage_log(void);
81 __dead static void	usage_diff(void);
82 __dead static void	usage_blame(void);
83 __dead static void	usage_tree(void);
84 __dead static void	usage_ref(void);
85 
86 static const struct got_error*	cmd_log(int, char *[]);
87 static const struct got_error*	cmd_diff(int, char *[]);
88 static const struct got_error*	cmd_blame(int, char *[]);
89 static const struct got_error*	cmd_tree(int, char *[]);
90 static const struct got_error*	cmd_ref(int, char *[]);
91 
92 static const struct tog_cmd tog_commands[] = {
93 	{ "log",	cmd_log,	usage_log },
94 	{ "diff",	cmd_diff,	usage_diff },
95 	{ "blame",	cmd_blame,	usage_blame },
96 	{ "tree",	cmd_tree,	usage_tree },
97 	{ "ref",	cmd_ref,	usage_ref },
98 };
99 
100 enum tog_view_type {
101 	TOG_VIEW_DIFF,
102 	TOG_VIEW_LOG,
103 	TOG_VIEW_BLAME,
104 	TOG_VIEW_TREE,
105 	TOG_VIEW_REF,
106 };
107 
108 enum tog_view_mode {
109 	TOG_VIEW_SPLIT_NONE,
110 	TOG_VIEW_SPLIT_VERT,
111 	TOG_VIEW_SPLIT_HRZN
112 };
113 
114 #define HSPLIT_SCALE	0.3  /* default horizontal split scale */
115 
116 #define TOG_EOF_STRING	"(END)"
117 
118 struct commit_queue_entry {
119 	TAILQ_ENTRY(commit_queue_entry) entry;
120 	struct got_object_id *id;
121 	struct got_commit_object *commit;
122 	int idx;
123 };
124 TAILQ_HEAD(commit_queue_head, commit_queue_entry);
125 struct commit_queue {
126 	int ncommits;
127 	struct commit_queue_head head;
128 };
129 
130 struct tog_color {
131 	STAILQ_ENTRY(tog_color) entry;
132 	regex_t regex;
133 	short colorpair;
134 };
135 STAILQ_HEAD(tog_colors, tog_color);
136 
137 static struct got_reflist_head tog_refs = TAILQ_HEAD_INITIALIZER(tog_refs);
138 static struct got_reflist_object_id_map *tog_refs_idmap;
139 static enum got_diff_algorithm tog_diff_algo = GOT_DIFF_ALGORITHM_MYERS;
140 
141 static const struct got_error *
142 tog_ref_cmp_by_name(void *arg, int *cmp, struct got_reference *re1,
143     struct got_reference* re2)
144 {
145 	const char *name1 = got_ref_get_name(re1);
146 	const char *name2 = got_ref_get_name(re2);
147 	int isbackup1, isbackup2;
148 
149 	/* Sort backup refs towards the bottom of the list. */
150 	isbackup1 = strncmp(name1, "refs/got/backup/", 16) == 0;
151 	isbackup2 = strncmp(name2, "refs/got/backup/", 16) == 0;
152 	if (!isbackup1 && isbackup2) {
153 		*cmp = -1;
154 		return NULL;
155 	} else if (isbackup1 && !isbackup2) {
156 		*cmp = 1;
157 		return NULL;
158 	}
159 
160 	*cmp = got_path_cmp(name1, name2, strlen(name1), strlen(name2));
161 	return NULL;
162 }
163 
164 static const struct got_error *
165 tog_load_refs(struct got_repository *repo, int sort_by_date)
166 {
167 	const struct got_error *err;
168 
169 	err = got_ref_list(&tog_refs, repo, NULL, sort_by_date ?
170 	    got_ref_cmp_by_commit_timestamp_descending : tog_ref_cmp_by_name,
171 	    repo);
172 	if (err)
173 		return err;
174 
175 	return got_reflist_object_id_map_create(&tog_refs_idmap, &tog_refs,
176 	    repo);
177 }
178 
179 static void
180 tog_free_refs(void)
181 {
182 	if (tog_refs_idmap) {
183 		got_reflist_object_id_map_free(tog_refs_idmap);
184 		tog_refs_idmap = NULL;
185 	}
186 	got_ref_list_free(&tog_refs);
187 }
188 
189 static const struct got_error *
190 add_color(struct tog_colors *colors, const char *pattern,
191     int idx, short color)
192 {
193 	const struct got_error *err = NULL;
194 	struct tog_color *tc;
195 	int regerr = 0;
196 
197 	if (idx < 1 || idx > COLOR_PAIRS - 1)
198 		return NULL;
199 
200 	init_pair(idx, color, -1);
201 
202 	tc = calloc(1, sizeof(*tc));
203 	if (tc == NULL)
204 		return got_error_from_errno("calloc");
205 	regerr = regcomp(&tc->regex, pattern,
206 	    REG_EXTENDED | REG_NOSUB | REG_NEWLINE);
207 	if (regerr) {
208 		static char regerr_msg[512];
209 		static char err_msg[512];
210 		regerror(regerr, &tc->regex, regerr_msg,
211 		    sizeof(regerr_msg));
212 		snprintf(err_msg, sizeof(err_msg), "regcomp: %s",
213 		    regerr_msg);
214 		err = got_error_msg(GOT_ERR_REGEX, err_msg);
215 		free(tc);
216 		return err;
217 	}
218 	tc->colorpair = idx;
219 	STAILQ_INSERT_HEAD(colors, tc, entry);
220 	return NULL;
221 }
222 
223 static void
224 free_colors(struct tog_colors *colors)
225 {
226 	struct tog_color *tc;
227 
228 	while (!STAILQ_EMPTY(colors)) {
229 		tc = STAILQ_FIRST(colors);
230 		STAILQ_REMOVE_HEAD(colors, entry);
231 		regfree(&tc->regex);
232 		free(tc);
233 	}
234 }
235 
236 static struct tog_color *
237 get_color(struct tog_colors *colors, int colorpair)
238 {
239 	struct tog_color *tc = NULL;
240 
241 	STAILQ_FOREACH(tc, colors, entry) {
242 		if (tc->colorpair == colorpair)
243 			return tc;
244 	}
245 
246 	return NULL;
247 }
248 
249 static int
250 default_color_value(const char *envvar)
251 {
252 	if (strcmp(envvar, "TOG_COLOR_DIFF_MINUS") == 0)
253 		return COLOR_MAGENTA;
254 	if (strcmp(envvar, "TOG_COLOR_DIFF_PLUS") == 0)
255 		return COLOR_CYAN;
256 	if (strcmp(envvar, "TOG_COLOR_DIFF_CHUNK_HEADER") == 0)
257 		return COLOR_YELLOW;
258 	if (strcmp(envvar, "TOG_COLOR_DIFF_META") == 0)
259 		return COLOR_GREEN;
260 	if (strcmp(envvar, "TOG_COLOR_TREE_SUBMODULE") == 0)
261 		return COLOR_MAGENTA;
262 	if (strcmp(envvar, "TOG_COLOR_TREE_SYMLINK") == 0)
263 		return COLOR_MAGENTA;
264 	if (strcmp(envvar, "TOG_COLOR_TREE_DIRECTORY") == 0)
265 		return COLOR_CYAN;
266 	if (strcmp(envvar, "TOG_COLOR_TREE_EXECUTABLE") == 0)
267 		return COLOR_GREEN;
268 	if (strcmp(envvar, "TOG_COLOR_COMMIT") == 0)
269 		return COLOR_GREEN;
270 	if (strcmp(envvar, "TOG_COLOR_AUTHOR") == 0)
271 		return COLOR_CYAN;
272 	if (strcmp(envvar, "TOG_COLOR_DATE") == 0)
273 		return COLOR_YELLOW;
274 	if (strcmp(envvar, "TOG_COLOR_REFS_HEADS") == 0)
275 		return COLOR_GREEN;
276 	if (strcmp(envvar, "TOG_COLOR_REFS_TAGS") == 0)
277 		return COLOR_MAGENTA;
278 	if (strcmp(envvar, "TOG_COLOR_REFS_REMOTES") == 0)
279 		return COLOR_YELLOW;
280 	if (strcmp(envvar, "TOG_COLOR_REFS_BACKUP") == 0)
281 		return COLOR_CYAN;
282 
283 	return -1;
284 }
285 
286 static int
287 get_color_value(const char *envvar)
288 {
289 	const char *val = getenv(envvar);
290 
291 	if (val == NULL)
292 		return default_color_value(envvar);
293 
294 	if (strcasecmp(val, "black") == 0)
295 		return COLOR_BLACK;
296 	if (strcasecmp(val, "red") == 0)
297 		return COLOR_RED;
298 	if (strcasecmp(val, "green") == 0)
299 		return COLOR_GREEN;
300 	if (strcasecmp(val, "yellow") == 0)
301 		return COLOR_YELLOW;
302 	if (strcasecmp(val, "blue") == 0)
303 		return COLOR_BLUE;
304 	if (strcasecmp(val, "magenta") == 0)
305 		return COLOR_MAGENTA;
306 	if (strcasecmp(val, "cyan") == 0)
307 		return COLOR_CYAN;
308 	if (strcasecmp(val, "white") == 0)
309 		return COLOR_WHITE;
310 	if (strcasecmp(val, "default") == 0)
311 		return -1;
312 
313 	return default_color_value(envvar);
314 }
315 
316 
317 struct tog_diff_view_state {
318 	struct got_object_id *id1, *id2;
319 	const char *label1, *label2;
320 	FILE *f, *f1, *f2;
321 	int fd1, fd2;
322 	int first_displayed_line;
323 	int last_displayed_line;
324 	int eof;
325 	int diff_context;
326 	int ignore_whitespace;
327 	int force_text_diff;
328 	struct got_repository *repo;
329 	struct tog_colors colors;
330 	size_t nlines;
331 	off_t *line_offsets;
332 	int matched_line;
333 	int selected_line;
334 
335 	/* passed from log or blame view; may be NULL */
336 	struct tog_view *parent_view;
337 };
338 
339 pthread_mutex_t tog_mutex = PTHREAD_MUTEX_INITIALIZER;
340 static volatile sig_atomic_t tog_thread_error;
341 
342 struct tog_log_thread_args {
343 	pthread_cond_t need_commits;
344 	pthread_cond_t commit_loaded;
345 	int commits_needed;
346 	int load_all;
347 	struct got_commit_graph *graph;
348 	struct commit_queue *commits;
349 	const char *in_repo_path;
350 	struct got_object_id *start_id;
351 	struct got_repository *repo;
352 	int *pack_fds;
353 	int log_complete;
354 	sig_atomic_t *quit;
355 	struct commit_queue_entry **first_displayed_entry;
356 	struct commit_queue_entry **selected_entry;
357 	int *searching;
358 	int *search_next_done;
359 	regex_t *regex;
360 };
361 
362 struct tog_log_view_state {
363 	struct commit_queue commits;
364 	struct commit_queue_entry *first_displayed_entry;
365 	struct commit_queue_entry *last_displayed_entry;
366 	struct commit_queue_entry *selected_entry;
367 	int selected;
368 	char *in_repo_path;
369 	char *head_ref_name;
370 	int log_branches;
371 	struct got_repository *repo;
372 	struct got_object_id *start_id;
373 	sig_atomic_t quit;
374 	pthread_t thread;
375 	struct tog_log_thread_args thread_args;
376 	struct commit_queue_entry *matched_entry;
377 	struct commit_queue_entry *search_entry;
378 	struct tog_colors colors;
379 	int use_committer;
380 };
381 
382 #define TOG_COLOR_DIFF_MINUS		1
383 #define TOG_COLOR_DIFF_PLUS		2
384 #define TOG_COLOR_DIFF_CHUNK_HEADER	3
385 #define TOG_COLOR_DIFF_META		4
386 #define TOG_COLOR_TREE_SUBMODULE	5
387 #define TOG_COLOR_TREE_SYMLINK		6
388 #define TOG_COLOR_TREE_DIRECTORY	7
389 #define TOG_COLOR_TREE_EXECUTABLE	8
390 #define TOG_COLOR_COMMIT		9
391 #define TOG_COLOR_AUTHOR		10
392 #define TOG_COLOR_DATE			11
393 #define TOG_COLOR_REFS_HEADS		12
394 #define TOG_COLOR_REFS_TAGS		13
395 #define TOG_COLOR_REFS_REMOTES		14
396 #define TOG_COLOR_REFS_BACKUP		15
397 
398 struct tog_blame_cb_args {
399 	struct tog_blame_line *lines; /* one per line */
400 	int nlines;
401 
402 	struct tog_view *view;
403 	struct got_object_id *commit_id;
404 	int *quit;
405 };
406 
407 struct tog_blame_thread_args {
408 	const char *path;
409 	struct got_repository *repo;
410 	struct tog_blame_cb_args *cb_args;
411 	int *complete;
412 	got_cancel_cb cancel_cb;
413 	void *cancel_arg;
414 };
415 
416 struct tog_blame {
417 	FILE *f;
418 	off_t filesize;
419 	struct tog_blame_line *lines;
420 	int nlines;
421 	off_t *line_offsets;
422 	pthread_t thread;
423 	struct tog_blame_thread_args thread_args;
424 	struct tog_blame_cb_args cb_args;
425 	const char *path;
426 	int *pack_fds;
427 };
428 
429 struct tog_blame_view_state {
430 	int first_displayed_line;
431 	int last_displayed_line;
432 	int selected_line;
433 	int last_diffed_line;
434 	int blame_complete;
435 	int eof;
436 	int done;
437 	struct got_object_id_queue blamed_commits;
438 	struct got_object_qid *blamed_commit;
439 	char *path;
440 	struct got_repository *repo;
441 	struct got_object_id *commit_id;
442 	struct tog_blame blame;
443 	int matched_line;
444 	struct tog_colors colors;
445 };
446 
447 struct tog_parent_tree {
448 	TAILQ_ENTRY(tog_parent_tree) entry;
449 	struct got_tree_object *tree;
450 	struct got_tree_entry *first_displayed_entry;
451 	struct got_tree_entry *selected_entry;
452 	int selected;
453 };
454 
455 TAILQ_HEAD(tog_parent_trees, tog_parent_tree);
456 
457 struct tog_tree_view_state {
458 	char *tree_label;
459 	struct got_object_id *commit_id;/* commit which this tree belongs to */
460 	struct got_tree_object *root;	/* the commit's root tree entry */
461 	struct got_tree_object *tree;	/* currently displayed (sub-)tree */
462 	struct got_tree_entry *first_displayed_entry;
463 	struct got_tree_entry *last_displayed_entry;
464 	struct got_tree_entry *selected_entry;
465 	int ndisplayed, selected, show_ids;
466 	struct tog_parent_trees parents; /* parent trees of current sub-tree */
467 	char *head_ref_name;
468 	struct got_repository *repo;
469 	struct got_tree_entry *matched_entry;
470 	struct tog_colors colors;
471 };
472 
473 struct tog_reflist_entry {
474 	TAILQ_ENTRY(tog_reflist_entry) entry;
475 	struct got_reference *ref;
476 	int idx;
477 };
478 
479 TAILQ_HEAD(tog_reflist_head, tog_reflist_entry);
480 
481 struct tog_ref_view_state {
482 	struct tog_reflist_head refs;
483 	struct tog_reflist_entry *first_displayed_entry;
484 	struct tog_reflist_entry *last_displayed_entry;
485 	struct tog_reflist_entry *selected_entry;
486 	int nrefs, ndisplayed, selected, show_date, show_ids, sort_by_date;
487 	struct got_repository *repo;
488 	struct tog_reflist_entry *matched_entry;
489 	struct tog_colors colors;
490 };
491 
492 /*
493  * We implement two types of views: parent views and child views.
494  *
495  * The 'Tab' key switches focus between a parent view and its child view.
496  * Child views are shown side-by-side to their parent view, provided
497  * there is enough screen estate.
498  *
499  * When a new view is opened from within a parent view, this new view
500  * becomes a child view of the parent view, replacing any existing child.
501  *
502  * When a new view is opened from within a child view, this new view
503  * becomes a parent view which will obscure the views below until the
504  * user quits the new parent view by typing 'q'.
505  *
506  * This list of views contains parent views only.
507  * Child views are only pointed to by their parent view.
508  */
509 TAILQ_HEAD(tog_view_list_head, tog_view);
510 
511 struct tog_view {
512 	TAILQ_ENTRY(tog_view) entry;
513 	WINDOW *window;
514 	PANEL *panel;
515 	int nlines, ncols, begin_y, begin_x; /* based on split height/width */
516 	int resized_y, resized_x; /* begin_y/x based on user resizing */
517 	int maxx, x; /* max column and current start column */
518 	int lines, cols; /* copies of LINES and COLS */
519 	int nscrolled, offset; /* lines scrolled and hsplit line offset */
520 	int ch, count; /* current keymap and count prefix */
521 	int resized; /* set when in a resize event */
522 	int focussed; /* Only set on one parent or child view at a time. */
523 	int dying;
524 	struct tog_view *parent;
525 	struct tog_view *child;
526 
527 	/*
528 	 * This flag is initially set on parent views when a new child view
529 	 * is created. It gets toggled when the 'Tab' key switches focus
530 	 * between parent and child.
531 	 * The flag indicates whether focus should be passed on to our child
532 	 * view if this parent view gets picked for focus after another parent
533 	 * view was closed. This prevents child views from losing focus in such
534 	 * situations.
535 	 */
536 	int focus_child;
537 
538 	enum tog_view_mode mode;
539 	/* type-specific state */
540 	enum tog_view_type type;
541 	union {
542 		struct tog_diff_view_state diff;
543 		struct tog_log_view_state log;
544 		struct tog_blame_view_state blame;
545 		struct tog_tree_view_state tree;
546 		struct tog_ref_view_state ref;
547 	} state;
548 
549 	const struct got_error *(*show)(struct tog_view *);
550 	const struct got_error *(*input)(struct tog_view **,
551 	    struct tog_view *, int);
552 	const struct got_error *(*reset)(struct tog_view *);
553 	const struct got_error *(*resize)(struct tog_view *, int);
554 	const struct got_error *(*close)(struct tog_view *);
555 
556 	const struct got_error *(*search_start)(struct tog_view *);
557 	const struct got_error *(*search_next)(struct tog_view *);
558 	int search_started;
559 	int searching;
560 #define TOG_SEARCH_FORWARD	1
561 #define TOG_SEARCH_BACKWARD	2
562 	int search_next_done;
563 #define TOG_SEARCH_HAVE_MORE	1
564 #define TOG_SEARCH_NO_MORE	2
565 #define TOG_SEARCH_HAVE_NONE	3
566 	regex_t regex;
567 	regmatch_t regmatch;
568 };
569 
570 static const struct got_error *open_diff_view(struct tog_view *,
571     struct got_object_id *, struct got_object_id *,
572     const char *, const char *, int, int, int, struct tog_view *,
573     struct got_repository *);
574 static const struct got_error *show_diff_view(struct tog_view *);
575 static const struct got_error *input_diff_view(struct tog_view **,
576     struct tog_view *, int);
577 static const struct got_error *reset_diff_view(struct tog_view *);
578 static const struct got_error* close_diff_view(struct tog_view *);
579 static const struct got_error *search_start_diff_view(struct tog_view *);
580 static const struct got_error *search_next_diff_view(struct tog_view *);
581 
582 static const struct got_error *open_log_view(struct tog_view *,
583     struct got_object_id *, struct got_repository *,
584     const char *, const char *, int);
585 static const struct got_error * show_log_view(struct tog_view *);
586 static const struct got_error *input_log_view(struct tog_view **,
587     struct tog_view *, int);
588 static const struct got_error *resize_log_view(struct tog_view *, int);
589 static const struct got_error *close_log_view(struct tog_view *);
590 static const struct got_error *search_start_log_view(struct tog_view *);
591 static const struct got_error *search_next_log_view(struct tog_view *);
592 
593 static const struct got_error *open_blame_view(struct tog_view *, char *,
594     struct got_object_id *, struct got_repository *);
595 static const struct got_error *show_blame_view(struct tog_view *);
596 static const struct got_error *input_blame_view(struct tog_view **,
597     struct tog_view *, int);
598 static const struct got_error *reset_blame_view(struct tog_view *);
599 static const struct got_error *close_blame_view(struct tog_view *);
600 static const struct got_error *search_start_blame_view(struct tog_view *);
601 static const struct got_error *search_next_blame_view(struct tog_view *);
602 
603 static const struct got_error *open_tree_view(struct tog_view *,
604     struct got_object_id *, const char *, struct got_repository *);
605 static const struct got_error *show_tree_view(struct tog_view *);
606 static const struct got_error *input_tree_view(struct tog_view **,
607     struct tog_view *, int);
608 static const struct got_error *close_tree_view(struct tog_view *);
609 static const struct got_error *search_start_tree_view(struct tog_view *);
610 static const struct got_error *search_next_tree_view(struct tog_view *);
611 
612 static const struct got_error *open_ref_view(struct tog_view *,
613     struct got_repository *);
614 static const struct got_error *show_ref_view(struct tog_view *);
615 static const struct got_error *input_ref_view(struct tog_view **,
616     struct tog_view *, int);
617 static const struct got_error *close_ref_view(struct tog_view *);
618 static const struct got_error *search_start_ref_view(struct tog_view *);
619 static const struct got_error *search_next_ref_view(struct tog_view *);
620 
621 static volatile sig_atomic_t tog_sigwinch_received;
622 static volatile sig_atomic_t tog_sigpipe_received;
623 static volatile sig_atomic_t tog_sigcont_received;
624 static volatile sig_atomic_t tog_sigint_received;
625 static volatile sig_atomic_t tog_sigterm_received;
626 
627 static void
628 tog_sigwinch(int signo)
629 {
630 	tog_sigwinch_received = 1;
631 }
632 
633 static void
634 tog_sigpipe(int signo)
635 {
636 	tog_sigpipe_received = 1;
637 }
638 
639 static void
640 tog_sigcont(int signo)
641 {
642 	tog_sigcont_received = 1;
643 }
644 
645 static void
646 tog_sigint(int signo)
647 {
648 	tog_sigint_received = 1;
649 }
650 
651 static void
652 tog_sigterm(int signo)
653 {
654 	tog_sigterm_received = 1;
655 }
656 
657 static int
658 tog_fatal_signal_received(void)
659 {
660 	return (tog_sigpipe_received ||
661 	    tog_sigint_received || tog_sigint_received);
662 }
663 
664 static const struct got_error *
665 view_close(struct tog_view *view)
666 {
667 	const struct got_error *err = NULL, *child_err = NULL;
668 
669 	if (view->child) {
670 		child_err = view_close(view->child);
671 		view->child = NULL;
672 	}
673 	if (view->close)
674 		err = view->close(view);
675 	if (view->panel)
676 		del_panel(view->panel);
677 	if (view->window)
678 		delwin(view->window);
679 	free(view);
680 	return err ? err : child_err;
681 }
682 
683 static struct tog_view *
684 view_open(int nlines, int ncols, int begin_y, int begin_x,
685     enum tog_view_type type)
686 {
687 	struct tog_view *view = calloc(1, sizeof(*view));
688 
689 	if (view == NULL)
690 		return NULL;
691 
692 	view->type = type;
693 	view->lines = LINES;
694 	view->cols = COLS;
695 	view->nlines = nlines ? nlines : LINES - begin_y;
696 	view->ncols = ncols ? ncols : COLS - begin_x;
697 	view->begin_y = begin_y;
698 	view->begin_x = begin_x;
699 	view->window = newwin(nlines, ncols, begin_y, begin_x);
700 	if (view->window == NULL) {
701 		view_close(view);
702 		return NULL;
703 	}
704 	view->panel = new_panel(view->window);
705 	if (view->panel == NULL ||
706 	    set_panel_userptr(view->panel, view) != OK) {
707 		view_close(view);
708 		return NULL;
709 	}
710 
711 	keypad(view->window, TRUE);
712 	return view;
713 }
714 
715 static int
716 view_split_begin_x(int begin_x)
717 {
718 	if (begin_x > 0 || COLS < 120)
719 		return 0;
720 	return (COLS - MAX(COLS / 2, 80));
721 }
722 
723 /* XXX Stub till we decide what to do. */
724 static int
725 view_split_begin_y(int lines)
726 {
727 	return lines * HSPLIT_SCALE;
728 }
729 
730 static const struct got_error *view_resize(struct tog_view *);
731 
732 static const struct got_error *
733 view_splitscreen(struct tog_view *view)
734 {
735 	const struct got_error *err = NULL;
736 
737 	if (!view->resized && view->mode == TOG_VIEW_SPLIT_HRZN) {
738 		if (view->resized_y && view->resized_y < view->lines)
739 			view->begin_y = view->resized_y;
740 		else
741 			view->begin_y = view_split_begin_y(view->nlines);
742 		view->begin_x = 0;
743 	} else if (!view->resized) {
744 		if (view->resized_x && view->resized_x < view->cols - 1 &&
745 		    view->cols > 119)
746 			view->begin_x = view->resized_x;
747 		else
748 			view->begin_x = view_split_begin_x(0);
749 		view->begin_y = 0;
750 	}
751 	view->nlines = LINES - view->begin_y;
752 	view->ncols = COLS - view->begin_x;
753 	view->lines = LINES;
754 	view->cols = COLS;
755 	err = view_resize(view);
756 	if (err)
757 		return err;
758 
759 	if (view->parent && view->mode == TOG_VIEW_SPLIT_HRZN)
760 		view->parent->nlines = view->begin_y;
761 
762 	if (mvwin(view->window, view->begin_y, view->begin_x) == ERR)
763 		return got_error_from_errno("mvwin");
764 
765 	return NULL;
766 }
767 
768 static const struct got_error *
769 view_fullscreen(struct tog_view *view)
770 {
771 	const struct got_error *err = NULL;
772 
773 	view->begin_x = 0;
774 	view->begin_y = view->resized ? view->begin_y : 0;
775 	view->nlines = view->resized ? view->nlines : LINES;
776 	view->ncols = COLS;
777 	view->lines = LINES;
778 	view->cols = COLS;
779 	err = view_resize(view);
780 	if (err)
781 		return err;
782 
783 	if (mvwin(view->window, view->begin_y, view->begin_x) == ERR)
784 		return got_error_from_errno("mvwin");
785 
786 	return NULL;
787 }
788 
789 static int
790 view_is_parent_view(struct tog_view *view)
791 {
792 	return view->parent == NULL;
793 }
794 
795 static int
796 view_is_splitscreen(struct tog_view *view)
797 {
798 	return view->begin_x > 0 || view->begin_y > 0;
799 }
800 
801 static int
802 view_is_fullscreen(struct tog_view *view)
803 {
804 	return view->nlines == LINES && view->ncols == COLS;
805 }
806 
807 static int
808 view_is_hsplit_top(struct tog_view *view)
809 {
810 	return view->mode == TOG_VIEW_SPLIT_HRZN && view->child &&
811 	    view_is_splitscreen(view->child);
812 }
813 
814 static void
815 view_border(struct tog_view *view)
816 {
817 	PANEL *panel;
818 	const struct tog_view *view_above;
819 
820 	if (view->parent)
821 		return view_border(view->parent);
822 
823 	panel = panel_above(view->panel);
824 	if (panel == NULL)
825 		return;
826 
827 	view_above = panel_userptr(panel);
828 	if (view->mode == TOG_VIEW_SPLIT_HRZN)
829 		mvwhline(view->window, view_above->begin_y - 1,
830 		    view->begin_x, got_locale_is_utf8() ?
831 		    ACS_HLINE : '-', view->ncols);
832 	else
833 		mvwvline(view->window, view->begin_y, view_above->begin_x - 1,
834 		    got_locale_is_utf8() ? ACS_VLINE : '|', view->nlines);
835 }
836 
837 static const struct got_error *view_init_hsplit(struct tog_view *, int);
838 static const struct got_error *request_log_commits(struct tog_view *);
839 static const struct got_error *offset_selection_down(struct tog_view *);
840 static void offset_selection_up(struct tog_view *);
841 static void view_get_split(struct tog_view *, int *, int *);
842 
843 static const struct got_error *
844 view_resize(struct tog_view *view)
845 {
846 	const struct got_error	*err = NULL;
847 	int			 dif, nlines, ncols;
848 
849 	dif = LINES - view->lines;  /* line difference */
850 
851 	if (view->lines > LINES)
852 		nlines = view->nlines - (view->lines - LINES);
853 	else
854 		nlines = view->nlines + (LINES - view->lines);
855 	if (view->cols > COLS)
856 		ncols = view->ncols - (view->cols - COLS);
857 	else
858 		ncols = view->ncols + (COLS - view->cols);
859 
860 	if (view->child) {
861 		int hs = view->child->begin_y;
862 
863 		if (!view_is_fullscreen(view))
864 			view->child->begin_x = view_split_begin_x(view->begin_x);
865 		if (view->mode == TOG_VIEW_SPLIT_HRZN ||
866 		    view->child->begin_x == 0) {
867 			ncols = COLS;
868 
869 			view_fullscreen(view->child);
870 			if (view->child->focussed)
871 				show_panel(view->child->panel);
872 			else
873 				show_panel(view->panel);
874 		} else {
875 			ncols = view->child->begin_x;
876 
877 			view_splitscreen(view->child);
878 			show_panel(view->child->panel);
879 		}
880 		/*
881 		 * XXX This is ugly and needs to be moved into the above
882 		 * logic but "works" for now and my attempts at moving it
883 		 * break either 'tab' or 'F' key maps in horizontal splits.
884 		 */
885 		if (hs) {
886 			err = view_splitscreen(view->child);
887 			if (err)
888 				return err;
889 			if (dif < 0) { /* top split decreased */
890 				err = offset_selection_down(view);
891 				if (err)
892 					return err;
893 			}
894 			view_border(view);
895 			update_panels();
896 			doupdate();
897 			show_panel(view->child->panel);
898 			nlines = view->nlines;
899 		}
900 	} else if (view->parent == NULL)
901 		ncols = COLS;
902 
903 	if (view->resize && dif > 0) {
904 		err = view->resize(view, dif);
905 		if (err)
906 			return err;
907 	}
908 
909 	if (wresize(view->window, nlines, ncols) == ERR)
910 		return got_error_from_errno("wresize");
911 	if (replace_panel(view->panel, view->window) == ERR)
912 		return got_error_from_errno("replace_panel");
913 	wclear(view->window);
914 
915 	view->nlines = nlines;
916 	view->ncols = ncols;
917 	view->lines = LINES;
918 	view->cols = COLS;
919 
920 	return NULL;
921 }
922 
923 static const struct got_error *
924 resize_log_view(struct tog_view *view, int increase)
925 {
926 	struct tog_log_view_state *s = &view->state.log;
927 	const struct got_error *err = NULL;
928 	int n = s->selected_entry->idx + view->lines - s->selected;
929 
930 	/*
931 	 * Request commits to account for the increased
932 	 * height so we have enough to populate the view.
933 	 */
934 	if (s->commits.ncommits < n) {
935 		view->nscrolled = n - s->commits.ncommits + increase + 1;
936 		err = request_log_commits(view);
937 	}
938 
939 	return err;
940 }
941 
942 static void
943 view_adjust_offset(struct tog_view *view, int n)
944 {
945 	if (n == 0)
946 		return;
947 
948 	if (view->parent && view->parent->offset) {
949 		if (view->parent->offset + n >= 0)
950 			view->parent->offset += n;
951 		else
952 			view->parent->offset = 0;
953 	} else if (view->offset) {
954 		if (view->offset - n >= 0)
955 			view->offset -= n;
956 		else
957 			view->offset = 0;
958 	}
959 }
960 
961 static const struct got_error *
962 view_resize_split(struct tog_view *view, int resize)
963 {
964 	const struct got_error	*err = NULL;
965 	struct tog_view		*v = NULL;
966 
967 	if (view->parent)
968 		v = view->parent;
969 	else
970 		v = view;
971 
972 	if (!v->child || !view_is_splitscreen(v->child))
973 		return NULL;
974 
975 	v->resized = v->child->resized = resize;  /* lock for resize event */
976 
977 	if (view->mode == TOG_VIEW_SPLIT_HRZN) {
978 		int y = v->child->begin_y;
979 
980 		if (v->child->resized_y)
981 			v->child->begin_y = v->child->resized_y;
982 		if (view->parent)
983 			v->child->begin_y -= resize;
984 		else
985 			v->child->begin_y += resize;
986 		if (v->child->begin_y < 3) {
987 			view->count = 0;
988 			v->child->begin_y = 3;
989 		} else if (v->child->begin_y > LINES - 1) {
990 			view->count = 0;
991 			v->child->begin_y = LINES - 1;
992 		}
993 		v->ncols = COLS;
994 		v->child->ncols = COLS;
995 		view_adjust_offset(view, resize);
996 		err = view_init_hsplit(v, v->child->begin_y);
997 		if (err)
998 			return err;
999 		v->child->resized_y = v->child->begin_y;
1000 		if (y > v->child->begin_y && v->child->type == TOG_VIEW_LOG)
1001 			v->child->nscrolled = y - v->child->begin_y;
1002 		else if (y < v->child->begin_y && v->type == TOG_VIEW_LOG)
1003 			v->nscrolled = v->child->begin_y - y;
1004 	} else {
1005 		if (v->child->resized_x)
1006 			v->child->begin_x = v->child->resized_x;
1007 		if (view->parent)
1008 			v->child->begin_x -= resize;
1009 		else
1010 			v->child->begin_x += resize;
1011 		if (v->child->begin_x < 11) {
1012 			view->count = 0;
1013 			v->child->begin_x = 11;
1014 		} else if (v->child->begin_x > COLS - 1) {
1015 			view->count = 0;
1016 			v->child->begin_x = COLS - 1;
1017 		}
1018 		v->child->resized_x = v->child->begin_x;
1019 	}
1020 
1021 	v->child->mode = v->mode;
1022 	v->child->nlines = v->lines - v->child->begin_y;
1023 	v->child->ncols = v->cols - v->child->begin_x;
1024 	v->focus_child = 1;
1025 
1026 	err = view_fullscreen(v);
1027 	if (err)
1028 		return err;
1029 	err = view_splitscreen(v->child);
1030 	if (err)
1031 		return err;
1032 
1033 	if (v->mode == TOG_VIEW_SPLIT_HRZN) {
1034 		err = offset_selection_down(v->child);
1035 		if (err)
1036 			return err;
1037 	}
1038 
1039 	if (v->nscrolled)
1040 		err = request_log_commits(v);
1041 	else if (v->child->nscrolled)
1042 		err = request_log_commits(v->child);
1043 
1044 	v->resized = v->child->resized = 0;
1045 
1046 	return err;
1047 }
1048 
1049 static void
1050 view_transfer_size(struct tog_view *dst, struct tog_view *src)
1051 {
1052 	struct tog_view *v = src->child ? src->child : src;
1053 
1054 	dst->resized_x = v->resized_x;
1055 	dst->resized_y = v->resized_y;
1056 }
1057 
1058 static const struct got_error *
1059 view_close_child(struct tog_view *view)
1060 {
1061 	const struct got_error *err = NULL;
1062 
1063 	if (view->child == NULL)
1064 		return NULL;
1065 
1066 	err = view_close(view->child);
1067 	view->child = NULL;
1068 	return err;
1069 }
1070 
1071 static const struct got_error *
1072 view_set_child(struct tog_view *view, struct tog_view *child)
1073 {
1074 	const struct got_error *err = NULL;
1075 
1076 	view->child = child;
1077 	child->parent = view;
1078 
1079 	err = view_resize(view);
1080 	if (err)
1081 		return err;
1082 
1083 	if (view->child->resized_x || view->child->resized_y)
1084 		err = view_resize_split(view, 0);
1085 
1086 	return err;
1087 }
1088 
1089 static void
1090 tog_resizeterm(void)
1091 {
1092 	int cols, lines;
1093 	struct winsize size;
1094 
1095 	if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &size) < 0) {
1096 		cols = 80;     /* Default */
1097 		lines = 24;
1098 	} else {
1099 		cols = size.ws_col;
1100 		lines = size.ws_row;
1101 	}
1102 	resize_term(lines, cols);
1103 }
1104 
1105 static const struct got_error *
1106 view_search_start(struct tog_view *view)
1107 {
1108 	const struct got_error *err = NULL;
1109 	struct tog_view *v = view;
1110 	char pattern[1024];
1111 	int ret;
1112 
1113 	if (view->search_started) {
1114 		regfree(&view->regex);
1115 		view->searching = 0;
1116 		memset(&view->regmatch, 0, sizeof(view->regmatch));
1117 	}
1118 	view->search_started = 0;
1119 
1120 	if (view->nlines < 1)
1121 		return NULL;
1122 
1123 	if (view_is_hsplit_top(view))
1124 		v = view->child;
1125 
1126 	mvwaddstr(v->window, v->nlines - 1, 0, "/");
1127 	wclrtoeol(v->window);
1128 
1129 	nodelay(view->window, FALSE);  /* block for search term input */
1130 	nocbreak();
1131 	echo();
1132 	ret = wgetnstr(v->window, pattern, sizeof(pattern));
1133 	wrefresh(v->window);
1134 	cbreak();
1135 	noecho();
1136 	nodelay(view->window, TRUE);
1137 	if (ret == ERR)
1138 		return NULL;
1139 
1140 	if (regcomp(&view->regex, pattern, REG_EXTENDED | REG_NEWLINE) == 0) {
1141 		err = view->search_start(view);
1142 		if (err) {
1143 			regfree(&view->regex);
1144 			return err;
1145 		}
1146 		view->search_started = 1;
1147 		view->searching = TOG_SEARCH_FORWARD;
1148 		view->search_next_done = 0;
1149 		view->search_next(view);
1150 	}
1151 
1152 	return NULL;
1153 }
1154 
1155 /* Switch split mode. If view is a parent or child, draw the new splitscreen. */
1156 static const struct got_error *
1157 switch_split(struct tog_view *view)
1158 {
1159 	const struct got_error	*err = NULL;
1160 	struct tog_view		*v = NULL;
1161 
1162 	if (view->parent)
1163 		v = view->parent;
1164 	else
1165 		v = view;
1166 
1167 	if (v->mode == TOG_VIEW_SPLIT_HRZN)
1168 		v->mode = TOG_VIEW_SPLIT_VERT;
1169 	else
1170 		v->mode = TOG_VIEW_SPLIT_HRZN;
1171 
1172 	if (!v->child)
1173 		return NULL;
1174 	else if (v->mode == TOG_VIEW_SPLIT_VERT && v->cols < 120)
1175 		v->mode = TOG_VIEW_SPLIT_NONE;
1176 
1177 	view_get_split(v, &v->child->begin_y, &v->child->begin_x);
1178 	if (v->mode == TOG_VIEW_SPLIT_HRZN && v->child->resized_y)
1179 		v->child->begin_y = v->child->resized_y;
1180 	else if (v->mode == TOG_VIEW_SPLIT_VERT && v->child->resized_x)
1181 		v->child->begin_x = v->child->resized_x;
1182 
1183 
1184 	if (v->mode == TOG_VIEW_SPLIT_HRZN) {
1185 		v->ncols = COLS;
1186 		v->child->ncols = COLS;
1187 		v->child->nscrolled = LINES - v->child->nlines;
1188 
1189 		err = view_init_hsplit(v, v->child->begin_y);
1190 		if (err)
1191 			return err;
1192 	}
1193 	v->child->mode = v->mode;
1194 	v->child->nlines = v->lines - v->child->begin_y;
1195 	v->focus_child = 1;
1196 
1197 	err = view_fullscreen(v);
1198 	if (err)
1199 		return err;
1200 	err = view_splitscreen(v->child);
1201 	if (err)
1202 		return err;
1203 
1204 	if (v->mode == TOG_VIEW_SPLIT_NONE)
1205 		v->mode = TOG_VIEW_SPLIT_VERT;
1206 	if (v->mode == TOG_VIEW_SPLIT_HRZN) {
1207 		err = offset_selection_down(v);
1208 		err = offset_selection_down(v->child);
1209 	} else {
1210 		offset_selection_up(v);
1211 		offset_selection_up(v->child);
1212 	}
1213 	if (v->resize)
1214 		err = v->resize(v, 0);
1215 	else if (v->child->resize)
1216 		err = v->child->resize(v->child, 0);
1217 
1218 	return err;
1219 }
1220 
1221 /*
1222  * Compute view->count from numeric input. Assign total to view->count and
1223  * return first non-numeric key entered.
1224  */
1225 static int
1226 get_compound_key(struct tog_view *view, int c)
1227 {
1228 	struct tog_view	*v = view;
1229 	int		 x, n = 0;
1230 
1231 	if (view_is_hsplit_top(view))
1232 		v = view->child;
1233 	else if (view->mode == TOG_VIEW_SPLIT_VERT && view->parent)
1234 		v = view->parent;
1235 
1236 	view->count = 0;
1237 	cbreak();  /* block for input */
1238 	wmove(v->window, v->nlines - 1, 0);
1239 	wclrtoeol(v->window);
1240 	waddch(v->window, ':');
1241 
1242 	do {
1243 		x = getcurx(v->window);
1244 		if (x != ERR && x < view->ncols) {
1245 			waddch(v->window, c);
1246 			wrefresh(v->window);
1247 		}
1248 
1249 		/*
1250 		 * Don't overflow. Max valid request should be the greatest
1251 		 * between the longest and total lines; cap at 10 million.
1252 		 */
1253 		if (n >= 9999999)
1254 			n = 9999999;
1255 		else
1256 			n = n * 10 + (c - '0');
1257 	} while (((c = wgetch(view->window))) >= '0' && c <= '9' && c != ERR);
1258 
1259 	/* Massage excessive or inapplicable values at the input handler. */
1260 	view->count = n;
1261 
1262 	return c;
1263 }
1264 
1265 static const struct got_error *
1266 view_input(struct tog_view **new, int *done, struct tog_view *view,
1267     struct tog_view_list_head *views)
1268 {
1269 	const struct got_error *err = NULL;
1270 	struct tog_view *v;
1271 	int ch, errcode;
1272 
1273 	*new = NULL;
1274 
1275 	/* Clear "no matches" indicator. */
1276 	if (view->search_next_done == TOG_SEARCH_NO_MORE ||
1277 	    view->search_next_done == TOG_SEARCH_HAVE_NONE) {
1278 		view->search_next_done = TOG_SEARCH_HAVE_MORE;
1279 		view->count = 0;
1280 	}
1281 
1282 	if (view->searching && !view->search_next_done) {
1283 		errcode = pthread_mutex_unlock(&tog_mutex);
1284 		if (errcode)
1285 			return got_error_set_errno(errcode,
1286 			    "pthread_mutex_unlock");
1287 		sched_yield();
1288 		errcode = pthread_mutex_lock(&tog_mutex);
1289 		if (errcode)
1290 			return got_error_set_errno(errcode,
1291 			    "pthread_mutex_lock");
1292 		view->search_next(view);
1293 		return NULL;
1294 	}
1295 
1296 	nodelay(view->window, FALSE);
1297 	/* Allow threads to make progress while we are waiting for input. */
1298 	errcode = pthread_mutex_unlock(&tog_mutex);
1299 	if (errcode)
1300 		return got_error_set_errno(errcode, "pthread_mutex_unlock");
1301 	/* If we have an unfinished count, let C-g or backspace abort. */
1302 	if (view->count && --view->count) {
1303 		cbreak();
1304 		nodelay(view->window, TRUE);
1305 		ch = wgetch(view->window);
1306 		if (ch == CTRL('g') || ch == KEY_BACKSPACE)
1307 			view->count = 0;
1308 		else
1309 			ch = view->ch;
1310 	} else {
1311 		ch = wgetch(view->window);
1312 		if (ch >= '1' && ch  <= '9')
1313 			view->ch = ch = get_compound_key(view, ch);
1314 	}
1315 	errcode = pthread_mutex_lock(&tog_mutex);
1316 	if (errcode)
1317 		return got_error_set_errno(errcode, "pthread_mutex_lock");
1318 	nodelay(view->window, TRUE);
1319 
1320 	if (tog_sigwinch_received || tog_sigcont_received) {
1321 		tog_resizeterm();
1322 		tog_sigwinch_received = 0;
1323 		tog_sigcont_received = 0;
1324 		TAILQ_FOREACH(v, views, entry) {
1325 			err = view_resize(v);
1326 			if (err)
1327 				return err;
1328 			err = v->input(new, v, KEY_RESIZE);
1329 			if (err)
1330 				return err;
1331 			if (v->child) {
1332 				err = view_resize(v->child);
1333 				if (err)
1334 					return err;
1335 				err = v->child->input(new, v->child,
1336 				    KEY_RESIZE);
1337 				if (err)
1338 					return err;
1339 				if (v->child->resized_x || v->child->resized_y) {
1340 					err = view_resize_split(v, 0);
1341 					if (err)
1342 						return err;
1343 				}
1344 			}
1345 		}
1346 	}
1347 
1348 	switch (ch) {
1349 	case '\t':
1350 		view->count = 0;
1351 		if (view->child) {
1352 			view->focussed = 0;
1353 			view->child->focussed = 1;
1354 			view->focus_child = 1;
1355 		} else if (view->parent) {
1356 			view->focussed = 0;
1357 			view->parent->focussed = 1;
1358 			view->parent->focus_child = 0;
1359 			if (!view_is_splitscreen(view)) {
1360 				if (view->mode == TOG_VIEW_SPLIT_HRZN &&
1361 				    view->parent->type == TOG_VIEW_LOG) {
1362 					err = request_log_commits(view->parent);
1363 					if (err)
1364 						return err;
1365 				}
1366 				offset_selection_up(view->parent);
1367 				err = view_fullscreen(view->parent);
1368 				if (err)
1369 					return err;
1370 			}
1371 		}
1372 		break;
1373 	case 'q':
1374 		if (view->parent && view->mode == TOG_VIEW_SPLIT_HRZN) {
1375 			if (view->parent->type == TOG_VIEW_LOG) {
1376 				/* might need more commits to fill fullscreen */
1377 				err = request_log_commits(view->parent);
1378 				if (err)
1379 					break;
1380 			}
1381 			offset_selection_up(view->parent);
1382 		}
1383 		err = view->input(new, view, ch);
1384 		view->dying = 1;
1385 		break;
1386 	case 'Q':
1387 		*done = 1;
1388 		break;
1389 	case 'F':
1390 		view->count = 0;
1391 		if (view_is_parent_view(view)) {
1392 			if (view->child == NULL)
1393 				break;
1394 			if (view_is_splitscreen(view->child)) {
1395 				view->focussed = 0;
1396 				view->child->focussed = 1;
1397 				err = view_fullscreen(view->child);
1398 			} else {
1399 				err = view_splitscreen(view->child);
1400 				if (!err)
1401 					err = view_resize_split(view, 0);
1402 			}
1403 			if (err)
1404 				break;
1405 			err = view->child->input(new, view->child,
1406 			    KEY_RESIZE);
1407 		} else {
1408 			if (view_is_splitscreen(view)) {
1409 				view->parent->focussed = 0;
1410 				view->focussed = 1;
1411 				err = view_fullscreen(view);
1412 			} else {
1413 				err = view_splitscreen(view);
1414 				if (!err && view->mode != TOG_VIEW_SPLIT_HRZN)
1415 					err = view_resize(view->parent);
1416 				if (!err)
1417 					err = view_resize_split(view, 0);
1418 			}
1419 			if (err)
1420 				break;
1421 			err = view->input(new, view, KEY_RESIZE);
1422 		}
1423 		if (err)
1424 			break;
1425 		if (view->type == TOG_VIEW_LOG) {
1426 			err = request_log_commits(view);
1427 			if (err)
1428 				break;
1429 		}
1430 		if (view->parent)
1431 			err = offset_selection_down(view->parent);
1432 		if (!err)
1433 			err = offset_selection_down(view);
1434 		break;
1435 	case 'S':
1436 		view->count = 0;
1437 		err = switch_split(view);
1438 		break;
1439 	case '-':
1440 		err = view_resize_split(view, -1);
1441 		break;
1442 	case '+':
1443 		err = view_resize_split(view, 1);
1444 		break;
1445 	case KEY_RESIZE:
1446 		break;
1447 	case '/':
1448 		view->count = 0;
1449 		if (view->search_start)
1450 			view_search_start(view);
1451 		else
1452 			err = view->input(new, view, ch);
1453 		break;
1454 	case 'N':
1455 	case 'n':
1456 		if (view->search_started && view->search_next) {
1457 			view->searching = (ch == 'n' ?
1458 			    TOG_SEARCH_FORWARD : TOG_SEARCH_BACKWARD);
1459 			view->search_next_done = 0;
1460 			view->search_next(view);
1461 		} else
1462 			err = view->input(new, view, ch);
1463 		break;
1464 	case 'A':
1465 		if (tog_diff_algo == GOT_DIFF_ALGORITHM_MYERS)
1466 			tog_diff_algo = GOT_DIFF_ALGORITHM_PATIENCE;
1467 		else
1468 			tog_diff_algo = GOT_DIFF_ALGORITHM_MYERS;
1469 		TAILQ_FOREACH(v, views, entry) {
1470 			if (v->reset) {
1471 				err = v->reset(v);
1472 				if (err)
1473 					return err;
1474 			}
1475 			if (v->child && v->child->reset) {
1476 				err = v->child->reset(v->child);
1477 				if (err)
1478 					return err;
1479 			}
1480 		}
1481 		break;
1482 	default:
1483 		err = view->input(new, view, ch);
1484 		break;
1485 	}
1486 
1487 	return err;
1488 }
1489 
1490 static int
1491 view_needs_focus_indication(struct tog_view *view)
1492 {
1493 	if (view_is_parent_view(view)) {
1494 		if (view->child == NULL || view->child->focussed)
1495 			return 0;
1496 		if (!view_is_splitscreen(view->child))
1497 			return 0;
1498 	} else if (!view_is_splitscreen(view))
1499 		return 0;
1500 
1501 	return view->focussed;
1502 }
1503 
1504 static const struct got_error *
1505 view_loop(struct tog_view *view)
1506 {
1507 	const struct got_error *err = NULL;
1508 	struct tog_view_list_head views;
1509 	struct tog_view *new_view;
1510 	char *mode;
1511 	int fast_refresh = 10;
1512 	int done = 0, errcode;
1513 
1514 	mode = getenv("TOG_VIEW_SPLIT_MODE");
1515 	if (!mode || !(*mode == 'h' || *mode == 'H'))
1516 		view->mode = TOG_VIEW_SPLIT_VERT;
1517 	else
1518 		view->mode = TOG_VIEW_SPLIT_HRZN;
1519 
1520 	errcode = pthread_mutex_lock(&tog_mutex);
1521 	if (errcode)
1522 		return got_error_set_errno(errcode, "pthread_mutex_lock");
1523 
1524 	TAILQ_INIT(&views);
1525 	TAILQ_INSERT_HEAD(&views, view, entry);
1526 
1527 	view->focussed = 1;
1528 	err = view->show(view);
1529 	if (err)
1530 		return err;
1531 	update_panels();
1532 	doupdate();
1533 	while (!TAILQ_EMPTY(&views) && !done && !tog_thread_error &&
1534 	    !tog_fatal_signal_received()) {
1535 		/* Refresh fast during initialization, then become slower. */
1536 		if (fast_refresh && fast_refresh-- == 0)
1537 			halfdelay(10); /* switch to once per second */
1538 
1539 		err = view_input(&new_view, &done, view, &views);
1540 		if (err)
1541 			break;
1542 		if (view->dying) {
1543 			struct tog_view *v, *prev = NULL;
1544 
1545 			if (view_is_parent_view(view))
1546 				prev = TAILQ_PREV(view, tog_view_list_head,
1547 				    entry);
1548 			else if (view->parent)
1549 				prev = view->parent;
1550 
1551 			if (view->parent) {
1552 				view->parent->child = NULL;
1553 				view->parent->focus_child = 0;
1554 				/* Restore fullscreen line height. */
1555 				view->parent->nlines = view->parent->lines;
1556 				err = view_resize(view->parent);
1557 				if (err)
1558 					break;
1559 				/* Make resized splits persist. */
1560 				view_transfer_size(view->parent, view);
1561 			} else
1562 				TAILQ_REMOVE(&views, view, entry);
1563 
1564 			err = view_close(view);
1565 			if (err)
1566 				goto done;
1567 
1568 			view = NULL;
1569 			TAILQ_FOREACH(v, &views, entry) {
1570 				if (v->focussed)
1571 					break;
1572 			}
1573 			if (view == NULL && new_view == NULL) {
1574 				/* No view has focus. Try to pick one. */
1575 				if (prev)
1576 					view = prev;
1577 				else if (!TAILQ_EMPTY(&views)) {
1578 					view = TAILQ_LAST(&views,
1579 					    tog_view_list_head);
1580 				}
1581 				if (view) {
1582 					if (view->focus_child) {
1583 						view->child->focussed = 1;
1584 						view = view->child;
1585 					} else
1586 						view->focussed = 1;
1587 				}
1588 			}
1589 		}
1590 		if (new_view) {
1591 			struct tog_view *v, *t;
1592 			/* Only allow one parent view per type. */
1593 			TAILQ_FOREACH_SAFE(v, &views, entry, t) {
1594 				if (v->type != new_view->type)
1595 					continue;
1596 				TAILQ_REMOVE(&views, v, entry);
1597 				err = view_close(v);
1598 				if (err)
1599 					goto done;
1600 				break;
1601 			}
1602 			TAILQ_INSERT_TAIL(&views, new_view, entry);
1603 			view = new_view;
1604 		}
1605 		if (view) {
1606 			if (view_is_parent_view(view)) {
1607 				if (view->child && view->child->focussed)
1608 					view = view->child;
1609 			} else {
1610 				if (view->parent && view->parent->focussed)
1611 					view = view->parent;
1612 			}
1613 			show_panel(view->panel);
1614 			if (view->child && view_is_splitscreen(view->child))
1615 				show_panel(view->child->panel);
1616 			if (view->parent && view_is_splitscreen(view)) {
1617 				err = view->parent->show(view->parent);
1618 				if (err)
1619 					goto done;
1620 			}
1621 			err = view->show(view);
1622 			if (err)
1623 				goto done;
1624 			if (view->child) {
1625 				err = view->child->show(view->child);
1626 				if (err)
1627 					goto done;
1628 			}
1629 			update_panels();
1630 			doupdate();
1631 		}
1632 	}
1633 done:
1634 	while (!TAILQ_EMPTY(&views)) {
1635 		const struct got_error *close_err;
1636 		view = TAILQ_FIRST(&views);
1637 		TAILQ_REMOVE(&views, view, entry);
1638 		close_err = view_close(view);
1639 		if (close_err && err == NULL)
1640 			err = close_err;
1641 	}
1642 
1643 	errcode = pthread_mutex_unlock(&tog_mutex);
1644 	if (errcode && err == NULL)
1645 		err = got_error_set_errno(errcode, "pthread_mutex_unlock");
1646 
1647 	return err;
1648 }
1649 
1650 __dead static void
1651 usage_log(void)
1652 {
1653 	endwin();
1654 	fprintf(stderr,
1655 	    "usage: %s log [-b] [-c commit] [-r repository-path] [path]\n",
1656 	    getprogname());
1657 	exit(1);
1658 }
1659 
1660 /* Create newly allocated wide-character string equivalent to a byte string. */
1661 static const struct got_error *
1662 mbs2ws(wchar_t **ws, size_t *wlen, const char *s)
1663 {
1664 	char *vis = NULL;
1665 	const struct got_error *err = NULL;
1666 
1667 	*ws = NULL;
1668 	*wlen = mbstowcs(NULL, s, 0);
1669 	if (*wlen == (size_t)-1) {
1670 		int vislen;
1671 		if (errno != EILSEQ)
1672 			return got_error_from_errno("mbstowcs");
1673 
1674 		/* byte string invalid in current encoding; try to "fix" it */
1675 		err = got_mbsavis(&vis, &vislen, s);
1676 		if (err)
1677 			return err;
1678 		*wlen = mbstowcs(NULL, vis, 0);
1679 		if (*wlen == (size_t)-1) {
1680 			err = got_error_from_errno("mbstowcs"); /* give up */
1681 			goto done;
1682 		}
1683 	}
1684 
1685 	*ws = calloc(*wlen + 1, sizeof(**ws));
1686 	if (*ws == NULL) {
1687 		err = got_error_from_errno("calloc");
1688 		goto done;
1689 	}
1690 
1691 	if (mbstowcs(*ws, vis ? vis : s, *wlen) != *wlen)
1692 		err = got_error_from_errno("mbstowcs");
1693 done:
1694 	free(vis);
1695 	if (err) {
1696 		free(*ws);
1697 		*ws = NULL;
1698 		*wlen = 0;
1699 	}
1700 	return err;
1701 }
1702 
1703 static const struct got_error *
1704 expand_tab(char **ptr, const char *src)
1705 {
1706 	char	*dst;
1707 	size_t	 len, n, idx = 0, sz = 0;
1708 
1709 	*ptr = NULL;
1710 	n = len = strlen(src);
1711 	dst = malloc(n + 1);
1712 	if (dst == NULL)
1713 		return got_error_from_errno("malloc");
1714 
1715 	while (idx < len && src[idx]) {
1716 		const char c = src[idx];
1717 
1718 		if (c == '\t') {
1719 			size_t nb = TABSIZE - sz % TABSIZE;
1720 			char *p;
1721 
1722 			p = realloc(dst, n + nb);
1723 			if (p == NULL) {
1724 				free(dst);
1725 				return got_error_from_errno("realloc");
1726 
1727 			}
1728 			dst = p;
1729 			n += nb;
1730 			memset(dst + sz, ' ', nb);
1731 			sz += nb;
1732 		} else
1733 			dst[sz++] = src[idx];
1734 		++idx;
1735 	}
1736 
1737 	dst[sz] = '\0';
1738 	*ptr = dst;
1739 	return NULL;
1740 }
1741 
1742 /*
1743  * Advance at most n columns from wline starting at offset off.
1744  * Return the index to the first character after the span operation.
1745  * Return the combined column width of all spanned wide character in
1746  * *rcol.
1747  */
1748 static int
1749 span_wline(int *rcol, int off, wchar_t *wline, int n, int col_tab_align)
1750 {
1751 	int width, i, cols = 0;
1752 
1753 	if (n == 0) {
1754 		*rcol = cols;
1755 		return off;
1756 	}
1757 
1758 	for (i = off; wline[i] != L'\0'; ++i) {
1759 		if (wline[i] == L'\t')
1760 			width = TABSIZE - ((cols + col_tab_align) % TABSIZE);
1761 		else
1762 			width = wcwidth(wline[i]);
1763 
1764 		if (width == -1) {
1765 			width = 1;
1766 			wline[i] = L'.';
1767 		}
1768 
1769 		if (cols + width > n)
1770 			break;
1771 		cols += width;
1772 	}
1773 
1774 	*rcol = cols;
1775 	return i;
1776 }
1777 
1778 /*
1779  * Format a line for display, ensuring that it won't overflow a width limit.
1780  * With scrolling, the width returned refers to the scrolled version of the
1781  * line, which starts at (*wlinep)[*scrollxp]. The caller must free *wlinep.
1782  */
1783 static const struct got_error *
1784 format_line(wchar_t **wlinep, int *widthp, int *scrollxp,
1785     const char *line, int nscroll, int wlimit, int col_tab_align, int expand)
1786 {
1787 	const struct got_error *err = NULL;
1788 	int cols;
1789 	wchar_t *wline = NULL;
1790 	char *exstr = NULL;
1791 	size_t wlen;
1792 	int i, scrollx;
1793 
1794 	*wlinep = NULL;
1795 	*widthp = 0;
1796 
1797 	if (expand) {
1798 		err = expand_tab(&exstr, line);
1799 		if (err)
1800 			return err;
1801 	}
1802 
1803 	err = mbs2ws(&wline, &wlen, expand ? exstr : line);
1804 	free(exstr);
1805 	if (err)
1806 		return err;
1807 
1808 	scrollx = span_wline(&cols, 0, wline, nscroll, col_tab_align);
1809 
1810 	if (wlen > 0 && wline[wlen - 1] == L'\n') {
1811 		wline[wlen - 1] = L'\0';
1812 		wlen--;
1813 	}
1814 	if (wlen > 0 && wline[wlen - 1] == L'\r') {
1815 		wline[wlen - 1] = L'\0';
1816 		wlen--;
1817 	}
1818 
1819 	i = span_wline(&cols, scrollx, wline, wlimit, col_tab_align);
1820 	wline[i] = L'\0';
1821 
1822 	if (widthp)
1823 		*widthp = cols;
1824 	if (scrollxp)
1825 		*scrollxp = scrollx;
1826 	if (err)
1827 		free(wline);
1828 	else
1829 		*wlinep = wline;
1830 	return err;
1831 }
1832 
1833 static const struct got_error*
1834 build_refs_str(char **refs_str, struct got_reflist_head *refs,
1835     struct got_object_id *id, struct got_repository *repo)
1836 {
1837 	static const struct got_error *err = NULL;
1838 	struct got_reflist_entry *re;
1839 	char *s;
1840 	const char *name;
1841 
1842 	*refs_str = NULL;
1843 
1844 	TAILQ_FOREACH(re, refs, entry) {
1845 		struct got_tag_object *tag = NULL;
1846 		struct got_object_id *ref_id;
1847 		int cmp;
1848 
1849 		name = got_ref_get_name(re->ref);
1850 		if (strcmp(name, GOT_REF_HEAD) == 0)
1851 			continue;
1852 		if (strncmp(name, "refs/", 5) == 0)
1853 			name += 5;
1854 		if (strncmp(name, "got/", 4) == 0 &&
1855 		    strncmp(name, "got/backup/", 11) != 0)
1856 			continue;
1857 		if (strncmp(name, "heads/", 6) == 0)
1858 			name += 6;
1859 		if (strncmp(name, "remotes/", 8) == 0) {
1860 			name += 8;
1861 			s = strstr(name, "/" GOT_REF_HEAD);
1862 			if (s != NULL && s[strlen(s)] == '\0')
1863 				continue;
1864 		}
1865 		err = got_ref_resolve(&ref_id, repo, re->ref);
1866 		if (err)
1867 			break;
1868 		if (strncmp(name, "tags/", 5) == 0) {
1869 			err = got_object_open_as_tag(&tag, repo, ref_id);
1870 			if (err) {
1871 				if (err->code != GOT_ERR_OBJ_TYPE) {
1872 					free(ref_id);
1873 					break;
1874 				}
1875 				/* Ref points at something other than a tag. */
1876 				err = NULL;
1877 				tag = NULL;
1878 			}
1879 		}
1880 		cmp = got_object_id_cmp(tag ?
1881 		    got_object_tag_get_object_id(tag) : ref_id, id);
1882 		free(ref_id);
1883 		if (tag)
1884 			got_object_tag_close(tag);
1885 		if (cmp != 0)
1886 			continue;
1887 		s = *refs_str;
1888 		if (asprintf(refs_str, "%s%s%s", s ? s : "",
1889 		    s ? ", " : "", name) == -1) {
1890 			err = got_error_from_errno("asprintf");
1891 			free(s);
1892 			*refs_str = NULL;
1893 			break;
1894 		}
1895 		free(s);
1896 	}
1897 
1898 	return err;
1899 }
1900 
1901 static const struct got_error *
1902 format_author(wchar_t **wauthor, int *author_width, char *author, int limit,
1903     int col_tab_align)
1904 {
1905 	char *smallerthan;
1906 
1907 	smallerthan = strchr(author, '<');
1908 	if (smallerthan && smallerthan[1] != '\0')
1909 		author = smallerthan + 1;
1910 	author[strcspn(author, "@>")] = '\0';
1911 	return format_line(wauthor, author_width, NULL, author, 0, limit,
1912 	    col_tab_align, 0);
1913 }
1914 
1915 static const struct got_error *
1916 draw_commit(struct tog_view *view, struct got_commit_object *commit,
1917     struct got_object_id *id, const size_t date_display_cols,
1918     int author_display_cols)
1919 {
1920 	struct tog_log_view_state *s = &view->state.log;
1921 	const struct got_error *err = NULL;
1922 	char datebuf[12]; /* YYYY-MM-DD + SPACE + NUL */
1923 	char *logmsg0 = NULL, *logmsg = NULL;
1924 	char *author = NULL;
1925 	wchar_t *wlogmsg = NULL, *wauthor = NULL;
1926 	int author_width, logmsg_width;
1927 	char *newline, *line = NULL;
1928 	int col, limit, scrollx;
1929 	const int avail = view->ncols;
1930 	struct tm tm;
1931 	time_t committer_time;
1932 	struct tog_color *tc;
1933 
1934 	committer_time = got_object_commit_get_committer_time(commit);
1935 	if (gmtime_r(&committer_time, &tm) == NULL)
1936 		return got_error_from_errno("gmtime_r");
1937 	if (strftime(datebuf, sizeof(datebuf), "%G-%m-%d ", &tm) == 0)
1938 		return got_error(GOT_ERR_NO_SPACE);
1939 
1940 	if (avail <= date_display_cols)
1941 		limit = MIN(sizeof(datebuf) - 1, avail);
1942 	else
1943 		limit = MIN(date_display_cols, sizeof(datebuf) - 1);
1944 	tc = get_color(&s->colors, TOG_COLOR_DATE);
1945 	if (tc)
1946 		wattr_on(view->window,
1947 		    COLOR_PAIR(tc->colorpair), NULL);
1948 	waddnstr(view->window, datebuf, limit);
1949 	if (tc)
1950 		wattr_off(view->window,
1951 		    COLOR_PAIR(tc->colorpair), NULL);
1952 	col = limit;
1953 	if (col > avail)
1954 		goto done;
1955 
1956 	if (avail >= 120) {
1957 		char *id_str;
1958 		err = got_object_id_str(&id_str, id);
1959 		if (err)
1960 			goto done;
1961 		tc = get_color(&s->colors, TOG_COLOR_COMMIT);
1962 		if (tc)
1963 			wattr_on(view->window,
1964 			    COLOR_PAIR(tc->colorpair), NULL);
1965 		wprintw(view->window, "%.8s ", id_str);
1966 		if (tc)
1967 			wattr_off(view->window,
1968 			    COLOR_PAIR(tc->colorpair), NULL);
1969 		free(id_str);
1970 		col += 9;
1971 		if (col > avail)
1972 			goto done;
1973 	}
1974 
1975 	if (s->use_committer)
1976 		author = strdup(got_object_commit_get_committer(commit));
1977 	else
1978 		author = strdup(got_object_commit_get_author(commit));
1979 	if (author == NULL) {
1980 		err = got_error_from_errno("strdup");
1981 		goto done;
1982 	}
1983 	err = format_author(&wauthor, &author_width, author, avail - col, col);
1984 	if (err)
1985 		goto done;
1986 	tc = get_color(&s->colors, TOG_COLOR_AUTHOR);
1987 	if (tc)
1988 		wattr_on(view->window,
1989 		    COLOR_PAIR(tc->colorpair), NULL);
1990 	waddwstr(view->window, wauthor);
1991 	if (tc)
1992 		wattr_off(view->window,
1993 		    COLOR_PAIR(tc->colorpair), NULL);
1994 	col += author_width;
1995 	while (col < avail && author_width < author_display_cols + 2) {
1996 		waddch(view->window, ' ');
1997 		col++;
1998 		author_width++;
1999 	}
2000 	if (col > avail)
2001 		goto done;
2002 
2003 	err = got_object_commit_get_logmsg(&logmsg0, commit);
2004 	if (err)
2005 		goto done;
2006 	logmsg = logmsg0;
2007 	while (*logmsg == '\n')
2008 		logmsg++;
2009 	newline = strchr(logmsg, '\n');
2010 	if (newline)
2011 		*newline = '\0';
2012 	limit = avail - col;
2013 	if (view->child && !view_is_hsplit_top(view) && limit > 0)
2014 		limit--;	/* for the border */
2015 	err = format_line(&wlogmsg, &logmsg_width, &scrollx, logmsg, view->x,
2016 	    limit, col, 1);
2017 	if (err)
2018 		goto done;
2019 	waddwstr(view->window, &wlogmsg[scrollx]);
2020 	col += MAX(logmsg_width, 0);
2021 	while (col < avail) {
2022 		waddch(view->window, ' ');
2023 		col++;
2024 	}
2025 done:
2026 	free(logmsg0);
2027 	free(wlogmsg);
2028 	free(author);
2029 	free(wauthor);
2030 	free(line);
2031 	return err;
2032 }
2033 
2034 static struct commit_queue_entry *
2035 alloc_commit_queue_entry(struct got_commit_object *commit,
2036     struct got_object_id *id)
2037 {
2038 	struct commit_queue_entry *entry;
2039 
2040 	entry = calloc(1, sizeof(*entry));
2041 	if (entry == NULL)
2042 		return NULL;
2043 
2044 	entry->id = id;
2045 	entry->commit = commit;
2046 	return entry;
2047 }
2048 
2049 static void
2050 pop_commit(struct commit_queue *commits)
2051 {
2052 	struct commit_queue_entry *entry;
2053 
2054 	entry = TAILQ_FIRST(&commits->head);
2055 	TAILQ_REMOVE(&commits->head, entry, entry);
2056 	got_object_commit_close(entry->commit);
2057 	commits->ncommits--;
2058 	/* Don't free entry->id! It is owned by the commit graph. */
2059 	free(entry);
2060 }
2061 
2062 static void
2063 free_commits(struct commit_queue *commits)
2064 {
2065 	while (!TAILQ_EMPTY(&commits->head))
2066 		pop_commit(commits);
2067 }
2068 
2069 static const struct got_error *
2070 match_commit(int *have_match, struct got_object_id *id,
2071     struct got_commit_object *commit, regex_t *regex)
2072 {
2073 	const struct got_error *err = NULL;
2074 	regmatch_t regmatch;
2075 	char *id_str = NULL, *logmsg = NULL;
2076 
2077 	*have_match = 0;
2078 
2079 	err = got_object_id_str(&id_str, id);
2080 	if (err)
2081 		return err;
2082 
2083 	err = got_object_commit_get_logmsg(&logmsg, commit);
2084 	if (err)
2085 		goto done;
2086 
2087 	if (regexec(regex, got_object_commit_get_author(commit), 1,
2088 	    &regmatch, 0) == 0 ||
2089 	    regexec(regex, got_object_commit_get_committer(commit), 1,
2090 	    &regmatch, 0) == 0 ||
2091 	    regexec(regex, id_str, 1, &regmatch, 0) == 0 ||
2092 	    regexec(regex, logmsg, 1, &regmatch, 0) == 0)
2093 		*have_match = 1;
2094 done:
2095 	free(id_str);
2096 	free(logmsg);
2097 	return err;
2098 }
2099 
2100 static const struct got_error *
2101 queue_commits(struct tog_log_thread_args *a)
2102 {
2103 	const struct got_error *err = NULL;
2104 
2105 	/*
2106 	 * We keep all commits open throughout the lifetime of the log
2107 	 * view in order to avoid having to re-fetch commits from disk
2108 	 * while updating the display.
2109 	 */
2110 	do {
2111 		struct got_object_id *id;
2112 		struct got_commit_object *commit;
2113 		struct commit_queue_entry *entry;
2114 		int errcode;
2115 
2116 		err = got_commit_graph_iter_next(&id, a->graph, a->repo,
2117 		    NULL, NULL);
2118 		if (err || id == NULL)
2119 			break;
2120 
2121 		err = got_object_open_as_commit(&commit, a->repo, id);
2122 		if (err)
2123 			break;
2124 		entry = alloc_commit_queue_entry(commit, id);
2125 		if (entry == NULL) {
2126 			err = got_error_from_errno("alloc_commit_queue_entry");
2127 			break;
2128 		}
2129 
2130 		errcode = pthread_mutex_lock(&tog_mutex);
2131 		if (errcode) {
2132 			err = got_error_set_errno(errcode,
2133 			    "pthread_mutex_lock");
2134 			break;
2135 		}
2136 
2137 		entry->idx = a->commits->ncommits;
2138 		TAILQ_INSERT_TAIL(&a->commits->head, entry, entry);
2139 		a->commits->ncommits++;
2140 
2141 		if (*a->searching == TOG_SEARCH_FORWARD &&
2142 		    !*a->search_next_done) {
2143 			int have_match;
2144 			err = match_commit(&have_match, id, commit, a->regex);
2145 			if (err)
2146 				break;
2147 			if (have_match)
2148 				*a->search_next_done = TOG_SEARCH_HAVE_MORE;
2149 		}
2150 
2151 		errcode = pthread_mutex_unlock(&tog_mutex);
2152 		if (errcode && err == NULL)
2153 			err = got_error_set_errno(errcode,
2154 			    "pthread_mutex_unlock");
2155 		if (err)
2156 			break;
2157 	} while (*a->searching == TOG_SEARCH_FORWARD && !*a->search_next_done);
2158 
2159 	return err;
2160 }
2161 
2162 static void
2163 select_commit(struct tog_log_view_state *s)
2164 {
2165 	struct commit_queue_entry *entry;
2166 	int ncommits = 0;
2167 
2168 	entry = s->first_displayed_entry;
2169 	while (entry) {
2170 		if (ncommits == s->selected) {
2171 			s->selected_entry = entry;
2172 			break;
2173 		}
2174 		entry = TAILQ_NEXT(entry, entry);
2175 		ncommits++;
2176 	}
2177 }
2178 
2179 static const struct got_error *
2180 draw_commits(struct tog_view *view)
2181 {
2182 	const struct got_error *err = NULL;
2183 	struct tog_log_view_state *s = &view->state.log;
2184 	struct commit_queue_entry *entry = s->selected_entry;
2185 	const int limit = view->nlines;
2186 	int width;
2187 	int ncommits, author_cols = 4;
2188 	char *id_str = NULL, *header = NULL, *ncommits_str = NULL;
2189 	char *refs_str = NULL;
2190 	wchar_t *wline;
2191 	struct tog_color *tc;
2192 	static const size_t date_display_cols = 12;
2193 
2194 	if (s->selected_entry &&
2195 	    !(view->searching && view->search_next_done == 0)) {
2196 		struct got_reflist_head *refs;
2197 		err = got_object_id_str(&id_str, s->selected_entry->id);
2198 		if (err)
2199 			return err;
2200 		refs = got_reflist_object_id_map_lookup(tog_refs_idmap,
2201 		    s->selected_entry->id);
2202 		if (refs) {
2203 			err = build_refs_str(&refs_str, refs,
2204 			    s->selected_entry->id, s->repo);
2205 			if (err)
2206 				goto done;
2207 		}
2208 	}
2209 
2210 	if (s->thread_args.commits_needed == 0)
2211 		halfdelay(10); /* disable fast refresh */
2212 
2213 	if (s->thread_args.commits_needed > 0 || s->thread_args.load_all) {
2214 		if (asprintf(&ncommits_str, " [%d/%d] %s",
2215 		    entry ? entry->idx + 1 : 0, s->commits.ncommits,
2216 		    (view->searching && !view->search_next_done) ?
2217 		    "searching..." : "loading...") == -1) {
2218 			err = got_error_from_errno("asprintf");
2219 			goto done;
2220 		}
2221 	} else {
2222 		const char *search_str = NULL;
2223 
2224 		if (view->searching) {
2225 			if (view->search_next_done == TOG_SEARCH_NO_MORE)
2226 				search_str = "no more matches";
2227 			else if (view->search_next_done == TOG_SEARCH_HAVE_NONE)
2228 				search_str = "no matches found";
2229 			else if (!view->search_next_done)
2230 				search_str = "searching...";
2231 		}
2232 
2233 		if (asprintf(&ncommits_str, " [%d/%d] %s",
2234 		    entry ? entry->idx + 1 : 0, s->commits.ncommits,
2235 		    search_str ? search_str :
2236 		    (refs_str ? refs_str : "")) == -1) {
2237 			err = got_error_from_errno("asprintf");
2238 			goto done;
2239 		}
2240 	}
2241 
2242 	if (s->in_repo_path && strcmp(s->in_repo_path, "/") != 0) {
2243 		if (asprintf(&header, "commit %s %s%s", id_str ? id_str :
2244 		    "........................................",
2245 		    s->in_repo_path, ncommits_str) == -1) {
2246 			err = got_error_from_errno("asprintf");
2247 			header = NULL;
2248 			goto done;
2249 		}
2250 	} else if (asprintf(&header, "commit %s%s",
2251 	    id_str ? id_str : "........................................",
2252 	    ncommits_str) == -1) {
2253 		err = got_error_from_errno("asprintf");
2254 		header = NULL;
2255 		goto done;
2256 	}
2257 	err = format_line(&wline, &width, NULL, header, 0, view->ncols, 0, 0);
2258 	if (err)
2259 		goto done;
2260 
2261 	werase(view->window);
2262 
2263 	if (view_needs_focus_indication(view))
2264 		wstandout(view->window);
2265 	tc = get_color(&s->colors, TOG_COLOR_COMMIT);
2266 	if (tc)
2267 		wattr_on(view->window,
2268 		    COLOR_PAIR(tc->colorpair), NULL);
2269 	waddwstr(view->window, wline);
2270 	if (tc)
2271 		wattr_off(view->window,
2272 		    COLOR_PAIR(tc->colorpair), NULL);
2273 	while (width < view->ncols) {
2274 		waddch(view->window, ' ');
2275 		width++;
2276 	}
2277 	if (view_needs_focus_indication(view))
2278 		wstandend(view->window);
2279 	free(wline);
2280 	if (limit <= 1)
2281 		goto done;
2282 
2283 	/* Grow author column size if necessary, and set view->maxx. */
2284 	entry = s->first_displayed_entry;
2285 	ncommits = 0;
2286 	view->maxx = 0;
2287 	while (entry) {
2288 		struct got_commit_object *c = entry->commit;
2289 		char *author, *eol, *msg, *msg0;
2290 		wchar_t *wauthor, *wmsg;
2291 		int width;
2292 		if (ncommits >= limit - 1)
2293 			break;
2294 		if (s->use_committer)
2295 			author = strdup(got_object_commit_get_committer(c));
2296 		else
2297 			author = strdup(got_object_commit_get_author(c));
2298 		if (author == NULL) {
2299 			err = got_error_from_errno("strdup");
2300 			goto done;
2301 		}
2302 		err = format_author(&wauthor, &width, author, COLS,
2303 		    date_display_cols);
2304 		if (author_cols < width)
2305 			author_cols = width;
2306 		free(wauthor);
2307 		free(author);
2308 		if (err)
2309 			goto done;
2310 		err = got_object_commit_get_logmsg(&msg0, c);
2311 		if (err)
2312 			goto done;
2313 		msg = msg0;
2314 		while (*msg == '\n')
2315 			++msg;
2316 		if ((eol = strchr(msg, '\n')))
2317 			*eol = '\0';
2318 		err = format_line(&wmsg, &width, NULL, msg, 0, INT_MAX,
2319 		    date_display_cols + author_cols, 0);
2320 		if (err)
2321 			goto done;
2322 		view->maxx = MAX(view->maxx, width);
2323 		free(msg0);
2324 		free(wmsg);
2325 		ncommits++;
2326 		entry = TAILQ_NEXT(entry, entry);
2327 	}
2328 
2329 	entry = s->first_displayed_entry;
2330 	s->last_displayed_entry = s->first_displayed_entry;
2331 	ncommits = 0;
2332 	while (entry) {
2333 		if (ncommits >= limit - 1)
2334 			break;
2335 		if (ncommits == s->selected)
2336 			wstandout(view->window);
2337 		err = draw_commit(view, entry->commit, entry->id,
2338 		    date_display_cols, author_cols);
2339 		if (ncommits == s->selected)
2340 			wstandend(view->window);
2341 		if (err)
2342 			goto done;
2343 		ncommits++;
2344 		s->last_displayed_entry = entry;
2345 		entry = TAILQ_NEXT(entry, entry);
2346 	}
2347 
2348 	view_border(view);
2349 done:
2350 	free(id_str);
2351 	free(refs_str);
2352 	free(ncommits_str);
2353 	free(header);
2354 	return err;
2355 }
2356 
2357 static void
2358 log_scroll_up(struct tog_log_view_state *s, int maxscroll)
2359 {
2360 	struct commit_queue_entry *entry;
2361 	int nscrolled = 0;
2362 
2363 	entry = TAILQ_FIRST(&s->commits.head);
2364 	if (s->first_displayed_entry == entry)
2365 		return;
2366 
2367 	entry = s->first_displayed_entry;
2368 	while (entry && nscrolled < maxscroll) {
2369 		entry = TAILQ_PREV(entry, commit_queue_head, entry);
2370 		if (entry) {
2371 			s->first_displayed_entry = entry;
2372 			nscrolled++;
2373 		}
2374 	}
2375 }
2376 
2377 static const struct got_error *
2378 trigger_log_thread(struct tog_view *view, int wait)
2379 {
2380 	struct tog_log_thread_args *ta = &view->state.log.thread_args;
2381 	int errcode;
2382 
2383 	halfdelay(1); /* fast refresh while loading commits */
2384 
2385 	while (!ta->log_complete && !tog_thread_error &&
2386 	    (ta->commits_needed > 0 || ta->load_all)) {
2387 		/* Wake the log thread. */
2388 		errcode = pthread_cond_signal(&ta->need_commits);
2389 		if (errcode)
2390 			return got_error_set_errno(errcode,
2391 			    "pthread_cond_signal");
2392 
2393 		/*
2394 		 * The mutex will be released while the view loop waits
2395 		 * in wgetch(), at which time the log thread will run.
2396 		 */
2397 		if (!wait)
2398 			break;
2399 
2400 		/* Display progress update in log view. */
2401 		show_log_view(view);
2402 		update_panels();
2403 		doupdate();
2404 
2405 		/* Wait right here while next commit is being loaded. */
2406 		errcode = pthread_cond_wait(&ta->commit_loaded, &tog_mutex);
2407 		if (errcode)
2408 			return got_error_set_errno(errcode,
2409 			    "pthread_cond_wait");
2410 
2411 		/* Display progress update in log view. */
2412 		show_log_view(view);
2413 		update_panels();
2414 		doupdate();
2415 	}
2416 
2417 	return NULL;
2418 }
2419 
2420 static const struct got_error *
2421 request_log_commits(struct tog_view *view)
2422 {
2423 	struct tog_log_view_state	*state = &view->state.log;
2424 	const struct got_error		*err = NULL;
2425 
2426 	if (state->thread_args.log_complete)
2427 		return NULL;
2428 
2429 	state->thread_args.commits_needed += view->nscrolled;
2430 	err = trigger_log_thread(view, 1);
2431 	view->nscrolled = 0;
2432 
2433 	return err;
2434 }
2435 
2436 static const struct got_error *
2437 log_scroll_down(struct tog_view *view, int maxscroll)
2438 {
2439 	struct tog_log_view_state *s = &view->state.log;
2440 	const struct got_error *err = NULL;
2441 	struct commit_queue_entry *pentry;
2442 	int nscrolled = 0, ncommits_needed;
2443 
2444 	if (s->last_displayed_entry == NULL)
2445 		return NULL;
2446 
2447 	ncommits_needed = s->last_displayed_entry->idx + 1 + maxscroll;
2448 	if (s->commits.ncommits < ncommits_needed &&
2449 	    !s->thread_args.log_complete) {
2450 		/*
2451 		 * Ask the log thread for required amount of commits.
2452 		 */
2453 		s->thread_args.commits_needed += maxscroll;
2454 		err = trigger_log_thread(view, 1);
2455 		if (err)
2456 			return err;
2457 	}
2458 
2459 	do {
2460 		pentry = TAILQ_NEXT(s->last_displayed_entry, entry);
2461 		if (pentry == NULL && view->mode != TOG_VIEW_SPLIT_HRZN)
2462 			break;
2463 
2464 		s->last_displayed_entry = pentry ?
2465 		    pentry : s->last_displayed_entry;;
2466 
2467 		pentry = TAILQ_NEXT(s->first_displayed_entry, entry);
2468 		if (pentry == NULL)
2469 			break;
2470 		s->first_displayed_entry = pentry;
2471 	} while (++nscrolled < maxscroll);
2472 
2473 	if (view->mode == TOG_VIEW_SPLIT_HRZN && !s->thread_args.log_complete)
2474 		view->nscrolled += nscrolled;
2475 	else
2476 		view->nscrolled = 0;
2477 
2478 	return err;
2479 }
2480 
2481 static const struct got_error *
2482 open_diff_view_for_commit(struct tog_view **new_view, int begin_y, int begin_x,
2483     struct got_commit_object *commit, struct got_object_id *commit_id,
2484     struct tog_view *log_view, struct got_repository *repo)
2485 {
2486 	const struct got_error *err;
2487 	struct got_object_qid *parent_id;
2488 	struct tog_view *diff_view;
2489 
2490 	diff_view = view_open(0, 0, begin_y, begin_x, TOG_VIEW_DIFF);
2491 	if (diff_view == NULL)
2492 		return got_error_from_errno("view_open");
2493 
2494 	parent_id = STAILQ_FIRST(got_object_commit_get_parent_ids(commit));
2495 	err = open_diff_view(diff_view, parent_id ? &parent_id->id : NULL,
2496 	    commit_id, NULL, NULL, 3, 0, 0, log_view, repo);
2497 	if (err == NULL)
2498 		*new_view = diff_view;
2499 	return err;
2500 }
2501 
2502 static const struct got_error *
2503 tree_view_visit_subtree(struct tog_tree_view_state *s,
2504     struct got_tree_object *subtree)
2505 {
2506 	struct tog_parent_tree *parent;
2507 
2508 	parent = calloc(1, sizeof(*parent));
2509 	if (parent == NULL)
2510 		return got_error_from_errno("calloc");
2511 
2512 	parent->tree = s->tree;
2513 	parent->first_displayed_entry = s->first_displayed_entry;
2514 	parent->selected_entry = s->selected_entry;
2515 	parent->selected = s->selected;
2516 	TAILQ_INSERT_HEAD(&s->parents, parent, entry);
2517 	s->tree = subtree;
2518 	s->selected = 0;
2519 	s->first_displayed_entry = NULL;
2520 	return NULL;
2521 }
2522 
2523 static const struct got_error *
2524 tree_view_walk_path(struct tog_tree_view_state *s,
2525     struct got_commit_object *commit, const char *path)
2526 {
2527 	const struct got_error *err = NULL;
2528 	struct got_tree_object *tree = NULL;
2529 	const char *p;
2530 	char *slash, *subpath = NULL;
2531 
2532 	/* Walk the path and open corresponding tree objects. */
2533 	p = path;
2534 	while (*p) {
2535 		struct got_tree_entry *te;
2536 		struct got_object_id *tree_id;
2537 		char *te_name;
2538 
2539 		while (p[0] == '/')
2540 			p++;
2541 
2542 		/* Ensure the correct subtree entry is selected. */
2543 		slash = strchr(p, '/');
2544 		if (slash == NULL)
2545 			te_name = strdup(p);
2546 		else
2547 			te_name = strndup(p, slash - p);
2548 		if (te_name == NULL) {
2549 			err = got_error_from_errno("strndup");
2550 			break;
2551 		}
2552 		te = got_object_tree_find_entry(s->tree, te_name);
2553 		if (te == NULL) {
2554 			err = got_error_path(te_name, GOT_ERR_NO_TREE_ENTRY);
2555 			free(te_name);
2556 			break;
2557 		}
2558 		free(te_name);
2559 		s->first_displayed_entry = s->selected_entry = te;
2560 
2561 		if (!S_ISDIR(got_tree_entry_get_mode(s->selected_entry)))
2562 			break; /* jump to this file's entry */
2563 
2564 		slash = strchr(p, '/');
2565 		if (slash)
2566 			subpath = strndup(path, slash - path);
2567 		else
2568 			subpath = strdup(path);
2569 		if (subpath == NULL) {
2570 			err = got_error_from_errno("strdup");
2571 			break;
2572 		}
2573 
2574 		err = got_object_id_by_path(&tree_id, s->repo, commit,
2575 		    subpath);
2576 		if (err)
2577 			break;
2578 
2579 		err = got_object_open_as_tree(&tree, s->repo, tree_id);
2580 		free(tree_id);
2581 		if (err)
2582 			break;
2583 
2584 		err = tree_view_visit_subtree(s, tree);
2585 		if (err) {
2586 			got_object_tree_close(tree);
2587 			break;
2588 		}
2589 		if (slash == NULL)
2590 			break;
2591 		free(subpath);
2592 		subpath = NULL;
2593 		p = slash;
2594 	}
2595 
2596 	free(subpath);
2597 	return err;
2598 }
2599 
2600 static const struct got_error *
2601 browse_commit_tree(struct tog_view **new_view, int begin_y, int begin_x,
2602     struct commit_queue_entry *entry, const char *path,
2603     const char *head_ref_name, struct got_repository *repo)
2604 {
2605 	const struct got_error *err = NULL;
2606 	struct tog_tree_view_state *s;
2607 	struct tog_view *tree_view;
2608 
2609 	tree_view = view_open(0, 0, begin_y, begin_x, TOG_VIEW_TREE);
2610 	if (tree_view == NULL)
2611 		return got_error_from_errno("view_open");
2612 
2613 	err = open_tree_view(tree_view, entry->id, head_ref_name, repo);
2614 	if (err)
2615 		return err;
2616 	s = &tree_view->state.tree;
2617 
2618 	*new_view = tree_view;
2619 
2620 	if (got_path_is_root_dir(path))
2621 		return NULL;
2622 
2623 	return tree_view_walk_path(s, entry->commit, path);
2624 }
2625 
2626 static const struct got_error *
2627 block_signals_used_by_main_thread(void)
2628 {
2629 	sigset_t sigset;
2630 	int errcode;
2631 
2632 	if (sigemptyset(&sigset) == -1)
2633 		return got_error_from_errno("sigemptyset");
2634 
2635 	/* tog handles SIGWINCH, SIGCONT, SIGINT, SIGTERM */
2636 	if (sigaddset(&sigset, SIGWINCH) == -1)
2637 		return got_error_from_errno("sigaddset");
2638 	if (sigaddset(&sigset, SIGCONT) == -1)
2639 		return got_error_from_errno("sigaddset");
2640 	if (sigaddset(&sigset, SIGINT) == -1)
2641 		return got_error_from_errno("sigaddset");
2642 	if (sigaddset(&sigset, SIGTERM) == -1)
2643 		return got_error_from_errno("sigaddset");
2644 
2645 	/* ncurses handles SIGTSTP */
2646 	if (sigaddset(&sigset, SIGTSTP) == -1)
2647 		return got_error_from_errno("sigaddset");
2648 
2649 	errcode = pthread_sigmask(SIG_BLOCK, &sigset, NULL);
2650 	if (errcode)
2651 		return got_error_set_errno(errcode, "pthread_sigmask");
2652 
2653 	return NULL;
2654 }
2655 
2656 static void *
2657 log_thread(void *arg)
2658 {
2659 	const struct got_error *err = NULL;
2660 	int errcode = 0;
2661 	struct tog_log_thread_args *a = arg;
2662 	int done = 0;
2663 
2664 	/*
2665 	 * Sync startup with main thread such that we begin our
2666 	 * work once view_input() has released the mutex.
2667 	 */
2668 	errcode = pthread_mutex_lock(&tog_mutex);
2669 	if (errcode) {
2670 		err = got_error_set_errno(errcode, "pthread_mutex_lock");
2671 		return (void *)err;
2672 	}
2673 
2674 	err = block_signals_used_by_main_thread();
2675 	if (err) {
2676 		pthread_mutex_unlock(&tog_mutex);
2677 		goto done;
2678 	}
2679 
2680 	while (!done && !err && !tog_fatal_signal_received()) {
2681 		errcode = pthread_mutex_unlock(&tog_mutex);
2682 		if (errcode) {
2683 			err = got_error_set_errno(errcode,
2684 			    "pthread_mutex_unlock");
2685 			goto done;
2686 		}
2687 		err = queue_commits(a);
2688 		if (err) {
2689 			if (err->code != GOT_ERR_ITER_COMPLETED)
2690 				goto done;
2691 			err = NULL;
2692 			done = 1;
2693 		} else if (a->commits_needed > 0 && !a->load_all)
2694 			a->commits_needed--;
2695 
2696 		errcode = pthread_mutex_lock(&tog_mutex);
2697 		if (errcode) {
2698 			err = got_error_set_errno(errcode,
2699 			    "pthread_mutex_lock");
2700 			goto done;
2701 		} else if (*a->quit)
2702 			done = 1;
2703 		else if (*a->first_displayed_entry == NULL) {
2704 			*a->first_displayed_entry =
2705 			    TAILQ_FIRST(&a->commits->head);
2706 			*a->selected_entry = *a->first_displayed_entry;
2707 		}
2708 
2709 		errcode = pthread_cond_signal(&a->commit_loaded);
2710 		if (errcode) {
2711 			err = got_error_set_errno(errcode,
2712 			    "pthread_cond_signal");
2713 			pthread_mutex_unlock(&tog_mutex);
2714 			goto done;
2715 		}
2716 
2717 		if (done)
2718 			a->commits_needed = 0;
2719 		else {
2720 			if (a->commits_needed == 0 && !a->load_all) {
2721 				errcode = pthread_cond_wait(&a->need_commits,
2722 				    &tog_mutex);
2723 				if (errcode) {
2724 					err = got_error_set_errno(errcode,
2725 					    "pthread_cond_wait");
2726 					pthread_mutex_unlock(&tog_mutex);
2727 					goto done;
2728 				}
2729 				if (*a->quit)
2730 					done = 1;
2731 			}
2732 		}
2733 	}
2734 	a->log_complete = 1;
2735 	errcode = pthread_mutex_unlock(&tog_mutex);
2736 	if (errcode)
2737 		err = got_error_set_errno(errcode, "pthread_mutex_unlock");
2738 done:
2739 	if (err) {
2740 		tog_thread_error = 1;
2741 		pthread_cond_signal(&a->commit_loaded);
2742 	}
2743 	return (void *)err;
2744 }
2745 
2746 static const struct got_error *
2747 stop_log_thread(struct tog_log_view_state *s)
2748 {
2749 	const struct got_error *err = NULL, *thread_err = NULL;
2750 	int errcode;
2751 
2752 	if (s->thread) {
2753 		s->quit = 1;
2754 		errcode = pthread_cond_signal(&s->thread_args.need_commits);
2755 		if (errcode)
2756 			return got_error_set_errno(errcode,
2757 			    "pthread_cond_signal");
2758 		errcode = pthread_mutex_unlock(&tog_mutex);
2759 		if (errcode)
2760 			return got_error_set_errno(errcode,
2761 			    "pthread_mutex_unlock");
2762 		errcode = pthread_join(s->thread, (void **)&thread_err);
2763 		if (errcode)
2764 			return got_error_set_errno(errcode, "pthread_join");
2765 		errcode = pthread_mutex_lock(&tog_mutex);
2766 		if (errcode)
2767 			return got_error_set_errno(errcode,
2768 			    "pthread_mutex_lock");
2769 		s->thread = NULL;
2770 	}
2771 
2772 	if (s->thread_args.repo) {
2773 		err = got_repo_close(s->thread_args.repo);
2774 		s->thread_args.repo = NULL;
2775 	}
2776 
2777 	if (s->thread_args.pack_fds) {
2778 		const struct got_error *pack_err =
2779 		    got_repo_pack_fds_close(s->thread_args.pack_fds);
2780 		if (err == NULL)
2781 			err = pack_err;
2782 		s->thread_args.pack_fds = NULL;
2783 	}
2784 
2785 	if (s->thread_args.graph) {
2786 		got_commit_graph_close(s->thread_args.graph);
2787 		s->thread_args.graph = NULL;
2788 	}
2789 
2790 	return err ? err : thread_err;
2791 }
2792 
2793 static const struct got_error *
2794 close_log_view(struct tog_view *view)
2795 {
2796 	const struct got_error *err = NULL;
2797 	struct tog_log_view_state *s = &view->state.log;
2798 	int errcode;
2799 
2800 	err = stop_log_thread(s);
2801 
2802 	errcode = pthread_cond_destroy(&s->thread_args.need_commits);
2803 	if (errcode && err == NULL)
2804 		err = got_error_set_errno(errcode, "pthread_cond_destroy");
2805 
2806 	errcode = pthread_cond_destroy(&s->thread_args.commit_loaded);
2807 	if (errcode && err == NULL)
2808 		err = got_error_set_errno(errcode, "pthread_cond_destroy");
2809 
2810 	free_commits(&s->commits);
2811 	free(s->in_repo_path);
2812 	s->in_repo_path = NULL;
2813 	free(s->start_id);
2814 	s->start_id = NULL;
2815 	free(s->head_ref_name);
2816 	s->head_ref_name = NULL;
2817 	return err;
2818 }
2819 
2820 static const struct got_error *
2821 search_start_log_view(struct tog_view *view)
2822 {
2823 	struct tog_log_view_state *s = &view->state.log;
2824 
2825 	s->matched_entry = NULL;
2826 	s->search_entry = NULL;
2827 	return NULL;
2828 }
2829 
2830 static const struct got_error *
2831 search_next_log_view(struct tog_view *view)
2832 {
2833 	const struct got_error *err = NULL;
2834 	struct tog_log_view_state *s = &view->state.log;
2835 	struct commit_queue_entry *entry;
2836 
2837 	/* Display progress update in log view. */
2838 	show_log_view(view);
2839 	update_panels();
2840 	doupdate();
2841 
2842 	if (s->search_entry) {
2843 		int errcode, ch;
2844 		errcode = pthread_mutex_unlock(&tog_mutex);
2845 		if (errcode)
2846 			return got_error_set_errno(errcode,
2847 			    "pthread_mutex_unlock");
2848 		ch = wgetch(view->window);
2849 		errcode = pthread_mutex_lock(&tog_mutex);
2850 		if (errcode)
2851 			return got_error_set_errno(errcode,
2852 			    "pthread_mutex_lock");
2853 		if (ch == CTRL('g') || ch == KEY_BACKSPACE) {
2854 			view->search_next_done = TOG_SEARCH_HAVE_MORE;
2855 			return NULL;
2856 		}
2857 		if (view->searching == TOG_SEARCH_FORWARD)
2858 			entry = TAILQ_NEXT(s->search_entry, entry);
2859 		else
2860 			entry = TAILQ_PREV(s->search_entry,
2861 			    commit_queue_head, entry);
2862 	} else if (s->matched_entry) {
2863 		int matched_idx = s->matched_entry->idx;
2864 		int selected_idx = s->selected_entry->idx;
2865 
2866 		/*
2867 		 * If the user has moved the cursor after we hit a match,
2868 		 * the position from where we should continue searching
2869 		 * might have changed.
2870 		 */
2871 		if (view->searching == TOG_SEARCH_FORWARD) {
2872 			if (matched_idx > selected_idx)
2873 				entry = TAILQ_NEXT(s->selected_entry, entry);
2874 			else
2875 				entry = TAILQ_NEXT(s->matched_entry, entry);
2876 		} else {
2877 			if (matched_idx < selected_idx)
2878 				entry = TAILQ_PREV(s->selected_entry,
2879 						commit_queue_head, entry);
2880 			else
2881 				entry = TAILQ_PREV(s->matched_entry,
2882 						commit_queue_head, entry);
2883 		}
2884 	} else {
2885 		entry = s->selected_entry;
2886 	}
2887 
2888 	while (1) {
2889 		int have_match = 0;
2890 
2891 		if (entry == NULL) {
2892 			if (s->thread_args.log_complete ||
2893 			    view->searching == TOG_SEARCH_BACKWARD) {
2894 				view->search_next_done =
2895 				    (s->matched_entry == NULL ?
2896 				    TOG_SEARCH_HAVE_NONE : TOG_SEARCH_NO_MORE);
2897 				s->search_entry = NULL;
2898 				return NULL;
2899 			}
2900 			/*
2901 			 * Poke the log thread for more commits and return,
2902 			 * allowing the main loop to make progress. Search
2903 			 * will resume at s->search_entry once we come back.
2904 			 */
2905 			s->thread_args.commits_needed++;
2906 			return trigger_log_thread(view, 0);
2907 		}
2908 
2909 		err = match_commit(&have_match, entry->id, entry->commit,
2910 		    &view->regex);
2911 		if (err)
2912 			break;
2913 		if (have_match) {
2914 			view->search_next_done = TOG_SEARCH_HAVE_MORE;
2915 			s->matched_entry = entry;
2916 			break;
2917 		}
2918 
2919 		s->search_entry = entry;
2920 		if (view->searching == TOG_SEARCH_FORWARD)
2921 			entry = TAILQ_NEXT(entry, entry);
2922 		else
2923 			entry = TAILQ_PREV(entry, commit_queue_head, entry);
2924 	}
2925 
2926 	if (s->matched_entry) {
2927 		int cur = s->selected_entry->idx;
2928 		while (cur < s->matched_entry->idx) {
2929 			err = input_log_view(NULL, view, KEY_DOWN);
2930 			if (err)
2931 				return err;
2932 			cur++;
2933 		}
2934 		while (cur > s->matched_entry->idx) {
2935 			err = input_log_view(NULL, view, KEY_UP);
2936 			if (err)
2937 				return err;
2938 			cur--;
2939 		}
2940 	}
2941 
2942 	s->search_entry = NULL;
2943 
2944 	return NULL;
2945 }
2946 
2947 static const struct got_error *
2948 open_log_view(struct tog_view *view, struct got_object_id *start_id,
2949     struct got_repository *repo, const char *head_ref_name,
2950     const char *in_repo_path, int log_branches)
2951 {
2952 	const struct got_error *err = NULL;
2953 	struct tog_log_view_state *s = &view->state.log;
2954 	struct got_repository *thread_repo = NULL;
2955 	struct got_commit_graph *thread_graph = NULL;
2956 	int errcode;
2957 
2958 	if (in_repo_path != s->in_repo_path) {
2959 		free(s->in_repo_path);
2960 		s->in_repo_path = strdup(in_repo_path);
2961 		if (s->in_repo_path == NULL)
2962 			return got_error_from_errno("strdup");
2963 	}
2964 
2965 	/* The commit queue only contains commits being displayed. */
2966 	TAILQ_INIT(&s->commits.head);
2967 	s->commits.ncommits = 0;
2968 
2969 	s->repo = repo;
2970 	if (head_ref_name) {
2971 		s->head_ref_name = strdup(head_ref_name);
2972 		if (s->head_ref_name == NULL) {
2973 			err = got_error_from_errno("strdup");
2974 			goto done;
2975 		}
2976 	}
2977 	s->start_id = got_object_id_dup(start_id);
2978 	if (s->start_id == NULL) {
2979 		err = got_error_from_errno("got_object_id_dup");
2980 		goto done;
2981 	}
2982 	s->log_branches = log_branches;
2983 
2984 	STAILQ_INIT(&s->colors);
2985 	if (has_colors() && getenv("TOG_COLORS") != NULL) {
2986 		err = add_color(&s->colors, "^$", TOG_COLOR_COMMIT,
2987 		    get_color_value("TOG_COLOR_COMMIT"));
2988 		if (err)
2989 			goto done;
2990 		err = add_color(&s->colors, "^$", TOG_COLOR_AUTHOR,
2991 		    get_color_value("TOG_COLOR_AUTHOR"));
2992 		if (err) {
2993 			free_colors(&s->colors);
2994 			goto done;
2995 		}
2996 		err = add_color(&s->colors, "^$", TOG_COLOR_DATE,
2997 		    get_color_value("TOG_COLOR_DATE"));
2998 		if (err) {
2999 			free_colors(&s->colors);
3000 			goto done;
3001 		}
3002 	}
3003 
3004 	view->show = show_log_view;
3005 	view->input = input_log_view;
3006 	view->resize = resize_log_view;
3007 	view->close = close_log_view;
3008 	view->search_start = search_start_log_view;
3009 	view->search_next = search_next_log_view;
3010 
3011 	if (s->thread_args.pack_fds == NULL) {
3012 		err = got_repo_pack_fds_open(&s->thread_args.pack_fds);
3013 		if (err)
3014 			goto done;
3015 	}
3016 	err = got_repo_open(&thread_repo, got_repo_get_path(repo), NULL,
3017 	    s->thread_args.pack_fds);
3018 	if (err)
3019 		goto done;
3020 	err = got_commit_graph_open(&thread_graph, s->in_repo_path,
3021 	    !s->log_branches);
3022 	if (err)
3023 		goto done;
3024 	err = got_commit_graph_iter_start(thread_graph, s->start_id,
3025 	    s->repo, NULL, NULL);
3026 	if (err)
3027 		goto done;
3028 
3029 	errcode = pthread_cond_init(&s->thread_args.need_commits, NULL);
3030 	if (errcode) {
3031 		err = got_error_set_errno(errcode, "pthread_cond_init");
3032 		goto done;
3033 	}
3034 	errcode = pthread_cond_init(&s->thread_args.commit_loaded, NULL);
3035 	if (errcode) {
3036 		err = got_error_set_errno(errcode, "pthread_cond_init");
3037 		goto done;
3038 	}
3039 
3040 	s->thread_args.commits_needed = view->nlines;
3041 	s->thread_args.graph = thread_graph;
3042 	s->thread_args.commits = &s->commits;
3043 	s->thread_args.in_repo_path = s->in_repo_path;
3044 	s->thread_args.start_id = s->start_id;
3045 	s->thread_args.repo = thread_repo;
3046 	s->thread_args.log_complete = 0;
3047 	s->thread_args.quit = &s->quit;
3048 	s->thread_args.first_displayed_entry = &s->first_displayed_entry;
3049 	s->thread_args.selected_entry = &s->selected_entry;
3050 	s->thread_args.searching = &view->searching;
3051 	s->thread_args.search_next_done = &view->search_next_done;
3052 	s->thread_args.regex = &view->regex;
3053 done:
3054 	if (err)
3055 		close_log_view(view);
3056 	return err;
3057 }
3058 
3059 static const struct got_error *
3060 show_log_view(struct tog_view *view)
3061 {
3062 	const struct got_error *err;
3063 	struct tog_log_view_state *s = &view->state.log;
3064 
3065 	if (s->thread == NULL) {
3066 		int errcode = pthread_create(&s->thread, NULL, log_thread,
3067 		    &s->thread_args);
3068 		if (errcode)
3069 			return got_error_set_errno(errcode, "pthread_create");
3070 		if (s->thread_args.commits_needed > 0) {
3071 			err = trigger_log_thread(view, 1);
3072 			if (err)
3073 				return err;
3074 		}
3075 	}
3076 
3077 	return draw_commits(view);
3078 }
3079 
3080 static void
3081 log_move_cursor_up(struct tog_view *view, int page, int home)
3082 {
3083 	struct tog_log_view_state *s = &view->state.log;
3084 
3085 	if (s->selected_entry->idx == 0)
3086 		view->count = 0;
3087 	if (s->first_displayed_entry == NULL)
3088 		return;
3089 
3090 	if ((page && TAILQ_FIRST(&s->commits.head) == s->first_displayed_entry)
3091 	    || home)
3092 		s->selected = home ? 0 : MAX(0, s->selected - page - 1);
3093 
3094 	if (!page && !home && s->selected > 0)
3095 		--s->selected;
3096 	else
3097 		log_scroll_up(s, home ? s->commits.ncommits : MAX(page, 1));
3098 
3099 	select_commit(s);
3100 	return;
3101 }
3102 
3103 static const struct got_error *
3104 log_move_cursor_down(struct tog_view *view, int page)
3105 {
3106 	struct tog_log_view_state	*s = &view->state.log;
3107 	struct commit_queue_entry	*first;
3108 	const struct got_error		*err = NULL;
3109 
3110 	first = s->first_displayed_entry;
3111 	if (first == NULL) {
3112 		view->count = 0;
3113 		return NULL;
3114 	}
3115 
3116 	if (s->thread_args.log_complete &&
3117 	    s->selected_entry->idx >= s->commits.ncommits - 1)
3118 		return NULL;
3119 
3120 	if (!page) {
3121 		int eos = view->nlines - 2;
3122 
3123 		if (view_is_hsplit_top(view))
3124 			--eos;  /* border consumes the last line */
3125 		if (s->selected < MIN(eos, s->commits.ncommits - 1))
3126 			++s->selected;
3127 		else
3128 			err = log_scroll_down(view, 1);
3129 	} else if (s->thread_args.load_all) {
3130 		if (s->last_displayed_entry->idx == s->commits.ncommits - 1)
3131 			s->selected += MIN(s->last_displayed_entry->idx -
3132 			    s->selected_entry->idx, page + 1);
3133 		else
3134 			err = log_scroll_down(view, MIN(page,
3135 			    s->commits.ncommits - s->selected_entry->idx - 1));
3136 		s->selected = MIN(view->nlines - 2, s->commits.ncommits - 1);
3137 	} else {
3138 		err = log_scroll_down(view, page);
3139 		if (err)
3140 			return err;
3141 		if (first == s->first_displayed_entry && s->selected <
3142 		    MIN(view->nlines - 2, s->commits.ncommits - 1)) {
3143 			s->selected = MIN(s->commits.ncommits - 1, page);
3144 		}
3145 	}
3146 	if (err)
3147 		return err;
3148 
3149 	/*
3150 	 * We might necessarily overshoot in horizontal
3151 	 * splits; if so, select the last displayed commit.
3152 	 */
3153 	s->selected = MIN(s->selected,
3154 	    s->last_displayed_entry->idx - s->first_displayed_entry->idx);
3155 
3156 	select_commit(s);
3157 
3158 	if (s->thread_args.log_complete &&
3159 	    s->selected_entry->idx == s->commits.ncommits - 1)
3160 		view->count = 0;
3161 
3162 	return NULL;
3163 }
3164 
3165 static void
3166 view_get_split(struct tog_view *view, int *y, int *x)
3167 {
3168 	*x = 0;
3169 	*y = 0;
3170 
3171 	if (view->mode == TOG_VIEW_SPLIT_HRZN) {
3172 		if (view->child && view->child->resized_y)
3173 			*y = view->child->resized_y;
3174 		else if (view->resized_y)
3175 			*y = view->resized_y;
3176 		else
3177 			*y = view_split_begin_y(view->lines);
3178 	} else if (view->mode == TOG_VIEW_SPLIT_VERT) {
3179 		if (view->child && view->child->resized_x)
3180 			*x = view->child->resized_x;
3181 		else if (view->resized_x)
3182 			*x = view->resized_x;
3183 		else
3184 			*x = view_split_begin_x(view->begin_x);
3185 	}
3186 }
3187 
3188 /* Split view horizontally at y and offset view->state->selected line. */
3189 static const struct got_error *
3190 view_init_hsplit(struct tog_view *view, int y)
3191 {
3192 	const struct got_error *err = NULL;
3193 
3194 	view->nlines = y;
3195 	view->ncols = COLS;
3196 	err = view_resize(view);
3197 	if (err)
3198 		return err;
3199 
3200 	err = offset_selection_down(view);
3201 
3202 	return err;
3203 }
3204 
3205 static const struct got_error *
3206 input_log_view(struct tog_view **new_view, struct tog_view *view, int ch)
3207 {
3208 	const struct got_error *err = NULL;
3209 	struct tog_log_view_state *s = &view->state.log;
3210 	struct tog_view *diff_view = NULL, *tree_view = NULL;
3211 	struct tog_view *ref_view = NULL;
3212 	struct commit_queue_entry *entry;
3213 	int begin_x = 0, begin_y = 0, eos, n, nscroll;
3214 
3215 	if (s->thread_args.load_all) {
3216 		if (ch == CTRL('g') || ch == KEY_BACKSPACE)
3217 			s->thread_args.load_all = 0;
3218 		else if (s->thread_args.log_complete) {
3219 			err = log_move_cursor_down(view, s->commits.ncommits);
3220 			s->thread_args.load_all = 0;
3221 		}
3222 		return err;
3223 	}
3224 
3225 	eos = nscroll = view->nlines - 1;
3226 	if (view_is_hsplit_top(view))
3227 		--eos;  /* border */
3228 
3229 	switch (ch) {
3230 	case 'q':
3231 		s->quit = 1;
3232 		break;
3233 	case '0':
3234 		view->x = 0;
3235 		break;
3236 	case '$':
3237 		view->x = MAX(view->maxx - view->ncols / 2, 0);
3238 		view->count = 0;
3239 		break;
3240 	case KEY_RIGHT:
3241 	case 'l':
3242 		if (view->x + view->ncols / 2 < view->maxx)
3243 			view->x += 2;  /* move two columns right */
3244 		else
3245 			view->count = 0;
3246 		break;
3247 	case KEY_LEFT:
3248 	case 'h':
3249 		view->x -= MIN(view->x, 2);  /* move two columns back */
3250 		if (view->x <= 0)
3251 			view->count = 0;
3252 		break;
3253 	case 'k':
3254 	case KEY_UP:
3255 	case '<':
3256 	case ',':
3257 	case CTRL('p'):
3258 		log_move_cursor_up(view, 0, 0);
3259 		break;
3260 	case 'g':
3261 	case KEY_HOME:
3262 		log_move_cursor_up(view, 0, 1);
3263 		view->count = 0;
3264 		break;
3265 	case CTRL('u'):
3266 	case 'u':
3267 		nscroll /= 2;
3268 		/* FALL THROUGH */
3269 	case KEY_PPAGE:
3270 	case CTRL('b'):
3271 	case 'b':
3272 		log_move_cursor_up(view, nscroll, 0);
3273 		break;
3274 	case 'j':
3275 	case KEY_DOWN:
3276 	case '>':
3277 	case '.':
3278 	case CTRL('n'):
3279 		err = log_move_cursor_down(view, 0);
3280 		break;
3281 	case '@':
3282 		s->use_committer = !s->use_committer;
3283 		break;
3284 	case 'G':
3285 	case KEY_END: {
3286 		/* We don't know yet how many commits, so we're forced to
3287 		 * traverse them all. */
3288 		view->count = 0;
3289 		if (!s->thread_args.log_complete) {
3290 			s->thread_args.load_all = 1;
3291 			return trigger_log_thread(view, 0);
3292 		}
3293 
3294 		s->selected = 0;
3295 		entry = TAILQ_LAST(&s->commits.head, commit_queue_head);
3296 		for (n = 0; n < eos; n++) {
3297 			if (entry == NULL)
3298 				break;
3299 			s->first_displayed_entry = entry;
3300 			entry = TAILQ_PREV(entry, commit_queue_head, entry);
3301 		}
3302 		if (n > 0)
3303 			s->selected = n - 1;
3304 		select_commit(s);
3305 		break;
3306 	}
3307 	case CTRL('d'):
3308 	case 'd':
3309 		nscroll /= 2;
3310 		/* FALL THROUGH */
3311 	case KEY_NPAGE:
3312 	case CTRL('f'):
3313 	case 'f':
3314 	case ' ':
3315 		err = log_move_cursor_down(view, nscroll);
3316 		break;
3317 	case KEY_RESIZE:
3318 		if (s->selected > view->nlines - 2)
3319 			s->selected = view->nlines - 2;
3320 		if (s->selected > s->commits.ncommits - 1)
3321 			s->selected = s->commits.ncommits - 1;
3322 		select_commit(s);
3323 		if (s->commits.ncommits < view->nlines - 1 &&
3324 		    !s->thread_args.log_complete) {
3325 			s->thread_args.commits_needed += (view->nlines - 1) -
3326 			    s->commits.ncommits;
3327 			err = trigger_log_thread(view, 1);
3328 		}
3329 		break;
3330 	case KEY_ENTER:
3331 	case '\r':
3332 		view->count = 0;
3333 		if (s->selected_entry == NULL)
3334 			break;
3335 
3336 		/* get dimensions--don't split till initialisation succeeds */
3337 		if (view_is_parent_view(view))
3338 			view_get_split(view, &begin_y, &begin_x);
3339 
3340 		err = open_diff_view_for_commit(&diff_view, begin_y, begin_x,
3341 		    s->selected_entry->commit, s->selected_entry->id,
3342 		    view, s->repo);
3343 		if (err)
3344 			break;
3345 
3346 		if (view_is_parent_view(view) &&
3347 		    view->mode == TOG_VIEW_SPLIT_HRZN) {  /* safe to split */
3348 			err = view_init_hsplit(view, begin_y);
3349 			if (err)
3350 				break;
3351 		}
3352 
3353 		view->focussed = 0;
3354 		diff_view->focussed = 1;
3355 		diff_view->mode = view->mode;
3356 		diff_view->nlines = view->lines - begin_y;
3357 
3358 		if (view_is_parent_view(view)) {
3359 			view_transfer_size(diff_view, view);
3360 			err = view_close_child(view);
3361 			if (err)
3362 				return err;
3363 			err = view_set_child(view, diff_view);
3364 			if (err)
3365 				return err;
3366 			view->focus_child = 1;
3367 		} else
3368 			*new_view = diff_view;
3369 		break;
3370 	case 't':
3371 		view->count = 0;
3372 		if (s->selected_entry == NULL)
3373 			break;
3374 		if (view_is_parent_view(view))
3375 			view_get_split(view, &begin_y, &begin_x);
3376 		err = browse_commit_tree(&tree_view, begin_y, begin_x,
3377 		    s->selected_entry, s->in_repo_path, s->head_ref_name,
3378 		    s->repo);
3379 		if (err)
3380 			break;
3381 		if (view_is_parent_view(view) &&
3382 		    view->mode == TOG_VIEW_SPLIT_HRZN) {
3383 			err = view_init_hsplit(view, begin_y);
3384 			if (err)
3385 				break;
3386 		}
3387 		view->focussed = 0;
3388 		tree_view->focussed = 1;
3389 		tree_view->mode = view->mode;
3390 		tree_view->nlines = view->lines - begin_y;
3391 		if (view_is_parent_view(view)) {
3392 			view_transfer_size(tree_view, view);
3393 			err = view_close_child(view);
3394 			if (err)
3395 				return err;
3396 			err = view_set_child(view, tree_view);
3397 			if (err)
3398 				return err;
3399 			view->focus_child = 1;
3400 		} else
3401 			*new_view = tree_view;
3402 		break;
3403 	case KEY_BACKSPACE:
3404 	case CTRL('l'):
3405 	case 'B':
3406 		view->count = 0;
3407 		if (ch == KEY_BACKSPACE &&
3408 		    got_path_is_root_dir(s->in_repo_path))
3409 			break;
3410 		err = stop_log_thread(s);
3411 		if (err)
3412 			return err;
3413 		if (ch == KEY_BACKSPACE) {
3414 			char *parent_path;
3415 			err = got_path_dirname(&parent_path, s->in_repo_path);
3416 			if (err)
3417 				return err;
3418 			free(s->in_repo_path);
3419 			s->in_repo_path = parent_path;
3420 			s->thread_args.in_repo_path = s->in_repo_path;
3421 		} else if (ch == CTRL('l')) {
3422 			struct got_object_id *start_id;
3423 			err = got_repo_match_object_id(&start_id, NULL,
3424 			    s->head_ref_name ? s->head_ref_name : GOT_REF_HEAD,
3425 			    GOT_OBJ_TYPE_COMMIT, &tog_refs, s->repo);
3426 			if (err)
3427 				return err;
3428 			free(s->start_id);
3429 			s->start_id = start_id;
3430 			s->thread_args.start_id = s->start_id;
3431 		} else /* 'B' */
3432 			s->log_branches = !s->log_branches;
3433 
3434 		if (s->thread_args.pack_fds == NULL) {
3435 			err = got_repo_pack_fds_open(&s->thread_args.pack_fds);
3436 			if (err)
3437 				return err;
3438 		}
3439 		err = got_repo_open(&s->thread_args.repo,
3440 		    got_repo_get_path(s->repo), NULL,
3441 		    s->thread_args.pack_fds);
3442 		if (err)
3443 			return err;
3444 		tog_free_refs();
3445 		err = tog_load_refs(s->repo, 0);
3446 		if (err)
3447 			return err;
3448 		err = got_commit_graph_open(&s->thread_args.graph,
3449 		    s->in_repo_path, !s->log_branches);
3450 		if (err)
3451 			return err;
3452 		err = got_commit_graph_iter_start(s->thread_args.graph,
3453 		    s->start_id, s->repo, NULL, NULL);
3454 		if (err)
3455 			return err;
3456 		free_commits(&s->commits);
3457 		s->first_displayed_entry = NULL;
3458 		s->last_displayed_entry = NULL;
3459 		s->selected_entry = NULL;
3460 		s->selected = 0;
3461 		s->thread_args.log_complete = 0;
3462 		s->quit = 0;
3463 		s->thread_args.commits_needed = view->lines;
3464 		s->matched_entry = NULL;
3465 		s->search_entry = NULL;
3466 		break;
3467 	case 'r':
3468 		view->count = 0;
3469 		if (view_is_parent_view(view))
3470 			view_get_split(view, &begin_y, &begin_x);
3471 		ref_view = view_open(0, 0, begin_y, begin_x, TOG_VIEW_REF);
3472 		if (ref_view == NULL)
3473 			return got_error_from_errno("view_open");
3474 		err = open_ref_view(ref_view, s->repo);
3475 		if (err) {
3476 			view_close(ref_view);
3477 			return err;
3478 		}
3479 		if (view_is_parent_view(view) &&
3480 		    view->mode == TOG_VIEW_SPLIT_HRZN) {
3481 			err = view_init_hsplit(view, begin_y);
3482 			if (err)
3483 				break;
3484 		}
3485 		view->focussed = 0;
3486 		ref_view->focussed = 1;
3487 		ref_view->mode = view->mode;
3488 		ref_view->nlines = view->lines - begin_y;
3489 		if (view_is_parent_view(view)) {
3490 			view_transfer_size(ref_view, view);
3491 			err = view_close_child(view);
3492 			if (err)
3493 				return err;
3494 			err = view_set_child(view, ref_view);
3495 			if (err)
3496 				return err;
3497 			view->focus_child = 1;
3498 		} else
3499 			*new_view = ref_view;
3500 		break;
3501 	default:
3502 		view->count = 0;
3503 		break;
3504 	}
3505 
3506 	return err;
3507 }
3508 
3509 static const struct got_error *
3510 apply_unveil(const char *repo_path, const char *worktree_path)
3511 {
3512 	const struct got_error *error;
3513 
3514 #ifdef PROFILE
3515 	if (unveil("gmon.out", "rwc") != 0)
3516 		return got_error_from_errno2("unveil", "gmon.out");
3517 #endif
3518 	if (repo_path && unveil(repo_path, "r") != 0)
3519 		return got_error_from_errno2("unveil", repo_path);
3520 
3521 	if (worktree_path && unveil(worktree_path, "rwc") != 0)
3522 		return got_error_from_errno2("unveil", worktree_path);
3523 
3524 	if (unveil(GOT_TMPDIR_STR, "rwc") != 0)
3525 		return got_error_from_errno2("unveil", GOT_TMPDIR_STR);
3526 
3527 	error = got_privsep_unveil_exec_helpers();
3528 	if (error != NULL)
3529 		return error;
3530 
3531 	if (unveil(NULL, NULL) != 0)
3532 		return got_error_from_errno("unveil");
3533 
3534 	return NULL;
3535 }
3536 
3537 static void
3538 init_curses(void)
3539 {
3540 	/*
3541 	 * Override default signal handlers before starting ncurses.
3542 	 * This should prevent ncurses from installing its own
3543 	 * broken cleanup() signal handler.
3544 	 */
3545 	signal(SIGWINCH, tog_sigwinch);
3546 	signal(SIGPIPE, tog_sigpipe);
3547 	signal(SIGCONT, tog_sigcont);
3548 	signal(SIGINT, tog_sigint);
3549 	signal(SIGTERM, tog_sigterm);
3550 
3551 	initscr();
3552 	cbreak();
3553 	halfdelay(1); /* Do fast refresh while initial view is loading. */
3554 	noecho();
3555 	nonl();
3556 	intrflush(stdscr, FALSE);
3557 	keypad(stdscr, TRUE);
3558 	curs_set(0);
3559 	if (getenv("TOG_COLORS") != NULL) {
3560 		start_color();
3561 		use_default_colors();
3562 	}
3563 }
3564 
3565 static const struct got_error *
3566 get_in_repo_path_from_argv0(char **in_repo_path, int argc, char *argv[],
3567     struct got_repository *repo, struct got_worktree *worktree)
3568 {
3569 	const struct got_error *err = NULL;
3570 
3571 	if (argc == 0) {
3572 		*in_repo_path = strdup("/");
3573 		if (*in_repo_path == NULL)
3574 			return got_error_from_errno("strdup");
3575 		return NULL;
3576 	}
3577 
3578 	if (worktree) {
3579 		const char *prefix = got_worktree_get_path_prefix(worktree);
3580 		char *p;
3581 
3582 		err = got_worktree_resolve_path(&p, worktree, argv[0]);
3583 		if (err)
3584 			return err;
3585 		if (asprintf(in_repo_path, "%s%s%s", prefix,
3586 		    (p[0] != '\0' && !got_path_is_root_dir(prefix)) ? "/" : "",
3587 		    p) == -1) {
3588 			err = got_error_from_errno("asprintf");
3589 			*in_repo_path = NULL;
3590 		}
3591 		free(p);
3592 	} else
3593 		err = got_repo_map_path(in_repo_path, repo, argv[0]);
3594 
3595 	return err;
3596 }
3597 
3598 static const struct got_error *
3599 cmd_log(int argc, char *argv[])
3600 {
3601 	const struct got_error *error;
3602 	struct got_repository *repo = NULL;
3603 	struct got_worktree *worktree = NULL;
3604 	struct got_object_id *start_id = NULL;
3605 	char *in_repo_path = NULL, *repo_path = NULL, *cwd = NULL;
3606 	char *start_commit = NULL, *label = NULL;
3607 	struct got_reference *ref = NULL;
3608 	const char *head_ref_name = NULL;
3609 	int ch, log_branches = 0;
3610 	struct tog_view *view;
3611 	int *pack_fds = NULL;
3612 
3613 	while ((ch = getopt(argc, argv, "bc:r:")) != -1) {
3614 		switch (ch) {
3615 		case 'b':
3616 			log_branches = 1;
3617 			break;
3618 		case 'c':
3619 			start_commit = optarg;
3620 			break;
3621 		case 'r':
3622 			repo_path = realpath(optarg, NULL);
3623 			if (repo_path == NULL)
3624 				return got_error_from_errno2("realpath",
3625 				    optarg);
3626 			break;
3627 		default:
3628 			usage_log();
3629 			/* NOTREACHED */
3630 		}
3631 	}
3632 
3633 	argc -= optind;
3634 	argv += optind;
3635 
3636 	if (argc > 1)
3637 		usage_log();
3638 
3639 	error = got_repo_pack_fds_open(&pack_fds);
3640 	if (error != NULL)
3641 		goto done;
3642 
3643 	if (repo_path == NULL) {
3644 		cwd = getcwd(NULL, 0);
3645 		if (cwd == NULL)
3646 			return got_error_from_errno("getcwd");
3647 		error = got_worktree_open(&worktree, cwd);
3648 		if (error && error->code != GOT_ERR_NOT_WORKTREE)
3649 			goto done;
3650 		if (worktree)
3651 			repo_path =
3652 			    strdup(got_worktree_get_repo_path(worktree));
3653 		else
3654 			repo_path = strdup(cwd);
3655 		if (repo_path == NULL) {
3656 			error = got_error_from_errno("strdup");
3657 			goto done;
3658 		}
3659 	}
3660 
3661 	error = got_repo_open(&repo, repo_path, NULL, pack_fds);
3662 	if (error != NULL)
3663 		goto done;
3664 
3665 	error = get_in_repo_path_from_argv0(&in_repo_path, argc, argv,
3666 	    repo, worktree);
3667 	if (error)
3668 		goto done;
3669 
3670 	init_curses();
3671 
3672 	error = apply_unveil(got_repo_get_path(repo),
3673 	    worktree ? got_worktree_get_root_path(worktree) : NULL);
3674 	if (error)
3675 		goto done;
3676 
3677 	/* already loaded by tog_log_with_path()? */
3678 	if (TAILQ_EMPTY(&tog_refs)) {
3679 		error = tog_load_refs(repo, 0);
3680 		if (error)
3681 			goto done;
3682 	}
3683 
3684 	if (start_commit == NULL) {
3685 		error = got_repo_match_object_id(&start_id, &label,
3686 		    worktree ? got_worktree_get_head_ref_name(worktree) :
3687 		    GOT_REF_HEAD, GOT_OBJ_TYPE_COMMIT, &tog_refs, repo);
3688 		if (error)
3689 			goto done;
3690 		head_ref_name = label;
3691 	} else {
3692 		error = got_ref_open(&ref, repo, start_commit, 0);
3693 		if (error == NULL)
3694 			head_ref_name = got_ref_get_name(ref);
3695 		else if (error->code != GOT_ERR_NOT_REF)
3696 			goto done;
3697 		error = got_repo_match_object_id(&start_id, NULL,
3698 		    start_commit, GOT_OBJ_TYPE_COMMIT, &tog_refs, repo);
3699 		if (error)
3700 			goto done;
3701 	}
3702 
3703 	view = view_open(0, 0, 0, 0, TOG_VIEW_LOG);
3704 	if (view == NULL) {
3705 		error = got_error_from_errno("view_open");
3706 		goto done;
3707 	}
3708 	error = open_log_view(view, start_id, repo, head_ref_name,
3709 	    in_repo_path, log_branches);
3710 	if (error)
3711 		goto done;
3712 	if (worktree) {
3713 		/* Release work tree lock. */
3714 		got_worktree_close(worktree);
3715 		worktree = NULL;
3716 	}
3717 	error = view_loop(view);
3718 done:
3719 	free(in_repo_path);
3720 	free(repo_path);
3721 	free(cwd);
3722 	free(start_id);
3723 	free(label);
3724 	if (ref)
3725 		got_ref_close(ref);
3726 	if (repo) {
3727 		const struct got_error *close_err = got_repo_close(repo);
3728 		if (error == NULL)
3729 			error = close_err;
3730 	}
3731 	if (worktree)
3732 		got_worktree_close(worktree);
3733 	if (pack_fds) {
3734 		const struct got_error *pack_err =
3735 		    got_repo_pack_fds_close(pack_fds);
3736 		if (error == NULL)
3737 			error = pack_err;
3738 	}
3739 	tog_free_refs();
3740 	return error;
3741 }
3742 
3743 __dead static void
3744 usage_diff(void)
3745 {
3746 	endwin();
3747 	fprintf(stderr, "usage: %s diff [-a] [-C number] [-r repository-path] "
3748 	    "[-w] object1 object2\n", getprogname());
3749 	exit(1);
3750 }
3751 
3752 static int
3753 match_line(const char *line, regex_t *regex, size_t nmatch,
3754     regmatch_t *regmatch)
3755 {
3756 	return regexec(regex, line, nmatch, regmatch, 0) == 0;
3757 }
3758 
3759 static struct tog_color *
3760 match_color(struct tog_colors *colors, const char *line)
3761 {
3762 	struct tog_color *tc = NULL;
3763 
3764 	STAILQ_FOREACH(tc, colors, entry) {
3765 		if (match_line(line, &tc->regex, 0, NULL))
3766 			return tc;
3767 	}
3768 
3769 	return NULL;
3770 }
3771 
3772 static const struct got_error *
3773 add_matched_line(int *wtotal, const char *line, int wlimit, int col_tab_align,
3774     WINDOW *window, int skipcol, regmatch_t *regmatch)
3775 {
3776 	const struct got_error *err = NULL;
3777 	char *exstr = NULL;
3778 	wchar_t *wline = NULL;
3779 	int rme, rms, n, width, scrollx;
3780 	int width0 = 0, width1 = 0, width2 = 0;
3781 	char *seg0 = NULL, *seg1 = NULL, *seg2 = NULL;
3782 
3783 	*wtotal = 0;
3784 
3785 	rms = regmatch->rm_so;
3786 	rme = regmatch->rm_eo;
3787 
3788 	err = expand_tab(&exstr, line);
3789 	if (err)
3790 		return err;
3791 
3792 	/* Split the line into 3 segments, according to match offsets. */
3793 	seg0 = strndup(exstr, rms);
3794 	if (seg0 == NULL) {
3795 		err = got_error_from_errno("strndup");
3796 		goto done;
3797 	}
3798 	seg1 = strndup(exstr + rms, rme - rms);
3799 	if (seg1 == NULL) {
3800 		err = got_error_from_errno("strndup");
3801 		goto done;
3802 	}
3803 	seg2 = strdup(exstr + rme);
3804 	if (seg2 == NULL) {
3805 		err = got_error_from_errno("strndup");
3806 		goto done;
3807 	}
3808 
3809 	/* draw up to matched token if we haven't scrolled past it */
3810 	err = format_line(&wline, &width0, NULL, seg0, 0, wlimit,
3811 	    col_tab_align, 1);
3812 	if (err)
3813 		goto done;
3814 	n = MAX(width0 - skipcol, 0);
3815 	if (n) {
3816 		free(wline);
3817 		err = format_line(&wline, &width, &scrollx, seg0, skipcol,
3818 		    wlimit, col_tab_align, 1);
3819 		if (err)
3820 			goto done;
3821 		waddwstr(window, &wline[scrollx]);
3822 		wlimit -= width;
3823 		*wtotal += width;
3824 	}
3825 
3826 	if (wlimit > 0) {
3827 		int i = 0, w = 0;
3828 		size_t wlen;
3829 
3830 		free(wline);
3831 		err = format_line(&wline, &width1, NULL, seg1, 0, wlimit,
3832 		    col_tab_align, 1);
3833 		if (err)
3834 			goto done;
3835 		wlen = wcslen(wline);
3836 		while (i < wlen) {
3837 			width = wcwidth(wline[i]);
3838 			if (width == -1) {
3839 				/* should not happen, tabs are expanded */
3840 				err = got_error(GOT_ERR_RANGE);
3841 				goto done;
3842 			}
3843 			if (width0 + w + width > skipcol)
3844 				break;
3845 			w += width;
3846 			i++;
3847 		}
3848 		/* draw (visible part of) matched token (if scrolled into it) */
3849 		if (width1 - w > 0) {
3850 			wattron(window, A_STANDOUT);
3851 			waddwstr(window, &wline[i]);
3852 			wattroff(window, A_STANDOUT);
3853 			wlimit -= (width1 - w);
3854 			*wtotal += (width1 - w);
3855 		}
3856 	}
3857 
3858 	if (wlimit > 0) {  /* draw rest of line */
3859 		free(wline);
3860 		if (skipcol > width0 + width1) {
3861 			err = format_line(&wline, &width2, &scrollx, seg2,
3862 			    skipcol - (width0 + width1), wlimit,
3863 			    col_tab_align, 1);
3864 			if (err)
3865 				goto done;
3866 			waddwstr(window, &wline[scrollx]);
3867 		} else {
3868 			err = format_line(&wline, &width2, NULL, seg2, 0,
3869 			    wlimit, col_tab_align, 1);
3870 			if (err)
3871 				goto done;
3872 			waddwstr(window, wline);
3873 		}
3874 		*wtotal += width2;
3875 	}
3876 done:
3877 	free(wline);
3878 	free(exstr);
3879 	free(seg0);
3880 	free(seg1);
3881 	free(seg2);
3882 	return err;
3883 }
3884 
3885 static const struct got_error *
3886 draw_file(struct tog_view *view, const char *header)
3887 {
3888 	struct tog_diff_view_state *s = &view->state.diff;
3889 	regmatch_t *regmatch = &view->regmatch;
3890 	const struct got_error *err;
3891 	int nprinted = 0;
3892 	char *line;
3893 	size_t linesize = 0;
3894 	ssize_t linelen;
3895 	struct tog_color *tc;
3896 	wchar_t *wline;
3897 	int width;
3898 	int max_lines = view->nlines;
3899 	int nlines = s->nlines;
3900 	off_t line_offset;
3901 
3902 	line_offset = s->line_offsets[s->first_displayed_line - 1];
3903 	if (fseeko(s->f, line_offset, SEEK_SET) == -1)
3904 		return got_error_from_errno("fseek");
3905 
3906 	werase(view->window);
3907 
3908 	if (header) {
3909 		if (asprintf(&line, "[%d/%d] %s",
3910 		    s->first_displayed_line - 1 + s->selected_line, nlines,
3911 		    header) == -1)
3912 			return got_error_from_errno("asprintf");
3913 		err = format_line(&wline, &width, NULL, line, 0, view->ncols,
3914 		    0, 0);
3915 		free(line);
3916 		if (err)
3917 			return err;
3918 
3919 		if (view_needs_focus_indication(view))
3920 			wstandout(view->window);
3921 		waddwstr(view->window, wline);
3922 		free(wline);
3923 		wline = NULL;
3924 		if (view_needs_focus_indication(view))
3925 			wstandend(view->window);
3926 		if (width <= view->ncols - 1)
3927 			waddch(view->window, '\n');
3928 
3929 		if (max_lines <= 1)
3930 			return NULL;
3931 		max_lines--;
3932 	}
3933 
3934 	s->eof = 0;
3935 	view->maxx = 0;
3936 	line = NULL;
3937 	while (max_lines > 0 && nprinted < max_lines) {
3938 		linelen = getline(&line, &linesize, s->f);
3939 		if (linelen == -1) {
3940 			if (feof(s->f)) {
3941 				s->eof = 1;
3942 				break;
3943 			}
3944 			free(line);
3945 			return got_ferror(s->f, GOT_ERR_IO);
3946 		}
3947 
3948 		/* Set view->maxx based on full line length. */
3949 		err = format_line(&wline, &width, NULL, line, 0, INT_MAX, 0,
3950 		    view->x ? 1 : 0);
3951 		if (err) {
3952 			free(line);
3953 			return err;
3954 		}
3955 		view->maxx = MAX(view->maxx, width);
3956 		free(wline);
3957 		wline = NULL;
3958 
3959 		tc = match_color(&s->colors, line);
3960 		if (tc)
3961 			wattr_on(view->window,
3962 			    COLOR_PAIR(tc->colorpair), NULL);
3963 		if (s->first_displayed_line + nprinted == s->matched_line &&
3964 		    regmatch->rm_so >= 0 && regmatch->rm_so < regmatch->rm_eo) {
3965 			err = add_matched_line(&width, line, view->ncols, 0,
3966 			    view->window, view->x, regmatch);
3967 			if (err) {
3968 				free(line);
3969 				return err;
3970 			}
3971 		} else {
3972 			int skip;
3973 			err = format_line(&wline, &width, &skip, line,
3974 			    view->x, view->ncols, 0, view->x ? 1 : 0);
3975 			if (err) {
3976 				free(line);
3977 				return err;
3978 			}
3979 			waddwstr(view->window, &wline[skip]);
3980 			free(wline);
3981 			wline = NULL;
3982 		}
3983 		if (tc)
3984 			wattr_off(view->window,
3985 			    COLOR_PAIR(tc->colorpair), NULL);
3986 		if (width <= view->ncols - 1)
3987 			waddch(view->window, '\n');
3988 		nprinted++;
3989 	}
3990 	free(line);
3991 	if (nprinted >= 1)
3992 		s->last_displayed_line = s->first_displayed_line +
3993 		    (nprinted - 1);
3994 	else
3995 		s->last_displayed_line = s->first_displayed_line;
3996 
3997 	view_border(view);
3998 
3999 	if (s->eof) {
4000 		while (nprinted < view->nlines) {
4001 			waddch(view->window, '\n');
4002 			nprinted++;
4003 		}
4004 
4005 		err = format_line(&wline, &width, NULL, TOG_EOF_STRING, 0,
4006 		    view->ncols, 0, 0);
4007 		if (err) {
4008 			return err;
4009 		}
4010 
4011 		wstandout(view->window);
4012 		waddwstr(view->window, wline);
4013 		free(wline);
4014 		wline = NULL;
4015 		wstandend(view->window);
4016 	}
4017 
4018 	return NULL;
4019 }
4020 
4021 static char *
4022 get_datestr(time_t *time, char *datebuf)
4023 {
4024 	struct tm mytm, *tm;
4025 	char *p, *s;
4026 
4027 	tm = gmtime_r(time, &mytm);
4028 	if (tm == NULL)
4029 		return NULL;
4030 	s = asctime_r(tm, datebuf);
4031 	if (s == NULL)
4032 		return NULL;
4033 	p = strchr(s, '\n');
4034 	if (p)
4035 		*p = '\0';
4036 	return s;
4037 }
4038 
4039 static const struct got_error *
4040 get_changed_paths(struct got_pathlist_head *paths,
4041     struct got_commit_object *commit, struct got_repository *repo)
4042 {
4043 	const struct got_error *err = NULL;
4044 	struct got_object_id *tree_id1 = NULL, *tree_id2 = NULL;
4045 	struct got_tree_object *tree1 = NULL, *tree2 = NULL;
4046 	struct got_object_qid *qid;
4047 
4048 	qid = STAILQ_FIRST(got_object_commit_get_parent_ids(commit));
4049 	if (qid != NULL) {
4050 		struct got_commit_object *pcommit;
4051 		err = got_object_open_as_commit(&pcommit, repo,
4052 		    &qid->id);
4053 		if (err)
4054 			return err;
4055 
4056 		tree_id1 = got_object_id_dup(
4057 		    got_object_commit_get_tree_id(pcommit));
4058 		if (tree_id1 == NULL) {
4059 			got_object_commit_close(pcommit);
4060 			return got_error_from_errno("got_object_id_dup");
4061 		}
4062 		got_object_commit_close(pcommit);
4063 
4064 	}
4065 
4066 	if (tree_id1) {
4067 		err = got_object_open_as_tree(&tree1, repo, tree_id1);
4068 		if (err)
4069 			goto done;
4070 	}
4071 
4072 	tree_id2 = got_object_commit_get_tree_id(commit);
4073 	err = got_object_open_as_tree(&tree2, repo, tree_id2);
4074 	if (err)
4075 		goto done;
4076 
4077 	err = got_diff_tree(tree1, tree2, NULL, NULL, -1, -1, "", "", repo,
4078 	    got_diff_tree_collect_changed_paths, paths, 0);
4079 done:
4080 	if (tree1)
4081 		got_object_tree_close(tree1);
4082 	if (tree2)
4083 		got_object_tree_close(tree2);
4084 	free(tree_id1);
4085 	return err;
4086 }
4087 
4088 static const struct got_error *
4089 add_line_offset(off_t **line_offsets, size_t *nlines, off_t off)
4090 {
4091 	off_t *p;
4092 
4093 	p = reallocarray(*line_offsets, *nlines + 1, sizeof(off_t));
4094 	if (p == NULL)
4095 		return got_error_from_errno("reallocarray");
4096 	*line_offsets = p;
4097 	(*line_offsets)[*nlines] = off;
4098 	(*nlines)++;
4099 	return NULL;
4100 }
4101 
4102 static const struct got_error *
4103 write_commit_info(off_t **line_offsets, size_t *nlines,
4104     struct got_object_id *commit_id, struct got_reflist_head *refs,
4105     struct got_repository *repo, FILE *outfile)
4106 {
4107 	const struct got_error *err = NULL;
4108 	char datebuf[26], *datestr;
4109 	struct got_commit_object *commit;
4110 	char *id_str = NULL, *logmsg = NULL, *s = NULL, *line;
4111 	time_t committer_time;
4112 	const char *author, *committer;
4113 	char *refs_str = NULL;
4114 	struct got_pathlist_head changed_paths;
4115 	struct got_pathlist_entry *pe;
4116 	off_t outoff = 0;
4117 	int n;
4118 
4119 	TAILQ_INIT(&changed_paths);
4120 
4121 	if (refs) {
4122 		err = build_refs_str(&refs_str, refs, commit_id, repo);
4123 		if (err)
4124 			return err;
4125 	}
4126 
4127 	err = got_object_open_as_commit(&commit, repo, commit_id);
4128 	if (err)
4129 		return err;
4130 
4131 	err = got_object_id_str(&id_str, commit_id);
4132 	if (err) {
4133 		err = got_error_from_errno("got_object_id_str");
4134 		goto done;
4135 	}
4136 
4137 	err = add_line_offset(line_offsets, nlines, 0);
4138 	if (err)
4139 		goto done;
4140 
4141 	n = fprintf(outfile, "commit %s%s%s%s\n", id_str, refs_str ? " (" : "",
4142 	    refs_str ? refs_str : "", refs_str ? ")" : "");
4143 	if (n < 0) {
4144 		err = got_error_from_errno("fprintf");
4145 		goto done;
4146 	}
4147 	outoff += n;
4148 	err = add_line_offset(line_offsets, nlines, outoff);
4149 	if (err)
4150 		goto done;
4151 
4152 	n = fprintf(outfile, "from: %s\n",
4153 	    got_object_commit_get_author(commit));
4154 	if (n < 0) {
4155 		err = got_error_from_errno("fprintf");
4156 		goto done;
4157 	}
4158 	outoff += n;
4159 	err = add_line_offset(line_offsets, nlines, outoff);
4160 	if (err)
4161 		goto done;
4162 
4163 	committer_time = got_object_commit_get_committer_time(commit);
4164 	datestr = get_datestr(&committer_time, datebuf);
4165 	if (datestr) {
4166 		n = fprintf(outfile, "date: %s UTC\n", datestr);
4167 		if (n < 0) {
4168 			err = got_error_from_errno("fprintf");
4169 			goto done;
4170 		}
4171 		outoff += n;
4172 		err = add_line_offset(line_offsets, nlines, outoff);
4173 		if (err)
4174 			goto done;
4175 	}
4176 	author = got_object_commit_get_author(commit);
4177 	committer = got_object_commit_get_committer(commit);
4178 	if (strcmp(author, committer) != 0) {
4179 		n = fprintf(outfile, "via: %s\n", committer);
4180 		if (n < 0) {
4181 			err = got_error_from_errno("fprintf");
4182 			goto done;
4183 		}
4184 		outoff += n;
4185 		err = add_line_offset(line_offsets, nlines, outoff);
4186 		if (err)
4187 			goto done;
4188 	}
4189 	if (got_object_commit_get_nparents(commit) > 1) {
4190 		const struct got_object_id_queue *parent_ids;
4191 		struct got_object_qid *qid;
4192 		int pn = 1;
4193 		parent_ids = got_object_commit_get_parent_ids(commit);
4194 		STAILQ_FOREACH(qid, parent_ids, entry) {
4195 			err = got_object_id_str(&id_str, &qid->id);
4196 			if (err)
4197 				goto done;
4198 			n = fprintf(outfile, "parent %d: %s\n", pn++, id_str);
4199 			if (n < 0) {
4200 				err = got_error_from_errno("fprintf");
4201 				goto done;
4202 			}
4203 			outoff += n;
4204 			err = add_line_offset(line_offsets, nlines, outoff);
4205 			if (err)
4206 				goto done;
4207 			free(id_str);
4208 			id_str = NULL;
4209 		}
4210 	}
4211 
4212 	err = got_object_commit_get_logmsg(&logmsg, commit);
4213 	if (err)
4214 		goto done;
4215 	s = logmsg;
4216 	while ((line = strsep(&s, "\n")) != NULL) {
4217 		n = fprintf(outfile, "%s\n", line);
4218 		if (n < 0) {
4219 			err = got_error_from_errno("fprintf");
4220 			goto done;
4221 		}
4222 		outoff += n;
4223 		err = add_line_offset(line_offsets, nlines, outoff);
4224 		if (err)
4225 			goto done;
4226 	}
4227 
4228 	err = get_changed_paths(&changed_paths, commit, repo);
4229 	if (err)
4230 		goto done;
4231 	TAILQ_FOREACH(pe, &changed_paths, entry) {
4232 		struct got_diff_changed_path *cp = pe->data;
4233 		n = fprintf(outfile, "%c  %s\n", cp->status, pe->path);
4234 		if (n < 0) {
4235 			err = got_error_from_errno("fprintf");
4236 			goto done;
4237 		}
4238 		outoff += n;
4239 		err = add_line_offset(line_offsets, nlines, outoff);
4240 		if (err)
4241 			goto done;
4242 		free((char *)pe->path);
4243 		free(pe->data);
4244 	}
4245 
4246 	fputc('\n', outfile);
4247 	outoff++;
4248 	err = add_line_offset(line_offsets, nlines, outoff);
4249 done:
4250 	got_pathlist_free(&changed_paths);
4251 	free(id_str);
4252 	free(logmsg);
4253 	free(refs_str);
4254 	got_object_commit_close(commit);
4255 	if (err) {
4256 		free(*line_offsets);
4257 		*line_offsets = NULL;
4258 		*nlines = 0;
4259 	}
4260 	return err;
4261 }
4262 
4263 static const struct got_error *
4264 create_diff(struct tog_diff_view_state *s)
4265 {
4266 	const struct got_error *err = NULL;
4267 	FILE *f = NULL;
4268 	int obj_type;
4269 
4270 	free(s->line_offsets);
4271 	s->line_offsets = malloc(sizeof(off_t));
4272 	if (s->line_offsets == NULL)
4273 		return got_error_from_errno("malloc");
4274 	s->nlines = 0;
4275 
4276 	f = got_opentemp();
4277 	if (f == NULL) {
4278 		err = got_error_from_errno("got_opentemp");
4279 		goto done;
4280 	}
4281 	if (s->f && fclose(s->f) == EOF) {
4282 		err = got_error_from_errno("fclose");
4283 		goto done;
4284 	}
4285 	s->f = f;
4286 
4287 	if (s->id1)
4288 		err = got_object_get_type(&obj_type, s->repo, s->id1);
4289 	else
4290 		err = got_object_get_type(&obj_type, s->repo, s->id2);
4291 	if (err)
4292 		goto done;
4293 
4294 	switch (obj_type) {
4295 	case GOT_OBJ_TYPE_BLOB:
4296 		err = got_diff_objects_as_blobs(&s->line_offsets, &s->nlines,
4297 		    s->f1, s->f2, s->fd1, s->fd2, s->id1, s->id2,
4298 		    s->label1, s->label2, tog_diff_algo, s->diff_context,
4299 		    s->ignore_whitespace, s->force_text_diff, s->repo, s->f);
4300 		break;
4301 	case GOT_OBJ_TYPE_TREE:
4302 		err = got_diff_objects_as_trees(&s->line_offsets, &s->nlines,
4303 		    s->f1, s->f2, s->fd1, s->fd2, s->id1, s->id2, NULL, "", "",
4304 		    tog_diff_algo, s->diff_context, s->ignore_whitespace,
4305 		    s->force_text_diff, s->repo, s->f);
4306 		break;
4307 	case GOT_OBJ_TYPE_COMMIT: {
4308 		const struct got_object_id_queue *parent_ids;
4309 		struct got_object_qid *pid;
4310 		struct got_commit_object *commit2;
4311 		struct got_reflist_head *refs;
4312 
4313 		err = got_object_open_as_commit(&commit2, s->repo, s->id2);
4314 		if (err)
4315 			goto done;
4316 		refs = got_reflist_object_id_map_lookup(tog_refs_idmap, s->id2);
4317 		/* Show commit info if we're diffing to a parent/root commit. */
4318 		if (s->id1 == NULL) {
4319 			err = write_commit_info(&s->line_offsets, &s->nlines,
4320 			    s->id2, refs, s->repo, s->f);
4321 			if (err)
4322 				goto done;
4323 		} else {
4324 			parent_ids = got_object_commit_get_parent_ids(commit2);
4325 			STAILQ_FOREACH(pid, parent_ids, entry) {
4326 				if (got_object_id_cmp(s->id1, &pid->id) == 0) {
4327 					err = write_commit_info(
4328 					    &s->line_offsets, &s->nlines,
4329 					    s->id2, refs, s->repo, s->f);
4330 					if (err)
4331 						goto done;
4332 					break;
4333 				}
4334 			}
4335 		}
4336 		got_object_commit_close(commit2);
4337 
4338 		err = got_diff_objects_as_commits(&s->line_offsets, &s->nlines,
4339 		    s->f1, s->f2, s->fd1, s->fd2, s->id1, s->id2, NULL,
4340 		    tog_diff_algo, s->diff_context, s->ignore_whitespace,
4341 		    s->force_text_diff, s->repo, s->f);
4342 		break;
4343 	}
4344 	default:
4345 		err = got_error(GOT_ERR_OBJ_TYPE);
4346 		break;
4347 	}
4348 	if (err)
4349 		goto done;
4350 done:
4351 	if (s->f && fflush(s->f) != 0 && err == NULL)
4352 		err = got_error_from_errno("fflush");
4353 	return err;
4354 }
4355 
4356 static void
4357 diff_view_indicate_progress(struct tog_view *view)
4358 {
4359 	mvwaddstr(view->window, 0, 0, "diffing...");
4360 	update_panels();
4361 	doupdate();
4362 }
4363 
4364 static const struct got_error *
4365 search_start_diff_view(struct tog_view *view)
4366 {
4367 	struct tog_diff_view_state *s = &view->state.diff;
4368 
4369 	s->matched_line = 0;
4370 	return NULL;
4371 }
4372 
4373 static const struct got_error *
4374 search_next_diff_view(struct tog_view *view)
4375 {
4376 	struct tog_diff_view_state *s = &view->state.diff;
4377 	const struct got_error *err = NULL;
4378 	int lineno;
4379 	char *line = NULL;
4380 	size_t linesize = 0;
4381 	ssize_t linelen;
4382 
4383 	if (!view->searching) {
4384 		view->search_next_done = TOG_SEARCH_HAVE_MORE;
4385 		return NULL;
4386 	}
4387 
4388 	if (s->matched_line) {
4389 		if (view->searching == TOG_SEARCH_FORWARD)
4390 			lineno = s->matched_line + 1;
4391 		else
4392 			lineno = s->matched_line - 1;
4393 	} else
4394 		lineno = s->first_displayed_line;
4395 
4396 	while (1) {
4397 		off_t offset;
4398 
4399 		if (lineno <= 0 || lineno > s->nlines) {
4400 			if (s->matched_line == 0) {
4401 				view->search_next_done = TOG_SEARCH_HAVE_MORE;
4402 				break;
4403 			}
4404 
4405 			if (view->searching == TOG_SEARCH_FORWARD)
4406 				lineno = 1;
4407 			else
4408 				lineno = s->nlines;
4409 		}
4410 
4411 		offset = s->line_offsets[lineno - 1];
4412 		if (fseeko(s->f, offset, SEEK_SET) != 0) {
4413 			free(line);
4414 			return got_error_from_errno("fseeko");
4415 		}
4416 		linelen = getline(&line, &linesize, s->f);
4417 		if (linelen != -1) {
4418 			char *exstr;
4419 			err = expand_tab(&exstr, line);
4420 			if (err)
4421 				break;
4422 			if (match_line(exstr, &view->regex, 1,
4423 			    &view->regmatch)) {
4424 				view->search_next_done = TOG_SEARCH_HAVE_MORE;
4425 				s->matched_line = lineno;
4426 				free(exstr);
4427 				break;
4428 			}
4429 			free(exstr);
4430 		}
4431 		if (view->searching == TOG_SEARCH_FORWARD)
4432 			lineno++;
4433 		else
4434 			lineno--;
4435 	}
4436 	free(line);
4437 
4438 	if (s->matched_line) {
4439 		s->first_displayed_line = s->matched_line;
4440 		s->selected_line = 1;
4441 	}
4442 
4443 	return err;
4444 }
4445 
4446 static const struct got_error *
4447 close_diff_view(struct tog_view *view)
4448 {
4449 	const struct got_error *err = NULL;
4450 	struct tog_diff_view_state *s = &view->state.diff;
4451 
4452 	free(s->id1);
4453 	s->id1 = NULL;
4454 	free(s->id2);
4455 	s->id2 = NULL;
4456 	if (s->f && fclose(s->f) == EOF)
4457 		err = got_error_from_errno("fclose");
4458 	s->f = NULL;
4459 	if (s->f1 && fclose(s->f1) == EOF && err == NULL)
4460 		err = got_error_from_errno("fclose");
4461 	s->f1 = NULL;
4462 	if (s->f2 && fclose(s->f2) == EOF && err == NULL)
4463 		err = got_error_from_errno("fclose");
4464 	s->f2 = NULL;
4465 	if (s->fd1 != -1 && close(s->fd1) == -1 && err == NULL)
4466 		err = got_error_from_errno("close");
4467 	s->fd1 = -1;
4468 	if (s->fd2 != -1 && close(s->fd2) == -1 && err == NULL)
4469 		err = got_error_from_errno("close");
4470 	s->fd2 = -1;
4471 	free_colors(&s->colors);
4472 	free(s->line_offsets);
4473 	s->line_offsets = NULL;
4474 	s->nlines = 0;
4475 	return err;
4476 }
4477 
4478 static const struct got_error *
4479 open_diff_view(struct tog_view *view, struct got_object_id *id1,
4480     struct got_object_id *id2, const char *label1, const char *label2,
4481     int diff_context, int ignore_whitespace, int force_text_diff,
4482     struct tog_view *parent_view, struct got_repository *repo)
4483 {
4484 	const struct got_error *err;
4485 	struct tog_diff_view_state *s = &view->state.diff;
4486 
4487 	memset(s, 0, sizeof(*s));
4488 	s->fd1 = -1;
4489 	s->fd2 = -1;
4490 
4491 	if (id1 != NULL && id2 != NULL) {
4492 	    int type1, type2;
4493 	    err = got_object_get_type(&type1, repo, id1);
4494 	    if (err)
4495 		return err;
4496 	    err = got_object_get_type(&type2, repo, id2);
4497 	    if (err)
4498 		return err;
4499 
4500 	    if (type1 != type2)
4501 		return got_error(GOT_ERR_OBJ_TYPE);
4502 	}
4503 	s->first_displayed_line = 1;
4504 	s->last_displayed_line = view->nlines;
4505 	s->selected_line = 1;
4506 	s->repo = repo;
4507 	s->id1 = id1;
4508 	s->id2 = id2;
4509 	s->label1 = label1;
4510 	s->label2 = label2;
4511 
4512 	if (id1) {
4513 		s->id1 = got_object_id_dup(id1);
4514 		if (s->id1 == NULL)
4515 			return got_error_from_errno("got_object_id_dup");
4516 	} else
4517 		s->id1 = NULL;
4518 
4519 	s->id2 = got_object_id_dup(id2);
4520 	if (s->id2 == NULL) {
4521 		err = got_error_from_errno("got_object_id_dup");
4522 		goto done;
4523 	}
4524 
4525 	s->f1 = got_opentemp();
4526 	if (s->f1 == NULL) {
4527 		err = got_error_from_errno("got_opentemp");
4528 		goto done;
4529 	}
4530 
4531 	s->f2 = got_opentemp();
4532 	if (s->f2 == NULL) {
4533 		err = got_error_from_errno("got_opentemp");
4534 		goto done;
4535 	}
4536 
4537 	s->fd1 = got_opentempfd();
4538 	if (s->fd1 == -1) {
4539 		err = got_error_from_errno("got_opentempfd");
4540 		goto done;
4541 	}
4542 
4543 	s->fd2 = got_opentempfd();
4544 	if (s->fd2 == -1) {
4545 		err = got_error_from_errno("got_opentempfd");
4546 		goto done;
4547 	}
4548 
4549 	s->first_displayed_line = 1;
4550 	s->last_displayed_line = view->nlines;
4551 	s->diff_context = diff_context;
4552 	s->ignore_whitespace = ignore_whitespace;
4553 	s->force_text_diff = force_text_diff;
4554 	s->parent_view = parent_view;
4555 	s->repo = repo;
4556 
4557 	STAILQ_INIT(&s->colors);
4558 	if (has_colors() && getenv("TOG_COLORS") != NULL) {
4559 		err = add_color(&s->colors,
4560 		    "^-", TOG_COLOR_DIFF_MINUS,
4561 		    get_color_value("TOG_COLOR_DIFF_MINUS"));
4562 		if (err)
4563 			goto done;
4564 		err = add_color(&s->colors, "^\\+",
4565 		    TOG_COLOR_DIFF_PLUS,
4566 		    get_color_value("TOG_COLOR_DIFF_PLUS"));
4567 		if (err)
4568 			goto done;
4569 		err = add_color(&s->colors,
4570 		    "^@@", TOG_COLOR_DIFF_CHUNK_HEADER,
4571 		    get_color_value("TOG_COLOR_DIFF_CHUNK_HEADER"));
4572 		if (err)
4573 			goto done;
4574 
4575 		err = add_color(&s->colors,
4576 		    "^(commit [0-9a-f]|parent [0-9]|"
4577 		    "(blob|file|tree|commit) [-+] |"
4578 		    "[MDmA]  [^ ])", TOG_COLOR_DIFF_META,
4579 		    get_color_value("TOG_COLOR_DIFF_META"));
4580 		if (err)
4581 			goto done;
4582 
4583 		err = add_color(&s->colors,
4584 		    "^(from|via): ", TOG_COLOR_AUTHOR,
4585 		    get_color_value("TOG_COLOR_AUTHOR"));
4586 		if (err)
4587 			goto done;
4588 
4589 		err = add_color(&s->colors,
4590 		    "^date: ", TOG_COLOR_DATE,
4591 		    get_color_value("TOG_COLOR_DATE"));
4592 		if (err)
4593 			goto done;
4594 	}
4595 
4596 	if (parent_view && parent_view->type == TOG_VIEW_LOG &&
4597 	    view_is_splitscreen(view))
4598 		show_log_view(parent_view); /* draw border */
4599 	diff_view_indicate_progress(view);
4600 
4601 	err = create_diff(s);
4602 
4603 	view->show = show_diff_view;
4604 	view->input = input_diff_view;
4605 	view->reset = reset_diff_view;
4606 	view->close = close_diff_view;
4607 	view->search_start = search_start_diff_view;
4608 	view->search_next = search_next_diff_view;
4609 done:
4610 	if (err)
4611 		close_diff_view(view);
4612 	return err;
4613 }
4614 
4615 static const struct got_error *
4616 show_diff_view(struct tog_view *view)
4617 {
4618 	const struct got_error *err;
4619 	struct tog_diff_view_state *s = &view->state.diff;
4620 	char *id_str1 = NULL, *id_str2, *header;
4621 	const char *label1, *label2;
4622 
4623 	if (s->id1) {
4624 		err = got_object_id_str(&id_str1, s->id1);
4625 		if (err)
4626 			return err;
4627 		label1 = s->label1 ? : id_str1;
4628 	} else
4629 		label1 = "/dev/null";
4630 
4631 	err = got_object_id_str(&id_str2, s->id2);
4632 	if (err)
4633 		return err;
4634 	label2 = s->label2 ? : id_str2;
4635 
4636 	if (asprintf(&header, "diff %s %s", label1, label2) == -1) {
4637 		err = got_error_from_errno("asprintf");
4638 		free(id_str1);
4639 		free(id_str2);
4640 		return err;
4641 	}
4642 	free(id_str1);
4643 	free(id_str2);
4644 
4645 	err = draw_file(view, header);
4646 	free(header);
4647 	return err;
4648 }
4649 
4650 static const struct got_error *
4651 set_selected_commit(struct tog_diff_view_state *s,
4652     struct commit_queue_entry *entry)
4653 {
4654 	const struct got_error *err;
4655 	const struct got_object_id_queue *parent_ids;
4656 	struct got_commit_object *selected_commit;
4657 	struct got_object_qid *pid;
4658 
4659 	free(s->id2);
4660 	s->id2 = got_object_id_dup(entry->id);
4661 	if (s->id2 == NULL)
4662 		return got_error_from_errno("got_object_id_dup");
4663 
4664 	err = got_object_open_as_commit(&selected_commit, s->repo, entry->id);
4665 	if (err)
4666 		return err;
4667 	parent_ids = got_object_commit_get_parent_ids(selected_commit);
4668 	free(s->id1);
4669 	pid = STAILQ_FIRST(parent_ids);
4670 	s->id1 = pid ? got_object_id_dup(&pid->id) : NULL;
4671 	got_object_commit_close(selected_commit);
4672 	return NULL;
4673 }
4674 
4675 static const struct got_error *
4676 reset_diff_view(struct tog_view *view)
4677 {
4678 	struct tog_diff_view_state *s = &view->state.diff;
4679 
4680 	view->count = 0;
4681 	wclear(view->window);
4682 	s->first_displayed_line = 1;
4683 	s->last_displayed_line = view->nlines;
4684 	s->matched_line = 0;
4685 	diff_view_indicate_progress(view);
4686 	return create_diff(s);
4687 }
4688 
4689 static struct got_object_id *get_selected_commit_id(struct tog_blame_line *,
4690     int, int, int);
4691 static struct got_object_id *get_annotation_for_line(struct tog_blame_line *,
4692     int, int);
4693 
4694 static const struct got_error *
4695 input_diff_view(struct tog_view **new_view, struct tog_view *view, int ch)
4696 {
4697 	const struct got_error *err = NULL;
4698 	struct tog_diff_view_state *s = &view->state.diff;
4699 	struct tog_log_view_state *ls;
4700 	struct commit_queue_entry *old_selected_entry;
4701 	char *line = NULL;
4702 	size_t linesize = 0;
4703 	ssize_t linelen;
4704 	int i, nscroll = view->nlines - 1, up = 0;
4705 
4706 	switch (ch) {
4707 	case '0':
4708 		view->x = 0;
4709 		break;
4710 	case '$':
4711 		view->x = MAX(view->maxx - view->ncols / 3, 0);
4712 		view->count = 0;
4713 		break;
4714 	case KEY_RIGHT:
4715 	case 'l':
4716 		if (view->x + view->ncols / 3 < view->maxx)
4717 			view->x += 2;  /* move two columns right */
4718 		else
4719 			view->count = 0;
4720 		break;
4721 	case KEY_LEFT:
4722 	case 'h':
4723 		view->x -= MIN(view->x, 2);  /* move two columns back */
4724 		if (view->x <= 0)
4725 			view->count = 0;
4726 		break;
4727 	case 'a':
4728 	case 'w':
4729 		if (ch == 'a')
4730 			s->force_text_diff = !s->force_text_diff;
4731 		if (ch == 'w')
4732 			s->ignore_whitespace = !s->ignore_whitespace;
4733 		err = reset_diff_view(view);
4734 		break;
4735 	case 'g':
4736 	case KEY_HOME:
4737 		s->first_displayed_line = 1;
4738 		view->count = 0;
4739 		break;
4740 	case 'G':
4741 	case KEY_END:
4742 		view->count = 0;
4743 		if (s->eof)
4744 			break;
4745 
4746 		s->first_displayed_line = (s->nlines - view->nlines) + 2;
4747 		s->eof = 1;
4748 		break;
4749 	case 'k':
4750 	case KEY_UP:
4751 	case CTRL('p'):
4752 		if (s->first_displayed_line > 1)
4753 			s->first_displayed_line--;
4754 		else
4755 			view->count = 0;
4756 		break;
4757 	case CTRL('u'):
4758 	case 'u':
4759 		nscroll /= 2;
4760 		/* FALL THROUGH */
4761 	case KEY_PPAGE:
4762 	case CTRL('b'):
4763 	case 'b':
4764 		if (s->first_displayed_line == 1) {
4765 			view->count = 0;
4766 			break;
4767 		}
4768 		i = 0;
4769 		while (i++ < nscroll && s->first_displayed_line > 1)
4770 			s->first_displayed_line--;
4771 		break;
4772 	case 'j':
4773 	case KEY_DOWN:
4774 	case CTRL('n'):
4775 		if (!s->eof)
4776 			s->first_displayed_line++;
4777 		else
4778 			view->count = 0;
4779 		break;
4780 	case CTRL('d'):
4781 	case 'd':
4782 		nscroll /= 2;
4783 		/* FALL THROUGH */
4784 	case KEY_NPAGE:
4785 	case CTRL('f'):
4786 	case 'f':
4787 	case ' ':
4788 		if (s->eof) {
4789 			view->count = 0;
4790 			break;
4791 		}
4792 		i = 0;
4793 		while (!s->eof && i++ < nscroll) {
4794 			linelen = getline(&line, &linesize, s->f);
4795 			s->first_displayed_line++;
4796 			if (linelen == -1) {
4797 				if (feof(s->f)) {
4798 					s->eof = 1;
4799 				} else
4800 					err = got_ferror(s->f, GOT_ERR_IO);
4801 				break;
4802 			}
4803 		}
4804 		free(line);
4805 		break;
4806 	case '[':
4807 		if (s->diff_context > 0) {
4808 			s->diff_context--;
4809 			s->matched_line = 0;
4810 			diff_view_indicate_progress(view);
4811 			err = create_diff(s);
4812 			if (s->first_displayed_line + view->nlines - 1 >
4813 			    s->nlines) {
4814 				s->first_displayed_line = 1;
4815 				s->last_displayed_line = view->nlines;
4816 			}
4817 		} else
4818 			view->count = 0;
4819 		break;
4820 	case ']':
4821 		if (s->diff_context < GOT_DIFF_MAX_CONTEXT) {
4822 			s->diff_context++;
4823 			s->matched_line = 0;
4824 			diff_view_indicate_progress(view);
4825 			err = create_diff(s);
4826 		} else
4827 			view->count = 0;
4828 		break;
4829 	case '<':
4830 	case ',':
4831 	case 'K':
4832 		up = 1;
4833 		/* FALL THROUGH */
4834 	case '>':
4835 	case '.':
4836 	case 'J':
4837 		if (s->parent_view == NULL) {
4838 			view->count = 0;
4839 			break;
4840 		}
4841 		s->parent_view->count = view->count;
4842 
4843 		if (s->parent_view->type == TOG_VIEW_LOG) {
4844 			ls = &s->parent_view->state.log;
4845 			old_selected_entry = ls->selected_entry;
4846 
4847 			err = input_log_view(NULL, s->parent_view,
4848 			    up ? KEY_UP : KEY_DOWN);
4849 			if (err)
4850 				break;
4851 			view->count = s->parent_view->count;
4852 
4853 			if (old_selected_entry == ls->selected_entry)
4854 				break;
4855 
4856 			err = set_selected_commit(s, ls->selected_entry);
4857 			if (err)
4858 				break;
4859 		} else if (s->parent_view->type == TOG_VIEW_BLAME) {
4860 			struct tog_blame_view_state *bs;
4861 			struct got_object_id *id, *prev_id;
4862 
4863 			bs = &s->parent_view->state.blame;
4864 			prev_id = get_annotation_for_line(bs->blame.lines,
4865 			    bs->blame.nlines, bs->last_diffed_line);
4866 
4867 			err = input_blame_view(&view, s->parent_view,
4868 			    up ? KEY_UP : KEY_DOWN);
4869 			if (err)
4870 				break;
4871 			view->count = s->parent_view->count;
4872 
4873 			if (prev_id == NULL)
4874 				break;
4875 			id = get_selected_commit_id(bs->blame.lines,
4876 			    bs->blame.nlines, bs->first_displayed_line,
4877 			    bs->selected_line);
4878 			if (id == NULL)
4879 				break;
4880 
4881 			if (!got_object_id_cmp(prev_id, id))
4882 				break;
4883 
4884 			err = input_blame_view(&view, s->parent_view, KEY_ENTER);
4885 			if (err)
4886 				break;
4887 		}
4888 		s->first_displayed_line = 1;
4889 		s->last_displayed_line = view->nlines;
4890 		s->matched_line = 0;
4891 		view->x = 0;
4892 
4893 		diff_view_indicate_progress(view);
4894 		err = create_diff(s);
4895 		break;
4896 	default:
4897 		view->count = 0;
4898 		break;
4899 	}
4900 
4901 	return err;
4902 }
4903 
4904 static const struct got_error *
4905 cmd_diff(int argc, char *argv[])
4906 {
4907 	const struct got_error *error = NULL;
4908 	struct got_repository *repo = NULL;
4909 	struct got_worktree *worktree = NULL;
4910 	struct got_object_id *id1 = NULL, *id2 = NULL;
4911 	char *repo_path = NULL, *cwd = NULL;
4912 	char *id_str1 = NULL, *id_str2 = NULL;
4913 	char *label1 = NULL, *label2 = NULL;
4914 	int diff_context = 3, ignore_whitespace = 0;
4915 	int ch, force_text_diff = 0;
4916 	const char *errstr;
4917 	struct tog_view *view;
4918 	int *pack_fds = NULL;
4919 
4920 	while ((ch = getopt(argc, argv, "aC:r:w")) != -1) {
4921 		switch (ch) {
4922 		case 'a':
4923 			force_text_diff = 1;
4924 			break;
4925 		case 'C':
4926 			diff_context = strtonum(optarg, 0, GOT_DIFF_MAX_CONTEXT,
4927 			    &errstr);
4928 			if (errstr != NULL)
4929 				errx(1, "number of context lines is %s: %s",
4930 				    errstr, errstr);
4931 			break;
4932 		case 'r':
4933 			repo_path = realpath(optarg, NULL);
4934 			if (repo_path == NULL)
4935 				return got_error_from_errno2("realpath",
4936 				    optarg);
4937 			got_path_strip_trailing_slashes(repo_path);
4938 			break;
4939 		case 'w':
4940 			ignore_whitespace = 1;
4941 			break;
4942 		default:
4943 			usage_diff();
4944 			/* NOTREACHED */
4945 		}
4946 	}
4947 
4948 	argc -= optind;
4949 	argv += optind;
4950 
4951 	if (argc == 0) {
4952 		usage_diff(); /* TODO show local worktree changes */
4953 	} else if (argc == 2) {
4954 		id_str1 = argv[0];
4955 		id_str2 = argv[1];
4956 	} else
4957 		usage_diff();
4958 
4959 	error = got_repo_pack_fds_open(&pack_fds);
4960 	if (error)
4961 		goto done;
4962 
4963 	if (repo_path == NULL) {
4964 		cwd = getcwd(NULL, 0);
4965 		if (cwd == NULL)
4966 			return got_error_from_errno("getcwd");
4967 		error = got_worktree_open(&worktree, cwd);
4968 		if (error && error->code != GOT_ERR_NOT_WORKTREE)
4969 			goto done;
4970 		if (worktree)
4971 			repo_path =
4972 			    strdup(got_worktree_get_repo_path(worktree));
4973 		else
4974 			repo_path = strdup(cwd);
4975 		if (repo_path == NULL) {
4976 			error = got_error_from_errno("strdup");
4977 			goto done;
4978 		}
4979 	}
4980 
4981 	error = got_repo_open(&repo, repo_path, NULL, pack_fds);
4982 	if (error)
4983 		goto done;
4984 
4985 	init_curses();
4986 
4987 	error = apply_unveil(got_repo_get_path(repo), NULL);
4988 	if (error)
4989 		goto done;
4990 
4991 	error = tog_load_refs(repo, 0);
4992 	if (error)
4993 		goto done;
4994 
4995 	error = got_repo_match_object_id(&id1, &label1, id_str1,
4996 	    GOT_OBJ_TYPE_ANY, &tog_refs, repo);
4997 	if (error)
4998 		goto done;
4999 
5000 	error = got_repo_match_object_id(&id2, &label2, id_str2,
5001 	    GOT_OBJ_TYPE_ANY, &tog_refs, repo);
5002 	if (error)
5003 		goto done;
5004 
5005 	view = view_open(0, 0, 0, 0, TOG_VIEW_DIFF);
5006 	if (view == NULL) {
5007 		error = got_error_from_errno("view_open");
5008 		goto done;
5009 	}
5010 	error = open_diff_view(view, id1, id2, label1, label2, diff_context,
5011 	    ignore_whitespace, force_text_diff, NULL,  repo);
5012 	if (error)
5013 		goto done;
5014 	error = view_loop(view);
5015 done:
5016 	free(label1);
5017 	free(label2);
5018 	free(repo_path);
5019 	free(cwd);
5020 	if (repo) {
5021 		const struct got_error *close_err = got_repo_close(repo);
5022 		if (error == NULL)
5023 			error = close_err;
5024 	}
5025 	if (worktree)
5026 		got_worktree_close(worktree);
5027 	if (pack_fds) {
5028 		const struct got_error *pack_err =
5029 		    got_repo_pack_fds_close(pack_fds);
5030 		if (error == NULL)
5031 			error = pack_err;
5032 	}
5033 	tog_free_refs();
5034 	return error;
5035 }
5036 
5037 __dead static void
5038 usage_blame(void)
5039 {
5040 	endwin();
5041 	fprintf(stderr,
5042 	    "usage: %s blame [-c commit] [-r repository-path] path\n",
5043 	    getprogname());
5044 	exit(1);
5045 }
5046 
5047 struct tog_blame_line {
5048 	int annotated;
5049 	struct got_object_id *id;
5050 };
5051 
5052 static const struct got_error *
5053 draw_blame(struct tog_view *view)
5054 {
5055 	struct tog_blame_view_state *s = &view->state.blame;
5056 	struct tog_blame *blame = &s->blame;
5057 	regmatch_t *regmatch = &view->regmatch;
5058 	const struct got_error *err;
5059 	int lineno = 0, nprinted = 0;
5060 	char *line = NULL;
5061 	size_t linesize = 0;
5062 	ssize_t linelen;
5063 	wchar_t *wline;
5064 	int width;
5065 	struct tog_blame_line *blame_line;
5066 	struct got_object_id *prev_id = NULL;
5067 	char *id_str;
5068 	struct tog_color *tc;
5069 
5070 	err = got_object_id_str(&id_str, &s->blamed_commit->id);
5071 	if (err)
5072 		return err;
5073 
5074 	rewind(blame->f);
5075 	werase(view->window);
5076 
5077 	if (asprintf(&line, "commit %s", id_str) == -1) {
5078 		err = got_error_from_errno("asprintf");
5079 		free(id_str);
5080 		return err;
5081 	}
5082 
5083 	err = format_line(&wline, &width, NULL, line, 0, view->ncols, 0, 0);
5084 	free(line);
5085 	line = NULL;
5086 	if (err)
5087 		return err;
5088 	if (view_needs_focus_indication(view))
5089 		wstandout(view->window);
5090 	tc = get_color(&s->colors, TOG_COLOR_COMMIT);
5091 	if (tc)
5092 		wattr_on(view->window,
5093 		    COLOR_PAIR(tc->colorpair), NULL);
5094 	waddwstr(view->window, wline);
5095 	if (tc)
5096 		wattr_off(view->window,
5097 		    COLOR_PAIR(tc->colorpair), NULL);
5098 	if (view_needs_focus_indication(view))
5099 		wstandend(view->window);
5100 	free(wline);
5101 	wline = NULL;
5102 	if (width < view->ncols - 1)
5103 		waddch(view->window, '\n');
5104 
5105 	if (asprintf(&line, "[%d/%d] %s%s",
5106 	    s->first_displayed_line - 1 + s->selected_line, blame->nlines,
5107 	    s->blame_complete ? "" : "annotating... ", s->path) == -1) {
5108 		free(id_str);
5109 		return got_error_from_errno("asprintf");
5110 	}
5111 	free(id_str);
5112 	err = format_line(&wline, &width, NULL, line, 0, view->ncols, 0, 0);
5113 	free(line);
5114 	line = NULL;
5115 	if (err)
5116 		return err;
5117 	waddwstr(view->window, wline);
5118 	free(wline);
5119 	wline = NULL;
5120 	if (width < view->ncols - 1)
5121 		waddch(view->window, '\n');
5122 
5123 	s->eof = 0;
5124 	view->maxx = 0;
5125 	while (nprinted < view->nlines - 2) {
5126 		linelen = getline(&line, &linesize, blame->f);
5127 		if (linelen == -1) {
5128 			if (feof(blame->f)) {
5129 				s->eof = 1;
5130 				break;
5131 			}
5132 			free(line);
5133 			return got_ferror(blame->f, GOT_ERR_IO);
5134 		}
5135 		if (++lineno < s->first_displayed_line)
5136 			continue;
5137 
5138 		/* Set view->maxx based on full line length. */
5139 		err = format_line(&wline, &width, NULL, line, 0, INT_MAX, 9, 1);
5140 		if (err) {
5141 			free(line);
5142 			return err;
5143 		}
5144 		free(wline);
5145 		wline = NULL;
5146 		view->maxx = MAX(view->maxx, width);
5147 
5148 		if (nprinted == s->selected_line - 1)
5149 			wstandout(view->window);
5150 
5151 		if (blame->nlines > 0) {
5152 			blame_line = &blame->lines[lineno - 1];
5153 			if (blame_line->annotated && prev_id &&
5154 			    got_object_id_cmp(prev_id, blame_line->id) == 0 &&
5155 			    !(nprinted == s->selected_line - 1)) {
5156 				waddstr(view->window, "        ");
5157 			} else if (blame_line->annotated) {
5158 				char *id_str;
5159 				err = got_object_id_str(&id_str,
5160 				    blame_line->id);
5161 				if (err) {
5162 					free(line);
5163 					return err;
5164 				}
5165 				tc = get_color(&s->colors, TOG_COLOR_COMMIT);
5166 				if (tc)
5167 					wattr_on(view->window,
5168 					    COLOR_PAIR(tc->colorpair), NULL);
5169 				wprintw(view->window, "%.8s", id_str);
5170 				if (tc)
5171 					wattr_off(view->window,
5172 					    COLOR_PAIR(tc->colorpair), NULL);
5173 				free(id_str);
5174 				prev_id = blame_line->id;
5175 			} else {
5176 				waddstr(view->window, "........");
5177 				prev_id = NULL;
5178 			}
5179 		} else {
5180 			waddstr(view->window, "........");
5181 			prev_id = NULL;
5182 		}
5183 
5184 		if (nprinted == s->selected_line - 1)
5185 			wstandend(view->window);
5186 		waddstr(view->window, " ");
5187 
5188 		if (view->ncols <= 9) {
5189 			width = 9;
5190 		} else if (s->first_displayed_line + nprinted ==
5191 		    s->matched_line &&
5192 		    regmatch->rm_so >= 0 && regmatch->rm_so < regmatch->rm_eo) {
5193 			err = add_matched_line(&width, line, view->ncols - 9, 9,
5194 			    view->window, view->x, regmatch);
5195 			if (err) {
5196 				free(line);
5197 				return err;
5198 			}
5199 			width += 9;
5200 		} else {
5201 			int skip;
5202 			err = format_line(&wline, &width, &skip, line,
5203 			    view->x, view->ncols - 9, 9, 1);
5204 			if (err) {
5205 				free(line);
5206 				return err;
5207 			}
5208 			waddwstr(view->window, &wline[skip]);
5209 			width += 9;
5210 			free(wline);
5211 			wline = NULL;
5212 		}
5213 
5214 		if (width <= view->ncols - 1)
5215 			waddch(view->window, '\n');
5216 		if (++nprinted == 1)
5217 			s->first_displayed_line = lineno;
5218 	}
5219 	free(line);
5220 	s->last_displayed_line = lineno;
5221 
5222 	view_border(view);
5223 
5224 	return NULL;
5225 }
5226 
5227 static const struct got_error *
5228 blame_cb(void *arg, int nlines, int lineno,
5229     struct got_commit_object *commit, struct got_object_id *id)
5230 {
5231 	const struct got_error *err = NULL;
5232 	struct tog_blame_cb_args *a = arg;
5233 	struct tog_blame_line *line;
5234 	int errcode;
5235 
5236 	if (nlines != a->nlines ||
5237 	    (lineno != -1 && lineno < 1) || lineno > a->nlines)
5238 		return got_error(GOT_ERR_RANGE);
5239 
5240 	errcode = pthread_mutex_lock(&tog_mutex);
5241 	if (errcode)
5242 		return got_error_set_errno(errcode, "pthread_mutex_lock");
5243 
5244 	if (*a->quit) {	/* user has quit the blame view */
5245 		err = got_error(GOT_ERR_ITER_COMPLETED);
5246 		goto done;
5247 	}
5248 
5249 	if (lineno == -1)
5250 		goto done; /* no change in this commit */
5251 
5252 	line = &a->lines[lineno - 1];
5253 	if (line->annotated)
5254 		goto done;
5255 
5256 	line->id = got_object_id_dup(id);
5257 	if (line->id == NULL) {
5258 		err = got_error_from_errno("got_object_id_dup");
5259 		goto done;
5260 	}
5261 	line->annotated = 1;
5262 done:
5263 	errcode = pthread_mutex_unlock(&tog_mutex);
5264 	if (errcode)
5265 		err = got_error_set_errno(errcode, "pthread_mutex_unlock");
5266 	return err;
5267 }
5268 
5269 static void *
5270 blame_thread(void *arg)
5271 {
5272 	const struct got_error *err, *close_err;
5273 	struct tog_blame_thread_args *ta = arg;
5274 	struct tog_blame_cb_args *a = ta->cb_args;
5275 	int errcode, fd1 = -1, fd2 = -1;
5276 	FILE *f1 = NULL, *f2 = NULL;
5277 
5278 	fd1 = got_opentempfd();
5279 	if (fd1 == -1)
5280 		return (void *)got_error_from_errno("got_opentempfd");
5281 
5282 	fd2 = got_opentempfd();
5283 	if (fd2 == -1) {
5284 		err = got_error_from_errno("got_opentempfd");
5285 		goto done;
5286 	}
5287 
5288 	f1 = got_opentemp();
5289 	if (f1 == NULL) {
5290 		err = (void *)got_error_from_errno("got_opentemp");
5291 		goto done;
5292 	}
5293 	f2 = got_opentemp();
5294 	if (f2 == NULL) {
5295 		err = (void *)got_error_from_errno("got_opentemp");
5296 		goto done;
5297 	}
5298 
5299 	err = block_signals_used_by_main_thread();
5300 	if (err)
5301 		goto done;
5302 
5303 	err = got_blame(ta->path, a->commit_id, ta->repo,
5304 	    tog_diff_algo, blame_cb, ta->cb_args,
5305 	    ta->cancel_cb, ta->cancel_arg, fd1, fd2, f1, f2);
5306 	if (err && err->code == GOT_ERR_CANCELLED)
5307 		err = NULL;
5308 
5309 	errcode = pthread_mutex_lock(&tog_mutex);
5310 	if (errcode) {
5311 		err = got_error_set_errno(errcode, "pthread_mutex_lock");
5312 		goto done;
5313 	}
5314 
5315 	close_err = got_repo_close(ta->repo);
5316 	if (err == NULL)
5317 		err = close_err;
5318 	ta->repo = NULL;
5319 	*ta->complete = 1;
5320 
5321 	errcode = pthread_mutex_unlock(&tog_mutex);
5322 	if (errcode && err == NULL)
5323 		err = got_error_set_errno(errcode, "pthread_mutex_unlock");
5324 
5325 done:
5326 	if (fd1 != -1 && close(fd1) == -1 && err == NULL)
5327 		err = got_error_from_errno("close");
5328 	if (fd2 != -1 && close(fd2) == -1 && err == NULL)
5329 		err = got_error_from_errno("close");
5330 	if (f1 && fclose(f1) == EOF && err == NULL)
5331 		err = got_error_from_errno("fclose");
5332 	if (f2 && fclose(f2) == EOF && err == NULL)
5333 		err = got_error_from_errno("fclose");
5334 
5335 	return (void *)err;
5336 }
5337 
5338 static struct got_object_id *
5339 get_selected_commit_id(struct tog_blame_line *lines, int nlines,
5340     int first_displayed_line, int selected_line)
5341 {
5342 	struct tog_blame_line *line;
5343 
5344 	if (nlines <= 0)
5345 		return NULL;
5346 
5347 	line = &lines[first_displayed_line - 1 + selected_line - 1];
5348 	if (!line->annotated)
5349 		return NULL;
5350 
5351 	return line->id;
5352 }
5353 
5354 static struct got_object_id *
5355 get_annotation_for_line(struct tog_blame_line *lines, int nlines,
5356     int lineno)
5357 {
5358 	struct tog_blame_line *line;
5359 
5360 	if (nlines <= 0 || lineno >= nlines)
5361 		return NULL;
5362 
5363 	line = &lines[lineno - 1];
5364 	if (!line->annotated)
5365 		return NULL;
5366 
5367 	return line->id;
5368 }
5369 
5370 static const struct got_error *
5371 stop_blame(struct tog_blame *blame)
5372 {
5373 	const struct got_error *err = NULL;
5374 	int i;
5375 
5376 	if (blame->thread) {
5377 		int errcode;
5378 		errcode = pthread_mutex_unlock(&tog_mutex);
5379 		if (errcode)
5380 			return got_error_set_errno(errcode,
5381 			    "pthread_mutex_unlock");
5382 		errcode = pthread_join(blame->thread, (void **)&err);
5383 		if (errcode)
5384 			return got_error_set_errno(errcode, "pthread_join");
5385 		errcode = pthread_mutex_lock(&tog_mutex);
5386 		if (errcode)
5387 			return got_error_set_errno(errcode,
5388 			    "pthread_mutex_lock");
5389 		if (err && err->code == GOT_ERR_ITER_COMPLETED)
5390 			err = NULL;
5391 		blame->thread = NULL;
5392 	}
5393 	if (blame->thread_args.repo) {
5394 		const struct got_error *close_err;
5395 		close_err = got_repo_close(blame->thread_args.repo);
5396 		if (err == NULL)
5397 			err = close_err;
5398 		blame->thread_args.repo = NULL;
5399 	}
5400 	if (blame->f) {
5401 		if (fclose(blame->f) == EOF && err == NULL)
5402 			err = got_error_from_errno("fclose");
5403 		blame->f = NULL;
5404 	}
5405 	if (blame->lines) {
5406 		for (i = 0; i < blame->nlines; i++)
5407 			free(blame->lines[i].id);
5408 		free(blame->lines);
5409 		blame->lines = NULL;
5410 	}
5411 	free(blame->cb_args.commit_id);
5412 	blame->cb_args.commit_id = NULL;
5413 	if (blame->pack_fds) {
5414 		const struct got_error *pack_err =
5415 		    got_repo_pack_fds_close(blame->pack_fds);
5416 		if (err == NULL)
5417 			err = pack_err;
5418 		blame->pack_fds = NULL;
5419 	}
5420 	return err;
5421 }
5422 
5423 static const struct got_error *
5424 cancel_blame_view(void *arg)
5425 {
5426 	const struct got_error *err = NULL;
5427 	int *done = arg;
5428 	int errcode;
5429 
5430 	errcode = pthread_mutex_lock(&tog_mutex);
5431 	if (errcode)
5432 		return got_error_set_errno(errcode,
5433 		    "pthread_mutex_unlock");
5434 
5435 	if (*done)
5436 		err = got_error(GOT_ERR_CANCELLED);
5437 
5438 	errcode = pthread_mutex_unlock(&tog_mutex);
5439 	if (errcode)
5440 		return got_error_set_errno(errcode,
5441 		    "pthread_mutex_lock");
5442 
5443 	return err;
5444 }
5445 
5446 static const struct got_error *
5447 run_blame(struct tog_view *view)
5448 {
5449 	struct tog_blame_view_state *s = &view->state.blame;
5450 	struct tog_blame *blame = &s->blame;
5451 	const struct got_error *err = NULL;
5452 	struct got_commit_object *commit = NULL;
5453 	struct got_blob_object *blob = NULL;
5454 	struct got_repository *thread_repo = NULL;
5455 	struct got_object_id *obj_id = NULL;
5456 	int obj_type, fd = -1;
5457 	int *pack_fds = NULL;
5458 
5459 	err = got_object_open_as_commit(&commit, s->repo,
5460 	    &s->blamed_commit->id);
5461 	if (err)
5462 		return err;
5463 
5464 	fd = got_opentempfd();
5465 	if (fd == -1) {
5466 		err = got_error_from_errno("got_opentempfd");
5467 		goto done;
5468 	}
5469 
5470 	err = got_object_id_by_path(&obj_id, s->repo, commit, s->path);
5471 	if (err)
5472 		goto done;
5473 
5474 	err = got_object_get_type(&obj_type, s->repo, obj_id);
5475 	if (err)
5476 		goto done;
5477 
5478 	if (obj_type != GOT_OBJ_TYPE_BLOB) {
5479 		err = got_error(GOT_ERR_OBJ_TYPE);
5480 		goto done;
5481 	}
5482 
5483 	err = got_object_open_as_blob(&blob, s->repo, obj_id, 8192, fd);
5484 	if (err)
5485 		goto done;
5486 	blame->f = got_opentemp();
5487 	if (blame->f == NULL) {
5488 		err = got_error_from_errno("got_opentemp");
5489 		goto done;
5490 	}
5491 	err = got_object_blob_dump_to_file(&blame->filesize, &blame->nlines,
5492 	    &blame->line_offsets, blame->f, blob);
5493 	if (err)
5494 		goto done;
5495 	if (blame->nlines == 0) {
5496 		s->blame_complete = 1;
5497 		goto done;
5498 	}
5499 
5500 	/* Don't include \n at EOF in the blame line count. */
5501 	if (blame->line_offsets[blame->nlines - 1] == blame->filesize)
5502 		blame->nlines--;
5503 
5504 	blame->lines = calloc(blame->nlines, sizeof(*blame->lines));
5505 	if (blame->lines == NULL) {
5506 		err = got_error_from_errno("calloc");
5507 		goto done;
5508 	}
5509 
5510 	err = got_repo_pack_fds_open(&pack_fds);
5511 	if (err)
5512 		goto done;
5513 	err = got_repo_open(&thread_repo, got_repo_get_path(s->repo), NULL,
5514 	    pack_fds);
5515 	if (err)
5516 		goto done;
5517 
5518 	blame->pack_fds = pack_fds;
5519 	blame->cb_args.view = view;
5520 	blame->cb_args.lines = blame->lines;
5521 	blame->cb_args.nlines = blame->nlines;
5522 	blame->cb_args.commit_id = got_object_id_dup(&s->blamed_commit->id);
5523 	if (blame->cb_args.commit_id == NULL) {
5524 		err = got_error_from_errno("got_object_id_dup");
5525 		goto done;
5526 	}
5527 	blame->cb_args.quit = &s->done;
5528 
5529 	blame->thread_args.path = s->path;
5530 	blame->thread_args.repo = thread_repo;
5531 	blame->thread_args.cb_args = &blame->cb_args;
5532 	blame->thread_args.complete = &s->blame_complete;
5533 	blame->thread_args.cancel_cb = cancel_blame_view;
5534 	blame->thread_args.cancel_arg = &s->done;
5535 	s->blame_complete = 0;
5536 
5537 	if (s->first_displayed_line + view->nlines - 1 > blame->nlines) {
5538 		s->first_displayed_line = 1;
5539 		s->last_displayed_line = view->nlines;
5540 		s->selected_line = 1;
5541 	}
5542 	s->matched_line = 0;
5543 
5544 done:
5545 	if (commit)
5546 		got_object_commit_close(commit);
5547 	if (fd != -1 && close(fd) == -1 && err == NULL)
5548 		err = got_error_from_errno("close");
5549 	if (blob)
5550 		got_object_blob_close(blob);
5551 	free(obj_id);
5552 	if (err)
5553 		stop_blame(blame);
5554 	return err;
5555 }
5556 
5557 static const struct got_error *
5558 open_blame_view(struct tog_view *view, char *path,
5559     struct got_object_id *commit_id, struct got_repository *repo)
5560 {
5561 	const struct got_error *err = NULL;
5562 	struct tog_blame_view_state *s = &view->state.blame;
5563 
5564 	STAILQ_INIT(&s->blamed_commits);
5565 
5566 	s->path = strdup(path);
5567 	if (s->path == NULL)
5568 		return got_error_from_errno("strdup");
5569 
5570 	err = got_object_qid_alloc(&s->blamed_commit, commit_id);
5571 	if (err) {
5572 		free(s->path);
5573 		return err;
5574 	}
5575 
5576 	STAILQ_INSERT_HEAD(&s->blamed_commits, s->blamed_commit, entry);
5577 	s->first_displayed_line = 1;
5578 	s->last_displayed_line = view->nlines;
5579 	s->selected_line = 1;
5580 	s->blame_complete = 0;
5581 	s->repo = repo;
5582 	s->commit_id = commit_id;
5583 	memset(&s->blame, 0, sizeof(s->blame));
5584 
5585 	STAILQ_INIT(&s->colors);
5586 	if (has_colors() && getenv("TOG_COLORS") != NULL) {
5587 		err = add_color(&s->colors, "^", TOG_COLOR_COMMIT,
5588 		    get_color_value("TOG_COLOR_COMMIT"));
5589 		if (err)
5590 			return err;
5591 	}
5592 
5593 	view->show = show_blame_view;
5594 	view->input = input_blame_view;
5595 	view->reset = reset_blame_view;
5596 	view->close = close_blame_view;
5597 	view->search_start = search_start_blame_view;
5598 	view->search_next = search_next_blame_view;
5599 
5600 	return run_blame(view);
5601 }
5602 
5603 static const struct got_error *
5604 close_blame_view(struct tog_view *view)
5605 {
5606 	const struct got_error *err = NULL;
5607 	struct tog_blame_view_state *s = &view->state.blame;
5608 
5609 	if (s->blame.thread)
5610 		err = stop_blame(&s->blame);
5611 
5612 	while (!STAILQ_EMPTY(&s->blamed_commits)) {
5613 		struct got_object_qid *blamed_commit;
5614 		blamed_commit = STAILQ_FIRST(&s->blamed_commits);
5615 		STAILQ_REMOVE_HEAD(&s->blamed_commits, entry);
5616 		got_object_qid_free(blamed_commit);
5617 	}
5618 
5619 	free(s->path);
5620 	free_colors(&s->colors);
5621 	return err;
5622 }
5623 
5624 static const struct got_error *
5625 search_start_blame_view(struct tog_view *view)
5626 {
5627 	struct tog_blame_view_state *s = &view->state.blame;
5628 
5629 	s->matched_line = 0;
5630 	return NULL;
5631 }
5632 
5633 static const struct got_error *
5634 search_next_blame_view(struct tog_view *view)
5635 {
5636 	struct tog_blame_view_state *s = &view->state.blame;
5637 	const struct got_error *err = NULL;
5638 	int lineno;
5639 	char *line = NULL;
5640 	size_t linesize = 0;
5641 	ssize_t linelen;
5642 
5643 	if (!view->searching) {
5644 		view->search_next_done = TOG_SEARCH_HAVE_MORE;
5645 		return NULL;
5646 	}
5647 
5648 	if (s->matched_line) {
5649 		if (view->searching == TOG_SEARCH_FORWARD)
5650 			lineno = s->matched_line + 1;
5651 		else
5652 			lineno = s->matched_line - 1;
5653 	} else
5654 		lineno = s->first_displayed_line - 1 + s->selected_line;
5655 
5656 	while (1) {
5657 		off_t offset;
5658 
5659 		if (lineno <= 0 || lineno > s->blame.nlines) {
5660 			if (s->matched_line == 0) {
5661 				view->search_next_done = TOG_SEARCH_HAVE_MORE;
5662 				break;
5663 			}
5664 
5665 			if (view->searching == TOG_SEARCH_FORWARD)
5666 				lineno = 1;
5667 			else
5668 				lineno = s->blame.nlines;
5669 		}
5670 
5671 		offset = s->blame.line_offsets[lineno - 1];
5672 		if (fseeko(s->blame.f, offset, SEEK_SET) != 0) {
5673 			free(line);
5674 			return got_error_from_errno("fseeko");
5675 		}
5676 		linelen = getline(&line, &linesize, s->blame.f);
5677 		if (linelen != -1) {
5678 			char *exstr;
5679 			err = expand_tab(&exstr, line);
5680 			if (err)
5681 				break;
5682 			if (match_line(exstr, &view->regex, 1,
5683 			    &view->regmatch)) {
5684 				view->search_next_done = TOG_SEARCH_HAVE_MORE;
5685 				s->matched_line = lineno;
5686 				free(exstr);
5687 				break;
5688 			}
5689 			free(exstr);
5690 		}
5691 		if (view->searching == TOG_SEARCH_FORWARD)
5692 			lineno++;
5693 		else
5694 			lineno--;
5695 	}
5696 	free(line);
5697 
5698 	if (s->matched_line) {
5699 		s->first_displayed_line = s->matched_line;
5700 		s->selected_line = 1;
5701 	}
5702 
5703 	return err;
5704 }
5705 
5706 static const struct got_error *
5707 show_blame_view(struct tog_view *view)
5708 {
5709 	const struct got_error *err = NULL;
5710 	struct tog_blame_view_state *s = &view->state.blame;
5711 	int errcode;
5712 
5713 	if (s->blame.thread == NULL && !s->blame_complete) {
5714 		errcode = pthread_create(&s->blame.thread, NULL, blame_thread,
5715 		    &s->blame.thread_args);
5716 		if (errcode)
5717 			return got_error_set_errno(errcode, "pthread_create");
5718 
5719 		halfdelay(1); /* fast refresh while annotating  */
5720 	}
5721 
5722 	if (s->blame_complete)
5723 		halfdelay(10); /* disable fast refresh */
5724 
5725 	err = draw_blame(view);
5726 
5727 	view_border(view);
5728 	return err;
5729 }
5730 
5731 static const struct got_error *
5732 log_annotated_line(struct tog_view **new_view, int begin_y, int begin_x,
5733     struct got_repository *repo, struct got_object_id *id)
5734 {
5735 	struct tog_view		*log_view;
5736 	const struct got_error	*err = NULL;
5737 
5738 	*new_view = NULL;
5739 
5740 	log_view = view_open(0, 0, begin_y, begin_x, TOG_VIEW_LOG);
5741 	if (log_view == NULL)
5742 		return got_error_from_errno("view_open");
5743 
5744 	err = open_log_view(log_view, id, repo, GOT_REF_HEAD, "", 0);
5745 	if (err)
5746 		view_close(log_view);
5747 	else
5748 		*new_view = log_view;
5749 
5750 	return err;
5751 }
5752 
5753 static const struct got_error *
5754 input_blame_view(struct tog_view **new_view, struct tog_view *view, int ch)
5755 {
5756 	const struct got_error *err = NULL, *thread_err = NULL;
5757 	struct tog_view *diff_view, *log_view;
5758 	struct tog_blame_view_state *s = &view->state.blame;
5759 	int eos, nscroll, begin_y = 0, begin_x = 0;
5760 
5761 	eos = nscroll = view->nlines - 2;
5762 	if (view_is_hsplit_top(view))
5763 		--eos;  /* border */
5764 
5765 	switch (ch) {
5766 	case '0':
5767 		view->x = 0;
5768 		break;
5769 	case '$':
5770 		view->x = MAX(view->maxx - view->ncols / 3, 0);
5771 		view->count = 0;
5772 		break;
5773 	case KEY_RIGHT:
5774 	case 'l':
5775 		if (view->x + view->ncols / 3 < view->maxx)
5776 			view->x += 2;  /* move two columns right */
5777 		else
5778 			view->count = 0;
5779 		break;
5780 	case KEY_LEFT:
5781 	case 'h':
5782 		view->x -= MIN(view->x, 2);  /* move two columns back */
5783 		if (view->x <= 0)
5784 			view->count = 0;
5785 		break;
5786 	case 'q':
5787 		s->done = 1;
5788 		break;
5789 	case 'g':
5790 	case KEY_HOME:
5791 		s->selected_line = 1;
5792 		s->first_displayed_line = 1;
5793 		view->count = 0;
5794 		break;
5795 	case 'G':
5796 	case KEY_END:
5797 		if (s->blame.nlines < eos) {
5798 			s->selected_line = s->blame.nlines;
5799 			s->first_displayed_line = 1;
5800 		} else {
5801 			s->selected_line = eos;
5802 			s->first_displayed_line = s->blame.nlines - (eos - 1);
5803 		}
5804 		view->count = 0;
5805 		break;
5806 	case 'k':
5807 	case KEY_UP:
5808 	case CTRL('p'):
5809 		if (s->selected_line > 1)
5810 			s->selected_line--;
5811 		else if (s->selected_line == 1 &&
5812 		    s->first_displayed_line > 1)
5813 			s->first_displayed_line--;
5814 		else
5815 			view->count = 0;
5816 		break;
5817 	case CTRL('u'):
5818 	case 'u':
5819 		nscroll /= 2;
5820 		/* FALL THROUGH */
5821 	case KEY_PPAGE:
5822 	case CTRL('b'):
5823 	case 'b':
5824 		if (s->first_displayed_line == 1) {
5825 			if (view->count > 1)
5826 				nscroll += nscroll;
5827 			s->selected_line = MAX(1, s->selected_line - nscroll);
5828 			view->count = 0;
5829 			break;
5830 		}
5831 		if (s->first_displayed_line > nscroll)
5832 			s->first_displayed_line -= nscroll;
5833 		else
5834 			s->first_displayed_line = 1;
5835 		break;
5836 	case 'j':
5837 	case KEY_DOWN:
5838 	case CTRL('n'):
5839 		if (s->selected_line < eos && s->first_displayed_line +
5840 		    s->selected_line <= s->blame.nlines)
5841 			s->selected_line++;
5842 		else if (s->first_displayed_line < s->blame.nlines - (eos - 1))
5843 			s->first_displayed_line++;
5844 		else
5845 			view->count = 0;
5846 		break;
5847 	case 'c':
5848 	case 'p': {
5849 		struct got_object_id *id = NULL;
5850 
5851 		view->count = 0;
5852 		id = get_selected_commit_id(s->blame.lines, s->blame.nlines,
5853 		    s->first_displayed_line, s->selected_line);
5854 		if (id == NULL)
5855 			break;
5856 		if (ch == 'p') {
5857 			struct got_commit_object *commit, *pcommit;
5858 			struct got_object_qid *pid;
5859 			struct got_object_id *blob_id = NULL;
5860 			int obj_type;
5861 			err = got_object_open_as_commit(&commit,
5862 			    s->repo, id);
5863 			if (err)
5864 				break;
5865 			pid = STAILQ_FIRST(
5866 			    got_object_commit_get_parent_ids(commit));
5867 			if (pid == NULL) {
5868 				got_object_commit_close(commit);
5869 				break;
5870 			}
5871 			/* Check if path history ends here. */
5872 			err = got_object_open_as_commit(&pcommit,
5873 			    s->repo, &pid->id);
5874 			if (err)
5875 				break;
5876 			err = got_object_id_by_path(&blob_id, s->repo,
5877 			    pcommit, s->path);
5878 			got_object_commit_close(pcommit);
5879 			if (err) {
5880 				if (err->code == GOT_ERR_NO_TREE_ENTRY)
5881 					err = NULL;
5882 				got_object_commit_close(commit);
5883 				break;
5884 			}
5885 			err = got_object_get_type(&obj_type, s->repo,
5886 			    blob_id);
5887 			free(blob_id);
5888 			/* Can't blame non-blob type objects. */
5889 			if (obj_type != GOT_OBJ_TYPE_BLOB) {
5890 				got_object_commit_close(commit);
5891 				break;
5892 			}
5893 			err = got_object_qid_alloc(&s->blamed_commit,
5894 			    &pid->id);
5895 			got_object_commit_close(commit);
5896 		} else {
5897 			if (got_object_id_cmp(id,
5898 			    &s->blamed_commit->id) == 0)
5899 				break;
5900 			err = got_object_qid_alloc(&s->blamed_commit,
5901 			    id);
5902 		}
5903 		if (err)
5904 			break;
5905 		s->done = 1;
5906 		thread_err = stop_blame(&s->blame);
5907 		s->done = 0;
5908 		if (thread_err)
5909 			break;
5910 		STAILQ_INSERT_HEAD(&s->blamed_commits,
5911 		    s->blamed_commit, entry);
5912 		err = run_blame(view);
5913 		if (err)
5914 			break;
5915 		break;
5916 	}
5917 	case 'C': {
5918 		struct got_object_qid *first;
5919 
5920 		view->count = 0;
5921 		first = STAILQ_FIRST(&s->blamed_commits);
5922 		if (!got_object_id_cmp(&first->id, s->commit_id))
5923 			break;
5924 		s->done = 1;
5925 		thread_err = stop_blame(&s->blame);
5926 		s->done = 0;
5927 		if (thread_err)
5928 			break;
5929 		STAILQ_REMOVE_HEAD(&s->blamed_commits, entry);
5930 		got_object_qid_free(s->blamed_commit);
5931 		s->blamed_commit =
5932 		    STAILQ_FIRST(&s->blamed_commits);
5933 		err = run_blame(view);
5934 		if (err)
5935 			break;
5936 		break;
5937 	}
5938 	case 'L': {
5939 		struct got_object_id *id = NULL;
5940 
5941 		view->count = 0;
5942 		id = get_selected_commit_id(s->blame.lines, s->blame.nlines,
5943 		    s->first_displayed_line, s->selected_line);
5944 		if (id == NULL)
5945 			break;
5946 
5947 		if (view_is_parent_view(view))
5948 			view_get_split(view, &begin_y, &begin_x);
5949 		err = log_annotated_line(&log_view, begin_y, begin_x,
5950 		    s->repo, id);
5951 		if (err)
5952 			break;
5953 		if (view_is_parent_view(view) &&
5954 		    view->mode == TOG_VIEW_SPLIT_HRZN) {
5955 			err = view_init_hsplit(view, begin_y);
5956 			if (err)
5957 				break;
5958 		}
5959 
5960 		view->focussed = 0;
5961 		log_view->focussed = 1;
5962 		log_view->mode = view->mode;
5963 		log_view->nlines = view->lines - begin_y;
5964 		if (view_is_parent_view(view)) {
5965 			view_transfer_size(log_view, view);
5966 			err = view_close_child(view);
5967 			if (err)
5968 				return err;
5969 			err = view_set_child(view, log_view);
5970 			if (err)
5971 				return err;
5972 			view->focus_child = 1;
5973 		} else
5974 			*new_view = log_view;
5975 		break;
5976 	}
5977 	case KEY_ENTER:
5978 	case '\r': {
5979 		struct got_object_id *id = NULL;
5980 		struct got_object_qid *pid;
5981 		struct got_commit_object *commit = NULL;
5982 
5983 		view->count = 0;
5984 		id = get_selected_commit_id(s->blame.lines, s->blame.nlines,
5985 		    s->first_displayed_line, s->selected_line);
5986 		if (id == NULL)
5987 			break;
5988 		err = got_object_open_as_commit(&commit, s->repo, id);
5989 		if (err)
5990 			break;
5991 		pid = STAILQ_FIRST(got_object_commit_get_parent_ids(commit));
5992 		if (*new_view) {
5993 			/* traversed from diff view, release diff resources  */
5994 			err = close_diff_view(*new_view);
5995 			if (err)
5996 				break;
5997 			diff_view = *new_view;
5998 		} else {
5999 			if (view_is_parent_view(view))
6000 				view_get_split(view, &begin_y, &begin_x);
6001 
6002 			diff_view = view_open(0, 0, begin_y, begin_x,
6003 			    TOG_VIEW_DIFF);
6004 			if (diff_view == NULL) {
6005 				got_object_commit_close(commit);
6006 				err = got_error_from_errno("view_open");
6007 				break;
6008 			}
6009 		}
6010 		err = open_diff_view(diff_view, pid ? &pid->id : NULL,
6011 		    id, NULL, NULL, 3, 0, 0, view, s->repo);
6012 		got_object_commit_close(commit);
6013 		if (err) {
6014 			view_close(diff_view);
6015 			break;
6016 		}
6017 		s->last_diffed_line = s->first_displayed_line - 1 +
6018 		    s->selected_line;
6019 		if (*new_view)
6020 			break;	/* still open from active diff view */
6021 		if (view_is_parent_view(view) &&
6022 		    view->mode == TOG_VIEW_SPLIT_HRZN) {
6023 			err = view_init_hsplit(view, begin_y);
6024 			if (err)
6025 				break;
6026 		}
6027 
6028 		view->focussed = 0;
6029 		diff_view->focussed = 1;
6030 		diff_view->mode = view->mode;
6031 		diff_view->nlines = view->lines - begin_y;
6032 		if (view_is_parent_view(view)) {
6033 			view_transfer_size(diff_view, view);
6034 			err = view_close_child(view);
6035 			if (err)
6036 				break;
6037 			err = view_set_child(view, diff_view);
6038 			if (err)
6039 				break;
6040 			view->focus_child = 1;
6041 		} else
6042 			*new_view = diff_view;
6043 		if (err)
6044 			break;
6045 		break;
6046 	}
6047 	case CTRL('d'):
6048 	case 'd':
6049 		nscroll /= 2;
6050 		/* FALL THROUGH */
6051 	case KEY_NPAGE:
6052 	case CTRL('f'):
6053 	case 'f':
6054 	case ' ':
6055 		if (s->last_displayed_line >= s->blame.nlines &&
6056 		    s->selected_line >= MIN(s->blame.nlines,
6057 		    view->nlines - 2)) {
6058 			view->count = 0;
6059 			break;
6060 		}
6061 		if (s->last_displayed_line >= s->blame.nlines &&
6062 		    s->selected_line < view->nlines - 2) {
6063 			s->selected_line +=
6064 			    MIN(nscroll, s->last_displayed_line -
6065 			    s->first_displayed_line - s->selected_line + 1);
6066 		}
6067 		if (s->last_displayed_line + nscroll <= s->blame.nlines)
6068 			s->first_displayed_line += nscroll;
6069 		else
6070 			s->first_displayed_line =
6071 			    s->blame.nlines - (view->nlines - 3);
6072 		break;
6073 	case KEY_RESIZE:
6074 		if (s->selected_line > view->nlines - 2) {
6075 			s->selected_line = MIN(s->blame.nlines,
6076 			    view->nlines - 2);
6077 		}
6078 		break;
6079 	default:
6080 		view->count = 0;
6081 		break;
6082 	}
6083 	return thread_err ? thread_err : err;
6084 }
6085 
6086 static const struct got_error *
6087 reset_blame_view(struct tog_view *view)
6088 {
6089 	const struct got_error *err;
6090 	struct tog_blame_view_state *s = &view->state.blame;
6091 
6092 	view->count = 0;
6093 	s->done = 1;
6094 	err = stop_blame(&s->blame);
6095 	s->done = 0;
6096 	if (err)
6097 		return err;
6098 	return run_blame(view);
6099 }
6100 
6101 static const struct got_error *
6102 cmd_blame(int argc, char *argv[])
6103 {
6104 	const struct got_error *error;
6105 	struct got_repository *repo = NULL;
6106 	struct got_worktree *worktree = NULL;
6107 	char *cwd = NULL, *repo_path = NULL, *in_repo_path = NULL;
6108 	char *link_target = NULL;
6109 	struct got_object_id *commit_id = NULL;
6110 	struct got_commit_object *commit = NULL;
6111 	char *commit_id_str = NULL;
6112 	int ch;
6113 	struct tog_view *view;
6114 	int *pack_fds = NULL;
6115 
6116 	while ((ch = getopt(argc, argv, "c:r:")) != -1) {
6117 		switch (ch) {
6118 		case 'c':
6119 			commit_id_str = optarg;
6120 			break;
6121 		case 'r':
6122 			repo_path = realpath(optarg, NULL);
6123 			if (repo_path == NULL)
6124 				return got_error_from_errno2("realpath",
6125 				    optarg);
6126 			break;
6127 		default:
6128 			usage_blame();
6129 			/* NOTREACHED */
6130 		}
6131 	}
6132 
6133 	argc -= optind;
6134 	argv += optind;
6135 
6136 	if (argc != 1)
6137 		usage_blame();
6138 
6139 	error = got_repo_pack_fds_open(&pack_fds);
6140 	if (error != NULL)
6141 		goto done;
6142 
6143 	if (repo_path == NULL) {
6144 		cwd = getcwd(NULL, 0);
6145 		if (cwd == NULL)
6146 			return got_error_from_errno("getcwd");
6147 		error = got_worktree_open(&worktree, cwd);
6148 		if (error && error->code != GOT_ERR_NOT_WORKTREE)
6149 			goto done;
6150 		if (worktree)
6151 			repo_path =
6152 			    strdup(got_worktree_get_repo_path(worktree));
6153 		else
6154 			repo_path = strdup(cwd);
6155 		if (repo_path == NULL) {
6156 			error = got_error_from_errno("strdup");
6157 			goto done;
6158 		}
6159 	}
6160 
6161 	error = got_repo_open(&repo, repo_path, NULL, pack_fds);
6162 	if (error != NULL)
6163 		goto done;
6164 
6165 	error = get_in_repo_path_from_argv0(&in_repo_path, argc, argv, repo,
6166 	    worktree);
6167 	if (error)
6168 		goto done;
6169 
6170 	init_curses();
6171 
6172 	error = apply_unveil(got_repo_get_path(repo), NULL);
6173 	if (error)
6174 		goto done;
6175 
6176 	error = tog_load_refs(repo, 0);
6177 	if (error)
6178 		goto done;
6179 
6180 	if (commit_id_str == NULL) {
6181 		struct got_reference *head_ref;
6182 		error = got_ref_open(&head_ref, repo, worktree ?
6183 		    got_worktree_get_head_ref_name(worktree) : GOT_REF_HEAD, 0);
6184 		if (error != NULL)
6185 			goto done;
6186 		error = got_ref_resolve(&commit_id, repo, head_ref);
6187 		got_ref_close(head_ref);
6188 	} else {
6189 		error = got_repo_match_object_id(&commit_id, NULL,
6190 		    commit_id_str, GOT_OBJ_TYPE_COMMIT, &tog_refs, repo);
6191 	}
6192 	if (error != NULL)
6193 		goto done;
6194 
6195 	view = view_open(0, 0, 0, 0, TOG_VIEW_BLAME);
6196 	if (view == NULL) {
6197 		error = got_error_from_errno("view_open");
6198 		goto done;
6199 	}
6200 
6201 	error = got_object_open_as_commit(&commit, repo, commit_id);
6202 	if (error)
6203 		goto done;
6204 
6205 	error = got_object_resolve_symlinks(&link_target, in_repo_path,
6206 	    commit, repo);
6207 	if (error)
6208 		goto done;
6209 
6210 	error = open_blame_view(view, link_target ? link_target : in_repo_path,
6211 	    commit_id, repo);
6212 	if (error)
6213 		goto done;
6214 	if (worktree) {
6215 		/* Release work tree lock. */
6216 		got_worktree_close(worktree);
6217 		worktree = NULL;
6218 	}
6219 	error = view_loop(view);
6220 done:
6221 	free(repo_path);
6222 	free(in_repo_path);
6223 	free(link_target);
6224 	free(cwd);
6225 	free(commit_id);
6226 	if (commit)
6227 		got_object_commit_close(commit);
6228 	if (worktree)
6229 		got_worktree_close(worktree);
6230 	if (repo) {
6231 		const struct got_error *close_err = got_repo_close(repo);
6232 		if (error == NULL)
6233 			error = close_err;
6234 	}
6235 	if (pack_fds) {
6236 		const struct got_error *pack_err =
6237 		    got_repo_pack_fds_close(pack_fds);
6238 		if (error == NULL)
6239 			error = pack_err;
6240 	}
6241 	tog_free_refs();
6242 	return error;
6243 }
6244 
6245 static const struct got_error *
6246 draw_tree_entries(struct tog_view *view, const char *parent_path)
6247 {
6248 	struct tog_tree_view_state *s = &view->state.tree;
6249 	const struct got_error *err = NULL;
6250 	struct got_tree_entry *te;
6251 	wchar_t *wline;
6252 	struct tog_color *tc;
6253 	int width, n, i, nentries;
6254 	int limit = view->nlines;
6255 
6256 	s->ndisplayed = 0;
6257 	if (view_is_hsplit_top(view))
6258 		--limit;  /* border */
6259 
6260 	werase(view->window);
6261 
6262 	if (limit == 0)
6263 		return NULL;
6264 
6265 	err = format_line(&wline, &width, NULL, s->tree_label, 0, view->ncols,
6266 	    0, 0);
6267 	if (err)
6268 		return err;
6269 	if (view_needs_focus_indication(view))
6270 		wstandout(view->window);
6271 	tc = get_color(&s->colors, TOG_COLOR_COMMIT);
6272 	if (tc)
6273 		wattr_on(view->window,
6274 		    COLOR_PAIR(tc->colorpair), NULL);
6275 	waddwstr(view->window, wline);
6276 	if (tc)
6277 		wattr_off(view->window,
6278 		    COLOR_PAIR(tc->colorpair), NULL);
6279 	if (view_needs_focus_indication(view))
6280 		wstandend(view->window);
6281 	free(wline);
6282 	wline = NULL;
6283 	if (width < view->ncols - 1)
6284 		waddch(view->window, '\n');
6285 	if (--limit <= 0)
6286 		return NULL;
6287 	err = format_line(&wline, &width, NULL, parent_path, 0, view->ncols,
6288 	    0, 0);
6289 	if (err)
6290 		return err;
6291 	waddwstr(view->window, wline);
6292 	free(wline);
6293 	wline = NULL;
6294 	if (width < view->ncols - 1)
6295 		waddch(view->window, '\n');
6296 	if (--limit <= 0)
6297 		return NULL;
6298 	waddch(view->window, '\n');
6299 	if (--limit <= 0)
6300 		return NULL;
6301 
6302 	if (s->first_displayed_entry == NULL) {
6303 		te = got_object_tree_get_first_entry(s->tree);
6304 		if (s->selected == 0) {
6305 			if (view->focussed)
6306 				wstandout(view->window);
6307 			s->selected_entry = NULL;
6308 		}
6309 		waddstr(view->window, "  ..\n");	/* parent directory */
6310 		if (s->selected == 0 && view->focussed)
6311 			wstandend(view->window);
6312 		s->ndisplayed++;
6313 		if (--limit <= 0)
6314 			return NULL;
6315 		n = 1;
6316 	} else {
6317 		n = 0;
6318 		te = s->first_displayed_entry;
6319 	}
6320 
6321 	nentries = got_object_tree_get_nentries(s->tree);
6322 	for (i = got_tree_entry_get_index(te); i < nentries; i++) {
6323 		char *line = NULL, *id_str = NULL, *link_target = NULL;
6324 		const char *modestr = "";
6325 		mode_t mode;
6326 
6327 		te = got_object_tree_get_entry(s->tree, i);
6328 		mode = got_tree_entry_get_mode(te);
6329 
6330 		if (s->show_ids) {
6331 			err = got_object_id_str(&id_str,
6332 			    got_tree_entry_get_id(te));
6333 			if (err)
6334 				return got_error_from_errno(
6335 				    "got_object_id_str");
6336 		}
6337 		if (got_object_tree_entry_is_submodule(te))
6338 			modestr = "$";
6339 		else if (S_ISLNK(mode)) {
6340 			int i;
6341 
6342 			err = got_tree_entry_get_symlink_target(&link_target,
6343 			    te, s->repo);
6344 			if (err) {
6345 				free(id_str);
6346 				return err;
6347 			}
6348 			for (i = 0; i < strlen(link_target); i++) {
6349 				if (!isprint((unsigned char)link_target[i]))
6350 					link_target[i] = '?';
6351 			}
6352 			modestr = "@";
6353 		}
6354 		else if (S_ISDIR(mode))
6355 			modestr = "/";
6356 		else if (mode & S_IXUSR)
6357 			modestr = "*";
6358 		if (asprintf(&line, "%s  %s%s%s%s", id_str ? id_str : "",
6359 		    got_tree_entry_get_name(te), modestr,
6360 		    link_target ? " -> ": "",
6361 		    link_target ? link_target : "") == -1) {
6362 			free(id_str);
6363 			free(link_target);
6364 			return got_error_from_errno("asprintf");
6365 		}
6366 		free(id_str);
6367 		free(link_target);
6368 		err = format_line(&wline, &width, NULL, line, 0, view->ncols,
6369 		    0, 0);
6370 		if (err) {
6371 			free(line);
6372 			break;
6373 		}
6374 		if (n == s->selected) {
6375 			if (view->focussed)
6376 				wstandout(view->window);
6377 			s->selected_entry = te;
6378 		}
6379 		tc = match_color(&s->colors, line);
6380 		if (tc)
6381 			wattr_on(view->window,
6382 			    COLOR_PAIR(tc->colorpair), NULL);
6383 		waddwstr(view->window, wline);
6384 		if (tc)
6385 			wattr_off(view->window,
6386 			    COLOR_PAIR(tc->colorpair), NULL);
6387 		if (width < view->ncols - 1)
6388 			waddch(view->window, '\n');
6389 		if (n == s->selected && view->focussed)
6390 			wstandend(view->window);
6391 		free(line);
6392 		free(wline);
6393 		wline = NULL;
6394 		n++;
6395 		s->ndisplayed++;
6396 		s->last_displayed_entry = te;
6397 		if (--limit <= 0)
6398 			break;
6399 	}
6400 
6401 	return err;
6402 }
6403 
6404 static void
6405 tree_scroll_up(struct tog_tree_view_state *s, int maxscroll)
6406 {
6407 	struct got_tree_entry *te;
6408 	int isroot = s->tree == s->root;
6409 	int i = 0;
6410 
6411 	if (s->first_displayed_entry == NULL)
6412 		return;
6413 
6414 	te = got_tree_entry_get_prev(s->tree, s->first_displayed_entry);
6415 	while (i++ < maxscroll) {
6416 		if (te == NULL) {
6417 			if (!isroot)
6418 				s->first_displayed_entry = NULL;
6419 			break;
6420 		}
6421 		s->first_displayed_entry = te;
6422 		te = got_tree_entry_get_prev(s->tree, te);
6423 	}
6424 }
6425 
6426 static const struct got_error *
6427 tree_scroll_down(struct tog_view *view, int maxscroll)
6428 {
6429 	struct tog_tree_view_state *s = &view->state.tree;
6430 	struct got_tree_entry *next, *last;
6431 	int n = 0;
6432 
6433 	if (s->first_displayed_entry)
6434 		next = got_tree_entry_get_next(s->tree,
6435 		    s->first_displayed_entry);
6436 	else
6437 		next = got_object_tree_get_first_entry(s->tree);
6438 
6439 	last = s->last_displayed_entry;
6440 	while (next && n++ < maxscroll) {
6441 		if (last)
6442 			last = got_tree_entry_get_next(s->tree, last);
6443 		if (last || (view->mode == TOG_VIEW_SPLIT_HRZN && next)) {
6444 			s->first_displayed_entry = next;
6445 			next = got_tree_entry_get_next(s->tree, next);
6446 		}
6447 	}
6448 
6449 	return NULL;
6450 }
6451 
6452 static const struct got_error *
6453 tree_entry_path(char **path, struct tog_parent_trees *parents,
6454     struct got_tree_entry *te)
6455 {
6456 	const struct got_error *err = NULL;
6457 	struct tog_parent_tree *pt;
6458 	size_t len = 2; /* for leading slash and NUL */
6459 
6460 	TAILQ_FOREACH(pt, parents, entry)
6461 		len += strlen(got_tree_entry_get_name(pt->selected_entry))
6462 		    + 1 /* slash */;
6463 	if (te)
6464 		len += strlen(got_tree_entry_get_name(te));
6465 
6466 	*path = calloc(1, len);
6467 	if (path == NULL)
6468 		return got_error_from_errno("calloc");
6469 
6470 	(*path)[0] = '/';
6471 	pt = TAILQ_LAST(parents, tog_parent_trees);
6472 	while (pt) {
6473 		const char *name = got_tree_entry_get_name(pt->selected_entry);
6474 		if (strlcat(*path, name, len) >= len) {
6475 			err = got_error(GOT_ERR_NO_SPACE);
6476 			goto done;
6477 		}
6478 		if (strlcat(*path, "/", len) >= len) {
6479 			err = got_error(GOT_ERR_NO_SPACE);
6480 			goto done;
6481 		}
6482 		pt = TAILQ_PREV(pt, tog_parent_trees, entry);
6483 	}
6484 	if (te) {
6485 		if (strlcat(*path, got_tree_entry_get_name(te), len) >= len) {
6486 			err = got_error(GOT_ERR_NO_SPACE);
6487 			goto done;
6488 		}
6489 	}
6490 done:
6491 	if (err) {
6492 		free(*path);
6493 		*path = NULL;
6494 	}
6495 	return err;
6496 }
6497 
6498 static const struct got_error *
6499 blame_tree_entry(struct tog_view **new_view, int begin_y, int begin_x,
6500     struct got_tree_entry *te, struct tog_parent_trees *parents,
6501     struct got_object_id *commit_id, struct got_repository *repo)
6502 {
6503 	const struct got_error *err = NULL;
6504 	char *path;
6505 	struct tog_view *blame_view;
6506 
6507 	*new_view = NULL;
6508 
6509 	err = tree_entry_path(&path, parents, te);
6510 	if (err)
6511 		return err;
6512 
6513 	blame_view = view_open(0, 0, begin_y, begin_x, TOG_VIEW_BLAME);
6514 	if (blame_view == NULL) {
6515 		err = got_error_from_errno("view_open");
6516 		goto done;
6517 	}
6518 
6519 	err = open_blame_view(blame_view, path, commit_id, repo);
6520 	if (err) {
6521 		if (err->code == GOT_ERR_CANCELLED)
6522 			err = NULL;
6523 		view_close(blame_view);
6524 	} else
6525 		*new_view = blame_view;
6526 done:
6527 	free(path);
6528 	return err;
6529 }
6530 
6531 static const struct got_error *
6532 log_selected_tree_entry(struct tog_view **new_view, int begin_y, int begin_x,
6533     struct tog_tree_view_state *s)
6534 {
6535 	struct tog_view *log_view;
6536 	const struct got_error *err = NULL;
6537 	char *path;
6538 
6539 	*new_view = NULL;
6540 
6541 	log_view = view_open(0, 0, begin_y, begin_x, TOG_VIEW_LOG);
6542 	if (log_view == NULL)
6543 		return got_error_from_errno("view_open");
6544 
6545 	err = tree_entry_path(&path, &s->parents, s->selected_entry);
6546 	if (err)
6547 		return err;
6548 
6549 	err = open_log_view(log_view, s->commit_id, s->repo, s->head_ref_name,
6550 	    path, 0);
6551 	if (err)
6552 		view_close(log_view);
6553 	else
6554 		*new_view = log_view;
6555 	free(path);
6556 	return err;
6557 }
6558 
6559 static const struct got_error *
6560 open_tree_view(struct tog_view *view, struct got_object_id *commit_id,
6561     const char *head_ref_name, struct got_repository *repo)
6562 {
6563 	const struct got_error *err = NULL;
6564 	char *commit_id_str = NULL;
6565 	struct tog_tree_view_state *s = &view->state.tree;
6566 	struct got_commit_object *commit = NULL;
6567 
6568 	TAILQ_INIT(&s->parents);
6569 	STAILQ_INIT(&s->colors);
6570 
6571 	s->commit_id = got_object_id_dup(commit_id);
6572 	if (s->commit_id == NULL)
6573 		return got_error_from_errno("got_object_id_dup");
6574 
6575 	err = got_object_open_as_commit(&commit, repo, commit_id);
6576 	if (err)
6577 		goto done;
6578 
6579 	/*
6580 	 * The root is opened here and will be closed when the view is closed.
6581 	 * Any visited subtrees and their path-wise parents are opened and
6582 	 * closed on demand.
6583 	 */
6584 	err = got_object_open_as_tree(&s->root, repo,
6585 	    got_object_commit_get_tree_id(commit));
6586 	if (err)
6587 		goto done;
6588 	s->tree = s->root;
6589 
6590 	err = got_object_id_str(&commit_id_str, commit_id);
6591 	if (err != NULL)
6592 		goto done;
6593 
6594 	if (asprintf(&s->tree_label, "commit %s", commit_id_str) == -1) {
6595 		err = got_error_from_errno("asprintf");
6596 		goto done;
6597 	}
6598 
6599 	s->first_displayed_entry = got_object_tree_get_entry(s->tree, 0);
6600 	s->selected_entry = got_object_tree_get_entry(s->tree, 0);
6601 	if (head_ref_name) {
6602 		s->head_ref_name = strdup(head_ref_name);
6603 		if (s->head_ref_name == NULL) {
6604 			err = got_error_from_errno("strdup");
6605 			goto done;
6606 		}
6607 	}
6608 	s->repo = repo;
6609 
6610 	if (has_colors() && getenv("TOG_COLORS") != NULL) {
6611 		err = add_color(&s->colors, "\\$$",
6612 		    TOG_COLOR_TREE_SUBMODULE,
6613 		    get_color_value("TOG_COLOR_TREE_SUBMODULE"));
6614 		if (err)
6615 			goto done;
6616 		err = add_color(&s->colors, "@$", TOG_COLOR_TREE_SYMLINK,
6617 		    get_color_value("TOG_COLOR_TREE_SYMLINK"));
6618 		if (err)
6619 			goto done;
6620 		err = add_color(&s->colors, "/$",
6621 		    TOG_COLOR_TREE_DIRECTORY,
6622 		    get_color_value("TOG_COLOR_TREE_DIRECTORY"));
6623 		if (err)
6624 			goto done;
6625 
6626 		err = add_color(&s->colors, "\\*$",
6627 		    TOG_COLOR_TREE_EXECUTABLE,
6628 		    get_color_value("TOG_COLOR_TREE_EXECUTABLE"));
6629 		if (err)
6630 			goto done;
6631 
6632 		err = add_color(&s->colors, "^$", TOG_COLOR_COMMIT,
6633 		    get_color_value("TOG_COLOR_COMMIT"));
6634 		if (err)
6635 			goto done;
6636 	}
6637 
6638 	view->show = show_tree_view;
6639 	view->input = input_tree_view;
6640 	view->close = close_tree_view;
6641 	view->search_start = search_start_tree_view;
6642 	view->search_next = search_next_tree_view;
6643 done:
6644 	free(commit_id_str);
6645 	if (commit)
6646 		got_object_commit_close(commit);
6647 	if (err)
6648 		close_tree_view(view);
6649 	return err;
6650 }
6651 
6652 static const struct got_error *
6653 close_tree_view(struct tog_view *view)
6654 {
6655 	struct tog_tree_view_state *s = &view->state.tree;
6656 
6657 	free_colors(&s->colors);
6658 	free(s->tree_label);
6659 	s->tree_label = NULL;
6660 	free(s->commit_id);
6661 	s->commit_id = NULL;
6662 	free(s->head_ref_name);
6663 	s->head_ref_name = NULL;
6664 	while (!TAILQ_EMPTY(&s->parents)) {
6665 		struct tog_parent_tree *parent;
6666 		parent = TAILQ_FIRST(&s->parents);
6667 		TAILQ_REMOVE(&s->parents, parent, entry);
6668 		if (parent->tree != s->root)
6669 			got_object_tree_close(parent->tree);
6670 		free(parent);
6671 
6672 	}
6673 	if (s->tree != NULL && s->tree != s->root)
6674 		got_object_tree_close(s->tree);
6675 	if (s->root)
6676 		got_object_tree_close(s->root);
6677 	return NULL;
6678 }
6679 
6680 static const struct got_error *
6681 search_start_tree_view(struct tog_view *view)
6682 {
6683 	struct tog_tree_view_state *s = &view->state.tree;
6684 
6685 	s->matched_entry = NULL;
6686 	return NULL;
6687 }
6688 
6689 static int
6690 match_tree_entry(struct got_tree_entry *te, regex_t *regex)
6691 {
6692 	regmatch_t regmatch;
6693 
6694 	return regexec(regex, got_tree_entry_get_name(te), 1, &regmatch,
6695 	    0) == 0;
6696 }
6697 
6698 static const struct got_error *
6699 search_next_tree_view(struct tog_view *view)
6700 {
6701 	struct tog_tree_view_state *s = &view->state.tree;
6702 	struct got_tree_entry *te = NULL;
6703 
6704 	if (!view->searching) {
6705 		view->search_next_done = TOG_SEARCH_HAVE_MORE;
6706 		return NULL;
6707 	}
6708 
6709 	if (s->matched_entry) {
6710 		if (view->searching == TOG_SEARCH_FORWARD) {
6711 			if (s->selected_entry)
6712 				te = got_tree_entry_get_next(s->tree,
6713 				    s->selected_entry);
6714 			else
6715 				te = got_object_tree_get_first_entry(s->tree);
6716 		} else {
6717 			if (s->selected_entry == NULL)
6718 				te = got_object_tree_get_last_entry(s->tree);
6719 			else
6720 				te = got_tree_entry_get_prev(s->tree,
6721 				    s->selected_entry);
6722 		}
6723 	} else {
6724 		if (s->selected_entry)
6725 			te = s->selected_entry;
6726 		else if (view->searching == TOG_SEARCH_FORWARD)
6727 			te = got_object_tree_get_first_entry(s->tree);
6728 		else
6729 			te = got_object_tree_get_last_entry(s->tree);
6730 	}
6731 
6732 	while (1) {
6733 		if (te == NULL) {
6734 			if (s->matched_entry == NULL) {
6735 				view->search_next_done = TOG_SEARCH_HAVE_MORE;
6736 				return NULL;
6737 			}
6738 			if (view->searching == TOG_SEARCH_FORWARD)
6739 				te = got_object_tree_get_first_entry(s->tree);
6740 			else
6741 				te = got_object_tree_get_last_entry(s->tree);
6742 		}
6743 
6744 		if (match_tree_entry(te, &view->regex)) {
6745 			view->search_next_done = TOG_SEARCH_HAVE_MORE;
6746 			s->matched_entry = te;
6747 			break;
6748 		}
6749 
6750 		if (view->searching == TOG_SEARCH_FORWARD)
6751 			te = got_tree_entry_get_next(s->tree, te);
6752 		else
6753 			te = got_tree_entry_get_prev(s->tree, te);
6754 	}
6755 
6756 	if (s->matched_entry) {
6757 		s->first_displayed_entry = s->matched_entry;
6758 		s->selected = 0;
6759 	}
6760 
6761 	return NULL;
6762 }
6763 
6764 static const struct got_error *
6765 show_tree_view(struct tog_view *view)
6766 {
6767 	const struct got_error *err = NULL;
6768 	struct tog_tree_view_state *s = &view->state.tree;
6769 	char *parent_path;
6770 
6771 	err = tree_entry_path(&parent_path, &s->parents, NULL);
6772 	if (err)
6773 		return err;
6774 
6775 	err = draw_tree_entries(view, parent_path);
6776 	free(parent_path);
6777 
6778 	view_border(view);
6779 	return err;
6780 }
6781 
6782 static const struct got_error *
6783 input_tree_view(struct tog_view **new_view, struct tog_view *view, int ch)
6784 {
6785 	const struct got_error *err = NULL;
6786 	struct tog_tree_view_state *s = &view->state.tree;
6787 	struct tog_view *log_view, *ref_view;
6788 	struct got_tree_entry *te;
6789 	int begin_y = 0, begin_x = 0, n, nscroll = view->nlines - 3;
6790 
6791 	switch (ch) {
6792 	case 'i':
6793 		s->show_ids = !s->show_ids;
6794 		view->count = 0;
6795 		break;
6796 	case 'l':
6797 		view->count = 0;
6798 		if (!s->selected_entry)
6799 			break;
6800 		if (view_is_parent_view(view))
6801 			view_get_split(view, &begin_y, &begin_x);
6802 		err = log_selected_tree_entry(&log_view, begin_y, begin_x, s);
6803 		if (view_is_parent_view(view) &&
6804 		    view->mode == TOG_VIEW_SPLIT_HRZN) {
6805 			err = view_init_hsplit(view, begin_y);
6806 			if (err)
6807 				break;
6808 		}
6809 		view->focussed = 0;
6810 		log_view->focussed = 1;
6811 		log_view->mode = view->mode;
6812 		log_view->nlines = view->lines - begin_y;
6813 		if (view_is_parent_view(view)) {
6814 			view_transfer_size(log_view, view);
6815 			err = view_close_child(view);
6816 			if (err)
6817 				return err;
6818 			err = view_set_child(view, log_view);
6819 			if (err)
6820 				return err;
6821 			view->focus_child = 1;
6822 		} else
6823 			*new_view = log_view;
6824 		break;
6825 	case 'r':
6826 		view->count = 0;
6827 		if (view_is_parent_view(view))
6828 			view_get_split(view, &begin_y, &begin_x);
6829 		ref_view = view_open(0, 0, begin_y, begin_x, TOG_VIEW_REF);
6830 		if (ref_view == NULL)
6831 			return got_error_from_errno("view_open");
6832 		err = open_ref_view(ref_view, s->repo);
6833 		if (err) {
6834 			view_close(ref_view);
6835 			return err;
6836 		}
6837 		if (view_is_parent_view(view) &&
6838 		    view->mode == TOG_VIEW_SPLIT_HRZN) {
6839 			err = view_init_hsplit(view, begin_y);
6840 			if (err)
6841 				break;
6842 		}
6843 		view->focussed = 0;
6844 		ref_view->focussed = 1;
6845 		ref_view->mode = view->mode;
6846 		ref_view->nlines = view->lines - begin_y;
6847 		if (view_is_parent_view(view)) {
6848 			view_transfer_size(ref_view, view);
6849 			err = view_close_child(view);
6850 			if (err)
6851 				return err;
6852 			err = view_set_child(view, ref_view);
6853 			if (err)
6854 				return err;
6855 			view->focus_child = 1;
6856 		} else
6857 			*new_view = ref_view;
6858 		break;
6859 	case 'g':
6860 	case KEY_HOME:
6861 		s->selected = 0;
6862 		view->count = 0;
6863 		if (s->tree == s->root)
6864 			s->first_displayed_entry =
6865 			    got_object_tree_get_first_entry(s->tree);
6866 		else
6867 			s->first_displayed_entry = NULL;
6868 		break;
6869 	case 'G':
6870 	case KEY_END: {
6871 		int eos = view->nlines - 3;
6872 
6873 		if (view->mode == TOG_VIEW_SPLIT_HRZN)
6874 			--eos;  /* border */
6875 		s->selected = 0;
6876 		view->count = 0;
6877 		te = got_object_tree_get_last_entry(s->tree);
6878 		for (n = 0; n < eos; n++) {
6879 			if (te == NULL) {
6880 				if (s->tree != s->root) {
6881 					s->first_displayed_entry = NULL;
6882 					n++;
6883 				}
6884 				break;
6885 			}
6886 			s->first_displayed_entry = te;
6887 			te = got_tree_entry_get_prev(s->tree, te);
6888 		}
6889 		if (n > 0)
6890 			s->selected = n - 1;
6891 		break;
6892 	}
6893 	case 'k':
6894 	case KEY_UP:
6895 	case CTRL('p'):
6896 		if (s->selected > 0) {
6897 			s->selected--;
6898 			break;
6899 		}
6900 		tree_scroll_up(s, 1);
6901 		if (s->selected_entry == NULL ||
6902 		    (s->tree == s->root && s->selected_entry ==
6903 		     got_object_tree_get_first_entry(s->tree)))
6904 			view->count = 0;
6905 		break;
6906 	case CTRL('u'):
6907 	case 'u':
6908 		nscroll /= 2;
6909 		/* FALL THROUGH */
6910 	case KEY_PPAGE:
6911 	case CTRL('b'):
6912 	case 'b':
6913 		if (s->tree == s->root) {
6914 			if (got_object_tree_get_first_entry(s->tree) ==
6915 			    s->first_displayed_entry)
6916 				s->selected -= MIN(s->selected, nscroll);
6917 		} else {
6918 			if (s->first_displayed_entry == NULL)
6919 				s->selected -= MIN(s->selected, nscroll);
6920 		}
6921 		tree_scroll_up(s, MAX(0, nscroll));
6922 		if (s->selected_entry == NULL ||
6923 		    (s->tree == s->root && s->selected_entry ==
6924 		     got_object_tree_get_first_entry(s->tree)))
6925 			view->count = 0;
6926 		break;
6927 	case 'j':
6928 	case KEY_DOWN:
6929 	case CTRL('n'):
6930 		if (s->selected < s->ndisplayed - 1) {
6931 			s->selected++;
6932 			break;
6933 		}
6934 		if (got_tree_entry_get_next(s->tree, s->last_displayed_entry)
6935 		    == NULL) {
6936 			/* can't scroll any further */
6937 			view->count = 0;
6938 			break;
6939 		}
6940 		tree_scroll_down(view, 1);
6941 		break;
6942 	case CTRL('d'):
6943 	case 'd':
6944 		nscroll /= 2;
6945 		/* FALL THROUGH */
6946 	case KEY_NPAGE:
6947 	case CTRL('f'):
6948 	case 'f':
6949 	case ' ':
6950 		if (got_tree_entry_get_next(s->tree, s->last_displayed_entry)
6951 		    == NULL) {
6952 			/* can't scroll any further; move cursor down */
6953 			if (s->selected < s->ndisplayed - 1)
6954 				s->selected += MIN(nscroll,
6955 				    s->ndisplayed - s->selected - 1);
6956 			else
6957 				view->count = 0;
6958 			break;
6959 		}
6960 		tree_scroll_down(view, nscroll);
6961 		break;
6962 	case KEY_ENTER:
6963 	case '\r':
6964 	case KEY_BACKSPACE:
6965 		if (s->selected_entry == NULL || ch == KEY_BACKSPACE) {
6966 			struct tog_parent_tree *parent;
6967 			/* user selected '..' */
6968 			if (s->tree == s->root) {
6969 				view->count = 0;
6970 				break;
6971 			}
6972 			parent = TAILQ_FIRST(&s->parents);
6973 			TAILQ_REMOVE(&s->parents, parent,
6974 			    entry);
6975 			got_object_tree_close(s->tree);
6976 			s->tree = parent->tree;
6977 			s->first_displayed_entry =
6978 			    parent->first_displayed_entry;
6979 			s->selected_entry =
6980 			    parent->selected_entry;
6981 			s->selected = parent->selected;
6982 			if (s->selected > view->nlines - 3) {
6983 				err = offset_selection_down(view);
6984 				if (err)
6985 					break;
6986 			}
6987 			free(parent);
6988 		} else if (S_ISDIR(got_tree_entry_get_mode(
6989 		    s->selected_entry))) {
6990 			struct got_tree_object *subtree;
6991 			view->count = 0;
6992 			err = got_object_open_as_tree(&subtree, s->repo,
6993 			    got_tree_entry_get_id(s->selected_entry));
6994 			if (err)
6995 				break;
6996 			err = tree_view_visit_subtree(s, subtree);
6997 			if (err) {
6998 				got_object_tree_close(subtree);
6999 				break;
7000 			}
7001 		} else if (S_ISREG(got_tree_entry_get_mode(
7002 		    s->selected_entry))) {
7003 			struct tog_view *blame_view;
7004 			int begin_x = 0, begin_y = 0;
7005 
7006 			if (view_is_parent_view(view))
7007 				view_get_split(view, &begin_y, &begin_x);
7008 
7009 			err = blame_tree_entry(&blame_view, begin_y, begin_x,
7010 			    s->selected_entry, &s->parents,
7011 			    s->commit_id, s->repo);
7012 			if (err)
7013 				break;
7014 
7015 			if (view_is_parent_view(view) &&
7016 			    view->mode == TOG_VIEW_SPLIT_HRZN) {
7017 				err = view_init_hsplit(view, begin_y);
7018 				if (err)
7019 					break;
7020 			}
7021 
7022 			view->count = 0;
7023 			view->focussed = 0;
7024 			blame_view->focussed = 1;
7025 			blame_view->mode = view->mode;
7026 			blame_view->nlines = view->lines - begin_y;
7027 			if (view_is_parent_view(view)) {
7028 				view_transfer_size(blame_view, view);
7029 				err = view_close_child(view);
7030 				if (err)
7031 					return err;
7032 				err = view_set_child(view, blame_view);
7033 				if (err)
7034 					return err;
7035 				view->focus_child = 1;
7036 			} else
7037 				*new_view = blame_view;
7038 		}
7039 		break;
7040 	case KEY_RESIZE:
7041 		if (view->nlines >= 4 && s->selected >= view->nlines - 3)
7042 			s->selected = view->nlines - 4;
7043 		view->count = 0;
7044 		break;
7045 	default:
7046 		view->count = 0;
7047 		break;
7048 	}
7049 
7050 	return err;
7051 }
7052 
7053 __dead static void
7054 usage_tree(void)
7055 {
7056 	endwin();
7057 	fprintf(stderr,
7058 	    "usage: %s tree [-c commit] [-r repository-path] [path]\n",
7059 	    getprogname());
7060 	exit(1);
7061 }
7062 
7063 static const struct got_error *
7064 cmd_tree(int argc, char *argv[])
7065 {
7066 	const struct got_error *error;
7067 	struct got_repository *repo = NULL;
7068 	struct got_worktree *worktree = NULL;
7069 	char *cwd = NULL, *repo_path = NULL, *in_repo_path = NULL;
7070 	struct got_object_id *commit_id = NULL;
7071 	struct got_commit_object *commit = NULL;
7072 	const char *commit_id_arg = NULL;
7073 	char *label = NULL;
7074 	struct got_reference *ref = NULL;
7075 	const char *head_ref_name = NULL;
7076 	int ch;
7077 	struct tog_view *view;
7078 	int *pack_fds = NULL;
7079 
7080 	while ((ch = getopt(argc, argv, "c:r:")) != -1) {
7081 		switch (ch) {
7082 		case 'c':
7083 			commit_id_arg = optarg;
7084 			break;
7085 		case 'r':
7086 			repo_path = realpath(optarg, NULL);
7087 			if (repo_path == NULL)
7088 				return got_error_from_errno2("realpath",
7089 				    optarg);
7090 			break;
7091 		default:
7092 			usage_tree();
7093 			/* NOTREACHED */
7094 		}
7095 	}
7096 
7097 	argc -= optind;
7098 	argv += optind;
7099 
7100 	if (argc > 1)
7101 		usage_tree();
7102 
7103 	error = got_repo_pack_fds_open(&pack_fds);
7104 	if (error != NULL)
7105 		goto done;
7106 
7107 	if (repo_path == NULL) {
7108 		cwd = getcwd(NULL, 0);
7109 		if (cwd == NULL)
7110 			return got_error_from_errno("getcwd");
7111 		error = got_worktree_open(&worktree, cwd);
7112 		if (error && error->code != GOT_ERR_NOT_WORKTREE)
7113 			goto done;
7114 		if (worktree)
7115 			repo_path =
7116 			    strdup(got_worktree_get_repo_path(worktree));
7117 		else
7118 			repo_path = strdup(cwd);
7119 		if (repo_path == NULL) {
7120 			error = got_error_from_errno("strdup");
7121 			goto done;
7122 		}
7123 	}
7124 
7125 	error = got_repo_open(&repo, repo_path, NULL, pack_fds);
7126 	if (error != NULL)
7127 		goto done;
7128 
7129 	error = get_in_repo_path_from_argv0(&in_repo_path, argc, argv,
7130 	    repo, worktree);
7131 	if (error)
7132 		goto done;
7133 
7134 	init_curses();
7135 
7136 	error = apply_unveil(got_repo_get_path(repo), NULL);
7137 	if (error)
7138 		goto done;
7139 
7140 	error = tog_load_refs(repo, 0);
7141 	if (error)
7142 		goto done;
7143 
7144 	if (commit_id_arg == NULL) {
7145 		error = got_repo_match_object_id(&commit_id, &label,
7146 		    worktree ? got_worktree_get_head_ref_name(worktree) :
7147 		    GOT_REF_HEAD, GOT_OBJ_TYPE_COMMIT, &tog_refs, repo);
7148 		if (error)
7149 			goto done;
7150 		head_ref_name = label;
7151 	} else {
7152 		error = got_ref_open(&ref, repo, commit_id_arg, 0);
7153 		if (error == NULL)
7154 			head_ref_name = got_ref_get_name(ref);
7155 		else if (error->code != GOT_ERR_NOT_REF)
7156 			goto done;
7157 		error = got_repo_match_object_id(&commit_id, NULL,
7158 		    commit_id_arg, GOT_OBJ_TYPE_COMMIT, &tog_refs, repo);
7159 		if (error)
7160 			goto done;
7161 	}
7162 
7163 	error = got_object_open_as_commit(&commit, repo, commit_id);
7164 	if (error)
7165 		goto done;
7166 
7167 	view = view_open(0, 0, 0, 0, TOG_VIEW_TREE);
7168 	if (view == NULL) {
7169 		error = got_error_from_errno("view_open");
7170 		goto done;
7171 	}
7172 	error = open_tree_view(view, commit_id, head_ref_name, repo);
7173 	if (error)
7174 		goto done;
7175 	if (!got_path_is_root_dir(in_repo_path)) {
7176 		error = tree_view_walk_path(&view->state.tree, commit,
7177 		    in_repo_path);
7178 		if (error)
7179 			goto done;
7180 	}
7181 
7182 	if (worktree) {
7183 		/* Release work tree lock. */
7184 		got_worktree_close(worktree);
7185 		worktree = NULL;
7186 	}
7187 	error = view_loop(view);
7188 done:
7189 	free(repo_path);
7190 	free(cwd);
7191 	free(commit_id);
7192 	free(label);
7193 	if (ref)
7194 		got_ref_close(ref);
7195 	if (repo) {
7196 		const struct got_error *close_err = got_repo_close(repo);
7197 		if (error == NULL)
7198 			error = close_err;
7199 	}
7200 	if (pack_fds) {
7201 		const struct got_error *pack_err =
7202 		    got_repo_pack_fds_close(pack_fds);
7203 		if (error == NULL)
7204 			error = pack_err;
7205 	}
7206 	tog_free_refs();
7207 	return error;
7208 }
7209 
7210 static const struct got_error *
7211 ref_view_load_refs(struct tog_ref_view_state *s)
7212 {
7213 	struct got_reflist_entry *sre;
7214 	struct tog_reflist_entry *re;
7215 
7216 	s->nrefs = 0;
7217 	TAILQ_FOREACH(sre, &tog_refs, entry) {
7218 		if (strncmp(got_ref_get_name(sre->ref),
7219 		    "refs/got/", 9) == 0 &&
7220 		    strncmp(got_ref_get_name(sre->ref),
7221 		    "refs/got/backup/", 16) != 0)
7222 			continue;
7223 
7224 		re = malloc(sizeof(*re));
7225 		if (re == NULL)
7226 			return got_error_from_errno("malloc");
7227 
7228 		re->ref = got_ref_dup(sre->ref);
7229 		if (re->ref == NULL)
7230 			return got_error_from_errno("got_ref_dup");
7231 		re->idx = s->nrefs++;
7232 		TAILQ_INSERT_TAIL(&s->refs, re, entry);
7233 	}
7234 
7235 	s->first_displayed_entry = TAILQ_FIRST(&s->refs);
7236 	return NULL;
7237 }
7238 
7239 static void
7240 ref_view_free_refs(struct tog_ref_view_state *s)
7241 {
7242 	struct tog_reflist_entry *re;
7243 
7244 	while (!TAILQ_EMPTY(&s->refs)) {
7245 		re = TAILQ_FIRST(&s->refs);
7246 		TAILQ_REMOVE(&s->refs, re, entry);
7247 		got_ref_close(re->ref);
7248 		free(re);
7249 	}
7250 }
7251 
7252 static const struct got_error *
7253 open_ref_view(struct tog_view *view, struct got_repository *repo)
7254 {
7255 	const struct got_error *err = NULL;
7256 	struct tog_ref_view_state *s = &view->state.ref;
7257 
7258 	s->selected_entry = 0;
7259 	s->repo = repo;
7260 
7261 	TAILQ_INIT(&s->refs);
7262 	STAILQ_INIT(&s->colors);
7263 
7264 	err = ref_view_load_refs(s);
7265 	if (err)
7266 		return err;
7267 
7268 	if (has_colors() && getenv("TOG_COLORS") != NULL) {
7269 		err = add_color(&s->colors, "^refs/heads/",
7270 		    TOG_COLOR_REFS_HEADS,
7271 		    get_color_value("TOG_COLOR_REFS_HEADS"));
7272 		if (err)
7273 			goto done;
7274 
7275 		err = add_color(&s->colors, "^refs/tags/",
7276 		    TOG_COLOR_REFS_TAGS,
7277 		    get_color_value("TOG_COLOR_REFS_TAGS"));
7278 		if (err)
7279 			goto done;
7280 
7281 		err = add_color(&s->colors, "^refs/remotes/",
7282 		    TOG_COLOR_REFS_REMOTES,
7283 		    get_color_value("TOG_COLOR_REFS_REMOTES"));
7284 		if (err)
7285 			goto done;
7286 
7287 		err = add_color(&s->colors, "^refs/got/backup/",
7288 		    TOG_COLOR_REFS_BACKUP,
7289 		    get_color_value("TOG_COLOR_REFS_BACKUP"));
7290 		if (err)
7291 			goto done;
7292 	}
7293 
7294 	view->show = show_ref_view;
7295 	view->input = input_ref_view;
7296 	view->close = close_ref_view;
7297 	view->search_start = search_start_ref_view;
7298 	view->search_next = search_next_ref_view;
7299 done:
7300 	if (err)
7301 		free_colors(&s->colors);
7302 	return err;
7303 }
7304 
7305 static const struct got_error *
7306 close_ref_view(struct tog_view *view)
7307 {
7308 	struct tog_ref_view_state *s = &view->state.ref;
7309 
7310 	ref_view_free_refs(s);
7311 	free_colors(&s->colors);
7312 
7313 	return NULL;
7314 }
7315 
7316 static const struct got_error *
7317 resolve_reflist_entry(struct got_object_id **commit_id,
7318     struct tog_reflist_entry *re, struct got_repository *repo)
7319 {
7320 	const struct got_error *err = NULL;
7321 	struct got_object_id *obj_id;
7322 	struct got_tag_object *tag = NULL;
7323 	int obj_type;
7324 
7325 	*commit_id = NULL;
7326 
7327 	err = got_ref_resolve(&obj_id, repo, re->ref);
7328 	if (err)
7329 		return err;
7330 
7331 	err = got_object_get_type(&obj_type, repo, obj_id);
7332 	if (err)
7333 		goto done;
7334 
7335 	switch (obj_type) {
7336 	case GOT_OBJ_TYPE_COMMIT:
7337 		*commit_id = obj_id;
7338 		break;
7339 	case GOT_OBJ_TYPE_TAG:
7340 		err = got_object_open_as_tag(&tag, repo, obj_id);
7341 		if (err)
7342 			goto done;
7343 		free(obj_id);
7344 		err = got_object_get_type(&obj_type, repo,
7345 		    got_object_tag_get_object_id(tag));
7346 		if (err)
7347 			goto done;
7348 		if (obj_type != GOT_OBJ_TYPE_COMMIT) {
7349 			err = got_error(GOT_ERR_OBJ_TYPE);
7350 			goto done;
7351 		}
7352 		*commit_id = got_object_id_dup(
7353 		    got_object_tag_get_object_id(tag));
7354 		if (*commit_id == NULL) {
7355 			err = got_error_from_errno("got_object_id_dup");
7356 			goto done;
7357 		}
7358 		break;
7359 	default:
7360 		err = got_error(GOT_ERR_OBJ_TYPE);
7361 		break;
7362 	}
7363 
7364 done:
7365 	if (tag)
7366 		got_object_tag_close(tag);
7367 	if (err) {
7368 		free(*commit_id);
7369 		*commit_id = NULL;
7370 	}
7371 	return err;
7372 }
7373 
7374 static const struct got_error *
7375 log_ref_entry(struct tog_view **new_view, int begin_y, int begin_x,
7376     struct tog_reflist_entry *re, struct got_repository *repo)
7377 {
7378 	struct tog_view *log_view;
7379 	const struct got_error *err = NULL;
7380 	struct got_object_id *commit_id = NULL;
7381 
7382 	*new_view = NULL;
7383 
7384 	err = resolve_reflist_entry(&commit_id, re, repo);
7385 	if (err) {
7386 		if (err->code != GOT_ERR_OBJ_TYPE)
7387 			return err;
7388 		else
7389 			return NULL;
7390 	}
7391 
7392 	log_view = view_open(0, 0, begin_y, begin_x, TOG_VIEW_LOG);
7393 	if (log_view == NULL) {
7394 		err = got_error_from_errno("view_open");
7395 		goto done;
7396 	}
7397 
7398 	err = open_log_view(log_view, commit_id, repo,
7399 	    got_ref_get_name(re->ref), "", 0);
7400 done:
7401 	if (err)
7402 		view_close(log_view);
7403 	else
7404 		*new_view = log_view;
7405 	free(commit_id);
7406 	return err;
7407 }
7408 
7409 static void
7410 ref_scroll_up(struct tog_ref_view_state *s, int maxscroll)
7411 {
7412 	struct tog_reflist_entry *re;
7413 	int i = 0;
7414 
7415 	if (s->first_displayed_entry == TAILQ_FIRST(&s->refs))
7416 		return;
7417 
7418 	re = TAILQ_PREV(s->first_displayed_entry, tog_reflist_head, entry);
7419 	while (i++ < maxscroll) {
7420 		if (re == NULL)
7421 			break;
7422 		s->first_displayed_entry = re;
7423 		re = TAILQ_PREV(re, tog_reflist_head, entry);
7424 	}
7425 }
7426 
7427 static const struct got_error *
7428 ref_scroll_down(struct tog_view *view, int maxscroll)
7429 {
7430 	struct tog_ref_view_state *s = &view->state.ref;
7431 	struct tog_reflist_entry *next, *last;
7432 	int n = 0;
7433 
7434 	if (s->first_displayed_entry)
7435 		next = TAILQ_NEXT(s->first_displayed_entry, entry);
7436 	else
7437 		next = TAILQ_FIRST(&s->refs);
7438 
7439 	last = s->last_displayed_entry;
7440 	while (next && n++ < maxscroll) {
7441 		if (last)
7442 			last = TAILQ_NEXT(last, entry);
7443 		if (last || (view->mode == TOG_VIEW_SPLIT_HRZN)) {
7444 			s->first_displayed_entry = next;
7445 			next = TAILQ_NEXT(next, entry);
7446 		}
7447 	}
7448 
7449 	return NULL;
7450 }
7451 
7452 static const struct got_error *
7453 search_start_ref_view(struct tog_view *view)
7454 {
7455 	struct tog_ref_view_state *s = &view->state.ref;
7456 
7457 	s->matched_entry = NULL;
7458 	return NULL;
7459 }
7460 
7461 static int
7462 match_reflist_entry(struct tog_reflist_entry *re, regex_t *regex)
7463 {
7464 	regmatch_t regmatch;
7465 
7466 	return regexec(regex, got_ref_get_name(re->ref), 1, &regmatch,
7467 	    0) == 0;
7468 }
7469 
7470 static const struct got_error *
7471 search_next_ref_view(struct tog_view *view)
7472 {
7473 	struct tog_ref_view_state *s = &view->state.ref;
7474 	struct tog_reflist_entry *re = NULL;
7475 
7476 	if (!view->searching) {
7477 		view->search_next_done = TOG_SEARCH_HAVE_MORE;
7478 		return NULL;
7479 	}
7480 
7481 	if (s->matched_entry) {
7482 		if (view->searching == TOG_SEARCH_FORWARD) {
7483 			if (s->selected_entry)
7484 				re = TAILQ_NEXT(s->selected_entry, entry);
7485 			else
7486 				re = TAILQ_PREV(s->selected_entry,
7487 				    tog_reflist_head, entry);
7488 		} else {
7489 			if (s->selected_entry == NULL)
7490 				re = TAILQ_LAST(&s->refs, tog_reflist_head);
7491 			else
7492 				re = TAILQ_PREV(s->selected_entry,
7493 				    tog_reflist_head, entry);
7494 		}
7495 	} else {
7496 		if (s->selected_entry)
7497 			re = s->selected_entry;
7498 		else if (view->searching == TOG_SEARCH_FORWARD)
7499 			re = TAILQ_FIRST(&s->refs);
7500 		else
7501 			re = TAILQ_LAST(&s->refs, tog_reflist_head);
7502 	}
7503 
7504 	while (1) {
7505 		if (re == NULL) {
7506 			if (s->matched_entry == NULL) {
7507 				view->search_next_done = TOG_SEARCH_HAVE_MORE;
7508 				return NULL;
7509 			}
7510 			if (view->searching == TOG_SEARCH_FORWARD)
7511 				re = TAILQ_FIRST(&s->refs);
7512 			else
7513 				re = TAILQ_LAST(&s->refs, tog_reflist_head);
7514 		}
7515 
7516 		if (match_reflist_entry(re, &view->regex)) {
7517 			view->search_next_done = TOG_SEARCH_HAVE_MORE;
7518 			s->matched_entry = re;
7519 			break;
7520 		}
7521 
7522 		if (view->searching == TOG_SEARCH_FORWARD)
7523 			re = TAILQ_NEXT(re, entry);
7524 		else
7525 			re = TAILQ_PREV(re, tog_reflist_head, entry);
7526 	}
7527 
7528 	if (s->matched_entry) {
7529 		s->first_displayed_entry = s->matched_entry;
7530 		s->selected = 0;
7531 	}
7532 
7533 	return NULL;
7534 }
7535 
7536 static const struct got_error *
7537 show_ref_view(struct tog_view *view)
7538 {
7539 	const struct got_error *err = NULL;
7540 	struct tog_ref_view_state *s = &view->state.ref;
7541 	struct tog_reflist_entry *re;
7542 	char *line = NULL;
7543 	wchar_t *wline;
7544 	struct tog_color *tc;
7545 	int width, n;
7546 	int limit = view->nlines;
7547 
7548 	werase(view->window);
7549 
7550 	s->ndisplayed = 0;
7551 	if (view_is_hsplit_top(view))
7552 		--limit;  /* border */
7553 
7554 	if (limit == 0)
7555 		return NULL;
7556 
7557 	re = s->first_displayed_entry;
7558 
7559 	if (asprintf(&line, "references [%d/%d]", re->idx + s->selected + 1,
7560 	    s->nrefs) == -1)
7561 		return got_error_from_errno("asprintf");
7562 
7563 	err = format_line(&wline, &width, NULL, line, 0, view->ncols, 0, 0);
7564 	if (err) {
7565 		free(line);
7566 		return err;
7567 	}
7568 	if (view_needs_focus_indication(view))
7569 		wstandout(view->window);
7570 	waddwstr(view->window, wline);
7571 	if (view_needs_focus_indication(view))
7572 		wstandend(view->window);
7573 	free(wline);
7574 	wline = NULL;
7575 	free(line);
7576 	line = NULL;
7577 	if (width < view->ncols - 1)
7578 		waddch(view->window, '\n');
7579 	if (--limit <= 0)
7580 		return NULL;
7581 
7582 	n = 0;
7583 	while (re && limit > 0) {
7584 		char *line = NULL;
7585 		char ymd[13];  /* YYYY-MM-DD + "  " + NUL */
7586 
7587 		if (s->show_date) {
7588 			struct got_commit_object *ci;
7589 			struct got_tag_object *tag;
7590 			struct got_object_id *id;
7591 			struct tm tm;
7592 			time_t t;
7593 
7594 			err = got_ref_resolve(&id, s->repo, re->ref);
7595 			if (err)
7596 				return err;
7597 			err = got_object_open_as_tag(&tag, s->repo, id);
7598 			if (err) {
7599 				if (err->code != GOT_ERR_OBJ_TYPE) {
7600 					free(id);
7601 					return err;
7602 				}
7603 				err = got_object_open_as_commit(&ci, s->repo,
7604 				    id);
7605 				if (err) {
7606 					free(id);
7607 					return err;
7608 				}
7609 				t = got_object_commit_get_committer_time(ci);
7610 				got_object_commit_close(ci);
7611 			} else {
7612 				t = got_object_tag_get_tagger_time(tag);
7613 				got_object_tag_close(tag);
7614 			}
7615 			free(id);
7616 			if (gmtime_r(&t, &tm) == NULL)
7617 				return got_error_from_errno("gmtime_r");
7618 			if (strftime(ymd, sizeof(ymd), "%G-%m-%d  ", &tm) == 0)
7619 				return got_error(GOT_ERR_NO_SPACE);
7620 		}
7621 		if (got_ref_is_symbolic(re->ref)) {
7622 			if (asprintf(&line, "%s%s -> %s", s->show_date ?
7623 			    ymd : "", got_ref_get_name(re->ref),
7624 			    got_ref_get_symref_target(re->ref)) == -1)
7625 				return got_error_from_errno("asprintf");
7626 		} else if (s->show_ids) {
7627 			struct got_object_id *id;
7628 			char *id_str;
7629 			err = got_ref_resolve(&id, s->repo, re->ref);
7630 			if (err)
7631 				return err;
7632 			err = got_object_id_str(&id_str, id);
7633 			if (err) {
7634 				free(id);
7635 				return err;
7636 			}
7637 			if (asprintf(&line, "%s%s: %s", s->show_date ? ymd : "",
7638 			    got_ref_get_name(re->ref), id_str) == -1) {
7639 				err = got_error_from_errno("asprintf");
7640 				free(id);
7641 				free(id_str);
7642 				return err;
7643 			}
7644 			free(id);
7645 			free(id_str);
7646 		} else if (asprintf(&line, "%s%s", s->show_date ? ymd : "",
7647 		    got_ref_get_name(re->ref)) == -1)
7648 			return got_error_from_errno("asprintf");
7649 
7650 		err = format_line(&wline, &width, NULL, line, 0, view->ncols,
7651 		    0, 0);
7652 		if (err) {
7653 			free(line);
7654 			return err;
7655 		}
7656 		if (n == s->selected) {
7657 			if (view->focussed)
7658 				wstandout(view->window);
7659 			s->selected_entry = re;
7660 		}
7661 		tc = match_color(&s->colors, got_ref_get_name(re->ref));
7662 		if (tc)
7663 			wattr_on(view->window,
7664 			    COLOR_PAIR(tc->colorpair), NULL);
7665 		waddwstr(view->window, wline);
7666 		if (tc)
7667 			wattr_off(view->window,
7668 			    COLOR_PAIR(tc->colorpair), NULL);
7669 		if (width < view->ncols - 1)
7670 			waddch(view->window, '\n');
7671 		if (n == s->selected && view->focussed)
7672 			wstandend(view->window);
7673 		free(line);
7674 		free(wline);
7675 		wline = NULL;
7676 		n++;
7677 		s->ndisplayed++;
7678 		s->last_displayed_entry = re;
7679 
7680 		limit--;
7681 		re = TAILQ_NEXT(re, entry);
7682 	}
7683 
7684 	view_border(view);
7685 	return err;
7686 }
7687 
7688 static const struct got_error *
7689 browse_ref_tree(struct tog_view **new_view, int begin_y, int begin_x,
7690     struct tog_reflist_entry *re, struct got_repository *repo)
7691 {
7692 	const struct got_error *err = NULL;
7693 	struct got_object_id *commit_id = NULL;
7694 	struct tog_view *tree_view;
7695 
7696 	*new_view = NULL;
7697 
7698 	err = resolve_reflist_entry(&commit_id, re, repo);
7699 	if (err) {
7700 		if (err->code != GOT_ERR_OBJ_TYPE)
7701 			return err;
7702 		else
7703 			return NULL;
7704 	}
7705 
7706 
7707 	tree_view = view_open(0, 0, begin_y, begin_x, TOG_VIEW_TREE);
7708 	if (tree_view == NULL) {
7709 		err = got_error_from_errno("view_open");
7710 		goto done;
7711 	}
7712 
7713 	err = open_tree_view(tree_view, commit_id,
7714 	    got_ref_get_name(re->ref), repo);
7715 	if (err)
7716 		goto done;
7717 
7718 	*new_view = tree_view;
7719 done:
7720 	free(commit_id);
7721 	return err;
7722 }
7723 static const struct got_error *
7724 input_ref_view(struct tog_view **new_view, struct tog_view *view, int ch)
7725 {
7726 	const struct got_error *err = NULL;
7727 	struct tog_ref_view_state *s = &view->state.ref;
7728 	struct tog_view *log_view, *tree_view;
7729 	struct tog_reflist_entry *re;
7730 	int begin_y = 0, begin_x = 0, n, nscroll = view->nlines - 1;
7731 
7732 	switch (ch) {
7733 	case 'i':
7734 		s->show_ids = !s->show_ids;
7735 		view->count = 0;
7736 		break;
7737 	case 'm':
7738 		s->show_date = !s->show_date;
7739 		view->count = 0;
7740 		break;
7741 	case 'o':
7742 		s->sort_by_date = !s->sort_by_date;
7743 		view->count = 0;
7744 		err = got_reflist_sort(&tog_refs, s->sort_by_date ?
7745 		    got_ref_cmp_by_commit_timestamp_descending :
7746 		    tog_ref_cmp_by_name, s->repo);
7747 		if (err)
7748 			break;
7749 		got_reflist_object_id_map_free(tog_refs_idmap);
7750 		err = got_reflist_object_id_map_create(&tog_refs_idmap,
7751 		    &tog_refs, s->repo);
7752 		if (err)
7753 			break;
7754 		ref_view_free_refs(s);
7755 		err = ref_view_load_refs(s);
7756 		break;
7757 	case KEY_ENTER:
7758 	case '\r':
7759 		view->count = 0;
7760 		if (!s->selected_entry)
7761 			break;
7762 		if (view_is_parent_view(view))
7763 			view_get_split(view, &begin_y, &begin_x);
7764 
7765 		err = log_ref_entry(&log_view, begin_y, begin_x,
7766 		    s->selected_entry, s->repo);
7767 		if (err)
7768 			break;
7769 
7770 		if (view_is_parent_view(view) &&
7771 		    view->mode == TOG_VIEW_SPLIT_HRZN) {
7772 			err = view_init_hsplit(view, begin_y);
7773 			if (err)
7774 				break;
7775 		}
7776 
7777 		view->focussed = 0;
7778 		log_view->focussed = 1;
7779 		log_view->mode = view->mode;
7780 		log_view->nlines = view->lines - begin_y;
7781 		if (view_is_parent_view(view)) {
7782 			view_transfer_size(log_view, view);
7783 			err = view_close_child(view);
7784 			if (err)
7785 				return err;
7786 			err = view_set_child(view, log_view);
7787 			if (err)
7788 				return err;
7789 			view->focus_child = 1;
7790 		} else
7791 			*new_view = log_view;
7792 		break;
7793 	case 't':
7794 		view->count = 0;
7795 		if (!s->selected_entry)
7796 			break;
7797 		if (view_is_parent_view(view))
7798 			view_get_split(view, &begin_y, &begin_x);
7799 		err = browse_ref_tree(&tree_view, begin_y, begin_x,
7800 		    s->selected_entry, s->repo);
7801 		if (err || tree_view == NULL)
7802 			break;
7803 		if (view_is_parent_view(view) &&
7804 		    view->mode == TOG_VIEW_SPLIT_HRZN) {
7805 			err = view_init_hsplit(view, begin_y);
7806 			if (err)
7807 				break;
7808 		}
7809 		view->focussed = 0;
7810 		tree_view->focussed = 1;
7811 		tree_view->mode = view->mode;
7812 		tree_view->nlines = view->lines - begin_y;
7813 		if (view_is_parent_view(view)) {
7814 			view_transfer_size(tree_view, view);
7815 			err = view_close_child(view);
7816 			if (err)
7817 				return err;
7818 			err = view_set_child(view, tree_view);
7819 			if (err)
7820 				return err;
7821 			view->focus_child = 1;
7822 		} else
7823 			*new_view = tree_view;
7824 		break;
7825 	case 'g':
7826 	case KEY_HOME:
7827 		s->selected = 0;
7828 		view->count = 0;
7829 		s->first_displayed_entry = TAILQ_FIRST(&s->refs);
7830 		break;
7831 	case 'G':
7832 	case KEY_END: {
7833 		int eos = view->nlines - 1;
7834 
7835 		if (view->mode == TOG_VIEW_SPLIT_HRZN)
7836 			--eos;  /* border */
7837 		s->selected = 0;
7838 		view->count = 0;
7839 		re = TAILQ_LAST(&s->refs, tog_reflist_head);
7840 		for (n = 0; n < eos; n++) {
7841 			if (re == NULL)
7842 				break;
7843 			s->first_displayed_entry = re;
7844 			re = TAILQ_PREV(re, tog_reflist_head, entry);
7845 		}
7846 		if (n > 0)
7847 			s->selected = n - 1;
7848 		break;
7849 	}
7850 	case 'k':
7851 	case KEY_UP:
7852 	case CTRL('p'):
7853 		if (s->selected > 0) {
7854 			s->selected--;
7855 			break;
7856 		}
7857 		ref_scroll_up(s, 1);
7858 		if (s->selected_entry == TAILQ_FIRST(&s->refs))
7859 			view->count = 0;
7860 		break;
7861 	case CTRL('u'):
7862 	case 'u':
7863 		nscroll /= 2;
7864 		/* FALL THROUGH */
7865 	case KEY_PPAGE:
7866 	case CTRL('b'):
7867 	case 'b':
7868 		if (s->first_displayed_entry == TAILQ_FIRST(&s->refs))
7869 			s->selected -= MIN(nscroll, s->selected);
7870 		ref_scroll_up(s, MAX(0, nscroll));
7871 		if (s->selected_entry == TAILQ_FIRST(&s->refs))
7872 			view->count = 0;
7873 		break;
7874 	case 'j':
7875 	case KEY_DOWN:
7876 	case CTRL('n'):
7877 		if (s->selected < s->ndisplayed - 1) {
7878 			s->selected++;
7879 			break;
7880 		}
7881 		if (TAILQ_NEXT(s->last_displayed_entry, entry) == NULL) {
7882 			/* can't scroll any further */
7883 			view->count = 0;
7884 			break;
7885 		}
7886 		ref_scroll_down(view, 1);
7887 		break;
7888 	case CTRL('d'):
7889 	case 'd':
7890 		nscroll /= 2;
7891 		/* FALL THROUGH */
7892 	case KEY_NPAGE:
7893 	case CTRL('f'):
7894 	case 'f':
7895 	case ' ':
7896 		if (TAILQ_NEXT(s->last_displayed_entry, entry) == NULL) {
7897 			/* can't scroll any further; move cursor down */
7898 			if (s->selected < s->ndisplayed - 1)
7899 				s->selected += MIN(nscroll,
7900 				    s->ndisplayed - s->selected - 1);
7901 			if (view->count > 1 && s->selected < s->ndisplayed - 1)
7902 				s->selected += s->ndisplayed - s->selected - 1;
7903 			view->count = 0;
7904 			break;
7905 		}
7906 		ref_scroll_down(view, nscroll);
7907 		break;
7908 	case CTRL('l'):
7909 		view->count = 0;
7910 		tog_free_refs();
7911 		err = tog_load_refs(s->repo, s->sort_by_date);
7912 		if (err)
7913 			break;
7914 		ref_view_free_refs(s);
7915 		err = ref_view_load_refs(s);
7916 		break;
7917 	case KEY_RESIZE:
7918 		if (view->nlines >= 2 && s->selected >= view->nlines - 1)
7919 			s->selected = view->nlines - 2;
7920 		break;
7921 	default:
7922 		view->count = 0;
7923 		break;
7924 	}
7925 
7926 	return err;
7927 }
7928 
7929 __dead static void
7930 usage_ref(void)
7931 {
7932 	endwin();
7933 	fprintf(stderr, "usage: %s ref [-r repository-path]\n",
7934 	    getprogname());
7935 	exit(1);
7936 }
7937 
7938 static const struct got_error *
7939 cmd_ref(int argc, char *argv[])
7940 {
7941 	const struct got_error *error;
7942 	struct got_repository *repo = NULL;
7943 	struct got_worktree *worktree = NULL;
7944 	char *cwd = NULL, *repo_path = NULL;
7945 	int ch;
7946 	struct tog_view *view;
7947 	int *pack_fds = NULL;
7948 
7949 	while ((ch = getopt(argc, argv, "r:")) != -1) {
7950 		switch (ch) {
7951 		case 'r':
7952 			repo_path = realpath(optarg, NULL);
7953 			if (repo_path == NULL)
7954 				return got_error_from_errno2("realpath",
7955 				    optarg);
7956 			break;
7957 		default:
7958 			usage_ref();
7959 			/* NOTREACHED */
7960 		}
7961 	}
7962 
7963 	argc -= optind;
7964 	argv += optind;
7965 
7966 	if (argc > 1)
7967 		usage_ref();
7968 
7969 	error = got_repo_pack_fds_open(&pack_fds);
7970 	if (error != NULL)
7971 		goto done;
7972 
7973 	if (repo_path == NULL) {
7974 		cwd = getcwd(NULL, 0);
7975 		if (cwd == NULL)
7976 			return got_error_from_errno("getcwd");
7977 		error = got_worktree_open(&worktree, cwd);
7978 		if (error && error->code != GOT_ERR_NOT_WORKTREE)
7979 			goto done;
7980 		if (worktree)
7981 			repo_path =
7982 			    strdup(got_worktree_get_repo_path(worktree));
7983 		else
7984 			repo_path = strdup(cwd);
7985 		if (repo_path == NULL) {
7986 			error = got_error_from_errno("strdup");
7987 			goto done;
7988 		}
7989 	}
7990 
7991 	error = got_repo_open(&repo, repo_path, NULL, pack_fds);
7992 	if (error != NULL)
7993 		goto done;
7994 
7995 	init_curses();
7996 
7997 	error = apply_unveil(got_repo_get_path(repo), NULL);
7998 	if (error)
7999 		goto done;
8000 
8001 	error = tog_load_refs(repo, 0);
8002 	if (error)
8003 		goto done;
8004 
8005 	view = view_open(0, 0, 0, 0, TOG_VIEW_REF);
8006 	if (view == NULL) {
8007 		error = got_error_from_errno("view_open");
8008 		goto done;
8009 	}
8010 
8011 	error = open_ref_view(view, repo);
8012 	if (error)
8013 		goto done;
8014 
8015 	if (worktree) {
8016 		/* Release work tree lock. */
8017 		got_worktree_close(worktree);
8018 		worktree = NULL;
8019 	}
8020 	error = view_loop(view);
8021 done:
8022 	free(repo_path);
8023 	free(cwd);
8024 	if (repo) {
8025 		const struct got_error *close_err = got_repo_close(repo);
8026 		if (close_err)
8027 			error = close_err;
8028 	}
8029 	if (pack_fds) {
8030 		const struct got_error *pack_err =
8031 		    got_repo_pack_fds_close(pack_fds);
8032 		if (error == NULL)
8033 			error = pack_err;
8034 	}
8035 	tog_free_refs();
8036 	return error;
8037 }
8038 
8039 /*
8040  * If view was scrolled down to move the selected line into view when opening a
8041  * horizontal split, scroll back up when closing the split/toggling fullscreen.
8042  */
8043 static void
8044 offset_selection_up(struct tog_view *view)
8045 {
8046 	switch (view->type) {
8047 	case TOG_VIEW_BLAME: {
8048 		struct tog_blame_view_state *s = &view->state.blame;
8049 		if (s->first_displayed_line == 1) {
8050 			s->selected_line = MAX(s->selected_line - view->offset,
8051 			    1);
8052 			break;
8053 		}
8054 		if (s->first_displayed_line > view->offset)
8055 			s->first_displayed_line -= view->offset;
8056 		else
8057 			s->first_displayed_line = 1;
8058 		s->selected_line += view->offset;
8059 		break;
8060 	}
8061 	case TOG_VIEW_LOG:
8062 		log_scroll_up(&view->state.log, view->offset);
8063 		view->state.log.selected += view->offset;
8064 		break;
8065 	case TOG_VIEW_REF:
8066 		ref_scroll_up(&view->state.ref, view->offset);
8067 		view->state.ref.selected += view->offset;
8068 		break;
8069 	case TOG_VIEW_TREE:
8070 		tree_scroll_up(&view->state.tree, view->offset);
8071 		view->state.tree.selected += view->offset;
8072 		break;
8073 	default:
8074 		break;
8075 	}
8076 
8077 	view->offset = 0;
8078 }
8079 
8080 /*
8081  * If the selected line is in the section of screen covered by the bottom split,
8082  * scroll down offset lines to move it into view and index its new position.
8083  */
8084 static const struct got_error *
8085 offset_selection_down(struct tog_view *view)
8086 {
8087 	const struct got_error	*err = NULL;
8088 	const struct got_error	*(*scrolld)(struct tog_view *, int);
8089 	int			*selected = NULL;
8090 	int			 header, offset;
8091 
8092 	switch (view->type) {
8093 	case TOG_VIEW_BLAME: {
8094 		struct tog_blame_view_state *s = &view->state.blame;
8095 		header = 3;
8096 		scrolld = NULL;
8097 		if (s->selected_line > view->nlines - header) {
8098 			offset = abs(view->nlines - s->selected_line - header);
8099 			s->first_displayed_line += offset;
8100 			s->selected_line -= offset;
8101 			view->offset = offset;
8102 		}
8103 		break;
8104 	}
8105 	case TOG_VIEW_LOG: {
8106 		struct tog_log_view_state *s = &view->state.log;
8107 		scrolld = &log_scroll_down;
8108 		header = view_is_parent_view(view) ? 3 : 2;
8109 		selected = &s->selected;
8110 		break;
8111 	}
8112 	case TOG_VIEW_REF: {
8113 		struct tog_ref_view_state *s = &view->state.ref;
8114 		scrolld = &ref_scroll_down;
8115 		header = 3;
8116 		selected = &s->selected;
8117 		break;
8118 	}
8119 	case TOG_VIEW_TREE: {
8120 		struct tog_tree_view_state *s = &view->state.tree;
8121 		scrolld = &tree_scroll_down;
8122 		header = 5;
8123 		selected = &s->selected;
8124 		break;
8125 	}
8126 	default:
8127 		selected = NULL;
8128 		scrolld = NULL;
8129 		header = 0;
8130 		break;
8131 	}
8132 
8133 	if (selected && *selected > view->nlines - header) {
8134 		offset = abs(view->nlines - *selected - header);
8135 		view->offset = offset;
8136 		if (scrolld && offset) {
8137 			err = scrolld(view, offset);
8138 			*selected -= offset;
8139 		}
8140 	}
8141 
8142 	return err;
8143 }
8144 
8145 static void
8146 list_commands(FILE *fp)
8147 {
8148 	size_t i;
8149 
8150 	fprintf(fp, "commands:");
8151 	for (i = 0; i < nitems(tog_commands); i++) {
8152 		const struct tog_cmd *cmd = &tog_commands[i];
8153 		fprintf(fp, " %s", cmd->name);
8154 	}
8155 	fputc('\n', fp);
8156 }
8157 
8158 __dead static void
8159 usage(int hflag, int status)
8160 {
8161 	FILE *fp = (status == 0) ? stdout : stderr;
8162 
8163 	fprintf(fp, "usage: %s [-h] [-V | --version] [command] [arg ...]\n",
8164 	    getprogname());
8165 	if (hflag) {
8166 		fprintf(fp, "lazy usage: %s path\n", getprogname());
8167 		list_commands(fp);
8168 	}
8169 	exit(status);
8170 }
8171 
8172 static char **
8173 make_argv(int argc, ...)
8174 {
8175 	va_list ap;
8176 	char **argv;
8177 	int i;
8178 
8179 	va_start(ap, argc);
8180 
8181 	argv = calloc(argc, sizeof(char *));
8182 	if (argv == NULL)
8183 		err(1, "calloc");
8184 	for (i = 0; i < argc; i++) {
8185 		argv[i] = strdup(va_arg(ap, char *));
8186 		if (argv[i] == NULL)
8187 			err(1, "strdup");
8188 	}
8189 
8190 	va_end(ap);
8191 	return argv;
8192 }
8193 
8194 /*
8195  * Try to convert 'tog path' into a 'tog log path' command.
8196  * The user could simply have mistyped the command rather than knowingly
8197  * provided a path. So check whether argv[0] can in fact be resolved
8198  * to a path in the HEAD commit and print a special error if not.
8199  * This hack is for mpi@ <3
8200  */
8201 static const struct got_error *
8202 tog_log_with_path(int argc, char *argv[])
8203 {
8204 	const struct got_error *error = NULL, *close_err;
8205 	const struct tog_cmd *cmd = NULL;
8206 	struct got_repository *repo = NULL;
8207 	struct got_worktree *worktree = NULL;
8208 	struct got_object_id *commit_id = NULL, *id = NULL;
8209 	struct got_commit_object *commit = NULL;
8210 	char *cwd = NULL, *repo_path = NULL, *in_repo_path = NULL;
8211 	char *commit_id_str = NULL, **cmd_argv = NULL;
8212 	int *pack_fds = NULL;
8213 
8214 	cwd = getcwd(NULL, 0);
8215 	if (cwd == NULL)
8216 		return got_error_from_errno("getcwd");
8217 
8218 	error = got_repo_pack_fds_open(&pack_fds);
8219 	if (error != NULL)
8220 		goto done;
8221 
8222 	error = got_worktree_open(&worktree, cwd);
8223 	if (error && error->code != GOT_ERR_NOT_WORKTREE)
8224 		goto done;
8225 
8226 	if (worktree)
8227 		repo_path = strdup(got_worktree_get_repo_path(worktree));
8228 	else
8229 		repo_path = strdup(cwd);
8230 	if (repo_path == NULL) {
8231 		error = got_error_from_errno("strdup");
8232 		goto done;
8233 	}
8234 
8235 	error = got_repo_open(&repo, repo_path, NULL, pack_fds);
8236 	if (error != NULL)
8237 		goto done;
8238 
8239 	error = get_in_repo_path_from_argv0(&in_repo_path, argc, argv,
8240 	    repo, worktree);
8241 	if (error)
8242 		goto done;
8243 
8244 	error = tog_load_refs(repo, 0);
8245 	if (error)
8246 		goto done;
8247 	error = got_repo_match_object_id(&commit_id, NULL, worktree ?
8248 	    got_worktree_get_head_ref_name(worktree) : GOT_REF_HEAD,
8249 	    GOT_OBJ_TYPE_COMMIT, &tog_refs, repo);
8250 	if (error)
8251 		goto done;
8252 
8253 	if (worktree) {
8254 		got_worktree_close(worktree);
8255 		worktree = NULL;
8256 	}
8257 
8258 	error = got_object_open_as_commit(&commit, repo, commit_id);
8259 	if (error)
8260 		goto done;
8261 
8262 	error = got_object_id_by_path(&id, repo, commit, in_repo_path);
8263 	if (error) {
8264 		if (error->code != GOT_ERR_NO_TREE_ENTRY)
8265 			goto done;
8266 		fprintf(stderr, "%s: '%s' is no known command or path\n",
8267 		    getprogname(), argv[0]);
8268 		usage(1, 1);
8269 		/* not reached */
8270 	}
8271 
8272 	close_err = got_repo_close(repo);
8273 	if (error == NULL)
8274 		error = close_err;
8275 	repo = NULL;
8276 
8277 	error = got_object_id_str(&commit_id_str, commit_id);
8278 	if (error)
8279 		goto done;
8280 
8281 	cmd = &tog_commands[0]; /* log */
8282 	argc = 4;
8283 	cmd_argv = make_argv(argc, cmd->name, "-c", commit_id_str, argv[0]);
8284 	error = cmd->cmd_main(argc, cmd_argv);
8285 done:
8286 	if (repo) {
8287 		close_err = got_repo_close(repo);
8288 		if (error == NULL)
8289 			error = close_err;
8290 	}
8291 	if (commit)
8292 		got_object_commit_close(commit);
8293 	if (worktree)
8294 		got_worktree_close(worktree);
8295 	if (pack_fds) {
8296 		const struct got_error *pack_err =
8297 		    got_repo_pack_fds_close(pack_fds);
8298 		if (error == NULL)
8299 			error = pack_err;
8300 	}
8301 	free(id);
8302 	free(commit_id_str);
8303 	free(commit_id);
8304 	free(cwd);
8305 	free(repo_path);
8306 	free(in_repo_path);
8307 	if (cmd_argv) {
8308 		int i;
8309 		for (i = 0; i < argc; i++)
8310 			free(cmd_argv[i]);
8311 		free(cmd_argv);
8312 	}
8313 	tog_free_refs();
8314 	return error;
8315 }
8316 
8317 int
8318 main(int argc, char *argv[])
8319 {
8320 	const struct got_error *error = NULL;
8321 	const struct tog_cmd *cmd = NULL;
8322 	int ch, hflag = 0, Vflag = 0;
8323 	char **cmd_argv = NULL;
8324 	static const struct option longopts[] = {
8325 	    { "version", no_argument, NULL, 'V' },
8326 	    { NULL, 0, NULL, 0}
8327 	};
8328 	char *diff_algo_str = NULL;
8329 
8330 	setlocale(LC_CTYPE, "");
8331 
8332 	while ((ch = getopt_long(argc, argv, "+hV", longopts, NULL)) != -1) {
8333 		switch (ch) {
8334 		case 'h':
8335 			hflag = 1;
8336 			break;
8337 		case 'V':
8338 			Vflag = 1;
8339 			break;
8340 		default:
8341 			usage(hflag, 1);
8342 			/* NOTREACHED */
8343 		}
8344 	}
8345 
8346 	argc -= optind;
8347 	argv += optind;
8348 	optind = 1;
8349 	optreset = 1;
8350 
8351 	if (Vflag) {
8352 		got_version_print_str();
8353 		return 0;
8354 	}
8355 
8356 #ifndef PROFILE
8357 	if (pledge("stdio rpath wpath cpath flock proc tty exec sendfd unveil",
8358 	    NULL) == -1)
8359 		err(1, "pledge");
8360 #endif
8361 
8362 	if (argc == 0) {
8363 		if (hflag)
8364 			usage(hflag, 0);
8365 		/* Build an argument vector which runs a default command. */
8366 		cmd = &tog_commands[0];
8367 		argc = 1;
8368 		cmd_argv = make_argv(argc, cmd->name);
8369 	} else {
8370 		size_t i;
8371 
8372 		/* Did the user specify a command? */
8373 		for (i = 0; i < nitems(tog_commands); i++) {
8374 			if (strncmp(tog_commands[i].name, argv[0],
8375 			    strlen(argv[0])) == 0) {
8376 				cmd = &tog_commands[i];
8377 				break;
8378 			}
8379 		}
8380 	}
8381 
8382 	diff_algo_str = getenv("TOG_DIFF_ALGORITHM");
8383 	if (diff_algo_str) {
8384 		if (strcasecmp(diff_algo_str, "patience") == 0)
8385 			tog_diff_algo = GOT_DIFF_ALGORITHM_PATIENCE;
8386 		if (strcasecmp(diff_algo_str, "myers") == 0)
8387 			tog_diff_algo = GOT_DIFF_ALGORITHM_MYERS;
8388 	}
8389 
8390 	if (cmd == NULL) {
8391 		if (argc != 1)
8392 			usage(0, 1);
8393 		/* No command specified; try log with a path */
8394 		error = tog_log_with_path(argc, argv);
8395 	} else {
8396 		if (hflag)
8397 			cmd->cmd_usage();
8398 		else
8399 			error = cmd->cmd_main(argc, cmd_argv ? cmd_argv : argv);
8400 	}
8401 
8402 	endwin();
8403 	putchar('\n');
8404 	if (cmd_argv) {
8405 		int i;
8406 		for (i = 0; i < argc; i++)
8407 			free(cmd_argv[i]);
8408 		free(cmd_argv);
8409 	}
8410 
8411 	if (error && error->code != GOT_ERR_CANCELLED)
8412 		fprintf(stderr, "%s: %s\n", getprogname(), error->msg);
8413 	return 0;
8414 }