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
24 #include <curses.h>
25 #undef _XOPEN_SOURCE_EXTENDED
26 #include <panel.h>
27 #include <locale.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 <util.h>
37 #include <limits.h>
38 #include <wchar.h>
39 #include <time.h>
40 #include <pthread.h>
41 #include <libgen.h>
42 #include <regex.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 
85 static const struct got_error*	cmd_log(int, char *[]);
86 static const struct got_error*	cmd_diff(int, char *[]);
87 static const struct got_error*	cmd_blame(int, char *[]);
88 static const struct got_error*	cmd_tree(int, char *[]);
89 
90 static struct tog_cmd tog_commands[] = {
91 	{ "log",	cmd_log,	usage_log },
92 	{ "diff",	cmd_diff,	usage_diff },
93 	{ "blame",	cmd_blame,	usage_blame },
94 	{ "tree",	cmd_tree,	usage_tree },
95 };
96 
97 enum tog_view_type {
98 	TOG_VIEW_DIFF,
99 	TOG_VIEW_LOG,
100 	TOG_VIEW_BLAME,
101 	TOG_VIEW_TREE
102 };
103 
104 #define TOG_EOF_STRING	"(END)"
105 
106 struct commit_queue_entry {
107 	TAILQ_ENTRY(commit_queue_entry) entry;
108 	struct got_object_id *id;
109 	struct got_commit_object *commit;
110 	int idx;
111 };
112 TAILQ_HEAD(commit_queue_head, commit_queue_entry);
113 struct commit_queue {
114 	int ncommits;
115 	struct commit_queue_head head;
116 };
117 
118 struct tog_color {
119 	SIMPLEQ_ENTRY(tog_color) entry;
120 	regex_t regex;
121 	short colorpair;
122 };
123 SIMPLEQ_HEAD(tog_colors, tog_color);
124 
125 static const struct got_error *
126 add_color(struct tog_colors *colors, const char *pattern,
127     int idx, short color)
128 {
129 	const struct got_error *err = NULL;
130 	struct tog_color *tc;
131 	int regerr = 0;
132 
133 	if (idx < 1 || idx > COLOR_PAIRS - 1)
134 		return NULL;
135 
136 	init_pair(idx, color, -1);
137 
138 	tc = calloc(1, sizeof(*tc));
139 	if (tc == NULL)
140 		return got_error_from_errno("calloc");
141 	regerr = regcomp(&tc->regex, pattern,
142 	    REG_EXTENDED | REG_NOSUB | REG_NEWLINE);
143 	if (regerr) {
144 		static char regerr_msg[512];
145 		static char err_msg[512];
146 		regerror(regerr, &tc->regex, regerr_msg,
147 		    sizeof(regerr_msg));
148 		snprintf(err_msg, sizeof(err_msg), "regcomp: %s",
149 		    regerr_msg);
150 		err = got_error_msg(GOT_ERR_REGEX, err_msg);
151 		free(tc);
152 		return err;
153 	}
154 	tc->colorpair = idx;
155 	SIMPLEQ_INSERT_HEAD(colors, tc, entry);
156 	return NULL;
157 }
158 
159 static void
160 free_colors(struct tog_colors *colors)
161 {
162 	struct tog_color *tc;
163 
164 	while (!SIMPLEQ_EMPTY(colors)) {
165 		tc = SIMPLEQ_FIRST(colors);
166 		SIMPLEQ_REMOVE_HEAD(colors, entry);
167 		regfree(&tc->regex);
168 		free(tc);
169 	}
170 }
171 
172 struct tog_color *
173 get_color(struct tog_colors *colors, int colorpair)
174 {
175 	struct tog_color *tc = NULL;
176 
177 	SIMPLEQ_FOREACH(tc, colors, entry) {
178 		if (tc->colorpair == colorpair)
179 			return tc;
180 	}
181 
182 	return NULL;
183 }
184 
185 static int
186 default_color_value(const char *envvar)
187 {
188 	if (strcmp(envvar, "TOG_COLOR_DIFF_MINUS") == 0)
189 		return COLOR_MAGENTA;
190 	if (strcmp(envvar, "TOG_COLOR_DIFF_PLUS") == 0)
191 		return COLOR_CYAN;
192 	if (strcmp(envvar, "TOG_COLOR_DIFF_CHUNK_HEADER") == 0)
193 		return COLOR_YELLOW;
194 	if (strcmp(envvar, "TOG_COLOR_DIFF_META") == 0)
195 		return COLOR_GREEN;
196 	if (strcmp(envvar, "TOG_COLOR_TREE_SUBMODULE") == 0)
197 		return COLOR_MAGENTA;
198 	if (strcmp(envvar, "TOG_COLOR_TREE_SYMLINK") == 0)
199 		return COLOR_MAGENTA;
200 	if (strcmp(envvar, "TOG_COLOR_TREE_DIRECTORY") == 0)
201 		return COLOR_CYAN;
202 	if (strcmp(envvar, "TOG_COLOR_TREE_EXECUTABLE") == 0)
203 		return COLOR_GREEN;
204 	if (strcmp(envvar, "TOG_COLOR_COMMIT") == 0)
205 		return COLOR_GREEN;
206 	if (strcmp(envvar, "TOG_COLOR_AUTHOR") == 0)
207 		return COLOR_CYAN;
208 	if (strcmp(envvar, "TOG_COLOR_DATE") == 0)
209 		return COLOR_YELLOW;
210 
211 	return -1;
212 }
213 
214 static int
215 get_color_value(const char *envvar)
216 {
217 	const char *val = getenv(envvar);
218 
219 	if (val == NULL)
220 		return default_color_value(envvar);
221 
222 	if (strcasecmp(val, "black") == 0)
223 		return COLOR_BLACK;
224 	if (strcasecmp(val, "red") == 0)
225 		return COLOR_RED;
226 	if (strcasecmp(val, "green") == 0)
227 		return COLOR_GREEN;
228 	if (strcasecmp(val, "yellow") == 0)
229 		return COLOR_YELLOW;
230 	if (strcasecmp(val, "blue") == 0)
231 		return COLOR_BLUE;
232 	if (strcasecmp(val, "magenta") == 0)
233 		return COLOR_MAGENTA;
234 	if (strcasecmp(val, "cyan") == 0)
235 		return COLOR_CYAN;
236 	if (strcasecmp(val, "white") == 0)
237 		return COLOR_WHITE;
238 	if (strcasecmp(val, "default") == 0)
239 		return -1;
240 
241 	return default_color_value(envvar);
242 }
243 
244 
245 struct tog_diff_view_state {
246 	struct got_object_id *id1, *id2;
247 	FILE *f;
248 	int first_displayed_line;
249 	int last_displayed_line;
250 	int eof;
251 	int diff_context;
252 	struct got_repository *repo;
253 	struct got_reflist_head *refs;
254 	struct tog_colors colors;
255 	int nlines;
256 	off_t *line_offsets;
257 	int matched_line;
258 	int selected_line;
259 	size_t filesize;
260 
261 	/* passed from log view; may be NULL */
262 	struct tog_view *log_view;
263 };
264 
265 pthread_mutex_t tog_mutex = PTHREAD_MUTEX_INITIALIZER;
266 
267 struct tog_log_thread_args {
268 	pthread_cond_t need_commits;
269 	pthread_cond_t commit_loaded;
270 	int commits_needed;
271 	struct got_commit_graph *graph;
272 	struct commit_queue *commits;
273 	const char *in_repo_path;
274 	struct got_object_id *start_id;
275 	struct got_repository *repo;
276 	int log_complete;
277 	sig_atomic_t *quit;
278 	struct commit_queue_entry **first_displayed_entry;
279 	struct commit_queue_entry **selected_entry;
280 	int *searching;
281 	int *search_next_done;
282 	regex_t *regex;
283 };
284 
285 struct tog_log_view_state {
286 	struct commit_queue commits;
287 	struct commit_queue_entry *first_displayed_entry;
288 	struct commit_queue_entry *last_displayed_entry;
289 	struct commit_queue_entry *selected_entry;
290 	int selected;
291 	char *in_repo_path;
292 	const char *head_ref_name;
293 	int log_branches;
294 	struct got_repository *repo;
295 	struct got_reflist_head *refs;
296 	struct got_object_id *start_id;
297 	sig_atomic_t quit;
298 	pthread_t thread;
299 	struct tog_log_thread_args thread_args;
300 	struct commit_queue_entry *matched_entry;
301 	struct commit_queue_entry *search_entry;
302 	struct tog_colors colors;
303 };
304 
305 #define TOG_COLOR_DIFF_MINUS		1
306 #define TOG_COLOR_DIFF_PLUS		2
307 #define TOG_COLOR_DIFF_CHUNK_HEADER	3
308 #define TOG_COLOR_DIFF_META		4
309 #define TOG_COLOR_TREE_SUBMODULE	5
310 #define TOG_COLOR_TREE_SYMLINK		6
311 #define TOG_COLOR_TREE_DIRECTORY	7
312 #define TOG_COLOR_TREE_EXECUTABLE	8
313 #define TOG_COLOR_COMMIT		9
314 #define TOG_COLOR_AUTHOR		10
315 #define TOG_COLOR_DATE		11
316 
317 struct tog_blame_cb_args {
318 	struct tog_blame_line *lines; /* one per line */
319 	int nlines;
320 
321 	struct tog_view *view;
322 	struct got_object_id *commit_id;
323 	int *quit;
324 };
325 
326 struct tog_blame_thread_args {
327 	const char *path;
328 	struct got_repository *repo;
329 	struct tog_blame_cb_args *cb_args;
330 	int *complete;
331 	got_cancel_cb cancel_cb;
332 	void *cancel_arg;
333 };
334 
335 struct tog_blame {
336 	FILE *f;
337 	size_t filesize;
338 	struct tog_blame_line *lines;
339 	int nlines;
340 	off_t *line_offsets;
341 	pthread_t thread;
342 	struct tog_blame_thread_args thread_args;
343 	struct tog_blame_cb_args cb_args;
344 	const char *path;
345 };
346 
347 struct tog_blame_view_state {
348 	int first_displayed_line;
349 	int last_displayed_line;
350 	int selected_line;
351 	int blame_complete;
352 	int eof;
353 	int done;
354 	struct got_object_id_queue blamed_commits;
355 	struct got_object_qid *blamed_commit;
356 	char *path;
357 	struct got_repository *repo;
358 	struct got_reflist_head *refs;
359 	struct got_object_id *commit_id;
360 	struct tog_blame blame;
361 	int matched_line;
362 	struct tog_colors colors;
363 };
364 
365 struct tog_parent_tree {
366 	TAILQ_ENTRY(tog_parent_tree) entry;
367 	struct got_tree_object *tree;
368 	struct got_tree_entry *first_displayed_entry;
369 	struct got_tree_entry *selected_entry;
370 	int selected;
371 };
372 
373 TAILQ_HEAD(tog_parent_trees, tog_parent_tree);
374 
375 struct tog_tree_view_state {
376 	char *tree_label;
377 	struct got_tree_object *root;
378 	struct got_tree_object *tree;
379 	struct got_tree_entry *first_displayed_entry;
380 	struct got_tree_entry *last_displayed_entry;
381 	struct got_tree_entry *selected_entry;
382 	int ndisplayed, selected, show_ids;
383 	struct tog_parent_trees parents;
384 	struct got_object_id *commit_id;
385 	struct got_repository *repo;
386 	struct got_reflist_head *refs;
387 	struct got_tree_entry *matched_entry;
388 	struct tog_colors colors;
389 };
390 
391 /*
392  * We implement two types of views: parent views and child views.
393  *
394  * The 'Tab' key switches between a parent view and its child view.
395  * Child views are shown side-by-side to their parent view, provided
396  * there is enough screen estate.
397  *
398  * When a new view is opened from within a parent view, this new view
399  * becomes a child view of the parent view, replacing any existing child.
400  *
401  * When a new view is opened from within a child view, this new view
402  * becomes a parent view which will obscure the views below until the
403  * user quits the new parent view by typing 'q'.
404  *
405  * This list of views contains parent views only.
406  * Child views are only pointed to by their parent view.
407  */
408 TAILQ_HEAD(tog_view_list_head, tog_view);
409 
410 struct tog_view {
411 	TAILQ_ENTRY(tog_view) entry;
412 	WINDOW *window;
413 	PANEL *panel;
414 	int nlines, ncols, begin_y, begin_x;
415 	int lines, cols; /* copies of LINES and COLS */
416 	int focussed;
417 	struct tog_view *parent;
418 	struct tog_view *child;
419 	int child_focussed;
420 
421 	/* type-specific state */
422 	enum tog_view_type type;
423 	union {
424 		struct tog_diff_view_state diff;
425 		struct tog_log_view_state log;
426 		struct tog_blame_view_state blame;
427 		struct tog_tree_view_state tree;
428 	} state;
429 
430 	const struct got_error *(*show)(struct tog_view *);
431 	const struct got_error *(*input)(struct tog_view **,
432 	    struct tog_view **, struct tog_view**, struct tog_view *, int);
433 	const struct got_error *(*close)(struct tog_view *);
434 
435 	const struct got_error *(*search_start)(struct tog_view *);
436 	const struct got_error *(*search_next)(struct tog_view *);
437 	int searching;
438 #define TOG_SEARCH_FORWARD	1
439 #define TOG_SEARCH_BACKWARD	2
440 	int search_next_done;
441 #define TOG_SEARCH_HAVE_MORE	1
442 #define TOG_SEARCH_NO_MORE	2
443 #define TOG_SEARCH_HAVE_NONE	3
444 	regex_t regex;
445 };
446 
447 static const struct got_error *open_diff_view(struct tog_view *,
448     struct got_object_id *, struct got_object_id *, struct tog_view *,
449     struct got_reflist_head *, struct got_repository *);
450 static const struct got_error *show_diff_view(struct tog_view *);
451 static const struct got_error *input_diff_view(struct tog_view **,
452     struct tog_view **, struct tog_view **, struct tog_view *, int);
453 static const struct got_error* close_diff_view(struct tog_view *);
454 static const struct got_error *search_start_diff_view(struct tog_view *);
455 static const struct got_error *search_next_diff_view(struct tog_view *);
456 
457 static const struct got_error *open_log_view(struct tog_view *,
458     struct got_object_id *, struct got_reflist_head *,
459     struct got_repository *, const char *, const char *, int);
460 static const struct got_error * show_log_view(struct tog_view *);
461 static const struct got_error *input_log_view(struct tog_view **,
462     struct tog_view **, struct tog_view **, struct tog_view *, int);
463 static const struct got_error *close_log_view(struct tog_view *);
464 static const struct got_error *search_start_log_view(struct tog_view *);
465 static const struct got_error *search_next_log_view(struct tog_view *);
466 
467 static const struct got_error *open_blame_view(struct tog_view *, char *,
468     struct got_object_id *, struct got_reflist_head *, struct got_repository *);
469 static const struct got_error *show_blame_view(struct tog_view *);
470 static const struct got_error *input_blame_view(struct tog_view **,
471     struct tog_view **, struct tog_view **, struct tog_view *, int);
472 static const struct got_error *close_blame_view(struct tog_view *);
473 static const struct got_error *search_start_blame_view(struct tog_view *);
474 static const struct got_error *search_next_blame_view(struct tog_view *);
475 
476 static const struct got_error *open_tree_view(struct tog_view *,
477     struct got_tree_object *, struct got_object_id *, struct got_reflist_head *,
478     struct got_repository *);
479 static const struct got_error *show_tree_view(struct tog_view *);
480 static const struct got_error *input_tree_view(struct tog_view **,
481     struct tog_view **, struct tog_view **, struct tog_view *, int);
482 static const struct got_error *close_tree_view(struct tog_view *);
483 static const struct got_error *search_start_tree_view(struct tog_view *);
484 static const struct got_error *search_next_tree_view(struct tog_view *);
485 
486 static volatile sig_atomic_t tog_sigwinch_received;
487 static volatile sig_atomic_t tog_sigpipe_received;
488 static volatile sig_atomic_t tog_sigcont_received;
489 
490 static void
491 tog_sigwinch(int signo)
492 {
493 	tog_sigwinch_received = 1;
494 }
495 
496 static void
497 tog_sigpipe(int signo)
498 {
499 	tog_sigpipe_received = 1;
500 }
501 
502 static void
503 tog_sigcont(int signo)
504 {
505 	tog_sigcont_received = 1;
506 }
507 
508 static const struct got_error *
509 view_close(struct tog_view *view)
510 {
511 	const struct got_error *err = NULL;
512 
513 	if (view->child) {
514 		view_close(view->child);
515 		view->child = NULL;
516 	}
517 	if (view->close)
518 		err = view->close(view);
519 	if (view->panel)
520 		del_panel(view->panel);
521 	if (view->window)
522 		delwin(view->window);
523 	free(view);
524 	return err;
525 }
526 
527 static struct tog_view *
528 view_open(int nlines, int ncols, int begin_y, int begin_x,
529     enum tog_view_type type)
530 {
531 	struct tog_view *view = calloc(1, sizeof(*view));
532 
533 	if (view == NULL)
534 		return NULL;
535 
536 	view->type = type;
537 	view->lines = LINES;
538 	view->cols = COLS;
539 	view->nlines = nlines ? nlines : LINES - begin_y;
540 	view->ncols = ncols ? ncols : COLS - begin_x;
541 	view->begin_y = begin_y;
542 	view->begin_x = begin_x;
543 	view->window = newwin(nlines, ncols, begin_y, begin_x);
544 	if (view->window == NULL) {
545 		view_close(view);
546 		return NULL;
547 	}
548 	view->panel = new_panel(view->window);
549 	if (view->panel == NULL ||
550 	    set_panel_userptr(view->panel, view) != OK) {
551 		view_close(view);
552 		return NULL;
553 	}
554 
555 	keypad(view->window, TRUE);
556 	return view;
557 }
558 
559 static int
560 view_split_begin_x(int begin_x)
561 {
562 	if (begin_x > 0 || COLS < 120)
563 		return 0;
564 	return (COLS - MAX(COLS / 2, 80));
565 }
566 
567 static const struct got_error *view_resize(struct tog_view *);
568 
569 static const struct got_error *
570 view_splitscreen(struct tog_view *view)
571 {
572 	const struct got_error *err = NULL;
573 
574 	view->begin_y = 0;
575 	view->begin_x = view_split_begin_x(0);
576 	view->nlines = LINES;
577 	view->ncols = COLS - view->begin_x;
578 	view->lines = LINES;
579 	view->cols = COLS;
580 	err = view_resize(view);
581 	if (err)
582 		return err;
583 
584 	if (mvwin(view->window, view->begin_y, view->begin_x) == ERR)
585 		return got_error_from_errno("mvwin");
586 
587 	return NULL;
588 }
589 
590 static const struct got_error *
591 view_fullscreen(struct tog_view *view)
592 {
593 	const struct got_error *err = NULL;
594 
595 	view->begin_x = 0;
596 	view->begin_y = 0;
597 	view->nlines = LINES;
598 	view->ncols = COLS;
599 	view->lines = LINES;
600 	view->cols = COLS;
601 	err = view_resize(view);
602 	if (err)
603 		return err;
604 
605 	if (mvwin(view->window, view->begin_y, view->begin_x) == ERR)
606 		return got_error_from_errno("mvwin");
607 
608 	return NULL;
609 }
610 
611 static int
612 view_is_parent_view(struct tog_view *view)
613 {
614 	return view->parent == NULL;
615 }
616 
617 static const struct got_error *
618 view_resize(struct tog_view *view)
619 {
620 	int nlines, ncols;
621 
622 	if (view->lines > LINES)
623 		nlines = view->nlines - (view->lines - LINES);
624 	else
625 		nlines = view->nlines + (LINES - view->lines);
626 
627 	if (view->cols > COLS)
628 		ncols = view->ncols - (view->cols - COLS);
629 	else
630 		ncols = view->ncols + (COLS - view->cols);
631 
632 	if (wresize(view->window, nlines, ncols) == ERR)
633 		return got_error_from_errno("wresize");
634 	if (replace_panel(view->panel, view->window) == ERR)
635 		return got_error_from_errno("replace_panel");
636 	wclear(view->window);
637 
638 	view->nlines = nlines;
639 	view->ncols = ncols;
640 	view->lines = LINES;
641 	view->cols = COLS;
642 
643 	if (view->child) {
644 		view->child->begin_x = view_split_begin_x(view->begin_x);
645 		if (view->child->begin_x == 0) {
646 			view_fullscreen(view->child);
647 			if (view->child->focussed)
648 				show_panel(view->child->panel);
649 			else
650 				show_panel(view->panel);
651 		} else {
652 			view_splitscreen(view->child);
653 			show_panel(view->child->panel);
654 		}
655 	}
656 
657 	return NULL;
658 }
659 
660 static const struct got_error *
661 view_close_child(struct tog_view *view)
662 {
663 	const struct got_error *err = NULL;
664 
665 	if (view->child == NULL)
666 		return NULL;
667 
668 	err = view_close(view->child);
669 	view->child = NULL;
670 	return err;
671 }
672 
673 static const struct got_error *
674 view_set_child(struct tog_view *view, struct tog_view *child)
675 {
676 	const struct got_error *err = NULL;
677 
678 	view->child = child;
679 	child->parent = view;
680 	return err;
681 }
682 
683 static int
684 view_is_splitscreen(struct tog_view *view)
685 {
686 	return view->begin_x > 0;
687 }
688 
689 static void
690 tog_resizeterm(void)
691 {
692 	int cols, lines;
693 	struct winsize size;
694 
695 	if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &size) < 0) {
696 		cols = 80;     /* Default */
697 		lines = 24;
698 	} else {
699 		cols = size.ws_col;
700 		lines = size.ws_row;
701 	}
702 	resize_term(lines, cols);
703 }
704 
705 static const struct got_error *
706 view_search_start(struct tog_view *view)
707 {
708 	const struct got_error *err = NULL;
709 	char pattern[1024];
710 	int ret;
711 
712 	if (view->nlines < 1)
713 		return NULL;
714 
715 	mvwaddstr(view->window, view->begin_y + view->nlines - 1, 0, "/");
716 	wclrtoeol(view->window);
717 
718 	nocbreak();
719 	echo();
720 	ret = wgetnstr(view->window, pattern, sizeof(pattern));
721 	cbreak();
722 	noecho();
723 	if (ret == ERR)
724 		return NULL;
725 
726 	if (view->searching) {
727 		regfree(&view->regex);
728 		view->searching = 0;
729 	}
730 
731 	if (regcomp(&view->regex, pattern,
732 	    REG_EXTENDED | REG_NOSUB | REG_NEWLINE) == 0) {
733 		err = view->search_start(view);
734 		if (err) {
735 			regfree(&view->regex);
736 			return err;
737 		}
738 		view->searching = TOG_SEARCH_FORWARD;
739 		view->search_next_done = 0;
740 		view->search_next(view);
741 	}
742 
743 	return NULL;
744 }
745 
746 static const struct got_error *
747 view_input(struct tog_view **new, struct tog_view **dead,
748     struct tog_view **focus, int *done, struct tog_view *view,
749     struct tog_view_list_head *views)
750 {
751 	const struct got_error *err = NULL;
752 	struct tog_view *v;
753 	int ch, errcode;
754 
755 	*new = NULL;
756 	*dead = NULL;
757 	*focus = NULL;
758 
759 	/* Clear "no matches" indicator. */
760 	if (view->search_next_done == TOG_SEARCH_NO_MORE ||
761 	    view->search_next_done == TOG_SEARCH_HAVE_NONE)
762 		view->search_next_done = TOG_SEARCH_HAVE_MORE;
763 
764 	if (view->searching && !view->search_next_done) {
765 		errcode = pthread_mutex_unlock(&tog_mutex);
766 		if (errcode)
767 			return got_error_set_errno(errcode,
768 			    "pthread_mutex_unlock");
769 		pthread_yield();
770 		errcode = pthread_mutex_lock(&tog_mutex);
771 		if (errcode)
772 			return got_error_set_errno(errcode,
773 			    "pthread_mutex_lock");
774 		view->search_next(view);
775 		return NULL;
776 	}
777 
778 	nodelay(stdscr, FALSE);
779 	/* Allow threads to make progress while we are waiting for input. */
780 	errcode = pthread_mutex_unlock(&tog_mutex);
781 	if (errcode)
782 		return got_error_set_errno(errcode, "pthread_mutex_unlock");
783 	ch = wgetch(view->window);
784 	errcode = pthread_mutex_lock(&tog_mutex);
785 	if (errcode)
786 		return got_error_set_errno(errcode, "pthread_mutex_lock");
787 	nodelay(stdscr, TRUE);
788 
789 	if (tog_sigwinch_received || tog_sigcont_received) {
790 		tog_resizeterm();
791 		tog_sigwinch_received = 0;
792 		tog_sigcont_received = 0;
793 		TAILQ_FOREACH(v, views, entry) {
794 			err = view_resize(v);
795 			if (err)
796 				return err;
797 			err = v->input(new, dead, focus, v, KEY_RESIZE);
798 			if (err)
799 				return err;
800 		}
801 	}
802 
803 	switch (ch) {
804 	case ERR:
805 		break;
806 	case '\t':
807 		if (view->child) {
808 			*focus = view->child;
809 			view->child_focussed = 1;
810 		} else if (view->parent) {
811 			*focus = view->parent;
812 			view->parent->child_focussed = 0;
813 		}
814 		break;
815 	case 'q':
816 		err = view->input(new, dead, focus, view, ch);
817 		*dead = view;
818 		break;
819 	case 'Q':
820 		*done = 1;
821 		break;
822 	case 'f':
823 		if (view_is_parent_view(view)) {
824 			if (view->child == NULL)
825 				break;
826 			if (view_is_splitscreen(view->child)) {
827 				*focus = view->child;
828 				view->child_focussed = 1;
829 				err = view_fullscreen(view->child);
830 			} else
831 				err = view_splitscreen(view->child);
832 			if (err)
833 				break;
834 			err = view->child->input(new, dead, focus,
835 			    view->child, KEY_RESIZE);
836 		} else {
837 			if (view_is_splitscreen(view)) {
838 				*focus = view;
839 				view->parent->child_focussed = 1;
840 				err = view_fullscreen(view);
841 			} else {
842 				err = view_splitscreen(view);
843 			}
844 			if (err)
845 				break;
846 			err = view->input(new, dead, focus, view,
847 			    KEY_RESIZE);
848 		}
849 		break;
850 	case KEY_RESIZE:
851 		break;
852 	case '/':
853 		if (view->search_start)
854 			view_search_start(view);
855 		else
856 			err = view->input(new, dead, focus, view, ch);
857 		break;
858 	case 'N':
859 	case 'n':
860 		if (view->search_next) {
861 			view->searching = (ch == 'n' ?
862 			    TOG_SEARCH_FORWARD : TOG_SEARCH_BACKWARD);
863 			view->search_next_done = 0;
864 			view->search_next(view);
865 		} else
866 			err = view->input(new, dead, focus, view, ch);
867 		break;
868 	default:
869 		err = view->input(new, dead, focus, view, ch);
870 		break;
871 	}
872 
873 	return err;
874 }
875 
876 void
877 view_vborder(struct tog_view *view)
878 {
879 	PANEL *panel;
880 	struct tog_view *view_above;
881 
882 	if (view->parent)
883 		return view_vborder(view->parent);
884 
885 	panel = panel_above(view->panel);
886 	if (panel == NULL)
887 		return;
888 
889 	view_above = panel_userptr(panel);
890 	mvwvline(view->window, view->begin_y, view_above->begin_x - 1,
891 	    got_locale_is_utf8() ? ACS_VLINE : '|', view->nlines);
892 }
893 
894 int
895 view_needs_focus_indication(struct tog_view *view)
896 {
897 	if (view_is_parent_view(view)) {
898 		if (view->child == NULL || view->child_focussed)
899 			return 0;
900 		if (!view_is_splitscreen(view->child))
901 			return 0;
902 	} else if (!view_is_splitscreen(view))
903 		return 0;
904 
905 	return view->focussed;
906 }
907 
908 static const struct got_error *
909 view_loop(struct tog_view *view)
910 {
911 	const struct got_error *err = NULL;
912 	struct tog_view_list_head views;
913 	struct tog_view *new_view, *dead_view, *focus_view, *main_view;
914 	int fast_refresh = 10;
915 	int done = 0, errcode;
916 
917 	errcode = pthread_mutex_lock(&tog_mutex);
918 	if (errcode)
919 		return got_error_set_errno(errcode, "pthread_mutex_lock");
920 
921 	TAILQ_INIT(&views);
922 	TAILQ_INSERT_HEAD(&views, view, entry);
923 
924 	main_view = view;
925 	view->focussed = 1;
926 	err = view->show(view);
927 	if (err)
928 		return err;
929 	update_panels();
930 	doupdate();
931 	while (!TAILQ_EMPTY(&views) && !done && !tog_sigpipe_received) {
932 		/* Refresh fast during initialization, then become slower. */
933 		if (fast_refresh && fast_refresh-- == 0)
934 			halfdelay(10); /* switch to once per second */
935 
936 		err = view_input(&new_view, &dead_view, &focus_view, &done,
937 		    view, &views);
938 		if (err)
939 			break;
940 		if (dead_view) {
941 			struct tog_view *prev = NULL;
942 
943 			if (view_is_parent_view(dead_view))
944 				prev = TAILQ_PREV(dead_view,
945 				    tog_view_list_head, entry);
946 			else if (view->parent != dead_view)
947 				prev = view->parent;
948 
949 			if (dead_view->parent)
950 				dead_view->parent->child = NULL;
951 			else
952 				TAILQ_REMOVE(&views, dead_view, entry);
953 
954 			err = view_close(dead_view);
955 			if (err || (dead_view == main_view && new_view == NULL))
956 				goto done;
957 
958 			if (view == dead_view) {
959 				if (focus_view)
960 					view = focus_view;
961 				else if (prev)
962 					view = prev;
963 				else if (!TAILQ_EMPTY(&views))
964 					view = TAILQ_LAST(&views,
965 					    tog_view_list_head);
966 				else
967 					view = NULL;
968 				if (view) {
969 					if (view->child && view->child_focussed)
970 						focus_view = view->child;
971 					else
972 						focus_view = view;
973 				}
974 			}
975 		}
976 		if (new_view) {
977 			struct tog_view *v, *t;
978 			/* Only allow one parent view per type. */
979 			TAILQ_FOREACH_SAFE(v, &views, entry, t) {
980 				if (v->type != new_view->type)
981 					continue;
982 				TAILQ_REMOVE(&views, v, entry);
983 				err = view_close(v);
984 				if (err)
985 					goto done;
986 				break;
987 			}
988 			TAILQ_INSERT_TAIL(&views, new_view, entry);
989 			view = new_view;
990 			if (focus_view == NULL)
991 				focus_view = new_view;
992 		}
993 		if (focus_view) {
994 			show_panel(focus_view->panel);
995 			if (view)
996 				view->focussed = 0;
997 			focus_view->focussed = 1;
998 			view = focus_view;
999 			if (new_view)
1000 				show_panel(new_view->panel);
1001 			if (view->child && view_is_splitscreen(view->child))
1002 				show_panel(view->child->panel);
1003 		}
1004 		if (view) {
1005 			if (focus_view == NULL) {
1006 				view->focussed = 1;
1007 				show_panel(view->panel);
1008 				if (view->child && view_is_splitscreen(view->child))
1009 					show_panel(view->child->panel);
1010 				focus_view = view;
1011 			}
1012 			if (view->parent) {
1013 				err = view->parent->show(view->parent);
1014 				if (err)
1015 					goto done;
1016 			}
1017 			err = view->show(view);
1018 			if (err)
1019 				goto done;
1020 			if (view->child) {
1021 				err = view->child->show(view->child);
1022 				if (err)
1023 					goto done;
1024 			}
1025 			update_panels();
1026 			doupdate();
1027 		}
1028 	}
1029 done:
1030 	while (!TAILQ_EMPTY(&views)) {
1031 		view = TAILQ_FIRST(&views);
1032 		TAILQ_REMOVE(&views, view, entry);
1033 		view_close(view);
1034 	}
1035 
1036 	errcode = pthread_mutex_unlock(&tog_mutex);
1037 	if (errcode && err == NULL)
1038 		err = got_error_set_errno(errcode, "pthread_mutex_unlock");
1039 
1040 	return err;
1041 }
1042 
1043 __dead static void
1044 usage_log(void)
1045 {
1046 	endwin();
1047 	fprintf(stderr,
1048 	    "usage: %s log [-b] [-c commit] [-r repository-path] [path]\n",
1049 	    getprogname());
1050 	exit(1);
1051 }
1052 
1053 /* Create newly allocated wide-character string equivalent to a byte string. */
1054 static const struct got_error *
1055 mbs2ws(wchar_t **ws, size_t *wlen, const char *s)
1056 {
1057 	char *vis = NULL;
1058 	const struct got_error *err = NULL;
1059 
1060 	*ws = NULL;
1061 	*wlen = mbstowcs(NULL, s, 0);
1062 	if (*wlen == (size_t)-1) {
1063 		int vislen;
1064 		if (errno != EILSEQ)
1065 			return got_error_from_errno("mbstowcs");
1066 
1067 		/* byte string invalid in current encoding; try to "fix" it */
1068 		err = got_mbsavis(&vis, &vislen, s);
1069 		if (err)
1070 			return err;
1071 		*wlen = mbstowcs(NULL, vis, 0);
1072 		if (*wlen == (size_t)-1) {
1073 			err = got_error_from_errno("mbstowcs"); /* give up */
1074 			goto done;
1075 		}
1076 	}
1077 
1078 	*ws = calloc(*wlen + 1, sizeof(**ws));
1079 	if (*ws == NULL) {
1080 		err = got_error_from_errno("calloc");
1081 		goto done;
1082 	}
1083 
1084 	if (mbstowcs(*ws, vis ? vis : s, *wlen) != *wlen)
1085 		err = got_error_from_errno("mbstowcs");
1086 done:
1087 	free(vis);
1088 	if (err) {
1089 		free(*ws);
1090 		*ws = NULL;
1091 		*wlen = 0;
1092 	}
1093 	return err;
1094 }
1095 
1096 /* Format a line for display, ensuring that it won't overflow a width limit. */
1097 static const struct got_error *
1098 format_line(wchar_t **wlinep, int *widthp, const char *line, int wlimit,
1099     int col_tab_align)
1100 {
1101 	const struct got_error *err = NULL;
1102 	int cols = 0;
1103 	wchar_t *wline = NULL;
1104 	size_t wlen;
1105 	int i;
1106 
1107 	*wlinep = NULL;
1108 	*widthp = 0;
1109 
1110 	err = mbs2ws(&wline, &wlen, line);
1111 	if (err)
1112 		return err;
1113 
1114 	i = 0;
1115 	while (i < wlen) {
1116 		int width = wcwidth(wline[i]);
1117 
1118 		if (width == 0) {
1119 			i++;
1120 			continue;
1121 		}
1122 
1123 		if (width == 1 || width == 2) {
1124 			if (cols + width > wlimit)
1125 				break;
1126 			cols += width;
1127 			i++;
1128 		} else if (width == -1) {
1129 			if (wline[i] == L'\t') {
1130 				width = TABSIZE -
1131 				    ((cols + col_tab_align) % TABSIZE);
1132 				if (cols + width > wlimit)
1133 					break;
1134 				cols += width;
1135 			}
1136 			i++;
1137 		} else {
1138 			err = got_error_from_errno("wcwidth");
1139 			goto done;
1140 		}
1141 	}
1142 	wline[i] = L'\0';
1143 	if (widthp)
1144 		*widthp = cols;
1145 done:
1146 	if (err)
1147 		free(wline);
1148 	else
1149 		*wlinep = wline;
1150 	return err;
1151 }
1152 
1153 static const struct got_error*
1154 build_refs_str(char **refs_str, struct got_reflist_head *refs,
1155     struct got_object_id *id, struct got_repository *repo)
1156 {
1157 	static const struct got_error *err = NULL;
1158 	struct got_reflist_entry *re;
1159 	char *s;
1160 	const char *name;
1161 
1162 	*refs_str = NULL;
1163 
1164 	SIMPLEQ_FOREACH(re, refs, entry) {
1165 		struct got_tag_object *tag = NULL;
1166 		struct got_object_id *ref_id;
1167 		int cmp;
1168 
1169 		name = got_ref_get_name(re->ref);
1170 		if (strcmp(name, GOT_REF_HEAD) == 0)
1171 			continue;
1172 		if (strncmp(name, "refs/", 5) == 0)
1173 			name += 5;
1174 		if (strncmp(name, "got/", 4) == 0)
1175 			continue;
1176 		if (strncmp(name, "heads/", 6) == 0)
1177 			name += 6;
1178 		if (strncmp(name, "remotes/", 8) == 0) {
1179 			name += 8;
1180 			s = strstr(name, "/" GOT_REF_HEAD);
1181 			if (s != NULL && s[strlen(s)] == '\0')
1182 				continue;
1183 		}
1184 		err = got_ref_resolve(&ref_id, repo, re->ref);
1185 		if (err)
1186 			break;
1187 		if (strncmp(name, "tags/", 5) == 0) {
1188 			err = got_object_open_as_tag(&tag, repo, ref_id);
1189 			if (err) {
1190 				if (err->code != GOT_ERR_OBJ_TYPE) {
1191 					free(ref_id);
1192 					break;
1193 				}
1194 				/* Ref points at something other than a tag. */
1195 				err = NULL;
1196 				tag = NULL;
1197 			}
1198 		}
1199 		cmp = got_object_id_cmp(tag ?
1200 		    got_object_tag_get_object_id(tag) : ref_id, id);
1201 		free(ref_id);
1202 		if (tag)
1203 			got_object_tag_close(tag);
1204 		if (cmp != 0)
1205 			continue;
1206 		s = *refs_str;
1207 		if (asprintf(refs_str, "%s%s%s", s ? s : "",
1208 		    s ? ", " : "", name) == -1) {
1209 			err = got_error_from_errno("asprintf");
1210 			free(s);
1211 			*refs_str = NULL;
1212 			break;
1213 		}
1214 		free(s);
1215 	}
1216 
1217 	return err;
1218 }
1219 
1220 static const struct got_error *
1221 format_author(wchar_t **wauthor, int *author_width, char *author, int limit,
1222     int col_tab_align)
1223 {
1224 	char *smallerthan, *at;
1225 
1226 	smallerthan = strchr(author, '<');
1227 	if (smallerthan && smallerthan[1] != '\0')
1228 		author = smallerthan + 1;
1229 	at = strchr(author, '@');
1230 	if (at)
1231 		*at = '\0';
1232 	return format_line(wauthor, author_width, author, limit, col_tab_align);
1233 }
1234 
1235 static const struct got_error *
1236 draw_commit(struct tog_view *view, struct got_commit_object *commit,
1237     struct got_object_id *id, struct got_reflist_head *refs,
1238     const size_t date_display_cols, int author_display_cols,
1239     struct tog_colors *colors)
1240 {
1241 	const struct got_error *err = NULL;
1242 	char datebuf[12]; /* YYYY-MM-DD + SPACE + NUL */
1243 	char *logmsg0 = NULL, *logmsg = NULL;
1244 	char *author = NULL;
1245 	wchar_t *wlogmsg = NULL, *wauthor = NULL;
1246 	int author_width, logmsg_width;
1247 	char *newline, *line = NULL;
1248 	int col, limit;
1249 	const int avail = view->ncols;
1250 	struct tm tm;
1251 	time_t committer_time;
1252 	struct tog_color *tc;
1253 
1254 	committer_time = got_object_commit_get_committer_time(commit);
1255 	if (localtime_r(&committer_time, &tm) == NULL)
1256 		return got_error_from_errno("localtime_r");
1257 	if (strftime(datebuf, sizeof(datebuf), "%G-%m-%d ", &tm)
1258 	    >= sizeof(datebuf))
1259 		return got_error(GOT_ERR_NO_SPACE);
1260 
1261 	if (avail <= date_display_cols)
1262 		limit = MIN(sizeof(datebuf) - 1, avail);
1263 	else
1264 		limit = MIN(date_display_cols, sizeof(datebuf) - 1);
1265 	tc = get_color(colors, TOG_COLOR_DATE);
1266 	if (tc)
1267 		wattr_on(view->window,
1268 		    COLOR_PAIR(tc->colorpair), NULL);
1269 	waddnstr(view->window, datebuf, limit);
1270 	if (tc)
1271 		wattr_off(view->window,
1272 		    COLOR_PAIR(tc->colorpair), NULL);
1273 	col = limit;
1274 	if (col > avail)
1275 		goto done;
1276 
1277 	if (avail >= 120) {
1278 		char *id_str;
1279 		err = got_object_id_str(&id_str, id);
1280 		if (err)
1281 			goto done;
1282 		tc = get_color(colors, TOG_COLOR_COMMIT);
1283 		if (tc)
1284 			wattr_on(view->window,
1285 			    COLOR_PAIR(tc->colorpair), NULL);
1286 		wprintw(view->window, "%.8s ", id_str);
1287 		if (tc)
1288 			wattr_off(view->window,
1289 			    COLOR_PAIR(tc->colorpair), NULL);
1290 		free(id_str);
1291 		col += 9;
1292 		if (col > avail)
1293 			goto done;
1294 	}
1295 
1296 	author = strdup(got_object_commit_get_author(commit));
1297 	if (author == NULL) {
1298 		err = got_error_from_errno("strdup");
1299 		goto done;
1300 	}
1301 	err = format_author(&wauthor, &author_width, author, avail - col, col);
1302 	if (err)
1303 		goto done;
1304 	tc = get_color(colors, TOG_COLOR_AUTHOR);
1305 	if (tc)
1306 		wattr_on(view->window,
1307 		    COLOR_PAIR(tc->colorpair), NULL);
1308 	waddwstr(view->window, wauthor);
1309 	if (tc)
1310 		wattr_off(view->window,
1311 		    COLOR_PAIR(tc->colorpair), NULL);
1312 	col += author_width;
1313 	while (col < avail && author_width < author_display_cols + 2) {
1314 		waddch(view->window, ' ');
1315 		col++;
1316 		author_width++;
1317 	}
1318 	if (col > avail)
1319 		goto done;
1320 
1321 	err = got_object_commit_get_logmsg(&logmsg0, commit);
1322 	if (err)
1323 		goto done;
1324 	logmsg = logmsg0;
1325 	while (*logmsg == '\n')
1326 		logmsg++;
1327 	newline = strchr(logmsg, '\n');
1328 	if (newline)
1329 		*newline = '\0';
1330 	limit = avail - col;
1331 	err = format_line(&wlogmsg, &logmsg_width, logmsg, limit, col);
1332 	if (err)
1333 		goto done;
1334 	waddwstr(view->window, wlogmsg);
1335 	col += logmsg_width;
1336 	while (col < avail) {
1337 		waddch(view->window, ' ');
1338 		col++;
1339 	}
1340 done:
1341 	free(logmsg0);
1342 	free(wlogmsg);
1343 	free(author);
1344 	free(wauthor);
1345 	free(line);
1346 	return err;
1347 }
1348 
1349 static struct commit_queue_entry *
1350 alloc_commit_queue_entry(struct got_commit_object *commit,
1351     struct got_object_id *id)
1352 {
1353 	struct commit_queue_entry *entry;
1354 
1355 	entry = calloc(1, sizeof(*entry));
1356 	if (entry == NULL)
1357 		return NULL;
1358 
1359 	entry->id = id;
1360 	entry->commit = commit;
1361 	return entry;
1362 }
1363 
1364 static void
1365 pop_commit(struct commit_queue *commits)
1366 {
1367 	struct commit_queue_entry *entry;
1368 
1369 	entry = TAILQ_FIRST(&commits->head);
1370 	TAILQ_REMOVE(&commits->head, entry, entry);
1371 	got_object_commit_close(entry->commit);
1372 	commits->ncommits--;
1373 	/* Don't free entry->id! It is owned by the commit graph. */
1374 	free(entry);
1375 }
1376 
1377 static void
1378 free_commits(struct commit_queue *commits)
1379 {
1380 	while (!TAILQ_EMPTY(&commits->head))
1381 		pop_commit(commits);
1382 }
1383 
1384 static const struct got_error *
1385 match_commit(int *have_match, struct got_object_id *id,
1386     struct got_commit_object *commit, regex_t *regex)
1387 {
1388 	const struct got_error *err = NULL;
1389 	regmatch_t regmatch;
1390 	char *id_str = NULL, *logmsg = NULL;
1391 
1392 	*have_match = 0;
1393 
1394 	err = got_object_id_str(&id_str, id);
1395 	if (err)
1396 		return err;
1397 
1398 	err = got_object_commit_get_logmsg(&logmsg, commit);
1399 	if (err)
1400 		goto done;
1401 
1402 	if (regexec(regex, got_object_commit_get_author(commit), 1,
1403 	    &regmatch, 0) == 0 ||
1404 	    regexec(regex, got_object_commit_get_committer(commit), 1,
1405 	    &regmatch, 0) == 0 ||
1406 	    regexec(regex, id_str, 1, &regmatch, 0) == 0 ||
1407 	    regexec(regex, logmsg, 1, &regmatch, 0) == 0)
1408 		*have_match = 1;
1409 done:
1410 	free(id_str);
1411 	free(logmsg);
1412 	return err;
1413 }
1414 
1415 static const struct got_error *
1416 queue_commits(struct got_commit_graph *graph, struct commit_queue *commits,
1417     int minqueue, struct got_repository *repo, const char *path,
1418     int *searching, int *search_next_done, regex_t *regex)
1419 {
1420 	const struct got_error *err = NULL;
1421 	int nqueued = 0;
1422 
1423 	/*
1424 	 * We keep all commits open throughout the lifetime of the log
1425 	 * view in order to avoid having to re-fetch commits from disk
1426 	 * while updating the display.
1427 	 */
1428 	while (nqueued < minqueue ||
1429 	    (*searching == TOG_SEARCH_FORWARD && !*search_next_done)) {
1430 		struct got_object_id *id;
1431 		struct got_commit_object *commit;
1432 		struct commit_queue_entry *entry;
1433 		int errcode;
1434 
1435 		err = got_commit_graph_iter_next(&id, graph, repo, NULL, NULL);
1436 		if (err || id == NULL)
1437 			break;
1438 
1439 		err = got_object_open_as_commit(&commit, repo, id);
1440 		if (err)
1441 			break;
1442 		entry = alloc_commit_queue_entry(commit, id);
1443 		if (entry == NULL) {
1444 			err = got_error_from_errno("alloc_commit_queue_entry");
1445 			break;
1446 		}
1447 
1448 		errcode = pthread_mutex_lock(&tog_mutex);
1449 		if (errcode) {
1450 			err = got_error_set_errno(errcode,
1451 			    "pthread_mutex_lock");
1452 			break;
1453 		}
1454 
1455 		entry->idx = commits->ncommits;
1456 		TAILQ_INSERT_TAIL(&commits->head, entry, entry);
1457 		nqueued++;
1458 		commits->ncommits++;
1459 
1460 		if (*searching == TOG_SEARCH_FORWARD && !*search_next_done) {
1461 			int have_match;
1462 			err = match_commit(&have_match, id, commit, regex);
1463 			if (err)
1464 				break;
1465 			if (have_match)
1466 				*search_next_done = TOG_SEARCH_HAVE_MORE;
1467 		}
1468 
1469 		errcode = pthread_mutex_unlock(&tog_mutex);
1470 		if (errcode && err == NULL)
1471 			err = got_error_set_errno(errcode,
1472 			    "pthread_mutex_unlock");
1473 		if (err)
1474 			break;
1475 	}
1476 
1477 	return err;
1478 }
1479 
1480 static const struct got_error *
1481 draw_commits(struct tog_view *view, struct commit_queue_entry **last,
1482     struct commit_queue_entry **selected, struct commit_queue_entry *first,
1483     struct commit_queue *commits, int selected_idx, int limit,
1484     struct got_reflist_head *refs, const char *path, int commits_needed,
1485     struct tog_colors *colors)
1486 {
1487 	const struct got_error *err = NULL;
1488 	struct tog_log_view_state *s = &view->state.log;
1489 	struct commit_queue_entry *entry;
1490 	int width;
1491 	int ncommits, author_cols = 4;
1492 	char *id_str = NULL, *header = NULL, *ncommits_str = NULL;
1493 	char *refs_str = NULL;
1494 	wchar_t *wline;
1495 	struct tog_color *tc;
1496 	static const size_t date_display_cols = 12;
1497 
1498 	entry = first;
1499 	ncommits = 0;
1500 	while (entry) {
1501 		if (ncommits == selected_idx) {
1502 			*selected = entry;
1503 			break;
1504 		}
1505 		entry = TAILQ_NEXT(entry, entry);
1506 		ncommits++;
1507 	}
1508 
1509 	if (*selected && !(view->searching && view->search_next_done == 0)) {
1510 		err = got_object_id_str(&id_str, (*selected)->id);
1511 		if (err)
1512 			return err;
1513 		if (refs) {
1514 			err = build_refs_str(&refs_str, refs, (*selected)->id,
1515 			    s->repo);
1516 			if (err)
1517 				goto done;
1518 		}
1519 	}
1520 
1521 	if (commits_needed == 0)
1522 		halfdelay(10); /* disable fast refresh */
1523 
1524 	if (commits_needed > 0) {
1525 		if (asprintf(&ncommits_str, " [%d/%d] %s",
1526 		    entry ? entry->idx + 1 : 0, commits->ncommits,
1527 		    (view->searching && !view->search_next_done) ?
1528 		    "searching..." : "loading...") == -1) {
1529 			err = got_error_from_errno("asprintf");
1530 			goto done;
1531 		}
1532 	} else {
1533 		const char *search_str = NULL;
1534 
1535 		if (view->searching) {
1536 			if (view->search_next_done == TOG_SEARCH_NO_MORE)
1537 				search_str = "no more matches";
1538 			else if (view->search_next_done == TOG_SEARCH_HAVE_NONE)
1539 				search_str = "no matches found";
1540 			else if (!view->search_next_done)
1541 				search_str = "searching...";
1542 		}
1543 
1544 		if (asprintf(&ncommits_str, " [%d/%d] %s",
1545 		    entry ? entry->idx + 1 : 0, commits->ncommits,
1546 		    search_str ? search_str :
1547 		    (refs_str ? refs_str : "")) == -1) {
1548 			err = got_error_from_errno("asprintf");
1549 			goto done;
1550 		}
1551 	}
1552 
1553 	if (path && strcmp(path, "/") != 0) {
1554 		if (asprintf(&header, "commit %s %s%s",
1555 		    id_str ? id_str : "........................................",
1556 		    path, ncommits_str) == -1) {
1557 			err = got_error_from_errno("asprintf");
1558 			header = NULL;
1559 			goto done;
1560 		}
1561 	} else if (asprintf(&header, "commit %s%s",
1562 	    id_str ? id_str : "........................................",
1563 	    ncommits_str) == -1) {
1564 		err = got_error_from_errno("asprintf");
1565 		header = NULL;
1566 		goto done;
1567 	}
1568 	err = format_line(&wline, &width, header, view->ncols, 0);
1569 	if (err)
1570 		goto done;
1571 
1572 	werase(view->window);
1573 
1574 	if (view_needs_focus_indication(view))
1575 		wstandout(view->window);
1576 	tc = get_color(colors, TOG_COLOR_COMMIT);
1577 	if (tc)
1578 		wattr_on(view->window,
1579 		    COLOR_PAIR(tc->colorpair), NULL);
1580 	waddwstr(view->window, wline);
1581 	if (tc)
1582 		wattr_off(view->window,
1583 		    COLOR_PAIR(tc->colorpair), NULL);
1584 	while (width < view->ncols) {
1585 		waddch(view->window, ' ');
1586 		width++;
1587 	}
1588 	if (view_needs_focus_indication(view))
1589 		wstandend(view->window);
1590 	free(wline);
1591 	if (limit <= 1)
1592 		goto done;
1593 
1594 	/* Grow author column size if necessary. */
1595 	entry = first;
1596 	ncommits = 0;
1597 	while (entry) {
1598 		char *author;
1599 		wchar_t *wauthor;
1600 		int width;
1601 		if (ncommits >= limit - 1)
1602 			break;
1603 		author = strdup(got_object_commit_get_author(entry->commit));
1604 		if (author == NULL) {
1605 			err = got_error_from_errno("strdup");
1606 			goto done;
1607 		}
1608 		err = format_author(&wauthor, &width, author, COLS,
1609 		    date_display_cols);
1610 		if (author_cols < width)
1611 			author_cols = width;
1612 		free(wauthor);
1613 		free(author);
1614 		ncommits++;
1615 		entry = TAILQ_NEXT(entry, entry);
1616 	}
1617 
1618 	entry = first;
1619 	*last = first;
1620 	ncommits = 0;
1621 	while (entry) {
1622 		if (ncommits >= limit - 1)
1623 			break;
1624 		if (ncommits == selected_idx)
1625 			wstandout(view->window);
1626 		err = draw_commit(view, entry->commit, entry->id, refs,
1627 		    date_display_cols, author_cols, colors);
1628 		if (ncommits == selected_idx)
1629 			wstandend(view->window);
1630 		if (err)
1631 			goto done;
1632 		ncommits++;
1633 		*last = entry;
1634 		entry = TAILQ_NEXT(entry, entry);
1635 	}
1636 
1637 	view_vborder(view);
1638 done:
1639 	free(id_str);
1640 	free(refs_str);
1641 	free(ncommits_str);
1642 	free(header);
1643 	return err;
1644 }
1645 
1646 static void
1647 scroll_up(struct tog_view *view,
1648     struct commit_queue_entry **first_displayed_entry, int maxscroll,
1649     struct commit_queue *commits)
1650 {
1651 	struct commit_queue_entry *entry;
1652 	int nscrolled = 0;
1653 
1654 	entry = TAILQ_FIRST(&commits->head);
1655 	if (*first_displayed_entry == entry)
1656 		return;
1657 
1658 	entry = *first_displayed_entry;
1659 	while (entry && nscrolled < maxscroll) {
1660 		entry = TAILQ_PREV(entry, commit_queue_head, entry);
1661 		if (entry) {
1662 			*first_displayed_entry = entry;
1663 			nscrolled++;
1664 		}
1665 	}
1666 }
1667 
1668 static const struct got_error *
1669 trigger_log_thread(struct tog_view *log_view, int wait,
1670     int *commits_needed, int *log_complete,
1671     pthread_cond_t *need_commits, pthread_cond_t *commit_loaded)
1672 {
1673 	int errcode;
1674 
1675 	halfdelay(1); /* fast refresh while loading commits */
1676 
1677 	while (*commits_needed > 0) {
1678 		if (*log_complete)
1679 			break;
1680 
1681 		/* Wake the log thread. */
1682 		errcode = pthread_cond_signal(need_commits);
1683 		if (errcode)
1684 			return got_error_set_errno(errcode,
1685 			    "pthread_cond_signal");
1686 
1687 		/*
1688 		 * The mutex will be released while the view loop waits
1689 		 * in wgetch(), at which time the log thread will run.
1690 		 */
1691 		if (!wait)
1692 			break;
1693 
1694 		/* Display progress update in log view. */
1695 		show_log_view(log_view);
1696 		update_panels();
1697 		doupdate();
1698 
1699 		/* Wait right here while next commit is being loaded. */
1700 		errcode = pthread_cond_wait(commit_loaded, &tog_mutex);
1701 		if (errcode)
1702 			return got_error_set_errno(errcode,
1703 			    "pthread_cond_wait");
1704 
1705 		/* Display progress update in log view. */
1706 		show_log_view(log_view);
1707 		update_panels();
1708 		doupdate();
1709 	}
1710 
1711 	return NULL;
1712 }
1713 
1714 static const struct got_error *
1715 scroll_down(struct tog_view *log_view,
1716     struct commit_queue_entry **first_displayed_entry, int maxscroll,
1717     struct commit_queue_entry **last_displayed_entry,
1718     struct commit_queue *commits, int *log_complete, int *commits_needed,
1719     pthread_cond_t *need_commits, pthread_cond_t *commit_loaded)
1720 {
1721 	const struct got_error *err = NULL;
1722 	struct commit_queue_entry *pentry;
1723 	int nscrolled = 0, ncommits_needed;
1724 
1725 	if (*last_displayed_entry == NULL)
1726 		return NULL;
1727 
1728 	ncommits_needed = (*last_displayed_entry)->idx + 1 + maxscroll;
1729 	if (commits->ncommits < ncommits_needed && !*log_complete) {
1730 		/*
1731 		 * Ask the log thread for required amount of commits.
1732 		 */
1733 		(*commits_needed) += maxscroll;
1734 		err = trigger_log_thread(log_view, 1, commits_needed,
1735 		    log_complete, need_commits, commit_loaded);
1736 		if (err)
1737 			return err;
1738 	}
1739 
1740 	do {
1741 		pentry = TAILQ_NEXT(*last_displayed_entry, entry);
1742 		if (pentry == NULL)
1743 			break;
1744 
1745 		*last_displayed_entry = pentry;
1746 
1747 		pentry = TAILQ_NEXT(*first_displayed_entry, entry);
1748 		if (pentry == NULL)
1749 			break;
1750 		*first_displayed_entry = pentry;
1751 	} while (++nscrolled < maxscroll);
1752 
1753 	return err;
1754 }
1755 
1756 static const struct got_error *
1757 open_diff_view_for_commit(struct tog_view **new_view, int begin_x,
1758     struct got_commit_object *commit, struct got_object_id *commit_id,
1759     struct tog_view *log_view, struct got_reflist_head *refs,
1760     struct got_repository *repo)
1761 {
1762 	const struct got_error *err;
1763 	struct got_object_qid *parent_id;
1764 	struct tog_view *diff_view;
1765 
1766 	diff_view = view_open(0, 0, 0, begin_x, TOG_VIEW_DIFF);
1767 	if (diff_view == NULL)
1768 		return got_error_from_errno("view_open");
1769 
1770 	parent_id = SIMPLEQ_FIRST(got_object_commit_get_parent_ids(commit));
1771 	err = open_diff_view(diff_view, parent_id ? parent_id->id : NULL,
1772 	    commit_id, log_view, refs, repo);
1773 	if (err == NULL)
1774 		*new_view = diff_view;
1775 	return err;
1776 }
1777 
1778 static const struct got_error *
1779 tree_view_visit_subtree(struct got_tree_object *subtree,
1780     struct tog_tree_view_state *s)
1781 {
1782 	struct tog_parent_tree *parent;
1783 
1784 	parent = calloc(1, sizeof(*parent));
1785 	if (parent == NULL)
1786 		return got_error_from_errno("calloc");
1787 
1788 	parent->tree = s->tree;
1789 	parent->first_displayed_entry = s->first_displayed_entry;
1790 	parent->selected_entry = s->selected_entry;
1791 	parent->selected = s->selected;
1792 	TAILQ_INSERT_HEAD(&s->parents, parent, entry);
1793 	s->tree = subtree;
1794 	s->selected = 0;
1795 	s->first_displayed_entry = NULL;
1796 	return NULL;
1797 }
1798 
1799 static const struct got_error *
1800 tree_view_walk_path(struct tog_tree_view_state *s,
1801     struct got_object_id *commit_id,
1802     const char *path, struct got_repository *repo)
1803 {
1804 	const struct got_error *err = NULL;
1805 	struct got_tree_object *tree = NULL;
1806 	const char *p;
1807 	char *slash, *subpath = NULL;
1808 
1809 	/* Walk the path and open corresponding tree objects. */
1810 	p = path;
1811 	while (*p) {
1812 		struct got_tree_entry *te;
1813 		struct got_object_id *tree_id;
1814 		char *te_name;
1815 
1816 		while (p[0] == '/')
1817 			p++;
1818 
1819 		/* Ensure the correct subtree entry is selected. */
1820 		slash = strchr(p, '/');
1821 		if (slash == NULL)
1822 			te_name = strdup(p);
1823 		else
1824 			te_name = strndup(p, slash - p);
1825 		if (te_name == NULL) {
1826 			err = got_error_from_errno("strndup");
1827 			break;
1828 		}
1829 		te = got_object_tree_find_entry(s->tree, te_name);
1830 		if (te == NULL) {
1831 			err = got_error_path(te_name, GOT_ERR_NO_TREE_ENTRY);
1832 			free(te_name);
1833 			break;
1834 		}
1835 		free(te_name);
1836 		s->selected_entry = te;
1837 		s->selected = got_tree_entry_get_index(te);
1838 		if (s->tree != s->root)
1839 			s->selected++; /* skip '..' */
1840 
1841 		if (!S_ISDIR(got_tree_entry_get_mode(s->selected_entry))) {
1842 			/* Jump to this file's entry. */
1843 			s->first_displayed_entry = s->selected_entry;
1844 			s->selected = 0;
1845 			break;
1846 		}
1847 
1848 		slash = strchr(p, '/');
1849 		if (slash)
1850 			subpath = strndup(path, slash - path);
1851 		else
1852 			subpath = strdup(path);
1853 		if (subpath == NULL) {
1854 			err = got_error_from_errno("strdup");
1855 			break;
1856 		}
1857 
1858 		err = got_object_id_by_path(&tree_id, repo, commit_id,
1859 		    subpath);
1860 		if (err)
1861 			break;
1862 
1863 		err = got_object_open_as_tree(&tree, repo, tree_id);
1864 		free(tree_id);
1865 		if (err)
1866 			break;
1867 
1868 		err = tree_view_visit_subtree(tree, s);
1869 		if (err) {
1870 			got_object_tree_close(tree);
1871 			break;
1872 		}
1873 		if (slash == NULL)
1874 			break;
1875 		free(subpath);
1876 		subpath = NULL;
1877 		p = slash;
1878 	}
1879 
1880 	free(subpath);
1881 	return err;
1882 }
1883 
1884 static const struct got_error *
1885 browse_commit_tree(struct tog_view **new_view, int begin_x,
1886     struct commit_queue_entry *entry, const char *path,
1887     struct got_reflist_head *refs, struct got_repository *repo)
1888 {
1889 	const struct got_error *err = NULL;
1890 	struct got_tree_object *tree;
1891 	struct tog_tree_view_state *s;
1892 	struct tog_view *tree_view;
1893 
1894 	err = got_object_open_as_tree(&tree, repo,
1895 	    got_object_commit_get_tree_id(entry->commit));
1896 	if (err)
1897 		return err;
1898 
1899 	tree_view = view_open(0, 0, 0, begin_x, TOG_VIEW_TREE);
1900 	if (tree_view == NULL)
1901 		return got_error_from_errno("view_open");
1902 
1903 	err = open_tree_view(tree_view, tree, entry->id, refs, repo);
1904 	if (err) {
1905 		got_object_tree_close(tree);
1906 		return err;
1907 	}
1908 	s = &tree_view->state.tree;
1909 
1910 	*new_view = tree_view;
1911 
1912 	if (got_path_is_root_dir(path))
1913 		return NULL;
1914 
1915 	return tree_view_walk_path(s, entry->id, path, repo);
1916 }
1917 
1918 static const struct got_error *
1919 block_signals_used_by_main_thread(void)
1920 {
1921 	sigset_t sigset;
1922 	int errcode;
1923 
1924 	if (sigemptyset(&sigset) == -1)
1925 		return got_error_from_errno("sigemptyset");
1926 
1927 	/* tog handles SIGWINCH and SIGCONT */
1928 	if (sigaddset(&sigset, SIGWINCH) == -1)
1929 		return got_error_from_errno("sigaddset");
1930 	if (sigaddset(&sigset, SIGCONT) == -1)
1931 		return got_error_from_errno("sigaddset");
1932 
1933 	/* ncurses handles SIGTSTP */
1934 	if (sigaddset(&sigset, SIGTSTP) == -1)
1935 		return got_error_from_errno("sigaddset");
1936 
1937 	errcode = pthread_sigmask(SIG_BLOCK, &sigset, NULL);
1938 	if (errcode)
1939 		return got_error_set_errno(errcode, "pthread_sigmask");
1940 
1941 	return NULL;
1942 }
1943 
1944 static void *
1945 log_thread(void *arg)
1946 {
1947 	const struct got_error *err = NULL;
1948 	int errcode = 0;
1949 	struct tog_log_thread_args *a = arg;
1950 	int done = 0;
1951 
1952 	err = block_signals_used_by_main_thread();
1953 	if (err)
1954 		return (void *)err;
1955 
1956 	while (!done && !err && !tog_sigpipe_received) {
1957 		err = queue_commits(a->graph, a->commits, 1, a->repo,
1958 		    a->in_repo_path, a->searching, a->search_next_done,
1959 		    a->regex);
1960 		if (err) {
1961 			if (err->code != GOT_ERR_ITER_COMPLETED)
1962 				return (void *)err;
1963 			err = NULL;
1964 			done = 1;
1965 		} else if (a->commits_needed > 0)
1966 			a->commits_needed--;
1967 
1968 		errcode = pthread_mutex_lock(&tog_mutex);
1969 		if (errcode) {
1970 			err = got_error_set_errno(errcode,
1971 			    "pthread_mutex_lock");
1972 			break;
1973 		} else if (*a->quit)
1974 			done = 1;
1975 		else if (*a->first_displayed_entry == NULL) {
1976 			*a->first_displayed_entry =
1977 			    TAILQ_FIRST(&a->commits->head);
1978 			*a->selected_entry = *a->first_displayed_entry;
1979 		}
1980 
1981 		errcode = pthread_cond_signal(&a->commit_loaded);
1982 		if (errcode) {
1983 			err = got_error_set_errno(errcode,
1984 			    "pthread_cond_signal");
1985 			pthread_mutex_unlock(&tog_mutex);
1986 			break;
1987 		}
1988 
1989 		if (done)
1990 			a->commits_needed = 0;
1991 		else {
1992 			if (a->commits_needed == 0) {
1993 				errcode = pthread_cond_wait(&a->need_commits,
1994 				    &tog_mutex);
1995 				if (errcode)
1996 					err = got_error_set_errno(errcode,
1997 					    "pthread_cond_wait");
1998 			}
1999 		}
2000 
2001 		errcode = pthread_mutex_unlock(&tog_mutex);
2002 		if (errcode && err == NULL)
2003 			err = got_error_set_errno(errcode,
2004 			    "pthread_mutex_unlock");
2005 	}
2006 	a->log_complete = 1;
2007 	return (void *)err;
2008 }
2009 
2010 static const struct got_error *
2011 stop_log_thread(struct tog_log_view_state *s)
2012 {
2013 	const struct got_error *err = NULL;
2014 	int errcode;
2015 
2016 	if (s->thread) {
2017 		s->quit = 1;
2018 		errcode = pthread_cond_signal(&s->thread_args.need_commits);
2019 		if (errcode)
2020 			return got_error_set_errno(errcode,
2021 			    "pthread_cond_signal");
2022 		errcode = pthread_mutex_unlock(&tog_mutex);
2023 		if (errcode)
2024 			return got_error_set_errno(errcode,
2025 			    "pthread_mutex_unlock");
2026 		errcode = pthread_join(s->thread, (void **)&err);
2027 		if (errcode)
2028 			return got_error_set_errno(errcode, "pthread_join");
2029 		errcode = pthread_mutex_lock(&tog_mutex);
2030 		if (errcode)
2031 			return got_error_set_errno(errcode,
2032 			    "pthread_mutex_lock");
2033 		s->thread = NULL;
2034 	}
2035 
2036 	errcode = pthread_cond_destroy(&s->thread_args.need_commits);
2037 	if (errcode && err == NULL)
2038 		err = got_error_set_errno(errcode, "pthread_cond_destroy");
2039 
2040 	if (s->thread_args.repo) {
2041 		got_repo_close(s->thread_args.repo);
2042 		s->thread_args.repo = NULL;
2043 	}
2044 
2045 	if (s->thread_args.graph) {
2046 		got_commit_graph_close(s->thread_args.graph);
2047 		s->thread_args.graph = NULL;
2048 	}
2049 
2050 	return err;
2051 }
2052 
2053 static const struct got_error *
2054 close_log_view(struct tog_view *view)
2055 {
2056 	const struct got_error *err = NULL;
2057 	struct tog_log_view_state *s = &view->state.log;
2058 
2059 	err = stop_log_thread(s);
2060 	free_commits(&s->commits);
2061 	free(s->in_repo_path);
2062 	s->in_repo_path = NULL;
2063 	free(s->start_id);
2064 	s->start_id = NULL;
2065 	return err;
2066 }
2067 
2068 static const struct got_error *
2069 search_start_log_view(struct tog_view *view)
2070 {
2071 	struct tog_log_view_state *s = &view->state.log;
2072 
2073 	s->matched_entry = NULL;
2074 	s->search_entry = NULL;
2075 	return NULL;
2076 }
2077 
2078 static const struct got_error *
2079 search_next_log_view(struct tog_view *view)
2080 {
2081 	const struct got_error *err = NULL;
2082 	struct tog_log_view_state *s = &view->state.log;
2083 	struct commit_queue_entry *entry;
2084 
2085 	/* Display progress update in log view. */
2086 	show_log_view(view);
2087 	update_panels();
2088 	doupdate();
2089 
2090 	if (s->search_entry) {
2091 		int errcode, ch;
2092 		errcode = pthread_mutex_unlock(&tog_mutex);
2093 		if (errcode)
2094 			return got_error_set_errno(errcode,
2095 			    "pthread_mutex_unlock");
2096 		ch = wgetch(view->window);
2097 		errcode = pthread_mutex_lock(&tog_mutex);
2098 		if (errcode)
2099 			return got_error_set_errno(errcode,
2100 			    "pthread_mutex_lock");
2101 		if (ch == KEY_BACKSPACE) {
2102 			view->search_next_done = TOG_SEARCH_HAVE_MORE;
2103 			return NULL;
2104 		}
2105 		if (view->searching == TOG_SEARCH_FORWARD)
2106 			entry = TAILQ_NEXT(s->search_entry, entry);
2107 		else
2108 			entry = TAILQ_PREV(s->search_entry,
2109 			    commit_queue_head, entry);
2110 	} else if (s->matched_entry) {
2111 		if (view->searching == TOG_SEARCH_FORWARD)
2112 			entry = TAILQ_NEXT(s->matched_entry, entry);
2113 		else
2114 			entry = TAILQ_PREV(s->matched_entry,
2115 			    commit_queue_head, entry);
2116 	} else {
2117 		if (view->searching == TOG_SEARCH_FORWARD)
2118 			entry = TAILQ_FIRST(&s->commits.head);
2119 		else
2120 			entry = TAILQ_LAST(&s->commits.head, commit_queue_head);
2121 	}
2122 
2123 	while (1) {
2124 		int have_match = 0;
2125 
2126 		if (entry == NULL) {
2127 			if (s->thread_args.log_complete ||
2128 			    view->searching == TOG_SEARCH_BACKWARD) {
2129 				view->search_next_done =
2130 				    (s->matched_entry == NULL ?
2131 				    TOG_SEARCH_HAVE_NONE : TOG_SEARCH_NO_MORE);
2132 				s->search_entry = NULL;
2133 				return NULL;
2134 			}
2135 			/*
2136 			 * Poke the log thread for more commits and return,
2137 			 * allowing the main loop to make progress. Search
2138 			 * will resume at s->search_entry once we come back.
2139 			 */
2140 			s->thread_args.commits_needed++;
2141 			return trigger_log_thread(view, 0,
2142 			    &s->thread_args.commits_needed,
2143 			    &s->thread_args.log_complete,
2144 			    &s->thread_args.need_commits,
2145 			    &s->thread_args.commit_loaded);
2146 		}
2147 
2148 		err = match_commit(&have_match, entry->id, entry->commit,
2149 		    &view->regex);
2150 		if (err)
2151 			break;
2152 		if (have_match) {
2153 			view->search_next_done = TOG_SEARCH_HAVE_MORE;
2154 			s->matched_entry = entry;
2155 			break;
2156 		}
2157 
2158 		s->search_entry = entry;
2159 		if (view->searching == TOG_SEARCH_FORWARD)
2160 			entry = TAILQ_NEXT(entry, entry);
2161 		else
2162 			entry = TAILQ_PREV(entry, commit_queue_head, entry);
2163 	}
2164 
2165 	if (s->matched_entry) {
2166 		int cur = s->selected_entry->idx;
2167 		while (cur < s->matched_entry->idx) {
2168 			err = input_log_view(NULL, NULL, NULL, view, KEY_DOWN);
2169 			if (err)
2170 				return err;
2171 			cur++;
2172 		}
2173 		while (cur > s->matched_entry->idx) {
2174 			err = input_log_view(NULL, NULL, NULL, view, KEY_UP);
2175 			if (err)
2176 				return err;
2177 			cur--;
2178 		}
2179 	}
2180 
2181 	s->search_entry = NULL;
2182 
2183 	return NULL;
2184 }
2185 
2186 static const struct got_error *
2187 open_log_view(struct tog_view *view, struct got_object_id *start_id,
2188     struct got_reflist_head *refs, struct got_repository *repo,
2189     const char *head_ref_name, const char *in_repo_path,
2190     int log_branches)
2191 {
2192 	const struct got_error *err = NULL;
2193 	struct tog_log_view_state *s = &view->state.log;
2194 	struct got_repository *thread_repo = NULL;
2195 	struct got_commit_graph *thread_graph = NULL;
2196 	int errcode;
2197 
2198 	if (in_repo_path != s->in_repo_path) {
2199 		free(s->in_repo_path);
2200 		s->in_repo_path = strdup(in_repo_path);
2201 		if (s->in_repo_path == NULL)
2202 			return got_error_from_errno("strdup");
2203 	}
2204 
2205 	/* The commit queue only contains commits being displayed. */
2206 	TAILQ_INIT(&s->commits.head);
2207 	s->commits.ncommits = 0;
2208 
2209 	s->refs = refs;
2210 	s->repo = repo;
2211 	s->head_ref_name = head_ref_name;
2212 	s->start_id = got_object_id_dup(start_id);
2213 	if (s->start_id == NULL) {
2214 		err = got_error_from_errno("got_object_id_dup");
2215 		goto done;
2216 	}
2217 	s->log_branches = log_branches;
2218 
2219 	SIMPLEQ_INIT(&s->colors);
2220 	if (has_colors() && getenv("TOG_COLORS") != NULL) {
2221 		err = add_color(&s->colors, "^$", TOG_COLOR_COMMIT,
2222 		    get_color_value("TOG_COLOR_COMMIT"));
2223 		if (err)
2224 			goto done;
2225 		err = add_color(&s->colors, "^$", TOG_COLOR_AUTHOR,
2226 		    get_color_value("TOG_COLOR_AUTHOR"));
2227 		if (err) {
2228 			free_colors(&s->colors);
2229 			goto done;
2230 		}
2231 		err = add_color(&s->colors, "^$", TOG_COLOR_DATE,
2232 		    get_color_value("TOG_COLOR_DATE"));
2233 		if (err) {
2234 			free_colors(&s->colors);
2235 			goto done;
2236 		}
2237 	}
2238 
2239 	view->show = show_log_view;
2240 	view->input = input_log_view;
2241 	view->close = close_log_view;
2242 	view->search_start = search_start_log_view;
2243 	view->search_next = search_next_log_view;
2244 
2245 	err = got_repo_open(&thread_repo, got_repo_get_path(repo), NULL);
2246 	if (err)
2247 		goto done;
2248 	err = got_commit_graph_open(&thread_graph, s->in_repo_path,
2249 	    !s->log_branches);
2250 	if (err)
2251 		goto done;
2252 	err = got_commit_graph_iter_start(thread_graph,
2253 	     s->start_id, s->repo, NULL, NULL);
2254 	if (err)
2255 		goto done;
2256 
2257 	errcode = pthread_cond_init(&s->thread_args.need_commits, NULL);
2258 	if (errcode) {
2259 		err = got_error_set_errno(errcode, "pthread_cond_init");
2260 		goto done;
2261 	}
2262 	errcode = pthread_cond_init(&s->thread_args.commit_loaded, NULL);
2263 	if (errcode) {
2264 		err = got_error_set_errno(errcode, "pthread_cond_init");
2265 		goto done;
2266 	}
2267 
2268 	s->thread_args.commits_needed = view->nlines;
2269 	s->thread_args.graph = thread_graph;
2270 	s->thread_args.commits = &s->commits;
2271 	s->thread_args.in_repo_path = s->in_repo_path;
2272 	s->thread_args.start_id = s->start_id;
2273 	s->thread_args.repo = thread_repo;
2274 	s->thread_args.log_complete = 0;
2275 	s->thread_args.quit = &s->quit;
2276 	s->thread_args.first_displayed_entry = &s->first_displayed_entry;
2277 	s->thread_args.selected_entry = &s->selected_entry;
2278 	s->thread_args.searching = &view->searching;
2279 	s->thread_args.search_next_done = &view->search_next_done;
2280 	s->thread_args.regex = &view->regex;
2281 done:
2282 	if (err)
2283 		close_log_view(view);
2284 	return err;
2285 }
2286 
2287 static const struct got_error *
2288 show_log_view(struct tog_view *view)
2289 {
2290 	struct tog_log_view_state *s = &view->state.log;
2291 
2292 	if (s->thread == NULL) {
2293 		int errcode = pthread_create(&s->thread, NULL, log_thread,
2294 		    &s->thread_args);
2295 		if (errcode)
2296 			return got_error_set_errno(errcode, "pthread_create");
2297 	}
2298 
2299 	return draw_commits(view, &s->last_displayed_entry,
2300 	    &s->selected_entry, s->first_displayed_entry,
2301 	    &s->commits, s->selected, view->nlines, s->refs,
2302 	    s->in_repo_path, s->thread_args.commits_needed, &s->colors);
2303 }
2304 
2305 static const struct got_error *
2306 input_log_view(struct tog_view **new_view, struct tog_view **dead_view,
2307     struct tog_view **focus_view, struct tog_view *view, int ch)
2308 {
2309 	const struct got_error *err = NULL;
2310 	struct tog_log_view_state *s = &view->state.log;
2311 	char *parent_path, *in_repo_path = NULL;
2312 	struct tog_view *diff_view = NULL, *tree_view = NULL, *lv = NULL;
2313 	int begin_x = 0;
2314 	struct got_object_id *start_id;
2315 
2316 	switch (ch) {
2317 	case 'q':
2318 		s->quit = 1;
2319 		break;
2320 	case 'k':
2321 	case KEY_UP:
2322 	case '<':
2323 	case ',':
2324 		if (s->first_displayed_entry == NULL)
2325 			break;
2326 		if (s->selected > 0)
2327 			s->selected--;
2328 		else
2329 			scroll_up(view, &s->first_displayed_entry, 1,
2330 			    &s->commits);
2331 		break;
2332 	case KEY_PPAGE:
2333 	case CTRL('b'):
2334 		if (s->first_displayed_entry == NULL)
2335 			break;
2336 		if (TAILQ_FIRST(&s->commits.head) ==
2337 		    s->first_displayed_entry) {
2338 			s->selected = 0;
2339 			break;
2340 		}
2341 		scroll_up(view, &s->first_displayed_entry,
2342 		    view->nlines - 1, &s->commits);
2343 		break;
2344 	case 'j':
2345 	case KEY_DOWN:
2346 	case '>':
2347 	case '.':
2348 		if (s->first_displayed_entry == NULL)
2349 			break;
2350 		if (s->selected < MIN(view->nlines - 2,
2351 		    s->commits.ncommits - 1)) {
2352 			s->selected++;
2353 			break;
2354 		}
2355 		err = scroll_down(view, &s->first_displayed_entry, 1,
2356 		    &s->last_displayed_entry, &s->commits,
2357 		    &s->thread_args.log_complete,
2358 		    &s->thread_args.commits_needed,
2359 		    &s->thread_args.need_commits,
2360 		    &s->thread_args.commit_loaded);
2361 		break;
2362 	case KEY_NPAGE:
2363 	case CTRL('f'): {
2364 		struct commit_queue_entry *first;
2365 		first = s->first_displayed_entry;
2366 		if (first == NULL)
2367 			break;
2368 		err = scroll_down(view, &s->first_displayed_entry,
2369 		    view->nlines - 1, &s->last_displayed_entry,
2370 		    &s->commits, &s->thread_args.log_complete,
2371 		    &s->thread_args.commits_needed,
2372 		    &s->thread_args.need_commits,
2373 		    &s->thread_args.commit_loaded);
2374 		if (err)
2375 			break;
2376 		if (first == s->first_displayed_entry &&
2377 		    s->selected < MIN(view->nlines - 2,
2378 		    s->commits.ncommits - 1)) {
2379 			/* can't scroll further down */
2380 			s->selected = MIN(view->nlines - 2,
2381 			    s->commits.ncommits - 1);
2382 		}
2383 		err = NULL;
2384 		break;
2385 	}
2386 	case KEY_RESIZE:
2387 		if (s->selected > view->nlines - 2)
2388 			s->selected = view->nlines - 2;
2389 		if (s->selected > s->commits.ncommits - 1)
2390 			s->selected = s->commits.ncommits - 1;
2391 		break;
2392 	case KEY_ENTER:
2393 	case ' ':
2394 	case '\r':
2395 		if (s->selected_entry == NULL)
2396 			break;
2397 		if (view_is_parent_view(view))
2398 			begin_x = view_split_begin_x(view->begin_x);
2399 		err = open_diff_view_for_commit(&diff_view, begin_x,
2400 		    s->selected_entry->commit, s->selected_entry->id,
2401 		    view, s->refs, s->repo);
2402 		if (err)
2403 			break;
2404 		if (view_is_parent_view(view)) {
2405 			err = view_close_child(view);
2406 			if (err)
2407 				return err;
2408 			err = view_set_child(view, diff_view);
2409 			if (err) {
2410 				view_close(diff_view);
2411 				break;
2412 			}
2413 			*focus_view = diff_view;
2414 			view->child_focussed = 1;
2415 		} else
2416 			*new_view = diff_view;
2417 		break;
2418 	case 't':
2419 		if (s->selected_entry == NULL)
2420 			break;
2421 		if (view_is_parent_view(view))
2422 			begin_x = view_split_begin_x(view->begin_x);
2423 		err = browse_commit_tree(&tree_view, begin_x,
2424 		    s->selected_entry, s->in_repo_path, s->refs, s->repo);
2425 		if (err)
2426 			break;
2427 		if (view_is_parent_view(view)) {
2428 			err = view_close_child(view);
2429 			if (err)
2430 				return err;
2431 			err = view_set_child(view, tree_view);
2432 			if (err) {
2433 				view_close(tree_view);
2434 				break;
2435 			}
2436 			*focus_view = tree_view;
2437 			view->child_focussed = 1;
2438 		} else
2439 			*new_view = tree_view;
2440 		break;
2441 	case KEY_BACKSPACE:
2442 		if (strcmp(s->in_repo_path, "/") == 0)
2443 			break;
2444 		parent_path = dirname(s->in_repo_path);
2445 		if (parent_path && strcmp(parent_path, ".") != 0) {
2446 			err = stop_log_thread(s);
2447 			if (err)
2448 				return err;
2449 			lv = view_open(view->nlines, view->ncols,
2450 			    view->begin_y, view->begin_x, TOG_VIEW_LOG);
2451 			if (lv == NULL)
2452 				return got_error_from_errno(
2453 				    "view_open");
2454 			err = open_log_view(lv, s->start_id, s->refs,
2455 			    s->repo, s->head_ref_name, parent_path,
2456 			    s->log_branches);
2457 			if (err)
2458 				return err;;
2459 			if (view_is_parent_view(view))
2460 				*new_view = lv;
2461 			else {
2462 				view_set_child(view->parent, lv);
2463 				*focus_view = lv;
2464 			}
2465 			return NULL;
2466 		}
2467 		break;
2468 	case CTRL('l'):
2469 		err = stop_log_thread(s);
2470 		if (err)
2471 			return err;
2472 		lv = view_open(view->nlines, view->ncols,
2473 		    view->begin_y, view->begin_x, TOG_VIEW_LOG);
2474 		if (lv == NULL)
2475 			return got_error_from_errno("view_open");
2476 		err = got_repo_match_object_id(&start_id, NULL,
2477 		    s->head_ref_name ? s->head_ref_name : GOT_REF_HEAD,
2478 		    GOT_OBJ_TYPE_COMMIT, 1, s->repo);
2479 		if (err) {
2480 			view_close(lv);
2481 			return err;
2482 		}
2483 		in_repo_path = strdup(s->in_repo_path);
2484 		if (in_repo_path == NULL) {
2485 			free(start_id);
2486 			view_close(lv);
2487 			return got_error_from_errno("strdup");
2488 		}
2489 		got_ref_list_free(s->refs);
2490 		err = got_ref_list(s->refs, s->repo, NULL,
2491 		    got_ref_cmp_by_name, NULL);
2492 		if (err) {
2493 			free(start_id);
2494 			view_close(lv);
2495 			return err;
2496 		}
2497 		err = open_log_view(lv, start_id, s->refs, s->repo,
2498 		    s->head_ref_name, in_repo_path, s->log_branches);
2499 		if (err) {
2500 			free(start_id);
2501 			view_close(lv);
2502 			return err;;
2503 		}
2504 		*dead_view = view;
2505 		*new_view = lv;
2506 		break;
2507 	case 'B':
2508 		s->log_branches = !s->log_branches;
2509 		err = stop_log_thread(s);
2510 		if (err)
2511 			return err;
2512 		lv = view_open(view->nlines, view->ncols,
2513 		    view->begin_y, view->begin_x, TOG_VIEW_LOG);
2514 		if (lv == NULL)
2515 			return got_error_from_errno("view_open");
2516 		err = open_log_view(lv, s->start_id, s->refs, s->repo,
2517 		    s->head_ref_name, s->in_repo_path, s->log_branches);
2518 		if (err) {
2519 			view_close(lv);
2520 			return err;;
2521 		}
2522 		*dead_view = view;
2523 		*new_view = lv;
2524 		break;
2525 	default:
2526 		break;
2527 	}
2528 
2529 	return err;
2530 }
2531 
2532 static const struct got_error *
2533 apply_unveil(const char *repo_path, const char *worktree_path)
2534 {
2535 	const struct got_error *error;
2536 
2537 #ifdef PROFILE
2538 	if (unveil("gmon.out", "rwc") != 0)
2539 		return got_error_from_errno2("unveil", "gmon.out");
2540 #endif
2541 	if (repo_path && unveil(repo_path, "r") != 0)
2542 		return got_error_from_errno2("unveil", repo_path);
2543 
2544 	if (worktree_path && unveil(worktree_path, "rwc") != 0)
2545 		return got_error_from_errno2("unveil", worktree_path);
2546 
2547 	if (unveil(GOT_TMPDIR_STR, "rwc") != 0)
2548 		return got_error_from_errno2("unveil", GOT_TMPDIR_STR);
2549 
2550 	error = got_privsep_unveil_exec_helpers();
2551 	if (error != NULL)
2552 		return error;
2553 
2554 	if (unveil(NULL, NULL) != 0)
2555 		return got_error_from_errno("unveil");
2556 
2557 	return NULL;
2558 }
2559 
2560 static void
2561 init_curses(void)
2562 {
2563 	initscr();
2564 	cbreak();
2565 	halfdelay(1); /* Do fast refresh while initial view is loading. */
2566 	noecho();
2567 	nonl();
2568 	intrflush(stdscr, FALSE);
2569 	keypad(stdscr, TRUE);
2570 	curs_set(0);
2571 	if (getenv("TOG_COLORS") != NULL) {
2572 		start_color();
2573 		use_default_colors();
2574 	}
2575 	signal(SIGWINCH, tog_sigwinch);
2576 	signal(SIGPIPE, tog_sigpipe);
2577 	signal(SIGCONT, tog_sigcont);
2578 }
2579 
2580 static const struct got_error *
2581 get_in_repo_path_from_argv0(char **in_repo_path, int argc, char *argv[],
2582     struct got_repository *repo, struct got_worktree *worktree)
2583 {
2584 	const struct got_error *err = NULL;
2585 
2586 	if (argc == 0) {
2587 		*in_repo_path = strdup("/");
2588 		if (*in_repo_path == NULL)
2589 			return got_error_from_errno("strdup");
2590 		return NULL;
2591 	}
2592 
2593 	if (worktree) {
2594 		const char *prefix = got_worktree_get_path_prefix(worktree);
2595 		char *wt_path, *p;
2596 
2597 		err = got_worktree_resolve_path(&wt_path, worktree, argv[0]);
2598 		if (err)
2599 			return err;
2600 
2601 		if (asprintf(&p, "%s%s%s", prefix,
2602 		    (strcmp(prefix, "/") != 0) ? "/" : "", wt_path) == -1) {
2603 			err = got_error_from_errno("asprintf");
2604 			free(wt_path);
2605 			return err;
2606 		}
2607 		err = got_repo_map_path(in_repo_path, repo, p, 0);
2608 		free(p);
2609 		free(wt_path);
2610 	} else
2611 		err = got_repo_map_path(in_repo_path, repo, argv[0], 1);
2612 
2613 	return err;
2614 }
2615 
2616 static const struct got_error *
2617 cmd_log(int argc, char *argv[])
2618 {
2619 	const struct got_error *error;
2620 	struct got_repository *repo = NULL;
2621 	struct got_worktree *worktree = NULL;
2622 	struct got_reflist_head refs;
2623 	struct got_object_id *start_id = NULL;
2624 	char *in_repo_path = NULL, *repo_path = NULL, *cwd = NULL;
2625 	char *start_commit = NULL, *head_ref_name = NULL;
2626 	int ch, log_branches = 0;
2627 	struct tog_view *view;
2628 
2629 	SIMPLEQ_INIT(&refs);
2630 
2631 #ifndef PROFILE
2632 	if (pledge("stdio rpath wpath cpath flock proc tty exec sendfd unveil",
2633 	    NULL) == -1)
2634 		err(1, "pledge");
2635 #endif
2636 
2637 	while ((ch = getopt(argc, argv, "bc:r:")) != -1) {
2638 		switch (ch) {
2639 		case 'b':
2640 			log_branches = 1;
2641 			break;
2642 		case 'c':
2643 			start_commit = optarg;
2644 			break;
2645 		case 'r':
2646 			repo_path = realpath(optarg, NULL);
2647 			if (repo_path == NULL)
2648 				return got_error_from_errno2("realpath",
2649 				    optarg);
2650 			break;
2651 		default:
2652 			usage_log();
2653 			/* NOTREACHED */
2654 		}
2655 	}
2656 
2657 	argc -= optind;
2658 	argv += optind;
2659 
2660 	if (argc > 1)
2661 		usage_log();
2662 
2663 	cwd = getcwd(NULL, 0);
2664 	if (cwd == NULL)
2665 		return got_error_from_errno("getcwd");
2666 
2667 	error = got_worktree_open(&worktree, cwd);
2668 	if (error && error->code != GOT_ERR_NOT_WORKTREE)
2669 		goto done;
2670 
2671 	if (repo_path == NULL) {
2672 		if (worktree)
2673 			repo_path =
2674 			    strdup(got_worktree_get_repo_path(worktree));
2675 		else
2676 			repo_path = strdup(cwd);
2677 	}
2678 	if (repo_path == NULL) {
2679 		error = got_error_from_errno("strdup");
2680 		goto done;
2681 	}
2682 
2683 	error = got_repo_open(&repo, repo_path, NULL);
2684 	if (error != NULL)
2685 		goto done;
2686 
2687 	error = get_in_repo_path_from_argv0(&in_repo_path, argc, argv,
2688 	    repo, worktree);
2689 	if (error)
2690 		goto done;
2691 
2692 	init_curses();
2693 
2694 	error = apply_unveil(got_repo_get_path(repo),
2695 	    worktree ? got_worktree_get_root_path(worktree) : NULL);
2696 	if (error)
2697 		goto done;
2698 
2699 	if (start_commit == NULL)
2700 		error = got_repo_match_object_id(&start_id, NULL, worktree ?
2701 		    got_worktree_get_head_ref_name(worktree) : GOT_REF_HEAD,
2702 		    GOT_OBJ_TYPE_COMMIT, 1, repo);
2703 	else
2704 		error = got_repo_match_object_id(&start_id, NULL, start_commit,
2705 		    GOT_OBJ_TYPE_COMMIT, 1, repo);
2706 	if (error != NULL)
2707 		goto done;
2708 
2709 	error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
2710 	if (error)
2711 		goto done;
2712 
2713 	view = view_open(0, 0, 0, 0, TOG_VIEW_LOG);
2714 	if (view == NULL) {
2715 		error = got_error_from_errno("view_open");
2716 		goto done;
2717 	}
2718 	if (worktree) {
2719 		head_ref_name = strdup(
2720 		    got_worktree_get_head_ref_name(worktree));
2721 		if (head_ref_name == NULL) {
2722 			error = got_error_from_errno("strdup");
2723 			goto done;
2724 		}
2725 	}
2726 	error = open_log_view(view, start_id, &refs, repo, head_ref_name,
2727 	    in_repo_path, log_branches);
2728 	if (error)
2729 		goto done;
2730 	if (worktree) {
2731 		/* Release work tree lock. */
2732 		got_worktree_close(worktree);
2733 		worktree = NULL;
2734 	}
2735 	error = view_loop(view);
2736 done:
2737 	free(in_repo_path);
2738 	free(repo_path);
2739 	free(cwd);
2740 	free(start_id);
2741 	free(head_ref_name);
2742 	if (repo)
2743 		got_repo_close(repo);
2744 	if (worktree)
2745 		got_worktree_close(worktree);
2746 	got_ref_list_free(&refs);
2747 	return error;
2748 }
2749 
2750 __dead static void
2751 usage_diff(void)
2752 {
2753 	endwin();
2754 	fprintf(stderr, "usage: %s diff [-r repository-path] object1 object2\n",
2755 	    getprogname());
2756 	exit(1);
2757 }
2758 
2759 static char *
2760 parse_next_line(FILE *f, size_t *len)
2761 {
2762 	char *line;
2763 	size_t linelen;
2764 	size_t lineno;
2765 	const char delim[3] = { '\0', '\0', '\0'};
2766 
2767 	line = fparseln(f, &linelen, &lineno, delim, 0);
2768 	if (len)
2769 		*len = linelen;
2770 	return line;
2771 }
2772 
2773 static int
2774 match_line(const char *line, regex_t *regex)
2775 {
2776 	regmatch_t regmatch;
2777 
2778 	return regexec(regex, line, 1, &regmatch, 0) == 0;
2779 }
2780 
2781 struct tog_color *
2782 match_color(struct tog_colors *colors, const char *line)
2783 {
2784 	struct tog_color *tc = NULL;
2785 
2786 	SIMPLEQ_FOREACH(tc, colors, entry) {
2787 		if (match_line(line, &tc->regex))
2788 			return tc;
2789 	}
2790 
2791 	return NULL;
2792 }
2793 
2794 static const struct got_error *
2795 draw_file(struct tog_view *view, FILE *f, int *first_displayed_line, int nlines,
2796     int selected_line, int max_lines, int *last_displayed_line, int *eof,
2797     char *header, struct tog_colors *colors)
2798 {
2799 	const struct got_error *err;
2800 	int lineno = 0, nprinted = 0;
2801 	char *line;
2802 	struct tog_color *tc;
2803 	size_t len;
2804 	wchar_t *wline;
2805 	int width;
2806 
2807 	rewind(f);
2808 	werase(view->window);
2809 
2810 	if (header) {
2811 		err = format_line(&wline, &width, header, view->ncols, 0);
2812 		if (err) {
2813 			return err;
2814 		}
2815 
2816 		if (view_needs_focus_indication(view))
2817 			wstandout(view->window);
2818 		waddwstr(view->window, wline);
2819 		if (view_needs_focus_indication(view))
2820 			wstandend(view->window);
2821 		if (width <= view->ncols - 1)
2822 			waddch(view->window, '\n');
2823 
2824 		if (max_lines <= 1)
2825 			return NULL;
2826 		max_lines--;
2827 	}
2828 
2829 	*eof = 0;
2830 	while (nprinted < max_lines) {
2831 		line = parse_next_line(f, &len);
2832 		if (line == NULL) {
2833 			*eof = 1;
2834 			break;
2835 		}
2836 		if (++lineno < *first_displayed_line) {
2837 			free(line);
2838 			continue;
2839 		}
2840 
2841 		err = format_line(&wline, &width, line, view->ncols, 0);
2842 		if (err) {
2843 			free(line);
2844 			return err;
2845 		}
2846 
2847 		tc = match_color(colors, line);
2848 		if (tc)
2849 			wattr_on(view->window,
2850 			    COLOR_PAIR(tc->colorpair), NULL);
2851 		waddwstr(view->window, wline);
2852 		if (tc)
2853 			wattr_off(view->window,
2854 			    COLOR_PAIR(tc->colorpair), NULL);
2855 		if (width <= view->ncols - 1)
2856 			waddch(view->window, '\n');
2857 		if (++nprinted == 1)
2858 			*first_displayed_line = lineno;
2859 		free(line);
2860 		free(wline);
2861 		wline = NULL;
2862 	}
2863 	*last_displayed_line = lineno;
2864 
2865 	view_vborder(view);
2866 
2867 	if (*eof) {
2868 		while (nprinted < view->nlines) {
2869 			waddch(view->window, '\n');
2870 			nprinted++;
2871 		}
2872 
2873 		err = format_line(&wline, &width, TOG_EOF_STRING, view->ncols, 0);
2874 		if (err) {
2875 			return err;
2876 		}
2877 
2878 		wstandout(view->window);
2879 		waddwstr(view->window, wline);
2880 		wstandend(view->window);
2881 	}
2882 
2883 	return NULL;
2884 }
2885 
2886 static char *
2887 get_datestr(time_t *time, char *datebuf)
2888 {
2889 	struct tm mytm, *tm;
2890 	char *p, *s;
2891 
2892 	tm = gmtime_r(time, &mytm);
2893 	if (tm == NULL)
2894 		return NULL;
2895 	s = asctime_r(tm, datebuf);
2896 	if (s == NULL)
2897 		return NULL;
2898 	p = strchr(s, '\n');
2899 	if (p)
2900 		*p = '\0';
2901 	return s;
2902 }
2903 
2904 static const struct got_error *
2905 get_changed_paths(struct got_pathlist_head *paths,
2906     struct got_commit_object *commit, struct got_repository *repo)
2907 {
2908 	const struct got_error *err = NULL;
2909 	struct got_object_id *tree_id1 = NULL, *tree_id2 = NULL;
2910 	struct got_tree_object *tree1 = NULL, *tree2 = NULL;
2911 	struct got_object_qid *qid;
2912 
2913 	qid = SIMPLEQ_FIRST(got_object_commit_get_parent_ids(commit));
2914 	if (qid != NULL) {
2915 		struct got_commit_object *pcommit;
2916 		err = got_object_open_as_commit(&pcommit, repo,
2917 		    qid->id);
2918 		if (err)
2919 			return err;
2920 
2921 		tree_id1 = got_object_commit_get_tree_id(pcommit);
2922 		got_object_commit_close(pcommit);
2923 
2924 	}
2925 
2926 	if (tree_id1) {
2927 		err = got_object_open_as_tree(&tree1, repo, tree_id1);
2928 		if (err)
2929 			goto done;
2930 	}
2931 
2932 	tree_id2 = got_object_commit_get_tree_id(commit);
2933 	err = got_object_open_as_tree(&tree2, repo, tree_id2);
2934 	if (err)
2935 		goto done;
2936 
2937 	err = got_diff_tree(tree1, tree2, "", "", repo,
2938 	    got_diff_tree_collect_changed_paths, paths, 0);
2939 done:
2940 	if (tree1)
2941 		got_object_tree_close(tree1);
2942 	if (tree2)
2943 		got_object_tree_close(tree2);
2944 	return err;
2945 }
2946 
2947 static const struct got_error *
2948 write_commit_info(struct got_object_id *commit_id,
2949     struct got_reflist_head *refs, struct got_repository *repo, FILE *outfile)
2950 {
2951 	const struct got_error *err = NULL;
2952 	char datebuf[26], *datestr;
2953 	struct got_commit_object *commit;
2954 	char *id_str = NULL, *logmsg = NULL;
2955 	time_t committer_time;
2956 	const char *author, *committer;
2957 	char *refs_str = NULL;
2958 	struct got_pathlist_head changed_paths;
2959 	struct got_pathlist_entry *pe;
2960 
2961 	TAILQ_INIT(&changed_paths);
2962 
2963 	if (refs) {
2964 		err = build_refs_str(&refs_str, refs, commit_id, repo);
2965 		if (err)
2966 			return err;
2967 	}
2968 
2969 	err = got_object_open_as_commit(&commit, repo, commit_id);
2970 	if (err)
2971 		return err;
2972 
2973 	err = got_object_id_str(&id_str, commit_id);
2974 	if (err) {
2975 		err = got_error_from_errno("got_object_id_str");
2976 		goto done;
2977 	}
2978 
2979 	if (fprintf(outfile, "commit %s%s%s%s\n", id_str, refs_str ? " (" : "",
2980 	    refs_str ? refs_str : "", refs_str ? ")" : "") < 0) {
2981 		err = got_error_from_errno("fprintf");
2982 		goto done;
2983 	}
2984 	if (fprintf(outfile, "from: %s\n",
2985 	    got_object_commit_get_author(commit)) < 0) {
2986 		err = got_error_from_errno("fprintf");
2987 		goto done;
2988 	}
2989 	committer_time = got_object_commit_get_committer_time(commit);
2990 	datestr = get_datestr(&committer_time, datebuf);
2991 	if (datestr && fprintf(outfile, "date: %s UTC\n", datestr) < 0) {
2992 		err = got_error_from_errno("fprintf");
2993 		goto done;
2994 	}
2995 	author = got_object_commit_get_author(commit);
2996 	committer = got_object_commit_get_committer(commit);
2997 	if (strcmp(author, committer) != 0 &&
2998 	    fprintf(outfile, "via: %s\n", committer) < 0) {
2999 		err = got_error_from_errno("fprintf");
3000 		goto done;
3001 	}
3002 	err = got_object_commit_get_logmsg(&logmsg, commit);
3003 	if (err)
3004 		goto done;
3005 	if (fprintf(outfile, "%s\n", logmsg) < 0) {
3006 		err = got_error_from_errno("fprintf");
3007 		goto done;
3008 	}
3009 	err = get_changed_paths(&changed_paths, commit, repo);
3010 	if (err)
3011 		goto done;
3012 	TAILQ_FOREACH(pe, &changed_paths, entry) {
3013 		struct got_diff_changed_path *cp = pe->data;
3014 		fprintf(outfile, "%c  %s\n", cp->status, pe->path);
3015 		free((char *)pe->path);
3016 		free(pe->data);
3017 	}
3018 	fputc('\n', outfile);
3019 done:
3020 	got_pathlist_free(&changed_paths);
3021 	free(id_str);
3022 	free(logmsg);
3023 	free(refs_str);
3024 	got_object_commit_close(commit);
3025 	return err;
3026 }
3027 
3028 const struct got_error *
3029 get_filestream_info(size_t *filesize, int *nlines, off_t **line_offsets,
3030     FILE *infile)
3031 {
3032 	const struct got_error *err = NULL;
3033 	size_t len, remain;
3034 	char buf[32768];
3035 	int i;
3036 	size_t nalloc = 0;
3037 	off_t off = 0;
3038 
3039 	*line_offsets = NULL;
3040 	*filesize = 0;
3041 	*nlines = 0;
3042 
3043 	if (fseek(infile, 0, SEEK_END) == -1)
3044 		return got_error_from_errno("fseek");
3045 	len = ftell(infile) + 1;
3046 	if (ferror(infile))
3047 		return got_error_from_errno("ftell");
3048 	if (fseek(infile, 0, SEEK_SET) == -1)
3049 		return got_error_from_errno("fseek");
3050 
3051 	if (len == 0)
3052 		return NULL;
3053 
3054 	remain = len;
3055 	while (remain > 0) {
3056 		size_t r, n = MIN(remain, sizeof(buf));
3057 		r = fread(buf, 1, n, infile);
3058 		if (r == 0) {
3059 			if (ferror(infile)) {
3060 				err = got_error_from_errno("fread");
3061 				goto done;
3062 			}
3063 			break;
3064 		}
3065 		i = 0;
3066 		remain -= r;
3067 
3068 		if (*line_offsets == NULL) {
3069 			/* Have some data but perhaps no '\n'. */
3070 			*nlines = 1;
3071 			nalloc = len / 40; /* 40-char average line length */
3072 			*line_offsets = calloc(nalloc, sizeof(**line_offsets));
3073 			if (*line_offsets == NULL) {
3074 				err = got_error_from_errno("calloc");
3075 				goto done;
3076 			}
3077 				/* Skip forward over end of first line. */
3078 			while (i < len) {
3079 				if (buf[i] == '\n')
3080 					break;
3081 				i++;
3082 			}
3083 		}
3084 
3085 		/* Scan '\n' offsets in remaining chunk of data. */
3086 		while (i < r) {
3087 			if (buf[i] != '\n') {
3088 				i++;
3089 				continue;
3090 			}
3091 			(*nlines)++;
3092 			if (nalloc < *nlines) {
3093 				size_t nallocnew = *nlines + (remain / 40);
3094 				off_t *o = recallocarray(*line_offsets,
3095 				    nalloc, nallocnew, sizeof(**line_offsets));
3096 				if (o == NULL) {
3097 					err = got_error_from_errno(
3098 					    "recallocarray");
3099 					goto done;
3100 				}
3101 				*line_offsets = o;
3102 				nalloc = nallocnew;
3103 			}
3104 			off = i + 1;
3105 			(*line_offsets)[*nlines - 1] = off;
3106 			i++;
3107 		}
3108 	}
3109 
3110 	if (fflush(infile) != 0) {
3111 		err = got_error_from_errno("fflush");
3112 		goto done;
3113 	}
3114 	rewind(infile);
3115 
3116 	*filesize = len;
3117 done:
3118 	if (err) {
3119 		free(*line_offsets);
3120 		*line_offsets = NULL;
3121 		*filesize = 0;
3122 		*nlines = 0;
3123 	}
3124 	return NULL;
3125 }
3126 
3127 static const struct got_error *
3128 create_diff(struct tog_diff_view_state *s)
3129 {
3130 	const struct got_error *err = NULL;
3131 	FILE *f = NULL;
3132 	int obj_type;
3133 
3134 	f = got_opentemp();
3135 	if (f == NULL) {
3136 		err = got_error_from_errno("got_opentemp");
3137 		goto done;
3138 	}
3139 	if (s->f && fclose(s->f) != 0) {
3140 		err = got_error_from_errno("fclose");
3141 		goto done;
3142 	}
3143 	s->f = f;
3144 
3145 	if (s->id1)
3146 		err = got_object_get_type(&obj_type, s->repo, s->id1);
3147 	else
3148 		err = got_object_get_type(&obj_type, s->repo, s->id2);
3149 	if (err)
3150 		goto done;
3151 
3152 	switch (obj_type) {
3153 	case GOT_OBJ_TYPE_BLOB:
3154 		err = got_diff_objects_as_blobs(s->id1, s->id2, NULL, NULL,
3155 		    s->diff_context, 0, s->repo, s->f);
3156 		break;
3157 	case GOT_OBJ_TYPE_TREE:
3158 		err = got_diff_objects_as_trees(s->id1, s->id2, "", "",
3159 		    s->diff_context, 0, s->repo, s->f);
3160 		break;
3161 	case GOT_OBJ_TYPE_COMMIT: {
3162 		const struct got_object_id_queue *parent_ids;
3163 		struct got_object_qid *pid;
3164 		struct got_commit_object *commit2;
3165 
3166 		err = got_object_open_as_commit(&commit2, s->repo, s->id2);
3167 		if (err)
3168 			goto done;
3169 		/* Show commit info if we're diffing to a parent/root commit. */
3170 		if (s->id1 == NULL) {
3171 			err = write_commit_info(s->id2, s->refs, s->repo, s->f);
3172 			if (err)
3173 				goto done;
3174 		} else {
3175 			parent_ids = got_object_commit_get_parent_ids(commit2);
3176 			SIMPLEQ_FOREACH(pid, parent_ids, entry) {
3177 				if (got_object_id_cmp(s->id1, pid->id) == 0) {
3178 					err = write_commit_info(s->id2, s->refs,
3179 					    s->repo, s->f);
3180 					if (err)
3181 						goto done;
3182 					break;
3183 				}
3184 			}
3185 		}
3186 		got_object_commit_close(commit2);
3187 
3188 		err = got_diff_objects_as_commits(s->id1, s->id2,
3189 		    s->diff_context, 0, s->repo, s->f);
3190 		break;
3191 	}
3192 	default:
3193 		err = got_error(GOT_ERR_OBJ_TYPE);
3194 		break;
3195 	}
3196 	if (err)
3197 		goto done;
3198 	err = get_filestream_info(&s->filesize, &s->nlines, &s->line_offsets,
3199 	    s->f);
3200 done:
3201 	if (s->f && fflush(s->f) != 0 && err == NULL)
3202 		err = got_error_from_errno("fflush");
3203 	return err;
3204 }
3205 
3206 static void
3207 diff_view_indicate_progress(struct tog_view *view)
3208 {
3209 	mvwaddstr(view->window, 0, 0, "diffing...");
3210 	update_panels();
3211 	doupdate();
3212 }
3213 
3214 static const struct got_error *
3215 search_start_diff_view(struct tog_view *view)
3216 {
3217 	struct tog_diff_view_state *s = &view->state.diff;
3218 
3219 	s->matched_line = 0;
3220 	return NULL;
3221 }
3222 
3223 static const struct got_error *
3224 search_next_diff_view(struct tog_view *view)
3225 {
3226 	struct tog_diff_view_state *s = &view->state.diff;
3227 	int lineno;
3228 
3229 	if (!view->searching) {
3230 		view->search_next_done = TOG_SEARCH_HAVE_MORE;
3231 		return NULL;
3232 	}
3233 
3234 	if (s->matched_line) {
3235 		if (view->searching == TOG_SEARCH_FORWARD)
3236 			lineno = s->matched_line + 1;
3237 		else
3238 			lineno = s->matched_line - 1;
3239 	} else {
3240 		if (view->searching == TOG_SEARCH_FORWARD)
3241 			lineno = 1;
3242 		else
3243 			lineno = s->nlines;
3244 	}
3245 
3246 	while (1) {
3247 		char *line = NULL;
3248 		off_t offset;
3249 		size_t len;
3250 
3251 		if (lineno <= 0 || lineno > s->nlines) {
3252 			if (s->matched_line == 0) {
3253 				view->search_next_done = TOG_SEARCH_HAVE_MORE;
3254 				free(line);
3255 				break;
3256 			}
3257 
3258 			if (view->searching == TOG_SEARCH_FORWARD)
3259 				lineno = 1;
3260 			else
3261 				lineno = s->nlines;
3262 		}
3263 
3264 		offset = s->line_offsets[lineno - 1];
3265 		if (fseeko(s->f, offset, SEEK_SET) != 0) {
3266 			free(line);
3267 			return got_error_from_errno("fseeko");
3268 		}
3269 		free(line);
3270 		line = parse_next_line(s->f, &len);
3271 		if (line && match_line(line, &view->regex)) {
3272 			view->search_next_done = TOG_SEARCH_HAVE_MORE;
3273 			s->matched_line = lineno;
3274 			free(line);
3275 			break;
3276 		}
3277 		free(line);
3278 		if (view->searching == TOG_SEARCH_FORWARD)
3279 			lineno++;
3280 		else
3281 			lineno--;
3282 	}
3283 
3284 	if (s->matched_line) {
3285 		s->first_displayed_line = s->matched_line;
3286 		s->selected_line = 1;
3287 	}
3288 
3289 	return NULL;
3290 }
3291 
3292 static const struct got_error *
3293 open_diff_view(struct tog_view *view, struct got_object_id *id1,
3294     struct got_object_id *id2, struct tog_view *log_view,
3295     struct got_reflist_head *refs, struct got_repository *repo)
3296 {
3297 	const struct got_error *err;
3298 	struct tog_diff_view_state *s = &view->state.diff;
3299 
3300 	if (id1 != NULL && id2 != NULL) {
3301 	    int type1, type2;
3302 	    err = got_object_get_type(&type1, repo, id1);
3303 	    if (err)
3304 		return err;
3305 	    err = got_object_get_type(&type2, repo, id2);
3306 	    if (err)
3307 		return err;
3308 
3309 	    if (type1 != type2)
3310 		return got_error(GOT_ERR_OBJ_TYPE);
3311 	}
3312 	s->first_displayed_line = 1;
3313 	s->last_displayed_line = view->nlines;
3314 	s->selected_line = 1;
3315 	s->repo = repo;
3316 	s->refs = refs;
3317 	s->id1 = id1;
3318 	s->id2 = id2;
3319 
3320 	if (id1) {
3321 		s->id1 = got_object_id_dup(id1);
3322 		if (s->id1 == NULL)
3323 			return got_error_from_errno("got_object_id_dup");
3324 	} else
3325 		s->id1 = NULL;
3326 
3327 	s->id2 = got_object_id_dup(id2);
3328 	if (s->id2 == NULL) {
3329 		free(s->id1);
3330 		s->id1 = NULL;
3331 		return got_error_from_errno("got_object_id_dup");
3332 	}
3333 	s->f = NULL;
3334 	s->first_displayed_line = 1;
3335 	s->last_displayed_line = view->nlines;
3336 	s->diff_context = 3;
3337 	s->log_view = log_view;
3338 	s->repo = repo;
3339 	s->refs = refs;
3340 
3341 	SIMPLEQ_INIT(&s->colors);
3342 	if (has_colors() && getenv("TOG_COLORS") != NULL) {
3343 		err = add_color(&s->colors,
3344 		    "^-", TOG_COLOR_DIFF_MINUS,
3345 		    get_color_value("TOG_COLOR_DIFF_MINUS"));
3346 		if (err)
3347 			return err;
3348 		err = add_color(&s->colors, "^\\+",
3349 		    TOG_COLOR_DIFF_PLUS,
3350 		    get_color_value("TOG_COLOR_DIFF_PLUS"));
3351 		if (err) {
3352 			free_colors(&s->colors);
3353 			return err;
3354 		}
3355 		err = add_color(&s->colors,
3356 		    "^@@", TOG_COLOR_DIFF_CHUNK_HEADER,
3357 		    get_color_value("TOG_COLOR_DIFF_CHUNK_HEADER"));
3358 		if (err) {
3359 			free_colors(&s->colors);
3360 			return err;
3361 		}
3362 
3363 		err = add_color(&s->colors,
3364 		    "^(commit [0-9a-f]|(blob|file) [-+] |[MDmA]  [^ ])",
3365 		    TOG_COLOR_DIFF_META,
3366 		    get_color_value("TOG_COLOR_DIFF_META"));
3367 		if (err) {
3368 			free_colors(&s->colors);
3369 			return err;
3370 		}
3371 
3372 		err = add_color(&s->colors,
3373 		    "^(from|via): ", TOG_COLOR_AUTHOR,
3374 		    get_color_value("TOG_COLOR_AUTHOR"));
3375 		if (err) {
3376 			free_colors(&s->colors);
3377 			return err;
3378 		}
3379 
3380 		err = add_color(&s->colors,
3381 		    "^date: ", TOG_COLOR_DATE,
3382 		    get_color_value("TOG_COLOR_DATE"));
3383 		if (err) {
3384 			free_colors(&s->colors);
3385 			return err;
3386 		}
3387 	}
3388 
3389 	if (log_view && view_is_splitscreen(view))
3390 		show_log_view(log_view); /* draw vborder */
3391 	diff_view_indicate_progress(view);
3392 
3393 	err = create_diff(s);
3394 	if (err) {
3395 		free(s->id1);
3396 		s->id1 = NULL;
3397 		free(s->id2);
3398 		s->id2 = NULL;
3399 		return err;
3400 	}
3401 
3402 	view->show = show_diff_view;
3403 	view->input = input_diff_view;
3404 	view->close = close_diff_view;
3405 	view->search_start = search_start_diff_view;
3406 	view->search_next = search_next_diff_view;
3407 
3408 	return NULL;
3409 }
3410 
3411 static const struct got_error *
3412 close_diff_view(struct tog_view *view)
3413 {
3414 	const struct got_error *err = NULL;
3415 	struct tog_diff_view_state *s = &view->state.diff;
3416 
3417 	free(s->id1);
3418 	s->id1 = NULL;
3419 	free(s->id2);
3420 	s->id2 = NULL;
3421 	if (s->f && fclose(s->f) == EOF)
3422 		err = got_error_from_errno("fclose");
3423 	free_colors(&s->colors);
3424 	free(s->line_offsets);
3425 	return err;
3426 }
3427 
3428 static const struct got_error *
3429 show_diff_view(struct tog_view *view)
3430 {
3431 	const struct got_error *err;
3432 	struct tog_diff_view_state *s = &view->state.diff;
3433 	char *id_str1 = NULL, *id_str2, *header;
3434 
3435 	if (s->id1) {
3436 		err = got_object_id_str(&id_str1, s->id1);
3437 		if (err)
3438 			return err;
3439 	}
3440 	err = got_object_id_str(&id_str2, s->id2);
3441 	if (err)
3442 		return err;
3443 
3444 	if (asprintf(&header, "diff %s %s",
3445 	    id_str1 ? id_str1 : "/dev/null", id_str2) == -1) {
3446 		err = got_error_from_errno("asprintf");
3447 		free(id_str1);
3448 		free(id_str2);
3449 		return err;
3450 	}
3451 	free(id_str1);
3452 	free(id_str2);
3453 
3454 	return draw_file(view, s->f, &s->first_displayed_line, s->nlines,
3455 	    s->selected_line, view->nlines, &s->last_displayed_line, &s->eof,
3456 	    header, &s->colors);
3457 }
3458 
3459 static const struct got_error *
3460 set_selected_commit(struct tog_diff_view_state *s,
3461     struct commit_queue_entry *entry)
3462 {
3463 	const struct got_error *err;
3464 	const struct got_object_id_queue *parent_ids;
3465 	struct got_commit_object *selected_commit;
3466 	struct got_object_qid *pid;
3467 
3468 	free(s->id2);
3469 	s->id2 = got_object_id_dup(entry->id);
3470 	if (s->id2 == NULL)
3471 		return got_error_from_errno("got_object_id_dup");
3472 
3473 	err = got_object_open_as_commit(&selected_commit, s->repo, entry->id);
3474 	if (err)
3475 		return err;
3476 	parent_ids = got_object_commit_get_parent_ids(selected_commit);
3477 	free(s->id1);
3478 	pid = SIMPLEQ_FIRST(parent_ids);
3479 	s->id1 = pid ? got_object_id_dup(pid->id) : NULL;
3480 	got_object_commit_close(selected_commit);
3481 	return NULL;
3482 }
3483 
3484 static const struct got_error *
3485 input_diff_view(struct tog_view **new_view, struct tog_view **dead_view,
3486     struct tog_view **focus_view, struct tog_view *view, int ch)
3487 {
3488 	const struct got_error *err = NULL;
3489 	struct tog_diff_view_state *s = &view->state.diff;
3490 	struct tog_log_view_state *ls;
3491 	struct commit_queue_entry *entry;
3492 	int i;
3493 
3494 	switch (ch) {
3495 	case 'k':
3496 	case KEY_UP:
3497 		if (s->first_displayed_line > 1)
3498 			s->first_displayed_line--;
3499 		break;
3500 	case KEY_PPAGE:
3501 	case CTRL('b'):
3502 		if (s->first_displayed_line == 1)
3503 			break;
3504 		i = 0;
3505 		while (i++ < view->nlines - 1 &&
3506 		    s->first_displayed_line > 1)
3507 			s->first_displayed_line--;
3508 		break;
3509 	case 'j':
3510 	case KEY_DOWN:
3511 		if (!s->eof)
3512 			s->first_displayed_line++;
3513 		break;
3514 	case KEY_NPAGE:
3515 	case CTRL('f'):
3516 	case ' ':
3517 		if (s->eof)
3518 			break;
3519 		i = 0;
3520 		while (!s->eof && i++ < view->nlines - 1) {
3521 			char *line;
3522 			line = parse_next_line(s->f, NULL);
3523 			s->first_displayed_line++;
3524 			if (line == NULL)
3525 				break;
3526 		}
3527 		break;
3528 	case '[':
3529 		if (s->diff_context > 0) {
3530 			s->diff_context--;
3531 			diff_view_indicate_progress(view);
3532 			err = create_diff(s);
3533 		}
3534 		break;
3535 	case ']':
3536 		if (s->diff_context < GOT_DIFF_MAX_CONTEXT) {
3537 			s->diff_context++;
3538 			diff_view_indicate_progress(view);
3539 			err = create_diff(s);
3540 		}
3541 		break;
3542 	case '<':
3543 	case ',':
3544 		if (s->log_view == NULL)
3545 			break;
3546 		ls = &s->log_view->state.log;
3547 		entry = TAILQ_PREV(ls->selected_entry,
3548 		    commit_queue_head, entry);
3549 		if (entry == NULL)
3550 			break;
3551 
3552 		err = input_log_view(NULL, NULL, NULL, s->log_view,
3553 		    KEY_UP);
3554 		if (err)
3555 			break;
3556 
3557 		err = set_selected_commit(s, entry);
3558 		if (err)
3559 			break;
3560 
3561 		s->first_displayed_line = 1;
3562 		s->last_displayed_line = view->nlines;
3563 
3564 		diff_view_indicate_progress(view);
3565 		err = create_diff(s);
3566 		break;
3567 	case '>':
3568 	case '.':
3569 		if (s->log_view == NULL)
3570 			break;
3571 		ls = &s->log_view->state.log;
3572 
3573 		if (TAILQ_NEXT(ls->selected_entry, entry) == NULL) {
3574 			ls->thread_args.commits_needed++;
3575 			err = trigger_log_thread(s->log_view, 1,
3576 			    &ls->thread_args.commits_needed,
3577 			    &ls->thread_args.log_complete,
3578 			    &ls->thread_args.need_commits,
3579 			    &ls->thread_args.commit_loaded);
3580 			if (err)
3581 				break;
3582 		}
3583 		err = input_log_view(NULL, NULL, NULL, s->log_view,
3584 		    KEY_DOWN);
3585 		if (err)
3586 			break;
3587 
3588 		entry = TAILQ_NEXT(ls->selected_entry, entry);
3589 		if (entry == NULL)
3590 			break;
3591 
3592 		err = set_selected_commit(s, entry);
3593 		if (err)
3594 			break;
3595 
3596 		s->first_displayed_line = 1;
3597 		s->last_displayed_line = view->nlines;
3598 
3599 		diff_view_indicate_progress(view);
3600 		err = create_diff(s);
3601 		break;
3602 	default:
3603 		break;
3604 	}
3605 
3606 	return err;
3607 }
3608 
3609 static const struct got_error *
3610 cmd_diff(int argc, char *argv[])
3611 {
3612 	const struct got_error *error = NULL;
3613 	struct got_repository *repo = NULL;
3614 	struct got_worktree *worktree = NULL;
3615 	struct got_reflist_head refs;
3616 	struct got_object_id *id1 = NULL, *id2 = NULL;
3617 	char *repo_path = NULL, *cwd = NULL;
3618 	char *id_str1 = NULL, *id_str2 = NULL;
3619 	int ch;
3620 	struct tog_view *view;
3621 
3622 	SIMPLEQ_INIT(&refs);
3623 
3624 #ifndef PROFILE
3625 	if (pledge("stdio rpath wpath cpath flock proc tty exec sendfd unveil",
3626 	    NULL) == -1)
3627 		err(1, "pledge");
3628 #endif
3629 
3630 	while ((ch = getopt(argc, argv, "r:")) != -1) {
3631 		switch (ch) {
3632 		case 'r':
3633 			repo_path = realpath(optarg, NULL);
3634 			if (repo_path == NULL)
3635 				return got_error_from_errno2("realpath",
3636 				    optarg);
3637 			break;
3638 		default:
3639 			usage_diff();
3640 			/* NOTREACHED */
3641 		}
3642 	}
3643 
3644 	argc -= optind;
3645 	argv += optind;
3646 
3647 	if (argc == 0) {
3648 		usage_diff(); /* TODO show local worktree changes */
3649 	} else if (argc == 2) {
3650 		id_str1 = argv[0];
3651 		id_str2 = argv[1];
3652 	} else
3653 		usage_diff();
3654 
3655 	cwd = getcwd(NULL, 0);
3656 	if (cwd == NULL)
3657 		return got_error_from_errno("getcwd");
3658 
3659 	error = got_worktree_open(&worktree, cwd);
3660 	if (error && error->code != GOT_ERR_NOT_WORKTREE)
3661 		goto done;
3662 
3663 	if (repo_path == NULL) {
3664 		if (worktree)
3665 			repo_path =
3666 			    strdup(got_worktree_get_repo_path(worktree));
3667 		else
3668 			repo_path = strdup(cwd);
3669 	}
3670 	if (repo_path == NULL) {
3671 		error = got_error_from_errno("strdup");
3672 		goto done;
3673 	}
3674 
3675 	error = got_repo_open(&repo, repo_path, NULL);
3676 	if (error)
3677 		goto done;
3678 
3679 	init_curses();
3680 
3681 	error = apply_unveil(got_repo_get_path(repo), NULL);
3682 	if (error)
3683 		goto done;
3684 
3685 	error = got_repo_match_object_id_prefix(&id1, id_str1,
3686 	    GOT_OBJ_TYPE_ANY, repo);
3687 	if (error)
3688 		goto done;
3689 
3690 	error = got_repo_match_object_id_prefix(&id2, id_str2,
3691 	    GOT_OBJ_TYPE_ANY, repo);
3692 	if (error)
3693 		goto done;
3694 
3695 	error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
3696 	if (error)
3697 		goto done;
3698 
3699 	view = view_open(0, 0, 0, 0, TOG_VIEW_DIFF);
3700 	if (view == NULL) {
3701 		error = got_error_from_errno("view_open");
3702 		goto done;
3703 	}
3704 	error = open_diff_view(view, id1, id2, NULL, &refs, repo);
3705 	if (error)
3706 		goto done;
3707 	error = view_loop(view);
3708 done:
3709 	free(repo_path);
3710 	free(cwd);
3711 	if (repo)
3712 		got_repo_close(repo);
3713 	if (worktree)
3714 		got_worktree_close(worktree);
3715 	got_ref_list_free(&refs);
3716 	return error;
3717 }
3718 
3719 __dead static void
3720 usage_blame(void)
3721 {
3722 	endwin();
3723 	fprintf(stderr, "usage: %s blame [-c commit] [-r repository-path] path\n",
3724 	    getprogname());
3725 	exit(1);
3726 }
3727 
3728 struct tog_blame_line {
3729 	int annotated;
3730 	struct got_object_id *id;
3731 };
3732 
3733 static const struct got_error *
3734 draw_blame(struct tog_view *view, struct got_object_id *id, FILE *f,
3735     const char *path, struct tog_blame_line *lines, int nlines,
3736     int blame_complete, int selected_line, int *first_displayed_line,
3737     int *last_displayed_line, int *eof, int max_lines,
3738     struct tog_colors *colors)
3739 {
3740 	const struct got_error *err;
3741 	int lineno = 0, nprinted = 0;
3742 	char *line;
3743 	size_t len;
3744 	wchar_t *wline;
3745 	int width;
3746 	struct tog_blame_line *blame_line;
3747 	struct got_object_id *prev_id = NULL;
3748 	char *id_str;
3749 	struct tog_color *tc;
3750 
3751 	err = got_object_id_str(&id_str, id);
3752 	if (err)
3753 		return err;
3754 
3755 	rewind(f);
3756 	werase(view->window);
3757 
3758 	if (asprintf(&line, "commit %s", id_str) == -1) {
3759 		err = got_error_from_errno("asprintf");
3760 		free(id_str);
3761 		return err;
3762 	}
3763 
3764 	err = format_line(&wline, &width, line, view->ncols, 0);
3765 	free(line);
3766 	line = NULL;
3767 	if (err)
3768 		return err;
3769 	if (view_needs_focus_indication(view))
3770 		wstandout(view->window);
3771 	tc = get_color(colors, TOG_COLOR_COMMIT);
3772 	if (tc)
3773 		wattr_on(view->window,
3774 		    COLOR_PAIR(tc->colorpair), NULL);
3775 	waddwstr(view->window, wline);
3776 	if (tc)
3777 		wattr_off(view->window,
3778 		    COLOR_PAIR(tc->colorpair), NULL);
3779 	if (view_needs_focus_indication(view))
3780 		wstandend(view->window);
3781 	free(wline);
3782 	wline = NULL;
3783 	if (width < view->ncols - 1)
3784 		waddch(view->window, '\n');
3785 
3786 	if (asprintf(&line, "[%d/%d] %s%s",
3787 	    *first_displayed_line - 1 + selected_line, nlines,
3788 	    blame_complete ? "" : "annotating... ", path) == -1) {
3789 		free(id_str);
3790 		return got_error_from_errno("asprintf");
3791 	}
3792 	free(id_str);
3793 	err = format_line(&wline, &width, line, view->ncols, 0);
3794 	free(line);
3795 	line = NULL;
3796 	if (err)
3797 		return err;
3798 	waddwstr(view->window, wline);
3799 	free(wline);
3800 	wline = NULL;
3801 	if (width < view->ncols - 1)
3802 		waddch(view->window, '\n');
3803 
3804 	*eof = 0;
3805 	while (nprinted < max_lines - 2) {
3806 		line = parse_next_line(f, &len);
3807 		if (line == NULL) {
3808 			*eof = 1;
3809 			break;
3810 		}
3811 		if (++lineno < *first_displayed_line) {
3812 			free(line);
3813 			continue;
3814 		}
3815 
3816 		if (view->ncols <= 9) {
3817 			width = 9;
3818 			wline = wcsdup(L"");
3819 			if (wline == NULL)
3820 				err = got_error_from_errno("wcsdup");
3821 		} else {
3822 			err = format_line(&wline, &width, line,
3823 			    view->ncols - 9, 9);
3824 			width += 9;
3825 		}
3826 		if (err) {
3827 			free(line);
3828 			return err;
3829 		}
3830 
3831 		if (view->focussed && nprinted == selected_line - 1)
3832 			wstandout(view->window);
3833 
3834 		if (nlines > 0) {
3835 			blame_line = &lines[lineno - 1];
3836 			if (blame_line->annotated && prev_id &&
3837 			    got_object_id_cmp(prev_id, blame_line->id) == 0 &&
3838 			    !(view->focussed &&
3839 			    nprinted == selected_line - 1)) {
3840 				waddstr(view->window, "        ");
3841 			} else if (blame_line->annotated) {
3842 				char *id_str;
3843 				err = got_object_id_str(&id_str, blame_line->id);
3844 				if (err) {
3845 					free(line);
3846 					free(wline);
3847 					return err;
3848 				}
3849 				tc = get_color(colors, TOG_COLOR_COMMIT);
3850 				if (tc)
3851 					wattr_on(view->window,
3852 					    COLOR_PAIR(tc->colorpair), NULL);
3853 				wprintw(view->window, "%.8s", id_str);
3854 				if (tc)
3855 					wattr_off(view->window,
3856 					    COLOR_PAIR(tc->colorpair), NULL);
3857 				free(id_str);
3858 				prev_id = blame_line->id;
3859 			} else {
3860 				waddstr(view->window, "........");
3861 				prev_id = NULL;
3862 			}
3863 		} else {
3864 			waddstr(view->window, "........");
3865 			prev_id = NULL;
3866 		}
3867 
3868 		if (view->focussed && nprinted == selected_line - 1)
3869 			wstandend(view->window);
3870 		waddstr(view->window, " ");
3871 
3872 		waddwstr(view->window, wline);
3873 		if (width <= view->ncols - 1)
3874 			waddch(view->window, '\n');
3875 		if (++nprinted == 1)
3876 			*first_displayed_line = lineno;
3877 		free(line);
3878 		free(wline);
3879 		wline = NULL;
3880 	}
3881 	*last_displayed_line = lineno;
3882 
3883 	view_vborder(view);
3884 
3885 	return NULL;
3886 }
3887 
3888 static const struct got_error *
3889 blame_cb(void *arg, int nlines, int lineno, struct got_object_id *id)
3890 {
3891 	const struct got_error *err = NULL;
3892 	struct tog_blame_cb_args *a = arg;
3893 	struct tog_blame_line *line;
3894 	int errcode;
3895 
3896 	if (nlines != a->nlines ||
3897 	    (lineno != -1 && lineno < 1) || lineno > a->nlines)
3898 		return got_error(GOT_ERR_RANGE);
3899 
3900 	errcode = pthread_mutex_lock(&tog_mutex);
3901 	if (errcode)
3902 		return got_error_set_errno(errcode, "pthread_mutex_lock");
3903 
3904 	if (*a->quit) {	/* user has quit the blame view */
3905 		err = got_error(GOT_ERR_ITER_COMPLETED);
3906 		goto done;
3907 	}
3908 
3909 	if (lineno == -1)
3910 		goto done; /* no change in this commit */
3911 
3912 	line = &a->lines[lineno - 1];
3913 	if (line->annotated)
3914 		goto done;
3915 
3916 	line->id = got_object_id_dup(id);
3917 	if (line->id == NULL) {
3918 		err = got_error_from_errno("got_object_id_dup");
3919 		goto done;
3920 	}
3921 	line->annotated = 1;
3922 done:
3923 	errcode = pthread_mutex_unlock(&tog_mutex);
3924 	if (errcode)
3925 		err = got_error_set_errno(errcode, "pthread_mutex_unlock");
3926 	return err;
3927 }
3928 
3929 static void *
3930 blame_thread(void *arg)
3931 {
3932 	const struct got_error *err;
3933 	struct tog_blame_thread_args *ta = arg;
3934 	struct tog_blame_cb_args *a = ta->cb_args;
3935 	int errcode;
3936 
3937 	err = block_signals_used_by_main_thread();
3938 	if (err)
3939 		return (void *)err;
3940 
3941 	err = got_blame(ta->path, a->commit_id, ta->repo,
3942 	    blame_cb, ta->cb_args, ta->cancel_cb, ta->cancel_arg);
3943 	if (err && err->code == GOT_ERR_CANCELLED)
3944 		err = NULL;
3945 
3946 	errcode = pthread_mutex_lock(&tog_mutex);
3947 	if (errcode)
3948 		return (void *)got_error_set_errno(errcode,
3949 		    "pthread_mutex_lock");
3950 
3951 	got_repo_close(ta->repo);
3952 	ta->repo = NULL;
3953 	*ta->complete = 1;
3954 
3955 	errcode = pthread_mutex_unlock(&tog_mutex);
3956 	if (errcode && err == NULL)
3957 		err = got_error_set_errno(errcode, "pthread_mutex_unlock");
3958 
3959 	return (void *)err;
3960 }
3961 
3962 static struct got_object_id *
3963 get_selected_commit_id(struct tog_blame_line *lines, int nlines,
3964     int first_displayed_line, int selected_line)
3965 {
3966 	struct tog_blame_line *line;
3967 
3968 	if (nlines <= 0)
3969 		return NULL;
3970 
3971 	line = &lines[first_displayed_line - 1 + selected_line - 1];
3972 	if (!line->annotated)
3973 		return NULL;
3974 
3975 	return line->id;
3976 }
3977 
3978 static const struct got_error *
3979 stop_blame(struct tog_blame *blame)
3980 {
3981 	const struct got_error *err = NULL;
3982 	int i;
3983 
3984 	if (blame->thread) {
3985 		int errcode;
3986 		errcode = pthread_mutex_unlock(&tog_mutex);
3987 		if (errcode)
3988 			return got_error_set_errno(errcode,
3989 			    "pthread_mutex_unlock");
3990 		errcode = pthread_join(blame->thread, (void **)&err);
3991 		if (errcode)
3992 			return got_error_set_errno(errcode, "pthread_join");
3993 		errcode = pthread_mutex_lock(&tog_mutex);
3994 		if (errcode)
3995 			return got_error_set_errno(errcode,
3996 			    "pthread_mutex_lock");
3997 		if (err && err->code == GOT_ERR_ITER_COMPLETED)
3998 			err = NULL;
3999 		blame->thread = NULL;
4000 	}
4001 	if (blame->thread_args.repo) {
4002 		got_repo_close(blame->thread_args.repo);
4003 		blame->thread_args.repo = NULL;
4004 	}
4005 	if (blame->f) {
4006 		if (fclose(blame->f) != 0 && err == NULL)
4007 			err = got_error_from_errno("fclose");
4008 		blame->f = NULL;
4009 	}
4010 	if (blame->lines) {
4011 		for (i = 0; i < blame->nlines; i++)
4012 			free(blame->lines[i].id);
4013 		free(blame->lines);
4014 		blame->lines = NULL;
4015 	}
4016 	free(blame->cb_args.commit_id);
4017 	blame->cb_args.commit_id = NULL;
4018 
4019 	return err;
4020 }
4021 
4022 static const struct got_error *
4023 cancel_blame_view(void *arg)
4024 {
4025 	const struct got_error *err = NULL;
4026 	int *done = arg;
4027 	int errcode;
4028 
4029 	errcode = pthread_mutex_lock(&tog_mutex);
4030 	if (errcode)
4031 		return got_error_set_errno(errcode,
4032 		    "pthread_mutex_unlock");
4033 
4034 	if (*done)
4035 		err = got_error(GOT_ERR_CANCELLED);
4036 
4037 	errcode = pthread_mutex_unlock(&tog_mutex);
4038 	if (errcode)
4039 		return got_error_set_errno(errcode,
4040 		    "pthread_mutex_lock");
4041 
4042 	return err;
4043 }
4044 
4045 static const struct got_error *
4046 run_blame(struct tog_blame *blame, struct tog_view *view, int *blame_complete,
4047     int *first_displayed_line, int *last_displayed_line, int *selected_line,
4048     int *done, int *eof, const char *path, struct got_object_id *commit_id,
4049     struct got_repository *repo)
4050 {
4051 	const struct got_error *err = NULL;
4052 	struct got_blob_object *blob = NULL;
4053 	struct got_repository *thread_repo = NULL;
4054 	struct got_object_id *obj_id = NULL;
4055 	int obj_type;
4056 
4057 	err = got_object_id_by_path(&obj_id, repo, commit_id, path);
4058 	if (err)
4059 		return err;
4060 
4061 	err = got_object_get_type(&obj_type, repo, obj_id);
4062 	if (err)
4063 		goto done;
4064 
4065 	if (obj_type != GOT_OBJ_TYPE_BLOB) {
4066 		err = got_error(GOT_ERR_OBJ_TYPE);
4067 		goto done;
4068 	}
4069 
4070 	err = got_object_open_as_blob(&blob, repo, obj_id, 8192);
4071 	if (err)
4072 		goto done;
4073 	blame->f = got_opentemp();
4074 	if (blame->f == NULL) {
4075 		err = got_error_from_errno("got_opentemp");
4076 		goto done;
4077 	}
4078 	err = got_object_blob_dump_to_file(&blame->filesize, &blame->nlines,
4079 	    &blame->line_offsets, blame->f, blob);
4080 	if (err || blame->nlines == 0)
4081 		goto done;
4082 
4083 	/* Don't include \n at EOF in the blame line count. */
4084 	if (blame->line_offsets[blame->nlines - 1] == blame->filesize)
4085 		blame->nlines--;
4086 
4087 	blame->lines = calloc(blame->nlines, sizeof(*blame->lines));
4088 	if (blame->lines == NULL) {
4089 		err = got_error_from_errno("calloc");
4090 		goto done;
4091 	}
4092 
4093 	err = got_repo_open(&thread_repo, got_repo_get_path(repo), NULL);
4094 	if (err)
4095 		goto done;
4096 
4097 	blame->cb_args.view = view;
4098 	blame->cb_args.lines = blame->lines;
4099 	blame->cb_args.nlines = blame->nlines;
4100 	blame->cb_args.commit_id = got_object_id_dup(commit_id);
4101 	if (blame->cb_args.commit_id == NULL) {
4102 		err = got_error_from_errno("got_object_id_dup");
4103 		goto done;
4104 	}
4105 	blame->cb_args.quit = done;
4106 
4107 	blame->thread_args.path = path;
4108 	blame->thread_args.repo = thread_repo;
4109 	blame->thread_args.cb_args = &blame->cb_args;
4110 	blame->thread_args.complete = blame_complete;
4111 	blame->thread_args.cancel_cb = cancel_blame_view;
4112 	blame->thread_args.cancel_arg = done;
4113 	*blame_complete = 0;
4114 
4115 done:
4116 	if (blob)
4117 		got_object_blob_close(blob);
4118 	free(obj_id);
4119 	if (err)
4120 		stop_blame(blame);
4121 	return err;
4122 }
4123 
4124 static const struct got_error *
4125 open_blame_view(struct tog_view *view, char *path,
4126     struct got_object_id *commit_id, struct got_reflist_head *refs,
4127     struct got_repository *repo)
4128 {
4129 	const struct got_error *err = NULL;
4130 	struct tog_blame_view_state *s = &view->state.blame;
4131 
4132 	SIMPLEQ_INIT(&s->blamed_commits);
4133 
4134 	s->path = strdup(path);
4135 	if (s->path == NULL)
4136 		return got_error_from_errno("strdup");
4137 
4138 	err = got_object_qid_alloc(&s->blamed_commit, commit_id);
4139 	if (err) {
4140 		free(s->path);
4141 		return err;
4142 	}
4143 
4144 	SIMPLEQ_INSERT_HEAD(&s->blamed_commits, s->blamed_commit, entry);
4145 	s->first_displayed_line = 1;
4146 	s->last_displayed_line = view->nlines;
4147 	s->selected_line = 1;
4148 	s->blame_complete = 0;
4149 	s->repo = repo;
4150 	s->refs = refs;
4151 	s->commit_id = commit_id;
4152 	memset(&s->blame, 0, sizeof(s->blame));
4153 
4154 	SIMPLEQ_INIT(&s->colors);
4155 	if (has_colors() && getenv("TOG_COLORS") != NULL) {
4156 		err = add_color(&s->colors, "^", TOG_COLOR_COMMIT,
4157 		    get_color_value("TOG_COLOR_COMMIT"));
4158 		if (err)
4159 			return err;
4160 	}
4161 
4162 	view->show = show_blame_view;
4163 	view->input = input_blame_view;
4164 	view->close = close_blame_view;
4165 	view->search_start = search_start_blame_view;
4166 	view->search_next = search_next_blame_view;
4167 
4168 	return run_blame(&s->blame, view, &s->blame_complete,
4169 	    &s->first_displayed_line, &s->last_displayed_line,
4170 	    &s->selected_line, &s->done, &s->eof, s->path,
4171 	    s->blamed_commit->id, s->repo);
4172 }
4173 
4174 static const struct got_error *
4175 close_blame_view(struct tog_view *view)
4176 {
4177 	const struct got_error *err = NULL;
4178 	struct tog_blame_view_state *s = &view->state.blame;
4179 
4180 	if (s->blame.thread)
4181 		err = stop_blame(&s->blame);
4182 
4183 	while (!SIMPLEQ_EMPTY(&s->blamed_commits)) {
4184 		struct got_object_qid *blamed_commit;
4185 		blamed_commit = SIMPLEQ_FIRST(&s->blamed_commits);
4186 		SIMPLEQ_REMOVE_HEAD(&s->blamed_commits, entry);
4187 		got_object_qid_free(blamed_commit);
4188 	}
4189 
4190 	free(s->path);
4191 	free_colors(&s->colors);
4192 
4193 	return err;
4194 }
4195 
4196 static const struct got_error *
4197 search_start_blame_view(struct tog_view *view)
4198 {
4199 	struct tog_blame_view_state *s = &view->state.blame;
4200 
4201 	s->matched_line = 0;
4202 	return NULL;
4203 }
4204 
4205 static const struct got_error *
4206 search_next_blame_view(struct tog_view *view)
4207 {
4208 	struct tog_blame_view_state *s = &view->state.blame;
4209 	int lineno;
4210 
4211 	if (!view->searching) {
4212 		view->search_next_done = TOG_SEARCH_HAVE_MORE;
4213 		return NULL;
4214 	}
4215 
4216 	if (s->matched_line) {
4217 		if (view->searching == TOG_SEARCH_FORWARD)
4218 			lineno = s->matched_line + 1;
4219 		else
4220 			lineno = s->matched_line - 1;
4221 	} else {
4222 		if (view->searching == TOG_SEARCH_FORWARD)
4223 			lineno = 1;
4224 		else
4225 			lineno = s->blame.nlines;
4226 	}
4227 
4228 	while (1) {
4229 		char *line = NULL;
4230 		off_t offset;
4231 		size_t len;
4232 
4233 		if (lineno <= 0 || lineno > s->blame.nlines) {
4234 			if (s->matched_line == 0) {
4235 				view->search_next_done = TOG_SEARCH_HAVE_MORE;
4236 				free(line);
4237 				break;
4238 			}
4239 
4240 			if (view->searching == TOG_SEARCH_FORWARD)
4241 				lineno = 1;
4242 			else
4243 				lineno = s->blame.nlines;
4244 		}
4245 
4246 		offset = s->blame.line_offsets[lineno - 1];
4247 		if (fseeko(s->blame.f, offset, SEEK_SET) != 0) {
4248 			free(line);
4249 			return got_error_from_errno("fseeko");
4250 		}
4251 		free(line);
4252 		line = parse_next_line(s->blame.f, &len);
4253 		if (line && match_line(line, &view->regex)) {
4254 			view->search_next_done = TOG_SEARCH_HAVE_MORE;
4255 			s->matched_line = lineno;
4256 			free(line);
4257 			break;
4258 		}
4259 		free(line);
4260 		if (view->searching == TOG_SEARCH_FORWARD)
4261 			lineno++;
4262 		else
4263 			lineno--;
4264 	}
4265 
4266 	if (s->matched_line) {
4267 		s->first_displayed_line = s->matched_line;
4268 		s->selected_line = 1;
4269 	}
4270 
4271 	return NULL;
4272 }
4273 
4274 static const struct got_error *
4275 show_blame_view(struct tog_view *view)
4276 {
4277 	const struct got_error *err = NULL;
4278 	struct tog_blame_view_state *s = &view->state.blame;
4279 	int errcode;
4280 
4281 	if (s->blame.thread == NULL) {
4282 		errcode = pthread_create(&s->blame.thread, NULL, blame_thread,
4283 		    &s->blame.thread_args);
4284 		if (errcode)
4285 			return got_error_set_errno(errcode, "pthread_create");
4286 
4287 		halfdelay(1); /* fast refresh while annotating  */
4288 	}
4289 
4290 	if (s->blame_complete)
4291 		halfdelay(10); /* disable fast refresh */
4292 
4293 	err = draw_blame(view, s->blamed_commit->id, s->blame.f,
4294 	    s->path, s->blame.lines, s->blame.nlines, s->blame_complete,
4295 	    s->selected_line, &s->first_displayed_line,
4296 	    &s->last_displayed_line, &s->eof, view->nlines, &s->colors);
4297 
4298 	view_vborder(view);
4299 	return err;
4300 }
4301 
4302 static const struct got_error *
4303 input_blame_view(struct tog_view **new_view, struct tog_view **dead_view,
4304     struct tog_view **focus_view, struct tog_view *view, int ch)
4305 {
4306 	const struct got_error *err = NULL, *thread_err = NULL;
4307 	struct tog_view *diff_view;
4308 	struct tog_blame_view_state *s = &view->state.blame;
4309 	int begin_x = 0;
4310 
4311 	switch (ch) {
4312 	case 'q':
4313 		s->done = 1;
4314 		break;
4315 	case 'k':
4316 	case KEY_UP:
4317 		if (s->selected_line > 1)
4318 			s->selected_line--;
4319 		else if (s->selected_line == 1 &&
4320 		    s->first_displayed_line > 1)
4321 			s->first_displayed_line--;
4322 		break;
4323 	case KEY_PPAGE:
4324 	case CTRL('b'):
4325 		if (s->first_displayed_line == 1) {
4326 			s->selected_line = 1;
4327 			break;
4328 		}
4329 		if (s->first_displayed_line > view->nlines - 2)
4330 			s->first_displayed_line -=
4331 			    (view->nlines - 2);
4332 		else
4333 			s->first_displayed_line = 1;
4334 		break;
4335 	case 'j':
4336 	case KEY_DOWN:
4337 		if (s->selected_line < view->nlines - 2 &&
4338 		    s->first_displayed_line +
4339 		    s->selected_line <= s->blame.nlines)
4340 			s->selected_line++;
4341 		else if (s->last_displayed_line <
4342 		    s->blame.nlines)
4343 			s->first_displayed_line++;
4344 		break;
4345 	case 'b':
4346 	case 'p': {
4347 		struct got_object_id *id = NULL;
4348 		id = get_selected_commit_id(s->blame.lines, s->blame.nlines,
4349 		    s->first_displayed_line, s->selected_line);
4350 		if (id == NULL)
4351 			break;
4352 		if (ch == 'p') {
4353 			struct got_commit_object *commit;
4354 			struct got_object_qid *pid;
4355 			struct got_object_id *blob_id = NULL;
4356 			int obj_type;
4357 			err = got_object_open_as_commit(&commit,
4358 			    s->repo, id);
4359 			if (err)
4360 				break;
4361 			pid = SIMPLEQ_FIRST(
4362 			    got_object_commit_get_parent_ids(commit));
4363 			if (pid == NULL) {
4364 				got_object_commit_close(commit);
4365 				break;
4366 			}
4367 			/* Check if path history ends here. */
4368 			err = got_object_id_by_path(&blob_id, s->repo,
4369 			    pid->id, s->path);
4370 			if (err) {
4371 				if (err->code == GOT_ERR_NO_TREE_ENTRY)
4372 					err = NULL;
4373 				got_object_commit_close(commit);
4374 				break;
4375 			}
4376 			err = got_object_get_type(&obj_type, s->repo,
4377 			    blob_id);
4378 			free(blob_id);
4379 			/* Can't blame non-blob type objects. */
4380 			if (obj_type != GOT_OBJ_TYPE_BLOB) {
4381 				got_object_commit_close(commit);
4382 				break;
4383 			}
4384 			err = got_object_qid_alloc(&s->blamed_commit,
4385 			    pid->id);
4386 			got_object_commit_close(commit);
4387 		} else {
4388 			if (got_object_id_cmp(id,
4389 			    s->blamed_commit->id) == 0)
4390 				break;
4391 			err = got_object_qid_alloc(&s->blamed_commit,
4392 			    id);
4393 		}
4394 		if (err)
4395 			break;
4396 		s->done = 1;
4397 		thread_err = stop_blame(&s->blame);
4398 		s->done = 0;
4399 		if (thread_err)
4400 			break;
4401 		SIMPLEQ_INSERT_HEAD(&s->blamed_commits,
4402 		    s->blamed_commit, entry);
4403 		err = run_blame(&s->blame, view, &s->blame_complete,
4404 		    &s->first_displayed_line, &s->last_displayed_line,
4405 		    &s->selected_line, &s->done, &s->eof,
4406 		    s->path, s->blamed_commit->id, s->repo);
4407 		if (err)
4408 			break;
4409 		break;
4410 	}
4411 	case 'B': {
4412 		struct got_object_qid *first;
4413 		first = SIMPLEQ_FIRST(&s->blamed_commits);
4414 		if (!got_object_id_cmp(first->id, s->commit_id))
4415 			break;
4416 		s->done = 1;
4417 		thread_err = stop_blame(&s->blame);
4418 		s->done = 0;
4419 		if (thread_err)
4420 			break;
4421 		SIMPLEQ_REMOVE_HEAD(&s->blamed_commits, entry);
4422 		got_object_qid_free(s->blamed_commit);
4423 		s->blamed_commit =
4424 		    SIMPLEQ_FIRST(&s->blamed_commits);
4425 		err = run_blame(&s->blame, view, &s->blame_complete,
4426 		    &s->first_displayed_line, &s->last_displayed_line,
4427 		    &s->selected_line, &s->done, &s->eof, s->path,
4428 		    s->blamed_commit->id, s->repo);
4429 		if (err)
4430 			break;
4431 		break;
4432 	}
4433 	case KEY_ENTER:
4434 	case '\r': {
4435 		struct got_object_id *id = NULL;
4436 		struct got_object_qid *pid;
4437 		struct got_commit_object *commit = NULL;
4438 		id = get_selected_commit_id(s->blame.lines, s->blame.nlines,
4439 		    s->first_displayed_line, s->selected_line);
4440 		if (id == NULL)
4441 			break;
4442 		err = got_object_open_as_commit(&commit, s->repo, id);
4443 		if (err)
4444 			break;
4445 		pid = SIMPLEQ_FIRST(
4446 		    got_object_commit_get_parent_ids(commit));
4447 		if (view_is_parent_view(view))
4448 		    begin_x = view_split_begin_x(view->begin_x);
4449 		diff_view = view_open(0, 0, 0, begin_x, TOG_VIEW_DIFF);
4450 		if (diff_view == NULL) {
4451 			got_object_commit_close(commit);
4452 			err = got_error_from_errno("view_open");
4453 			break;
4454 		}
4455 		err = open_diff_view(diff_view, pid ? pid->id : NULL,
4456 		    id, NULL, s->refs, s->repo);
4457 		got_object_commit_close(commit);
4458 		if (err) {
4459 			view_close(diff_view);
4460 			break;
4461 		}
4462 		if (view_is_parent_view(view)) {
4463 			err = view_close_child(view);
4464 			if (err)
4465 				break;
4466 			err = view_set_child(view, diff_view);
4467 			if (err) {
4468 				view_close(diff_view);
4469 				break;
4470 			}
4471 			*focus_view = diff_view;
4472 			view->child_focussed = 1;
4473 		} else
4474 			*new_view = diff_view;
4475 		if (err)
4476 			break;
4477 		break;
4478 	}
4479 	case KEY_NPAGE:
4480 	case CTRL('f'):
4481 	case ' ':
4482 		if (s->last_displayed_line >= s->blame.nlines &&
4483 		    s->selected_line >= MIN(s->blame.nlines,
4484 		    view->nlines - 2)) {
4485 			break;
4486 		}
4487 		if (s->last_displayed_line >= s->blame.nlines &&
4488 		    s->selected_line < view->nlines - 2) {
4489 			s->selected_line = MIN(s->blame.nlines,
4490 			    view->nlines - 2);
4491 			break;
4492 		}
4493 		if (s->last_displayed_line + view->nlines - 2
4494 		    <= s->blame.nlines)
4495 			s->first_displayed_line +=
4496 			    view->nlines - 2;
4497 		else
4498 			s->first_displayed_line =
4499 			    s->blame.nlines -
4500 			    (view->nlines - 3);
4501 		break;
4502 	case KEY_RESIZE:
4503 		if (s->selected_line > view->nlines - 2) {
4504 			s->selected_line = MIN(s->blame.nlines,
4505 			    view->nlines - 2);
4506 		}
4507 		break;
4508 	default:
4509 		break;
4510 	}
4511 	return thread_err ? thread_err : err;
4512 }
4513 
4514 static const struct got_error *
4515 cmd_blame(int argc, char *argv[])
4516 {
4517 	const struct got_error *error;
4518 	struct got_repository *repo = NULL;
4519 	struct got_reflist_head refs;
4520 	struct got_worktree *worktree = NULL;
4521 	char *cwd = NULL, *repo_path = NULL, *in_repo_path = NULL;
4522 	char *link_target = NULL;
4523 	struct got_object_id *commit_id = NULL;
4524 	char *commit_id_str = NULL;
4525 	int ch;
4526 	struct tog_view *view;
4527 
4528 	SIMPLEQ_INIT(&refs);
4529 
4530 #ifndef PROFILE
4531 	if (pledge("stdio rpath wpath cpath flock proc tty exec sendfd unveil",
4532 	    NULL) == -1)
4533 		err(1, "pledge");
4534 #endif
4535 
4536 	while ((ch = getopt(argc, argv, "c:r:")) != -1) {
4537 		switch (ch) {
4538 		case 'c':
4539 			commit_id_str = optarg;
4540 			break;
4541 		case 'r':
4542 			repo_path = realpath(optarg, NULL);
4543 			if (repo_path == NULL)
4544 				return got_error_from_errno2("realpath",
4545 				    optarg);
4546 			break;
4547 		default:
4548 			usage_blame();
4549 			/* NOTREACHED */
4550 		}
4551 	}
4552 
4553 	argc -= optind;
4554 	argv += optind;
4555 
4556 	if (argc != 1)
4557 		usage_blame();
4558 
4559 	cwd = getcwd(NULL, 0);
4560 	if (cwd == NULL)
4561 		return got_error_from_errno("getcwd");
4562 
4563 	error = got_worktree_open(&worktree, cwd);
4564 	if (error && error->code != GOT_ERR_NOT_WORKTREE)
4565 		goto done;
4566 
4567 	if (repo_path == NULL) {
4568 		if (worktree)
4569 			repo_path =
4570 			    strdup(got_worktree_get_repo_path(worktree));
4571 		else
4572 			repo_path = strdup(cwd);
4573 	}
4574 	if (repo_path == NULL) {
4575 		error = got_error_from_errno("strdup");
4576 		goto done;
4577 	}
4578 
4579 	error = got_repo_open(&repo, repo_path, NULL);
4580 	if (error != NULL)
4581 		goto done;
4582 
4583 	error = get_in_repo_path_from_argv0(&in_repo_path, argc, argv, repo,
4584 	    worktree);
4585 	if (error)
4586 		goto done;
4587 
4588 	init_curses();
4589 
4590 	error = apply_unveil(got_repo_get_path(repo), NULL);
4591 	if (error)
4592 		goto done;
4593 
4594 	if (commit_id_str == NULL) {
4595 		struct got_reference *head_ref;
4596 		error = got_ref_open(&head_ref, repo, worktree ?
4597 		    got_worktree_get_head_ref_name(worktree) : GOT_REF_HEAD, 0);
4598 		if (error != NULL)
4599 			goto done;
4600 		error = got_ref_resolve(&commit_id, repo, head_ref);
4601 		got_ref_close(head_ref);
4602 	} else {
4603 		error = got_repo_match_object_id(&commit_id, NULL,
4604 		    commit_id_str, GOT_OBJ_TYPE_COMMIT, 1, repo);
4605 	}
4606 	if (error != NULL)
4607 		goto done;
4608 
4609 	error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
4610 	if (error)
4611 		goto done;
4612 
4613 	view = view_open(0, 0, 0, 0, TOG_VIEW_BLAME);
4614 	if (view == NULL) {
4615 		error = got_error_from_errno("view_open");
4616 		goto done;
4617 	}
4618 
4619 	error = got_object_resolve_symlinks(&link_target, in_repo_path,
4620 	    commit_id, repo);
4621 	if (error)
4622 		goto done;
4623 
4624 	error = open_blame_view(view, link_target ? link_target : in_repo_path,
4625 	    commit_id, &refs, repo);
4626 	if (error)
4627 		goto done;
4628 	if (worktree) {
4629 		/* Release work tree lock. */
4630 		got_worktree_close(worktree);
4631 		worktree = NULL;
4632 	}
4633 	error = view_loop(view);
4634 done:
4635 	free(repo_path);
4636 	free(in_repo_path);
4637 	free(link_target);
4638 	free(cwd);
4639 	free(commit_id);
4640 	if (worktree)
4641 		got_worktree_close(worktree);
4642 	if (repo)
4643 		got_repo_close(repo);
4644 	got_ref_list_free(&refs);
4645 	return error;
4646 }
4647 
4648 static const struct got_error *
4649 draw_tree_entries(struct tog_view *view,
4650     struct got_tree_entry **first_displayed_entry,
4651     struct got_tree_entry **last_displayed_entry,
4652     struct got_tree_entry **selected_entry, int *ndisplayed,
4653     const char *label, int show_ids, const char *parent_path,
4654     struct got_tree_object *tree, int selected, int limit,
4655     int isroot, struct tog_colors *colors, struct got_repository *repo)
4656 {
4657 	const struct got_error *err = NULL;
4658 	struct got_tree_entry *te;
4659 	wchar_t *wline;
4660 	struct tog_color *tc;
4661 	int width, n, i, nentries;
4662 
4663 	*ndisplayed = 0;
4664 
4665 	werase(view->window);
4666 
4667 	if (limit == 0)
4668 		return NULL;
4669 
4670 	err = format_line(&wline, &width, label, view->ncols, 0);
4671 	if (err)
4672 		return err;
4673 	if (view_needs_focus_indication(view))
4674 		wstandout(view->window);
4675 	tc = get_color(colors, TOG_COLOR_COMMIT);
4676 	if (tc)
4677 		wattr_on(view->window,
4678 		    COLOR_PAIR(tc->colorpair), NULL);
4679 	waddwstr(view->window, wline);
4680 	if (tc)
4681 		wattr_off(view->window,
4682 		    COLOR_PAIR(tc->colorpair), NULL);
4683 	if (view_needs_focus_indication(view))
4684 		wstandend(view->window);
4685 	free(wline);
4686 	wline = NULL;
4687 	if (width < view->ncols - 1)
4688 		waddch(view->window, '\n');
4689 	if (--limit <= 0)
4690 		return NULL;
4691 	err = format_line(&wline, &width, parent_path, view->ncols, 0);
4692 	if (err)
4693 		return err;
4694 	waddwstr(view->window, wline);
4695 	free(wline);
4696 	wline = NULL;
4697 	if (width < view->ncols - 1)
4698 		waddch(view->window, '\n');
4699 	if (--limit <= 0)
4700 		return NULL;
4701 	waddch(view->window, '\n');
4702 	if (--limit <= 0)
4703 		return NULL;
4704 
4705 	if (*first_displayed_entry == NULL) {
4706 		te = got_object_tree_get_first_entry(tree);
4707 		if (selected == 0) {
4708 			if (view->focussed)
4709 				wstandout(view->window);
4710 			*selected_entry = NULL;
4711 		}
4712 		waddstr(view->window, "  ..\n");	/* parent directory */
4713 		if (selected == 0 && view->focussed)
4714 			wstandend(view->window);
4715 		(*ndisplayed)++;
4716 		if (--limit <= 0)
4717 			return NULL;
4718 		n = 1;
4719 	} else {
4720 		n = 0;
4721 		te = *first_displayed_entry;
4722 	}
4723 
4724 	nentries = got_object_tree_get_nentries(tree);
4725 	for (i = got_tree_entry_get_index(te); i < nentries; i++) {
4726 		char *line = NULL, *id_str = NULL, *link_target = NULL;
4727 		const char *modestr = "";
4728 		mode_t mode;
4729 
4730 		te = got_object_tree_get_entry(tree, i);
4731 		mode = got_tree_entry_get_mode(te);
4732 
4733 		if (show_ids) {
4734 			err = got_object_id_str(&id_str,
4735 			    got_tree_entry_get_id(te));
4736 			if (err)
4737 				return got_error_from_errno(
4738 				    "got_object_id_str");
4739 		}
4740 		if (got_object_tree_entry_is_submodule(te))
4741 			modestr = "$";
4742 		else if (S_ISLNK(mode)) {
4743 			int i;
4744 
4745 			err = got_tree_entry_get_symlink_target(&link_target,
4746 			    te, repo);
4747 			if (err) {
4748 				free(id_str);
4749 				return err;
4750 			}
4751 			for (i = 0; i < strlen(link_target); i++) {
4752 				if (!isprint((unsigned char)link_target[i]))
4753 					link_target[i] = '?';
4754 			}
4755 			modestr = "@";
4756 		}
4757 		else if (S_ISDIR(mode))
4758 			modestr = "/";
4759 		else if (mode & S_IXUSR)
4760 			modestr = "*";
4761 		if (asprintf(&line, "%s  %s%s%s%s", id_str ? id_str : "",
4762 		    got_tree_entry_get_name(te), modestr,
4763 		    link_target ? " -> ": "",
4764 		    link_target ? link_target : "") == -1) {
4765 			free(id_str);
4766 			free(link_target);
4767 			return got_error_from_errno("asprintf");
4768 		}
4769 		free(id_str);
4770 		free(link_target);
4771 		err = format_line(&wline, &width, line, view->ncols, 0);
4772 		if (err) {
4773 			free(line);
4774 			break;
4775 		}
4776 		if (n == selected) {
4777 			if (view->focussed)
4778 				wstandout(view->window);
4779 			*selected_entry = te;
4780 		}
4781 		tc = match_color(colors, line);
4782 		if (tc)
4783 			wattr_on(view->window,
4784 			    COLOR_PAIR(tc->colorpair), NULL);
4785 		waddwstr(view->window, wline);
4786 		if (tc)
4787 			wattr_off(view->window,
4788 			    COLOR_PAIR(tc->colorpair), NULL);
4789 		if (width < view->ncols - 1)
4790 			waddch(view->window, '\n');
4791 		if (n == selected && view->focussed)
4792 			wstandend(view->window);
4793 		free(line);
4794 		free(wline);
4795 		wline = NULL;
4796 		n++;
4797 		(*ndisplayed)++;
4798 		*last_displayed_entry = te;
4799 		if (--limit <= 0)
4800 			break;
4801 	}
4802 
4803 	return err;
4804 }
4805 
4806 static void
4807 tree_scroll_up(struct tog_view *view,
4808     struct got_tree_entry **first_displayed_entry, int maxscroll,
4809     struct got_tree_object *tree, int isroot)
4810 {
4811 	struct got_tree_entry *te;
4812 	int i;
4813 
4814 	if (*first_displayed_entry == NULL)
4815 		return;
4816 
4817 	te = got_object_tree_get_entry(tree, 0);
4818 	if (*first_displayed_entry == te) {
4819 		if (!isroot)
4820 			*first_displayed_entry = NULL;
4821 		return;
4822 	}
4823 
4824 	i = 0;
4825 	while (*first_displayed_entry && i < maxscroll) {
4826 		*first_displayed_entry = got_tree_entry_get_prev(tree,
4827 		    *first_displayed_entry);
4828 		i++;
4829 	}
4830 	if (!isroot && te == got_object_tree_get_first_entry(tree) && i < maxscroll)
4831 		*first_displayed_entry = NULL;
4832 }
4833 
4834 static int
4835 tree_scroll_down(struct got_tree_entry **first_displayed_entry, int maxscroll,
4836 	struct got_tree_entry *last_displayed_entry,
4837 	struct got_tree_object *tree)
4838 {
4839 	struct got_tree_entry *next, *last;
4840 	int n = 0;
4841 
4842 	if (*first_displayed_entry)
4843 		next = got_tree_entry_get_next(tree, *first_displayed_entry);
4844 	else
4845 		next = got_object_tree_get_first_entry(tree);
4846 
4847 	last = last_displayed_entry;
4848 	while (next && last && n++ < maxscroll) {
4849 		last = got_tree_entry_get_next(tree, last);
4850 		if (last) {
4851 			*first_displayed_entry = next;
4852 			next = got_tree_entry_get_next(tree, next);
4853 		}
4854 	}
4855 	return n;
4856 }
4857 
4858 static const struct got_error *
4859 tree_entry_path(char **path, struct tog_parent_trees *parents,
4860     struct got_tree_entry *te)
4861 {
4862 	const struct got_error *err = NULL;
4863 	struct tog_parent_tree *pt;
4864 	size_t len = 2; /* for leading slash and NUL */
4865 
4866 	TAILQ_FOREACH(pt, parents, entry)
4867 		len += strlen(got_tree_entry_get_name(pt->selected_entry))
4868 		    + 1 /* slash */;
4869 	if (te)
4870 		len += strlen(got_tree_entry_get_name(te));
4871 
4872 	*path = calloc(1, len);
4873 	if (path == NULL)
4874 		return got_error_from_errno("calloc");
4875 
4876 	(*path)[0] = '/';
4877 	pt = TAILQ_LAST(parents, tog_parent_trees);
4878 	while (pt) {
4879 		const char *name = got_tree_entry_get_name(pt->selected_entry);
4880 		if (strlcat(*path, name, len) >= len) {
4881 			err = got_error(GOT_ERR_NO_SPACE);
4882 			goto done;
4883 		}
4884 		if (strlcat(*path, "/", len) >= len) {
4885 			err = got_error(GOT_ERR_NO_SPACE);
4886 			goto done;
4887 		}
4888 		pt = TAILQ_PREV(pt, tog_parent_trees, entry);
4889 	}
4890 	if (te) {
4891 		if (strlcat(*path, got_tree_entry_get_name(te), len) >= len) {
4892 			err = got_error(GOT_ERR_NO_SPACE);
4893 			goto done;
4894 		}
4895 	}
4896 done:
4897 	if (err) {
4898 		free(*path);
4899 		*path = NULL;
4900 	}
4901 	return err;
4902 }
4903 
4904 static const struct got_error *
4905 blame_tree_entry(struct tog_view **new_view, int begin_x,
4906     struct got_tree_entry *te, struct tog_parent_trees *parents,
4907     struct got_object_id *commit_id, struct got_reflist_head *refs,
4908     struct got_repository *repo)
4909 {
4910 	const struct got_error *err = NULL;
4911 	char *path;
4912 	struct tog_view *blame_view;
4913 
4914 	*new_view = NULL;
4915 
4916 	err = tree_entry_path(&path, parents, te);
4917 	if (err)
4918 		return err;
4919 
4920 	blame_view = view_open(0, 0, 0, begin_x, TOG_VIEW_BLAME);
4921 	if (blame_view == NULL) {
4922 		err = got_error_from_errno("view_open");
4923 		goto done;
4924 	}
4925 
4926 	err = open_blame_view(blame_view, path, commit_id, refs, repo);
4927 	if (err) {
4928 		if (err->code == GOT_ERR_CANCELLED)
4929 			err = NULL;
4930 		view_close(blame_view);
4931 	} else
4932 		*new_view = blame_view;
4933 done:
4934 	free(path);
4935 	return err;
4936 }
4937 
4938 static const struct got_error *
4939 log_tree_entry(struct tog_view **new_view, int begin_x,
4940     struct got_tree_entry *te, struct tog_parent_trees *parents,
4941     struct got_object_id *commit_id, struct got_reflist_head *refs,
4942     struct got_repository *repo)
4943 {
4944 	struct tog_view *log_view;
4945 	const struct got_error *err = NULL;
4946 	char *path;
4947 
4948 	*new_view = NULL;
4949 
4950 	log_view = view_open(0, 0, 0, begin_x, TOG_VIEW_LOG);
4951 	if (log_view == NULL)
4952 		return got_error_from_errno("view_open");
4953 
4954 	err = tree_entry_path(&path, parents, te);
4955 	if (err)
4956 		return err;
4957 
4958 	err = open_log_view(log_view, commit_id, refs, repo, NULL, path, 0);
4959 	if (err)
4960 		view_close(log_view);
4961 	else
4962 		*new_view = log_view;
4963 	free(path);
4964 	return err;
4965 }
4966 
4967 static const struct got_error *
4968 open_tree_view(struct tog_view *view, struct got_tree_object *root,
4969     struct got_object_id *commit_id, struct got_reflist_head *refs,
4970     struct got_repository *repo)
4971 {
4972 	const struct got_error *err = NULL;
4973 	char *commit_id_str = NULL;
4974 	struct tog_tree_view_state *s = &view->state.tree;
4975 
4976 	TAILQ_INIT(&s->parents);
4977 
4978 	err = got_object_id_str(&commit_id_str, commit_id);
4979 	if (err != NULL)
4980 		goto done;
4981 
4982 	if (asprintf(&s->tree_label, "commit %s", commit_id_str) == -1) {
4983 		err = got_error_from_errno("asprintf");
4984 		goto done;
4985 	}
4986 
4987 	s->root = s->tree = root;
4988 	s->first_displayed_entry = got_object_tree_get_entry(s->tree, 0);
4989 	s->selected_entry = got_object_tree_get_entry(s->tree, 0);
4990 	s->commit_id = got_object_id_dup(commit_id);
4991 	if (s->commit_id == NULL) {
4992 		err = got_error_from_errno("got_object_id_dup");
4993 		goto done;
4994 	}
4995 	s->refs = refs;
4996 	s->repo = repo;
4997 
4998 	SIMPLEQ_INIT(&s->colors);
4999 
5000 	if (has_colors() && getenv("TOG_COLORS") != NULL) {
5001 		err = add_color(&s->colors, "\\$$",
5002 		    TOG_COLOR_TREE_SUBMODULE,
5003 		    get_color_value("TOG_COLOR_TREE_SUBMODULE"));
5004 		if (err)
5005 			goto done;
5006 		err = add_color(&s->colors, "@$", TOG_COLOR_TREE_SYMLINK,
5007 		    get_color_value("TOG_COLOR_TREE_SYMLINK"));
5008 		if (err) {
5009 			free_colors(&s->colors);
5010 			goto done;
5011 		}
5012 		err = add_color(&s->colors, "/$",
5013 		    TOG_COLOR_TREE_DIRECTORY,
5014 		    get_color_value("TOG_COLOR_TREE_DIRECTORY"));
5015 		if (err) {
5016 			free_colors(&s->colors);
5017 			goto done;
5018 		}
5019 
5020 		err = add_color(&s->colors, "\\*$",
5021 		    TOG_COLOR_TREE_EXECUTABLE,
5022 		    get_color_value("TOG_COLOR_TREE_EXECUTABLE"));
5023 		if (err) {
5024 			free_colors(&s->colors);
5025 			goto done;
5026 		}
5027 
5028 		err = add_color(&s->colors, "^$", TOG_COLOR_COMMIT,
5029 		    get_color_value("TOG_COLOR_COMMIT"));
5030 		if (err) {
5031 			free_colors(&s->colors);
5032 			goto done;
5033 		}
5034 	}
5035 
5036 	view->show = show_tree_view;
5037 	view->input = input_tree_view;
5038 	view->close = close_tree_view;
5039 	view->search_start = search_start_tree_view;
5040 	view->search_next = search_next_tree_view;
5041 done:
5042 	free(commit_id_str);
5043 	if (err) {
5044 		free(s->tree_label);
5045 		s->tree_label = NULL;
5046 	}
5047 	return err;
5048 }
5049 
5050 static const struct got_error *
5051 close_tree_view(struct tog_view *view)
5052 {
5053 	struct tog_tree_view_state *s = &view->state.tree;
5054 
5055 	free_colors(&s->colors);
5056 	free(s->tree_label);
5057 	s->tree_label = NULL;
5058 	free(s->commit_id);
5059 	s->commit_id = NULL;
5060 	while (!TAILQ_EMPTY(&s->parents)) {
5061 		struct tog_parent_tree *parent;
5062 		parent = TAILQ_FIRST(&s->parents);
5063 		TAILQ_REMOVE(&s->parents, parent, entry);
5064 		free(parent);
5065 
5066 	}
5067 	if (s->tree != s->root)
5068 		got_object_tree_close(s->tree);
5069 	got_object_tree_close(s->root);
5070 
5071 	return NULL;
5072 }
5073 
5074 static const struct got_error *
5075 search_start_tree_view(struct tog_view *view)
5076 {
5077 	struct tog_tree_view_state *s = &view->state.tree;
5078 
5079 	s->matched_entry = NULL;
5080 	return NULL;
5081 }
5082 
5083 static int
5084 match_tree_entry(struct got_tree_entry *te, regex_t *regex)
5085 {
5086 	regmatch_t regmatch;
5087 
5088 	return regexec(regex, got_tree_entry_get_name(te), 1, &regmatch,
5089 	    0) == 0;
5090 }
5091 
5092 static const struct got_error *
5093 search_next_tree_view(struct tog_view *view)
5094 {
5095 	struct tog_tree_view_state *s = &view->state.tree;
5096 	struct got_tree_entry *te = NULL;
5097 
5098 	if (!view->searching) {
5099 		view->search_next_done = TOG_SEARCH_HAVE_MORE;
5100 		return NULL;
5101 	}
5102 
5103 	if (s->matched_entry) {
5104 		if (view->searching == TOG_SEARCH_FORWARD) {
5105 			if (s->selected_entry)
5106 				te = got_tree_entry_get_next(s->tree,
5107 				    s->selected_entry);
5108 			else
5109 				te = got_object_tree_get_first_entry(s->tree);
5110 		} else {
5111 			if (s->selected_entry == NULL)
5112 				te = got_object_tree_get_last_entry(s->tree);
5113 			else
5114 				te = got_tree_entry_get_prev(s->tree,
5115 				    s->selected_entry);
5116 		}
5117 	} else {
5118 		if (view->searching == TOG_SEARCH_FORWARD)
5119 			te = got_object_tree_get_first_entry(s->tree);
5120 		else
5121 			te = got_object_tree_get_last_entry(s->tree);
5122 	}
5123 
5124 	while (1) {
5125 		if (te == NULL) {
5126 			if (s->matched_entry == NULL) {
5127 				view->search_next_done = TOG_SEARCH_HAVE_MORE;
5128 				return NULL;
5129 			}
5130 			if (view->searching == TOG_SEARCH_FORWARD)
5131 				te = got_object_tree_get_first_entry(s->tree);
5132 			else
5133 				te = got_object_tree_get_last_entry(s->tree);
5134 		}
5135 
5136 		if (match_tree_entry(te, &view->regex)) {
5137 			view->search_next_done = TOG_SEARCH_HAVE_MORE;
5138 			s->matched_entry = te;
5139 			break;
5140 		}
5141 
5142 		if (view->searching == TOG_SEARCH_FORWARD)
5143 			te = got_tree_entry_get_next(s->tree, te);
5144 		else
5145 			te = got_tree_entry_get_prev(s->tree, te);
5146 	}
5147 
5148 	if (s->matched_entry) {
5149 		s->first_displayed_entry = s->matched_entry;
5150 		s->selected = 0;
5151 	}
5152 
5153 	return NULL;
5154 }
5155 
5156 static const struct got_error *
5157 show_tree_view(struct tog_view *view)
5158 {
5159 	const struct got_error *err = NULL;
5160 	struct tog_tree_view_state *s = &view->state.tree;
5161 	char *parent_path;
5162 
5163 	err = tree_entry_path(&parent_path, &s->parents, NULL);
5164 	if (err)
5165 		return err;
5166 
5167 	err = draw_tree_entries(view, &s->first_displayed_entry,
5168 	    &s->last_displayed_entry, &s->selected_entry,
5169 	    &s->ndisplayed, s->tree_label, s->show_ids, parent_path,
5170 	    s->tree, s->selected, view->nlines, s->tree == s->root,
5171 	    &s->colors, s->repo);
5172 	free(parent_path);
5173 
5174 	view_vborder(view);
5175 	return err;
5176 }
5177 
5178 static const struct got_error *
5179 input_tree_view(struct tog_view **new_view, struct tog_view **dead_view,
5180     struct tog_view **focus_view, struct tog_view *view, int ch)
5181 {
5182 	const struct got_error *err = NULL;
5183 	struct tog_tree_view_state *s = &view->state.tree;
5184 	struct tog_view *log_view;
5185 	int begin_x = 0, nscrolled;
5186 
5187 	switch (ch) {
5188 	case 'i':
5189 		s->show_ids = !s->show_ids;
5190 		break;
5191 	case 'l':
5192 		if (!s->selected_entry)
5193 			break;
5194 		if (view_is_parent_view(view))
5195 			begin_x = view_split_begin_x(view->begin_x);
5196 		err = log_tree_entry(&log_view, begin_x,
5197 		    s->selected_entry, &s->parents,
5198 		    s->commit_id, s->refs, s->repo);
5199 		if (view_is_parent_view(view)) {
5200 			err = view_close_child(view);
5201 			if (err)
5202 				return err;
5203 			err = view_set_child(view, log_view);
5204 			if (err) {
5205 				view_close(log_view);
5206 				break;
5207 			}
5208 			*focus_view = log_view;
5209 			view->child_focussed = 1;
5210 		} else
5211 			*new_view = log_view;
5212 		break;
5213 	case 'k':
5214 	case KEY_UP:
5215 		if (s->selected > 0) {
5216 			s->selected--;
5217 			if (s->selected == 0)
5218 				break;
5219 		}
5220 		if (s->selected > 0)
5221 			break;
5222 		tree_scroll_up(view, &s->first_displayed_entry, 1,
5223 		    s->tree, s->tree == s->root);
5224 		break;
5225 	case KEY_PPAGE:
5226 	case CTRL('b'):
5227 		tree_scroll_up(view, &s->first_displayed_entry,
5228 		    MAX(0, view->nlines - 4 - s->selected), s->tree,
5229 		    s->tree == s->root);
5230 		s->selected = 0;
5231 		if (got_object_tree_get_first_entry(s->tree) ==
5232 		    s->first_displayed_entry && s->tree != s->root)
5233 			s->first_displayed_entry = NULL;
5234 		break;
5235 	case 'j':
5236 	case KEY_DOWN:
5237 		if (s->selected < s->ndisplayed - 1) {
5238 			s->selected++;
5239 			break;
5240 		}
5241 		if (got_tree_entry_get_next(s->tree, s->last_displayed_entry)
5242 		    == NULL)
5243 			/* can't scroll any further */
5244 			break;
5245 		tree_scroll_down(&s->first_displayed_entry, 1,
5246 		    s->last_displayed_entry, s->tree);
5247 		break;
5248 	case KEY_NPAGE:
5249 	case CTRL('f'):
5250 		if (got_tree_entry_get_next(s->tree, s->last_displayed_entry)
5251 		    == NULL) {
5252 			/* can't scroll any further; move cursor down */
5253 			if (s->selected < s->ndisplayed - 1)
5254 				s->selected = s->ndisplayed - 1;
5255 			break;
5256 		}
5257 		nscrolled = tree_scroll_down(&s->first_displayed_entry,
5258 		    view->nlines, s->last_displayed_entry, s->tree);
5259 		if (nscrolled < view->nlines) {
5260 			int ndisplayed = 0;
5261 			struct got_tree_entry *te;
5262 			te = s->first_displayed_entry;
5263 			do {
5264 				ndisplayed++;
5265 				te = got_tree_entry_get_next(s->tree, te);
5266 			} while (te);
5267 			s->selected = ndisplayed - 1;
5268 		}
5269 		break;
5270 	case KEY_ENTER:
5271 	case '\r':
5272 	case KEY_BACKSPACE:
5273 		if (s->selected_entry == NULL || ch == KEY_BACKSPACE) {
5274 			struct tog_parent_tree *parent;
5275 			/* user selected '..' */
5276 			if (s->tree == s->root)
5277 				break;
5278 			parent = TAILQ_FIRST(&s->parents);
5279 			TAILQ_REMOVE(&s->parents, parent,
5280 			    entry);
5281 			got_object_tree_close(s->tree);
5282 			s->tree = parent->tree;
5283 			s->first_displayed_entry =
5284 			    parent->first_displayed_entry;
5285 			s->selected_entry =
5286 			    parent->selected_entry;
5287 			s->selected = parent->selected;
5288 			free(parent);
5289 		} else if (S_ISDIR(got_tree_entry_get_mode(
5290 		    s->selected_entry))) {
5291 			struct got_tree_object *subtree;
5292 			err = got_object_open_as_tree(&subtree, s->repo,
5293 			    got_tree_entry_get_id(s->selected_entry));
5294 			if (err)
5295 				break;
5296 			err = tree_view_visit_subtree(subtree, s);
5297 			if (err) {
5298 				got_object_tree_close(subtree);
5299 				break;
5300 			}
5301 		} else if (S_ISREG(got_tree_entry_get_mode(
5302 		    s->selected_entry))) {
5303 			struct tog_view *blame_view;
5304 			int begin_x = view_is_parent_view(view) ?
5305 			    view_split_begin_x(view->begin_x) : 0;
5306 
5307 			err = blame_tree_entry(&blame_view, begin_x,
5308 			    s->selected_entry, &s->parents,
5309 			    s->commit_id, s->refs, s->repo);
5310 			if (err)
5311 				break;
5312 			if (view_is_parent_view(view)) {
5313 				err = view_close_child(view);
5314 				if (err)
5315 					return err;
5316 				err = view_set_child(view, blame_view);
5317 				if (err) {
5318 					view_close(blame_view);
5319 					break;
5320 				}
5321 				*focus_view = blame_view;
5322 				view->child_focussed = 1;
5323 			} else
5324 				*new_view = blame_view;
5325 		}
5326 		break;
5327 	case KEY_RESIZE:
5328 		if (s->selected > view->nlines)
5329 			s->selected = s->ndisplayed - 1;
5330 		break;
5331 	default:
5332 		break;
5333 	}
5334 
5335 	return err;
5336 }
5337 
5338 __dead static void
5339 usage_tree(void)
5340 {
5341 	endwin();
5342 	fprintf(stderr, "usage: %s tree [-c commit] [-r repository-path] [path]\n",
5343 	    getprogname());
5344 	exit(1);
5345 }
5346 
5347 static const struct got_error *
5348 cmd_tree(int argc, char *argv[])
5349 {
5350 	const struct got_error *error;
5351 	struct got_repository *repo = NULL;
5352 	struct got_worktree *worktree = NULL;
5353 	struct got_reflist_head refs;
5354 	char *cwd = NULL, *repo_path = NULL, *in_repo_path = NULL;
5355 	struct got_object_id *commit_id = NULL;
5356 	char *commit_id_arg = NULL;
5357 	struct got_commit_object *commit = NULL;
5358 	struct got_tree_object *tree = NULL;
5359 	int ch;
5360 	struct tog_view *view;
5361 
5362 	SIMPLEQ_INIT(&refs);
5363 
5364 #ifndef PROFILE
5365 	if (pledge("stdio rpath wpath cpath flock proc tty exec sendfd unveil",
5366 	    NULL) == -1)
5367 		err(1, "pledge");
5368 #endif
5369 
5370 	while ((ch = getopt(argc, argv, "c:r:")) != -1) {
5371 		switch (ch) {
5372 		case 'c':
5373 			commit_id_arg = optarg;
5374 			break;
5375 		case 'r':
5376 			repo_path = realpath(optarg, NULL);
5377 			if (repo_path == NULL)
5378 				return got_error_from_errno2("realpath",
5379 				    optarg);
5380 			break;
5381 		default:
5382 			usage_tree();
5383 			/* NOTREACHED */
5384 		}
5385 	}
5386 
5387 	argc -= optind;
5388 	argv += optind;
5389 
5390 	if (argc > 1)
5391 		usage_tree();
5392 
5393 	cwd = getcwd(NULL, 0);
5394 	if (cwd == NULL)
5395 		return got_error_from_errno("getcwd");
5396 
5397 	error = got_worktree_open(&worktree, cwd);
5398 	if (error && error->code != GOT_ERR_NOT_WORKTREE)
5399 		goto done;
5400 
5401 	if (repo_path == NULL) {
5402 		if (worktree)
5403 			repo_path =
5404 			    strdup(got_worktree_get_repo_path(worktree));
5405 		else
5406 			repo_path = strdup(cwd);
5407 	}
5408 	if (repo_path == NULL) {
5409 		error = got_error_from_errno("strdup");
5410 		goto done;
5411 	}
5412 
5413 	error = got_repo_open(&repo, repo_path, NULL);
5414 	if (error != NULL)
5415 		goto done;
5416 
5417 	error = get_in_repo_path_from_argv0(&in_repo_path, argc, argv,
5418 	    repo, worktree);
5419 	if (error)
5420 		goto done;
5421 
5422 	init_curses();
5423 
5424 	error = apply_unveil(got_repo_get_path(repo), NULL);
5425 	if (error)
5426 		goto done;
5427 
5428 	error = got_repo_match_object_id(&commit_id, NULL,
5429 	    commit_id_arg ? commit_id_arg : GOT_REF_HEAD,
5430 	    GOT_OBJ_TYPE_COMMIT, 1, repo);
5431 	if (error)
5432 		goto done;
5433 
5434 	error = got_object_open_as_commit(&commit, repo, commit_id);
5435 	if (error)
5436 		goto done;
5437 
5438 	error = got_object_open_as_tree(&tree, repo,
5439 	    got_object_commit_get_tree_id(commit));
5440 	if (error)
5441 		goto done;
5442 
5443 	error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
5444 	if (error)
5445 		goto done;
5446 
5447 	view = view_open(0, 0, 0, 0, TOG_VIEW_TREE);
5448 	if (view == NULL) {
5449 		error = got_error_from_errno("view_open");
5450 		goto done;
5451 	}
5452 	error = open_tree_view(view, tree, commit_id, &refs, repo);
5453 	if (error)
5454 		goto done;
5455 	if (!got_path_is_root_dir(in_repo_path)) {
5456 		error = tree_view_walk_path(&view->state.tree, commit_id,
5457 		    in_repo_path, repo);
5458 		if (error)
5459 			goto done;
5460 	}
5461 
5462 	if (worktree) {
5463 		/* Release work tree lock. */
5464 		got_worktree_close(worktree);
5465 		worktree = NULL;
5466 	}
5467 	error = view_loop(view);
5468 done:
5469 	free(repo_path);
5470 	free(cwd);
5471 	free(commit_id);
5472 	if (commit)
5473 		got_object_commit_close(commit);
5474 	if (tree)
5475 		got_object_tree_close(tree);
5476 	if (repo)
5477 		got_repo_close(repo);
5478 	got_ref_list_free(&refs);
5479 	return error;
5480 }
5481 
5482 static void
5483 list_commands(FILE *fp)
5484 {
5485 	int i;
5486 
5487 	fprintf(fp, "commands:");
5488 	for (i = 0; i < nitems(tog_commands); i++) {
5489 		struct tog_cmd *cmd = &tog_commands[i];
5490 		fprintf(fp, " %s", cmd->name);
5491 	}
5492 	fputc('\n', fp);
5493 }
5494 
5495 __dead static void
5496 usage(int hflag, int status)
5497 {
5498 	FILE *fp = (status == 0) ? stdout : stderr;
5499 
5500 	fprintf(fp, "usage: %s [-h] [-V | --version] [command] [arg ...]\n",
5501 	    getprogname());
5502 	if (hflag) {
5503 		fprintf(fp, "lazy usage: %s path\n", getprogname());
5504 		list_commands(fp);
5505 	}
5506 	exit(status);
5507 }
5508 
5509 static char **
5510 make_argv(int argc, ...)
5511 {
5512 	va_list ap;
5513 	char **argv;
5514 	int i;
5515 
5516 	va_start(ap, argc);
5517 
5518 	argv = calloc(argc, sizeof(char *));
5519 	if (argv == NULL)
5520 		err(1, "calloc");
5521 	for (i = 0; i < argc; i++) {
5522 		argv[i] = strdup(va_arg(ap, char *));
5523 		if (argv[i] == NULL)
5524 			err(1, "strdup");
5525 	}
5526 
5527 	va_end(ap);
5528 	return argv;
5529 }
5530 
5531 /*
5532  * Try to convert 'tog path' into a 'tog log path' command.
5533  * The user could simply have mistyped the command rather than knowingly
5534  * provided a path. So check whether argv[0] can in fact be resolved
5535  * to a path in the HEAD commit and print a special error if not.
5536  * This hack is for mpi@ <3
5537  */
5538 static const struct got_error *
5539 tog_log_with_path(int argc, char *argv[])
5540 {
5541 	const struct got_error *error = NULL;
5542 	struct tog_cmd *cmd = NULL;
5543 	struct got_repository *repo = NULL;
5544 	struct got_worktree *worktree = NULL;
5545 	struct got_object_id *commit_id = NULL, *id = NULL;
5546 	char *cwd = NULL, *repo_path = NULL, *in_repo_path = NULL;
5547 	char *commit_id_str = NULL, **cmd_argv = NULL;
5548 
5549 	cwd = getcwd(NULL, 0);
5550 	if (cwd == NULL)
5551 		return got_error_from_errno("getcwd");
5552 
5553 	error = got_worktree_open(&worktree, cwd);
5554 	if (error && error->code != GOT_ERR_NOT_WORKTREE)
5555 		goto done;
5556 
5557 	if (worktree)
5558 		repo_path = strdup(got_worktree_get_repo_path(worktree));
5559 	else
5560 		repo_path = strdup(cwd);
5561 	if (repo_path == NULL) {
5562 		error = got_error_from_errno("strdup");
5563 		goto done;
5564 	}
5565 
5566 	error = got_repo_open(&repo, repo_path, NULL);
5567 	if (error != NULL)
5568 		goto done;
5569 
5570 	error = get_in_repo_path_from_argv0(&in_repo_path, argc, argv,
5571 	    repo, worktree);
5572 	if (error)
5573 		goto done;
5574 
5575 	error = got_repo_match_object_id(&commit_id, NULL, worktree ?
5576 	    got_worktree_get_head_ref_name(worktree) : GOT_REF_HEAD,
5577 	    GOT_OBJ_TYPE_COMMIT, 1, repo);
5578 	if (error)
5579 		goto done;
5580 
5581 	if (worktree) {
5582 		got_worktree_close(worktree);
5583 		worktree = NULL;
5584 	}
5585 
5586 	error = got_object_id_by_path(&id, repo, commit_id, in_repo_path);
5587 	if (error) {
5588 		if (error->code != GOT_ERR_NO_TREE_ENTRY)
5589 			goto done;
5590 		fprintf(stderr, "%s: '%s' is no known command or path\n",
5591 		    getprogname(), argv[0]);
5592 		usage(1, 1);
5593 		/* not reached */
5594 	}
5595 
5596 	got_repo_close(repo);
5597 	repo = NULL;
5598 
5599 	error = got_object_id_str(&commit_id_str, commit_id);
5600 	if (error)
5601 		goto done;
5602 
5603 	cmd = &tog_commands[0]; /* log */
5604 	argc = 4;
5605 	cmd_argv = make_argv(argc, cmd->name, "-c", commit_id_str, argv[0]);
5606 	error = cmd->cmd_main(argc, cmd_argv);
5607 done:
5608 	if (repo)
5609 		got_repo_close(repo);
5610 	if (worktree)
5611 		got_worktree_close(worktree);
5612 	free(id);
5613 	free(commit_id_str);
5614 	free(commit_id);
5615 	free(cwd);
5616 	free(repo_path);
5617 	free(in_repo_path);
5618 	if (cmd_argv) {
5619 		int i;
5620 		for (i = 0; i < argc; i++)
5621 			free(cmd_argv[i]);
5622 		free(cmd_argv);
5623 	}
5624 	return error;
5625 }
5626 
5627 int
5628 main(int argc, char *argv[])
5629 {
5630 	const struct got_error *error = NULL;
5631 	struct tog_cmd *cmd = NULL;
5632 	int ch, hflag = 0, Vflag = 0;
5633 	char **cmd_argv = NULL;
5634 	static struct option longopts[] = {
5635 	     { "version", no_argument, NULL, 'V' },
5636 	     { NULL, 0, NULL, 0}
5637 	};
5638 
5639 	setlocale(LC_CTYPE, "");
5640 
5641 	while ((ch = getopt_long(argc, argv, "+hV", longopts, NULL)) != -1) {
5642 		switch (ch) {
5643 		case 'h':
5644 			hflag = 1;
5645 			break;
5646 		case 'V':
5647 			Vflag = 1;
5648 			break;
5649 		default:
5650 			usage(hflag, 1);
5651 			/* NOTREACHED */
5652 		}
5653 	}
5654 
5655 	argc -= optind;
5656 	argv += optind;
5657 	optind = 1;
5658 	optreset = 1;
5659 
5660 	if (Vflag) {
5661 		got_version_print_str();
5662 		return 0;
5663 	}
5664 
5665 	if (argc == 0) {
5666 		if (hflag)
5667 			usage(hflag, 0);
5668 		/* Build an argument vector which runs a default command. */
5669 		cmd = &tog_commands[0];
5670 		argc = 1;
5671 		cmd_argv = make_argv(argc, cmd->name);
5672 	} else {
5673 		int i;
5674 
5675 		/* Did the user specify a command? */
5676 		for (i = 0; i < nitems(tog_commands); i++) {
5677 			if (strncmp(tog_commands[i].name, argv[0],
5678 			    strlen(argv[0])) == 0) {
5679 				cmd = &tog_commands[i];
5680 				break;
5681 			}
5682 		}
5683 	}
5684 
5685 	if (cmd == NULL) {
5686 		if (argc != 1)
5687 			usage(0, 1);
5688 		/* No command specified; try log with a path */
5689 		error = tog_log_with_path(argc, argv);
5690 	} else {
5691 		if (hflag)
5692 			cmd->cmd_usage();
5693 		else
5694 			error = cmd->cmd_main(argc, cmd_argv ? cmd_argv : argv);
5695 	}
5696 
5697 	endwin();
5698 	putchar('\n');
5699 	if (cmd_argv) {
5700 		int i;
5701 		for (i = 0; i < argc; i++)
5702 			free(cmd_argv[i]);
5703 		free(cmd_argv);
5704 	}
5705 
5706 	if (error && error->code != GOT_ERR_CANCELLED)
5707 		fprintf(stderr, "%s: %s\n", getprogname(), error->msg);
5708 	return 0;
5709 }