1 /* Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
2 * See license info at the bottom. */
9 * tig - text-mode interface for git
15 * tig [options] [--] [git log options]
16 * tig [options] log [git log options]
17 * tig [options] diff [git diff options]
18 * tig [options] show [git show options]
19 * tig [options] < [git command output]
23 * Browse changes in a git repository. Additionally, tig(1) can also act
24 * as a pager for output of various git commands.
26 * When browsing repositories, tig(1) uses the underlying git commands
27 * to present the user with various views, such as summarized commit log
28 * and showing the commit with the log message, diffstat, and the diff.
30 * Using tig(1) as a pager, it will display input from stdin and try
35 #define VERSION "tig-0.3"
55 static void die(const char *err, ...);
56 static void report(const char *msg, ...);
57 static void set_nonblocking_input(bool loading);
58 static size_t utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed);
60 #define ABS(x) ((x) >= 0 ? (x) : -(x))
61 #define MIN(x, y) ((x) < (y) ? (x) : (y))
63 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
64 #define STRING_SIZE(x) (sizeof(x) - 1)
66 #define SIZEOF_REF 256 /* Size of symbolic or SHA1 ID. */
67 #define SIZEOF_CMD 1024 /* Size of command buffer. */
69 /* This color name can be used to refer to the default term colors. */
70 #define COLOR_DEFAULT (-1)
72 #define TIG_HELP "(d)iff, (l)og, (m)ain, (q)uit, (h)elp"
74 /* The format and size of the date column in the main view. */
75 #define DATE_FORMAT "%Y-%m-%d %H:%M"
76 #define DATE_COLS STRING_SIZE("2006-04-29 14:21 ")
78 #define AUTHOR_COLS 20
80 /* The default interval between line numbers. */
81 #define NUMBER_INTERVAL 1
85 #define SCALE_SPLIT_VIEW(height) ((height) * 2 / 3)
87 /* Some ascii-shorthands fitted into the ncurses namespace. */
89 #define KEY_RETURN '\r'
93 /* User action requests. */
95 /* Offset all requests to avoid conflicts with ncurses getch values. */
96 REQ_OFFSET = KEY_MAX + 1,
98 /* XXX: Keep the view request first and in sync with views[]. */
113 REQ_TOGGLE_LINE_NUMBERS,
127 REQ_SCROLL_LINE_DOWN,
129 REQ_SCROLL_PAGE_DOWN,
133 char *name; /* Ref name; tag or head names are shortened. */
134 char id[41]; /* Commit SHA1 ID */
135 unsigned int tag:1; /* Is it a tag? */
136 unsigned int next:1; /* For ref lists: are there more refs? */
140 char id[41]; /* SHA1 ID. */
141 char title[75]; /* The first line of the commit message. */
142 char author[75]; /* The author of the commit. */
143 struct tm time; /* Date from the author ident. */
144 struct ref **refs; /* Repository references; tags & branch heads. */
153 string_ncopy(char *dst, const char *src, int dstlen)
155 strncpy(dst, src, dstlen - 1);
160 /* Shorthand for safely copying into a fixed buffer. */
161 #define string_copy(dst, src) \
162 string_ncopy(dst, src, sizeof(dst))
167 * NOTE: The following is a slightly modified copy of the git project's shell
168 * quoting routines found in the quote.c file.
170 * Help to copy the thing properly quoted for the shell safety. any single
171 * quote is replaced with '\'', any exclamation point is replaced with '\!',
172 * and the whole thing is enclosed in a
175 * original sq_quote result
176 * name ==> name ==> 'name'
177 * a b ==> a b ==> 'a b'
178 * a'b ==> a'\''b ==> 'a'\''b'
179 * a!b ==> a'\!'b ==> 'a'\!'b'
183 sq_quote(char buf[SIZEOF_CMD], size_t bufsize, const char *src)
187 #define BUFPUT(x) do { if (bufsize < SIZEOF_CMD) buf[bufsize++] = (x); } while (0)
190 while ((c = *src++)) {
191 if (c == '\'' || c == '!') {
211 static const char usage[] =
212 VERSION " (" __DATE__ ")\n"
214 "Usage: tig [options]\n"
215 " or: tig [options] [--] [git log options]\n"
216 " or: tig [options] log [git log options]\n"
217 " or: tig [options] diff [git diff options]\n"
218 " or: tig [options] show [git show options]\n"
219 " or: tig [options] < [git command output]\n"
222 " -l Start up in log view\n"
223 " -d Start up in diff view\n"
224 " -n[I], --line-number[=I] Show line numbers with given interval\n"
225 " -t[N], --tab-size[=N] Set number of spaces for tab expansion\n"
226 " -- Mark end of tig options\n"
227 " -v, --version Show version and exit\n"
228 " -h, --help Show help message and exit\n";
230 /* Option and state variables. */
231 static bool opt_line_number = FALSE;
232 static int opt_num_interval = NUMBER_INTERVAL;
233 static int opt_tab_size = TABSIZE;
234 static enum request opt_request = REQ_VIEW_MAIN;
235 static char opt_cmd[SIZEOF_CMD] = "";
236 static FILE *opt_pipe = NULL;
238 /* Returns the index of log or diff command or -1 to exit. */
240 parse_options(int argc, char *argv[])
244 for (i = 1; i < argc; i++) {
249 * Start up in log view using the internal log command.
251 if (!strcmp(opt, "-l")) {
252 opt_request = REQ_VIEW_LOG;
258 * Start up in diff view using the internal diff command.
260 if (!strcmp(opt, "-d")) {
261 opt_request = REQ_VIEW_DIFF;
266 * -n[INTERVAL], --line-number[=INTERVAL]::
267 * Prefix line numbers in log and diff view.
268 * Optionally, with interval different than each line.
270 if (!strncmp(opt, "-n", 2) ||
271 !strncmp(opt, "--line-number", 13)) {
277 } else if (opt[STRING_SIZE("--line-number")] == '=') {
278 num = opt + STRING_SIZE("--line-number=");
282 opt_num_interval = atoi(num);
284 opt_line_number = TRUE;
289 * -t[NSPACES], --tab-size[=NSPACES]::
290 * Set the number of spaces tabs should be expanded to.
292 if (!strncmp(opt, "-t", 2) ||
293 !strncmp(opt, "--tab-size", 10)) {
299 } else if (opt[STRING_SIZE("--tab-size")] == '=') {
300 num = opt + STRING_SIZE("--tab-size=");
304 opt_tab_size = MIN(atoi(num), TABSIZE);
310 * Show version and exit.
312 if (!strcmp(opt, "-v") ||
313 !strcmp(opt, "--version")) {
314 printf("tig version %s\n", VERSION);
320 * Show help message and exit.
322 if (!strcmp(opt, "-h") ||
323 !strcmp(opt, "--help")) {
330 * End of tig(1) options. Useful when specifying command
331 * options for the main view. Example:
333 * $ tig -- --since=1.month
335 if (!strcmp(opt, "--")) {
341 * log [git log options]::
342 * Open log view using the given git log options.
344 * diff [git diff options]::
345 * Open diff view using the given git diff options.
347 * show [git show options]::
348 * Open diff view using the given git show options.
350 if (!strcmp(opt, "log") ||
351 !strcmp(opt, "diff") ||
352 !strcmp(opt, "show")) {
353 opt_request = opt[0] == 'l'
354 ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
359 * [git log options]::
360 * tig(1) will stop the option parsing when the first
361 * command line parameter not starting with "-" is
362 * encountered. All options including this one will be
363 * passed to git log when loading the main view.
364 * This makes it possible to say:
366 * $ tig tag-1.0..HEAD
368 if (opt[0] && opt[0] != '-')
371 die("unknown command '%s'", opt);
374 if (!isatty(STDIN_FILENO)) {
378 * If stdin is a pipe, any log or diff options will be ignored and the
379 * pager view will be opened loading data from stdin. The pager mode
380 * can be used for colorizing output from various git commands.
382 * Example on how to colorize the output of git-show(1):
386 opt_request = REQ_VIEW_PAGER;
389 } else if (i < argc) {
393 * Git command options
394 * ~~~~~~~~~~~~~~~~~~~
395 * All git command options specified on the command line will
396 * be passed to the given command and all will be shell quoted
397 * before they are passed to the shell.
399 * NOTE: If you specify options for the main view, you should
400 * not use the `--pretty` option as this option will be set
401 * automatically to the format expected by the main view.
403 * Example on how to open the log view and show both author and
404 * committer information:
406 * $ tig log --pretty=fuller
408 * See the <<refspec, "Specifying revisions">> section below
409 * for an introduction to revision options supported by the git
410 * commands. For details on specific git command options, refer
411 * to the man page of the command in question.
414 if (opt_request == REQ_VIEW_MAIN)
415 /* XXX: This is vulnerable to the user overriding
416 * options required for the main view parser. */
417 string_copy(opt_cmd, "git log --stat --pretty=raw");
419 string_copy(opt_cmd, "git");
420 buf_size = strlen(opt_cmd);
422 while (buf_size < sizeof(opt_cmd) && i < argc) {
423 opt_cmd[buf_size++] = ' ';
424 buf_size = sq_quote(opt_cmd, buf_size, argv[i++]);
427 if (buf_size >= sizeof(opt_cmd))
428 die("command too long");
430 opt_cmd[buf_size] = 0;
439 * Line-oriented content detection.
443 /* Line type String to match Foreground Background Attributes
444 * --------- --------------- ---------- ---------- ---------- */ \
446 LINE(DIFF, "diff --git ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
447 LINE(DIFF_INDEX, "index ", COLOR_BLUE, COLOR_DEFAULT, 0), \
448 LINE(DIFF_CHUNK, "@@", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
449 LINE(DIFF_ADD, "+", COLOR_GREEN, COLOR_DEFAULT, 0), \
450 LINE(DIFF_DEL, "-", COLOR_RED, COLOR_DEFAULT, 0), \
451 LINE(DIFF_OLDMODE, "old file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
452 LINE(DIFF_NEWMODE, "new file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
453 LINE(DIFF_COPY, "copy ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
454 LINE(DIFF_RENAME, "rename ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
455 LINE(DIFF_SIM, "similarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
456 LINE(DIFF_DISSIM, "dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
457 /* Pretty print commit header */ \
458 LINE(PP_AUTHOR, "Author: ", COLOR_CYAN, COLOR_DEFAULT, 0), \
459 LINE(PP_COMMIT, "Commit: ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
460 LINE(PP_MERGE, "Merge: ", COLOR_BLUE, COLOR_DEFAULT, 0), \
461 LINE(PP_DATE, "Date: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
462 LINE(PP_ADATE, "AuthorDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
463 LINE(PP_CDATE, "CommitDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
464 /* Raw commit header */ \
465 LINE(COMMIT, "commit ", COLOR_GREEN, COLOR_DEFAULT, 0), \
466 LINE(PARENT, "parent ", COLOR_BLUE, COLOR_DEFAULT, 0), \
467 LINE(TREE, "tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
468 LINE(AUTHOR, "author ", COLOR_CYAN, COLOR_DEFAULT, 0), \
469 LINE(COMMITTER, "committer ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
471 LINE(DIFF_TREE, "diff-tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
472 LINE(SIGNOFF, " Signed-off-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
474 LINE(DEFAULT, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
475 LINE(CURSOR, "", COLOR_WHITE, COLOR_GREEN, A_BOLD), \
476 LINE(STATUS, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
477 LINE(TITLE_BLUR, "", COLOR_WHITE, COLOR_BLUE, 0), \
478 LINE(TITLE_FOCUS, "", COLOR_WHITE, COLOR_BLUE, A_BOLD), \
479 LINE(MAIN_DATE, "", COLOR_BLUE, COLOR_DEFAULT, 0), \
480 LINE(MAIN_AUTHOR, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
481 LINE(MAIN_COMMIT, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
482 LINE(MAIN_DELIM, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
483 LINE(MAIN_TAG, "", COLOR_MAGENTA, COLOR_DEFAULT, A_BOLD), \
484 LINE(MAIN_REF, "", COLOR_CYAN, COLOR_DEFAULT, A_BOLD),
487 #define LINE(type, line, fg, bg, attr) \
494 const char *line; /* The start of line to match. */
495 int linelen; /* Size of string to match. */
496 int fg, bg, attr; /* Color and text attributes for the lines. */
499 static struct line_info line_info[] = {
500 #define LINE(type, line, fg, bg, attr) \
501 { (line), STRING_SIZE(line), (fg), (bg), (attr) }
506 static enum line_type
507 get_line_type(char *line)
509 int linelen = strlen(line);
512 for (type = 0; type < ARRAY_SIZE(line_info); type++)
513 /* Case insensitive search matches Signed-off-by lines better. */
514 if (linelen >= line_info[type].linelen &&
515 !strncasecmp(line_info[type].line, line, line_info[type].linelen))
522 get_line_attr(enum line_type type)
524 assert(type < ARRAY_SIZE(line_info));
525 return COLOR_PAIR(type) | line_info[type].attr;
531 int default_bg = COLOR_BLACK;
532 int default_fg = COLOR_WHITE;
537 if (use_default_colors() != ERR) {
542 for (type = 0; type < ARRAY_SIZE(line_info); type++) {
543 struct line_info *info = &line_info[type];
544 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
545 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
547 init_pair(type, fg, bg);
553 * ENVIRONMENT VARIABLES
554 * ---------------------
555 * Several options related to the interface with git can be configured
556 * via environment options.
558 * Repository references
559 * ~~~~~~~~~~~~~~~~~~~~~
560 * Commits that are referenced by tags and branch heads will be marked
561 * by the reference name surrounded by '[' and ']':
563 * 2006-03-26 19:42 Petr Baudis | [cogito-0.17.1] Cogito 0.17.1
565 * If you want to filter out certain directories under `.git/refs/`, say
566 * `tmp` you can do it by setting the following variable:
568 * $ TIG_LS_REMOTE="git ls-remote . | sed /\/tmp\//d" tig
570 * Or set the variable permanently in your environment.
573 * Set command for retrieving all repository references. The command
574 * should output data in the same format as git-ls-remote(1).
577 #define TIG_LS_REMOTE \
578 "git ls-remote . 2>/dev/null"
584 * It is possible to alter which commands are used for the different views.
585 * If for example you prefer commits in the main view to be sorted by date
586 * and only show 500 commits, use:
588 * $ TIG_MAIN_CMD="git log --date-order -n500 --pretty=raw %s" tig
590 * Or set the variable permanently in your environment.
592 * Notice, how `%s` is used to specify the commit reference. There can
593 * be a maximum of 5 `%s` ref specifications.
596 * The command used for the diff view. By default, git show is used
600 * The command used for the log view. If you prefer to have both
601 * author and committer shown in the log view be sure to pass
602 * `--pretty=fuller` to git log.
605 * The command used for the main view. Note, you must always specify
606 * the option: `--pretty=raw` since the main view parser expects to
610 #define TIG_DIFF_CMD \
611 "git show --patch-with-stat --find-copies-harder -B -C %s"
613 #define TIG_LOG_CMD \
614 "git log --cc --stat -n100 %s"
616 #define TIG_MAIN_CMD \
617 "git log --topo-order --stat --pretty=raw %s"
619 /* ... silently ignore that the following are also exported. */
621 #define TIG_HELP_CMD \
622 "man tig 2>/dev/null"
624 #define TIG_PAGER_CMD \
631 * The display consists of a status window on the last line of the screen and
632 * one or more views. The default is to only show one view at the time but it
633 * is possible to split both the main and log view to also show the commit
636 * If you are in the log view and press 'Enter' when the current line is a
637 * commit line, such as:
639 * commit 4d55caff4cc89335192f3e566004b4ceef572521
641 * You will split the view so that the log view is displayed in the top window
642 * and the diff view in the bottom window. You can switch between the two
643 * views by pressing 'Tab'. To maximize the log view again, simply press 'l'.
648 /* The display array of active views and the index of the current view. */
649 static struct view *display[2];
650 static unsigned int current_view;
652 #define foreach_view(view, i) \
653 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
657 * Current head and commit ID
658 * ~~~~~~~~~~~~~~~~~~~~~~~~~~
659 * The viewer keeps track of both what head and commit ID you are currently
660 * viewing. The commit ID will follow the cursor line and change everytime time
661 * you highlight a different commit. Whenever you reopen the diff view it
662 * will be reloaded, if the commit ID changed.
664 * The head ID is used when opening the main and log view to indicate from
665 * what revision to show history.
668 static char ref_commit[SIZEOF_REF] = "HEAD";
669 static char ref_head[SIZEOF_REF] = "HEAD";
673 const char *name; /* View name */
674 const char *cmd_fmt; /* Default command line format */
675 const char *cmd_env; /* Command line set via environment */
676 const char *id; /* Points to either of ref_{head,commit} */
679 /* What type of content being displayed. Used in the
682 /* Draw one line; @lineno must be < view->height. */
683 bool (*draw)(struct view *view, unsigned int lineno);
684 /* Read one line; updates view->line. */
685 bool (*read)(struct view *view, char *line);
686 /* Depending on view, change display based on current line. */
687 bool (*enter)(struct view *view);
690 char cmd[SIZEOF_CMD]; /* Command buffer */
691 char ref[SIZEOF_REF]; /* Hovered commit reference */
692 char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
694 int height, width; /* The width and height of the main window */
695 WINDOW *win; /* The main window */
696 WINDOW *title; /* The title window living below the main window */
699 unsigned long offset; /* Offset of the window top */
700 unsigned long lineno; /* Current line number */
702 /* If non-NULL, points to the view that opened this view. If this view
703 * is closed tig will switch back to the parent view. */
707 unsigned long lines; /* Total number of lines */
708 void **line; /* Line index; each line contains user data */
709 unsigned int digits; /* Number of digits in the lines member. */
716 static struct view_ops pager_ops;
717 static struct view_ops main_ops;
719 #define VIEW_STR(name, cmd, env, ref, ops) \
720 { name, cmd, #env, ref, ops }
722 #define VIEW_(id, name, ops, ref) \
723 VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops)
728 * tig(1) presents various 'views' of a repository. Each view is based on output
729 * from an external command, most often 'git log', 'git diff', or 'git show'.
732 * Is the default view, and it shows a one line summary of each commit
733 * in the chosen list of revisions. The summary includes commit date,
734 * author, and the first line of the log message. Additionally, any
735 * repository references, such as tags, will be shown.
738 * Presents a more rich view of the revision log showing the whole log
739 * message and the diffstat.
742 * Shows either the diff of the current working tree, that is, what
743 * has changed since the last commit, or the commit diff complete
744 * with log message, diffstat and diff.
747 * Is used for displaying both input from stdin and output from git
748 * commands entered in the internal prompt.
751 * Displays the information from the tig(1) man page. For the help view
752 * to work you need to have the tig(1) man page installed.
755 static struct view views[] = {
756 VIEW_(MAIN, "main", &main_ops, ref_head),
757 VIEW_(DIFF, "diff", &pager_ops, ref_commit),
758 VIEW_(LOG, "log", &pager_ops, ref_head),
759 VIEW_(HELP, "help", &pager_ops, "static"),
760 VIEW_(PAGER, "pager", &pager_ops, "static"),
763 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
767 redraw_view_from(struct view *view, int lineno)
769 assert(0 <= lineno && lineno < view->height);
771 for (; lineno < view->height; lineno++) {
772 if (!view->ops->draw(view, lineno))
776 redrawwin(view->win);
781 redraw_view(struct view *view)
784 redraw_view_from(view, 0);
791 * Each view has a title window which shows the name of the view, current
792 * commit ID if available, and where the view is positioned:
794 * [main] c622eefaa485995320bc743431bae0d497b1d875 - commit 1 of 61 (1%)
796 * By default, the title of the current view is highlighted using bold font.
800 update_view_title(struct view *view)
802 if (view == display[current_view])
803 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
805 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
808 wmove(view->title, 0, 0);
811 wprintw(view->title, "[%s] %s", view->name, view->ref);
813 wprintw(view->title, "[%s]", view->name);
816 wprintw(view->title, " - %s %d of %d (%d%%)",
820 (view->lineno + 1) * 100 / view->lines);
823 wrefresh(view->title);
830 struct view *base = display[0];
831 struct view *view = display[1] ? display[1] : display[0];
833 /* Setup window dimensions */
835 getmaxyx(stdscr, base->height, base->width);
837 /* Make room for the status window. */
841 /* Horizontal split. */
842 view->width = base->width;
843 view->height = SCALE_SPLIT_VIEW(base->height);
844 base->height -= view->height;
846 /* Make room for the title bar. */
850 /* Make room for the title bar. */
855 foreach_view (view, i) {
856 /* Keep the height of all view->win windows one larger than is
857 * required so that the cursor can wrap-around on the last line
858 * without scrolling the window. */
860 view->win = newwin(view->height + 1, 0, offset, 0);
862 die("Failed to create %s view", view->name);
864 scrollok(view->win, TRUE);
866 view->title = newwin(1, 0, offset + view->height, 0);
868 die("Failed to create title window");
871 wresize(view->win, view->height + 1, view->width);
872 mvwin(view->win, offset, 0);
873 mvwin(view->title, offset + view->height, 0);
877 offset += view->height + 1;
887 foreach_view (view, i) {
889 update_view_title(view);
898 /* Scrolling backend */
900 do_scroll_view(struct view *view, int lines)
902 /* The rendering expects the new offset. */
903 view->offset += lines;
905 assert(0 <= view->offset && view->offset < view->lines);
908 /* Redraw the whole screen if scrolling is pointless. */
909 if (view->height < ABS(lines)) {
913 int line = lines > 0 ? view->height - lines : 0;
914 int end = line + ABS(lines);
916 wscrl(view->win, lines);
918 for (; line < end; line++) {
919 if (!view->ops->draw(view, line))
924 /* Move current line into the view. */
925 if (view->lineno < view->offset) {
926 view->lineno = view->offset;
927 view->ops->draw(view, 0);
929 } else if (view->lineno >= view->offset + view->height) {
930 if (view->lineno == view->offset + view->height) {
931 /* Clear the hidden line so it doesn't show if the view
933 wmove(view->win, view->height, 0);
934 wclrtoeol(view->win);
936 view->lineno = view->offset + view->height - 1;
937 view->ops->draw(view, view->lineno - view->offset);
940 assert(view->offset <= view->lineno && view->lineno < view->lines);
942 redrawwin(view->win);
947 /* Scroll frontend */
949 scroll_view(struct view *view, enum request request)
954 case REQ_SCROLL_PAGE_DOWN:
955 lines = view->height;
956 case REQ_SCROLL_LINE_DOWN:
957 if (view->offset + lines > view->lines)
958 lines = view->lines - view->offset;
960 if (lines == 0 || view->offset + view->height >= view->lines) {
961 report("Cannot scroll beyond the last line");
966 case REQ_SCROLL_PAGE_UP:
967 lines = view->height;
968 case REQ_SCROLL_LINE_UP:
969 if (lines > view->offset)
970 lines = view->offset;
973 report("Cannot scroll beyond the first line");
981 die("request %d not handled in switch", request);
984 do_scroll_view(view, lines);
989 move_view(struct view *view, enum request request)
994 case REQ_MOVE_FIRST_LINE:
995 steps = -view->lineno;
998 case REQ_MOVE_LAST_LINE:
999 steps = view->lines - view->lineno - 1;
1002 case REQ_MOVE_PAGE_UP:
1003 steps = view->height > view->lineno
1004 ? -view->lineno : -view->height;
1007 case REQ_MOVE_PAGE_DOWN:
1008 steps = view->lineno + view->height >= view->lines
1009 ? view->lines - view->lineno - 1 : view->height;
1013 case REQ_MOVE_UP_ENTER:
1018 case REQ_MOVE_DOWN_ENTER:
1023 die("request %d not handled in switch", request);
1026 if (steps <= 0 && view->lineno == 0) {
1027 report("Cannot move beyond the first line");
1030 } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1031 report("Cannot move beyond the last line");
1035 /* Move the current line */
1036 view->lineno += steps;
1037 assert(0 <= view->lineno && view->lineno < view->lines);
1039 /* Repaint the old "current" line if we be scrolling */
1040 if (ABS(steps) < view->height) {
1041 int prev_lineno = view->lineno - steps - view->offset;
1043 wmove(view->win, prev_lineno, 0);
1044 wclrtoeol(view->win);
1045 view->ops->draw(view, prev_lineno);
1048 /* Check whether the view needs to be scrolled */
1049 if (view->lineno < view->offset ||
1050 view->lineno >= view->offset + view->height) {
1051 if (steps < 0 && -steps > view->offset) {
1052 steps = -view->offset;
1054 } else if (steps > 0) {
1055 if (view->lineno == view->lines - 1 &&
1056 view->lines > view->height) {
1057 steps = view->lines - view->offset - 1;
1058 if (steps >= view->height)
1059 steps -= view->height - 1;
1063 do_scroll_view(view, steps);
1067 /* Draw the current line */
1068 view->ops->draw(view, view->lineno - view->offset);
1070 redrawwin(view->win);
1071 wrefresh(view->win);
1077 * Incremental updating
1081 begin_update(struct view *view)
1083 const char *id = view->id;
1086 string_copy(view->cmd, opt_cmd);
1088 /* When running random commands, the view ref could have become
1089 * invalid so clear it. */
1092 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1094 if (snprintf(view->cmd, sizeof(view->cmd), format,
1095 id, id, id, id, id) >= sizeof(view->cmd))
1099 /* Special case for the pager view. */
1101 view->pipe = opt_pipe;
1104 view->pipe = popen(view->cmd, "r");
1110 set_nonblocking_input(TRUE);
1115 string_copy(view->vid, id);
1120 for (i = 0; i < view->lines; i++)
1122 free(view->line[i]);
1128 view->start_time = time(NULL);
1134 end_update(struct view *view)
1138 set_nonblocking_input(FALSE);
1139 if (view->pipe == stdin)
1147 update_view(struct view *view)
1149 char buffer[BUFSIZ];
1152 /* The number of lines to read. If too low it will cause too much
1153 * redrawing (and possible flickering), if too high responsiveness
1155 unsigned long lines = view->height;
1156 int redraw_from = -1;
1161 /* Only redraw if lines are visible. */
1162 if (view->offset + view->height >= view->lines)
1163 redraw_from = view->lines - view->offset;
1165 tmp = realloc(view->line, sizeof(*view->line) * (view->lines + lines));
1171 while ((line = fgets(buffer, sizeof(buffer), view->pipe))) {
1172 int linelen = strlen(line);
1175 line[linelen - 1] = 0;
1177 if (!view->ops->read(view, line))
1187 lines = view->lines;
1188 for (digits = 0; lines; digits++)
1191 /* Keep the displayed view in sync with line number scaling. */
1192 if (digits != view->digits) {
1193 view->digits = digits;
1198 if (redraw_from >= 0) {
1199 /* If this is an incremental update, redraw the previous line
1200 * since for commits some members could have changed when
1201 * loading the main view. */
1202 if (redraw_from > 0)
1205 /* Incrementally draw avoids flickering. */
1206 redraw_view_from(view, redraw_from);
1209 /* Update the title _after_ the redraw so that if the redraw picks up a
1210 * commit reference in view->ref it'll be available here. */
1211 update_view_title(view);
1213 if (ferror(view->pipe)) {
1214 report("Failed to read: %s", strerror(errno));
1217 } else if (feof(view->pipe)) {
1218 time_t secs = time(NULL) - view->start_time;
1220 if (view == VIEW(REQ_VIEW_HELP)) {
1221 const char *msg = TIG_HELP;
1223 if (view->lines == 0) {
1224 /* Slightly ugly, but abusing view->ref keeps
1225 * the error message. */
1226 string_copy(view->ref, "No help available");
1227 msg = "The tig(1) manpage is not installed";
1234 report("Loaded %d lines in %ld second%s", view->lines, secs,
1235 secs == 1 ? "" : "s");
1242 report("Allocation failure");
1250 OPEN_DEFAULT = 0, /* Use default view switching. */
1251 OPEN_SPLIT = 1, /* Split current view. */
1252 OPEN_BACKGROUNDED = 2, /* Backgrounded. */
1253 OPEN_RELOAD = 4, /* Reload view even if it is the current. */
1257 open_view(struct view *prev, enum request request, enum open_flags flags)
1259 bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
1260 bool split = !!(flags & OPEN_SPLIT);
1261 bool reload = !!(flags & OPEN_RELOAD);
1262 struct view *view = VIEW(request);
1263 struct view *displayed;
1266 /* Cycle between displayed views and count the views. */
1267 foreach_view (displayed, nviews) {
1269 view == displayed &&
1270 !strcmp(view->vid, prev->vid)) {
1271 current_view = nviews;
1272 /* Blur out the title of the previous view. */
1273 update_view_title(prev);
1279 if (view == prev && nviews == 1 && !reload) {
1280 report("Already in %s view", view->name);
1284 if ((reload || strcmp(view->vid, view->id)) &&
1285 !begin_update(view)) {
1286 report("Failed to load %s view", view->name);
1291 display[current_view + 1] = view;
1295 /* Maximize the current view. */
1296 memset(display, 0, sizeof(display));
1298 display[current_view] = view;
1303 if (split && prev->lineno - prev->offset >= prev->height) {
1304 /* Take the title line into account. */
1305 int lines = prev->lineno - prev->offset - prev->height + 1;
1307 /* Scroll the view that was split if the current line is
1308 * outside the new limited view. */
1309 do_scroll_view(prev, lines);
1312 if (prev && view != prev) {
1313 /* "Blur" the previous view. */
1315 update_view_title(prev);
1317 /* Continue loading split views in the background. */
1320 view->parent = prev;
1324 /* Clear the old view and let the incremental updating refill
1327 report("Loading...");
1330 if (view == VIEW(REQ_VIEW_HELP))
1331 report("%s", TIG_HELP);
1336 /* If the view is backgrounded the above calls to report()
1337 * won't redraw the view title. */
1339 update_view_title(view);
1344 * User request switch noodle
1348 view_driver(struct view *view, enum request request)
1355 case REQ_MOVE_PAGE_UP:
1356 case REQ_MOVE_PAGE_DOWN:
1357 case REQ_MOVE_FIRST_LINE:
1358 case REQ_MOVE_LAST_LINE:
1359 move_view(view, request);
1362 case REQ_SCROLL_LINE_DOWN:
1363 case REQ_SCROLL_LINE_UP:
1364 case REQ_SCROLL_PAGE_DOWN:
1365 case REQ_SCROLL_PAGE_UP:
1366 scroll_view(view, request);
1373 case REQ_VIEW_PAGER:
1374 open_view(view, request, OPEN_DEFAULT);
1377 case REQ_MOVE_UP_ENTER:
1378 case REQ_MOVE_DOWN_ENTER:
1379 move_view(view, request);
1384 report("Nothing to enter");
1387 return view->ops->enter(view);
1391 int nviews = display[1] ? 2 : 1;
1392 int next_view = (current_view + 1) % nviews;
1394 if (next_view == current_view) {
1395 report("Only one view is displayed");
1399 current_view = next_view;
1400 /* Blur out the title of the previous view. */
1401 update_view_title(view);
1405 case REQ_TOGGLE_LINE_NUMBERS:
1406 opt_line_number = !opt_line_number;
1411 /* Always reload^Wrerun commands from the prompt. */
1412 open_view(view, opt_request, OPEN_RELOAD);
1415 case REQ_STOP_LOADING:
1416 foreach_view (view, i) {
1418 report("Stopped loaded the %s view", view->name),
1423 case REQ_SHOW_VERSION:
1424 report("%s (built %s)", VERSION, __DATE__);
1427 case REQ_SCREEN_RESIZE:
1430 case REQ_SCREEN_REDRAW:
1434 case REQ_SCREEN_UPDATE:
1438 case REQ_VIEW_CLOSE:
1440 memset(display, 0, sizeof(display));
1442 display[current_view] = view->parent;
1443 view->parent = NULL;
1453 /* An unknown key will show most commonly used commands. */
1454 report("Unknown key, press 'h' for help");
1463 * View backend handlers
1467 pager_draw(struct view *view, unsigned int lineno)
1469 enum line_type type;
1474 if (view->offset + lineno >= view->lines)
1477 line = view->line[view->offset + lineno];
1478 type = get_line_type(line);
1480 wmove(view->win, lineno, 0);
1482 if (view->offset + lineno == view->lineno) {
1483 if (type == LINE_COMMIT) {
1484 string_copy(view->ref, line + 7);
1485 string_copy(ref_commit, view->ref);
1489 wchgat(view->win, -1, 0, type, NULL);
1492 attr = get_line_attr(type);
1493 wattrset(view->win, attr);
1495 linelen = strlen(line);
1497 if (opt_line_number || opt_tab_size < TABSIZE) {
1498 static char spaces[] = " ";
1499 int col_offset = 0, col = 0;
1501 if (opt_line_number) {
1502 unsigned long real_lineno = view->offset + lineno + 1;
1504 if (real_lineno == 1 ||
1505 (real_lineno % opt_num_interval) == 0) {
1506 wprintw(view->win, "%.*d", view->digits, real_lineno);
1509 waddnstr(view->win, spaces,
1510 MIN(view->digits, STRING_SIZE(spaces)));
1512 waddstr(view->win, ": ");
1513 col_offset = view->digits + 2;
1516 while (line && col_offset + col < view->width) {
1517 int cols_max = view->width - col_offset - col;
1521 if (*line == '\t') {
1522 assert(sizeof(spaces) > TABSIZE);
1525 cols = opt_tab_size - (col % opt_tab_size);
1528 line = strchr(line, '\t');
1529 cols = line ? line - text : strlen(text);
1532 waddnstr(view->win, text, MIN(cols, cols_max));
1537 int col = 0, pos = 0;
1539 for (; pos < linelen && col < view->width; pos++, col++)
1540 if (line[pos] == '\t')
1541 col += TABSIZE - (col % TABSIZE) - 1;
1543 waddnstr(view->win, line, pos);
1550 pager_read(struct view *view, char *line)
1552 /* Compress empty lines in the help view. */
1553 if (view == VIEW(REQ_VIEW_HELP) &&
1556 !*((char *) view->line[view->lines - 1]))
1559 view->line[view->lines] = strdup(line);
1560 if (!view->line[view->lines])
1568 pager_enter(struct view *view)
1570 char *line = view->line[view->lineno];
1573 if ((view == VIEW(REQ_VIEW_LOG) ||
1574 view == VIEW(REQ_VIEW_LOG)) &&
1575 get_line_type(line) == LINE_COMMIT) {
1576 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
1580 /* Always scroll the view even if it was split. That way
1581 * you can use Enter to scroll through the log view and
1582 * split open each commit diff. */
1583 scroll_view(view, REQ_SCROLL_LINE_DOWN);
1585 /* FIXME: A minor workaround. Scrolling the view will call report("")
1586 * but if we are scolling a non-current view this won't properly update
1587 * the view title. */
1589 update_view_title(view);
1594 static struct view_ops pager_ops = {
1602 static struct ref **get_refs(char *id);
1605 main_draw(struct view *view, unsigned int lineno)
1607 char buf[DATE_COLS + 1];
1608 struct commit *commit;
1609 enum line_type type;
1615 if (view->offset + lineno >= view->lines)
1618 commit = view->line[view->offset + lineno];
1619 if (!*commit->author)
1622 wmove(view->win, lineno, col);
1624 if (view->offset + lineno == view->lineno) {
1625 string_copy(view->ref, commit->id);
1626 string_copy(ref_commit, view->ref);
1628 wattrset(view->win, get_line_attr(type));
1629 wchgat(view->win, -1, 0, type, NULL);
1632 type = LINE_MAIN_COMMIT;
1633 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
1636 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
1637 waddnstr(view->win, buf, timelen);
1638 waddstr(view->win, " ");
1641 wmove(view->win, lineno, col);
1642 if (type != LINE_CURSOR)
1643 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
1645 /* FIXME: Make this optional, and add i18n.commitEncoding support. */
1646 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
1649 waddnstr(view->win, commit->author, authorlen);
1650 if (type != LINE_CURSOR)
1651 wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
1652 waddch(view->win, '~');
1654 waddstr(view->win, commit->author);
1658 if (type != LINE_CURSOR)
1659 wattrset(view->win, A_NORMAL);
1661 mvwaddch(view->win, lineno, col, ACS_LTEE);
1662 wmove(view->win, lineno, col + 2);
1669 if (type == LINE_CURSOR)
1671 else if (commit->refs[i]->tag)
1672 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
1674 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
1675 waddstr(view->win, "[");
1676 waddstr(view->win, commit->refs[i]->name);
1677 waddstr(view->win, "]");
1678 if (type != LINE_CURSOR)
1679 wattrset(view->win, A_NORMAL);
1680 waddstr(view->win, " ");
1681 col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
1682 } while (commit->refs[i++]->next);
1685 if (type != LINE_CURSOR)
1686 wattrset(view->win, get_line_attr(type));
1689 int titlelen = strlen(commit->title);
1691 if (col + titlelen > view->width)
1692 titlelen = view->width - col;
1694 waddnstr(view->win, commit->title, titlelen);
1700 /* Reads git log --pretty=raw output and parses it into the commit struct. */
1702 main_read(struct view *view, char *line)
1704 enum line_type type = get_line_type(line);
1705 struct commit *commit;
1709 commit = calloc(1, sizeof(struct commit));
1713 line += STRING_SIZE("commit ");
1715 view->line[view->lines++] = commit;
1716 string_copy(commit->id, line);
1717 commit->refs = get_refs(commit->id);
1722 char *ident = line + STRING_SIZE("author ");
1723 char *end = strchr(ident, '<');
1726 for (; end > ident && isspace(end[-1]); end--) ;
1730 commit = view->line[view->lines - 1];
1731 string_copy(commit->author, ident);
1733 /* Parse epoch and timezone */
1735 char *secs = strchr(end + 1, '>');
1739 if (!secs || secs[1] != ' ')
1743 time = (time_t) atol(secs);
1744 zone = strchr(secs, ' ');
1745 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
1749 tz = ('0' - zone[1]) * 60 * 60 * 10;
1750 tz += ('0' - zone[2]) * 60 * 60;
1751 tz += ('0' - zone[3]) * 60;
1752 tz += ('0' - zone[4]) * 60;
1759 gmtime_r(&time, &commit->time);
1764 /* We should only ever end up here if there has already been a
1765 * commit line, however, be safe. */
1766 if (view->lines == 0)
1769 /* Fill in the commit title if it has not already been set. */
1770 commit = view->line[view->lines - 1];
1771 if (commit->title[0])
1774 /* Require titles to start with a non-space character at the
1775 * offset used by git log. */
1776 /* FIXME: More gracefull handling of titles; append "..." to
1777 * shortened titles, etc. */
1778 if (strncmp(line, " ", 4) ||
1782 string_copy(commit->title, line + 4);
1789 main_enter(struct view *view)
1791 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
1795 static struct view_ops main_ops = {
1806 * Below the default key bindings are shown.
1814 static struct keymap keymap[] = {
1819 * Switch to main view.
1821 * Switch to diff view.
1823 * Switch to log view.
1825 * Switch to pager view.
1829 * Close view, if multiple views are open it will jump back to the
1830 * previous view in the view stack. If it is the last open view it
1831 * will quit. Use 'Q' to quit all views at once.
1833 * This key is "context sensitive" depending on what view you are
1834 * currently in. When in log view on a commit line or in the main
1835 * view, split the view and show the commit diff. In the diff view
1836 * pressing Enter will simply scroll the view one line down.
1838 * Switch to next view.
1840 { 'm', REQ_VIEW_MAIN },
1841 { 'd', REQ_VIEW_DIFF },
1842 { 'l', REQ_VIEW_LOG },
1843 { 'p', REQ_VIEW_PAGER },
1844 { 'h', REQ_VIEW_HELP },
1846 { 'q', REQ_VIEW_CLOSE },
1847 { KEY_TAB, REQ_VIEW_NEXT },
1848 { KEY_RETURN, REQ_ENTER },
1854 * Move cursor one line up.
1856 * Move cursor one line down.
1858 * Move cursor one line up and enter. When used in the main view
1859 * this will always show the diff of the current commit in the
1862 * Move cursor one line down and enter.
1866 * Move cursor one page up.
1869 * Move cursor one page down.
1871 * Jump to first line.
1873 * Jump to last line.
1875 { KEY_UP, REQ_MOVE_UP },
1876 { KEY_DOWN, REQ_MOVE_DOWN },
1877 { 'k', REQ_MOVE_UP_ENTER },
1878 { 'j', REQ_MOVE_DOWN_ENTER },
1879 { KEY_HOME, REQ_MOVE_FIRST_LINE },
1880 { KEY_END, REQ_MOVE_LAST_LINE },
1881 { KEY_NPAGE, REQ_MOVE_PAGE_DOWN },
1882 { ' ', REQ_MOVE_PAGE_DOWN },
1883 { KEY_PPAGE, REQ_MOVE_PAGE_UP },
1884 { 'b', REQ_MOVE_PAGE_UP },
1885 { '-', REQ_MOVE_PAGE_UP },
1891 * Scroll view one line up.
1893 * Scroll view one line down.
1895 * Scroll view one page up.
1897 * Scroll view one page down.
1899 { KEY_IC, REQ_SCROLL_LINE_UP },
1900 { KEY_DC, REQ_SCROLL_LINE_DOWN },
1901 { 'w', REQ_SCROLL_PAGE_UP },
1902 { 's', REQ_SCROLL_PAGE_DOWN },
1912 * Stop all background loading. This can be useful if you use
1913 * tig(1) in a repository with a long history without limiting
1918 * Toggle line numbers on/off.
1920 * Open prompt. This allows you to specify what git command
1926 { 'z', REQ_STOP_LOADING },
1927 { 'v', REQ_SHOW_VERSION },
1928 { 'r', REQ_SCREEN_REDRAW },
1929 { 'n', REQ_TOGGLE_LINE_NUMBERS },
1930 { ':', REQ_PROMPT },
1932 /* wgetch() with nodelay() enabled returns ERR when there's no input. */
1933 { ERR, REQ_SCREEN_UPDATE },
1935 /* Use the ncurses SIGWINCH handler. */
1936 { KEY_RESIZE, REQ_SCREEN_RESIZE },
1940 get_request(int key)
1944 for (i = 0; i < ARRAY_SIZE(keymap); i++)
1945 if (keymap[i].alias == key)
1946 return keymap[i].request;
1948 return (enum request) key;
1953 * Unicode / UTF-8 handling
1955 * NOTE: Much of the following code for dealing with unicode is derived from
1956 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
1957 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
1960 /* I've (over)annotated a lot of code snippets because I am not entirely
1961 * confident that the approach taken by this small UTF-8 interface is correct.
1965 unicode_width(unsigned long c)
1968 (c <= 0x115f /* Hangul Jamo */
1971 || (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f)
1973 || (c >= 0xac00 && c <= 0xd7a3) /* Hangul Syllables */
1974 || (c >= 0xf900 && c <= 0xfaff) /* CJK Compatibility Ideographs */
1975 || (c >= 0xfe30 && c <= 0xfe6f) /* CJK Compatibility Forms */
1976 || (c >= 0xff00 && c <= 0xff60) /* Fullwidth Forms */
1977 || (c >= 0xffe0 && c <= 0xffe6)
1978 || (c >= 0x20000 && c <= 0x2fffd)
1979 || (c >= 0x30000 && c <= 0x3fffd)))
1985 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
1986 * Illegal bytes are set one. */
1987 static const unsigned char utf8_bytes[256] = {
1988 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
1989 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
1990 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
1991 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
1992 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
1993 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
1994 2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,
1995 3,3,3,3,3,3,3,3, 3,3,3,3,3,3,3,3, 4,4,4,4,4,4,4,4, 5,5,5,5,6,6,1,1,
1998 /* Decode UTF-8 multi-byte representation into a unicode character. */
1999 static inline unsigned long
2000 utf8_to_unicode(const char *string, size_t length)
2002 unsigned long unicode;
2006 unicode = string[0];
2009 unicode = (string[0] & 0x1f) << 6;
2010 unicode += (string[1] & 0x3f);
2013 unicode = (string[0] & 0x0f) << 12;
2014 unicode += ((string[1] & 0x3f) << 6);
2015 unicode += (string[2] & 0x3f);
2018 unicode = (string[0] & 0x0f) << 18;
2019 unicode += ((string[1] & 0x3f) << 12);
2020 unicode += ((string[2] & 0x3f) << 6);
2021 unicode += (string[3] & 0x3f);
2024 unicode = (string[0] & 0x0f) << 24;
2025 unicode += ((string[1] & 0x3f) << 18);
2026 unicode += ((string[2] & 0x3f) << 12);
2027 unicode += ((string[3] & 0x3f) << 6);
2028 unicode += (string[4] & 0x3f);
2031 unicode = (string[0] & 0x01) << 30;
2032 unicode += ((string[1] & 0x3f) << 24);
2033 unicode += ((string[2] & 0x3f) << 18);
2034 unicode += ((string[3] & 0x3f) << 12);
2035 unicode += ((string[4] & 0x3f) << 6);
2036 unicode += (string[5] & 0x3f);
2039 die("Invalid unicode length");
2042 /* Invalid characters could return the special 0xfffd value but NUL
2043 * should be just as good. */
2044 return unicode > 0xffff ? 0 : unicode;
2047 /* Calculates how much of string can be shown within the given maximum width
2048 * and sets trimmed parameter to non-zero value if all of string could not be
2051 * Additionally, adds to coloffset how many many columns to move to align with
2052 * the expected position. Takes into account how multi-byte and double-width
2053 * characters will effect the cursor position.
2055 * Returns the number of bytes to output from string to satisfy max_width. */
2057 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
2059 const char *start = string;
2060 const char *end = strchr(string, '\0');
2066 while (string < end) {
2067 int c = *(unsigned char *) string;
2068 unsigned char bytes = utf8_bytes[c];
2070 unsigned long unicode;
2072 if (string + bytes > end)
2075 /* Change representation to figure out whether
2076 * it is a single- or double-width character. */
2078 unicode = utf8_to_unicode(string, bytes);
2079 /* FIXME: Graceful handling of invalid unicode character. */
2083 ucwidth = unicode_width(unicode);
2085 if (width > max_width) {
2090 /* The column offset collects the differences between the
2091 * number of bytes encoding a character and the number of
2092 * columns will be used for rendering said character.
2094 * So if some character A is encoded in 2 bytes, but will be
2095 * represented on the screen using only 1 byte this will and up
2096 * adding 1 to the multi-byte column offset.
2098 * Assumes that no double-width character can be encoding in
2099 * less than two bytes. */
2100 if (bytes > ucwidth)
2101 mbwidth += bytes - ucwidth;
2106 *coloffset += mbwidth;
2108 return string - start;
2116 /* Whether or not the curses interface has been initialized. */
2117 static bool cursed = FALSE;
2119 /* The status window is used for polling keystrokes. */
2120 static WINDOW *status_win;
2122 /* Update status and title window. */
2124 report(const char *msg, ...)
2126 static bool empty = TRUE;
2127 struct view *view = display[current_view];
2129 if (!empty || *msg) {
2132 va_start(args, msg);
2135 wmove(status_win, 0, 0);
2137 vwprintw(status_win, msg, args);
2142 wrefresh(status_win);
2147 update_view_title(view);
2149 /* Move the cursor to the right-most column of the cursor line.
2151 * XXX: This could turn out to be a bit expensive, but it ensures that
2152 * the cursor does not jump around. */
2154 wmove(view->win, view->lineno - view->offset, view->width - 1);
2155 wrefresh(view->win);
2159 /* Controls when nodelay should be in effect when polling user input. */
2161 set_nonblocking_input(bool loading)
2163 static unsigned int loading_views;
2165 if ((loading == FALSE && loading_views-- == 1) ||
2166 (loading == TRUE && loading_views++ == 0))
2167 nodelay(status_win, loading);
2175 /* Initialize the curses library */
2176 if (isatty(STDIN_FILENO)) {
2177 cursed = !!initscr();
2179 /* Leave stdin and stdout alone when acting as a pager. */
2180 FILE *io = fopen("/dev/tty", "r+");
2182 cursed = !!newterm(NULL, io, io);
2186 die("Failed to initialize curses");
2188 nonl(); /* Tell curses not to do NL->CR/NL on output */
2189 cbreak(); /* Take input chars one at a time, no wait for \n */
2190 noecho(); /* Don't echo input */
2191 leaveok(stdscr, TRUE);
2196 getmaxyx(stdscr, y, x);
2197 status_win = newwin(1, 0, y - 1, 0);
2199 die("Failed to create status window");
2201 /* Enable keyboard mapping */
2202 keypad(status_win, TRUE);
2203 wbkgdset(status_win, get_line_attr(LINE_STATUS));
2208 * Repository references
2211 static struct ref *refs;
2212 static size_t refs_size;
2214 static struct ref **
2217 struct ref **id_refs = NULL;
2218 size_t id_refs_size = 0;
2221 for (i = 0; i < refs_size; i++) {
2224 if (strcmp(id, refs[i].id))
2227 tmp = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
2235 if (id_refs_size > 0)
2236 id_refs[id_refs_size - 1]->next = 1;
2237 id_refs[id_refs_size] = &refs[i];
2239 /* XXX: The properties of the commit chains ensures that we can
2240 * safely modify the shared ref. The repo references will
2241 * always be similar for the same id. */
2242 id_refs[id_refs_size]->next = 0;
2252 const char *cmd_env = getenv("TIG_LS_REMOTE");
2253 const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
2254 FILE *pipe = popen(cmd, "r");
2255 char buffer[BUFSIZ];
2261 while ((line = fgets(buffer, sizeof(buffer), pipe))) {
2262 char *name = strchr(line, '\t');
2266 bool tag_commit = FALSE;
2272 namelen = strlen(name) - 1;
2274 /* Commits referenced by tags has "^{}" appended. */
2275 if (name[namelen - 1] == '}') {
2276 while (namelen > 0 && name[namelen] != '^')
2283 if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
2286 name += STRING_SIZE("refs/tags/");
2289 } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
2290 name += STRING_SIZE("refs/heads/");
2292 } else if (!strcmp(name, "HEAD")) {
2296 refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
2300 ref = &refs[refs_size++];
2302 ref->name = strdup(name);
2306 string_copy(ref->id, line);
2315 die("Not a git repository");
2325 #define __NORETURN __attribute__((__noreturn__))
2330 static void __NORETURN
2333 /* XXX: Restore tty modes and let the OS cleanup the rest! */
2339 static void __NORETURN
2340 die(const char *err, ...)
2346 va_start(args, err);
2347 fputs("tig: ", stderr);
2348 vfprintf(stderr, err, args);
2349 fputs("\n", stderr);
2356 main(int argc, char *argv[])
2359 enum request request;
2362 signal(SIGINT, quit);
2364 if (!parse_options(argc, argv))
2367 if (load_refs() == ERR)
2368 die("Failed to load refs.");
2370 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
2371 view->cmd_env = getenv(view->cmd_env);
2373 request = opt_request;
2377 while (view_driver(display[current_view], request)) {
2381 foreach_view (view, i)
2384 /* Refresh, accept single keystroke of input */
2385 key = wgetch(status_win);
2386 request = get_request(key);
2388 /* Some low-level request handling. This keeps access to
2389 * status_win restricted. */
2393 /* Temporarily switch to line-oriented and echoed
2398 if (wgetnstr(status_win, opt_cmd + 4, sizeof(opt_cmd) - 4) == OK) {
2399 memcpy(opt_cmd, "git ", 4);
2400 opt_request = REQ_VIEW_PAGER;
2409 case REQ_SCREEN_RESIZE:
2413 getmaxyx(stdscr, height, width);
2415 /* Resize the status view and let the view driver take
2416 * care of resizing the displayed views. */
2417 wresize(status_win, 1, width);
2418 mvwin(status_win, height - 1, 0);
2419 wrefresh(status_win);
2434 * Revision specification
2435 * ----------------------
2436 * This section describes various ways to specify what revisions to display
2437 * or otherwise limit the view to. tig(1) does not itself parse the described
2438 * revision options so refer to the relevant git man pages for futher
2439 * information. Relevant man pages besides git-log(1) are git-diff(1) and
2442 * You can tune the interaction with git by making use of the options
2443 * explained in this section. For example, by configuring the environment
2444 * variables described in the <<view-commands, "View commands">> section.
2446 * Limit by path name
2447 * ~~~~~~~~~~~~~~~~~~
2448 * If you are interested only in those revisions that made changes to a
2449 * specific file (or even several files) list the files like this:
2451 * $ tig log Makefile README
2453 * To avoid ambiguity with repository references such as tag name, be sure
2454 * to separate file names from other git options using "\--". So if you
2455 * have a file named 'master' it will clash with the reference named
2456 * 'master', and thus you will have to use:
2458 * $ tig log -- master
2460 * NOTE: For the main view, avoiding ambiguity will in some cases require
2461 * you to specify two "\--" options. The first will make tig(1) stop
2462 * option processing and the latter will be passed to git log.
2464 * Limit by date or number
2465 * ~~~~~~~~~~~~~~~~~~~~~~~
2466 * To speed up interaction with git, you can limit the amount of commits
2467 * to show both for the log and main view. Either limit by date using
2468 * e.g. `--since=1.month` or limit by the number of commits using `-n400`.
2470 * If you are only interested in changed that happened between two dates
2473 * $ tig -- --after="May 5th" --before="2006-05-16 15:44"
2475 * NOTE: If you want to avoid having to quote dates containing spaces you
2476 * can use "." instead, e.g. `--after=May.5th`.
2478 * Limiting by commit ranges
2479 * ~~~~~~~~~~~~~~~~~~~~~~~~~
2480 * Alternatively, commits can be limited to a specific range, such as
2481 * "all commits between 'tag-1.0' and 'tag-2.0'". For example:
2483 * $ tig log tag-1.0..tag-2.0
2485 * This way of commit limiting makes it trivial to only browse the commits
2486 * which haven't been pushed to a remote branch. Assuming 'origin' is your
2487 * upstream remote branch, using:
2489 * $ tig log origin..HEAD
2491 * will list what will be pushed to the remote branch. Optionally, the ending
2492 * 'HEAD' can be left out since it is implied.
2494 * Limiting by reachability
2495 * ~~~~~~~~~~~~~~~~~~~~~~~~
2496 * Git interprets the range specifier "tag-1.0..tag-2.0" as
2497 * "all commits reachable from 'tag-2.0' but not from 'tag-1.0'".
2498 * Where reachability refers to what commits are ancestors (or part of the
2499 * history) of the branch or tagged revision in question.
2501 * If you prefer to specify which commit to preview in this way use the
2504 * $ tig log tag-2.0 ^tag-1.0
2506 * You can think of '^' as a negation operator. Using this alternate syntax,
2507 * it is possible to further prune commits by specifying multiple branch
2510 * Combining revisions specification
2511 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2512 * Revisions options can to some degree be combined, which makes it possible
2513 * to say "show at most 20 commits from within the last month that changed
2514 * files under the Documentation/ directory."
2516 * $ tig -- --since=1.month -n20 -- Documentation/
2518 * Examining all repository references
2519 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2520 * In some cases, it can be useful to query changes across all references
2521 * in a repository. An example is to ask "did any line of development in
2522 * this repository change a particular file within the last week". This
2523 * can be accomplished using:
2525 * $ tig -- --all --since=1.week -- Makefile
2529 * Known bugs and problems:
2531 * - In it's current state tig is pretty much UTF-8 only.
2533 * - If the screen width is very small the main view can draw
2534 * outside the current view causing bad wrapping. Same goes
2535 * for title and status windows.
2539 * Features that should be explored.
2547 * Copyright (c) Jonas Fonseca <fonseca@diku.dk>, 2006
2549 * This program is free software; you can redistribute it and/or modify
2550 * it under the terms of the GNU General Public License as published by
2551 * the Free Software Foundation; either version 2 of the License, or
2552 * (at your option) any later version.
2557 * link:http://www.kernel.org/pub/software/scm/git/docs/[git(7)],
2558 * link:http://www.kernel.org/pub/software/scm/cogito/docs/[cogito(7)]
2559 * gitk(1): git repository browser written using tcl/tk,
2560 * qgit(1): git repository browser written using c++/Qt,
2561 * gitview(1): git repository browser written using python/gtk.