2 * Copyright (c) 2018, 2019, 2020 Stefan Sperling <stsp@openbsd.org>
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.
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.
17 #include <sys/queue.h>
19 #include <sys/ioctl.h>
23 #define _XOPEN_SOURCE_EXTENDED
25 #undef _XOPEN_SOURCE_EXTENDED
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"
50 #include "got_opentemp.h"
52 #include "got_cancel.h"
53 #include "got_commit_graph.h"
54 #include "got_blame.h"
55 #include "got_privsep.h"
57 #include "got_worktree.h"
60 #define MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
64 #define MAX(_a,_b) ((_a) > (_b) ? (_a) : (_b))
67 #define CTRL(x) ((x) & 0x1f)
70 #define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
75 const struct got_error *(*cmd_main)(int, char *[]);
76 void (*cmd_usage)(void);
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);
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 *[]);
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 },
104 #define TOG_EOF_STRING "(END)"
106 struct commit_queue_entry {
107 TAILQ_ENTRY(commit_queue_entry) entry;
108 struct got_object_id *id;
109 struct got_commit_object *commit;
112 TAILQ_HEAD(commit_queue_head, commit_queue_entry);
113 struct commit_queue {
115 struct commit_queue_head head;
119 SIMPLEQ_ENTRY(tog_color) entry;
123 SIMPLEQ_HEAD(tog_colors, tog_color);
125 static const struct got_error *
126 add_color(struct tog_colors *colors, const char *pattern,
127 int idx, short color)
129 const struct got_error *err = NULL;
130 struct tog_color *tc;
133 if (idx < 1 || idx > COLOR_PAIRS - 1)
136 init_pair(idx, color, -1);
138 tc = calloc(1, sizeof(*tc));
140 return got_error_from_errno("calloc");
141 regerr = regcomp(&tc->regex, pattern,
142 REG_EXTENDED | REG_NOSUB | REG_NEWLINE);
144 static char regerr_msg[512];
145 static char err_msg[512];
146 regerror(regerr, &tc->regex, regerr_msg,
148 snprintf(err_msg, sizeof(err_msg), "regcomp: %s",
150 err = got_error_msg(GOT_ERR_REGEX, err_msg);
155 SIMPLEQ_INSERT_HEAD(colors, tc, entry);
160 free_colors(struct tog_colors *colors)
162 struct tog_color *tc;
164 while (!SIMPLEQ_EMPTY(colors)) {
165 tc = SIMPLEQ_FIRST(colors);
166 SIMPLEQ_REMOVE_HEAD(colors, entry);
173 get_color(struct tog_colors *colors, int colorpair)
175 struct tog_color *tc = NULL;
177 SIMPLEQ_FOREACH(tc, colors, entry) {
178 if (tc->colorpair == colorpair)
186 default_color_value(const char *envvar)
188 if (strcmp(envvar, "TOG_COLOR_DIFF_MINUS") == 0)
189 return COLOR_MAGENTA;
190 if (strcmp(envvar, "TOG_COLOR_DIFF_PLUS") == 0)
192 if (strcmp(envvar, "TOG_COLOR_DIFF_CHUNK_HEADER") == 0)
194 if (strcmp(envvar, "TOG_COLOR_DIFF_META") == 0)
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)
202 if (strcmp(envvar, "TOG_COLOR_TREE_EXECUTABLE") == 0)
204 if (strcmp(envvar, "TOG_COLOR_COMMIT") == 0)
206 if (strcmp(envvar, "TOG_COLOR_AUTHOR") == 0)
208 if (strcmp(envvar, "TOG_COLOR_DATE") == 0)
215 get_color_value(const char *envvar)
217 const char *val = getenv(envvar);
220 return default_color_value(envvar);
222 if (strcasecmp(val, "black") == 0)
224 if (strcasecmp(val, "red") == 0)
226 if (strcasecmp(val, "green") == 0)
228 if (strcasecmp(val, "yellow") == 0)
230 if (strcasecmp(val, "blue") == 0)
232 if (strcasecmp(val, "magenta") == 0)
233 return COLOR_MAGENTA;
234 if (strcasecmp(val, "cyan") == 0)
236 if (strcasecmp(val, "white") == 0)
238 if (strcasecmp(val, "default") == 0)
241 return default_color_value(envvar);
245 struct tog_diff_view_state {
246 struct got_object_id *id1, *id2;
248 int first_displayed_line;
249 int last_displayed_line;
252 struct got_repository *repo;
253 struct got_reflist_head *refs;
254 struct tog_colors colors;
260 /* passed from log view; may be NULL */
261 struct tog_view *log_view;
264 pthread_mutex_t tog_mutex = PTHREAD_MUTEX_INITIALIZER;
266 struct tog_log_thread_args {
267 pthread_cond_t need_commits;
268 pthread_cond_t commit_loaded;
270 struct got_commit_graph *graph;
271 struct commit_queue *commits;
272 const char *in_repo_path;
273 struct got_object_id *start_id;
274 struct got_repository *repo;
277 struct commit_queue_entry **first_displayed_entry;
278 struct commit_queue_entry **selected_entry;
280 int *search_next_done;
284 struct tog_log_view_state {
285 struct commit_queue commits;
286 struct commit_queue_entry *first_displayed_entry;
287 struct commit_queue_entry *last_displayed_entry;
288 struct commit_queue_entry *selected_entry;
291 const char *head_ref_name;
293 struct got_repository *repo;
294 struct got_reflist_head *refs;
295 struct got_object_id *start_id;
298 struct tog_log_thread_args thread_args;
299 struct commit_queue_entry *matched_entry;
300 struct commit_queue_entry *search_entry;
301 struct tog_colors colors;
304 #define TOG_COLOR_DIFF_MINUS 1
305 #define TOG_COLOR_DIFF_PLUS 2
306 #define TOG_COLOR_DIFF_CHUNK_HEADER 3
307 #define TOG_COLOR_DIFF_META 4
308 #define TOG_COLOR_TREE_SUBMODULE 5
309 #define TOG_COLOR_TREE_SYMLINK 6
310 #define TOG_COLOR_TREE_DIRECTORY 7
311 #define TOG_COLOR_TREE_EXECUTABLE 8
312 #define TOG_COLOR_COMMIT 9
313 #define TOG_COLOR_AUTHOR 10
314 #define TOG_COLOR_DATE 11
316 struct tog_blame_cb_args {
317 struct tog_blame_line *lines; /* one per line */
320 struct tog_view *view;
321 struct got_object_id *commit_id;
325 struct tog_blame_thread_args {
327 struct got_repository *repo;
328 struct tog_blame_cb_args *cb_args;
330 got_cancel_cb cancel_cb;
337 struct tog_blame_line *lines;
341 struct tog_blame_thread_args thread_args;
342 struct tog_blame_cb_args cb_args;
346 struct tog_blame_view_state {
347 int first_displayed_line;
348 int last_displayed_line;
353 struct got_object_id_queue blamed_commits;
354 struct got_object_qid *blamed_commit;
356 struct got_repository *repo;
357 struct got_reflist_head *refs;
358 struct got_object_id *commit_id;
359 struct tog_blame blame;
361 struct tog_colors colors;
364 struct tog_parent_tree {
365 TAILQ_ENTRY(tog_parent_tree) entry;
366 struct got_tree_object *tree;
367 struct got_tree_entry *first_displayed_entry;
368 struct got_tree_entry *selected_entry;
372 TAILQ_HEAD(tog_parent_trees, tog_parent_tree);
374 struct tog_tree_view_state {
376 struct got_tree_object *root;
377 struct got_tree_object *tree;
378 struct got_tree_entry *first_displayed_entry;
379 struct got_tree_entry *last_displayed_entry;
380 struct got_tree_entry *selected_entry;
381 int ndisplayed, selected, show_ids;
382 struct tog_parent_trees parents;
383 struct got_object_id *commit_id;
384 struct got_repository *repo;
385 struct got_reflist_head *refs;
386 struct got_tree_entry *matched_entry;
387 struct tog_colors colors;
391 * We implement two types of views: parent views and child views.
393 * The 'Tab' key switches between a parent view and its child view.
394 * Child views are shown side-by-side to their parent view, provided
395 * there is enough screen estate.
397 * When a new view is opened from within a parent view, this new view
398 * becomes a child view of the parent view, replacing any existing child.
400 * When a new view is opened from within a child view, this new view
401 * becomes a parent view which will obscure the views below until the
402 * user quits the new parent view by typing 'q'.
404 * This list of views contains parent views only.
405 * Child views are only pointed to by their parent view.
407 TAILQ_HEAD(tog_view_list_head, tog_view);
410 TAILQ_ENTRY(tog_view) entry;
413 int nlines, ncols, begin_y, begin_x;
414 int lines, cols; /* copies of LINES and COLS */
416 struct tog_view *parent;
417 struct tog_view *child;
420 /* type-specific state */
421 enum tog_view_type type;
423 struct tog_diff_view_state diff;
424 struct tog_log_view_state log;
425 struct tog_blame_view_state blame;
426 struct tog_tree_view_state tree;
429 const struct got_error *(*show)(struct tog_view *);
430 const struct got_error *(*input)(struct tog_view **,
431 struct tog_view **, struct tog_view**, struct tog_view *, int);
432 const struct got_error *(*close)(struct tog_view *);
434 const struct got_error *(*search_start)(struct tog_view *);
435 const struct got_error *(*search_next)(struct tog_view *);
437 #define TOG_SEARCH_FORWARD 1
438 #define TOG_SEARCH_BACKWARD 2
439 int search_next_done;
440 #define TOG_SEARCH_HAVE_MORE 1
441 #define TOG_SEARCH_NO_MORE 2
442 #define TOG_SEARCH_HAVE_NONE 3
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 *);
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 *);
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 *);
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 *);
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;
491 tog_sigwinch(int signo)
493 tog_sigwinch_received = 1;
497 tog_sigpipe(int signo)
499 tog_sigpipe_received = 1;
503 tog_sigcont(int signo)
505 tog_sigcont_received = 1;
508 static const struct got_error *
509 view_close(struct tog_view *view)
511 const struct got_error *err = NULL;
514 view_close(view->child);
518 err = view->close(view);
520 del_panel(view->panel);
522 delwin(view->window);
527 static struct tog_view *
528 view_open(int nlines, int ncols, int begin_y, int begin_x,
529 enum tog_view_type type)
531 struct tog_view *view = calloc(1, sizeof(*view));
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) {
548 view->panel = new_panel(view->window);
549 if (view->panel == NULL ||
550 set_panel_userptr(view->panel, view) != OK) {
555 keypad(view->window, TRUE);
560 view_split_begin_x(int begin_x)
562 if (begin_x > 0 || COLS < 120)
564 return (COLS - MAX(COLS / 2, 80));
567 static const struct got_error *view_resize(struct tog_view *);
569 static const struct got_error *
570 view_splitscreen(struct tog_view *view)
572 const struct got_error *err = NULL;
575 view->begin_x = view_split_begin_x(0);
576 view->nlines = LINES;
577 view->ncols = COLS - view->begin_x;
580 err = view_resize(view);
584 if (mvwin(view->window, view->begin_y, view->begin_x) == ERR)
585 return got_error_from_errno("mvwin");
590 static const struct got_error *
591 view_fullscreen(struct tog_view *view)
593 const struct got_error *err = NULL;
597 view->nlines = LINES;
601 err = view_resize(view);
605 if (mvwin(view->window, view->begin_y, view->begin_x) == ERR)
606 return got_error_from_errno("mvwin");
612 view_is_parent_view(struct tog_view *view)
614 return view->parent == NULL;
617 static const struct got_error *
618 view_resize(struct tog_view *view)
622 if (view->lines > LINES)
623 nlines = view->nlines - (view->lines - LINES);
625 nlines = view->nlines + (LINES - view->lines);
627 if (view->cols > COLS)
628 ncols = view->ncols - (view->cols - COLS);
630 ncols = view->ncols + (COLS - view->cols);
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);
638 view->nlines = nlines;
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);
650 show_panel(view->panel);
652 view_splitscreen(view->child);
653 show_panel(view->child->panel);
660 static const struct got_error *
661 view_close_child(struct tog_view *view)
663 const struct got_error *err = NULL;
665 if (view->child == NULL)
668 err = view_close(view->child);
673 static const struct got_error *
674 view_set_child(struct tog_view *view, struct tog_view *child)
676 const struct got_error *err = NULL;
679 child->parent = view;
684 view_is_splitscreen(struct tog_view *view)
686 return view->begin_x > 0;
695 if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &size) < 0) {
696 cols = 80; /* Default */
702 resize_term(lines, cols);
705 static const struct got_error *
706 view_search_start(struct tog_view *view)
708 const struct got_error *err = NULL;
712 if (view->nlines < 1)
715 mvwaddstr(view->window, view->begin_y + view->nlines - 1, 0, "/");
716 wclrtoeol(view->window);
720 ret = wgetnstr(view->window, pattern, sizeof(pattern));
726 if (view->searching) {
727 regfree(&view->regex);
731 if (regcomp(&view->regex, pattern, REG_EXTENDED | REG_NEWLINE) == 0) {
732 err = view->search_start(view);
734 regfree(&view->regex);
737 view->searching = TOG_SEARCH_FORWARD;
738 view->search_next_done = 0;
739 view->search_next(view);
745 static const struct got_error *
746 view_input(struct tog_view **new, struct tog_view **dead,
747 struct tog_view **focus, int *done, struct tog_view *view,
748 struct tog_view_list_head *views)
750 const struct got_error *err = NULL;
758 /* Clear "no matches" indicator. */
759 if (view->search_next_done == TOG_SEARCH_NO_MORE ||
760 view->search_next_done == TOG_SEARCH_HAVE_NONE)
761 view->search_next_done = TOG_SEARCH_HAVE_MORE;
763 if (view->searching && !view->search_next_done) {
764 errcode = pthread_mutex_unlock(&tog_mutex);
766 return got_error_set_errno(errcode,
767 "pthread_mutex_unlock");
769 errcode = pthread_mutex_lock(&tog_mutex);
771 return got_error_set_errno(errcode,
772 "pthread_mutex_lock");
773 view->search_next(view);
777 nodelay(stdscr, FALSE);
778 /* Allow threads to make progress while we are waiting for input. */
779 errcode = pthread_mutex_unlock(&tog_mutex);
781 return got_error_set_errno(errcode, "pthread_mutex_unlock");
782 ch = wgetch(view->window);
783 errcode = pthread_mutex_lock(&tog_mutex);
785 return got_error_set_errno(errcode, "pthread_mutex_lock");
786 nodelay(stdscr, TRUE);
788 if (tog_sigwinch_received || tog_sigcont_received) {
790 tog_sigwinch_received = 0;
791 tog_sigcont_received = 0;
792 TAILQ_FOREACH(v, views, entry) {
793 err = view_resize(v);
796 err = v->input(new, dead, focus, v, KEY_RESIZE);
807 *focus = view->child;
808 view->child_focussed = 1;
809 } else if (view->parent) {
810 *focus = view->parent;
811 view->parent->child_focussed = 0;
815 err = view->input(new, dead, focus, view, ch);
822 if (view_is_parent_view(view)) {
823 if (view->child == NULL)
825 if (view_is_splitscreen(view->child)) {
826 *focus = view->child;
827 view->child_focussed = 1;
828 err = view_fullscreen(view->child);
830 err = view_splitscreen(view->child);
833 err = view->child->input(new, dead, focus,
834 view->child, KEY_RESIZE);
836 if (view_is_splitscreen(view)) {
838 view->parent->child_focussed = 1;
839 err = view_fullscreen(view);
841 err = view_splitscreen(view);
845 err = view->input(new, dead, focus, view,
852 if (view->search_start)
853 view_search_start(view);
855 err = view->input(new, dead, focus, view, ch);
859 if (view->search_next) {
860 view->searching = (ch == 'n' ?
861 TOG_SEARCH_FORWARD : TOG_SEARCH_BACKWARD);
862 view->search_next_done = 0;
863 view->search_next(view);
865 err = view->input(new, dead, focus, view, ch);
868 err = view->input(new, dead, focus, view, ch);
876 view_vborder(struct tog_view *view)
879 struct tog_view *view_above;
882 return view_vborder(view->parent);
884 panel = panel_above(view->panel);
888 view_above = panel_userptr(panel);
889 mvwvline(view->window, view->begin_y, view_above->begin_x - 1,
890 got_locale_is_utf8() ? ACS_VLINE : '|', view->nlines);
894 view_needs_focus_indication(struct tog_view *view)
896 if (view_is_parent_view(view)) {
897 if (view->child == NULL || view->child_focussed)
899 if (!view_is_splitscreen(view->child))
901 } else if (!view_is_splitscreen(view))
904 return view->focussed;
907 static const struct got_error *
908 view_loop(struct tog_view *view)
910 const struct got_error *err = NULL;
911 struct tog_view_list_head views;
912 struct tog_view *new_view, *dead_view, *focus_view, *main_view;
913 int fast_refresh = 10;
914 int done = 0, errcode;
916 errcode = pthread_mutex_lock(&tog_mutex);
918 return got_error_set_errno(errcode, "pthread_mutex_lock");
921 TAILQ_INSERT_HEAD(&views, view, entry);
925 err = view->show(view);
930 while (!TAILQ_EMPTY(&views) && !done && !tog_sigpipe_received) {
931 /* Refresh fast during initialization, then become slower. */
932 if (fast_refresh && fast_refresh-- == 0)
933 halfdelay(10); /* switch to once per second */
935 err = view_input(&new_view, &dead_view, &focus_view, &done,
940 struct tog_view *prev = NULL;
942 if (view_is_parent_view(dead_view))
943 prev = TAILQ_PREV(dead_view,
944 tog_view_list_head, entry);
945 else if (view->parent != dead_view)
948 if (dead_view->parent)
949 dead_view->parent->child = NULL;
951 TAILQ_REMOVE(&views, dead_view, entry);
953 err = view_close(dead_view);
954 if (err || (dead_view == main_view && new_view == NULL))
957 if (view == dead_view) {
962 else if (!TAILQ_EMPTY(&views))
963 view = TAILQ_LAST(&views,
968 if (view->child && view->child_focussed)
969 focus_view = view->child;
976 struct tog_view *v, *t;
977 /* Only allow one parent view per type. */
978 TAILQ_FOREACH_SAFE(v, &views, entry, t) {
979 if (v->type != new_view->type)
981 TAILQ_REMOVE(&views, v, entry);
987 TAILQ_INSERT_TAIL(&views, new_view, entry);
989 if (focus_view == NULL)
990 focus_view = new_view;
993 show_panel(focus_view->panel);
996 focus_view->focussed = 1;
999 show_panel(new_view->panel);
1000 if (view->child && view_is_splitscreen(view->child))
1001 show_panel(view->child->panel);
1004 if (focus_view == NULL) {
1006 show_panel(view->panel);
1007 if (view->child && view_is_splitscreen(view->child))
1008 show_panel(view->child->panel);
1012 err = view->parent->show(view->parent);
1016 err = view->show(view);
1020 err = view->child->show(view->child);
1029 while (!TAILQ_EMPTY(&views)) {
1030 view = TAILQ_FIRST(&views);
1031 TAILQ_REMOVE(&views, view, entry);
1035 errcode = pthread_mutex_unlock(&tog_mutex);
1036 if (errcode && err == NULL)
1037 err = got_error_set_errno(errcode, "pthread_mutex_unlock");
1047 "usage: %s log [-b] [-c commit] [-r repository-path] [path]\n",
1052 /* Create newly allocated wide-character string equivalent to a byte string. */
1053 static const struct got_error *
1054 mbs2ws(wchar_t **ws, size_t *wlen, const char *s)
1057 const struct got_error *err = NULL;
1060 *wlen = mbstowcs(NULL, s, 0);
1061 if (*wlen == (size_t)-1) {
1063 if (errno != EILSEQ)
1064 return got_error_from_errno("mbstowcs");
1066 /* byte string invalid in current encoding; try to "fix" it */
1067 err = got_mbsavis(&vis, &vislen, s);
1070 *wlen = mbstowcs(NULL, vis, 0);
1071 if (*wlen == (size_t)-1) {
1072 err = got_error_from_errno("mbstowcs"); /* give up */
1077 *ws = calloc(*wlen + 1, sizeof(**ws));
1079 err = got_error_from_errno("calloc");
1083 if (mbstowcs(*ws, vis ? vis : s, *wlen) != *wlen)
1084 err = got_error_from_errno("mbstowcs");
1095 /* Format a line for display, ensuring that it won't overflow a width limit. */
1096 static const struct got_error *
1097 format_line(wchar_t **wlinep, int *widthp, const char *line, int wlimit,
1100 const struct got_error *err = NULL;
1102 wchar_t *wline = NULL;
1109 err = mbs2ws(&wline, &wlen, line);
1115 int width = wcwidth(wline[i]);
1122 if (width == 1 || width == 2) {
1123 if (cols + width > wlimit)
1127 } else if (width == -1) {
1128 if (wline[i] == L'\t') {
1130 ((cols + col_tab_align) % TABSIZE);
1131 if (cols + width > wlimit)
1137 err = got_error_from_errno("wcwidth");
1152 static const struct got_error*
1153 build_refs_str(char **refs_str, struct got_reflist_head *refs,
1154 struct got_object_id *id, struct got_repository *repo)
1156 static const struct got_error *err = NULL;
1157 struct got_reflist_entry *re;
1163 SIMPLEQ_FOREACH(re, refs, entry) {
1164 struct got_tag_object *tag = NULL;
1165 struct got_object_id *ref_id;
1168 name = got_ref_get_name(re->ref);
1169 if (strcmp(name, GOT_REF_HEAD) == 0)
1171 if (strncmp(name, "refs/", 5) == 0)
1173 if (strncmp(name, "got/", 4) == 0)
1175 if (strncmp(name, "heads/", 6) == 0)
1177 if (strncmp(name, "remotes/", 8) == 0) {
1179 s = strstr(name, "/" GOT_REF_HEAD);
1180 if (s != NULL && s[strlen(s)] == '\0')
1183 err = got_ref_resolve(&ref_id, repo, re->ref);
1186 if (strncmp(name, "tags/", 5) == 0) {
1187 err = got_object_open_as_tag(&tag, repo, ref_id);
1189 if (err->code != GOT_ERR_OBJ_TYPE) {
1193 /* Ref points at something other than a tag. */
1198 cmp = got_object_id_cmp(tag ?
1199 got_object_tag_get_object_id(tag) : ref_id, id);
1202 got_object_tag_close(tag);
1206 if (asprintf(refs_str, "%s%s%s", s ? s : "",
1207 s ? ", " : "", name) == -1) {
1208 err = got_error_from_errno("asprintf");
1219 static const struct got_error *
1220 format_author(wchar_t **wauthor, int *author_width, char *author, int limit,
1223 char *smallerthan, *at;
1225 smallerthan = strchr(author, '<');
1226 if (smallerthan && smallerthan[1] != '\0')
1227 author = smallerthan + 1;
1228 at = strchr(author, '@');
1231 return format_line(wauthor, author_width, author, limit, col_tab_align);
1234 static const struct got_error *
1235 draw_commit(struct tog_view *view, struct got_commit_object *commit,
1236 struct got_object_id *id, struct got_reflist_head *refs,
1237 const size_t date_display_cols, int author_display_cols,
1238 struct tog_colors *colors)
1240 const struct got_error *err = NULL;
1241 char datebuf[12]; /* YYYY-MM-DD + SPACE + NUL */
1242 char *logmsg0 = NULL, *logmsg = NULL;
1243 char *author = NULL;
1244 wchar_t *wlogmsg = NULL, *wauthor = NULL;
1245 int author_width, logmsg_width;
1246 char *newline, *line = NULL;
1248 const int avail = view->ncols;
1250 time_t committer_time;
1251 struct tog_color *tc;
1253 committer_time = got_object_commit_get_committer_time(commit);
1254 if (localtime_r(&committer_time, &tm) == NULL)
1255 return got_error_from_errno("localtime_r");
1256 if (strftime(datebuf, sizeof(datebuf), "%G-%m-%d ", &tm)
1258 return got_error(GOT_ERR_NO_SPACE);
1260 if (avail <= date_display_cols)
1261 limit = MIN(sizeof(datebuf) - 1, avail);
1263 limit = MIN(date_display_cols, sizeof(datebuf) - 1);
1264 tc = get_color(colors, TOG_COLOR_DATE);
1266 wattr_on(view->window,
1267 COLOR_PAIR(tc->colorpair), NULL);
1268 waddnstr(view->window, datebuf, limit);
1270 wattr_off(view->window,
1271 COLOR_PAIR(tc->colorpair), NULL);
1278 err = got_object_id_str(&id_str, id);
1281 tc = get_color(colors, TOG_COLOR_COMMIT);
1283 wattr_on(view->window,
1284 COLOR_PAIR(tc->colorpair), NULL);
1285 wprintw(view->window, "%.8s ", id_str);
1287 wattr_off(view->window,
1288 COLOR_PAIR(tc->colorpair), NULL);
1295 author = strdup(got_object_commit_get_author(commit));
1296 if (author == NULL) {
1297 err = got_error_from_errno("strdup");
1300 err = format_author(&wauthor, &author_width, author, avail - col, col);
1303 tc = get_color(colors, TOG_COLOR_AUTHOR);
1305 wattr_on(view->window,
1306 COLOR_PAIR(tc->colorpair), NULL);
1307 waddwstr(view->window, wauthor);
1309 wattr_off(view->window,
1310 COLOR_PAIR(tc->colorpair), NULL);
1311 col += author_width;
1312 while (col < avail && author_width < author_display_cols + 2) {
1313 waddch(view->window, ' ');
1320 err = got_object_commit_get_logmsg(&logmsg0, commit);
1324 while (*logmsg == '\n')
1326 newline = strchr(logmsg, '\n');
1329 limit = avail - col;
1330 err = format_line(&wlogmsg, &logmsg_width, logmsg, limit, col);
1333 waddwstr(view->window, wlogmsg);
1334 col += logmsg_width;
1335 while (col < avail) {
1336 waddch(view->window, ' ');
1348 static struct commit_queue_entry *
1349 alloc_commit_queue_entry(struct got_commit_object *commit,
1350 struct got_object_id *id)
1352 struct commit_queue_entry *entry;
1354 entry = calloc(1, sizeof(*entry));
1359 entry->commit = commit;
1364 pop_commit(struct commit_queue *commits)
1366 struct commit_queue_entry *entry;
1368 entry = TAILQ_FIRST(&commits->head);
1369 TAILQ_REMOVE(&commits->head, entry, entry);
1370 got_object_commit_close(entry->commit);
1371 commits->ncommits--;
1372 /* Don't free entry->id! It is owned by the commit graph. */
1377 free_commits(struct commit_queue *commits)
1379 while (!TAILQ_EMPTY(&commits->head))
1380 pop_commit(commits);
1383 static const struct got_error *
1384 match_commit(int *have_match, struct got_object_id *id,
1385 struct got_commit_object *commit, regex_t *regex)
1387 const struct got_error *err = NULL;
1388 regmatch_t regmatch;
1389 char *id_str = NULL, *logmsg = NULL;
1393 err = got_object_id_str(&id_str, id);
1397 err = got_object_commit_get_logmsg(&logmsg, commit);
1401 if (regexec(regex, got_object_commit_get_author(commit), 1,
1402 ®match, 0) == 0 ||
1403 regexec(regex, got_object_commit_get_committer(commit), 1,
1404 ®match, 0) == 0 ||
1405 regexec(regex, id_str, 1, ®match, 0) == 0 ||
1406 regexec(regex, logmsg, 1, ®match, 0) == 0)
1414 static const struct got_error *
1415 queue_commits(struct got_commit_graph *graph, struct commit_queue *commits,
1416 int minqueue, struct got_repository *repo, const char *path,
1417 int *searching, int *search_next_done, regex_t *regex)
1419 const struct got_error *err = NULL;
1423 * We keep all commits open throughout the lifetime of the log
1424 * view in order to avoid having to re-fetch commits from disk
1425 * while updating the display.
1427 while (nqueued < minqueue ||
1428 (*searching == TOG_SEARCH_FORWARD && !*search_next_done)) {
1429 struct got_object_id *id;
1430 struct got_commit_object *commit;
1431 struct commit_queue_entry *entry;
1434 err = got_commit_graph_iter_next(&id, graph, repo, NULL, NULL);
1435 if (err || id == NULL)
1438 err = got_object_open_as_commit(&commit, repo, id);
1441 entry = alloc_commit_queue_entry(commit, id);
1442 if (entry == NULL) {
1443 err = got_error_from_errno("alloc_commit_queue_entry");
1447 errcode = pthread_mutex_lock(&tog_mutex);
1449 err = got_error_set_errno(errcode,
1450 "pthread_mutex_lock");
1454 entry->idx = commits->ncommits;
1455 TAILQ_INSERT_TAIL(&commits->head, entry, entry);
1457 commits->ncommits++;
1459 if (*searching == TOG_SEARCH_FORWARD && !*search_next_done) {
1461 err = match_commit(&have_match, id, commit, regex);
1465 *search_next_done = TOG_SEARCH_HAVE_MORE;
1468 errcode = pthread_mutex_unlock(&tog_mutex);
1469 if (errcode && err == NULL)
1470 err = got_error_set_errno(errcode,
1471 "pthread_mutex_unlock");
1479 static const struct got_error *
1480 draw_commits(struct tog_view *view, struct commit_queue_entry **last,
1481 struct commit_queue_entry **selected, struct commit_queue_entry *first,
1482 struct commit_queue *commits, int selected_idx, int limit,
1483 struct got_reflist_head *refs, const char *path, int commits_needed,
1484 struct tog_colors *colors)
1486 const struct got_error *err = NULL;
1487 struct tog_log_view_state *s = &view->state.log;
1488 struct commit_queue_entry *entry;
1490 int ncommits, author_cols = 4;
1491 char *id_str = NULL, *header = NULL, *ncommits_str = NULL;
1492 char *refs_str = NULL;
1494 struct tog_color *tc;
1495 static const size_t date_display_cols = 12;
1500 if (ncommits == selected_idx) {
1504 entry = TAILQ_NEXT(entry, entry);
1508 if (*selected && !(view->searching && view->search_next_done == 0)) {
1509 err = got_object_id_str(&id_str, (*selected)->id);
1513 err = build_refs_str(&refs_str, refs, (*selected)->id,
1520 if (commits_needed == 0)
1521 halfdelay(10); /* disable fast refresh */
1523 if (commits_needed > 0) {
1524 if (asprintf(&ncommits_str, " [%d/%d] %s",
1525 entry ? entry->idx + 1 : 0, commits->ncommits,
1526 (view->searching && !view->search_next_done) ?
1527 "searching..." : "loading...") == -1) {
1528 err = got_error_from_errno("asprintf");
1532 const char *search_str = NULL;
1534 if (view->searching) {
1535 if (view->search_next_done == TOG_SEARCH_NO_MORE)
1536 search_str = "no more matches";
1537 else if (view->search_next_done == TOG_SEARCH_HAVE_NONE)
1538 search_str = "no matches found";
1539 else if (!view->search_next_done)
1540 search_str = "searching...";
1543 if (asprintf(&ncommits_str, " [%d/%d] %s",
1544 entry ? entry->idx + 1 : 0, commits->ncommits,
1545 search_str ? search_str :
1546 (refs_str ? refs_str : "")) == -1) {
1547 err = got_error_from_errno("asprintf");
1552 if (path && strcmp(path, "/") != 0) {
1553 if (asprintf(&header, "commit %s %s%s",
1554 id_str ? id_str : "........................................",
1555 path, ncommits_str) == -1) {
1556 err = got_error_from_errno("asprintf");
1560 } else if (asprintf(&header, "commit %s%s",
1561 id_str ? id_str : "........................................",
1562 ncommits_str) == -1) {
1563 err = got_error_from_errno("asprintf");
1567 err = format_line(&wline, &width, header, view->ncols, 0);
1571 werase(view->window);
1573 if (view_needs_focus_indication(view))
1574 wstandout(view->window);
1575 tc = get_color(colors, TOG_COLOR_COMMIT);
1577 wattr_on(view->window,
1578 COLOR_PAIR(tc->colorpair), NULL);
1579 waddwstr(view->window, wline);
1581 wattr_off(view->window,
1582 COLOR_PAIR(tc->colorpair), NULL);
1583 while (width < view->ncols) {
1584 waddch(view->window, ' ');
1587 if (view_needs_focus_indication(view))
1588 wstandend(view->window);
1593 /* Grow author column size if necessary. */
1600 if (ncommits >= limit - 1)
1602 author = strdup(got_object_commit_get_author(entry->commit));
1603 if (author == NULL) {
1604 err = got_error_from_errno("strdup");
1607 err = format_author(&wauthor, &width, author, COLS,
1609 if (author_cols < width)
1610 author_cols = width;
1614 entry = TAILQ_NEXT(entry, entry);
1621 if (ncommits >= limit - 1)
1623 if (ncommits == selected_idx)
1624 wstandout(view->window);
1625 err = draw_commit(view, entry->commit, entry->id, refs,
1626 date_display_cols, author_cols, colors);
1627 if (ncommits == selected_idx)
1628 wstandend(view->window);
1633 entry = TAILQ_NEXT(entry, entry);
1646 scroll_up(struct tog_view *view,
1647 struct commit_queue_entry **first_displayed_entry, int maxscroll,
1648 struct commit_queue *commits)
1650 struct commit_queue_entry *entry;
1653 entry = TAILQ_FIRST(&commits->head);
1654 if (*first_displayed_entry == entry)
1657 entry = *first_displayed_entry;
1658 while (entry && nscrolled < maxscroll) {
1659 entry = TAILQ_PREV(entry, commit_queue_head, entry);
1661 *first_displayed_entry = entry;
1667 static const struct got_error *
1668 trigger_log_thread(struct tog_view *log_view, int wait,
1669 int *commits_needed, int *log_complete,
1670 pthread_cond_t *need_commits, pthread_cond_t *commit_loaded)
1674 halfdelay(1); /* fast refresh while loading commits */
1676 while (*commits_needed > 0) {
1680 /* Wake the log thread. */
1681 errcode = pthread_cond_signal(need_commits);
1683 return got_error_set_errno(errcode,
1684 "pthread_cond_signal");
1687 * The mutex will be released while the view loop waits
1688 * in wgetch(), at which time the log thread will run.
1693 /* Display progress update in log view. */
1694 show_log_view(log_view);
1698 /* Wait right here while next commit is being loaded. */
1699 errcode = pthread_cond_wait(commit_loaded, &tog_mutex);
1701 return got_error_set_errno(errcode,
1702 "pthread_cond_wait");
1704 /* Display progress update in log view. */
1705 show_log_view(log_view);
1713 static const struct got_error *
1714 scroll_down(struct tog_view *log_view,
1715 struct commit_queue_entry **first_displayed_entry, int maxscroll,
1716 struct commit_queue_entry **last_displayed_entry,
1717 struct commit_queue *commits, int *log_complete, int *commits_needed,
1718 pthread_cond_t *need_commits, pthread_cond_t *commit_loaded)
1720 const struct got_error *err = NULL;
1721 struct commit_queue_entry *pentry;
1722 int nscrolled = 0, ncommits_needed;
1724 if (*last_displayed_entry == NULL)
1727 ncommits_needed = (*last_displayed_entry)->idx + 1 + maxscroll;
1728 if (commits->ncommits < ncommits_needed && !*log_complete) {
1730 * Ask the log thread for required amount of commits.
1732 (*commits_needed) += maxscroll;
1733 err = trigger_log_thread(log_view, 1, commits_needed,
1734 log_complete, need_commits, commit_loaded);
1740 pentry = TAILQ_NEXT(*last_displayed_entry, entry);
1744 *last_displayed_entry = pentry;
1746 pentry = TAILQ_NEXT(*first_displayed_entry, entry);
1749 *first_displayed_entry = pentry;
1750 } while (++nscrolled < maxscroll);
1755 static const struct got_error *
1756 open_diff_view_for_commit(struct tog_view **new_view, int begin_x,
1757 struct got_commit_object *commit, struct got_object_id *commit_id,
1758 struct tog_view *log_view, struct got_reflist_head *refs,
1759 struct got_repository *repo)
1761 const struct got_error *err;
1762 struct got_object_qid *parent_id;
1763 struct tog_view *diff_view;
1765 diff_view = view_open(0, 0, 0, begin_x, TOG_VIEW_DIFF);
1766 if (diff_view == NULL)
1767 return got_error_from_errno("view_open");
1769 parent_id = SIMPLEQ_FIRST(got_object_commit_get_parent_ids(commit));
1770 err = open_diff_view(diff_view, parent_id ? parent_id->id : NULL,
1771 commit_id, log_view, refs, repo);
1773 *new_view = diff_view;
1777 static const struct got_error *
1778 tree_view_visit_subtree(struct got_tree_object *subtree,
1779 struct tog_tree_view_state *s)
1781 struct tog_parent_tree *parent;
1783 parent = calloc(1, sizeof(*parent));
1785 return got_error_from_errno("calloc");
1787 parent->tree = s->tree;
1788 parent->first_displayed_entry = s->first_displayed_entry;
1789 parent->selected_entry = s->selected_entry;
1790 parent->selected = s->selected;
1791 TAILQ_INSERT_HEAD(&s->parents, parent, entry);
1794 s->first_displayed_entry = NULL;
1798 static const struct got_error *
1799 tree_view_walk_path(struct tog_tree_view_state *s,
1800 struct got_object_id *commit_id,
1801 const char *path, struct got_repository *repo)
1803 const struct got_error *err = NULL;
1804 struct got_tree_object *tree = NULL;
1806 char *slash, *subpath = NULL;
1808 /* Walk the path and open corresponding tree objects. */
1811 struct got_tree_entry *te;
1812 struct got_object_id *tree_id;
1818 /* Ensure the correct subtree entry is selected. */
1819 slash = strchr(p, '/');
1821 te_name = strdup(p);
1823 te_name = strndup(p, slash - p);
1824 if (te_name == NULL) {
1825 err = got_error_from_errno("strndup");
1828 te = got_object_tree_find_entry(s->tree, te_name);
1830 err = got_error_path(te_name, GOT_ERR_NO_TREE_ENTRY);
1835 s->selected_entry = te;
1836 s->selected = got_tree_entry_get_index(te);
1837 if (s->tree != s->root)
1838 s->selected++; /* skip '..' */
1840 if (!S_ISDIR(got_tree_entry_get_mode(s->selected_entry))) {
1841 /* Jump to this file's entry. */
1842 s->first_displayed_entry = s->selected_entry;
1847 slash = strchr(p, '/');
1849 subpath = strndup(path, slash - path);
1851 subpath = strdup(path);
1852 if (subpath == NULL) {
1853 err = got_error_from_errno("strdup");
1857 err = got_object_id_by_path(&tree_id, repo, commit_id,
1862 err = got_object_open_as_tree(&tree, repo, tree_id);
1867 err = tree_view_visit_subtree(tree, s);
1869 got_object_tree_close(tree);
1883 static const struct got_error *
1884 browse_commit_tree(struct tog_view **new_view, int begin_x,
1885 struct commit_queue_entry *entry, const char *path,
1886 struct got_reflist_head *refs, struct got_repository *repo)
1888 const struct got_error *err = NULL;
1889 struct got_tree_object *tree;
1890 struct tog_tree_view_state *s;
1891 struct tog_view *tree_view;
1893 err = got_object_open_as_tree(&tree, repo,
1894 got_object_commit_get_tree_id(entry->commit));
1898 tree_view = view_open(0, 0, 0, begin_x, TOG_VIEW_TREE);
1899 if (tree_view == NULL)
1900 return got_error_from_errno("view_open");
1902 err = open_tree_view(tree_view, tree, entry->id, refs, repo);
1904 got_object_tree_close(tree);
1907 s = &tree_view->state.tree;
1909 *new_view = tree_view;
1911 if (got_path_is_root_dir(path))
1914 return tree_view_walk_path(s, entry->id, path, repo);
1917 static const struct got_error *
1918 block_signals_used_by_main_thread(void)
1923 if (sigemptyset(&sigset) == -1)
1924 return got_error_from_errno("sigemptyset");
1926 /* tog handles SIGWINCH and SIGCONT */
1927 if (sigaddset(&sigset, SIGWINCH) == -1)
1928 return got_error_from_errno("sigaddset");
1929 if (sigaddset(&sigset, SIGCONT) == -1)
1930 return got_error_from_errno("sigaddset");
1932 /* ncurses handles SIGTSTP */
1933 if (sigaddset(&sigset, SIGTSTP) == -1)
1934 return got_error_from_errno("sigaddset");
1936 errcode = pthread_sigmask(SIG_BLOCK, &sigset, NULL);
1938 return got_error_set_errno(errcode, "pthread_sigmask");
1944 log_thread(void *arg)
1946 const struct got_error *err = NULL;
1948 struct tog_log_thread_args *a = arg;
1951 err = block_signals_used_by_main_thread();
1955 while (!done && !err && !tog_sigpipe_received) {
1956 err = queue_commits(a->graph, a->commits, 1, a->repo,
1957 a->in_repo_path, a->searching, a->search_next_done,
1960 if (err->code != GOT_ERR_ITER_COMPLETED)
1964 } else if (a->commits_needed > 0)
1965 a->commits_needed--;
1967 errcode = pthread_mutex_lock(&tog_mutex);
1969 err = got_error_set_errno(errcode,
1970 "pthread_mutex_lock");
1972 } else if (*a->quit)
1974 else if (*a->first_displayed_entry == NULL) {
1975 *a->first_displayed_entry =
1976 TAILQ_FIRST(&a->commits->head);
1977 *a->selected_entry = *a->first_displayed_entry;
1980 errcode = pthread_cond_signal(&a->commit_loaded);
1982 err = got_error_set_errno(errcode,
1983 "pthread_cond_signal");
1984 pthread_mutex_unlock(&tog_mutex);
1989 a->commits_needed = 0;
1991 if (a->commits_needed == 0) {
1992 errcode = pthread_cond_wait(&a->need_commits,
1995 err = got_error_set_errno(errcode,
1996 "pthread_cond_wait");
2000 errcode = pthread_mutex_unlock(&tog_mutex);
2001 if (errcode && err == NULL)
2002 err = got_error_set_errno(errcode,
2003 "pthread_mutex_unlock");
2005 a->log_complete = 1;
2009 static const struct got_error *
2010 stop_log_thread(struct tog_log_view_state *s)
2012 const struct got_error *err = NULL;
2017 errcode = pthread_cond_signal(&s->thread_args.need_commits);
2019 return got_error_set_errno(errcode,
2020 "pthread_cond_signal");
2021 errcode = pthread_mutex_unlock(&tog_mutex);
2023 return got_error_set_errno(errcode,
2024 "pthread_mutex_unlock");
2025 errcode = pthread_join(s->thread, (void **)&err);
2027 return got_error_set_errno(errcode, "pthread_join");
2028 errcode = pthread_mutex_lock(&tog_mutex);
2030 return got_error_set_errno(errcode,
2031 "pthread_mutex_lock");
2035 if (s->thread_args.repo) {
2036 got_repo_close(s->thread_args.repo);
2037 s->thread_args.repo = NULL;
2040 if (s->thread_args.graph) {
2041 got_commit_graph_close(s->thread_args.graph);
2042 s->thread_args.graph = NULL;
2048 static const struct got_error *
2049 close_log_view(struct tog_view *view)
2051 const struct got_error *err = NULL;
2052 struct tog_log_view_state *s = &view->state.log;
2055 err = stop_log_thread(s);
2057 errcode = pthread_cond_destroy(&s->thread_args.need_commits);
2058 if (errcode && err == NULL)
2059 err = got_error_set_errno(errcode, "pthread_cond_destroy");
2061 errcode = pthread_cond_destroy(&s->thread_args.commit_loaded);
2062 if (errcode && err == NULL)
2063 err = got_error_set_errno(errcode, "pthread_cond_destroy");
2065 free_commits(&s->commits);
2066 free(s->in_repo_path);
2067 s->in_repo_path = NULL;
2073 static const struct got_error *
2074 search_start_log_view(struct tog_view *view)
2076 struct tog_log_view_state *s = &view->state.log;
2078 s->matched_entry = NULL;
2079 s->search_entry = NULL;
2083 static const struct got_error *
2084 search_next_log_view(struct tog_view *view)
2086 const struct got_error *err = NULL;
2087 struct tog_log_view_state *s = &view->state.log;
2088 struct commit_queue_entry *entry;
2090 /* Display progress update in log view. */
2091 show_log_view(view);
2095 if (s->search_entry) {
2097 errcode = pthread_mutex_unlock(&tog_mutex);
2099 return got_error_set_errno(errcode,
2100 "pthread_mutex_unlock");
2101 ch = wgetch(view->window);
2102 errcode = pthread_mutex_lock(&tog_mutex);
2104 return got_error_set_errno(errcode,
2105 "pthread_mutex_lock");
2106 if (ch == KEY_BACKSPACE) {
2107 view->search_next_done = TOG_SEARCH_HAVE_MORE;
2110 if (view->searching == TOG_SEARCH_FORWARD)
2111 entry = TAILQ_NEXT(s->search_entry, entry);
2113 entry = TAILQ_PREV(s->search_entry,
2114 commit_queue_head, entry);
2115 } else if (s->matched_entry) {
2116 if (view->searching == TOG_SEARCH_FORWARD)
2117 entry = TAILQ_NEXT(s->matched_entry, entry);
2119 entry = TAILQ_PREV(s->matched_entry,
2120 commit_queue_head, entry);
2122 if (view->searching == TOG_SEARCH_FORWARD)
2123 entry = TAILQ_FIRST(&s->commits.head);
2125 entry = TAILQ_LAST(&s->commits.head, commit_queue_head);
2131 if (entry == NULL) {
2132 if (s->thread_args.log_complete ||
2133 view->searching == TOG_SEARCH_BACKWARD) {
2134 view->search_next_done =
2135 (s->matched_entry == NULL ?
2136 TOG_SEARCH_HAVE_NONE : TOG_SEARCH_NO_MORE);
2137 s->search_entry = NULL;
2141 * Poke the log thread for more commits and return,
2142 * allowing the main loop to make progress. Search
2143 * will resume at s->search_entry once we come back.
2145 s->thread_args.commits_needed++;
2146 return trigger_log_thread(view, 0,
2147 &s->thread_args.commits_needed,
2148 &s->thread_args.log_complete,
2149 &s->thread_args.need_commits,
2150 &s->thread_args.commit_loaded);
2153 err = match_commit(&have_match, entry->id, entry->commit,
2158 view->search_next_done = TOG_SEARCH_HAVE_MORE;
2159 s->matched_entry = entry;
2163 s->search_entry = entry;
2164 if (view->searching == TOG_SEARCH_FORWARD)
2165 entry = TAILQ_NEXT(entry, entry);
2167 entry = TAILQ_PREV(entry, commit_queue_head, entry);
2170 if (s->matched_entry) {
2171 int cur = s->selected_entry->idx;
2172 while (cur < s->matched_entry->idx) {
2173 err = input_log_view(NULL, NULL, NULL, view, KEY_DOWN);
2178 while (cur > s->matched_entry->idx) {
2179 err = input_log_view(NULL, NULL, NULL, view, KEY_UP);
2186 s->search_entry = NULL;
2191 static const struct got_error *
2192 open_log_view(struct tog_view *view, struct got_object_id *start_id,
2193 struct got_reflist_head *refs, struct got_repository *repo,
2194 const char *head_ref_name, const char *in_repo_path,
2197 const struct got_error *err = NULL;
2198 struct tog_log_view_state *s = &view->state.log;
2199 struct got_repository *thread_repo = NULL;
2200 struct got_commit_graph *thread_graph = NULL;
2203 if (in_repo_path != s->in_repo_path) {
2204 free(s->in_repo_path);
2205 s->in_repo_path = strdup(in_repo_path);
2206 if (s->in_repo_path == NULL)
2207 return got_error_from_errno("strdup");
2210 /* The commit queue only contains commits being displayed. */
2211 TAILQ_INIT(&s->commits.head);
2212 s->commits.ncommits = 0;
2216 s->head_ref_name = head_ref_name;
2217 s->start_id = got_object_id_dup(start_id);
2218 if (s->start_id == NULL) {
2219 err = got_error_from_errno("got_object_id_dup");
2222 s->log_branches = log_branches;
2224 SIMPLEQ_INIT(&s->colors);
2225 if (has_colors() && getenv("TOG_COLORS") != NULL) {
2226 err = add_color(&s->colors, "^$", TOG_COLOR_COMMIT,
2227 get_color_value("TOG_COLOR_COMMIT"));
2230 err = add_color(&s->colors, "^$", TOG_COLOR_AUTHOR,
2231 get_color_value("TOG_COLOR_AUTHOR"));
2233 free_colors(&s->colors);
2236 err = add_color(&s->colors, "^$", TOG_COLOR_DATE,
2237 get_color_value("TOG_COLOR_DATE"));
2239 free_colors(&s->colors);
2244 view->show = show_log_view;
2245 view->input = input_log_view;
2246 view->close = close_log_view;
2247 view->search_start = search_start_log_view;
2248 view->search_next = search_next_log_view;
2250 err = got_repo_open(&thread_repo, got_repo_get_path(repo), NULL);
2253 err = got_commit_graph_open(&thread_graph, s->in_repo_path,
2257 err = got_commit_graph_iter_start(thread_graph, s->start_id,
2258 s->repo, NULL, NULL);
2262 errcode = pthread_cond_init(&s->thread_args.need_commits, NULL);
2264 err = got_error_set_errno(errcode, "pthread_cond_init");
2267 errcode = pthread_cond_init(&s->thread_args.commit_loaded, NULL);
2269 err = got_error_set_errno(errcode, "pthread_cond_init");
2273 s->thread_args.commits_needed = view->nlines;
2274 s->thread_args.graph = thread_graph;
2275 s->thread_args.commits = &s->commits;
2276 s->thread_args.in_repo_path = s->in_repo_path;
2277 s->thread_args.start_id = s->start_id;
2278 s->thread_args.repo = thread_repo;
2279 s->thread_args.log_complete = 0;
2280 s->thread_args.quit = &s->quit;
2281 s->thread_args.first_displayed_entry = &s->first_displayed_entry;
2282 s->thread_args.selected_entry = &s->selected_entry;
2283 s->thread_args.searching = &view->searching;
2284 s->thread_args.search_next_done = &view->search_next_done;
2285 s->thread_args.regex = &view->regex;
2288 close_log_view(view);
2292 static const struct got_error *
2293 show_log_view(struct tog_view *view)
2295 struct tog_log_view_state *s = &view->state.log;
2297 if (s->thread == NULL) {
2298 int errcode = pthread_create(&s->thread, NULL, log_thread,
2301 return got_error_set_errno(errcode, "pthread_create");
2304 return draw_commits(view, &s->last_displayed_entry,
2305 &s->selected_entry, s->first_displayed_entry,
2306 &s->commits, s->selected, view->nlines, s->refs,
2307 s->in_repo_path, s->thread_args.commits_needed, &s->colors);
2310 static const struct got_error *
2311 input_log_view(struct tog_view **new_view, struct tog_view **dead_view,
2312 struct tog_view **focus_view, struct tog_view *view, int ch)
2314 const struct got_error *err = NULL;
2315 struct tog_log_view_state *s = &view->state.log;
2316 char *parent_path, *in_repo_path = NULL;
2317 struct tog_view *diff_view = NULL, *tree_view = NULL, *lv = NULL;
2319 struct got_object_id *start_id;
2329 if (s->first_displayed_entry == NULL)
2331 if (s->selected > 0)
2334 scroll_up(view, &s->first_displayed_entry, 1,
2339 if (s->first_displayed_entry == NULL)
2341 if (TAILQ_FIRST(&s->commits.head) ==
2342 s->first_displayed_entry) {
2346 scroll_up(view, &s->first_displayed_entry,
2347 view->nlines - 1, &s->commits);
2353 if (s->first_displayed_entry == NULL)
2355 if (s->selected < MIN(view->nlines - 2,
2356 s->commits.ncommits - 1)) {
2360 err = scroll_down(view, &s->first_displayed_entry, 1,
2361 &s->last_displayed_entry, &s->commits,
2362 &s->thread_args.log_complete,
2363 &s->thread_args.commits_needed,
2364 &s->thread_args.need_commits,
2365 &s->thread_args.commit_loaded);
2369 struct commit_queue_entry *first;
2370 first = s->first_displayed_entry;
2373 err = scroll_down(view, &s->first_displayed_entry,
2374 view->nlines - 1, &s->last_displayed_entry,
2375 &s->commits, &s->thread_args.log_complete,
2376 &s->thread_args.commits_needed,
2377 &s->thread_args.need_commits,
2378 &s->thread_args.commit_loaded);
2381 if (first == s->first_displayed_entry &&
2382 s->selected < MIN(view->nlines - 2,
2383 s->commits.ncommits - 1)) {
2384 /* can't scroll further down */
2385 s->selected = MIN(view->nlines - 2,
2386 s->commits.ncommits - 1);
2392 if (s->selected > view->nlines - 2)
2393 s->selected = view->nlines - 2;
2394 if (s->selected > s->commits.ncommits - 1)
2395 s->selected = s->commits.ncommits - 1;
2400 if (s->selected_entry == NULL)
2402 if (view_is_parent_view(view))
2403 begin_x = view_split_begin_x(view->begin_x);
2404 err = open_diff_view_for_commit(&diff_view, begin_x,
2405 s->selected_entry->commit, s->selected_entry->id,
2406 view, s->refs, s->repo);
2409 if (view_is_parent_view(view)) {
2410 err = view_close_child(view);
2413 err = view_set_child(view, diff_view);
2415 view_close(diff_view);
2418 *focus_view = diff_view;
2419 view->child_focussed = 1;
2421 *new_view = diff_view;
2424 if (s->selected_entry == NULL)
2426 if (view_is_parent_view(view))
2427 begin_x = view_split_begin_x(view->begin_x);
2428 err = browse_commit_tree(&tree_view, begin_x,
2429 s->selected_entry, s->in_repo_path, s->refs, s->repo);
2432 if (view_is_parent_view(view)) {
2433 err = view_close_child(view);
2436 err = view_set_child(view, tree_view);
2438 view_close(tree_view);
2441 *focus_view = tree_view;
2442 view->child_focussed = 1;
2444 *new_view = tree_view;
2447 if (got_path_cmp(s->in_repo_path, "/",
2448 strlen(s->in_repo_path), 1) == 0)
2450 err = got_path_dirname(&parent_path, s->in_repo_path);
2453 err = stop_log_thread(s);
2458 lv = view_open(view->nlines, view->ncols,
2459 view->begin_y, view->begin_x, TOG_VIEW_LOG);
2462 return got_error_from_errno("view_open");
2464 err = open_log_view(lv, s->start_id, s->refs,
2465 s->repo, s->head_ref_name, parent_path,
2470 if (view_is_parent_view(view))
2473 view_set_child(view->parent, lv);
2478 err = stop_log_thread(s);
2481 lv = view_open(view->nlines, view->ncols,
2482 view->begin_y, view->begin_x, TOG_VIEW_LOG);
2484 return got_error_from_errno("view_open");
2485 err = got_repo_match_object_id(&start_id, NULL,
2486 s->head_ref_name ? s->head_ref_name : GOT_REF_HEAD,
2487 GOT_OBJ_TYPE_COMMIT, 1, s->repo);
2492 in_repo_path = strdup(s->in_repo_path);
2493 if (in_repo_path == NULL) {
2496 return got_error_from_errno("strdup");
2498 got_ref_list_free(s->refs);
2499 err = got_ref_list(s->refs, s->repo, NULL,
2500 got_ref_cmp_by_name, NULL);
2506 err = open_log_view(lv, start_id, s->refs, s->repo,
2507 s->head_ref_name, in_repo_path, s->log_branches);
2517 s->log_branches = !s->log_branches;
2518 err = stop_log_thread(s);
2521 lv = view_open(view->nlines, view->ncols,
2522 view->begin_y, view->begin_x, TOG_VIEW_LOG);
2524 return got_error_from_errno("view_open");
2525 err = open_log_view(lv, s->start_id, s->refs, s->repo,
2526 s->head_ref_name, s->in_repo_path, s->log_branches);
2541 static const struct got_error *
2542 apply_unveil(const char *repo_path, const char *worktree_path)
2544 const struct got_error *error;
2547 if (unveil("gmon.out", "rwc") != 0)
2548 return got_error_from_errno2("unveil", "gmon.out");
2550 if (repo_path && unveil(repo_path, "r") != 0)
2551 return got_error_from_errno2("unveil", repo_path);
2553 if (worktree_path && unveil(worktree_path, "rwc") != 0)
2554 return got_error_from_errno2("unveil", worktree_path);
2556 if (unveil(GOT_TMPDIR_STR, "rwc") != 0)
2557 return got_error_from_errno2("unveil", GOT_TMPDIR_STR);
2559 error = got_privsep_unveil_exec_helpers();
2563 if (unveil(NULL, NULL) != 0)
2564 return got_error_from_errno("unveil");
2574 halfdelay(1); /* Do fast refresh while initial view is loading. */
2577 intrflush(stdscr, FALSE);
2578 keypad(stdscr, TRUE);
2580 if (getenv("TOG_COLORS") != NULL) {
2582 use_default_colors();
2584 signal(SIGWINCH, tog_sigwinch);
2585 signal(SIGPIPE, tog_sigpipe);
2586 signal(SIGCONT, tog_sigcont);
2589 static const struct got_error *
2590 get_in_repo_path_from_argv0(char **in_repo_path, int argc, char *argv[],
2591 struct got_repository *repo, struct got_worktree *worktree)
2593 const struct got_error *err = NULL;
2596 *in_repo_path = strdup("/");
2597 if (*in_repo_path == NULL)
2598 return got_error_from_errno("strdup");
2603 const char *prefix = got_worktree_get_path_prefix(worktree);
2606 err = got_worktree_resolve_path(&p, worktree, argv[0]);
2609 if (asprintf(in_repo_path, "%s%s%s", prefix,
2610 (p[0] != '\0' && !got_path_is_root_dir(prefix)) ? "/" : "",
2612 err = got_error_from_errno("asprintf");
2613 *in_repo_path = NULL;
2617 err = got_repo_map_path(in_repo_path, repo, argv[0]);
2622 static const struct got_error *
2623 cmd_log(int argc, char *argv[])
2625 const struct got_error *error;
2626 struct got_repository *repo = NULL;
2627 struct got_worktree *worktree = NULL;
2628 struct got_reflist_head refs;
2629 struct got_object_id *start_id = NULL;
2630 char *in_repo_path = NULL, *repo_path = NULL, *cwd = NULL;
2631 char *start_commit = NULL, *head_ref_name = NULL;
2632 int ch, log_branches = 0;
2633 struct tog_view *view;
2635 SIMPLEQ_INIT(&refs);
2638 if (pledge("stdio rpath wpath cpath flock proc tty exec sendfd unveil",
2643 while ((ch = getopt(argc, argv, "bc:r:")) != -1) {
2649 start_commit = optarg;
2652 repo_path = realpath(optarg, NULL);
2653 if (repo_path == NULL)
2654 return got_error_from_errno2("realpath",
2669 cwd = getcwd(NULL, 0);
2671 return got_error_from_errno("getcwd");
2673 error = got_worktree_open(&worktree, cwd);
2674 if (error && error->code != GOT_ERR_NOT_WORKTREE)
2677 if (repo_path == NULL) {
2680 strdup(got_worktree_get_repo_path(worktree));
2682 repo_path = strdup(cwd);
2684 if (repo_path == NULL) {
2685 error = got_error_from_errno("strdup");
2689 error = got_repo_open(&repo, repo_path, NULL);
2693 error = get_in_repo_path_from_argv0(&in_repo_path, argc, argv,
2700 error = apply_unveil(got_repo_get_path(repo),
2701 worktree ? got_worktree_get_root_path(worktree) : NULL);
2705 if (start_commit == NULL)
2706 error = got_repo_match_object_id(&start_id, NULL, worktree ?
2707 got_worktree_get_head_ref_name(worktree) : GOT_REF_HEAD,
2708 GOT_OBJ_TYPE_COMMIT, 1, repo);
2710 error = got_repo_match_object_id(&start_id, NULL, start_commit,
2711 GOT_OBJ_TYPE_COMMIT, 1, repo);
2715 error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
2719 view = view_open(0, 0, 0, 0, TOG_VIEW_LOG);
2721 error = got_error_from_errno("view_open");
2725 head_ref_name = strdup(
2726 got_worktree_get_head_ref_name(worktree));
2727 if (head_ref_name == NULL) {
2728 error = got_error_from_errno("strdup");
2732 error = open_log_view(view, start_id, &refs, repo, head_ref_name,
2733 in_repo_path, log_branches);
2737 /* Release work tree lock. */
2738 got_worktree_close(worktree);
2741 error = view_loop(view);
2747 free(head_ref_name);
2749 got_repo_close(repo);
2751 got_worktree_close(worktree);
2752 got_ref_list_free(&refs);
2760 fprintf(stderr, "usage: %s diff [-r repository-path] object1 object2\n",
2766 parse_next_line(FILE *f, size_t *len)
2771 const char delim[3] = { '\0', '\0', '\0'};
2773 line = fparseln(f, &linelen, &lineno, delim, 0);
2780 match_line(const char *line, regex_t *regex, size_t nmatch,
2781 regmatch_t *regmatch)
2783 return regexec(regex, line, nmatch, regmatch, 0) == 0;
2787 match_color(struct tog_colors *colors, const char *line)
2789 struct tog_color *tc = NULL;
2791 SIMPLEQ_FOREACH(tc, colors, entry) {
2792 if (match_line(line, &tc->regex, 0, NULL))
2799 static const struct got_error *
2800 add_matched_line(int *wtotal, const char *line, int wlimit, int col_tab_align,
2801 WINDOW *window, regmatch_t *regmatch)
2803 const struct got_error *err = NULL;
2810 s = strndup(line, regmatch->rm_so);
2812 return got_error_from_errno("strndup");
2814 err = format_line(&wline, &width, s, wlimit, col_tab_align);
2819 waddwstr(window, wline);
2826 s = strndup(line + regmatch->rm_so,
2827 regmatch->rm_eo - regmatch->rm_so);
2829 err = got_error_from_errno("strndup");
2833 err = format_line(&wline, &width, s, wlimit, col_tab_align);
2838 wattr_on(window, A_STANDOUT, NULL);
2839 waddwstr(window, wline);
2840 wattr_off(window, A_STANDOUT, NULL);
2847 if (wlimit > 0 && strlen(line) > regmatch->rm_eo) {
2848 err = format_line(&wline, &width,
2849 line + regmatch->rm_eo, wlimit, col_tab_align);
2852 waddwstr(window, wline);
2860 static const struct got_error *
2861 draw_file(struct tog_view *view, FILE *f, int first_displayed_line, int nlines,
2862 off_t *line_offsets, int selected_line, int max_lines,
2863 int *last_displayed_line, int *eof, char *header,
2864 struct tog_colors *colors, int matched_line, regmatch_t *regmatch)
2866 const struct got_error *err;
2869 struct tog_color *tc;
2875 line_offset = line_offsets[first_displayed_line - 1];
2876 if (fseeko(f, line_offset, SEEK_SET) == -1)
2877 return got_error_from_errno("fseek");
2879 werase(view->window);
2882 if (asprintf(&line, "[%d/%d] %s",
2883 first_displayed_line - 1 + selected_line, nlines,
2885 return got_error_from_errno("asprintf");
2886 err = format_line(&wline, &width, line, view->ncols, 0);
2891 if (view_needs_focus_indication(view))
2892 wstandout(view->window);
2893 waddwstr(view->window, wline);
2896 if (view_needs_focus_indication(view))
2897 wstandend(view->window);
2898 if (width <= view->ncols - 1)
2899 waddch(view->window, '\n');
2907 while (max_lines > 0 && nprinted < max_lines) {
2908 line = parse_next_line(f, &len);
2914 tc = match_color(colors, line);
2916 wattr_on(view->window,
2917 COLOR_PAIR(tc->colorpair), NULL);
2918 if (first_displayed_line + nprinted == matched_line &&
2919 regmatch->rm_so >= 0 && regmatch->rm_so < regmatch->rm_eo) {
2920 err = add_matched_line(&width, line, view->ncols, 0,
2921 view->window, regmatch);
2927 err = format_line(&wline, &width, line, view->ncols, 0);
2932 waddwstr(view->window, wline);
2937 wattr_off(view->window,
2938 COLOR_PAIR(tc->colorpair), NULL);
2939 if (width <= view->ncols - 1)
2940 waddch(view->window, '\n');
2945 *last_displayed_line = first_displayed_line + (nprinted - 1);
2947 *last_displayed_line = first_displayed_line;
2952 while (nprinted < view->nlines) {
2953 waddch(view->window, '\n');
2957 err = format_line(&wline, &width, TOG_EOF_STRING, view->ncols, 0);
2962 wstandout(view->window);
2963 waddwstr(view->window, wline);
2966 wstandend(view->window);
2973 get_datestr(time_t *time, char *datebuf)
2975 struct tm mytm, *tm;
2978 tm = gmtime_r(time, &mytm);
2981 s = asctime_r(tm, datebuf);
2984 p = strchr(s, '\n');
2990 static const struct got_error *
2991 get_changed_paths(struct got_pathlist_head *paths,
2992 struct got_commit_object *commit, struct got_repository *repo)
2994 const struct got_error *err = NULL;
2995 struct got_object_id *tree_id1 = NULL, *tree_id2 = NULL;
2996 struct got_tree_object *tree1 = NULL, *tree2 = NULL;
2997 struct got_object_qid *qid;
2999 qid = SIMPLEQ_FIRST(got_object_commit_get_parent_ids(commit));
3001 struct got_commit_object *pcommit;
3002 err = got_object_open_as_commit(&pcommit, repo,
3007 tree_id1 = got_object_commit_get_tree_id(pcommit);
3008 got_object_commit_close(pcommit);
3013 err = got_object_open_as_tree(&tree1, repo, tree_id1);
3018 tree_id2 = got_object_commit_get_tree_id(commit);
3019 err = got_object_open_as_tree(&tree2, repo, tree_id2);
3023 err = got_diff_tree(tree1, tree2, "", "", repo,
3024 got_diff_tree_collect_changed_paths, paths, 0);
3027 got_object_tree_close(tree1);
3029 got_object_tree_close(tree2);
3033 static const struct got_error *
3034 add_line_offset(off_t **line_offsets, size_t *nlines, off_t off)
3038 p = reallocarray(*line_offsets, *nlines + 1, sizeof(off_t));
3040 return got_error_from_errno("reallocarray");
3042 (*line_offsets)[*nlines] = off;
3047 static const struct got_error *
3048 write_commit_info(off_t **line_offsets, size_t *nlines,
3049 struct got_object_id *commit_id, struct got_reflist_head *refs,
3050 struct got_repository *repo, FILE *outfile)
3052 const struct got_error *err = NULL;
3053 char datebuf[26], *datestr;
3054 struct got_commit_object *commit;
3055 char *id_str = NULL, *logmsg = NULL, *s = NULL, *line;
3056 time_t committer_time;
3057 const char *author, *committer;
3058 char *refs_str = NULL;
3059 struct got_pathlist_head changed_paths;
3060 struct got_pathlist_entry *pe;
3064 TAILQ_INIT(&changed_paths);
3067 err = build_refs_str(&refs_str, refs, commit_id, repo);
3072 err = got_object_open_as_commit(&commit, repo, commit_id);
3076 err = got_object_id_str(&id_str, commit_id);
3078 err = got_error_from_errno("got_object_id_str");
3082 err = add_line_offset(line_offsets, nlines, 0);
3086 n = fprintf(outfile, "commit %s%s%s%s\n", id_str, refs_str ? " (" : "",
3087 refs_str ? refs_str : "", refs_str ? ")" : "");
3089 err = got_error_from_errno("fprintf");
3093 err = add_line_offset(line_offsets, nlines, outoff);
3097 n = fprintf(outfile, "from: %s\n",
3098 got_object_commit_get_author(commit));
3100 err = got_error_from_errno("fprintf");
3104 err = add_line_offset(line_offsets, nlines, outoff);
3108 committer_time = got_object_commit_get_committer_time(commit);
3109 datestr = get_datestr(&committer_time, datebuf);
3111 n = fprintf(outfile, "date: %s UTC\n", datestr);
3113 err = got_error_from_errno("fprintf");
3117 err = add_line_offset(line_offsets, nlines, outoff);
3121 author = got_object_commit_get_author(commit);
3122 committer = got_object_commit_get_committer(commit);
3123 if (strcmp(author, committer) != 0) {
3124 n = fprintf(outfile, "via: %s\n", committer);
3126 err = got_error_from_errno("fprintf");
3130 err = add_line_offset(line_offsets, nlines, outoff);
3134 err = got_object_commit_get_logmsg(&logmsg, commit);
3138 while ((line = strsep(&s, "\n")) != NULL) {
3139 n = fprintf(outfile, "%s\n", line);
3141 err = got_error_from_errno("fprintf");
3145 err = add_line_offset(line_offsets, nlines, outoff);
3150 err = get_changed_paths(&changed_paths, commit, repo);
3153 TAILQ_FOREACH(pe, &changed_paths, entry) {
3154 struct got_diff_changed_path *cp = pe->data;
3155 n = fprintf(outfile, "%c %s\n", cp->status, pe->path);
3157 err = got_error_from_errno("fprintf");
3161 err = add_line_offset(line_offsets, nlines, outoff);
3164 free((char *)pe->path);
3168 fputc('\n', outfile);
3170 err = add_line_offset(line_offsets, nlines, outoff);
3172 got_pathlist_free(&changed_paths);
3176 got_object_commit_close(commit);
3178 free(*line_offsets);
3179 *line_offsets = NULL;
3185 static const struct got_error *
3186 create_diff(struct tog_diff_view_state *s)
3188 const struct got_error *err = NULL;
3192 free(s->line_offsets);
3193 s->line_offsets = malloc(sizeof(off_t));
3194 if (s->line_offsets == NULL)
3195 return got_error_from_errno("malloc");
3200 err = got_error_from_errno("got_opentemp");
3203 if (s->f && fclose(s->f) != 0) {
3204 err = got_error_from_errno("fclose");
3210 err = got_object_get_type(&obj_type, s->repo, s->id1);
3212 err = got_object_get_type(&obj_type, s->repo, s->id2);
3217 case GOT_OBJ_TYPE_BLOB:
3218 err = got_diff_objects_as_blobs(&s->line_offsets, &s->nlines,
3219 s->id1, s->id2, NULL, NULL, s->diff_context, 0,
3222 case GOT_OBJ_TYPE_TREE:
3223 err = got_diff_objects_as_trees(&s->line_offsets, &s->nlines,
3224 s->id1, s->id2, "", "", s->diff_context, 0, s->repo, s->f);
3226 case GOT_OBJ_TYPE_COMMIT: {
3227 const struct got_object_id_queue *parent_ids;
3228 struct got_object_qid *pid;
3229 struct got_commit_object *commit2;
3231 err = got_object_open_as_commit(&commit2, s->repo, s->id2);
3234 /* Show commit info if we're diffing to a parent/root commit. */
3235 if (s->id1 == NULL) {
3236 err = write_commit_info(&s->line_offsets, &s->nlines,
3237 s->id2, s->refs, s->repo, s->f);
3241 parent_ids = got_object_commit_get_parent_ids(commit2);
3242 SIMPLEQ_FOREACH(pid, parent_ids, entry) {
3243 if (got_object_id_cmp(s->id1, pid->id) == 0) {
3244 err = write_commit_info(
3245 &s->line_offsets, &s->nlines,
3246 s->id2, s->refs, s->repo, s->f);
3253 got_object_commit_close(commit2);
3255 err = got_diff_objects_as_commits(&s->line_offsets, &s->nlines,
3256 s->id1, s->id2, s->diff_context, 0, s->repo, s->f);
3260 err = got_error(GOT_ERR_OBJ_TYPE);
3266 if (s->f && fflush(s->f) != 0 && err == NULL)
3267 err = got_error_from_errno("fflush");
3272 diff_view_indicate_progress(struct tog_view *view)
3274 mvwaddstr(view->window, 0, 0, "diffing...");
3279 static const struct got_error *
3280 search_start_diff_view(struct tog_view *view)
3282 struct tog_diff_view_state *s = &view->state.diff;
3284 s->matched_line = 0;
3288 static const struct got_error *
3289 search_next_diff_view(struct tog_view *view)
3291 struct tog_diff_view_state *s = &view->state.diff;
3294 if (!view->searching) {
3295 view->search_next_done = TOG_SEARCH_HAVE_MORE;
3299 if (s->matched_line) {
3300 if (view->searching == TOG_SEARCH_FORWARD)
3301 lineno = s->matched_line + 1;
3303 lineno = s->matched_line - 1;
3305 if (view->searching == TOG_SEARCH_FORWARD)
3316 if (lineno <= 0 || lineno > s->nlines) {
3317 if (s->matched_line == 0) {
3318 view->search_next_done = TOG_SEARCH_HAVE_MORE;
3323 if (view->searching == TOG_SEARCH_FORWARD)
3329 offset = s->line_offsets[lineno - 1];
3330 if (fseeko(s->f, offset, SEEK_SET) != 0) {
3332 return got_error_from_errno("fseeko");
3335 line = parse_next_line(s->f, &len);
3337 match_line(line, &view->regex, 1, &view->regmatch)) {
3338 view->search_next_done = TOG_SEARCH_HAVE_MORE;
3339 s->matched_line = lineno;
3344 if (view->searching == TOG_SEARCH_FORWARD)
3350 if (s->matched_line) {
3351 s->first_displayed_line = s->matched_line;
3352 s->selected_line = 1;
3358 static const struct got_error *
3359 open_diff_view(struct tog_view *view, struct got_object_id *id1,
3360 struct got_object_id *id2, struct tog_view *log_view,
3361 struct got_reflist_head *refs, struct got_repository *repo)
3363 const struct got_error *err;
3364 struct tog_diff_view_state *s = &view->state.diff;
3366 if (id1 != NULL && id2 != NULL) {
3368 err = got_object_get_type(&type1, repo, id1);
3371 err = got_object_get_type(&type2, repo, id2);
3376 return got_error(GOT_ERR_OBJ_TYPE);
3378 s->first_displayed_line = 1;
3379 s->last_displayed_line = view->nlines;
3380 s->selected_line = 1;
3387 s->id1 = got_object_id_dup(id1);
3389 return got_error_from_errno("got_object_id_dup");
3393 s->id2 = got_object_id_dup(id2);
3394 if (s->id2 == NULL) {
3397 return got_error_from_errno("got_object_id_dup");
3400 s->first_displayed_line = 1;
3401 s->last_displayed_line = view->nlines;
3402 s->diff_context = 3;
3403 s->log_view = log_view;
3407 SIMPLEQ_INIT(&s->colors);
3408 if (has_colors() && getenv("TOG_COLORS") != NULL) {
3409 err = add_color(&s->colors,
3410 "^-", TOG_COLOR_DIFF_MINUS,
3411 get_color_value("TOG_COLOR_DIFF_MINUS"));
3414 err = add_color(&s->colors, "^\\+",
3415 TOG_COLOR_DIFF_PLUS,
3416 get_color_value("TOG_COLOR_DIFF_PLUS"));
3418 free_colors(&s->colors);
3421 err = add_color(&s->colors,
3422 "^@@", TOG_COLOR_DIFF_CHUNK_HEADER,
3423 get_color_value("TOG_COLOR_DIFF_CHUNK_HEADER"));
3425 free_colors(&s->colors);
3429 err = add_color(&s->colors,
3430 "^(commit [0-9a-f]|(blob|file) [-+] |[MDmA] [^ ])",
3431 TOG_COLOR_DIFF_META,
3432 get_color_value("TOG_COLOR_DIFF_META"));
3434 free_colors(&s->colors);
3438 err = add_color(&s->colors,
3439 "^(from|via): ", TOG_COLOR_AUTHOR,
3440 get_color_value("TOG_COLOR_AUTHOR"));
3442 free_colors(&s->colors);
3446 err = add_color(&s->colors,
3447 "^date: ", TOG_COLOR_DATE,
3448 get_color_value("TOG_COLOR_DATE"));
3450 free_colors(&s->colors);
3455 if (log_view && view_is_splitscreen(view))
3456 show_log_view(log_view); /* draw vborder */
3457 diff_view_indicate_progress(view);
3459 s->line_offsets = NULL;
3461 err = create_diff(s);
3470 view->show = show_diff_view;
3471 view->input = input_diff_view;
3472 view->close = close_diff_view;
3473 view->search_start = search_start_diff_view;
3474 view->search_next = search_next_diff_view;
3479 static const struct got_error *
3480 close_diff_view(struct tog_view *view)
3482 const struct got_error *err = NULL;
3483 struct tog_diff_view_state *s = &view->state.diff;
3489 if (s->f && fclose(s->f) == EOF)
3490 err = got_error_from_errno("fclose");
3491 free_colors(&s->colors);
3492 free(s->line_offsets);
3493 s->line_offsets = NULL;
3498 static const struct got_error *
3499 show_diff_view(struct tog_view *view)
3501 const struct got_error *err;
3502 struct tog_diff_view_state *s = &view->state.diff;
3503 char *id_str1 = NULL, *id_str2, *header;
3506 err = got_object_id_str(&id_str1, s->id1);
3510 err = got_object_id_str(&id_str2, s->id2);
3514 if (asprintf(&header, "diff %s %s",
3515 id_str1 ? id_str1 : "/dev/null", id_str2) == -1) {
3516 err = got_error_from_errno("asprintf");
3524 return draw_file(view, s->f, s->first_displayed_line, s->nlines,
3525 s->line_offsets, s->selected_line, view->nlines,
3526 &s->last_displayed_line, &s->eof, header, &s->colors,
3527 s->matched_line, &view->regmatch);
3530 static const struct got_error *
3531 set_selected_commit(struct tog_diff_view_state *s,
3532 struct commit_queue_entry *entry)
3534 const struct got_error *err;
3535 const struct got_object_id_queue *parent_ids;
3536 struct got_commit_object *selected_commit;
3537 struct got_object_qid *pid;
3540 s->id2 = got_object_id_dup(entry->id);
3542 return got_error_from_errno("got_object_id_dup");
3544 err = got_object_open_as_commit(&selected_commit, s->repo, entry->id);
3547 parent_ids = got_object_commit_get_parent_ids(selected_commit);
3549 pid = SIMPLEQ_FIRST(parent_ids);
3550 s->id1 = pid ? got_object_id_dup(pid->id) : NULL;
3551 got_object_commit_close(selected_commit);
3555 static const struct got_error *
3556 input_diff_view(struct tog_view **new_view, struct tog_view **dead_view,
3557 struct tog_view **focus_view, struct tog_view *view, int ch)
3559 const struct got_error *err = NULL;
3560 struct tog_diff_view_state *s = &view->state.diff;
3561 struct tog_log_view_state *ls;
3562 struct commit_queue_entry *entry;
3568 if (s->first_displayed_line > 1)
3569 s->first_displayed_line--;
3573 if (s->first_displayed_line == 1)
3576 while (i++ < view->nlines - 1 &&
3577 s->first_displayed_line > 1)
3578 s->first_displayed_line--;
3583 s->first_displayed_line++;
3591 while (!s->eof && i++ < view->nlines - 1) {
3593 line = parse_next_line(s->f, NULL);
3594 s->first_displayed_line++;
3600 if (s->diff_context > 0) {
3602 diff_view_indicate_progress(view);
3603 err = create_diff(s);
3607 if (s->diff_context < GOT_DIFF_MAX_CONTEXT) {
3609 diff_view_indicate_progress(view);
3610 err = create_diff(s);
3615 if (s->log_view == NULL)
3617 ls = &s->log_view->state.log;
3618 entry = TAILQ_PREV(ls->selected_entry,
3619 commit_queue_head, entry);
3623 err = input_log_view(NULL, NULL, NULL, s->log_view,
3628 err = set_selected_commit(s, entry);
3632 s->first_displayed_line = 1;
3633 s->last_displayed_line = view->nlines;
3635 diff_view_indicate_progress(view);
3636 err = create_diff(s);
3640 if (s->log_view == NULL)
3642 ls = &s->log_view->state.log;
3644 if (TAILQ_NEXT(ls->selected_entry, entry) == NULL) {
3645 ls->thread_args.commits_needed++;
3646 err = trigger_log_thread(s->log_view, 1,
3647 &ls->thread_args.commits_needed,
3648 &ls->thread_args.log_complete,
3649 &ls->thread_args.need_commits,
3650 &ls->thread_args.commit_loaded);
3654 err = input_log_view(NULL, NULL, NULL, s->log_view,
3659 entry = TAILQ_NEXT(ls->selected_entry, entry);
3663 err = set_selected_commit(s, entry);
3667 s->first_displayed_line = 1;
3668 s->last_displayed_line = view->nlines;
3670 diff_view_indicate_progress(view);
3671 err = create_diff(s);
3680 static const struct got_error *
3681 cmd_diff(int argc, char *argv[])
3683 const struct got_error *error = NULL;
3684 struct got_repository *repo = NULL;
3685 struct got_worktree *worktree = NULL;
3686 struct got_reflist_head refs;
3687 struct got_object_id *id1 = NULL, *id2 = NULL;
3688 char *repo_path = NULL, *cwd = NULL;
3689 char *id_str1 = NULL, *id_str2 = NULL;
3691 struct tog_view *view;
3693 SIMPLEQ_INIT(&refs);
3696 if (pledge("stdio rpath wpath cpath flock proc tty exec sendfd unveil",
3701 while ((ch = getopt(argc, argv, "r:")) != -1) {
3704 repo_path = realpath(optarg, NULL);
3705 if (repo_path == NULL)
3706 return got_error_from_errno2("realpath",
3719 usage_diff(); /* TODO show local worktree changes */
3720 } else if (argc == 2) {
3726 cwd = getcwd(NULL, 0);
3728 return got_error_from_errno("getcwd");
3730 error = got_worktree_open(&worktree, cwd);
3731 if (error && error->code != GOT_ERR_NOT_WORKTREE)
3734 if (repo_path == NULL) {
3737 strdup(got_worktree_get_repo_path(worktree));
3739 repo_path = strdup(cwd);
3741 if (repo_path == NULL) {
3742 error = got_error_from_errno("strdup");
3746 error = got_repo_open(&repo, repo_path, NULL);
3752 error = apply_unveil(got_repo_get_path(repo), NULL);
3756 error = got_repo_match_object_id_prefix(&id1, id_str1,
3757 GOT_OBJ_TYPE_ANY, repo);
3761 error = got_repo_match_object_id_prefix(&id2, id_str2,
3762 GOT_OBJ_TYPE_ANY, repo);
3766 error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
3770 view = view_open(0, 0, 0, 0, TOG_VIEW_DIFF);
3772 error = got_error_from_errno("view_open");
3775 error = open_diff_view(view, id1, id2, NULL, &refs, repo);
3778 error = view_loop(view);
3783 got_repo_close(repo);
3785 got_worktree_close(worktree);
3786 got_ref_list_free(&refs);
3794 fprintf(stderr, "usage: %s blame [-c commit] [-r repository-path] path\n",
3799 struct tog_blame_line {
3801 struct got_object_id *id;
3804 static const struct got_error *
3805 draw_blame(struct tog_view *view, struct got_object_id *id, FILE *f,
3806 const char *path, struct tog_blame_line *lines, int nlines,
3807 int blame_complete, int selected_line, int *first_displayed_line,
3808 int *last_displayed_line, int *eof, int max_lines,
3809 struct tog_colors *colors, int matched_line, regmatch_t *regmatch)
3811 const struct got_error *err;
3812 int lineno = 0, nprinted = 0;
3817 struct tog_blame_line *blame_line;
3818 struct got_object_id *prev_id = NULL;
3820 struct tog_color *tc;
3822 err = got_object_id_str(&id_str, id);
3827 werase(view->window);
3829 if (asprintf(&line, "commit %s", id_str) == -1) {
3830 err = got_error_from_errno("asprintf");
3835 err = format_line(&wline, &width, line, view->ncols, 0);
3840 if (view_needs_focus_indication(view))
3841 wstandout(view->window);
3842 tc = get_color(colors, TOG_COLOR_COMMIT);
3844 wattr_on(view->window,
3845 COLOR_PAIR(tc->colorpair), NULL);
3846 waddwstr(view->window, wline);
3848 wattr_off(view->window,
3849 COLOR_PAIR(tc->colorpair), NULL);
3850 if (view_needs_focus_indication(view))
3851 wstandend(view->window);
3854 if (width < view->ncols - 1)
3855 waddch(view->window, '\n');
3857 if (asprintf(&line, "[%d/%d] %s%s",
3858 *first_displayed_line - 1 + selected_line, nlines,
3859 blame_complete ? "" : "annotating... ", path) == -1) {
3861 return got_error_from_errno("asprintf");
3864 err = format_line(&wline, &width, line, view->ncols, 0);
3869 waddwstr(view->window, wline);
3872 if (width < view->ncols - 1)
3873 waddch(view->window, '\n');
3876 while (nprinted < max_lines - 2) {
3877 line = parse_next_line(f, &len);
3882 if (++lineno < *first_displayed_line) {
3887 if (view->focussed && nprinted == selected_line - 1)
3888 wstandout(view->window);
3891 blame_line = &lines[lineno - 1];
3892 if (blame_line->annotated && prev_id &&
3893 got_object_id_cmp(prev_id, blame_line->id) == 0 &&
3895 nprinted == selected_line - 1)) {
3896 waddstr(view->window, " ");
3897 } else if (blame_line->annotated) {
3899 err = got_object_id_str(&id_str, blame_line->id);
3904 tc = get_color(colors, TOG_COLOR_COMMIT);
3906 wattr_on(view->window,
3907 COLOR_PAIR(tc->colorpair), NULL);
3908 wprintw(view->window, "%.8s", id_str);
3910 wattr_off(view->window,
3911 COLOR_PAIR(tc->colorpair), NULL);
3913 prev_id = blame_line->id;
3915 waddstr(view->window, "........");
3919 waddstr(view->window, "........");
3923 if (view->focussed && nprinted == selected_line - 1)
3924 wstandend(view->window);
3925 waddstr(view->window, " ");
3927 if (view->ncols <= 9) {
3929 wline = wcsdup(L"");
3930 if (wline == NULL) {
3931 err = got_error_from_errno("wcsdup");
3935 } else if (*first_displayed_line + nprinted == matched_line &&
3936 regmatch->rm_so >= 0 && regmatch->rm_so < regmatch->rm_eo) {
3937 err = add_matched_line(&width, line, view->ncols - 9, 9,
3938 view->window, regmatch);
3945 err = format_line(&wline, &width, line,
3946 view->ncols - 9, 9);
3947 waddwstr(view->window, wline);
3953 if (width <= view->ncols - 1)
3954 waddch(view->window, '\n');
3955 if (++nprinted == 1)
3956 *first_displayed_line = lineno;
3959 *last_displayed_line = lineno;
3966 static const struct got_error *
3967 blame_cb(void *arg, int nlines, int lineno, struct got_object_id *id)
3969 const struct got_error *err = NULL;
3970 struct tog_blame_cb_args *a = arg;
3971 struct tog_blame_line *line;
3974 if (nlines != a->nlines ||
3975 (lineno != -1 && lineno < 1) || lineno > a->nlines)
3976 return got_error(GOT_ERR_RANGE);
3978 errcode = pthread_mutex_lock(&tog_mutex);
3980 return got_error_set_errno(errcode, "pthread_mutex_lock");
3982 if (*a->quit) { /* user has quit the blame view */
3983 err = got_error(GOT_ERR_ITER_COMPLETED);
3988 goto done; /* no change in this commit */
3990 line = &a->lines[lineno - 1];
3991 if (line->annotated)
3994 line->id = got_object_id_dup(id);
3995 if (line->id == NULL) {
3996 err = got_error_from_errno("got_object_id_dup");
3999 line->annotated = 1;
4001 errcode = pthread_mutex_unlock(&tog_mutex);
4003 err = got_error_set_errno(errcode, "pthread_mutex_unlock");
4008 blame_thread(void *arg)
4010 const struct got_error *err;
4011 struct tog_blame_thread_args *ta = arg;
4012 struct tog_blame_cb_args *a = ta->cb_args;
4015 err = block_signals_used_by_main_thread();
4019 err = got_blame(ta->path, a->commit_id, ta->repo,
4020 blame_cb, ta->cb_args, ta->cancel_cb, ta->cancel_arg);
4021 if (err && err->code == GOT_ERR_CANCELLED)
4024 errcode = pthread_mutex_lock(&tog_mutex);
4026 return (void *)got_error_set_errno(errcode,
4027 "pthread_mutex_lock");
4029 got_repo_close(ta->repo);
4033 errcode = pthread_mutex_unlock(&tog_mutex);
4034 if (errcode && err == NULL)
4035 err = got_error_set_errno(errcode, "pthread_mutex_unlock");
4040 static struct got_object_id *
4041 get_selected_commit_id(struct tog_blame_line *lines, int nlines,
4042 int first_displayed_line, int selected_line)
4044 struct tog_blame_line *line;
4049 line = &lines[first_displayed_line - 1 + selected_line - 1];
4050 if (!line->annotated)
4056 static const struct got_error *
4057 stop_blame(struct tog_blame *blame)
4059 const struct got_error *err = NULL;
4062 if (blame->thread) {
4064 errcode = pthread_mutex_unlock(&tog_mutex);
4066 return got_error_set_errno(errcode,
4067 "pthread_mutex_unlock");
4068 errcode = pthread_join(blame->thread, (void **)&err);
4070 return got_error_set_errno(errcode, "pthread_join");
4071 errcode = pthread_mutex_lock(&tog_mutex);
4073 return got_error_set_errno(errcode,
4074 "pthread_mutex_lock");
4075 if (err && err->code == GOT_ERR_ITER_COMPLETED)
4077 blame->thread = NULL;
4079 if (blame->thread_args.repo) {
4080 got_repo_close(blame->thread_args.repo);
4081 blame->thread_args.repo = NULL;
4084 if (fclose(blame->f) != 0 && err == NULL)
4085 err = got_error_from_errno("fclose");
4089 for (i = 0; i < blame->nlines; i++)
4090 free(blame->lines[i].id);
4092 blame->lines = NULL;
4094 free(blame->cb_args.commit_id);
4095 blame->cb_args.commit_id = NULL;
4100 static const struct got_error *
4101 cancel_blame_view(void *arg)
4103 const struct got_error *err = NULL;
4107 errcode = pthread_mutex_lock(&tog_mutex);
4109 return got_error_set_errno(errcode,
4110 "pthread_mutex_unlock");
4113 err = got_error(GOT_ERR_CANCELLED);
4115 errcode = pthread_mutex_unlock(&tog_mutex);
4117 return got_error_set_errno(errcode,
4118 "pthread_mutex_lock");
4123 static const struct got_error *
4124 run_blame(struct tog_blame *blame, struct tog_view *view, int *blame_complete,
4125 int *first_displayed_line, int *last_displayed_line, int *selected_line,
4126 int *done, int *eof, const char *path, struct got_object_id *commit_id,
4127 struct got_repository *repo)
4129 const struct got_error *err = NULL;
4130 struct got_blob_object *blob = NULL;
4131 struct got_repository *thread_repo = NULL;
4132 struct got_object_id *obj_id = NULL;
4135 err = got_object_id_by_path(&obj_id, repo, commit_id, path);
4139 err = got_object_get_type(&obj_type, repo, obj_id);
4143 if (obj_type != GOT_OBJ_TYPE_BLOB) {
4144 err = got_error(GOT_ERR_OBJ_TYPE);
4148 err = got_object_open_as_blob(&blob, repo, obj_id, 8192);
4151 blame->f = got_opentemp();
4152 if (blame->f == NULL) {
4153 err = got_error_from_errno("got_opentemp");
4156 err = got_object_blob_dump_to_file(&blame->filesize, &blame->nlines,
4157 &blame->line_offsets, blame->f, blob);
4158 if (err || blame->nlines == 0)
4161 /* Don't include \n at EOF in the blame line count. */
4162 if (blame->line_offsets[blame->nlines - 1] == blame->filesize)
4165 blame->lines = calloc(blame->nlines, sizeof(*blame->lines));
4166 if (blame->lines == NULL) {
4167 err = got_error_from_errno("calloc");
4171 err = got_repo_open(&thread_repo, got_repo_get_path(repo), NULL);
4175 blame->cb_args.view = view;
4176 blame->cb_args.lines = blame->lines;
4177 blame->cb_args.nlines = blame->nlines;
4178 blame->cb_args.commit_id = got_object_id_dup(commit_id);
4179 if (blame->cb_args.commit_id == NULL) {
4180 err = got_error_from_errno("got_object_id_dup");
4183 blame->cb_args.quit = done;
4185 blame->thread_args.path = path;
4186 blame->thread_args.repo = thread_repo;
4187 blame->thread_args.cb_args = &blame->cb_args;
4188 blame->thread_args.complete = blame_complete;
4189 blame->thread_args.cancel_cb = cancel_blame_view;
4190 blame->thread_args.cancel_arg = done;
4191 *blame_complete = 0;
4195 got_object_blob_close(blob);
4202 static const struct got_error *
4203 open_blame_view(struct tog_view *view, char *path,
4204 struct got_object_id *commit_id, struct got_reflist_head *refs,
4205 struct got_repository *repo)
4207 const struct got_error *err = NULL;
4208 struct tog_blame_view_state *s = &view->state.blame;
4210 SIMPLEQ_INIT(&s->blamed_commits);
4212 s->path = strdup(path);
4213 if (s->path == NULL)
4214 return got_error_from_errno("strdup");
4216 err = got_object_qid_alloc(&s->blamed_commit, commit_id);
4222 SIMPLEQ_INSERT_HEAD(&s->blamed_commits, s->blamed_commit, entry);
4223 s->first_displayed_line = 1;
4224 s->last_displayed_line = view->nlines;
4225 s->selected_line = 1;
4226 s->blame_complete = 0;
4229 s->commit_id = commit_id;
4230 memset(&s->blame, 0, sizeof(s->blame));
4232 SIMPLEQ_INIT(&s->colors);
4233 if (has_colors() && getenv("TOG_COLORS") != NULL) {
4234 err = add_color(&s->colors, "^", TOG_COLOR_COMMIT,
4235 get_color_value("TOG_COLOR_COMMIT"));
4240 view->show = show_blame_view;
4241 view->input = input_blame_view;
4242 view->close = close_blame_view;
4243 view->search_start = search_start_blame_view;
4244 view->search_next = search_next_blame_view;
4246 return run_blame(&s->blame, view, &s->blame_complete,
4247 &s->first_displayed_line, &s->last_displayed_line,
4248 &s->selected_line, &s->done, &s->eof, s->path,
4249 s->blamed_commit->id, s->repo);
4252 static const struct got_error *
4253 close_blame_view(struct tog_view *view)
4255 const struct got_error *err = NULL;
4256 struct tog_blame_view_state *s = &view->state.blame;
4258 if (s->blame.thread)
4259 err = stop_blame(&s->blame);
4261 while (!SIMPLEQ_EMPTY(&s->blamed_commits)) {
4262 struct got_object_qid *blamed_commit;
4263 blamed_commit = SIMPLEQ_FIRST(&s->blamed_commits);
4264 SIMPLEQ_REMOVE_HEAD(&s->blamed_commits, entry);
4265 got_object_qid_free(blamed_commit);
4269 free_colors(&s->colors);
4274 static const struct got_error *
4275 search_start_blame_view(struct tog_view *view)
4277 struct tog_blame_view_state *s = &view->state.blame;
4279 s->matched_line = 0;
4283 static const struct got_error *
4284 search_next_blame_view(struct tog_view *view)
4286 struct tog_blame_view_state *s = &view->state.blame;
4289 if (!view->searching) {
4290 view->search_next_done = TOG_SEARCH_HAVE_MORE;
4294 if (s->matched_line) {
4295 if (view->searching == TOG_SEARCH_FORWARD)
4296 lineno = s->matched_line + 1;
4298 lineno = s->matched_line - 1;
4300 if (view->searching == TOG_SEARCH_FORWARD)
4303 lineno = s->blame.nlines;
4311 if (lineno <= 0 || lineno > s->blame.nlines) {
4312 if (s->matched_line == 0) {
4313 view->search_next_done = TOG_SEARCH_HAVE_MORE;
4318 if (view->searching == TOG_SEARCH_FORWARD)
4321 lineno = s->blame.nlines;
4324 offset = s->blame.line_offsets[lineno - 1];
4325 if (fseeko(s->blame.f, offset, SEEK_SET) != 0) {
4327 return got_error_from_errno("fseeko");
4330 line = parse_next_line(s->blame.f, &len);
4332 match_line(line, &view->regex, 1, &view->regmatch)) {
4333 view->search_next_done = TOG_SEARCH_HAVE_MORE;
4334 s->matched_line = lineno;
4339 if (view->searching == TOG_SEARCH_FORWARD)
4345 if (s->matched_line) {
4346 s->first_displayed_line = s->matched_line;
4347 s->selected_line = 1;
4353 static const struct got_error *
4354 show_blame_view(struct tog_view *view)
4356 const struct got_error *err = NULL;
4357 struct tog_blame_view_state *s = &view->state.blame;
4360 if (s->blame.thread == NULL) {
4361 errcode = pthread_create(&s->blame.thread, NULL, blame_thread,
4362 &s->blame.thread_args);
4364 return got_error_set_errno(errcode, "pthread_create");
4366 halfdelay(1); /* fast refresh while annotating */
4369 if (s->blame_complete)
4370 halfdelay(10); /* disable fast refresh */
4372 err = draw_blame(view, s->blamed_commit->id, s->blame.f,
4373 s->path, s->blame.lines, s->blame.nlines, s->blame_complete,
4374 s->selected_line, &s->first_displayed_line,
4375 &s->last_displayed_line, &s->eof, view->nlines, &s->colors,
4376 s->matched_line, &view->regmatch);
4382 static const struct got_error *
4383 input_blame_view(struct tog_view **new_view, struct tog_view **dead_view,
4384 struct tog_view **focus_view, struct tog_view *view, int ch)
4386 const struct got_error *err = NULL, *thread_err = NULL;
4387 struct tog_view *diff_view;
4388 struct tog_blame_view_state *s = &view->state.blame;
4397 if (s->selected_line > 1)
4399 else if (s->selected_line == 1 &&
4400 s->first_displayed_line > 1)
4401 s->first_displayed_line--;
4405 if (s->first_displayed_line == 1) {
4406 s->selected_line = 1;
4409 if (s->first_displayed_line > view->nlines - 2)
4410 s->first_displayed_line -=
4413 s->first_displayed_line = 1;
4417 if (s->selected_line < view->nlines - 2 &&
4418 s->first_displayed_line +
4419 s->selected_line <= s->blame.nlines)
4421 else if (s->last_displayed_line <
4423 s->first_displayed_line++;
4427 struct got_object_id *id = NULL;
4428 id = get_selected_commit_id(s->blame.lines, s->blame.nlines,
4429 s->first_displayed_line, s->selected_line);
4433 struct got_commit_object *commit;
4434 struct got_object_qid *pid;
4435 struct got_object_id *blob_id = NULL;
4437 err = got_object_open_as_commit(&commit,
4441 pid = SIMPLEQ_FIRST(
4442 got_object_commit_get_parent_ids(commit));
4444 got_object_commit_close(commit);
4447 /* Check if path history ends here. */
4448 err = got_object_id_by_path(&blob_id, s->repo,
4451 if (err->code == GOT_ERR_NO_TREE_ENTRY)
4453 got_object_commit_close(commit);
4456 err = got_object_get_type(&obj_type, s->repo,
4459 /* Can't blame non-blob type objects. */
4460 if (obj_type != GOT_OBJ_TYPE_BLOB) {
4461 got_object_commit_close(commit);
4464 err = got_object_qid_alloc(&s->blamed_commit,
4466 got_object_commit_close(commit);
4468 if (got_object_id_cmp(id,
4469 s->blamed_commit->id) == 0)
4471 err = got_object_qid_alloc(&s->blamed_commit,
4477 thread_err = stop_blame(&s->blame);
4481 SIMPLEQ_INSERT_HEAD(&s->blamed_commits,
4482 s->blamed_commit, entry);
4483 err = run_blame(&s->blame, view, &s->blame_complete,
4484 &s->first_displayed_line, &s->last_displayed_line,
4485 &s->selected_line, &s->done, &s->eof,
4486 s->path, s->blamed_commit->id, s->repo);
4492 struct got_object_qid *first;
4493 first = SIMPLEQ_FIRST(&s->blamed_commits);
4494 if (!got_object_id_cmp(first->id, s->commit_id))
4497 thread_err = stop_blame(&s->blame);
4501 SIMPLEQ_REMOVE_HEAD(&s->blamed_commits, entry);
4502 got_object_qid_free(s->blamed_commit);
4504 SIMPLEQ_FIRST(&s->blamed_commits);
4505 err = run_blame(&s->blame, view, &s->blame_complete,
4506 &s->first_displayed_line, &s->last_displayed_line,
4507 &s->selected_line, &s->done, &s->eof, s->path,
4508 s->blamed_commit->id, s->repo);
4515 struct got_object_id *id = NULL;
4516 struct got_object_qid *pid;
4517 struct got_commit_object *commit = NULL;
4518 id = get_selected_commit_id(s->blame.lines, s->blame.nlines,
4519 s->first_displayed_line, s->selected_line);
4522 err = got_object_open_as_commit(&commit, s->repo, id);
4525 pid = SIMPLEQ_FIRST(
4526 got_object_commit_get_parent_ids(commit));
4527 if (view_is_parent_view(view))
4528 begin_x = view_split_begin_x(view->begin_x);
4529 diff_view = view_open(0, 0, 0, begin_x, TOG_VIEW_DIFF);
4530 if (diff_view == NULL) {
4531 got_object_commit_close(commit);
4532 err = got_error_from_errno("view_open");
4535 err = open_diff_view(diff_view, pid ? pid->id : NULL,
4536 id, NULL, s->refs, s->repo);
4537 got_object_commit_close(commit);
4539 view_close(diff_view);
4542 if (view_is_parent_view(view)) {
4543 err = view_close_child(view);
4546 err = view_set_child(view, diff_view);
4548 view_close(diff_view);
4551 *focus_view = diff_view;
4552 view->child_focussed = 1;
4554 *new_view = diff_view;
4562 if (s->last_displayed_line >= s->blame.nlines &&
4563 s->selected_line >= MIN(s->blame.nlines,
4564 view->nlines - 2)) {
4567 if (s->last_displayed_line >= s->blame.nlines &&
4568 s->selected_line < view->nlines - 2) {
4569 s->selected_line = MIN(s->blame.nlines,
4573 if (s->last_displayed_line + view->nlines - 2
4575 s->first_displayed_line +=
4578 s->first_displayed_line =
4583 if (s->selected_line > view->nlines - 2) {
4584 s->selected_line = MIN(s->blame.nlines,
4591 return thread_err ? thread_err : err;
4594 static const struct got_error *
4595 cmd_blame(int argc, char *argv[])
4597 const struct got_error *error;
4598 struct got_repository *repo = NULL;
4599 struct got_reflist_head refs;
4600 struct got_worktree *worktree = NULL;
4601 char *cwd = NULL, *repo_path = NULL, *in_repo_path = NULL;
4602 char *link_target = NULL;
4603 struct got_object_id *commit_id = NULL;
4604 char *commit_id_str = NULL;
4606 struct tog_view *view;
4608 SIMPLEQ_INIT(&refs);
4611 if (pledge("stdio rpath wpath cpath flock proc tty exec sendfd unveil",
4616 while ((ch = getopt(argc, argv, "c:r:")) != -1) {
4619 commit_id_str = optarg;
4622 repo_path = realpath(optarg, NULL);
4623 if (repo_path == NULL)
4624 return got_error_from_errno2("realpath",
4639 cwd = getcwd(NULL, 0);
4641 return got_error_from_errno("getcwd");
4643 error = got_worktree_open(&worktree, cwd);
4644 if (error && error->code != GOT_ERR_NOT_WORKTREE)
4647 if (repo_path == NULL) {
4650 strdup(got_worktree_get_repo_path(worktree));
4652 repo_path = strdup(cwd);
4654 if (repo_path == NULL) {
4655 error = got_error_from_errno("strdup");
4659 error = got_repo_open(&repo, repo_path, NULL);
4663 error = get_in_repo_path_from_argv0(&in_repo_path, argc, argv, repo,
4670 error = apply_unveil(got_repo_get_path(repo), NULL);
4674 if (commit_id_str == NULL) {
4675 struct got_reference *head_ref;
4676 error = got_ref_open(&head_ref, repo, worktree ?
4677 got_worktree_get_head_ref_name(worktree) : GOT_REF_HEAD, 0);
4680 error = got_ref_resolve(&commit_id, repo, head_ref);
4681 got_ref_close(head_ref);
4683 error = got_repo_match_object_id(&commit_id, NULL,
4684 commit_id_str, GOT_OBJ_TYPE_COMMIT, 1, repo);
4689 error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
4693 view = view_open(0, 0, 0, 0, TOG_VIEW_BLAME);
4695 error = got_error_from_errno("view_open");
4699 error = got_object_resolve_symlinks(&link_target, in_repo_path,
4704 error = open_blame_view(view, link_target ? link_target : in_repo_path,
4705 commit_id, &refs, repo);
4709 /* Release work tree lock. */
4710 got_worktree_close(worktree);
4713 error = view_loop(view);
4721 got_worktree_close(worktree);
4723 got_repo_close(repo);
4724 got_ref_list_free(&refs);
4728 static const struct got_error *
4729 draw_tree_entries(struct tog_view *view,
4730 struct got_tree_entry **first_displayed_entry,
4731 struct got_tree_entry **last_displayed_entry,
4732 struct got_tree_entry **selected_entry, int *ndisplayed,
4733 const char *label, int show_ids, const char *parent_path,
4734 struct got_tree_object *tree, int selected, int limit,
4735 int isroot, struct tog_colors *colors, struct got_repository *repo)
4737 const struct got_error *err = NULL;
4738 struct got_tree_entry *te;
4740 struct tog_color *tc;
4741 int width, n, i, nentries;
4745 werase(view->window);
4750 err = format_line(&wline, &width, label, view->ncols, 0);
4753 if (view_needs_focus_indication(view))
4754 wstandout(view->window);
4755 tc = get_color(colors, TOG_COLOR_COMMIT);
4757 wattr_on(view->window,
4758 COLOR_PAIR(tc->colorpair), NULL);
4759 waddwstr(view->window, wline);
4761 wattr_off(view->window,
4762 COLOR_PAIR(tc->colorpair), NULL);
4763 if (view_needs_focus_indication(view))
4764 wstandend(view->window);
4767 if (width < view->ncols - 1)
4768 waddch(view->window, '\n');
4771 err = format_line(&wline, &width, parent_path, view->ncols, 0);
4774 waddwstr(view->window, wline);
4777 if (width < view->ncols - 1)
4778 waddch(view->window, '\n');
4781 waddch(view->window, '\n');
4785 if (*first_displayed_entry == NULL) {
4786 te = got_object_tree_get_first_entry(tree);
4787 if (selected == 0) {
4789 wstandout(view->window);
4790 *selected_entry = NULL;
4792 waddstr(view->window, " ..\n"); /* parent directory */
4793 if (selected == 0 && view->focussed)
4794 wstandend(view->window);
4801 te = *first_displayed_entry;
4804 nentries = got_object_tree_get_nentries(tree);
4805 for (i = got_tree_entry_get_index(te); i < nentries; i++) {
4806 char *line = NULL, *id_str = NULL, *link_target = NULL;
4807 const char *modestr = "";
4810 te = got_object_tree_get_entry(tree, i);
4811 mode = got_tree_entry_get_mode(te);
4814 err = got_object_id_str(&id_str,
4815 got_tree_entry_get_id(te));
4817 return got_error_from_errno(
4818 "got_object_id_str");
4820 if (got_object_tree_entry_is_submodule(te))
4822 else if (S_ISLNK(mode)) {
4825 err = got_tree_entry_get_symlink_target(&link_target,
4831 for (i = 0; i < strlen(link_target); i++) {
4832 if (!isprint((unsigned char)link_target[i]))
4833 link_target[i] = '?';
4837 else if (S_ISDIR(mode))
4839 else if (mode & S_IXUSR)
4841 if (asprintf(&line, "%s %s%s%s%s", id_str ? id_str : "",
4842 got_tree_entry_get_name(te), modestr,
4843 link_target ? " -> ": "",
4844 link_target ? link_target : "") == -1) {
4847 return got_error_from_errno("asprintf");
4851 err = format_line(&wline, &width, line, view->ncols, 0);
4856 if (n == selected) {
4858 wstandout(view->window);
4859 *selected_entry = te;
4861 tc = match_color(colors, line);
4863 wattr_on(view->window,
4864 COLOR_PAIR(tc->colorpair), NULL);
4865 waddwstr(view->window, wline);
4867 wattr_off(view->window,
4868 COLOR_PAIR(tc->colorpair), NULL);
4869 if (width < view->ncols - 1)
4870 waddch(view->window, '\n');
4871 if (n == selected && view->focussed)
4872 wstandend(view->window);
4878 *last_displayed_entry = te;
4887 tree_scroll_up(struct tog_view *view,
4888 struct got_tree_entry **first_displayed_entry, int maxscroll,
4889 struct got_tree_object *tree, int isroot)
4891 struct got_tree_entry *te;
4894 if (*first_displayed_entry == NULL)
4897 te = got_object_tree_get_entry(tree, 0);
4898 if (*first_displayed_entry == te) {
4900 *first_displayed_entry = NULL;
4905 while (*first_displayed_entry && i < maxscroll) {
4906 *first_displayed_entry = got_tree_entry_get_prev(tree,
4907 *first_displayed_entry);
4910 if (!isroot && te == got_object_tree_get_first_entry(tree) && i < maxscroll)
4911 *first_displayed_entry = NULL;
4915 tree_scroll_down(struct got_tree_entry **first_displayed_entry, int maxscroll,
4916 struct got_tree_entry *last_displayed_entry,
4917 struct got_tree_object *tree)
4919 struct got_tree_entry *next, *last;
4922 if (*first_displayed_entry)
4923 next = got_tree_entry_get_next(tree, *first_displayed_entry);
4925 next = got_object_tree_get_first_entry(tree);
4927 last = last_displayed_entry;
4928 while (next && last && n++ < maxscroll) {
4929 last = got_tree_entry_get_next(tree, last);
4931 *first_displayed_entry = next;
4932 next = got_tree_entry_get_next(tree, next);
4938 static const struct got_error *
4939 tree_entry_path(char **path, struct tog_parent_trees *parents,
4940 struct got_tree_entry *te)
4942 const struct got_error *err = NULL;
4943 struct tog_parent_tree *pt;
4944 size_t len = 2; /* for leading slash and NUL */
4946 TAILQ_FOREACH(pt, parents, entry)
4947 len += strlen(got_tree_entry_get_name(pt->selected_entry))
4950 len += strlen(got_tree_entry_get_name(te));
4952 *path = calloc(1, len);
4954 return got_error_from_errno("calloc");
4957 pt = TAILQ_LAST(parents, tog_parent_trees);
4959 const char *name = got_tree_entry_get_name(pt->selected_entry);
4960 if (strlcat(*path, name, len) >= len) {
4961 err = got_error(GOT_ERR_NO_SPACE);
4964 if (strlcat(*path, "/", len) >= len) {
4965 err = got_error(GOT_ERR_NO_SPACE);
4968 pt = TAILQ_PREV(pt, tog_parent_trees, entry);
4971 if (strlcat(*path, got_tree_entry_get_name(te), len) >= len) {
4972 err = got_error(GOT_ERR_NO_SPACE);
4984 static const struct got_error *
4985 blame_tree_entry(struct tog_view **new_view, int begin_x,
4986 struct got_tree_entry *te, struct tog_parent_trees *parents,
4987 struct got_object_id *commit_id, struct got_reflist_head *refs,
4988 struct got_repository *repo)
4990 const struct got_error *err = NULL;
4992 struct tog_view *blame_view;
4996 err = tree_entry_path(&path, parents, te);
5000 blame_view = view_open(0, 0, 0, begin_x, TOG_VIEW_BLAME);
5001 if (blame_view == NULL) {
5002 err = got_error_from_errno("view_open");
5006 err = open_blame_view(blame_view, path, commit_id, refs, repo);
5008 if (err->code == GOT_ERR_CANCELLED)
5010 view_close(blame_view);
5012 *new_view = blame_view;
5018 static const struct got_error *
5019 log_tree_entry(struct tog_view **new_view, int begin_x,
5020 struct got_tree_entry *te, struct tog_parent_trees *parents,
5021 struct got_object_id *commit_id, struct got_reflist_head *refs,
5022 struct got_repository *repo)
5024 struct tog_view *log_view;
5025 const struct got_error *err = NULL;
5030 log_view = view_open(0, 0, 0, begin_x, TOG_VIEW_LOG);
5031 if (log_view == NULL)
5032 return got_error_from_errno("view_open");
5034 err = tree_entry_path(&path, parents, te);
5038 err = open_log_view(log_view, commit_id, refs, repo, NULL, path, 0);
5040 view_close(log_view);
5042 *new_view = log_view;
5047 static const struct got_error *
5048 open_tree_view(struct tog_view *view, struct got_tree_object *root,
5049 struct got_object_id *commit_id, struct got_reflist_head *refs,
5050 struct got_repository *repo)
5052 const struct got_error *err = NULL;
5053 char *commit_id_str = NULL;
5054 struct tog_tree_view_state *s = &view->state.tree;
5056 TAILQ_INIT(&s->parents);
5058 err = got_object_id_str(&commit_id_str, commit_id);
5062 if (asprintf(&s->tree_label, "commit %s", commit_id_str) == -1) {
5063 err = got_error_from_errno("asprintf");
5067 s->root = s->tree = root;
5068 s->first_displayed_entry = got_object_tree_get_entry(s->tree, 0);
5069 s->selected_entry = got_object_tree_get_entry(s->tree, 0);
5070 s->commit_id = got_object_id_dup(commit_id);
5071 if (s->commit_id == NULL) {
5072 err = got_error_from_errno("got_object_id_dup");
5078 SIMPLEQ_INIT(&s->colors);
5080 if (has_colors() && getenv("TOG_COLORS") != NULL) {
5081 err = add_color(&s->colors, "\\$$",
5082 TOG_COLOR_TREE_SUBMODULE,
5083 get_color_value("TOG_COLOR_TREE_SUBMODULE"));
5086 err = add_color(&s->colors, "@$", TOG_COLOR_TREE_SYMLINK,
5087 get_color_value("TOG_COLOR_TREE_SYMLINK"));
5089 free_colors(&s->colors);
5092 err = add_color(&s->colors, "/$",
5093 TOG_COLOR_TREE_DIRECTORY,
5094 get_color_value("TOG_COLOR_TREE_DIRECTORY"));
5096 free_colors(&s->colors);
5100 err = add_color(&s->colors, "\\*$",
5101 TOG_COLOR_TREE_EXECUTABLE,
5102 get_color_value("TOG_COLOR_TREE_EXECUTABLE"));
5104 free_colors(&s->colors);
5108 err = add_color(&s->colors, "^$", TOG_COLOR_COMMIT,
5109 get_color_value("TOG_COLOR_COMMIT"));
5111 free_colors(&s->colors);
5116 view->show = show_tree_view;
5117 view->input = input_tree_view;
5118 view->close = close_tree_view;
5119 view->search_start = search_start_tree_view;
5120 view->search_next = search_next_tree_view;
5122 free(commit_id_str);
5124 free(s->tree_label);
5125 s->tree_label = NULL;
5130 static const struct got_error *
5131 close_tree_view(struct tog_view *view)
5133 struct tog_tree_view_state *s = &view->state.tree;
5135 free_colors(&s->colors);
5136 free(s->tree_label);
5137 s->tree_label = NULL;
5139 s->commit_id = NULL;
5140 while (!TAILQ_EMPTY(&s->parents)) {
5141 struct tog_parent_tree *parent;
5142 parent = TAILQ_FIRST(&s->parents);
5143 TAILQ_REMOVE(&s->parents, parent, entry);
5147 if (s->tree != s->root)
5148 got_object_tree_close(s->tree);
5149 got_object_tree_close(s->root);
5154 static const struct got_error *
5155 search_start_tree_view(struct tog_view *view)
5157 struct tog_tree_view_state *s = &view->state.tree;
5159 s->matched_entry = NULL;
5164 match_tree_entry(struct got_tree_entry *te, regex_t *regex)
5166 regmatch_t regmatch;
5168 return regexec(regex, got_tree_entry_get_name(te), 1, ®match,
5172 static const struct got_error *
5173 search_next_tree_view(struct tog_view *view)
5175 struct tog_tree_view_state *s = &view->state.tree;
5176 struct got_tree_entry *te = NULL;
5178 if (!view->searching) {
5179 view->search_next_done = TOG_SEARCH_HAVE_MORE;
5183 if (s->matched_entry) {
5184 if (view->searching == TOG_SEARCH_FORWARD) {
5185 if (s->selected_entry)
5186 te = got_tree_entry_get_next(s->tree,
5189 te = got_object_tree_get_first_entry(s->tree);
5191 if (s->selected_entry == NULL)
5192 te = got_object_tree_get_last_entry(s->tree);
5194 te = got_tree_entry_get_prev(s->tree,
5198 if (view->searching == TOG_SEARCH_FORWARD)
5199 te = got_object_tree_get_first_entry(s->tree);
5201 te = got_object_tree_get_last_entry(s->tree);
5206 if (s->matched_entry == NULL) {
5207 view->search_next_done = TOG_SEARCH_HAVE_MORE;
5210 if (view->searching == TOG_SEARCH_FORWARD)
5211 te = got_object_tree_get_first_entry(s->tree);
5213 te = got_object_tree_get_last_entry(s->tree);
5216 if (match_tree_entry(te, &view->regex)) {
5217 view->search_next_done = TOG_SEARCH_HAVE_MORE;
5218 s->matched_entry = te;
5222 if (view->searching == TOG_SEARCH_FORWARD)
5223 te = got_tree_entry_get_next(s->tree, te);
5225 te = got_tree_entry_get_prev(s->tree, te);
5228 if (s->matched_entry) {
5229 s->first_displayed_entry = s->matched_entry;
5236 static const struct got_error *
5237 show_tree_view(struct tog_view *view)
5239 const struct got_error *err = NULL;
5240 struct tog_tree_view_state *s = &view->state.tree;
5243 err = tree_entry_path(&parent_path, &s->parents, NULL);
5247 err = draw_tree_entries(view, &s->first_displayed_entry,
5248 &s->last_displayed_entry, &s->selected_entry,
5249 &s->ndisplayed, s->tree_label, s->show_ids, parent_path,
5250 s->tree, s->selected, view->nlines, s->tree == s->root,
5251 &s->colors, s->repo);
5258 static const struct got_error *
5259 input_tree_view(struct tog_view **new_view, struct tog_view **dead_view,
5260 struct tog_view **focus_view, struct tog_view *view, int ch)
5262 const struct got_error *err = NULL;
5263 struct tog_tree_view_state *s = &view->state.tree;
5264 struct tog_view *log_view;
5265 int begin_x = 0, nscrolled;
5269 s->show_ids = !s->show_ids;
5272 if (!s->selected_entry)
5274 if (view_is_parent_view(view))
5275 begin_x = view_split_begin_x(view->begin_x);
5276 err = log_tree_entry(&log_view, begin_x,
5277 s->selected_entry, &s->parents,
5278 s->commit_id, s->refs, s->repo);
5279 if (view_is_parent_view(view)) {
5280 err = view_close_child(view);
5283 err = view_set_child(view, log_view);
5285 view_close(log_view);
5288 *focus_view = log_view;
5289 view->child_focussed = 1;
5291 *new_view = log_view;
5295 if (s->selected > 0) {
5297 if (s->selected == 0)
5300 if (s->selected > 0)
5302 tree_scroll_up(view, &s->first_displayed_entry, 1,
5303 s->tree, s->tree == s->root);
5307 tree_scroll_up(view, &s->first_displayed_entry,
5308 MAX(0, view->nlines - 4 - s->selected), s->tree,
5309 s->tree == s->root);
5311 if (got_object_tree_get_first_entry(s->tree) ==
5312 s->first_displayed_entry && s->tree != s->root)
5313 s->first_displayed_entry = NULL;
5317 if (s->selected < s->ndisplayed - 1) {
5321 if (got_tree_entry_get_next(s->tree, s->last_displayed_entry)
5323 /* can't scroll any further */
5325 tree_scroll_down(&s->first_displayed_entry, 1,
5326 s->last_displayed_entry, s->tree);
5330 if (got_tree_entry_get_next(s->tree, s->last_displayed_entry)
5332 /* can't scroll any further; move cursor down */
5333 if (s->selected < s->ndisplayed - 1)
5334 s->selected = s->ndisplayed - 1;
5337 nscrolled = tree_scroll_down(&s->first_displayed_entry,
5338 view->nlines, s->last_displayed_entry, s->tree);
5339 if (nscrolled < view->nlines) {
5341 struct got_tree_entry *te;
5342 te = s->first_displayed_entry;
5345 te = got_tree_entry_get_next(s->tree, te);
5347 s->selected = ndisplayed - 1;
5353 if (s->selected_entry == NULL || ch == KEY_BACKSPACE) {
5354 struct tog_parent_tree *parent;
5355 /* user selected '..' */
5356 if (s->tree == s->root)
5358 parent = TAILQ_FIRST(&s->parents);
5359 TAILQ_REMOVE(&s->parents, parent,
5361 got_object_tree_close(s->tree);
5362 s->tree = parent->tree;
5363 s->first_displayed_entry =
5364 parent->first_displayed_entry;
5366 parent->selected_entry;
5367 s->selected = parent->selected;
5369 } else if (S_ISDIR(got_tree_entry_get_mode(
5370 s->selected_entry))) {
5371 struct got_tree_object *subtree;
5372 err = got_object_open_as_tree(&subtree, s->repo,
5373 got_tree_entry_get_id(s->selected_entry));
5376 err = tree_view_visit_subtree(subtree, s);
5378 got_object_tree_close(subtree);
5381 } else if (S_ISREG(got_tree_entry_get_mode(
5382 s->selected_entry))) {
5383 struct tog_view *blame_view;
5384 int begin_x = view_is_parent_view(view) ?
5385 view_split_begin_x(view->begin_x) : 0;
5387 err = blame_tree_entry(&blame_view, begin_x,
5388 s->selected_entry, &s->parents,
5389 s->commit_id, s->refs, s->repo);
5392 if (view_is_parent_view(view)) {
5393 err = view_close_child(view);
5396 err = view_set_child(view, blame_view);
5398 view_close(blame_view);
5401 *focus_view = blame_view;
5402 view->child_focussed = 1;
5404 *new_view = blame_view;
5408 if (s->selected > view->nlines)
5409 s->selected = s->ndisplayed - 1;
5422 fprintf(stderr, "usage: %s tree [-c commit] [-r repository-path] [path]\n",
5427 static const struct got_error *
5428 cmd_tree(int argc, char *argv[])
5430 const struct got_error *error;
5431 struct got_repository *repo = NULL;
5432 struct got_worktree *worktree = NULL;
5433 struct got_reflist_head refs;
5434 char *cwd = NULL, *repo_path = NULL, *in_repo_path = NULL;
5435 struct got_object_id *commit_id = NULL;
5436 char *commit_id_arg = NULL;
5437 struct got_commit_object *commit = NULL;
5438 struct got_tree_object *tree = NULL;
5440 struct tog_view *view;
5442 SIMPLEQ_INIT(&refs);
5445 if (pledge("stdio rpath wpath cpath flock proc tty exec sendfd unveil",
5450 while ((ch = getopt(argc, argv, "c:r:")) != -1) {
5453 commit_id_arg = optarg;
5456 repo_path = realpath(optarg, NULL);
5457 if (repo_path == NULL)
5458 return got_error_from_errno2("realpath",
5473 cwd = getcwd(NULL, 0);
5475 return got_error_from_errno("getcwd");
5477 error = got_worktree_open(&worktree, cwd);
5478 if (error && error->code != GOT_ERR_NOT_WORKTREE)
5481 if (repo_path == NULL) {
5484 strdup(got_worktree_get_repo_path(worktree));
5486 repo_path = strdup(cwd);
5488 if (repo_path == NULL) {
5489 error = got_error_from_errno("strdup");
5493 error = got_repo_open(&repo, repo_path, NULL);
5497 error = get_in_repo_path_from_argv0(&in_repo_path, argc, argv,
5504 error = apply_unveil(got_repo_get_path(repo), NULL);
5508 error = got_repo_match_object_id(&commit_id, NULL,
5509 commit_id_arg ? commit_id_arg : GOT_REF_HEAD,
5510 GOT_OBJ_TYPE_COMMIT, 1, repo);
5514 error = got_object_open_as_commit(&commit, repo, commit_id);
5518 error = got_object_open_as_tree(&tree, repo,
5519 got_object_commit_get_tree_id(commit));
5523 error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
5527 view = view_open(0, 0, 0, 0, TOG_VIEW_TREE);
5529 error = got_error_from_errno("view_open");
5532 error = open_tree_view(view, tree, commit_id, &refs, repo);
5535 if (!got_path_is_root_dir(in_repo_path)) {
5536 error = tree_view_walk_path(&view->state.tree, commit_id,
5537 in_repo_path, repo);
5543 /* Release work tree lock. */
5544 got_worktree_close(worktree);
5547 error = view_loop(view);
5553 got_object_commit_close(commit);
5555 got_object_tree_close(tree);
5557 got_repo_close(repo);
5558 got_ref_list_free(&refs);
5563 list_commands(FILE *fp)
5567 fprintf(fp, "commands:");
5568 for (i = 0; i < nitems(tog_commands); i++) {
5569 struct tog_cmd *cmd = &tog_commands[i];
5570 fprintf(fp, " %s", cmd->name);
5576 usage(int hflag, int status)
5578 FILE *fp = (status == 0) ? stdout : stderr;
5580 fprintf(fp, "usage: %s [-h] [-V | --version] [command] [arg ...]\n",
5583 fprintf(fp, "lazy usage: %s path\n", getprogname());
5590 make_argv(int argc, ...)
5598 argv = calloc(argc, sizeof(char *));
5601 for (i = 0; i < argc; i++) {
5602 argv[i] = strdup(va_arg(ap, char *));
5603 if (argv[i] == NULL)
5612 * Try to convert 'tog path' into a 'tog log path' command.
5613 * The user could simply have mistyped the command rather than knowingly
5614 * provided a path. So check whether argv[0] can in fact be resolved
5615 * to a path in the HEAD commit and print a special error if not.
5616 * This hack is for mpi@ <3
5618 static const struct got_error *
5619 tog_log_with_path(int argc, char *argv[])
5621 const struct got_error *error = NULL;
5622 struct tog_cmd *cmd = NULL;
5623 struct got_repository *repo = NULL;
5624 struct got_worktree *worktree = NULL;
5625 struct got_object_id *commit_id = NULL, *id = NULL;
5626 char *cwd = NULL, *repo_path = NULL, *in_repo_path = NULL;
5627 char *commit_id_str = NULL, **cmd_argv = NULL;
5629 cwd = getcwd(NULL, 0);
5631 return got_error_from_errno("getcwd");
5633 error = got_worktree_open(&worktree, cwd);
5634 if (error && error->code != GOT_ERR_NOT_WORKTREE)
5638 repo_path = strdup(got_worktree_get_repo_path(worktree));
5640 repo_path = strdup(cwd);
5641 if (repo_path == NULL) {
5642 error = got_error_from_errno("strdup");
5646 error = got_repo_open(&repo, repo_path, NULL);
5650 error = get_in_repo_path_from_argv0(&in_repo_path, argc, argv,
5655 error = got_repo_match_object_id(&commit_id, NULL, worktree ?
5656 got_worktree_get_head_ref_name(worktree) : GOT_REF_HEAD,
5657 GOT_OBJ_TYPE_COMMIT, 1, repo);
5662 got_worktree_close(worktree);
5666 error = got_object_id_by_path(&id, repo, commit_id, in_repo_path);
5668 if (error->code != GOT_ERR_NO_TREE_ENTRY)
5670 fprintf(stderr, "%s: '%s' is no known command or path\n",
5671 getprogname(), argv[0]);
5676 got_repo_close(repo);
5679 error = got_object_id_str(&commit_id_str, commit_id);
5683 cmd = &tog_commands[0]; /* log */
5685 cmd_argv = make_argv(argc, cmd->name, "-c", commit_id_str, argv[0]);
5686 error = cmd->cmd_main(argc, cmd_argv);
5689 got_repo_close(repo);
5691 got_worktree_close(worktree);
5693 free(commit_id_str);
5700 for (i = 0; i < argc; i++)
5708 main(int argc, char *argv[])
5710 const struct got_error *error = NULL;
5711 struct tog_cmd *cmd = NULL;
5712 int ch, hflag = 0, Vflag = 0;
5713 char **cmd_argv = NULL;
5714 static struct option longopts[] = {
5715 { "version", no_argument, NULL, 'V' },
5719 setlocale(LC_CTYPE, "");
5721 while ((ch = getopt_long(argc, argv, "+hV", longopts, NULL)) != -1) {
5741 got_version_print_str();
5748 /* Build an argument vector which runs a default command. */
5749 cmd = &tog_commands[0];
5751 cmd_argv = make_argv(argc, cmd->name);
5755 /* Did the user specify a command? */
5756 for (i = 0; i < nitems(tog_commands); i++) {
5757 if (strncmp(tog_commands[i].name, argv[0],
5758 strlen(argv[0])) == 0) {
5759 cmd = &tog_commands[i];
5768 /* No command specified; try log with a path */
5769 error = tog_log_with_path(argc, argv);
5774 error = cmd->cmd_main(argc, cmd_argv ? cmd_argv : argv);
5781 for (i = 0; i < argc; i++)
5786 if (error && error->code != GOT_ERR_CANCELLED)
5787 fprintf(stderr, "%s: %s\n", getprogname(), error->msg);