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? */
139 static struct ref
**get_refs(char *id
);
147 string_ncopy(char *dst
, const char *src
, int dstlen
)
149 strncpy(dst
, src
, dstlen
- 1);
154 /* Shorthand for safely copying into a fixed buffer. */
155 #define string_copy(dst, src) \
156 string_ncopy(dst, src, sizeof(dst))
161 * NOTE: The following is a slightly modified copy of the git project's shell
162 * quoting routines found in the quote.c file.
164 * Help to copy the thing properly quoted for the shell safety. any single
165 * quote is replaced with '\'', any exclamation point is replaced with '\!',
166 * and the whole thing is enclosed in a
169 * original sq_quote result
170 * name ==> name ==> 'name'
171 * a b ==> a b ==> 'a b'
172 * a'b ==> a'\''b ==> 'a'\''b'
173 * a!b ==> a'\!'b ==> 'a'\!'b'
177 sq_quote(char buf
[SIZEOF_CMD
], size_t bufsize
, const char *src
)
181 #define BUFPUT(x) do { if (bufsize < SIZEOF_CMD) buf[bufsize++] = (x); } while (0)
184 while ((c
= *src
++)) {
185 if (c
== '\'' || c
== '!') {
205 static const char usage
[] =
206 VERSION
" (" __DATE__
")\n"
208 "Usage: tig [options]\n"
209 " or: tig [options] [--] [git log options]\n"
210 " or: tig [options] log [git log options]\n"
211 " or: tig [options] diff [git diff options]\n"
212 " or: tig [options] show [git show options]\n"
213 " or: tig [options] < [git command output]\n"
216 " -l Start up in log view\n"
217 " -d Start up in diff view\n"
218 " -n[I], --line-number[=I] Show line numbers with given interval\n"
219 " -t[N], --tab-size[=N] Set number of spaces for tab expansion\n"
220 " -- Mark end of tig options\n"
221 " -v, --version Show version and exit\n"
222 " -h, --help Show help message and exit\n";
224 /* Option and state variables. */
225 static bool opt_line_number
= FALSE
;
226 static int opt_num_interval
= NUMBER_INTERVAL
;
227 static int opt_tab_size
= TABSIZE
;
228 static enum request opt_request
= REQ_VIEW_MAIN
;
229 static char opt_cmd
[SIZEOF_CMD
] = "";
230 static FILE *opt_pipe
= NULL
;
232 /* Returns the index of log or diff command or -1 to exit. */
234 parse_options(int argc
, char *argv
[])
238 for (i
= 1; i
< argc
; i
++) {
243 * Start up in log view using the internal log command.
245 if (!strcmp(opt
, "-l")) {
246 opt_request
= REQ_VIEW_LOG
;
252 * Start up in diff view using the internal diff command.
254 if (!strcmp(opt
, "-d")) {
255 opt_request
= REQ_VIEW_DIFF
;
260 * -n[INTERVAL], --line-number[=INTERVAL]::
261 * Prefix line numbers in log and diff view.
262 * Optionally, with interval different than each line.
264 if (!strncmp(opt
, "-n", 2) ||
265 !strncmp(opt
, "--line-number", 13)) {
271 } else if (opt
[STRING_SIZE("--line-number")] == '=') {
272 num
= opt
+ STRING_SIZE("--line-number=");
276 opt_num_interval
= atoi(num
);
278 opt_line_number
= TRUE
;
283 * -t[NSPACES], --tab-size[=NSPACES]::
284 * Set the number of spaces tabs should be expanded to.
286 if (!strncmp(opt
, "-t", 2) ||
287 !strncmp(opt
, "--tab-size", 10)) {
293 } else if (opt
[STRING_SIZE("--tab-size")] == '=') {
294 num
= opt
+ STRING_SIZE("--tab-size=");
298 opt_tab_size
= MIN(atoi(num
), TABSIZE
);
304 * Show version and exit.
306 if (!strcmp(opt
, "-v") ||
307 !strcmp(opt
, "--version")) {
308 printf("tig version %s\n", VERSION
);
314 * Show help message and exit.
316 if (!strcmp(opt
, "-h") ||
317 !strcmp(opt
, "--help")) {
324 * End of tig(1) options. Useful when specifying command
325 * options for the main view. Example:
327 * $ tig -- --since=1.month
329 if (!strcmp(opt
, "--")) {
335 * log [git log options]::
336 * Open log view using the given git log options.
338 * diff [git diff options]::
339 * Open diff view using the given git diff options.
341 * show [git show options]::
342 * Open diff view using the given git show options.
344 if (!strcmp(opt
, "log") ||
345 !strcmp(opt
, "diff") ||
346 !strcmp(opt
, "show")) {
347 opt_request
= opt
[0] == 'l'
348 ? REQ_VIEW_LOG
: REQ_VIEW_DIFF
;
353 * [git log options]::
354 * tig(1) will stop the option parsing when the first
355 * command line parameter not starting with "-" is
356 * encountered. All options including this one will be
357 * passed to git log when loading the main view.
358 * This makes it possible to say:
360 * $ tig tag-1.0..HEAD
362 if (opt
[0] && opt
[0] != '-')
365 die("unknown command '%s'", opt
);
368 if (!isatty(STDIN_FILENO
)) {
372 * If stdin is a pipe, any log or diff options will be ignored and the
373 * pager view will be opened loading data from stdin. The pager mode
374 * can be used for colorizing output from various git commands.
376 * Example on how to colorize the output of git-show(1):
380 opt_request
= REQ_VIEW_PAGER
;
383 } else if (i
< argc
) {
387 * Git command options
388 * ~~~~~~~~~~~~~~~~~~~
389 * All git command options specified on the command line will
390 * be passed to the given command and all will be shell quoted
391 * before they are passed to the shell.
393 * NOTE: If you specify options for the main view, you should
394 * not use the `--pretty` option as this option will be set
395 * automatically to the format expected by the main view.
397 * Example on how to open the log view and show both author and
398 * committer information:
400 * $ tig log --pretty=fuller
402 * See the <<refspec, "Specifying revisions">> section below
403 * for an introduction to revision options supported by the git
404 * commands. For details on specific git command options, refer
405 * to the man page of the command in question.
408 if (opt_request
== REQ_VIEW_MAIN
)
409 /* XXX: This is vulnerable to the user overriding
410 * options required for the main view parser. */
411 string_copy(opt_cmd
, "git log --stat --pretty=raw");
413 string_copy(opt_cmd
, "git");
414 buf_size
= strlen(opt_cmd
);
416 while (buf_size
< sizeof(opt_cmd
) && i
< argc
) {
417 opt_cmd
[buf_size
++] = ' ';
418 buf_size
= sq_quote(opt_cmd
, buf_size
, argv
[i
++]);
421 if (buf_size
>= sizeof(opt_cmd
))
422 die("command too long");
424 opt_cmd
[buf_size
] = 0;
433 * Line-oriented content detection.
437 /* Line type String to match Foreground Background Attributes
438 * --------- --------------- ---------- ---------- ---------- */ \
440 LINE(DIFF, "diff --git ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
441 LINE(DIFF_INDEX, "index ", COLOR_BLUE, COLOR_DEFAULT, 0), \
442 LINE(DIFF_CHUNK, "@@", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
443 LINE(DIFF_ADD, "+", COLOR_GREEN, COLOR_DEFAULT, 0), \
444 LINE(DIFF_DEL, "-", COLOR_RED, COLOR_DEFAULT, 0), \
445 LINE(DIFF_OLDMODE, "old file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
446 LINE(DIFF_NEWMODE, "new file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
447 LINE(DIFF_COPY, "copy ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
448 LINE(DIFF_RENAME, "rename ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
449 LINE(DIFF_SIM, "similarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
450 LINE(DIFF_DISSIM, "dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
451 /* Pretty print commit header */ \
452 LINE(PP_AUTHOR, "Author: ", COLOR_CYAN, COLOR_DEFAULT, 0), \
453 LINE(PP_COMMIT, "Commit: ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
454 LINE(PP_MERGE, "Merge: ", COLOR_BLUE, COLOR_DEFAULT, 0), \
455 LINE(PP_DATE, "Date: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
456 LINE(PP_ADATE, "AuthorDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
457 LINE(PP_CDATE, "CommitDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
458 /* Raw commit header */ \
459 LINE(COMMIT, "commit ", COLOR_GREEN, COLOR_DEFAULT, 0), \
460 LINE(PARENT, "parent ", COLOR_BLUE, COLOR_DEFAULT, 0), \
461 LINE(TREE, "tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
462 LINE(AUTHOR, "author ", COLOR_CYAN, COLOR_DEFAULT, 0), \
463 LINE(COMMITTER, "committer ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
465 LINE(DIFF_TREE, "diff-tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
466 LINE(SIGNOFF, " Signed-off-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
468 LINE(DEFAULT, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
469 LINE(CURSOR, "", COLOR_WHITE, COLOR_GREEN, A_BOLD), \
470 LINE(STATUS, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
471 LINE(TITLE_BLUR, "", COLOR_WHITE, COLOR_BLUE, 0), \
472 LINE(TITLE_FOCUS, "", COLOR_WHITE, COLOR_BLUE, A_BOLD), \
473 LINE(MAIN_DATE, "", COLOR_BLUE, COLOR_DEFAULT, 0), \
474 LINE(MAIN_AUTHOR, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
475 LINE(MAIN_COMMIT, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
476 LINE(MAIN_DELIM, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
477 LINE(MAIN_TAG, "", COLOR_MAGENTA, COLOR_DEFAULT, A_BOLD), \
478 LINE(MAIN_REF, "", COLOR_CYAN, COLOR_DEFAULT, A_BOLD),
481 #define LINE(type, line, fg, bg, attr) \
488 const char *line
; /* The start of line to match. */
489 int linelen
; /* Size of string to match. */
490 int fg
, bg
, attr
; /* Color and text attributes for the lines. */
493 static struct line_info line_info
[] = {
494 #define LINE(type, line, fg, bg, attr) \
495 { (line), STRING_SIZE(line), (fg), (bg), (attr) }
500 static enum line_type
501 get_line_type(char *line
)
503 int linelen
= strlen(line
);
506 for (type
= 0; type
< ARRAY_SIZE(line_info
); type
++)
507 /* Case insensitive search matches Signed-off-by lines better. */
508 if (linelen
>= line_info
[type
].linelen
&&
509 !strncasecmp(line_info
[type
].line
, line
, line_info
[type
].linelen
))
516 get_line_attr(enum line_type type
)
518 assert(type
< ARRAY_SIZE(line_info
));
519 return COLOR_PAIR(type
) | line_info
[type
].attr
;
525 int default_bg
= COLOR_BLACK
;
526 int default_fg
= COLOR_WHITE
;
531 if (use_default_colors() != ERR
) {
536 for (type
= 0; type
< ARRAY_SIZE(line_info
); type
++) {
537 struct line_info
*info
= &line_info
[type
];
538 int bg
= info
->bg
== COLOR_DEFAULT ? default_bg
: info
->bg
;
539 int fg
= info
->fg
== COLOR_DEFAULT ? default_fg
: info
->fg
;
541 init_pair(type
, fg
, bg
);
547 * ENVIRONMENT VARIABLES
548 * ---------------------
549 * Several options related to the interface with git can be configured
550 * via environment options.
552 * Repository references
553 * ~~~~~~~~~~~~~~~~~~~~~
554 * Commits that are referenced by tags and branch heads will be marked
555 * by the reference name surrounded by '[' and ']':
557 * 2006-03-26 19:42 Petr Baudis | [cogito-0.17.1] Cogito 0.17.1
559 * If you want to filter out certain directories under `.git/refs/`, say
560 * `tmp` you can do it by setting the following variable:
562 * $ TIG_LS_REMOTE="git ls-remote . | sed /\/tmp\//d" tig
564 * Or set the variable permanently in your environment.
567 * Set command for retrieving all repository references. The command
568 * should output data in the same format as git-ls-remote(1).
571 #define TIG_LS_REMOTE \
572 "git ls-remote . 2>/dev/null"
578 * It is possible to alter which commands are used for the different views.
579 * If for example you prefer commits in the main view to be sorted by date
580 * and only show 500 commits, use:
582 * $ TIG_MAIN_CMD="git log --date-order -n500 --pretty=raw %s" tig
584 * Or set the variable permanently in your environment.
586 * Notice, how `%s` is used to specify the commit reference. There can
587 * be a maximum of 5 `%s` ref specifications.
590 * The command used for the diff view. By default, git show is used
594 * The command used for the log view. If you prefer to have both
595 * author and committer shown in the log view be sure to pass
596 * `--pretty=fuller` to git log.
599 * The command used for the main view. Note, you must always specify
600 * the option: `--pretty=raw` since the main view parser expects to
604 #define TIG_DIFF_CMD \
605 "git show --patch-with-stat --find-copies-harder -B -C %s"
607 #define TIG_LOG_CMD \
608 "git log --cc --stat -n100 %s"
610 #define TIG_MAIN_CMD \
611 "git log --topo-order --stat --pretty=raw %s"
613 /* ... silently ignore that the following are also exported. */
615 #define TIG_HELP_CMD \
616 "man tig 2>/dev/null"
618 #define TIG_PAGER_CMD \
625 * The display consists of a status window on the last line of the screen and
626 * one or more views. The default is to only show one view at the time but it
627 * is possible to split both the main and log view to also show the commit
630 * If you are in the log view and press 'Enter' when the current line is a
631 * commit line, such as:
633 * commit 4d55caff4cc89335192f3e566004b4ceef572521
635 * You will split the view so that the log view is displayed in the top window
636 * and the diff view in the bottom window. You can switch between the two
637 * views by pressing 'Tab'. To maximize the log view again, simply press 'l'.
642 /* The display array of active views and the index of the current view. */
643 static struct view
*display
[2];
644 static unsigned int current_view
;
646 #define foreach_view(view, i) \
647 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
651 * Current head and commit ID
652 * ~~~~~~~~~~~~~~~~~~~~~~~~~~
653 * The viewer keeps track of both what head and commit ID you are currently
654 * viewing. The commit ID will follow the cursor line and change everytime time
655 * you highlight a different commit. Whenever you reopen the diff view it
656 * will be reloaded, if the commit ID changed.
658 * The head ID is used when opening the main and log view to indicate from
659 * what revision to show history.
662 static char ref_commit
[SIZEOF_REF
] = "HEAD";
663 static char ref_head
[SIZEOF_REF
] = "HEAD";
667 const char *name
; /* View name */
668 const char *cmd_fmt
; /* Default command line format */
669 const char *cmd_env
; /* Command line set via environment */
670 const char *id
; /* Points to either of ref_{head,commit} */
673 /* What type of content being displayed. Used in the
676 /* Draw one line; @lineno must be < view->height. */
677 bool (*draw
)(struct view
*view
, unsigned int lineno
);
678 /* Read one line; updates view->line. */
679 bool (*read
)(struct view
*view
, char *line
);
680 /* Depending on view, change display based on current line. */
681 bool (*enter
)(struct view
*view
);
684 char cmd
[SIZEOF_CMD
]; /* Command buffer */
685 char ref
[SIZEOF_REF
]; /* Hovered commit reference */
686 char vid
[SIZEOF_REF
]; /* View ID. Set to id member when updating. */
688 int height
, width
; /* The width and height of the main window */
689 WINDOW
*win
; /* The main window */
690 WINDOW
*title
; /* The title window living below the main window */
693 unsigned long offset
; /* Offset of the window top */
694 unsigned long lineno
; /* Current line number */
696 /* If non-NULL, points to the view that opened this view. If this view
697 * is closed tig will switch back to the parent view. */
701 unsigned long lines
; /* Total number of lines */
702 void **line
; /* Line index; each line contains user data */
703 unsigned int digits
; /* Number of digits in the lines member. */
710 static struct view_ops pager_ops
;
711 static struct view_ops main_ops
;
713 #define VIEW_STR(name, cmd, env, ref, ops) \
714 { name, cmd, #env, ref, ops }
716 #define VIEW_(id, name, ops, ref) \
717 VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops)
722 * tig(1) presents various 'views' of a repository. Each view is based on output
723 * from an external command, most often 'git log', 'git diff', or 'git show'.
726 * Is the default view, and it shows a one line summary of each commit
727 * in the chosen list of revisions. The summary includes commit date,
728 * author, and the first line of the log message. Additionally, any
729 * repository references, such as tags, will be shown.
732 * Presents a more rich view of the revision log showing the whole log
733 * message and the diffstat.
736 * Shows either the diff of the current working tree, that is, what
737 * has changed since the last commit, or the commit diff complete
738 * with log message, diffstat and diff.
741 * Is used for displaying both input from stdin and output from git
742 * commands entered in the internal prompt.
745 * Displays the information from the tig(1) man page. For the help view
746 * to work you need to have the tig(1) man page installed.
749 static struct view views
[] = {
750 VIEW_(MAIN
, "main", &main_ops
, ref_head
),
751 VIEW_(DIFF
, "diff", &pager_ops
, ref_commit
),
752 VIEW_(LOG
, "log", &pager_ops
, ref_head
),
753 VIEW_(HELP
, "help", &pager_ops
, "static"),
754 VIEW_(PAGER
, "pager", &pager_ops
, "static"),
757 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
761 redraw_view_from(struct view
*view
, int lineno
)
763 assert(0 <= lineno
&& lineno
< view
->height
);
765 for (; lineno
< view
->height
; lineno
++) {
766 if (!view
->ops
->draw(view
, lineno
))
770 redrawwin(view
->win
);
775 redraw_view(struct view
*view
)
778 redraw_view_from(view
, 0);
785 * Each view has a title window which shows the name of the view, current
786 * commit ID if available, and where the view is positioned:
788 * [main] c622eefaa485995320bc743431bae0d497b1d875 - commit 1 of 61 (1%)
790 * By default, the title of the current view is highlighted using bold font.
794 update_view_title(struct view
*view
)
796 if (view
== display
[current_view
])
797 wbkgdset(view
->title
, get_line_attr(LINE_TITLE_FOCUS
));
799 wbkgdset(view
->title
, get_line_attr(LINE_TITLE_BLUR
));
802 wmove(view
->title
, 0, 0);
805 wprintw(view
->title
, "[%s] %s", view
->name
, view
->ref
);
807 wprintw(view
->title
, "[%s]", view
->name
);
810 wprintw(view
->title
, " - %s %d of %d (%d%%)",
814 (view
->lineno
+ 1) * 100 / view
->lines
);
817 wrefresh(view
->title
);
824 struct view
*base
= display
[0];
825 struct view
*view
= display
[1] ? display
[1] : display
[0];
827 /* Setup window dimensions */
829 getmaxyx(stdscr
, base
->height
, base
->width
);
831 /* Make room for the status window. */
835 /* Horizontal split. */
836 view
->width
= base
->width
;
837 view
->height
= SCALE_SPLIT_VIEW(base
->height
);
838 base
->height
-= view
->height
;
840 /* Make room for the title bar. */
844 /* Make room for the title bar. */
849 foreach_view (view
, i
) {
850 /* Keep the height of all view->win windows one larger than is
851 * required so that the cursor can wrap-around on the last line
852 * without scrolling the window. */
854 view
->win
= newwin(view
->height
+ 1, 0, offset
, 0);
856 die("Failed to create %s view", view
->name
);
858 scrollok(view
->win
, TRUE
);
860 view
->title
= newwin(1, 0, offset
+ view
->height
, 0);
862 die("Failed to create title window");
865 wresize(view
->win
, view
->height
+ 1, view
->width
);
866 mvwin(view
->win
, offset
, 0);
867 mvwin(view
->title
, offset
+ view
->height
, 0);
871 offset
+= view
->height
+ 1;
881 foreach_view (view
, i
) {
883 update_view_title(view
);
892 /* Scrolling backend */
894 do_scroll_view(struct view
*view
, int lines
)
896 /* The rendering expects the new offset. */
897 view
->offset
+= lines
;
899 assert(0 <= view
->offset
&& view
->offset
< view
->lines
);
902 /* Redraw the whole screen if scrolling is pointless. */
903 if (view
->height
< ABS(lines
)) {
907 int line
= lines
> 0 ? view
->height
- lines
: 0;
908 int end
= line
+ ABS(lines
);
910 wscrl(view
->win
, lines
);
912 for (; line
< end
; line
++) {
913 if (!view
->ops
->draw(view
, line
))
918 /* Move current line into the view. */
919 if (view
->lineno
< view
->offset
) {
920 view
->lineno
= view
->offset
;
921 view
->ops
->draw(view
, 0);
923 } else if (view
->lineno
>= view
->offset
+ view
->height
) {
924 if (view
->lineno
== view
->offset
+ view
->height
) {
925 /* Clear the hidden line so it doesn't show if the view
927 wmove(view
->win
, view
->height
, 0);
928 wclrtoeol(view
->win
);
930 view
->lineno
= view
->offset
+ view
->height
- 1;
931 view
->ops
->draw(view
, view
->lineno
- view
->offset
);
934 assert(view
->offset
<= view
->lineno
&& view
->lineno
< view
->lines
);
936 redrawwin(view
->win
);
941 /* Scroll frontend */
943 scroll_view(struct view
*view
, enum request request
)
948 case REQ_SCROLL_PAGE_DOWN
:
949 lines
= view
->height
;
950 case REQ_SCROLL_LINE_DOWN
:
951 if (view
->offset
+ lines
> view
->lines
)
952 lines
= view
->lines
- view
->offset
;
954 if (lines
== 0 || view
->offset
+ view
->height
>= view
->lines
) {
955 report("Cannot scroll beyond the last line");
960 case REQ_SCROLL_PAGE_UP
:
961 lines
= view
->height
;
962 case REQ_SCROLL_LINE_UP
:
963 if (lines
> view
->offset
)
964 lines
= view
->offset
;
967 report("Cannot scroll beyond the first line");
975 die("request %d not handled in switch", request
);
978 do_scroll_view(view
, lines
);
983 move_view(struct view
*view
, enum request request
)
988 case REQ_MOVE_FIRST_LINE
:
989 steps
= -view
->lineno
;
992 case REQ_MOVE_LAST_LINE
:
993 steps
= view
->lines
- view
->lineno
- 1;
996 case REQ_MOVE_PAGE_UP
:
997 steps
= view
->height
> view
->lineno
998 ?
-view
->lineno
: -view
->height
;
1001 case REQ_MOVE_PAGE_DOWN
:
1002 steps
= view
->lineno
+ view
->height
>= view
->lines
1003 ? view
->lines
- view
->lineno
- 1 : view
->height
;
1007 case REQ_MOVE_UP_ENTER
:
1012 case REQ_MOVE_DOWN_ENTER
:
1017 die("request %d not handled in switch", request
);
1020 if (steps
<= 0 && view
->lineno
== 0) {
1021 report("Cannot move beyond the first line");
1024 } else if (steps
>= 0 && view
->lineno
+ 1 >= view
->lines
) {
1025 report("Cannot move beyond the last line");
1029 /* Move the current line */
1030 view
->lineno
+= steps
;
1031 assert(0 <= view
->lineno
&& view
->lineno
< view
->lines
);
1033 /* Repaint the old "current" line if we be scrolling */
1034 if (ABS(steps
) < view
->height
) {
1035 int prev_lineno
= view
->lineno
- steps
- view
->offset
;
1037 wmove(view
->win
, prev_lineno
, 0);
1038 wclrtoeol(view
->win
);
1039 view
->ops
->draw(view
, prev_lineno
);
1042 /* Check whether the view needs to be scrolled */
1043 if (view
->lineno
< view
->offset
||
1044 view
->lineno
>= view
->offset
+ view
->height
) {
1045 if (steps
< 0 && -steps
> view
->offset
) {
1046 steps
= -view
->offset
;
1048 } else if (steps
> 0) {
1049 if (view
->lineno
== view
->lines
- 1 &&
1050 view
->lines
> view
->height
) {
1051 steps
= view
->lines
- view
->offset
- 1;
1052 if (steps
>= view
->height
)
1053 steps
-= view
->height
- 1;
1057 do_scroll_view(view
, steps
);
1061 /* Draw the current line */
1062 view
->ops
->draw(view
, view
->lineno
- view
->offset
);
1064 redrawwin(view
->win
);
1065 wrefresh(view
->win
);
1071 * Incremental updating
1075 begin_update(struct view
*view
)
1077 const char *id
= view
->id
;
1080 string_copy(view
->cmd
, opt_cmd
);
1082 /* When running random commands, the view ref could have become
1083 * invalid so clear it. */
1086 const char *format
= view
->cmd_env ? view
->cmd_env
: view
->cmd_fmt
;
1088 if (snprintf(view
->cmd
, sizeof(view
->cmd
), format
,
1089 id
, id
, id
, id
, id
) >= sizeof(view
->cmd
))
1093 /* Special case for the pager view. */
1095 view
->pipe
= opt_pipe
;
1098 view
->pipe
= popen(view
->cmd
, "r");
1104 set_nonblocking_input(TRUE
);
1109 string_copy(view
->vid
, id
);
1114 for (i
= 0; i
< view
->lines
; i
++)
1116 free(view
->line
[i
]);
1122 view
->start_time
= time(NULL
);
1128 end_update(struct view
*view
)
1132 set_nonblocking_input(FALSE
);
1133 if (view
->pipe
== stdin
)
1141 update_view(struct view
*view
)
1143 char buffer
[BUFSIZ
];
1146 /* The number of lines to read. If too low it will cause too much
1147 * redrawing (and possible flickering), if too high responsiveness
1149 unsigned long lines
= view
->height
;
1150 int redraw_from
= -1;
1155 /* Only redraw if lines are visible. */
1156 if (view
->offset
+ view
->height
>= view
->lines
)
1157 redraw_from
= view
->lines
- view
->offset
;
1159 tmp
= realloc(view
->line
, sizeof(*view
->line
) * (view
->lines
+ lines
));
1165 while ((line
= fgets(buffer
, sizeof(buffer
), view
->pipe
))) {
1166 int linelen
= strlen(line
);
1169 line
[linelen
- 1] = 0;
1171 if (!view
->ops
->read(view
, line
))
1181 lines
= view
->lines
;
1182 for (digits
= 0; lines
; digits
++)
1185 /* Keep the displayed view in sync with line number scaling. */
1186 if (digits
!= view
->digits
) {
1187 view
->digits
= digits
;
1192 if (redraw_from
>= 0) {
1193 /* If this is an incremental update, redraw the previous line
1194 * since for commits some members could have changed when
1195 * loading the main view. */
1196 if (redraw_from
> 0)
1199 /* Incrementally draw avoids flickering. */
1200 redraw_view_from(view
, redraw_from
);
1203 /* Update the title _after_ the redraw so that if the redraw picks up a
1204 * commit reference in view->ref it'll be available here. */
1205 update_view_title(view
);
1207 if (ferror(view
->pipe
)) {
1208 report("Failed to read: %s", strerror(errno
));
1211 } else if (feof(view
->pipe
)) {
1212 time_t secs
= time(NULL
) - view
->start_time
;
1214 if (view
== VIEW(REQ_VIEW_HELP
)) {
1215 const char *msg
= TIG_HELP
;
1217 if (view
->lines
== 0) {
1218 /* Slightly ugly, but abusing view->ref keeps
1219 * the error message. */
1220 string_copy(view
->ref
, "No help available");
1221 msg
= "The tig(1) manpage is not installed";
1228 report("Loaded %d lines in %ld second%s", view
->lines
, secs
,
1229 secs
== 1 ?
"" : "s");
1236 report("Allocation failure");
1244 OPEN_DEFAULT
= 0, /* Use default view switching. */
1245 OPEN_SPLIT
= 1, /* Split current view. */
1246 OPEN_BACKGROUNDED
= 2, /* Backgrounded. */
1247 OPEN_RELOAD
= 4, /* Reload view even if it is the current. */
1251 open_view(struct view
*prev
, enum request request
, enum open_flags flags
)
1253 bool backgrounded
= !!(flags
& OPEN_BACKGROUNDED
);
1254 bool split
= !!(flags
& OPEN_SPLIT
);
1255 bool reload
= !!(flags
& OPEN_RELOAD
);
1256 struct view
*view
= VIEW(request
);
1257 int nviews
= display
[1] ?
2 : 1;
1259 if (view
== prev
&& nviews
== 1 && !reload
) {
1260 report("Already in %s view", view
->name
);
1264 if ((reload
|| strcmp(view
->vid
, view
->id
)) &&
1265 !begin_update(view
)) {
1266 report("Failed to load %s view", view
->name
);
1271 display
[current_view
+ 1] = view
;
1275 /* Maximize the current view. */
1276 memset(display
, 0, sizeof(display
));
1278 display
[current_view
] = view
;
1283 if (split
&& prev
->lineno
- prev
->offset
>= prev
->height
) {
1284 /* Take the title line into account. */
1285 int lines
= prev
->lineno
- prev
->offset
- prev
->height
+ 1;
1287 /* Scroll the view that was split if the current line is
1288 * outside the new limited view. */
1289 do_scroll_view(prev
, lines
);
1292 if (prev
&& view
!= prev
) {
1293 /* "Blur" the previous view. */
1295 update_view_title(prev
);
1297 /* Continue loading split views in the background. */
1300 view
->parent
= prev
;
1304 /* Clear the old view and let the incremental updating refill
1307 report("Loading...");
1310 if (view
== VIEW(REQ_VIEW_HELP
))
1311 report("%s", TIG_HELP
);
1316 /* If the view is backgrounded the above calls to report()
1317 * won't redraw the view title. */
1319 update_view_title(view
);
1324 * User request switch noodle
1328 view_driver(struct view
*view
, enum request request
)
1335 case REQ_MOVE_PAGE_UP
:
1336 case REQ_MOVE_PAGE_DOWN
:
1337 case REQ_MOVE_FIRST_LINE
:
1338 case REQ_MOVE_LAST_LINE
:
1339 move_view(view
, request
);
1342 case REQ_SCROLL_LINE_DOWN
:
1343 case REQ_SCROLL_LINE_UP
:
1344 case REQ_SCROLL_PAGE_DOWN
:
1345 case REQ_SCROLL_PAGE_UP
:
1346 scroll_view(view
, request
);
1353 case REQ_VIEW_PAGER
:
1354 open_view(view
, request
, OPEN_DEFAULT
);
1357 case REQ_MOVE_UP_ENTER
:
1358 case REQ_MOVE_DOWN_ENTER
:
1359 move_view(view
, request
);
1364 report("Nothing to enter");
1367 return view
->ops
->enter(view
);
1371 int nviews
= display
[1] ?
2 : 1;
1372 int next_view
= (current_view
+ 1) % nviews
;
1374 if (next_view
== current_view
) {
1375 report("Only one view is displayed");
1379 current_view
= next_view
;
1380 /* Blur out the title of the previous view. */
1381 update_view_title(view
);
1385 case REQ_TOGGLE_LINE_NUMBERS
:
1386 opt_line_number
= !opt_line_number
;
1391 /* Always reload^Wrerun commands from the prompt. */
1392 open_view(view
, opt_request
, OPEN_RELOAD
);
1395 case REQ_STOP_LOADING
:
1396 foreach_view (view
, i
) {
1398 report("Stopped loaded the %s view", view
->name
),
1403 case REQ_SHOW_VERSION
:
1404 report("%s (built %s)", VERSION
, __DATE__
);
1407 case REQ_SCREEN_RESIZE
:
1410 case REQ_SCREEN_REDRAW
:
1414 case REQ_SCREEN_UPDATE
:
1418 case REQ_VIEW_CLOSE
:
1420 memset(display
, 0, sizeof(display
));
1422 display
[current_view
] = view
->parent
;
1423 view
->parent
= NULL
;
1433 /* An unknown key will show most commonly used commands. */
1434 report("Unknown key, press 'h' for help");
1447 pager_draw(struct view
*view
, unsigned int lineno
)
1449 enum line_type type
;
1454 if (view
->offset
+ lineno
>= view
->lines
)
1457 line
= view
->line
[view
->offset
+ lineno
];
1458 type
= get_line_type(line
);
1460 wmove(view
->win
, lineno
, 0);
1462 if (view
->offset
+ lineno
== view
->lineno
) {
1463 if (type
== LINE_COMMIT
) {
1464 string_copy(view
->ref
, line
+ 7);
1465 string_copy(ref_commit
, view
->ref
);
1469 wchgat(view
->win
, -1, 0, type
, NULL
);
1472 attr
= get_line_attr(type
);
1473 wattrset(view
->win
, attr
);
1475 linelen
= strlen(line
);
1477 if (opt_line_number
|| opt_tab_size
< TABSIZE
) {
1478 static char spaces
[] = " ";
1479 int col_offset
= 0, col
= 0;
1481 if (opt_line_number
) {
1482 unsigned long real_lineno
= view
->offset
+ lineno
+ 1;
1484 if (real_lineno
== 1 ||
1485 (real_lineno
% opt_num_interval
) == 0) {
1486 wprintw(view
->win
, "%.*d", view
->digits
, real_lineno
);
1489 waddnstr(view
->win
, spaces
,
1490 MIN(view
->digits
, STRING_SIZE(spaces
)));
1492 waddstr(view
->win
, ": ");
1493 col_offset
= view
->digits
+ 2;
1496 while (line
&& col_offset
+ col
< view
->width
) {
1497 int cols_max
= view
->width
- col_offset
- col
;
1501 if (*line
== '\t') {
1502 assert(sizeof(spaces
) > TABSIZE
);
1505 cols
= opt_tab_size
- (col
% opt_tab_size
);
1508 line
= strchr(line
, '\t');
1509 cols
= line ? line
- text
: strlen(text
);
1512 waddnstr(view
->win
, text
, MIN(cols
, cols_max
));
1517 int col
= 0, pos
= 0;
1519 for (; pos
< linelen
&& col
< view
->width
; pos
++, col
++)
1520 if (line
[pos
] == '\t')
1521 col
+= TABSIZE
- (col
% TABSIZE
) - 1;
1523 waddnstr(view
->win
, line
, pos
);
1530 pager_read(struct view
*view
, char *line
)
1532 /* Compress empty lines in the help view. */
1533 if (view
== VIEW(REQ_VIEW_HELP
) &&
1536 !*((char *) view
->line
[view
->lines
- 1]))
1539 view
->line
[view
->lines
] = strdup(line
);
1540 if (!view
->line
[view
->lines
])
1548 pager_enter(struct view
*view
)
1550 char *line
= view
->line
[view
->lineno
];
1553 if ((view
== VIEW(REQ_VIEW_LOG
) ||
1554 view
== VIEW(REQ_VIEW_PAGER
)) &&
1555 get_line_type(line
) == LINE_COMMIT
) {
1556 open_view(view
, REQ_VIEW_DIFF
, OPEN_SPLIT
);
1560 /* Always scroll the view even if it was split. That way
1561 * you can use Enter to scroll through the log view and
1562 * split open each commit diff. */
1563 scroll_view(view
, REQ_SCROLL_LINE_DOWN
);
1565 /* FIXME: A minor workaround. Scrolling the view will call report("")
1566 * but if we are scolling a non-current view this won't properly update
1567 * the view title. */
1569 update_view_title(view
);
1574 static struct view_ops pager_ops
= {
1587 char id
[41]; /* SHA1 ID. */
1588 char title
[75]; /* The first line of the commit message. */
1589 char author
[75]; /* The author of the commit. */
1590 struct tm time
; /* Date from the author ident. */
1591 struct ref
**refs
; /* Repository references; tags & branch heads. */
1595 main_draw(struct view
*view
, unsigned int lineno
)
1597 char buf
[DATE_COLS
+ 1];
1598 struct commit
*commit
;
1599 enum line_type type
;
1605 if (view
->offset
+ lineno
>= view
->lines
)
1608 commit
= view
->line
[view
->offset
+ lineno
];
1609 if (!*commit
->author
)
1612 wmove(view
->win
, lineno
, col
);
1614 if (view
->offset
+ lineno
== view
->lineno
) {
1615 string_copy(view
->ref
, commit
->id
);
1616 string_copy(ref_commit
, view
->ref
);
1618 wattrset(view
->win
, get_line_attr(type
));
1619 wchgat(view
->win
, -1, 0, type
, NULL
);
1622 type
= LINE_MAIN_COMMIT
;
1623 wattrset(view
->win
, get_line_attr(LINE_MAIN_DATE
));
1626 timelen
= strftime(buf
, sizeof(buf
), DATE_FORMAT
, &commit
->time
);
1627 waddnstr(view
->win
, buf
, timelen
);
1628 waddstr(view
->win
, " ");
1631 wmove(view
->win
, lineno
, col
);
1632 if (type
!= LINE_CURSOR
)
1633 wattrset(view
->win
, get_line_attr(LINE_MAIN_AUTHOR
));
1635 /* FIXME: Make this optional, and add i18n.commitEncoding support. */
1636 authorlen
= utf8_length(commit
->author
, AUTHOR_COLS
- 2, &col
, &trimmed
);
1639 waddnstr(view
->win
, commit
->author
, authorlen
);
1640 if (type
!= LINE_CURSOR
)
1641 wattrset(view
->win
, get_line_attr(LINE_MAIN_DELIM
));
1642 waddch(view
->win
, '~');
1644 waddstr(view
->win
, commit
->author
);
1648 if (type
!= LINE_CURSOR
)
1649 wattrset(view
->win
, A_NORMAL
);
1651 mvwaddch(view
->win
, lineno
, col
, ACS_LTEE
);
1652 wmove(view
->win
, lineno
, col
+ 2);
1659 if (type
== LINE_CURSOR
)
1661 else if (commit
->refs
[i
]->tag
)
1662 wattrset(view
->win
, get_line_attr(LINE_MAIN_TAG
));
1664 wattrset(view
->win
, get_line_attr(LINE_MAIN_REF
));
1665 waddstr(view
->win
, "[");
1666 waddstr(view
->win
, commit
->refs
[i
]->name
);
1667 waddstr(view
->win
, "]");
1668 if (type
!= LINE_CURSOR
)
1669 wattrset(view
->win
, A_NORMAL
);
1670 waddstr(view
->win
, " ");
1671 col
+= strlen(commit
->refs
[i
]->name
) + STRING_SIZE("[] ");
1672 } while (commit
->refs
[i
++]->next
);
1675 if (type
!= LINE_CURSOR
)
1676 wattrset(view
->win
, get_line_attr(type
));
1679 int titlelen
= strlen(commit
->title
);
1681 if (col
+ titlelen
> view
->width
)
1682 titlelen
= view
->width
- col
;
1684 waddnstr(view
->win
, commit
->title
, titlelen
);
1690 /* Reads git log --pretty=raw output and parses it into the commit struct. */
1692 main_read(struct view
*view
, char *line
)
1694 enum line_type type
= get_line_type(line
);
1695 struct commit
*commit
;
1699 commit
= calloc(1, sizeof(struct commit
));
1703 line
+= STRING_SIZE("commit ");
1705 view
->line
[view
->lines
++] = commit
;
1706 string_copy(commit
->id
, line
);
1707 commit
->refs
= get_refs(commit
->id
);
1712 char *ident
= line
+ STRING_SIZE("author ");
1713 char *end
= strchr(ident
, '<');
1716 for (; end
> ident
&& isspace(end
[-1]); end
--) ;
1720 commit
= view
->line
[view
->lines
- 1];
1721 string_copy(commit
->author
, ident
);
1723 /* Parse epoch and timezone */
1725 char *secs
= strchr(end
+ 1, '>');
1729 if (!secs
|| secs
[1] != ' ')
1733 time
= (time_t) atol(secs
);
1734 zone
= strchr(secs
, ' ');
1735 if (zone
&& strlen(zone
) == STRING_SIZE(" +0700")) {
1739 tz
= ('0' - zone
[1]) * 60 * 60 * 10;
1740 tz
+= ('0' - zone
[2]) * 60 * 60;
1741 tz
+= ('0' - zone
[3]) * 60;
1742 tz
+= ('0' - zone
[4]) * 60;
1749 gmtime_r(&time
, &commit
->time
);
1754 /* We should only ever end up here if there has already been a
1755 * commit line, however, be safe. */
1756 if (view
->lines
== 0)
1759 /* Fill in the commit title if it has not already been set. */
1760 commit
= view
->line
[view
->lines
- 1];
1761 if (commit
->title
[0])
1764 /* Require titles to start with a non-space character at the
1765 * offset used by git log. */
1766 /* FIXME: More gracefull handling of titles; append "..." to
1767 * shortened titles, etc. */
1768 if (strncmp(line
, " ", 4) ||
1772 string_copy(commit
->title
, line
+ 4);
1779 main_enter(struct view
*view
)
1781 open_view(view
, REQ_VIEW_DIFF
, OPEN_SPLIT
);
1785 static struct view_ops main_ops
= {
1796 * Below the default key bindings are shown.
1804 static struct keymap keymap
[] = {
1809 * Switch to main view.
1811 * Switch to diff view.
1813 * Switch to log view.
1815 * Switch to pager view.
1819 * Close view, if multiple views are open it will jump back to the
1820 * previous view in the view stack. If it is the last open view it
1821 * will quit. Use 'Q' to quit all views at once.
1823 * This key is "context sensitive" depending on what view you are
1824 * currently in. When in log view on a commit line or in the main
1825 * view, split the view and show the commit diff. In the diff view
1826 * pressing Enter will simply scroll the view one line down.
1828 * Switch to next view.
1830 { 'm', REQ_VIEW_MAIN
},
1831 { 'd', REQ_VIEW_DIFF
},
1832 { 'l', REQ_VIEW_LOG
},
1833 { 'p', REQ_VIEW_PAGER
},
1834 { 'h', REQ_VIEW_HELP
},
1836 { 'q', REQ_VIEW_CLOSE
},
1837 { KEY_TAB
, REQ_VIEW_NEXT
},
1838 { KEY_RETURN
, REQ_ENTER
},
1844 * Move cursor one line up.
1846 * Move cursor one line down.
1848 * Move cursor one line up and enter. When used in the main view
1849 * this will always show the diff of the current commit in the
1852 * Move cursor one line down and enter.
1856 * Move cursor one page up.
1859 * Move cursor one page down.
1861 * Jump to first line.
1863 * Jump to last line.
1865 { KEY_UP
, REQ_MOVE_UP
},
1866 { KEY_DOWN
, REQ_MOVE_DOWN
},
1867 { 'k', REQ_MOVE_UP_ENTER
},
1868 { 'j', REQ_MOVE_DOWN_ENTER
},
1869 { KEY_HOME
, REQ_MOVE_FIRST_LINE
},
1870 { KEY_END
, REQ_MOVE_LAST_LINE
},
1871 { KEY_NPAGE
, REQ_MOVE_PAGE_DOWN
},
1872 { ' ', REQ_MOVE_PAGE_DOWN
},
1873 { KEY_PPAGE
, REQ_MOVE_PAGE_UP
},
1874 { 'b', REQ_MOVE_PAGE_UP
},
1875 { '-', REQ_MOVE_PAGE_UP
},
1881 * Scroll view one line up.
1883 * Scroll view one line down.
1885 * Scroll view one page up.
1887 * Scroll view one page down.
1889 { KEY_IC
, REQ_SCROLL_LINE_UP
},
1890 { KEY_DC
, REQ_SCROLL_LINE_DOWN
},
1891 { 'w', REQ_SCROLL_PAGE_UP
},
1892 { 's', REQ_SCROLL_PAGE_DOWN
},
1902 * Stop all background loading. This can be useful if you use
1903 * tig(1) in a repository with a long history without limiting
1908 * Toggle line numbers on/off.
1910 * Open prompt. This allows you to specify what git command
1916 { 'z', REQ_STOP_LOADING
},
1917 { 'v', REQ_SHOW_VERSION
},
1918 { 'r', REQ_SCREEN_REDRAW
},
1919 { 'n', REQ_TOGGLE_LINE_NUMBERS
},
1920 { ':', REQ_PROMPT
},
1922 /* wgetch() with nodelay() enabled returns ERR when there's no input. */
1923 { ERR
, REQ_SCREEN_UPDATE
},
1925 /* Use the ncurses SIGWINCH handler. */
1926 { KEY_RESIZE
, REQ_SCREEN_RESIZE
},
1930 get_request(int key
)
1934 for (i
= 0; i
< ARRAY_SIZE(keymap
); i
++)
1935 if (keymap
[i
].alias
== key
)
1936 return keymap
[i
].request
;
1938 return (enum request
) key
;
1943 * Unicode / UTF-8 handling
1945 * NOTE: Much of the following code for dealing with unicode is derived from
1946 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
1947 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
1950 /* I've (over)annotated a lot of code snippets because I am not entirely
1951 * confident that the approach taken by this small UTF-8 interface is correct.
1955 unicode_width(unsigned long c
)
1958 (c
<= 0x115f /* Hangul Jamo */
1961 || (c
>= 0x2e80 && c
<= 0xa4cf && c
!= 0x303f)
1963 || (c
>= 0xac00 && c
<= 0xd7a3) /* Hangul Syllables */
1964 || (c
>= 0xf900 && c
<= 0xfaff) /* CJK Compatibility Ideographs */
1965 || (c
>= 0xfe30 && c
<= 0xfe6f) /* CJK Compatibility Forms */
1966 || (c
>= 0xff00 && c
<= 0xff60) /* Fullwidth Forms */
1967 || (c
>= 0xffe0 && c
<= 0xffe6)
1968 || (c
>= 0x20000 && c
<= 0x2fffd)
1969 || (c
>= 0x30000 && c
<= 0x3fffd)))
1975 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
1976 * Illegal bytes are set one. */
1977 static const unsigned char utf8_bytes
[256] = {
1978 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,
1979 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,
1980 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,
1981 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,
1982 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,
1983 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,
1984 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,
1985 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,
1988 /* Decode UTF-8 multi-byte representation into a unicode character. */
1989 static inline unsigned long
1990 utf8_to_unicode(const char *string
, size_t length
)
1992 unsigned long unicode
;
1996 unicode
= string
[0];
1999 unicode
= (string
[0] & 0x1f) << 6;
2000 unicode
+= (string
[1] & 0x3f);
2003 unicode
= (string
[0] & 0x0f) << 12;
2004 unicode
+= ((string
[1] & 0x3f) << 6);
2005 unicode
+= (string
[2] & 0x3f);
2008 unicode
= (string
[0] & 0x0f) << 18;
2009 unicode
+= ((string
[1] & 0x3f) << 12);
2010 unicode
+= ((string
[2] & 0x3f) << 6);
2011 unicode
+= (string
[3] & 0x3f);
2014 unicode
= (string
[0] & 0x0f) << 24;
2015 unicode
+= ((string
[1] & 0x3f) << 18);
2016 unicode
+= ((string
[2] & 0x3f) << 12);
2017 unicode
+= ((string
[3] & 0x3f) << 6);
2018 unicode
+= (string
[4] & 0x3f);
2021 unicode
= (string
[0] & 0x01) << 30;
2022 unicode
+= ((string
[1] & 0x3f) << 24);
2023 unicode
+= ((string
[2] & 0x3f) << 18);
2024 unicode
+= ((string
[3] & 0x3f) << 12);
2025 unicode
+= ((string
[4] & 0x3f) << 6);
2026 unicode
+= (string
[5] & 0x3f);
2029 die("Invalid unicode length");
2032 /* Invalid characters could return the special 0xfffd value but NUL
2033 * should be just as good. */
2034 return unicode
> 0xffff ?
0 : unicode
;
2037 /* Calculates how much of string can be shown within the given maximum width
2038 * and sets trimmed parameter to non-zero value if all of string could not be
2041 * Additionally, adds to coloffset how many many columns to move to align with
2042 * the expected position. Takes into account how multi-byte and double-width
2043 * characters will effect the cursor position.
2045 * Returns the number of bytes to output from string to satisfy max_width. */
2047 utf8_length(const char *string
, size_t max_width
, int *coloffset
, int *trimmed
)
2049 const char *start
= string
;
2050 const char *end
= strchr(string
, '\0');
2056 while (string
< end
) {
2057 int c
= *(unsigned char *) string
;
2058 unsigned char bytes
= utf8_bytes
[c
];
2060 unsigned long unicode
;
2062 if (string
+ bytes
> end
)
2065 /* Change representation to figure out whether
2066 * it is a single- or double-width character. */
2068 unicode
= utf8_to_unicode(string
, bytes
);
2069 /* FIXME: Graceful handling of invalid unicode character. */
2073 ucwidth
= unicode_width(unicode
);
2075 if (width
> max_width
) {
2080 /* The column offset collects the differences between the
2081 * number of bytes encoding a character and the number of
2082 * columns will be used for rendering said character.
2084 * So if some character A is encoded in 2 bytes, but will be
2085 * represented on the screen using only 1 byte this will and up
2086 * adding 1 to the multi-byte column offset.
2088 * Assumes that no double-width character can be encoding in
2089 * less than two bytes. */
2090 if (bytes
> ucwidth
)
2091 mbwidth
+= bytes
- ucwidth
;
2096 *coloffset
+= mbwidth
;
2098 return string
- start
;
2106 /* Whether or not the curses interface has been initialized. */
2107 static bool cursed
= FALSE
;
2109 /* The status window is used for polling keystrokes. */
2110 static WINDOW
*status_win
;
2112 /* Update status and title window. */
2114 report(const char *msg
, ...)
2116 static bool empty
= TRUE
;
2117 struct view
*view
= display
[current_view
];
2119 if (!empty
|| *msg
) {
2122 va_start(args
, msg
);
2125 wmove(status_win
, 0, 0);
2127 vwprintw(status_win
, msg
, args
);
2132 wrefresh(status_win
);
2137 update_view_title(view
);
2139 /* Move the cursor to the right-most column of the cursor line.
2141 * XXX: This could turn out to be a bit expensive, but it ensures that
2142 * the cursor does not jump around. */
2144 wmove(view
->win
, view
->lineno
- view
->offset
, view
->width
- 1);
2145 wrefresh(view
->win
);
2149 /* Controls when nodelay should be in effect when polling user input. */
2151 set_nonblocking_input(bool loading
)
2153 static unsigned int loading_views
;
2155 if ((loading
== FALSE
&& loading_views
-- == 1) ||
2156 (loading
== TRUE
&& loading_views
++ == 0))
2157 nodelay(status_win
, loading
);
2165 /* Initialize the curses library */
2166 if (isatty(STDIN_FILENO
)) {
2167 cursed
= !!initscr();
2169 /* Leave stdin and stdout alone when acting as a pager. */
2170 FILE *io
= fopen("/dev/tty", "r+");
2172 cursed
= !!newterm(NULL
, io
, io
);
2176 die("Failed to initialize curses");
2178 nonl(); /* Tell curses not to do NL->CR/NL on output */
2179 cbreak(); /* Take input chars one at a time, no wait for \n */
2180 noecho(); /* Don't echo input */
2181 leaveok(stdscr
, TRUE
);
2186 getmaxyx(stdscr
, y
, x
);
2187 status_win
= newwin(1, 0, y
- 1, 0);
2189 die("Failed to create status window");
2191 /* Enable keyboard mapping */
2192 keypad(status_win
, TRUE
);
2193 wbkgdset(status_win
, get_line_attr(LINE_STATUS
));
2198 * Repository references
2201 static struct ref
*refs
;
2202 static size_t refs_size
;
2204 /* Id <-> ref store */
2205 static struct ref
***id_refs
;
2206 static size_t id_refs_size
;
2208 static struct ref
**
2211 struct ref
***tmp_id_refs
;
2212 struct ref
**ref_list
= NULL
;
2213 size_t ref_list_size
= 0;
2216 for (i
= 0; i
< id_refs_size
; i
++)
2217 if (!strcmp(id
, id_refs
[i
][0]->id
))
2220 tmp_id_refs
= realloc(id_refs
, (id_refs_size
+ 1) * sizeof(*id_refs
));
2224 id_refs
= tmp_id_refs
;
2226 for (i
= 0; i
< refs_size
; i
++) {
2229 if (strcmp(id
, refs
[i
].id
))
2232 tmp
= realloc(ref_list
, (ref_list_size
+ 1) * sizeof(*ref_list
));
2240 if (ref_list_size
> 0)
2241 ref_list
[ref_list_size
- 1]->next
= 1;
2242 ref_list
[ref_list_size
] = &refs
[i
];
2244 /* XXX: The properties of the commit chains ensures that we can
2245 * safely modify the shared ref. The repo references will
2246 * always be similar for the same id. */
2247 ref_list
[ref_list_size
]->next
= 0;
2252 id_refs
[id_refs_size
++] = ref_list
;
2260 const char *cmd_env
= getenv("TIG_LS_REMOTE");
2261 const char *cmd
= cmd_env
&& *cmd_env ? cmd_env
: TIG_LS_REMOTE
;
2262 FILE *pipe
= popen(cmd
, "r");
2263 char buffer
[BUFSIZ
];
2269 while ((line
= fgets(buffer
, sizeof(buffer
), pipe
))) {
2270 char *name
= strchr(line
, '\t');
2274 bool tag_commit
= FALSE
;
2280 namelen
= strlen(name
) - 1;
2282 /* Commits referenced by tags has "^{}" appended. */
2283 if (name
[namelen
- 1] == '}') {
2284 while (namelen
> 0 && name
[namelen
] != '^')
2291 if (!strncmp(name
, "refs/tags/", STRING_SIZE("refs/tags/"))) {
2294 name
+= STRING_SIZE("refs/tags/");
2297 } else if (!strncmp(name
, "refs/heads/", STRING_SIZE("refs/heads/"))) {
2298 name
+= STRING_SIZE("refs/heads/");
2300 } else if (!strcmp(name
, "HEAD")) {
2304 refs
= realloc(refs
, sizeof(*refs
) * (refs_size
+ 1));
2308 ref
= &refs
[refs_size
++];
2310 ref
->name
= strdup(name
);
2314 string_copy(ref
->id
, line
);
2330 #define __NORETURN __attribute__((__noreturn__))
2335 static void __NORETURN
2338 /* XXX: Restore tty modes and let the OS cleanup the rest! */
2344 static void __NORETURN
2345 die(const char *err
, ...)
2351 va_start(args
, err
);
2352 fputs("tig: ", stderr
);
2353 vfprintf(stderr
, err
, args
);
2354 fputs("\n", stderr
);
2361 main(int argc
, char *argv
[])
2364 enum request request
;
2367 signal(SIGINT
, quit
);
2369 if (!parse_options(argc
, argv
))
2372 if (load_refs() == ERR
)
2373 die("Failed to load refs.");
2375 /* Require a git repository unless when running in pager mode. */
2376 if (refs_size
== 0 && opt_request
!= REQ_VIEW_PAGER
)
2377 die("Not a git repository");
2379 for (i
= 0; i
< ARRAY_SIZE(views
) && (view
= &views
[i
]); i
++)
2380 view
->cmd_env
= getenv(view
->cmd_env
);
2382 request
= opt_request
;
2386 while (view_driver(display
[current_view
], request
)) {
2390 foreach_view (view
, i
)
2393 /* Refresh, accept single keystroke of input */
2394 key
= wgetch(status_win
);
2395 request
= get_request(key
);
2397 /* Some low-level request handling. This keeps access to
2398 * status_win restricted. */
2402 /* Temporarily switch to line-oriented and echoed
2407 if (wgetnstr(status_win
, opt_cmd
+ 4, sizeof(opt_cmd
) - 4) == OK
) {
2408 memcpy(opt_cmd
, "git ", 4);
2409 opt_request
= REQ_VIEW_PAGER
;
2418 case REQ_SCREEN_RESIZE
:
2422 getmaxyx(stdscr
, height
, width
);
2424 /* Resize the status view and let the view driver take
2425 * care of resizing the displayed views. */
2426 wresize(status_win
, 1, width
);
2427 mvwin(status_win
, height
- 1, 0);
2428 wrefresh(status_win
);
2443 * Revision specification
2444 * ----------------------
2445 * This section describes various ways to specify what revisions to display
2446 * or otherwise limit the view to. tig(1) does not itself parse the described
2447 * revision options so refer to the relevant git man pages for futher
2448 * information. Relevant man pages besides git-log(1) are git-diff(1) and
2451 * You can tune the interaction with git by making use of the options
2452 * explained in this section. For example, by configuring the environment
2453 * variables described in the <<view-commands, "View commands">> section.
2455 * Limit by path name
2456 * ~~~~~~~~~~~~~~~~~~
2457 * If you are interested only in those revisions that made changes to a
2458 * specific file (or even several files) list the files like this:
2460 * $ tig log Makefile README
2462 * To avoid ambiguity with repository references such as tag name, be sure
2463 * to separate file names from other git options using "\--". So if you
2464 * have a file named 'master' it will clash with the reference named
2465 * 'master', and thus you will have to use:
2467 * $ tig log -- master
2469 * NOTE: For the main view, avoiding ambiguity will in some cases require
2470 * you to specify two "\--" options. The first will make tig(1) stop
2471 * option processing and the latter will be passed to git log.
2473 * Limit by date or number
2474 * ~~~~~~~~~~~~~~~~~~~~~~~
2475 * To speed up interaction with git, you can limit the amount of commits
2476 * to show both for the log and main view. Either limit by date using
2477 * e.g. `--since=1.month` or limit by the number of commits using `-n400`.
2479 * If you are only interested in changed that happened between two dates
2482 * $ tig -- --after="May 5th" --before="2006-05-16 15:44"
2484 * NOTE: If you want to avoid having to quote dates containing spaces you
2485 * can use "." instead, e.g. `--after=May.5th`.
2487 * Limiting by commit ranges
2488 * ~~~~~~~~~~~~~~~~~~~~~~~~~
2489 * Alternatively, commits can be limited to a specific range, such as
2490 * "all commits between 'tag-1.0' and 'tag-2.0'". For example:
2492 * $ tig log tag-1.0..tag-2.0
2494 * This way of commit limiting makes it trivial to only browse the commits
2495 * which haven't been pushed to a remote branch. Assuming 'origin' is your
2496 * upstream remote branch, using:
2498 * $ tig log origin..HEAD
2500 * will list what will be pushed to the remote branch. Optionally, the ending
2501 * 'HEAD' can be left out since it is implied.
2503 * Limiting by reachability
2504 * ~~~~~~~~~~~~~~~~~~~~~~~~
2505 * Git interprets the range specifier "tag-1.0..tag-2.0" as
2506 * "all commits reachable from 'tag-2.0' but not from 'tag-1.0'".
2507 * Where reachability refers to what commits are ancestors (or part of the
2508 * history) of the branch or tagged revision in question.
2510 * If you prefer to specify which commit to preview in this way use the
2513 * $ tig log tag-2.0 ^tag-1.0
2515 * You can think of '^' as a negation operator. Using this alternate syntax,
2516 * it is possible to further prune commits by specifying multiple branch
2519 * Combining revisions specification
2520 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2521 * Revisions options can to some degree be combined, which makes it possible
2522 * to say "show at most 20 commits from within the last month that changed
2523 * files under the Documentation/ directory."
2525 * $ tig -- --since=1.month -n20 -- Documentation/
2527 * Examining all repository references
2528 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2529 * In some cases, it can be useful to query changes across all references
2530 * in a repository. An example is to ask "did any line of development in
2531 * this repository change a particular file within the last week". This
2532 * can be accomplished using:
2534 * $ tig -- --all --since=1.week -- Makefile
2538 * Known bugs and problems:
2540 * - In it's current state tig is pretty much UTF-8 only.
2542 * - If the screen width is very small the main view can draw
2543 * outside the current view causing bad wrapping. Same goes
2544 * for title and status windows.
2548 * Features that should be explored.
2556 * Copyright (c) Jonas Fonseca <fonseca@diku.dk>, 2006
2558 * This program is free software; you can redistribute it and/or modify
2559 * it under the terms of the GNU General Public License as published by
2560 * the Free Software Foundation; either version 2 of the License, or
2561 * (at your option) any later version.
2566 * link:http://www.kernel.org/pub/software/scm/git/docs/[git(7)],
2567 * link:http://www.kernel.org/pub/software/scm/cogito/docs/[cogito(7)]
2568 * gitk(1): git repository browser written using tcl/tk,
2569 * qgit(1): git repository browser written using c++/Qt,
2570 * gitview(1): git repository browser written using python/gtk.